Python基础Day7
七步记忆法：
① 预习（30min）
② 听课 （重点）
③ 课间练习
④ 下午或者晚上练习（大量练习、重复练习）
⑤ 晚上睡觉前的回忆
⑥ 第二天早晨回顾
⑦ 每周总结，自己默写方法
一、enumerate 枚举
对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
将可迭代对象以元组的形式展现。
遍历时用两个变量接受，一个变量接收序号，一个变量接收可迭代对象。
二、编码转换
一种非unicode编码转换为另一种非unicode编码，需要通过unicode来中转；
先解码为unicode编码，再编码为其他非unicode
b1 = b'\xb9\xfe\xb9\xfe' # gbk编码格式
s1 = b1.decode('gbk') # 解码成unicode编码
b2 = s1.encode('utf-8') # 转换为uft-8编码
print(b2)
# 结果
b'\xe5\x93\x88\xe5\x93\x88'
英文字母、数字、特殊字符可以通过其他编码的方式解码，因为utf-8 gbk,unicode等编码的英文字母，数字，特殊字符都是映射的ascii码
b1 = 'abc'.encode('gbk')
s2 = b1.decode('utf-8')
print(s2,type(s2))
# 结果
abc <class 'str'>
三、基础数据类型补充
① 字符串
isspace() # 判断字符串是否全部为空格，全部都是空格返回True，否则返回False
s1 = ' \n \t '
print(s1.isspace()) # 判断字符串是否全部为空格
s2 = ' a '
print(s2.isspace()) # 判断字符串是否全部为空格
# 结果
True
False
② 元组
元组只有一个元素，且没有逗号的情况，跟元素的数据类型一致
tu1 = ([1,2,3]) # 一个列表
tu2 = (1) # 一个数字
print(tu1,type(tu1))
print(tu2,type(tu2))
#结果
[1, 2, 3] <class 'list'>
1 <class 'int'>
只有一个元素，但是加了逗号，都视为元组
tu1 = ([1,2,3],)
tu2 = (1,)
print(tu1,type(tu1))
print(tu2,type(tu2))
# 结果
([1, 2, 3],) <class 'tuple'>
(1,) <class 'tuple'>
③ 列表
在循环一个列表时，如果对列表中的某些元素进行删除，那么此元素后面的所有元素就会前进一位，它们的索引就会发生变化
需求：lis = [11,22,33,44,55,66,77,88,99] 删除所有奇数索引的值
方法一：del 删除
#lis = [11,22,33,44,55,66,77,88,99] 删除所有奇数索引的值
lis = [11,22,33,44,55,66,77,88,99]
del lis[1::2]
print(lis)
# 结果
[11, 33, 55, 77, 99]
方法二： 将元素添加至新列表里
#lis = [11,22,33,44,55,66,77,88,99] 删除所有奇数索引的值
lis = [11,22,33,44,55,66,77,88,99]
lis2 = []
for i in range(len(lis)):
if i % 2 == 0:
lis2.append(lis[i])
lis = lis2
print(lis)
# 结果
[11, 33, 55, 77, 99]
方法三：倒序删除
#lis = [11,22,33,44,55,66,77,88,99] 删除所有奇数索引的值
lis = [11,22,33,44,55,66,77,88,99]
for i in range(len(lis)-1,-1,-1):
if i % 2 == 1:
lis.pop(i)
print(lis)
# 结果
[11, 33, 55, 77, 99]
总结：在循环一个列表时，尽量不要对此列表进行增和删的操作，否则会造成索引的变化。
列表与列表可以相加
l1 = [1,2,3]
l2 = ['a','b']
l3 = l1 + l2
print(l3)
# 结果
[1, 2, 3, 'a', 'b']
④ 字典
总结：循环一个字典时，不能改变字典的大小（即不能对字典进行增删操作）
# 对字典中的的键含有k的删除键值对
dic = {'key1': 'value1','key2': 'value2', 'k3':'v3', 'name': 'xiaoming','age':20}
li = []
for i in dic:
if 'k' in i:
li.append(i)
for j in li:
dic.pop(j)
print(dic)
# 结果
{'name': 'xiaoming', 'age': 20}
创建字典的方法
a. 直接创建
dic = {'name':'xiaoming','age':20}
print(dic)
# 结果
{'name': 'xiaoming', 'age': 20}
b. dict创建
dic = dict({'name':'xiaoming','age':18})
print(dic)
dic1 = dict((['name','xiaoming'],('age',20)))
dic2 = dict([('name','小黑'),['location','深圳']])
print(dic1)
print(dic2)
# 结果
{'name': 'xiaoming', 'age': 18}
{'name': 'xiaoming', 'age': 20}
{'name': '小黑', 'location': '深圳'}
c. 使用dict.fromkeys() 创建
dic = dict.fromkeys([1,2,3],['a','b','c'])
print(dic)
# 结果
{1: ['a', 'b', 'c'], 2: ['a', 'b', 'c'], 3: ['a', 'b', 'c']}
若使用fromkeys()方法创建的字典，值是可变数据类型（列表，字典，集合），所有的键指向的都是同一个
dic = dict.fromkeys([1,2,3],['a','b','c'])
print(dic)
dic[1].append('d') # 在值的容器里添加，所有的值都会变化，因为是同一个容器
print(dic)
dic[2] = []
print(dic)
# 结果
{1: ['a', 'b', 'c'], 2: ['a', 'b', 'c'], 3: ['a', 'b', 'c']}
{1: ['a', 'b', 'c', 'd'], 2: ['a', 'b', 'c', 'd'], 3: ['a', 'b', 'c', 'd']}
{1: ['a', 'b', 'c', 'd'], 2: [], 3: ['a', 'b', 'c', 'd']}
四、数据类型的转换
str ---> list # 使用字符串的方法split()
s1 = 'a b c d e'
lis = s1.split()
print(lis)
# 结果
['a', 'b', 'c', 'd', 'e']
list ---> str # 使用字符串的方法 join（）
lis = ['a', 'b', 'c', 'd', 'e']
s1 = ''.join(lis)
print(s1)
# 结果
abcde
tuple ---> list # list(tuple)
lis = [1,2,3]
tu = tuple(lis)
print(tu)
# 结果
(1, 2, 3)
list ---> tuple # tuple(list)
tu = ('a','b','c')
lis = list(tu)
print(lis)
# 结果
['a', 'b', 'c']
dict ---> list # list(dict)
将字典转为列表，只能把字典的所有键转化为列表
dic = {1:'a',2:'b',3:'c'}
lis = list(dic)
print(lis)
# 结果
[1, 2, 3]
所有类型 ---> bool
s1 = ''
print(bool(s1)) # 空字符转换为bool是False
i = 0
print(bool(i)) # 0转换为bool是False
lis = []
print(bool(lis)) # 空列表转换为bool是False
tu = ()
print(bool(tu)) # 空元组转换为bool是False
dic = {}
print(bool(dic)) # 空字典转换为bool是False
set1 = set()
print(bool(set1)) # 空集合转换为bool是False
# 结果
False
False
False
False
False
False
五、集合
集合一般用于科学运算，大数据，后端开发使用集合相对比较少
集合的元素不重复，无序的
集合里的元素必须时不可变的数据类型（可哈希），但是集合本身是可变的数据类型
集合的主要用途：① 去重 ② 关系测试
重点：
A、列表去重（用集合去重）
lis = [1,1,2,3,5,9,6,3,6,5]
set1 = set(lis)
print(set1)
lis = list(set1)
print(lis)
# 结果
{1, 2, 3, 5, 6, 9}
[1, 2, 3, 5, 6, 9]
B、frozenset()
将集合变成不可变的数据类型
set1 = {1,2,3,4,5,6,7,8}
set2 = frozenset(set1)
print(set1,type(set1))
print(set2,type(set2))
# 结果
{1, 2, 3, 4, 5, 6, 7, 8} <class 'set'>
frozenset({1, 2, 3, 4, 5, 6, 7, 8}) <class 'frozenset'>
集合的创建
set1 = {1,2,3,'a','b','c'}
set2 = ({1,2,3,'a','b'})
print(set1)
print(set2)
# 结果
{1, 2, 3, 'a', 'c', 'b'}
{1, 2, 3, 'a', 'b'}
集合的增
set1 = {1,2,3,'a','b','c'}
set1.add('z')
print(set1)
# 结果
{1, 2, 3, 'z', 'a', 'c', 'b'}
set1 = {1,2,3,'a','b','c'}
set1.update([5,6,8])
print(set1)
# 结果
{1, 2, 3, 5, 6, 'b', 8, 'a', 'c'}
集合的删
set1 = {1,2,3,'a','b','c'}
set1.clear() # 清空集合
print(set1)
# 结果
set()
set1 = {1,2,3,'a','b','c'}
set1.remove(2) # 删除一个元素
print(set1)
# 结果
{'b', 1, 3, 'c', 'a'}
set1 = {1,2,3,'a','b','c'}
print(set1.pop()) # 随机删除一个元素,返回值是被删除的元素
print(set1)
# 结果
1
{2, 3, 'c', 'b', 'a'}
set1 = {1,2,3,'a','b','c'}
del set1 # 删除整个集合
关系测试
set1 = {1,2,3,'a','b','c'}
set2 = {'a','b',5,6,7}
set3 = set1 & set2 # 交集
set4 = set1.intersection(set2) # 交集
print(set3)
print(set4)
# 结果
{'b', 'a'}
{'b', 'a'}
set1 = {1,2,3,'a','b','c'}
set2 = {'a','b',5,6,7}
set3 = set1 | set2 # 并集
set4 = set1.union(set2) # 并集
print(set3)
print(set4)
# 结果
{1, 2, 3, 'b', 5, 6, 7, 'a', 'c'}
{1, 2, 3, 'b', 5, 6, 7, 'a', 'c'}
set1 = {1,2,3,'a','b','c'}
set2 = {'a','b',5,6,7}
set3 = set1 ^ set2 # 反交集
set4 = set1.symmetric_difference(set2) # 反交集
print(set3)
print(set4)
# 结果
{1, 2, 3, 5, 6, 7, 'c'}
{1, 2, 3, 5, 6, 7, 'c'}
set1 = {1,2,3,'a','b','c'}
set2 = {'a','b',5,6,7}
set3 = set1 - set2 # 差集
set4 = set1.difference(set2) # 差集
print(set3)
print(set4)
# 结果
{1, 2, 3, 'c'}
{1, 2, 3, 'c'}
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2) # set1 是 set2 的子集
print(set1.issubset(set2)) # set1 是 set2 的子集
# 结果
True
True
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set2 > set1) # set2 是 set1 的超集
print(set2.issuperset(set1)) # set2 是 set1 的超集
# 结果
True
True
六、深浅拷贝copy
① 浅拷贝copy
l1 = [1,2,3]
l2 = l1.copy() # copy列表l1
l1.append(6)
print(l1 is l2)
print(l1)
print(l2)
结论：复制后的两个列表的id不同
l1 = [1,2,3,['a','b']]
l2 = l1.copy()
l1[-1].append('c') # 在列表里嵌套的列表追加元素
l1.append(5) # 在列表里追加元素
print(l1)
print(l2)
print(l1[3] is l2[3]) # 对比['a', 'b', 'c'] 是否同一个
# 结果
[1, 2, 3, ['a', 'b', 'c'], 5]
[1, 2, 3, ['a', 'b', 'c']]
True
结论：浅拷贝复制最外层是在内存中是独立的，从第二层以及更内层都是使用同一个的内存地址，内层变动复制后的内层也会跟着变动
对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。
l1 = [1,2,3,['a','b']]
l2 = l1[:]
l1[-1].append('c') # 在列表里嵌套的列表追加元素
l1.append(5) # 在列表里追加元素
print(l1)
print(l2)
print(l1[3] is l2[3]) # 对比['a', 'b', 'c'] 是否同一个
# 结果
[1, 2, 3, ['a', 'b', 'c'], 5]
[1, 2, 3, ['a', 'b', 'c']]
True
结论：使用l2 = l1[:]复制也是浅拷贝
② 深拷贝ccopy
import copy
l1 = ['a','b','c',[6,7,8]]
l2 = copy.deepcopy(l1)
l1[-1].append(9)
l1.append('z')
print(l1)
print(l2)
# 结果
['a', 'b', 'c', [6, 7, 8, 9], 'z']
['a', 'b', 'c', [6, 7, 8]]
结论：深拷贝copy是完全独立的，原列表嵌套的内容进行修改也不会影响新列表
两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。
应用场景：面试会考，解释深浅copy
完全独立的copy一份数据，与原数据没有关系，深copy
如果一份数据（列表）第二层时，你想与原数据进行公用，浅copy。
八、昨日内容回顾
小数据池：
前提：int,str,bool
1，节省内存。
2，提高性能和效率。
在内存中，创建一个'池'，提前存放了 -5 ~256 的整数，一定规则的字符串。
后续程序中，如果设置的变量指向的是小数据池的内容，那么就不会再内存中重新创建。
小数据池与代码块的关系：
同一个代码块：python在执行时，遇到了初始化对象命令，他会将这个变量名和数值放到一个字典中，
再次遇到他会从这字典中寻找。
不同代码块：python在执行时，直接从小数据池中寻找，满足条件id相同。
