列表
在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)
列表中可以包含各种对象，甚至是列表
方法
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
