Py 数据容器

Py 数据容器

Python中的数据容器：

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

一、list（列表）

列表的定义

定义变量：

变量名 = [元素1, 元素2, …]

定义空列表：

变量名 = []

变量名 = list()

列表内可以放各种元素，包括另一个列表

my_list =[['123', 321], ["1234567", False]]
# 列表的嵌套
# 这个列表要有两个元素，每个元素都是列表
print(my_list)
print(type(my_list))

列表的下标索引

列表中的每个元素都有对应的下标，当用正数作为下标时，从左到右，从0开始；当以负数作为下标时，从右向左，从-1开始

我们可以用 列表名[下标] 来引用列表中的元素

当列表进行嵌套时，要用两次下标索引，即 列表名[内层列表在外层列表的下标][所需元素在内层列表的下标]

my_list = ["abc", 123, 3210]
# 用正数下标
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 用负数下标
print(my_list[-3])
print(my_list[-2])
print(my_list[-1])
# 输出 abc  123 3210 abc 123 3210

# 列表的嵌套
my_list = [["abc", 123], [3210]]
print(my_list[0])
# 输出 ['abc', 123]}

列表的特点

• 可以容纳多个元素（2**63 - 1个）
• 可以存储不同种类的的元素
• 允许重复数据存在
• 可以修改

列表的常用操作

查找元素的下标

语法：列表名.index(元素)

my_list = ["abc", 123, 3210]
ret = my_list.index(123)
print(ret)

# 输出1
# index的返回值为int类型

修改特定位置的值

语法：列表名[下标] = 值

插入元素

语法：insert(下标， 元素)

在指定位置插入指定元素，并将该位置原有的元素后移

my_list = ["abc", 123, 3210]
my_list.insert(1, 456)
print(my_list)
# 输出['abc', 456, 123, 3210]

追加元素

语法：列表名.append(元素)

将指定元素追加到列表的尾部

my_list = ["abc", 123, 3210]
my_list2 = ["efg", 456, 3210]
my_list.extend(my_list2)
print(my_list)
# 输出['abc', 123, 3210, 'efg', 456, 3210]

删除元素

删除指定位置元素

语法1：del 列表名[下标]

语法2：列表名.pop(下标)

区别：pop有返回值，返回值为移除的内容（相当于从列表中取走内容）

my_list = ["abc", 123, 3210]
my_list2 = ["efg", 456, 3210]
del my_list[1]
ret = my_list2.pop(1)
# pop有返回值，为移除（取出）的内容
print(my_list)
print(my_list2)
print(ret)
# 输出['abc', 3210]
     ['efg', 3210]
   456

根据内容删除元素

删除某元素在列表中的第一个匹配项（列表内容可以重复）

语法：列表名.remove(元素)

my_list = ["abc", 123, 3210, "abc", 123, 3210]
my_list.remove(123)
# 如果要删掉两个的话要用两次
print(my_list)
my_list.clear()
print(my_list)
# 输出['abc', 3210, 'abc', 123, 3210]
   []

清空列表

语法： 列表名.clear()

列表内容统计

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

语法：列表名.count(元素)

统计列表内的元素数量

语法：len(列表名)

my_list = ["abc", 123, 3210, "abc", 123, 3210]
count = my_list.count(123)
print(count)
count2 = len(my_list)
print(count2)
# 输出2
  6

列表的遍历

将容器内的元素依次取出进行处理的行为，称之为：遍历

可以用while加下标索引进行遍历

或者用for循环，for循环更适合数据容器的遍历

# 利用遍历分别取出奇数和偶数
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list1 = []
list2 = []
index = 0
while index < len(my_list):
    if my_list[index] % 2 == 0:
       list1.append(my_list[index])
    index += 1

for num in my_list:
    if num % 2 == 1:
        list2.append(num)

print(list1)
print(list2)

二、tuple（元组）

元组同列表一样，都可以封装多个、不同类型的元素

但最大的不同点在于：元组一旦定义完成，就不可修改

所以，当我们需要在程序内封装数据，又不希望封装的数据被修改，就可以使用元组

元组的定义

变量名 = (元素1, 元素2, …)

（把变量名去掉就是定义字面量）

注意：当元组只有一个数据，数据后面需要加上括号，后面没加逗号时，变量会变成str

定义空元组：
法一：变量名 = ()

法二：变量名 = tuple()

（变量名称 = tuple（） 实际上是得到了一个元组的类对象）

元组也支持嵌套和下标索引

元组的常用操作

由于元组不能被修改，其可进行的操作较少

查找元素下标

语法： 变量名.index(元素)

统计某个元素的数量

语法： 变量名.count(元素)

统计元组内元素个数

语法：len(变量名)

元组内容的修改

由于元组不能被修改，因此直接修改元组内的元素会报错，但是当元组内存在列表时，我们可以修改列表的内容

t1 = (1, 2, 3, [45612, "wdakjnsf", "dwa000"])
t1[3][2] = "abc"
print(t1)
# 输出(1, 2, 3, [45612, 'wdakjnsf', 'abc'])

三、str（字符串）

同元组一样，字符串也无法被修改

字符串的下标索引以每个字符为单位计算

字符串的操作

注意：需要追加、修改字符等，需要创建新的字符串

查找特定字符的下标

语法： 变量名.index(字符串)

当括号中的为字符串时，得到的下标为首元素下标

字符串的替换

语法： replace(字符串1, 字符串2)

用途：将字符串1替换为字符串2的内容，并生成一个新的字符串（注意：原字符串不变）

str1 = "123 654 789121"
str2 = str1.replace("123", "321")
print(str1)
print(str2)
# 输出123 654 789121
# 321 654 789121

字符串的分割

语法：变量名.split(字符串)

用途：根据split后面的括号中的字符串进行切分，注意：在分割后，用于分割标记的字符会消失

字符串本身不变，得到一个列表

str1 = "123 654 7893121"
my_list = str1.split("3")
print(my_list)
# 输出['12', ' 654 789', '121']

字符串的规整

字符串的规整为去掉字符串前后的元素

语法：变量名.strip(字符串)

当括号内不写参数时，为去掉前后空格，写了参数时，为去掉前后对应的字符串

此处的去除是指创建一个新的字符串，原字符串不变

注意是只能去除前后的，中间的能去

字符串的统计

统计某字符串出现的次数

语法：变量名.count(字符串)

统计字符串长度

语法： len(变量名)

统计时，数字、英文、中文、符号均算作一个字符

字符串的遍历

字符串可通过for和while遍历

四、序列

序列是指：内容连续、有序，可使用下标索引的一类数据容器

列表、元组、字符串，均可以可以视为序列。

序列的切片

切片是指：从一个序列中，取出子序列

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

其中，起始和结束下标留空代表从头开始、取到结尾，步长为取元素的间隔

该操作不影响序列本身，而是会获得一个新的序列

my_list = [1321, 11651, 319813, 9845, 4897, 464, 194, 984, 131, 6513, 44313]
new_list = my_list[2:8:2]
print(new_list)
# 输出[319813, 4897, 194]

str1 = ("abiysgbfkbfg biaubsdkawdasdwda 2")
str2 = str1[::-1]
# 倒序存入str2
list1 = str2.split(" ")
# 以空格为界分割
str3 = str2.replace("a","3")
# 替换a
print(str1)
print(str2)
print(str3)
print(list1)
# 输出abiysgbfkbfg biaubsdkawdasdwda 2
# 2 adwdsadwakdsbuaib gfbkfbgsyiba
# 2 3dwds3dw3kdsbu3ib gfbkfbgsyib3
# ['2', 'adwdsadwakdsbuaib', 'gfbkfbgsyiba']

五、set（集合）

集合的特点

• 不支持重复元素
• 没有顺序（即不能用下标索引）

集合的定义

语法：变量名 = {元素1, 元素2, …}

（把变量名去掉就是定义字面量）

定义空集合：
变量名 = set()

（不能直接放一个大括号）

set1 = {"abc", "bcd", 485364, "abc", 0x13212, "bcd"}
print(set1)
# 输出{78354, 485364, 'abc', 'bcd'}
# 去重了，且每次输出的顺序不同

集合的操作

注意：集合没有下标索引操作，因为它没有顺序（不是序列）

集合的修改

注意是集合本身被修改

添加元素

语法：变量名.add(元素)

移除元素

语法：变量名.remove(元素)

随机取出元素

语法：变量名.pop()

用途：从集合中随机取出一个元素（集合本身被修改）

清空集合

语法：变量名.clear()

取出两个集合的差集

语法：变量名1.difference(变量名2)

得到一个新集合，内容为两个集合的差集（集合1有而集合2没有的）

消除两个集合的差集

语法：变量名1.difference_update(变量名2)

用途：在集合1内删除集合2没有的元素（集合1被改变）

集合合并

语法：变量名1.union(变量名2)

用途：得到一个包含集合1和集合2的新集合（原集合不变）

求集合长度

语法： len(变量名)

集合的遍历

由于集合是无序的，所以集合只能用for循环遍历，而不能用while加上下标遍历

list1 = ["abc", "cba", "abc", "abcbca", "123456", 123456]
set1 = set()
# 注意这要用set(),不能直接放一个{}
for a in list1:
    set1.add(a)
# 随机取出元素放进set1
print(set1)

六、dict（字典）

python中的字典：

key：Value

通过字典，可以用key取出Value（每一对是一个键值对）

注意：

• key不能重复，否则相同key，后面的Value会覆盖前面的Value
• Key和Value可以是任意类型（key不能是字典）

字典的定义

语法：变量名 = {key1:Value1, key2:Value2, …}

dict1 = {"a":"awjmdasmk", "b":65411, "c":41, "d":"awdasd"}
print(dict1)
print(type(dict1))
# 输出{'a': 'awjmdasmk', 'b': 65411, 'c': 41, 'd': 'awdasd'}
# <class 'dict'>

字典的操作

获取数据

字典不能用下标索引，但是字典可以用key取出对应的Value

语法：变量名[key]

字典的嵌套

字典是可以进行嵌套的，而嵌套字典内的元素的调用方式和列表等序列类似

语法：变量名[外层字典的key][内层字典的key]

字典的修改

新增/修改元素

语法： 变量名[key] = Value

当key是原有的，为修改Value值，否则为新增元素

删除元素

语法：变量名.pop(key)

用途：获取key对应的Value，同时字典内该元素被删除

清空字典

语法：变量名.clear()

获取全部key

语法： 变量名.keys()

字典的遍历

字典不支持下标索引，只能用for循环遍历

dict1 = {"a":"awjmdasmk", "b":65411, "c":41, "d":"awdasd"}
for a in dict1.keys():
    print(dict1[a])

计算键值对的数量

语法： len(变量名)

七、数据容器的通用操作

统计

语法：操作(变量名)

操作	用途
len(变量名)	统计容器内的元素个数
max(变量名)	统计容器内的最大元素
min(变量名)	统计容器内的最小元素

注意：字符串的比较为逐个比较ASCII值（即两个字符串比较时，只要前面的字符对应的ASCII值大，则整个大）

容器的转换

语法： 操作(变量名)

操作	用途	备注
list()	将容器转换为列表	字符串转列表是把字符串里的每一个元素都取出来，字典转列表会把value都丢掉
str()	将容器转换为字符串	字典、列表、元组、集合在转换后打印出来不变，但是实际上已经在两边加上了双引号
tuple()	将容器转换为元组	字符串转列元组是把字符串里的每一个元素都取出来，字典转元组会把value都丢掉
set()	将容器转换为集合	把括号改成{ }，同时具有无序性，字典转集合会把value都丢掉

各类型转字典一般转不了，没有键值对

容器的通用排序

语法： sorted(变量名, [reverse=True])

第二个参数是有默认参数的，控制从大到小还是从小到大排序

排序后均得到list

dict1 = {"a":"dasd", "b":"ajsbduiaw", "c":"dadasd"}
list1 = sorted(dict1)
print(list1)
# 输出['a', 'b', 'c']
# 这里的字典也丢失了value

dict1 = {"a":"dasd", "b":"ajsbduiaw", "c":"dadasd"}
list1 = sorted(dict1, reverse=True)
print(list1)
# 输出['c', 'b', 'a']