【Python】基础·学习笔记5——数据容器(未完待续...)-CSDN博客

本文链接：https://blog.csdn.net/ansys177/article/details/140251243

一、数据容器

定义：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素可以是任意类型的数据（字符串、数字、布尔等等）

分类：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

二、列表 [list]

1. 列表定义、创建和删除

# 字面量

[元素1，元素2，元素3，.....]

# 定义变量

变量名 = [元素1，元素2，元素3，.....]

# 定义空列表

变量名 = []

或者

变量名 = list()

# 创建数值列表

使用list()函数直接将range()函数循环出来的结果转换为列表。

list(data)

# 删除列表

对于不再使用的列表，可以使用del语句删除。

del 变量名

2. 列表的嵌套

# 数据容器：列表 list

# 定义一个列表
my_info = ["行走的赵哈哈", 18 , True]
print(my_info)
print(type(my_info))

# 列表的嵌套
my_info_add = [["行走的","赵哈哈"], [18 , True]]
print(my_info_add)
print(type(my_info_add))

""" 输出内容：
['行走的赵哈哈', 18, True]
<class 'list'>
[['行走的', '赵哈哈'], [18, True]]
<class 'list'>
"""

可以看出，列表中的元素可以是字符串、也可以是数字、也可以是布尔。

3. 列表的下标索引（通过下标索引取值）

3.1 正序

注意从 0 开始

# 列表的下标索引
# 正序
my_info = ["行走的赵哈哈", 18 , True]
print(my_info[0])
print(my_info[1])
print(my_info[2])

3.2 倒序

# 列表的下标索引
# 倒序
my_info = ["行走的赵哈哈", 18 , True]
print(my_info[-3])
print(my_info[-2])
print(my_info[-1])

3.3 嵌套列表的下标索引

使用格式：[ 外层 ] [ 内层 ]

# 列表的嵌套
my_info_add = [["行走的","赵哈哈"], [18 , True]]
print(my_info_add[0][1])

注意：下标索引取值范围若超出实际范围，则无法取出元素，并且会报错。

4. 列表的常用功能（增减改查）

函数：装代码的单元，提供特定功能

方法：将函数定义为类（class），那么函数就会称为方法

# 函数

def add(x,y)

return x + y

# 方法

class Student：

def add(self ，x , y)：

return x + y

函数的使用： num = add (1, 2 )

方法的使用：student = Student（）

num = student . add （1，2）

4.1 列表中元素的查询功能

语法：列表.index(元素) 获取指定元素首次出现的下标

4.2 列表中元素的修改功能

语法：列表 [ 下标 ] = 值

4.3 列表中元素的插入/追加功能

【插入】语法：列表 .insert(下标，元素) 在指定的下标位置插入指定的元素

【追加】【元素】语法：列表 .append(元素) 在列表最后插入一个元素

【追加】【列表】语法：列表 .extend(其它数据容器) 在列表最后插入一个数据容器

4.4 列表中元素的删除/清空功能

【按下标删除】

语法1 ：del列表[下标] 仅删除

语法2 ：列表.pop(下标) 不仅能删除，而且能将删除的元素作为返回值得到

【按元素删除】

语法3：列表.remove(元素) 删除某元素在列表中的第一个匹配项

【清空】语法4：列表.clear() 清空列表内容

4.5 统计元素在列表内的数量

语法1：列表.count(元素) 统计某个元素在列表内的数量

语法2：len.() 统计列表中全部的元素数量

4.6 总结（记查表）

列表.index(元素)	查询指定元素在列表中首次出现的下标查不到报错ValueError
列表[下标]	查询指定下标位置处的元素
列表[下标] = 值	修改指定下标位置处的元素 == 值
列表.insert(下标，元素)	在指定下标位置处插入指定元素
列表.append(元素)	在列表末尾追加指定元素
列表.extend(数据容器)	在列表末尾追加指定数据容器
del列表[下标]	删除指定下标处的元素
列表.pop(下标)	删除指定下标处的元素（返回值输出）
列表.remove(元素)	删除列表中指定元素（1个），注意是第一个
列表.clear()	清空列表
列表.count(元素)	统计指定元素在列表中的个数
len(列表)	统计列表中所有元素的总个数

# 定义列表，并用变量接收
list = [21,25,21,23,22,20]
print(f"{list}")

# 追加一个数字31，到列表尾部
list.append(31)
print(f"{list}")

# 追加一个新列表[29,33,30],到列表尾部
list.extend([29,33,30])
print(f"{list}")

# 删除第2个元素
del list [1]
print(f"{list}")

# 删除第2个元素
list.pop(1)
print(f"{list}")

# 删除列表中第一个30
# list = [21, 25, 21, 23, 22, 20, 31, 29, 33, 30]
list.remove(21)
print(f"{list}")

# 修改第二个元素为99
list[1]=31
print(f"{list}")

# 列表中31的个数
num_31 = list.count(31)
print(f"{num_31}")

# 列表中元素总个数
num_all = len(list)
print(f"{num_all }")

# 取出第一个元素，应该是21
num_1 = list[0]
print(f"{num_1}")

# 取出最后一个元素，应该是30
num_last = list[-1]
print(f"{num_last}")

# 查找元素31，在列表中的下标位置
a = list.index(31)
print(f"{a}")

5. 列表的遍历

什么是遍历？将数据容器内的元素依次取出进行处理的行为。

5.1 while循环遍历

while循环遍历代码格式：

index = 0 # 定义一个变量，用来记录列表的下标
while index < len(列表):
元素 = 列表 [index] # 通过index变量提取对应下标的元素
对元素进行处理例：print(f"列表元素为{element}")
index += 1

注意事项：Index != index i 要小写

# def定义函数
def list_while():
    # 定义列表
    list = ["哈哈哈","python",666]
    # 列表元素 给个初始值
    index = 0
    while index <len(list):
        element = list[index]
        print(f"列表元素为{element}")
        index += 1     # 终止条件

# 调用函数
list_while()

5.2 for循环遍历

for循环遍历代码格式：

for 临时变量 in 数据容器：

对临时变量进行处理例：print(f"列表元素为{element}")

def list_for():
    list= ["哈哈哈","python",666]
    for element in list:
        print(f"列表元素为{element}")
list_for()

6. 列表的特点/注意事项

注意事项：

可容纳多个数据
可容纳不同类型的数据
数据是有序存储的（下标索引）
允许有重复的数据存在
可以修改元素（增减改）
支持for循环遍历

三、元组(tuple)

1. 元组的定义

1.1 定义元组

# 定义元组
t1 = (1 , " hello ", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是:{t1}")
print(f"t2的类型是：{type(t2)},内容是:{t2}")
print(f"t3的类型是：{type(t3)},内容是:{t3}")

1.2 定义单个元素的元组

注意事项：单个元素后边加一个逗号(,)，否则是字符串

# 定义单个元素的元组
t4 = ("hello",)
print(f"t4的类型是：{type(t4)},内容是:{t4}")

2. 元组的嵌套

# 元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)},内容是:{t5}")

3. 元组的下标索引（通过下标索引取值）

# 取出t5元组的5
t5 = ((1,2,3),(4,5,6))
num = t5[1][1]
print(f"从元组t5中取出的内容是:{num}")

4. 元组的常用功能

4.1 index 根据元素查询下标

# 元组的功能:index查询下标
t6 = ( " 哈哈哈 ", "python",666)
index_1 = t6.index(666)
print(f"从元组t6中查询666,其下标是:{index_1}")

4.2 count 统计

# 元组的功能:count统计
t7 = ( 666 , " hello ", True," 哈哈哈 ", "python",666)
count_2 = t7.count(666)
print(f"从元组t7中查询666,其数量是:{count_2}")

4.3 len()统计

# 元组的功能:len()统计总数
t8 = ( 666 , " hello ", True," 哈哈哈 ", "python",666)
len_3 = len(t8)
print(f"从元组t8中元素的总数是:{len_3}")

4.4 while遍历

# 元组的遍历while
index_xiabiao = 0
while index_xiabiao < len(t8):
    print(f"元组t8中的元素有:{t8[index_xiabiao]}")
    index_xiabiao += 1

4.5 for遍历

# 元组的遍历 for
for index_for in t8:
    print(f"元组t8中的元素有:{index_for}")

5. 元组的特点/注意事项

注意事项：

可容纳多个数据
可容纳不同类型的数据
数据是有序存储的（下标索引）
允许有重复的数据存在
不可以修改元素
支持for循环遍历