Python笔记-4-内置数据结构-列表

数据类型

数值：都是类class，每个数字都是对象（类的实例）

int
float
complex
bool:True,False

序列对象：

字符串str
列表list
元组tuple

键值对：

集合set
字典dict

类型转换（built-in）

int(x)
float(x)
complet(x),complex(x,y)
bool(x):不是转换成Ture，就是转换成False
import math
math.floor()地板，向左取整 // 整除, 正数负数都往左走，floor
math.ceil()天花板，向右取整
round()四舍，六入，五取偶（取离他最近的偶数）
int()向0取整，其实也就是保留整数位

数字处理

min()，可迭代对象
max()
pow(x,y) = x**y
math.sqrt()
进制函数，返回字符串
bin()
oct()
hex()
0x
0o
math.pi = π
math.e 自然底数
type(obj) 类型判断，返回的是一个类型，不是字符串
isinstance(对象obj,类class) 判断某个对象是不是某各类的实例
isinstance(对象obj,元组(类class1,类class2,类class3)) 判断某个对象是不是属于这些类中的某一个
（说明元组是可迭代对象）
（数值）隐式类型转换：只做数值类型之间的隐式类型转换，不同数值类型相互计算时向最大范围的数值类型转换

列表（list）

是一个排列整齐的队伍
个体是元素，元素可以是任意对象（数字，字符串，对象，列表）
元素有顺序，可以使用索引，0开始
线性数据结构
使用[ ]表示
列表是可变的
列表list、链表chain、队列queue、栈stack的差异
定义列表：
list()
[ ]
list(iterable) 将一个可迭代对象一个一个加入list
注意，列表本身是可迭代对象，而且可以索引
不需要定义大小，也不能定义大小

列表的索引：

下标索引
正索引，0开始标，且不能越界，否则引发异常IndexError
负索引，从右到左-1开始
list[index]使用索引

列表的查询,对象方法

list.index(value,[start,[stop]])
匹配第一个找到的值，返回索引，匹配不到就返回ValueError
list.count(value)
返回匹配value的次数
时间复杂度index、count都是O(n),效率随规模增大而效率下降
len(obj) 返回列表元素的个数，返回容器中的项目数
帮助查询help（变量，对象，类名，函数名，方法名）

列表元素修改

list[index]=value 不能越界

列表增加、插入元素

list.append(obj)尾部追加 返回->None
时间复杂度是O(1)
list.insert(index,obj)在索引处插入obj 返回->None
超越上限尾部追加，超越下限头部追加
时间复杂度是O(n)
list.extend(iterable) -> None
将ite追加到后面
+-> new list
链接操作，将两个列表连接起来，原列表不变，产生新列表，本质上是调用的add()魔术方法
*-> new list 用于一次性开辟足够的空间
重复操作，将本列表重复n次，返回新列表
坑！：[[1,2]]4形成二维数组
注意，复杂类型(嵌套)在列表中储存的是地址，4表示的是地址*4，在改动某个内容如[0][0]时，三个被复制的地址都改变了
简单类型暂时不受影响，但是我觉得肯定没那么简单，但是现在学的知识解决不了。。。

列表元素删除

list.remove(value) -> None
查找第一个匹配到value的值，移除，O(n)
list.pop([index]) -> item
默认从尾部得到一个元素
指定index，从索引处弹出一个元素，越界InexError，(弹出+挪动，O(n))
list.clear() -> None
清楚所有元素，剩下一个空列表

其他操作

list.reverse() -> None (原地操作)
列表元素自身反转，返回None
reverded（），内置函数，返回列表反转的迭代器，迭代器可以迭代，for打印
迭代器的优势就是用的时候再迭代使用，不用的时候也不占空间
list.sort(key=None,reverse=False)->None就地修改
将列表排序，默认为升序
reverse为True，反转，降序
key传入一个函数名，指定key如何排序，list(ket=FunName) 将每个元素在函数里调用, 按结果排序, 排序后还是原来的值
key=str 转换成字符串排序
key=int 转换成整数数值排序
给key传入的是一个函数名，利用这个函数处理每个值，然后将得到的结果排序，
当然，原来的元素值不变，可以想象，该函数可以实现很多复杂的功能！
sorted(iterable,key=?,reverse=?) -> new list,内建函数
in
A in [b,B,A,a]
检查一个元素在不在列表里,True False

列表复制

==比较的是内容
=复杂结构是引用赋值，复制的是地址
list.copy() -> shadow copy返回新列表
对于list本身,复制以后地址不同，内容相同，不再相互影响
注意：如果列表中有复杂的引用元素，复制的还是复杂元素的地址,因为复杂元素这个位置上地址就是该复杂对象的引用地址，一方发生改变时都改变，与之前乘法原理相同

浅拷贝shadow copy
遇到引用类型也只是复制了一个引用，其实没毛病，怪就怪在你自己要复制引用
深拷贝 from copy import deepcopy
将所有内容完全复制
deepcopy(x) -> 返回a deepcopy of x
id(检查对象地址)
数据结构的方法很多，但是用的时候一定要考虑效率
函数积累