python 集合（列表，元祖，字典）

python 集合（列表，元祖，字典）

目录

• 一： 列表
  • 1.1 列表概述
  • 1.2 列表的增删改查
    • 1.2.1 在列表中查找元素
    • 1.2.2 在列表中增加元素
    • 1.2.3 修改列表中的元素
    • 1.2.4删除列表中的元素
  • 1.3 列表的遍历循环
    • 1.3.1 for 循环遍历列表
    • 1.3.2 while循环遍历列表
  • 1.4 列表的嵌套
  • 1.5 列表的排序
• 二: 元组
  • 2.1 什么是元组
  • 2.2 元组的定义与使用
  • 2.3 元组的遍历
  • 2.4 元组的内置函数
• 三 字典
  • 3.1 字典的介绍
  • 3.2 字典的定义与使用
    • 3.2.1 字典以key:value形式存储值,需要根据键值访问
    • 3.2.2 字典的get方法
    • 3.2.3修改与添加字典元素
    • 3.2.4删除字典元素
    • 3.2.5 setdefault
    • 3.2.6 len 获取字典key个数
  • 3.3 字典的视图操作
    • 3.3.1 获取字典的键视图
    • 3.3.2 valus() 方法获取字典的 值的视图
    • 3.3.3 使用items() 获取字典元素视图
  • 3.4 遍历字典的键值对
• 四:列表排序算法
  • 4.1 冒泡排序
  • 4.2 选择排序
  • 4.3 插入排序
    • 4.3.1 在一个有序列表里插入元素
    • 4.3.2 插入排序

一： 列表

1.1 列表概述

• 列表是python中的一种数据结构，可以存储不同的类型的数据。

  • 如: A = [1,"abc",[2,"b"]]

• 列表表示为： list

  • 复制a = [1,2,3]
    print(type(a))
    # 输出：
    <class 'list'>
    

•   列表索引是从0开始的。我们可以通过索引来访问列表中的值

  • 复制a = ["a", "b", "c", "e"]
    
    print(a[0])
    print(a[1])
    
    # 输出结果：
    a
    b
    

1.2 列表的增删改查

1.2.1 在列表中查找元素

• 我们使用 “列表[下标] 的方式来查找列表中的元素
  • A[0] ：查找列表A的下标为0的元素
  • A[0:2] : 查找列表A的下标为0 到2前(左闭右开，实际是0-1)的元素
  • A[0:10:2]: 以步长为2，查看列表A的下标为0 到10前的元素
• 也可以使用运算符 in 和not in 来查找
  • in : 如果存在，那么结果为True。否则为False
  • not in : 如果不存在，那么结果为True。否则为False
• 也可以使用函数index 来查看。print(A.index("abc")) 查看列表A中是否有元素“abc"
  • 有，返回该元素第一次出现的下标
  • 没有，则报错

复制A = ["a", "b", "c", "d", "e", "f", "g"]

print(A[0])
print(A[0:5])
print(A[0:5:2])

# 输出结果：
a
['a', 'b', 'c', 'd', 'e']
['a', 'c', 'e']

复制A = ["a", "b", "c", "d", "e", "f", "g"]

print("a" in A)
print("abc" in A)
print("abc" not in A)

# 输出结果：
True
False
True

复制A = ["a", "b", "c", "d", "e", "f", "g"]

print(A.index("a"))
print(A.index("abc"))

# 输出结果：
0
报错

1.2.2 在列表中增加元素

• 通过append 可以向列表中追加元素（在末尾）
• 通过 extend 可以将另一个列表的元素添加到列表中
• 通过insert可以在指定位置前插入元素

复制A = ["a", "b", "c", "d", "e", "f", "g"]
# 向列表A末尾追加一个元素
A.append(10)
print(A)

# 输出结果:
['a', 'b', 'c', 'd', 'e', 'f', 'g', 10]

复制A = ["a", "b", "c", "d", "e", "f", "g"]
B = [100, 40, 50]

# 如果直接使用append，将B列表追加到A列表，只会将B列表整体当成一个元素，追加到A列表的尾部
A.append(B)
print(A)

# 使用extend，可以将B列表中的元素添加到A列表中
A.extend(B)
print(A)

#输出：
['a', 'b', 'c', 'd', 'e', 'f', 'g', [100, 40, 50]]
['a', 'b', 'c', 'd', 'e', 'f', 'g', [100, 40, 50], 100, 40, 50]

复制A = ["a", "b", "c", "d", "e", "f", "g"]
print(A)
# 在列表A下标为0 的元素前面，插入一个元素100
A.insert(0,100)
print(A)

#输出:
['a', 'b', 'c', 'd', 'e', 'f', 'g']
[100, 'a', 'b', 'c', 'd', 'e', 'f', 'g']

1.2.3 修改列表中的元素

对于列表中的元素的值，我们通过列表[下标]的方式找出该元素，然后重新赋值

eg:

• A[0] = "abc"

复制A = ["a", "b", "c", "d", "e", "f", "g"]
print(A)

# 将列表A的下标为0 的元素的值修改为100
A[0] = 100
print(A)

#将列表A下标0到2前(左闭右开)的元素的值修改为1,2
A[0:2] = 1,2
print(A)

# #将列表A下标0到2前(左闭右开)的元素的值修改为100,200,300,400
# 注意,列表多个值修改,只可以多对多,即多个值修改为任意多个值.但是不可以多对单,即,不能将多个值修改为一个值
A[0:2] = 100,200,300,400
print(A)

# 如果只取列表中一个值,想要修改为多个值,这些值会以一个元组的形式,成为列表中的一个值
A[0] = 999, 888, 777
print(A)

# 列表中多个不连续的值的修改. 
# A[-1] 表示列表中最后一个元素.A[-3]表示列表中倒数第三个元素
A[-1],A[-3] = "Hi" , "Hello"
print(A)

注意:如果列表中元素的值是一个元组,则只能整体修改该元素,而无法修改元组里的元素

复制A = [(1,2,3),100,200,300]

# 对于列表中值为元组的元素,我们只能整体替换该元素
A[0]=("a","b","c")
print(A)
#输出结果:[('a', 'b', 'c'), 100, 200, 300]

# 获取列表中,元组的第一个值
print(A[0][0])
#输出结果:a

#如果企图替换列表中,元组的元素值,则会报错
# TypeError: 'tuple' object does not support item assignment
# A[0][0] = 999

1.2.4删除列表中的元素

对于删除列表中元素的方法,常用的有del 和 pop ,及remove

• del[index]

  • del的方法是通过下标删除

  • 复制A = [1,2,3,4]
    del A[0]
    print(A)
    #输出结果:
    [2, 3, 4]
    

• list.remove(值) :

  • remove 的方法,是通过列表里的值进行删除(多个相同的值,只会删除第一个)

  • 复制A = ["a", "a", "b", "c", "d"]
    A.remove("a")
    
    print(A)
    #输出结果:
    ['a', 'b', 'c', 'd']
    

• list.pop(index)

  • pop 使用下标删除.如果不加参数，则默认最后一个

  • 复制A = [1,2,3,4]
    
    #不加下标,默认弹出最后一个元素
    A.pop()
    print(A)
    #输出结果:[1, 2, 3]
    
    
    A.pop(0)
    print(A)
    #输出结果:[2, 3]
    

1.3 列表的遍历循环

• for 循环遍历列表
• while循环遍历列表

1.3.1 for 循环遍历列表

复制A = [100, 10, 88, 1024, 30]

for i in A:
    print(i)
#输出结果:
'''
100
10
88
1024
30
[100, 10, 88, 1024, 30]

'''
    
# 这里，x的值是个临时变量，只是lst中每个元素的复制.对复制的操作不能影响元素本身
for i in A:
    i += 1
print(A)

# 输出结果:[100, 10, 88, 1024, 30]

复制#for循环 使用长度遍历
A = [100, 10, 88, 1024, 30]

#如果传入的地址，对其内容的改变是可以传递进入的
# 使用列表的长度值作为循环次数.取值从0开始,直到(列表长度值-1)
for i in range(len(A)):
   # 由于i的值正好是列表的元素下标.因此,可以使用A[i]来取值
    print(A[i])
    # 每次循环,对应下标的元素值+1
    A[i] += 1

print(A)

#输出结果
100
10
88
1024
30
[101, 11, 89, 1025, 31]

1.3.2 while循环遍历列表

复制length = len(A)
i = 0

while i < length:
    print(A[i])
    i +=1
    
# 输出结果:
100
10
88
1024
30

1.4 列表的嵌套

列表的嵌套指的是列表的元素又是一个列表

复制# 列表A有两个元素,两个元素都是列表.
# 元素0 是列表[1,2,3]  ; 元素1是列表["a","b","c"]
A = [[1,2],["a","b","c"]]
print(A[0])
print(A[1])
#输出结果:
'''
[1, 2]
['a', 'b', 'c']
'''

#获取列表A里,元素标号为0的列表[1,2,3]的第一个值
print(A[0][0])
#输出结果: 1


# 使用双重循环,遍历嵌套列表.外层循环遍历列表A.内层循环遍历嵌套的列表
for i in A:
    for n in i:
        print(n)
        
#输出结果:
'''
1
2
a
b
c
'''

1.5 列表的排序

列表的排序可以通过以下两个方法实现:

• sort 方法: 列表的元素按照特定的顺序排列
• reverse方法: 将列表逆置

复制A = [100, 10, 88, 1024, 30, 1, 999]

#reverse=False ,表示按照升序排列.可以省略
A.sort(reverse=False)
print(A)
#输出结果:[1, 10, 30, 88, 100, 999, 1024]

# reverse = True ,表示按照降序排列
A.sort(reverse=True)
print(A)
# 输出结果:[1024, 999, 100, 88, 30, 10, 1]

二: 元组

2.1 什么是元组

• python元组与列表类似,不同之处在于元组的元素不能更改.

• 元组使用小括号() 包裹元素,列表使用方括号

• 元素标识为 tuple

  • 复制A = (1,2,"abc")
    print(type(A))
    #输出结果:
    <class 'tuple'>
    

2.2 元组的定义与使用

复制A = (1, 2, 3, 4, 5)
#输出元组A下标为0的元素
print(A[0])

#输出元组A下标为0到2前的元素(左闭右开)
print(A[0:2])

#以步长为2,输出元组A下标为0到5前的元素(左闭右开)
print(A[0:5:2])

#输出结果:
1
(1, 2)
(1, 3, 5)

2.3 元组的遍历

复制A = (1, 2, 3, 4, 5)

for i in A:
    print(i)
#输出结果:
'''
1
2
3
4
5
'''

for i in range(len(A)):
    print(A[i])
#输出结果:
'''
1
2
3
4
5
'''

注意:虽然元组的值无法修改,但是当元组里元素是列表时,我们可以修改列表里元素的值

复制A = (1,2,[100,200])
#元组A的下标为2的元素是一个列表
print(A[2])
#输出结果:[100, 200]

#获取列表里元素的值
print(A[2][0])
#输出结果:100


#修改元组里,元素为列表的列表元素值
A[2][0] = 9999
print(A[2][0])
#输出结果:9999

2.4 元组的内置函数

方法	描述
len(tuple)	计算元组元素个数
max(tuple)	计算元组中元素最大值
min(tuple)	计算元组中元素最小 值
tuple(seq)	将列表转为元组
list(seq)	将元组转为 列表

复制A = (1, 2, 3)
B = [100, 200, 300]

print(len(A))
# 3

print(max(A))
# 3
print(min(A))
#1

# 将列表转为元组
tuple(B)
print(type(B))
#输出结果:<class 'list'>

#将元组转为列表
list(A)
print(type(A))
#输出结果:<class 'tuple'>

虽然元组里元素无法修改,但是,我们可以先将元组转为列表 ,修改元素值之后,再将列表转为元组

三 字典

3.1 字典的介绍

• 字典是一个存储数据的容器,它和列表类似,都可存储多个数据

• 字典使用大括号存储,以键值对的形式

• 字典的标识是 dict

• 如果大括号{}里没有键值对时,则为set 无序结合,里面的数据不会重复

  • 复制A = {1,3,1,4}
    print(type(A))
    print(A)
    
    #输出结果
    <class 'set'>
    {1, 3, 4}
    

3.2 字典的定义与使用

3.2.1 字典以key:value形式存储值,需要根据键值访问

复制A = {"name":"zhangsan","age":18}

print(type(A))
#输出结果:<class 'dict'>

#字典是以key:value的形式存储值.
#当访问时,下标需要时字典的key. "name","age"是字典A的key
print(A["name"])
print(A["age"])
#输出结果:
'''
zhangsan
18
'''

3.2.2 字典的get方法

当访问字典不存再的键时,程序会报错.

当我们想获取某个键对应的值,但又不确定该值是否存在时,可以使用get方法

复制A = {"name":"zhangsan","age":18}

#字典A不存在键"sex".直接使用"sex"键访问则报错
print(A["sex"])
#报错:KeyError: 'sex'

#使用get方法访问
#如果"sex"键不存在,则返回none
print(A.get("sex"))

#设置返回值,当"sex"键不存在时,返回"男"
print(A.get("sex","男"))

3.2.3修改与添加字典元素

复制A = {"name":"zhangsan", "age":18, "department":"OPS"}

#修改字典A的"name"键的值
A["name"] = "wangwu"
print(A)
#输出结果:{'name': 'wangwu', 'age': 18, 'department': 'OPS'}

# 为字典A添加键值对
A["salart"] = 18000
print(A)
#输出结果:{'name': 'wangwu', 'age': 18, 'department': 'OPS', 'salart': 18000}

字典中,不允许一个键出现两次.如果创建时,一个键被赋值两次.后一个值会被记住

复制#"name"键出现两次.只会记住最后出现的值
A = {"name":"zhangsan","age":18, "name":"wangwu"}
print(A["name"])

# 输出结果:wangwu

3.2.4删除字典元素

• del : 删除字典.字典直接从内存中删除,无法再根据键访问
• pop: 根据字典键删除
• clear: 清空字典的元素.字典仍然存在与内存中,但其中没有任何元素

复制A = {"name":"zhangsan", "age":18, "department":"OPS"}

# 删除字典中"name"键
del A["name"]
print(A)
#输出结果:{'age': 18, 'department': 'OPS'}

#删除字典A里"age"键
A.pop("age")
print(A)
#输出结果:{'department': 'OPS'}

#清空字典
A.clear()
print(A)
#输出结果: {}

#删除整个字典
del A
print(A)
# 报错,因为字典A已经被删除,不存在了

3.2.5 setdefault

如果key已经存在,则不做任何操作.如果key不存在,则以默认值插入

复制A = {"name":"zhangsan", "age":18, "department":"OPS"}

#因为存在"name"键,所以不做任何操作
A.setdefault("name","wangwu")
print(A)
#输出结果:{'name': 'zhangsan', 'age': 18, 'department': 'OPS'}

# 因为没有"salary"键,所以会插入该键值对
A.setdefault("salary",18000)
print(A)
#输出结果:{'name': 'zhangsan', 'age': 18, 'department': 'OPS', 'salary': 18000}

3.2.6 len 获取字典key个数

复制A = {"name":"zhangsan", "age":18, "department":"OPS"}

print(len(A))
#输出结果:3

3.3 字典的视图操作

视图只是字典上的视图(窗口,windows),在字典内容发生改变时,也会实时显示.

字典的视图是只读的.但是可以使用list()将其转为列表

3.3.1 获取字典的键视图

keys() 方法可以获取字典的键视图,以实时反应字典中键的变化

复制A = {"name":"zhangsan", "age":18, "department":"OPS"}
#获取字典键视图
print(A.keys())
#输出结果:dict_keys(['name', 'age', 'department'])

#当字典键改变,字典键视图改变
A["salary"] = 18000
print(A.keys())
#输出结果:dict_keys(['name', 'age', 'department', 'salary'])

3.3.2 valus() 方法获取字典的 值的视图

复制A = {"name":"zhangsan", "age":18, "department":"OPS"}

#返回字典 值的视图
print(A.values())
#输出结果
dict_values(['zhangsan', 18, 'OPS'])

3.3.3 使用items() 获取字典元素视图

items() 方法可以获取字典的元素视图,以实时地反应字典中键值对的变化

以列表的形式反应

复制A = {"name":"zhangsan", "age":18, "department":"OPS"}

#获取字典的元素视图
print(A.items())
#输出结果:dict_items([('name', 'zhangsan'), ('age', 18), ('department', 'OPS')])

3.4 遍历字典的键值对

我们可以使用字典的元素视图和for 循环,来达到遍历字典键值对的效果

复制A = {"name":"zhangsan", "age":18, "department":"OPS"}

for x,y in A.items():
    print("keys=%s,value=%s"%(x,y))

#输出结果:
'''
keys=name,value=zhangsan
keys=age,value=18
keys=department,value=OPS

'''

四:列表排序算法

4.1 冒泡排序

依次比较相邻的两个元素.如果过前面的元素比后面的大,则交换它们

步骤:

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

复制import random

# 生成随机数列表
lst = []
for i in range(5):
    lst.append(random.randint(0,100))
print(lst)

# 冒泡排序
# 需要双重循环.外层循环控制比较轮数
# 内存循环控制每轮比较次数

# 最后一轮只剩下一个元素，不需要比。所以-1
for x in range(len(lst)-1):
    # 最后一次，也只剩下一个元素，也不需要比。因此-1
    # 每轮都能确定一个最大值，所以每轮都比上一轮减少一次比较
    for y in range(len(lst) -x -1):
        # 列表前后值比较
        if lst[y] > lst[y+1]:
            tmp = lst[y]
            lst[y] = lst[y+1]
            lst[y+1] = tmp
print(lst)

# 输出结果：
[45, 97, 56, 73, 43]
[43, 45, 56, 73, 97]

4.2 选择排序

• 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
• 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
• 重复第二步，直到所有元素均排序完毕

复制import random

# 生成随机数列表
lst = []
for i in range(5):
    lst.append(random.randint(0, 100))
print(lst)

# 冒泡排序
# 需要双重循环.外层循环控制比较轮数
# 内存循环控制每轮比较次数

# 选择排序.每次从前向后遍历,找到一个最小值,与该位置交换
# 最后一个位置不需要比较
for x in range(len(lst) - 1):
    # 每轮定义一个初始值,目的是每一轮和后面的值进行比较
    tmp = lst[x]  # 后续用于保存最小值
    idx = x  # 初始值下标.后续用于保存最小值的下标
    # 从初始值向后遍历
    for y in range(x + 1, len(lst)):
        # 在每一轮比较中找出最小值
        if tmp > lst[y]:
            tmp = lst[y]  # 将最小值保存到tmp中
            idx = y  # 下标保存在idx中

    # 根据最小值下标,把初始值放入
    lst[idx] = lst[x]
    # 把最小值放入初始位置
    lst[x] = tmp
print(lst)

# 结果
[88, 0, 33, 26, 10]
[0, 10, 26, 33, 88]

4.3 插入排序

在只有一个元素时,列表是有序的.当出现第二个元素时,依据升序或者降序排列,获得到有两个有序元素的列表.第三个,根据前面的降序,或者升序,将其放入合适的位置,获得到一个有三个有序元素的列表......

• 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
• 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

4.3.1 在一个有序列表里插入元素

复制# import random
#
# # 生成随机数列表
# lst = []
# for i in range(5):
#     lst.append(random.randint(0, 100))
# print(lst)

# 这是一个升序的有序列表
arr = [10, 20, 30, 40, 50]
a = int(input("请输入一个整数:"))

arr.append(a)
"""
我们将插入的数,从大到小比较.
如果列表是升序,则从最后开始比较.如果列表是降序,则从前向后比较
这里是升序列表.如果插入的数据比前面的数小(插入数<比较数),则继续向前比较
如果插入的数比前面的数大(插入数>比较数),则在该数后面插入
"""
# 获取列表最后一个元素的索引
idx = len(arr) -1
while idx > 0:
    # 从后向前遍历
    idx -= 1
    # 遇到比自己小的数,则在后方插入
    if a > arr[idx]:
        arr[idx+1] = a
        break  # 结束循环
    # 遇到比自己大的,大的值向后移动
    else: #if a <= arr[idx]
        arr[idx+1] = arr[idx]
    # 如果最后都没有插入(插入数小于所有列表里的数),则插入到首位
    if idx == 0:
        arr[0] = a
print(arr)

# 输出结果:
请输入一个整数:5
[5, 10, 20, 30, 40, 50]

4.3.2 插入排序

复制import random

# 生成随机数列表
lst = []
for i in range(5):
    lst.append(random.randint(0, 100))
print(lst)

for x in range(1, len(lst)):
    idx = x
    tmp = lst[x]
    while x > 0:
        x -= 1
        if tmp >= lst[x]:
            lst[x+1] = tmp
            break
        else:
            lst[x+1] = lst[x]
        if x == 0:
            lst[0] = tmp
print(lst)

# 输出结果
[94, 50, 36, 2, 71]
[2, 36, 50, 71, 94]