python初识三

字典

　　ps:数据类型分类：1、不可变数据类型：元组、bool、int、str、（也被称为可哈希）

　　　　　　　　　　 2、可变数据类型：list、dict（不可哈希）

　　字典的Key必须为不可变数据类型，但字典的值value可以为任意数据类型

　　dict 的优点：可以使用二分查找查询、可以存储大量的关系型数据

　　特点：在python3.5之前的版本，字典是无序的

字典的增

dic = {'name':'haohao'}
dic['age'] = 22  # 若无键值对，则增加键值对
print(dic)
dic['name'] = 'huahua'  # 若有键值对，则值覆盖
print(dic)

dic = {'name': 'HaoHao'}
dic.setdefault('age', 22)  # 若无键值对，则增加键值对
print(dic)
dic.setdefault('name', 'HuaHua')  # 若有键值对，则不执行操作
print(dic)

字典的删

dic = {'name': 'HaoHao', 'age': 22, 'hobby': 'IT'}
s = dic.pop('name', None)  # 若键值存在，则删除键，返回值；若不存在返回None(可自定义)
print(s)

dic = {'name': 'HaoHao', 'age': 22, 'hobby': 'IT'}
k,v = dic.popitem()  # 随机删除键值对，返回删掉的键值对
print(k,v)

dic = {'name': 'HaoHao', 'age': 22, 'hobby': 'IT'}
dic.clear()  # 清空字典
print(dic)

dic = {'name': 'HaoHao', 'age': 22, 'hobby': 'IT'}
del dic['name']  # 删除键'name'，没有则会报错
print(dic)
del dic  # 删除字典
print(dic)

字典的改

dic = {'name': 'HaoHao', 'age': 22, 'hobby': 'IT'}
dic['name'] = 'HuaHua'  # 直接对键值进行修改
print(dic)

dic = {'name': 'HaoHao', 'age': 22, 'hobby': 'IT'}
dic2 = {'name': 'HuaHua'}
dic2.update(dic)  # dic的键值对对dic2进行覆盖添加
print(dic2)

字典的查

dic = {'name': 'HaoHao', 'age': 22, 'hobby': 'IT'}
l1 = dic.keys()  # 字典的Key放入列表
l2 = dic.values()  # 字典的值放入列表
l3 = dic.items()  # 将字典的键值对构成一个小元组，放入列表
print(l1, '
', l2, '
', l3)
for k, v in l3:  # 通过循环查询输出键值对
    print(k,v)
s = dic.get('name1', None)  # 通过get获取键值信息，查到后返回对应值,若没有查到返回None(可自定义)
print(s)

字典的嵌套

dic = {'sushe':{1:{'name': 'HaoHao', 'age': 22, 'hobby': 'IT'},
                2:{'name': 'HuaHua', 'age': 20, 'hobby': 'IT'},
                3:{'name': 'AnShao', 'age': 22, 'hobby': 'IT'}},
       'school': 'ShiFan'}
dic['sushe'][4] = {'name': 'QianGe', 'age': 23, 'hobby': 'IT'}  # 添加新的建值对
dic['sushe'][2]['name'] = dic['sushe'][2]['name'].upper()  # 将字典中的某个字符串大写
print(dic)

小知识点总结

　　1、python2与python3的区别

　　　　python2中   print 'abc' 可以加()也可以不加

　　　　　　　　　 range()  xrange()

　　　　　　　　　 raw_input()

　　　　python3中   print ('abc')必须加()

　　　　　　　　　 range()

　　　　　　　　　 input()

　　2、=   ==    is     id

　　　= 赋值

　　　== 比较值是否相等

　　　is 比较内存地址

　　　id  内容地址

l1 = [1, 2, 3]
l2 = [1, 2, 3]
print(l1 is l2)
l3 = l1
print(l1 is l3)
print(id(l1), id(l2), id(l3))

　　3、int     str

　　注意：数字和字符串类型有小数据池（可以节省内存空间）

　　　　数字的范围 -5~256

　　　　字符串：1、不能有特殊字符；2、s*20还是同一个地址，但s*21以后就是不同地址了（python3.7第二点好像不适用）

i1 = 6
i2 = 6
print(i1 is i2, id(i1), id(i2))
s1 = 'abc'
s2 = 'abc'
print(s1 is s2, id(s1), id(s2))

　　4、(1)多个编码规则之间的二进制是不能相互识别的，互相之间会产生乱码

　　　  (2)文件的存储、传输的时候不能是unicode编码方式(可以是utf-8、utf-16、gbk、gb2312等)

　　　  (3)python3的str 在内存中是用unicode编码的，在存储和传输时要转换成bytes类型（utf-8、gbk、gb2312）

　　ps:编码类型的转换方式

　　　　对于英文： str ：表现形式：s = 'alexi'    编码方式为：01010101······(unicode)，

　　　　　　　　　bytes: 表现形式：s = b'alexi'  编码方式为：010101010·······（utf-8、gbk、gb2312）

　　　　对于中文： str :  表现形式： s = '中国'   编码方式为： 0101011110······（unicode）

　　　　　　　　　bytes: 表现形式：s = b'xe4xb8xadxe5x9bxbd'  编码方式为：01010100·····(utf-8、gbk、gb2312)

　　如何将str 转换为 bytes编码方式？encode（）

s1 = '中国'
s2 = s1.encode('utf-8')
print(s2)

　　5、for 、 enumerate 、range

　　　　for：用户按照循环顺序可以遍历可迭代对象的内容

msg = 'akjshgfksg'
for i in msg:
    print(i)

li = [1, 2, 5, 6, 'we']
for i in li:
    print(i)

dic = {'name': 'haohao', 'age': 22}
for k,v in dic.items():
    print(k, v)

　　　　enumerate: 枚举，对于可迭代对象进行遍历时，可同时获得索引和元素，可自定义索引开始值

li = ['haohao', 'huahua', 'xinghui', 'anshao', 'qiange']
for i in enumerate(li):
    print(i, type(i))
for index, name in enumerate(li,1):
    print(index, name)
for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
    print(index, name)

　　　　range: 指定范围，生成指定数字列表

for i in range(10):
    print(i)

for i in range(0, 10, 2):  # 可以设置步长
    print(i)

for i in range(10, 0, -1):  # 倒序时要设置负步长
    print(i)

基础数据类型补充

　　list: 在循环列表时要注意不要删除列表中的内容，因为列表时可变数据类型，在删除列表中内容后会影响循环

　　dict：补充一种字典的建立方式

dic = dict.fromkeys([1, 2, 3], [])  # 迭代添加Key，添加同样的值
print(dic)
dic[1].extend('泰格')
dic[2].append('二哥')
print(dic)
# 要注意的是，这样建的字典和直接定义的字典的不同之处，这种字典中修改一个键值，所有的都会改变，要注意与下面方式的区别

dic = {1: [], 2: [], 3: []}
print(dic)
dic[1].extend('泰格')
dic[2].append('二哥')
print(dic)

　　　　同样，字典也属于可变数据类型，因此与列表一样，在循环字典时不能删除字典的键值对，当想删除字典的键值对时，应

　　先将想要删除的键写入一个列表中，然后在通过循环列表删除字典中的键值对。

dic = {1: [], 2: [], 3: [], 4: []}
li = []
for i in dic:
    if i%2 == 0:  # 删除字典中的偶数键值对
        li.append(i)
for i in li:
    del dic[i]
print(dic)

　　ps:小知识 0 ''  []  {}  set() 转化为 bool 时为False

 　　元组：当元组中只有一个元素时，不加逗号就不是元组

tu1 = (1)
tu2 = (1,)
print(type(tu1), type(tu2))

集合

　　集合是可变数据类型，但集合里面的元素必须是不可变的元素，集合是无序的、不重复的

　集合的增

set = {1, '2', '3', 4, 'q'}
set.add('a')
print(set)
set.update('aq23')  # 迭代增加，但不会重复
print(set)

　集合的删

set = {'w', 't', 'a', 'n', 'p'}
s = set.pop()  # 随机删除，有返回值
print(s, set)

set = {'w', 't', 'a', 'n', 'p'}
set.remove('n')  # 按元素删
print(set)

set1 = {'w', 't', 'a', 'n', 'p'}
set1.clear()  # 清空集合
print(set1)
del set1
print(set1)  # 删除集合

　交集：输出集合1和集合2中重复的元素

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 & set2)
print(set1.intersection(set2))

　并集：输出集合1和集合2中的元素，注意重复的元素只输出一次

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 | set2)
print(set1.union(set2))

　反交集：输出集合1和集合2中不共有的元素

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 ^ set2)
print(set1.symmetric_difference(set2))

　差集：输出集合1中集合2没有的元素

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 - set2)
print(set1.difference(set2))

　子集与超集：如果集合1中所有的元素集合2中都有，相反却不成立，则集合1为2的子集，2为1的超集

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3, 4, 5, 6, 7, 8}
print(set1 < set2)
print(set1.issubset(set2))
print(set2 > set1)
print(set2.issuperset(set1))

　　ps：小技巧补充：因为集合中没有重复元素，所以可以利用集合的特性进行去重

li = [1, 2, 3, 4, 22, 33, 1, 2, 3, 5, 6, 4]
set1 = set(li)
li = list(set1)
print(li)

 　集合的深浅copy

　　1、赋值运算

l1 = [1, 2, 3, {'name': 'HaoHao','age': 22}, 4]
l2 = l1
l1[0] = 111
l1[3]['name'] = 'HuaHua'
print(l1,l2)

　　出现这种结果是因为l2和l1指向了同一个内存地址，所以最后的结果相同

　　2、浅拷贝copy

l1 = [1, 2, 3, {'name': 'HaoHao','age': 22}, 4]
l2 = l1.copy()
print(l1,id(l1))
print(l2,id(l2))
l1[1] = 222
print(l1,id(l1))
print(l2,id(l2))
l1[3]['name'] = 'HuaHua'
print(l1[3], id(l1[3]))
print(l2[3], id(l2[3]))

　　　　出现这种结果的原因是对于浅copy来说，第一层创建了新内存地址，而对第二层甚至更深层来说指向的仍是同一个地址，

　　所以对这些层来说还依然保持着一致性。

　　3、深层拷贝deepcopy

import copy
l1 = [1, 2, 3, {'name': 'HaoHao','age': 22}, 4]
l2 = copy.deepcopy(l1)
print(l1,id(l1))
print(l2,id(l2))
l1[1] = 222
print(l1,id(l1))
print(l2,id(l2))
l1[3]['name'] = 'HuaHua'
print(l1[3], id(l1[3]))
print(l2[3], id(l2[3]))

　　对于深层拷贝来说，两个文件保持完全独立，不会有任何关联，无论多少层，改变任何一个元素另外一个都不会改变