09Python基础-列表List

什么是列表？

列表（list）是由元素组成的有序集合，是 Python 中最基本的数据结构。

创建列表

#创建一个空列表
empty_list = []

#创建一个非空列表
#通常列表会包含一个或多个元素。为了区分多个元素，我们需要使用逗号
my_list = ['Python List','CSDN']

#列表中元素的类型不要求一致，例如
my_list1 = [1,'2',[1,2]]

#内置函数list()创建列表
a = list(0,1,2,3)
print(a) # [1,2,3]

b = list(range(4))
print(b) #[0,1,2,3]

使用列表(查改增删)

访问列表(查列表)

打印整个列表

my_list = [1,2,3]
print(my_list) #输出[1,2,3],输出结果会包含方括号

判断列表中是否包含某个元素

• in

a = [10,20,30,40,50,60]
if 10 in a:
    print("10存在于列表a中")
else:
    print("列表a中不存在元素10")

访问列表某个元素

列表是一个有序集合，因此我们可以通过下标访问它的元素。列表的第一个元素下标为 0，第二个元素的下标为 1，依此类推。
例如打印列表中的第一个元素(即下标为0的元素)

my_list = [1,2,3]
print(my_list[0]) # 1

正数下标从0开始，表示元素从左到有依次增长。列表也有负数下标，负数下标可以从列表的右侧开始返回元素。list[-1] 返回最后一个元素，list[-2] 返回倒数第二个元素，依此类推。例如：

numbers = [1, 3, 2, 7, 9, 4]
print(numbers[-1]) # 4
print(numbers[-2]) # 9

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符。下标规则是左闭右开。

访问列表几个元素（列表切片）

#1.下标均为正数截取列表
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4]) # [10, 20, 30, 40]

#2.下标均为负数截取列表
print(nums[-3:-1])#[70,80]

#3.下标为一正一负截取列表
print(nums[3:-1])#[40, 50, 60, 70, 80]

#当下标都是正数且左大右小时
print(nums[3:1])#[] 此时取出的是空列表，相当于找出大于等于3同事小于1的数一样，不存在则返回空列表

#当下标都是负数且左大右小时
print(nums[-1:-3])#[] 此时取出的也是空列表，与正数一样

#默认
#1.开始结束都默认
print(nums[:]) #[10, 20, 30, 40, 50, 60, 70, 80, 90]

#2.默认开始，从0开始
print(nums[:2]) #[10, 20]

#3.默认结束，到最后一个元素
print(nums[2:]) #[30, 40, 50, 60, 70, 80, 90]

#4.默认步长为1
#4.1
print(nums[1:5]) #[10,20,30,40]

#4.2
print(nums[1:5:]) #[10,20,30,40]

总结下切片：无非就是正数从左往右从0开始数，负数从右往左从-1开始数。正负数在切片的左右没有所谓。只要最终切片左边的下标数出来在切片右边的下标数出来的数的左边（包含相同）就能切出来有元素的列表。

总结举例：可以看到下面的代码，只要tmp_list[a] 在 tmp_list[b]左边或者相同即可切出有元素的列表。只要记得a,b的正负数，正数是从0开始从左往右，负数是从-1开始从右往左，且切边的区间是左开右闭[a,b)。

#有列表tmp_list 
tmp_list = [0,1,2,3,4,5,6,7,8,9]
#此时切片
print(tmp_list[a:b]) # a,b为下标不论正负数

另外切片不会出现下标溢出的问题，不会报错。如果切片中的下标超出了列表元素的个数，则且到个数的最大值，例如：

my_list = [1,2,3,4,5]
print(my_list[0:100])# [1,2,3,4,5]
print(my_list[-100:5])# [1,2,3,4,5] 
print(my_list[-100:100])# [1,2,3,4,5] 

同事切片也是可以设置有步长切列表，例如：

#将列表a中的奇数下标对应的元素全部取出，返回一个新列表并打印
a = [1,2,3,4,5,6,7,8,9]
print(a[1,10,2]) #[2, 4, 6, 8]
# 奇数下表即a[1],a[3],a[5],a[7],a[9]
#上述的切片可以理解为，从下标为1开始，按照每两个元素(步长)一切，切到下表9。

修改列表(改列表)

列表中的元素是可变的。为了修改列表元素，我们可以使用以下语法为其指定一个新的数据

list[index] = new_value

修改某个元素

例如，修改列表的某个元素值

a = [1,2,3,4,5]

#修改a列表的第一个元素值为-1
a[0] = -1
print(a) #[-1,2,3,4,5]

修改多个元素

列表循环修改

循环列表中的每个元素，乘以2后再赋值给对应下标的原元素即可，例如

#将列表中的每个元素乘2
for i in range(len(a)):
    a[i] = a[i] * 2
print(a) #[2, 4, 6, 8, 10]

列表推导式

# 列表推导式格式：
[表达式 for 变量 in 旧列表] 
#或者
[表达式 for 变量 in 旧列表 if 条件 ]

#修改上述列表a，每个元素乘以2
a = [i * 2 for i in a]
print(a) # [2, 4, 6, 8, 10]

#修改列表a中元素，小于3的乘以2
a = [i * 2 for i in a if i < 3]
print(a) # [2,4]    if i < 3后剩下两个元素[1,2]，乘以2，所以是[2,4]

添加列表元素(增列表)

append() 方法

该方法用于追加元素到列表的最后面，例如：

a = [1,2,3,4]
a.append(5)
print(a) # [1,2,3,4,5]

insert()方法

该方法用于在指定下标前插入元素，例如：

a = [1,2,3,4,5]
a.insert(2,10)
print(a) # [1,2,10,3,4,5]
#上述可以理解为，在下标2前面插入元素10

#当然下标越界也无妨，例如
a.insert(100,9)
print(a) #[1,2,10,3,4,5,9]
#上述可以理解为，在下标为100,没有100即最后插入元素9

#同理
a.insert(-1,8)
print(a) #[1,2,10,3,4,5,8,9]

a.insert(-100,7)
print(a) #[7,1,2,10,3,4,5,8,9]

列表运算增加元素

列表可以进行加 和 乘的"运算"，类似字符串

加运算

列表加上列表，生成新的列表，包含参与加法的所有列表的所有元素，例如：

a = [1,2]
b = [3,4]
c = [1,4]
d = a + b + c
print(d) #[1,2,3,4,1,4]

乘运算

列表乘上某个数值n，生成新的列表，相当于原列表元素个数翻n倍，例如：

a = [1,2,3]
a = a * 2
print(a) # [1,2,3,1,2,3]

删除列表元素(删列表)

del语句

del 语句可以用于删除列表中指定位置的元素，但是如果删除的下标不存在，则报错。例如：

a = [1,2,3]
del a[0]
print(a) # [2,3]

del a[5]
print(a) # IndexError: list assignment index out of range
# 在del a[5]处报错，列表a没有下标是5的元素

pop()方法

pop()删除最后元素

列表的 pop() 方法可以删除最后一个元素并返回该元素，如果我们想要删除列表中的某个元素，同时又想访问该元素的值，可以使用 pop() 方法。例如：

a = [1,2,3,4]
num = a.pop()
print(num) # 4
print(a) # [1,2,3]

pop(n)删除指定元素

pop() 方法可以通过下标删除指定的元素，且返回该元素，如果指定的下标不存在，则报错。例如：

a = [1,2,3]
a.pop(0) # 1
print(a) # [2,3]

a.pop(10)
print(a) # IndexError: pop index out of range
# a.pop(10)处报错，列表a不存在下标为10的元素

remove()方法

如果想要通过数据删除元素，不返回删除的元素，可以使用 remove() 方法，如果想要删除的数据不存在于列表中，则报错。例如：

a = [1,2,3,4]
a.remove(1)
print(a) # [2, 3, 4]
a.remove(10) #list.remove(x): x not in list
# a.remove(10)处报错，列表a中不存在元素10

列表嵌套

上面说列表的元素没有类型的规定，不要求元素是一样的类型。所以列表中的元素也可以是列表，即列表嵌套。
例如：

a = [[1,2],[3,4],[5,6]]
print(a) #[[1,2],[3,4],[5,6]]

#访问a列表元素与上述一致
print(a[0]) # [1,2] 返回的是列表[1,2]

## 访问元素是列表里的元素
print(a[0][0]) # 1  类似java中的二维数组

## 增删改查操作与上述讲述一致

列表函数&方法

函数

len(list)

列表元素个数：

list1 = ['Google', 'CSDN', 'Taobao']
print (len(list1)) # 3
list2=list(range(5)) # 创建一个 0-4 的列表
print (len(list2)) # 5

max(list)

返回列表元素最大值

list1, list2 = ['Google', 'CSDN', 'Taobao'], [456, 700, 200]

print ("list1 最大元素值 : ", max(list1))
print ("list2 最大元素值 : ", max(list2))

# list1 最大元素值 :  Taobao
# list2 最大元素值 :  700

min(list)

返回列表元素最小值

list1, list2 = ['Google', 'CSDN', 'Taobao'], [456, 700, 200]

print ("list1 最小元素值 : ", min(list1))
print ("list2 最小元素值 : ", min(list2))

# list1 最小元素值 :  Google
# list2 最小元素值 :  200

list(seq)

将元组转换为列表，后面会详细介绍元组。

aTuple = (123, 'Google', 'CSDN', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)

str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)

# 列表元素 :  [123, 'Google', 'CSDN', 'Taobao']
# 列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

方法

list.append(obj)

上述说的在列表末尾添加新的元素，不再赘述

list.count(obj)

统计某个元素在列表中出现的次数

aList = [123, 'Google', 'CSDN', 'Taobao', 123];

print ("123 元素个数 : ", aList.count(123))
print ("CSDN元素个数 : ", aList.count('CSDN'))

# 123 元素个数 :  2
# CSDN元素个数 :  1

list.extend(seq)

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

• seq:元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾

list1 = ['Google', 'CSDN', 'Taobao']
list2=list(range(5)) # 创建 0-4 的列表
list1.extend(list2)  # 扩展列表
print ("扩展后的列表：", list1)

# 扩展后的列表： ['Google', 'CSDN', 'Taobao', 0, 1, 2, 3, 4]

list.index(obj)

从列表中找出某个值第一个匹配项的索引位置,未找到对象则报错

语法：list.index(x[, start[, end]])

• x-- 查找的对象。
• start-- 可选，查找的起始位置。
• end-- 可选，查找的结束位置。

list1 = ['Google', 'CSDN', 'Taobao']
print ('CSDN 索引值为', list1.index('CSDN'))
print ('Taobao 索引值为', list1.index('Taobao'))

# CSDN 索引值为 1
# Taobao 索引值为 2

list.insert(index, obj)

上述说的将对象插入列表，不再赘述

list.pop([index=-1])

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值，上述已详细说明，不再赘述

list.remove(obj)

移除列表中某个值的第一个匹配项，上述已详细说明，不再赘述

list.reverse()

反向列表中元素

list1 = ['Google', 'CSDN', 'Taobao', 'Baidu']
list1.reverse()
print ("列表反转后: ", list1)

# 列表反转后:  ['Baidu', 'Taobao', 'CSDN', 'Google']

list.sort( key=None, reverse=False)

sort() 用于对原列表进行排序，如果指定参数，则使用比较函数指定规则的比较函数。该方法没有返回值，但是会对列表的对象进行排序

语法：
list.sort( key=None, reverse=False)

• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

aList = ['Google', 'CSDN', 'Taobao', 'Facebook']
aList.sort()
print ( "List : ", aList)

#List :  ['CSDN', 'Facebook', 'Google', 'Taobao']


# 降序排序
# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
# 降序
vowels.sort(reverse=True)
print ( '降序输出:', vowels )

# 降序输出: ['u', 'o', 'i', 'e', 'a']

# 如果列表中是由元组或字典或对象元素组成的，则可以指定远组/字典/对象的某个值/属性来排序。这里用元组举例:

# 定义按照元祖中的第几个值排序  这里是第二个值，下标是1
def takeSecond(elem):
    return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
# 输出类别
print('排序列表：', random)
# 排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]

list.clear()

清空列表

list1 = ['Google', 'CSDN', 'Taobao', 'Baidu']
list1.clear()
print ("列表清空后 : ", list1)

#列表清空后 :  []

list.copy()

copy() 函数用于复制列表，类似于 a[:]

list1 = ['Google', 'CSDN', 'Taobao', 'Baidu']
list2 = list1.copy()
list3 = list1[:]
print ("list1 列表: ", list1)
print ("list2 列表: ", list2)

# list1 列表:  ['Google', 'CSDN', 'Taobao', 'Baidu']
# list2 列表:  ['Google', 'CSDN', 'Taobao', 'Baidu']