字典 集合 序列

一、字典

1、可变类型与不可变类型

1）序列是以连续的整数为索引，与此不同的是，字典以“关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值
2）字典是Python唯一的一个映射类型，字符串、元组、列表属于序列类型
3）如何快速判断一个数据类型x是不是可变类型？
①麻烦方法:用id(X)函数，对X进行某种操作，比较操作前后的Id,如果不一样，则X不可变,如果一样，则X可变
②便捷方法：用hash(X)，只要不报错，证明X可被hash，即不可变，反过来不可被hash，即可变。

i=1
print(id(i))
i = i + 2
print(id(i))  
#整数i在加1之后和之前不一样，因此加完后的i不是之前的i,姑整数时不可变类型。

l = [1,2]
print(id(l))

l.append('Python')
print(id(l))

#列表l在附加'Python'之后的id和之前一样，因此列表是可变类型

140722039529872
140722039529936
1429949042760
1429949042760

#数值、字符和元组都能被hash，因此是不可变类型
print(hash('Name'))
print(hash((1,2,'Python')))

#列表、集合、字典不能被hash，因此是可变类型
print(hash([1,2,'Python'])) #报错 unhashable type:'list'
print(hash({1,2,3})) #报错 unhashable type:'set'

-1725622109172748539
4943630497369693706



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-98ba1b7a22e9> in <module>
      1 print(hash('Name'))
      2 print(hash((1,2,'Python')))
----> 3 print(hash([1,2,'Python'])) #报错
      4 print(hash({1,2,3}))


TypeError: unhashable type: 'list'

2.字典的意义

字典是无序的键:值(key:value)对集合，键必须是互不相同的（在同一个字典之内）
1）dict内部存放的顺序和key放入的顺序是没有关系的
2）dict 查找和插入的速度极快，不会随着key的增加而增加，但是需要占用大量的内存
3）字典定义语法为{元素1，元素2，…，元素n)
其中每一个元素是一个键值对–键:值 key:value
关键点是大括号{} 逗号, 冒号：
{}把所有元素绑在一起
,将每个键值对分开
： 将建和值分开

3.创建和访问字典

brand = ['李宁','耐克','阿迪达斯']
slogan = ['一切皆有可能','Just do it','Impossible is nothing']
print('耐克的口号是：',slogan[brand.index('耐克')])

dic = {'李宁':'一切皆有可能','耐克':'Just do it','阿迪达斯':'Impossible is nothing'}
print('耐克的口号是:',dic['耐克'])

耐克的口号是： Just do it
耐克的口号是: Just do it

#通过字符串或数值作为key来创建字典
dict1 = {1:'one',2:'two',3:'three'}
print(dict1)
print(dict1[1])
#print(dict1[4])  报错 KeyError:4

dict2 = {'rice':35,'wheat':101,'corn':67}
print(dict2)
print(dict2['rice'])

{1: 'one', 2: 'two', 3: 'three'}
one
{'rice': 35, 'wheat': 101, 'corn': 67}
35

#通过元组作为key来创建字典，但一般不这样用
dic = {(1,2,3):"Tom","Age":12,3:[3,5,7]}
print(dic)
print(type(dic))

{(1, 2, 3): 'Tom', 'Age': 12, 3: [3, 5, 7]}
<class 'dict'>

#通过构造函数dict来创建字典
#dict()创建一个空的字典

#通过key直接把数据放入字典中，但一个key只能对应一个value，多次对一个key放入value,后面的值会把前面的值冲掉
dic = dict()
dic['a'] =  1
dic['b'] = 2
dic['c'] = 3

print(dic)

dic['a'] = 11
print(dic)

dic['d'] = 4
print(dic)

{'a': 1, 'b': 2, 'c': 3}
{'a': 11, 'b': 2, 'c': 3}
{'a': 11, 'b': 2, 'c': 3, 'd': 4}

# dict(mapping) new dictionary initialized from a mapping object's (key,value)pairs

dic1 = dict([('apple',4139),('peach',4127),('cherry',4098)])
print(dic1)
dic2 = dict((('apple',4139),('peach',4127),('cherry',4098)))
print(dic2)

{'apple': 4139, 'peach': 4127, 'cherry': 4098}
{'apple': 4139, 'peach': 4127, 'cherry': 4098}

#dcit(**kwargs) → new dictionary initialized with the name=value pairs in the keyword argument list.For example:dic(one=1,two=2)
#这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误
dic = dict(name='TOm',age=10)
print(dic)
print(type(dic))

{'name': 'TOm', 'age': 10}
<class 'dict'>

4.字典的内置方法

#1）dict.fromkeys(deq[,value])用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
seq = ('name','age','sex')
dic1 = dict.fromkeys(seq)
print(dic1)

dic2 = dict.fromkeys(seq,10)
print(dic2)

dic3 = dict.fromkeys(seq,('小马','8','男'))
print(dic3)

{'name': None, 'age': None, 'sex': None}
{'name': 10, 'age': 10, 'sex': 10}
{'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}

#2） dic.keys()返回一个可迭代对象，可以使用List()来转换为列表，列表为字典中的所有键
dic = {'Name':'lsgogroup','Age':7}
print(dic.keys())
lst = list(dic.keys())
print(lst)

dict_keys(['Name', 'Age'])
['Name', 'Age']

#3) dict.values()返回一个迭代器，可以使用List()来转换为列表，列表为字典中的所有值
dic = {'Sex':'female','Age':7,'Name':'Zara'}
print(dic.values())

print(list(dic.values()))

dict_values(['female', 7, 'Zara'])
['female', 7, 'Zara']

#4) dict.items()以列表返回可遍历的（键，值）元组数组
dic = {'Name':'Lsgogroup','Age':7}
print(dic.items())

print(tuple(dic.items()))
print(list(dic.items()))

dict_items([('Name', 'Lsgogroup'), ('Age', 7)])
(('Name', 'Lsgogroup'), ('Age', 7))
[('Name', 'Lsgogroup'), ('Age', 7)]

#5) dict.get(key,default=None)返回指定键的值，如果值不在字典中返回默认值
dic = {'Name':'Lsgogroup','Age':27}
print("Age值为 ： %s" % dic.get('Age'))
print("Sex值为: %s" % dic.get('Sex',"NA"))
print(dic)

Age值为 ： 27
Sex值为: NA
{'Name': 'Lsgogroup', 'Age': 27}

#6) dict.setdefault(key,default=None)和get()方法类似，如果键不存在于字典中，将会添加键并将值设为默认值
dic = {'Name':'Lsgogroup','Age':27}
print("Age值为 ： %s" % dic.setdefault('Age',None))
print("Sex值为: %s" % dic.setdefault('Sex',None))
print(dic)

Age值为 ： 27
Sex值为: None
{'Name': 'Lsgogroup', 'Age': 27, 'Sex': None}

# 7）key in dict
# in操作符用于判断键是否存在于字典中，如果在返回true，否则false；not in 刚好相反
dic = {'Name':'Lsgogroup','Age':27}

# in 检测Age是否存在
if 'Age' in dic:
    print("键 Age 存在")
else:
    print("键 Age 不存在")
    
# 检测键Sex是否存在
if 'Sex' in dic:
    print("键 Sex 存在")
else:
    print("键 Sex 不存在")
      
# not in 检测Age是否存在
if 'Age' not in dic:
    print("键 Age 不存在")
else:
    print("键 Age 存在")
    

键 Age 存在
键 Sex 不存在
键 Age 存在

print("Age值为 ： %s" % dic.get('Age'))
print("Sex值为: %s" % dic.get('Sex',"NA"))
print(dic)

# 8）dict.pop(key[,default])删除字典给定键key所对应的值，返回值为被删除的值。
#key值必须给出，若key不存在，则返回default值
# del dict[key] 删除字典给定键key所对应的值
dic1 = {1:"a",2:[1,2]}
print(dic1.pop(1),dic1)
#设置默认值，必须添加，否则报错
print(dic1.pop(3,"nokey"),dic1)

del dic1[2]
print(dic1)

a {2: [1, 2]}
nokey {2: [1, 2]}
{}

# 9)dict.popitem()随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常
dic1 = {1:"a",2:[1,2]}
print(dic1.popitem())
print(dic1)

(2, [1, 2])
{1: 'a'}

# 10) dict.clear()用于删除字典内所有元素
dic = {'Name':'Zara','Age':7}
print("字典长度： %d" % len(dic)) #字典长度:2
dic.clear()
print("地点删除后长度: %d" % len(dic))

字典长度： 2
地点删除后长度: 0

# 11) dict.copy返回一个字典的浅复制
dic1 = {'Name':'Lsgogroup','Age':7,'Class':'First'}
dic2 = dic1.copy()
print(dic2)

{'Name': 'Lsgogroup', 'Age': 7, 'Class': 'First'}

#直接复制和copy的区别
dic1 = {'user':'lsgogroup','num':[1,2,3]}

#引用对象
dic2 = dic1
#浅拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dic3 = dic1.copy()

print(id(dic1))
print(id(dic2))
print(id(dic3))

#修改data数据
dic1['user'] = 'root'
dic1['num'].remove(1)

print(dic1)
print(dic2)
print(dic3)

1429950594008
1429950594008
1429950594168
{'user': 'root', 'num': [2, 3]}
{'user': 'root', 'num': [2, 3]}
{'user': 'lsgogroup', 'num': [2, 3]}

# 12) dict.update(dict2)把字典参数dict2的key:value对 更新到字典dict里
dic = {'Name':'Lsgogroup','Age':27}
dic2 = {'Sex': 'female','Age':8}
dic.update(dic2)
print(dic)

{'Name': 'Lsgogroup', 'Age': 8, 'Sex': 'female'}

练习题：
1、字典基本操作
字典内容如下:
dic = {
‘python’: 95,
‘java’: 99,
‘c’: 100
}
用程序解答下面的题目
字典的长度是多少
请修改’java’ 这个key对应的value值为98
删除 c 这个key
增加一个key-value对，key值为 php, value是90
获取所有的key值，存储在列表里
获取所有的value值，存储在列表里
判断 javascript 是否在字典中
获得字典里所有value 的和
获取字典里最大的value
获取字典里最小的value
字典 dic1 = {‘php’: 97}， 将dic1的数据更新到dic中
2、字典中的value
有一个字典，保存的是学生各个编程语言的成绩，内容如下
data = {
‘python’: {‘上学期’: ‘90’, ‘下学期’: ‘95’},
‘c++’: [‘95’, ‘96’, ‘97’],
‘java’: [{‘月考’:‘90’, ‘期中考试’: ‘94’, ‘期末考试’: ‘98’}]
}
各门课程的考试成绩存储方式并不相同，有的用字典，有的用列表，但是分数都是字符串类型，请实现函数transfer_score(score_dict)，将分数修改成int类型

def transfer_score(data):
# your code here

二、集合

'''
Python中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的Key
注:key为不可变类型，即可hash的值
'''
num = {}
print(type(num))
num = {1,2,3,4}
print(type(num))

<class 'dict'>
<class 'set'>

1、集合的创建

#先创建对象再加入元素
#在创建空集合时只能用s = set()，因为s = {}创建的是孔子点
basket = set()
basket.add('apple')
basket.add('banana')
print(basket)

{'banana', 'apple'}

2、访问集合中的值

3、集合的内置方法

4、集合的转换

5、不可变集合

三、序列

#在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

1、针对序列的内置函数

#1)list(sub)把一个可迭代对象转换为列表

#2)tuple(sub)把一个可迭代对象转换为元组

#3）str(obj)把obj对象转换为字符串

#4）len(s)返回对象（字符、列表、元组等）长度或元素个数

#5）max(sub)返回序列或参数集合中的最大值

#6）min(sub)返回序列或参数集合中的最小值

#7）sum(iterable[,start=0])返回序列iterable与可选参数start的综合

#8) sotred(iterable,key=None,reverse=False)对所有可迭代对象进行排序操作

#9）reversed(seq)函数返回一个反转的迭代器

#10）zip(iter1,[,iter2[...]])