列表

列表可以存储成组的信息，可以包含几个元素，也可以包含数百万个元素，列表是用方括号来表示的

定义

列表由一系列按特定顺序排列的元素组成。元素之间可以没有任何关系。

通常命名列表使用复数单词，例如：letters、digits、names

用方括号（[]）表示列表，并用逗号来分隔其中的元素

打印列表时，将打印列表的内部表示，包括方括号、引号：

>>> bicycles = ['trek', 'cannondale', 'redline', 'specialized']
>>> print(bicycles)
['trek', 'cannondale', 'redline', 'specialized']

>>> a = ["A"]
>>> print(a)
['A']

>>> a = ["A", 'B', 3]
>>> print(a)
['A', 'B', 3]

无论列表中的元素，字符串是用单引号还是双引号，直接打印列表时，输出的字符串都是用单引号来表示

访问列表元素

列表是有序集合，要访问列表的任何元素，只需要知道该元素的位置或者索引

方式：列表名称[索引]

>>> bicycles = ['trek', 'cannodale', 'redline', 'specialized']
>>> print(bicycles[0])
trek

当去访问列表元素时，会返回元素，而不返回 引号 与 方括号，这点与直接打印列表不一样

列表的索引是从 0 开始的

通过索引 -1 ，可以访问最后一个列表元素，以此类推，索引 -2 访问倒数第二个列表元素...

通过索引 -1，可以在不知道列表长度的情况下访问最后的元素，但如果列表是空的，则不能使用 索引-1 去访问

>>> motors = []
>>> motors[-1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

修改、添加和删除列表元素

大多数列表都是动态的

修改列表元素

列表名[元素索引] = 新值

>>> cycles = ['honda', 'yamaha', 'suzuki']
>>> print(cycles)
['honda', 'yamaha', 'suzuki']
>>> cycles[0] = 'ducati'
>>> print(cycles)
['ducati', 'yamaha', 'suzuki']

添加列表元素

• 在列表末尾添加元素
• 在列表中插入元素

在列表末尾添加元素 append()

在列表末尾添加元素的方法是：append()

>>> cycles.append('123')
>>> print(cycles)
['ducati', 'yamaha', 'suzuki', '123']

创建一个空列表，使用一系列 append() 添加元素

>>> motors = []
>>> motors.append('a')
>>> motors.append('b')
>>> motors.append('c')
>>> print(motors)
['a', 'b', 'c']

在列表中插入元素 insert()

在列表任何位置添加新元素的方法：insert(索引，值)，需要指定新元素的 索引 和 值

这个方法会将添加位置后面既有的每个元素都右移一个位置

>>> motors.insert(0, '1')
>>> print(motors)
['1', 'a', 'b', 'c']
>>> motors.insert(-1, '2')
>>> print(motors)
['1', 'a', 'b', '2', 'c']

删除列表元素

可以根据 位置 或 值 来删除列表中的元素

• del 知道要删除的元素的位置，不返回删除的元素
• pop() 或 pop(索引) 知道要删除元素的位置，会返回删除的元素
• remove() 知道要删除元素的值，会返回删除的元素

del

知其位置，可以使用 del 删除

使用方法：del 列表名[索引]

>>> print(motors)
['1', 'a', 'b', '2', 'c']
>>> del motors[0]
>>> print(motors)
['a', 'b', '2', 'c']

使用 del 可删除任何位置处的列表元素，前提是知道元素的索引

使用 del 语句将元素在列表中删除以后，就无法再访问了

pop()

del语句删除后无法继续使用，但pop()删除后可以继续使用它的值，因为它会返回被删除的元素

pop()方法可删除列表末尾的元素，用一个变量接收，就能接着使用被删除的元素了，但是列表里已经没这个元素了

>>> poped_motor = motors.pop()
>>> print(poped_motor)
c
>>> print(motors)
['a', 'b', '2']

弹栈后，pop() 返回值是删除的值，所以用一个变量接收，就能接着使用了，如果不接收，其效果与 del 语句删除一样，并且 pop() 也能删除列表中任何位置的元素

使用方法：pop(索引)

>>> print(motors)
['a', 'b', '2']
>>> motors.pop(0)
'a'
>>> print(motors)
['b', '2']

若从列表中删除的元素不再使用，则使用 del语句

如果删除元素还要继续使用，则使用 pop(索引) 方法，若没有索引，默认删除栈顶元素

remove()

pop() 和 remove() 都返回删除的元素，区别是：

知道删除元素的索引，使用 pop()

知道删除元素的值，使用 remove()

>>> print(motors)
['b', '2']
>>> motors.remove('2')
>>> print(motors)
['b']

注意：remove() 只删除第一个指定的值，如果要删除的值在列表中出现多次，需要使用循环来判断是否删除了所有这样的值。

组织列表

永久性排序

方法 sort() 永久性地改变了列表元素的排列顺序

>>> cars = ['b', 'a', 't', 's']
>>> cars.sort()
>>> print(cars)
['a', 'b', 's', 't']

sort默认是按字母顺序排列

若要逆序排列，则要给sort传入参数reverse = True，即 sort(reverse=True)

>>> cars = ['b', 'a', 't', 's']
>>> cars.sort(reverse=True)
>>> print(cars)
['t', 's', 'b', 'a']

若字母有大写

>>> cars = ['B', 'b', 'C', 'c']
>>> cars.sort()
>>> print(cars)
['B', 'C', 'b', 'c']

先排大写字母，再排小写字母

若还有数字，则先排数字，再排大写字母，最后排小写

>>> cars = ['B', 'b', 'C', 'c', '1', '2']
>>> cars.sort()
>>> print(cars)
['1', '2', 'B', 'C', 'b', 'c']

注意：使用sort()排序后输出时，步骤要分开

>>> scenics.sort()
>>> print(scenics)

# print(scenics.sort())

第4行那种方式输出结果是 None，只能是把两步分开。

临时性排序

方法 sorted() 能够按特定顺序显示列表顺序，同时不影响列表原始列表顺序，是临时性的排序

>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> print("original list:")
original list:
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
>>> print("the sorted list")
the sorted list
>>> print(sorted(cars))
['audi', 'bmw', 'subaru', 'toyota']
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']

注意：列表调用函数 sorted() 后，原始列表元素的排列顺序并没有变

若要按字母逆序输出，也可传入参数 reverse = True

调用sorted()函数时，参数是 列表 ，reverse=True。这点与调用sort()不一样，列表是作为对象去调用 sort()，参数只有 reverse=True 可选

>>> sorted(cars)
['audi', 'bmw', 'subaru', 'toyota']
>>> sorted(cars, reverse=True)
['toyota', 'subaru', 'bmw', 'audi']

对列表倒序（不排序）

reverse() 不会让列表反向顺序排序，而只是倒着排列，是永久性的改变，若想恢复原状，只需再执行一次 reverse()

>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
>>> cars.reverse()
>>> print(cars)
['subaru', 'toyota', 'audi', 'bmw']

reverse() 与 sort(reverse=True) 虽然都是倒序，但是效果不一样，reverse()不是排序，只是单纯倒着排列列表，而 sort(reverse=True) 会倒序的方式按字母顺序排序列表

len()

获取列表的长度

>>> len(cars)
4

索引错误

IndexError

>>> motors = ['honda', 'yamaha', 'suzuki']
>>> motors[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

当列表为空时，使用 索引-1 会导致错误

>>> motors = []
>>> motors[-1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

遍历列表

for循环

>>> magicians = ['alice', 'david', 'carolina']
>>> for magician in magicians:
...     print(magician)
... 
alice
david
carolina

Python每次都从列表中取出一个变量，并将其存入临时变量中

编写for循环时，用于存储列表中每个值的临时变量，可指定为任何名称。

for item in list_of_items:
    ...

注意 for 后面有 :

使用复数命名列表，使用单数命名临时变量

>>> magicians = ['alice', 'david', 'carolina']
>>> for magician in magicians:
...     print(magician.title() + ", that was a great trick!")
... 
Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!

在 for 语句后面的每一个缩进的代码都是循环的一部分，且对列表中的每个值都会执行一次。

>>> for magician in magicians:
...     print(magician.title() + ", that was a great trick!")
...     print("I can't wait to see your next trick, " + magician.title() + ".\n")
... 
Alice, that was a great trick!
I can't wait to see your next trick, Alice.

David, that was a great trick!
I can't wait to see your next trick, David.

Carolina, that was a great trick!
I can't wait to see your next trick, Carolina.

print() 自带换行

缩进错误

Python 根据缩进来判断代码行与前一个代码行的关系

IndentationError

• 忘记缩进

  Python 没有找到期望缩进的代码块时，会报 缩进错误

  >>> magicians = ['alice', 'david', 'carolina']
  >>> for magician in magicians:
  ... print(magician)
    File "<stdin>", line 2
      print(magician)
          ^
  IndentationError: expected an indented block
  

• 忘记缩进额外的代码行

  逻辑错误，不会报错，但结果不符合预期

• 不必要的缩进

  >>> message = "Hello"
  >>>     print("123")
    File "<stdin>", line 1
      print("123")
      ^
  IndentationError: unexpected indent
  

• 循环后不必要的缩进

• 遗漏冒号

  for语句末尾的冒号告诉 Python，下一行是循环的第一行

数字列表

列表非常适合用于存储数字集合

range()方法

可以生成一系列数字

range(a, b) 让Python从 数字a 开始计数，到 数字b 停止，但不包含 数字b

>>> for value in range(1, 5):
...     print(value)
... 
1
2
3
4

range() 还可以指定 步长

range(2, 11, 2) 数字范围是 2到11（不包含11），步长是 2

>>> even_numbers = list(range(2, 11, 2))
>>> print(even_numbers)
[2, 4, 6, 8, 10]

创建数字列表

可以用 函数list() 将 range()的结果 直接转换为列表

将 range() 作为 list() 的参数，返回值将是一个数字列表

>>> numbers = list(range(1, 6))
>>> print(numbers)
[1, 2, 3, 4, 5]

将10个整数的平方加入到一个列表中

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

也可以用 range() 产生的数字循环存入临时变量，再使用 append() 将 临时变量乘方后的值 添加到 事先创建好的空列表 中

简洁一点，不使用临时变量，这样更简洁，但是易读性不如上面的思路：

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

简而言之，有以下两种方法：

numbers = list(range(1, 11))
# **************************
numbers1 = []
for value in range(1, 11):
    numbers1.append(value)

生成偶数和奇数列表：

odd_numbers = list(range(1, 21, 2))
even_numbers = list(range(2, 21, 2))

数字列表的统计计算函数

• min()
• max()
• sum()

>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>> sum(digits)
45

列表解析

列表解析将 for 循环和创建新元素的代码合并成一行，并自动附加新元素

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

首先，指定一个 描述性的列表名

然后，指定一个 左方括号，并定义一个表达式，该表达式用于生成要存储在列表中的值

最后，编写一个 for循环，用于给表达式提供值，再加上 右方括号

切片

创建切片

指定要使用的第一个元素的索引和最后一个元素的索引加1，Python在到达第二个指定的元素后停止，不包含第二个指定的元素，例如 [0:3] 会输出 索引 0、1、2

>>> men = ['Bob', 'Jack', 'David', 'Mark', 'Sean', 'Lisa']
>>> print(men[0:3])
['Bob', 'Jack', 'David']

输出结果是一个 列表

若未指定第一个索引，将自动从列表开头开始

>>> print(men[:4])
['Bob', 'Jack', 'David', 'Mark']

若未指定第二个索引，则切片将包括第一个索引后面的所有元素

>>> print(men[2:])
['David', 'Mark', 'Sean', 'Lisa']

可以获取从特定位置到列表末尾的所有元素

负数索引返回离列表末尾相应距离的元素：

>>> print(men[-1:])
['Lisa']
>>> print(men[-3:])
['Mark', 'Sean', 'Lisa']

若要包含列表所有元素的切片，则是同时省略起始索引和终止索引 [:]

遍历切片

使用 for 循环遍历切片

>>> players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>> for player in players[:3]:
...     print(player.title())
... 
Charles
Martina
Michael

利用切片复制列表

创建一个包含整个列表的切片赋值给新的列表就是复制列表，这个切片就是原列表的副本

>>> my_foods = ['pizza', 'falafel', 'carrot cake']

>>> friend_foods = my_foods[:]

>>> print(my_foods)
['pizza', 'falafel', 'carrot cake']
>>> print(friend_foods)
['pizza', 'falafel', 'carrot cake']

若直接将列表赋值给另外一个列表，这样无法实现列表的复制

这样只是让两个变量指向了同一个列表

正确的复制是 将列表的副本存储到新的列表中，而副本通过切片来产生

friend_pizzas = pizzas[:]

标签：Python,cars,元素,motors,列表,索引,print
来源： https://www.cnblogs.com/seansheep/p/14357074.html