python基本语法之数据容器（list列表、tuple元组）

数据容器根据特点的不同，如：

1. 是否支持重复元素
2. 是否可以修改
3. 是否有序

等等分为5类，分别是：
列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

序列

序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求

序列切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

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

注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]	# 下标1开始，下标4（不含）结束，步长1
print(new_list)		# 结果：[2, 3, 4]

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]	# 从头开始，到最后结束，步长1
print(new_tuple)		# 结果：(1, 2, 3, 4, 5)

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]		# 从头开始，到最后结束，步长2
print(new_list)		# 结果：[1, 3, 5]

my_str = "12345"
new_str = my_str[:4:2]	# 从头开始，到下标4（不含）结束，步长2
print(new_str)		# 结果："13"

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:1:-2] 	# 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）
print(new_tuple)		# 结果：(5, 3)

列表

列表定义

• 列表内的每一个数据，称之为元素
• 以 [] 作为标识
• 列表内每一个元素之间用, 逗号隔开

#共两种定义方式
list1 = [1, 2, 3, 4]
list2 = list([5, 6, 7])#注意[]不能掉

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

list3 = [[1, 2], [1, 3], [1, 4]]
list4 = [111, 'aaa', True]

列表特点

• 可以容纳多个元素（上限为2**63-1、9223372036854775807个）
• 可以容纳不同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等）

列表索引

正向索引

print(list1[0])

反向索引

嵌套索引

列表常用功能

• 查询元素下标
• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数

查找某元素的下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index(元素)，index就是列表对象（变量）内置的方法（函数）

print(list1.index(2))

列表修改

修改特定位置（索引）的元素值：
语法：列表[下标] = 值
可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

list1[1] = 0

插入元素

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

list1.insert(1, 0)#先下标后元素

• 追加元素append
  语法：列表.append(元素)，将指定元素，追加到列表的尾部

list1.append(4)

• 追加元素extend
  语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部，其他数据容器中数据不变

list1.extend(list2)

删除元素

• 删除元素del
  语法：del 列表[下标]

del list1[1]

• 删除元素pop
  语法：列表.pop(下标)

list1.pop(1)

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

list1.remove(2)

清空列表

语法：列表.clear()

list1.clear()

统计元素个数

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

print(list1.count(2))

• 统计列表内，有多少元素len
  语法：len(列表)，可以得到一个int数字，表示列表内的元素数量

print(len(list1))

键盘输入列表

eval()函数

文章参考python中的eval函数的使用详解

a = eval(input("请输入列表数据:"))

print(a)
print(type(a))

结果

但是eval()函数是一个比较危险的，容易引发安全漏洞的函数，建议在本地运行时使用

e.g.

split

split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

str.split(str="", num=string.count(str))

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
• num – 分割次数。默认为 -1, 即分隔所有
• 返回分割后的字符串列表

#输入分隔符为空格：21 36 52
a = input().split()
#输入分隔符为逗号：21,36,52
#a = input().split(',')
print(a)
print(type(a))

但是split函数转化出来的是字符串，可以使用map函数将字符串转化为数字

a = input().split()

b = list(map(int, a))

print(a)
print(b)

for循环

适用于一行一个输入以及嵌套列表

n = int(input())#列表元素个数
lists = [int(input()) for i in range(n)]
print(lists)

嵌套列表

n = int(input())#列表元素个数
lists = [list(map(int, input().split())) for i in range(n)]

print(lists)

总览

小练习

有一个列表，内容是：[21, 25, 21, 23, 22, 20]，记录的是一批学生的年龄

请通过列表的功能（方法），对其进行

1. 定义这个列表，并用变量接收它
2. 追加一个数字31，到列表的尾部
3. 追加一个新列表[29, 33, 30]，到列表的尾部
4. 取出第一个元素（应是：21）
5. 取出最后一个元素（应是：30）
6. 查找元素31，在列表中的下标位置

a = input("请输入年龄：").split()
age = list(map(int, a))

age.append(31)
add_list = [29, 33, 30]
age.extend(add_list)
print(age)

print(age[0])
print(age[-1])
print(age.index(31))

元组

元组一旦被定义，就不可修改

元组定义

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
元组同样有两种定义方式

a = (1, 2, 3)
b = tuple((1, 2, 3))#别忘记括号

元组同样可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

tuple3 = ((1, 2), (3, 4))
tuple4 = (1, 'hello', True)

注意：元组只有一个数据，这个数据后面要添加逗号

tuple5 = (1, )

元组特点

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（下标索引）
• 允许重复数据存在
• 不可以修改（增加或删除元素等）
• 支持for/while循环

元组常用功能

元组由于不可修改的特性，所以其操作方法非常少。

查找元素下标

功能：查找指定元素在元组的下标，如果找不到，报错ValueError
语法：元组.index(元素)，index就是元组对象（变量）内置的方法（函数）

print(tuple1.index(2))

统计元素个数

• 统计某元素在元组内的数量count
  语法：元组.count(元素)

print(tuple1.count(2))

• 统计元组内，有多少元素len
  语法：len(元组)，可以得到一个int数字，表示元组内的元素数量

print(len(tuple1))

注意事项

• 不可以修改元组的内容，否则会直接报错
• 可以修改元组内的list的内容（修改元素、增加、删除、反转等）

tuple6 = (1, ['Klas', 'apple'], 2)
tuple6[1][0] = 'banana'

print(tuple6)

• 不可以替换list为其它list或其它类型

tuple6 = (1, ['Klas', 'apple'], 2)
tuple6[1] = [1, 2]

print(tuple6)

键盘输入元组

利用列表转换

先创建列表接收输入信息，再转换成元组

lists = input().split() #创建列表接收输入信息
tup = tuple(map(int, lists)) #利用map和tuple函数转换成元组

print(tup)

嵌套亦同，但是需要先用列表接收被嵌套的元组，再将列表转化为元组

n = int(input())#列表元素个数
#先用列表接收被嵌套的元组
tup_arr = [tuple(map(int, input().split())) for i in range(n)]
#直接用圆括号做对比，看看如果不用列表转换的情况会怎么样
tup_eg = (tuple(map(int, input().split())) for j in range(n))
tup = tuple(tup_arr)

print(f"tup_arr: {tup_arr}")
print(f"tup_eg: {tup_eg}")
print(f"tup: {tup}")

利用字符串转换

先将输入保存为字符串，再利用split函数分割

user_input = input()
tup = tuple(item for item in user_input.split())

print(user_input)
print(tup)

函数总览