Python中常用的数据类型：

最新推荐文章于 2023-10-20 00:03:38 发布

apple_50618492

最新推荐文章于 2023-10-20 00:03:38 发布

阅读量1k

点赞数 1

文章标签： python

本文链接：https://blog.csdn.net/apple_50618492/article/details/114677666

版权

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…