运维开发网

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

运维开发网 https://www.qedev.com 2020-03-19 13:42 出处:51CTO 作者:chaijowin
内置数据结构 帮助:手册中找关键字;help(keyword),keyword可以是变量、对象、类名、函数名、方法名; 分类:数值型:int,float,complex,bool;sequence序列对象:str,list,tuple;键值对:set集合(约定set为集,collection为集合类型),dict字典;   数值型:int,float,complex,book都是class,1,5

内置数据结构

 

帮助:

手册中找关键字;

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,有序的整齐排列;

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

链表(元素手拉手在一起,不是网状,在内存中零散的存放,不能用索引);

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

queue(先进先出或后进先出,可用list模拟queue);

stack(压栈,后进先出,撂盘子);

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

 

注:

赋值即定义(动态语言与静态语言的差别);

 

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]

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

 

例:

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)

0

精彩评论

暂无评论...
验证码 换一张
取 消