概览：
转码
enumerate枚举
循环里面的坑
数据类型之间的转化
集合
深浅copy
#第一部分 转码
#gbk 与 utf-8之间的转换
#gbk形式的bytes
-->decode('gbk')-->
unicode str字符串
-->encode('utf-8')-->
utf8形式的bytes
#utf8形式的bytes
# -->encode('utf-8')-->
#unicode str字符串
# -->encode('gbk')-->
#gbk形式的bytes
s1 = '我爱北京天安门'
b1 = s1.encode('GB18030') #以GB18030形式编码
print(b1)
s2 = b1.decode('gbk') #把b1解码 请记住 编码与解码的形式必须相同
print(s2,type(s2))
#已知
#b1 = b'\xce\xd2\xb0\xae\xb1\xb1\xbe\xa9\xcc\xec\xb0\xb2\xc3\xc5'
#是以GB18030编码形式编码的bytes数据
#请将其转化成str
b1 = b'\xce\xd2\xb0\xae\xb1\xb1\xbe\xa9\xcc\xec\xb0\xb2\xc3\xc5'
s1 = b1.decode('GB18030')
print(s1)
#已知
#b1 = b'\xce\xd2\xb0\xae\xb1\xb1\xbe\xa9\xcc\xec\xb0\xb2\xc3\xc5'
#是以GB18030编码形式编码的bytes数据
#请将其转化成utf-8编码形式的bytes数据
b1 = b'\xce\xd2\xb0\xae\xb1\xb1\xbe\xa9\xcc\xec\xb0\xb2\xc3\xc5'
s1 = b1.decode('GB18030')
b2 = s1.encode('utf-8')
print(b2)
print(b2.decode('utf-8'))
b'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8' 我爱北京天安门
#非unicode编码的数据 如果是
#英文 数字 特殊字符可以相互转化 他们引用的都是ASICC
s1 = 'alex taibai'
b1 = s1.encode('gbk')
print(b1.decode('GB18030'))
alex taibai
#第二部分 enumerate枚举
#enumerate(可迭代对象，起始编号)
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998}]
for i in enumerate(goods,100):
print(i)
-->
(100, {'name': '电脑', 'price': 1999})
(101, {'name': '鼠标', 'price': 10})
(102, {'name': '游艇', 'price': 20})
(103, {'name': '美女', 'price': 998})
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998}]
for index,item in enumerate(goods,10):
print(index,item['name'],item['price'])
10 电脑 1999 11 鼠标 10 12 游艇 20 13 美女 998
#format()标准化输出
#print(变量1，变量2，变量3)
#print（'{}{}{}'.format(变量1，变量2，变量3))
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998}]
for index,item in enumerate(goods,100):
print('编号：{}，\t名称：{}，\t价格：{}'.format(index,item['name'],item['price']))
编号：100， 名称：电脑， 价格：1999 编号：101， 名称：鼠标， 价格：10 编号：102， 名称：游艇， 价格：20 编号：103， 名称：美女， 价格：998
#元组里面的坑
#元组里面只有一个元素 且没有，
#那么这个元组的数据类型 与这个唯一的数据元素 的数据类型相同
tu1 = (1)
tu2 = ('a')
print(tu1,type(tu1))
print(tu2,type(tu2))
1 <class 'int'> a <class 'str'>
tu1 = (1,)
tu2 = ('a',)
print(tu1,type(tu1))
print(tu2,type(tu2))
(1,) <class 'tuple'>
('a',) <class 'tuple'>
#列表可以直接相加 拼接
l1 = [1,2,3] l2 = ['alex','wusir'] print(l1+l2)
'''[1, 2, 3, 'alex', 'wusir']'''
#for循环里面的坑
#将列表中 索引为奇数的元素 从列表中删除
#在循环使用一个列表的时候，最好不要对此列表进行改变大小的操作 比如 增加元素 删除元素
#方法一
li = [11,22,33,44,55,66,77,88] del li[1::2] print(li)
#方法二 将删除后剩下的元素装入一个新的 列表
li = [11,22,33,44,55,66,77,88]
list1 = []
for i in li :
if li.index(i) % 2 == 0:
list1.append(i)
li = list1
print(li)
#方法三
#从后往前删除
li = [11,22,33,44,55,66,77,88]
for i in range(len(li)-1,-1,-1):
if i % 2 == 1:
li.pop(i)
print(li)
#创建字典的三种方式
#方式1 直接创建
#dic = {'name':alex,'age':18,'job':it}
#方式二 根据定义创建
#dic= dict（{’name'：'alex}）
#方式三 通过keys创建
dic1 = dict.fromkeys(['a','b','c'],[])
print(dic1)
dic1['a'].append('wusir')
print(dic1['a'])
print(dic1['b'])
print(dic1['c'])
print(id(dic1['a']))
print(id(dic1['b']))
print(id(dic1['c']))#指向的是同一个地址
{'a': [], 'b': [], 'c': []}
['wusir']
['wusir']
['wusir']
415105793544
415105793544
415105793544
#for 循环在 字典应用中的坑
#删除key中含有看的键值对
dic = {'key1':'value1','key2':'value2','key3':'value3','k':'v'}
for i in dic:
if 'k' in i :
dic.pop(i)
print(dic)
'''dictionary changed size during iteration'''
#创建一个新的列表 把含有k的key 装进这个列表 循环这个列表
dic = {'key1':'value1','key2':'value2','key3':'value3','a':'v'}
li = []
for i in dic:
if 'k' in i:
li.append(i)
print(li)
for i in li:
if 'k' in i :
dic.pop(i)
print(dic)
#第四部分
#数据类型之间的转化
#str字符串 ---> 列表
#很重要 很重要 很重要
s1 = 'alex wusir taibai' li = s1.split() print(li)
['alex', 'wusir', 'taibai']
#很重要 很重要 很重要
#列表 --> str
li = ['alex', 'wusir', 'taibai'] s1 =''.join(li)#千万记住''放在前面 print(s1) s2 =' '.join(li)#千万记住''放在前面 print(s2) s3 ='*'.join(li)#千万记住''放在前面 print(s3)
alexwusirtaibai alex wusir taibai alex*wusir*taibai
#元组tuple --> list
'''tu1 = (1, 2, 3)
li = list(tu1)
print(li)'''
'''-->[1, 2, 3]'''
#元组 list--> tuple
'''li = [1, 2, 3]
tu = tuple(li)
print(tu)'''
'''(1, 2, 3)'''
#字典 --> list
'''dic = {'name':'alex','age':18}
li = list(dic)
print(li)'''
'''['name', 'age']'''#只输出了 key 因为字典里面实际存储的的也就是 key 数据存放的只是数据的地址
#集合
#set
#表现形式：{'alex',1,2}
#集合里面的数据必须是不可变的类型
#但是集合本身是可变的 数据类型
#集合里面的元素不重复 天然的去重
#集合里面的元素是无序的
#集合 不要与字典搞混了
#集合的创建
'''set1 = {1,2,'alex'}
set2 = set({2,3,'wusir'})'''
#集合的增
'''set2 = set({2,3,'wusir'})
set2.add('女神')
set2.update('中国')#逐个添加 itearable
print(set2)'''
#集合的删除
#set1 = {'alex','wusir','ritian','egon','barry'}
#set1.remove('alex')#按照元素的值删除
#set1.pop()#随机删除
#clear set1 #清空元素
#del set1 删除集合
#集合的运算
#交集 & 或者 intersection
'''set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
#print(set1 & set2)
print(set1.intersection(set2))'''
'''{4, 5}'''
#并集 | 或者 union
'''set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
#print(set1 | set2)
print(set1.union(set2))'''
'''{1, 2, 3, 4, 5, 6, 7, 8}'''
#差集 - 或者different
'''set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1-set2)
print(set1.difference(set2))'''
'''{1, 2, 3}
{1, 2, 3}'''
#反交集
#^ symmetric_diffreence
'''set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1^set2)
print(set1.symmetric_difference(set2))'''
'''{1, 2, 3, 6, 7, 8}'''
#子集 超集
'''set1 = {1,2,3}
set2 = {1,2,3,4,5,6,7,8}
print(set1 < set2)
print(set1.issubset(set2))'''
'''True
True
'''
#冻结集合frozenset
#让集合编程不可变得数据类型
#编程不可变的数据类型之后 可以作为字典的 key
set1 = frozenset({1,2,3})
print(set1,type(set1))
dic = dict.fromkeys(set1,'alex')
print(dic)
frozenset({1, 2, 3}) <class 'frozenset'>
{1: 'alex', 2: 'alex', 3: 'alex'}
#第六部分 深浅copy
#浅copy
#对于浅copy 第一层在内存中是相互独立的
#重第二层开始 以及更深的层数使用的都是统一个地址 一变全变
l1 = [1,2,3,[22,]]
l2 = l1.copy()
l1[-1].append('美女')
print(l2,l1)
print(id(l1),id(l2))
print(id(l1[-1]),id(l2[-1]))
[1, 2, 3, [22, '美女']] [1, 2, 3, [22, '美女']] 405133639176 405135686984 #地址不相同 说明第一层是相互独立的 存放在不同的地址 405148567432 405148567432#地址相同 说明第二层 存放在相同的地址
#深copy
#copy之后的文件 是与原文件事相互独立的 互不影响
import copy
l1 = [1,2,3,[22,]]
l2 = copy.deepcopy(l1)
l1[-1].append('美女')
l1.append(666)
print(l1)
print(l2)
[1, 2, 3, [22, '美女'], 666] [1, 2, 3, [22]]#l1做任何更改 第一层 第二层 的更改 都不会影响 l2
#应用场景
#完全独立的备份 与原数据没有关系的 copy 深copy
#一份数据在第二层 列表的第二层 与元数据进行公用 浅 copy