列表

在python中列表是有序的序列
列表用一对 [] 生成，中间的元素用 , 隔开，其中的元素不需要是同一类型，同时列表的长度也不固定。

l = [1,2.34,'123dsfa ']
print(l)

空列表可以用 [] 或者 list() 生成：

empty_list = []
empty_list = list()

操作

加法乘法

a = [1, 2, 3]
b = [3.2, 'hello']
a + b
l * 2

索引和分片
同上一章，字符串不可修改，列表可以通过这种方式修改修改

a = [10 , 11,12,13,14,15]
a[0] = 100                                       #单个元素修改
a[1:3] = [1,2,3,4]                            #多个连续元素修改，左边与右边可以不相等，即可以[1,2]替换[1,2,3,4]
a[1:3] = []                                      #通过连续方式修改，可以辅助为空删除元素
a [::2] = [1,2,3]                             #对多个不连续元素修改，必须左右元素个数相等

• 多个连续元素修改，左边与右边可以不相等，即可以[1,2]替换，通过连续方式修改，可以辅助为空删除元素
• 对多个不连续元素修改，必须左右元素个数相等

删除元素

a = [1002, 'a', 'b', 'c']
del a[0]
del a[1:]
del a[::2]

测试从属关系

a = [10, 11, 12, 13, 14]
print (10 in a)
print (10 not in a)

s = 'hello world'
print ('he' in s)
print ('world' not in s)

列表中可以包含各种对象，甚至是列表

方法

image.png image.png

list = [1,2,3,4]
len(list)
max(list)
min(list)
str = "hello world"
tuple = ('orange','apple','banana')
list(str)                                          # ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
list(tuple)                                     #['orange', 'apple', 'banana']

不清楚方法的使用可以用
list.sort?

元组tuple

有序序列，但是不可变，用括号生成最后一个元素后面逗号可有可无，但是单个元素时一定要写逗号

t = (1,2,3,4)

单个元素的元组，要用'，'区别基本数据类型与元组

t = (10)
type(t)                      #<class 'int'>
t = (10,)
type(t)                        #<class 'tuple'>

函数

t = (1,2,3,4,)
t.count(10)               #0
t.index(4)                #3
t.index(5)                #报错！！！！！

为什么需要元组

旧式字符串格式化中参数要用元组；
在字典中当作键值；
数据库的返回值

列表与元组速度比较

生成速度

>>%timeit [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]

119 ns ± 1.04 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

>>timeit (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25)

10.1 ns ± 0.382 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
元组的生成速度比列表快很多

比较遍历速度

from numpy.random import rand
values = rand(10000,4)
lst = [list(row) for row in values]
tup = tuple(tuple(row) for row in values)

%timeit for row in lst: list(row)

1.35 ms ± 13.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

timeit for row in tup:tuple(row)

838 µs ± 912 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)
元组遍历比列表快三分之一

比较遍历和索引速度

timeit for row in lst: a = row[0] + 1

1.86 ms ± 11.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit for row in tup: a = row[0] + 1  

1.86 ms ± 21.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
索引速度差不多
总结：在生成速度上元组比list快，迭代快，索引速度差不多

空间比较

from sys import getsizeof
getsizeof(lst)

87624

getsizeof(tup)

80048
list 比tuple消耗更多的空间

immutable(不可变)好处

• 性能优化，多线程安全，不需要锁，不担心被恶意修改或者不小心修改。
• 用作dict的key