3内置数据结构_数值_列表

叁歲伎倆 2022-01-10 22:59 234阅读 0赞

内置数据结构

帮助：

手册中找关键字；

help(keyword)，keyword可以是变量、对象、类名、函数名、方法名；

分类：

数值型：int,float,complex,bool；

sequence序列对象：str,list,tuple；

键值对：set集合（约定set为集，collection为集合类型），dict字典；

数值型：

int,float,complex,book都是class，1,5,0,2+3j都是对象（即实例）；

int，python3的int就是长整型，且没有大小限制（没有上限，指进程寻址的最大内存区域），受制于内存区域的大小；

float，由整数部分和小数部分组成，支持十进制和科学计数法表示，只有双精度型，通常浮点数比较时用<,>，不能用==（注：浮点数并不能完全准确的表达我们指定的小数，只能说近似表达）；

complex，复数，由实数部分和虚数部分组成，实数部分和虚数部分都是浮点数，如3+4.2j；

bool，int的子类（类似哺乳类下的人类），仅有2个实例True（对应1），False（对应0），可以和整数直接运算；

类型转换：

int(x)，返回一个整数；

float(x)，返回一个浮点数；

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

bool(x)，返回布尔值；

数字的处理函数：

round()，不是四舍五入，是四舍六入五取偶，银行家算法，其它语言的round()也一样；

math.floor()，地板，向下取整；

math.ceil()，天花板，向上取整；   \#django.core.paginator.Paginator中Paginator.num\_pages用到

int()，取整数部分，和//整除一样；

min()；

max()；

pow()，等于x\*\*6；

math.sqrt()，开平方；

bin()，进制函数，返回值是字符串；

oct()，进制函数，返回值是字符串；

hex()，进制函数，返回值是字符串；

math.pi，取PI；

math.e，自如常数；

例：

In \[1\]: round(1.4)

Out\[1\]: 1

In \[2\]: round(1.5)

Out\[2\]: 2

In \[3\]: round(1.6)

Out\[3\]: 2

In \[4\]: round(2.6)

Out\[4\]: 3

In \[5\]: round(2.5)   \#四舍六入五取偶

Out\[5\]: 2

In \[6\]: import math

In \[7\]: math.floor(2.5)

Out\[7\]: 2

In \[8\]: math.ceil(2.5)

Out\[8\]: 3

类型判断：

type(obj)，返回类型，而不是字符串；

isinstance(obj,class\_or\_tuple)，返回布尔值；

例：

In \[9\]: a=1

In \[10\]: type(a)

Out\[10\]: int

In \[11\]: type(type(a))

Out\[11\]: type

In \[12\]: type(a)==int

Out\[12\]: True

In \[13\]: isinstance(a,int)   \#类继承时使用

Out\[13\]: True

In \[14\]: type(1+True)

Out\[14\]: int

In \[15\]: type(1+True+2.0)   \#有隐式转换，int和float都是数值型，可理解为这俩是表亲；

Out\[15\]: float

list：

一个队列，一个排列整齐的队伍（有序）；

列表内的个体称作元素（item或element），由若干元素组成列表；

元素可以是任意对象（数字、字符串、对象、列表）；

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

线性的数据结构；

使用\[\]表示；

列表是可变的；

list列表、链表、queue队列、stack栈的差异：

list，有序的整齐排列；

![1.jpg][]

链表（元素手拉手在一起，不是网状，在内存中零散的存放，不能用索引）；

![2.jpg][]

queue（先进先出或后进先出，可用list模拟queue）；

stack（压栈，后进先出，撂盘子）；

![3.jpg][]

注：

赋值即定义（动态语言与静态语言的差别）；

list定义，初始化：

list()，new empty list；

list(iterable)，new list initialized from iterable's item，如lst=list(5)不可以，必须是可迭代对象，list()里要么放可迭代对象，要么什么都不放；

列表不能一开始就定义大小；

例：

In \[16\]: lst=list()   \#工厂方法定义

In \[17\]: lst=\[\]

In \[18\]: lst=\[2,6,9,'ab',None\]   \#通常用此种，定义和初始化一起搞

In \[19\]: lst=list(range(5))

In \[21\]: lst

Out\[21\]: \[0, 1, 2, 3, 4\]

In \[22\]: \_   \#仅在ipython中使用此变量，返回上一次输出

Out\[22\]: \[0, 1, 2, 3, 4\]

list索引访问：

索引也叫下标，列表通过索引访问，list\[index\]，使用\[\]访问；

正索引，从左至右，从0开始，为列表中的第一个元素编号；

负索引，从右至左，从\-1开始；

正负索引不可以超界，否则引发异常IndexError；

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

list查询：

index(value,\[start,\[stop\]\])，通过value，从指定区间查找列表内的元素是否匹配；匹配第一个就立即返回索引；从左至右，从右至左，返回的索引值是不一样的，通常从右至左找更快更便利，如在给定路径中找文件名；匹配不到，抛出异常ValueError；

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

时间复杂度：

O(1)，性能最好；

O(n),O(n\*\*2)，随着列表数据规模的增大而效率下降；

index()和count()都是O(n)；

如何返回列表元素的个数？如何遍历？如何设计高效？len(lst)，len()是公共内置函数，O(1)，增删list元素时记录着该list的类似元数据信息；

空间复杂度：生产中，尤其是vm中要考虑；

list元素修改：

lst\[index\]=value，索引访问修改，索引不要超界；

list增加插入元素：

append(object)-->None，列表尾部追加元素，返回None；返回None就意味着没有新的list产生，就地修改；时间复杂度O(1)；

insert(index,object)-->None，在指定的index处插入元素object；返回None，就地修改；时间复杂度O(1)，该方法少用，若在头部或中间插入，整个内存中的元素需移动；

索引能超上下界吗？超越上界，尾部追加，超越下界，头部追加；

extend(iterable)-->None，将可迭代的元素追加进来，返回None，就地修改；

\+-->list，连接操作，将两个list连接起来，产生新的list，原list不变；本质上调用的是\_\_add\_\_()方法；

\*-->list，重复操作，将本list元素重复n次，返回新的list；

注：

返回若不是None，将有特殊的编程方式；

list不适用insert元素，头或中间插入时需要挪动，链表适合insert；

list删除元素：

remove(value)-->None，从左至右查找第一个匹配value的值，移除该元素返回None，就地修改；效率？不高；

pop(\[index\])-->item，若不指定index就从list尾部弹出一个元素；指定index，就从索引处弹出指定元素；索引超界，抛出IndexError；效率？移除尾部元素效率高，不是尾部不要用；指定索引的时间复杂度？不指定索引的时间复杂度？

clear()-->None，清除列表的元素，剩下一个空列表；元素量大时会引起GC；

list其它操作：

reverse()-->None，将列表元素反转，返回None，就地修改，少用；

sort(key=None,reverse=False)\-->None，对列表元素进行排序，就地修改，默认升序，少用；reverse为True，反转，降序；key（高阶函数）指定一个函数，用于自定义排序；

in，not in，返回bool型；

例：

In \[23\]: lst=\[1,2,3,4\]

In \[24\]: lst.sort(reverse=True)   \#注意关键字参数，就地修改

In \[25\]: lst

Out\[25\]: \[4, 3, 2, 1\]

In \[26\]: lst.append('a')

In \[27\]: lst.sort(key=str)   \#把每个元素都转为str，按ASCII码排序

In \[28\]: lst

Out\[28\]: \[1, 2, 3, 4, 'a'\]

In \[29\]: lst.sort(key=str,reverse=True)

In \[30\]: lst

Out\[30\]: \['a', 4, 3, 2, 1\]

列表复制（深浅拷贝）：

在构造嵌套结构的列表时要注意；

==是值比较，内容是否相同；

is是比较内存地址，相当于先取id()再比较；

copy()-->list，shadow copy，影子拷贝，浅拷贝，返回一个新列表，遇到引用类型，只是复制了一个引用，列表如果有嵌套则拷贝的是嵌套列表的内存地址，内层相当于在引用；

深拷贝，copy模块提供了deepcopy()，copy.deepcopy()；

例：

In \[35\]: lst0=list(range(4))

In \[36\]: lst1=list(range(4))

In \[37\]: lst0==lst1   \#但lst\[0\] is lst\[1\]结果为False

Out\[37\]: True

In \[38\]: lst2=lst0

In \[39\]: lst2\[2\]=10

In \[42\]: lst2==lst1

Out\[42\]: False

In \[44\]: lst0

Out\[44\]: \[0, 1, 10, 3\]

In \[45\]: lst1

Out\[45\]: \[0, 1, 2, 3\]

In \[46\]: lst2

Out\[46\]: \[0, 1, 10, 3\]

In \[47\]: id(lst0)   \#lst2引用lst0，这俩指向同一个内存地址

Out\[47\]: 139655179771656

In \[48\]: id(lst2)

Out\[48\]: 139655179771656

例：

In \[50\]: lst3=list(range(4))

In \[51\]: lst4=lst3.copy()

In \[52\]: lst3==lst4

Out\[52\]: True

In \[53\]: lst3 is lst4

Out\[53\]: False

In \[54\]: lst3\[2\]=10

In \[55\]: lst3==lst4

Out\[55\]: False

例：

In \[71\]: lst5=\[1,\[2,3,4\],5\]

In \[72\]: lst6=lst5.copy()

In \[73\]: lst5==lst6

Out\[73\]: True

In \[74\]: lst5\[1\]\[1\]=8

In \[75\]: lst5==lst6   \#注意，返回True，lst6是lst5的拷贝，对于嵌套结构只copy()了引用

Out\[75\]: True

In \[76\]: lst5 is lst6

Out\[76\]: False

In \[77\]: lst5

Out\[77\]: \[1, \[2, 8, 4\], 5\]

In \[78\]: lst6

Out\[78\]: \[1, \[2, 8, 4\], 5\]

![4.jpg][]

例：

In \[1\]: import copy

In \[2\]: lst0=\[1,\[2,3,4\],5\]

In \[3\]: lst1=copy.deepcopy(lst0)

In \[4\]: lst1\[1\]\[1\]=8

In \[5\]: lst0==lst1

Out\[5\]: False

In \[6\]: lst0 is lst1

Out\[6\]: False

随机数：

random模块；

random.randint(a,b)，返回\[a,b\]之间的整数，两边都是闭区间（不同于range(a,b)，\[a,b)前包后不包）；

random.choice(seq)，从非空序列的元素中随机挑选一个元素，如random.choice(range(10))，从0-9中挑选一个整数，random.choice(\[1,3,5,7\])；

random.randrange(\[start,\]stop\[,step\])，同range()，从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1，如random.randrange(1,7,2)，返回1,3,5中的一个；

random.shuffle(list)-->None，就地打乱列表元素；

测试效率：

\#作性能测试时把print()语句注释掉，否则影响较大；

import datetime

start = datetime.datetime.now()

code segment

stop = datetime.datetime.now()

delta =(stop-start).total\_seconds()

print(delta)

转载于:https://blog.51cto.com/jowin/2388524

[1.jpg]: https://s1.51cto.com/images/20190503/1556861255659416.jpg?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=
[2.jpg]: https://s1.51cto.com/images/20190503/1556861263411222.jpg?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=
[3.jpg]: https://s1.51cto.com/images/20190503/1556861270970437.jpg?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=
[4.jpg]: https://s1.51cto.com/images/20190503/1556861290306517.jpg?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=