一文快速入门Python——Python基础
作者：永不落的梦想
作者主页：传送
座右铭：过去属于死神，未来属于自己
本文专栏：Python篇
今日鸡汤：眼里有不朽的光芒，心里有永恒的希望
目录
一、简介
二、环境搭建
1.python搭建环境
2.PyCharm安装
三、python基础语法
1.字面量
2.注释
3.变量
4.标识符
5.运算符
6.字符串
7.数据输入
8.缩进
四、数据类型
1.数据类型
2.数据类型查看
3.数据类型转换
4.数据容器
5.数据容器对比
五、python解释器
六、条件控制语句
1.布尔类型与比较运算符
2.if语句
3.if [elif] else语句
4.条件语句的嵌套
七、循环语句
1.while循环
2.for循环
3.break与continue
4.循环语句的嵌套
八、字符串
1.定义
2.下标索引
3.常用方法
4.特点
九、列表
1.定义
2.下标索引
3.常用方法
4.特点
5.列表的循环遍历
十、元组
1.定义
2.下标索引
3.常用方法
4.特点
5.元组的循环遍历
十一、序列的切片
十二、集合
1.定义
2.常用方法
3.特点
十三、字典
1.定义
2.Key取元素
3.常用方法
4.特点
十四、函数
1.介绍
2.函数的定义
3.函数的参数
4.函数的返回值
5.函数的说明文档
7.变量的作用域
十五、文件操作
1.文件的编码
2.文件的读取
3.文件的写入
4.文件的追加
十六、异常
1.异常的概念
2.异常的捕获
3.异常的传递
十七、Python模块
1.概念
2.模块导入方式
3.自定义模块
4.Python标准库的模块
十八、Python包
1.概念
2.自定义Python包
3.Python包的模块调用
4.第三方Python包
5.pip安装Python包
一、简介
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言；Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构；
二、环境搭建
1.python搭建环境
传送：零基础python环境搭建(详细)
2.PyCharm安装
下载网址：PyCharm：JetBrains为专业开发者提供的Python IDE
选择适用windows的社区免费版下载，下载其.exe文件；双击安装包根据提示进行安装即可安装
PyCharm常用插件
chinese language：中文语言包
translation：用于翻译不理解的英文(选中后右键即可选择翻译)
三、python基础语法
1.字面量
在代码中，被写下来的固定的值，称为字面量；如整数10、浮点数10.6、字符串“hh”等都可以称为字面量；
2.注释
#用于单行注释，三单引号''' '''和三双引号""" """用于多行注释；
a = 10
b = 6.6
# c = "haha"
c = 6
"""
print("%s" % a)
print("%s" % b)
"""
print("%s" % c)
print(666)
#输出
6
6663.变量
变量是在程序运行时，能存储计算结果或能表示值的抽象概念；
变量定义格式：变量名=变量值
a = 1
b = "haha"4.标识符
变量名、方法名、类名等统称为标识符，用于作内容的标识；
标识符命名规则：大小写敏感、不可使用关键字、内容限定(只能使用英文、数字和下划线且不能以数字开头，python也可以使用中文命名但是不推荐使用）
a1 = 10
A1 = 11
_a = 6
# 1a = 5 #使用数字开头，不符合命名规则
# for = 1 #使用关键字，不符合命名规则
print(f"{a1}\n{A1}\n{_a}")
#输出
10
11
65.运算符
算术运算符
| + | 相加，如1 + 2返回3 |
| - | 相减，如1 - 1返回0 |
| * | 相乘，如2 * 3返回6 |
| / | 相除，如4 / 2返回2 |
| // | 整除，如5 // 2返回2 |
| % |
取余，如5 % 2返回1 |
| ** | 指数，如2 ** 3返回8 |
赋值运算符
| = | += | -= | *= |
| /= | //= | %= | **= |
a = 3
b = 2
print(a+b)
print(a*b)
print(a/b)
print(a//b)
print(a**b)
a *= b
b /= a
print(a)
print(b)
#输出
5
6
1.5
1
9
6
0.33333333333333336.字符串
字符串定义方法：单引号定义法、双引号定义法、三引号定义法；
转义字符 \：当字符串本身包含引号时，为防止发生歧义需要在字符串的引号前加转义字符\，使其成为普通引号(也可以不用转义字符但需要有正确的引号层次结构)；
字符串拼接：字符串之间通过加号+拼接；
字符串格式化：%s占位格式化(将变量转换为字符串放到占位处，还有%d、%f等，%5.2f表示浮点数长5位四舍五入保留2位小数)、f"{变量}"格式化；
表达式格式化：将表达式的返回值当成变量格式化；
a = 'h'
b = "h\"h"
c = """hhh"""
d = "hh"+"gg"
print("123-%s-%s-10" % (456, 789))
print("%6.2f" % 10.77777)
print(f"{a}\n{b}\n{d}")
print(f"{1+3}--{2*3}--{type(11)}")
#输出
123-456-789-10
10.78
h
h"h
hhgg
4--6--
7.数据输入
使用input()获取键盘输入，并用变量接收键盘输入(input()的参数是输入提示，输入提示可有可无，输入值都为字符串类型，若需要变为其他类型需使用类型转换)；
a = input("输入你的名字：")
b = input("输入你的年龄：")
print(f"哦，原来你是{a}，{b}岁")
print(f"a的类型是{type(a)},b的类型是{type(b)}")
#输入输出
输入你的名字：哈哈
输入你的年龄：19
哦，原来你是哈哈，19岁
a的类型是,b的类型是
8.缩进
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}；
a = 2
if a > 0:
print(f'{a}是正数')
else:
print(f'{a}不是正数')四、数据类型
1.数据类型
| 数字(Number) | 整数(int) |
| 浮点数(float) | |
| 复数(complex) | |
| 布尔(bool) | |
| 字符串(String) | 描述文本的一种数据类型 |
| 列表(List) | 有序的可变序列 |
| 元组(Tuple) | 有序的不可变序列 |
| 集合(Set) | 无序不重复集合 |
| 字典(Dictionary) | 无序的键值对集合 |
2.数据类型查看
type(变量)可以返回变量存储的数据的数据类型，而变量本身无类型区别；
a = 10
b = 1.1
c = True
d = "haha"
e = list()
f = tuple()
print(f"{type(a)}\n{type(b)}\n{type(c)}\n{type(d)}\n{type(e)}\n{type(f)}")
//输出
3.数据类型转换
新类型(变量)可返回转换为新类型后的变量；
任何类型都可以转换为字符串，浮点型转整型只保留整数部分；
a = 10
b = 1.1
c = bool(a)
d = int(b)
print(f"c={c},c的类型为:{type(c)}")
print(f"d={d},c的类型为:{type(d)}")
//输出
c=True,c的类型为:
d=1,c的类型为: 4.数据容器
数据容器是指一种可以容纳多个数据元素的数据类型，其中数据元素可以是任意数据类型的数据，如字符串、列表、元组等都可以称为数据容器；
5.数据容器对比
| 列表 | 元组 | 字符串 | 集合 | 字典 | |
| 元素数量 | 多个 | 多个 | 多个 | 多个 | 多个 |
| 元素类型 | 任意 | 任意 | 仅字符 |
任意 | key非 字典value 任意 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 可修改性 | 可 | 不可 | 不可 | 可 | 可 |
| 数据有序 | 是 | 是 | 是 | 否 | 否 |
| 使用场景 | 可修 改可 重复 的数 据 |
不可 修改 不可 重复 的数 据 |
字符 数据 |
不可重 复的数 据 |
存在索引 的1数据 |
五、python解释器
Python解释器由编译器和虚拟机构成，编译器将源代码转换成字节码，然后再通过Python虚拟机来逐行执行这些字节码；简单来说，Python解释器就是把Python代码解释为计算机能理解的二进制数据，以实现程序的运行；
Python解释器种类较多，最常用的是CPython，它是C语言开发、使用最广、默认的解释器；
六、条件控制语句
1.布尔类型与比较运算符
| 布尔类型 | |
| True | False |
| 比较运算符 | |
| == | != |
| > | < |
| >= | <= |
非零、非空字符串和成立的表达式都为True，零、空字符串和不成立的表达式为False；
a = True
b = False
a1 = 12
b1 = 0
a2 = "hh"
b2 = ""
a3 = 1 == 1
b3 = 1 >= 0
print(f"a为{a}--a1为{bool(a1)}--a2为{bool(a2)}--a3为{a3}")
print(f"b为{b}--b1为{bool(b1)}--b2为{bool(b2)}--b3为{b3}")
#输出
a为True--a1为True--a2为True--a3为True
b为False--b1为False--b2为False--b3为True
2.if语句
if 判断条件:
条件成立时需要执行的代码
a = 19
if a >= 18:
print("你已经成年了")
#输出
你已经成年了注意：需要严格使用缩进控制代码的执行层次结构，判断条件后的冒号不可少；
3.if [elif] else语句
if 判断条件1:
执行代码1
elif 判断条件2:
执行代码2
else:
条件都不满足时需要执行的代码
a = 19
if a < 18:
print("你还是个孩子")
elif 18 <= a < 60:
print("你已经是个成年人了")
else:
print("你老了")
#输出
你已经是个成年人了注意：if语句尽管有多个执行代码块，只能执行其中一个，判断条件满足时执行对应代码后退出if语句，条件都不满足时执行else对应的代码；
4.条件语句的嵌套
a = 19
if a < 18:
print("你还是个孩子")
else:
if a < 60:
print("你已经是个成年人了")
else:
print("你老了")
#输出
你已经是个成年人了注意：缩进不能错
七、循环语句
1.while循环
while 判断条件:
只要条件成立循环执行的代码
a = 1
while a < 10:
a += 1
print(f"a={a},a>=10")
#输出
a=10，a>=102.for循环
for循环是一种轮询机制，对数据容器的元素逐个处理；而while循环是自定义循环条件的；
for 临时变量 in 数据集
对数据逐个处理的代码
a = "hello"
for i in a:
print(f"{i}-", end="") #end=""，end为空表示不换行，默认是换行的
print()
for i in range(0, 10): #range(0, 10)表示0至9的数字集，左闭右开
print(f"{i}-", end="")
#输出
h-e-l-l-o-
0-1-2-3-4-5-6-7-8-9-3.break与continue
break结束当前层的循环，continue跳过本次循环继续执行下次循环；
print("continue的结果：")
for i in range(1, 6):
if i == 3:
continue
print(f"{i}-", end="")
print("\nbreak的结果：")
for i in range(1, 6):
if i == 3:
break
print(f"{i}-", end="")
#输出
continue的结果：
1-2-4-5-
break的结果：
1-2-
4.循环语句的嵌套
#利用循环嵌套实现九九乘法表的输出
for i in range(1, 10):
for j in range(1, i+1):
print(f"{j}*{i}={j*i}\t",end="")
print()
//输出
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 八、字符串
1.定义
#可使用单引号、双引号或三引号定义字符串
str1 = 'ha'
str2 = "haha"
str3 = '''hahaha'''
str4 = """hahaha"""
print(f"{str1}\n{str2}\n{str3}\n{str4}")
#输出
ha
haha
hahaha
hahaha2.下标索引
my_str = 'hello word!'
# 下标索引正向从0开始，反向从-1开始
print(f"{my_str[0]}-{my_str[1]}-{my_str[2]}-{my_str[-1]}-{my_str[-2]}")
#输出
h-e-l-!-d3.常用方法
| 方法 | 作用 |
| 字符串[下标] | 取出字符串指定位置处的字符 |
| 字符串.index(字符) | 返回第一个与指定字符匹配的下标 |
| 字符串.replace(字符串1，字符串2) | 将字符串中的子串1全部替换为子串2 ，返回一个新字符串，原字符串不可 修改 |
| 字符串.split(字符) | 返回以指定字符分隔后的列表 |
| 字符串.strip() | 去除字符串首尾的空格和换行符 |
| 字符串.count(字符串) | 统计字符串中指定子串的个数 |
| len(子符串) | 返回字符串的字符总数 |
4.特点
可容纳多个字符、元素仅字符、数据是有序存储的(即有下标)、允许存在重复元素、数据是不可修改的；
九、列表
1.定义
# 定义列表
a1 = [1, 'ha', True]
# 定义空列表
a2 = []
a3 = list()
print(f"{a1}\n{a2}\n{a3}")
#输出
[1, 'ha', True]
[]
[]2.下标索引
a = ['ha', 23, True, [1, 2, 3]]
# 下标索引正向从0开始，反向从-1开始
print(f"{a[0]}\n{a[1]}\n{a[2]}\n{a[3]}\n{a[-1]}\n{a[-2]}")
# 容器中嵌套容器时使用多层索引取元素,字符串、列表、元组等作为容器元素时都属于容器嵌套
print(f"{a[3][0]}-{a[3][1]}-{a[3][2]}-{a[0][0]}-{a[0][1]}")
#输出
ha
23
True
[1, 2, 3]
[1, 2, 3]
True
1-2-3-h-a3.常用方法
| 方法 | 作用 |
| 列表.append(元素) | 向列表末尾追加一个元素 |
| 列表.extend(容器) | 将容器内的数据依次追加到列表末尾 |
| 列表.insert(下标,元素) | 在指定下标处插入指定元素 |
| del 列表[下标] | 删除指定下标处的元素 |
| 列表.pop(下标) | 删除指定下标处的元素 |
| 列表.remove(元素) | 从前往后删除第一个与此元素匹配的元素 |
| 列表.clear() | 清空列表 |
| 列表.count(元素) | 统计列表指定元素的个数 |
| 列表.index(元素) | 返回指定元素的下标，匹配失败则报错 |
| len(列表) | 返回列表(容器)的元素总数 |
4.特点
可容纳多个元素、元素可以为不同类型、数据是有序存储的(即有下标)、允许存在重复元素、数据是可修改的；
5.列表的循环遍历
a = [1, 4, 6, 'haha', True, [1, 2], (7, 8)]
# while循环遍历列表
index = 0
while index < len(a):
print(f"{a[index]}---", end='')
index += 1
print()
# for循环遍历列表
for i in a:
print(f"{i}__", end='')
#输出
1---4---6---haha---True---[1, 2]---(7, 8)---
1__4__6__haha__True__[1, 2]__(7, 8)__十、元组
1.定义
# 定义元组
t1 = (1, 'ha', True)
# 定义的元组只有一个元素时需要在元素后加逗号
t2 = ('haha',)
# 定义空元组
t3 = ()
t4 = tuple()
print(f"{t1}\n{t2}\n{t3}\n{t4}")
#输出
(1, 'ha', True)
haha
()
()2.下标索引
与列表类似，下标索引正向从0开始，反向从-1开始，存在容器嵌套时使用多层索引取元素；
3.常用方法
| 方法 | 作用 |
| 元组.index(元素) | 返回指定元素的下标，匹配失败则报错 |
| 元组.count(元素) | 统计容器内指定元素的个数 |
| len(元组) | 返回元组的元素总数 |
4.特点
可容纳多个元素、元素可以为不同类型、数据是有序存储的、允许存在重复元素、数据是不可修改的；
5.元组的循环遍历
与列表类似；
十一、序列的切片
序列：有序的数据集合，包括字符串、列表和元组；
切片：从序列中取出一个子序列；
语法：序列[起始下标:结束下标:步长]
my_str = 'hello word!'
# 起始下标对应的为第一个元素，结束下标减一对应的为最后一个元素，即左闭右开，步长表示每个隔步长个元素取
print(my_str[0:5:1])
# 留空表示默认取，起始下标默认为0，结束下标默认为最大下标，步长默认为1
print(my_str[:5:1])
print(my_str[0::])
print(my_str[::2])
# 步长为负数表示反向取，反向取时起始下标和结束下标也需要反向标记
print(my_str[-1::-1])
print(my_str[-1:-3:-1])
#输出
hello
hello
hello word!
hlowr!
!drow olleh
!d
#元组和列表与字符串类似，都可以切片
my_list = [12, 'hj', True, 6, 'k', False, 88]
print(my_list[1:5:1])
my_tuple = (12, 3, 'jjj', True)
print(my_tuple[-1::-1])
#输出
['hj', True, 6, 'k']
(True, 'jjj', 3, 12)
十二、集合
1.定义
# 定义集合
set1 = {1, 3, 'haha'}
set2 = {}
# 集合元素不可重复，若存在重复元素自动去重
set3 = {1, 2, 2, 'ha', 'ha'}
print(f"{set1}\n{set2}\n{set3}")
#输出
{1, 3, 'haha'}
{}
{1, 2, 'ha'}
2.常用方法
| 方法 | 作用 |
| 集合.add(元素) | 向集合中增加一个元素 |
| 集合.remove(元素) | 移除集合中的指定元素 |
| 集合.pop() | 随机返回集合的一个元素 |
| 集合.clear() | 清空集合 |
| 集合1.difference(集合2) | |
| 集合1.difference_update(集合2) | |
| 集合1.union(集合2) | |
| len(集合) | 返回集合内的元素总数 |
3.特点
不允许存在重复元素、数据是无序存储的(即无下标)；
十三、字典
1.定义
# 定义字典
d1 = {'name': '小明', 'age': 17, 'sex': '男'}
d2 = {}
d3 = dict()
# 字典的value可重复，而key不可重复，若key重复后面的key会覆盖前面的
d4 = {'name': '小红', 'age': 17, 'name': '小美'}
print(f"{d1}\n{d2}\n{d3}\n{d4}")
#输出
{'name': '小明', 'age': 17, 'sex': '男'}
{}
{}
{'name': '小美', 'age': 17}
2.Key取元素
dd = {
'name': '小明',
'age': 17,
'haha': {'name': '小美', 'age': 17},
'my_list': [1, 3, True, 'hello']
}
# 通过Key获取Value
print(dd['name'])
# 容器嵌套获取元素
print(dd['haha']['name'])
print(dd['my_list'][0:3:1])
#输出
小明
小美
[1, 3, True]3.常用方法
| 方法 | 作用 |
| 字典[Key] | 获取Key对于的Value值 |
| 字典[Key]=Value | 增加或更新键值对(Key存在更新而不存在增加键值对) |
| 字典.pop(Key) | 取出并删除Key对应的键值对 |
| 字典.clear() | 清空字典 |
| 字典.keys() | 获取所有Key，用于for循环 |
| len(字典) | 返回字典的元素总数 |
4.特点
Key不可重复、数据是无需存储的；
十四、函数
1.介绍
函数是组织好的、可重复使用的用于实现特定功能的代码段；
2.函数的定义
#普通函数的定义
def 函数名(参数): #参数和return返回值可有可无
函数体
return 返回值
#匿名函数的定义
lambda 参数 : 函数体(只能有一行代码)
def add():
a = 3
b = 4
return a + b
print(add())
def ha(hh, x, y):
print(hh(x, y))
ha(lambda x, y: x + y, 10, 4)
ha(lambda x, y: x - y, 10, 4)
ha(lambda x, y: x ** y, 10, 4)
//输出
7
14
6
10000注意：匿名函数每定义一次只能使用一次，多用于简化计算逻辑的传参
3.函数的参数
位置参数：调用函数时根据函数定义的参数位置来传参；
关键字参数：函数调用时通过键=值的形式传参；
缺省参数：缺省参数也称为默认参数，调用函数若未传递缺省参数的值时使用默认值作参数值；
不定长参数：不定长参数也称为可变参数，用于不确定调用函数时传递多少个参数的场景(*表示位置传参不定长，**表示关键字传参不定长)；
def hello(name, age, sex='男'):
print(f"{name}的年龄是{age},性别为{sex}")
hello('小明', 10, '男') # 位置参数
hello(sex='男', age=10, name='小明') # 关键字参数
hello('小明', 10) # 缺省参数
hello('小明', 10, '女') # 缺省参数可被覆盖
def t1(*args):
print(f"传入了{len(args)}个参数，它们是：{args}，以{type(args)}类型的形式传入参数")
t1('a', 123, 'b', 456, 'c', 789) # 以元组的形式传入不确定个参数
def t2(**kwargs):
print(f"传入了{len(kwargs)}个参数，它们是：{kwargs}，以{type(kwargs)}类型的形式传入参数")
t2(a=123, b=456, c=789) # 以字典的形式传入不确定个参数
#输出
小明的年龄是10,性别为男
小明的年龄是10,性别为男
小明的年龄是10,性别为男
小明的年龄是10,性别为女
传入了6个参数，它们是：('a', 123, 'b', 456, 'c', 789)，以类型的形式传入参数
传入了3个参数，它们是：{'a': 123, 'b': 456, 'c': 789}，以类型的形式传入参数 注意：位置参数必须在关键字参数前面，缺省参数可被覆盖，不定长参数传入的是存有数据元素的元组或字典；args和kwargs是规范命名而不是规则命名；
4.函数的返回值
使用return关键字返回值，若返回多个值返回值之间用逗号隔开且需要多个以逗号隔开的变量接收(无返回值时返回None类型，即空类型)；
def haha():
return 1
def ha():
return 1, 2, 3
a = haha()
print(a)
b1, b2, b3 = ha()
print(f"{b1}, {b2}, {b3}")
#输出
1
1, 2, 3
5.函数的说明文档
函数的说明文档对函数及函数参数解释说明，更有利于对函数及函数参数的理解；
def add(x, y):
"""
实现两数相加的功能 #PyCharm在定义函数中输入三个引号后回车会自动补全说明文档的格式
:param x: 相加的一个值
:param y: 相加的另一个值
:return: 返回两数相加的结果
"""
return x + y
print(add(5, 2))
#输出
76.函数的嵌套调用
在定义函数时调用另一个函数，即为函数的嵌套调用(需要注意嵌套调用后代码的执行顺序)；
def a1(x, y):
return x + y
def a2():
print(123)
print(a1(17, 6))
print(456)
a2()
#输出
123
23
4567.变量的作用域
变量作用域是指变量的作用范围，按作用范围分为局部变量(只在特定范围能生效)和全局变量(全局生效)；
a1 = 10
def test():
a2 = 10
global a1 # 在函数内部修改全局变量需要使用global关键字声明，否则会被当作新定义的局部变量
a1 = 1
print(a1) # 全局变量可在所有范围内被调用
print(a2)
# print(a2) #调用函数内部的局部变量会报错
test()
print(a1)
#输出
1
10
1十五、文件操作
1.文件的编码
编码技术是指翻译的规则，记录了内容翻译成二进制及二进制翻译回内容的规则；编码方法有UTF-8、GBK、Unicode、Big5等；UTF-8是全球通用的，一般都使用UTF-8读写文件；
2.文件的读取
| 操作 | 功能 |
| 文件对象=open() | 打开文件获取文件对象 |
| 文件对象.read(num) | 读取num字节的文件内容，缺省为整个文件 |
| 文件对象.readlines() | 返回每个元素为文件每行内容的列表 |
| for line in 文件对象 | 返回每行为一个元素的列表 |
| 文件对象.close() | 关闭文件对象 |
| with open() as 文件对象 | 操作文件后可自动关闭文件 |
# 打开文件获取文件对象
# f = open('1.txt', 'r', encoding='UTF-8') #可使用文件的相对路径或绝对路径
# 读取文件指定字节数的内容
# print(f.read()) #读取文件后下次读取时从上次读取结束位置开始读取
# 读取文件全部内容
# print(f.read())
# 读取文件全部行，返回元素为行内容的列表
# print(f"内容为：{f.readlines()}，类型是：{type(f.readlines())}")
# for循环读取文件行
# for line in f:
# print(line)
# 关闭文件
# f.close()
# 使用如下格式读取文件后可自动关闭文件
# with open('1.txt', 'r', encoding='UTF-8') as file:
# for line in file:
# print(line)3.文件的写入
# 打开文件获取文件对象，w模式文件存在重写文件，文件不存在先创建再写文件
f = open('1.txt', 'w', encoding='UTF-8')
# 写入文件
f.write('hello world!') # 实际上只是写入到了缓存区，并未真正写入文件
# 刷新内容
f.flush() # 刷新内容，将写入缓存区的内容写入文件，可减少对硬盘的操作
# 关闭文件
f.close() # close()方法内置了flush()方法
4.文件的追加
# 打开文件获取文件对象，a模式文件存在在文件末尾追加写入，文件不存在先创建再写文件
f = open('1.txt', 'a', encoding='UTF-8')
# 写入文件
f.write('\na ha ha ha')
# 刷新内容
f.flush()
# 关闭文件
f.close()
十六、异常
1.异常的概念
当程序检测到错误时，Python解释器就会停止执行，出现错误提示，这就是异常，也称为Bug；
Bug的诞生：1945年9月9日下午三点，马克二型计算机无法正常工作，技术人员最后发现是一只飞蛾导致继电器异常，进而导致计算机无法工作，此后，引发软件失效的缺陷便称之为Bug；
# 打开文件获取文件对象，r模式只能打开存在的文件
f = open('1.txt', 'r', encoding='UTF-8') #r打开不存在的文件会产生异常
# 关闭文件对象
f.close()
#输出
Traceback (most recent call last):
File "E:\python Project\1.py", line 2, in
f = open('1.txt', 'r', encoding='UTF-8')
FileNotFoundError: [Errno 2] No such file or directory: '1.txt'
2.异常的捕获
捕获异常的作用在于 提前假设某处会出现异常并做好提前处理方法，当异常真正出现时，程序能正确处理而不是中断程序的运行；
try:
可能发生的错误代码
except:
出现异常时执行的代码
[else:]
无异常时执行的代码
[finally:]
有无异常都要执行的代码
# 简单的异常捕获
# try:
# # 可能出现异常的代码
# f = open('1.txt', 'r', encoding='UTF-8')
# except:
# # 出现异常后执行的代码
# f = open('1.txt', 'w', encoding='UTF-8')
# else: # else表示没有出现异常时执行的代码，可有可无
# print('没有出现异常‘)
# finally: # finally表示不管有无异常都要执行的代码，可有可无
# f.close()
# f.close()
# 捕获指定异常
# try:
# print(haha)
# except NameError as e: # 未指定的异常不会被捕获，若出现将导致程序的终止
# print('出现了变量未定义的异常')
# print(e) # e是自定义表示异常的对象
# 捕获多个异常
# try:
# print(1/0)
# except (NameError, ZeroDivisionError) as e:
# print('出现了变量未定义的异常或零计算异常')
# print(e)
# 捕获所有异常
# try:
# f = open('1.txt', 'r', encoding='UTF-8')
# except Exception as e:
# print('出现了异常')
# print(e)
3.异常的传递
当存在异常的函数被不存在异常的函数调用时，在不存在异常的函数中作处理是可以捕获到异常的，这就是异常的传递性；
def a1():
print(haha)
def a2():
try:
a1()
except NameError as ee:
print(f'捕获到了异常\n异常为：{ee}')
a2()
#输出
捕获到了异常
异常为：name 'haha' is not defined
十七、Python模块
1.概念
Python模块(Module)是.py文件，其中能定义函数、类和变量，也可以包含可执行代码；调用不同的模块可以之间使用其中的函数、类等，更加方便代码功能的实现；
2.模块导入方式
[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]
# 导入Python内置的time模块(即time.py文件)
# import time
# time.sleep(5) # 调用模块内的函数
# 导入time模块中的sleep()函数，time模块中只有sleep()函数能被使用
# from time import sleep
# sleep(10) # 调用导入的函数
# 导入time模块的全部内容(*号表示全部内容)
# from time import * # 与import time的区别是调用模块内的内容时格式不同，如time.sleep()和sleep()
# sleep(5)
# 给导入的模块取别名，当模块名过于复杂时使用模块别名更加方便
# import time as t
# t.sleep(5)3.自定义模块
导入自定义模块即导入自定义的个性化.py文件；
# 自定义模块my_module.py
# __all__ = ['a1'] # 表示调用该模块时可被使用的内容，若无__all__声明默认所有可以被使用
# 这两个函数可在导入该模块后使用
def a1(x, y):
return x + y
def a2(x, y):
return x - y
if __name__ == '__main__': # 表示只能在当前文件执行的代码，可有可无
print(a1(3, 4))
print(a2(3, 4)) # 该模块被调用时会自动执行可执行代码
4.Python标准库的模块
os 模块：
os 模块提供了许多与操作系统交互的函数，例如创建、移动和删除文件和目录，以及访问环境变量等。
sys 模块：
sys 模块提供了与 Python 解释器和系统相关的功能，例如解释器的版本和路径，以及与 stdin、stdout 和 stderr 相关的信息。
time 模块：
time 模块提供了处理时间的函数，例如获取当前时间、格式化日期和时间、计时等。
datetime 模块：
datetime 模块提供了更高级的日期和时间处理函数，例如处理时区、计算时间差、计算日期差等。
random 模块：
random 模块提供了生成随机数的函数，例如生成随机整数、浮点数、序列等。
math 模块：
math 模块提供了数学函数，例如三角函数、对数函数、指数函数、常数等。
re 模块：
re 模块提供了正则表达式处理函数，可以用于文本搜索、替换、分割等。
json 模块：
json 模块提供了 JSON 编码和解码函数，可以将 Python 对象转换为 JSON 格式，并从 JSON 格式中解析出 Python 对象。
urllib 模块：
urllib 模块提供了访问网页和处理 URL 的功能，包括下载文件、发送 POST 请求、处理 cookies 等。
十八、Python包
1.概念
当模块太多时不方便管理，需要使用Python包；Python包相当于一个文件夹，其内包括多个模块.py文件和__init__.py文件(Python包必不可少的)
2.自定义Python包
在PyCharm项目处右键选择创建Python包即可，成功创建的Python包目录下会自动生成__init__.py文件
# __init__.py文件
# 可控制Python包内可以被导入的.py模块，无__all__声明则全部模块可被导入
__all__ = ['my_module']3.Python包的模块调用
# 调用自定义Python包中的模块
import my_packge.my_module as h
print(h.a2(3, 4))
4.第三方Python包
Python包包含许多模块，模块包含许多功能；为实现更多的功能，提高开发效率，在Python程序的生态中产生了非常多的第三方包(非官方的)；
5.pip安装Python包
第三方Python包是非官方的，Python没有内置，需要自己安装第三方Python包；
安装方式1：
命令行输入pip install 包名称
安装方式2：
在Pycharm的python解释器设置中安装Python包