Python3组合数据类型(元组、列表、集合、字典)语法

 

一、序列类型(字符串,元组(),列表[])

 

序列类型支持in,len(),分片[],迭代,5种内置序列类型:bytearray,bytes,list,str,tuple(元组)。

1、元组可以嵌套(如:x=str[2][1][0][1])

2、元组的命名(collections.namedtuple(),即自定义)

       样:sale=collctions.namedtuple("sale","productid customerid date price") 逗号前的为元组类型的名称,逗号后的参数为字符串,用空格分隔,每个名称都代表该元组数据类型的一项,数据项如:x=sale(121,"2017-03-22",1,10.99);调用某一项则可用x.price来实现,此处结果为10.99;

       对于格式化替换,可用**namedtuple._asdict()函数实现直接用名称替换索引,如:"{productid}{price}".format(**x._asdict())。此方法用于多层元组较好,name即为最外层元组的name.

       单个元素的元组需要加上逗号。

3、列表

       1>列表也可存储任意类型的数据,且可使用比较操作符(逐项进行比较)和修改列表内容。

       2>列表支持元组的所有操作,同时还有以下函数:

       append()  追加

       count(x)  统计x出现的次数

       index(x,start,end)找x,如没有则产生一个ValueError,

       extend()    (等同于+=),

       insert(i,x)  (在索引位置i处插入x),

       pop()    移除最后一项

       pop(i)    (移除i索引位置处的数据项,如没有i值,则默认移除最后一项),

       remove(x)  (移除从左边开始出现的第一个数据为x的项,如没有则返回一个ValueError),

       reverse()    反转,

       sort()     排序。

       对序列特定位置进行赋值可以对列表中单个数据进行替换修改(x[1]=2;x[1:2]=[a,b],对片进行替换时新数据项的个数不一定要等于原数据项的个数,可以是任意个数,结果都是新的分片替换已选定的分片,如果新的替换分片为空,就相当于删除了已选定的原分片),del x[1:2]也可以起到删除这一分片的效果(不过del其实是解除了这一数据项与变量之间的绑定)。

       3>用*对序列进行拆分赋值

       样:a,*b,c=[1,2,3,4,5,6]  -> a,b,c=(1, [2, 3, 4, 5], 6)

       数据项按位置依次经变量赋值,然后将剩余的所有数据都赋给带有*号的变量。*的作用就是将一个iterable进行拆分.

       “*”的另一个作用是复制操作符,其效果相当于乘号,不过对象不限于数字,可以为任何对象。

       4>列表内涵(用于创建一些含有大量数据的列表)

       [expression for item in iterable](对iterable中每个数据项进行expression操作)

       [expression for item in iterable if condition],对限定条件的对象进行操作。

       例:leaps=[y for y in range(1900,2000) if (y%4==0 and y%100!=0)or(y%400==0)] 计算闰年。(range同样为前闭后开)

       列表内涵的多变量嵌套:

       例:cods=[s+z+c for s in "MF" for z in "SMLX" for c in "BGW"

              if not(s=="F" and z=="X")]相当于三层叠加的for循环.

 

二、集合类型(set)({})

 

  set支持 in ,len(),比较,位逻辑操作符;并且也是iterable的。只有可hash运算的对象才可以添加到集合中。所有内置的固定数据类型(float,frozenset,int,str,tupul...)都是可hash运算的。内置的可变数据类型(如:dict,list,set)都不是可hash运算的。

  创建一个集合可用set("a","b",3),且创建一个空集合必须用set()。集合创建时可以存在两个相同的项,但没意义,最终形成的集合只会保留一个。

例:s={2,"veil",("a",5),frozenset({8,4,7}),"a"}

  集合是没索引位置区分的,也不能分片或按步距分片。集合中每个数据都是独一无二的,所以集合常被用于删除重复的数据项(x=list(set(x)))。

1、集合常用函数:

       s.add(x)  添加x到集合s中;

       s.clear()  清空;

       s.pop()    移除集合中任意一项,如果为空了则返回产生KeyError异常;

       s.remove(x) 移除x项,如x不存在就产生KeyError异常;

       s.discard(x)  如果x 存在就移除掉该项;

       s.copy()   浅拷贝;  *

       s.different(t)s-t  返回一个新集合,其只包含s但不在集合t中;  *

       s.difference_update(t)s-=t  移除每一个在集合t但不在s中的项;

       s.intersection(t)s&t     返回s和t的交集;  *

2、集合联合操作运算符结果:

       s|t,合集;s&t,交集;s-t,减去与t的交集;s^t,合集减去交集。

3、集合内涵(同列表内涵)

       {expression for item in iterable}

       {expression for item in iterable if condition}

4、固定集合(frozenset())

       一旦创建了就不可改变,同static,可用的函数只有那些不改变集合本身内容的函数(上已用*标注)。

 

三、映射类型(dict)

 

映射是键-值数据的无序组合。内置的映射类型有:dict(),collections.defaultdict();对于3.1以上的还有collections.OrderedDict(),它同dict()一样,不过有索引序列。

映射的键只有可hash运算的类型才可使用,而值则可使用任意类型的数据。

1、字典的创建

d=dict(id=1948,name="washer",size=3)  #关键字参数

d={"id":1948,"name":"washer","size":3}   #面值

d=dict({"id":1948,"name":"washer","size":3})    #面值

d=dict([("id",1948),("name","washer"),("size",3)])  #序列

d=dict(zip(("id","name","size"),(1948,"washer",3)))  #序列

{}或用d=dict()来创建一个空字典

2、使用d["id"]则返回相应的值,如果此键不存在,则产生一个KeyError.

d["xx"]=34可添加一个项,如果此键已经存在,则会修改原始的值。

del d["xx"]会删除键为"xx"的项,如果不存在则产生一个KeyError。

3、常用函数(全)

       d.clear()  清空

       d.copy()  浅拷贝

       d.pop(k,v) 返回k的值,并删除k项,如果k不存在,就返回KeyError或者v(如v存在的话)

       d.popitem() 移除任意一对键-值,如果d为空就产生KeyError

       d.values()  返回字典中所有值的视图

       d.keys()   返回字典所有键的视图

       d.items()  返回字典所有(key,value)对的视图

       d.get(k)   返回k的值,如果k不存在就返回None

       d.get(k,v)  返回k的值,如果k不存在就返回v

       d.setdefault(k,v) 同get(),如果k不存在就插入一个k项,值为None或者v(如果给了v)

       d.fromkeys(s,v) 返回一个dict,它的键为序列s的项,值为None或者v(如果给了v)

       d.update(a) 用a更新d,如果键已存在则更新值,如不存在则插入。a可以是dict也可以是(key,value)对的一个iterable.

for

4、对字典的迭代

       对键:for key in d:    print(key)

              或:for key in d.keys():   print(key)

       对值:for value in d.values():     print(value)

       对键-值:for key,value in d.items():    print(key,value)

              或:for item in d.items():    print(item[0],item[1])

5、字典键的视图与项的视图支持一些类似于集合的操作(集合处的联合操作运算)

此可用in来查看某个键是否存在于dict,也可用联合操作运算查看特定集合的键是否存在于dict,如下:

d={}.fromkeys("ABCD",3);  s=set("ACX"); matches=d.keys()&s  #matches=={'A','C'}

6、字典内涵

{keyexpression:valueexpression for key ,value in terable}

{keyexpression:valueexpression for key ,value in terable if condition}

例:一个字典的键-值反转:inverted_d={v:k for k, v in d.items()}

7、默认字典(collectons.defaultdict())

默认字典永远不会产生KeyError,当查询的键不存在时,字典就会自动生成一个新的以此查询键为键的项,其值为创建字典时设定的默认值。

例:words=collections.defaultdict(int),新增入此字典的默认值就会是数字0。传入的int为工厂函数(也就是一个不带括号、没有参数的函数),以后可用lambda函数进行简单设置。

8、有序字典(collctions.OrderedDict())

字典的数据项以插入的顺序进行保存,如果用了一个无序的字典来进行update(),得到的结果也会变成无序的。

do=collections.OderedDict([('z',5),(3,6),(8,'a')])或者先建一个空的,再一项一项的添加。

将一个普通字典转换成有序字典:d=collections.OderedDict(sorted(d.items()))。

 

四、组合数据的迭代与复制

1、常见迭代操作符与函数:

       s+t  两个序列的连接;

       s*n  返回n个s序列的连接的序列;

       x in s  判断是否在内,not in;

       all(i)    如果iterable i中的每一项都评估为True,则返回True;

       any(i)  如果任意一项为True,则返回True;

       enumerate(i,start)通常用于for...in循环,提供一个(index,item)元组序列,其中的索引起始值为0或start;{相当于将一个序列i折分成单个,并给每个一个序列号,用(index,item),index为自动产生的序列号,item则依次为i每一项的值}

       len()   返回长度;

       max(i,key) 返回iterable i 中最大的项,如果给定的是key函数,就返回key(item)值最大的项;

       min(i,key)  同上;

       range(start,stop,step) 返回一个数字迭代子,左闭右开,如果没给start,则从0开始;

       reversed(i) 反转序列;

       sorted(i,key,reverse)   排序;reverse=True时进行逆序排列。当key存在时可以设置为需要的任意函数规则,甚至可以是自己构造的函数,如key=abs以绝对值排列,key=str.lower,以str中的lower()函数规则排序。sorted()排序只适用于所有数据项都可以进行互相比较的组合类型,如果有不同的类型则会产生一个TypeError。

       sum(i,start)  求和,start为可选

       zip(i1,...,iN)  返回元组的迭代子,使用迭代子i1到iN;i1-iN都是iterable数据组,例可参考dict的zip构造方式。只要有某个iterable中的元素用完,就终止迭代过程。

2、用a=iter(iterable结构)可以获取一个迭代子,在每次循环时可用next(a)方法获取下一个数据项,当结尾时会产生一个StopIteration异常。

3、组合数据类型的复制。

样:b="sudent",a=b   这样的用等号只是简单的将b的值赋给了a,但b的值"student"在系统内并没有被复制成2份,只是a和b都指向"student"这个值,无论是从a还是从b改变这个对象"student",另一个变量也会显示出改变后的结果。要想复制出一个"student"的副本则可以用加上类型名:a=str(b);或者分片的方式a=b[:],因为提取分片时会产生一个副本。对于字典和集合类型则用copy()函数来实现。

       以上的方法都属于浅拷贝,因为它只会复制对象的第一层内容。如果对象中还存在可变的iterable对象,它拷贝的只是iterable对象的引用地址,如果iterable从原对象改变了,拷贝对象的iterable部分也会跟着改变。如嵌套的列表:['a',['b','c']],复制此对象['b','c']部分时只是复制的一个引用地址。 如果要对此对象进行完全的复制则需用到深拷贝,import copy;       a=copy.deepcopy(b)

4、位置常量命名一般方法:WATER,TREE,MONEY=range(1,4);那么这三个字符的值依次就为1,2,3

转载于:https://www.cnblogs.com/aland-1415/p/6906437.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值