6.1_4 Python3.x入门 P5 【基础】可变序列（列表list、字典dict、集合set）

原创 已于 2022-09-20 18:00:37 修改 · 1.9k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #开发语言

于 2022-06-28 13:50:46 首次发布
本文详细介绍了Python 3.x中列表(list)的查找、增删改查、统计和排序，集合(set)的基本操作，以及字典(dict)的查找、增加、修改、删除和常用方法。适合初学者快速上手Python数据结构。

相关链接

目录

一、列表list -> [v1,v2,…]

方法总结
序号分类关键字/函数/方法说明
1查找列表.index(数据)值->索引，返回数据第一次出现位置的索引
列表[索引]索引->值，返回指定索引位置的数据
遍历for i in 列表
索引->值，依次获取每个索引对应的值
2增加列表.insert(索引,数据)在指定位置插入数据
列表.append(数据)在末尾追加数据
列表.extend(列表2)将列表2 的数据追加到列表
列表 = 列表1 + 列表2将列表2的数据追加到列表1，并返回一个新的列表
3修改列表[索引]=数据修改指定索引的数据
4删除del 列表删除列表，将列表从内存中清除
del 列表[索引]删除指定索引的数据
列表.remove(数据)删除第一个出现的指定数据
列表.pop删除末尾数据，pop有出栈、弹出的意思
列表.pop(索引)删除指定索引数据，pop有出栈、弹出的意思
列表.clear()清空列表
5统计len(列表)列表长度
列表.count(数据)数据在列表中出现的次数
6排序sorted(列表)升序排序（返回一个新列表，Python内置函数）
sorted(列表,reverse=True)降序排序（返回一个新列表，Python内置函数）
列表.sort()升序排序
列表.sort(revers=True)降序排序
列表.reverse()反转、逆序
7判断数据 in 列表判断列表中是否有指定数据，返回布尔类型值
数据 not in 列表判断列表中是否无指定数据，返回布尔类型值
序号分类关键字/函数/方法 +说明
-切片删除del 列表[开始:结束] ： 删除指定范围索引的数据。[切片]，参数详情见序号8

假设已知：lst = [0, 10, 20, 30]
del lst[:] => print(lst) # []
del lst[0:2] => print(lst) # [20,30]
切片删除del 列表[开始:结束:步长] ：删除指定范围索引的数据。[切片]，参数详情见序号8

假设已知：lst = [0, 10, 20, 30]
del lst[::] => print(lst) # []
del lst[0:2:1] => print(lst) # [20,30]
del lst[0:4:2] => print(lst) # [10,30]
8切片列表[开始:结束] = 迭代器 ：先对列表进行切片，再用迭代器中的数据替换切片删除掉的数据

假设已知：lst = [0, 10, 20, 30]、tmp = [‘a’, ‘b’]

1) 迭代器可以是列表、字典等。字典取key值
2) 两个参数均可以省略，默认值为：
  开始=1；结束=len(列表)
3) 若开始=结束，将迭代器中的数据插入指定列表索引位置，效果等于增加
  lst[0:0] = tmp => print(lst) # [‘a’, ‘b’, 0, 10, 20, 30]
4) 若开始≠结束，将切片切掉部分数据替换为迭代器中的数据，效果等于删除并增加
  lst[1:4] = tmp => print(lst) # [0,‘a’,‘b’]
  注意：被替换的元素数量，和替换的元素数量，不需要相等。
列表[开始:结束:步长] = 迭代器 ：先对列表进行切片，再用迭代器中的数据替换切片删除掉的数据

假设已知：lst = [0, 10, 20, 30]、tmp = [‘a’, ‘b’]

1) 迭代器可以是列表、字典等。字典取key值
2) 三个参数均可以省略，默认值为：
  开始=1；结束=len(列表)；步长=1
3) 若开始=结束，将迭代器中的数据插入指定列表索引位置，效果等于增加
  lst[0:0:] = tmp => print(lst) # [‘a’, ‘b’, 0, 10, 20, 30]
  需要保证：步长=1，否则会抛出ValueError
4) 若开始≠结束，且步长≠1，将切片切掉部分数据替换为迭代器中的数据，效果等于替换
  lst[::2] = tmp => print(lst) # [‘a’,10,‘b’,30]
  lst[::3] = tmp => print(lst) # [‘a’,10,20,‘b’]
  lst[::4] = tmp => print(lst) # ValueError: attempt to assign sequence of size 2 to extended slice of size 1
  注意：被替换的元素数量，和替换的元素数量，要相等。
  需要保证：count(切片切掉的数据) = len(迭代器)，否则会抛出ValueError
5) 若开始≠结束，且步长=1，将切片切掉部分数据替换为迭代器中的数据，效果等于删除并增加
  lst[0:1:] = tmp => print(lst) # [‘a’,‘b’,10,20,30]
  lst[0:6:] = tmp => print(lst) # [‘a’,‘b’]
列表=列表[开始:结束:步长] ： 删除切片部分数据
以上所有开始、结束、步长x参数，均可为负值，参数>0走正向索引，参数<0走逆向索引
一般情况下正向索引可以满足所有需求，需要徐翔索引时自行测试，了解即可
在这里插入图片描述
类型 
lst = ['hello', 'world', 100]
print(type(lst))  # <class 'list'>
print(lst)  # ['hello', 'world', 100]
创建语法 
"""
列表创建方式：
    方式一：使用中括号[]，元素之间英文逗号分隔
        list = ['hello','python']
    方式二：内置函数 list() 类型转换
        list(('hello','php'))                   # list -> list
        list({'name': '张三', 'age': 100})       # 字典 -> list
        list(['hello','php'])                   # 元组 -> list
        list({'python', 'hello', 90})           # 集合 -> list
        list('hello')                           # 字符串->list
"""
'''方式一'''
lst = ['hello', 'python', 13]
print(lst)  # ['hello', 'python', 13]

'''方式二'''
'''1.list->list'''
lst1 = list(('hello', 'php'))  # list -> list
print('lst1', lst1) # ['hello', 'php']

'''2.字典->list时，自动取字典的key'''
lst2 = list({'name': '张三', 'age': 100})  # 字典 -> list
print('lst2', lst2) # ['name', 'age']

'''3.元组->list'''
lst3 = list(['hello', 'php'])  # 元组 -> list
print('lst3', lst3) # ['hello', 'php']

'''4.集合->list'''
lst4 = list({'python', 'hello', 90})  # 集合 -> list
print('lst4', lst4) # [90, 'python', 'hello']

'''5.字符串->list'''
lst5 = list('hello')  # 字符串->list
print('lst5', lst5) # ['h', 'e', 'l', 'l', 'o']
列表特点

1. 列表的数据有序
2. 列表的每个索引映射唯一数据
3. 列表的数据值可重复
4. 列表的数据可以任意类型混合存储
5. 根据需要动态分配和回收内存
6. 基本类型：值相同时，内存地址一样
7. 引用类型：值相同时，内存地址不一样

list = ['hello', 'hello', ['张三', '李四'], ['张三', '李四'], 50, True]
print(len(list))  # 5
for i in range(0, len(list)):
    print(list[i], end="\t")
    '''hello	hello	['张三', '李四']	['张三', '李四']	50	True	'''
print()

for i in range(0, len(list)):
    print(id(list[i]), end="\t")
    '''
    hello出现了两次，两次的id都是4310643824
    ['张三', '李四']：两次出现，id却不同        
    4310643824	4310643824	4312636928	4312643456	4321732376	4321512264	
    '''

1.1 查找

索引：索引从0开始计数，表示在列表中的位置编号，索引也叫下标
  正向索引：从0到n-1 list[0] -> list[n-1]，如下图n=4，list[0]->list[3]
  逆向索引：从-n到-1 list[-n] -> list[-1] ，如下图n=4，list[-4]->list[-1]
   在这里插入图片描述
注意：从列表中取值时，如果超出索引范围，程序会报错，抛出IndexError

a. index() - 值 -> 索引

"""
index():
    如果列表中存在n个相同元素，只返回相同元素中第一个元素索引
    如果查询的元素在列表中不存在，则会抛出ValueError
"""

list = ['hello', 'python', 'python', 50, True]
'''索引位置
          0        1           2      3    4
        ['hello', 'python', 'python', 50, True]
'''

num: int = list.index('python')
print(num) # 1

num: int = list[2:4].index('python')
print(num) # 0 先切片，对切片后的列表再查找

num: int = list.index(50)
print(num) # 3

num: int = list.index('50')
print(num) # ValueError: '50' is not in list

b. 列表[索引] - 索引 -> 值

list = ['hello', 'python', 'python', 50, True]

print(list[0])  # hello
print(list[1])  # python

c. 遍历

list = ['hello', 'python', 'python', 50, True]

print('--------正向索引遍历--------')
for i in range(0, len(list)):
    print(list[i], end="\t") # # hello	python	python	50	True

print('\n--------逆向索引遍历--------')
for i in range(-len(list), 0, 1):
    print(list[i], end="\t")  # hello	python	python	50	True

print("\n----直接遍历------")
for i in list:
    print(i, end="\t")  # hello	python	python	50	True

1.2 增加

a. insert()-在指定位置插入数据

"""
    insert(Integer i,Object obj)：在列表的指定位置添加元素。
"""
'''
    添加元素 - 基本类型
    在索引0的位置添加一个元素 'a'
'''
lst = [10, 20, 30]
print(lst, id(lst))  # [10, 20, 30] 4305885440
lst.insert(0, 'a')
print(lst, id(lst))  # ['a', 10, 20, 30] 4305885440

'''
    添加元素 - 引用类型
    在索引0的位置添加一个列表['a','b']
'''
lst = [10, 20, 30]
tmp = ['a', 'b']
print(lst, id(lst))  # [10, 20, 30] 4305886272
lst.insert(0, tmp)
print(lst, id(lst))  # [['a', 'b'], 10, 20, 30] 4305886272

b. append()-在末尾追加数据

"""
    append(Object obj)：在列表末尾添加一个元素。
"""
'''添加元素 - 基本类型'''
lst = [10, 20, 30]
lst.append(40)
lst.append(50)
print(lst, id(lst))  # [10, 20, 30, 40, 50] 4378974400    lst重新赋值，id发生改变

'''添加元素 - 列表'''
lst = [10, 20, 30]
tmp = [40, 50]
print(lst, id(lst))  # [10, 20, 30] 4377304000
lst.append(tmp)
print(lst, id(lst))  # [10, 20, 30, [40, 50]] 4377304000,id没变，说明还是原来的列表

c. extend()-将列表2的数据追加到列表

"""
    extend(Iterator iter)：在列表末尾添加一个元素。（遍历其中所有元素）
"""
'''
    添加元素 - 基本类型(x)
    extend只适用于迭代器类型元素
'''
lst = [10, 20, 30, 40]
try:
    lst.extend(50)
except Exception as e:
    print(e)  # 'int' object is not iterable
print(lst)

'''
    添加元素 - 列表(v)
    列表属迭代器
'''
lst = [10, 20, 30, 40]
tmp = [40, 50]
lst.extend(tmp)
print(lst)

d. 列表 = 列表1 + 列表2

两个list可以相加 (+)，但是不可以做减法(-)。

lst1 = [1, 2, 3, 4, 5, 6]
lst2 = [5, 6, 7, 8]
lst = lst1 + lst2
print(lst)  # [1, 2, 3, 4, 5, 6, 5, 6, 7, 8]

1.3 修改

lst = [10, 20, 30, 40]
lst[2] = 100
print(lst)  # [10, 20, 100, 40]

1.4 删除

a. del 列表 -删除列表

lst = [10, 20, 30, 40, 50]
del lst
print(lst) # NameError: name 'lst' is not defined

b. del 列表[索引] -删除指定元素

lst = [10, 20, 30, 40, 50]
del lst[0]
print(lst) # [20, 30, 40, 50]

c. remove(数据)-删除第一个出现的指定数据

"""
remove(): 删除指定Value的元素
    一次删除一个元素
    重复元素只删除第一个
    Value不存在则抛出ValueError
"""
lst = [10, 20, 30, 20, 10]
lst.remove(10)
print(lst)  # [20, 30, 20, 10]

lst.remove(30)
print(lst)  # [20, 20, 10]

d. pop()-删除末尾数据

"""
pop(): 删除末尾数据
	   空数组继续执行pop()，会抛出IndexError
"""
lst = [10, 20]
lst.pop()
print(lst) # [10]
lst.pop()
print(lst) # []
lst.pop()
print(lst) # IndexError: pop from empty list

e. pop(索引)-删除指定索引位置

"""
pop(索引): 删除指定index的元素
    指定索引不存在抛出IndexError
    不指定索引，删除列表中最后一个元素
"""
lst = [10, 20, 30, 40, 50]
lst.pop(1)
print(lst)  # [10, 30, 40, 50]

lst.pop(11)  # IndexError: pop index out of range

f. clear()-清空列表

"""
    clear(): 清空列表
"""
lst = [10, 20, 30, 40, 50]
lst.clear()
print(lst)  # []

1.5 统计

a. len(列表)-列表长度

"""
    len(列表): 列表长度
"""
list = [10, 20, 20, 30, 40, 30, 30]
print(len(list)) #7

b. count(数据)-数据在列表中出现的次数

"""
    列表.count(数据): 数据在列表中出现的次数
"""
list = [10, 20, 20, 30, 40, 30, 30]
print(list.count(20)) # 2

1.6 排序

"""
 常见方式
    1) sorted(列表) 升序排序
    2) sorted(列表,reverse=True) 降序排序
    3) 列表.sort() 升序排序
    4) 列表.sort(reverse=True) 降序排序
    5) 列表.reverse()反转/逆序

    区别：
        sort()   修改原列表
        sorted() 生成新列表，原列表不发生改变
"""
'''1 升序排序'''
lst = [10, 90, 20, 80, 30, 70]
n_lst = sorted(lst)
print(n_lst)  # [10, 20, 30, 70, 80, 90]

'''2 降序排序'''
lst = [10, 90, 20, 80, 30, 70]
n_lst = sorted(lst, reverse=True)
print(n_lst)  # [90, 80, 70, 30, 20, 10]

'''3 升序排序'''
lst = [10, 90, 20, 80, 30, 70]
lst.sort()
print(lst)  # [10, 20, 30, 70, 80, 90]

'''4 降序排序'''
lst = [10, 90, 20, 80, 30, 70]
lst.sort(reverse=True)
print(lst)  # [90, 80, 70, 30, 20, 10]

'''5 反转'''
lst = [10, 90, 20, 80, 30, 70]
lst.reverse()
print(lst)  # [70, 30, 80, 20, 90, 10]

1.7 判断

a. 数据 in 列表-判断列表中有指定数据

"""
    数据 in 列表名
"""
list = [10, 20, 30, 40]
print('p' in 'python')  # True
print(10 in list)  # True
print(15 in list)  # False

b. 数据 not in 列表-判断列表中无指定数据

"""
    数据 not in 列表名
"""
list = [10, 20, 30, 40]
print('abc' not in list)  # True

1.8 切片

"""
 获取列表中的多个元素
 语法格式：
    列表名[start:stop]
    列表名[start:stop:step]
 切片操作：
    切片的结果：原列表切片，形成新的列表
    step为正数：从start开始往后计算切片
        [:stop:step]：切片的第一个元素默认是列表的第一个元素
        [start::step]：切片的最后一个元素默认是列表的最后一个元素
    step为负数：从start开始往前计算切片
        [:stop:step]：切片的第一个元素默认是列表的最后一个元素
        [start::step]：切片的最后一个元素默认是列表的第一个元素
"""
#       0  1  2  3  4  5  6  7  8  9  正向索引
list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#      -9 -8 -7 -6 -5 -4 -3 -2 -1  0  逆向索引

'''step默认为0'''
print(list[1:8])  # [2, 3, 4, 5, 6, 7, 8]
print(list[1:-2])  # [2, 3, 4, 5, 6, 7, 8]

'''step为正数'''
print(list[:10:2])  # [1, 3, 5, 7, 9]
print(list[0::2])  # [1, 3, 5, 7, 9]

'''step为负数'''
print(list[:-10:-2])  # [10, 8, 6, 4, 2]
print(list[10::-2])  # [10, 8, 6, 4, 2]

1.9 列表生成式

"""
 全称"生成列表的公式"
    语法格式：
        [fx(i) for i in range(n,m)]
            fx(i): 表达式
            i : 自定义变量
            range(n,m) : 可迭代对象
    注意事项：
        表示列表元素的表达式中，通常包含自定义变量
"""

lst = [i * i for i in range(0,10)]
print(lst) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
'''
    第一次循环 i=0, i*i = 0
    第二次循环 i=1, i*i = 1
    第三次循环 i=2, i*i = 4
    第四次循环 i=3, i*i = 9
    第五次循环 i=4, i*i = 16
'''

1.10 转换-zip->list

"""
 内置函数zip(): 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回有这些元组组成的列表
              key-value数量不一致时，参考短板效应

"""
items = ['水果', '书本', '鱼缸', '马桶']
prices = [10, 20, 30]
zip = zip(items, prices)
lst = list(zip)
print(type(zip), zip)  # <class 'zip'> <zip object at 0x1046d6e80>
print(type(lst), lst)  # <class 'list'> [('水果', 10), ('书本', 20), ('鱼缸', 30)]

二、集合set -> {k1,k2,…}

方法总结
序号分类关键字/函数/方法说明
1查找-可以通过函数 list(集合) 转为list后操作
遍历for i in 集合
依次获取每个数据，每次遍历顺序随机
2增加集合.add(数据)在随机位置插入数据
集合.update(迭代器)在随机位置插入迭代器中的每条数据
3修改-可以通过函数 list(集合) 转为list后操作
4删除del 集合删除集合，将集合从内存中清除
集合.remove(数据)删除指定数据
集合.discard删除指定数据（不存在不报错）
集合.pop()删除末尾数据，pop有出栈、弹出的意思
集合.clear()清空集合
5统计len(集合)集合长度
6排序-可以通过函数 list(集合) 转为list后操作
7判断数据 in 集合判断集合中是否有指定数据，返回布尔类型值
数据 not in 集合判断集合中是否无指定数据，返回布尔类型值
8判断集合集合==集合1判断集合A和集合B是否相等
集合!=集合1判断集合A和集合B是否不相等
集合.issubset(集合1)判断集合是否为集合1的子集
集合.issuperset(集合1)判断集合是否为集合1的超集
这里超集定义与数学中不同，集合AB元素完全相等时，也互为超集
函数isdisjoint(集合1)判断集合是否与集合1无交集
集合-数学基本概念 
"""
 空集：有一类特殊的集合，它不包含任何元素，如{x|x∈R x²+1=0} ，称之为空集，记为∅。
 		1) 空集∅是任意一个非空集合的真子集。
		2) 空集是任何一个集合的子集。

    		
 集合关系概念：
 	1.相等：如果两个集合A和B有同样的元素组成，就说集合A和集合B相同。
 			记作"A=B"或"B=A"
 			
    2.子集：如果集合B的元素都是集合A的元素，B叫做A的子集合（简称子集）。
    		记作"B⊆A"
    		
    3.真子集：在上述情况下，A中至少有一个元素不属于B，那么B就是A的真子集。
    		记作"B⊊A"
    		
    4.超集：如果集合B是集合A的真子集，那么集合A就是集合B的超集。
    5.交集：由属于A且属于B的相同元素组成的集合，
    		记作"A∩B"（或"B∩A"），读作"A交B"（或"B交A"）
    		
    6.并集：由所有属于集合A或属于集合B的元素所组成的集合，
    		记作"A∪B"（或"B∪A"），读作"A并B"（或"B并A"）
    		
    7.补集：分为相对补集和绝对补集
    a.相对补集：由属于A而不属于B的元素组成的集合，称为B关于A的相对补集，
    		记作"A-B"或"A\B"，即A-B={x|x∈A，且x∉B}
    		
    b.绝对补集：A关于全集合U的相对补集称作A的绝对补集，
    		记作"A'"或"∁u（A）"或"~A"。有U'=Φ；Φ'=U。	
"""
类型 
s = {'python', 'hello', 90, 90}
print(type(s))  # <class 'set'>
print(s) # {90, 'python', 'hello'}
创建语法 
"""
    方式一：使用花括号{}，元素之间英文逗号分隔
        set = {'python', 'hello', 90}
    方式二：内置函数 list() 类型转换
        set(['hello','php']) # 元组->set
        set('hello') # 字符串->set

集合创建方式：
    方式一：使用花括号{}，元素之间英文逗号分隔
        set = ['hello','python']
    方式二：内置函数 list() 类型转换
        set(('hello','php'))                   # list -> set
        set({'name': '张三', 'age': 100})       # 字典 -> set
        set(['hello','php'])                   # 元组 -> set
        set({'python', 'hello', 90})           # 集合 -> set
        set('hello')                           # 字符串->set
"""

'''方式一'''
s = {'hello', 'python'}
print(s)  # {'python', 'hello'}

'''方式二'''
'''1.list->set'''
set1 = set(('hello', 'php'))  # list -> set
print('set1', set1)  # {'php', 'hello'}

'''2.字典->set时，自动取字典的key'''
set2 = set({'name': '张三', 'age': 100})  # 字典 -> set
print('set2', set2)  # {'age', 'name'}

'''3.元组->set'''
set3 = set(['hello', 'php'])  # 元组 -> set
print('set3', set3)  # {'php', 'hello'}

'''4.集合->set'''
set4 = set({'python', 'hello', 90})  # 集合 -> set
print('set4', set4)  # {'python', 90, 'hello'}

'''5.字符串->set'''
set5 = set('hello')  # 字符串->set
print('set5', set5)  # {'h', 'o', 'l', 'e'}
集合特点

1. 可变序列
2. 自动去重
3. 集合中元素无序排列，每次遍历顺序都会发生改变
4. 数据类型只能为：基本类型

2.1 查找(遍历)

s = {'python', 'hello', 90, 90}
for i in s:
    print(i)
'''测试结果1
90
hello
python
'''
'''测试结果2
python
90
hello
'''

2.2 增加

a. add(数据)-插入指定数据

"""
    add(Object obj)：添加一个元素
"""
s = {10, 20, 30, 40, 50}

s.add(60)
print(s)  # {40, 10, 50, 20, 60, 30}

b. update(迭代器)-插入迭代器中的每条数据

"""
    update(Iterator iter):添加一个迭代器(列表、元组、集合等)
"""
s = {10, 20, 30, 40, 50}

s.update(['a', 'b', 'c'])
print(s)  # {'a', 40, 10, 50, 20, 'c', 'b', 60, 30}

2.3 修改(不支持)

2.4 删除

a. del 集合 -删除集合

s = {10, 20, 30, 40, 50}
del s
print(s) # NameError: name 's' is not defined

b. remove(数据)-删除指定数据

"""
  remove(Object obj):删除指定元素，不存在抛出KeyError
  					一次删除一个元素。
"""
s = {10, 20, 30, 40, 50}
s.remove(10)
print(s)  # {40, 50, 20, 30}

c. discard(数据)-删除指定数据（不存在不报错）

"""
     discard(Object obj):删除指定元素，不存在不报错
"""
s = {10, 20, 30, 40, 50}
s.discard(15)
s.discard(20)
print(s)  # {40, 10, 50, 30}

d. pop()-删除末尾数据

"""
    pop():删除一个任意元素(左侧弹出）
"""
s = {10, 20, 30, 40, 50}
s.pop()
print(s)  # {10, 50, 20, 30}

e. clear()-清空集合

"""
     clear():清空
"""
s = {10, 20, 30, 40, 50}
s.clear()
print(s)  # set()

2.5 统计

a. len(集合)-集合长度

"""
    len(集合): 集合长度
"""
s = {10, 20, 20, 30, 40, 30, 30}
print(len(s)) #4

2.6 排序(不支持)

2.7 判断

a. 数据 in 集合-判断集合中有指定数据

"""
    数据 in 集合：判断集合中有指定数据
"""
s = {10, 20, 30, 40, 50}
print(10 in s)  # True
print(100 in s)  # False

b. 数据 not in 集合-判断集合中无指定数据

"""
    数据 not in 集合：判断集合中无指定数据
"""
s = {10, 20, 30, 40, 50}
print(15 not in s)  # True

2.8 判断集合

a. == 相等

"""
    == ：集合是否相等
"""
a = {1, 2}
a1 = {1, 2}
b = {1, 2, 3, 4, 5}
c = {5, 6}
d = {6, 7}

print(a == a1)  # True
print(a == b)  # False

b. != 不相等

"""
    != ：集合是否不相等
"""
a = {1, 2}
a1 = {1, 2}
b = {1, 2, 3, 4, 5}
c = {5, 6}
d = {6, 7}

print(a != a1)  # False
print(a != b)  # True

c. issubset() - 子集

"""
    issubset(): 是否子集 
"""
a = {1, 2}
a1 = {1, 2}
b = {1, 2, 3, 4, 5}
c = {5, 6}
d = {6, 7}

print(a.issubset(a1))  # True
print(a.issubset(b))  # True
print(a.issubset(c))  # False

d. issuperset() - 超集

"""
   issuperset(): 是否超集 (这里超集定义与数学中不同，ab集合元素完全相等时，也互为超集）
"""
a = {1, 2}
a1 = {1, 2}
b = {1, 2, 3, 4, 5}
c = {5, 6}
d = {6, 7}

print(a.issuperset(a1)) # True
print(b.issuperset(a)) # True
print(b.issuperset(c)) # False

e. isdisjoint() - 无交集

"""
    isdisjoint() : 是否无交集 
"""
a = {1, 2}
a1 = {1, 2}
b = {1, 2, 3, 4, 5}
c = {5, 6}
d = {6, 7}

print(a.isdisjoint(a1)) # False
print(b.isdisjoint(c)) # False
print(b.isdisjoint(d)) # True

2.9 集合的数学计算

"""
   交集： {1,2} & {2,3} => {2}
       方式一：intersection()
       方式二：&
   并集： {1,2} & {2,3} => {1,2,3}
       方式一：union()
       方式二：|
   差集： {1,2} x {2,3} => {1}
       方式一：difference()
       方式二：-
   对称差集： {1,2} & {2,3} => {1,3}
       方式一：symmetric_difference()
       方式二：^      => shift + 数字6
"""
s1 = {1, 2}
s2 = {2, 3}
print('---------交集 {2} --------')
print(s1.intersection(s2))
print(s1 & s2)

print('---------并集 {1, 2, 3}--------')
print(s1.union(s2))
print(s1 | s2)

print('---------差集 {1}--------')
print(s1.difference(s2))
print(s1 - s2)


print('---------对称差集 {1,3}--------')
print(s1.symmetric_difference(s2))
print(s1 ^ s2)

2.10 集合生成式

"""
 @introduction <class 'set'>
  全称"生成集合的公式"
    语法格式：
        {fx(i) for i in range(n,m)}
            fx(i): 表达式
            i : 自定义变量
            range(n,m) : 可迭代对象
    注意事项：
        将{}改为[]，就是list 列表生成式
"""
set1 = {i * 2 for i in range(1, 5)}
print(set1)  # {8, 2, 4, 6}

三、字典dict -> {k1:v1,…}

 字典：dictionary（字典）是除列表以外，Python之中最灵活的数据类型。

 键、值：字典中的key叫做键（键唯一不可重复），value叫做值（可以通过键获取值），一对key+value叫键值对。

序号分类关键字/函数/方法说明
1查找字典[键]键->值，返回键对应的值。
如果不存在指定key，抛出keyError异常。
字典.get(键)键->值，返回键对应的值。
如果不存在指定key，返回None。
字典.get(键,默认值)键->值，获取指定键的值。
可以通过参数设置默认value，查不到key时返回默认值。
遍历1) for i in 字典： 获取所有键
2) for i in 字典.keys()： 获取所有键
3) for i in 字典.values()： 获取所有值
4) for i in 字典.items()： 获取所有键值对(元组形式）
2增加字典[键]=值当指定键不存在时，添加指定的键与值
3修改字典[键]=值当指定的键存在时，修改指定键的值
4删除del 字典删除列表，将字典从内存中清除
del 字典[键]删除字典中指定键及其对应值的数据。键不存在时抛出KeyError
字典.pop(键)删除指定键及其对应值的数据。键不存在时抛出KeyError
字典.clear()清空字典
5统计len(字典)字典长度
6排序-可以通过函数 list(字典) 转为list后操作
7判断数据 in 字典字典中有指定键，返回布尔类型值
数据 in 字典.keys()字典中有指定键，返回布尔类型值
数据 in 字典.values()字典中有指定值，返回布尔类型值
数据 in 字典.items()字典中有指定键值对（元组），返回布尔类型值
数据 not in 字典字典中无指定键，返回布尔类型值
数据 not in 字典.keys()字典中无指定键，返回布尔类型值
数据 not in 字典.values()字典中无指定值，返回布尔类型值
数据 not in 字典.items()字典中无指定键值对（元组），返回布尔类型值
字典视图

字典.keys() -> dict_keys: <class ‘dict_keys’>
字典.values() -> dict_values: <class ‘dict_values’>
字典.items() -> dict_items: <class ‘dict_items’>

类型 
dct = {'name': '张三', 'age': 100}
print(type(dct))  # <class 'dict'>
print(dct)  # {'name': '张三', 'age': 100}
创建语法 
"""
 字典创建方式：
     方式一：使用花括号 {}，元素之间英文逗号分隔
            scores = {'name': '张三', 'age': 100}
     方式二：内置函数 dict() 类型转换
        dict(k1=v1,k2=v2,...)
"""
'''方式一'''
dct1 = {'name': '张三', 'age': 100, 'salary': 1888}
print(dct1)  # {'name': '张三', 'age': 100, 'salary': 1888}

'''方式二'''
dct2 = dict(name='张三', age=100, salary=1888)
print(dct2)  # {'name': '张三', 'age': 100, 'salary': 1888}

'''空字典'''
dct3 = {}  # 空字典
print(dct3)  # {}
字典特点

1. 所有元素都是 k-v键值对，key不允许重复，value可以重复
  {‘name’: ‘李四’}
  {‘name’: ‘张三’, ‘nickname’: ‘张三’}
2. 字典中的元素是无序的
3. 字典中的key必须是基本类型、不可变序列（字符、元组）
4. 字典也可以根据需要动态的伸缩
5. 字典会浪费比较大的内存，是一种使用空间换时间的数据结构

dct = {'name':'张三','name':'李四'}
print(dct)

dct = {'name':'张三','nickname':'张三'}
print(dct)

3.1 查找

a. 字典[键] - 键->值

dct = {'name': '张三', 'age': 100, 'salary': 1888}
print(dct['name'])  # 张三
print(dct['weight']) # KeyError: 'weight'

b. get(键) - 键->值（不报错）

dct = {'name': '张三', 'age': 100, 'salary': 1888}
print(dct.get('name'))  # 张三
print(dct.get('weight')) # None

c. get(键,默认值) - 键->值（查不到则返回默认值）

dct = {'name': '张三', 'age': 100, 'salary': 1888}
print(dct.get('name'))  # 张三
print(dct.get('weight','75kg')) # 75kg

d. 遍历

"""
1) for i in 字典： 获取所有键
2) for i in 字典.keys()： 获取所有键
3) for i in 字典.values()： 获取所有值
4) for i in 字典.items()： 获取所有键值对(元组形式）
"""
dct = {'name': '张三', 'age': 100, 'salary': 1888}

# 1) for i in 字典： 获取所有键
for i in dct:
    print(i)
'''测试结果
name
age
salary
'''

# 2) for i in 字典.keys()： 获取所有键
for i in dct.keys():
    print(i)
'''测试结果
name
age
salary
'''

# 3) for i in 字典.values()： 获取所有值
for i in dct.values():
    print(i)
'''测试结果
张三
100
1888
'''

# 4) for i in 字典.items()： 获取所有键值对(元组形式）
for i in dct.items():
    print(i)
'''测试结果
('name', '张三')
('age', 100)
('salary', 1888)
'''

# 5) 组合使用
for i in dct.keys():
    print(i,dct[i])
'''测试结果
name 张三
age 100
salary 1888
'''

3.2 增加

a. 字典[键]=值 (key不存在)

当字典中没有这个键时，增加新数据。

"""
    dict[键]= xxx
"""
dct = {'name': '张三', 'age': 100, 'salary': 1888}
dct['country'] = '中国'
print(dct)  # {'name': '张三', 'age': 100, 'salary': 1888, 'country': '中国'}

3.3 修改

a. 字典[键]=值 (key已存在)

当字典中有这个键时，修改这个键的值。

"""
    dict[键]= xxx
"""
dct = {'name': '张三', 'age': 100, 'salary': 1888}
dct['name'] = '李四'
print(dct)  # {'name': '李四', 'age': 100, 'salary': 1888}

3.4 删除

a. del 字典

"""
    del dict
"""
dct = {'name': '张三', 'age': 100, 'salary': 1888}
del dct
print(dct) # NameError: name 'dct' is not defined

b. del 字典[键]

"""
    del dict[键]
"""
dct = {'name': '张三', 'age': 100, 'salary': 1888}
del dct['name']
print(dct) # {'age': 100, 'salary': 1888}

# 键不存在时抛出KeyError
del dct['weight'] # KeyError: 'weight'

3.5 统计

a. len(字典)-字典长度

"""
    len(字典): 字典长度
"""
dct = {'name': '张三', 'age': 100, 'salary': 1888}
print(len(dct))  # 3

3.6 排序(不支持)

3.7 判断

a. 数据 in 字典-判断字典中有指定键

dct = {'name': '张三', 'age': 100, 'salary': 1888}

b. 数据 in 字典.keys()-判断字典中有指定键

dct = {'name': '张三', 'age': 100, 'salary': 1888}

c. 数据 in 字典.values()-判断字典中有指定值

dct = {'name': '张三', 'age': 100, 'salary': 1888}

d. 数据 in 字典.items()-判断字典中有指定键值对

dct = {'name': '张三', 'age': 100, 'salary': 1888}

e. 数据 not in 字典-判断字典中无指定键

dct = {'name': '张三', 'age': 100, 'salary': 1888}

f. 数据 not in 字典.keys()-判断字典中无指定键

dct = {'name': '张三', 'age': 100, 'salary': 1888}

g. 数据 not in 字典.values()-判断字典中无指定值

dct = {'name': '张三', 'age': 100, 'salary': 1888}

h. 数据 not in 字典.items()-判断字典中无指定键值对

dct = {'name': '张三', 'age': 100, 'salary': 1888}

3.8 获取字典视图3种方式

"""
 方式1：keys() : 获取字典中所有key    返回值类型：<class 'dict_keys'>
 方式2：values() : 获取字典中所有value    返回值类型：<class 'dict_values'>
 方式3：items() : 获取字典中所有key,value对    返回值类型：<class 'dict_items'>
"""

a. 获取字段中所有key-keys()

"""
 类型： <class 'dict_keys'>
"""
map = {'name': '张三', 'age': 100, 'salary': 1888}
key_lst = map.keys()
print(key_lst, type(key_lst))  # dict_keys(['name', 'age', 'salary']) <class 'dict_keys'>

'''
    dict_keys -> list 
    其中dict_keys是元组类型(), 详见b1元组tuple
'''
print(list(key_lst))  # ['name', 'age', 'salary']

b. 获取字典中所有value-values()

"""
 类型： <class 'dict_values'>
"""
map = {'name': '张三', 'age': 100, 'salary': 1888}
value_lst = map.values()
print(value_lst, type(value_lst))  # dict_values(['张三', 100, 1888]) <class 'dict_values'>

'''
    dict_keys -> list 
    其中dict_keys是元组类型(), 详见b1元组tuple
'''
print(list(value_lst))  # ['张三', 100, 1888]

c. 获取字典中所有kv对-items()

"""
 类型：	 <class 'dict_items'>
"""
map = {'name': '张三', 'age': 100, 'salary': 1888}
item_lst = map.items()
print(item_lst, type(item_lst))  # dict_items([('name', '张三'), ('age', 100), ('salary', 1888)]) <class 'dict_items'>

'''
    dict_keys -> list 
    其中dict_keys是元组类型(), 详见b1元组tuple
'''
print(list(item_lst))  # [('name', '张三'), ('age', 100), ('salary', 1888)]

3.9 转换-zip->dict

"""
    语法格式：
        {k: v for k, v in zip}
            k : 自定义变量key
            v : 自定义变量value
            zip : 可迭代zip对象

 内置函数zip(): 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回有这些元组组成的列表
              key-value数量不一致时，参考短板效应

"""
items = ['水果', '书本', '鱼缸', '马桶']
prices = [10, 20, 30]

'''方式一：dict()'''
zip1 = zip(items, prices)
dct1 = dict(zip1)
print(type(zip1), zip1)  # <class 'zip'> <zip object at 0x1046d6e80>
print(type(dct1), dct1)  # <class 'dict'> {'水果': 10, '书本': 20, '鱼缸': 30}

'''方式二：{k: v for k, v in zip}'''
zip2 = zip(items, prices)
dct2 = {k: v for k, v in zip2}  # zip1只能使用一次，如果此处继续使用zip1，则返回空字典dct2
print(type(dct2), dct2)  # <class 'dict'> {'水果': 10, '书本': 20, '鱼缸': 30}

22/06/28

M

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值