1 Python私房菜【一】——（前置基础）
1.1 编码
就是把人类语言（文字）通过编码的形式（如 a --> 1100001）一一映射成计算机认识的语言（0101…），即 将人类语言 通过某种形式 转换成计算机认识的二进制数。这种编码形式是人为定义的，因此就有多种不同的编码方式。
1.1.1 ASCII码
是早期的编码方式之一，规定了大小写英文字母、数字及其他一些符号或字符与二进制数的映射关系，起初只定义了128个可映射的字符，即 1个字符可用7个二进制位表示（0000000 ~ 1111111 共128个）。后来随之扩展，又引入了额外的128个字符或符号，这样一来，就使得ASCII码的映射范围扩大到了256个字符（28个），即1个字符可用8个二进制位（00000000 ~ 11111111）表示。
1.1.2 Unicode码
是继ASCII码后的另一种编码方式，又称万国码，因其可表示世界上各国的各语言而得名，且向下兼容了ASCII码。起初它只是一个抽象概念，后面随之时间推移，推出了如UTF-8、UTF-16等具体的编码方案。
【1】UTF-8
是可变长的编码方式，可变长指的是可以根据不同文字对应不同的二进制编码，在存储空间上可存放1或2或3或4个字节（1个字节=8个二进制位），总的来说，一个字符可用8 * 1 到 8 * 4 位二进制数表示，有效压缩了存储空间。
【2】UTF-16
也是一种可变长的编码方式，一个字符可用8 * 2 到 8 * 4 位二进制数表示。
【3】 UTF-32
是固定长度的编码方式，无论什么字符都是用32位二进制数进行存储，使得空间上造成浪费
- 注：中文占3个字节的长度 UTF-8使用较为广泛
1.1.3 其他
还有诸如像 GBK / GB2312 的编码形式，其存储的是中文字符，也包含其他亚洲国家的文字且中文占2个字节。
1.2 数据类型
1.2.1 数字类型（number）
又可细分为 整数型（int）和 浮点型（float）。
int型诸如 -1，-2,1，2，…形式的数字；
float型诸如 -1.0,2.0，…形式的数字。
1.2.2 字符串类型（str）
是一串文字，且是用一对英文引号“包起来”的文字。诸如 “aa”，‘bb’，“”“cc”“”,…的形式（引号包括单引号、双引号及三引号）
1.2.3 布尔类型（boolean）
是真假值，该类型只有 true 或 false 两个值，多用于判断语句。
对于其他数据类型，其中，0、0.0、None、“”、“0”、“false”，也表示布尔值false。
1.2.4 列表（list）
存放多个不同数据的容器，诸如 [1, “2”, false, “ok”] 的形式。
即 通过 [] 可定义一个 list 类型的容器，容器存放的数据称之为元素。
- 特点 ：有序 、可变、可重复。
- 有序：即可以通过下标（索引）获取列表中的元素 诸如 li = [1, 2, 3] 那么 li[0] 则意味着可以获取li列表的第一个元素1；
- 可变：即可以通过 增删改 等方法 操作列表或列表中的元素；
- 可重复：即列表中的元素不是唯一的，而是可以重复存放的，诸如 li = [1, 1, 2, 3, 3]
- 空列表的定义：
li = [] li = list()
1.2.5 元组（tuple）
通过 () 定义的容器，也是可以存放不同类型的数据。诸如 (1, 2, “a”)。
- 特点：有序、不可变、可重复。
- 有序：即可以通过下标（索引）获取元组中的元素 诸如 tu = (1, 2, 3) 那么 tu[0] 则意味着可以获取tu元组中的第一个元素1；
- 不可变：意味着 不能通过 增删改 等方法去操作元组中的元素；
- 可重复：即元组中的元素不是唯一的。
- 空元组的定义：
tu = () tu = tuple() - 元组中只有一个元素的定义形式：
tu = (1,)
注：根据 元组 不可变 的特性，可将其 作为 字典的 key。
1.2.6 集合（set）
通过 {} 定义的容器，也是可以存放不同类型的数据。诸如{1, 2, “a”}。
- 特点：无序、可变、不可重复。
- 无序：意味着不能通过 下标 获取对应位置的元素；
- 可变：意味着可以通过 增删改 等方法 操作集合中的元素；
- 不可重复：意味着该容器的元素是唯一的。若出现多个相同元素，则只会保留一个。
- 空集合的定义：
s = set() - 注：根据集合 不可变 的特性，可利用其特性对列表或元组中的元素进行去重
li = [1, 1, 2, 3, 4, 4] li = list( set( li ) )
1.2.7 字典（dict）
形如 {“a”: 1, “b”: “哈哈”} ，通过{}“包起来的”，里面的元素形式以键值对的方式式定义的容器。
- 特点：无序、可变、key不可重复。
- 无序：意味着不能通过 下标 获取对应位置的元素；
- 可变：意味着可以通过 增删改 等方法 操作字典中的元素；
- key不可重复：意味着该容器的键（key）是唯一的。
- 空字典的定义：
d = {} d = dict()
1.2.8 NoneType
是 None 这个值对应的数据类型
1.2.9 自定义类
除了内置的数据类型，还可以通过class关键字自行定义其他类型，如
class 类名:
类属性 = 类属性值
def __init__(self):
pass
def 实例方法名(self,参数列表):
pass
1.3 运算符
1.3.1 算术运算符
诸如 ：+ 加、 - 减、 *乘、 /除、 //整除、 %取余
【1】+
- 通常用作数值间的加法操作，但需要注意以下几种情况：
- int + float ：可以相加且值是float型，但是有可能会出现精度丢失的情况（浮点数底层转换成二进制数导致的）；
- int + boolean ：可以相加且值是int型，其中boolean的true或false在底层实际上就是转换成1或0 ；
- float + boolean ：可以相加但同样也可能出现精度丢失的情况；
- str + str ：可以相加，字符串的拼接，且str若是和其他数据类型进行 + 操作，会报错；
- list + list ：可以相加，列表的合并；
- tuple + tuple ：可以相加，元组的合并；
- set + set ：不能相加，若需合并，可采用 set | set 的形式；
- dict + dict ：不能相加。
【2】*
- 通常用作数值间的乘法操作，但需要注意以下几种情况：
- int * str ：可以相乘，表示int个str拼接在一起；
- int * list、int * tuple ：可以相乘，表示int个list或int个tuple进行合并；
- float * str ：不能相乘。
【3】/
- 通常用作int类型或float类型间的除法操作，但需要注意以下几种情况：
- int / int ，结果值是float
【4】//
- 通常用作int类型或float类型间的整除操作，但需要注意以下几种情况：
- int // int ，结果会向下取整；
- int // float ，结果向下取整后会转换成float型
1.3.2 逻辑运算符
【1】and 逻辑与
相当于Java中的短路与，通常用于条件判断语句。
用法：表达式1 and 表达式2 and 表达式3 and…
若有一个表达式的值为false，则该表达式后面的表达式不再运算，直接返回该表达式的值；
若所有表达式都为true，则返回最后一个表达式的值。
【2】or 逻辑或
相当于Java中的短路或，通常用于条件判断语句。
用法：表达式1 or 表达式2 or 表达式3 or…
若有一个表达式的值为true，则该表达式后面的表达式不再运算，直接返回该表达式的值；
若所有表达式都为false，则返回最后一个表达式的值。
【3】not 取反
相当于Java中的 ! 操作符，通常用于条件判断语句。
**用法：not 表达式 **
当表达式的值为true 则该结果为false；反之为true
1.3.3 同一运算符
【1】is
判断两个值是否为同一个，比较的是地址，通常用于条件判断语句。
is 与 == 的区别：
is 比较的是地址，==比较的是值；但在比较数值类型以及字符串类型是否相同时，一般还是采用 == 进行比较。
【2】is not
判断两个值是否不是同一个，比较的是地址，通常用于条件判断语句。
1.3.4 成员关系运算符
【1】in
判断某个元素 / 值是否在某个容器中，这个容器可以是 字符串、列表、元组、集合、字典。
【2】not in
判断某个元素 / 值是否不在某个容器中。
注：对于字典而已，判断某个元素 / 值是否在字典中，是对 key 进行判断。
2 Python私房菜【二】——（字符串内置方法）
下面为大家介绍一些常见的字符串内置方法，首先需要定义几个变量方便后续调用相关方法的使用
str1 = "abc"
str2 = "ABC"
str3 = "aBcd"
str4 = "hello world"
str5 = "hello world. hello world."
str6 = "123"
str7 = "123abc"
str8 = "你！是！我的神！"
str9 = " "
str10 = "\n"
str11 = "\t"
str12 = """锄禾日当午
汗滴禾下土
谁知盘中餐
粒粒皆辛苦"""
为方便讲解，假设以下方法调用后的变量值，只针对当前讲解的方法时生效；讲解结束后以上变量值仍恢复为以上定义的值
【1】upper()
针对于英文字母，将小写字母转换为大写字母；且该方法会返回一个新的字符串
str1 = str1.upper()
print(str1) # ABC
【2】lower()
针对于英文字母，将大写字母转换为小写字母；且该方法会返回一个新的字符串
str2 = str2.lower()
print(str2) # abc
【3】swapcase()
针对于英文字母，将大小写字母互相转换；且该方法会返回一个新的字符串
str3 = str3.swapcase()
print(str3) # AbCD
【4】title()
针对于英文语句，将每个单词的首字母变大写，其余字母变为小写；且该方法会返回一个新的字符串
str4 = str4.title()
print(str4) # Hello World
【5】capitalize()
针对于英文语句，将该字符串的首个单词的首字母变大写，其余字母变为小写；且该方法会返回一个新的字符串
str5 = str5.capitalize()
print(str5) # Hello world. hello world.
【6】isupper()
针对于英文字母，判断字符串中每个字符是否为小写字母；会返回一个布尔值，常用在判断语句
print(str2.isupper()) # true
【7】islower()
针对于英文字母，判断字符串中每个字符是否为大写字母；会返回一个布尔值，常用在判断语句
print(str1.islower()) # true
【8】istitle()
针对于英文语句，判断字符串中的每个单词的首字母是否为大写字母；会返回一个布尔值，常用在判断语句
print(str4.istitle()) # false
【9】isspace()
判断字符串是否为 " " 或 “\n” 或 “\t”；会返回一个布尔值，常用在判断语句
print(str9.isspace()) # true
print(str10.isspace()) # true
print(str11.isspace()) # true
【10】isalpha()
判断字符串是否为字母或文字【不包含数字及特殊字符】；会返回一个布尔值，常用在判断语句
print(str6.isalpha()) # false
print(str7.isalpha()) # false
print(str1.isalpha()) # true
【11】isdigit()
判断字符串中的每个字符是否都是数字；会返回一个布尔值，常用在判断语句
print(str6.isdigit()) # true
print(str7.isdigit()) # false
【12】isdecimal()
判断字符串中的每个字符是否都是数字；会返回一个布尔值，常用在判断语句
print(str6.isdecimal()) # true
print(str7.isdecimal()) # false
区别：isdecimal() 方法与 isdigit() 类似，但 isdecimal() 更为严格，它只接受 Unicode 的十进制字符，而 isdigit() 还接受其他数字字符，如罗马数字。
【13】isalnum()
判断字符串是否只包含数字或字母（不包含特殊符号）
print(str7.isalnum()) # true
print(str8.isalnum()) # false
【14】isprintable()
判断字符串是否为可打印的（换行符、制表符不可打印）；会返回一个布尔值，常用在判断语句
print(str9.isprintable()) # true
print(str10.isprintable()) # false
print(str11.isprintable()) # false
【15】startswith(参数列表)
判断字符串是否以指定字符串开头；会返回一个布尔值，常用在判断语句
"""
参数列表：
参数1：指定字符串
可选参数2：起始位置，下标值
可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行判断
若加上可选参数2，则会从参数2的位置开始判断
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行判断
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.startswith("hel")) # true
print(str4.startswith("hello", 0)) # true
print(str4.startswith("hell", 1, 5)) # false
【16】endswith(参数列表)
判断字符串是否以指定字符串结尾；会返回一个布尔值，常用在判断语句
"""
参数列表：
参数1：指定字符串
可选参数2：起始位置，下标值
可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行判断
若加上可选参数2，则会从参数2的位置开始判断
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行判断
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.endswith("d")) # true
print(str4.endswith("ld", 0)) # true
print(str4.endswith("hell", 1, 5)) # false
【17】count(参数列表)
返回 指定字符串 在字符串中 出现的次数；查找到指定字符串返回出现的次数，没有查找到则返回 0
"""
参数列表：
参数1：指定字符串
可选参数2：起始位置，下标值
可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.count("h")) # 1
print(str4.count("l", 0)) # 3
print(str4.count("hell", 1, 5)) # 0
【18】find(参数列表)
返回 指定字符串 在字符串中 的下标值（从左往右第一个被查找到的位置）；若查找不到该指定字符串，则返回 -1
"""
参数列表：
参数1：指定字符串
可选参数2：起始位置，下标值
可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.find("h")) # 0
print(str4.find("l", 0)) # 1
print(str4.find("hell", 1, 5)) # -1
【19】rfind(参数列表)
返回 指定字符串 在字符串中 的下标值（从右往左第一个被查找到的位置）；若查找不到该指定字符串，则返回 -1
"""
参数列表：
参数1：指定字符串
可选参数2：起始位置，下标值
可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.rfind("h")) # 0
print(str4.rfind("l", 0)) # 9
print(str4.rfind("hell", 1, 5)) # -1
【20】index(参数列表)
返回 指定字符串 在字符串中 的下标值（从左往右第一个被查找到的位置）；若查找不到该指定字符串，则报错
"""
参数列表：
参数1：指定字符串
可选参数2：起始位置，下标值
可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.index("h")) # 0
print(str4.index("l", 0)) # 1
print(str4.index("hell", 1, 5)) # 报错！！！！
【21】rindex(参数列表)
返回 指定字符串 在字符串中 的下标值（从右往左第一个被查找到的位置）；若查找不到该指定字符串，则返回 报错
"""
参数列表：
参数1：指定字符串
可选参数2：起始位置，下标值
可选参数3：结束位置，下标值
若只有参数1，则默认是从头到尾进行查找
若加上可选参数2，则会从参数2的位置开始查找
若加上可选参数2和可选参数3，则会从参数2的位置开始到参数3的前一个位置进行查找
参数2 和 参数3 的范围是 左闭右开
"""
print(str4.rfind("h")) # 0
print(str4.rfind("l", 0)) # 9
print(str4.rfind("hell", 1, 5)) # 报错！！！！
【22】center(参数列表)
以指定长度对字符串进行填充，并让字符串居中显示；返回一个新字符串
"""
参数列表：
参数1：指定长度
可选参数2：指定字符串
若 指定字符串的长度 小于 原有字符串的长度 则还是返回原有字符串
若不填写 指定字符串 则默认以 空格 进行填充
"""
print(str4.center(15)) # hello world
print(str4.center(15, "*")) # **hello world**
【23】ljust(参数列表)
以指定长度对字符串进行填充，并让字符串居左显示；返回一个新字符串
"""
参数列表：
参数1：指定长度
可选参数2：指定字符串
若 指定字符串的长度 小于 原有字符串的长度 则还是返回原有字符串
若不填写 指定字符串 则默认以 空格 进行填充
"""
print(str4.ljust(15)) # hello world
print(str4.ljust(15, "*")) # hello world*****
【24】rjust(参数列表)
以指定长度对字符串进行填充，并让字符串居右显示；返回一个新字符串
"""
参数列表：
参数1：指定长度
可选参数2：指定字符串
若 指定字符串的长度 小于 原有字符串的长度 则还是返回原有字符串
若不填写 指定字符串 则默认以 空格 进行填充
"""
print(str4.rjust(15)) # hello world
print(str4.rjust(15, "*")) # *****hello world
【25】split(参数列表)
以指定字符串进行分割，返回一个列表（分割后的每个字符串都会作为一个元素添加到列表中）
"""
参数列表：
可选参数1：指定字符串
可选参数2：分割次数
若 指定字符串 不写 默认按原有字符串作为一个整体进行分割
"""
print(str8.split()) # ["你！是！我的神！"]
print(str8.split("！")) # ["你", "是", "我的神", ""]
print(str8.split("！", 1)) # ["你", "是！我的神！"]
【26】rsplit(参数列表)
以指定字符串进行分割，返回一个列表（分割后的每个字符串都会作为一个元素添加到列表中），从右往左分割
"""
参数列表：
可选参数1：指定字符串
可选参数2：分割次数
若 指定字符串 不写 默认按原有字符串作为一个整体进行分割
"""
print(str8.rsplit()) # ["你！是！我的神！"]
print(str8.rsplit("！")) # ["你", "是", "我的神", ""]
print(str8.rsplit("！", 1)) # ["你！是！我的神", ""]
【27】splitlines()
以换行符进行分割，返回一个新字符串
"""
参数列表：
可选参数 keepends：若赋值为True 则分割后的字符串元素都会携带"\n"
"""
print(str12.splitlines()) # ["锄禾日当午","汗滴禾下土", "谁知盘中餐", "粒粒皆辛苦"]
print(str12.splitlines(keepends=True)) # ["锄禾日当午\n","汗滴禾下土\n", "谁知盘中餐\n", "粒粒皆辛苦\n"]
【28】partition(参数列表)
以指定字符串进行分割，分割成三个部分（从左往右），指定字符串左侧为一部分，指定字符串为一部分，指定字符串右侧为一部分；返回一个元组
"""
参数列表：
参数1：指定字符串
"""
print(str8.partition()) # ("你", "！", "是！我的神！")
【29】rpartition(参数列表)
作用和partition()一样，不一样的是从右往左分割
"""
参数列表：
参数1：指定字符串
"""
print(str8.rpartition()) # ("你！是！我的神", "！", "")
【30】join(参数列表)
通过指定字符串将可迭代对象中的每一个元素拼接成一个字符串
"""
参数列表：
参数1：可迭代对象 且可迭代对象中的每一个元素都需是字符串类型
"""
print("*".join(["你", "是", "我", "的", "神"])) # 你*是*我*的*神
【31】replace(参数列表)
字符串中将原字符替换为目标字符，返回一个新字符串
"""
参数列表：
参数1：原字符
参数2：目标字符
可选参数3：替换的次数
"""
print("祝你生日快乐".replace("生日", "新年")) # 祝你新年快乐
print("一二三 三二一 一二三四五六七".replace("一", "1", 2)) # 1二三 三二1 一二三四五六七
【32】strip()
去除前后空格包括换行符，返回新字符串
print(" 祝你生日快乐 ".strip()) # 祝你新年快乐
【33】lstrip()
去除前空格包括换行符，返回新字符串
print(" 祝你生日快乐 ".strip()) # 祝你新年快乐
【34】rstrip()
去除后空格包括换行符，返回新字符串
print(" 祝你生日快乐 ".strip()) # 祝你新年快乐
【35】encode(参数列表)
将字符串转换成对应编码方式的字节串
"""
参数1：编码方式 如 "UTF-8"
"""
print("我爱你".encode("UTF-8")) # b'\xe6\x88\x91\xe7\x88\xb1\xe4\xbd\xa0'
【36】decode(参数列表)
将字节串转换成对应编码方式的字符串
"""
参数1：编码方式 如 "UTF-8"
"""
print(b'\xe6\x88\x91\xe7\x88\xb1\xe4\xbd\xa0'.decode("UTF-8")) # 我爱你
3 Python私房菜【三】——（列表内置方法）
3.1 增
【1】append(参数列表)
将指定元素添加到列表的最后一个，会改变原有列表
"""
参数列表：
参数1：指定元素
"""
list1 = [1,2,3]
list1.append(4)
print(list1) # [1,2,3,4]
【2】extend()
将指定列表中的每一个元素添加到列表末尾，会改变原有列表
"""
参数列表：
参数1：指定列表
"""
list1 = [1,2,3]
list1.extend([4,5,6])
print(list1) # [1,2,3,4,5,6]
【3】insert(参数列表)
将指定元素添加到列表的指定位置，会改变原有列表
"""
参数列表：
参数1：指定位置
参数2：指定元素
"""
list1 = [1,2,3]
list1.insert(1, 6)
print(list1) # [1,6,2,3]
3.2 删
【1】pop(参数列表)
根据索引值删除列表中的元素，会改变原有列表
"""
参数列表：
参数1：指定索引值
"""
list1 = [1,2,3]
list1.pop(1)
print(list1) # [1,3]
【2】remove(参数列表)
根据元素值删除列表中的元素，会改变原有列表
"""
参数列表：
参数1：指定元素
"""
list1 = [1,2,3]
list1.remove(1)
print(list1) # [2,3]
【3】del
这是一个关键字，可通过del对列表或列表中的元素进行删除
"""
del 列表[索引] 删除对应索引的元素
del 列表 删除整个列表 即意味着这个变量将被删除 无法使用
"""
list1 = [1,2,3]
del list1[2]
print(list1) # [1,2]
del list1
print(list1) # 报错！！！！
3.3 其他
【1】sort(参数列表)
针对于数值元素的列表会按照数值大小进行排序，对于字符元素的列表，是根据ASCII编码大小进行排序，默认升序，会改变原有列表
"""
参数列表：
reverse=True 会将排序改为降序
"""
list1 = [2,1,3]
list1.sort()
print(list1) # [1,2,3]
list1.sort(reverse=True)
print(list1) # [3,2,1]
【2】sorted(参数列表)
和sort()作用一样，不同的是它不会改变原有列表，而是返回一个新列表
【3】reverse()
对列表元素的倒置
list1 = [1,2,3]
list1.reverse()
print(list1) # [3,2,1]
【4】count(参数列表)
和字符串的count()方法一样，用于获取指定元素在列表中的出现次数
"""
参数列表：
参数1：指定元素
可选参数2：起始位置
可选参数3：结束位置
"""
list1 = [1,2,3,1,1,2]
print(list1.count(1)) # 3
【5】index(参数列表)
和字符串的index()方法一样，用于获取指定元素在列表中的出现的索引值（从左往右）
"""
参数列表：
参数1：指定索引
可选参数2：起始位置
可选参数3：结束位置
"""
list1 = [1,2,3,1,1,2]
print(list1.index(1)) # 0
3.4 深拷贝 与 浅拷贝
区分 拷贝 与 =（赋值）：
拷贝： 即 将 原有数据 的内容复制一份到 目标变量
一般情况下，通过目标变量修改数据，不会影响原有数据的变化
赋值：即 将 原有数据 的地址指向 目标变量
通过目标变量修改数据，会影响到原有数据
区分 深拷贝 与 浅拷贝：
浅拷贝：
除了上述的一般情况，还有特殊情况：
当 原有数据 是复杂类型的数据（如嵌套列表），
那么拷贝后，通过目标变量修改数据时，若修改的是嵌套列表里的元素，也会引起原有数据的变化
因为拷贝的是嵌套列表的地址
而这种拷贝 称之为 浅拷贝
深拷贝：
在操作目标变量的数据时，不会引起 原有数据 的变化，即使是嵌套对象也一样
这种拷贝称之为 深拷贝
"""如何进行浅拷贝"""
list1 = [1,2,3,[4,5,6]]
# (1) 采用 extend() 的方式
new_list = []
new_list.extend(源列表)
# （2）采用 切片 的方式
new_list = list1[:]
# （3）采用 list() 的方式
new_list = list(list1)
# (4) 采用 copy 模块中的 copy() 方法
import copy
new_list = copy.copy(list1)
"""如何进行深拷贝"""
# (1) 采用 copy模块中的 deepcopy() 方法
new_list = copy.deepcopy(list1)
4 Python私房菜【四】——（集合内置方法）
4.1 增
【1】add(参数列表)
往集合中添加一个元素，会修改原有集合
"""
参数列表：
参数1：指定元素
"""
set_ = {1,2,3}
set_.add(5)
print(set_) # {1,2,3,5}
【2】update(参数列表)
往集合中添加多个元素，会修改原有集合
"""
参数列表：
参数1：指定集合
"""
set_ = {1,2,3}
set_.update({4,5})
print(set_) # {1,2,3,4,5}
4.2 删
【1】remove(参数列表)
往集合中删除指定元素，会修改原有集合
"""
参数列表：
参数1：指定元素
"""
set_ = {1,2,3}
set_.remove(1)
print(set_) # {2,3}
【2】clear()
清空集合中的元素，会修改原有集合
set_ = {1,2,3}
set_.clear()
print(set_) # set()
【3】pop()
随机删除集合中的一个元素，会修改原有集合
set_ = {1,2,3}
set_.pop()
print(set_) # {2, 3} 或 {1, 3} 或 {1, 2}
4.3 其他
【1】& 交集
两个集合的公共部分，返回一个新集合
set_1 = {1,2,3}
set_2 = {2,3,4}
print(set_1 & set_2) # {2,3}
【2】| 并集
两个集合合并在一起，返回一个新集合
set_1 = {1,2,3}
set_2 = {2,3,4}
print(set_1 | set_2) # {1,2,3,4}
【3】- 差集
去除前一个集合和后一个集合的公共部分，留下前一个集合剩余的元素，返回一个新集合
set_1 = {1,2,3}
set_2 = {2,3,4}
print(set_1 - set_2) # {1}
【4】^ 对称差集
去除两个集合的公共部分后，合并在一起，返回一个新集合
set_1 = {1,2,3}
set_2 = {2,3,4}
print(set_1 ^ set_2) # {1,4}
5 Python私房菜【五】——（字典内置方法）
5.1 增
【1】通过 字典名[key] = value 的形式
当要添加的可以不在字典中时，可采取该种方法将key以及其对应的value作为键值对添加到字典中
dict_1 = {"name": "zhangsan","age": 64}
dict_1["sex"] = "男"
print(dict_1) # {"name": "zhangsan","age": 64, "sex": "男"}
【2】通过 update(参数列表) 的形式
可将指定字典中每一对k: v以键值对的形式添加到字典中，会修改原有字典
"""
参数列表：
参数1：字典 如 {"sex": "男", "phone": "13433383888"}
"""
dict_1 = {"name": "zhangsan","age": 64}
dict_1.update({"sex": "男", "phone": "13433383888"})
print(dict_1) # {"name": "zhangsan","age": 64, "sex": "男"}
5.2 删
【1】pop(参数列表)
根据指定键删除字典中对应的键值对，会修改原有字典
"""
参数列表：
参数1：key
"""
dict_1 = {"name": "zhangsan","age": 64}
dict_1.pop("name")
print(dict_1) # {"age": 64, "sex": "男"}
【2】clear()
清空字典，会修改原有字典
dict_1 = {"name": "zhangsan","age": 64}
dict_1.clear()
print(dict_1) # {}
5.3 其他
【1】keys()
获取字典中所有的key 以形如列表的形式返回
dict_1 = {"name": "zhangsan","age": 64}
print(dict_1.keys()) # dict_keys(["name","age"])
【2】values()
获取字典中所有的value 以形如列表的形式返回
dict_1 = {"name": "zhangsan","age": 64}
print(dict_1.values()) # dict_values(["zhangsan",64])
【3】items()
获取字典中所有的key和value 以形如列表的形式返回，且列表中每一个元素是一个元组，元组中第一个元素是key，第二个元素是value
dict_1 = {"name": "zhangsan","age": 64}
print(dict_1.items()) # dict_items([("name","zhangsan"),("age",64)])
【4】get(参数列表)
通过键查询值，查找不到默认返回None
"""
参数列表：
参数1：key
可选参数2：查找不到返回的值 默认返回None
"""
dict_1 = {"name": "zhangsan","age": 64}
print(dict_1.get("name")) # zhangsan
print(dict_1.get("sex")) # None
print(dict_1.get("phone", "找不到")) # 找不到
【5】fromkeys(参数列表)
将指定的可迭代对象中的每个元素作为字典中的key，值默认为 None ，返回一个新字典
"""
参数列表：
参数1：可迭代对象（列表、元组、字符串） 且要求每个元素都是 可哈希对象
可哈希的：
意味着它有一个哈希值（hash value），这个值在整个生命周期中是固定不变的，
并且它可以与其他对象进行比较以确定是否相等
可哈希的对象都有：字符串（str)、数字（int, float, complex）、元组（tuple）但仅当其包含的元素都是可哈希的
不可哈希对象都有：列表（list）、字典（dict）、集合（set）
可选参数2：对应的值 默认为None
"""
dict_1 = {}
print(dict_1.fromkeys(['a', 'b', 'c'])) # {'a': None, 'b': None, 'c': None}
print(dict_1.fromkeys(('a', 'b', 'c'), 0)) # {'a': 0, 'b': 0, 'c': 0}
print(dict_1.fromkeys('abc', "default")) # {'a': default, 'b': default, 'c': default}
"""
注：实际上该方法是 类方法 直接通过 dict.fromkeys()调用即可
"""
【6】setdefault(参数列表)
通过键查询值，查找不到会将该键添加到字典的key中，值为None
"""
参数列表：
参数1：键名
"""
dict_1 = {"name": "zhangsan","age": 64}
print(dict_1.setdefault("name")) # zhangsan
print(dict_1.setdefault("sex")) # None
print(dict_1) # {"name": "zhangsan","age": 64, "sex": None}
6 Python私房菜【六】——（函数）
6.1 参数
【1】位置参数
在传参时按照定义形参的位置按顺序传递参数值
【2】默认参数
在定义形参时，可以指定默认值，若传参时没有传递对应参数值，则该参数的值为定义形参时的值
【3】不定长参数
一般需要定义在最末尾。
*args：参数值是以元组的元素形式进行传递的；该参数数据类是元组
**kwargs：传递参数时，需要以 k=v 的形式传递；该参数数据类型是字典
【4】强制命名参数
当形参定义在不定长参数后面，在传递参数时，需要指定对应的值传递给具体哪个参数
6.2 nonlocal关键字
在嵌套函数中 若内层函数需要用到外层函数的某一变量
即可通过 nonlocal 外层函数变量名 的形式进行引用
同样的 和global关键字一样 在引用前不能先使用
6.3 lambda表达式
函数体简单的函数，定义在一行的函数，且除了父级变量及形式参数可以引用，自己不能定义变量；默认会将函数体的值返回
"""
书写方式
"""
""" 1 无参 """
func1 = lambda : 100
""" 2 1个参数 """
func2 = lambda x1 : x1 * 10
""" 3 多参 """
func3 = lambda *args, **kwargs : len(args) + len(kwargs)
""" 4 三目表达式 """
func3 = lambda x1, x2 : x1 if x1 > x2 else x2
6.4 三目表达式
a = 条件为真的值 if 条件 else 条件为假的值
7 Python私房菜【七】——（常用内置函数）
7.1 强制数据类型转换
【1】int()、float()、str()、list()、tuple()、dict()、set()、bool()
传入需要转换的数据类型的值，就会把该值的类型强制转换为对应调用函数的数据类型
当然，传入的值也是需要符合一定条件才能作为参数被传入，否则会报错
int()所需参数是：整数字符串 或 浮点数 （若参数为浮点数，会向下取整 如 3.9会强转为3）
float()所需参数是：数值字符串 或 数字类型 的数据
list()、tuple()、dict()、set()所需参数是可迭代的，而int型、float型不可迭代
需要注意的是 对于dict()，接收的参数类型需为嵌套列表或为元组列表，且里面每个列表和元组的元素需为两个
li_list = [[1, 2], [3, 4]]
tu_list = [(5, 6), (7, 8)]
li_dict = dict(li_list)
tu_dict = dict(tu_list)
print(li_dict) # {1: 2, 3: 4}
print(tu_dict) # {5: 6, 7: 8}
7.2 输入输出
【1】input(提示字符串)
这是一个 输入 函数，等待用户进行输入交互，最终会返回用户输入的字符串
程序运行到该函数时，会被阻塞，且会显示提示字符串等待用户输入
【2】print(要输出的信息)
这是一个 输出 函数，会将信息输出到控制台上
注：以下是常用参数 ——
sep：指定输出多个对象时的分隔符。默认是空格。
end：指定输出结束时的字符。默认是换行符 \n。
file：指定输出的文件对象，默认是 sys.stdout。
flush：一个布尔值。如果设置为 True，则强制刷新输出缓冲区。
print("Hello", "World", sep="---", end="!\n")
print("First Line", file=open("example.txt", "w"), flush=True)
7.3 数字相关
【1】abs(参数列表)
绝对值函数，参数是一个数值类型的数据
【2】max(参数列表)
取最大值函数，参数是可迭代对象（元组、列表、集合、字典、字符串…）
且可迭代对象中的每个元素需要是数值字面量（整数型、浮点型、数值字符串），且每个元素需为相同类型
即 里面的元素要么是int型或float型，要么全是str型
且若传入的参数是dict类型，比较的是key，同样key的类似也需相同
max([1,2.0]) # 2.0
max((2.0,3.0)) # 3.0
max({"4.0","5"}) # 5
max({"4.0": "A","5": "B"}) # 5
max({"5",6}) # 报错！！！
max([7,8,"10.0"]) # 报错！！！
【3】min(参数列表)
取最小值函数，参数是可迭代对象，用法和max()一样
【4】sum(参数列表)
求和函数，将可迭代对象中的每一个元素进行相加
且可迭代对象中的每一个元素都需是数值类型（int、float）
且可迭代对象若为dict，则key必须为数值类型，相加的是key
"""
参数列表：
参数1：可迭代对象
可选参数2：初始值
"""
sum([1,2.0]) # 3.0
sum((2,3)) # 5
sum({6: "66", 7: "77"}) # 13
sum([1,2], 66) # 69
【5】divmod(参数列表)
两数相除的商和余，以元组形式返回
且两个参数的数据类型需是int或float
"""
参数列表：
参数1：数1
参数2：数2
"""
divmod(6,3) # (2,0)
divmod(6,3.0) # (2.0,0.0)
7.4 进制转换
二进制 ：0b开头
八进制 ：0o开头
十六进制 ：0x开头
【1】int(参数列表)
将其他进制转换为十进制
"""
参数列表：
参数1：要进行进制转换的字符串数
可选参数2：base 值可选择 2 或 8 或 16 或 10 表示第一个参数的进制类型
当第一个参数没有显式说明具体进制时，就需要写上第二个参数
"""
int("0b101") # 5
int("101", base=2) # 5
int("0o101") # 65
int("101", base=8) # 65
int("101", base=16) # 257
【2】bin(参数列表)
将十进制转换为二进制字符串
"""
参数列表：
参数1：十进制整数
"""
bin(101) # '0b1100101'
【3】oct(参数列表)
将十进制转换为八进制字符串
用法同【2】
【4】hex(参数列表)
将十进制转换为十六进制字符串
用法同【2】
7.5 编码
【1】chr(参数列表)
参数是一个Unicode十进制数，会将Unicode十进制编码转换成Unicode中对应编码的字符
【2】ord(参数列表)
参数是一个Unicode字符，将Unicode字符转换成Unicode中对应字符的十进制编码
7.6 其他
【1】zip(参数列表)
用于将两个或两个以上的可迭代对象中的每个元素以元组的形式组合在一起，并返回一个迭代器（python2返回的是列表）
"""
参数列表：
参数1: 可迭代对象1
参数2：可迭代对象2
...
"""
list1 = [1, 2, 3]
list2 = ["a", "b", "c"]
it1 = zip(list1, list2)
print(it1.__next__()) # (1,"a")
print(next(it1)) # (2,"b")
print(next(it1)) # (3,"c")
"""
注：由于返回的是迭代器 因此需要通过 __next__() 或 next() 才可以获取迭代器中的元素 且每次调用只会产出一个元素
因此，若是想一次性获取 可通过 for 进行遍历：
for i in it1:
print(i)
若迭代器中的元素被取完，再次调用 __next__() 或 next() 则会报错
"""
【2】map(参数列表)
参数是一个函数以及一个可迭代对象，返回一个生成器；
会循环可迭代对象的每一个元素；
每循环一次，调用作为第一个参数的函数；
且会把可迭代对象的每个元素作为函数的参数；
将每次循环后函数的返回结果作为元素添加到生成器中；
应用场景：若想对可迭代对象中的每个元素进行某些处理，可利用该函数
"""
参数列表：
参数1：函数
参数2：可迭代对象
"""
li = [2,5,7] # 可迭代对象
def func1(x): # 函数1
return x + 10
func2 = lambda y : y + 20 # 函数2
iter1 = map(func1, li) # 调用map并返回一个iter1迭代器【会把li中的每个元素都+10】
for it1 in iter1:
print(it1, end=" ") # 12 15 17
iter2 = map(func2, li) # 调用map并返回一个iter1迭代器【会把li中的每个元素都+20】
for it2 in iter2:
print(it2, end=" ") # 22 25 27
【3】filter(参数列表)
参数是一个函数以及一个可迭代对象，返回一个生成器；
会循环可迭代对象的每一个元素；
每循环一次，调用作为第一个参数的函数；
且会把可迭代对象的每个元素作为函数的参数；
会将函数判断条件为True的元素添加到生成器中
"""
参数列表：
参数1：函数
参数2：可迭代对象
"""
li = [2,5,7] # 可迭代对象
def func1(x): # 函数1
return x <= 5
func2 = lambda y : True if y % 2 != 0 else False # 函数2
iter1 = filter(func1, li) # 调用filter()并返回一个iter1迭代器【会把li中<=5的元素添加到iter1生成器中】
for it1 in iter1:
print(it1, end=" ") # 2 5
iter2 = filter(func2, li) # 调用filter()并返回一个iter2迭代器【会把li中是奇数的元素添加到iter2生成器中】
for it2 in iter2:
print(it2, end=" ") # 5 7
"""若是func需要多个参数，可采取以下写法"""
def func(x, y):
return x + y <= 5
li = [2, 5, 7] # 可迭代对象
constant = 3 # 第二个参数的值
iter1 = filter(lambda x: func(x, constant), li)
for it1 in iter1:
print(it1, end=" ") # 输出将取决于func的实现和constant的值
【4】reduce(参数列表)
参数是一个函数以及一个可迭代对象，返回一个结果；
会循环迭代可迭代对象中的元素，首先会将可迭代对象的前两个元素分别传入函数的第一二个参数;
之后会将函数的返回值作为函数的第一个参数，把可迭代对象的后一个元素作为第二个参数；
将函数的最终return值返回
若是定义了初始值，则在循环遍历可迭代对象中的元素时，
第一次循环，会将可迭代对象的前两个元素分别传入函数的第一第二个参数；
此后的循环中，会将函数的返回结果传入函数的第一个参数，可迭代对象的后一个元素传入函数的第二个参数；
最后返回函数的结果值
注：在Python3中，要使用该函数，需要导包functools
"""
参数列表：
参数1：函数
参数2：可迭代对象
可选参数3：初始值
"""
import functools # 导包
li = [2,5,7] # 可迭代对象
def func1(x, y): # 函数1
return x + y
result = functools.reduce(func1, li) # 调用reduce()并返回一个结果【会把li中的元素进行求和并返回】
print(result) # 14
【5】eval(参数列表)
根据字符串表达式返回一个结果
表达式可以是：算术表达式、逻辑表达式、条件表达式
"""
参数列表：
参数1：字符串表达式
可选参数2：命名空间
"""
dict1 = {"a": 6, "b": 8} # 命名空间
str_express1 = "a + b" # 字符串表达式1【算术表达式】
str_express2 = "6 > 8" # 字符串表达式2【条件表达式】
str_express3 = "6 in [1, 6]" # 字符串表达式3【成员运算符表达式】
str_express4 = "6 and 1 and 0" # 字符串表达式4【逻辑运算符表达式】
str_express5 = "type(list()) is list" # 字符串表达式5【同一运算符表达式】
result = eval(str_express1, dict1)
print(result) # 14
result = eval(str_express1)
print(result) # 14
result = eval(str_express2)
print(result) # False
result = eval(str_express3)
print(result) # True
result = eval(str_express4)
print(result) # 0
result = eval(str_express5)
print(result) # True
【6】len(参数列表)
参数是一个可迭代对象，返回可迭代对象的长度
【7】type(参数列表)
参数是一个对象，返回这个对象的类型，一般可用来判断对象是否属于某个类
【8】dir(参数列表)
参数是一个对象，以列表形式返回对象的所有属性和方法
【9】isinstance(参数列表)
参数1是一个对象，参数2是一个类名，判断对象是不是属于某个（祖先）类的实例，返回一个布尔值
【10】issubclass(子类, 祖先类)
参数1是一个子类名，参数2是一个祖先类名，判断子类是否属于祖先类，返回一个布尔值
8 Python私房菜【八】——（面向对象）
8.1 内置方法
【1】__new__()
在实例化对象时，先是调用了__new__()创建空对象，
再调用__init__()初始化对象内部数据
【2】__init__()
类似于java中的构造方法 方便在创建对象时为各属性赋值
【3】__setitem__(self, key, value)
若想直接通过如字典的形式 : obj[“key”] = value 为对象内部添加数据
需要先在类中定义__setitem__()
"""
参数列表：
self：表示当前实例化的对象
key：表示 obj["key"] = value 中的 key
value：表示 obj["key"] = value 中的 value
"""
class Foo:
def __init__(self):
self.data = {} # 初始化一个字典来存储数据
def __setitem__(self, key, value):
self.data[key] = value # 将数据存储在字典中
f = Foo()
f["name"] = "小丑" # f 即为__setitem__(self, key, value)中的self，name为key，小丑为value，且内部会自动调用该方法
【4】__getitem__(self, key)
若想直接通过如字典的形式 : value = obj[“key”] 进行取值
需要先在类中定义__getitem__()
"""
参数列表：
self：表示当前实例化的对象
key：表示 属性名
"""
class Foo:
def __init__(self):
self.data = {} # 初始化一个字典来存储数据
def __setitem__(self, key, value):
self.data[key] = value # 将数据存储在字典中
def __getitem__(self, key):
return self.data[key] # 从字典中获取数据
f = Foo()
f["name"] = "小丑"
name = f["name"]
print(name) # 小丑
【5】__delitem__(self, key)
在类中定义该函数后，可通过 del 关键字进行删除属性，如 del obj[‘key’]
"""
参数列表：
self：表示当前实例化的对象
key：表示 属性名
"""
class Foo:
def __init__(self):
self.data = {} # 初始化一个字典来存储数据
def __setitem__(self, key, value):
self.data[key] = value # 将数据存储在字典中
def __getitem__(self, key):
return self.data[key] # 从字典中获取数据
def __delitem__(self,key):
del self.data[key] # 从字典中删除数据
f = Foo()
f["name"] = "小丑"
name = f["name"]
print(f.data) # {"name": "小丑"}
del f["name"]
print(f.data) # {}
【6】__str__(self)
当通过print(obj)去输出obj对象时，实际上输出的就是__str__()的返回值
class Foo:
def __init__(self):
pass
def __str__(self):
return "对象的相关信息，调用print(对象)会将这句话进行输出"
f = Foo()
print(f) # "对象的相关信息，调用print(对象)会将这句话进行输出"
【7】__enter__(self) 与 __exit__(self)
上下文管理，当我们使用with关键字与obj配合使用时，
实际上会先调用__enter__(self)，然后再执行with内部的代码，最后再执行 __exit__(self)
class Foo:
def __init__(self):
pass
def __enter__(self):
print("__enter__")
def __exit__(self):
print(" __exit__")
with Foo():
print("foo")
"""
以上代码的输出顺序为：
__enter__
foo
__exit__
"""
可通过该方式灵活操作文件对象
class Foo:
def __init__(self, filename, mode="w", encoding="utf-8"):
self.filename = filename
self.mode = mode
self.encoding = encoding
def __enter__(self):
self.f = open(self.filename, mode=self.mode, encoding=self.encoding)
return self.f
def __exit__(self, exc_type, exc_val, exc_tb):
self.f.close()
with Foo("文件.txt") as ff:
ff.write("hahahah")
"""
以上代码会先调用__enter__(self)并打开一个文件，并返回一个文件操作对象；
而这个文件操作对象会被 ff 这个变量所接收，再调用write()写入文件；
最后执行__exit__(self)关闭这个文件操作对象
其中 exc_type, exc_val, exc_tb 这三个参数是用于处理在 with 块中发生的任何异常
"""
【8】对象.__dict__
获取对象中自定义属性 以字典的形式返回
8.2 类属性
作用于整个类的属性；
定义在类内部及方法外部的变量称为 类变量/属性；
可通过类名或类方法中cls参数进行调用或实例对象调用。
8.3 实例属性
每个对象都有属于自己的属性；
定义在__init__(self)方法中的变量 称为实例变量；
可通过实例方法中的self参数调用或对象.的方式调用。
8.4 类方法
方法定义上方有@classmethod装饰的 称为 类方法
同样是通过类名进行调用或可通过类方法中cls参数进行调用或实例对象调用。
8.5 实例方法
方法定义上方没有任何@staticmethod或@classmethod装饰的；
且在class内部的 称为 实例方法；
可通过 对象.进行访问。
8.6 静态方法
每一个实例对象共有的方法；
方法定义上方有@staticmethod装饰的 称为 静态方法；
同样是通过类名进行调用；
不能访问实例属性和实例方法。
8.7 self 与 cls
前者是实例方法及__init__()的形式参数，后者是类方法的形式参数；
前者表示当前对象，后者表示当前类。
8.8 私有属性/私有方法
通过 __属性名 或 __方法名 定义;
只有类内部可进行访问；
而无法通过 对象（类）.属性名 或 对象（类）.方法名 的形式进行访问；
因为定义为私有属性/方法后，实际上底层是将其名字更改为 _ClassName__method 和 _ClassName__attribute 此种形式。
8.9 @property 与 @方法名.setter
是一种装饰器，用@property 装饰器装饰的方法，通常用于定义只读属性，在调用该方法时如同调用属性一样；
@方法名.setter用于定义属性的设置器方法
可用于私有属性的访问或修改。
通过@property装饰的函数要求只能有self参数
class Foo:
def __init__(self):
self.__age = 16
@property
def age(self):
return self.__age
@age.setter
def age(self, age):
self.__age = age
f = Foo()
print(f.get_age) # 16
f.get_age = 20
print(f.get_age) # 20
8.10 继承
可单继承也可多继承 如: class 子类(父类1, 父类2)；
子类可继承父类的私有属性（方法）但不能直接访问；
通常子类可以通过super()调用父类的方法，若是父类没有，还会层层往上找父类对应的方法。
8.11 组合
当一个类（B）要使用到另一个类(A）的数据的时候，可在B类中将A类对象作为属性a；
以后若想在B类中调用A类的数据，通过属性a即可调用。
class A:
pass
class B:
def __init__(self):
self.a = A()
8.12 接口
定义：若干抽象方法的集合
作用：限制 实现接口的类 必须按照接口给定的调用方式实现这些方法；对高层模块隐藏了类的内部实现；
即对于高层模块（调用类的方法的代码段）来说，无需看对应类的底层实现，直接看接口类的实现即可（有什么方法、方法中有什么参数…）
实现方式：利用abc模块——
"""
提供了一个机制来定义抽象基类，这些抽象基类可以用来创建不能直接实例化的类，并且可以定义必须在子类中实现的抽象方法；
这种机制帮助开发者设计更清晰的类层次结构，并确保子类遵循一定的接口规范。
"""
from abc import ABC,abstractmethod
# 定义一个抽象基类
class Shape(ABC):
@abstractmethod
def area(self):
"""算面积"""
pass
@abstractmethod
def perimeter(self):
"""算周长"""
pass
# 定义子类继承抽象基类
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def perimeter(self):
return 2 * (self.width + self.height)
# 实例化子类
r = Rectangle(3,4)
print(r.area()) # 12
print(r.perimeter()) # 24
主要内容说明：
总结：
抽象类不能被实例化；
继承了抽象类的类如果未实现抽象类当中的方法，也是一个抽象类，即也不能被实例化；
继承抽象类的类必须实现里面的抽象方法才能被实例化。
9 Python私房菜【九】——（文件操作）
9.1 文件类型
分为 文本文件 以及 二进制文件。
9.2 open(参数列表)
打开一个文件，返回一个文件操作对象，通过这个文件操作对象调用方法进行读写操作。
"""
参数列表：
参数1：文件路径
参数2：打开模式
r
只读 文件路径不存在会报错
w
只写 且每次写入都会清空原有内容，若文件不存在会自动创建
a
追加写 文件不存在会自动创建
rb、wb、ab
二进制方式的 只读 只写 追加写
此种方式无需再指定编码方式，直接以二进制读 / 写
r+、rb+
该模式下 若文件不存在不会自动创建
且在有读/又有写的情况下要注意指针的位置
先读取后写入 :
会读取完文件原有字符后将光标所在位置之后的原有字符覆盖【覆盖的字符数和写入字符数一致】
先写入后读取 :
将光标所在位置之后的原有字符覆盖后【覆盖的字符数和写入字符数一致】读取写入后光标所在位置之后的字符
w+、wb+
不管读/写都会覆盖原有文件 文件不存在则会自动创建
先读取后写入 :
每次都会清空原有内容，所以一般都会读到空字符，而后文件的内容会变更为写入的字符
先写入后读取 :
清空原有内容再写入，写入后指针在文件末尾，若要读取写入后的字符，
则要把指针移到头部位置再进行读取，否则读到空值
a+、ab+
文件不存在则会自动创建
文件指针默认在文件末尾
直接读取会读不到内容 需要移动指针再进行读取
若进行写入操作，则直接会自动将光标移到最后进行写入
参数3：encoding编码方式，一般为 encoding='utf-8'
"""
f = open("a.text", mode="a", encoding="utf-8") # 以追加写的方式打开a.text文件，并返回一个文件操作对象f
9.3 读操作
调用文件操作对象中的读取方法。
【1】read(参数列表)
通过该函数可读取文件中的内容，可指定读取个数，默认读取全部
"""参数列表
可选参数1：字符/字节 个数n
"""
f = open("a.text", mode="r", encoding="utf-8")
f.read() # 读取文件的全部内容
f.read(8) # 若文件为文本文件，则读取8个字符；若为二进制文件，则读取8个字节
f.close() # 养成习惯 文件对象操作完需要进行关闭
【2】readline()
每次读取一行，通过循环遍历反复调用该方法直到readLine()返回 ‘’ 可取出全部内容
f = open("a.text", mode="r", encoding="utf-8")
while True:
line = f.readline()
if not line:
break
print(line, end='') # 使用 end='' 以避免添加额外的换行符
f.close()
【3】readlines()
读取所有行，将每一行作为一个字符串元素保存到列表中
f = open("a.text", mode="r", encoding="utf-8")
f_lis = f.readlines()
for f_li in f_lis:
print(f_li)
f.close()
注：若需要读取一个特别大的文件，可采取以下操作
with open("a.text", mode="r", encoding="utf-8") as files:
for f in files:
print(f)
"""
以上方式是直接读取文件操作对象的，因为文件操作对象是可迭代的，因此也可以采用循环遍历
而每循环变量一次文件操作对象，同样也会 读取一行 到内存，使得内存占用及效率上会更少更快点
和 调用readline() 的区别是，该种方式不用显示调用readline()方法，且配合with as使用，
因此在效率上会稍微快点，代码也更简洁点
"""
9.4 写操作
write(参数列表)
通过文件操作对象调用该方法，将数据写入到文件；
这里有一点需要注意的是，如果文件是以文本模式打开的（如使用 encoding=“utf-8”），则只能写入字符串数据。
"""
参数列表：
参数1：要写入的数据
"""
f = open("a.text", mode="w", encoding="utf-8")
f.write("点赞加关注，带你上高速")
f.close()
9.5 tell()
通过文件操作对象调用该函数 ；
返回指针指向的字节位置（若文件刚打开，则从0开始）；
通过指针的指向，可决定文件是从哪开始读写的。
9.6 seek(参数列表)
通过文件操作对象可调用该函数；
参数是 字符/字节 数n（utf-8编码下 中文占3个字节）；
可操作指针（光标）停留的位置；
如果是以可读可写的模式 进行读写操作，指针指向会停留在上一次操作的位置 ；
如果想让指针指向文件的开头 参数可设为0。
9.7 flush()
强制将内存中的数据刷到硬盘中
9.8 close()
通过open()返回的文件操作对象调用该方法；
进行文件操作的关闭。
9.10 常用类型文件操作
9.10.1 csv文件读写操作
【1】读操作
csv.reader(参数列表) ——
参数是open()返回的文件操作对象；
通过该函数可保存文件的所有内容并返回一个迭代器；
可通过遍历该迭代器将每一行内容取出。
"""
参数列表：
参数1：文件操作对象
"""
# 内置模块 csv
import csv
# 文件操作对象
f = open("a.csv", mode="r", encoding="utf-8")
# 返回一个迭代器
f_iter = csv.reader(f)
for f_i in f_iter:
print(f_i)
f.close()
【2】写操作
csv.writer(参数列表)——
参数是open()返回的文件操作对象
返回一个可写入的操作对象
可通过该操作对象调用写入方法——
① writerow(参数列表)
参数是一维列表，即进行单行写入
② writerows(参数列表)
参数是二维列表，即进行多行写入
"""
writer()
参数列表：
参数1：文件操作对象
writerow()
参数列表：
参数1：一维列表
writerows()
参数列表：
参数1：二维列表
"""
import csv # 内置模块
# 文件操作对象
f = open("a.csv", mode="w", encoding="utf-8")
# 可写入的操作对象
fw_iter = csv.writer(f)
# 单行写入
"""我是好人"""
fw_iter.writerow(["我","是","好","人"])
# 多行写入
"""
他是坏人
你是笨蛋
"""
fw_iter.writerows([["他","是","坏","人"],["你","是","笨","蛋"]])
f.close()
9.10.2 json文件操作
【1】json格式
【2】读操作
json.load(参数列表)
读取文件中的数据，并以字典或列表的形式返回
"""
参数列表：
参数1：文件操作对象
"""
# 导入内置模块json
import json
# 文件操作对象
f = open("a.json", mode="r", encoding="utf-8")
# 读取文件数据
content = json.load(f)
print(content)
f.close()
【3】写操作
json.dump(参数列表)
写入文件数据，且写入的数据须为json格式
"""
参数列表：
参数1：需要写入的数据 数据以字典形式传入
参数2：文件操作对象
可选参数3：ensure_ascii 传入一个布尔值 若为False表示将数据的中文正常显示
可选参数4：indent 传入一个数值 表示将写入的数据进行缩进显示，数值代表缩进宽度
"""
# 导入内置模块json
import json
# 文件操作对象
with open("a.json", mode="w", encoding="utf-8") as f:
# 写入文件数据 —— 只写入一个json对象
json.dump({"age": 18}, f, ensure_ascii=False, indent=10)
# 写入文件数据 —— 写入多个json对象
# 需要将多个文件对象放入一个列表中
json_data_list = [{"age": 18},{"name": "zhangsan"}]
json.dump(json_data_list, f, ensure_ascii=False, indent=10)
print(f.read())
【4】序列化与反序列化
① dumps(参数列表)——
序列化：把其他数据类型转换为 str或bytes型
import json
"""
参数列表：
参数1： 其他数据类型的数据
"""
data = {"name": "张三", "age": 30}
json_string = json.dumps(data, ensure_ascii=False, indent=4)
② loads(参数列表)——
反序列化：把 str或bytes型 转换为 原有的对应的数据类型
import json
"""
参数列表：
参数1： str或bytes型的数据
"""
json_string = '{"name": "张三", "age": 30}'
data = json.loads(json_string)
9.10.3 excel文件操作
【1】xlrd模块
安装 ： pip install xlrd==1.2
导包 ：import xlrd
使用——
① 创建excel操作对象
ex = xlrd.open_workbook(‘文件路径’)
② 操作文件对象中的哪个工作区sheet
sheet = ex.sheet_by_index(0)
或
sheet = ex.sheet_by_name(“工作表名称”)
③ 获取行数
sheet.nrows 返回总行数
④ 获取列数
sheet.ncols 返回总列数
⑤ 获取行数据内容
sheet.row_values(行号) 以列表形式返回指定行号的数据内容
⑥ 获取所有列数据内容
sheet.col_values(列号) 以列表形式返回指定列号的数据内容
⑦ 获取指定单元格数据
sheet.cell(行号, 列号)
【2】openpyxl模块
安装 ：pip install openpyxl
导包 ：from openpyxl import Workbook
使用——
① 实例化 用于创建表格: wb = Workbook()
② 选择要操作的表格
导包: from openpyxl import load_workbook
指定表格: load_workbook(“表格文件路径”)
③ 使用默认的工作区: sheet_obj = wb.active(‘工作区名’)
④ 使用指定的工作区: sheet_obj = wb[“工作区名”]
⑤ 创建工作区: wb.create_sheet(“工作区名”, 索引位)
⑥ 获取表格中的所有sheet: wb.sheetnames
⑦ 添加内容
方式一: sheet_obj[“B2”] = “值”
方式二: sheet_obj.cell(行数，列数).value = “值”
⑧ 插入行
在第n行插入空行 ：sheet_obj.insert_rows(行号n)
在第n行的位置上插入m行空行 ：sheet_obj.insert_rows(行号n, 行数m)
⑨ 插入列 ：sheet_obj.insert_cols(列号)
⑩ 删除行 ：sheet_obj.delete_rows(n,m)
删除列 ：sheet_obj.delete_cols(n,m)
⑪ 获取最大行 ：sheet_obj.max_row()
⑫ 获取最大列 ：sheet_obj.max_column()
⑬ 修改工作区的名字 ：sheet_obj.title = “工作区名”
⑭另存为: wb.save(“表名”)
若是操作已有的表格文件，若保存的文件名和原来的不一致，则是另存为
9.10.4 yaml文件操作
【1】yaml文件书写格式
【2】安装 ：pip install pyyaml
【3】导包 ：import yaml
【4】使用
① 打开yaml文件
with open(“yaml文件路径”, “r”, encoding=“utf-8”) as f:
② 调用方法读取yaml文件 以字典形式返回yaml文件的内容
- 读取单个文档
- yaml.safe_load(f)
- 读取多个文档 可通过遍历获取每个文档的内容
- yaml.safe_load_all(f)
③ 写入数据到yaml文件
- yaml.safe_load_all(f)
"""写入单个"""
# 准备要写入的数据
data = {
'name': 'John Doe',
'age': 30,
'is_student': False
}
# 写入 YAML 文件
with open("output.yaml", "w", encoding="utf-8") as f:
yaml.dump(data, f, allow_unicode=True)
"""写入多个"""
# 准备多个要写入的文档
documents = [
{'name': 'John Doe', 'age': 30},
{'name': 'Jane Doe', 'age': 25}
]
# 写入多个 YAML 文档
with open("output.yaml", "w", encoding="utf-8") as f:
yaml.dump_all(documents, f, allow_unicode=True)
10 Python私房菜【十】——（异常）
程序运行过程中可能因各种错误而出现的异常导致程序无法正常运行
"""
raise 异常类(异常信息)
用来抛出异常
异常如果不捕获 会向上传递
若一直没被捕获就会报错 终止下面代码的运行
"""
"""
try:
可能发生异常的代码
except 异常类:
出现异常要进行的处理
else:
没发生异常运行的代码
finally:
无论发生异常与否都会运行的代码
注：
try 或 excep t中若是有 return，
finally 中的代码照样也会执行
"""
11 Python私房菜【十一】——（模块与包）
11.1 模块
【1】定义
每一个py文件都是一个模块
【2】导入方式
① import 模块名
导入模块后即可使用模块中的功能（如函数、类、属性等）
"""
使用：模块名.工具名
示例：
import random
random.randint(1,6)
"""
② from 模块名 import 工具名
从模块中导入具体的工具名，使用时直接调用工具名即可
"""
使用：工具名
示例：
from random import randint
randint(1,6)
"""
③ from 模块名 import *
从模块中导入该模块中所有内容，不常用
【3】__name__
该属性有两个值，表示当前模块的名称——
① 当该模块直接被执行时 ：值为 __main__
② 当该模块被导入到其他模块时 ：值为 当前模块名
注：
每个模块被导入时 都会执行该模块的代码
若不想某些代码在被导入时执行 可通过以下方式定义
"""
if __name__ == "__main__":
不想被导入时执行的代码
"""
11.2 包
包含 __init__.py文件的目录 称为 包；
当这个包被导入时，会自动加载__init__py文件中的内容
至此 筑基篇 完结
请移步至