Python之元组 字典 集合

Bertha 。 2023-02-19 11:28 22阅读 0赞

Python列表

Python之元组 字典 集合

元组介绍

元组的表现形式是tuple
元组是一个不可变的序列（一般但这个数据不改变的时候，我们就采用元组，其余情况都用列表。）

  • 创建元组
    通过()创建元素

    tup = ()
    print(tup,type(tup))

    ()

  • 添加元素
    直接在元组中添加

    tup = ()
    print(tup)
    tup = (1,2,3,4)
    print(tup)

    ()
    (1, 2, 3, 4)

  • 通过索引访问元组中的元素值

    tup = (1,2,3,4,5,6)
    print(tup[3])

    4

  • 注意：元组不能修改其中的值，否则会报一个TypeError

    tup = (1,2,3,4,5,6)

    tup[3] = 44元组中的值不可以更改

    print(tup)

    (1, 2, 3, 4, 5, 6)

接下来我们看一个现象：

  1. tup = 10
  2. print(tup,type(tup))# 10 int型
  3. # 如果在10后面加一个逗号
  4. tup = 10,
  5. print(tup,type(tup))# (10,) tuple型
  7. 10 <class 'int'>
  8. (10,) <class 'tuple'>

如果元组不是空的，元组至少要有一个逗号

  • 特殊的用法
    元组可以不加()，但是不能没有逗号

    tup = 1,2,3,4,5,
    print(tup,type(tup))# (1,2,3,4,5,) tuple型

    (1, 2, 3, 4, 5)

  • 元组解包
    元组解包指的是元组中的每一个值分别赋值给变量

    tup = 10,20,30,40
    a,b,c,d = tup
    print(a)
    print(b)
    print(c)
    print(d)

    10
    20
    30
    40

再看一个奇怪的现象

  1. tup = 10,20,30,40
  2. *a,b,c = tup
  3. print(a)
  4. print(b)
  5. print(c)
  6. # 结果：a b c依次是[10,20] 30 40
  7. a,*b,c = tup
  8. print(a)
  9. print(b)
  10. print(c)
  11. # 结果：a b c依次是10 [20,30] 40
  12. a,b,*c = tup
  13. print(a)
  14. print(b)
  15. print(c)
  16. # 结果：a b c依次是10 20 [30,40]
  18. [10, 20]
  19. 30
  20. 40
  21. 10
  22. [20, 30]
  23. 40
  24. 10
  25. 20
  26. [30, 40]

其实列表和字符串也可以这样操作

  1. # 列表
  2. list1 = [1,2,3,4,5]
  3. a,b,*c = list1
  4. print(a)
  5. print(b)
  6. print(c)
  7. # 字符串
  8. str_1 = 'python'
  9. a,b,*c = str_1
  10. print(a)
  11. print(b)
  12. print(c)
  14. 1
  15. 2
  16. [3, 4, 5]
  17. p
  18. y
  19. ['t', 'h', 'o', 'n']

综上序列中都可以进行一个这样的操作

字典(键值对)

一种新的数据结构–>印射(mapping)

  • 字典的作用：
    用来存储对象的容器
  • 字典和列表的区别
    列表存储数据的性能特别好，但是查询的数据性能比较差，字典正好与之相反。这是因为字典当中每一个元素都有唯一的一个名字，通过这个为一个名字快速查找到指定的元素。
  • 唯一个名字称之为key,通过key来查询值，值称为value，键值对(key-value) 一项称之为item。

  • 语法:
    字典 = {key:value,key:value…}
    (注意：字典的key可以是任意个不可变对象，字典的value可以是任意对象。字典的key是不可以重复的，如果重复后面的会替换前面的)

    d = { ‘name’:’葫芦娃’,’age’:20,’sex’:’男’}
    print(d,type(d))
    d = { ‘name’:’葫芦娃’,’age’:20,’sex’:’男’,’name’:’钢特侠’}
    print(d,type(d))

    { ‘name’: ‘葫芦娃’, ‘age’: 20, ‘sex’: ‘男’}
    { ‘name’: ‘钢特侠’, ‘age’: 20, ‘sex’: ‘男’}

当字典的键值对过多可以有以下这种写法：

  1. headers = { 
  2.     'name':'葫芦娃',
  3.     'age':20
  4. }

  • 根据键来获取值：

    d = { ‘name’:’葫芦娃’,’age’:20,’sex’:’男’}

    根据键来获取值

    print(d[‘name’],d[‘age’],d[‘sex’])

    葫芦娃 20 男

  • 使用dict()这个函数来创建字典

    d = dict(name = ‘葫芦娃’,age = 18,sex= ‘男’)
    print(d,type(d))

    双值序列：序列中有两个值[3,4]

    双值子序列：如果序列中的元素也是序列，那么我们称这个元素是子序列[(2,3),(4,5)]

    d = dict([(‘name’,’葫芦娃’),(‘age’,19)])
    print(d)

    { ‘name’: ‘葫芦娃’, ‘age’: 18, ‘sex’: ‘男’}
    { ‘name’: ‘葫芦娃’, ‘age’: 19}

  • len()获取键值对中的个数

    d = dict(name = ‘葫芦娃’,age = 18,sex= ‘男’)
    print(len(d))

    3

  • in或者not in 检查字典中是否包含（不包含）指定的键。

    d = dict(name = ‘葫芦娃’,age = 18,sex= ‘男’)
    print(‘name’ in d)
    print(‘葫芦娃’ in d)
    print(‘sex’ not in d)

    True
    False
    False

  • 根据键来获取字典当中的值
    语法：dict[key]
    (注意：key一定要加上引号)

    d = dict(name = ‘葫芦娃’,age = 18,sex= ‘男’)
    print(d[‘age’])

    18

那么什么时候可以不加引号呢？

  1. d = dict(name = '葫芦娃',age = 18,sex= '男')
  2. n = 'name'
  3. print(d[n])
  5. 葫芦娃

如果key赋值给变量时，可以不加引号。

  • get()函数
    get(key[,default])该方法用来根据字典中的key来获取值，如果key不存在则返回None

    d = dict(name = ‘葫芦娃’,age = 18,sex= ‘男’)
    print(d.get(‘name’))

    葫芦娃

也可以指定第二个参数，当这个key值不存在的时候会返回一个默认值

  1. d = dict(name = '葫芦娃',age = 18,sex= '男')
  2. print(d.get('n','key值不存在'))
  4. key值不存在

  • 修改字典

    d = dict(name = ‘葫芦娃’,age = 18,sex= ‘男’)
    d[‘name’] = ‘钢特侠’# 修改键值对
    print(d)

    { ‘name’: ‘钢特侠’, ‘age’: 18, ‘sex’: ‘男’}

  • 添加键值对

    d = dict(name = ‘葫芦娃’,age = 18,sex= ‘男’)
    d[‘phone’] = 347889
    print(d)

    { ‘name’: ‘葫芦娃’, ‘age’: 18, ‘sex’: ‘男’, ‘phone’: 347889}

使用setdefault(key,[,default])方法可以向字典中添加键值对：
如果key已经存在在字典中，则返回key的值，不会对字典有任何的操作

  1. d = dict(name = '葫芦娃',age = 18,sex= '男')
  2. d['phone'] = 347889
  3. print(d)
  4. d.setdefault('name','钢特侠')
  5. r = d.setdefault('name','钢特侠')
  6. print(d)
  7. print(r)
  9. { 'name': '葫芦娃', 'age': 18, 'sex': '男', 'phone': 347889}
  10. { 'name': '葫芦娃', 'age': 18, 'sex': '男', 'phone': 347889}
  11. 葫芦娃

如果key不存在，则向字典中添加这个key,并设置value。

  1. d = { 'name': '葫芦娃', 'age': 18, 'sex': '男', 'phone': 347889}
  2. d.setdefault('address','china')
  3. print(d)
  4. r = d.setdefault('address','china')
  5. print(r)
  7. { 'name': '葫芦娃', 'age': 18, 'sex': '男', 'phone': 347889, 'address': 'china'}
  8. china

update()方法将其他的字典的键值对添加到当前的字典中
（注意： 如果有重复的key,后面的会替换掉前面的）

  1. d1 = { 'a':1,'b':2,'c':3}
  2. d2 = { 'd':4,'e':5,'f':6}
  3. d1.update(d2)
  4. print(d1)
  5. d2 = { 'd':4,'e':5,'f':6,'a':9}
  6. d1.update(d2)
  7. print(d1)
  9. { 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  10. { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

  • 删除元素–>删除字典中的键值对
    通过del来删除字典中的键值对

    d1 = { ‘a’: 9, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}
    del d1[‘a’]
    print(d1)

    { ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}

通过popitem()方法随机删除字典中的键值对，但是一般都会删除最后一个。
注意：有返回值，删除之后会将删除后的键值对的元素以元组的形式进行返回，并且第一项是删除的键值对的key，第二项是删除键值对的value。

  1. d1 = { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  2. print(d1)
  3. d1.popitem()
  4. print(d1)
  5. r = d1.popitem()
  6. print(r)
  8. { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  9. { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
  10. ('e', 5)

通过pop()来删除键值对
pop(key[,default])
根据key来删除字典中的键值对，会将删除的value返回，如果删除一个没有的值则会进行报错。

  1. d1 = { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  2. r = d1.pop('b')
  3. print(r)
  4. print(d1)
  6. 2
  7. { 'a': 9, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

那么如何让程序不报错呢？

  1. d1 = { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  2. r = d1.pop('u','这个key值不存在')
  3. print(r)
  4. print(d1)
  6. 这个key值不存在
  7. { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

  • 浅复制
    什么叫复制呢？先看以下代码：

    d1 = { ‘a’: 9, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}
    d2 = d1
    print(d1)
    print(d2)

    { ‘a’: 9, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}
    { ‘a’: 9, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}

上述代码算不算复制呢，所谓的复制指的是把对方的元素抄过来但是可以做一些修改，两者没关系。所以上述代码不算是复制，更谈不上是浅复制。
那么再看下列代码：

  1. d1 = { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  2. d2 = d1.copy()
  3. d1['b'] = 59907
  4. print(d1,id(d1))
  5. print(d2,id(d2))
  7. { 'a': 9, 'b': 59907, 'c': 3, 'd': 4, 'e': 5, 'f': 6} 2109244840840
  8. { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6} 2109244840920

上述代码才是实现了复制，由此可见：复制以后的对象和原对象是独立的，修改其中的一个值不会对另一个值产生影响。

浅复制只会复制字典本身，如果字典中还有一个字典，是不会被复制的，这个值也可以是一个可变对象，这个可变对象也不会被复制。

  1. d1 = { 'a': { 'name':'葫芦娃','age':89,'sex':'男'}, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  2. d2 = d1.copy()
  3. d2['a']['name'] = '黑猫警长'
  4. print(d1,id(d1))
  5. print(d2,id(d2))
  7. { 'a': { 'name': '黑猫警长', 'age': 89, 'sex': '男'}, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6} 2752341089240
  8. { 'a': { 'name': '黑猫警长', 'age': 89, 'sex': '男'}, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6} 2752341090040

  • 遍历字典
    通过keys()遍历字典，该方法会返回字典中的所有的key

    d1 = { ‘a’: 9, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}
    print(d1.keys())
    for k in d1.keys():

    1. print(k)

    dict_keys([‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’])
    a
    b
    c
    d
    e
    f

通过values()遍历字典，该方法会返回一个序列，序列中保存有字典的值

  1. d1 = { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  2. print(d1.values())
  3. for v in d1.values():
  4.     print(v)
  6. dict_values([9, 2, 3, 4, 5, 6])
  7. 9
  8. 2
  9. 3
  10. 4
  11. 5
  12. 6

通过items()遍历字典，该方法会返回字典中的所有项,但是所有项会以双值序列的方式进行返回。

  1. d1 = { 'a': 9, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
  2. print(d1.items())
  3. for k,v in d1.items():
  4.     print(k,'=',v)
  6. dict_items([('a', 9), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6)])
  7. a = 9
  8. b = 2
  9. c = 3
  10. d = 4
  11. e = 5
  12. f = 6

集合

集合和列表非常相似

  • 集合和列表的不同点：
    集合只能存储区不可变的对象。
    集合中存储的对象是无序的,输出的值也是无序的。

集合不可以出现重复元素

  • 集合的创建

    s = { 1,2,3,4}
    print(s,type(s))

    { 1, 2, 3, 4}

如若{}中不添加值会发生什么？

  1. s = { }
  2. print(s,type(s))
  4. { } <class 'dict'>

可见集合就变成了字典
如果集合中的元素在创建的时候是无序的

  1. s = { 4,6,3,8,7,'o',' ','p'}
  2. print(s,type(s))
  4. { 'o', 3, 4, 'p', 6, 7, 8, ' '} <class 'set'>
  5. { 'o', 3, 4, 6, 7, 8, ' ', 'p'} <class 'set'>
  6. { 3, 4, 6, 7, 8, ' ', 'o', 'p'} <class 'set'>

可见在集合输出的时候也是无序的。
那么集合中如果出现多个相同的值呢？会发生什么？

  1. s = { 4,6,3,8,7,1,1,1,1,1,1}
  2. print(s,type(s))
  4. { 1, 3, 4, 6, 7, 8} <class 'set'>

由结果可以知道多个相同的值会去除。所以集合中的值是不可以出现重复的。
通过set()函数来创建集合

  1. s = set([9,868,8,0])
  2. print(s,type(s))
  3. s = set('python')
  4. print(s,type(s))
  5. s = set({ 'a':1,'b':2,'c':3})# 如果是字典则会返回字典中的key值给集合
  6. print(s,type(s))
  8. { 8, 9, 868, 0} <class 'set'>
  9. { 'p', 't', 'n', 'y', 'o', 'h'} <class 'set'>
  10. { 'a', 'b', 'c'} <class 'set'>

集合可不可以根据索引找值？

  1. s = { 1,2,3,4,5}
  2. print(s[0])
  4. print(s[0])
  5. TypeError: 'set' object is not subscriptable

会报一个TypeError，所以集合不可以通过索引找值。
那么如何通过列表找值？

  1. s = { 1,2,3,4,5}
  2. print(list(s)[0])
  4. 1

  • 集合的使用
    len()来获取集合中元素的数量
    add()向集合中添加元素
    update()将一个集合中的元素添加到另一个集合中
    pop()随机删除集合中的一个元素，一般是删除最后一个元素
    remove()删除集合中的指定元素
    clear()清空集合

    s = { 4,6,3,8,7,’o’,’ ‘,’p’}
    print(len(s))
    s.add(50)
    s.add(100)
    print(s)
    s2 = set(‘python’)
    s.update(s2)
    print(s)
    r = s.pop()# 有返回值
    print(s)
    print(r)
    s.remove(8)
    print(s)
    s.clear()
    print(s)

    8
    { 3, 4, 100, 6, 7, 8, ‘o’, ‘p’, 50, ‘ ‘}
    { 3, 4, 100, 6, 7, 8, ‘h’, ‘o’, ‘n’, ‘p’, 50, ‘y’, ‘ ‘, ‘t’}
    { 4, 100, 6, 7, 8, ‘h’, ‘o’, ‘n’, ‘p’, 50, ‘y’, ‘ ‘, ‘t’}
    3
    { 4, 100, 6, 7, ‘h’, ‘o’, ‘n’, ‘p’, 50, ‘y’, ‘ ‘, ‘t’}
    set()

  • 集合的运算
    &交集运算
    |并集运算
    -差级运算
    ^亦或集

<=检查一个集合是否是另一个集合的子集
<检查一个集合是否是另一个集合的真子集
>= 检查一个集合是否是另一个集合的超集
*>*检查一个集合是否是另一个集合的真超集

  1. # & 交集运算
  2. s1 = { 1,2,3,4,5}
  3. s2 = { 3,4,5,6,7}
  4. result = s1 & s2
  5. print(s1,s2,result)
  6. # | 并集运算
  7. result = s1 | s2
  8. print(s1,s2,result)
  9. # - 差集运算
  10. result = s1 - s2
  11. print(s1,s2,result)
  12. result = s2 - s1
  13. print(s1,s2,result)
  14. # ^ 亦或集:两个集合中不相交的部分
  15. result = s1 ^ s2
  16. print(s1,s2,result)
  17. # <=检查一个集合是否是另一个集合的子集，另一个集合就是这个集合的超集
  18. # <检查一个集合是否是另一个集合的真子集，另一个集合就是这个集合的真超集
  19. # >= 检查一个集合是否是另一个结合的超集
  20. # # > 检查一个集合是否是另一个集合的真超集
  21. a = { 1,2,3,4,5}
  22. b = { 1,2,3,4,5}
  23. result = a <= b# a是b的子集，b是a的超集
  24. print(result)
  25. a = { 1,2,3}
  26. b = { 1,2,3,4,5}
  27. result  = a < b# a是b的真子集，b是a的真超集
  28. print(result)
  30. { 1, 2, 3, 4, 5} { 3, 4, 5, 6, 7} { 3, 4, 5}
  31. { 1, 2, 3, 4, 5} { 3, 4, 5, 6, 7} { 1, 2, 3, 4, 5, 6, 7}
  32. { 1, 2, 3, 4, 5} { 3, 4, 5, 6, 7} { 1, 2}
  33. { 1, 2, 3, 4, 5} { 3, 4, 5, 6, 7} { 6, 7}
  34. { 1, 2, 3, 4, 5} { 3, 4, 5, 6, 7} { 1, 2, 6, 7}
  35. True
  36. True

可变对象

每个对象当中都保存了3个数据 id(标识) type(类型) value(值)
列表是一个可变的对象
a = [1,2,3]
指向的对象
a[0] = 10(改对象 改对像里面的值)
这个操作是通过变量来修改对象里面的值，不会改变变量指向的对象
a = [4,5,6]
这个操作是在给变量重新赋值，会改变变量

  1. # 可变对象
  2. a = [1,2,3]
  3. print('修改前：',a,id(a))
  4. # 通过索引来修改列表
  5. a[0] = 10
  6. print('修改后：',a,id(a))
  7. # 为变量重新赋值
  8. a = [4,5,6]
  9. print('修改后：',a,id(a))
  10. a = [1,2,3]
  11. b = a
  12. b[0] = 10
  13. print('a = ',a,id(a))
  14. print('b = ',b,id(b))
  15. a = [1,2,3]
  16. b = a
  17. b = [20,2,3]
  18. print('a = ',a,id(a))
  19. print('b = ',b,id(b))
  21. 修改前： [1, 2, 3] 2262078280264
  22. 修改后： [10, 2, 3] 2262078280264
  23. 修改后： [4, 5, 6] 2262083237384
  24. a =  [10, 2, 3] 2262078280264
  25. b =  [10, 2, 3] 2262078280264
  26. a =  [1, 2, 3] 2262083237384
  27. b =  [20, 2, 3] 2262078280264

现在有一个字典
a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{‘src’:“python2”},{“src”:“python3”}]}}中找到python1和python2和python3

  1. a = { "name":"123","data":{ "result":[{ "src":"python1"},{ 'src':"python2"},{ "src":"python3"}]}}
  2. b = a["data"]
  3. c = b["result"]
  4. for i in c:
  5.     print(i["src"])
  7. python1
  8. python2
  9. python3

有如下值的列表[11,22,33,44,55,66,77,88,99,90]将所有大于66的值保存到字典的第一个key的值中，将小于66的值保存至第二个key的值中

  1. lst = [11,22,33,44,55,66,77,88,99,90]
  2. dic = { }
  3. n = []# 大于66的元素
  4. m = []# 小于66的元素
  5. for i in lst:
  6.     if i > 66:
  7.         n.append(i)
  8.     else:
  9.         m.append(i)
  10. #print(m,n)
  11. dic.update(k1 = n,k2 = m)
  12. print(dic)
  14. { 'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]}

python之函数

发表评论

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

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

相关阅读