数据结构01---列表list

分类

• 数值型
  int、float、complex、bool
• 序列对象
  字符串 str
  列表 list
  tuple
• 键值对
  集合set
  字典dict

数值型

数值型

int、float、complex、bool都是class，1、5.0、2+3j都是对象即实例
int：python3的int就是长整型，且没有大小限制，受限于内存区域的大小
float：有整数部分和小数部分组成。支持十进制和科学计数法表示。只有双精度型。
complex：有实数和虚数部分组成，实数和虚数部分都是浮点数，3+4.2J
bool：int的子类，仅有2个实例True、False对应1和0，可以和整数直接运算

类型转换（built-in）

int(x) 返回一个整数

float(x) 返回一个浮点数

complex(x)、complex(x,y) 返回一个复数

bool(x) 返回布尔值，前面讲过False等价的对象

数字的处理函数

• round()，四舍六入五取偶
• floor()向下取整、ceil()向上取整
• int() 取整数部分
• // 整除且向下取整
• min()
• max()
• pow(x,y) 等于 x**y
• math.sqrt()
• 进制函数，返回值是字符串
• bin()
• oct()
• hex()
• math.e 自如常数
• math.pi π

类型判断

• type(obj) ，返回类型，而不是字符串
• isinstance(obj, class_or_tuple)，返回布尔值

列表list

一个队列，一个排列整齐的队伍
列表内的个体称作元素，由若干元素组成列表
元素可以是任意对象（数字、字符串、对象、列表等）
列表内元素有顺序，可以使用索引
线性的数据结构
使用 [ ] 表示 or list()
定义个list

l1 = list(range(10))
print(l1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

index(value,[start,[stop]])····不推荐指数：*****

时间复杂度：O(n)

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

通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError

l1.index(13)
3         #3（位置信息）-10（代表列表里面有10个值）=-7（对应的负索引）
在队列里找到内容是13并且定位到其在列表中的位置

count(value) ······················不推荐指数：*****

（统计队列所含数值次数）

时间复杂度：O(n)

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

返回列表中匹配value的次数

l1.count(13)
1         #在l1列表中匹配13的次数，有1次
l1.count(15)
0         #在l1列表中匹配15的次数，有0次

l1[1]

时间复杂度：O(1)

l1[1]
1         #一次定位到结果

list赋值======队列不动，内容替换

l1[3] = l1[3] + 10    把l1中的3位置加10再赋值给l1的3位置
print(l1[3])
13

len() （查队列长度）

时间复杂度：O(1)

list长度属性，加元素+1，减元素-1

返回列表元素的个数

len(l1)
10        #队列的长度是10

append(object) -> None（尾部追加）

时间复杂度：O(1)

列表尾部追加元素，返回None
返回None就意味着没有新的列表产生，就地修改

l1.append(3) #尾部追加1个3元素
[0, 1, 2, 13, 4, 5, 6, 7, 8, 9, 0, 1, 2, 13, 4, 5, 6, 7, 8, 9, 3]
l1.append([1,2,3,5,5,6])
l1
[111, 222, 333, 444, 555, 0, 1, 2, [1, 2, 3, 5, 5, 6]]
#与l1.extend([3,4,5,6,7,8])相比较，append是把整个列表加到l1后面

insert(index, object) -> None（在索引位置插入元素）

时间复杂度：O(n)

在指定的索引index处插入元素object
返回None就意味着没有新的列表产生，就地修改

l1.insert(2,2222)
[33123, 1235, 2222, 345, 4556, 7567]

extend(iteratable) -> None（扩展）

将可迭代对象的元素追加进来，返回None
就地修改

l1.extend(range(3))
l1
[111, 222, 333, 444, 555, 0, 1, 2]
l1.extend([3,4,5,6,7,8])  
l1
[111, 222, 333, 444, 555, 0, 1, 2, [1, 2, 3, 5, 5, 6], 3, 4, 5, 6, 7, 8]
#与 l1.append([1,2,3,5,5,6])相比较extend把列表拆开，把元素插入到l1列表；

+ -> list (列表相加吃内存)

空间复杂度大

连接操作，将两个列表连接起来
产生新的列表，原列表不变
本质上调用的是__add__()方法

l1 = [7,8,9]
l2 = [1,2,3,4]
l1 + l2
[7, 8, 9, 1, 2, 3, 4]

* -> list （乘、几倍）

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

l3 = [3,4,5] * 3
[3, 4, 5, 3, 4, 5, 3, 4, 5]
l3 = [[3,4,5]] * 3
[[3, 4, 5], [3, 4, 5], [3, 4, 5]

remove(value) -> None （列表内找到值然后删除）

时间复杂度：O(n)

从左至右查找第一个匹配value的值，移除该元素，返回None
就地修改

l1
[7, 8, 9]
l1.remove(7)
[8, 9]

pop([index]) -> item (索引处弹出元素)

时间复杂度：O(1)

不指定索引index，就从列表尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误

l3
[[3, 4, 5], [3, 4, 5], [3, 4, 5]]
l3.pop(2)
[3, 4, 5]
l3
[[3, 4, 5], [3, 4, 5]]

clear() -> None （引用计数都减1）

清除列表所有元素，剩下一个空列表

l1.clear()
l1
[]

reverse() -> None（反转）

将列表元素反转，返回None
就地修改

sort(key=None, reverse=False) -> None(排序)

对列表元素进行排序，就地修改，默认升序
reverse为True，反转，降序
key一个函数，指定key如何排序
lst.sort(key=functionname)
同类型进行比较

l2.append('8')
l2
[1, 2, 3, 3, 4, 5, 7, 9, '8']
l2.sort(key=int,reverse=False)    #key=int（把str变成int类型，reverse，True反转，False，不反转）
l2
[1, 2, 3, 3, 4, 5, 7, '8', 9]     #key不影响元素本身，只参与到比较中

l2.append('a')                     #插入一个str
l2.sort(key=str,reverse=False)  
l2
[1, 2, 3, 3, 4, 5, 7, '8', 9, 'a'] #安照askii码比较   

in

[3,4] in [1, 2, [3,4]]
for x in [1,2,3,4]
l2
[1, 2, 3, 3, 4, 5, 7, '8', 9, 'a']
[12,123,5213] in l2
False

copy() -> List

shadow copy返回一个新的列表
影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已

例如:

copy模块提供了deepcopy

import copy

l2 = [1,[2,3],4,5]
l1 = copy.deepcopy(l2)
l1
[1, [2, 3], 4, 5]
l1[1][1] = 100
l1
[1, [2, 100], 4, 5]
l2
[1, [2, 3], 4, 5]