python基础--数据类型

len()

返回字典的长度，是键的个数，也是值的个数，也是键值对的个数。空字典长度为0

len({'a':1,'b':2}) #2len({}) #0

any()

类似于对列表、元组的操作，不过函数检验的是字典的键。any():只要字典有一个键为True则返回True

any({'':1,0:'abc',False:111}) #Falseany({'a':1,0:'abc',False:111}) #Trueany({}) #False

all()

all():只有字典的所有键都为True才返回True

all({'':1,0:'abc',False:111}) #Falseall({'a':1,0:'abc',False:111}) #Falseall({}) #True,没有键却认为所有键都为True

sorted()

把字典的所有key当做一个列表(或元组)进行排序

sorted({'a':1,'c':3,'b':4}) #['a','b','c']

keys()

返回键(key)(类型是dict_keys)。这个view对象可以动态查看字典内部的对象，当字典改变后，这个view对象也会反应变化

d1 = dict(a=1,b=2,c=3,d=4)kk = d1.keys()type(kk) #<class 'dict_keys'>for k in kk: print(k) #a b c dd1['e'] = 5 #修改了字典for k in kk: #没有重新获取kk,但kk已经发生了变化 print(k) #a b c d e

values()

返回值(values)(类型是dict_values)。

d1 = dict(a=1,b=2,c=3,d=4)vv = d1.values()type(vv) #<class 'dict_values'>for v in vv: print(v) #1 2 3 4d1['e'] = 5for v in vv: print(v) #1 2 3 4 5

items()

返回键值对(key-value)(类型是dict_items)

d1 = dict(a=1,b=2,c=3,d=4)ii = d1.items()type(ii) #<class 'dict_items'>for i in ii: print(i) #('a',1) ('b',2) ('c',3) ('d',4)d1['e'] = 5for i in ii: print(i) #('a',1) ('b',2) ('c',3) ('d',4) ('e',5)

get()

获取key对应的value，可设置默认值

d1 = dict(a=1,b=2,c=3,d=4)d1.get('a') #1d1.get('lili',100) #100

clear()

清空一个字典

d1 = dict(a=1,b=2,c=3,d=4)d1.clear() #{}

copy()

在Python中，把列表、字典对象赋值给变量时，都是“浅拷贝”，即变量指向了对象，原来的对象改变了，这个变量的值也会跟着变。而copy()函数是“深拷贝”，重新创造一个新的对象赋值给变量，原来的对象的改变不影响新对象。

>>> d1 = {'a':1}>>> d2 = d1 #浅拷贝>>> d3 = d1.copy() #深拷贝>>> d1['b'] = 2 #改变原来字典>>> d1{'a': 1, 'b': 2}>>> d2 #d2也跟着改变{'a': 1, 'b': 2}>>> d3 #深拷贝d3还是原来的值{'a': 1}

pop(key)

删除key及其所对应的值，返回值为被删除键所对应的值。

>>> d1 = {'a': 1, 'b': 2}>>> d1.pop('a')1>>> d1{'b': 2}

popitem()

随机删除字典中一对键和值，返回值为被删除的键值对

>>> d1 = {'a':1,'b':2,'c':3}>>> d1.popitem()('c', 3)>>> d1{'a': 1, 'b': 2}

fromkeys(seq,[val])

创建一个字典，以序列seq中元素做字典的键，val(可选)为字典所有键对应的值

>>> d = {}>>> d.fromkeys([1,2,3]){1: None, 2: None, 3: None}>>> d.fromkeys([1,2,3],1){1: 1, 2: 1, 3: 1}

update()

用一个字典来更新另一个字典

>>> d = d.fromkeys([1,2,3],0)>>> d{1: 0, 2: 0, 3: 0}>>> d.update({1:10,2:20})>>> d{1: 10, 2: 20, 3: 0}

列表合并在一起

['a', 'b', 'c'] + [1, 2, 3]

['a', 'b', 'c', 1, 2, 3]

*

列表重复 ['a'] * 3

['a'] * 3

['a', 'a', 'a']

in

是否为列表元素

'a' in ['a', 'b']

True

len()

计算列表长度，即计算列表中元素个数

len([1,2,3]) #3

max()

返回列表元素中最大值，列表元素必须是同一类型且可比较，比如都是数字型或都是字符串，如果类型不统一就会报错。

max(['a','b','c']) #c

min()

返回列表元素中的最小值。元素类型要求跟max()一样。

min([1,2,3]) #1min(['a','b','c']) #a

sum()

计算列表所有元素的和，其元素类型必须是数值型的（整数、浮点数）

sum([1,2,3]) #6

sorted()

返回一个排序的列表，但并不改变原列表。

sorted([1,0,-1,4]) #[-1, 0, 1, 4]sorted(['ab','da','c','f']) #['ab', 'c', 'da', 'f']

list()

生成一个空列表，或把其它类型数据转换成list。

list() #[]list('python') #['p', 'y', 't', 'h', 'o', 'n']

any()

只要列表中有一个元素是True就返回True

any([0,1,'']) #True

all()

只有列表所有元素为True才返回True

all([0,'','2']) #Falseall([1,'a','2']) #True

append()

把一个元素加到列表尾部

L = ['a','b','c','a','d','a'];L.append('A');print(L)

L变为['a','b','c','a','d','a','A']

insert()

把一个元素插到列表指定位置

L = ['a','b','c','a','d','a'];L.insert(1,'A');print(L)

L变为['a','A','b','c','a','d','a']

remove()

删除列表中某个值的第一个匹配项

L = ['a','b','c','a','d','a'];L.remove('a');print(L)

L变为['b','c','a','d','a']

pop()

删除列表中指定位置元素(默认最后一个元素)

L = ['a','b','c','a','d','a'];L.pop(2);print(L)

L变为['a','b','a','d','a']

clear()

清空列表

L = ['a','b','c','a','d','a'];L.clear();print(L)

L变为[]

index()

从列表中找出某个值第一个匹配项的索引位置

L = ['a','b','c','a','d','a'];print(L.index('a'))

0

count()

统计某个元素在列表中出现的次数

L = ['a','b','c','a','d','a'];print(L.count('a'))

3

sort()

对原列表进行排序

L = ['a','b','c','a','d','a'];L.sort();print(L)

L变为['a','a','a','b','c','d']

reverse()

将列表倒置

L = ['a','b','c','a','d','a'];L.reverse();print(L)

L变为['a','d','a','c','b','a']

合并在一起

('a', 'b', 'c') + (1, 2, 3)

('a', 'b', 'c', 1, 2, 3)

*

重复

('a',) * 3

('a', 'a', 'a')

in

是否为元素

'a' in ('a', 'b')

True

len()

计算元组长度，即计算元组中元素个数

len((1,2,3)) #3

max()

返回元组元素中最大值，元组元素必须是同一类型且可比较，比如都是数字型或都是字符串，如果类型不统一就会报错。

max(('a','b','c')) #c

min()

返回元组元素中的最小值。元素类型要求跟max()一样。

min((1,2,3)) #1min(('a','b','c')) #a

sum()

计算元组所有元素的和，其元素类型必须是数值型的（整数、浮点数）

sum((1,2,3)) #6

sorted()

返回一个排序的元组，但并不改变原元组。

sorted((1,0,-1,4)) #(-1, 0, 1, 4)sorted(('ab','da','c','f')) #('ab', 'c', 'da', 'f')

tuple()

生成一个空元组，或把其它类型数据转换成元组。

tuple() #()tuple('python') #('p', 'y', 't', 'h', 'o', 'n')

any()

只要元组中有一个元素是True就返回True

any((0,1,'')) #True

all()

只有元组所有元素为True才返回True

all((0,'','2')) #Falseall((1,'a','2')) #True

index()

从元组中找出某个值第一个匹配项的索引位置

T = ('a','b','c','a','d','a');print(T.index('a'))

0

count()

统计某个元素在元组中出现的次数

T = ('a','b','c','a','d','a');print(T.count('a'))

3

len()

返回集合长度，即集合包含的元素个数，空集合长度为0

>>> len({'a','b','c'})3>>> len({})0

any()

类似于对列表、元组的操作any():只要集合有一个元素为True则返回True

>>> any({'',0,False})False>>> any({'a',0,False})True>>> any({})False

all()

all():只有集合的所有元素都为True才返回True

>>> all({'',0,False})False>>> all({'a',0,False})False>>> all({})True

sorted()

跟操作列表、元组效果一样，它把集合的所有元素进行排序

>>> sorted({'d','b','a','c'})['a', 'b', 'c', 'd']

add(x)

把对象x添加到集合中

>>> s = {'a','b','c'}>>> s.add(1)>>> s{1, 'a', 'b', 'c'}

update()

把多个对象添加到集合中

>>> s = {'a','b','c'}>>> s.update([1,2,3])>>> s{1, 2, 3, 'c', 'a', 'b'}>>> s.update(['x','y'],{8,9})>>> s{1, 2, 3, 8, 9, 'c', 'x', 'a', 'b', 'y'}

discard(x)remove(x)

两个都是从集合中删除一个元素x,不同的是，如果x不在集合中，discard()会忽略；而remove()会抛出KeyError错误

>>> s = {'a','b','c'}>>> s.discard('a') #删除a>>> s{'b', 'c'}>>> s.remove('c') #删除c>>> s{'b'}>>> s.discard('x') #删除x,集合中没有x,忽略>>> s.remove('x') #删除x,集合中没有x,报错Traceback (most recent call last): File "<stdin>", line 1, in <module>KeyError: 'x'

pop()

类似于字典和列表中pop(),都是从其中删除一个元素并返回该元素。因为集合没有key和索引的概念，所以集合pop()不带参数。

>>> s = {'a','b','c'}>>> s.pop()'a'>>> s{'b', 'c'}

clear()

清空一个集合

>>> s = {'a','b','c'}>>> s.clear()>>> sset()

copy()

跟字典中的copy()一样，返回一个集合的深拷贝

>>> s1 = {'a','b','c'}>>> s2 = s1.copy()>>> s2{'a', 'b', 'c'}>>> s1.add(1)>>> s1{1, 'a', 'b', 'c'}>>> s2{'a', 'b', 'c'}

union()

求两个或多个集合的并集

>>> s1 = {'a','b','c'}>>> s2 = {1,2,3}>>> s1.union(s2){1, 'a', 2, 3, 'b', 'c'}

intersection()

求两个多多个集合的交集

>>> s1 = {'a','b','c'}>>> s2 = {'a','b',1,2}>>> s1.intersection(s2){'a', 'b'}

difference()

求一个集合与另一个或多个集合的差集，相当于集合减法

>>> s1 = {'a','b','c'}>>> s2 = {'a','b',1,2}>>> s1.difference(s2) #返回s1包含却不在s2中的元素组成的集合{'c'}>>> s2.difference(s1)#返回s2包含却不在s1中的元素组成的集合{1, 2}

symmetric_difference()

两个集合中除去交集之外的元素集合

>>> s1 = {'a','b','c'}>>> s2 = {'a','b',1,2}>>> s1.symmetric_difference(s2){1, 2, 'c'}

intersection_update()

同intsersection()一样求得新集合，但此方法改变调用它的对象

>>> s1 = {'a','b','c'}>>> s2 = {'a','b',1,2}>>> s1.intersection(s2){'a', 'b'}>>> s1 #s1不变{'a', 'b', 'c'}>>> s1.intersection_update(s2)>>> s1 #s1发生了变化{'a', 'b'}

difference_update()

同difference()一样求得新集合，并用新集合改变调用该方法的集合。

>>> s1 = {'a','b','c'}>>> s2 = {'a','b',1,2}>>> s1.difference(s2){'c'}>>> s1 #s1不变{'a', 'b', 'c'}>>> s1.difference_update(s2)>>> s1 #s1发生了变化{'c'}

symmetric_difference_update()

同symmetric_difference()一样求得新集合，并用新集合改变调用该方法的集合

>>> s1 = {'a','b','c'>>> s2 = {'a','b',1,2}>>> s1.symmetric_difference(s2){1, 2, 'c'}>>> s1{'a', 'b', 'c'}>>> s1.symmetric_difference_update(s2)>>> s1{1, 2, 'c'}--------------------- 版权声明：本文为CSDN博主「Aamax」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/xjtuse123/article/details/90519146

isdisjoint()

如果两个集合没有交集则返回True

>>> s1 = {'a','b','c'}>>> s2 = {1,2,3}>>> s1.isdisjoint(s2)True

issubset()

判断一个集合是不是另一个集合的子集

>>> s1 = {'a','b','c'}>>> s2 = {'a'}>>> s2.issubset(s1)True

issuperset()

判断一个集合是不是另一个集合的超集

>>> s1 = {'a','b','c'}>>> s2 = {'a','b'}>>> s1.issuperset(s2)True