Python快速参考手册

一.Python常用参考表
-1.Python的35个关键字
-2.Python中变量的命名规则
-3.Python中的转义字符
-4.Python中的运算符
-5.Python的运算符优先级
二.Python控制流
-1.for循环
-2.while循环
-3.跳出循环
-4.if语句
-5.match-case语句
三.Python的复合数据类型
-1.字符串
-2.bytes字节数组
-3.列表
-4.元组
-5.集合
-6.字典
四.Python函数
-1.定义函数
-2.调用函数
-3.函数参数
-4.不定长参数
-5.匿名函数
-6.main函数
-7.内置函数
回到顶部

# Python快速参考手册

## 一.Python常用参考表<a name="Python常用参考表"></a>

### 1.Python的35个关键字<a name="Python的35个关键字"></a>

Python3的关键字分为八个大类，一共35个关键字。

第一类：控制流关键字（7个）

| 编号  | 关键字      | 功能说明                                          |
|:---:| -------- | --------------------------------------------- |
| 1   | if       | 用于创建条件语句（if语句），并且仅当条件为True时，才允许执行if代码块。       |
| 2   | elif     | 在条件语句（if语句）中使用，是else if的缩写。                   |
| 3   | else     | 在条件语句（if语句）中使用，并确定在if条件与elif条件全为False时该执行的代码。 |
| 4   | for      | 用于创建一个for循环，它可以用来遍历序列，例如列表、元组等。               |
| 5   | while    | 用于定义一个while循环，while循环将继续，直到while的条件为False。    |
| 6   | continue | 用于在for循环（或while循环）中结束当前一次迭代，并继续进行下一次迭代。       |
| 7   | break    | 用于跳出for循环（或while循环）。                          |

第二类：值关键字（3个）

| 编号  | 关键字   | 功能说明                                                  |
|:---:| ----- | ----------------------------------------------------- |
| 1   | True  | 布尔真值                                                  |
| 2   | False | 布尔假值                                                  |
| 3   | None  | 表示空值或无值，None与0、False或空字符串不同。 None是其自身的数据类型（NoneType）。 |

第三类：运算符关键字（5个）

| 编号  | 关键字 | 功能说明                                                              |
|:---:| --- | ----------------------------------------------------------------- |
| 1   | and | 逻辑与，如果左右语句都为True，则返回True，否则返回False。                               |
| 2   | or  | 逻辑或，如果左右语句其中一条语句为True，则返回True，则返回True，否则返回False。                  |
| 3   | not | 逻辑非，如果右边语句为False，则返回True，否则返回False。                               |
| 4   | is  | 身份运算符，用于对象标识比较，返回True或者False。如果两个标识符引用的是同一个对象则返回 True，否则返回 False。 |
| 5   | in  | 成员运算符，用于判断是否为成员，返回True或者False。                                    |

第四类：函数与类相关关键字（5个）

| 编号  | 关键字    | 功能说明                                    |
|:---:| ------ | --------------------------------------- |
| 1   | def    | 用于创建（或定义）一个函数。                          |
| 2   | return | 函数返回值。                                  |
| 3   | lambda | 用于创建匿名函数。                               |
| 4   | class  | 用于创建（或定义）一个类。                           |
| 5   | pass   | 空语句占位符，当执行pass语句时，不会有任何影响，只是占位作用代表空白代码。 |

第五类：模块导入关键字（3个）

| 编号  | 关键字    | 功能说明                                   |
|:---:| ------ | -------------------------------------- |
| 1   | import | 用于导入模块。                                |
| 2   | from   | 用于从模块中导入指定的部分，按需要导入指定子类或函数，减少不必要的资源浪费。 |
| 3   | as     | 用于创建别名。                                |

第六类：变量作用域关键字（2个）

| 编号  | 关键字      | 功能说明     |
|:---:| -------- | -------- |
| 1   | global   | 声明全局变量。  |
| 2   | nonlocal | 声明非局部变量。 |

第七类：异常处理关键字（4个）

| 编号  | 关键字     | 功能说明                                                         |
|:---:| ------- | ------------------------------------------------------------ |
| 1   | try     | 尝试执行代码块，try定义了一个代码块，并在没有问题的情况下执行块。如果包含任何异常，可以为不同的异常类型定义不同的块。 |
| 2   | except  | 捕获异常，如果try块引发异常，并在有异常的情况下执行对应的代码块。                           |
| 3   | finally | 无论是否异常都执行，无论try块是否引发异常，都将执行finally代码块。                       |
| 4   | raise   | 抛出异常，可以定义引发哪种错误，以及向用户显示错误信息。                                 |

第八类：异步编程关键字（2个）

| 编号  | 关键字   | 功能说明                                                                                                   |
|:---:| ----- | ------------------------------------------------------------------------------------------------------ |
| 1   | async | 定义异步函数，声明一个函数为异步函数，异步函数的特点是能在函数执行过程中挂起，去执行其他异步函数，等到挂起条件（假设挂起条件是sleep(5)）消失后，也就是5秒到了再回来执行               |
| 2   | await | 等待异步操作完成，声明程序挂起，比如异步程序执行到某一步时需要等待的时间很长，就将此挂起，去执行其他的异步程序。await 后面只能跟异步程序或有__await__属性的对象，因为异步程序与一般程序不同。 |

其它关键字（4个）

| 编号  | 关键字    | 功能说明                                                   |
|:---:| ------ | ------------------------------------------------------ |
| 1   | del    | 删除对象                                                   |
| 2   | with   | 上下文管理，比如with常和open一起使用，用于读取或写入文件。                      |
| 3   | yield  | 生成器返回值，用于结束一个函数，并返回一个生成器。                              |
| 4   | assert | 断言条件为真，用于测试代码中的条件是否为True，如果为False，将引发AssertionError异常。 |

### 2.Python中变量的命名规则<a name="Python中变量的命名规则"></a>

1. 变量名必须是单个词；

2. 变量名区分大小写；

3. 变量名必须以字母或者下划线打头，之后可以是任意字母、数字或下划线；

4. 变量名中不允许使用下划线以外的标点符号；

5. 变量名不能使用Python的关键字。

### 3.Python中的转义字符<a name="Python中的转义字符"></a>

| 转义字符 | 意义               |
| ---- | ---------------- |
| \\'   | 单引号              |
| \\''  | 双引号              |
| \\\  | 反斜杠              |
| \n   | 换行符，将当前位置移到下一行开头 |
| \r   | 回车，将当前位置移到本行开头   |
| \t   | 横向制表符，跳到下一个TAB位置 |
| \v   | 垂直制表符            |
| \b   | 退格符，将当前位置移到前一列   |
| \f   | 换页符，将当前位置移到下页开头  |
| \oyy | 两位八进制数 yy 代表的字符  |
| \xyy | 两位十六进制数 yy 代表的字符 |
| \0   | 空字符              |

### 4.Python中的运算符<a name="Python中的运算符"></a>

1. **算术运算符**

| 编号  | 运算符 | 含义  | 运算示例    | 运算结果     |
|:---:|:---:| --- | ------- | -------- |
| 1   | +   | 加法  | 1+2     | 3        |
| 2   | -   | 减法  | 2-1     | 1        |
| 3   | *   | 乘法  | 5*3     | 15       |
| 4   | /   | 除法  | 5.0/3.0 | 1.666667 |
| 5   | %   | 取模  | 5%3     | 2        |
| 6   | **  | 幂   | 5**2    | 25       |
| 7   | //  | 取整  | 5//3    | 1        |

2. **关系和比较运算符**

| 编号 | 运算符 | 含义 | 运算示例 | 运算结果 |
|:---:|:---:| ---- | ------------ | ------------- |
| 1 | > | 大于 | 2>1 2>9 | True False |
| 2 | >= | 大于等于 | 2>=1 2>=9 | True False |
| 3 | < | 小于 | 2<1 2<9 | False True |
| 4 | <= | 小于等于 | 2<=1 2<=9 | False True |
| 5 | == | 等于 | 2==1 2==2 | False True |
| 6 | != | 不等于 | 2!=1 2!=2 | 1 0 |

3. **赋值运算符**

| 编号  | 运算符 | 运算示例         | 等效运算               |
|:---:| --- | ------------ | ------------------ |
| 1   | =   | var = expr   | 无                  |
| 2   | +=  | var += expr  | var = var + expr   |
| 3   | -=  | var -= expr  | var = var - expr   |
| 4   | *=  | var *= expr  | var = var * expr   |
| 5   | /=  | var /= expr  | var = var / expr   |
| 6   | %=  | var %= expr  | var = var % expr   |
| 7   | **= | var **= expr | var = var ** expr  |
| 8   | //= | var /= expr  | var = var //= expr |

4. **位运算符**

| 编号 | 位运算符 | 说明 | 示例 | 示例运算结果 |
|:---:|:----:| ---- | -------------------- | ----------- |
| 1 | & | 按位与 | 1&1 1&0 0&0 | 1 0 0 |
| 2 | '\|' | 按位或 | 1\|1 1\|0 0\|0 | 1 1 0 |
| 3 | ~ | 按位取反 | ~1   ~0 | -2 -1 |
| 4 | ^ | 按位异或 | 1^0 1^1 0^0 | 1 0 0 |
| 5 | << | 按位左移 | 0001<<2 | 0100（二进制） |
| 6 | >> | 按位右移 | 0100>>2 | 0001（二进制） |

Python中的逻辑运算符（逻辑与and、逻辑或or、逻辑非not），身份运算符（is、is not），成员运算符（in、not in）使用关键字来实现，因此没有特殊的符号类运算符。

### 5.Python的运算符优先级<a name="Python的运算符优先级"></a>

下表列出了从最高到最低优先级的所有运算符：

| 运算符 | 描述 |
| ------------------------ | ------------ |
| ** | 幂运算符（最高优先级） |
| ~ + - | 按位取反、正号、负号 |
| * / % // | 乘法、除法、取模、取整 |
| + - | 加法、减法 |
| >> << | 按位右移、按位左移 |
| & | 按位与 |
| ^ \| | 按位异或、按位异或 |
| > >= <= < | 比较运算符 |
| == != | 等于、不等于 |
| = += -= *= /= %= //= **= | 赋值运算符 |
| is | 身份运算符 |
| in | 成员运算符 |
| and or not | 逻辑运算符（最低优先级） |

## 二.Python控制流<a name="Python控制流"></a>

### 1.for循环<a name="for循环"></a>

Python for循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

for循环的简单示例：

```python
sum = 0
for x in range(101):
  sum = sum + x
print("1到100之和为: " , sum)
```

for循环后的else语句容易让代码产生歧义，因此需要避免在for循环后写else语句。

### 2.while循环<a name="while循环"></a>

while循环是Python中最常用的循环语句，在Python中没有 do..while 循环。

while循环的简单示例：

```py
n = int(input("请输入整数: "))
sum = 0
counter = 1
while counter <= n:
 sum = sum + counter
 counter += 1
print(f'1 到 {n} 之和为：{sum}')
```

while循环后的else语句容易让代码产生歧义，因此需要避免在while循环后写else语句。

### 3.跳出循环<a name="跳出循环"></a>

break语句可以跳出for和while的循环体。如果从for或while循环中终止，任何对应的循环else块将不执行。

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

continue语句示例：

```py
sum = 0
for x in range(101):
  if x%10 == 0:
    continue
  sum = sum + x
print("1到100（去掉10的整数倍）之和为: " , sum)
```

break语句示例：

```py
n = int(input("请再次输入整数: "))
sum = 0
counter = 1
while counter <= n:
 if counter > 1000:
 break
 sum = sum + counter
 counter += 1
print(f'1 到 {n}（最大1000）之和为：{sum}')
```

break与continue的对比：break用来结束所有循环，循环语句不再有执行的机会；

continue用来结束本次循环，直接跳到下一次循环，如果循环条件成立，还会继续循环。

### 4.if语句<a name="if语句"></a>

Python中if语句的一般形式如下所示（elif与else均可以省略）：

```py
if condition_1:
  statement_block_1
elif condition_2:
  statement_block_2
else:
  statement_block_3
```

Python用elif代替了else if，所以if语句的关键字为：if – elif – else，其中elif可以有0个1个或者多个。

```py
age = int(input("请输入你的年龄: "))
if age <= 0:
 print("你是在逗我吧!")
elif age <= 18:
 print("你还未成年。")
elif age <= 200:
 print("你是成年人。")
else:
 print("你输入得不对！")
```

if语句允许嵌套，在嵌套if语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

### 5.match-case语句<a name="match-case语句"></a>

match-case语句是Python3.10新增的语句，使用方法类似C语言的switch-case语句。

```py
day = int(input("请输入整数(1~7): "))
match day:
  case 1:
    print('Monday')
  case 2:
    print('Tuesday')
  case 3:
    print('Wednesday')
  case 4:
    print('Thursday')
  case 5:
    print('Friday')
  case 6:
    print('Saturday')
  case 7:
    print('Sunday')
  case _:
    print('输入错误！')
```

case后跟一个模式，可以是具体值、变量、通配符等。

## 三.Python的复合数据类型<a name="Python的复合数据类型"></a>

### 1.字符串<a name="字符串"></a>

字符串是Python中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。通过索引[]获取字符串中字符。

```python
var1 = 'Hello World!'
print(var1[0])
print(var1[0:2])
print(var1[-1])
print(var1[::-1]) # 反转字符串
```

与数字类似，字符串同样也是不可变数据类型。

Python字符串常用的运算符（a 为 "Hello"，b 为 "Python"）：

| 运算符    | 描述                                                                                                     | 示例                           |
| ------ | ------------------------------------------------------------------------------------------------------ | ---------------------------- |
| +      | 连接字符串                                                                                                  | a + b 输出： HelloPython        |
| *      | 重复输出字符串                                                                                                | a*2 输出：HelloHello            |
| []     | 索引或者切片                                                                                                 | a[1] 输出结果 e a[1:4] 输出结果 ell  |
| in     | 成员运算符：如果字符串中包含给定的字符返回 True                                                                             | 'H' in a 输出： True            |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True                                                                          | 'M' not in a 输出： True        |
| r或者R   | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | print( r'\n' )或者print(R'\n') |

当需要在字符中使用特殊字符（比如单引号）时，python 用反斜杠 \ 转义字符。具体的转移字符列表可参考本手册章节一中的 《Python的转义字符》。

Python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。示例如下：

```python
para_str = """这是一个多行字符串的实例
多行字符串可以使用特殊字符比如换行符[\n]。
"""
print (para_str)
```

Python提供了很多操作字符串的内建函数：

| 序号  | 方法                                  | 方法说明                                                                                                 |
| --- | ----------------------------------- | ---------------------------------------------------------------------------------------------------- |
| 1   | s1.capitalize()                     | 将字符串的第一个字符转换为大写                                                                                      |
| 2   | s1.count(sub, start= 0,end=len(s1)) | 返回sub在s1里面出现的次数，如果 start 或者 end 指定则返回指定范围内sub出现的次数                                                   |
| 3   | s1.encode("UTF8")                   | 以指定的编码格式编码字符串，编码后的数据类型为bytes，常与bytes.decode()配对使用                                                    |
| 4   | bytes.decode("UTF8")                | 将bytes数据类型解码为字符串，常与s1.encode()配对使用                                                                   |
| 5   | s1.find(sub, beg=0, end=len(s1))    | 检测字符串中是否包含子字符串 sub，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内包含，返回的是sub在字符串中的起始位置。如果不包含索引值，返回-1 |
| 6   | s1.isalpha()                        | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False                                                       |
| 7   | s1.isdigit()                        | 如果字符串只包含数字则返回 True 否则返回 False，方法只对正整数有效，负数及小数均返回False                                                |
| 8   | s1.isalnum()                        | 检查字符串是否由字母和数字组成，即字符串中的所有字符都是字母或数字。如果字符串至少有一个字符，并且所有字符都是字母或数字，则返回 True；否则返回 False                     |
| 9   | s1.isupper()                        | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False                                        |
| 10  | s1.islower()                        | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False                                        |
| 11  | s1.lower()                          | 转换字符串中所有大写字符为小写.                                                                                     |
| 12  | s1.upper()                          | 转换字符串中的小写字母为大写                                                                                       |
| 13  | s1.lstrip([chars])                  | 截掉字符串左边的空格或指定字符                                                                                      |
| 14  | s1.rstrip([chars])                  | 删除字符串末尾的空格或指定字符                                                                                      |
| 15  | s1.strip([chars])                   | 在字符串上执行lstrip()和rstrip()                                                                             |
| 16  | s1.split(str=" ")                   | 通过指定分隔符（默认为空格）对字符串进行切片，该方法将字符串分割成子字符串并返回一个由这些子字符串组成的列表。split()方法特别适用于根据特定的分隔符将字符串拆分成多个部分。            |
| 17  | s1.replace(old, new)                | 将字符串中的old替换成new                                                                                      |
| 18  | max(s1)                             | 返回字符串s1中最大的字母                                                                                        |
| 19  | min(s1)                             | 返回字符串s1中最小的字母                                                                                        |
| 20  | len(s1)                             | 返回字符串s1的长度                                                                                           |

### 2.bytes字节数组<a name="bytes字节数组"></a>

bytes字节数组是Python的一种有用的数据类型，bytes里面的元素只能是ASCⅡ码支持的字符，超出这个范围就会出错，bytes在数据通信中非常有用，比如socket套接字socket.recv()接收函数返回的数据类型就是bytes，socket.sendall()发送函数要求的参数数据类型也是bytes。

创建bytes最常用的方法是用字母b-string，bytes常用两种方法：hex()与decode()

```python
b0 = b'ABCDEFG'
h0 = b0.hex()
print(f'b0 = {b0}, hex()运算结果h0 = {h0}')  # h0 = 41424344454647
d0 = b0.decode()
print(f'b0 = {b0}, decode()运算结果d0 = {d0}')  # d0 = ABCDEFG
```

hex()运算将bytes转换为每个bytes字符对应一个16进制数字的字符串，decode()运算将bytes直接解码为字符串。

字符串方法encode()与字节数组方法decode()形成一对可逆运算：

```python
s1 = 'Hello'
b1 = s1.encode()  # 将字符串编码为bytes
d1 = b1.decode()  # 将bytes解码为字符串
print(f'b1 = {b1}, decode()运算结果d1 = {d1}')
```

字符串方法encode()可将字符串编码为bytes，而字节数组方法decode()可将bytes解码为字符串，字符串便于显示和文本处理，字节数组便于数据通信，显然encode()与decode()在实际开发过程中十分有用。

int型数据也可以转换成bytes，对小于128的数据，直接使用bytes([x])即可转换成bytes，对于数值较大的数据，使用to_bytes()方法可转换成bytes。

```python
a = 100
b = 1234
a_bytes = bytes([a])
b_bytes = b.to_bytes(length = 2, byteorder = 'big')
print(f'a = {a}, 转换为bytes = {a_bytes}')  # 转换为bytes = b'd'
print(f'b = {b}, 转换为bytes = {b_bytes}')  # 转换为bytes = b'\x04\xd2'
```

使用bytes([x])时[]不可省略，否则会产生完全不同的结果。

使用to_bytes()方法必须指定字节顺序byteorder，否则会报错。

十六进制字符串也可以转换为bytes：

```python
h1 = '4c4e4b4643413047305357303030303036'
h1b = bytes.fromhex(h1)
print(f'h1b: {h1b}')  # h1b: b'LNKFCA0G0SW000006'
```

各种不同数据类型转换为bytes字节数组的方法汇总如下表：

| 数据类型              | 转换为bytes的方法       | 示例                                                  |
| ----------------- | ----------------- | --------------------------------------------------- |
| 常规字符串s1 = 'Hello' | s1.encode()       | b1 = s1.encode()                                    |
| 小于128的int型数据a     | bytes([a])        | a_bytes = bytes([a])                                |
| 大于128的int型数据b     | b.to_bytes()      | b_bytes = b.to_bytes(length = 2, byteorder = 'big') |
| 十六进制字符串h1         | bytes.fromhex(h1) | h1b = bytes.fromhex(h1)                             |

### 3.列表<a name="列表"></a>

Python列表是任意对象的有序集合，可通过索引访问指定元素，首个元素索引为0，最后一个元素索引为-1。列表的数据项不需要具有相同的类型。

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。当方括号内没有任何元素时创建的是空列表。

```py
list1 = [1, 2, 3, 4, 5]
list2 = ['a', 'b', 'c', 'd']
list3 = [1, 2, 'OK']
print(list1[0])
print(list1[-1])
```

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符。

```py
print(list1[1:3]) #访问索引1到索引2的元素，显示[2, 3]
print(list1[2:-1]) #访问索引2到索引倒数第2的元素，显示[3, 4]
```

Python可以对列表进行遍历：

```py
for i in list1:  #遍历列表
  print(i)
for i, j in enumerate(list1):  #使用枚举遍历列表,i是元素序号，j是元素值
  print(i, j)
```

Python提供了一些函数可以获取列表信息：

```py
print(len(list1)) #列表的元素个数，显示5
print(max(list1)) #列表元素最大值，显示5
print(min(list1)) #列表元素最小值，显示1
print(sum(list1)) #列表的元素求和，显示15
```

Python提供了操作列表的很多方法：

| 序号  | 方法                                  | 方法说明                              |
| --- | ----------------------------------- | --------------------------------- |
| 1   | list.append(obj)                    | 在列表末尾添加新的对象                       |
| 2   | list.count(obj)                     | 统计某个元素在列表中出现的次数                   |
| 3   | list.extend(seq)                    | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4   | list.index(obj)                     | 从列表中找出某个值第一个匹配项的索引位置              |
| 5   | list.insert(index, obj)             | 将对象插入列表                           |
| 6   | list.pop([index=-1])                | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值    |
| 7   | list.remove(obj)                    | 移除列表中某个值的第一个匹配项                   |
| 8   | list.reverse()                      | 反向列表中元素                           |
| 9   | list.sort( key=None, reverse=False) | 对原列表进行排序                          |
| 10  | list.clear()                        | 清空列表                              |
| 11  | list.copy()                         | 复制列表                              |

### 4.元组<a name="元组"></a>

Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号 ( )，列表使用方括号 [ ]。创建一个元组，只要把逗号分隔的不同的数据项使用小括号括起来即可。当小括号内没有任何元素时创建的是空列表。当元组里只有一个元素时，需要在元素后加一个逗号，否则Python会将变量识别为其它数据类型（比如int）。

```py
tup1 = (1, 2, 3, 4, 5)
tup2 = ('a', 'b', 'c', 'd')
tup3 = (1, 2, 'OK')
print(tup1[0])
print(tup1[-1])
tup4 = (8,) #创建只有1个元素的元组
print(tup4[0])
```

Python提供了一些函数可以获取元组信息：

```py
print(len(tup1)) #元组的元素个数，显示5
print(max(tup1)) #元组元素最大值，显示5
print(min(tup1)) #元组元素最小值，显示1
print(sum(tup1)) #元组的元素求和，显示15
```

Python可以对元组进行遍历（for in），使用方法与列表类似。

Python提供了操作元组的方法包括count()方法与index()方法。

### 5.集合<a name="集合"></a>

Python集合是一个无序的不重复元素序列。集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用set() 函数创建集合。

```py
set1 = {1, 2, 3, 4, 5}        # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合
set1 - set2  #集合1中包含而集合2中不包含的元素，即差集，此处应为{1, 2, 3}
set1 | set2  #集合1或2中包含的所有元素，即并集，此处应为{1, 2, 3, 4, 5, 6, 7}
set1 & set2  #集合1和2中都包含了的元素，即交集，此处应为{4, 5}
set1 ^ set2  #不同时包含于1和2的元素，此处应为{1, 2, 3, 6, 7}
```

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

Python提供了一些函数可以获取集合信息：

```py
print(len(set1)) #集合的元素个数，显示5
print(max(set1)) #集合元素最大值，显示5
print(min(set1)) #集合元素最小值，显示1
print(sum(set1)) #集合的元素求和，显示15
```

集合元素无法索引，但Python可以对集合进行遍历，使用方法与列表类似。

Python提供了操作集合的很多方法：

| 序号  | 方法           | 方法说明                                  |
| --- | ------------ | ------------------------------------- |
| 1   | add()        | 为集合添加元素                               |
| 2   | clear()      | 移除集合中的所有元素                            |
| 3   | copy()       | 拷贝一个集合                                |
| 4   | discard()    | 删除集合中指定的元素                            |
| 5   | isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回True，否则返回False。 |
| 6   | issubset()   | 判断指定集合是否为该方法参数集合的子集。                  |
| 7   | issuperset() | 判断指定集合是否为该方法参数集合的超集。                  |
| 8   | pop()        | 随机移除元素                                |
| 9   | remove()     | 移除指定元素，remove方法在移除一个不存在的元素时会发生错误。     |
| 10  | update()     | 给集合添加元素，update方法参数更加灵活。               |
| 11  | len()        | 计算集合元素个数                              |

### 6.字典<a name="字典"></a>

字典是一种可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(**,**)分割，整个字典包括在花括号 {} 中。

键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串、数字。

```py
tinydict = {'Name': 'Tongtong', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
```

通过方括号[]可以访问字典里的值，修改、删除字典元素。字典不允许同一个键出现两次。创建时如果同一个键被赋值多次，虽然不会报错，但仅有最后一个值会被记住。

```py
tinydict['Age'] = 8 #修改键Age对应的值
print ("tinydict['Age']: ", tinydict['Age'])
dict1 = {'Height':145}
tinydict.update(dict1) #增加键值对dict1到字典tinydict中
print(tinydict)
```

Python提供了一些函数可以获取字典信息，字典也可以进行max函数与min函数运算，但是意义不大，因此不常使用：

```py
print(len(tinydict)) #字典的元素个数，显示4
```

字典不允许直接遍历，但是可以遍历字典的items()、keys()与values()，也可以使用枚举遍历字典的key。

```py
for i in tinydict.keys():  #遍历字典的所有key
  print(i)
for i, j in tinydict.items():  #遍历字典的所有对象
  print(i, j)
for i, j in enumerate(tinydict): #使用枚举遍历字典,i是元素序号，j是key
  print(i, j)
```

Python提供了操作字典的很多方法：

| 序号  | 方法                                 | 方法说明                                    |
| --- | ---------------------------------- | --------------------------------------- |
| 1   | dict.clear()                       | 删除字典内所有元素                               |
| 2   | dict.copy()                        | 返回一个字典的浅复制                              |
| 3   | dict.fromkeys()                    | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值  |
| 4   | dict.get(key, default=None)        | 返回指定键的值，如果键不在字典中返回 default 设置的默认值       |
| 5   | key in dict                        | 如果键在字典dict里返回true，否则返回false             |
| 6   | dict.items()                       | 以列表返回一个视图对象                             |
| 7   | dict.keys()                        | 返回一个视图对象                                |
| 8   | dict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9   | dict.update(dict2)                 | 把字典dict2的键/值对更新到dict里                   |
| 10  | dict.values()                      | 返回一个视图对象                                |
| 11  | dict.pop(key[,default])            | 删除字典 key（键）所对应的值，返回被删除的值。               |
| 12  | dict.popitem()                     | 返回并删除字典中的最后一对键和值。                       |

## 四.Python函数<a name="Python函数"></a>

### 1.定义函数<a name="定义函数"></a>

Python定义函数使用def关键字，一般格式如下：

```py
def 函数名（参数列表）:
    函数体
```

一个定义函数的简单示例：

```py
def max(a, b):
    if a > b:
        return a
    else:
        return b

a = 4
b = 5
print(max(a, b))
```

### 2.调用函数<a name="调用函数"></a>

调用带有参数的函数时，需要传递参数。Python函数的参数传递：

- 不可变类型：类似C语言的值传递，如整数、字符串、元组。如fun(a)，传递的只是a的值，没有影响a对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个a的对象。

- 可变类型：类似C语言的引用传递，如列表、字典。如fun(la)，则是将la真正的传过去，修改后fun外部的la也会受影响。

调用函数示例：

```py
def callme(myp):
  print ("修改前: ", myp)
  myp = '新的对象'
  print ("修改后: ", myp)
  return

def changeme(myp):
  myp.append(8)
  print ("函数内取值: ", myp)
  myp[0] = 6
  print ("函数内取值: ", myp)
  return

mystring = 'abc'
callme( mystring )
print ("函数外取值（字符串）: ", mystring) # mystring的值没有变化
mylist = [1, 2, 3]
changeme( mylist )
print ("函数外取值（列表）: ", mylist) # mylist的值发生了变化
```

### 3.函数参数<a name="函数参数"></a>

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。

调用函数时，如果没有传递参数，则会使用默认参数。

```py
def vol(radius, height, pi = 3.14):
  return pi*radius*radius*height

print(vol(1, 10, 3.1416)) # 按照参数顺序调用函数
print(vol(height = 10, radius = 1)) # 使用关键字参数调用函数，pi使用默认参数
```

### 4.不定长参数<a name="不定长参数"></a>

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述两种参数不同，声明时不会命名。基本语法如下：

```py
def functionname([formal_args,] *var_args_tuple ):
  function_suite
  return [expression]
```

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们可以不向函数传递未命名的变量，也可以向函数传递各种长度的参数。如下实例：

```py
def printinfo( arg1, *vartuple ):
  print ("打印任何传入的参数: ")
  print (arg1)
  for var in vartuple:
    print (var)
  return

printinfo( 10 ) #不向函数传递未命名的变量
printinfo( 70, 60, 50, 40, 30 ) #向函数传递各种长度的参数
```

加了星号 * 的参数会以元组(tuple)的形式导入，可以正确处理整数、字符串、元组、列表等各种输入参数，但是无法处理字典。因此，对于字典，需要特殊处理：参数前加两个星号，表明当前参数的数据类型应该是字典。

### 5.匿名函数<a name="匿名函数"></a>

Python使用关键字lambda来创建匿名函数。所谓匿名，意即不再使用def语句这样标准的形式定义一个函数。

- lambda只是一个表达式，函数体比def简单很多。
- lambda的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
- lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

lambda函数的语法只包含一个语句，如下：

```py
lambda [arg1 [,arg2,.....argn]]:expression
```

一个匿名函数的简单示例：

```py
area = lambda x : x * x
a = int(input('请输入正方形的边长：'))
print('正方形的面积是：', area(a))
```

匿名函数经常与map()（对指定序列做映射）、filter()（过滤序列）等内置函数配合使用。

```py
A = [1, 2, 3, 4, 5, 6, 7, 8]
B = list(map(lambda x: x ** 2, A))  # 在map()函数中使用lambda匿名函数
C = list(filter(lambda x: x%2, A))  # 在filter()函数中使用lambda匿名函数
print(B)
print(C)
```

### 6.main函数<a name="main函数"></a>

一些编程语言（比如C语言）有一个称为的特殊函数main()，它是程序文件的执行点。但是，Python解释器从文件顶部开始依次运行每一行，并且没有显式main()函数。

Python提供了其他约定来定义执行点。其中之一是使用python文件的main()函数和__name__属性。

__name__变量是一个特殊的内置Python变量，它表示当前模块的名称。根据执行Python文件的位置，它具有不同的值。当我们将程序作为脚本运行时，变量的值__name__设置为固定名称__main__。在将Python文件作为模块运行的情况下，模块本身的名称已分配给__name__变量。通常将if条件与__name__一起使用：

```py
def main():
    print("Hello World")

if __name__=="__main__":
    main()
```

当我们通过命令行将其作为脚本运行时，输出将是：Hello World。当我们通过将其导入main.py文件将其作为模块运行时，由于if条件不成立不调用执行函数，因此不会显示任何输出。

总结来说，Python中的main函数是一个约定俗成的入口点，通过将if条件与__name__一起使用来控制代码的执行，使得脚本既可以作为独立程序运行，也可以作为模块被其他代码导入和重用。在不同的运行方式下脚本可具备不同的功能。

### 7.内置函数<a name="内置函数"></a>

Python提供了很多有用的内置函数。

| 函数           | 说明                                                                                                                                         | 简单示例                             |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- |
| abs()        | 返回数字的绝对值。                                                                                                                                  | abs(-3)                          |
| bool()       | 将给定参数转换为布尔类型，如果没有参数，返回 False。                                                                                                              | bool(2)                          |
| bin()        | 返回一个整数的二进制表示（字符串）。                                                                                                                         | bin(10)                          |
| oct()        | 返回一个整数的8进制表示（字符串）。                                                                                                                         | oct(10)                          |
| hex()        | 返回一个整数的16进制表示（字符串）。                                                                                                                        | hex(10)                          |
| str()        | 将对象转化为适于人阅读的形式（字符串）。                                                                                                                       | str(3.14)                        |
| chr()        | 将整数转换为ASCII字符。                                                                                                                             | chr(33)                          |
| ord()        | 将ASCII字符转换为整数。                                                                                                                             | ord('A')                         |
| eval()       | 执行一个字符串表达式，并返回表达式的值。                                                                                                                       | eval('1+1')                      |
| help()       | 查看函数或模块用途的详细说明。                                                                                                                            | help('abs')                      |
| enumerate()  | 将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。                                                                                | for i, element in enumerate(seq) |
| isinstance() | 判断一个对象是否是一个已知的类型，类似 type()。                                                                                                                | isinstance (2,int)               |
| filter()     | 用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。 函数接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。 | filter(lambda x: x%2, A)         |
| map()        | 根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。                                                       | map(lambda x: x ** 2, A)         |
| format()     | 格式化字符串的函数 str.format()，它增强了字符串格式化的功能。                                                                                                      | "{} {}".format("hello", "world") |
| id()         | 返回对象的唯一标识符，标识符是一个整数。                                                                                                                       | id(A)                            |
| input()      | 接受一个标准输入数据，返回为 string 类型。                                                                                                                  | a = input("input:")              |
| len()        | 返回对象的长度或元素个数，适用于字符串、列表、元组等具有长度信息的数据类型。                                                                                                     | len([1, 2, 3])                   |
| max()        | 返回给定参数的最大值，参数可以为序列。                                                                                                                        | max([1, 2, 3])                   |
| min()        | 返回给定参数的最小值，参数可以为序列。                                                                                                                        | min([1, 2, 3])                   |
| pow()        | 返回x的y次方的值。                                                                                                                                 | pow(2,3)                         |
| range()      | 创建一个整数列表，一般用在 for 循环中。                                                                                                                     | range(10)                        |
| reversed()   | 返回一个反转的迭代器。                                                                                                                                | reversed('ABC')                  |
| sorted()     | 对所有可迭代的对象进行排序操作,返回重新排序的列表。                                                                                                                 | sorted('DABC')                   |
| round()      | 返回浮点数x的四舍五入值。                                                                                                                              | round(3.1416, 2)                 |
| int()        | 用于将一个字符串或数字转换为整型。                                                                                                                          | int(3.6)                         |
| list()       | 用于将元组转换为列表。                                                                                                                                | list(tup1)                       |
| set()        | 创建一个无序不重复元素集合。                                                                                                                             | set([4, 5, 6, 7])                |
| tuple()      | 将列表转换为元组。                                                                                                                                  | tuple([1,2,3,4])                 |
| type()       | 返回对象的类型。                                                                                                                                   | type(A)                          |
| zip()        | 用于将可迭代的对象（如列表、元组、字符串等）作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。                                                                               | zipped = zip(a,b)                |