初学者python笔记（元组、字典、集合详解）

╰+哭是因爲堅強的太久メ 2023-07-08 02:39 24阅读 0赞

文章目录

          1. 元组(与列表最大的区别就是能否更改)
          1. 本不可修改元组，但这样就可以修改了
          1. 字典(dict类)：键值对，无序(列表和元组都有序)
          1. 字典的循环遍历
          1. 特殊方法创建、取值字典
        • 6.在查询字典的键时，若键不存在，则创建该键
          1. pop()删除在字典中的用法
          1. 字典键值对修改的2种方法
          1. 键值对（key与value）的 in 用法
          1. 五大数据类型分类总结
          1. 集合的交叉、并、补集
          1. 字符串拼接的两种方法（百分号、format()）

我们可能知道字符串、数字、列表、元组、字典是python中的五大基本数据类型。前面的文章已经介绍过数字、字符串、列表，这篇则是关于元组、字典和集合这方面的一些重点知识。(还会提到元组的修改)

1. 元组(与列表最大的区别就是能否更改)

列表(list类)：有序，中括号，元素可以被修改
元组(tuple类)：有序，小括号，元素不可被修改且不能删除增加

  1. #元组定义一般在结尾多加一个逗号，以区分方法中的参数
  2. tu = (111,22,"alex",(11,22),44,) #定义一个元组
  3. #元组可以索引，可以切片
  4. s = "asjfdkjkfhg"
  5. li = ["safj",123,"alex"]
  6. tu = ("alex","age",43,)
  7. v = tuple(s)  #字符串可以转成元组
  8. v1 = tuple(li)  #列表可以转成元组
  9. v2 = list(tu)  #元组也可以转成列表,而且顺序不会改变
  10. print(v)
  11. print(v1)
  12. print(v2)

结果是：
(‘a’, ‘s’, ‘j’, ‘f’, ‘d’, ‘k’, ‘j’, ‘k’, ‘f’, ‘h’, ‘g’)
(‘safj’, 123, ‘alex’)
[‘alex’, ‘age’, 43]

2. 本不可修改元组，但这样就可以修改了

  1. tu = (11,33,"alex",[1314,22],44,True,(13,"一世"),22,)
  2. print(tu)
  3. tu[3][1] = 520  #列表本身可以修改，所以元组里的列表也可以修改
  4. #tu[6][0] = "一生"----->>>>同理，元组不可修改，元组中的元组也不可修改
  5. print(tu)

结果是：
(11, 33, ‘alex’, [1314, 22], 44, True, (13, ‘一世’), 22)
(11, 33, ‘alex’, [1314, 520], 44, True, (13, ‘一世’), 22)
Ps：元组的第一级元素不可修改，但二、三…级的元素可以修改

  1. tu = (11,33,"alex",[1314,22,['trust me']],44,True,(13,"一世"),33,)
  2. tu[3][1] = 520
  3. tu[3].insert(0,'5发4')  #在指定的0位置插入
  4. n1 = tu.count(33)  #计算某元素出现次数
  5. n2 = tu.index(44)  #返回某元素的索引，即下标
  6. print(tu)
  7. print(n1)
  8. print(n2)

结果是：
(11, 33, ‘alex’, [‘5发4’, 1314, 520, [‘trust me’]], 44, True, (13, ‘一世’), 33)
2
4

3. 字典(dict类)：键值对，无序(列表和元组都有序)

列表、元组、字典三者可以无限嵌套，像这样：

  1. info = { 
  2.     "k1": "v1",
  3.     "k2": "v2",
  4.     "True": "v3",
  5.     "k3": [
  6.         11,
  7.         22,
  8.         33,
  9.         { 
  10.             "kk1": "vv1",
  11.             "kk2": "vv2",
  12.             "kk3": (11,22,)        
  13.         }
  14.     ],
  15.     "k4" : (11,22,33,44,)
  16. }
  17. #找到11这个数：
  18. v = info["k3"][3]["kk3"][0]
  19. print(v)
  20. #字典的删除操作：
  21. del info["k1"]  #会将键值都删除

Ps：数字，字符串，元组，布尔值(要注意1和0是否重复)都可以作为字典的key，而列表和字典不可以作为key，因为它们可修改，是动态的

4. 字典的循环遍历

  1. for item in info.keys():  #循环key，就是循环键值对
  2.     print(info)
  3. for item in info.values():  #循环values，即值
  4.     print(item)
  6. for item in info.keys():    #key与value都循环：
  7.     print(item,info[item])

因为这里的结果太长了，显得冗余，就不展示了。
关于key与value都循环还有一种简便的写法

  1. #py简化：
  2. for k,v in info.items():  #把键值对作为一个items
  3.     print(k,v)

5. 特殊方法创建、取值字典

  1. #根据序列来创建字典，指定的值都为第二个参数
  2. dic = dict.fromkeys(["k1",123,"k3"],123)
  3. print(dic)
  5. #用dic.get()的好处是，若key对应的值不存，不会报错：
  6. v = dic.get('k11111')
  7. print(v)  #默认返回值是None
  8. v1 = dic.get('k11111',1111)  #若不存在'k11111',则返回1111
  9. print(v1)

结果是：
{‘k1’: 123, 123: 123, ‘k3’: 123}
None
1111

6.在查询字典的键时，若键不存在，则创建该键

  1. dic.setdefault(key,[]).append(value)

这个语句可以很好得解决字典中键的查询问题，同时加入该键值对。

7. pop()删除在字典中的用法

pop()删除最大的好处就是删完了可以将值保存个一个变量

  1. dic = { 
  2.     "k1": "v1"
  3.     "k2": "v2"
  4. }
  5. v = dic.popitem()  #随机删除一个键值对并默认将value赋值给v
  6. print(dic,v)
  7. k,v = dic.popitem()  #随机删除一个键值对并默认将key赋值给k，将value赋值给v

结果是：
{‘k1’: ‘v1’} (‘k2’, ‘v2’)
k1 v1

8. 字典键值对修改的2种方法

  1. #设置值，已存在就不设置，获取原来的值；不存在就设置，获取设置后的值：
  2. dic = { 
  3.     "k1": "v1",
  4.     "k2": "v2"
  5. }
  6. v = dic.setdefault("k1111",123)
  7. print(dic,v)
  8. dic.update(k1=123,k3=345,k5=322)  #更新dic字典，若不存在的key,则添进去
  9. print(dic)

结果是：
{‘k1’: ‘v1’, ‘k2’: ‘v2’, ‘k1111’: 123} 123
{‘k1’: 123, ‘k2’: ‘v2’, ‘k1111’: 123, ‘k3’: 345, ‘k5’: 322}
很明显，字典中加入元素也是无序的

9. 键值对（key与value）的 in 用法

  1. dic = { "k1": "v1" 
  2. }
  3. v = "k1" in dic
  4. vv = "v1" in dic.values()
  5. print(v,vv)

结果为：True True

  1. 我们都知道布尔值中的1是真，0是假，其实还有很多False，
    布尔值中的假：
    None “” () [] {} 0

10. 五大数据类型分类总结

到此为止，五大数据类型就都总结完了，这里再简单分一下类
按是否可变来分
可变：列表、字典、集合
不可变:字符串、数字、元组
s = frozenset(‘hello’) #定义不可变类型集合
s = set(‘hello’) #正常集合是可变的
按访问顺序来分
直接访问：数字
顺序访问：字符串、列表、元组
映射访问：字典

  1. 再介绍一种数据类型，集合
    （集合：花括号，不重复，无序，集合中元素必须是不可变类型）

    s = { “alex”,11,33,22,”sb”}
    s = set(“hello”) #结果是’e’,’l’,’h’,’o’ #无序且不重复
    s.add(‘3’) #添加元素
    s.pop() #因为无序，所有会随机删除一个元素
    print(s)

结果是：
{‘l’, ‘o’, ‘3’, ‘e’}
Ps：第二步，将原来的一整串集合设置成了分开放进去的字符串，因为集合不重复，所以集合变成只有4个元素，每个元素都是一个字符

11. 集合的交叉、并、补集

  1. s = { "alex",11,33,22,"sb"}
  2. s.remove('sb')  #指定删除
  3. s.discard('sbbbb')  #不存在时不会报错,相当于不操作
  4. s1 = { 33,22,11,'大黄蜂','鸡排饭','猪'}
  5. print(s.union(s1))  #求s与s1的并集
  6. print(s | s1)  #求s与s1的并集
  7. print(s - s1)  #求s与s1的差集，s独有的
  8. print(s & s1)  #求s与s1的交集，s与s1都有的
  9. print(s ^ s1)  #求s与s1的交叉补集，s独有与s1独有组成的集合

结果是：
{33, ‘alex’, 11, ‘猪’, 22, ‘鸡排饭’, ‘大黄蜂’}
{33, ‘alex’, 11, ‘猪’, 22, ‘鸡排饭’, ‘大黄蜂’}
{‘alex’}
{33, 11, 22}
{‘alex’, ‘鸡排饭’, ‘大黄蜂’, ‘猪’}

12. 字符串拼接的两种方法（百分号、format()）

  1. #百分号拼接类似C语言中的输出变量
  2. msg = 'I am %s my hobby is %s' %('Ross,','playing game')  
  3. print(msg)
  5. #常用格式化之format后类似一个元组，下标从0开始，多余的舍弃
  6. tpl = "i am {1}, age {2}".format("seven","Andy",18)  
  7. print(tpl)
  9. #格式化保留小数点：
  10. a = 98.32425545443
  11. tp2 = "我有{:.2f}%的可能性会揍你".format(a)
  12. print(tp2)

结果是：
I am Ross, my hobby is playing game
i am Andy, age 18
我有98.32%的可能性会揍你

发表评论

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

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

相关阅读