列表简介

列表由一系列按特定顺序排列的元素组成，即是一系列数据对象的集合。列表用方括号 [] 标识，里面的元素用逗号 , 分割。

将列表赋给一个变量时，传递的是引用，即传址不传值。

列表的元素可以是变量，也可以是表达式，解释器会自动计算结果，放入列表中。

操作列表

访问列表元素：

使用 列表名[索引] 访问列表中的元素，其中索引号从0开始计数。负数索引是从最后一个元素计数，例如-1表示最后一个元素，-2是倒数第二个，以此类推。

可以像使用其他变量一样使用列表元素。

列表是动态的，可以对其进行增删改操作，使其发生变化。

添加列表元素：

在列表末尾追加：append('值')

names = ['Jack', 'Lucy', 'Tom', 'Jone']
names.append('Lily')
#方法 append() 将元素 Lily 添加到列表末尾，而不影响列表中的其他元素。

在列表任一位置插入添加：insert(索引, '值')

names = ['Jack', 'Lucy', 'Tom', 'Jone']
names.insert(2, 'Lily')
#方法 insert() 在索引2处插入新元素，其后的元素索引往后顺移一位。

删除列表元素：

1.通过索引删除

del语句删除元素

del 目标元素

names = ['Jack', 'Lucy', 'Tom', 'Jone']
del names[2]

pop()删除并返回该元素

该方法参数为要删除的元素的索引，默认为最后一个元素的索引。

names = ['Jack', 'Lucy', 'Tom', 'Jone']
deletedname = names.pop(1)

注：删除列表元素后，如果确定不再使用该元素，则使用del语句。如果删除后还需要使用该元素，则使用 pop() 方法。

2.通过值删除

remove()根据值删除指定元素

该方法参数为要删除的元素的值。如果列表中存在多个相同的值，则该方法删除第一个该值。

names = ['Jack', 'Lucy', 'Tom', 'Jone']
names.remove('Lucy')

修改列表元素：

与字符串不同，列表内的元素可以修改。可以通过索引或者切片进行修改操作：

cubes = [1, 8, 27, 65, 125]
cubes[3] = 64
print(cubes)  
# 输出 ：[1, 8, 27, 64, 125]

# 为切片赋值可以改变列表大小，甚至清空整个列表：
letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
letters[2:5] = ['C', 'D', 'E']
print(letters)
# 输出 ：['a', 'b', 'C', 'D', 'E', 'f', 'g']

letters[2:5] = []
print(letters)
# 输出 ：['a', 'b', 'f', 'g']

letters[:] = []
print(letters)
# 输出 ：[]

合并列表元素：

与字符串类似：

+ 操作符可以连接两个列表，组成一个新的列表；

* 操作符可以作用于一个列表和一个整数，实现列表的复制，返回一个新列表；

[1,2,3] + [4,5,6]

结果：[1,2,3,4,5,6]

倒序列表元素：

使用 reverse() 方法可以将列表的元素倒过来。

注：该方法只是进行了倒序操作，并未将操作后的列表进行返回，即没有返回值。

#!/usr/bin/python3
list = ['zhangsan','lisi','wangwu','zhaoliu']
list.reverse()
print(list)

其他列表操作方法：

clear()    移除列表中的所有元素。

index('值')    返回列表中指定元素值的索引。

count('值')   返回列表中指定元素值出现的次数。

copy()    复制列表，等同于a[:]

切片

切片可以理解为是从一个列表中复制出来的一个子列表。本质上，切片其实就是复制列表，复制部分或整个列表，生成一个新的列表。

既然要‘切’，那么就需要知道两个数值，切入点和结束点。切片的区间表示方法是用冒号隔开两个数字，左边数字是起始下标，右侧数字是结束下标，但不包括它。

如：

spam = [‘a', 'b', 'c', 'd', 'e']
spam[1:4] 
结果为 [ 'b', 'c', 'd']
# 切片赋值：
spam[1:4] = ['B', 'C','D']
# 修改后的列表：['a','B','C','D','e']

注：冒号两边的数字可以省略，第一个数字省略表示从0开始，第二个数字省略表示到列表长度结束，即直到（包含）最后一个列表列表项。两个都省略 [:] 则表示复制整个列表。

用 len() 函数返回传给它的列表的长度，即列表中元素个数。

元组

元组是一种特殊的序列类型，使用圆括号 () 标识。列表和元组都是有序列表，索引从0开始，区别在于元祖在初始化之后就不可改变了。

如果元组中只有一个元素，必须要在后面加上逗号，像这样

a = (1, )

否则 这样写的话

a = (1)

a就是 数字1 了， 而不是包含 数字1 的元组

多个变量同时赋值

可以是用列表或元祖对多个变量同时赋值：

name,age = ['GavinHsueh', 30]

注意：变量个数必须与列表/元组中的元素个数一致。

判断列表中是否存在目标元素

有时候，我们要检查列表、元组对象中是否存储我们要找的元素。 我们可以通过 in 这个关键字 ，比如：

a in var   # 检查 a 是否在var 中存在，存在返回True，否则返回False

而 not in 则判断是否不存在，比如

a not in var   # 检查 a 是否不在var 中，存在返回 False，否则返回 True

示例：

list1 = [1,2,3,4, 'hello']
tuple1 = (1,2,3,4, 'hello')
if 'hello' in list1:
    print('hello 在列表中存在')
if 'boy' not in tuple1:
    print('boy 在元组中不存在')

列表推导式

列表推导式创建列表的方式更简洁。常见的用法为，对序列或可迭代对象中的每个元素应用某种操作，用生成的结果创建新的列表；或用满足特定条件的元素创建子序列。

例如，创建平方值的列表：

squares = []
for x in range(10):
    squares.append(x**2)

print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

等价于：

squares = [x**2 for x in range(10)]

上面这种写法更简洁、易读。

列表推导式的方括号内包含以下内容：一个表达式，后面为一个 for 子句，然后，是零个或多个 for 或 if 子句。结果是由表达式依据 for 和 if 子句求值计算而得出一个新列表。 举例来说，以下列表推导式将两个列表中不相等的元素组合起来：

[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

for 循环遍历列表

for循环遍历整个列表，对列表中的每个元素执行相同的操作。

for var in list:
循环体
……

for-in 后面，每个缩进的代码都是循环体的一部分。不要漏掉冒号！

a =  [1, 3, 5, 7, 9]
for var in a:
    print(var)
输出结果：1 3 5 7 9

在序列中循环时，用 enumerate() 函数可以同时取出位置索引和对应的值：

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

# 输出结果：
0 tic
1 tac
2 toe

同时循环两个或多个序列时，用 zip() 函数可以将其内的元素一一匹配：

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print('What is your {0}?  It is {1}.'.format(q, a))

# 输出结果：
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

函数返回列表或者元组

函数的返回值可以是一个列表或者 元组对象，像这样

def func1():
    age = input('请输入年龄')
    gender = input('请输入性别')
    return  [age,gender]

当我们有多个数据对象需要在函数里面返回的时候，就可以放到列表中。