Python – 数据容器基础

简介

Python 的数据容器是指可以存储多数据的类型。

 

列表 List

定义

使用 [] 来定义一个空列表，或者使用 list() 来定义一个列表

list = []
list = list()

带数据定义

 

list = ['a','b','c']

同时它可以存放不同类型的数据

 

list = ['abc', 666, True]

列表中也可以存入列表

 

list = ['a', 666, True]
list2 = [ 'abc', list, [1,2,3] ]

 

 

列表的下标

可以通过下标索引来取出列表中的数据，下标以 0 开始，依次递增

name = list[0]

也可以使用倒序的放式读取，使用负数为索引下标，则表示倒序获取

 

list = ['a','b','c']
name = list[-1]
name => 'c'

当出现嵌套列表时，也可以多个索引下标访问

 

list = ['a','b', ['x','y','z'] ]
name = list[-1][1]
name => 'y'

 

 

查询元素(index)

查询指定元素在列表中所在索引值，如果找不到，会报出ValueError 错误

语法：列表.index(元素)

list = ['a','b', ['x','y','z'] ]
index = list.index('b')
index=>1

 

 

 

修改元素

通过指定下标索引的值，并赋值数据，即可修改元素的数据

list = ['a','b', ['x','y','z'] ]
list[-1][1] = 'k'
# y 会被改为 k
'y' -> 'k'

 

插入元素(insert)

在已有的列表中插入元素

语法：列表.insert(下标，元素)

list = ['a','b', ['x','y','z'] ]
index = list.insert(1,'n')
list => ['a','n', 'b', ['x','y','z'] ]

 

追加元素(append)

在已有的列表中追加一个元素到列表尾部

语法:列表.append(元素)

 

list = ['a','b', ['x','y','z'] ]
index = list.append('n')
list => ['a', 'b', ['x','y','z'] ,'n']

 

批量追加(extend)

把另一个列表中的数据全部追加到指定列表中

语法：列表.extend(其它list元素)

list = ['a','b', ['x','y','z'] ]
append = [1,2,3]
index = list.extend( append )
list => ['a', 'b', ['x','y','z'] ,1,2,3]

 

 

删除元素(del)

在已有的列表中删除一个成员

语法1: del 列表[下标]

语法2: 列表.pop(下标) ,使用pop方法，会返回被删除的元素值

list = ['a','b', ['x','y','z'] ]
del list[1]
list.pop(2)

 

对指定元素进行删除，会对列表进行每个匹配，匹配到了就会删除该元素，如果有多个相同的原素，只会删除最先一个，从左到右进行删除

语法3: 列表.remove(元素)

 

清空列表(clear)

清空当前列表中的所有元素。

语法：列表.clear()

 

统计元素数量(count)

统计某元素在列表中的数量

语法：列表.count(元素) ，返回数量值

 

统计总元素量(len)

统计出当前列表的元素数量

语法：len(列表) ，返回数量值

 

List 遍历

使用 while 进行遍历

index = 0
while index < len(list):
    element = list[index]
    print(f"每一项的值为{element}")
    index += 1

 

使用 for 进行遍历

for element in list:
    print(f"每一项的值为{element}")

 

 

元组 Tuple

元组同列表一样，都是可以封装多个、不同类型的元素在内，但最大的不同点在于：元组一旦定义完成，就不可修改！

定义

语法1: 变量名称 = ()

语法2: 变量名称 = tuple()

定义一个元组数据：

t = (1, 'abc', True)

注意：如果定义元组时只有一个元素，必须要在元素最后加上“,”,否则它将不会认为是元组类型

t = (“abc” , )

只有一个元素的元组，不加上“ , ”号，会被认为是元素类型本身

 

嵌套元组

元组也可以像列表一样嵌套多层的：

t = (“abc” , (1,2,3) )

 

访问成员

访问成员和列表一样，使用下标进行获取：

t = (“abc” , (1,2,3) )

t[0] => "abc"
t[1][1] => 2

 

查找元素(index)

查找当前元素在元组中的索引位置

t = (“abc” , (1,2,3) )

t.index("abc")  => 0

 

统计元素在元组中的数量(count)

统计某个相同元素在元组中的数量

t = (“abc” , (1,2,3) )

t.count("abc")  => 1

 

统计元组个数(len)

统计元组中的总元素个数

t = (“abc” , (1,2,3) )

len(t) => 2

 

遍历

使用 while 遍历

t = (“abc” , (1,2,3) )

index = 0
while index < len(t):
    element = t[index]
    print(f"元组的元素为：{element}")
    index += 1

 

 

使用 for 遍历

t = (“abc” , (1,2,3) )

for element in t:
    print(f"元组的元素为：{element}")

 

 

字符串 Str

本例是以数据容器的角度去理解字符串

和其它容器一样，它可以使用下标来读取单个字符，但字符串是属于不可修改型容器：

str = "abcde"
str[0] => a
str[-1] => e

 

查找索引(index)

在当前字符串中查找对应字符所在的位置索引

str = "abcde"
str.index("c") => 2

 

字符串替换(replace)

语法：字符串.replace(字符串1, 字符串2) ,会把字符串1全部替换为字符串2

注意，并非修改原先的字符串，而是返回一个新的字符串。

str = "abcde"
re = str.replace("b","v")
re => "avcde"

 

字符串分割(split)

对一个字符串进行字符串的分割

语法：字符串.split(分割符)

注意，并非修改原先的字符串，而是返回一个新的字符串。

str = "a,b,c,d,e"
re = str.split(",")
re => ["a","b","c","d","e"]

 

字符串规整(strip)

删前尾空格字符串

语法：字符串.strip() 默认为空格，如果传入参数，则认为是删除前后相应的字符

str = "    abcde    "
re = str.strip()
re =>"abcde"

当传入参数时，会对前后的字符进行删除指定的字符

str = "2211abcde12"
re = str.strip("12")
re =>"abcde"

 

统计字符出现数量(count)

str = "2211abcde12"
re = str.count(1)
re => 3

 

统计字符总数量(len)

str = "2211abcde12"
re = len(str)
re => 11

 

切片

序列是指包含有序，下标的数据，列表、元组、字符串都可以看作为序列

切片是指在基于序列的内容情况下，切出里面部分数据，比如【1,2,3,4,5】中获取【2,3,4】

语法：序列[起始下标:结束下标:步长]

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔
  • 步长1表示：一个个取元素
  • 步长2表示：每次跳过一个元素隔一个取一个
  • 步长N表示：每次跳过N-1个元素取一个
  • 步长为负数表示，反向取元素（注意：起始下标和结束下标也要反向标记）

# 对list 列表进行切片
my_list = [0, 1, 2, 3, 4, 5, 6, 7]

# 对list进行切片，从1开始，4结束，步长1
result = my_list[1:4]
print(f"结果为：{result}")
# 结果为：[1, 2, 3]

# 对tuple进行切片，从头开始，到最后结束，步进为1
t = (1, 2, 3, 4, 5, 6, 7)
result2 = t[:]
print(f"结果为：{result2}")
# 结果为：(1, 2, 3, 4, 5, 6, 7)

# 对str进行切片，从头开始，到最后结束，步长为2
str = "1234567"
result3 = str[::2]
print(f"结果为：{result3}")
# 结果为：1357

# 对str进行切片，从头开始，到最后结束，步长-1
str2 = "1234567"
result4 = str2[::-1]
print(f"结果为：{result4}")
# 结果为：7654321

# 对列表进行切片，从3开始，到1结束，步长-1
result5 = my_list[3:1:-1]
print(f"结果为：{result5}")
# 结果为：[3, 2]

# 对元组进行切片，从头开始，到尾结束，步长-2
result6 = t[::-2]
print(f"结果为：{result6}")
# 结果为：(7, 5, 3, 1)

 

 

 

集合 Set

列表可修改、支持重复元素且有序

元组、字符串不可修改、支持重复元素且有序

而集合则是可修改、不支持复复、且无序的，所以不支持下标访问

语法1：{元素,元素,元素,元素,元素,....元素}

语法2: empty = set()  定义空集合

注意：空集合的定义不可以使用 {} 因为 {} 被字典定义所占用

 

添加元素(add)

在已有的set集合中增加新的元素

语法：set.add(元素)

 

移除元素(remove)

在已有的set集合中移除指定的元素

语法：set.remove(元素)

 

随机移除元素(pop)

从已有的集合中随机取出一个元素返回并删除

语法：set.pop()  随机返回一个元素值，集合中删除

 

清空集合(clear)

清空已有的集合中的所有元素

语法：set.clear()

 

取两个集合的差集(difference)

取出两个集合中，集合1中有，而集合2中没有的元素，返回一个新的集合

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
set3 => {2,3}

 

 

消除两个集合的差集(difference_update)

对比集合1和集合2,在集合1内，删除和集合2相同的元素，结果是集合1被修改，集合2不变

set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
set1 => {2,3}
set2 => {1,5,6}

 

 

合并合集(union)

合并两个集合中的元素为一个新的合集

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
set3 => {1,2,3,5,6}

 

 

统计元素数量(len)

统计一个集合的所有元素数量

set1 = {1,2,3}
set2 = {1,5,6}
len(set1) => 3
len(set2) => 3

set3 = set1.union(set2)
set3 => {1,2,3,5,6}
len(set3) => 5

 

 

遍历

使用 for 进行遍历

set1 = {1,2,3}
for ele in set1:
    print(f"结果为：{ele}")  # => 1 2 3

 

 

字典 Dict

字典的定义，同样使用 {} 作为包裹，不过存储的元素是一个个的【键】：【值】对

语法1: dict = {} 空字典

语法2: dict = {key:value,key:value,...key:value}

语法3: dict = dict() 空字典

 

查询元素

通过使用 [key] 来取出该key的value值

value = dict[key]

注意：

• 字典不支持下标访问
• 字典不支持重复key

 

新增与更新元素

语法：字典[key] = value

• 当字典中不存在 key 时，则为新增元素操作
• 当字典中存在 key 时，则为修改原元素数据操作

 

删除元素(pop)

删除字典中特定key的元素，返回被删除的元素value值

语法：字典.pop(key) 获得指定的value值，同时在字典中移除

 

清空元素(clear)

删除字典中所有的元素

语法: 字典.clear()

 

获取全部key值(keys)

获取字典中的所有元素的全部key

语法：字典.keys()

 

统计元素数量(len)

语法：len(dict) 返回字典元素个数

 

遍历

使用 for 遍历字典中的元素

dict1 = {key:value,key:value}
for key in dict1.keys():
    print(f"结果为：{dict1[key]}") 

同时直接遍历字典，所输出的值也为key

 

dict1 = {key:value,key:value}
for key in dict1:
    print(f"结果为：{dict1[key]}") 

 

 

数据容器通用操作

计算总元素个数(len)

统计出一个数据容器的总个数，略

 

取出最大的元素值(max)

取出容器中所有数值中最大的数值

list = [1,2,3,4,5]
max(list) => 5

 

取出最小的元素值(min)

list = [1,2,3,4,5]
min(list) => 1

 

 

容器类型的互相转换

给任意数据容器转换为 list 列表

语法：list(其它数据容器)

注意：字典转到list容器时，会把 value 丢弃，只留下 key

 

给任意数据容器转换为 tuple 元组

语法：tuple(其它数据容器)

注意：字典转到tuple 容器时，会把 value 丢弃，只留下 key

 

给任意数据容器转换为 Str 字符串

语法：str(其它数据容器)

注意：会把编程格式转为文本表达方式

 

给任意数据容器转换为 set 集合

语法：set(其它数据容器)

注意：字典转到set容器时，会把 value 丢弃，只留下 key，若并有相同元素，会被去重

 

数据容器的排序(sorted)

语法: sorted(容器, [reverse=true|false]) 排序结果会返回为一个list列表类型

• 当正向排序时，直接传入容器就可以
• 当需要反向排序时，需要传入另一个参数 reverse=true

list = [1,2,3,4,5]
sorted(list) => 正向排序
sorted(list, reverse=True) => 反向排序