reference/docs/python.md

Python 3 备忘清单
===

Python 备忘单是 [Python 3](https://www.python.org/) 编程语言的单页参考表

入门
-----

### 介绍

- [Python 官方网站](https://www.python.org/)  _(python.org)_
- [Python 文档](https://docs.python.org/zh-cn/3/index.html)  _(docs.python.org)_
- [Y 分钟学会 Python](https://learnxinyminutes.com/docs/zh-cn/python-cn/) _(learnxinyminutes.com)_
- [Python 中的正则表达式](./regex.md#python-中的正则表达式) _(jaywcjlove.github.io)_

### 控制台打印

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

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

### 变量

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

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

### 内置数据类型
<!--rehype:wrap-class=row-span-2-->
序列指一批有序的元素，集合指一批无序且不重复的元素

| :-                                      | :-               |
|:----------------------------------------|:-----------------|
| `str`                                   | 文本／字符串（Text）     |
| `int`, `float`, `complex`               | 数值（Numeric）      |
| `dict`                                  | 映射／键值对（Mapping）  |
| `list`, `tuple`, `range`                | 序列（Sequence）     |
| `set`, `frozenset`                      | 集合（Set）          |
| `bool`                                  | 布尔值／逻辑值（Boolean） |
| `bytes`, `bytearray`, <br> `memoryview` | 二进制数据（Binary）    |

查看: [数据类型](#python-数据类型)

### 字符串切片

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

查看: [字符串](#python-字符串)

### 列表

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

查看: [列表](#python-列表)

### 判断

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

查看: [判断](#python-判断)

### 循环

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

查看: [循环](#python-循环)

### 函数

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

查看: [函数](#函数)

### 文件处理
<!--rehype:wrap-class=col-span-2-->

```python
with open("myfile.txt", "r", encoding='utf8') as file:
    for line in file:
        print(line)
```

查看: [文件处理](#python-文件处理)

### 算术

```python
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](https://stackoverflow.com/a/183870/13192320)

### 加等于

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

### f-字符串 (Python 3.6+)

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

查看: [f-字符串](#python-f-字符串-python-36)

Python 数据类型
---------------

### 字符串

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

查看: [字符串](#python-字符串)

### 数值

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

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

### 布尔值

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

bool 是 int 的子类

### 列表

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

查看: [列表](#python-列表)

### 元组

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

类似列表，但自身不可变

### 集合

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

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

### 字典

```python
>>> 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 那样对象

### 类型转换

#### 转换为整数

```python
x = int(1)       # 得到 1
y = int(2.8)     # 得到 2
z = int("3")     # 得到 3
```

#### 转换为浮点数

```python
x = float(1)     # 得到 1.0
y = float(2.8)   # 得到 2.8
z = float("3")   # 得到 3.0
w = float("4.2") # 得到 4.2
```

#### 转换为字符串

```python
x = str("s1")    # 得到 "s1"
y = str(2)       # 得到 "2"
z = str(3.0)     # 得到 "3.0"
```

Python 字符串
------------

### 下标访问

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

### 循环

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

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

### 切割字符串
<!--rehype:wrap-class=row-span-4-->

```java
 ┌───┬───┬───┬───┬───┬───┬───┐
 | m | y | b | a | c | o | n |
 └───┴───┴───┴───┴───┴───┴───┘
 0   1   2   3   4   5   6   7
-7  -6  -5  -4  -3  -2  -1
```

---

```python
>>> s = 'mybacon'
>>> s[2:5]
'bac'
>>> s[0:2]
'my'
```

---

```python
>>> s = 'mybacon'
>>> s[:2]
'my'
>>> s[2:]
'bacon'
>>> s[:2] + s[2:]
'mybacon'
>>> s[:]
'mybacon'
```

---

```python
>>> s = 'mybacon'
>>> s[-5:-1]
'baco'
>>> s[2:6]
'baco'
```

#### 步长

```python
>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'
>>> s[::-5]
'55555'
>>> s[::-1]
'5432154321543215432154321'
```

### 获取长度

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

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

### 重复多次

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

### 存在性判断

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

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

### 字符串拼接

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

### 格式化
<!--rehype:wrap-class=col-span-2-->

```python
name = "John"
print("Hello, %s!" % name)
```

---

```python
name = "John"
age = 23
print("%s is %d years old." % (name, age))
```

#### format() 方法

```python
txt1 = "My name is {fname}, I'm {age}".format(fname="John", age=36)
txt2 = "My name is {0}, I'm {1}".format("John", 36)
txt3 = "My name is {}, I'm {}".format("John", 36)
```

### 转义符号
<!--rehype:wrap-class=row-span-2-->

| 转义符号 | 对应的操作  |
|------|--------|
| `\\` | 输出反斜杠  |
| `\'` | 输出单引号  |
| `\"` | 输出双引号  |
| `\n` | 换行     |
| `\t` | 水平制表符  |
| `\r` | 光标回到首位 |
| `\b` | 退格     |

### 控制台输入

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

从控制台获取输入数据

### 头尾判断
<!--rehype:wrap-class=row-span-2-->

```python
>>> # 是否以 H 开头
>>> "Hello, world!".startswith("H")
True
>>> # 是否以 h 开头
>>> "Hello, world!".startswith("h")
False
>>> # 是否以 ! 结尾
>>> "Hello, world!".endswith("!")
True
```

### 插入分隔符拼接

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

Python f-字符串 (Python 3.6+)
----------------

### f-字符串 用法
<!--rehype:wrap-class=row-span-2-->

```python
>>> website = 'Reference'
>>> f"Hello, {website}"
"Hello, Reference"
>>> num = 10
>>> f'{num} + 10 = {num + 10}'
'10 + 10 = 20'
>>> f"""He said {"I'm John"}"""
"He said I'm John"
>>> f'5 {"{stars}"}'
'5 {stars}'
>>> f'{{5}} {"stars"}'
'{5} stars'
>>> name = 'Eric'
>>> age = 27
>>> f"""Hello!
...     I'm {name}.
...     I'm {age}."""
"Hello!\n    I'm Eric.\n    I'm 27."
```

它从 Python 3.6 开始可用，另见: [格式字符串字面值](https://docs.python.org/zh-cn/3/reference/lexical_analysis.html#f-strings)

### 填充对齐

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

### 按类型输出
<!--rehype:wrap-class=row-span-2-->

```python
>>> f'{10:b}'     # 输出二进制数值
'1010'
>>> f'{10:o}'     # 输出八进制数值
'12'
>>> f'{200:x}'    # 输出十六进制数值
'c8'
>>> f'{200:X}'
'C8'
>>> f'{345600000000:e}' # 科学计数法
'3.456000e+11'
>>> f'{65:c}'       # 将整数转化为一个字符后输出
'A'
>>> f'{10:#b}'      # [类型] 带符号（基础）
'0b1010'
>>> f'{10:#o}'
'0o12'
>>> f'{10:#x}'
'0xa'
```

### 显示正负号

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

### 其它

```python
>>> 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%'
```

Python 列表
------------

### 定义

```python
>>> 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]
```

### 生成
<!--rehype:wrap-class=col-span-2-->

```python
>>> list(filter(lambda x : x % 2 == 1, range(1, 20)))
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> [x ** 2 for x in range (1, 11) if  x % 2 == 1]
[1, 9, 25, 49, 81]
>>> [x for x in [3, 4, 5, 6, 7] if x > 5]
[6, 7]
>>> list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))
[6, 7]
```

### 添加元素

```python
>>> 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]
```

### 切片
<!--rehype:wrap-class=col-span-2 row-span-3-->

列表切片的语法：

```python
a_list[start:end]
a_list[start:end:step]
```

#### 切片

```python
>>> a = ['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[2:5]
['bacon', 'tomato', 'ham']
>>> a[-5:-2]
['egg', 'bacon', 'tomato']
>>> a[1:4]
['egg', 'bacon', 'tomato']
```

#### 省略索引

```python
>>> a[:4]
['spam', 'egg', 'bacon', 'tomato']
>>> a[0:4]
['spam', 'egg', 'bacon', 'tomato']
>>> a[2:]
['bacon', 'tomato', 'ham', 'lobster']
>>> a[2:len(a)]
['bacon', 'tomato', 'ham', 'lobster']
>>> a
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[:]
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
```

#### 间隔索引

```python
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[0:6:2]
['spam', 'bacon', 'ham']
>>> a[1:6:2]
['egg', 'tomato', 'lobster']
>>> a[6:0:-2]
['lobster', 'tomato', 'egg']
>>> a
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[::-1]
['lobster', 'ham', 'tomato', 'bacon', 'egg', 'spam']
```

### 删除

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

### 列表边界

```python
>>> 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
```

### 连接
<!--rehype:wrap-class=row-span-2-->

```python
>>> odd = [1, 3, 5]
>>> odd.extend([9, 11, 13])
>>> odd
[1, 3, 5, 9, 11, 13]
>>> odd = [1, 3, 5]
>>> odd + [9, 11, 13]
[1, 3, 5, 9, 11, 13]
```

### 排序和反转
<!--rehype:wrap-class=row-span-2-->

```python
>>> li = [3, 1, 3, 2, 5]
>>> li.sort()
>>> li
[1, 2, 3, 3, 5]
>>> li.reverse()
>>> li
[5, 3, 3, 2, 1]
```

### 计数

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

### 重复

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

### 搜索
  
```python
>>> 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`。
  
Python 判断
------------

### if-else

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

### if-elif-else

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

### 三目运算

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

注意条件是放在中间的

Python 循环
--------

### 一般形式

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

### 带索引

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

### while 循环

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

### 跳出循环

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

### 跳过一轮循环

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

### 范围循环

```python
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
```

### 使用 zip()

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

### 列表生成式
<!--rehype:wrap-class=col-span-2-->

```python
result = [x**2 for x in range(10) if x % 2 == 0]
 
print(result)
# [0, 4, 16, 36, 64]
```

Python 函数
--------

### 基础

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

### 返回

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

### 位置参数

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

args 的类型是 tuple

### 关键字参数

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

kwargs 的类型是 dict

### 返回多个

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

### 默认值

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

### 匿名函数

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

Python 解包
--------

- 解包是将一个
  [序列](https://docs.python.org/zh-cn/3/library/stdtypes.html#sequence-types-list-tuple-range)
  内的多个元素依次重新分配到有限个容器的过程，这只发生在 **变量赋值**、**参数传递** 和 **生成式生成** 过程中。
- `_` 这个变量是命令行交互中最后一次计算得到的值，在程序设计中一般用来存放解包时不再需要的值。
  但它的含义会因赋值而改变，比如标准库 [gettext](https://docs.python.org/zh-cn/3/library/gettext.html) 中常用作动态获取翻译文本。

### 等量解包

```python
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]
```

### 适量解包

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

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

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

### 过量解包

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

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

这里的 `*` 就是收集[序列](https://docs.python.org/zh-cn/3/library/stdtypes.html#sequence-types-list-tuple-range)在解包过程中多出来的元素，
只能有一个，与向函数传递[位置参数](#位置参数)时的 `*` 别无二致。

### 解包取左边

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

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

### 解包取两边

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

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

### 解包取右边

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

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

### 解包集合

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

[集合](https://docs.python.org/zh-cn/3/library/stdtypes.html#set-types-set-frozenset)
中的元素是无序的，因此解包结果不能轻易确定。

### 解包迭代器

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

支持
[迭代器](https://docs.python.org/zh-cn/3/library/stdtypes.html#iterator-types)
协议的对象也可被解包。

### 解包字典

```python
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]
```

### 生成式中的解包

```python
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}
```

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

### 迭代中解包

```python
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
```

### 函数中的解包

```python
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")
```

Python 模块
--------

### 导入模块

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

### 从一个模块导入

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

### 导入一个模块的全部

```python
from math import *
```

### 给模块起别名

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

### 浏览模块的函数和属性

```python
import math
dir(math)
```

Python 文件处理
----------

### 读取文件

#### 逐行

```python
with open("myfile.txt") as file:
    for line in file:
        print(line)
```

#### 带行号

```python
file = open('myfile.txt', 'r')
for i, line in enumerate(file, start=1):
    print("Number %s: %s" % (i, line))
```

### 字符串

#### 写入一个字符串

```python
contents = {"aa": 12, "bb": 21}
with open("myfile1.txt", "w+") as file:
    file.write(str(contents))
```

#### 读取一个字符串

```python
with open('myfile1.txt', "r+") as file:
    contents = file.read()
print(contents)
```

### 对象

#### 写一个对象

```python
contents = {"aa": 12, "bb": 21}
with open("myfile2.txt", "w+") as file:
    file.write(json.dumps(contents))
```

#### 读取对象

```python
with open('myfile2.txt', "r+") as file:
    contents = json.load(file)
print(contents)
```

### 删除文件

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

### 检查和删除

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

### 删除文件夹

```python
import os
os.rmdir("myfolder")
```

Python 类和继承
--------

### 定义

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

### 构造函数

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

### 方法

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

### 类变量
<!--rehype:wrap-class=row-span-2-->

```python
class MyClass:
    class_variable = "A class variable!"
# => 一个类变量！
print(MyClass.class_variable)
x = MyClass()
 
# => 一个类变量！
print(x.class_variable)
```

### super() 函数
<!--rehype:wrap-class=row-span-2-->

```python
class ParentClass:
    def print_test(self):
        print("Parent Method")
 
class ChildClass(ParentClass):
    def print_test(self):
        print("Child Method")
        # 调用父级的 print_test()
        super().print_test() 
```

---

```python
>>> child_instance = ChildClass()
>>> child_instance.print_test()
Child Method
Parent Method
```

### repr() 方法

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

### 用户定义的异常

```python
class CustomError(Exception):
    pass
```

### 多态性

```python
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
```

### 重写

```python
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
```

### 继承

```python
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!
```

Python 数据模型
--------

更多请移步 <https://docs.python.org/zh-cn/3/reference/datamodel.html>

### 自定义类创建

参见 [自定义类创建](https://docs.python.org/zh-cn/3/reference/datamodel.html#customizing-class-creation) 。

```python
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()
```

### 上下文管理器
<!--rehype:wrap-class=col-span-2-->
参见 [上下文管理器](https://docs.python.org/zh-cn/3/reference/datamodel.html#with-statement-context-managers) 。

```python
from typing import Any

class Object:
    def __enter__(self) -> Optional[Any]:
        # with 语句会将返回值绑定到 as 子句中的变量，如果有的话。
        return

    def __exit__(self, exc_type, exc_value, traceback):
        # 若 with 内没有发生异常，则三个参数都是 None 。
        # 不应该重新引发传入的异常，这是调用者的责任。
        pass

with Object() as alias:
    # 进入 with 之前调用 obj.__enter__() 并得到 alias（如果有返回的话）
    pass
# 离开 with 后调用 obj.__exit__() ，不管是正常结束还是因异常抛出而离开。

# 当需要获取 Object 的对象时可以这样写
obj = Object()
with obj as alias:
    pass
```

### 特殊方法
<!--rehype:wrap-class=col-span-3-->
下表使用 `-> *` 代表返回值类型是任意的，或者需要视情况而定，实际上并不存在这种写法。  
诸如 `-> str` 仅表示绝大多数情况下应当返回 `str` 类型，或者推荐返回 `str` 类型。  
没有 `->` 的方法一般没有返回值。  
参见 <https://docs.python.org/zh-cn/3/reference/datamodel.html>

| 语句                  | 特殊方法                               | 备注                                                                                                                                                                                                                                                 |     |
|---------------------|------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----|
| `repr(obj)`         | `__repr__(self) -> str`            | 详见 [`repr()`](https://docs.python.org/zh-cn/3/library/functions.html#repr) 。                                                                                                                                                                       |     |
| `str(obj)`          | `__str__(self) -> str`             | 详见 [`str` 类型](https://docs.python.org/zh-cn/3/library/stdtypes.html#str) 。                                                                                                                                                                         |     |
| `bytes(obj)`        | `__bytes__(self) -> bytes`         | 详见 [`bytes()`](https://docs.python.org/zh-cn/3/library/functions.html#func-bytes) 。                                                                                                                                                                |     |
| `format(obj, spec)` | `__format__(self, spec) -> str`    | 详见 [`format()`](https://docs.python.org/zh-cn/3/library/functions.html#format)、[格式化字符串字面值](https://docs.python.org/zh-cn/3/reference/lexical_analysis.html#f-strings)、[格式规格迷你语言](https://docs.python.org/zh-cn/3/library/string.html#formatspec) 。 |     |
| `hash(obj)`         | `__hash__(self) -> int`            | 详见 [`hash()`](https://docs.python.org/zh-cn/3/library/functions.html#hash) 。                                                                                                                                                                       |     |
| `bool(obj)`         | `__bool__(self) -> bool`           | 未定义时调用 `obj.__len__() != 0` ，若 `__len__()` 也未定义，则所有对象都被视为 `True` 。另见 [`bool()`](https://docs.python.org/zh-cn/3/library/functions.html#bool) 。                                                                                                     |     |
| `dir(obj)`          | `__dir__(self) -> list`            | 返回值必须是一个序列，[`dir()`](https://docs.python.org/zh-cn/3/library/functions.html#dir) 会把返回的序列转换为列表并对其排序。                                                                                                                                                |     |
| `Object[key]`       | `__class_getitem__(cls, key) -> *` | 不建议用于除了 [模拟泛型类型](https://docs.python.org/zh-cn/3/reference/datamodel.html#emulating-generic-types) 以外的用途，避免 IDE 误判。                                                                                                                                |     |

- 自定义实例及子类检查，参见 <https://docs.python.org/zh-cn/3/reference/datamodel.html#customizing-instance-and-subclass-checks>

| 语句                            | 特殊方法                                              | 备注                                        |     |
|-------------------------------|---------------------------------------------------|:------------------------------------------|-----|
| `isinstance(instance, class)` | `class.__instancecheck__(self, instance) -> bool` | 如果 instance 应被视为 class 的一个（直接或间接）实例则返回真值。 |     |
| `issubclass(subclass, class)` | `class.__subclasscheck__(self, subclass) -> bool` | 如果 subclass 应被视为 class 的一个（直接或间接）子类则返回真值。 |     |

- “富比较”方法，参见 <https://docs.python.org/zh-cn/3/reference/datamodel.html#object.__lt__>

| 语句              | 特殊方法                           | 备注                                                                                                                                                  |     |
|-----------------|--------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------|-----|
| `obj < other`   | `__lt__(self, other) -> bool`  |                                                                                                                                                     |     |
| `obj <= other`  | `__le__(self, other) -> bool`  |                                                                                                                                                     |     |
| `obj == other`  | `__eq__(self, other) -> bool`  | 默认返回 `obj is other` ，如果结果为 `False` ，则会返回 [`NotImplemented`](https://docs.python.org/zh-cn/3/reference/datamodel.html#the-standard-type-hierarchy) 。 |     |
| `obj != other`  | `__ne__(self, other) -> bool`  | 默认返回 `not obj.__eq__(other)` 。                                                                                                                      |     |
| `obj > other`   | `__gt__(self, other) -> bool`  |                                                                                                                                                     |     |
| `obj >= other`  | `__ge__(self, other) -> bool`  |                                                                                                                                                     |     |

- 自定义属性访问，参见 <https://docs.python.org/zh-cn/3/reference/datamodel.html#customizing-attribute-access>

| 语句                  | 特殊方法                                | 备注                                                                                                                               |     |
|---------------------|-------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------|-----|
| `obj.name`          | `__getattr__(self, name) -> *`      | 优先调用。当抛出 [`AttributeError`](https://docs.python.org/zh-cn/3/library/exceptions.html#AttributeError) 时转向调用 `__getattribute__()` 。 |     |
| `obj.name`          | `__getattribute__(self, name) -> *` | 参见 [自定义属性访问](https://docs.python.org/zh-cn/3/reference/datamodel.html#customizing-attribute-access) 避免无限递归。                      |     |
| `obj.name = value`  | `__setattr__(self, name, value)`    |                                                                                                                                  |     |
| `del obj.name`      | `__delattr__(self, name)`           | 仅在 `del obj.name` 对于该对象有意义时才应该被实现。                                                                                               |     |

- 模拟容器类型，参见 <https://docs.python.org/zh-cn/3/reference/datamodel.html#emulating-container-types>

| 语句                    | 特殊方法                               | 备注                                                                                                                                                                                                                                                                                                            |     |
|-----------------------|------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----|
| `len(obj)`            | `__len__(self) -> int`             |                                                                                                                                                                                                                                                                                                               |     |
| `op.length_hint(obj)` | `__length_hint__(self) -> int`     | 在使用标准库 [operator](https://docs.python.org/zh-cn/3/library/operator.html) 的 [`length_hint()`](https://docs.python.org/zh-cn/3/library/operator.html#operator.length_hint) 时会被调用（Python 3.4+）。                                                                                                                  |     |
| `obj[key]`            | `__getitem__(self, key) -> *`      | 需要抛出 [IndexError](https://docs.python.org/zh-cn/3/library/exceptions.html#IndexError) 以便正确地结束 [for](https://docs.python.org/zh-cn/3/reference/compound_stmts.html#for) 循环。                                                                                                                                    |     |
| `obj[key]`            | `__missing__(self, key) -> *`      | 仅在 dict 的子类找不到键时被调用（不能重写 `__getitem__` 方法）。                                                                                                                                                                                                                                                                   |     |
| `obj[key] = value`    | `__setitem__(self, key, value)`    | `a[1:2] = b` 实际上是 `a[slice(1, 2, None)] = b` ，其它情形及在其余方法中同理。详见 [`slice()`](https://docs.python.org/zh-cn/3/library/functions.html#slice) 。                                                                                                                                                                    |     |
| `del obj[key]`        | `__delitem__(self, key)`           |                                                                                                                                                                                                                                                                                                               |     |
| _调用途径有很多_             | `__iter__(self) -> Iterator`       | 在需要创建一个 [迭代器](https://docs.python.org/zh-cn/3/glossary.html#term-iterator) 时被调用，例如使用 [`iter()`](https://docs.python.org/zh-cn/3/library/functions.html#iter) 、 [`for` 循环](https://docs.python.org/zh-cn/3/reference/compound_stmts.html#for) 。<br>最好返回一个新对象，因为迭代器在语义上是一次性的。若返回 `self` ，则必须实现 `__next__()` 方法。 |     |
| `reversed(obj)`       | `__reversed__(self) -> *`          | 详见 [`reversed()`](https://docs.python.org/zh-cn/3/library/functions.html#reversed) 。                                                                                                                                                                                                                          |     |
| `item in obj`         | `__contains__(self, item) -> bool` | 对于未定义该方法的对象在 `in` 和 `not in` 时，参考 [成员检测运算](https://docs.python.org/zh-cn/3/reference/expressions.html#membership-test-details) 。                                                                                                                                                                              |     |

- 模拟数字类型，参见 <https://docs.python.org/zh-cn/3/reference/datamodel.html#emulating-numeric-types>

| 语句                   | 特殊方法                               | 备注                                                                                                                                                                                 |     |
|----------------------|------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----|
| `+obj`               | `__neg__(self) -> *`               |                                                                                                                                                                                    |     |
| `-obj`               | `__pos__(self) -> *`               |                                                                                                                                                                                    |     |
| `~obj`               | `__invert__(self) -> *`            |                                                                                                                                                                                    |     |
| `abs(obj)`           | `__abs__(self) -> *`               |                                                                                                                                                                                    |     |
| `int(obj)`           | `__int__(self) -> *`               |                                                                                                                                                                                    |     |
| `float(obj)`         | `__float__(self) -> *`             |                                                                                                                                                                                    |     |
| `complex(obj)`       | `__complex__(self) -> *`           |                                                                                                                                                                                    |     |
| `round(obj)`         | `__round__(self) -> int`           | 详见 [`round()`](https://docs.python.org/zh-cn/3/library/functions.html#round) 。                                                                                                     |     |
| `round(obj)`         | `__round__(self, ndigits) -> *`    | 详见 [`round()`](https://docs.python.org/zh-cn/3/library/functions.html#round) 。                                                                                                     |     |
| `math.ceil(obj)`     | `__ceil__(self) -> int`            | 详见标准库 [math](https://docs.python.org/zh-cn/3/library/math.html#module-math) 的 [`ceil()`](https://docs.python.org/zh-cn/3/library/math.html#math.ceil) 。                            |     |
| `math.floor(obj)`    | `__floor__(self) -> int`           | 详见标准库 [math](https://docs.python.org/zh-cn/3/library/math.html#module-math) 的 [`floor()`](https://docs.python.org/zh-cn/3/library/math.html#math.floor) 。                          |     |
| `math.trunc(obj)`    | `__trunc__(self) -> int`           | 详见标准库 [math](https://docs.python.org/zh-cn/3/library/math.html#module-math) 的 [`trunc()`](https://docs.python.org/zh-cn/3/library/math.html#math.trunc) 。                          |     |
|                      | `__index__(self) -> int`           | 需要无损地将数值转换为整数的时候会被调用。详见 [这里](https://docs.python.org/zh-cn/3/reference/datamodel.html#object.__index__) 。                                                                          |     |
| `obj + other`        | `__add__(self, other) -> *`        |                                                                                                                                                                                    |     |
| `obj - other`        | `__sub__(self, other) -> *`        |                                                                                                                                                                                    |     |
| `obj * other`        | `__mul__(self, other) -> *`        |                                                                                                                                                                                    |     |
| `obj @ other`        | `__matmul__(self, other) -> *`     | 为第三方库而生的矩阵乘法运算符，[这里](https://docs.python.org/zh-cn/3/reference/expressions.html#binary-arithmetic-operations)提了一嘴。（Python 3.5+）                                                    |     |
| `obj / other`        | `__truediv__(self, other) -> *`    |                                                                                                                                                                                    |     |
| `obj // other`       | `__floordiv__(self, other) -> *`   |                                                                                                                                                                                    |     |
| `obj % other`        | `__mod__(self, other) -> *`        |                                                                                                                                                                                    |     |
| `divmod(obj, other)` | `__divmod__(self, other) -> tuple` | `divmod(a, b)` 返回一个元组 `(a // b, a % b)` ，详见 [`divmod()`](https://docs.python.org/zh-cn/3/library/functions.html#divmod) 。                                                          |     |
| `obj ** exp`         | `__pow__(self, exp) -> *`          |                                                                                                                                                                                    |     |
| `pow(obj, exp, mod)` | `__pow__(self, exp, mod) -> *`     | `pow(base, exp, mod)` 比 `pow(base, exp) % mod` 更高效。                                                                                                                                |     |
| `obj << other`       | `__lshift__(self, other) -> *`     |                                                                                                                                                                                    |     |
| `obj >> other`       | `__rshift__(self, other) -> *`     |                                                                                                                                                                                    |     |
| `obj & other`        | `__and__(self, other) -> *`        |                                                                                                                                                                                    |     |
| `obj ^ other`        | `__xor__(self, other) -> *`        |                                                                                                                                                                                    |     |
| `obj \| other`       | `__or__(self, other) -> *`         |                                                                                                                                                                                    |     |
| `other + obj`        | `__radd__(self, obj) -> *`         | 仅当 obj 未定义 `__add__()` 或其返回 `NotImplemented` ，<br>且与 other 互相都没有继承关系时，调用 other 的 `__radd__()` 。详见 [这里](https://docs.python.org/zh-cn/3/reference/datamodel.html#object.__radd__) 。 |     |
| `other - obj`        | `__rsub__(self, obj) -> *`         | 以下，如此类推。                                                                                                                                                                           |     |
| `other * obj`        | `__rmul__(self, obj) -> *`         |                                                                                                                                                                                    |     |
| `other @ obj`        | `__rmatmul__(self, obj) -> *`      |                                                                                                                                                                                    |     |
| `other / obj`        | `__rtruediv__(self, obj) -> *`     |                                                                                                                                                                                    |     |
| `other // obj`       | `__rfloordiv__(self, obj) -> *`    |                                                                                                                                                                                    |     |
| `other % obj`        | `__rmod__(self, obj) -> *`         |                                                                                                                                                                                    |     |
| `divmod(other, obj)` | `__rdivmod__(self, obj) -> tuple`  |                                                                                                                                                                                    |     |
| `other ** obj`       | `__rpow__(self, obj) -> *`         |                                                                                                                                                                                    |     |
|                      | `__rpow__(self, obj, mod) -> *`    | `pow(obj, other, mod)` 不会尝试调用 `other.__rpow__(obj, mod)` ，因为强制转换规则会太过复杂。                                                                                                           |     |
| `other << obj`       | `__rlshift__(self, obj) -> *`      |                                                                                                                                                                                    |     |
| `other >> obj`       | `__rrshift__(self, obj) -> *`      |                                                                                                                                                                                    |     |
| `other & obj`        | `__rand__(self, obj) -> *`         |                                                                                                                                                                                    |     |
| `other ^ obj`        | `__rxor__(self, obj) -> *`         |                                                                                                                                                                                    |     |
| `other \| obj`       | `__ror__(self, obj) -> *`          |                                                                                                                                                                                    |     |
| `obj += other`       | `__iadd__(self, other) -> *`       | 若方法已定义，则 `a += b` 等价于 `a.__iadd(b)` ；<br>若未定义，则回退到 `a + b` 选择 `x.__add__(y)` 和 `y.__radd__(x)` 。                                                                                   |     |
| `obj -= other`       | `__isub__(self, other) -> *`       | 以下，如此类推。                                                                                                                                                                           |     |
| `obj *= other`       | `__imul__(self, other) -> *`       |                                                                                                                                                                                    |     |
| `obj @= other`       | `__imatmul__(self, other) -> *`    |                                                                                                                                                                                    |     |
| `obj /= other`       | `__itruediv__(self, other) -> *`   |                                                                                                                                                                                    |     |
| `obj //= other`      | `__ifloordiv__(self, other) -> *`  |                                                                                                                                                                                    |     |
| `obj %= other`       | `__imod__(self, other) -> *`       |                                                                                                                                                                                    |     |
| `obj **= exp`        | `__ipow__(self, other) -> *`       |                                                                                                                                                                                    |     |
| `obj <<= other`      | `__ilshift__(self, other) -> *`    |                                                                                                                                                                                    |     |
| `obj >>= other`      | `__irshift__(self, other) -> *`    |                                                                                                                                                                                    |     |
| `obj &= other`       | `__iand__(self, other) -> *`       |                                                                                                                                                                                    |     |
| `obj ^= other`       | `__ixor__(self, other) -> *`       |                                                                                                                                                                                    |     |
| `obj \|= other`      | `__ior__(self, other) -> *`        |                                                                                                                                                                                    |     |

Python 类型标注 (Python 3.5+)
--------

### 变量

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

print(string * times)  # => hahaha
```

### 变量

```python
result: str = 1 + 2

print(result)  # => 3
```

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

### 参数

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

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

### 位置参数

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

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

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

### 返回值

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

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

### 多种可能的返回值

```python
from typing import Union

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

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

### 关键字参数

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

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

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

### 多个返回值

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

### 多种可能的返回值 (3.10+)

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

自 Python 3.10 起可用。

### 属性

```python
class Employee:
    name: str
    age: int

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

### 标注自己

```python
class Employee:
    name: str
    age: int

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

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

### 标注自己 (3.11+)

```python
from typing import Self

class Employee:
    name: str
    age: int

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

### 标注一个值为类型的参数
<!--rehype:wrap-class=col-span-2-->
```python
from typing import TypeVar, Type

T = TypeVar("T")

# "mapper" 的值是一个像 int、str、MyClass 这样的类型
# "default" 是一个 T 类型的值，比如 314、"string"、MyClass()
# 函数的返回值也是一个 T 类型的值
def converter(raw, mapper: Type[T], default: T) -> T:
    try:
        return mapper(raw)
    except:
        return default

raw: str = input("请输入一个整数：")
result: int = converter(raw, mapper=int, default=0)
```

### 标注一个值为函数的参数
<!--rehype:wrap-class=col-span-2-->

```python
from typing import TypeVar, Callable, Any

T = TypeVar("T")

def converter(raw, mapper: Callable[[Any], T], default: T) -> T:
    try:
        return mapper(raw)
    except:
        return default

# Callable[[Any], T] 表示值是一个像这样声明的函数:
# def anynomous(arg: Any) -> T:
#     pass

def is_success(value) -> bool:
    return value in (0, "OK", True, "success")

resp = dict(code=0, message="OK", data=[])
successed: bool = converter(resp.message, mapper=is_success, default=False)
```

各种各样的
----------

### 注释

```python
# 这是单行注释
```

---

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

---

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

### 生成器

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

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

### 要列出的生成器

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

### 处理异常
<!--rehype:wrap-class=col-span-3-->

```python
try:
    # 使用“raise”来引发错误
    raise IndexError("这是一个索引错误")
except IndexError as e:
    pass                 # pass只是一个空操作。 通常你会在这里做恢复。
except (TypeError, NameError):
    pass                 # 如果需要，可以一起处理多个异常。
else:                    # try/except 块的可选子句。 必须遵循除块之外的所有内容
    print("All good!")   # 仅当 try 中的代码未引发异常时运行
finally:                 # 在所有情况下执行
    print("我们可以在这里清理资源")
```

### pyenv & pipenv
<!--rehype:wrap-class=col-span-3-->

pvenv 用于管理python版本，pipenv 用于管理项目包版本

#### pyenv

```shell
# 安装 pyenv
curl https://pyenv.run | bash
```

[更多安装方式](https://github.com/pyenv/pyenv#installation)

```shell
# 安装 python 版本
pyenv install 3.10.12

# 设置 python 版本
pyenv global 3.10.12 # 全局设置
pyenv shell  3.10.12 # 针对当前 shell session
pyenv local  3.10.12 # 针对当前目录 
```

#### pipenv

```shell
# 安装 pipenv
pip install pipenv --user  # pip
brew install pipenv        # homebrew

# 更新 pipenv
pip install --user --upgrade pipenv # pip
brew upgrade pipenv                 # homebrew
```

```shell
# 将 pipenv 命令加入到系统环境变量 $PATH 中 (Unix and MacOS)
dir=$(python -c 'import site; print(site.USER_BASE + "/bin")') # 打印 python site-packages bin 路径
echo 'export PATH="'$dir':$PATH"' >> ~/.zshrc # 将 dir 路径加入到 PATH 中
source ~/.zshrc


# 安装 package
pipenv install <package name> # 不指定版本
pipenv install <package name>==<version>    # 精确指定版本
pipenv install <package name>~=<version>    # 指定版本范围，例如 1.1则表示安装1.x的最新版本，1.0.1则表示安装1.0.x的最新版本
pipenv install "<package name>=<version>"   # 大于等于指定版本
pipenv install "<package name>=<version>"   # 小于等于指定版本
```

```shell
# 指定 python 版本
pipenv --python 3.10.12

# 激活当前目录虚拟环境
pipenv shell
```

另见
----

- [Python 官方网站](https://www.python.org/)  _(python.org)_
- [Python 文档](https://docs.python.org/zh-cn/3/index.html)  _(docs.python.org)_
- [Y 分钟学会 Python](https://learnxinyminutes.com/docs/zh-cn/python-cn/) _(learnxinyminutes.com)_
- [Python 中的正则表达式](./regex.md#python-中的正则表达式) _(jaywcjlove.github.io)_