python六大常用基本数据类型之列表

列表

1.一个容器
2.容器内个体称为元素
3.元素可以是任意对象(数字、字符串、对象、列表等)

a = []
b = 'bsss'
a = [1,b,int,a]
print (a)
[1, 'bsss', <class 'int'>, []]

4.列表内元素有顺序，可以使用索引

a = [1,2,3,4]
 a[0]
1

5.线性的数据结构，在内存中连续一块存储
6.使用[]表示
7.列表是可变的
8.list实际上是python的内置类型，即基本数据类型。

列表list定义 初始化

1.list() ->new empty list
2.list(iterable) -> new list initialized from iterable’s items
说明:参数iterable是可选的，它可以是序列，支持编译的容器对象，或iterator对象。

使用索引去访问列表

1.索引，也叫下标，标记元素顺序
2.正索引：从左至右，左第一个(标0)开始，为列表中每一个元素编号
3.负索引：从右至左，从右边第一个(标-1)开始,为列表中每一个元素编号
4.索引有界 正负索引不可越界，否则引发IndexError异常
5.列表通过索引访问 方式list[index],index为索引，使用中括号

列表查询

1.index(value,[start,[stop]])
value:查找的值
start:起始索引
stop:结束索引

a = [1,2,3,4,5,6,7,8,9]
a.index(5,3,6)
4#  5 在 a中的索引 a[4]
# 用索引前最好确定一下 元素是否在 容器中 不然抛出异常 处理麻烦 可以使用in/not in来检查一下 其实就是用一个可控返回值来替代 这个异常

count(value)
返回列表中匹配value的次数

a.count(3)
1

时间复杂度
index和count方法都是O(n)
n越大 效率越低
这样每次返回列表元素的个数是不是很麻烦
第一次用记录下来是不是好点
你输入完->再去遍历(一个一个数)是不是也麻烦 不如你输入的时候就给你记住个数
len()

a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
len(a)
9

多看官方帮助文档
windows下 找到 Python(版本号) Manuals
IPython中
help(keyword)
keyword-> 变量、对象、类名、函数名、方法名
多试->比较不同方式输出结果 多看->官方手册 千人千面不要迷信某种方法
第一次上课最深刻的一句话"你写了什么就是什么"

列表元素修改

1.索引访问修改
list[index] = value
通过索引去查你修改你要修改的值
索引有什么？ 索引有界限

列表增加、插入元素

尾部追加append

append(object) -> None
尾部追加(尾部开口的对象) ->返回None
记住None这个返回

type(None)
<class 'NoneType'>

记得上面索引有什么？ 索引有边界 越界则 抛出异常
就像查找考虑到了如果越界 如果不在加个判断过滤一下 返回None也可以过滤一下：Null对象或者是None Type，它只有一个值None.
返回None就意味着没有新的容器产生，原地修改 ->这边容器是 list
时间复杂度O(1)

插入insert

insert(index,objec) -> None
在指定的索引index处插入元素object
返回None就意味着没有新的列表产生，就地修改
时间复杂度O(n)
这里index索引能超上下界吗？
1.超越上界，尾部追加
2.超越下界，头部追加

extend

extend(iteratable) -> None
iteratable -> 可迭代元素
1.将可迭代对象的元素追加进来，
2.就地修改

+ -> list

1.连接操作,将两个列表连接起来
2.产生新的列表,原列表不变
3.本质上调用的是_add_()方法

a = [1,2,3]
b = [3,2,1]
c = a+b
print(c)
[1, 2, 3, 3, 2, 1]

* -> list

1.重复操作，将本列表元素重复n次,返回新的列表

a = [1,2,3]
a*10
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
a*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

列表 * 重复的坑

a = [1,2,3]
x = [[1,2,3]]*3
print(x)
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
x[0][1] = 20
print(x)
[[1, 20, 3], [1, 20, 3], [1, 20, 3]]

比较观察 看看不同修改方式改的是什么

>>> y = [1]*5
>>> y[0] = 6
>>> y[1] = 7
>>> print(y)
[6, 7, 1, 1, 1]
>>> c = y*3
>>> print(c)
[6, 7, 1, 1, 1, 6, 7, 1, 1, 1, 6, 7, 1, 1, 1]
>>> c =[y*3]
>>> print(y)
[6, 7, 1, 1, 1]
>>> print(c)
[[6, 7, 1, 1, 1, 6, 7, 1, 1, 1, 6, 7, 1, 1, 1]]
>>> c = [y]*3
>>> print(c)
[[6, 7, 1, 1, 1], [6, 7, 1, 1, 1], [6, 7, 1, 1, 1]]
>>> c[0][1] = 8#改的是7 但是改的是什么
>>> print(c)
[[6, 8, 1, 1, 1], [6, 8, 1, 1, 1], [6, 8, 1, 1, 1]]
>>>

列表删除元素

remove

remove(value) -> None
1.从左至右查找第一个匹配的value的值，移除该元素，返回None
返回None意味着什么？ 原地修改不生成新(容器)->列表
2.从左至右意味着什么？效率？

>>> a = [1,2,3,4,5,6]
>>> a.remove(5)##删除的是5这个值 删完返回值为None 所以没有输出 原地修改
>>> print(a)#输出a a被修改了
[1, 2, 3, 4, 6]
>>>

pop

pop([index]) -> item
1.不指定索引index,从列表尾部弹出一个元素
2.指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
3.效率？指定索引时间复杂度？不指定索引？

>>> print(a)
[1, 2, 3, 4, 6]
>>> a.pop()
6
>>> a.pop(0)###弹出来索引为0 值为1 
1
>>> a.pop(1)
3
>>> a.pop(0)
2
>>>

clear

clear() -> None
清除列表所有元素，返回值为None，原列表成为空列表[]

>>> a.clear()
>>> print(a)
[]
>>>

列表其他操作

reverse

reverse() -> None
1.将列表元素反转,返回None？None意味着什么？ 没有产生新的就地修改
如果进行反转之后 用尾部操作 是不是变成头部操作了？

sort

sort(key=None,reverse=False) -> None
1.对列表进行排序,就地修改,默认升序
2.reverse为True,反转，降序 ->默认False所以默认不反转 升序:从小到大
3.key一个函数，指定key如何排序
lst.sort(key=function) #function函数 函数封装

>>> a = [1,6,5,8,4,3,2,1]
>>> a.sort()
>>> print(a)
[1, 1, 2, 3, 4, 5, 6, 8]
>>> a.sort(reverse=True)
>>> print(a)
[8, 6, 5, 4, 3, 2, 1, 1]
>>>

in

[3,4] in [1,2,[3,4]]

>>> [3,4] in [1,2,[3,4]]
True
>>>

for x in [1,2,3,4]

>>> for x in [1,2,3,4]:
...     print(x) 		#注意缩进
...                    #windows命令行下回车执行
1
2
3
4
>>>

复制列表

>>> ls0 = list(range(4))#range（4）可迭代 从0-3 ->[0,4)
>>> ls2 = list(range(4))
>>> print(ls0==ls2)
True
>>> ls1 = ls0
>>> ls1[2] = 10
>>> print(ls0)
[0, 1, 10, 3]
>>> print(ls1)
[0, 1, 10, 3]
>>>

ls0==ls2?
ls1[2] = 10?

copy

1.copy() -> list
浅拷贝shadow copy -> 返回一个新的列表
遇到引用类型，只是复制了一个引用

>>> lst0 = list(range(4))#ls0 = list(range(4))
>>> lst5 = lst0.copy() #ls2 = list(range(4))
>>> print(lst5 == lst0) #print(ls0==ls2)
True
>>> lst5[2] = 10        #ls1[2] = 10
>>> print(lst5 == lst0)
False
>>> print(lst5)     #print(ls0)
[0, 1, 10, 3]       #[0, 1, 10, 3]
>>> print(lst0)     #print(ls1)
[0, 1, 2, 3]        #[0, 1, 10, 3]

对比一下
2.deepcopy
copy模块提供了深拷贝deepcopy

>>> import copy
>>> ls0 = [1,[2,3,4],5]
>>> print(ls0)
[1, [2, 3, 4], 5]
>>> ls5 = copy.deepcopy(ls0)
>>> print(ls5)
[1, [2, 3, 4], 5]
>>> ls5[1][1] = 20
>>> print(ls5)
[1, [2, 20, 4], 5]
>>> ls5 == ls0
False
>>> print(ls0)
[1, [2, 3, 4], 5]

由此可见深拷贝的效果

随机数

1.random模块
2.randint(a,b)返回[a,b]之间的整数

>>> import random
>>> random.randint(1,9)
6
>>>

3.choice(seq)从非空序列的元素中随机挑选一个元素注意这边是元素哦

>>> import random
>>> a = ['a','b','c','d']
>>> print(a)
['a', 'b', 'c', 'd']
>>> random.choice(a)
'c'

4.randrange([start,]stop[,step])从指定范围内，按指定基数(步长)递增的集合中获取一个随机数,基数(步长)缺省值(你不填默认值)为1.

>>> import random
>>> random.randrange(1,7,2)
3
>>>

5.randomshuffle(list) -> None None 他又来了 原地修改list 原地打乱列表中元素

>>> a = [1,3,4,8,7,5]
>>> import random
>>> random.shuffle(a)
>>> print(a)
[8, 4, 7, 1, 3, 5]
>>>

6.sample(population,k)从样本空间或总体(序列或者集合类型)中随机取出k个不同的元素，返回一个新的列表。

>>> print(a)
[8, 4, 7, 1, 3, 5]
>>> random.sample(a,2)
[7, 8]
>>>random.sample(['a','b','c','d'],2)
['c', 'a']
>>> random.sample(['a','a'],2)
['a', 'a']
>>>

生活不可能像你想象得那么好，但也不会像你想象得那么糟。 
我觉得人的脆弱和坚强都超乎自己的想象。 
有时，我可能脆弱得一句话就泪流满面；有时，也发现自己咬着牙走了很长的路。

---

border="0" width="330" height="86" src="//music.163.com/outchain/player?type=2&id=1308041620&auto=1&height=66">

---