type
status
date
slug
summary
tags
category
icon
password

Python知识点

一.保留关键字 -35个

类别
关键字
说明
逻辑值
True
布尔真值
False
布尔假值
None
表示空值或无值
逻辑运算
and
逻辑与运算
or
逻辑或运算
not
逻辑非运算
条件控制
if
条件判断语句
elif
否则如果(else if 的缩写)
else
否则分支
循环控制
for
迭代循环
while
条件循环
break
跳出循环
continue
跳过当前循环的剩余部分,进入下一次迭代
异常处理
try
尝试执行代码块
except
捕获异常
finally
无论是否发生异常都会执行的代码块
raise
抛出异常
函数定义
def
定义函数
return
从函数返回值
lambda
创建匿名函数
类与对象
class
定义类
del
删除对象引用
模块导入
import
导入模块
from
从模块导入特定部分
as
为导入的模块或对象创建别名
作用域
global
声明全局变量
nonlocal
声明非局部变量(用于嵌套函数)
异步编程
async
声明异步函数
await
等待异步操作完成
其他
assert
断言,用于测试条件是否为真
in
检查成员关系
is
检查对象身份(是否是同一个对象)
pass
空语句,用于占位
with
上下文管理器,用于资源管理
yield
从生成器函数返回值

二.基本数据类型

  • 不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
  • 可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。
  • bool(布尔类型) bool 是 int 的子类,True 和 False 可以和数字相加, True==1、False==0 会返回 True,但可以通过 is 来判断类型。
  1. 数字类型:
    1. List(列表):
      1. 加号 + 是列表连接运算符,星号 * 是重复操作。
    1. Tuple(元组):
      1. tuple的元素不可改变,但它可以包含可变的对象,比如list列表
    1. Set(集合):
      1. Dictionary(字典)

        三.symbols 符号 59-2(弃用)个

        运算符
        描述
        实例
        , ‘ ” ’’’ ”””
        列表/元组/参数分隔 ,逗号 单/双引号定义字符串 多行字符串 / 文档字符串
        +
        加 - 两个对象相加
        a + b 输出结果 31
        -
        减 - 得到负数或是一个数减去另一个数
        a - b 输出结果 -11
        *
        乘 - 两个数相乘或是返回一个被重复若干次的字符串
        a * b 输出结果 210
        /
        除 - x 除以 y
        b / a 输出结果 2.1
        %
        取模 - 返回除法的余数
        b % a 输出结果 1
        **
        幂 - 返回x的y次幂
        a**b 为10的21次方
        //
        取整除 - 往小的方向取整数
        >>> 9//2 4 >>> -9//2 -5
        ==
        等于 - 比较对象是否相等
        (a == b) 返回 False。
        !=
        不等于 - 比较两个对象是否不相等
        (a != b) 返回 True。
        >
        大于 - 返回x是否大于y
        (a > b) 返回 False。
        <
        小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。注意,这些变量名的大写。
        (a < b) 返回 True。
        >=
        大于等于 - 返回x是否大于等于y。
        (a >= b) 返回 False。
        <=
        小于等于 - 返回x是否小于等于y。
        (a <= b) 返回 True。
        = (无)
        简单的赋值运算符
        c = a + b 将 a + b 的运算结果赋值为 c
        +=
        加法赋值运算符
        c += a 等效于 c = c + a
        -=
        减法赋值运算符
        c -= a 等效于 c = c - a
        *=
        乘法赋值运算符
        c *= a 等效于 c = c * a
        /=
        除法赋值运算符
        c /= a 等效于 c = c / a
        %=
        取模赋值运算符
        c %= a 等效于 c = c % a
        **=
        幂赋值运算符
        c **= a 等效于 c = c ** a
        //=
        取整除赋值运算符
        c //= a 等效于 c = c // a
        := (无)
        海象运算符,这个运算符的主要目的是在表达式中同时进行赋值和返回赋值的值。
        在这个示例中,赋值表达式可以避免调用 len() 两次:if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")
        a = 0011 1100 b = 0000 1101
        &
        按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
        (a & b) 输出结果 12 ,二进制解释: 0000 1100
        |
        按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。
        (a | b) 输出结果 61 ,二进制解释: 0011 1101
        ^
        按位异或运算符:当两对应的二进位相异时,结果为1
        (a ^ b) 输出结果 49 ,二进制解释: 0011 0001
        ~
        按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1
        (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。
        <<
        左移动运算符:运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。
        a << 2 输出结果 240 ,二进制解释: 1111 0000
        >>
        右移动运算符:把">>"左边的运算数的各二进位全部右移若干位,">>"右边的数指定移动的位数
        a >> 2 输出结果 15 ,二进制解释: 0000 1111
        &= >>= |= ^= <<=
        b"…" b'…’
        bytes
        r"…" r'…’
        原始字符串(不转义)
        f"…" f'…’
        f-string 格式化字符串
        u"…" u'…’
        unicode 字符串(Python3 默认就是 unicode)
        [ ]
        列表、索引、切片
        { (无) } (无)
        字典、集合
        ( )
        元组、函数调用
        _
        1.一般作占位变量 2.在交互式解释器中,表示上一次表达式的结果Python REPL 中 _ 自动保存上一次表达式的结果 >>> 10 + 5 15 >>> _ * 2 30 # 上一次结果 15 被 _ 保存 3.在模块或类中表示 弱“受保护”约定 单下划线开头的变量 _name(注意这里是 _name,不是单独 _)表示 内部使用,不希望被外部 import 或直接访问 这是一种约定,不是语法限制(和双下划线 __ 不同,没有 name mangling)
        __ 双下划线
        1.在类定义内部-名称保护机制 双下划线开头,但不以双下划线结尾的属性,被视为类私有名称,会触发“名称改写”,Python 编译阶段会自动把它重命名为 _类名__属性名,用于避免与子类产生命名冲突。 class Ham: __spam = 42 改写为:_Ham__spam 2.魔术方法 双下划线开头 + 双下划线结尾的名字为 Python 保留:
        省略号对象(用于切片、高级语法、占位)
        @
        装饰器语法,如 @staticmethod
        :
        用于函数、类、条件语句、切片等
        .
        属性访问(如 obj.attr
        \
        转义符 / 行连接符
        j J
        复数的虚数部分(如 3+4j)
        `
        弃用
        <>
        弃用、不等于

        四.字符串

        • 转义字符
        转义字符
        描述
        示例
        \\
        反斜杠本身
        "\\n"\n
        \'
        单引号
        'I\'m OK'
        \"
        双引号
        "He said \"Hi\""
        \n
        换行
        "Hello\nWorld"
        \r
        回车
        "abc\r123"
        \t
        制表符(Tab)
        "A\tB"
        \b
        退格
        "AB\bC"
        \f
        换页符
        \v
        纵向制表符
        \a
        响铃(Beep)
        某些系统可听到提示音
        \0
        空字符 NULL
        \N{…}
        Unicode 字符名
        "\N{GREEK CAPITAL LETTER DELTA}"
        \uXXXX
        16 位 Unicode 编码
        "\u4F60" → “你”
        \UXXXXXXXX
        32 位 Unicode 编码
        \xhh
        十六进制字符
        "\x41"'A'
        \ooo
        八进制字符
        "\101"'A'
        • 格式化字符号(第一代)
        符号
        描述
        示例
        %s
        字符串
        "%s" % "hello"
        %d
        十进制整数
        "%d" % 10
        %i
        整数(同 %d
        %f
        浮点数
        "%.2f" % 3.1415
        %.nf
        保留 n 位小数
        "%.3f" % 1.23456
        %x
        十六进制(小写)
        "%x" % 255ff
        %X
        十六进制(大写)
        "%X" % 255FF
        %o
        八进制
        "%o" % 10
        %e
        科学计数法(小写)
        "%.2e" % 12345
        %E
        科学计数法(大写)
        %c
        单个字符
        "%c" % 65'A'
        %%
        字面量 %
        "100%%"'100%'
        格式化操作符辅助指令
        标志
        作用
        示例
        -
        左对齐
        "%-10s" % "hi"
        +
        显示符号(正负号)
        "%+d" % 5 → +5
        (空格)
        正数前补空格
        "% d" % 5
        0
        数字前补 0
        "%05d" % 42 → 00042
        #
        八进制/十六进制带前缀
        "%#x" % 255 → 0xff
        • str.format 格式化符号(第二代)
        对齐相关
        描述
        示例
        {:>10}
        右对齐,宽度 10
        `"{}{}".format('
        {:<10}
        左对齐,宽度 10
        "{:<10}".format("hi")'hi '
        {:^10}
        居中,宽 10
        "{:^10}".format("hi")' hi '
        {:*<10}
        右侧用 * 填充
        "{:*<10}".format("hi")'hi********'
        {:*>10}
        左侧用 * 填充
        "{:*>10}".format("hi")'********hi'
        {:*^10}
        居中用 *
        "{:*^10}".format("hi")'****hi****'
        {:<10.5}
        截断 + 左对齐
        "{:<10.5}".format("HelloWorld") → 'Hello '
        {:.5}
        截取前 5 个字符
        "{:.5}".format("HelloWorld") → Hello
        数字相关
        描述
        示例
        {:d}
        十进制整数
        "{:d}".format(42) → 42
        {:b}
        二进制
        "{:b}".format(10) → 1010
        {:o}
        八进制
        "{:o}".format(10) → 12
        {:x}
        十六进制(小写)
        "{:x}".format(255) → ff
        {:X}
        十六进制(大写)
        "{:X}".format(255) → FF
        :#x
        十六进制带 0x
        "{:#x}".format(255) → 0xff
        :,
        千分位
        "{:,}".format(1234567) → 1,234,567
        {:f}
        默认小数点后 6 位
        "{:f}".format(3.14) → 3.140000
        {:.2f}
        保留 2 位小数
        "{:.2f}".format(3.1415) → 3.14
        {:e}
        科学计数法
        "{:e}".format(10000) → 1.000000e+04
        {:.2e}
        科学计数法 2 位小数
        "{:.2e}".format(10000)
        {:g}
        自适应格式
        "{:g}".format(123456) → 123456
        {:+.2f}
        显示正负号
        "{:+.2f}".format(3.14) → +3.14
        {:0>8.2f}
        左侧补 0,宽 8
        "{:0>8.2f}".format(3.14) → 00003.14
        格式
        描述
        示例
        {:s}
        字符串(自动)
        "{:s}".format("hi")
        {:}
        默认格式
        "{}".format(123)
        {!s}
        强制 str
        "{!s}".format(123) → '123'
        {!r}
        强制 repr
        "{!r}".format("hi") → "'hi'"
        {!a}
        ascii 格式
        "{!a}".format("中")
        {0}
        位置参数
        "{} {}".format("hello", "world")
        {name}
        命名参数
        "{greet} {name}".format(greet="hi", name="Tom")
        {0[1]}
        下标访问
        "{0[1]}".format([10, 20]) → 20
        {user.name}
        属性访问
        "{p.x}".format(p=Point(3,5)) → 3
        • f-string(第三代)
        f-string 格式化规则 完全继承 str.format 的格式说明符,但书写更简单。

        五.内置函数 71个

        函数名
        描述
        实例
        abs(number/)
        返回一个数字的绝对值。 参数可以是整数、浮点数或任何实现了 __abs__() 的对象。 如果参数是一个复数,则返回它的模。
        abs(-10) --> 10
        aiter(async_iterable/)
        返回一个 异步迭代器。返回 asynchronous iterable 的 asynchronous iterator 。相当于调用 x.__aiter__()。与iter()不同,aiter()没有两个参数的版本。
        async def gen(): yield 1; --> aiter(gen())
        all(iterable/)
        如果 iterable 的所有元素均为真值(或可迭代对象为空)则返回 True 。
        all([1, True, 'a']) --> True
        awaitable anext(async_iterator/) awaitable anext(async_iteratordefault/)
        异步迭代器中获取下一项。
        async def gen(): yield 1; await anext(gen()) --> 1
        any(iterable/)
        如果 可迭代对象中至少有一个元素为 ,则返回 True
        any([0, False, '']) --> False
        ascii(object/)
        返回对象的 可打印表示形式,对于非 ASCII 字符使用 \x\u\U 转义。
        ascii('你好') --> "'\\u4f60\\u597d'"
        bin(integer/)
        将整数转换为以 "0b" 开头的 二进制字符串
        bin(10) --> '0b1010'
        bool()
        将给定值转换为 布尔值(True 或 False)。
        bool(0) --> False
        breakpoint()
        调用 调试器(默认为 pdb)。
        在代码行中插入 breakpoint() 即可进入调试模式。
        bytearray()
        返回一个新的 字节数组对象,它是可变的序列。
        bytearray(5) --> bytearray(b'\x00\x00\x00\x00\x00')
        bytes()
        返回一个新的 字节对象,它是不可变的序列。
        bytes('abc', 'utf-8') --> b'abc'
        callable(object/)
        如果对象看起来可被 调用(如函数、方法),则返回 True
        callable(len) --> True
        chr(codepoint/)
        返回 Unicode 码点为给定整数的字符。
        chr(65) --> 'A'
        @classmethod
        将方法转换为 类方法
        在类方法定义前使用 @classmethod 装饰器。
        ccompile(sourcefilenamemodeflags=0dont_inherit=Falseoptimize=-1)
        将源字符串编译成 代码对象AST 对象,以便 exec()eval() 执行。
        code = compile('print(1+1)', '', 'exec')
        complex()
        创建一个 复数(带实部和虚部)。
        complex(3, 4) --> (3+4j)
        delattr()
        删除对象的命名属性。
        delattr(obj, 'attr_name')
        dict()
        创建一个新的 字典
        dict(a=1, b=2) --> {'a': 1, 'b': 2}
        dir() dir(object/)
        返回对象 有效属性的列表。
        dir(list) --> ['append', 'count', ...]
        divmod(ab/)
        返回 (商, 余数)元组
        divmod(10, 3) --> (3, 1)
        enumerate(iterablestart=0)
        返回一个 枚举对象(包含 (索引, 值) 对)。
        list(enumerate(['a', 'b'])) --> [(0, 'a'), (1, 'b')]
        eval(source/globals=Nonelocals=None)
        将字符串作为 Python 表达式求值并返回结果。
        eval('10 + 5') --> 15
        exec(source/globals=Nonelocals=None, , closure=None)
        执行作为字符串或代码对象给定的 Python 代码
        exec('x = 10; print(x)') --> 10
        filter(functioniterable/)
        使用函数过滤 可迭代对象中的元素,返回一个 迭代器
        list(filter(lambda x: x > 5, [1, 6, 3, 8])) --> [6, 8]
        float()
        将整数或字符串转换为 浮点数
        float('3.14') --> 3.14
        format(valueformat_spec=''/)
        将值格式化为 指定的格式
        format(123, '06d') --> '000123'
        frozenset(iterable=()/)
        返回一个新的 不可变集合对象。
        frozenset([1, 2, 3]) --> frozenset({1, 2, 3})
        getattr(objectname/) getattr(objectnamedefault/)
        object 中指定名称的属性的值。 name 必须是字符串。 如果该字符串是对象的某一属性的名称,则结果将为该属性的值。
        getattr(obj, 'attr_name', default)
        globals()
        返回表示当前 全局符号表的字典。
        globals()['__name__'] --> '__main__'
        hasattr(objectname/)
        检查对象是否具有命名的 属性
        hasattr(obj, 'attr_name') --> True/False
        hash(object/)
        返回对象的 哈希值(仅适用于可哈希对象)。
        hash(123) --> 123
        help() help(request)
        启动 内置帮助系统(或打印对象的帮助信息)。
        help(str.lower)
        hex(integer/)
        将整数转换为以 "0x" 开头的 十六进制字符串
        hex(255) --> '0xff'
        id(object/)
        返回对象的 “身份”(在 CPython 中是内存地址)。
        id(1) --> ...
        input() input(prompt/)
        从标准输入读取 一行文本。
        s = input('--> ') --> -> Monty Python's Flying Circus s --> "Monty Python's Flying Circus"
        int(number=0/) int(string/base=10)
        将字符串或数字转换为 整数
        int('10') --> 10 int('01110011', base=2) --> 115
        isinstance(objectclassinfo/)
        检查对象是否是给定 类或类型的实例。
        isinstance(1, int) --> True
        issubclass(classclassinfo/)
        检查一个类是否是另一个类的 子类
        issubclass(bool, int) --> True
        iter(iterable/) iter(callablesentinel/)
        返回一个 迭代器对象。
        iter([1, 2]) --> <list_iterator object at ...>
        len(object/)
        返回对象的 长度(元素数量)。
        len('hello') --> 5
        list(iterable=()/)
        创建一个新的 列表
        list('abc') --> ['a', 'b', 'c']
        locals()
        返回表示当前 局部符号表的字典。
        def func(): x=1; return locals()['x'] --> 1
        map(functioniterable/iterablesstrict=False)
        将函数应用于 可迭代对象的所有元素,返回一个 迭代器
        list(map(str.upper, ['a', 'b'])) --> ['A', 'B']
        max(iterable/, , key=None) max(iterable/, , defaultkey=None) max(arg1arg2/argskey=None)
        返回可迭代对象中的 最大元素或多个参数中的最大值。
        max(1, 5, 2) --> 5
        memoryview(object)
        返回给定参数的 内存视图对象。
        mv = memoryview(b'abc')
        min(iterable/, , key=None) min(iterable/, , defaultkey=None) min(arg1arg2/argskey=None)
        返回可迭代对象中的 最小元素或多个参数中的最小值。
        min(1, 5, 2) --> 1
        next(iterator/) next(iteratordefault/)
        通过调用迭代器的 __next__() 方法返回 迭代器中的下一项。如果迭代器耗尽,则返回给定的default
        it = iter([1, 2]); next(it) --> 1
        class object
        这是所有其他类的终极基类。 它提供了所有 Python 类实例均具有的方法。 当其构造器被调用时,它将返回一个新的基本对象。 该构造器不接受任何参数。object实例没有__dict__属性,因此你无法将任意属性赋给object的实例。
        obj = object()
        oct(integer/)
        将整数转换为以 "0o" 开头的 八进制字符串
        oct(8) --> '0o10'
        open(filemode='r'buffering=-1encoding=Noneerrors=Nonenewline=Noneclosefd=Trueopener=None)
        打开文件并返回一个 文件对象'r'读取(默认) 'w'写入,并先截断文件 'x'排它性创建,如果文件已存在则失败 'a'打开文件用于写入,如果文件存在则在末尾追加 'b'二进制模式 't'文本模式(默认) '+'打开用于更新(读取与写入)
        f = open('file.txt', 'r')
        ord(character/)
        返回给定 字符的 Unicode 码点(整数)。
        ord('A') --> 65
        pow(baseexpmod=None)
        返回 base 的 exp 次幂;如果 mod 存在,则返回 base 的 exp 次幂对 mod 取余
        pow(2, 3) --> 8
        print(objectssep=' 'end='\n'file=Noneflush=False)
        将对象打印到 文本流(默认为 sys.stdout)。
        print('Hello', 'World') --> Hello World
        property(fget=Nonefset=Nonefdel=Nonedoc=None)
        fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。见附表
        在方法定义前使用 @property 装饰器。
        class range(stop/) class range(startstopstep=1/)
        返回一个生成数字序列的 不可变序列
        list(range(3)) --> [0, 1, 2]
        repr(object/)
        返回对象的一个包含其 正式表示的字符串。
        repr('a\nb') --> "'a\\nb'"
        reversed(object/)
        返回一个 反向迭代器。该参数必须是一个具有 reversed() 方法或是支持序列协议(具有 len() 方法和从 0 开始的整数参数的 getitem() 方法)的对象。
        list(reversed([1, 2, 3])) --> [3, 2, 1]
        round(numberndigits=None)
        返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None,则返回最接近输入值的整数。这个函数有点奇葩,尽量别用
        round(3.14159, 2) --> 3.14
        set(iterable=()/)
        创建一个新的 集合对象。
        set([1, 2, 2]) --> {1, 2}
        setattr(objectnamevalue/)
        设置对象的命名属性的值。
        setattr(x, 'foobar', 123) 等价 x.foobar = 123
        class slice(stop/) class slice(startstopstep=None/)
        回一个表示由 range(start, stop, step) 指定的索引集的 切片 对象。 start 和 step 参数默认为 None
        my_list[1:5:2] 等价于 my_list[slice(1, 5, 2)]
        sorted(iterable/, , key=Nonereverse=False)
        返回一个新的 排序列表
        sorted([3, 1, 2]) --> [1, 2, 3]
        @staticmethod
        将方法转换为 静态方法见附表
        在静态方法定义前使用 @staticmethod 装饰器。
        class str(*, encoding='utf-8'errors='strict') class str(object) class str(objectencodingerrors='strict') class str(object, , errors)
        返回对象的 字符串表示
        str(123) --> '123'
        sum(iterable/start=0)
        从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字,而 start 值则不允许为字符串。
        sum([1, 2, 3]) --> 6
        class super class super(typeobject_or_type=None/)
        返回一个 代理对象,它委托对父类或同级类方法的调用。见附表
        super().method()
        tuple(iterable=()/)
        创建一个新的 元组
        tuple([1, 2, 3]) --> (1, 2, 3)
        class type(object/)class type(namebasesdict/*kwargs)
        返回对象的 类型(或用于创建新类型)。
        type(1) --> <class 'int'>
        vars() vars(object/)
        返回模块、类、实例或另一个具有 __dict__ 属性的对象的 __dict__ 属性。并非所有实例都具有 __dict__ 属性;
        class A: pass; vars(A) --> {'__module__': ...}
        zip(iterablesstrict=False)
        创建一个迭代器,它将来自多个可迭代对象的元素 聚合在一起。如果未指定 strict=True 参数,所有导致可迭代对象长度不同的错误都会被抑制,这可能会在程序的其他地方表现为难以发现的错误。
        list(zip([1, 2], ['a', 'b'])) --> [(1, 'a'), (2, 'b')]
        __import__(nameglobals=Nonelocals=Nonefromlist=()level=0)
        此函数由 import 语句调用,用于 导入模块
        module = __import__('os')
         
         

        五.控制语句

        关键字:if、elif、else、while、for、break、continue、match、case
        推导式:

        六.迭代器和生成器

        迭代器

        迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。迭代器有两个基本的方法:iter() 和 next()
        • 创建一个迭代器
        把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

        生成器

        使用了 yield 的函数被称为生成器(generator)。yield 是一个关键字,用于定义生成器函数,生成器函数是一种特殊的函数,可以在迭代过程中逐步产生值,而不是一次性返回所有结果。跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。当在生成器函数中使用 yield 语句时,函数的执行将会暂停,并将 yield 后面的表达式作为当前迭代的值返回。每次调用生成器的 next() 方法或使用 for 循环进行迭代时,函数会从上次暂停的地方继续执行,直到再次遇到 yield 语句。这样,生成器函数可以逐步产生值,而不需要一次性计算并返回所有结果。调用一个生成器函数,返回的是一个迭代器对象。

        七.函数

        函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
        notion image

        1.参数传递:

        python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。
        Python中变量是没有类型的,a=[1,2,3]a="Runoob"[1,2,3] 是 List 类型,"Runoob" 是 String 类型,而变量 a 是没有类型,它仅仅是一个对象的引用(一个指针),可以是指向 List 类型对象,也可以是指向 String 类型对象。
        python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
        • 不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变 a 的值,相当于新生成了 a。
        • 可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。
         
         

        2.参数分类:

        • 位置形参:须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
        • 关键字形参:允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
        • 默认参数:调用函数时,如果没有传递参数,则会使用默认
        • 不定长参数:你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名。
            1. 加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。
            1. 两个星号 ** 的参数会以字典的形式导入。
            1. 声明函数时,参数中星号 * 可以单独出现,如果单独出现星号 *,则星号 * 后的参数必须用关键字传入。
            1. 语法 / 用来指明函数形参必须使用指定位置参数,不能使用关键字参数的形式。
        • 混合参数顺序:普通参数 → *args → 默认参数 → **kwargs

          3.return 语句

          return [表达式] 语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。

          4.匿名函数 lambda

          不再使用 def 语句这样标准的形式定义一个函数。
          • lambda 只是一个表达式,函数体比 def 简单很多。
          • lambda 的主体是一个表达式,而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
          • lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
          • 虽然 lambda 函数看起来只能写一行,却不等同于 C 或 C++ 的内联函数,内联函数的目的是调用小函数时不占用栈内存从而减少函数调用的开销,提高代码的执行速度。

          5.作用域

          Python 查找变量的顺序:
          1. Local (局部作用域:当前函数内)
          1. Enclosing (嵌套作用域:外部嵌套函数内)
          1. Global (全局作用域:模块级别)
          1. Built-in (内置作用域:如 print, len 等)
          使用 globalnonlocal 关键字来修改外部作用域的变量。

          6.装饰器

          装饰器本质上是一个接受函数作为参数并返回一个新函数的函数。它用于在不修改原函数代码的情况下,增强原函数的功能。
          装饰器的语法使用 @decorator_name 来应用在函数或方法上。
          Python 还提供了一些内置的装饰器,比如 @staticmethod 和 @classmethod,用于定义静态方法和类方法。
          装饰器的应用场景:
          • 日志记录: 装饰器可用于记录函数的调用信息、参数和返回值。
          • 性能分析: 可以使用装饰器来测量函数的执行时间。
          • 权限控制: 装饰器可用于限制对某些函数的访问权限。
          • 缓存: 装饰器可用于实现函数结果的缓存,以提高性能。
          示例:
          • my_decorator 是一个装饰器函数,它接受 say_hello 作为参数,并返回 wrapper 函数。
          • @my_decorator 将 say_hello 替换为 wrapper。
           
           
           
           
           

          对象

          在python中一切皆是对象,对象是python中对数据的抽象,python程序中的所有数据都是由对象或对象间的关系来表示的。无论是你写的代码、定义的函数、导入的模块、创建的类、类的实例、内置数据类型、甚至数据类型本身等都是对象,
          核心概念:对象(Object) 在Python中,“对象”可以理解为内存中一块存储数据的区域,并且这块区域有三个核心要素: 1. 身份(Identity):对象的内存地址。你可以使用内置函数 $id()$ 来获取它。身份在对象创建后通常不会改变。 2. 类型(Type):对象所属的类别,它定义了对象可以存储什么数据以及可以执行什么操作(即它的属性方法)。你可以使用内置函数 $type()$ 来获取它。 3. 值(Value):对象所存储的实际数据。值可能会改变(对于可变对象,如列表 $list$),也可能不会改变(对于不可变对象,如整数 $int$ 和字符串 $str$)。
          对象的类型 由于Python中一切皆是对象,这意味着: • 函数也是对象:函数可以像普通变量一样被赋值给另一个变量,可以作为参数传递给其他函数,也可以作为另一个函数的返回值。 • 类也是对象:当你定义一个类时,它本身就是一个类型对象。你可以像处理其他对象一样处理这个类对象,比如将它存储在一个列表中。 • 模块也是对象:当你使用 $import$ 语句导入一个模块时,Python会在内存中创建一个模块对象
          有些对象的  可以改变。值可以改变的对象被称为 可变对象;值不可以改变的对象就被称为 不可变对象。(一个不可变容器对象如果包含对可变对象的引用,当后者的值改变时,前者的值也会改变;但是该容器仍属于不可变对象,因为它所包含的对象集是不会改变的。因此,不可变并不严格等同于值不能改变,实际含义要更微妙。) 一个对象的可变性是由其类型决定的;例如,数字、字符串和元组是不可变的,而字典和列表是可变的。
          对象绝不会被显式地销毁;然而,当无法访问时它们可能会被作为垃圾回收。允许具体的实现推迟垃圾回收或完全省略此机制 --- 如何实现垃圾回收是实现的质量问题,只要可访问的对象不会被回收即可。CPython 目前使用带有 (可选) 延迟检测循环链接垃圾的引用计数方案,会在对象不可访问时立即回收其中的大部分,但不保证回收包含循环引用的垃圾。不要依赖不可访问对象的立即终结机制 (所以你应当总是显式地关闭文件)。
          注意:使用实现的跟踪或调试功能可能令正常情况下会被回收的对象继续存活。还要注意通过 try...except 语句捕捉异常也可能令对象保持存活。try...finally 语句和 with 语句提供了进行显式关闭操。
          类型会影响对象行为的几乎所有方面(比如1,可以是int类型,float类型,bool类型,但是这些类型的行为可是千差万别)。 甚至对象标识号的重要性也在某种程度上受到影响:对于不可变类型,计算新值的操作实际上可能返回一个指向具有相同类型和值的任何现存对象的引用,而对于可变对象来说这是不允许的。 例如在 a = 1; b = 1 之后,a 和 b 可能会也可能不会指向同一个值为一的对象。 这是因为 int 是不可变对象,因此对 1 的引用可以被重用。 此行为依赖于所使用的具体实现,因此不应该依赖它,而在使用对象标识测试时需要注意。 不过,在 c = []; d = [] 之后,c 和 d 保证会指向两个不同的、独特的、新创建的空列表。 (注意 e = f = [] 会将 同一个 对象同时赋值给 e 和 f。)
           
           
           

          类:

          类定义就是对类对象的定义
          类定义是一条可执行语句。 其中继承列表通常给出基类的列表 (进阶用法请参见 元类),列表中的每一项都应当被求值为一个允许子类的类对象。 没有继承列表的类默认继承自基类 object;因此,:
           
           
           

          collections --- 容器数据类型

          这个模块实现了一些专门化的容器,提供了对 Python 的通用内建容器 dictlistset 和 tuple 的补充。
          对象
          描述
          特点
          示例
          一个工厂函数,用来创建元组的子类,子类的字段是有名称的。
          - 元组子类,支持字段名作为属性访问。 - 元素不可变。 - 提高代码可读性,适用于需要使用多个元素的结构化数据。
          from collections import namedtuple Point = namedtuple('Point', ['x', 'y']) p = Point(10, 20) print(p.x, p.y) # 输出: 10 20
          一个双端队列,支持从两端快速添加或删除元素。
          - 具备 append()pop() 的双端操作,比 list 在队列操作上更高效。 - 支持 rotate() 操作。 - 内存利用率高,适合频繁的队列操作。
          from collections import deque dq = deque([1, 2, 3]) dq.append(4) dq.appendleft(0) dq.pop() # 4 dq.popleft() # 0
          类似字典的类,用于创建包含多个映射的单个视图。
          - 多个字典(或映射)可以组合成一个 ChainMap 对象,查询会依次查找。 - 修改操作只会影响第一个映射。
          from collections import ChainMap a = {'x': 1, 'y': 2} b = {'y': 3, 'z': 4} cm = ChainMap(a, b) print(cm['y']) # 输出: 2 print(cm['z']) # 输出: 4
          用于计数哈希对象的字典子类,统计对象在可迭代对象中的出现次数。
          - 返回元素出现次数的计数器对象。 - 支持常见的集合操作:+, , &, |
          from collections import Counter c = Counter('abracadabra') print(c) # 输出: Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
          字典的子类,能记住条目被添加进去的顺序。
          - 内置的 dict 已经默认保持插入顺序,但 OrderedDict 提供了更明确的顺序控制。 - 支持一些额外方法,如 move_to_end()
          from collections import OrderedDict od = OrderedDict() od['a'] = 1 od['b'] = 2 od['c'] = 3 od.move_to_end('b') print(list(od.keys())) # 输出: ['a', 'c', 'b']
          字典的子类,通过调用用户指定的工厂函数,为键提供默认值。
          - 如果字典中访问一个不存在的键,会自动调用指定的工厂函数生成默认值,避免 KeyError。 - 支持指定不同的默认值类型,如 int(默认 0)或 list(默认空列表)。
          from collections import defaultdict dd = defaultdict(int) dd['a'] += 1 print(dd['a']) # 输出: 1 print(dd['b']) # 输出: 0
          封装了字典对象,简化了字典子类化
          - 提供字典的基本功能,但允许更容易地扩展和自定义行为。
          from collections import UserDict class MyDict(UserDict): def setitem(self, key, value): if isinstance(value, str): super().setitem(key, value.upper()) # 强制值为大写 else: super().setitem(key, value) d = MyDict() d['a'] = 'hello' print(d['a']) # 输出: 'HELLO'
          封装了列表对象,简化了列表子类化
          - 提供对列表的操作,但允许自定义行为,适合需要扩展列表功能的场景。
          from collections import UserList class MyList(UserList): def append(self, value): if value not in self.data: super().append(value) # 不重复添加 else: print(f"{value} 已经在列表中") l = MyList([1, 2, 3]) l.append(4) l.append(2) # 输出: 2 已经在列表中 print(l) # 输出: [1, 2, 3, 4]
          封装了字符串对象,简化了字符串子类化
          - 提供对字符串操作的封装,并允许自定义行为,适合需要扩展字符串功能的场景。
          from collections import UserString class MyString(UserString): def reverse(self): return self.data[::-1] s = MyString("hello") print(s.reverse()) # 输出: 'olleh'
           
           
           
           
           
           
           

          环境配置

          1. 直接使用Python安装
          1. conda 安装
          1. venv环境
          1. uv环境
          1. pip指令安装包
           
           
           
           
           
           

          特殊要点附录

          特殊要点
          with关键字(上下文管理器)
          with 是用于 简化资源管理 的关键字,用于确保资源在使用后被正确释放(如文件、网络连接、锁、数据库连接等)。 - 👍基本用法 with expression [as variable]:# 代码块 expression 返回一个支持上下文管理协议的对象as variable 是可选的,用于将表达式结果赋值给变量代码块执行完毕后,自动调用清理方法 - 👍🏼工作原理 with 语句背后是 Python 的上下文管理协议,该协议要求对象实现两个方法:1.__enter__():进入上下文时调用,返回值赋给 as 后的变量2.__exit__():退出上下文时调用,处理清理工作 3.异常处理机制:__exit__() 方法接收三个参数:exc_type:异常类型、exc_val:异常值、exc_tb:异常追踪信息、如果 __exit__() 返回 True,则表示异常已被处理,不会继续传播;返回 False 或 None,异常会👍🏼继续向外传播。 - 👍🏻示例: class Timer: def __enter__(self): import time self.start = time.time() return self def __exit__(self, exc_type, exc_val, exc_tb): import time self.end = time.time() print(f"耗时: {self.end - self.start:.2f}秒") return False # 使用示例 with Timer() as t: # 执行一些耗时操作 sum(range(1000000)) - 👍🏾使用contextlib模块快速实现上下文管理器 from contextlib import contextmanager @contextmanager def tag(name): print(f"<{name}>") yield print(f"</{name}>") # 使用示例 with tag("h1"): print("这是一个标题")
          类方法(@classmethod@staticmethod
          classmethod 是一种绑定到类而不是实例的方法。调用类方法时,方法的第一个参数是类本身(而不是实例),通常使用 cls 来表示类。它的定义方式是通过 @classmethod 装饰器。当函数是类的属性时,它可以成为类方法,而普通的用户定义函数不会自动绑定为类或实例的方法。 class MyClass: # 实例方法 def instance_method(self, arg): print(f"Instance method called with {self} and {arg}") # 用户自定义函数(普通方法) # 第一个参数是self,也就是类实例对象,普通函数(没有使用@classmethod@staticmethod 装饰器),这些函数并不会自动绑定到类或者实例上,调用时需要显式地传递实例或者类作为第一个参数 def regular_method(self, arg): print(f"Regular method called with {self} and {arg}") # 类方法 @classmethod def class_method(cls, arg): # classmethod的第一个参数是cls,即使不实例化也能调用类C的该方法 print(f"Called {cls} with {arg}") # 静态方法 @staticmethod def static_method(arg): print(f"Static method called with {arg}") # 创建实例 obj = MyClass() # 实例类obj,得到一个类实例对象 # 调用实例方法,自动传入实例(self) obj.instance_method(10) # 正常的实例方法调用 # 调用普通用户自定义方法,传入实例作为第一个参数 obj.regular_method(20) # 推荐 MyClass.regular_method(obj, 10) # 手动传入self # 调用类方法,自动传入类(cls) obj.class_method(30) # 实例调用,也传入类 MyClass.class_method(30) # 类调用,自动传入类 # 调用静态方法,不传递实例或类 obj.static_method(40) # 实例调用,静态方法没有自动绑定 MyClass.static_method(40) # 类调用
          class property(fget=Nonefset=Nonefdel=Nonedoc=None)
          fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。 property 函数是 Python 面向对象编程中一个非常重要的机制,它允许你以访问 属性 的方式来操作 方法,从而实现 属性的托管(Managed Attributes)property 函数的作用是 将一个类的普通方法(getter、setter、deleter)“封装”或“绑定”到一个属性名上。这样,当你访问、修改或删除这个属性时,实际上执行的是你指定的方法,而不是直接操作实例的字典(__dict__)。 class C: def __init__(self): self._x = None def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I'm the 'x' property.") 如果 c 为 C 的实例,c.x 将调用 getter,c.x = value 将调用 setter, del c.x 将调用 deleter。你可以在不改变外部调用接口(保持 c.x 的形式)的情况下,在幕后默默地添加复杂的逻辑,实现了良好的 封装。 1. 只读属性(@property@property 装饰器用于修饰 getter 方法,将其转换为一个 只读属性。 class Parrot: def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage @property 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性 "getter",并将 voltage 的文档字符串设为 "Get the current voltage." 当你使用parrot.voltage 会执行 voltage() 方法。尝试设置 parrot.voltage = value 会报错,因为它没有定义 setter。 2. 可读写属性(@property + @setter)要创建一个完整的可读写属性,你需要先用 @property 装饰 getter,然后使用 特征属性对象(这里是 x)的 .setter.deleter 方法来装饰相应的方法 class C: # 1. 定义 Getter 并创建 property 对象 x @property def x(self): """I'm the 'x' property.""" return self._x # 2. 使用 x.setter 装饰器定义 Setter # ⚠️ 注意:方法名必须与属性名 (x) 相同 @x.setter def x(self, value): # 可以在这里添加逻辑,如类型检查 self._x = value # 3. 使用 x.deleter 装饰器定义 Deleter @x.deleter def x(self): del self._x 这种装饰器写法 与第一个例子(函数传入)是完全等价的,但结构更清晰,更常用于现代 Python 代码中。 3.懒加载/延迟计算(Lazy Loading) class AppConfig: @property def settings(self): # 只有第一次访问 self.settings 时才会执行下面的逻辑 if not hasattr(self, '_settings'): print("正在加载配置文件...") # 假设这是耗时的文件读取操作 self._settings = {"timeout": 30, "log_level": "DEBUG"} return self._settings config = AppConfig() # 第一次访问:触发加载 设置self._settings属性 print(config.settings['timeout']) # 第二次访问:直接返回已存储的值,不再重新加载 print(config.settings['log_level']) 4.迁移和重构(Refactoring) # 早期版本 class User: def __init__(self, email): self.email = email # 公共属性,直接存储 user = User("test@example.com") print(user.email) # 外部代码直接访问 # 后续新增:必须对 email 进行格式验证和规范化,以确保数据的质量。 class User: def init(self, email): # 初始化时调用 setter,确保初始值也被验证 self.email = email # --- Getter (提供只读访问) --- @property def email(self): """外部代码访问 user.email 时,实际执行此方法""" return self._email # --- Setter (引入验证和新逻辑) --- @email.setter def email(self, new_email): # 1. 新增逻辑:数据验证 (例如,确保包含 '@') if "@" not in new_email: raise ValueError("Email 地址格式不正确,必须包含 @ 符号。") # 2. 新增逻辑:数据清洗/规范化 (例如,全部转为小写) validated_email = new_email.lower() # 3. 存储到私有属性 self._email = validated_email print(f"✅ Email 已更新并验证:{self._email}") # --- 外部代码调用(无需修改) --- user = User("Test@Example.com") # ✅ Email 已更新并验证:test@example.com # 外部代码仍使用 user.email 访问和赋值 print(f"获取 Email: {user.email}") # 输出:test@example.com # 尝试非法赋值 try: user.email = "invalidemail" except ValueError as e: print(f"❌ 错误捕获:{e}") # 错误捕获:Email 地址格式不正确...
          super()
          Python 的一个内置类,它提供了一种委托方法调用给父类或兄弟类的方式。它在处理需要协作继承的类层次结构时非常有用。 super()的主要作用是返回一个代理对象(proxy object),这个代理对象会将方法的调用委托给类层次结构中的下一个合适类。 - 调用父类方法: 在子类中调用被覆盖的父类方法,比如调用父类的 __init__ 方法。 - 协作继承: 在涉及多重继承的复杂类结构中,它能确保调用正确的方法,遵循方法解析顺序 (Method Resolution Order, MRO)。 1. 零参数调用 (最常见用法)用法: super().method_name() 上下文: 仅在类定义内部实例方法中(即方法接收 self 作为第一个参数)使用。 super() 自动确定当前类和当前实例。它实际上等同于 super(CurrentClass, self)。 class Parent: def __init__(self, value): self.value = value class Child(Parent): def __init__(self, value, extra): # 自动委托给 Parent.__init__(self, value) super().__init__(value) self.extra = extra # super() 会确保在多重继承时, # 调用 MRO 中下一个类的 __init__ 方法。 2. MRO (方法解析顺序) 在多重继承中,super() 的行为完全由类的 __mro__ 属性定义的方法解析顺序控制。super() 不是简单地查找“直接父类”,而是查找 MRO 中当前类之后的第一个类。你可以通过调用 Class.mro() 或查看 Class.__mro__ 来查看任何类的 MRO。 class A: def method(self): print("A") class B(A): def method(self): print("B"); super().method() class C(A): def method(self): print("C"); super().method() class D(B, C): def method(self): print("D"); super().method() # MRO for D: (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>) d = D() d.method() # 输出: D -> B -> C -> A # D 调用 super() -> B # B 调用 super() -> C # C 调用 super() -> A
           

          函数学习

          重要内置函数
          描述
          类型转换函数
          描述
          将x转换为一个整数
          将x转换到一个浮点数
          创建一个复数
          将对象 x 转换为字符串
          将对象 x 转换为表达式字符串
          用来计算在字符串中的有效Python表达式,并返回一个对象
          将序列 s 转换为一个元组
          将序列 s 转换为一个列表
          转换为可变集合
          创建一个字典。d 必须是一个 (key, value)元组序列。
          转换为不可变集合
          将一个整数转换为一个字符
          将一个字符转换为它的整数值
          将一个整数转换为一个十六进制字符串
          将一个整数转换为一个八进制字符串
          数学函数
          abs(x)
          返回数字的绝对值,如abs(-10) 返回 10
          ceil(x)
          返回数字的上入整数,如math.ceil(4.1) 返回 5
          cmp(x, y)
          如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃,使用 (x>y)-(x<y) 替换。
          exp(x)
          返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
          fabs(x)
          以浮点数形式返回数字的绝对值,如math.fabs(-10) 返回10.0
          floor(x)
          返回数字的下舍整数,如math.floor(4.9)返回 4
          log(x)
          如math.log(math.e)返回1.0,math.log(100,10)返回2.0
          log10(x)
          返回以10为基数的x的对数,如math.log10(100)返回 2.0
          max(x1, x2,...)
          返回给定参数的最大值,参数可以为序列。
          min(x1, x2,...)
          返回给定参数的最小值,参数可以为序列。
          modf(x)
          返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。
          pow(x, y)
          x**y 运算后的值。
          round(x [,n])
          返回浮点数 x 的四舍五入值,如给出 n 值,则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
          sqrt(x)
          返回数字x的平方根。
          随机数函数
          choice(seq)
          从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。
          randrange ([start,] stop [,step])
          从指定范围内,按指定基数递增的集合中获取一个随机数,基数默认值为 1
          random()
          随机生成下一个实数,它在[0,1)范围内。
          seed([x])
          改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。
          shuffle(lst)
          将序列的所有元素随机排序
          uniform(x, y)
          随机生成下一个实数,它在[x,y]范围内。
          三角函数
          acos(x)
          返回x的反余弦弧度值。
          asin(x)
          返回x的反正弦弧度值。
          atan(x)
          返回x的反正切弧度值。
          atan2(y, x)
          返回给定的 X 及 Y 坐标值的反正切值。
          cos(x)
          返回x的弧度的余弦值。
          hypot(x, y)
          返回欧几里德范数 sqrt(x*x + y*y)。
          sin(x)
          返回的x弧度的正弦值。
          tan(x)
          返回x弧度的正切值。
          degrees(x)
          将弧度转换为角度,如degrees(math.pi/2) , 返回90.0
          radians(x)
          将角度转换为弧度
          数学常量
          pi
          数学常量 pi(圆周率,一般以π来表示)
          e
          数学常量 e,e即自然常数(自然常数)。
          字符串函数
          描述
          len(s)
          返回字符串长度
          s.lower()
          转小写
          s.upper()
          转大写
          s.title()
          单词首字母大写
          s.capitalize()
          首字符大写,其余小写
          s.strip()
          去掉首尾空白字符
          s.lstrip()
          去掉左侧空白
          s.rstrip()
          去掉右侧空白
          s.replace(old, new)
          替换字符串
          s.split(sep)
          按分隔符切割为列表(默认空白)
          s.rsplit(sep)
          从右侧开始切割
          s.join(list)
          用当前字符串把列表连接起来
          s.startswith(x)
          判断是否以 x 开头
          s.endswith(x)
          判断是否以 x 结尾
          s.find(x)
          查找子串索引,找不到返回 -1
          s.rfind(x)
          从右侧查找子串索引
          s.index(x)
          查找子串,找不到报错
          s.count(x)
          统计子串出现次数
          s.isdigit()
          是否全为数字字符
          s.isalpha()
          是否全为字母
          s.isalnum()
          是否字母数字组合
          s.isspace()
          是否全为空白字符
          s.islower()
          是否全为小写
          s.isupper()
          是否全为大写
          s.zfill(n)
          左侧补零到长度 n
          s.center(n)
          居中并填充
          s.ljust(n)
          左对齐
          s.rjust(n)
          右对齐
          s.encode(encoding)
          转为字节串
          s.format(...)
          格式化字符串
          f"{var}"
          f-string 插值,更推荐
          序列和可迭代对象操作
          描述
          range()
          创建一个不可变的数字序列,常用于循环。
          sorted()
          返回一个新的已排序的列表,不改变原对象
          reversed()
          返回一个反向的迭代器。
          enumerate()
          将一个可迭代对象组合为一个包含 索引元素 的元组序列。
          zip()
          将多个可迭代对象中对应位置的元素打包成元组。
          函数式编程工具
          map()
          对可迭代对象中的每个元素应用同一个函数,返回一个迭代器。
          list(map(str.upper, ['a', 'b'])) -> ['A', 'B']
          filter()
          过滤掉不满足条件的元素,返回一个迭代器。
          list(filter(lambda x: x > 5, [1, 7, 3, 9])) -> [7, 9]
          输入/输出于属性
          print()
          将值输出到标准输出设备。
          input()
          从用户获取输入(返回值为字符串)。
          open()
          打开文件并返回文件对象,用于文件操作。
          help()
          启动内置帮助系统,查看对象文档。
          dir()
          返回对象属性和方法的列表。
          高级函数
          all()
          如果可迭代对象的所有元素都为 True(或可迭代对象为空),则返回 True
          any()
          如果可迭代对象中至少有一个元素为 True,则返回 True
          id()
          返回对象的“身份”值,通常是其内存地址。
          isinstance()
          检查一个对象是否是指定类型或类型的子类。
           

          附录:

          补充知识点
          global interpreter lock (GIL)-- 全局解释器锁CPython 解释器所采用的一种机制,它确保同一时刻只有一个线程在执行 Python 字节码。此机制通过设置对象模型针对并发访问的隐式安全简化了 CPython 实现。给整个解释器加锁使得解释器多线程运行更方便,其代价则是牺牲了在多处理器上的并行性。不过,某些标准库或第三方库的扩展模块被设计为在执行计算密集型任务如压缩或哈希时释放 GIL。 此外,在执行 I/O 操作时也总是会释放 GIL。在 Python 3.13 中,GIL 可以使用 -disable-gil 构建配置选项来禁用。 在使用此选项构建 Python 之后,代码必须附带 X gil=0 或在设置 PYTHON_GIL=0 环境变量后运行。 此特性将为多线程应用程序启用性能提升并让高效率地使用多核 CPU 更加容易。 要了解详情,请参阅 PEP 703。在之前版本的 Python's C API 中,一个函数可能会声明它需要持有 GIL 才能够使用。 这被称为具有一个 attached thread state
          bytecode -- 字节码Python 源代码会被编译为字节码,即 CPython 解释器中表示 Python 程序的内部代码。字节码还会缓存在文件中的__pycache__文件夹下的 .pyc 文件中(可以被cpu直接读取的字节码),这样第二次执行同一文件时速度更快(可以免去将源码重新编译为字节码)。这种 "中间语言" 运行在根据字节码执行相应机器码的 虚拟机(这里可以理解为Python解释器) 之上。请注意不同 Python 虚拟机上的字节码不一定通用,也不一定能在不同 Python 版本上兼容。
          python文件编码 默认情况下,Python 源码文件的编码是 UTF-8。这种编码支持世界上大多数语言的字符,可以用于字符串字面值、变量、函数名及注释 —— 尽管标准库只用常规的 ASCII 字符作为变量名或函数名,可移植代码都应遵守此约定。要正确显示这些字符,编辑器必须能识别 UTF-8 编码,而且必须使用支持文件中所有字符的字体。 使用utf-8编码、文件第一行写: # -- coding: utf-8 --
          切片、索引: 索引指向的是字符 之间 ,第一个字符的左侧标为 0,最后一个字符的右侧标为 n ,n 是字符串长度。例如: +---+---+---+---+---+---+ | P | y | t | h | o | n | +---+---+---+---+---+---+ å0 1 2 3 4 5 6 -6 -5 -4 -3 -2 -1
           
           
           
          算法(二)网站说明和notion书写技巧
          Loading...
          🐲🦄😁😄
          🐲🦄😁😄
          一个普通的干饭人🍚
          Latest posts
          Python复习
          2025-12-9
          算法学习
          2025-11-19
          数据结构与算法
          2025-11-19
          算法(一)
          2025-11-19
          算法(二)
          2025-11-19
          网站说明和notion书写技巧
          2025-5-7
          Announcement
          🦚🦜当然是选择热爱生活了🐲🦄
          自强不息,厚德载物 格物致知,正心修身 致知于行,知行合一