字典 集合 序列

一、字典

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[...]])
©️2020 CSDN 皮肤主题: 1024 设计师:上身试试 返回首页