Python 3 备忘清单

• Python 官方网站 (python.org)
• Python 文档 (docs.python.org)
• Y 分钟学会 Python (learnxinyminutes.com)
• Python 中的正则表达式 (jaywcjlove.github.io)

>>> print("Hello, World!")
Hello, World!

著名的“Hello World”程序在 Python 中的实现

age = 18       # 年龄是 int 类型
name = "John"  # 名字现在是 str 类型
print(name)

• Python 不能在没有赋值的情况下声明变量
• 变量可以存放不同类型的值

>>> msg = "Hello, World!"
>>> print(msg[2:5])
llo

查看: 字符串

mylist = []
mylist.append(1)
mylist.append(2)
for item in mylist:
    print(item) # 打印输出 1,2

查看: 列表

num = 200
if num > 0:
    print("num is greater than 0")
else:
    print("num is not greater than 0")

查看: 判断

for item in range(6):
    if item == 3: break
    print(item)
else:
    print("Finally finished!")

查看: 循环

>>> def my_function():
...     print("来自函数的你好")
...
>>> my_function()
来自函数的你好

查看: 函数

result = 10 + 30 # => 40
result = 40 - 10 # => 30
result = 50 * 5  # => 250
result = 16 / 4  # => 4.0 (Float Division)
result = 16 // 4 # => 4 (Integer Division)
result = 25 % 2  # => 1
result = 5 ** 3  # => 125

/ 表示 x 和 y 的商，// 表示 x 和 y 的底商，另见 StackOverflow

counter = 0
counter += 10           # => 10
counter = 0
counter = counter + 10  # => 10
message = "Part 1."
# => Part 1.Part 2.
message += "Part 2."   

>>> website = 'Quick Reference'
>>> f"Hello, {website}"
"Hello, Quick Reference"
>>> num = 10
>>> f'{num} + 10 = {num + 10}'
'10 + 10 = 20'

查看: f-字符串

hello = "Hello World"
hello = 'Hello World'
multi_string = """Multiline Strings
Lorem ipsum dolor sit amet,
consectetur adipiscing elit """

查看: 字符串

x = 1    # 整数
y = 2.8  # 浮点小数
z = 1j   # 复数
>>> print(type(x))
<class 'int'>

只要内存足够，可以容纳无限大(小)的数值

my_bool = True 
my_bool = False
bool(0)     # => False
bool(1)     # => True

bool 是 int 的子类

list1 = ["apple", "banana", "cherry"]
list2 = [True, False, False]
list3 = [1, 5, 7, 9, 3]
list4 = list((1, 5, 7, 9, 3))

查看: 列表

my_tuple = (1, 2, 3)
my_tuple = tuple((1, 2, 3))

类似列表，但自身不可变

set1 = {"a", "b", "c"}   
set2 = set(("a", "b", "c"))

类似列表，但里面的元素是无序而不重复的

>>> empty_dict = {}
>>> a = {"one": 1, "two": 2, "three": 3}
>>> a["one"]
1
>>> a.keys()
dict_keys(['one', 'two', 'three'])
>>> a.values()
dict_values([1, 2, 3])
>>> a.update({"four": 4})
>>> a.keys()
dict_keys(['one', 'two', 'three', 'four'])
>>> a['four']
4

键-值对，一种像 JSON 那样对象

>>> hello = "Hello, World"
>>> print(hello[1])  # 获取第二个字符
e
>>> print(hello[-1])  # 获取倒数第一个字符
d
>>> print(type(hello[-1]))  # 得到的还是字符串
<class 'str'>

>>> for char in "foo":
...     print(char)
f
o
o

对字符串 for-in 可以得到每个字符（类型还是字符串）

>>> hello = "Hello, World!"
>>> print(len(hello))
13

len() 函数返回字符串的长度

>>> s = '===+'
>>> n = 8
>>> s * n
'===+===+===+===+===+===+===+===+'

>>> s = 'spam'
>>> s in 'I saw spamalot!'
True
>>> s not in 'I saw The Holy Grail!'
True

判断 "spam" 这个字符串是否在其它字符串里

>>> s = 'spam'
>>> t = 'egg'
>>> s + t  # 可以使用加号进行拼接
'spamegg'
>>> 'spam' 'egg'  # 两个字符串之间可以省略加号
'spamegg'

>>> name = input("Enter your name: ")
Enter your name: Tom
>>> name
'Tom'

从控制台获取输入数据

>>> "、".join(["John", "Peter", "Vicky"])
'John、Peter、Vicky'

>>> f'{"text":10}'   # 使用空格填充到指定长度
'text      '
>>> f'{"test":*>10}' # 向左填充
'******test'
>>> f'{"test":*<10}' # 向右填充
'test******'
>>> f'{"test":*^10}' # 居中填充
'***test***'
>>> f'{12345:0>10}'  # 使用数字填充
'0000012345'

>>> f'{12345:+}'      # 显示正数的正号
'+12345'
>>> f'{-12345:+}'     # 显示负数的负号
'-12345'
>>> f'{-12345:+10}'   # 显示负号，并使用空格填充，直到长度为 10
'    -12345'
>>> f'{-12345:+010}'  # 显示负号，并使用0填充，直到长度为 10
'-000012345'

>>> f'{-12345:0=10}'  # 负数
'-000012345'
>>> f'{12345:010}'    # [0] 快捷方式（不对齐）
'0000012345'
>>> f'{-12345:010}'
'-000012345'
>>> import math       # [.precision]
>>> math.pi
3.141592653589793
>>> f'{math.pi:.2f}'
'3.14'
>>> f'{1000000:,.2f}' # [分组选项]
'1,000,000.00'
>>> f'{1000000:_.2f}'
'1_000_000.00'
>>> f'{0.25:0%}'      # 百分比
'25.000000%'
>>> f'{0.25:.0%}'
'25%'

>>> li1 = []
>>> li1
[]
>>> li2 = [4, 5, 6]
>>> li2
[4, 5, 6]
>>> li3 = list((1, 2, 3))
>>> li3
[1, 2, 3]
>>> li4 = list(range(1, 11))
>>> li4
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> li = []
>>> li.append(1)
>>> li
[1]
>>> li.append(2)
>>> li
[1, 2]
>>> li.append(4)
>>> li
[1, 2, 4]
>>> li.append(3)
>>> li
[1, 2, 4, 3]

>>> li = ['bread', 'butter', 'milk']
>>> li.pop()
'milk'
>>> li
['bread', 'butter']
>>> del li[0]
>>> li
['butter']
>>> li.remove('butter')
>>> li
[]

>>> li = ['a', 'b', 'c', 'd']
>>> li[0]
'a'
>>> li[-1]
'd'
>>> li[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

>>> li = [3, 1, 3, 2, 5]
>>> li.count(3)
2

>>> li = ["re"] * 3
>>> li
['re', 're', 're']

>>> nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]
>>> nums.index(2)
3
>>> nums.index(100, 3, 7)  # 搜索3-7之间的元素
5
>>> nums.index(7, 4) # 搜索4之后的元素
6

当寻找一个不存在的值时，抛出ValueError。

number = int(input('输入一个整数：'))
if number < 0:
    print("您输入了一个负数。")
else:
    print("您输入了一个非负整数。")

number = int(input('输入一个整数：'))
if number < 0:
    print("您输入了一个负数。")
elif number == 0:
    print("您输入了一个 0 。")
else:
    print("您输入了一个正数。")

scope = int(input('输入百分制成绩：'))
line = 60
tip = "及格" if scope >= line else "不及格"
# 相当于 scope >= line ? "及格" : "不及格"
print(tip)

注意条件是放在中间的

primes = [2, 3, 5, 7]
for prime in primes:
    print(prime)

animals = ["dog", "cat", "mouse"]
for i, value in enumerate(animals):
    print(i, value)

x = 0
while x < 4:
    print(x)
    x += 1  # Shorthand for x = x + 1

x = 0
for index in range(10):
    x = index * 10
    if index == 5:
        break
    print(x)

for index in range(3, 8): 
    x = index * 10
    if index == 5:
        continue
    print(x)

for i in range(4):
    print(i) # Prints: 0 1 2 3
for i in range(4, 8):
    print(i) # Prints: 4 5 6 7
for i in range(4, 10, 2):
    print(i) # Prints: 4 6 8

name = ['Pete', 'John', 'Elizabeth']
age = [6, 23, 44]
for n, a in zip(name, age):
    print('%s is %d years old' %(n, a))

def hello_world():  
    print('Hello, World!')

def add(x, y):
    print("x is %s, y is %s" %(x, y))
    return x + y
add(5, 6)    # => 11

def varargs(*args):
    return args
varargs(1, 2, 3)  # => (1, 2, 3)

args 的类型是 tuple

def keyword_args(**kwargs):
    return kwargs
# => {"big": "foot", "loch": "ness"}
keyword_args(big="foot", loch="ness")

kwargs 的类型是 dict

def swap(x, y):
    return y, x
x = 1
y = 2
x, y = swap(x, y)  # => x = 2, y = 1

def add(x, y=10):
    return x + y
add(5)      # => 15
add(5, 20)  # => 25

# => True
(lambda x: x > 2)(3)
# => 5
(lambda x, y: x ** 2 + y ** 2)(2, 1)

ip, port = "127.0.0.1", 80
print(ip)  # -> "127.0.0.1"
print(port)  # -> 80

# 与以下代码等价
ip, port = ("127.0.0.1", 80)

# 与以下代码效果相同
ip, port = ["127.0.0.1", 80]

ip, _, port = "127.0.0.1:80".rpartition(":")
print(ip)  # -> "127.0.0.1"
print(port)  # -> "80"

# _ 这个变量此刻的值是 ":" ，但一般不再使用。

_ 也是一个单一变量，不允许解包多个元素，因此变量与值必须一一对应。

major, minor, *parts = "3.10.2.beta".split(".")
print(major)  # -> "3"
print(minor)  # -> "10"
print(parts)  # -> ["2", "beta"]

# 可将 parts 改为 _ 来表示不再需要后面的元素

这里的 * 就是收集序列在解包过程中多出来的元素， 只能有一个，与向函数传递位置参数时的 * 别无二致。

major, minor, *_ = "3.10.2.beta".split(".")

print(major)  # -> "3"
print(minor)  # -> "10"

major, *_, level = "3.10.2.beta".split(".")

print(major)  # -> "3"
print(level)  # -> "beta"

*_, micro, level = "3.10.2.beta".split(".")

print(micro)  # -> "2"
print(level)  # -> "beta"

a, b, *_ = {3, 2, 1}
print(a)  # -> 1
print(b)  # -> 2
print(_)  # -> [3]

集合 中的元素是无序的，因此解包结果不能轻易确定。

a, b, *_ = range(3)
print(a)  # -> 0
print(b)  # -> 1
print(_)  # -> [2]

支持 迭代器 协议的对象也可被解包。

a, b, *_ = dict(a=1, b=2, c=3)
print(a)  # -> "a"
print(_)  # -> ["c"]
a, b, *_ = dict(a=1, b=2, c=3).values()
print(a)  # -> 1
print(_)  # -> [3]

chars = (*"abc", *"def", "g", "h")
# -> ("a", "b", "c", "d", "e", "f", "g", "h")

digits = [*range(10), *"abcdef"]
# -> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
#     "a", "b", "c", "d", "e", "f"]

part = {"小明": 18, "小亮": 22}
summary = {"小花": 16, **part}
print(summary)
# -> {"小花": 16, "小明": 18, "小亮": 22}

• 仅在列表／元组生成式中可以使用多个 *
• 仅在字典生成式中可以使用多个 **

students = [
    ("小明", 18),
    ("小亮", 22),
]
for k, v in students:
    print(k)  # -> "小明"、"小亮"
    print(v)  # -> 18、22

students = [
    (0, ("小明", 18)),
    (1, ("小亮", 22)),
]
for i, (k, v) in students:
    print(i)  # -> 0、1
    print(k)  # -> "小明"、"小亮"
    print(v)  # -> 18、22

def version(major, minor, *parts):
    print(major)  # -> "3"
    print(minor)  # -> "10"
    print(parts)  # -> ("2", "beta", "0")

version("3", "10", "2", "beta", "0")
# 过程类似于
major, minor, *parts = ("3", "10", "2", "beta", "0")


def version():
    parts = "3.10.2.beta.0".split(".")
    return *parts, "x64"

print(version())
# -> ("3", "10", "2", "beta", "0", "x64")

import math
print(math.sqrt(16))  # => 4.0

from math import ceil, floor
print(ceil(3.7))   # => 4.0
print(floor(3.7))  # => 3.0

from math import *

import math as m
# => True
math.sqrt(16) == m.sqrt(16)

import math
dir(math)

import os
os.remove("myfile.txt")

import os
if os.path.exists("myfile.txt"):
    os.remove("myfile.txt")
else:
    print("The file does not exist")

import os
os.rmdir("myfolder")

class MyNewClass:
    pass
# 类的实例化
my = MyNewClass()

class Animal:
    def __init__(self, voice):
        self.voice = voice
 
cat = Animal('Meow')
print(cat.voice)    # => Meow
 
dog = Animal('Woof') 
print(dog.voice)    # => Woof

class Dog:
    # 类的方法
    def bark(self):
        print("Ham-Ham")
 
charlie = Dog()
charlie.bark()   # => "Ham-Ham"

class Employee:
    def __init__(self, name):
        self.name = name
 
    def __repr__(self):
        return self.name
 
john = Employee('John')
print(john)  # => John

class CustomError(Exception):
    pass

class ParentClass:
    def print_self(self):
        print('A')
 
class ChildClass(ParentClass):
    def print_self(self):
        print('B')
 
obj_A = ParentClass()
obj_B = ChildClass()
 
obj_A.print_self() # => A
obj_B.print_self() # => B

class ParentClass:
    def print_self(self):
        print("Parent")
 
class ChildClass(ParentClass):
    def print_self(self):
        print("Child")
 
child_instance = ChildClass()
child_instance.print_self() # => Child

class Animal: 
    def __init__(self, name, legs):
        self.name = name
        self.legs = legs
        
class Dog(Animal):
    def sound(self):
        print("Woof!")
 
Yoki = Dog("Yoki", 4)
print(Yoki.name) # => YOKI
print(Yoki.legs) # => 4
Yoki.sound()     # => Woof!

实现计算属性、只读属性和验证逻辑。

class Person:
    def __init__(self, age):
        self._age = age  # 约定：_age 为内部属性

    @property
    def age(self):
        """获取年龄的方法，伪装成属性"""
        return self._age

    @age.setter
    def age(self, value):
        """设置年龄的方法，添加验证逻辑"""
        if value < 0:
            raise ValueError("年龄不能为负数")
        self._age = value

# 使用示例
p = Person(30)
print(p.age)  # 直接访问属性，无需括号 → 30
p.age = 31    # 赋值操作调用 @age.setter → 验证通过
p.age = -5    # 抛出 ValueError: 年龄不能为负数

参见 自定义类创建 。

from typing import Any

class Object:
    def __new__(cls, *args, **kwargs) -> "self":
        # new 和 init 声明的参数必须一致
        # 或者用 *args 和 **kwargs 进行兼容
        return object.__new__(cls)

    def __init__(self, *args, **kwargs):
        # 初始化方法没有返回值，也不能返回值。
        pass

    def __call__(self, *args, **kwargs) -> Any:
        pass

# 依次调用了 new 和 init，所以如果
# 手动调用 new，那么别忘了调用 init
obj = Object()

# 触发 __call__ 方法，要给什么参数取决于声明
obj()

string: str = "ha"
times: int = 3

print(string * times)  # => hahaha

result: str = 1 + 2

print(result)  # => 3

错误的类型标注不会影响正常运行，也不会报错

def say(name: str, start: str = "Hi"):
    return start + ", " + name

print(say("Python"))  # => Hi, Python

def calc_summary(*args: int):
    return sum(args)

print(calc_summary(3, 1, 4))  # => 8

表示 args 的所有元素都是 int 类型的。

def say_hello(name) -> str:
    return "Hello, " + name

var = "Python"
print(say_hello(var))  # => Hello, Python

from typing import Union

def resp200(meaningful) -> Union[int, str]:
    return "OK" if meaningful else 200

表示返回值可能是 int，也可能是 str 。

def calc_summary(**kwargs: int):
    return sum(kwargs.values())

print(calc_summary(a=1, b=2))  # => 3

表示 kwargs 的所有值都是 int 类型的。

def resp200() -> (int, str):
    return 200, "OK"

def resp200(meaningful) -> int | str:
    return "OK" if meaningful else 200

自 Python 3.10 起可用。

class Employee:
    name: str
    age: int

    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.graduated: bool = False

class Employee:
    name: str
    age: int

    def set_name(self, name) -> "Employee":
        self.name = name
        return self

这里表示 set_name() 返回了一个 Employee 对象。

from typing import Self

class Employee:
    name: str
    age: int

    def set_name(self: Self, name) -> Self:
        self.name = name
        return self

# 这是单行注释

""" 可以写多行字符串
    使用三个"，并且经常使用
    作为文档。
"""

''' 可以写多行字符串
    使用三个'，并且经常使用
    作为文档。
'''

def double_numbers(iterable):
    for i in iterable:
        yield i + i

生成器可帮助您编写惰性代码

values = (-x for x in [1,2,3,4,5])
gen_to_list = list(values)
# => [-1, -2, -3, -4, -5]
print(gen_to_list)

将一个函数应用到可迭代对象（如列表）的每个元素上，并返回一个新的迭代器。

def square(x):
    return x ** 2

使用 map 函数
numbers = [1, 2, 3, 4]
result = map(square, numbers)

转换为列表查看结果
print(list(result))  # 输出: [1, 4, 9, 16]

对可迭代对象进行排序，返回一个新的已排序列表（原对象不变）

# 按照分数排序
users = [
    {"name": "Alice", "score": 95, "time": "2023-01-15 10:30:00"},
    {"name": "Bob", "score": 88, "time": "2023-01-15 09:45:00"},
    {"name": "Charlie", "score": 95, "time": "2023-01-14 15:20:00"},
    {"name": "David", "score": 85, "time": "2023-01-16 11:10:00"}
]
# reverse=True代表降序排序
sorted_users = sorted(users, key=lambda x: x["score"], reverse=True)

# 输出结果
for user in sorted_users:
    print(f"{user['name']}: {user['score']}")

# 结果：
# Alice: 95
# Charlie: 95
# Bob: 88
# David: 85

将一个二元函数（接受两个参数的函数）累积应用到可迭代对象的元素上，最终合并为单个值

from functools import reduce

# 定义一个乘法函数
def multiply(x, y):
    return x * y

# 使用 reduce 函数
numbers = [2, 3, 4, 5]
result = reduce(multiply, numbers)

print(result)  # 输出: 120（2×3×4×5=120）

固定原函数的某些参数，生成新函数

from functools import partial

# 原函数：计算 x 的 y 次幂
def power(x, y):
    return x ** y

# 创建偏函数，固定 y=2（即平方函数）
square = partial(power, y=2)

# 调用偏函数
print(square(5))  # 输出: 25 (5²)
print(square(10)) # 输出: 100 (10²)