python的六大数据类型及其常用操作

python一共有六大数据类型，即数字，字符串，列表，元组，字典，集合；此篇文章将介绍这六种数据类型及其基本操作

一、数字（number）

数字类型包括整型（int），浮点型（float），布尔型（bool），复数型（complex）

整型

只能存储整数，可以用int(变量)函数将可转为整型的数据强行转为整型，包括浮点型（强转后直接抹去小数部分）和纯数字构成的字符串（如"123"转为123），占位符为%d

浮点型

可以存储整数和小数，有普通表示形式（%f，默认保留六位小数，可用 %0.bf 形式控制输出保留b位小数）和科学计数法（%e，输出如2.5e-2，e后面表示10的次方），用float(变量)函数强转

布尔型

输出的为True或False，True的值为1，False的值为0，可以用bool(变量)将数字强转为布尔型，值为0转为False，非0转为True

复数

用z=complex(a,b)的形式创建z=a+bi的复数，real(z)返回实部，imag(z)返回虚部

运算

符号	意义
a+b	a+b
a-b	a-b
a*b	a×b
a/b	a÷b，可为小数
a//b	a整除b，结果为整数抹去小数
a%b	a整除b所得的余数
a**b	a的b次方

二、字符串（string）

常字符串的表现形式是用一对单或双引号括起，如"abc"，多行字符串用一对"""括起，如

"""
123
abc
"""

用str(变量)强转为字符串类型
下用str来表示字符串变量

字符串的索引

字符串用下标索引，可以把字符串看做一串字符从头开始从0开始依次编号，str[i]输出字符串第i位字符，可以取负数编号，意为从后往前倒序,如

str="abcdef"
print(str[0]) #输出第0位字符，即a
print(str[-1]) #输出倒数第一位字符，即f

当下标超出字符串的编号时会报错

字符串的切片

str[开始下标:结尾下标:步长]在开始到结尾的范围内（开始下标取到，结尾下标取不到），从开始下标起输出第一个字符，向后数，每经过一个步长输出下一个字符，直到达到结尾下标；步长若省略默认为1,；可以取负数编号；如

str="abcdef"
print(str[0:4:2]) #输出从str[0]到str[4](取不到)每隔2步长的字符，即ac
print(str[-3:-1]) #输出从str[-3]到str[-1](取不到)的字符(步长默认1)，即de

字符串的常用操作

合并：str1+str2，输出将str2接在str1末尾形成的字符串
复制：str*a，输出str复制a遍形成的字符串
检索：(1)str.find(子串,开始下标,结束下标)在开始下标到结束下标之间检索子串，检索存在则输出子串第一次出现时头字符的下标，不存在则输出-1；
(2)str.index(子串,开始下标,结束下标)基本同find()，区别是不存在会报错；
(3)子串 in str和子串 not in str，判断子串在/不在str中，输出为布尔型（True or False）；
(4)str.count(子列,开始下标,结束下标)，返回子串出现的次数；
(5) len(str)输出字符串长度
修改：(1)str.replace(旧子串,新子串,替换次数)，将str中的旧子串按出现顺序替换为新子串，省略次数默认全部替换，返回修改后的字符串；
(2)str.split(子串,分割次数)，检索子串并将字符串从子串两侧分开，返回一个字符串列表；
(3)str.capitalize()第一个字母大写，str.upper()小写转大写，str.lower()大写转小写，str.title()单词首字母大写，返回修改后的字符串
判断：str.startswith(字符)判断是否以某字符开始，str.endswith(字符)判断是否以某字符结尾；str.islower/isupper/isdigit()判断字符串是否都是小写/大写/数字，返回布尔型
遍历：可以用for i in str遍历字符串，i表示遍历时指向的字符

列表（list）

列表是一系列有序的元素，用一对中括号[ ]括起，元素之间用逗号隔开，元素类型不限，可以是数字字符串，元组字典集合，甚至是列表，如

li1=[] #定义空列表
li=[1,"abc",(x,y),{"key":"value"},{'d','e','f'},[1,2,3]}

list(变量)将变量强转为列表类型
下用li表示列表类型变量

列表的索引

列表采用下标索引，和字符串类似（元组的索引也类似），列表从0开始为其中元素依次编号，复数表示倒序，li[i]输出第i位元素，对列表中的序列型元素（列表、元组、字典）可以用li[i][j]索引列表第i位的序列元素中的第j位数据

列表的常用操作（注意列表的大部分函数不是输出，而是直接修改原列表，即在print中输出None）

添加：(1)直接用+合并列表，即list=li1+li2或li1+=li2；
(2)li.insert(下标,元素)在该下标前插入一个元素，后面的元素下标依次后移；
(3)li.append(元素)在末尾追加元素，不限类型；
(4)li.extend(元素)在末尾末尾追加元素，但会将可迭代对象（即可以从中再取出下属数据的，如列表、元组、字典、集合是可迭代对象）拆成单个元素加入列表；
(5)li[i:i]=[列表元素]在下标i之前插入所有列表元素；
(6)复制用li*a，输出将列表元素复制a次后形成的新列表；
修改元素：通过下标访问li[i]=新元素，li[起始下标:终止下标:步长]=新元素按步长长度依次将下标指向的元素修改为新元素；
删除：(1)del li删除整个列表，del li[i]、del li[i:j]删除下标指向的元素；
(2)li.pop(下标)删除下标元素，没有下标默认最后一位，输出删除的元素；
(3)li.remove(元素)根据元素来删除，只删除第一个出现的元素，输出删除的元素，无则报错；
(4)li.clear()删除所有元素，原列表变成空列表[ ]；
查找：(1)元素 in/not in li，输出布尔型；
(2)li.count(元素)，统计出现次数；
(3)li.index(元素)，返回下标，无则报错；
(4)len(li)输出元素个数；
排序：(1)li.reverse()列表倒置；
(2)li.sort()升序排列，li.sort(reverse=True)降序排列；
(3)sorted(li)输出升序列表，不改变原列表；
遍历：for i in li遍历列表，i表示遍历时指向的元素
列表推导式：[变量表达式 for 变量 in li]新列表对原列表的每一个元素执行表达式得出，li可以是列表、range()等可迭代数据（可从中遍历数据），如

li1=[1,2,3] #
li2=[i*2 for i in li1] #或 li2=[i*2 for i in range(1,3)]
print(li2) #输出[2,4,6]

元组（tuple）

元组是一系列有序数据，用一对小括号( )括起，数据间用逗号隔开，定义单个数据的元组末尾要加逗号(x , )，数据类型不限,如

tu1=(1,) #定义单个数据的元组
tu2=(1,"abc",[1,2,3]) #定义多个数据的元组

元组不可修改，可用于构建只读数据；
用tuple(变量)强转为元组类型；

元组的索引

元组索引与列表类似，数据用下标索引，即tu[i]；元组数据不可修改，但元组中的列表、字典、集合里的数据可以修改，用下标序列tu[i][j]进行索引和修改

元组的常用操作

查找：(1)tu.index(数据)，返回下标，无则报错；
(2)tu.count(数据)，返回出现次数；
(3)len(tu)统计数据个数；
(4)数据 in/not in tu，输出布尔型；
复制用tu*次数; 合并用tu=t1+t2；

字典（dictionary）

字典是一种映射类型，用大括号{}括起或用dict定义，其中元素以键值对形式{key：value}出现，键和值一一对应，键值对之间用逗号分隔，键（key）必须是不可变类型（数字、字符串、元组）且不可重复，如

dict1={}
dict2=dict() #定义空字典用{}或dict()
dict3={"name":"jack","age":18,"grade":["A","C","B"]}

字典的强转对象必须是以元组对(key:value)为元素的列表，可以用d=zip(lista,listb)将两个列表打包成一个(ai,bi)的元组列表，对应关系截止到短列表的长度，再用dict(d)强转成字典；
下用dict表示字典类型

字典的索引

字典用键（key）来索引，即dict[key]输出对应的值

字典的常见操作

修改/增加：dict[key]=value有则修改无则增加；
删除：del dict[key]删除对应键值对；clear(dict)清空字典；
查找：(1)len(dict)统计键值对个数；
(2)dict.keys()返回所有键列表；
(3)dict.values()返回所有值列表；
(4)dict.items()返回所有（键，值）列表；
(5)键 in/not in dict.keys(),值 in/not in dict.values()，键,值 in/not in dict.items()，返回布尔型；
遍历：用上文三个列表遍历for i in dict.keys()、for i in dict.value()、for key,value in dict.items()；
字典推导式：{i:i*2 for i in list}

集合（set）

集合是无序不重复序列，用{}或set()函数创建，后者可创建空集合，如

set1=set()
set2={"abc",[1,2,3],1}

用set()强转成集合类型；
下用set表示集合变量；
集合不可索引

集合的常见操作

增加：(1)set.add(数据)，用来添加不可迭代对象，重复则不添加；
(2)set.update(数据)，只能用来追加可迭代对象（即可以从中再取出数据的，如列表、元组、字典、集合是可迭代对象），自动将其拆分出下属数据加入集合并去重，其中对字典只加入key，如

set={1}
dict={11:22,33:44}
tu=(a,b,c)
set.update(dict)
print(set) #输出{1,11,33}
set.update(tu)
print(set) #输出{1,11,33,a,b,c}

删除：(1)set.remove(数据)，无则报错；
(2)set.discard(数据)，不存在不报错；
(3)set.pop()随机删除数据，返回删除的数据；
交集：set=s1&s2，取交集；并集：set=s1|s2，取并集；
##可变对象和不可变对象
六大数据类型可分为两类，可变对象和不可变对象
可变对象：存储的数据可以在原地址修改；不可变对象：存储的数据不可修改，修改值时实际上是修改引用的地址，如

#不可变对象
a=10 #将10赋值给a，即a引用值为10的地址
print(id(a)) #查看a的地址，如此处输出的是140737193382448
a=11 #将11赋值给a，即此时a引用值为11的地址
print(id(a)) #查看此时a的地址，如此处输出的是140737193382480，地址改变

大致是这个意思
不可变对象有：数字，字符串，元组；可变对象有：列表，字典，集合

深拷贝和浅拷贝

在python中使用 a=b 的赋值操作时实际上是将 b 的地址引用给 a ，即 a，b 共用一个地址，因此对不可变对象，修改 a 时 b 也会改变；对可变对象，修改 a 时实际上是修改引用给 a 的地址
想要修改 a 而不影响 b，需要创建 a 的一个拷贝。拷贝可以是浅拷贝或深拷贝：
浅拷贝（shallow copy）创建一个新对象，但它填充的仍然是对原始对象内容的引用（适用于对象中包含的是不可变类型）；
深拷贝（deep copy）创建一个新对象，并且递归地复制原对象中的所有子对象。因此，新对象与原对象完全独立，如

import copy #使用copy模块进行深拷贝
a=[1,2,3]
b=copy.deepcopy(a)
a.append(4)
print(a) #输出[1,2,3,4]
print(b) #输出[1,2,3]

可以用 is 运算符判断是否为浅拷贝（两个变量是否指向同一个量）a is b 返回布尔型