Python基础——数据类型—列表

Python基础——数据结构—列表

1、列表List，一种有序的集合，可以进行索引操作，第一个位置是0
2、列表里的元素时可以进行修改的，可执行添加删除操作
3、列表中的元素可以是不同数据类型
4、列表中的元素也可以是列表
5、列表是一种基本的数据类型，可以进行索引，切片，加，乘检查成员操作

列表的创建

列表的创建方式有两种：
方法一：直接创建，使用 [] 创建列表
列表中可以创建表达式

#创建一个空列表
lis = []
#直接创建一个列表
listName = ['kiki','Tom',1997]
print(listName)

输出：

方法二：用 list（）函数创建
利用list函数和tuple函数可以实现列表和元组之间的相互转换

#元组转列表
tup = (12,34,'rrr')
lis = list(tup)
print(lis)
#列表转元组
lis = [1,2,3,'tt']
tup = tuple(lis)
print(tup)

#创建一个字符串
string = 'kiki'
#通过list（）函数，创建列表
lis = list(string)
print(lis)

输出，将字符串中的元素进行拆分，组成成列表

列表的访问

索引访问

列表的索引同字符串操作

创建一个列表，获取列表中第三个位置的元素，并输出数据类型

#创建一个列表
lis = ['kiki','tom',1997]
#获取类表中的第3个元素
num = lis[2]
print(num)
#查看num的数据类型
print(type(num))
 

输出：

列表的切片（同字符串）

返回值是一个列表

list[头元素索引:尾元素索引+1[,步长]]

连续输出列表的前两个元素

num2 = lis[0:2]#切片列表前两个元素
print(num2)

输出：

enumerate() 函数函数访问

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

enumerate(sequence, [start=0])

sequence ：一个序列、迭代器或其他支持迭代对象。
start ：下标起始位置。默认从第一个到最后一个
返回 enumerate(枚举) 对象。
实例：

#enumerate(sequence, [start=0])方法的使用
#定义一个可迭代对象，这里取数列
lis = ['e','r','t','6']
#打印数列的索引和值
for i,item in enumerate(lis):
    print(i,item)
print('------------打印第一个到第三个元素的索引和值---------------')
#打印第一个到第三个元素的索引和值
for i,item in enumerate(lis[0:3]):
    print(i,item)

输出：

列表元素的添加和修改

• 方法一：默认添加，添加在列表的最后

#默认在列表最后添加Jack
lis.append('Jack')
print(lis)

• 方法二：在指定位置添加元素

#在第一个位置添加元素2021
lis.insert(0,2021)
print(lis)

输出：

修改列表中某个位置的元素值

#创建一个列表
lis = ['kiki','tom',1997]
#修改第一个元素为2021
lis[0] = 2021
print(lis)

输出：

列表的拼接和复制

列表的复制

复制列表lis，定义为lis2

• 方法一：用 list.copy(列表名) 函数复制，生成一个相同的列表

复制的是存储地址，随着元序列的改变而改变

lis2 = list.copy(lis)
print(lis2)

• 方法二：复制lis 多份，生成一个新列表

lis3 = lis*3
print(lis3)

输出：

列表的拼接

#定义两个列表
lis1 = ['kiki','tom',1997]
lis2 = [333,444,555]
print('拼接两个列表：',lis1+lis2)

删除列表元素

• 方法一：删除 指定位置 的元素，不传索引时，默认删除最后一个元素，返回值为移除的元素

#删除第一个元素
result = lis.pop(0)
print(lis)#打印删除元素后的列表
print('删除的元素值是：',result)#打印删除的元素值

• 方法二：删除 指定值 元素，没有返回值
• 如果列表中有多个相同值元素，则删除第一个

#删除指定元素1997
lis.remove(1997)
print(lis)

输出：

统计

统计列表中指定值元素的个数，返回值是int型数值

lis.count('kiki')#统计列表中 kiki的个数
print('列表中 kiki 有%d个'%lis.count('kiki'))

输出：

列表的翻转

得到一个逆向的新列表
对元列表进行的修改

list.reverse()方法

lis = ['kiki','tom',1997,3333,6666]
list.reverse(lis)#将列表翻转
print('修改后的列表',lis)

输出：

reversed（）函数

reversed(seq)方法和lis.reverse()方法不同在于：
seq – 要转换的序列，可以是 tuple, string, list 或 range。
但是 reversed（）函数返回的是一个不可见的迭代器地址，要用list（）转换才能打印出

reversed(seq)

实例：

# 字符串
seqString = 'Runoob'
print(list(reversed(seqString)))
 
# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
 
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
 
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))

输出：

列表元素的排序

list.sort(reverse = False)#不写默认正向排序
list.sort(reverse = True)#逆向排序

#创建一个列表
lis = [4,2,7,3,9,5,1,0]
#正向排序列表
lis.sort()#默认reverse = False
print('正向排序',lis)
#逆向排序
lis.sort(reverse=True)
print('逆向排序',lis)

输出：

查看元素是否在列表中

x in list# 返回值是bool型

列表函数

求列表长度

len(list)#返回列表中元素的个数

返回列表中元素的最大值，最小值

#返回列表中元素最小值
min(list)
#返回列表中元素最大值
max(list)

将元组转化成列表

list(tup)

列表方法

在列表末尾一次性追加另一个列表多个值

list.extend(seq)

#创建一个列表
lis = ['kiki','tom',1997]
#创建一个元组
tup = (2,4,'e','t')
#将元祖序列加入到列表里，组成新的列表
lis.extend(tup)
print(lis)

输出：

从列表中找出某个值第一个匹配项的索引位置

list.index(obj)

#创建一个列表
lis = ['kiki','tom',1997,'kiki']
#从列表中找出'kiki'第一个匹配项的索引位置
result = lis.index('kiki')
print(f'第一个匹配的元素在第 {result} 个位置')

输出：

清空列表

list.clear()
del list[:]

del

删除一个元素

#定义一个列表
a = [1,2,3,4,5]
del a[0]#按照索引删除索引为0的元素
print(a)

删除切片

#定义一个列表
a = [1,2,3,4,5]
del a[0:3]#按照索引删除索引为0~3的元素
print(a)

嵌套列表解析

把4x3的矩阵转换成3x4的列表

matrix = [
	[1, 2, 3, 4],
	[5, 6, 7, 8],
	[9, 10, 11, 12]
	]
#实际上就是一个4X3的列表
#用for循环
#定义一个空列表，用于存储转换后的列表元素
lis = []
#将他转化成一个四行三列的列表
for i in range(4):#控制取第几个元素
    #创建一个新列表用于存放内层列表元素
    lis2 = []
    for item in matrix:#取matrix一个列表元素
        #取item的第i个元素，加入列表
        lis2.append(item[i])
    #将内层列表添加到外层列表内
    lis.append(lis2)
print(lis)


#用列表推导式：
lis3 = [[item[i] for item in matrix] for i in range(len(matrix)+1)]
print('利用列表推导式转换的：',lis3)

输出：