• 【Python】第六课 字典和集合

    在python中字典是唯一的映射类型，映射是数学上的一个术语，指两个元素集之间元素相互“对应”的关系。与Java中的Map集合很类似。映射类型区别于序列类型，序列类型以数组的形式存储，通过索引的方式类获取相应位置的值，一般索引值与对应位置存储的数据是毫无关系的。

    1. brand=["李宁","耐克","阿迪达斯","Python"]
    2. slogan=["一切皆有可能","Just do it","Impossible is nothing","让编程改变世界"]
    3. print("计算机科学的口号是",slogan[brand.index("Python")])
    4. #运行结果: 计算机科学的口号是 让编程改变世界

    两列表的索引和相对的值是没有任何关系的，唯一有联系的就是两个列表间，索引号相同的元素是有关系的。

    6.1 字典

    6.1.1 创建和访问字典

    1. #字典的创建
    2. dict1={"李宁":"一切皆有可能","耐克":"Just do it","阿迪达斯":"Impossible is nothing","Python":"让编程改变世界"}
    3. print(dict1)
    4. print("计算机科学的口号是",dict1["Python"])
    5. 运行结果: 
    6.     {'李宁': '一切皆有可能', '耐克': 'Just do it', '阿迪达斯': 'Impossible is nothing', 'Python': '让编程改变世界'}
    7. 	计算机科学的口号是 让编程改变世界

    通过以上的案例可以发现，python中的字典的定义与Java中的Map类似，与Json格式也非常类似。

    字典的使用很简单，以大括号作为标志性符号，字典是以键值对的方式作为映射关系一一对应，但字典的键必须独一无二，而值可以取任何数据类型。

    dict是字典的类名。

    1. #字典的初始化
    2. #定义空字典
    3. dict2={}
    4. print(type(dict2))#
    5. dict3=dict((('a',70),('b',170),('c',30),('d',50),('e',60)))
    6. print(dict3)#{'a': 70, 'b': 170, 'c': 30, 'd': 50, 'e': 60}

    以上案例中dict()函数中只能有一个元素，因此将多个元素封装成一个元组作为一个元素传入dict()函数中，也可以用以下方式来定义字典:

    1. dict4=dict(a=70,b=170,c=30,d=50,e=60)
    2. print(dict4)
    3. 运行结果: {'a': 70, 'b': 170, 'c': 30, 'd': 50, 'e': 60}

    也可以给字典中进行追加数据

    1. dict4["f"]=100
    2. dict4["g"]=200
    3. print(dict4)
    4. 运行结果: {'a': 70, 'b': 170, 'c': 30, 'd': 50, 'e': 60, 'f': 100, 'g': 200}

    这里总结一些创建字典的六种方式:

    1. a=dict(one=1,two=2,three=3)
    2. b={"one":1,"two":2,"three":3}
    3. c=dict(zip(["one","two","three"],[1,2,3]))
    4. d=dict({"one":1,"two":2,"three":3})
    5. e=dict([("one",1),("two",2),("three",3)])
    6. f=dict((("one",1),("two",2),("three",3)))
    7. print(a==b==c==d==e==f)
    8. 输出结果为: True

    6.1.2 字典的各种内置方法

    fromkeys()函数该方法用于创建并返回一个新的字典，有两个参数，第一个参数是字典的键，第二个参数是可选的，是传入键对应的值。如果不提供值，那么默认是None。

    1. dict1={}
    2. print(dict1.fromkeys((1,2,3)))#{1: None, 2: None, 3: None}
    3. print(dict1.fromkeys((1,2,3),"Python"))#{1: 'Python', 2: 'Python', 3: 'Python'}
    4. print(dict1.fromkeys((1,2,3),("one","two","three")))
    5. #{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}

    该函数将("one","two","three")作为一个元素，将该元素传递给三个索引。

    keys(),values()和items()函数的用法

    1. dict2={}
    2. #快速赋值为32个赞
    3. dict2=dict2.fromkeys(range(32),"赞")
    4. print(dict2)
    5. #获得字典的所有键
    6. print(dict2.keys())
    7. #获得字典的所有值
    8. print(dict2.values())
    9. #获得字典的所有键值对
    10. print(dict2.items())

    运行结果:

    {0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞', 6: '赞', 7: '赞', 8: '赞', 9: '赞', 10: '赞', 11: '赞', 12: '赞', 13: '赞', 14: '赞', 15: '赞', 16: '赞', 17: '赞', 18: '赞', 19: '赞', 20: '赞', 21: '赞', 22: '赞', 23: '赞', 24: '赞', 25: '赞', 26: '赞', 27: '赞', 28: '赞', 29: '赞', 30: '赞', 31: '赞'} dict_keys([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]) dict_values(['赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞', '赞']) dict_items([(0, '赞'), (1, '赞'), (2, '赞'), (3, '赞'), (4, '赞'), (5, '赞'), (6, '赞'), (7, '赞'), (8, '赞'), (9, '赞'), (10, '赞'), (11, '赞'), (12, '赞'), (13, '赞'), (14, '赞'), (15, '赞'), (16, '赞'), (17, '赞'), (18, '赞'), (19, '赞'), (20, '赞'), (21, '赞'), (22, '赞'), (23, '赞'), (24, '赞'), (25, '赞'), (26, '赞'), (27, '赞'), (28, '赞'), (29, '赞'), (30, '赞'), (31, '赞')])

    get()函数用于从字典中根据键取值，如果不存在，则可以设定默认值

    1. #根据键取值
    2. print(dict2[1])
    3. print(dict2.get(1))
    4. print(dict2.get(32,"不存在该值"))
    5. 运行结果:
    6.     赞
    7. 	赞
    8. 	不存在该值

    也可以通过in和not in来判断字典中是否存在这个键

    1. if 32 in dict2:
    2.     print("该键存在")
    3. else:
    4.     print("该键不存在")

    **清除字典的所有数据使用clear()函数。**

    copy()函数用于拷贝一个字典，属于值传递，不是引用传递。

    1. a={"one":1,"two":2,"three":3}
    2. b=a.copy()
    3. a["two"]=10
    4. print(a)
    5. print(b)
    6. 运行结果:
    7.     {'one': 1, 'two': 10, 'three': 3}
    8. 	{'one': 1, 'two': 2, 'three': 3}

    pop()和popitem()函数的使用

    1. a={"one":1,"two":2,"three":3}
    2. #根据键输出这个值，并从字典中删除这个元素
    3. print(a.pop("two"))
    4. print(a)
    5. #从字典中输出一个键值对，并从字典中删除这个元素，可作为随机取出
    6. print(a.popitem())
    7. print(a)

    setdefault()函数和get()函数有点相似，但是setdefault()函数在字典中找不到相应的键时会自动添加至字典中:

    1. a={"one":1,"two":2,"three":3}
    2. print(a.setdefault("two"))
    3. print(a.setdefault(10))
    4. print(a)

    update()函数用于更新字典中的数据

    1. pets={"米奇":"老鼠","汤姆":"猫","小白":"猪"}
    2. pets["米奇"]="大老鼠"
    3. print(pets)#{'米奇': '大老鼠', '汤姆': '猫', '小白': '猪'}
    4. pets.update(小白="狗")
    5. print(pets)#{'米奇': '大老鼠', '汤姆': '猫', '小白': '狗'}

    字典作为可变字符传入函数的形参时，需要使用**来进行表示

    1. def test(** params):
    2.     print("有%d个参数"%len(params))
    3.     print("它们分别是：",params)
    4. test(**pets)
    5. test(a=1,b=2)
    6. 运行结果:
    7.     有3个参数
    8. 	它们分别是： {'米奇': '大老鼠', '汤姆': '猫', '小白': '狗'}
    9. 	有2个参数
    10. 	它们分别是： {'a': 1, 'b': 2}

    6.2 集合

    在python中集合类似与Java中的set集合，集合中用大括号表示，并不能存在重复的数据。

    1. #集合的使用
    2. num1={}
    3. print(type(num1))#以大括号空值表示的不是集合，而是字典
    4. #
    5. num2={1,2,3,4,5}
    6. print(type(num2))#在大括号中没有键值对，只有值，这是集合的格式
    7. #

    集合中不能存在重复的数据

    1. num3={1,2,3,4,5,1,2,3}
    2. print(num3)

    运行结果为:{1, 2, 3, 4, 5}

    集合和字典类似，数据是无序的，因此不能通过索引值来获取其中的元素。

    集合的内建函数是set()，因此可以使用该函数将列表，元组转换成集合。

    1. num3={1,2,3,4,5,1,2,3}
    2. num4=set([1,2,3,4,5,1,2,3])
    3. print(num3)
    4. print(num4)
    5. print(num3==num4)

    运行结果:

    {1, 2, 3, 4, 5} {1, 2, 3, 4, 5} True

    例如，没有学习set集合之前，要去除具有重复数据的列表中的数据，那案例如下:

    1. num3=[1,2,3,4,5,1,2,3]
    2. #通过分片获得副本列表
    3. temp=num3[:]
    4. #将原列表清空
    5. num3.clear()
    6. for x in temp:
    7.     if x not in num3:
    8.         num3.append(x)
    9.  
    10. print(num3)

    但通过set集合的话就简单了

    1. num3=[1,2,3,4,5,1,2,3]
    2. #将列表转换成集合，则会自动去除重复的数据，然后转换会列表
    3. num3=list(set(num3))
    4. print(num3)

    但需要注意的是列表的元素是有顺序的，set集合的元素是无需的，当将列表转换后成集合的时候，再转换回列表，可能原本的列表的元素顺序不一定是原本的位置。

    通过循环迭代的方式访问集合:

    1. num5={4,5,1,2,3}
    2. for i in num5:
    3.     print(i,end=" ")

    运行结果:1 2 3 4 5

    可以使用in和not in来判断某个元素是否存在于集合中。

    使用add()方法可以为集合中添加元素，使用remove()方法可以删除集合中存在的元素。

    如果不想让集合中的元素被删除，修改和添加，那么我们可以将集合设置为终态，一旦定义后，不允许被改变，这时候需要使用frozenset()函数将集合进行固定起来。

  • 相关阅读:
    CDH 01CentOS配置(markdown新版二)
    tomcat配置ssl证书
    深度学习笔记其三：多层感知机和PYTORCH
    vue中关于表单的常用学习
    js获取上周、本周、上月、本月、第一天和最后一天
    k8s 灰度发布（未完）
    【算法训练-动态规划 一】【应用DP问题】零钱兑换、爬楼梯、买卖股票的最佳时机I、打家劫舍
    stable-diffusion-webui+sadTalker开启GFPGAN as Face enhancer
    函数调用栈分析
    etcd安装
  • 原文地址：https://blog.csdn.net/u010321564/article/details/126598925