day06_python_1124

01 昨日内容回顾
字典：
增：
setdefault() 有责不变，无责添加
dic['key'] = vaulue
删：
pop 按照key
pop('key')
pop('key',None)
popitem() 删除最后一个
clear 清空
del dic['key']
改：
dic['key'] = 'v'
update()
dic1.update(dic) : dic的所有的键值对覆盖并添加到dic1中，dic不变
dic1.update(name='alex')
查：
dic['key']
dic.get('key')
dic.get('key','设置返回值')

for i in dic:
print(i)
dic.keys() dic.values() dic.items() 类似于列表的容器，没有索引但是可以for循环去遍历。

a, b = [11, 22]
a, b = 11, 22
a, b = b, a
创建字典的三种方式：
dic = {'name': 'alex'}
dic = dict()
dic = dict(name='alex', age='12')
dic = dict({'name': 'alex', 'age': 12})
dict.fromkeys('abc','alex')

02 作业讲解

#03 id is ==

04 小数据池(了解)

03 数据类型的补充（总结） ***
int
str
bool
list
tuple
dict
set
05 编码
ascii:早期的密码本 英文字母，数字，特殊字符。
00000001 a
00000010 b

8位(bit) == 1 byte
在ascii码中 8位一个字节表示一个字符。
'hello'
01101000 01100101 01100111 01100111 01100110

unicode :万国码，将全世界所有的文字全都包含进去
起初：
a : 0000 0000 0001 0010
中: 0000 0000 1001 0010

升级：
一个字符 用32位 4个字节表示
a : 0000 0000 0001 0010 0000 0000 0001 0010
中: 0000 0000 1001 0010 0000 0000 1001 0010
浪费资源。

utf-8:最少用8位表示一个字符
a : 0000 0010 8位表示一个字符
欧洲： 0000 0010 0010 0000 16位 两个字节表示一个字符
中： 0000 0010 0000 0010 0000 0010 24位 3个字节表示一个字符

gbk:国标 只包含英文与自己国家的文字
a: 0000 0010 8位一个字节表示一个字符
中：0000 0010 0000 0010 16位 两个字节表示一个字符

# 以上四个编码本：
1，不同的编码之间能否互相识别（报错或者出现乱码）。 不能！！
2， 规定：文字通过网络传输，或者硬盘存储不能使用Unicode编码方式。

大前提：
python3x环境：
唯独str类型：他在内部编码方式是unicode
所以 python3x中的字符串不能用于直接的网络传输 文件的存储 '中午请我去吃饭'

补充一个数据类型：bytes类型 与str类型是海尔兄弟。
为啥要有bytes：
bytes内部编码方式非unicode

为啥还要有str？ bytes直接就解决了所有问题呀?
bytes 中文是16进制表示，看不懂。
英文：
str：
表现形式：'alex'
内部编码：unicode

bytes：
表现形式：b'alex'
内部编码：非unicode

中文：
str：
表现形式：'屌丝'
内部编码：unicode

bytes：
表现形式：b'\xe5\xb1\x8c\xe4\xb8\x9d''
内部编码：非unicode

bytes：当你需要网络传输数据，文件存储数据时要考虑到bytes。

str ---> bytes(gbk utf-8)
unicode ---> gbk utf-8
06 深浅copy
07 集合（了解）

03 数据类型的补充

# int
# str
# bool
# list
# tuple
# dict
# set
# 数据类型之间的转换：
# str ---> list split ***
# list ---> str join ***

# bool ：False 0 '' [] () {} set() ***
# list <---> tuple
# l1 = [1,2,3]
# tu1 = tuple(l1)
# l2 = list(tu1)
# print(tu1)
# print(l2)

# list <---- dict
# dic1 = {'name': 'alex', 'age': 12}
# # print(list(dic1))

# tuple <---- dict
# dic1 = {'name': 'alex', 'age': 12}
# print(tuple(dic1))

# list <---> set ***

# 元组中只有一个元素并且没有逗号，则他不是元组与元素数据类型相同。
# tu1 = (1,)
# tu2 = ('alex',)
# tu3 = ([1,2,3],)
# print(tu1, tu2, tu3)

# list

# li = [11, 22, 33, 'alex', 55]
# 将列表中索引为奇数位的元素删除。
# 方法一：
# del li[1::2]
# print(li)

# 错误实例：
# for index in range(len(li)):
# if index % 2 == 1:
# li.pop(index)
# print(li)
# 在循环一个列表时，最好不要改变列表的大小，这样会影响你的最终结果

# 方法二：
# new_l1 = []
# for index in range(len(li)):
# if index % 2 == 0:
# new_l1.append(li[index])
# li = new_l1
# print(li)

# 方法三：倒叙循环列表 删除索引为奇数的元素
# for index in range(len(li)-1,-1,-1):
# if index % 2 == 1:
# li.pop(index)
# print(li)
# # for i in range(1,11):
# # print(i)
#
# for i in range(10,0,-1):
# print(i)

# dict 在循环一个字典时，不能改变字典的大小，会报错
dic = {'k1':1,'k2':2, 'k3': 3, 'name': '太白'}
# 将字典中键含有k元素的键值对删除
#
# for key in dic:
# if 'k' in key:
# dic.pop(key)
# l1 = []
# for key in dic:
# if 'k' in key:
# l1.append(key)
# # print(l1)
# for k1 in l1:
# dic.pop(k1)
# print(dic)

04 小数据池

# == 比较的两边的数据是否完全相同。
name = 'alex'
name1 = 'alex'

# print(name == name1)
# id
# print(id(name))
# print(id(name1))
# is 判断的是两个对象的内存地址是否相同。
# l1 = [1, 2, 3]
# l2 = [1, 2, 3]
# print(l1 == l2)
# print(l1 is l2)
# print(name is name1)

# 代码块
# 代码全都是基于代码块去运行的（好比校长给一个班发布命令），一个文件就是一个代码块。
# 不同的文件就是不同的代码块。
# 终端：

# 两种优化机制： 小数据池，代码块内的缓存机制。

# 代码块内的缓存机制
# Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，
# 如果存在，会将其重用。换句话说：执行同一个代码块时，
# 遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，
# 在遇到新的变量时，会先在字典中查询记录，
# 如果有同样的记录那么它会重复使用这个字典中的之前的这个值。
# 所以在你给出的例子中，文件执行时（同一个代码块）会把i1、i2两个变量指向同一个对象，
# 满足缓存机制则他们在内存中只存在一个，即：id相同。
# 注意：
# 机制只是在同一个代码块下！！！，才实行。
# 满足此机制的数据类型：int str bool。
# n = 100
# n1 = 100
# n2 = 100

# l1 = [1, 2, 3]
# l2 = [1, 2, 3]
# print(l1 is l2) # False

# 优点：
# 1，节省内存。
# 2，提升性能。

# 小数据池（驻留机制，驻村机制，字符串的驻存机制，字符串的缓存机制等等）
# 不同代码块之间的优化。
# 适应的数据类型：str bool int
# int： -5 ~256
# str: 一定条件下的str满足小数据池。
# bool值 全部。

# 优点：
# 1，节省内存。
# 2，提升性能。

# 总结：

# 如果你在同一个代码块中，用同一个代码块中的缓存机制。
# 如果你在不同代码块中，用小数据池。

05 编码进阶

# bytes
# s1 = 'alex'
# b1 = b'alex'
# print(b1,type(b1))
# print(b1.upper())
# s1 = b'屌丝'
# b1 = s1.encode('utf-8')
# print(s1)
# s1 = '太白'
# unicode ---> gbk 字符串 ---> gbk编码方式的bytes
# b1 = s1.encode('gbk') # 编码
# s2 = b1.decode('gbk') # 解码
# print(s2)

# s2 = '太白'
# unicode ---> utf-8 字符串 ---> utf-8 编码方式的bytes
# b2 = s2.encode('utf-8')
# s3 = b2.decode('utf-8')
# print(s3)

# gbk ---> utf-8
#
# b1 = b'\xcc\xab\xb0\xd7' # gbk编码的bytes类型
# s = b1.decode('gbk')
# b2 = s.encode('utf-8') # utf-8编码的bytes类型
# print(b2)

# s1 = 'いらないよ'
# b = s1.encode('shift_jis') #
# s2 = b.decode('shift_jis')
# # print(b)
# print(s2)

06 深浅copy

# 赋值运算
# l1 = [1, 2, 3]
# l2 = l1
# l2.append(666)
# print(l1, l2)

# 浅copy
# 在内存中创建一个新的list(dict)，但是新的列表里面的元素还是与原列表共用一个。
# l1 = [1, 'alex', [11,22]]
# l2 = l1.copy()
# print(id(l1),id(l2))
# l1.append(33)
# print(l1,l2)
# print(id(l1[0]))
# print(id(l2[0]))
# print(id(l1[-1]))
# print(id(l2[-1]))
# print(l1 is l2)
# l1[-1].append(666)
# print(l1)
# print(l2)

# 深copy
# 深copy会在内存中对原列表（dict）以及列表里面的可变的数据类型重新创建一份，
# 而 列表中不可变的数据类型还是沿用原来的。
import copy
# l1 = [1, 'alex', [11,22]]
# l2 = copy.deepcopy(l1)
# # l1[0] = 1000
# print(l1)
# print(l2)
# # print(id(l1))
# print(id(l2))
# print(id(l1[-1])) # 2190627337480
# print(id(l2[-1])) # 2190627338888
# print(id(l1[0]))
# print(id(l2[0]))
# l1[-1].append(666)
# print(l1)
# print(l2)

# 全切得到的列表是对原列表进行的浅copy
# l1 = [1, 2, 3, [22,33]]
# l2 = l1[:] # [::]
# l1[-1].append(666)
# print(l2)

07 集合

# 集合里面的元素必须是不可变类型（可哈希）
# set1 = {1, 2, "子豪", ["alex", "tiger"]}
# print(set1)

# 1 集合的创建 *
# set1 = {1, 2, "alex", "barry"}
# print(set1)
# set2 = set((1, 2, "alex"))
# print(set2, type(set2))

# 2 增加 *
# # add
# set1 = {'alex','wusir','ritian','egon','barry'}
# # set1.add("tiger")
# # print(set1)
# # update 迭代着增加
# set1.update("alex")
# print(set1)

# # 3 删除 *
# set1 = {'alex','wusir','ritian','egon','barry'}
# set1.remove("alex") # 删除指定的元素
# print(set1)

# set1.pop() # 随机删除一个元素
# print(set1)

# set1.clear() # 清空集合
# print(set1)

# del set1 # 删除集合
# print(set1)

# # 面试必考 *****
# list1 = [1, 2, 3, 4, 5]
# list2 = [2, 3, 4, 5, 6]
#
# new_list = list1 + list2
# print(new_list)
#
# new_set = list(set(new_list))
# print(new_set, type(new_set))

# 集合的其他操作
# set1 = {1,2,3,4,5}
# set2 = {4,5,6,7,8}

# 交集
# print(set1 & set2)
# print(set1.intersection(set2))

# 并集
# print(set1 | set2)
# print(set1.union(set2))

# 差集
# print(set1 - set2)
# print(set1.difference(set2))

# 反交集
# print(set1 ^ set2)
# print(set1.symmetric_difference(set2))

# 子集和超集
# set1 = {1,2,3}
# set2 = {1,2,3,4,5,6}

# print(set1 < set2)
# print(set1.issubset(set2))

# print(set2 > set1)
# print(set2.issuperset(set1))

# frozenset不可变集合, 让集合变成不可变类型
set2 = {1,2,3,4,5,6}
set3 = frozenset(set2)
print(set3, type(set3))