1146 lines
16 KiB
Markdown
1146 lines
16 KiB
Markdown
# Python基础语法
|
||
|
||
第一个程序
|
||
|
||
```python
|
||
print("hello word")
|
||
```
|
||
|
||
## 数据类型
|
||
|
||
* 数字 Number
|
||
* 整数 int
|
||
* 浮点数 float
|
||
* 复数 complex 4+3j
|
||
* 布尔 bool
|
||
* 字符串 String : 用单引号或者双引号包裹, 或者三对双引号 `"""字符串"""`
|
||
* 列表 List : 有序的可变序列
|
||
* 元组 Tuple : 有序的不可变序列
|
||
* 集合 Set : 无序不重复集合
|
||
* 字典 Dictionary : 无序key-value集合
|
||
|
||
`type(1)` : 检查类型
|
||
|
||
## 注释
|
||
|
||
```python
|
||
# 单行注释
|
||
|
||
'''
|
||
三个单引号多行注释
|
||
'''
|
||
|
||
"""
|
||
或者三个双引号
|
||
"""
|
||
|
||
```
|
||
|
||
## 风格
|
||
|
||
### 代码块
|
||
|
||
===不使用{}, 而是缩进表示代码块. 同一个代码块缩进的空格数必须一致===
|
||
|
||
```python
|
||
if True:
|
||
print("true")
|
||
else:
|
||
print("false")
|
||
```
|
||
|
||
### 多行语句
|
||
|
||
```python
|
||
# 用 \ 实现换行
|
||
total = one + two + \
|
||
three + four
|
||
|
||
# 在 [] {} 中不需要 \
|
||
total = [one , two
|
||
three, four]
|
||
```
|
||
|
||
### 保留字
|
||
|
||
```python
|
||
import keyword
|
||
print(keyword.kwlist)
|
||
|
||
'''
|
||
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
|
||
'''
|
||
```
|
||
|
||
## 变量
|
||
|
||
```python
|
||
# 语法:
|
||
变量名 = 变量值
|
||
```
|
||
|
||
## 数据类型转换
|
||
|
||
```python
|
||
int(x)
|
||
float(x)
|
||
str(x)
|
||
```
|
||
|
||
## 标识符
|
||
|
||
* 内容限定: 英文 数字 下划线, ===数字不能在空头===
|
||
* 大小写敏感
|
||
* 不可使用关键字, 关键字也是大小写敏感
|
||
|
||
变量命名规范: 蛇形命名法: ===全小写, 下划线===
|
||
|
||
## 运算符
|
||
|
||
* 算数运算符
|
||
* * * * /
|
||
* // 取整除 : 9//2输出4
|
||
* % 取余
|
||
* ** 指数
|
||
* 赋值运算符
|
||
* =
|
||
* `+= -= *= /= //= %= **=` 复合赋值运算符
|
||
|
||
===没有 ++ -- ===
|
||
|
||
## 字符扩展
|
||
|
||
* `\` 转义
|
||
* 拼接: 加号, 只能用字符串拼字符串
|
||
* 占位格式化
|
||
|
||
```python
|
||
"""
|
||
语法:
|
||
%s在字面量中占位, 后面 % 变量
|
||
顺序不能变
|
||
|
||
%s 字符串
|
||
%d 整数
|
||
%f 浮点数
|
||
"""
|
||
|
||
|
||
name = "张三"
|
||
|
||
age = 18
|
||
|
||
message1 = "%s是男性" % name
|
||
|
||
message2 = "%s今年%d岁了" % (name, age)
|
||
|
||
print(message1,message2)
|
||
```
|
||
|
||
* 格式化的精度控制
|
||
|
||
```python
|
||
"""
|
||
m.n m表示宽度, n表示小数的精度
|
||
|
||
# 示例
|
||
%5d # 宽度控制为5, 少的宽度用空格补全; 如果宽度小于实际, 不生效; 宽度包含小数和小数点
|
||
%5.2f # 宽度为5, 两位小数, 小数部分4舍5入
|
||
%.2f # 不限制宽度, 只限制小数
|
||
"""
|
||
|
||
num = 11.456
|
||
|
||
print("%7d" % num) # 11
|
||
print("%7.2f" % num) # 11.46
|
||
print("%.2f" % num) # 11.46
|
||
```
|
||
|
||
* 快速格式化
|
||
|
||
```python
|
||
# f"内容{变量}"
|
||
# 没有类型和精度控制
|
||
# f format
|
||
|
||
name = "张三"
|
||
age = 18.5
|
||
message = f"{name}今年{age}岁了"
|
||
print(message)
|
||
```
|
||
|
||
* 格式化中使用表达式
|
||
|
||
```python
|
||
print("11的类型是%s" % type(11))
|
||
|
||
print(f"11的类型是{type(11)}")
|
||
```
|
||
|
||
## 数据输入
|
||
|
||
```python
|
||
"""
|
||
input() 接收键盘输入
|
||
input("提示文本")
|
||
获取的是字符串格式,其他格式需要自行转换
|
||
"""
|
||
|
||
name = input("请输出你的名字")
|
||
print(f"name: {name}")
|
||
```
|
||
|
||
## 判断语句
|
||
|
||
* 比较运算符:
|
||
|
||
```python
|
||
>
|
||
<
|
||
==
|
||
!==
|
||
>=
|
||
<=
|
||
```
|
||
|
||
* 布尔类型: `True` `False` ===大写===
|
||
* if 语句
|
||
|
||
```python
|
||
if 条件:
|
||
执行语句
|
||
```
|
||
|
||
* if else 语句
|
||
|
||
```python
|
||
if 条件:
|
||
执行语句
|
||
else:
|
||
执行语句
|
||
```
|
||
|
||
* if elif else
|
||
|
||
```python
|
||
if 条件:
|
||
执行语句
|
||
elif 条件:
|
||
执行语句
|
||
else:
|
||
执行语句
|
||
```
|
||
|
||
* 嵌套
|
||
|
||
```python
|
||
# 关键 缩进
|
||
if 条件:
|
||
执行语句
|
||
if 条件:
|
||
执行语句
|
||
```
|
||
|
||
## while 循环
|
||
|
||
```python
|
||
while 条件:
|
||
执行语句
|
||
```
|
||
|
||
* 嵌套
|
||
|
||
```python
|
||
while 条件:
|
||
执行语句
|
||
while 条件:
|
||
执行语句
|
||
```
|
||
|
||
## for in 循环
|
||
|
||
```python
|
||
for 临时变量 in 序列类型
|
||
执行的代码
|
||
```
|
||
|
||
```python
|
||
str="hello word"
|
||
for i in str:
|
||
print(i)
|
||
```
|
||
|
||
* 嵌套
|
||
|
||
```python
|
||
for 临时变量 in 序列类型
|
||
执行的代码
|
||
for 临时变量 in 序列类型
|
||
执行的代码
|
||
```
|
||
|
||
## range 语句
|
||
|
||
> 生成数字序列
|
||
|
||
```python
|
||
# 生成一个从0开始到num的数字序列, 不包含num本身
|
||
range(num)
|
||
|
||
range(5)
|
||
# [0, 1, 2, 3, 4]
|
||
|
||
|
||
# 从 num1 到num2, 不包含num2
|
||
range(num1, num2)
|
||
|
||
# 从num1到num2, 步进为step
|
||
range(num1, num2, step)
|
||
|
||
range(2, 7, 2)
|
||
# 2, 4, 6
|
||
```
|
||
|
||
使用场景:
|
||
|
||
```python
|
||
for x in range(10):
|
||
print(x)
|
||
```
|
||
|
||
## print 控制是否换行
|
||
|
||
> print("", end=""), end参数控制输出的结尾内容, 而不是默认换行
|
||
|
||
99乘法表
|
||
|
||
```python
|
||
for i in range(1,10):
|
||
for j in range(1,i+1):
|
||
print(f"{i}*{j}={i*j} \t",end="")
|
||
print()
|
||
```
|
||
|
||
## continue 和 break
|
||
|
||
continue 临时跳过
|
||
|
||
break 结束
|
||
|
||
示例:
|
||
|
||
```python
|
||
for x in range(1, 6):
|
||
if x == 3:
|
||
continue
|
||
print(x)
|
||
```
|
||
|
||
```python
|
||
for x in range(1, 6):
|
||
if x == 3:
|
||
break
|
||
print(x)
|
||
```
|
||
|
||
## 函数
|
||
|
||
```python
|
||
def 函数名(形参):
|
||
函数体
|
||
return 返回值
|
||
|
||
# 调用
|
||
函数名(实参)
|
||
```
|
||
|
||
函数注释
|
||
|
||
```python
|
||
def 函数名(x, y):
|
||
"""
|
||
函数说明
|
||
:param x: 行参x的说明
|
||
:param y: 行参y的说明
|
||
:return: 返回值的说明
|
||
"""
|
||
函数体
|
||
return 返回值
|
||
```
|
||
|
||
示例:
|
||
|
||
```python
|
||
def add(num1, num2):
|
||
"""
|
||
这是一个计算两个数相加的函数
|
||
:param num1: 第一个数
|
||
:param num2: 第二个数
|
||
:return: 两个数相加的结果
|
||
"""
|
||
return num1 + num2
|
||
|
||
print(add(1,2))
|
||
```
|
||
|
||
## 列表
|
||
|
||
```python
|
||
变量名 = []
|
||
|
||
变量名 = list()
|
||
|
||
变量名 = [元素1, 元素2, ...]
|
||
```
|
||
|
||
### 下标索引
|
||
|
||
```python
|
||
# 从0开始
|
||
变量名[下标]
|
||
|
||
# 反向索引
|
||
# 从-1开始
|
||
变量名[-1]
|
||
|
||
# 嵌套列表
|
||
变量名[0][0]
|
||
```
|
||
|
||
### 常用方法
|
||
|
||
* 增:
|
||
* 插入: `列表.insert(下标, 值)`
|
||
* 追加: `列表.append(值)`
|
||
* 把列表内容取出追加到列表: `列表1.extend(列表2)`
|
||
* 删:
|
||
* `del 列表[下标]`
|
||
* `被取出的元素=列表.pop(下标)`
|
||
* `列表.remove(元素)`:从前到后第一个匹配项
|
||
* `列表.clear()`: 清空
|
||
* 改: `列表[下标]=新的值`
|
||
* 查: 查询下标 `列表.index(元素)`
|
||
* 统计元素个数: `列表.count(元素)`
|
||
* 长度: `len(列表)`
|
||
|
||
### 列表的遍历
|
||
|
||
* while
|
||
|
||
```python
|
||
list = ["a", "b", "c"]
|
||
index = 0
|
||
while index < len(list):
|
||
print(len[i])
|
||
index+=1
|
||
```
|
||
|
||
* for in
|
||
|
||
```python
|
||
list = ["a", "b", "c"]
|
||
for x in list:
|
||
print(x)
|
||
```
|
||
|
||
## 元组
|
||
|
||
> 只读的列表, 定义完成, 不能修改
|
||
|
||
```python
|
||
元组 = (元素1, 元素2, ...)
|
||
|
||
元组 = tuple()
|
||
```
|
||
|
||
===只有一个元素的元组, 必须带逗号===
|
||
|
||
```python
|
||
元组 = (元素1, )
|
||
```
|
||
|
||
### 下标索引
|
||
|
||
```python
|
||
t1 = ((1, 2, 3), (4, 5, 6))
|
||
element = t1[1][2]
|
||
print(element)
|
||
```
|
||
|
||
### 方法
|
||
|
||
* 查: `元组.index(元素)`
|
||
* 统计:
|
||
* 元素的数量 `元组.count(元素)`
|
||
* 长度: `len(元组)`
|
||
|
||
### 遍历
|
||
|
||
while
|
||
|
||
for in
|
||
|
||
### 修改
|
||
|
||
```python
|
||
t2 = ((1, 2, 3), [4, 5, 6])
|
||
t2[1][2] = 7 # 元组里的数组里的元素可以修改
|
||
print(t2)
|
||
```
|
||
|
||
## 字符串
|
||
|
||
```python
|
||
str = "hello word"
|
||
print(str[0])
|
||
print(str[-1])
|
||
```
|
||
|
||
===字符串是不可修改的数据容器===
|
||
|
||
### 常用的方法
|
||
|
||
* `字符串.index(字符)`
|
||
* 替换: 不是修改, 是得到新的字符串 `newstr = 字符串.replace(字符1, 字符2)`
|
||
* 分割: `列表 = 字符串.split(用来分割的字符)`
|
||
* 去首尾空格: `newstr = 字符串.strip()`
|
||
* 去指定字符: `newstr = 字符串.strip(要去除的字符)`
|
||
* ===去除是逐个去除=== `print("12hello word21".strip("12"))`, 结果是 hello word, 不止12被去除了,21也被去除了
|
||
* 统计次数: `count = 字符串.count(字符)`
|
||
* 长度: `num = len(字符串)`
|
||
|
||
## 序列的切片
|
||
|
||
> 列表 元组 字符串 都支持切片
|
||
> 对序列切割不影响序列本身, 而是返回新的序列
|
||
|
||
```python
|
||
序列[起始:结束:步长]
|
||
# 起始为空, 表示从头开始
|
||
# 结束为空, 表示到尾. 不为空, 到该下标结束, 不包含该下标所在的元素
|
||
# 默认为1,可省略, 表示连续取；为n, 表示跳过n-1个; 为正, 表示从左到右; 为负, 表示反方向(下标也得反方向).
|
||
```
|
||
|
||
示例:
|
||
|
||
```python
|
||
print([1, 2, 3, 4, 5, 6, 7, 8, 9][1:7])
|
||
# 输出[2, 3, 4, 5, 6, 7]
|
||
|
||
print([1, 2, 3, 4, 5, 6, 7, 8, 9][1:7:2])
|
||
# 输出[2, 4, 6]
|
||
|
||
print([1, 2, 3, 4, 5, 6, 7, 8, 9][1:7:3])
|
||
# 输出[2, 5]
|
||
|
||
print("1234567"[::-1])
|
||
# 7654321
|
||
```
|
||
|
||
## 集合
|
||
|
||
```python
|
||
# 集合不支持重复, 自带去重
|
||
new_set = {元素1, 元素2, ...}
|
||
|
||
new_set2 = set()
|
||
```
|
||
|
||
===不支持下标索引访问===
|
||
|
||
### 常用的方法
|
||
|
||
```python
|
||
# 增
|
||
集合.add(元素)
|
||
|
||
# 删
|
||
集合.remove(元素)
|
||
|
||
# 随机取出一个元素, 同时集合被修改, 该元素被移除
|
||
集合.pop()
|
||
|
||
# 清空
|
||
集合.clear()
|
||
|
||
# 差集, 集合1 集合2不变, 得到集合1有集合2没有的
|
||
新集合 = 集合1.difference(集合2)
|
||
|
||
print({1, 2, 3}.difference({3, 4, 5}))
|
||
# 输出 {1, 2}
|
||
|
||
# 消除差集, 集合1被修改, 集合2不变, 在集合1内删除和集合2相同的内容
|
||
集合1.difference_upate(集合2)
|
||
|
||
my_set={1, 2, 3}
|
||
my_set.difference_update({3, 4, 5})
|
||
print(my_set)
|
||
|
||
# 集合合并, 集合1 集合2不变, 返回合并后的集合
|
||
集合1.union(集合2)
|
||
|
||
print({1, 2, 3}.union({3, 4, 5}))
|
||
|
||
# 长度
|
||
len(集合)
|
||
```
|
||
|
||
### 遍历
|
||
|
||
没有下标, 不支持 while, 但可以用for in
|
||
|
||
## 字典
|
||
|
||
```python
|
||
{key1: value1, key2: value2, ...}
|
||
|
||
emy_dict = {} # 不是集合
|
||
# 或者
|
||
emy_dict = dict()
|
||
|
||
# 取出值
|
||
字典[key]
|
||
|
||
===key不能是字典===
|
||
```
|
||
|
||
### 常用方法
|
||
|
||
#### 新增/更改
|
||
|
||
```python
|
||
# 不存在就是新增, 已存在就是更改
|
||
字典[key] = value
|
||
```
|
||
|
||
#### 删
|
||
|
||
```python
|
||
# 取出来的同时, 也从原字典中删除
|
||
value = 字典.pop(key)
|
||
```
|
||
|
||
#### 清空
|
||
|
||
```python
|
||
字典.clear()
|
||
```
|
||
|
||
#### 获取所有的键
|
||
|
||
```python
|
||
keys = 字典.keys()
|
||
```
|
||
|
||
#### 长度
|
||
|
||
```python
|
||
len(字典)
|
||
```
|
||
|
||
### 遍历
|
||
|
||
方法一:
|
||
|
||
```python
|
||
dict = {"name": "张三", "age": 18, "address": "北京"}
|
||
for key in dict.keys():
|
||
print(dict[key])
|
||
```
|
||
|
||
方法二:
|
||
|
||
```python
|
||
dict = {"name": "张三", "age": 18, "address": "北京"}
|
||
for key in dict:
|
||
print(dict[key])
|
||
```
|
||
|
||
## 数据容器的通用操作
|
||
|
||
1. 遍历
|
||
2. `len(容器)`
|
||
3. `max(容器)` 最大元素
|
||
4. `min(容器)` 最小元素
|
||
5. 容器转换
|
||
1. `list(容器)` 字典转列表, 会只保留key
|
||
2. `str(容器)`
|
||
3. `tuple(容器)`
|
||
4. `set(容器)`
|
||
6. 通用排序: `sorted(容器, [reverse=True])` 把内容排序后放到列表中
|
||
|
||
## 字符串比较大小
|
||
|
||
数字 字符 是如何比较大小的: 按照ASCII的码值
|
||
|
||
比较的时候是一位位从左到右比较的, 只要有一位大, 就整体大
|
||
|
||
## 函数
|
||
|
||
### 返回多个值
|
||
|
||
```python
|
||
# 用逗号隔开
|
||
def test():
|
||
return 1, 2
|
||
a, b = test()
|
||
print(a, b)
|
||
```
|
||
|
||
### 关键字传参
|
||
|
||
```python
|
||
# 位置传参
|
||
def sum(num1, num2):
|
||
return num1 + num2
|
||
|
||
sum(1, 2)
|
||
|
||
# 关键字传参
|
||
# 键=值
|
||
# 顺序可以打乱
|
||
sum(num2=1, num1=2)
|
||
|
||
# 还可以混用, 但位置传参在前, 关键字传参在后
|
||
```
|
||
|
||
### 缺省/默认参数
|
||
|
||
===默认参数必须写到最后面===
|
||
|
||
```python
|
||
def user_info(name, age, gender="男"):
|
||
print(name, age, gender)
|
||
```
|
||
|
||
### 可变参数
|
||
|
||
```python
|
||
# 位置传递
|
||
# 一个星号
|
||
# 传递的所有参数都会被args收集, 合并成一个元组
|
||
def user_info(*args):
|
||
print(args)
|
||
|
||
user_info("张三", 18,"男")
|
||
# ('张三', 18, '男')
|
||
|
||
# 关键字传递
|
||
# 两个星号
|
||
# 参数必须是键值对的形式
|
||
# 字典
|
||
def user_info(**kwargs):
|
||
print(kwargs)
|
||
|
||
user_info(name="张三", age=18, gender="男")
|
||
# {'name': '张三', 'age': 18, 'gender': '男'}
|
||
```
|
||
|
||
### lambda 匿名函数
|
||
|
||
```python
|
||
# 函数体只能写一行
|
||
lambda 参数: 函数体
|
||
|
||
def test(fn):
|
||
res = fn(1, 2)
|
||
print(res)
|
||
|
||
test(lambda x, y: x + y)
|
||
```
|
||
|
||
## 文件操作
|
||
|
||
### 文件编码
|
||
|
||
* UTF-8
|
||
* GBK
|
||
* Big5
|
||
|
||
### 文件的打开
|
||
|
||
```python
|
||
open(name, mode, encoding)
|
||
# name 文件名或路径
|
||
# mode r只读 w写入 a追加
|
||
# encoding 编码格式, 常用UTF-8
|
||
|
||
f = open("test.txt", "r", encoding="utf-8")
|
||
print(type(f))
|
||
|
||
# <class '_io.TextIOWrapper'>
|
||
```
|
||
|
||
### 读取
|
||
|
||
* `read([num])`: 不传参时读取所有；传参时, 读取 num 字节
|
||
* `readlines()`: 读取全部行, 依次存到列表中
|
||
* `readline()`: 一次读取一行
|
||
|
||
注意: 如果多次调用 read() 方法, 会记录上次读取的位置, 例如:
|
||
|
||
```python
|
||
f = open("test.txt", "r", encoding="utf-8")
|
||
|
||
print(f.read(2))
|
||
print(f.read())
|
||
# 从第三个字节开始读取
|
||
print(f.readlines())
|
||
# 为空
|
||
```
|
||
|
||
* for in 循环读取文件
|
||
|
||
```python
|
||
for line in open("test.txt", "r", encoding="utf-8"):
|
||
print(line)
|
||
```
|
||
|
||
### 关闭
|
||
|
||
```python
|
||
# 结束对文件的占用
|
||
f = open("test.txt", "r", encoding="utf-8")
|
||
f.close()
|
||
```
|
||
|
||
`with open() as f` 语法会自动关闭
|
||
|
||
示例:
|
||
|
||
```python
|
||
with open("test.txt", "r") as f:
|
||
f.readlines()
|
||
```
|
||
|
||
### 写入
|
||
|
||
```python
|
||
f.write("写入的内容")
|
||
|
||
# 内容刷新, 从内存写入到硬盘
|
||
# 好处是避免频繁操作硬盘
|
||
f.flush()
|
||
```
|
||
|
||
示例:
|
||
|
||
```python
|
||
# w 模式
|
||
# 当文件不存在时, 创建该文件
|
||
# 当文件存在, 会清空
|
||
f = open("test.txt", "w")
|
||
f.write("hello word\n")
|
||
f.write("123")
|
||
f.flush()
|
||
f.close()
|
||
|
||
# close()方法内置了 flush(), 关闭时也会自动写入硬盘
|
||
```
|
||
|
||
### 追加
|
||
|
||
```python
|
||
# a 模式
|
||
f = open("test.txt", "a")
|
||
```
|
||
|
||
## 异常的捕获
|
||
|
||
```python
|
||
try:
|
||
可能发生错误的代码
|
||
except:
|
||
如果出现错误执行的代码
|
||
```
|
||
|
||
示例:
|
||
|
||
```python
|
||
try:
|
||
f = open("none.txt","r")
|
||
except:
|
||
print("文件不存在")
|
||
```
|
||
|
||
### 捕获指定的异常
|
||
|
||
```python
|
||
try:
|
||
可能发生错误的代码
|
||
except 异常的类型 as e:
|
||
如果异常类型符合就执行
|
||
e是异常信息
|
||
```
|
||
|
||
示例:
|
||
|
||
```python
|
||
try:
|
||
print(name)
|
||
except NameError as e:
|
||
print(e)
|
||
```
|
||
|
||
### 捕获多个异常
|
||
|
||
```python
|
||
# 用元组来指定异常类型
|
||
try:
|
||
可能发生错误的代码
|
||
except (类型1, 类型2, ...) as e:
|
||
如果异常类型符合就执行
|
||
e是异常信息
|
||
```
|
||
|
||
示例:
|
||
|
||
```python
|
||
try:
|
||
print(1/0)
|
||
except (NameError,ZeroDivisionError) as e:
|
||
print(e)
|
||
```
|
||
|
||
### 捕获所有异常
|
||
|
||
```python
|
||
# except 不指定类型就可以捕获所有异常
|
||
|
||
# 也可以指定类型 Exception
|
||
try:
|
||
可能发生错误的代码
|
||
except Exception as e:
|
||
如果异常类型符合就执行
|
||
e是异常信息
|
||
```
|
||
|
||
示例:
|
||
|
||
```python
|
||
try:
|
||
print(name)
|
||
except Exception as e:
|
||
print(e)
|
||
```
|
||
|
||
### 主动抛出异常
|
||
|
||
```python
|
||
raise Exception("异常消息")
|
||
```
|
||
|
||
### else
|
||
|
||
```python
|
||
try:
|
||
可能发生错误的代码
|
||
except Exception as e:
|
||
如果异常类型符合就执行
|
||
e是异常信息
|
||
else:
|
||
没有异常时执行的代码
|
||
```
|
||
|
||
### finally
|
||
|
||
```python
|
||
try:
|
||
可能发生错误的代码
|
||
except Exception as e:
|
||
如果异常类型符合就执行
|
||
e是异常信息
|
||
else:
|
||
没有异常时执行
|
||
finally:
|
||
无论如何都要执行
|
||
```
|
||
|
||
### 异常的传递
|
||
|
||
```python
|
||
# 异常会一层层往外传
|
||
# 只要函数具有调用关系, 只须在最顶级捕获异常
|
||
def fun1():
|
||
print(name)
|
||
|
||
def fun2():
|
||
fun1()
|
||
|
||
def main():
|
||
try:
|
||
fun2()
|
||
except Exception as e:
|
||
print(e)
|
||
|
||
main()
|
||
```
|
||
|
||
## 模块
|
||
|
||
### 导入
|
||
|
||
```python
|
||
[from 模块名] import [模块|类|变量|函数|*] [as 别名]
|
||
|
||
import 模块名
|
||
模块名.函数()
|
||
|
||
import 模块名1, 模块名2
|
||
```
|
||
|
||
示例:
|
||
|
||
```python
|
||
import time
|
||
|
||
print(time.time())
|
||
time.sleep(5)
|
||
print(time.time())
|
||
```
|
||
|
||
```python
|
||
from time import sleep
|
||
print(time.time())
|
||
sleep(5)
|
||
print(time.time())
|
||
```
|
||
|
||
```python
|
||
# 也是导入全部
|
||
from time import *
|
||
sleep(5)
|
||
```
|
||
|
||
```python
|
||
# as 别名
|
||
from time import sleep as t
|
||
t(5)
|
||
```
|
||
|
||
### 自定义模块
|
||
|
||
```python
|
||
# 新建一个py文件
|
||
# 在该文件里写函数
|
||
|
||
# import 文件名
|
||
# 或者
|
||
# from 文件名 import 函数
|
||
```
|
||
|
||
* 模块导入的时候会执行模块里的语句
|
||
|
||
例如:
|
||
|
||
```python
|
||
# module.py
|
||
def sum(a,b):
|
||
print(a+b)
|
||
|
||
sum(1,2)
|
||
|
||
# test.py
|
||
import module
|
||
# 这里导入时就会输出3
|
||
```
|
||
|
||
改造:
|
||
|
||
```python
|
||
def sum(a,b):
|
||
print(a+b)
|
||
|
||
if __name__ == "__main__":
|
||
sum(1,2)
|
||
|
||
# 直接运行该文件时, 内置变量 __name__ 就会设置为 __main__
|
||
# 作为模块被导入时, if 里的代码不执行
|
||
```
|
||
|
||
* `__all__` 变量
|
||
|
||
```python
|
||
__all__=["sum"]
|
||
|
||
def sum(a,b):
|
||
print(a+b)
|
||
|
||
def sub(a, b):
|
||
print(a-b)
|
||
```
|
||
|
||
```python
|
||
from module import *
|
||
# 通过*只能导入 __all__ 列出的函数
|
||
# __all__ 不定义, 就可以导入全部
|
||
```
|
||
|
||
## 包
|
||
|
||
> 文件夹里有多个模块
|
||
|
||
```
|
||
1. 创建文件夹
|
||
2. 创建 __init__.py 文件
|
||
3. 创建 模块.py
|
||
4. 使用: import 包名.模块名
|
||
包名.模块名.函数
|
||
|
||
或者
|
||
from 包名 import 模块名
|
||
模块名.函数()
|
||
|
||
或者
|
||
from 包名.模块名 import 函数
|
||
函数()
|
||
|
||
结构:
|
||
|
||
文件夹名为包名
|
||
__init__py
|
||
module1.py
|
||
module2.py
|
||
```
|
||
|
||
示例:
|
||
|
||
```python
|
||
import my_package.module1
|
||
import my_package.module2
|
||
|
||
my_package.module1.sum(1, 2)
|
||
my_package.module2.sub(1, 2)
|
||
```
|
||
|
||
或者
|
||
|
||
```python
|
||
from my_package import module1
|
||
from my_package import module2
|
||
|
||
module1.sum(1, 2)
|
||
module2.sub(1, 2)
|
||
```
|
||
|
||
```python
|
||
from my_package.module1 import sum
|
||
from my_package.module2 import sub
|
||
|
||
sum(1, 2)
|
||
sub(1, 2)
|
||
```
|
||
|
||
* `__all__`
|
||
|
||
```python
|
||
# 写在__init__.py
|
||
__all__ = ["module1", "module2"]
|
||
```
|
||
|
||
## 安装第三方包
|
||
|
||
```python
|
||
pip install 包名
|
||
```
|