Python列表、元组大总结

列表定义及特点

Python的列表是有序的，是包含0个或多个元素的有序序列，属于序列类型。列表可以进行修改。

由于列表属于序列类型，故继承了序列类型的所有属性和方法。

可以使用比较操作符（如 > 或 < 等）对列表进行比较。

列表用方括号 [] 表示，用逗号分隔其中的元素，也可以通过 list() 函数将元组或字符串转换为列表，直接使用 list() 函数会返回一个空列表。

print(list('av892%#@'))
>>>['a', 'v', '8', '9', '2', '%', '#', '@']

在列表中，值可以是任何数据类型，被称为元素或项。列表没有长度限制，因为元素类型可以不同，所以不需要预先定义列表长度。

Python可以通过元素在列表中所占的位置进行访问，即对列表中所有元素按序编号（称为索引），从而实现对列表的操作。列表的索引是从0开始的，以此类推。

操作列表

使用range()创建数字列表

要创建数字列表，使用函数list()将range()的结果直接转换为列表。

numbers=list(range(1,6))
print(numbers)

输出结果：

[1, 2, 3, 4, 5]

even_numbers=list(range(2,11,2)) #第三个参数指定步长
print(even_numbers)

输出结果：

[2, 4, 6, 8, 10]

列表解析***

列表解析将 for 循环和创建新元素的代码合并成一行，并自动附加新元素。只需要编写一行代码就能生成列表，非常简洁！！！

squares=[value**2 for value in range(1,11)]
print(squares)
>>>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

lis=[2.3, 3.4, 4.5, 5.6, 6.7]
print([int(x)**2 for x in lis])  #打印 lis 中所有数的平方
print([int(x)**2 for x in lis if int(x)%2==0])  #只打印 lis 转换为整数后其中所有偶数的平方
>>>[4, 9, 16, 25, 36]
[4, 16, 36]

lista = [i for i in range(7) if i%2 != 0]
listb = [2*i+1 for i in range(7) if i%2 != 0]
print(lista)
print(listb)
>>>[1, 3, 5]
[3, 7, 11]

列表解析还可运用于处理输入的字符串：

例：输入一行以空格分隔的年龄，打印这些年龄的总和以及平均年龄

ages = [eval(x) for x in input('请输入：').split()]
s = sum(ages)
m = s/len(ages)
print(f"{s} {m:.1f}")

输入内容以及输出结果：

请输入：22 23 24
69 23.0

列表切片及遍历切片

列表可以使用下标索引来访问列表中的元素，也可以使用类似于字符串切片运算的形式截取列表中的元素。

列表的第一个元素的索引为0，第二个元素的索引为1，根据这种简单的计数方式，可以通过形如 list [ index ] 来访问列表的任何一个元素。

创建切片，应使用切片运算符 list [ i : j ] 或者 list [ i : j : k ] ，前者返回列表中从索引 i （包括 i ）到索引 j （不包括 j ）之间的元素。后者在前者的基础上，要间隔 k 个元素，k 为正数表示从左往右截取，k 为负数表示从右往左截取。其中的 i 和 j 可以省略。

lis = [1,2,3,4,5,6,7,8,9,10]
lis[8:2:-2]
>>>[9, 7, 5]

lis[4:9:3]
>>>[5, 8]

lis[::-1]
>>>[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

lis[::1]
>>>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

通过 for 循环可以遍历列表的切片，如下：

players=['charles','martina','michael','florence','eli']
print('Here are the first three players on my team:')
for player in players[:3]:
    print(player.title())

输出结果：

Here are the first three players on my team:
Charles
Martina
Michael

修改、添加和删除元素

作用	代码	备注
在列表末尾添加元素	list.append(xx)	能保存到list中，同下
在列表中插入元素	list.insert(index，xx)	index指的是插入到的位置索引
使用del语句删除元素	del list[index]或者del(list[index])	index指要删除元素的索引，注意是方括号！！可以删除整个列表（del list）
使用pop()方法删除元素	list.pop()	pop可以理解为“弹出”，如下。默认弹出末尾元素。
根据值删除元素	list.remove(xx)	xx指要删除的值，注意如果xx出现多次，只删除第一个xx

• 方法pop()

如果需要将元素从列表中删除，并接着使用它的值，可以用pop()进行操作。
方法pop()默认删除末尾元素，并接着使用它，也可以指定要删除元素的索引。注意每次使用pop()时，被弹出的元素就不再在列表中！

motorcycles=['honda','yamaha','suzuki']
print(motorcycles)

popped_motorcycle=motorcycles.pop()
print(motorcycles)
print(popped_motorcycle)

first_owned=motorcycles.pop(0)
print(motorcycles)
print(first_owned)

输出结果：

[‘honda’, ‘yamaha’, ‘suzuki’]
[‘honda’, ‘yamaha’]
suzuki
[‘yamaha’]
honda

对列表排序、反转打印

作用	代码	备注
对列表永久排序	list.sort(reverse)	永久性修改 list 的排列顺序，无法恢复原来的顺序，默认为升序，参数 reverse=True 时为降序
对列表临时排序	sorted(list,reverse)	临时排序，并返回排序后的列表副本，不影响列表的原始顺序，默认为升序，参数 reverse=True 时为降序
反转列表元素	list.reverse()	也就是倒着打印列表，永久性修改列表原始排列顺序，但可以通过再次调用reverse()恢复

注：1. sort 方法和 sorted 函数可以使用参数 key = list2.index 使列表按照 list2 列表中的顺序排序。（列表去重那里有例子）
2.以上排序方式针对大多数情况，有些列表排序要复杂些。

cars=['bmw','audi','toyota','subaru']
cars.sort()
print(cars)

输出结果：

[‘audi’, ‘bmw’, ‘subaru’, ‘toyota’]

cars=['bmw','audi','toyota','subaru']
cars.sort(reverse=True)
print(cars)

输出结果：

[‘toyota’, ‘subaru’, ‘bmw’, ‘audi’]

cars=['bmw','audi','toyota','subaru']
print(sorted(cars))
print(cars)

输出结果：

[‘audi’, ‘bmw’, ‘subaru’, ‘toyota’]
[‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]

cars=['bmw','audi','toyota','subaru']
print(cars)
cars.reverse()  #第一次反转
print(cars)
cars.reverse()  #第二次反转
print(cars)

输出结果：

[‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
[‘subaru’, ‘toyota’, ‘audi’, ‘bmw’]
[‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]

list.sort()还有一种指定某位置排序的高级功能（使用lambda）：

names = '护士 旅游 老师 护士 老师 老师'
lis = names.split(' ')
d = {}
for i in lis:
    d[i] = d.get(i,0) + 1
content = list(d.items())
content.sort(key = lambda x:x[1] ,reverse = True)  #以元组的第二个元素进行排序
for i in content:
    print(f"{i[0]}:{i[1]}")

输出结果：

老师:3
护士:2
旅游:1

复制列表[:]

方法：创建一个包含整个列表的切片，同时省略起始索引和终止索引即[:]。注意不能直接将该列表名称赋值为另一个列表名称，否则不能得到两个列表！！

my_foods=['pizza','falafel']
friend_foods=my_foods[:]  #第一种（正确）
print('my favorite foods are:')
print(my_foods)
print("\nmy friend's favorite foods are:")
print(friend_foods)

print('\n#为核实确实有两个列表，为每个列表添加相应人员喜欢的食品:')
my_foods.append('cannoli')
friend_foods.append('ice cream')
print('my favorite foods are:')
print(my_foods)
print("\nmy friend's favorite foods are:")
print(friend_foods)

输出结果：

my favorite foods are:
[‘pizza’, ‘falafel’]

my friend’s favorite foods are:
[‘pizza’, ‘falafel’]

#为核实确实有两个列表，为每个列表添加相应人员喜欢的食品:
my favorite foods are:
[‘pizza’, ‘falafel’, ‘cannoli’]

my friend’s favorite foods are:
[‘pizza’, ‘falafel’, ‘ice cream’]

my_foods=['pizza','falafel']
friend_foods=my_foods  #第二种（此处不正确）
print('\n#如果使用friend_foods=my_foods，为每个列表添加相应人员喜欢的食品:')
my_foods.append('cannoli')
friend_foods.append('ice cream')
print('my favorite foods are:')
print(my_foods)
print("\nmy friend's favorite foods are:")
print(friend_foods)

输出结果：

#如果使用friend_foods=my_foods，为每个列表添加相应人员喜欢的食品:
my favorite foods are:
[‘pizza’, ‘falafel’, ‘cannoli’, ‘ice cream’]

my friend’s favorite foods are:
[‘pizza’, ‘falafel’, ‘cannoli’, ‘ice cream’]

这里的friend_foods=my_foods意思是将my_foods赋给friend_foods，而不是将my_foods的副本赋给friend_foods，这种语法实际上是让python将新变量friend_foods关联到已与my_foods相关联的列表，因此这两个变量指向同一个变量。

其他常用操作方法/内建函数

内建函数	含义
len(list)	返回列表元素的个数
max(list)	返回列表元素的最大值
min(list)	返回列表元素的最小值
sum(list)	返回数字列表元素的总和

方法	含义
list.count(a)	返回某个元素 a 在列表中出现的次数
list.extend(b)	在列表 list 末尾一次性追加另一个数据类型 b 中的所有元素，用于扩展列表，b 可以为列表、字符串、元组、集合、字典等。若 b 为集合，则追加的是所有键。
list.index(a)	返回列表中第一次出现的元素 a 的索引，如 a 不存在则报错。
list.clear()	用于清空列表
list.copy()	用于复制列表

a = [1,2]
b = [3,4]
a.extend(b)
a
>>>[1, 2, 3, 4]

c = (5,6)
a.extend(c)
a
>>>[1, 2, 3, 4, 5, 6]

d = '78'
a.extend(d)
a
>>>[1, 2, 3, 4, 5, 6, '7', '8']

e = {'i','j'}
a.extend(e)
a
>>>[1, 2, 3, 4, 5, 6, '7', '8', 'j', 'i']

f = {'g':1,'h':3}
a.extend(f)
a
>>>[1, 2, 3, 4, 5, 6, '7', '8', 'j', 'i', 'g', 'h']

列表元素检查

lis = [1,2,3,4,5]
print(1 in lis)
print(3 not in lis)
print(8 in lis)
print(9 not in lis)

>>>True
False
False
True

列表的更新

lis = ['a','b', 4, 5]
print(lis[2])

lis[2] = 'c'   # 对列表的数据项进行更新
print(lis)
print(lis[2])

>>> 4
['a', 'b', 'c', 5]
c

列表去重

第一种方法，使用集合转换函数set()实现列表去重（但是会改变原来的顺序）

lis = ['a', 'c', 'd', 5, 3, 'c', 5]
list(set(lis))
>>>[3, 5, 'c', 'a', 'd']

第二种方法，使用 sorted() 进行改进（不会改变原来的顺序）

lis = ['a', 'c', 'd', 5, 3, 'c', 5]
sorted(list(set(lis)), key = lis.index)
>>>['a', 'c', 'd', 5, 3]

列表大小比较

列表之间可以用比较运算符 > 、< 来进行比较！进行比较时首先会比较两个列表的第一个值，如果能进行判断则返回判断结果，如果不能则比较两个列表的第二个值，以此类推。

print([66,-5] > [66])   # true
print([66,0] > [66])    # true
print([1,2] > [5])     # false
print([5,8] > [1])    # true
print('-------')
print([44,8,9] > [99])   # false
print([1,4,6] > [1,9])  # false
print([1,2,3] > [1,2])  # true
print([1,2,0] > [8,2])  # false

输出结果：

True
True
False
True
-------
False
False
True
False

元组

元组定义及特点

元组与列表相似，不同之处在于元组的元素不能修改。

严格地说，元组是由逗号标识的，圆括号只是让元组看起来更整洁、更清晰。如果要定义一个只包含一个元素的元组，必须在这个元素后面加上逗号。如下所示:

n=(3)
print(type(n))
>>> <class 'int'>

n1=(3,)
print(type(n1))
>>> <class 'tuple'>

创建只包含一个元素的元组通常没有意义，但自动生成的元组有可能只有一个元素。

元组的创建语法非常简单：若用逗号分隔一些数据，系统会自动创建元组。也可以用圆括号进行标注。

连接、删除元组

元组的元素值是不允许修改的，但是可以对元组进行连接。

tuple1 = (1,2,3)
tuple2 = (4,5,6)
tuple1 + tuple2
>>>(1, 2, 3, 4, 5, 6)

元组的元素值是不允许删除的，但是可以使用 del 语句删除整个元组。

tuple1 = (1,2,3)
del tuple1
tuple1
>>>
NameError    Traceback (most recent call last)
<ipython-input-43-913694074add> in <module>
      1 tuple1 = (1,2,3)
      2 del tuple1
----> 3 tuple1

NameError: name 'tuple1' is not defined

将列表转换为元组

lis = ['a','b','c']
tuple(lis)
>>>('a', 'b', 'c')