Python的数据结构-列表

1、分类

数值型，int  浮点型 float，复数complex， bool 布尔值。

2、序列对象

字符串str  列表 list。 Tuple   元组。

3、键值对：

集合set，字典dict。

4、数值型

（1）int、float、complex。bool都是class，1,5.0,2+3j都是对象即实例。

（2）int 长整型，没有大小限制，受限于内存区域的大小。

（3）float，有整数和小数部分组成，支持十进制和科学计数法表示，只有双精度。

（4）complex。有实数和虚数部分组成，实数和虚数都是浮点数、3+4.2j。

（5）bool ：int的子类，仅有两个实例，True和Flase，对应的1和0，可以和整数直接运算。

5、类型转换

（1）int(x)；返回一个整数.查看帮助文档

（2）float(x)；返回一个浮点数

（3）complex(x)；返回一个复数。

（4）bool(x)；返回布尔值，和前面的Flase等价。

6、数字处理函数

1）导入的math函数（import math ）(floor地板向下取整  ceil .天花板 向上取整数->是math模块中的)

2）int() 取整数部分。

3）round()函数 四舍六入五取偶。取向他最近的偶数靠近。

4）//  正数负数全部往地板走。floor.地板 整除且向下取整。

5） min()  max()  pow(x,y)等于x**y。次幂。math.sqrt()。min（1，2，3，）比较大小的。

6）进制函数：返回的是字符串。

bin（）  oct（）   hex（）   math.pi  3.14    math.e  

7)     数据类型。数据类型判断，返回的是类型，而不是字符串。

字符串要加单引号。

type（）

类型比较   

type('a')

8)         类型判断 

type()

 

isinstance(obj,class_or-tuple)   

isinstance()返回布尔值。

隐式转化。。（type（1+true+2.1））float。。type（1+True)  int .      isinstance(1,int)

7、列表list

一个队列，一个排列整齐的队伍，列表内的个体称作元素，由若干元素组成列表。

元素可以是任意个对象（数字，字符串，对象，列表等）。列表内元素有顺序，可以使用索引(编号在0开始)，线性的数据结构。使用[]表示。 (列表是个对象，列表内的元素也可以是个列表） 列表是可变的..(有编号未必是连续的)

1)list  链表  queue  stack的差异。

list ,(列表)。可以中间插队，前后均可以插队。线性数据结构。

queue ,(队列)。不可以中间插队，先进先出，后进先出都可以。线性模型。

stack. 栈。函数。只能后进先出。（罗盘子）函数中用的最多的。

链表：不连续的。通常是上级指向下级，下级指向上级。手拉手形式。内存中散落着。

 

8、列表list定义，初始化。

lsit()->new empty list

list(iterable)->

list不能一开始就定义大小。

list()可迭代对象。

lst=list

lst=[ ]

lst=list[2,6,9,’ab’]

lst=list(range(5))

(使用方式：list（range（1,3）[2,6,9,’ab’] )..

可索引和可迭代两个概念。

list可迭代对象和可索引的。：

 迭代（乱拿方式），索引（按照序号拿出）

9、列表的索引

也叫下标。内存上连续的空间。

     正索引：从左到右，从0开始，为列表中的每一个元素编号，按照顺序编号。

     负索引：从右到左，从-1开始。

     正索引不可以超界，否则引发异常IndexError。索引是不可以超界的。

     为了理解方便，可以理解列表是从左至右排列的 。左边是头部，右边是尾部，左边是下界，右边是上界。

     列表通过索引访问。

    (lst=list(range(5))  lst[-5]

10、列表查询

1)Index（value，[start,[stop]]]）（[]可以写，可以不写。）通过值value，从指定区间查找列表内的元素是否匹配。匹配第一个就立即返回索引。匹配不到，抛出valueErr 。     lst.index（1，-1）

lst.index()  (返回的是索引号)

使用负索引的时候必须要高度注意索引方向。

2) count（value）

返回列表中匹配的value的次数。lst.count(1)

3)时间复杂度：

index和count方法都是O（n）。建议不常用。

随着列表元素数据规模的增大，而效率下降。

4）len()。

      用来计数的,计算长度的。。

      5)查看帮助：

      官方帮助文档，搜索关键字；

       ipython中：help（keyword），，keyword可以是变量、对象、类名、函数名、方法名。

11、列表元素修改

索引访问权限修改：（修改其元素值）list[index]=value    索引不能超界。  lst[2]=200

12、列表增加、插入元素。

1)append(object)->None不会返回有效的值。    lst.append(200)   加几个元素都是依次写。

列表尾部追加元素，返回none值。

返回none就意味着没有新的列表产生，就地修改。

时间复杂度是O（1）

2)insert（index，object）->None.      lst.insert(4,300)

在指定的索引index处插入元素object

返回None就意味着没有新的列表产生，就地修改。

时间复杂度是O（n）

索引能超上下界吗？

 超越上届，尾部追加。

超越下界，头部追加。

3)extend（iteratable）-> None       lst.extend(range(11,16))

将可迭代对象的元素追加进来，返回none。

就地修改。

简单的类型，引用类型。

4)  + -> list       lst +list(range(17,20))

连接操作，将两个列表连接起来

产生新的列表，原列表不会改变。

5)* -> list         ['a1']*5

重复操作，将本列表元素重复n次，返回新的列表本质上调用的是__add__(

13、单支类型，复杂类型

单支类型，复杂类型（引用类型）*3,相当于复制的是地址，(一个变，三个全部变)。

复杂类型：x = [[1,2,3]]*3

print(x)x[0][1] = 20print(x）

简单类型：y = [1]*5

y[0] = 6

y[1] = 7

print(y)

14、列表删除元素

1)         remove（value）->none.      lst.remove(200)

从左至右查找第一个匹配value的值，移除该元素，返回none。。。

就地修改。。。

效率。

      2）pop([index])->item.            n=list(range(1,9))     n.pop()

     不指定索引index，就从列表尾部弹出一个元素。O（1）

      制定索引index，就从索引处弹出一个元素，索引超界抛出IndexErr。O（n）

3）clear（）->none。         list.clear(n)

清除列表所有元素，剩下一个空列表。慎重使用，会产生大量的垃圾，建议使用方法就是覆盖（重新赋值）避免使用。

15、列表其它操作

1)reverse()->None                n.reverse()

将列表元素反转，返回None。

就地修改。。读取的时候进行调头

列表反转的迭代器。   reversed(n)

 

for i in reversed(n):

    print(i)

 

能够立刻使用的的可迭代器。list(reversed(n)) 不耽误别人使用。

  迭代器是一个可迭代对象。

2）in

判断成员是否所在元素组里面。[3,4] in [1, 2, [3,4]]

3)sort（key=None,reverse=Flase）->None

对列表元素进行排序，就地修改，默认升序。

reverse为True，反转，降序。

key一个函数，指定key如何排序。

  lst.sort(key=functionname)

（）括号里面有*号必须按照要求写。

lst.sort(key=str)    利用str函数进行排序。

lst.sort（key=int）利用int进行排序。

 lst.sort(key=functionname)

sorted(lst,key=str)  不影响原来列表，不会就地修改。生成新的列表。

 

16、列表复制

1)Shadow copy，影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已.

lst1=lst0...只是地址相同，复制的是地址。

Copy（）-》list

Shadow copy  返回一个新的列表。(影子复制)

Id(list)显示的是内存地址。

遇到乘法和copy浅拷贝，只是拷贝的地址，简单类型的就是复制，复杂类型的复制的是地址。

2)深拷贝，copy模块提供了deepcopy。

import copy

lst0 = [1, [2, 3, 4], 5]

lst5 = copy.deepcopy(lst0)

lst5[1][1] = 20

lst5 == lst0

浅拷贝：简单类型元模原样复制，引用类型复制的是地址。引用类型里面改变一个全部变。

深拷贝：简单类型元模原样复制，引用类型是按照地址重新复制一份。改变一个不影响另外一个。

拷贝总结：lst=[1,2,3,4]

          lst1=lst  #同一个对象。

          lst2=lst.copy（）#内容相同，不同的对象，遇到引用类型不会复制对象，只会复制地址。

          lst3=copy，deepcopy（lst）#内容相同，但不同的对象，如果有引用类型也会复制出不同的对象。

17、random模块

 1）导入import random。

2）randint（a，b）之间返回一个随机数.

3）choice（seq）从非空序列的元素中随意挑选一个元素，random.choice（range（10）。random([1,3,5,7]).

4）randrange ([start,] stop [,step]) 从指定范围内,按照指定基数递归的一个集合中获取一个随机数，基数缺省值为1.     random.randrange(1,7,2)

5）random.shuffle(list) ->None 就地打乱列表元素  random.shuffle(lst0)

for i in range（10）6）sample(population, k) 从样本空间或总体（序列或者集合类型）中随机取出k个不同的元素，返回一个新的列表.random.sample(['a','a','a','a'],2)

Print（random.randint（1,6）)