python基础2

自用总结

于 2024-04-10 21:55:39 发布

阅读量804

点赞数 20

文章标签： python 开发语言

本文链接：https://blog.csdn.net/weixin_53966429/article/details/137607933

版权

装饰器是 Python 中一种非常强大的语法特性，它允许我们在不修改原函数代码的情况下，为函数添加额外的功能。下面我来解释一下装饰器的几个常见功能，并介绍 @staticmethod、@classmethod 和 @property 这几个装饰器的用法和区别。

引入日志：可以在函数执行前后打印日志，用于调试和追踪程序执行流程。
函数执行时间统计：记录函数执行所花费的时间，用于性能分析和优化。
执行函数前预备处理：在执行函数之前进行一些准备工作，如参数验证等。
执行函数后清理功能：在函数执行后进行一些清理工作，如资源释放等。
权限校验：在函数执行前进行权限验证，确保只有具有特定权限的用户才能执行该函数。
缓存：缓存函数的返回值，避免重复计算，提高程序性能。

下面是 @staticmethod 和 @classmethod 装饰器的区别和使用方法：

@staticmethod：
- 静态方法不需要表示自身对象的 self 和自身类的 cls 参数，就跟使用函数一样。
- 可以使用类名直接调用。
- 使用 @staticmethod 装饰器来定义静态方法。

示例：

class MyClass:
    @staticmethod
    def my_static_method(x, y):
        return x + y

# 不需要实例化，直接通过类名调用静态方法
result = MyClass.my_static_method(5, 3)
print(result)  # 输出: 8

@classmethod：
- 类方法必须有一个类对象作为第一个参数，通常习惯使用 cls。
- 可以通过类或者实例调用。
- 使用 @classmethod 装饰器来定义类方法。

示例：

class MyClass:
    @classmethod
    def my_class_method(cls, x, y):
        return cls.__name__, x + y

# 可以通过类或者实例调用类方法
result = MyClass.my_class_method(5, 3)
print(result)  # 输出: ('MyClass', 8)

obj = MyClass()
result = obj.my_class_method(5, 3)
print(result)  # 输出: ('MyClass', 8)

@property：
- 将一个实例方法提升为属性，使其可以像访问属性一样直接访问，而不需要加上括号调用。
- 使用 @property 装饰器来定义。

示例：

class MyClass:
    def __init__(self):
        self._value = 0

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        self._value = new_value

# 访问 value 属性，实际调用 value 方法
obj = MyClass()
obj.value = 10
print(obj.value)  # 输出: 10

GIL（全局解释器锁）确实是 Python 解释器中的一个重要特性，但是它并不是为了让多个线程在 CPU 上轮流运行，也不是为了模拟并行执行。相反，GIL 的主要目的是保护解释器内部的数据结构免受并发访问的影响，以确保解释器的安全性。

在 CPython 中，由于存在 GIL，任何时候只有一个线程能够执行 Python 字节码，而其他线程会被阻塞。这意味着在多核 CPU 上运行多个线程时，并不能充分利用 CPU 的多核能力，因为无法并行执行多个 Python 字节码。因此，即使使用了多线程，对于 CPU 密集型任务而言，并不能提高程序的执行效率。

但是，GIL 并不会影响 I/O 操作或者调用 C 语言编写的扩展模块（比如 numpy、OpenCV 等），因为这些操作并不涉及 Python 字节码的执行，所以可以在多个线程之间并行执行，从而提高程序的响应速度和效率。

Python 的内存管理

引用计数：Python 使用引用计数来追踪对象的引用情况。每个对象都有一个引用计数，当引用计数为 0 时，说明对象不再被使用，可以被垃圾回收。这是 Python 内存管理的第一层机制。
垃圾回收：Python 中还有一个垃圾回收器，用于处理循环引用等情况。循环引用指的是两个或多个对象相互引用，但是没有其他对象引用它们。Python 的垃圾回收器会检测并清除这些不可达的对象，以释放内存空间。
内存池机制：Python 引入了内存池机制，用于管理小块内存的申请和释放，以提高内存分配的效率。Python 使用 pymalloc 实现的分配器来处理小于 256 个字节的对象，而大的对象则使用系统的 malloc。Python 对象（如整数、浮点数和列表）都有自己的私有内存池，这意味着不同类型的对象不共享内存池，以避免出现竞争和碎片化问题。

猴子补丁（Monkey Patching）是指在运行时动态修改一个类或模块的技术。这种技术通常被用来在不修改原始源代码的情况下，为已有的类或模块添加、修改或删除功能。猴子补丁的主要优势在于其灵活性，允许开发者在运行时动态地改变程序的行为，而无需修改原始代码。

使用猴子补丁的一些常见情况包括：

扩展功能：当你想要在已有的类或模块中添加新的功能或方法时，可以使用猴子补丁。这对于第三方库或框架来说特别有用，你可以通过添加新的方法或属性来满足特定需求，而无需修改库的源代码。
修复错误：有时你可能遇到第三方库或框架中的 bug 或问题，而官方尚未发布修复版本。使用猴子补丁可以在不等待修复版本发布的情况下，自行修复这些问题。
适配不同版本：当你需要与多个版本的某个库或框架进行交互时，可能会遇到版本之间的差异。通过猴子补丁，你可以在不同版本之间提供统一的接口，简化代码的编写和维护。

虽然猴子补丁提供了一种灵活的方式来动态修改类或模块，但也存在一些潜在的问题和风险。例如，过度使用猴子补丁可能导致代码变得难以理解和维护，因为它会改变程序的行为，使得代码的行为不再符合预期。因此，在使用猴子补丁时，需要慎重考虑，并确保清晰地记录所有的修改，以便于后续的维护和调试。

在 Python 中，函数的参数可以分为位置参数和关键字参数，并且可以使用 *args 和 **kwargs 来处理不确定数量的参数。

位置参数和关键字参数的区别：
- 位置参数是按照定义时的位置顺序传递给函数的参数，调用函数时必须按照相同的顺序传递相应的参数值。
- 关键字参数是以 key=value 的形式传递给函数的参数，调用函数时可以不按照定义时的顺序传递参数，并且可以只传递部分参数，未传递的参数将使用默认值（如果有的话）。
*args 和 **kwargs 的含义：
- *args 是用来接收任意数量的位置参数的，它将接收到的位置参数存储为一个元组（tuple）。
- **kwargs 是用来接收任意数量的关键字参数的，它将接收到的关键字参数存储为一个字典（dictionary）。

在函数定义时，*args 通常放在所有参数的最前面，用于收集位置参数，而 **kwargs 通常放在所有参数的最后面，用于收集关键字参数。这是因为位置参数必须在关键字参数之前，而 *args 和 **kwargs 可以用来收集未知数量的位置参数和关键字参数，因此将它们放在合适的位置可以更好地处理不确定数量的参数。

以下是一个示例：

def func(*args, **kwargs):
    print("Positional arguments (*args):", args)
    print("Keyword arguments (**kwargs):", kwargs)

# 使用*args和**kwargs来处理不确定数量的参数
func(1, 2, 3, a=4, b=5)

在这个示例中，*args 接收了位置参数 (1, 2, 3)，而 **kwargs 接收了关键字参数 {'a': 4, 'b': 5}。

在 Python 中，全局变量和局部变量是指在不同作用域下定义的变量。

全局变量：在函数外部定义的变量称为全局变量，它可以在程序的任何地方被访问。全局变量在整个程序中都是可见的。
局部变量：在函数内部定义的变量称为局部变量，它只能在函数内部被访问。局部变量只在其被定义的函数内部可见，超出该函数的范围则无法访问。

以下是一个示例：

global_var = 10  # 全局变量

def func():
    local_var = 20  # 局部变量
    print("Inside func(): global_var =", global_var)
    print("Inside func(): local_var =", local_var)

func()
print("Outside func(): global_var =", global_var)
# print("Outside func(): local_var =", local_var)  # 这一行会导致错误，因为无法访问局部变

常用方法：

join()：将字符串列表中的每个元素用指定的字符串连接起来，返回连接后的字符串。例如：
```
my_list = ['Hello', 'World', 'Python']
result = '-'.join(my_list)
print(result)  # 输出：Hello-World-Python
```
split()：将字符串按照指定的分隔符分割成多个子串，并返回一个列表。例如：

my_string = "Hello-World-Python"
result = my_string.split('-')
print(result)  # 输出：['Hello', 'World', 'Python']

strip()、lstrip()、rstrip()：用于移除字符串两端的空白字符（空格、制表符、换行符等）。
- strip()：移除字符串两端的空白字符。
- lstrip()：移除字符串左边的空白字符。
- rstrip()：移除字符串右边的空白字符。

常用方法

字符串检查方法：
- islower()：检查字符串中的所有字符是否都是小写字母。
- isupper()：检查字符串中的所有字符是否都是大写字母。
- istitle()：检查字符串中的所有单词是否首字母大写。
- isalnum()：检查字符串是否由字母和数字组成。
- isdigit()：检查字符串是否只包含数字。
- isnumeric()：检查字符串是否只包含数字字符。这个方法更广义，可以检查除了阿拉伯数字外的其他数字字符。
- isdecimal()：检查字符串是否只包含十进制数字。这个方法更严格，只接受阿拉伯数字。
pass：在 Python 中，pass 是一个空语句，什么都不做。它可以用作语法上的占位符，用来保持代码结构的完整性。当你定义了一个函数或者条件语句，但是函数体或者条件分支还没有实现时，你可以使用 pass 作为占位符，保证语法正确，避免出现语法错误。
continue：在循环中，continue 语句用于跳过当前循环中的剩余代码，并直接进入下一次循环的迭代。当条件满足时，continue 会终止本次循环的执行，直接跳到下一次循环的开始处。
yield： yield 是一个关键字，主要用于生成器函数中。它的作用有两个：
- 暂停执行：yield 会保存当前函数的运行状态，并暂停执行生成器函数，返回 yield 后面表达式的值。
- 生成值：将 yield 后面表达式的值作为返回值返回给调用者。此时，生成器函数处于挂起状态，等待再次被调用。
生成器函数是一种特殊的函数，可以通过 yield 关键字来生成值。每次调用生成器函数时，函数会执行到下一个 yield 语句，并返回其后的表达式的值。当生成器函数执行完毕或者遇到 return 语句时，生成器函数就会抛出 StopIteration 异常。
match() 和 search()：
- match() 和 search() 都是 Python 中正则表达式模块 re 中的方法，用于匹配字符串中的模式。
- match() 从字符串的开头开始匹配，只有当模式完全匹配字符串的开头时才返回匹配对象，否则返回 None。
- search() 则在整个字符串中搜索匹配，返回第一个匹配成功的匹配对象，如果没有找到匹配项，则返回 None。
模块和包：
- 模块：在 Python 中，模块是一个包含 Python 代码的文件，文件名即为模块名，以 .py 为后缀。模块可以包含函数、类、变量等定义，用于组织和重用代码。
- 包：包是一个包含了多个模块的目录，它必须包含一个名为 __init__.py 的文件以标识其为一个包。包可以有多层次的子包，通过点号 . 来进行层级访问。
- 库：库是指具有相关功能模块的集合，它可以包含标准库（Python 自带的模块和包）和第三方库（由第三方开发者提供的模块和包），用于提供各种功能和工具。
闭包：
- 闭包是指在函数内部定义的函数，并且内部函数可以访问外部函数的局部变量。当外部函数返回内部函数时，如果内部函数引用了外部函数的局部变量，那么这个内部函数和其所引用的变量称为闭包。
- 闭包使得局部变量在函数外部仍然可以被访问，保持了函数的状态，可以实现类似于面向对象编程的封装和信息隐藏的效果。

python运算符（7）

算术运算符：用于执行算术运算的运算符，如加法、减法、乘法等。
- +：加法
- -：减法
- *：乘法
- /：除法
- //：整除（向下取整）
- %：取模（取余数）
- **：幂运算
关系运算符：用于比较两个值之间的关系，并返回布尔值（True 或 False）。
- ==：等于
- !=：不等于
- <：小于
- >：大于
- <=：小于等于
- >=：大于等于
赋值运算符：用于给变量赋值。
- =：赋值
- +=：加法赋值
- -=：减法赋值
- *=：乘法赋值
- /=：除法赋值
- //=：整除赋值
- %=：取模赋值
- **=：幂赋值
逻辑运算符：用于组合多个条件，并返回布尔值。
- and：逻辑与
- or：逻辑或
- not：逻辑非
位运算符：用于对二进制数进行操作。
- &：按位与
- |：按位或
- ^：按位异或
- ~：按位取反
- <<：左移
- >>：右移
成员运算符：用于检查指定的值是否存在于序列中。
- in：存在于
- not in：不存在于
身份运算符：用于检查两个对象是否指向同一个内存地址。
- is：是
- is not：不是
二进制（Binary）：以 0b 开头，后跟由 0 和 1 组成的数字。
- 例如：0b1010 表示十进制数 10。
八进制（Octal）：以 0o 开头，后跟由 0 到 7 组成的数字。
- 例如：0o12 表示十进制数 10。
十六进制（Hexadecimal）：以 0x 开头，后跟由 0 到 9 和 A 到 F（不区分大小写）组成的数字。
- 例如：0xA 表示十进制数 10。

在 Python 中，常见的标准数据类型包括数字（Numbers）、字符串（Strings）、列表（Lists）、元组（Tuples）和字典（Dictionary）。下面是它们的一些特点：

数字（Numbers）：
- 包括整数（int）、浮点数（float）、复数（complex）等类型。
- 可以进行常规的数学运算，如加减乘除等。
- 支持类型转换和数学函数。
字符串（Strings）：
- 由单个字符组成的序列，用单引号（'）或双引号（"）括起来。
- 支持切片（slice）、拼接（concatenate）、格式化等操作。
- 是不可变（immutable）的，即不能直接修改字符串的某个字符。
列表（Lists）：
- 有序的可变序列，用方括号（[ ]）表示，其中的元素可以是不同类型的数据。
- 支持索引和切片操作，以及添加、删除和修改元素等操作。
元组（Tuples）：
- 有序的不可变序列，用圆括号（( )）表示，其中的元素可以是不同类型的数据。
- 支持索引和切片操作，但不能修改元素。
- 元组解封装（Tuple Unpacking）：可以将一个元组的元素解封装给多个变量。
字典（Dictionary）：
- 无序的键值对集合，用花括号（{ }）表示，每个键值对由键和对应的值组成，键和值之间用冒号（:）分隔。
- 键必须是不可变的（通常是字符串或数字），而值可以是任意类型的数据。
- 支持通过键来访问、添加、修改和删除元素。

除了上述五种标准数据类型之外，还有一些其他的数据类型和数据结构，如集合（Set）、命名元组（Namedtuple）等：

集合（Set）：无序且元素不重复的集合，用花括号（{ }）表示，可以进行交集、并集、差集等操作。
命名元组（Namedtuple）：位于 collections 模块中，是一种创建具有命名字段的元组的工厂函数。能够用标签获取一个元组的元素，比普通元组更具可读性。

在 Python 中，常见的标准数据类型包括数字（Numbers）、字符串（Strings）、列表（Lists）、元组（Tuples）和字典（Dictionary）。下面是它们的一些特点：

数字（Numbers）：
- 包括整数（int）、浮点数（float）、复数（complex）等类型。
- 可以进行常规的数学运算，如加减乘除等。
- 支持类型转换和数学函数。
字符串（Strings）：
- 由单个字符组成的序列，用单引号（'）或双引号（"）括起来。
- 支持切片（slice）、拼接（concatenate）、格式化等操作。
- 是不可变（immutable）的，即不能直接修改字符串的某个字符。
列表（Lists）：
- 有序的可变序列，用方括号（[ ]）表示，其中的元素可以是不同类型的数据。
- 支持索引和切片操作，以及添加、删除和修改元素等操作。
元组（Tuples）：
- 有序的不可变序列，用圆括号（( )）表示，其中的元素可以是不同类型的数据。
- 支持索引和切片操作，但不能修改元素。
- 元组解封装（Tuple Unpacking）：可以将一个元组的元素解封装给多个变量。
字典（Dictionary）：
- 无序的键值对集合，用花括号（{ }）表示，每个键值对由键和对应的值组成，键和值之间用冒号（:）分隔。
- 键必须是不可变的（通常是字符串或数字），而值可以是任意类型的数据。
- 支持通过键来访问、添加、修改和删除元素。

除了上述五种标准数据类型之外，还有一些其他的数据类型和数据结构，如集合（Set）、命名元组（Namedtuple）等：

集合（Set）：无序且元素不重复的集合，用花括号（{ }）表示，可以进行交集、并集、差集等操作。
命名元组（Namedtuple）：位于 collections 模块中，是一种创建具有命名字段的元组的工厂函数。能够用标签获取一个元组的元素，比普通元组更具可读性。

PYTHONPATH变量是什么

PYTHONPATH 是一个环境变量，用于指定 Python 解释器在导入模块时要搜索的路径。当你在 Python 程序中使用 import 语句导入模块时，解释器会在 PYTHONPATH 中指定的路径下搜索要导入的模块。

通常情况下，PYTHONPATH 包含了 Python 源库目录以及其他含有 Python 源代码的目录。它可以包含一个或多个目录路径，多个路径之间用系统路径分隔符（如在 Unix 系统中是冒号 :，在 Windows 系统中是分号 ;）分隔。

如果你需要在 Python 程序中使用自定义的模块或包，并且这些模块或包不在默认的搜索路径下，你可以将它们所在的目录添加到 PYTHONPATH 环境变量中，这样 Python 解释器就能够找到并导入这些模块或包了。

生成器（Generator）：

生成器是一种特殊的迭代器，它可以通过定义一个函数（使用 def 关键字），并在其中使用 yield 关键字来生成值。
每次调用生成器的 __next__() 方法时，它会从上一次 yield 的位置恢复执行，并继续执行到下一个 yield。
生成器函数可以保存状态，并且在迭代过程中，只在需要时才会计算值，因此生成器在处理大量数据时更加高效，并且可以节省内存。

迭代器（Iterator）：

迭代器是一个具有 __iter__() 和 __next__() 方法的对象，它用于遍历集合中的元素。
迭代器通过调用 iter() 函数得到，然后使用 next() 函数来获取下一个元素，直到遍历完所有元素。
迭代器的设计思想是惰性计算，它不会一次性把所有数据加载到内存中，而是在需要时逐个生成，从而节省内存空间。
在 Python 中，许多内置的数据类型和数据结构都是可迭代的，比如列表、元组、字典等，它们都可以通过 iter() 函数转换为迭代器。

两者之间的区别和联系：

生成器是迭代器的一种实现方式，通过函数来创建，而迭代器可以是任何具有 __iter__() 和 __next__() 方法的对象。
生成器更加简洁、灵活，并且能够动态生成值，而迭代器通常是基于某种数据结构或算法生成的。
生成器在定义时使用 yield 来生成值，而迭代器通过 __next__() 方法来逐个获取值。
生成器可以在迭代过程中保存状态，而迭代器通常只在遍历时计算值。

生成器与函数：
- 函数是一段代码的封装，可以通过调用来执行特定的任务，并且可以返回一个值或多个值。
- 生成器是一种特殊的函数，它在执行过程中可以暂停并保存当前状态，然后在需要时再恢复执行。生成器使用 yield 关键字来产生值，每次调用生成器的 __next__() 方法或使用 for 循环时，都会执行生成器函数直到遇到下一个 yield 语句。
参数传递机制：
- Python 中的参数传递方式主要有两种：引用传递和值传递。
- 对于可变对象（如列表、字典等），函数内部对参数的修改会影响到原始对象，这是因为在函数内部操作的是对象的引用，而不是对象本身的拷贝，这就是引用传递。
- 对于不可变对象（如字符串、数值、元组等），由于其值在传递过程中不可变，所以函数内部的修改不会影响原始对象，这是因为函数内部会生成一个对象的副本，这就是值传递。

id、type 和 value：
- id() 函数返回对象的内存地址，即对象在内存中的唯一标识符。
- type() 函数返回对象的类型。
- "==" 操作符用于比较两个对象的值是否相等，即比较对象的内容。
- "is" 操作符用于比较两个对象的内存地址是否相等，即判断两个对象是否是同一个对象。
__new__ 和 __init__ 的区别：
- __new__() 是一个静态方法，用于创建对象实例。它是在对象实际创建之前调用的，并且负责返回一个新的实例。它的主要作用是创建一个实例对象，通常用于自定义不可变类型的实例化过程。
- __init__() 是一个实例方法，用于初始化对象。它在对象实例已经创建之后调用，可以在这个方法中对对象进行一些属性的初始化操作。它不返回任何值，只是对已经存在的对象进行初始化。

调用顺序通常是 __new__() 方法创建对象实例，然后将这个实例作为第一个参数传递给 __init__() 方法进行初始化。例如：

class MyClass:
    def __new__(cls, *args, **kwargs):
        instance = super().__new__(cls)  # 创建对象实例
        return instance

    def __init__(self, value):
        self.value = value  # 初始化对象属性

obj = MyClass(10)  # 这里会依次调用 __new__() 和 __init__() 方法

cookie和session的关系和区别

关系和区别：
- Cookie 和 Session 是用来跟踪用户身份和状态的机制，它们之间有密切的关系，但也有一些重要的区别。
- Cookie 是在客户端（浏览器）上存储数据的一种机制，而 Session 则是在服务器端存储数据的一种机制。
- 为了确保会话的连续性，服务器会在客户端创建一个唯一的标识符（通常称为 session ID），然后将该标识符存储在 Cookie 中，以便在后续请求中将其发送回服务器。因此，Session 机制依赖于 Cookie 机制。
安全性：
- 由于 Cookie 存储在客户端，因此存在一定的安全风险，因为它们可以被本地分析和篡改。这使得 Cookie 可能会受到 CSRF（跨站请求伪造）等攻击的影响。相比之下，Session 存储在服务器端，更加安全，因为客户端无法直接访问和修改 Session 数据。
性能考虑：
- 由于 Session 数据存储在服务器端，对服务器的性能会有一定的影响，特别是在有大量并发访问的情况下。相比之下，Cookie 存储在客户端，不会直接影响服务器性能，但是如果过多的数据存储在 Cookie 中也会影响网络传输的性能。
数据限制：
- 单个 Cookie 存储的数据量通常有限，一般不超过4KB，而且大多数浏览器对每个站点的 Cookie 数量也有限制。相比之下，Session 数据存储在服务器端，受服务器硬件和配置等因素的影响，一般可以存储更大量的数据。
建议：
- 对于重要的用户身份信息和敏感数据，应当存储在 Session 中，以保证安全性。
- 对于一些临时性的数据和用户偏好设置等，可以存储在 Cookie 中，以减轻服务器负担并提升性能。

命名空间是一个存储了变量名和对象之间关联关系的容器，它用来确定变量名在程序中的作用域和可见性。Python 中有以下几种命名空间：

内置命名空间（Built-in Namespace）：包含了 Python 内置的函数和类型，如 print()、len()、int、str 等。这些函数和类型无需导入即可直接使用，它们在 Python 解释器启动时就加载到内存中。
全局命名空间（Global Namespace）：每个模块都拥有一个全局命名空间，用来存储该模块中定义的变量、函数、类等。模块中的全局变量在整个模块中可见，但在其他模块中需要通过模块名来访问。
局部命名空间（Local Namespace）：在函数或方法内部定义的变量存储在局部命名空间中，它们只能在函数或方法内部访问。局部命名空间在函数或方法被调用时创建，在函数或方法执行完毕后销毁。
嵌套命名空间（Enclosing Namespace）：在函数或类的内部定义的函数或类会创建嵌套命名空间。嵌套命名空间可以访问外部函数或类的变量，但不能直接修改，需要通过 nonlocal 关键字声明。

在 Python 中，命名空间的查找顺序是：局部命名空间 -> 嵌套命名空间 -> 全局命名空间 -> 内置命名空间。当查找一个变量时，Python 解释器会按照这个顺序逐级向外查找，直到找到为止。如果在所有的命名空间中都找不到对应的变量，则会抛出 NameError 异常。

自用总结

关注

20
点赞
踩
23

收藏

觉得还不错? 一键收藏
1
评论
python基础2

装饰器是 Python 中一种非常强大的语法特性，它允许我们在不修改原函数代码的情况下，为函数添加额外的功能。下面我来解释一下装饰器的几个常见功能，并介绍 @staticmethod、@classmethod 和 @property 这几个装饰器的用法和区别。：可以在函数执行前后打印日志，用于调试和追踪程序执行流程。：记录函数执行所花费的时间，用于性能分析和优化。：在执行函数之前进行一些准备工作，如参数验证等。：在函数执行后进行一些清理工作，如资源释放等。
复制链接

扫一扫