文章目录
- 1.main函数入口
- 2.__init__.py 文件作用
- 3.from .applications import server解释
- 4.变量没有修饰，直接创建使用
- 1. 内置数据类型和函数
- 2. 类和对象
- 3.总结
- 5.mod = app.__module__
- 6.集合对比区分
- 集合类型：
- 混合集合类型
- 7.安装包失败
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))
7.安装包失败
报错：
Try to run this command from the system terminal. Make sure that you use the correct version of ‘pip’ installed for your Python interpreter located at ‘F:\python-workspaces\TestEnv\venv\Scripts\python.exe’.
问题原因：
解决办法：
