Python基础之数据类型（二）本篇文章会讲解Python中的列表（list）、元组（tuple）以及它们常见的方法。后

Python中常见的数据类型有：

int 整形

bool 布尔类型

str 字符串

float 浮点型

list 列表

dict 字典

set 集合

tuple 元组

本篇文章会讲解列表（list）、元组（tuple）以及它们常见的方法。

1. 列表

关于列表的概念大家都不陌生，Python里的列表就相当于C语言中的数组。是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

1.1 定义

number_list = [98,88,666,12,-1]
data_list = [1,True,"abc","宝强"] # 列表中可以存放多个不同类型的元素

1.2 独有功能

列表在Python中的使用频率非常高，所以在Python中有许多列表独有方法。因为篇幅原因这里只会介绍常用的方法，更多的大家可以参见Python官方文档

1. 追加，在原列表中尾部追加值。(append方法)

data_list = []
data_list.append("abc")
print(data_list) # ["abc"]

2. 批量追加。（extend方法）

tools = ["搬砖","菜刀","榔头"]
tools.extend( [11,22,33] ) # weapon中的值逐一追加到tools中
print(tools) # ["搬砖","菜刀","榔头",11,22,33]

# 注意：此处extend方法的参数不一定为一个列表，只要是一个可迭代对象都可以达到上述效果。
tools = ["搬砖","菜刀","榔头"]
tools.extend( (11,22,33) ) # (11,22,33)为一个元组
print(tools) # ["搬砖","菜刀","榔头",11,22,33]

3. 插入，在原列表的指定索引位置插入值。（insert方法）

user_list = ["a","b"]
user_list.insert(0,"c")
print(user_list) # ["c","a","b"]

4. 在原列表中根据值删除. (remove方法)

user_list = ["a","b","c","d"]
user_list.remove("a")
print(user_list) # ["b","c","d"]
# 注意：remove删除是按从左到右找到第一个删除，且里面没有会报错，所以要谨慎使用！

5. 在原列表中根据索引踢出某个元素 (pop方法)

user_list = ["a","b","c","d","e"]
#             0   1   2   3   4
user_list.pop(1)
print(user_list) #  ["a","c","d","e"]

# 不加参数默认删除最后一个
user_list.pop()
print(user_list) # ["a","c","d"]

6. 清空原列表 (clear方法)

user_list = ["a","b","c"]
user_list.clear()
print(user_list) # []

7. 根据值获取索引 (index方法)

user_list = ["a","b","c","d","e"]
#             0   1   2   3   4
index = user_list.index("a")
print(index) #  0
# 注意：index方法是是按从左到右找到第一个元素，且里面没有会报错，所以要谨慎使用！

8. 列表元素排序 (sort方法)

# 数字排序
num_list = [11, 22, 4, 5, 11, 99, 88]
num_list.sort()  # 让num_list从小到大排序
num_list.sort(reverse=True)  # # 让num_list从大到小排序

# 对于字符串，程序会先将字符串拆解并按照某个编码表转换成数字，再进行比较

# 注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）。

9. 反转原列表 (reverse方法)

user_list = [11,22,33]
user_list.reverse()

print(user_list) # [33,22,11]

1.3 公共功能

1. 相加，两个列表相加获取生成一个新的列表。

data = ["赵四","刘能"] + ["宋晓峰","范德彪"]
print(data) # ["赵四","刘能","宋晓峰","范德彪"]

v1 = ["赵四","刘能"]
v2 = ["宋晓峰","范德彪"]
v3 = v1 + v2
print(v3) # ["赵四","刘能","宋晓峰","范德彪"]

2. 相乘，列表*整型将列表中的元素再创建N份并生成一个新的列表。

data = ["赵四","刘能"] * 2
print(data) # ["赵四","刘能","赵四","刘能"]

v1 = ["赵四","刘能"]
v2 = v1 * 2
print(v1) # ["赵四","刘能"]
print(v2) # ["赵四","刘能","赵四","刘能"]

3. 由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。

user_list = ["狗子","二蛋","沙雕","你"] 
result = "你" in user_list
# result = "你" not in user_list
print(result) #  True

# 列表检查元素是否存在时，是采用逐一比较的方式，效率会比较低。

# 案例：敏感词替换
text = input("请输入文本内容：") 
forbidden_list = ["草"]
for item in forbidden_list:
    text = text.replace(item,"**")
print(text)

4. 获取长度

user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( len(user_list) ) # 3

5. 索引，一个元素的操作

# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0] )
print( user_list[2] )
print( user_list[3] ) # 报错

# 改
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
user_list[0] = "武沛齐"
print(user_list) # ["武沛齐","刘华强",'尼古拉斯赵四']

# 删
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
del user_list[1]

user_list.remove("刘华强")
ele = user_list.pop(1)
#  注意：超出索引范围会报错。

6. 切片，多个元素的操作（很少用）

# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']

print( user_list[0:2] ) # ["范德彪","刘华强"]
print( user_list[1:] )
print( user_list[:-1] )

# 改
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[0:2] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[2:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', 11, 22, 33, 44]

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[3:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]


user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[10000:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]


user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '刘华强', '尼古拉斯赵四']

# 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']

7. 步长

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
#              0        1        2          3       4
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )

# 案例：实现列表的翻转
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
new_data = user_list[::-1]
print(new_data) # ["刘能","宋小宝",'尼古拉斯赵四',"刘华强","范德彪"]


data_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data_list.reverse()
print(data_list) # ["刘能","宋小宝",'尼古拉斯赵四',"刘华强","范德彪"]

8. for循环

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
print(item)

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]

for index in range( len(user_list) ):
    item = user_index[index]
    print(item)

1.4 转换

int、bool无法转换成列表

str

name = "武沛齐"

data = list(name)  # ["武","沛","齐"]
print(data)

tuplp、set

v1 = (11,22,33,44) # 元组
vv1 = list(v1)     # 列表 [11,22,33,44]

v2 = {"abc","eric","dsb"} # 集合
vv2 = list(v2) # 列表 ["acb","eric","dsb"]

1.5. 其他

1. 嵌套

列表属于容器，内部可以存放各种数据，所以他也支持列表的嵌套，如：
data = [ "谢广坤",["海燕","赵本山"],True,[11,22,[999,123],33,44],"宋小宝" ]
对于嵌套的值，可以根据之前学习的索引知识点来进行学习，例如：
data = [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝" ]

print( data[0] ) # "谢广坤"
print( data[1] ) # ["海燕","赵本山"]
print( data[0][2] ) # "坤"
print( data[1][-1] ) # "赵本山"

2.元组

元组（tuple），是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。

如何体现不可变呢？记住一句话：《"我儿子永远不能换成是别人，但我儿子可以长大"》

2.1 定义

d1 = (1)  # 1
d2 = (1,) # (1,)
d3 = (1,2)
# 注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。

2.2 独有功能

无

2.3 公共功能

1. 相加，两个列表相加获取生成一个新的元组。

data = ("赵四","刘能") + ("宋晓峰","范德彪")
print(data) # ("赵四","刘能","宋晓峰","范德彪")

v1 = ("赵四","刘能")
v2 = ("宋晓峰","范德彪")
v3 = v1 + v2
print(v3) # ("赵四","刘能","宋晓峰","范德彪")

2. 相乘，列表*整型将列表中的元素再创建N份并生成一个新的元组。

data = ("赵四","刘能") * 2
print(data) # ("赵四","刘能","赵四","刘能")

v1 = ("赵四","刘能")
v2 = v1 * 2
print(v1) # ("赵四","刘能")
print(v2) # ("赵四","刘能","赵四","刘能")

3. 获取长度

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( len(user_list) ) # 3

4. 索引

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0] ) # "范德彪"
print( user_list[2] ) # "刘华强"
print( user_list[3] ) # "尼古拉斯赵四"

5. 切片

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0:2] ) # ("范德彪","刘华强")
print( user_list[1:] )  # ("刘华强",'尼古拉斯赵四')
print( user_list[:-1] ) #  ("范德彪","刘华强")

6. 步长

user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
print( user_list[1:4:2] ) # ("刘华强","宋小宝")
print( user_list[0::2] )  # ("范德彪",'尼古拉斯赵四',"刘能")
print( user_list[1::2] )  # ("刘华强","宋小宝")
print( user_list[4:1:-1]) # ("刘能","宋小宝",'尼古拉斯赵四')

7. for循环

user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:
	print(item)

2.4 转换

其他类型转换为元组，使用tuple(其他类型)，目前只有字符串和列表可以转换为元组。

data = tuple(其他)

# str / list

name = "你好呀"
data = tuple(name)
print(data) # 输出 ("你","好","呀")

name = ["吴",18,"python"]
data = tuple(name)
print(data) # 输出 ("吴",18,"python")

2.5 其他

1. 嵌套

由于元组和列表都可以充当容器，他们内部可以放很多元素，并且也支持元素内的各种嵌套。
tu = ( 'a', 'b', ('c','d') )
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
tu5 = tu[2][1][3]

print(tu1) # a
print(tu2) # b
print(tu3) # c
print(tu4) # d
print(tu5) # 抛出（IndexError）错误

原文作者：小吴同学
原文链接： Python基础之数据类型（二）
欢迎转载，文章有错误请联系我修改，感谢！