Python基础：字典、元组

不念不忘少年蓝@ 2022-03-31 08:50 406阅读 0赞

一、概述
1.字典是一个无序的，可以修改的，元素呈键值对的形式，以逗号分割的，以大括号包围的序列。

2.字典是python基础数据类型当中唯一一个映射关系的数据类型。

3.由于字典无序，所以我们定义字典和字典生成之后的元素的顺序是不同的。

4.字典的格式：
key:value 键值对
变量名={key1:value1,key2:value2,…}

平常我们生活中字典非常常见，一般都是由一些如偏旁部首或是拼音首字母等来查相关的字的，当我们查字典时用到的前几页

目录中的偏旁部首或拼音首字母就相当于这里的key，而查到的字就是value。

5.注意：
使用的符号都是英文，一定定义变量的时候不能定义成dict ；

字典的key只能是不可变数据类型，而value可以为任意数据类型

不可变数据类型(可哈希数据类型，就是用哈希算法算出来的数据类型)， 可变数据类型(不可哈希数据类型)。

6.说明：字典和列表一样，也能够存储多个数据，字典中的值并没有特殊顺序；

列表中找某个元素时，是根据下标进行的，如果下标很多，查找数据不方；

当索引不好用时，使用字典，字典中找某个元素时字典的每个元素由2部分组成，键:值。

例如 ‘name’:‘班长’ ,’name’为键，’班长’为值，字典由键值组成。

二、字典操作
1.创建字典

  1. dic={'name':'zs','age':19,'sex':'男'}
  2. print(dic)
  3. print(type(dic))
  4. dic1={'name':'azy',23:'dcv',(1,2):'lyc'}
  5. print(dic1)
  6. #dic2={['name','sg']:'azy',23:'dcv',(1,2):'lyc'}
  7. #TypeError: unhashable type: 'list'
  8. {'name': 'zs', 'age': 19, 'sex': '男'}
  9. <class 'dict'>
  11. {'name': 'azy', 23: 'dcv', (1, 2): 'lyc'}

2.增加操作
（1）dic.setdefault()增加操作时，如果键在字典中已经存在了，就不会覆盖字典中的值，如下第三行代码是不会对原字典的weight值进行改变的，仍为120。

  1. dic.setdefault('weight',120)
  2. print(dic)
  3. dic.setdefault('weight',140)
  4. print(dic)
  5. {'name': 'zs', 'age': 19, 'sex': '男', 'weight': 120}
  6. {'name': 'zs', 'age': 19, 'sex': '男', 'weight': 120}

（2）根据key来设置value，若key存在就覆盖掉原来的值。

  1. dic['weight']=140
  2. print(dic)
  3. dic['weight']=135
  4. print(dic)
  5. {'name': 'zs', 'age': 19, 'sex': '男', 'weight': 140}
  6. {'name': 'zs', 'age': 19, 'sex': '男', 'weight': 135}

3.删除操作
（1）根据key进行删除，删除一个键值对

  1. dic.pop('sex')
  2. print(dic)
  3. {'name': 'zs', 'age': 19, 'weight': 135}

（2）随机删除一个键值对

  1. dic.popitem()
  2. print(dic)
  3. {'name': 'zs', 'age': 19}

（3）清空字典中的键值对，使字典成为一个空字典dic={}

  1. dic.clear()
  2. print(dic)

(4)直接从内存中删除字典类型的变量，打印结果会报错

  1. del dic
  2. print(dic)

4.修改操作
（1）根据key来修改value

  1. dic['name']='mm'
  2. print(dic)
  3. {'name': 'mm', 'age': 19}

（2）利用update方法来修改

  1. dic2={'name':'baibai','age':20,'weight':120}
  2. dic.update(dic2)
  3. print(dic)
  4. {'name': 'baibai', 'age': 20, 'weight': 120}

5.查找操作
（1）根据key来获取对应的value，可定义一个变量接收返回的值

  1. v=dic.get('name')
  2. print(v)
  3. baibai

（2）获取所有的key，并返回所有key组成的列表

  1. k=dic.keys()
  2. print(k)
  3. dict_keys
  4. (['name', 'age', 'weight'])

（3）获取所有的value，并返回所有的value组成的列表

  1. v1=dic.values()
  2. print(v1)
  3. dict_values(['baibai', 20, 120])

（4）以元组的的形式返回字典中的每一个键值对

  1. v2=dic.items()
  2. print(v2)
  3. print(type(v2))
  4. dict_items
  5. ([('name', 'baibai'), ('age', 20), ('weight', 120)])
  6. <class 'dict_items'>

（5）获取键值对的个数并返回键值对的个数

  1. v3=len(dic)
  2. print(v3)

3
（6）利用元组以及fromkeys方法生成字典

  1. tup=(1,2,3)
  2. ret=dic.fromkeys(tup)
  3. print(ret)
  4. ret2=dic.fromkeys(tup,'aa')
  5. print(ret2)
  6. {1: None, 2: None, 3: None}
  7. {1: 'aa', 2: 'aa', 3: 'aa'}

6.in 和 not in
in
判断指定的键是否在字典当中，即将被废除，之后我们python3用in

for…in…
通过for … in …:的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构。

not in
判断指定的键是否不在字典当中

  1. if 'name' in k:
  2.     dic['name']='jx'
  3. else:
  4.     dic['name']='ngls'
  5. print(dic)
  6. if 'height' not in k:
  7.     dic['height']=180
  8. else:
  9.     dic['height']=160
  10. print(dic)
  11. s1=dic.get('sex',1)
  12. print(s1)
  13. for i in k:
  14.     print(i)
  15. for key in dic:
  16.     print(key)
  17. for item in dic.items():
  18.     print(item)
  19. for key,value in dic.items():
  20.     print(key,value)

三、字典的特点
因为字典是无序的，所以字典没有索引值；

因为字典没有索引值，所以字典以键取值，(字典的键相当于列表的索引)；

因为字典以键取值，所以字典的键唯一且不可修改；

因为字典的键不可修改，所以列表和字典等可变类型的数据不可以给字典做键。

集合：
一、概述
‘’‘无序的可修改的序列’’’

集合与之前列表、元组类似，可以存储多个数据，但是这些数据是不重复的(具有自动去重功能)。

集合对象还支持交集(intersection),差集(difference)、并集和对称差集(sysmmetric_difference)，即关系测试。

(集合的基本功能包括关系测试和消除重复元素)

集合定义：

变量名={元素1，元素2，元素3，…}

元素不能为可变数据类型

变量名=set(可迭代内容) 例如 变量名=set(元组，自动，字符串)

可迭代内容：列表，字符串，元组，字典
二、集合的操作
1.创建集合
（1）按照集合的格式直接创建

注意：True会转换成1，False会转换成0，集合的最大作用就是去重复，默认去掉后边重复的

  1. set1={'a',True,1,(1,2,3),0,False}#{0, True, 'a', (1, 2, 3)}
  2. print(set1)
  3. print(type(set1))
  4. {0, 'a', True, (1, 2, 3)}
  5. <class 'set'>

（2）用列表以及set函数生成集合

  1. lst=[1,2]
  2. set2=set(lst)
  3. print(set2)
  4. {1, 2}

（3）用字符串以及set函数生成集合

  1. str1='hello'
  2. set3=set(str1)
  3. print(set3)
  4. {'l', 'e', 'h', 'o'}

（4）用元组以及set函数生成集合

  1. tup=(1,3,4)
  2. set5=set(tup)
  3. print(set5)
  4. {1, 3, 4}

（5）用字典以及set函数生成集合

{‘a’, ‘b’}，字典只会输出key值

  1. dic={'a':13,'b':18}
  2. set6=set(dic)
  3. print(set6)
  4. {'a', 'b'}

（6）创建空集合

  1. set2=set()
  2. print(set2)
  3. print(type(set2))
  4. set()
  5. <class 'set'>

2.增加操作
（1）利用add方法添加

  1. set1.add('舞')
  2. print(set1)
  3. {0, True, (1, 2, 3), 'a', '舞'}

（2）利用update方法添加

  1. set_1={'舞','aa'}
  2. set1.update(set_1)
  3. print(set1)
  4. {0, True, (1, 2, 3), 'a', '舞', 'aa'}

3.删除操作
（1）利用pop方法随机删除集合中的一个元素

  1. set1.pop()
  2. print(set1)
  3. {True, (1, 2, 3), 'a', '舞', 'aa'}

（2）利用remove方法指定删除集合中的元素

  1. set1.remove('a')
  2. print(set1)
  3. {True, (1, 2, 3), '舞', 'aa'}

（3）利用clear方法清空集合中的元素成为一个空集合set（）

  1. set1.clear()
  2. print(set1)
  3. set（）

（4）利用del直接从内存中删除集合

输出会报错

  1. del set1
  2. print(set1)

4.遍历集合

  1. for i in set1:
  2.     print(i)
  3. True
  4. (1, 2, 3)
  5. 舞
  6. aa

三、关系测试
1.交集（&或intersection，取公共部分）

  1. se={1,2,3,4}
  2. se1={3,4,5,6}
  3. print(se&se1)
  4. print(se.intersection(se1))
  5. {3, 4}
  6. {3, 4}

2.反交集（^或symmetric_difference,取非公共部分）

  1. print(se^se1)
  2. print(se.symmetric_difference(se1))
  3. {1, 2, 5, 6}
  4. {1, 2, 5, 6}

3.并集（|或union，获取两集合全部内容，自动去重）

  1. print(se|se1)
  2. print(se.union(se1))
  3. {1, 2, 3, 4, 5, 6}
  4. {1, 2, 3, 4, 5, 6}

4.差集（-或difference，取set1或set2除去set1与set2的公共部分）

  1. print(se-se1)
  2. print(se.difference(se1))
  3. print(se1-se)
  4. print(se1.difference(se))
  5. {1, 2}
  6. {5, 6}

5.子集（<或issubset，set1<set2,set1为set2的子集）

  1. se2={1,2}
  2. se3={1,2,3}
  3. print(se2<se3)
  4. print(se2.issubset(se3))

True
6.超集（>或issuperset，set2>set1，set2为set1的超集）

  1. print(se3>se2)
  2. print(se3.issuperset(se2)

发表评论

表情：
评论列表 （有 0 条评论，406人围观）

还没有评论，来说两句吧...

相关阅读