2023.12.21 python 5大容器,列表-元组-字符串-集合-字典

?

目录

1.列表?

一些增删改查函数:

2.元组

元组推导式?

3.字典

4.字符串

5.集合

---

1.列表?

存储的每个数据称为元素.

列表可以存放各种类型的元素,但一般都是放同种类型的元素.

下标索引:? 正向索引0,1,2,3? ? 反向索引? -4,-3,-2,-1

列表在JAVA中叫做数组,嵌套内的叫做二维数组或者三维数组

列表与列表之间使用+号拼接后,会自动合成一个列表

一些增删改查函数:

• append末尾追加
• remove 删除列表中第一个出现的指定数据
• del 列表[索引] 删除指定索引的元素
• 列表[索引] = 新值? ?修改指定索引元素的数据 (注意:对列表中不存在的元素进行赋值会报错)
• len 计算长度,元素个数
• 值in列表? 判断列表中是否包含某个元素
• 值not in 列表? 判断列表中是否不包含某个元素
• 列表.sort() 对列表中的数据进行排序,默认升序?
• reverse 反转 ,一般配合sort 进行降序排序??list.sort(reverse=True)
• enumerate(list) 枚举加编号,一般配合循环,获取容器内的下标索引, 遍历后的元素类型为元组
• 使用pop抽出一个元素,抽出后就不在容器里了,没有输入索引的话就默认最后一个

第一个冒号的左右两边,索引开始:索引结束:左闭右开,也就是包括左边,不包括右边

如果step为负数,先将列表反转,再截取列表

注意:即使步长是负数,相当于列表元素进行了反转,但是对应的下标索引也是没有变的

如果step为正数,小的索引在前面:如果step为负数,大的索引在前面

[起始:结束:步长]? 左闭右开 ,有左边没有右边

# 列表
name_list = ['lmf']
# 添加元素
name_list.append('bwj')
print(name_list)
# 删除元素
name_list.remove('bwj')
print(name_list)
# 根据下标索引获取元素
print(name_list[0])
# 根据下标索引修改元素
name_list[0] = 'lhl'
print(name_list)
# 通过下表索引删除元素
int_list = [1, 2, 3, 4, 5]
del int_list[0]
print(int_list)

# 列表元素的个数
print(len(int_list))
# 正向访问+len()方法
print(-len(int_list))
print(int_list[-len(int_list)])
# 正向访问+len()方法
print(int_list[len(int_list)-1])

# 求最大元素
print(max(int_list))
# 求最小元素
print(min(int_list))
# 求元素和
print(sum(int_list))  # 需要全数字类型

# 列表中的元素重新排序
int_list = [3, 2, 1, 4, 5]
int_list.sort()
print(int_list)
# 1,2,3,4,5
int_list.sort(reverse=True)
# reverse翻转 True就是真的翻转  5,4,3,2,1
print(int_list)

a = int_list.sort(reverse=True)
print(a) #结果为none,sort方法无法将反转后的结果赋值给变量

# 判断元素是否在列表中
print('lmf' in name_list)  # False
print('lmf' not in name_list)  # True

# 添加元素,之后用作遍历
name_list.append('bwj')
name_list.append('lxz')
name_list.append('wwd')
name_list.append('wyc')
name_list.append('zy')
print(name_list)

for name in name_list:
    print(name)

# 返回下标
for index, name in enumerate(name_list):
    print(index, name)
print('-' * 40)
# 列表切片,[起始索引:结束索引:步长] 返回列表
print(name_list)
# ['lhl', 'bwj', 'lxz', 'wwd', 'wyc', 'zy']

print(name_list[1:2])
print(name_list[0:-2:1])
print(name_list[0::2])
print(name_list[::-1])
print(name_list[1::-1])

# 列表推导式,做题常用,将遍历后的元素放到列表中
# new_list = [int(i) for i in input('请输入内容').split()]
# 用户输入的内容,每一个都用空格隔开后,就会切割成各个字符
# print(new_list)

int_list = [10, 20, 30, 40, 50]
new_int_list = [i * 2 for i in int_list[::-1]]
# [100, 80, 60, 40, 20]
print(new_int_list)

int_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 10,9,8,7,6,5,4,3,2,1
# 0,1,2,3,4,5,6,7,8,9
print(int_list[5:8:])
print(int_list[::-1])
print(int_list[9:8:-1])
# 步长是负数,所以反转后[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
# 之后再取正向时的索引第9位和第8位,所以步长为负数时,冒号左边一定是比右边大的
# 正向索引的 8对应列表里的数字9, 索引的9对应列表的数字10
## 10,9,8,7,6,5,4,3,2,1 所以能得到[10,9]

2.元组

最大特点,数据无法修改?

注意:如果元组中只有一个元素,必须加逗号,为了和其他类型的数据作区分,否则就会类型错误

?元组对元素数据类型没有统一要求,但一般存储相同类型的元素

• ?元组[索引]
• len(元组)
• 值 in 元组
• 值 not in 元组?
• for 变量 in 元组?

# 元组类型
tuple1 = tuple(new_int_list)
print(tuple1, type(tuple1))
# 推导式再转回列表
tuple_to_list = [i for i in tuple1]
print(tuple_to_list, type(tuple_to_list))

元组推导式?

int_tuple = ('您好', '我好', '大家好')
print(type(int_tuple))
# <class 'tuple'>
new_generator = (i for i in int_tuple[::-1])
print(new_generator)
# 返回可迭代对象
# 返回了这个东西<generator object <genexpr> at 0x000002776AC73900>
for i in new_generator:
    print(i)  # 得要循环遍历一次这个东西才看得到内容
    # 大家好
    # 我好
    # 您好

3.字典

JSON和字典是不同的,JSON需要用双引号

定义空字典:

mydict = {}

mydict = dict()

通过键找值: print(字典[key])

修改字典中的元素,类似于upsert:update + insert?如果表中已存在指定值，则更新现有行；如果指定值不存在，则插入新行。

如果key存在,就相当于修改value? ; 如果key不存在,就相当于新增

使用.get获取值的时候,如果key不存在,则返回none

在循环遍历时,想要把键值对都遍历出来,需要加.items()

dict_int = {'a': 128, 'b': 64, 'c': 32}
print(len(dict_int))
print(max(dict_int))
print(min(dict_int))  
# 取出来做运算的是key

for i in dict_int.items():
    print(i, type(i))
    # ('a', 128) <class 'tuple'>
    # ('b', 64) <class 'tuple'>
    # ('c', 32) <class 'tuple'>
for i in dict_int.keys():
    print(i, type(i))
    # a <class 'str'>
    # b <class 'str'>
    # c <class 'str'>
for i in dict_int.values():
    print(i, type(i))
    # 128 <class 'int'>
    # 64 <class 'int'>
    # 32 <class 'int'>
for i in enumerate(dict_int.items()):
    print(i)
    # (0, ('a', 128))
    # (1, ('b', 64))
    # (2, ('c', 32))

for index, (key, value) in enumerate(dict_int.items()):
    print(index, key, value)
    # 0 a 128
    # 1 b 64
    # 2 c 32

4.字符串

find 找指定元素的索引,没找到就返回-1

index 找指定元素的索引,没找到报错

replace? (字符串.replace('旧字符串','新字符串',替换的次数,假如不写次数则默认全部替换))

split 从指定的字符,分割字符串?

str1 = 'aaaaaa,bbbbbbbbb,'
str2 = str1.split(',')
print(str2)
# ['aaaaaa', 'bbbbbbbbb', '']

?eval 去除引号

str_int = '1,2,3,4,5'
print(eval(str_int),type(eval(str_int)))
# 去掉引号变为 (1, 2, 3, 4, 5) <class 'tuple'>

?join 用字符串拼接列表中的每一个元素

list1 = ['a', 'b', 'c', 'd']
join1 = '-'.join(list1)
print(join1)
#  a-b-c-d

5.集合

集合最大的特点就是 去重和无序

使用pop随机抽出一个元素,抽出后就不在集合里了,在列表中也有pop函数,需要加索引

set2 = {30, 40, 50, 60, 70, '我是数字'}
print('set2:', set2)
# 往队尾添加元素,集合是去重的,所以添加的内容也要和原来的数据不一样
set2.add(80)
set2.add(90)
set2.add('我就是数字')
print('set2.add:', set2)
# 删除指定的元素
set2.remove('我是数字'), print('set.remove:', set2)
# 随机取出一个元素
print('set2.pop随机抽一个数字:', set2.pop())
# 遍历每个元素
for i in set2:
    print(i)
print('-' * 40)
# 集合是无序的,但也可以枚举
for index, i in enumerate(set2):
    print(index, i)