python初学者知识点笔记更新

文章目录

1.main函数入口

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

python 复制代码
if __name__ == '__main__':

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

2.init.py 文件作用

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


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

python 复制代码
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的内置命名空间中,你可以直接使用它们。

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

2. 类和对象

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

python 复制代码
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)

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

python 复制代码
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))
相关推荐
databook11 小时前
Manim实现闪光轨迹特效
后端·python·动效
Juchecar13 小时前
解惑:NumPy 中 ndarray.ndim 到底是什么?
python
用户83562907805113 小时前
Python 删除 Excel 工作表中的空白行列
后端·python
Json_13 小时前
使用python-fastApi框架开发一个学校宿舍管理系统-前后端分离项目
后端·python·fastapi
数据智能老司机20 小时前
精通 Python 设计模式——分布式系统模式
python·设计模式·架构
数据智能老司机21 小时前
精通 Python 设计模式——并发与异步模式
python·设计模式·编程语言
数据智能老司机21 小时前
精通 Python 设计模式——测试模式
python·设计模式·架构
数据智能老司机21 小时前
精通 Python 设计模式——性能模式
python·设计模式·架构
c8i21 小时前
drf初步梳理
python·django
每日AI新事件21 小时前
python的异步函数
python