python-12 数据类型

数据类型（常用）：

• string（字符串）
• int(整型)
• float（浮点型）

检测数据的类型的语句：

type(被检测类型的数据)

作用：a.查看字面量 b.查看变量

变量无类型，但它存储的数据有类型

python-13 数据类型转换

数据类型转换：

input（）
获取的输入默认为字符串类型

• 任何类型都可以转换为字符串
• 字符串内必须全部是数字，才能转化为数字

print(float(123))  #整数转浮点数不会丢失精度
print(int(12.34))  #浮点数转整数会丢失精度

python-14 命名规则

标识符：用户在编程的时候使用的一系列名字，用于给变量、类、方法等命名。

命名规则:

• 内容限定:只允许出现英文、中文（不推荐使用）、数字（不能开头）、下划线
• 大小写敏感
• 不可使用关键字

变量的命名规范：

• 见名知意
• 简洁（短）
• 多个单词组合变量名，使用下划线做分割
• 英文字母全部小写

python-15 运算符

运算符：

• 算术运算符 : // 取整除 **指数
• 赋值运算符=
• ？= 复合赋值运算符 （？为任何算术运算符）

python-16 字符串

字符串的三种写法

• 单引号
• 双引号
• 三引号

三引号的使用：如果没有变量接受它，就是注释；有变量接受它，就是字符串。
适用于包含单双引号的字符串

扩展转义字符：

如果转义字符后的符号有特殊功能，加上转义字符就没有了 如："\"\"" 输出为 ""

如果转义字符后的符号无特殊功能，加上转义字符就有了 如：\n换行

python-17 字符串的拼接

字符串的拼接

用加号（+）拼接字符串，用逗号（，）拼接会有空格

补充：字符串*数字 是将多少个字符串拼接到一些

python-18

括号里的内容是一个整体，哪怕中间换行，也是一个整体

python-19 字符串格式化

字符串格式化：

语法：

“%占位符” %变量
“%占位符%占位符%占位符”%（变量，变量，变量）

• %s以字符串的格式进行占位，并且多个变量用括号括起来，按顺序对应，并且其他格式是自动转化为字符串的
• %d 将内容转化为整数型，放入占位位置
• %f 将内容转化为浮点型，放入占位位置

python-21 格式化的精度控制

格式化的精度控制:

m.n

• m 控制宽度，要求是数字（很少使用）。设置的宽度小于数字自身，不生效；设置的宽度大，会补在前面空格。有利于输出对齐。
• .n 控制小数点的精度，要求是数字，会进行小数的四舍五入，但整数不生效。

python-22 字符串拼接

字符串格式化（字符串拼接）的快速写法：

f"内容{变量}" 不理会类型，不做精度控制，原样输出

python-23

补充：可做精度控制，但没有四舍五入

如： f"内容{变量：精度}"

print(f"年龄是{height:6.2f}岁")

python-24 表达式格式化

对表达式进行格式化：

表达式：一条具有明确结果的代码语句

f"{表达式}"

"%s%d%s" % {表达式，表达式，表达式}

python-26（基础语法结束）

input()语句：获取键盘的输入，默认是字符串类型的

print（）语句：数据输出

python-27 字符串比较

布尔类型（数字类型的一种）：

• True (真，1)
• False(假，0)

比较运算符：

== （判断是否相等）
！=（判断是否不相等）
> >= < <= （判断是否大于、大于等于、小于、小于等于）

字符串比较：

按位比较

• 小写>大写>数字 有内容>无内容
• 非中文字符主要参考ASCII码表
• 中文字符参考UTF8

python-28 逻辑运算符

逻辑运算符：

• 与AND（and）：多条件同时满足则为True,否则为False
• 或OR(or)：多条件至少满足一个为True,否则为False
• 非NOT(not)：取反结果

python-29 if语句

if语句的基本语法格式：

if  条件：
      条件成立，则执行

注意：归属关系，前方缩进4个空格

python-30 if-else语句

if  条件：
    条件成立，则执行
else：#（就近原则）
    条件不成立，则执行

python-33 if-elif-else语句

• 全部都满足，只执行第一个（先执行的那个）
• 互斥且有序

if  条件1: #（条件里可以直接写input语句）
    满足条件1，需执行
elif 条件2：
    满足条件2，需执行
elif 条件N：
    满足条件N，需执行
else：
    所有条件都不满足，需执行    

python-35 if语句的嵌套使用

if语句的嵌套使用：满足前置条件才会二次判断

多条件多层次的判断，注意缩进。

python-36

注意多次嵌套写流程图理清思路

python-37 循环语句

循环语句

while 条件表达式：

   条件满足时，需执行。

条件不满足时，跳出循环。

控制循环在有限次数内执行，有三个要素：

1. 循环控制因子（某个变量）
2. 循环控制条件（基于因子做判断）
3. 循环因子更新（修改因子的值）

python-38 while循环的嵌套

while循环的嵌套：基于空格缩进决定层次关系
避免无限循环

python-39

print（"输出内容"，end=""）输出不换行

end 是参数 默认值是\n 换行

制表符 \t 对齐后面的 按照四个空格对齐

Tab 每次也是按四个空格对齐

python-40 for循环

• while循环条件是自定义的，自行控制循环条件
• for循环 轮询（遍历）机制，对一批内容进行逐个处理

语法：

for 临时变量 in 待处理数据集(可迭代对象)：

  循环满足条件时执行的代码

字符串可以被循环使用，逐个遍历。

python-42 可迭代类型

可迭代类型：可迭代对象，其内容可以一个个依次取出的一种类型

1. 字符串
2. 列表
3. 元组
4. range语句
   获得一个简单的数字序列

语法1：
range（num）（不含num本身）
获取一个从0开始，到num结束的数字序列

语法2：

range（num1，num2）
从num1开始到num2结束的数字序列 （包头不包尾）

语法3：
range（num1，num2,step）
从num1开始到num2结束的数字序列（包头不包尾）数字之间的步长以step为准，平时不写的时候默认为1

~【】在描写语法时表示：可选

python-43 变量的作用域

变量的作用域：

for循环中的临时变量，其作用域限定为循环内

这种限定：

编程规范的限定，而非强制限定

不遵守也能运行，但是不建议

如需访问临时变量，可以预先在循环外定义它

python-46 循环中断

循环中断：

• continue暂时跳过某次循环，直接进行下一次
• break提前退出循环，不再继续
• continue 和 break 都只对 for 和 while 生效

对于嵌套循环，只对当前所在循环有效

python-47 函数

函数：
（1）提前组织好的（写好的）
（2）可以重复使用的
（3）实现特定功能的

好处：

• 将功能封装在函数内，可供随时随地地重复利用
• 提高代码复用性，减少重复代码，提高开发效率

python-48 函数基础定义语法

基础定义语法：

def  函数名（传入参数）

      函数体

      return 返回值

函数的调用：函数名（参数）

注意：

• 参数不需要可以省略
• 返回值不需要可以省略
• 函数必须先定义后使用

python-49 函数参数

传入参数：在函数进行计算的时候，接受外部（调用时）提供的数据

• 形式参数，即:def add(x,y)：这个x和y是形式参数，没有实体，是一种声明，没有限制数据的类型
• 实际参数，即：add（10,20）这里的10和20称之为实际参数（实参）
  是因为在函数的声明要求下，调用的时候，真的传递了符合要求的数据，实际参数是真实存在的

传入实际参数的类型不受限制，随意传，但是能不能跑看具体代码

传入参数的数量不限制，但需一一对应

python-50 函数返回值

函数返回值：程序中的函数完成事情后，最后给调用者的结果

语法格式：

def  函数（参数）

       函数体

       return  返回值

变量 = 函数（参数）

函数体遇到return后就结束了，return 后的代码不会执行

None类型：
无返回值的函数，实际上就是返回了None这个字面量

在if判断中，None等同于False

1.None可用来设置判断函数

在python里，只要不是0，False,None,空字符串，其余都是True

2.None可用来初始化变量

当使用变量的时候，初始化的值没有任何要求，可以用None代替

python-51 函数说明文档

函数说明文档：对函数进行说明解释，帮助更好地理解函数的功能

param(parameter)参数的缩写

定义语法：

def add3(x,y):
    """
    这个函数的功能是实现两个数相加
    :param x: 相加的第一个数
    :param y: 相加的第二个数
    :return:  相加的结果
    """
    return x + y

python-52 函数的嵌套调用

函数的嵌套调用：一个函数里面又调用了另外一个函数

基本原则：遇到函数就进入执行，执行完成后再回到当初的位置继续向下

python-53 变量的作用域

变量的作用域指的是变量的作用范围（变量在哪里可用，哪里不可用）
分为：

1. 局部变量
2. 全局变量

局部变量：定义在函数体内部的变量，即只在函数体内部生效
作用：在函数体内部，临时保存作用，即当函数调用完成后，则销毁局部变量

全局变量：在函数体内、外都能生效的变量

global关键字：在函数内部修改全局变量的值

global  变量名

python-54

\t对齐的原理是四个一对齐

python-55 数据容器

数据容器：

一种可以容纳多份元素数据（任意类型）的数据类型

• 列表（list）
• 元祖（tuple）
• 字符串（str）
• 集合（set）
• 字典（dict）

列表：

基本语法：

字面量：【元素1，元素2，元素3……】

定义变量：变量名称 = 【元素1，元素2…】

定义空列表：

变量名称  =  【】
变量名称  =  list()

列表内的每一个数据，称之为元素

嵌套列表的定义：列表中的元素，仍然是列表

python-56 列表索引

列表的下标（索引）：

正向索引： 序号从零开始

语法：

列表【下标/索引】（取出相应的元素）

注意：下标索引的取值范围，超出范围无法取出元素，并且会报错（-0 = +0 =0）

反向索引：从后往前，从-1开始

嵌套列表的下标：

下标有两个层级（list【1】【0】）

python-57 函数方法

如果将函数定义为class（类）的成员，那么函数就会称之为方法

方法和函数的功能一样，有传入参数，有返回值，只是方法的使用格式不同

调用方法：对象名.方法名（参数）

列表的常用操作（方法）：

列表的查询功能:查找指定元素在列表的下标

语法：列表名.index（元素）

index就是列表对象（变量）内置的方法（函数）

无法找到对应的下标的情况下：

快捷操作：确定某个元素是否在列表内

语法：元素 in 列表变量

在里面给Ture ,不在里面给False

列表的修改功能：

修改特定位置（索引）的元素值：

语法：列表[下标] = 值（修改，重新赋值）

正向和反向下标都可以

插入元素：

在指定的下标位置，插入指定的元素

语法：列表.insert(下标，元素)

当下标的值超出索引的范围，则相当于在尾部插入新元素

追加元素方式1：

将指定元素，追加到列表的尾部

语法：列表.append(元素)

注意：只能追加一个元素

追加元素方式2：

将其他数据容器中的内容取出，依次追加到列表尾部

语法：列表.extend（其他数据容器）

在尾部 加一批

删除元素：

1. 语法1：del 列表【下标】
2. 语法2： 列表.pop(下标)

第二种方式有返回值，返回的是，被删除的元素

删除某元素在列表中的第一个匹配项：

语法：列表.remove（元素）

如果删除元素不存在则报错

清空列表内容：

语法：列表.clear()

统计某元素在列表内的数量：

语法：列表.count（元素）

统计容器中共有多少元素：

语法：len(列表)

列表的特点：

1. 空间容量大
2. 可以容纳不同类型的元素（混装）
3. 数据是有序存储的（有下标序号）
4. 允许重复数据存在
5. 可以修改（增删）

python-58 列表的遍历

遍历（迭代）：将容器中的元素依次取出进行处理的行为

列表的遍历：

while 循环：可无限循环

index = 0           #循环控制因子
while index < len(lst):  #判断条件
    print(lst[index])  
    index += 1    #更新循环控制因子

for循环：有限循环

语法：

for 临时变量 in 数据容器
    对临时变量进行处理

python-59 元组

元组：一旦定义完成，就不可修改

适用于不希望封装的数据被篡改的

元组的定义：

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的类型

定义元组字面量：

(元素，元素，元素，元素，元素)

定义元组变量：

变量名称 =（元素，元素，......元素）

定义空元组：

变量名称 = （）
变量名称 = tuple()

注意：元组中只有一个元素需要带逗号

• 元组也支持嵌套
• 元组也有下标，可以通过元组名【下标】取值

元组的相关操作：

index（）查找某个数据对应的下标，查不到报错

count（）统计某个数据在当前元组出现的次数

len(元组) 统计元组内元素的个数

对应练习：
Python-59-元组的基础语法和特点 P61 - 09:29

注意：

• 不可以修改元组的内容，否则会直接报错
• 可以修改元组内list的内容，不可以替换list为其他list或其他类型

对应练习：
Python-59-元组的基础语法和特点 P61 - 13:10

元组的遍历：

for循环 或 while循环

对应练习：
Python-59-元组的基础语法和特点 P61 - 28:15 元组的遍历

元组的特点：

基本同list，但是元组内的元素不可修改

python-60 字符串

字符串：一个无法修改的存放字符的数据容器 （标志）" " """ """ ' '

注意：字符串中的元素无法修改，但是字符串整体变量可以重新赋值

字符串的下标（索引）：【】

（正向）从前向后，下标从0开始；（反向）从后到前，下标从-1开始

对应练习：
Python-60-数据容器字符串的操作 P62 - 02:35 字符串的操作

字符串的常用操作：

查找：查找指定字符串的下标索引，找不到则报错

语法：字符串.index(字符串)

对应练习：
Python-60-数据容器字符串的操作 P62 - 07:58 查找指定字符串的索引

字符串的替换：

语法：字符串.replace（字符串1，字符串2）

功能：将字符串内的全部：字符串1 替换成字符串2

注意：不是修改字符串本身，而是得到一个新的字符串

对应练习：
Python-60-数据容器字符串的操作 P62 - 09:19 字符串的替换

字符串的分割：

语法：字符串.split(分隔符字符串)

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到一个列表对象

字符串的规整操作：
语法：
1.字符串.strip() 去除前后空格和回车符
2.字符串.strip(字符串) 去除前后指定字符串

注意：
1、传入的字符串的所有都会移除，按照单个字符算
2、没有修改字符串本身，而是形成新的字符串

比如：传入12，则1和2 都会被移除

统计字符串中某字符串出现次数：

语法：字符串.count(字符串)

统计字符串的长度：

语法：len（字符串）

可以看出：数字、字母、符号（包括空格）和中文均算作一个字符

字符串：只可以存贮字符串且不能修改

python-61 序列

序列的切片语法：

序列：内容连续，有序，可使用下标索引的一类数据容器

如：列表、元组、字符串

序列的常用操作—切片：

切片：从一个序列中，取出一个（新的）子序列（不影响旧序列）

语法：序列【起始下标：结束下标：步长】

表示从序列中从指定位置开始，依次取出元素，到指定位置结束，得到一个序列

• 起始下标：可以留空，留空视作从头开始
• 结束下标（不含）：可以留空，留空视作截取到结尾
• 步长：依次取元素的间隔 默认为1
  步长1：一个个取
  步长2：表示隔一个取一个
  步长N：表示隔N-1个取一个
  步长为负数：表示反向取（注意：起始下标和结束下标也要反向标记）先看正向反向

python-62 集合

集合的定义：可修改、不重复、无序

定义集合字面量：{元素，元素......}

定义集合变量：变量名称={元素，元素......}

定义空集合：变量名称=set（）

注意：{}表示空字典

集合可以自动去重，并且是无序的

集合的常用操作：

修改（集合可被修改）：

由于集合是无序的，故不支持下标索引访问

添加新的元素：

将指定元素添加到集合内

语法：集合.add(元素)

移除元素：

将指定元素，从集合内移除

语法：集合.remove(元素)

从集合中随机取出（一个）元素：

语法：集合.pop()

清空集合本身：

语法:集合.clear()

取出2个集合的差集：

取出集合1和集合2的差集（集合1有但集合2没有的）

语法：集合1.difference(集合2)

结果：得到一个新集合，集合1和集合2不变

消除两个集合的差集：

在集合1中，删除与集合2相同的元素

语法：集合1.difference_update(集合2)

结果: 集合1被修改，集合2不变

2个集合的合并：

将集合1和集合2组成新的集合

语法：集合1.union(集合2)

结果:得到新的集合，集合1和集合2不变

查看集合的元素数量：统计集合中有多少个元素

语法：len（集合）

结果：返回一个整数结果

for循环遍历：

集合不支持下标索引，所以也就不支持使用while循环

python-63 字典（映射）

字典的定义：{} 存储的是键值对（Key Value)

定义字典字面量：

{key:value,key:value,key:value,key:value......}

定义字典变量：

my_dict = {key:value,key:value,key:value......}

定义空字典：

my_dict = {}
my_dict = dict()

重要语法：

• 字典中的每个元素都是一个键值对
• key和value可以是任意类型的数据（key不可以是字典）
• key不可重复，重复会覆盖原有的值

字典数据的获取：

通过key值来寻找对应的value

如：my_dict【1】 是寻找以1为key值的value，不是找下标为1的键值对

字典的嵌套：

key一般为字符串或整数，不可为字典

value任意，字典、整数、浮点数、列表、元组、集合等

嵌套字典内容的获取：

字典名【key】

【根据实际情况】

python-64 字典的常用操作

新增元素：字典被修改，新增了元素

语法：字典【key】=Value （key不存在）

更新元素:字典被修改，元素被更新

语法：字典【key】=Value （key存在）

删除元素：字典被修改，指定key的数据被删除，返回对应的value值

语法：字典.pop(Key)

清空字典：字典被修改，元素被清空

语法：字典.clear()

获取全部的key：

语法：字典.keys()

遍历字典：不支持while循环

语法：for key in 字典.keys()

计算字典内的全部元素（键值对）数量：返回一个整数

语法：len（字典）

字典的特点：

1.支持修改，不支持下标索引的多个不同类型的数据（键值对）

2.通过key获取value，key不可重复

3.支持for循环，不支持while循环

python-66 数据容器的总结

数据容器的分类：

是否支持下标索引：

• 支持：列表、元组、字符串 ——序列类型（可切片）
• 不支持：集合、字典 ——非序列类型（不可切片）

是否支持重复元素：

• 支持：列表、元组、字符串 ——序列类型
• 不支持：集合、字典 ——非序列类型

是否可以修改：

• 支持：列表、集合、字典
• 不支持：元组、字符串

数据容器的通用操作：

遍历：

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

通用的统计功能：

• len（数据容器） 统计容器的元素个数
• max（数据容器）统计容器的最大元素
• min（数据容器）统计容器的最小元素

容器的通用转换操作：

1. list（容器） 将指定容器转换为列表
2. str（容器）将指定容器转换为字符串
3. tuple（容器）将指定容器转换为元组
4. set（容器）将指定容器转换为集合
5. dict字典格式太过复杂，没法强制转换

容器的通用排序功能：

sorted（容器，[reverse=True]）给容器进行排序

注意：排序后都会得到list对象

python-67 字符串比较大小

ASC码表：

在程序中，字符串所用的所有字符如：

• 大小写英文单词
• 数字
• 特殊符号

都有其对应的ASCⅠⅠ码值。

字符串的比较，是对符号对应的码值进行比较。

注意：一个一个字符比较

1. 中文比较根据UTF8 或GBK编码表
2. 英文系列可以记忆：
   小写字母大于大写
   大写字母大于数字
3. 有内容大于空

python-68 函数进阶

函数多个返回值：

def test_return():
    #返回了（1,2）的元组,本质返回的是一个数据
    return 1, 2
#自动解包，将元组的两个元素赋值给x和y
x, y = test_return()
print(x,y)          #返回1 2
print(x)            #返回1
print(y)            #返回2
x = test_return()   #接收的是一个元组
print(x,type(x))    #返回（1,2） <class 'tuple'>

1，按照返回值的顺序，写对应顺序的多个变量接收即可
2，变量之间用逗号隔开
3，支持不同类型的数据

python-69 函数的传参方式

一、位置参数

调用参数时根据函数定义的参数位置来传递参数。

传递的参数和定义的参数的顺序及个数必须一致

二、关键字参数

函数调用时通过“键=值”形式来传递参数。（可不考虑顺序）name = “李明”

可以混用，但是位置参数在前，关键字参数在后

三、缺省参数（默认参数）

缺省参数：用于定义函数，为参数提供默认值，调用该函数时可不传该默认参数的值

调用函数时，不传就会使用默认参数的值，传参的话，就会覆盖默认值。

混用：在函数定义时，默认值参数必须在非默认值参数的右侧

四、不定长参数（可变参数）

用于不确定调用的时候会传递多少个参数（不传参也可以）的场景

类型：位置传递和关键字传递

位置传递：注意位置

def fun(name,*xxx):
    """
    *是不定长参数的标记，表示收集全部参数到元组中，*xxx一般写成*args
    """
    print(f"我们是{name},我们的成员有：")
    for i in xxx:
        print(i)
    print(type(xxx))
fun("TFBOYS","王俊凯","王源","易烊千玺")

关键字传递：参数是“键=值”的形式，所有的键值对都会被接收，然后组成字典。

def fun2(name,**kwargs):
    print(type(kwargs))   
    print(name,kwargs)    
    """  **是不定长关键字传递的标志
输出：lili {'id': 1, 'age': 11, 'gender': '男', 'addr': '深圳'}
    """
#本质上我们传递的是KV键值对，被收集到kwargs这个字典内
fun2("lili",id=1,age=11,gender="男",addr="深圳")

python-70 函数传参练习题

• 注意不定长元组，输出的时候用循环遍历
• 不定长字典，输出的时候用循环遍历

python-71 函数作为参数传递

函数本身作为参数，传入另一个函数中进行使用

计算逻辑的传递而不是数据的传递

def func(compute):
    #被计算数据固定为1和2，要计算的逻辑取决于传入的compute
    result = compute(1,2)+compute(3,4)
    return result
def compute(x,y):
    return x+y
print(func(compute))

应用（函数编程）：数据处理流程固定，但是数据的计算是可以改变

python-72 lambda表达式匿名函数

函数定义：

def关键字：定义带有名称的函数

lambda关键字：定义匿名函数（无名称）

有名称的函数：基于名称重复使用

无名称的匿名函数：只可临时使用一次

匿名函数定义语法：

lambda 传入参数：函数体（一行代码）

def func(compute):
    #被计算数据固定为1和2，要计算的逻辑取决于传入的compute
    result = compute(1,2)
    print(result)
#def compute(x,y):
#    return x+y
#func(compute)
func(lambda x,y:x+y)  #与上面三句的作用相同

python-73 文件编码

编码技术：
翻译的规则，记录了如何将内容翻译成二进制，以及如何将二进制翻译回可识别内容

编码：规则的集合，记录内容与二进制的转换逻辑

默认：UTF-8

python-74 文件的打开读取关闭

文件：长久地保存在我们计算中的数据

文件操作：打开、读写、关闭

open（）函数：打开一个已经存在的文件，或者创建一个新文件

open（name，mode，encoding）

name：打开的目标文件名的字符串（可包含文件所在的路径）

mode：设置打开文件的访问模式：只读（r）、写入（w）、追加（a）

encoding：编码格式（推荐UTF-8）

f = open（name，"mode"，encoding）

f是open函数的文件对象（类），对象是python中的一种特殊的数据类型，拥有属性和方法，通过对象.属性（方法）进行访问。

• 相对路径：相对于当前文件夹下的文件名（它的旁边有没有）
• 绝对路径：完整路径，一般从C盘、D盘开始的

read()方法：

文件对象.read(num)

num 表示要从文件中读取的数据长度（单位是字节），默认是读取文件中的所有数据

readlines（）方法

按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素

readline（）一次只读取一行
对象.close（） 关闭文件

文件操作： 先打开文件（必须有）-读写操作-关闭文件（必须有）

不关闭文件的话，文件会一直被占用

python-75 文件的打开读取关闭

通过for循环读取对象：

for line in open("test.txt","r",encoding="utf-8"):
    print(line.strip())

#这三个步骤都集成了 open打开文件 for循环读取行 for循环结束会自动close

读操作相关方法：

with open（） as f:

以这种语法写，文件会自动关闭，即自动调用close

with open("test.txt","r",encoding="utf-8") as f:
    #文件处理
    for line in f:
        print(line.strip())
#在python中任何with xxx as xx: 的写法，都可以不用调用close

python-77 文件的写入（w）操作

write（）覆盖写操作：

1、打开文件

2、文件写入

3、内容刷新

#1、打开   w 文件存在则清空重新写 文件不存在则创建新文件
f = open('D:\Python\hi.txt','w',encoding="utf-8")
#2、将helloworld写入文件
#write函数表示将内容写入到缓冲区
f.write("hello world")
#3、将缓冲区内的内容，写到硬盘（文件）中
f.flush()
#4、关闭
f.close()

直接调用write(多次)，内容并未真正写入文件，会积攒在程序的内存中，称为缓冲区
当调用函数flush（）的时候，内容才会真正写入文件（硬盘）
因为硬盘是低速设备，所以会进行批量写入，一次写一次，速度慢。

注意：
w模式
如果文件不存在，会创建新的文件
如果文件存在，会将原有内容清空

close（）自带flush（）功能

python-78 文件的a模式写入

a（append追加写）模式：

文件不存在会创建，文件存在会在最后追加

函数write（）不自带换行功能（\n）

python-79 【扩展】b模式操作非文本文件

只有文本模式用 r w a

非文本文件必须带有b,以二进制模式处理（读取01操作）

-b 二进制处理 （rb、wb、ab）

注意：

二进制读写是直接进行字节读写，不需要加encoding参数，加了反而报错

python-80 文件操作综合练习题

数据备份：复制一份

数据清洗：筛选

python-81 异常（bug）

异常就是程序运行的过程中出现了错误。

debug消除异常

python-82 异常（bug）的捕获语法

捕获异常的作用：

提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。

基本语法：

try：

 可能出现错误的代码

except：

  如果出现异常执行的代码

捕获指定异常：（只对指定异常有效）

try:

可能出现错误的代码

except NameError（异常类型） as e（变量）：（给异常类型起个别名e）

 如果出现异常执行的代码

捕获多个指定异常：（括号里写多个异常）

try：

可能出现错误的代码

except （NameError,ZeroDivisionError）as e:

 如果出现异常执行的代码

注意： 可以捕获多个异常，但是没法区分

捕获多个异常并进行区分：

#可以捕获多个异常，并进行区分
try:
    open("ask",'r')
except ZeroDivisionError as e:
    print("除以0异常",e)
except FileNotFoundError as e:
    print("文件没找到",e)

捕获全部异常（不管是什么异常，只是想抓住而已）：

#抓住全部异常，不区分具体是哪个异常
try:
    open("ask",'w')
#Exception包括了全部的异常
except Exception as e:
    print("出问题了，问题是：",e)

没有抓住异常也可以有处理（else）：可选

try:
    open("ask",'a')
except Exception as e:
    print("出问题了，问题是：",e)
else:
    print("一切正常")

不管有没有异常必须做的事情（finally）：可选

try:
    1/0
except Exception as e:
    print("出问题了，问题是：",e)
else:
    print("一切正常")
finally:
    print("无论是否有异常，我都会执行")

python-83 异常的传递性

异常会在函数调用中一层一层地传递，直到被捕获（在顶层）的时候

注意：当所有函数都没有捕获异常的时候，程序就会报错

python-84 模块的导入语法

模块的定义：

• 一个python文件，以.py结尾；
• 能定义函数、类、变量；
• 模块里也能包含可执行代码。

作用：快速实现一些功能，相当于工具包

模块在使用前需要先导入，语法：

【from  模块名】import【模块|类|变量|函数|*】【as 别名】

1 import 模块名

基本语法：

import 模块名
import 模块名1，模块名2 
模块名.功能名（）

2 import 模块名 as 别名

给太长的模块名起一个别名，方便使用

别名.功能名（）

3 from 模块名 import 功能 【as 别名】

导入某个模块中的某个功能

使用：功能名（）

可选：给功能名起一个别名

4 from 模块名 import *

导入模块中的全部功能，都可以直接使用 功能名（）

python-85 自定义模块

如何自定义模块？

在B文件中，写函数，写变量
然后在A文件中引用（用以上方法）

测试模块：（python 内置变量）

#如果本文件被直接执行，则内置变量__name__会被赋值为：__main__
#如果本文件被import或from导入，则内置变量__name__会被赋值为文件名称
#__name__是python内置变量，任何代码文件都有
#我们可以通过读取这个变量的值，从而确定这个代码文件是被人导入了，还是被作为程序执行了
if __name__ == '__main__':
    say_hello()
    say_goodbye()
如果导入重名的功能，则后来导入的生效

#__all__是内置python变量，默认是*
#如果你给一个列表，列表内写上函数名称
#可以控制这个文件（模块）被from 。。。import *的时候，哪些函数可以导入
__all__ = ['wangwang','say_hello']

python-86 python包

python包（Package）

• 从物理上看，包是一个文件夹，在该文件夹下包含了一个__int__.py文件，该文件夹可用于包含多个模块文件
• 从逻辑上看，包的本质依然是模块

作用：包里包含多个模块文件，帮助我们管理模块文件

导入包(方式一)：

导入：import 包名.模块名
使用：包名.模块名.目标

方式二：

导入：from 包名 import *
使用：模块名.目标

注意：必须在’__init__.py’文件中添加’__all__ = [ ]'，控制允许导入的模块列表

#在包里面的__init__.py中 __all__内置变量默认是None

python-87 安装第三方包

一个包就是一堆同类型功能的集合体
第三方包：非Python官方内置的包，可以安装它们扩展功能，提高开发效率

安装方法：pip install 包名称