1 python基本语法 - List

列表（list）是一个有序且可更改的序列，允许重复。列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，同一个列表中元素的类型也可以不同，格式为：[element1 , element2 , element3 , ... , elementn]，其中，listname 表示变量名，element1 ~ elementn 表示列表元素。

1 使用 [] 创建列表

使用 [] 创建列表后，一般使用 = 将它赋值给某个变量，语法格式为：listname = [element1 , element2 , element3 , ... , elementn]，其中，listname 表示变量名，element1 ~ elementn 表示列表元素。

list = ['zhaoshuai', 25, True, 137.9, ['读书', '旅行'], (1, 2, 3, 4)]
print(list)
? ['zhaoshuai', 25, True, 137.9, ['读书', '旅行'], (1, 2, 3, 4)] <class 'list'>

2 用 list 函数创建列表

除了使用 [] 创建列表外，Python 还提供了内置的 list 函数，可以将其它数据类型转换为列表类型。

2.1 将字符串转换成列表

list1 = list('zhaoshuai-lc')
print(type(list1))
# ? <class 'list'>
print(list1)
# ? ['z', 'h', 'a', 'o', 's', 'h', 'u', 'a', 'i', '-', 'l', 'c']

2.2 将元组转换成列表

tuple1 = ('1', '2', '3', '4')
print(type(tuple1))
# ==> <class 'tuple'>
print(tuple1)
# ==> ('1', '2', '3', '4')

list1 = list(tuple1)
print(type(list1))
# ==> <class 'list'>
print(list1)
# ==> ['1', '2', '3', '4']

2.3 将字典转换成列表

dict1 = {'name': 'zhaoshuai-lc', 'age': 23, 'gender': 'male'}
print(type(dict1))
# ==> <class 'dict'>
print(dict1)
# ==> {'name': 'zhaoshuai-lc', 'age': 23, 'gender': 'male'}

list1 = list(dict1)
print(type(list1))
# ==> <class 'list'>
print(list1)
# ==> ['name', 'age', 'gender']

2.4 将区间转换成列表

range1 = range(1, 5)
print(type(range1))
# ==> <class 'range'>
print(range1)
# ==> range(1, 5)

list1 = list(range1)
print(type(list1))
# ==> <class 'list'>
print(list1)
# ==> [1, 2, 3, 4]

2.5 创建空列表

list1 = list()
print(type(list1))
print(list1)
# ==> []

3 列表的索引、访问和切片

3.1 列表的索引

与字符串的索引一样，列表正向索引从 0 开始，第二个索引是 1，依此类推：

也可以反向索引，最后一个元素的索引为 -1，往前一位为 -2，以此类推：

3.2 列表的访问

列表是 Python 序列的一种，我们可以使用索引访问列表中的某个元素（得到的是一个元素的值），也可以使用切片返回列表中的一组元素（得到的是一个新的子列表）。

使用索引访问列表元素的语法格式为：listname[i]，其中，listname 表示列表名字，i 表示索引值。列表的索引可以是正数，也可以是负数。

3.3 列表的切片

使用切片返回列表元素的语法格式为：listname[start:end:step]，其中，listname 表示列表名字，start 表示开始检索的位置所对应的索引值，如果不指定，则默认从头开始检索；end 表示结束检索的位置所对应的索引值，如果不指定，则默认一直检索到结尾；step 表示步长，默认为 1；顾头不顾尾。

list1 = ["a", "b", "c", 1, "d"]
print(list1[0])
print(list1[-5])
print(list1[0:4])
print(list1[0:5])
print(list1[0:5:2])
'''
a
a
['a', 'b', 'c', 1]
['a', 'b', 'c', 1, 'd']
['a', 'c', 'd']
'''

4 列表的基础操作

4.1 列表的组合

使用 + 将多个列表合并：

a = ["h", "a", "p", "p", "y"]
b = ["n", "e", "w"]
c = ["y", "e", "a", "r"]
e = [[1, 2, 3, 4]]
d = a + b + c + e
print(d)
# ==> ['h', 'a', 'p', 'p', 'y', 'n', 'e', 'w', 'y', 'e', 'a', 'r', [1, 2, 3, 4]]

4.2 列表的重复

使用 * 将列表重复打印：

b = ["n", "e", "w"]
print(b * 3)
# ==> ['n', 'e', 'w', 'n', 'e', 'w', 'n', 'e', 'w']

4.3 列表的长度

Python 中可以使用 len 函数查看列表长度，语法格式为：len(listname)

b = ["n", "e", "w"]
print(len(b))
# ==> 3

4.4 返回列表中元素最小值和最大值

Python 中可以分别使用 max 函数和 min 函数查看列表中元素的最大值和最小值，语法格式为：max(listname)，min(listname)

list1 = [4, 5, 3, 1, 2]
print(max(list1))
print(min(list1))

4.5 返回列表中元素的总和

Python 中可以使用 sum 函数返回列表各元素的总和，语法格式为：sum(listname)

list1 = [1, 2, 3, 4]
a = sum(list1)
print(a)

5 列表的遍历

5.1 通过 for 循环遍历（最常用）

list1 = [1, 2, 3, 4]
for item in list1:
    print(item)
'''
1
2
3
4
'''

item 表示遍历到的每一个元素，listname 表示需要遍历的列表。

5.2 通过 range 函数遍历

list1 = [1, 2, 3, 4]
range1 = range(len(list1))
# ==> range1:  range(0, 4)
print('range1: ', range1)
for index in range1: # range 函数顾头不顾尾
    print('index: ', index)
    print('value: ', list1[index])
'''
index:  0
value:  1
index:  1
value:  2
index:  2
value:  3
index:  3
value:  4
'''

i 表示遍历到的每一个元素的索引，listname 表示需要遍历的列表。

5.3 通过 enumerate 函数遍历

enumerate 是 Python 的内置函数，对于一个可迭代的对象（如列表、字符串），enumerate 函数可以将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，语法格式为：enumerate(iteration, start)，其中，iteration 为需要遍历的参数，比如字典、列表、元组等，start参数为开始的参数，默认为 0。当既需要遍历索引同时需要遍历元素的时候，可以考虑使用 enumerate 函数。

list1 = [1, 2, 3, 4]
for i_value in enumerate(list1):
    print(i_value)
'''
(0, 1)
(1, 2)
(2, 3)
(3, 4)
'''

for index, value in enumerate(list1):
    print(index, ': ', value)
'''
0 :  1
1 :  2
2 :  3
3 :  4
'''

其中，index 为遍历列表得到的索引，value 为遍历列表得到的每一个列表的元素。

6 列表中元素的添加【增】

6.1 append 函数

append 函数用于在列表的末尾追加元素，语法格式为：listname.append(obj)，其中，listname 表示要添加元素的列表；obj 表示添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

append 函数是在要添加元素的列表 listname 末尾添加元素，添加元素后列表 listname 就已经发生了改变；此外，当给 append 函数传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。

list1 = ['aaa', 'bbb', 'ccc']
list1.append('ddd')
print(list1)
# ==> ['aaa', 'bbb', 'ccc', 'ddd']

list2 = ['aaa1', 'bbb1', 'ccc1']
list1.append(list2)
print(list1)
# ==> ['aaa', 'bbb', 'ccc', 'ddd', ['aaa1', 'bbb1', 'ccc1']]

6.2 extend 函数

append 函数也用于在列表的末尾追加元素，extend 函数和 append 函数的不同之处在于**：extend 函数不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中**，语法格式为：listname.extend(obj)。其中，listname 表示要添加元素的列表；obj 表示添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

此外，当添加的单个元素包含多个字符时，extend 函数会把这个元素所包含的字符逐个添加到列表中。

list1 = ['aaa', 'bbb', 'ccc']
list1.extend('ddd')
print(list1)
# ==> ['aaa', 'bbb', 'ccc', 'd', 'd', 'd']

list2 = ['aaa1', 'bbb1', 'ccc1']
list1.extend(list2)
print(list1)
# ==> ['aaa', 'bbb', 'ccc', 'd', 'd', 'd', 'aaa1', 'bbb1', 'ccc1']

list3 = ['aaa1', 'bbb1', 'ccc1', ['aaa2', 'bbb2', ('aaa3', 'bbb3')]]
list1.extend(list3)
print(list1)
# ==> ['aaa', 'bbb', 'ccc', 'd', 'd', 'd', 'aaa1', 'bbb1', 'ccc1', 'aaa1', 'bbb1', 'ccc1', ['aaa2', 'bbb2', ('aaa3', 'bbb3')]]

6.3 insert 函数

insert 函数用于在列表中间某个位置插入元素，语法格式为：listname.insert(index, obj)，其中，index 表示指定位置的索引值，obj 表示添加的数据，insert 函数会将 obj 插入到 listname 列表第 index 个元素的位置。

当插入列表或者元祖时，insert 函数也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append 函数相同。

list1 = ["aa", "bb", "cc", "dd"]
list1.insert(0, "11")
print(list1)
list1.insert(3, "22")
print(list1)
list1.insert(5, ["ee", "ff", "gg"])
print(list1)
'''
['11', 'aa', 'bb', 'cc', 'dd']
['11', 'aa', 'bb', '22', 'cc', 'dd']
['11', 'aa', 'bb', '22', 'cc', ['ee', 'ff', 'gg'], 'dd']
'''

7 列表中元素的删除【删】

7.1 del 关键字

del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

• 删除整个列表

对于已经创建的列表，如果不再使用，可以使用 del 关键字将其删除，语法格式为：del listname，其中，listname 表示列表名称。

list1 = ["aa", "bb", "cc", "dd"]
del list1
print(list1)
'''
Traceback (most recent call last):
  File "D:\code\pythonDev\test\main.py", line 3, in <module>
    print(list1)
NameError: name 'list1' is not defined
'''

• 删除单个元素

del 可以删除列表中的单个元素，语法格式为：del listname[index]，其中listname 表示列表名称，index 表示元素的索引值。

del 删除列表 listname 中的元素后，列表 listname 就已经发生了改变

list1 = ["a", "b", "c"]
del list1[0]
print(list1)
# ==> ['b', 'c']

• 删除一段连续的元素

del 删除中间一段连续元素的语法格式为：del.listname[start:end]，其中start 表示起始索引，end 表示结束索引，顾头不顾尾

list1 = ["a", "b", "c", "d", "e", "f"]
list2 = ["a", "b", "c", "d", "e", "f"]
del list1[0:4]
del list2[2:5]
print(list1)
print(list2)
'''
['e', 'f']
['a', 'b', 'f']
'''

• pop 函数

pop 函数用来删除列表中指定索引处的元素，语法格式为：listname.pop(index)，其中，listname 表示列表名称，index 表示索引值，如果不写 index 参数，默认会删除列表中的最后一个元素。

• remove 函数

remove 函数会根据元素本身的值来进行删除操作，语法格式为：listname.remove(obj)，其中，listname 表示列表名称，obj 表示要删除的目标元素。

需要注意的是，remove 函数只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

list1 = [2, 36, 2, 7, "aa", "bb"]
list1.remove("aa")
print(list1)
list1.remove(2)
print(list1)
list1.remove(2)
print(list1)
list1.remove(2)
print(list1)
'''
[2, 36, 2, 7, 'bb']
[36, 2, 7, 'bb']
[36, 7, 'bb']
'''

'''
Traceback (most recent call last):
  File "D:\code\pythonDev\test\main.py", line 8, in <module>
    list1.remove(2)
ValueError: list.remove(x): x not in list
'''

• clear 函数

clear 函数用来删除列表的所有元素，即清空列表，语法格式为：listname.clear()

list1 = [2, 36, 2, 7, "aa", "bb"]
list1.clear()
print(list1)
# ==> []

8 列表中元素的修改【改】

Python 提供了两种修改列表元素的方法，可以每次修改单个元素，也可以每次修改一组元素（多个）。

8.1 修改单个元素

修改单个元素，即直接对元素赋值，语法格式为：listname[index] = valuation，其中，listname 表示要被修改的列表，index 表示指定位置的索引值，valuation 表示要赋的值。

list1 = [2, 36, 2, 7, "aa", "bb"]
list1[2] = 66
print(list1)
list1[5] = "ee"
print(list1)
'''
[2, 36, 66, 7, 'aa', 'bb']
[2, 36, 66, 7, 'aa', 'ee']
'''

8.2 修改一组元素

Python 支持通过切片语法给一组元素赋值，语法格式为：listname[start:end] = [obj_list]，listname 表示要被修改的列表，start 表示开始修改的位置所对应的索引值，end 表示结束修改的位置所对应的索引值（顾头不顾尾），obj_list 表示要替换成的那部分列表。

list1 = ["a", 1, "b", 2, "c", 3]
list1[1:4] = [4, "d", 5, [1, 2, 3]]
print(list1)
# ==> ['a', 4, 'd', 5, [1, 2, 3], 'c', 3]

在进行这种操作时，如果不指定步长，Python 就不要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元素：

list1 = ["a", 1, "b", 2, "c", 3]
list1[1:4] = [4, "d", 5, "e", 6, "f"]
print(list1)
# ==> ['a', 4, 'd', 5, 'e', 6, 'f', 'c', 3]
list1[0:6] = [7]
print(list1)
# ==> [7, 'f', 'c', 3]

如果对空切片赋值，就相当于插入一组新的元素：

list1 = ["a", 1, "b", 2, "c", 3]
list1[4:4] = [4, "d"]
print(list1)
# ==> ['a', 1, 'b', 2, 4, 'd', 'c', 3]

9 列表中元素的查找【查】

9.1 count 函数

count 函数用于统计某个元素在列表中出现的次数，语法格式为：listname.count(obj)，其中，listname 表示列表名，obj 表示要统计的元素。如果 count 函数返回 0，就表示列表中不存在该元素，所以 count 函数也可以用来判断列表中的某个元素是否存在。

list1 = ["a", "b", "a", "b", 1, 2, 1, 1]
print(list1.count("c"))  # 0
print(list1.count("a"))  # 2
print(list1.count(1))  # 3

9.2 index 函数

index 函数用于查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，语法格式为：listname.index(obj, start, end)，其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置对应的索引值，end 表示结束位置对应的索引值（顾头不顾尾）。

start 和 end 可以都不写，此时会检索整个列表；如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。

list1 = ["a", "b", "a", "b", 1, 2, 1, 1, "a"]
print(list1.index("a"))
print(list1.index(1))
print(list1.index(1, 3, 8))
print(list1.index("b", 0, 4))
print(list1.index("c"))
'''
0
4
4
1
'''

'''
Traceback (most recent call last):
  File "D:\code\pythonDev\test\main.py", line 6, in <module>
    print(list1.index("c"))
ValueError: 'c' is not in list
'''

9.3 in，not in 成员运算符

成员运算符 in 和 not in 用于断列表中的某个元素是否存在，语法格式为：obj in listname 和 obj not in listname，obj 表示要查找的元素，listname 表示列表名称，如果表述正确，返回 True，否则返回 False。

list1 = ["a", "b", "a", "b", 1, 2, 1, 1, "a"]
print("a" in list1)
print("a" not in list1)
'''
True
False
'''

10 列表中元素的排列【排】

10.1 sorted 函数

sorted 函数作为 Python 内置函数之一，用于对序列（列表、元组、字典、集合、还包括字符串）进行排序，语法格式为：listname = sorted(iterable, key=None, reverse=False)

其中，iterable 表示指定的序列（可迭代的对象），key 参数可以自定义排序规则，reverse 参数指定以升序（False，默认）还是降序（True）进行排序，sorted 函数会返回一个排好序的列表。注意，key 参数和 reverse 参数是可选参数，即可以使用，也可以忽略。使用 sorted 函数对序列进行排序，并不会在原序列的基础进行修改，而是会重新生成一个排好序的列表。

list1 = [4, 5, 3, 1, 2]  # 列表
list2 = sorted(list1)
print(list1) # ==> [4, 5, 3, 1, 2]
print(list2) # ==> [1, 2, 3, 4, 5]


list3 = ["c", "a", "e", "d", "b"]
print(sorted(list3))
# ==> ['a', 'b', 'c', 'd', 'e']
print(sorted(list3, reverse=True))
# ==> ['e', 'd', 'c', 'b', 'a']

tuple1 = (4, 5, 3, 1, 2)
print(sorted(tuple1))  # 元组
# ==> [1, 2, 3, 4, 5]

dict1 = {1: "a", 5: "b", 3: "e", 2: "d", 4: "c"}  # 字典
print(sorted(dict1))
# ==> [1, 2, 3, 4, 5]

a1 = {4, 5, 3, 1, 2}  # 集合
print(sorted(a1))
# ==> [1, 2, 3, 4, 5]

str1 = "45312"  # 字符串
print(sorted(str1))
# ==> [1, 2, 3, 4, 5]

10.2 sort 函数

sort 函数用于对原列表进行排序，语法格式为：listname.sort(key=None, reverse=False)，listname 表示指定的序列，key 参数可以自定义排序规则，reverse 参数指定以升序（False，默认）还是降序（True）进行排序。使用 sort 函数对列表进行排序，不返回值，直接在列表上操作，会改变原列表的值。

list1 = [4, 5, 3, 1, 2]
list1.sort()
print(list1)
list1.sort(reverse=True)
print(list1)
'''
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
'''

10.2 reverse 函数

reverse 函数用于对列表中的元素反向排序，语法格式为：listname.reverse()，listname 表示指定的序列，使用 reverse 函数对列表进行排序，不返回值，直接在列表上操作，会改变原列表的值。

list1 = [4, 5, 3, 1, 2]
list1.reverse()
print(list1)
list2 = ["c", "a", "e", "d", "b"]
list2.reverse()
print(list2)
'''
[2, 1, 3, 5, 4]
['b', 'd', 'e', 'a', 'c']
'''