首页 / PYTHON / Python中常用的数据类型：
Python中常用的数据类型：
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Python中常用的数据类型：，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含26326字，纯文字阅读大概需要38分钟。
内容图文
Python中常用的数据类型：
-
int：数字：主要用于运算。1 ，2,3…
-
float：浮点
python保留小数位的方法
方法一：format函数 print('{:.3f}'.format(1.23456)) 结果：1.235 print(format(1.23456, '.2f')) 结果：1.23 正如上面代码所示，format有不同用法，前者使用了占位符{}，使用占位符可以同时输出多个，后者一次只能输出一个，需要注意的是占位符中的冒号不能丢。笔者推荐使用占位符+format输出。 print('{:.3f} {:.2f}'.format(1.23456, 1.23456)) 结果：1.235 1.23 方法二：'%.xf'方法 print('%.2f' % 1.23456) 结果：1.23 方法三：round()函数 print(round(1.23456,3)) 结果：1.235 print(round(2.355,2)) 结果：2.35 print(round(2.5)) 结果：2 print(round(3.5)) -
str：简单少量的储存数据，并进行相应的操作。name = ‘this is a python’
-
bool：判断真假：True, False.
-
Tuple-元祖：只读，不能更改。(1,‘alex’)****
-
list：大量有序数据，[1,‘ses’,True,[1,2,3],{‘name’:‘jinxin’}]****
-
dict：大量数据，且是关联性比较强的数据{}
-
bytes:bytes类型，是python3.新增加的数据类型
一常见字符串str方法。
1:casefold()将所有的字符转化为小写:
name = "ZhangSan"
print("{0}".format(name.casefold()))
打印结果:zhangsan
2:capitalize()字符串首字母大写其他字符都小写:
name = "zhangSan"
name = name.capitalize()
print("{0}".format(name))
# 打印结果:Zhangsan
3:center()字符串宽度填充:
name = "zhangSan"
name = name.center(12)
print("{0}".format(name))
# 打印结果:' Zhangsan '
# 默认以空格填充
name = "zhangSan"
name = name.center(12, "#")
print("{0}".format(name))
# 打印结果:'##Zhangsan##'
# 以‘#’填充
4:count()统计字符在字符串中出现的次数:
name = "zhangSan"
num = name.count('S')
print("{0}".format(num))
# 打印结果:1
name = "zhangSan"
num = name.count('S', 0, 3) #从0，1，2索引里找
print("{0}".format(num))
#打印结果:0
5:encode()字符串编码:
name = "zhangsan"
name = name.encode('gbk')
print("{0}".format(name))
# 打印结果:b'zhangsan'
6:startswith()判断字符串以某个字符串开头，返回boolean类型:
name = "zhangsan"
isTrue = name.startswith("zh")
print(isTrue)
# 打印结果:True
7:endswith()判断字符串以某个字符串结尾，返回boolean类型:
name = "zhangsan"
isTrue = name.endswith("san")
print(isTrue)
# 打印结果:True
8:find()在字符串中查找指定字符串，找不到时返回-1:
rfind反向查找
name = "zhangsan"
isIn = name.find("an")
print(isIn)
# 打印结果:2
isIn = name.find("an",4)#第二个值为开始的索引值
# 打印结果:6
# 返回字符串开始的下标
9:format()格式化输出字符串:
name = "{} {} zhangsan"
#"{} {}"是占位符，用下边format()里边的参数填充
name = name.format('I', 'am')
print(name)
# 打印结果:I am zhangsan
10:index()在字符串中查找指定的字符串,返回索引找不到时直接报错:
rindex反向查找
name = "zhangsan"
isIn = name.index('a')
print(isIn)
#打印结果:2
11:join()字符串连接：
name = "zhangsan"
name = '*'.join(name)
print(name)
# 打印结果:z*h*a*n*g*s*a*n
12:isalnum()判断字符串是否只包含字母数字：
name = "zhangsan1"
isTrue = name.isalnum()
print(isTrue)
# 打印结果:True
name = "zhangsan1*"
isTrue = name.isalnum()
print(isTrue)
# 打印结果:False
13:isalpha()判断是否只包含字母:
name = "zhangsan"
isTrue = name.isalpha()
print(isTrue)
# 打印结果:True
name = "zhangsan1"
isTrue = name.isalpha()
print(isTrue)
# 打印结果:False
14:isdigit()判断字符串只由数字构成:
name = "1234"
isTrue = name.isdigit()
print(isTrue)
# 打印结果:True
name = "zhangsan1234"
isTrue = name.isdigit()
print(isTrue)
# 打印结果:False
15:isspace()判断字符串是否是空格:
name = " "
isTrue = name.isspace()
print(isTrue)
# 打印结果:True
name = "zhang san"
isTrue = name.isspase()
print(isTrue)
# 打印结果:False
16:isupper()判断字符串是否全是大写字符:
name = "ZHANGSAN"
isTrue = name.isupper()
print(isTrue)
# 打印结果:True
17:lower()将所有的大写字符转为小写字符:
name = "ZHANGSAN"
name = name.lower()
print(name)
# 打印结果:zhangsan
18:lstrip()去除字符串左边的空格:
name = " zhangsan "
name = name.lstrip()
print(name)
# 打印结果:zhangsan
19:rstrip()去除字符串右边的空格:
name = " zhangsan "
name = name.rstrip()
print(name)
# 打印结果: zhangsan
20：strip()去除字符串2边的空格:
name = " zhangsan "
name = name.strip()
print(name)
# 打印结果:zhangsan
21:replace()字符串替换:
name = "zhangsan"
name = name.replace("zhang", "li")
print(name)
# 打印结果:lisan
22:split()字符串分割，默认是空格:
name = "zhang san"
name = name.split()
print(name)
# 打印结果:['zhang', 'san']
23:add()在字符串后边添加字符串:
name = "zhang"
name = name.__add__("san")
print(name)
# 打印结果:zhangsan
24:contains()判断指定字符串是否包含在字符串中:
name = "zhangsan"
isTrue = name.__contains__("san")
print(isTrue)
# 打印结果:True
25:eq（）判断字符串是否相等:
name = "zhangsan"
name1 = "zhangsan"
isEq = name.__eq__(name1)
print(isEq)
# 打印结果:True
二读取字符串中的某些字符
s = “Hello, my name is Alex,golden king.”
字符串特性：
1 按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
2 不可变，字符串是不可变的，不能像列表?样修改其中某个元素，所有对字符串的修改操作其实都是相当于生成了?份新数据。
3 可进行切片操作
切片：就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾尾）。
s = 'abcdefghigklmn'
print(s[0:3]) #abc
print(s[2:5]) #cde
print(s[0:]) #默认到最后
print(a[0:len(a)])
print(s[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(s[0:5:2]) #加步长 ace
print(s[5:0:-2]) #反向加步长
print(s[::2])#返回acegikm
三元祖类型 tuple
定义元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改
如果要定义一个空的tuple，可以写成()：
但是，要定义一个只有1个元素的tuple，如果你这么定义： t = (1)，定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：
t = (1,)
创建元组：
tup = (11, 22, 33, 44, 55)
或
tup = tuple((11, 22, 33, 44, 55))
基本操作：索引，切片，循环，长度，包含
基本函数：
cmp（tuple1,tuple2):比较两个元组元素
len（tuple）计算元组元素个数
max（tuple）返回元组中元素最大值
min（tuple）返回元组中元素最小值
tuple（seq)将列表转换为元组
四列表list
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型
常用方法
| 方法 | 意义 |
|---|---|
| L.index(val, start,end) | 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误 |
| L.insert(index, obj) | 将某个元素插放到列表中指定的位置，其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。 |
| L.count(x) | 返回列表中元素的个数 |
| L.remove(x) | 从列表中删除第一次出现在列表中的值 |
| L.copy() | 复制此列表（只复制一层，不会复制深层对象)，此层发生改变，复制曾也会受到影响 |
| L.append(x) | 向列表尾部追加单个元素，当给 append() 方法传递列表或者元组时，会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。 |
| L.extend(lst) | 向列表追加另一个列表，不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。 |
| L.clear() | 清空列表,等同于 L[:] = [] |
| L.sort(reverse=False) | 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列 |
| L.reverse() | 列表的反转，用来改变原列表的先后顺序 |
| L.pop([index]) | 删除索引对应的元素，如果不加索引，默认删除最后元素，有返回值 |
| del L[start,end] | 按照索引去删除，也可切片删除没有返回值 |
一，改变list中的值利用索引既可以改变：
L[2]="我是新数据"
二，按切片去改实质是按迭代增加到列表
L [1:4] = ['a','b'] #索引1-3的值改为a，b
已知列表 li=[("s",12),("b",23)]
6.1 按照第二个元素进行从大到小的排序
li.sort(key=lambda x:x[1],reverse=True)
数据转成字典
dict(li)
列表生成式
list = [i for i in range(9)]
print(list)#012345678
五字典dict
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
创建字典的方法
创建一个空字典 这是最常用的
dict={}
传入可迭代对象
b = dict(zip(['one','two','three'],[1,2,3]))
print(b) #{'one': 1, 'two': 2, 'three': 3}
listRet=list(zip(['one','two','three'],[1,2,3]))
print(listRet) #[('one', 1), ('two', 2), ('three', 3)]
c = dict([('one', 1), ('two', 2), ('three', 3)])
print(c) #{'one': 1, 'two': 2, 'three': 3}
c1 = dict([('one', 1), ('two', 2), ('three', 3),('three', 4),('three', 5)])
print(c1) #如果键有重复，其值为最后重复项的值。
#传入映射对象，字典创建字典
d = dict({'one': 1, 'two': 2, 'three': 3})
print(d)
对字典操作的方法：
增：
第一种：
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['address'] = "海南"
dic["address1"] = "云南"
print(dic)
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['li'] = ["a","b","c"]
print(dic)
第二种：
#setdefault()方法： 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.setdefault('k','v')
print(dic) # {'age': 18, 'name': 'tan', 'sex': 'girle', 'k': 'v'}
dic.setdefault('k','v1')# {'age': 18, 'name': 'tan', 'sex': 'girle', 'k': 'v'}
print(dic)
setdefault() 方法：
setdefault() 方法用来返回某个 key 对应的 value，其语法格式如下：
dictname.setdefault(key, defaultvalue)
说明，dictname 表示字典名称，key 表示键，defaultvalue 表示默认值（可以不写，不写的话是 None）。
当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue。
也就是说，setdefault() 方法总能返回指定 key 对应的 value：
- 如果该 key 存在，那么直接返回该 key 对应的 value；
- 如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。
删：
第一种：pop()方法：根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic_pop = dic.pop("tan",'无key默认返回值')
print(dic_pop)
del 除键值对 没有返回值
del dic["name"] # 没有返回值。
print(dic)
第二种：
dic_clear = dic.clear() # 清空字典
print(dic,dic_clear) # {} None
popitem()：用来随机删除一个键值对
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.popitem()
改：
第一种：通过键去改
dic = {"name":"tom","age":18,"sex":"male"}
dic["name"]="jom"
print(dic)
第二种：update()方法：将所有的键值对覆盖添加(相同覆盖，没有的添加）
dic = {"name":"tom","age":18,"sex":"male"}
dic2 = {"name":"wu","weight":75}
dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic2)#{'name': 'tom', 'weight': 75, 'age': 18, 'sex': 'male'}
查：
第一种：通过键名查
value1 = dic["name"] # 没有会报错
print(value1)
第二种：通过get（）方法去查
value2 = dic.get("key","默认返回值") # 没有可以返回设定的返回值默认defalut=none
print(value2)
其他操作：
items()方法是可迭代的，返回列表，含所有（键，值）元组的列表
keys()方法:得到字典的键，返回列表，可迭代
values()方法：得到字典的值，返回列表 ，可迭代
'key' in dic #若存在则返回True，没有则返回False
dic.keys() #返回?个包含字典所有KEY的列表；
dic.values() #返回?个包含字典所有value的列表；
dic.items() #返回?个包含所有（键，值）元组的列表；
遍历
1、for k in dic.keys():
2、for k,v in dic.items() :
3、for k in dic :# 推荐?这种，效率速度最快
info = {
"name":"张勇峰",
"mission": "加油加油",
"website": "www"
}
for k in info:
print(k,info[k])
六set集合
定义：集合是无序的，不重复的数据集合。以下是集合最重要的两点：去重，把一个列表变成集合，就自动去重了。
特性：因为集合中的元素是不可重复的，且无序的，所以不支持索引，切片，连接。集合只支持成员操作符 迭代（for循环）
集合的创建
第一：set({})方法：创建集合
set1 = set({1,2,'marry'})
第二：{}
set2 = {1,2,'marry'}
增
add（）
update()方法：迭代着增加
删除
remove()方法：删除一个元素
pop()方法：随机删除一个元素
clear()方法： 清空集合
del属性： 删除集合
交集intersection（）
s1 = {1,2,3}
s2 = {2,3,4}
#交集
print('交集: ',s1.intersection(s2))
print('交集: ',s1 & s2)
并集union（）
s1 = {1,2,3}
s2 = {2,3,4}
#并集
print('并集: ',s1.union(s2))
print('并集: ',s1 | s2)
差集difference（）
s1 = {1,2,3}
s2 = {2,3,4}
print('差集: ',s1.difference(s2)) #s1 - (s1&s2)
print('差集: ',s2.difference(s1)) #s2 - (s1&s2)
对等差分symmetric_difference（）
s1 = {1,2,3}
s2 = {2,3,4}
print('对等差分: ',s1.symmetric_difference(s2))
print('对等差分: ',s2^s1)
子集issuperset（）
s1 = {1,2}
s2 = {1,2,3}
print(s1.issuperset(s2))
print(s1.issubset(s2))
判断两个集合是否相交isdisjoint
s1 = {1,2}
s2 = {1,2,3}
print(s1.isdisjoint(s2))
七enumerate枚举是同时获得索引和值
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li = ['marry','男神','女神','tim','吴东坡']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):#第二个参数是索引值
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0，可更改
print(index, name)
八字符串str，列表list，元祖tuple和字典dict之间的相互转换
元组转为字典（方式和列表转成字典的方法是一样的）需要通过zip（）转换
tup=("a","b","c","d","e")
tup1=(1, 2, 3, 4, 5)
dic=dict(zip(tup,tup1))
print(dic)#{'d': 4, 'e': 5, 'b': 2, 'a': 1, 'c': 3}
列表转换为字典
方法一：使用zip()函数
a = ['a1','a2','a3','a4']
b = ['b1','b2','b3']
d = zip(a,b)
print(dict(d)) # {'a1': 'b1', 'a2': 'b2', 'a3': 'b3'}
将a和b两个列表内的元素两两组合成键值对。
当两个列表的长度不一致时，多出的元素在另一个列表无匹配的元素时就不展示多出的元素。
方法二：使用嵌套列表转换为字典
a = ['a1','a2']
b = ['b1','b2']
c = [a,b]
print(dict(c)) # {'a1': 'a2', 'b1': 'b2'}
# 相当于遍历子列表，如下
dit = {}
for i in c:
dit[i[0]] = i[1]
print(dit)
将列表内的元素自行组合成键值对。
eval() 函数用来执行一个字符串表达式，并返回表达式的值。# Python中常用的数据类型：
-
int：数字：主要用于运算。1 ，2,3…
-
float：浮点
python保留小数位的方法
方法一：format函数 print('{:.3f}'.format(1.23456)) 结果：1.235 print(format(1.23456, '.2f')) 结果：1.23 正如上面代码所示，format有不同用法，前者使用了占位符{}，使用占位符可以同时输出多个，后者一次只能输出一个，需要注意的是占位符中的冒号不能丢。笔者推荐使用占位符+format输出。 print('{:.3f} {:.2f}'.format(1.23456, 1.23456)) 结果：1.235 1.23 方法二：'%.xf'方法 print('%.2f' % 1.23456) 结果：1.23 方法三：round()函数 print(round(1.23456,3)) 结果：1.235 print(round(2.355,2)) 结果：2.35 print(round(2.5)) 结果：2 print(round(3.5)) -
str：简单少量的储存数据，并进行相应的操作。name = ‘this is a python’
-
bool：判断真假：True, False.
-
Tuple-元祖：只读，不能更改。(1,‘alex’)****
-
list：大量有序数据，[1,‘ses’,True,[1,2,3],{‘name’:‘jinxin’}]****
-
dict：大量数据，且是关联性比较强的数据{}
-
bytes:bytes类型，是python3.新增加的数据类型
一常见字符串str方法。
1:casefold()将所有的字符转化为小写:
name = "ZhangSan"
print("{0}".format(name.casefold()))
打印结果:zhangsan
2:capitalize()字符串首字母大写其他字符都小写:
name = "zhangSan"
name = name.capitalize()
print("{0}".format(name))
# 打印结果:Zhangsan
3:center()字符串宽度填充:
name = "zhangSan"
name = name.center(12)
print("{0}".format(name))
# 打印结果:' Zhangsan '
# 默认以空格填充
name = "zhangSan"
name = name.center(12, "#")
print("{0}".format(name))
# 打印结果:'##Zhangsan##'
# 以‘#’填充
4:count()统计字符在字符串中出现的次数:
name = "zhangSan"
num = name.count('S')
print("{0}".format(num))
# 打印结果:1
name = "zhangSan"
num = name.count('S', 0, 3) #从0，1，2索引里找
print("{0}".format(num))
#打印结果:0
5:encode()字符串编码:
name = "zhangsan"
name = name.encode('gbk')
print("{0}".format(name))
# 打印结果:b'zhangsan'
6:startswith()判断字符串以某个字符串开头，返回boolean类型:
name = "zhangsan"
isTrue = name.startswith("zh")
print(isTrue)
# 打印结果:True
7:endswith()判断字符串以某个字符串结尾，返回boolean类型:
name = "zhangsan"
isTrue = name.endswith("san")
print(isTrue)
# 打印结果:True
8:find()在字符串中查找指定字符串，找不到时返回-1:
rfind反向查找
name = "zhangsan"
isIn = name.find("an")
print(isIn)
# 打印结果:2
isIn = name.find("an",4)#第二个值为开始的索引值
# 打印结果:6
# 返回字符串开始的下标
9:format()格式化输出字符串:
name = "{} {} zhangsan"
#"{} {}"是占位符，用下边format()里边的参数填充
name = name.format('I', 'am')
print(name)
# 打印结果:I am zhangsan
10:index()在字符串中查找指定的字符串,返回索引找不到时直接报错:
rindex反向查找
name = "zhangsan"
isIn = name.index('a')
print(isIn)
#打印结果:2
11:join()字符串连接：
name = "zhangsan"
name = '*'.join(name)
print(name)
# 打印结果:z*h*a*n*g*s*a*n
12:isalnum()判断字符串是否只包含字母数字：
name = "zhangsan1"
isTrue = name.isalnum()
print(isTrue)
# 打印结果:True
name = "zhangsan1*"
isTrue = name.isalnum()
print(isTrue)
# 打印结果:False
13:isalpha()判断是否只包含字母:
name = "zhangsan"
isTrue = name.isalpha()
print(isTrue)
# 打印结果:True
name = "zhangsan1"
isTrue = name.isalpha()
print(isTrue)
# 打印结果:False
14:isdigit()判断字符串只由数字构成:
name = "1234"
isTrue = name.isdigit()
print(isTrue)
# 打印结果:True
name = "zhangsan1234"
isTrue = name.isdigit()
print(isTrue)
# 打印结果:False
15:isspace()判断字符串是否是空格:
name = " "
isTrue = name.isspace()
print(isTrue)
# 打印结果:True
name = "zhang san"
isTrue = name.isspase()
print(isTrue)
# 打印结果:False
16:isupper()判断字符串是否全是大写字符:
name = "ZHANGSAN"
isTrue = name.isupper()
print(isTrue)
# 打印结果:True
17:lower()将所有的大写字符转为小写字符:
name = "ZHANGSAN"
name = name.lower()
print(name)
# 打印结果:zhangsan
18:lstrip()去除字符串左边的空格:
name = " zhangsan "
name = name.lstrip()
print(name)
# 打印结果:zhangsan
19:rstrip()去除字符串右边的空格:
name = " zhangsan "
name = name.rstrip()
print(name)
# 打印结果: zhangsan
20：strip()去除字符串2边的空格:
name = " zhangsan "
name = name.strip()
print(name)
# 打印结果:zhangsan
21:replace()字符串替换:
name = "zhangsan"
name = name.replace("zhang", "li")
print(name)
# 打印结果:lisan
22:split()字符串分割，默认是空格:
name = "zhang san"
name = name.split()
print(name)
# 打印结果:['zhang', 'san']
23:add()在字符串后边添加字符串:
name = "zhang"
name = name.__add__("san")
print(name)
# 打印结果:zhangsan
24:contains()判断指定字符串是否包含在字符串中:
name = "zhangsan"
isTrue = name.__contains__("san")
print(isTrue)
# 打印结果:True
25:eq（）判断字符串是否相等:
name = "zhangsan"
name1 = "zhangsan"
isEq = name.__eq__(name1)
print(isEq)
# 打印结果:True
二读取字符串中的某些字符
s = “Hello, my name is Alex,golden king.”
字符串特性：
1 按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
2 不可变，字符串是不可变的，不能像列表?样修改其中某个元素，所有对字符串的修改操作其实都是相当于生成了?份新数据。
3 可进行切片操作
切片：就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾尾）。
s = 'abcdefghigklmn'
print(s[0:3]) #abc
print(s[2:5]) #cde
print(s[0:]) #默认到最后
print(a[0:len(a)])
print(s[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(s[0:5:2]) #加步长 ace
print(s[5:0:-2]) #反向加步长
print(s[::2])#返回acegikm
三元祖类型 tuple
定义元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改
如果要定义一个空的tuple，可以写成()：
但是，要定义一个只有1个元素的tuple，如果你这么定义： t = (1)，定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：
t = (1,)
创建元组：
tup?=?(11,?22,?33,?44,?55)
或
tup?=?tuple((11,?22,?33,?44,?55))
基本操作：索引，切片，循环，长度，包含
基本函数：
cmp（tuple1,tuple2):比较两个元组元素
len（tuple）计算元组元素个数
max（tuple）返回元组中元素最大值
min（tuple）返回元组中元素最小值
tuple（seq)将列表转换为元组
四列表list
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型
常用方法
| 方法 | 意义 |
|---|---|
| L.index(val, start,end) | 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误 |
| L.insert(index, obj) | 将某个元素插放到列表中指定的位置，其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。 |
| L.count(x) | 返回列表中元素的个数 |
| L.remove(x) | 从列表中删除第一次出现在列表中的值 |
| L.copy() | 复制此列表（只复制一层，不会复制深层对象)，此层发生改变，复制曾也会受到影响 |
| L.append(x) | 向列表尾部追加单个元素，当给 append() 方法传递列表或者元组时，会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。 |
| L.extend(lst) | 向列表追加另一个列表，不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。 |
| L.clear() | 清空列表,等同于 L[:] = [] |
| L.sort(reverse=False) | 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列 |
| L.reverse() | 列表的反转，用来改变原列表的先后顺序 |
| L.pop([index]) | 删除索引对应的元素，如果不加索引，默认删除最后元素，有返回值 |
| del L[start,end] | 按照索引去删除，也可切片删除没有返回值 |
一，改变list中的值利用索引既可以改变：
L[2]="我是新数据"
二，按切片去改实质是按迭代增加到列表
L [1:4] = ['a','b'] #索引1-3的值改为a，b
已知列表 li=[("s",12),("b",23)]
6.1 按照第二个元素进行从大到小的排序
li.sort(key=lambda x:x[1],reverse=True)
数据转成字典
dict(li)
列表生成式
list?=?[i?for?i?in?range(9)]
print(list)#012345678
五字典dict
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
创建字典的方法
创建一个空字典 这是最常用的
dict={}
传入可迭代对象
b = dict(zip(['one','two','three'],[1,2,3]))
print(b) #{'one': 1, 'two': 2, 'three': 3}
listRet=list(zip(['one','two','three'],[1,2,3]))
print(listRet) #[('one', 1), ('two', 2), ('three', 3)]
c = dict([('one', 1), ('two', 2), ('three', 3)])
print(c) #{'one': 1, 'two': 2, 'three': 3}
c1 = dict([('one', 1), ('two', 2), ('three', 3),('three', 4),('three', 5)])
print(c1) #如果键有重复，其值为最后重复项的值。
#传入映射对象，字典创建字典
d = dict({'one': 1, 'two': 2, 'three': 3})
print(d)
对字典操作的方法：
增：
第一种：
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['address'] = "海南"
dic["address1"] = "云南"
print(dic)
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['li'] = ["a","b","c"]
print(dic)
第二种：
#setdefault()方法： 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.setdefault('k','v')
print(dic) # {'age': 18, 'name': 'tan', 'sex': 'girle', 'k': 'v'}
dic.setdefault('k','v1')# {'age': 18, 'name': 'tan', 'sex': 'girle', 'k': 'v'}
print(dic)
setdefault() 方法：
setdefault() 方法用来返回某个 key 对应的 value，其语法格式如下：
dictname.setdefault(key, defaultvalue)
说明，dictname 表示字典名称，key 表示键，defaultvalue 表示默认值（可以不写，不写的话是 None）。
当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue。
也就是说，setdefault() 方法总能返回指定 key 对应的 value：
- 如果该 key 存在，那么直接返回该 key 对应的 value；
- 如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。
删：
第一种：pop()方法：根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic_pop = dic.pop("tan",'无key默认返回值')
print(dic_pop)
del 除键值对 没有返回值
del dic["name"] # 没有返回值。
print(dic)
第二种：
dic_clear = dic.clear() # 清空字典
print(dic,dic_clear) # {} None
popitem()：用来随机删除一个键值对
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.popitem()
改：
第一种：通过键去改
dic = {"name":"tom","age":18,"sex":"male"}
dic["name"]="jom"
print(dic)
第二种：update()方法：将所有的键值对覆盖添加(相同覆盖，没有的添加）
dic = {"name":"tom","age":18,"sex":"male"}
dic2 = {"name":"wu","weight":75}
dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic2)#{'name': 'tom', 'weight': 75, 'age': 18, 'sex': 'male'}
查：
第一种：通过键名查
value1 = dic["name"] # 没有会报错
print(value1)
第二种：通过get（）方法去查
value2 = dic.get("key","默认返回值") # 没有可以返回设定的返回值默认defalut=none
print(value2)
其他操作：
items()方法是可迭代的，返回列表，含所有（键，值）元组的列表
keys()方法:得到字典的键，返回列表，可迭代
values()方法：得到字典的值，返回列表 ，可迭代
'key' in dic #若存在则返回True，没有则返回False
dic.keys() #返回?个包含字典所有KEY的列表；
dic.values() #返回?个包含字典所有value的列表；
dic.items() #返回?个包含所有（键，值）元组的列表；
遍历
1、for k in dic.keys():
2、for k,v in dic.items() :
3、for k in dic :# 推荐?这种，效率速度最快
info = {
"name":"张勇峰",
"mission": "加油加油",
"website": "www"
}
for k in info:
print(k,info[k])
六set集合
定义：集合是无序的，不重复的数据集合。以下是集合最重要的两点：去重，把一个列表变成集合，就自动去重了。
特性：因为集合中的元素是不可重复的，且无序的，所以不支持索引，切片，连接。集合只支持成员操作符 迭代（for循环）
集合的创建
第一：set({})方法：创建集合
set1 = set({1,2,'marry'})
第二：{}
set2 = {1,2,'marry'}
增
add（）
update()方法：迭代着增加
删除
remove()方法：删除一个元素
pop()方法：随机删除一个元素
clear()方法： 清空集合
del属性： 删除集合
交集intersection（）
s1 = {1,2,3}
s2 = {2,3,4}
#交集
print('交集: ',s1.intersection(s2))
print('交集: ',s1 & s2)
并集union（）
s1 = {1,2,3}
s2 = {2,3,4}
#并集
print('并集: ',s1.union(s2))
print('并集: ',s1 | s2)
差集difference（）
s1 = {1,2,3}
s2 = {2,3,4}
print('差集: ',s1.difference(s2)) #s1 - (s1&s2)
print('差集: ',s2.difference(s1)) #s2 - (s1&s2)
对等差分symmetric_difference（）
s1 = {1,2,3}
s2 = {2,3,4}
print('对等差分: ',s1.symmetric_difference(s2))
print('对等差分: ',s2^s1)
子集issuperset（）
s1 = {1,2}
s2 = {1,2,3}
print(s1.issuperset(s2))
print(s1.issubset(s2))
判断两个集合是否相交isdisjoint
s1 = {1,2}
s2 = {1,2,3}
print(s1.isdisjoint(s2))
七enumerate枚举是同时获得索引和值
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li = ['marry','男神','女神','tim','吴东坡']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):#第二个参数是索引值
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0，可更改
print(index, name)
八字符串str，列表list，元祖tuple和字典dict之间的相互转换
元组转为字典（方式和列表转成字典的方法是一样的）需要通过zip（）转换
tup=("a","b","c","d","e")
tup1=(1, 2, 3, 4, 5)
dic=dict(zip(tup,tup1))
print(dic)#{'d': 4, 'e': 5, 'b': 2, 'a': 1, 'c': 3}
列表转换为字典
方法一：使用zip()函数
a = ['a1','a2','a3','a4']
b = ['b1','b2','b3']
d = zip(a,b)
print(dict(d)) # {'a1': 'b1', 'a2': 'b2', 'a3': 'b3'}
将a和b两个列表内的元素两两组合成键值对。
当两个列表的长度不一致时，多出的元素在另一个列表无匹配的元素时就不展示多出的元素。
方法二：使用嵌套列表转换为字典
a = ['a1','a2']
b = ['b1','b2']
c = [a,b]
print(dict(c)) # {'a1': 'a2', 'b1': 'b2'}
# 相当于遍历子列表，如下
dit = {}
for i in c:
dit[i[0]] = i[1]
print(dit)
将列表内的元素自行组合成键值对。
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
内容总结
以上是互联网集市为您收集整理的Python中常用的数据类型：全部内容，希望文章能够帮你解决Python中常用的数据类型：所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。