Python数据类型常用方法速查总结

数据类型

数据类型	表头
数字	123 45.1
字符串	‘hello world’
列表	[123,’abc,’{4,5,6}]
元组	(123,’abc,’{4,5,6})
字典	{‘a’:1,’b’:2,’c’:3}
集合	{‘a’,’b’,’c’}

数字 / Numeric

字符串 / Str

构建字符串

# 单引号
a1='hello world!'
print(a1)

# 双引号
a2="hello world!"
print(a2)

a3="I'm Phoebe. " # 当字符串内需要用单引号时，用双引号代表字符串

# 三重引号
a3='''hello world!
I am Phoebe...enennenen '''
print(a3)

字符串的基本操作

拼接和重复

a='Bob'
b='and Andy'
d=42

# 加法操作（拼接）
c=a+b
print(c) # 运行结果：Boband Andy
e=c+str(d) # 数字与字符串进行拼接时，必须将数字转化为str类型
print(e) # 运行结果：Boband Andy42

# 乘法操作（重复）
print(a*4)   #运行结果：BobBobBobBob

索引

1
2
3

s='point.'
print(s[0]) # 运行结果：p
print(s[-2]) # 运行结果：t

分片

# [start:end:step],左闭右开
s='point.'
print(s[1:3]) # 运行结果: oi
print(s[2:]) # 运行结果: int.
print(s[:-2]) # 运行结果: poin
print(s[:]) # 运行结果: point.
print(s[1:5:2]) # 运行结果: on
print(s[1::2]) # 运行结果: on.

字符串的转换

1
2
3

# 数字与字符串的转换，数字与字符串相加会报错
a=42
str(a)

字符串修改

# 不可变序列，不能在原处修改一个字符串。
i='o'
s='point.'
s[0]=i # 运行结果：报错，'str' object does not support item assignment

# 方法1：可以通过分片、合并来使用
'i'+s[:len(s)]+'er' #  运行结果：'ipoint.er'

# 方法2：可以通过replace字符串方法来实现
s1=s.replace('p','ip')
print(s1)
s2=s1.replace('.','.er')
print(s2) # 运行结果：'ipoint.er'

字符串格式化表达式

'That is %d %s bird'%(2,'dead')
# 运行结果：'That is 2 dead bird'

'====%f====%s====%d'%(1.3,'red',3)
# 运行结果：'====1.300000====red====3'

列表 / List

列表是python中最灵活的有序集合对象，具有有序、可变性，可以是其他对象的集合，如：[123,’abc’,{4,5,6}]

创建列表

L=[]	空列表
L=[1,2,3,4]	索引L[0],L[1],L[2],L[3]
L=[‘abc’,[‘def’,’gif’]]	嵌套子列表
L=list(‘spam’)	字符串转化为列表
list(range(-4,4))	For循环常用，值遍历

列表的基本操作

合并和重复

a=[1,3,2]
b=[7,6,8]

# 加法操作（合并）
print(a+b) # 运行结果：[1, 3, 2, 7, 6, 8]

# 乘法操作（重复）
c=['hi']*4
print(c) # 运行结果：['hi', 'hi', 'hi', 'hi']

索引

a=[1,2,4,6,'bird']
print(a[0]) # 运行结果：1
print(a[2]) # 运行结果：4
print(a[4]) # 运行结果：bird
print(a[-1])  # 运行结果：bird

分片

1 2	print(a[0:2]) # 运行结果：[1,2] print(a[0::2]) # 运行结果：[1, 4, 'bird']

修改列表操作

# 和字符串不同，列表是有序、可变的,支持原处修改对象的操作。例如下例中字符串修改会报错
a='point.'
a[0]='o'

# 列表支持原处修改对象
fruit=['Apple','Banana','Tomato']
fruit[1]='Watermelon'
print(fruit) # 运行结果：['Apple', 'Watermelon', 'Tomato']

fruit[1:2]=['Grape','Strawberry'] # 运行结果['Apple', 'Grape', 'Strawberry', 'Tomato']
print(fruit)

常见的列表调用方法

增 / append, extend, insert

# L.append(X) 在末尾添加一项
# L.extend() 在末端插入多个元素
# L.insert(index,'') 在某处插入某个元素

fruit=['Apple','Banana','Tomato']
fruit.append('Watermelon')
print(fruit) # 运行结果：['Apple', 'Banana', 'Tomato', 'Watermelon']

fruit.append(['w','h'])
print(fruit)  # 运行结果：['Apple', 'Banana', 'Tomato', 'Watermelon', ['w', 'h']]

fruit.extend(['Grape','Mango'])
print(fruit)

删 / remove, pop, del

# L.remove() 删除某个元素
# L.pop() 在末端删除一个.append([])元素
# del L[0] 删除某项或某个片段

fruit=['Apple','Banana','Tomato']
fruit.append(['w', 'h'])
print(fruit) # 运行结果：['Apple', 'Banana', 'Tomato', ['w', 'h']]

fruit.remove(['w', 'h']) # 运行结果：['Apple', 'Banana', 'Tomato']
print(fruit)

fruit.pop() # 删除末端 'Tomato'
fruit.pop() # 删除末端 'Banana'
print(fruit) # 运行结果：['Apple']

查 / index

1
2
3

# L.index() 查找某元素的下标
fruit=['Apple','Banana','Tomato']
fruit.index('Tomato') # 运行结果：2

排序 / sort, sorted, reverse

# L.sort() or sorted(L)  排序,前者在原列表修改,后者生成新列表
# L.reverse() 反转

fruit=['Apple','Banana','Tomato','Mango','Grape']
fruit.sort()
print(fruit) # 原处修改，运行结果：['Apple', 'Banana', 'Grape', 'Mango', 'Tomato']

fruit1=['Apple','Banana','Tomato','Mango','Grape']
print(sorted(fruit1,reverse=True)) # 生成新对象，['Tomato', 'Mango', 'Grape', 'Banana', 'Apple']
print(fruit1) # fruit1没有改变，['Apple', 'Banana', 'Tomato', 'Mango', 'Grape']

元组 / Tuple

元组与列表的方法类似，包括如下（置灰部分为元组没有的方法）：

合并(+)和重复(*)
索引(T[i])和分片(T[i:j])
增：append
删：del/remove/pop
查：index
改：可变、可在原处修改
排序：sorted(T)

区别

表示方式：列表-方括号[]；元组-圆括号()
可变性：列表可变；元组不可变

为什么有了列表还要元组？

元组不可变性提供了某种完整性，使得元组在程序中不会被另一个引用修改

创建列表

# 方式一：圆括号
a=(1,2,3,4)
print(a)

# 若只有单个元素，关闭圆括号之前加一个逗号即可
b=(1,)
print(b)

# 方式二
a1=1,2,3,4
print(a1) #效果和上面的一样

# 方式三：先创建列表，通过tuple转换成元组
a=[1,2,3,4]
print(tuple(a))

元组的基本操作

合并和重复

# 加法操作（合并）
a=(1,3,2)
b=(7,6,8)
print(a+b) # 运行结果：(1, 3, 2, 7, 6, 8)

# 乘法操作（重复）
c=('hi',)*4
print(c) # 运行结果：('hi', 'hi', 'hi', 'hi')

索引

a=(1,2,4,6,'bird')
print(a[0]) # 运行结果：1
print(a[2]) # 运行结果：4
print(a[4]) # 运行结果：bird
print(a[-1])  # 运行结果：bird

分片

1 2	print(a[0:2]) # 运行结果：(1,2) print(a[0::2]) # 运行结果：(1, 4, 'bird')

修改元组操作

1
2
3

# 不支持原处修改
a=(1,2,4,6,'bird')
a[0]=3 #  运行结果：'tuple' object does not support item assignment

常见的元组调用方法

元组不可变性=不能对原处进行增删，没有add,delete方法

查 / index

1
2
3

# index方法,返回2第一次出现的位置
T=(1,2,3,2,3,1)
T.index(2)

排序 / sorted

# sorted(T)
T=('aa','ff','bb')
T1=sorted(T)
print(T1) # 运行结果：返回列表，['aa', 'bb', 'ff']
print(tuple(T1))  # 运行结果：('aa', 'bb', 'ff')

其他

1
2
3

# 计数方法
T=('aa','ff','bb','aa','aa')
print(T.count('aa'))

字典 / Dict

列表是python中最灵活的无序集合对象，具有无序、可变性，以键值对的形式存在，可以是其他对象的集。比如：{‘a’:1,’b’:[1,2,3,4],’c’:{1,2,3}}

创建字典

D={}	空字典
D={‘apple’:3,’banana’:2}	两项目字典
D={‘apple’:3,’banana’:{‘A’:1,’B’:5}}	嵌套
D=dict(zip(keyslist,valslist))	键值列表
D=dict(name=’Bob’,age=42)

# 方法一：直接。字典是以键值对的形式存在的
Person={}
print(Person) # 空字典，运行结果：{}
Person={'name':'Jack','age':42,'sex':'Female','Province':'Shanghai'}
print(Person) # 运行结果： {'name': 'Jack', 'age': 42, 'sex': 'Female', 'Province': 'Shanghai'}

# 嵌套字典
All={'food':{'ham','rice','noodle'},'fruit':{'banana':'yellow','apple':'red','grape':'purple'}}
print(All)

# 方法二：赋值
Person={}
Person['name']='Eva'
Person['age']=42
print(Person) # 运行结果： {'name': 'Eva', 'age': 42}

# 方法三：列表转换成字典
D=dict.fromkeys(['a','b','c'],0)
print(D) # 运行结果：{'a': 0, 'b': 0, 'c': 0}

字典的基本操作

读/访问

键：D.keys()

值：D.values()

项：D.items()

Person={'name':'Jack','age':42,'sex':'Female','Province':'Shanghai'}

# 键
print(Person.keys()) # 运行结果：dict_keys(['name', 'age', 'sex', 'Province'])

# 值
print(Person.values())  # 运行结果：dict_values(['Jack', 42, 'Female', 'Shanghai'])

# 项
for i in Person.items():
    print(i)
# 运行结果：
# ('name', 'Jack')
# ('age', 42)
# ('sex', 'Female')
# ('Province', 'Shanghai')

print(Person['name'])  # 运行结果：Jack

修改字典

# 无序、可变，可以在字典原处对其进行修改
Person={'name':'Jack','age':42,'sex':'Female','Province':'Shanghai'}
Person['name']='Mr Jack'
print(Person) # 运行结果：{'name': 'Mr Jack', 'age': 42, 'sex': 'Female', 'Province': 'Shanghai'}

常见的字典调用方法

增 / update

# D.update()  类似于字典合并
Person={'name':'Jack','age':42,'sex':'Female','Province':'Shanghai'}
P2={'Company':'Google','Department':'Finance'}
Person.update(P2)
Person

删 / pop

# D.pop('') 从字典中删除一个键，并且返回值
Person={'name':'Jack','age':42,'sex':'Female','Province':'Shanghai'}
Person.pop('sex')
print(Person)

查 / get

# D.get()  get方法返回默认值，当键值不存在时，返回None或默认值
Person={'name':'Jack','age':42,'sex':'Female','Province':'Shanghai'}
print(Person.get('Company')) # 运行结果：None
print(Person.get('Company','Unknown')) #  运行结果：Unknown

改

同上“修改字典”

排序 / sorted

# 使用sorted
dict={'z':1,'f':3,'g':9,'a':11}

for key in sorted(dict.keys()):
    print(key+'\t'+str(dict[key]))

集合 / Set

集合类似于字典的键，且集合是无序不重复的。集合是无序、不可变。

创建集合

S=set()	空集合，而不是{}
S=set([1,2,3,4])	四个项的集合
S={1,2,3}

# 方法一
set([1,2,3,4]) # {1, 2, 3, 4}

# 方法二
{1,2,3,4,4} # {1, 2, 3, 4}

常见的集合调用方法

增 / add

1
2
3

s={1,3,2,4}
s.add(7)
print(s) # {1, 2, 3, 4, 7}

删 / remove

1 2	s.remove(3) print(s) # {1, 2, 4, 7}

集合的运算

# 集合是特殊的字典
dict={'z':1,'f':3,'g':9,'a':11}
# 并 / &
print(set(dict.keys())) # {'z', 'a', 'g', 'f'}
print(set(dict.keys())|{'h'}) # {'g', 'h', 'f', 'z', 'a'}
# 交 / |
print(set(dict.keys())&{'h','g'}) # {'g'}
# 差 / -
print(set(dict.keys())-{'g'}) # {'f', 'a', 'z'}
# 补 /  ^
print(set(dict.keys())^{'a','s'}) # {'s', 'z', 'g', 'f'}


x=[1,2,3,4]
y=[1,2,4,5,6]
print(list(set(x)&set(y){'a':1,'b':[1,2,3,4],'c':{1,2,3}}))  # 即在x集合，也在y集合
print(list(set(x)|set(y{'a':1,'b':[1,2,3,4],'c':{1,2,3}})))  # 在x集合或者y集合
print(list(set(x)-set(y))) #在x集合，不在y集合
print(list(set(x)^set(y))) #在 x或者y集合，但不在两个集合的交集，即 (set(x)|set(y))-(set(x)&set(y))
print((set(x)|set(y))-(set(x)&set(y)))