002python基础数据容器学习

最新推荐文章于 2024-05-17 18:09:22 发布

Cles8it

最新推荐文章于 2024-05-17 18:09:22 发布

阅读量65

点赞数

文章标签：学习 python

本文链接：https://blog.csdn.net/m0_57790599/article/details/131405919

版权

Python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等

数据容器list(列表)

基本语法：

# 字面量
[元素1, 元素2, 元素3, 元素4, ...]
# 定义变量
变量名称 = [元素1, 元素2, 元素3, 元素4, ...]

# 定义空列表
变量名称 = []
变量名称 = list()

注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

my_list1 = ['nihao', 'python', 'xiaohong', 'pycharm']
my_list2 = [my_list1, 'world']
print(my_list2)
print(type(my_list2))
>>>
[['nihao', 'python', 'xiaohong', 'pycharm'], 'world']
<class 'list'>

list的遍历

列表的下标(索引)

# 语法: 列表[下标索引]
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0])
print(name_list[1])
print(name_list[2])
>>>
Tom
Lily
Rose

索引也可以使用反向索引，从-1开始

# 语法: 列表[下标索引]
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
>>>
Rose
Lily
Tom

注意，操作索引范围会报错
嵌套列表索引

list1 = [[1, 2, 3], [4, 5, 6]]
# 要求取list1中的5
print(list[1][1])
>>>
5

list1 = [[1, 2, 3], [4, 5, 6, [7, 8, 9]]]
# 要求取list1中的8
print(list1[1][3][1])
>>>
8

列表类方法

列表的查询方法：list.index(元素)

功能：查找指定元素在列表的下标，如果找不到，报错ValueError，返回的下标类型为int
对于嵌套列表的查询只能查询到第一层

列表元素的修改方法：list[下标] = 修改值

功能：将列表中对应下标的元素的值修改成‘=’右边的值

列表的元素插入方法：list.insert(下标, 元素)

my_list1 = ['nihao', 'python', 'xiaohong', 'pycharm']
my_list1.insert(1, 'bit')
print(my_list1)
>>>
['nihao', 'bit', 'python', 'xiaohong', 'pycharm']

列表的元素追加方法：list.append(元素)

功能：在列表尾部进行一个追加

my_list1 = ['nihao', 'python', 'xiaohong', 'pycharm']
my_list1.append('人生苦短，我用python')
print(my_list1) 
>>>
['nihao', 'python', 'xiaohong', 'pycharm', '人生苦短，我用python']

注意，append()方法只能追加一个元素，如果要追加一批元素，可以使用extend()方法
语法如下：list.extend(其他数据容器)

my_list1 = ['nihao', 'python', 'xiaohong', 'pycharm']
my_list2 = [1, 2, 3]
my_list1.extend(my_list2)# 如果使用append的话,此处的my_list2会被当成一个整体追加到my_list1尾部
print(my_list1)
>>>
['nihao', 'python', 'xiaohong', 'pycharm', 1, 2, 3]

列表元素的删除方法：
1. del list[下标]
2. list.pop(下标) 此方法还会返回删除元素的值
3. list.remove(元素)调用正确返回值为None，否则会报错，从列表0号元素开始查找，找到与之匹配的第1个元素进行删除

my_list1 = ['nihao', 'python', 'xiaohong', 'pycharm']

# del list[]
del list[3] # pycharm
print(my_list1)
# list.pop()
e1 = list.pop(2) # xiaohong
print(e1)
print(my_list1)
# list.remove()
my_list1.remove('nihao')
print(my_list1)
>>>
['nihao', 'python', 'xiaohong']
xiaohong
['nihao', 'python']
['python']

列表清空方法：list.clear()
列表某个元素统计方法：list.count(元素)

功能：统计某一个元素在列表中的数量

列表长度获取方法(也表示列表中有多少个元素)：len(列表名)

总结

index	使用方法	作用
1	list.addend(元素)	向列表中追加一个元素
2	list.extend(容器)	将容器中的元素取出，追加到list末尾
3	list.insert(下标, 元素)	指定下标，插入指定元素
4	del list[下标]	删除list指定下标元素
5	list.pop(下标)	删除list指定下标元素，并且返回该元素
6	list.remove(元素)	删除list中指定的元素
7	list.clear()	清空整个list
8	list.count(元素)	统计该元素在list中的个数
9	list.index(元素)	查找指定元素在列表中的下标
10	len(容器)	统计容器内有多少个元素

遍历方法

while循环
for循环
演示代码

# while循环的方式遍历
def list_while_func():
    mylist = ['cles', 'bit', 'love', 'code']
    index = 0
    print("while循环的方式遍历")
    while index < len(mylist):
        elem = mylist[index]
        print(f"列表的元素：{elem}")
        index += 1

# for循环的方式遍历
def list_for_func():
    mylist = ['cles', 'bit', 'love', 'code']
    print("for循环的方式遍历")
    for elem in mylist:
        print(f"列表中的元素：{elem}")

list_while_func()
list_for_func()
>>>
while循环的方式遍历
列表的元素：cles
列表的元素：bit
列表的元素：love
列表的元素：code
for循环的方式遍历
列表中的元素：cles
列表中的元素：bit
列表中的元素：love
列表中的元素：code

tuple元组

特点

不可修改
与列表比较，列表是可以修改的，元组是不可以修改的，所以可以将元组理解为：定义完成后，不可修改的列表
元组的定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

# 定义元组字面量
(元素, 元素, 元素, 元素, ...)
# 定义元组变量
变量名称 = (元素, 元素, 元素, 元素, ...)
# 定义空元组
变量名称 = () # 方式1
变量名称 = tuple() # 方式2
# 定义单个元组的元组
t1 = ("hello", ) # 逗号是不可以省略的，省略之后变成了str类型
# 元组可以嵌套定义
# 元组的基本操作.index()		.count()	len()

元组的遍历

# 元组的遍历
mytuple = (9, 8, 7, 6, 5, 4)

def tuple_while():
    print("while循环遍历")
    index = 0
    while index < len(mytuple):
        print(f"元组内的元素有：{mytuple[index]}")
        index += 1

def tuple_for():
    print("for循环遍历")
    for elem in mytuple:
        print(f"元组内的元素有：{elem}")


tuple_while()
tuple_for()

特例

当元组中嵌套列表的时候，可以对元组中的列表进行修改

mytuple1 = (1, 2, 3, [4, 5, 6])
print(f"未修改的元组为：{mytuple1}")

mytuple1[3].append("hello tuple")
print(f"修改后的元组为：{mytuple1}")
>>>
未修改的元组为：(1, 2, 3, [4, 5, 6])
修改后的元组为：(1, 2, 3, [4, 5, 6, 'hello tuple'])

str(字符串)

特点

和元组一样，字符串是一个无法修改的数据容器

常用方法

index方法

# index方法
mystr = 'cles and bit'
print(f"在字符串{mystr}中查找and,起始下标为{mystr.index('and')}")
>>>
在字符串 cles and bit中查找and,起始下标为6

replace方法

# replace方法
'''
string.replace(str1,str2)
功能：将string中的str1替换成str2
返回值是一个新的字符串
'''
mystr = 'cles and bit'
temp_str = mystr.replace('and', '和')
print(temp_str)
>>>
cles 和 bit

split方法

# split方法
'''
string.split(str)
功能：将str作为分隔符，将string中的内容分割，并且保存到一个list中
返回值是一个list容器
'''
mystr = 'clesbit love coding and skateboard'
temp = mystr.split(' ')
print(f"字符串{mystr},被分割之后变成了{temp},类型是{type(temp)}")
>>>
字符串clesbit love coding and skateboard,被分割之后变成了['clesbit', 'love', 'coding', 'and', 'skateboard'],类型是<class 'list'>

strip方法

# strip方法
'''
string.strip() 参数可选
当不传参数的时候，此方法会去除掉字符串前后的空格
当传入参数的时候，此方法会将参数的内容划分为字串，进行字符串的规整操作
返回值是一个字符串
'''
newstr = '  **#clesbit love coding and skateboard*#*   '
print(f"原字符串是：{newstr}")
temp1 = newstr.strip()
print(f"不传参数的时候：{temp1}")
temp2 = newstr.strip(' *# ')
print(f"传入参数' *# '的时候：{temp2}")
>>>
原字符串是：  **#clesbit love coding and skateboard*#*   
不传参数的时候：**#clesbit love coding and skateboard*#*
传入参数' *# '的时候：clesbit love coding and skateboard

count方法统计字符串中某个字符串出现的次数
len方法也就是字符串长度了

数据容器的切片

序列是指:内容连续、有序，可使用下标索引的一类数据容器列表、元组、字符串，均可以可以视为序列。
偷懒一下嘿嘿

说明：切片后的序列类型和原序列一样

set集合

定义语法

# 定义集合字面量
{元素, 元素, 元素, 元素, ...}
# 定义集合变量
变量名称 = {元素, 元素, 元素, 元素, ...}
# 定义空集合
变量名称 = set()

集合的特点

不能重复，内容是无序的，所以不支持下标索引访问

集合的常用方法

# 集合的常用方法
# 添加新元素
# 集合.add(元素)
my_set = {'hello', 'world'}
my_set.add('clesbit')

# 移除元素
# 集合.remove(元素)，将指定元素从集合中移除
my_set = {'hello', 'python', 'pycharm', 'clesbit'}
my_set.remove('python')
# >>> {'pycharm', 'clesbit', 'hello'}

# 取元素
# 集合.pop(),功能是从集合中随机取出一个元素，同时集合本身会被修改，取出的元素会在集合中移除
my_set = {'hello', 'python', 'pycharm', 'clesbit'}
print(f"集合中取出的元素是:{my_set.pop()},集合中还剩下{my_set}")


# 清空集合
# 集合.clear()，功能是清空整个集合
my_set = {'hello', 'python', 'pycharm', 'clesbit'}
print(f"集合清空之后：{my_set.clear()}")

# 取两个集合的差集
# 集合1.difference(集合2)
# 结果：得到一个新的集合，包含集合1内有但是集合2没有的元素
myset1 = {1, 3, 5, 7, 9}
myset2 = {1, 2, 4, 7, 8}
diffset = myset1.difference(myset2)
print(diffset)
# >>> {9, 3, 5}

# 消除差集
# 集合1.difference_update(集合2)
# 结果在集合1内删除和集合2相同的元素,修改的是集合1
myset1 = {1, 3, 5, 7, 9}
myset2 = {1, 2, 4, 7, 8}
myset1.difference_update(myset2)
print(myset1)
# >>> {3, 5, 9}

# 集合合并
# 集合1.union(集合2)
# 结果将集合1与集合2进行一个合并，得到一个新的集合
myset1 = {1, 3, 5, 7, 9}
myset2 = {1, 2, 4, 7, 8}
unionset = myset1.union(myset2)
print(unionset)
# >>> {1, 2, 3, 4, 5, 7, 8, 9}

# 集合元素统计
# len(集合)
myset1 = {1, 1, 2, 3, 5, 4}
print(len(myset1))
# >>> 5

# 集合遍历
# 只能通过for循环
my_set = {'hello', 'python', 'pycharm', 'clesbit'}
for elem in my_set:
    print(f"集合中的元素是：{elem}")

dict字典、映射

字典的定义

# 定义字典字面量
{key: value, key: value, key: value, key: value, ...}
# 定义字典变量
my_dict = {key: value, key: value, key: value, key: value, ...}
# 定义空字典
my_dict = {}
my_dict = dict()

字典的特点

字典和集合一样，是没有索引的，只能通过key值去访问对应的value
字典的key值可以重复，重复后的key值对应的value会把旧的key对应的value进行一个覆盖

my_dict = {"bit": 20, "bit": 18, "cles": 456}
print(my_dict)
>>>
{'bit': 18, 'cles': 456}

注意：字典可以嵌套，但是key不能为字典

student_dict ={
    "小明": {
        "语文": 77,
        "数学": 66,
        "英语": 33,
        },
        "小红": {
            "语文": 88,
            "数学": 86,
            "英语": 55,
        },
        "小军": {
            "语文": 99,
            "数学": 96,
            "英语": 66,
        },
}
print(f"小明的数学成绩：{student_dict['小明']['数学']},分数类型是:{type(student_dict['小明']['数学'])}")
>>>
小明的数学成绩：66,分数类型是:<class 'int'>

字典的常用操作

新增元素和更新元素

# 语法 字典[key] = value 结果：字典被修改，如果key不存在于字典中，则视为新增

my_dict = {
    "xiaoming": 84,
    "xiaohong": 94,
    "xiaojun": 74,
}
my_dict['xiaoming'] = 99
my_dict['xiaogang'] = 69
print(my_dict)
>>>
{'xiaoming': 99, 'xiaohong': 94, 'xiaojun': 74, 'xiaogang': 69}

删除元素

# 字典.pop(key) 结果：key对应的元素被删除,并且返回key所对应的value
my_dict = {
    "xiaoming": 84,
    "xiaohong": 94,
    "xiaojun": 74,
}
score = my_dict.pop('xiaojun')
print(f"对应删除后的字典是{my_dict},删除元素对应的value是：{score}")
>>>
对应删除后的字典是{'xiaoming': 84, 'xiaohong': 94},删除元素对应的value是：74

清空元素

# 清空字典
my_dict = {
    "xiaoming": 84,
    "xiaohong": 94,
    "xiaojun": 74,
}
my_dict.clear()
print(my_dict)
>>>
{}

获取字典全部的key

# 获取字典全部的key
my_dict = {
    "xiaoming": 84,
    "xiaohong": 94,
    "xiaojun": 74,
}
keys = my_dict.keys()
print(f"获取到的全部的key是{keys},类型是{type(key)}")
>>>
获取到的全部的key是dict_keys(['xiaoming', 'xiaohong', 'xiaojun']),类型是<class 'dict_keys'>

字典的遍历

# 通过keys方法可以获取到字典的所有的key，通过key进行遍历
my_dict = {
    "xiaoming": 84,
    "xiaohong": 94,
    "xiaojun": 74,
}
keys = my_dict.keys()
print("字典的遍历")
for x in keys:
    print(f"key是：{x},对应的值是{my_dict[x]}")
>>>
key是：xiaoming,对应的值是84
key是：xiaohong,对应的值是94
key是：xiaojun,对应的值是74

# 第二种写法(比较常用)
for x in my_dict:
    print(f"key是：{x},对应的值是{my_dict[x]}")