python初学者知识点笔记更新

菠菜很好吃

已于 2024-07-14 20:13:49 修改

阅读量556

点赞数 8

文章标签： python 笔记开发语言

于 2024-07-14 20:10:31 首次发布

本文链接：https://blog.csdn.net/paulwang040/article/details/140412102

版权

文章目录

1.main函数入口
2.__init__.py 文件作用
3.from .applications import server解释
4.变量没有修饰，直接创建使用
5.mod = app.__module__
6.集合对比区分
- 集合类型：
- 混合集合类型

1.main函数入口

老程序员欢迎加入扣扣组织，783092701

if __name__ == '__main__':

这段代码是Python的程序入口，它会在程序运行时自动执行。在Python中，如果想让一个文件作为程序运行，需要在文件的第一行添加__name__ == '__main__'这行代码。这行代码的作用是让Python知道该文件是否是程序的入口文件，如果是，则执行文件中的代码。

2.init.py 文件作用

init.py 文件是一个特殊文件，它的存在告诉Python解释器这个目录应该被视为一个Python包（package）。这个文件可以是空的，但它必须存在（在Python 3.3及以后的版本中，对于纯Python包来说，init.py 文件不再是必需的，但如果你希望包在旧版本的Python中也能工作，或者你的包包含了一些需要在包被导入时执行的初始化代码，那么仍然需要这个文件）。
在这里插入图片描述

在__init__函数中，可以定义该类的属性和成员变量，并对它们进行初始化。例如：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

这段代码是Python类的构造函数，它用于初始化类的对象。

3.from .applications import server解释

从当前包（即包含这个导入语句的文件的包）中导入名为 applications 的子包或模块，并从这个子包或模块中进一步导入名为 server 的内容

对比 from fastapi import FastAPI
从fastapi这个包中导入FastAPI类

4.变量没有修饰，直接创建使用

函数式编程，有些东西都不知道哪里来的就用起来了
直接创建变量使用，这个名可以不叫response
在这里插入图片描述
分析，response = await call_next(request) 这行代码之所以不需要对 response 进行额外的修饰（比如使用 async 关键字），是因为 await 已经处理了异步调用的等待和结果接收。这里的 response 变量简单地用于存储 await call_next(request) 执行完成后的结果，这个结果通常是下一个中间件或路由处理函数返回的响应对象。

1. 内置数据类型和函数

对于Python的内置数据类型（如整数、浮点数、字符串、列表、元组、字典、集合等）和内置函数，你通常不需要显式地定义对象来使用它们。这些类型和函数已经存在于Python的内置命名空间中，你可以直接使用它们。

# 使用内置数据类型  
num = 10  # 整数  
text = "Hello, World!"  # 字符串  
lst = [1, 2, 3]  # 列表  
  
# 使用内置函数  
result = len(lst)  # 调用内置函数len来获取列表的长度

2. 类和对象

当你使用Python的类（class）来定义自己的数据结构或行为时，你需要创建（或“实例化”）类的对象来使用它。这是因为类是用于创建对象的蓝图或模板，而对象则是根据这个蓝图创建的具体实例。

class MyClass:  
    def __init__(self, name):  
        self.name = name  
  
    def greet(self):  
        print(f"Hello, {self.name}!")  
  
# 实例化MyClass类  
my_object = MyClass("Alice")  
  
# 使用对象的方法  
my_object.greet()  # 输出: Hello, Alice!

在这个例子中，MyClass 是一个类定义，它包含了一个构造函数 init 和一个方法 greet。要使用这个类，我们首先必须实例化它，创建一个对象 my_object，然后我们可以通过这个对象来调用 greet 方法。

3.总结

虽然Python是一种面向对象的语言，但它也支持函数式编程。在函数式编程中，你更倾向于使用函数而不是对象，但这并不意味着你不需要定义函数就可以直接使用它（因为你还是需要知道函数名才能调用它）。

5.mod = app.module

解释：

它执行了一个特定的操作来获取与app对象相关联的模块（module）的名称。这里，app可以是一个类、函数、变量或者任何定义在某个模块中的对象。__module__是一个特殊的属性，它存在于几乎所有的Python对象中（除了内建类型和一些特殊情况），用于指示该对象是在哪个模块中定义的。
app.__module__返回的是一个字符串，表示app对象所在模块的名称。这个名称通常包括模块的文件名和（如果模块是包的一部分）其包的路径。

举例：

如果app是在名为myapp.py的文件中定义的，并且该文件位于Python的搜索路径中的某个目录下，那么app.__module__的值可能就是’myapp’（如果myapp.py位于顶层目录）或者是一个更长的路径，比如’mypackage.subpackage.myapp’（如果myapp.py是mypackage.subpackage包的一部分）。

使用场景：

这个特性在动态编程、调试、日志记录或任何需要知道对象来源模块的场景中都非常有用。例如，你可能想要记录一个函数或方法被调用的模块，以便更好地理解程序的执行流程或调试问题。

注意bug：
需要注意的是，对于内建类型（如int、list等）和一些特殊情况（如使用exec或eval动态创建的对象），__module__属性可能不存在或返回的值可能不是你期望的。在这些情况下，尝试访问__module__属性可能会引发AttributeError异常。

6.集合对比区分

集合类型：

列表（List），集合（Set），元组（Tuple），字典（Dictionary）

有序：列表（List），元组（Tuple）
不可重复：集合（Set）
key-value：字典（Dictionary），元组列表
不可更改：元组（Tuple）
大小中括号：
{}：集合（Set）,字典（Dictionary）
[]：列表（List）
()：元组（Tuple）

混合集合类型

元组列表，元组嵌套，深嵌套，字典列表等等

print("===============定义元组，遍历输出===============")
# 元组是一种有序且不可更改的集合
fruits = ('apple', 'banana', 'cherry')
for fruit in fruits:
    print(fruit)

print("===============定义字典，遍历输出===============")
# 字典一个无序的、可变的、有索引的集合
student_info = {
    'Tom': 95,
    'Jerry': 90,
    'Mary': 85,
    'Bob': 98}
for name, score in student_info.items():
    print(f"{name}: {score}")

print("===============定义列表，遍历输出================")
# 定义一个列表 一种有序且可更改的集合
students = ['Alice', 'Bob', 'Charlie']
for student in students:
    print(student)

print("===============定义set可变集合，遍历输出================")
# set集合，无序且不包含重复元素的集合
my_set = set()

# 添加元素到集合
my_set.add(1)
my_set.add(2)
my_set.add(3)

# 遍历输出集合中的元素
for item in my_set:
    print(item)
print("=====定义集合，遍历输出====")
# 定义一个集合，元素为字符串
names = {'Alice', 'Bob', 'Bob', 'Charlie'}

# 使用 for 循环遍历集合中的元素
for name in names:
    print(name)

# 创建一个不可变集合
fruits = frozenset(['apple', 'banana', 'cherry'])

# 使用 for 循环遍历集合中的元素
for fruit in fruits:
    print(fruit)

print("===============混合类型================")
print("===============定义元组列表，遍历输出================")
# 元组列表
names = [('John', 25), ('Alice', 30), ('Bob', 35)]

for _, member in names:
    print(f"Member: {member}")

# 遍历元组 set 集合
# 1. 创建一个元组 set 集合
student_scores = {'Alice': 95, 'Bob': 92, 'Charlie': 97}
# 2. 使用 for 循环遍历该集合
for student, score in student_scores.items():
    print(f'{student}: {score}')

# 遍历元组字典
# 首先定义一个元组字典
student_info = (
    ('Alice', 'Math', 95),
    ('Bob', 'English', 90),
    ('Charlie', 'Physics', 98)
)

# 遍历元组字典
for student in student_info:
    # 提取学生姓名、课程名称和成绩
    name, course, score = student
    # 打印学生信息
    print(f'Student name: {name}')
    print(f'Course: {course}')
    print(f'Score: {score}')
    print()

# 创建一个嵌套元组的例子
nested_tuple = (1, 2, (3, 4, 5), 6)

# 访问嵌套元组中的元素
print(nested_tuple)  # 输出: (1, 2, (3, 4, 5), 6)
print(nested_tuple[2])  # 输出: (3, 4, 5)，这是嵌套元组
print(nested_tuple[2][1])  # 输出: 4，这是嵌套元组中的第二个元素

# 嵌套可以非常深
deep_nested_tuple = (1, (2, (3, (4, (5, 6)))), 7)
print(deep_nested_tuple)  # 输出: (1, (2, (3, (4, (5, 6)))), 7)
print(deep_nested_tuple[1][1])

print(deep_nested_tuple[1][1][1])
print(deep_nested_tuple[1][1][1][1])
# 大模型给出的错误答案
# print(deep_nested_tuple[1][1][2][1][0])

multi_nested_tuple = (1, (2, (3, (4, 5))))
print(multi_nested_tuple[1][1][1][0])


# 字典列表
# 实现一个字典列表，列表中每个元素是一个字典
# 字典的键是字符串，值可以是任意类型
# 实现函数：
# 创建一个空的字典列表
def create_dict_list():
    return []


# 添加一个元素到字典列表中
# 参数：
# dict_list - 字典列表
# key - 字典的键
# value - 字典的值
def add_element_to_dict_list(dict_list, key, value):
    dict_list.append({key: value})


# 返回字典列表的长度
# 参数：
# dict_list - 字典列表
def get_dict_list_length(dict_list):
    return len(dict_list)


# 返回第 index 个元素
# 参数：
# dict_list - 字典列表
# index - 元素的索引，从 0 开始计算
def get_element_from_dict_list(dict_list, index):
    return dict_list[index]


# 修改第 index 个元素
# 参数：
# dict_list - 字典列表
# index - 元素的索引，从 0 开始计算
# key - 字典的键
# value - 字典的值
def modify_element_in_dict_list(dict_list, index, key, value):
    dict_list[index][key] = value


# 删除第 index 个元素
# 参数：
# dict_list - 字典列表
# index - 元素的索引，从 0 开始计算
def delete_element_from_dict_list(dict_list, index):
    del dict_list[index]


# 判断字典列表中是否包含某个元素
# 参数：
# dict_list - 字典列表
# key - 字典的键
def contains_element_in_dict_list(dict_list, key):
    for element in dict_list:
        if key in element:
            return True
    return False


# 遍历字典列表
# 参数：
# dict_list - 字典列表
# 遍历函数的形式为：def visit_element(element):
def traverse_dict_list(dict_list, visit_element):
    for element in dict_list:
        visit_element(element)


# 示例：
dict_list = create_dict_list()
add_element_to_dict_list(dict_list, "name", "alice")
add_element_to_dict_list(dict_list, "age", 20)
print("长度:", get_dict_list_length(dict_list))
print("第 0 个元素:", get_element_from_dict_list(dict_list, 0))
modify_element_in_dict_list(dict_list, 0, "name", "alice2")
delete_element_from_dict_list(dict_list, 1)
print("长度:", get_dict_list_length(dict_list))
print("是否包含 name:", contains_element_in_dict_list(dict_list, "name"))
traverse_dict_list(dict_list, lambda x: print(x))

菠菜很好吃

关注

8
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
python初学者知识点笔记更新

虽然Python是一种面向对象的语言，但它也支持函数式编程。在函数式编程中，你更倾向于使用函数而不是对象，但这并不意味着你不需要定义函数就可以直接使用它（因为你还是需要知道函数名才能调用它）。
复制链接

扫一扫