基础数据类型汇总
2022-04-01 11:50:43 0 举报AI智能生成
基础数据类型汇总
作者其他创作
大纲/内容
list
why
'1 True alex' 像这样的字符串，我如果通过切片或者其他方法将1 True alex取出来，他也只能是字符串，但是我想要得到数字的1，布尔值
的True,必须还要转化，是不是很麻烦，对于字符串来说，我只能存储少量的单一的(字符串类型)的数据，不方便，python给咱们也提供了一
'1 True alex'
像这样的字符串，我如果通过切片或者其他方法将1 True alex取出来，他也只能是字符串，但是我想要得到数字的1，布尔值
的True,必须还要转化，是不是很麻烦，对于字符串来说，我只能存储少量的单一的(字符串类型)的数据，不方便，python给咱们也提供了一
类数据类型，他能承载多种数据类型，这类数据类型被称作容器类数据类型可以存储大量的数据。列表就属于容器类的数据类型。
的True,必须还要转化，是不是很麻烦，对于字符串来说，我只能存储少量的单一的(字符串类型)的数据，不方便，python给咱们也提供了一
'1 True alex'
像这样的字符串，我如果通过切片或者其他方法将1 True alex取出来，他也只能是字符串，但是我想要得到数字的1，布尔值
的True,必须还要转化，是不是很麻烦，对于字符串来说，我只能存储少量的单一的(字符串类型)的数据，不方便，python给咱们也提供了一
类数据类型，他能承载多种数据类型，这类数据类型被称作容器类数据类型可以存储大量的数据。列表就属于容器类的数据类型。
what
列表是python中的基础数据类型之一， 其他语言中也有类似于列表的数据类型，比如js中叫数组， 他是以[括起来，每个元素以逗号隔开，而
且他里面可以存放各种数据类型比如:li= [ 'alex' ,123,Ture,(1,2,3,' wusir' ),[1,2,3,' 小明’]{ 'name'’ ’alex' }]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是536870912个元素64位python的限制是11
52921504606846975个元素。而且列表是有序的，有索引值，可切片，方便取值。
且他里面可以存放各种数据类型比如:li= [ 'alex' ,123,Ture,(1,2,3,' wusir' ),[1,2,3,' 小明’]{ 'name'’ ’alex' }]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是536870912个元素64位python的限制是11
52921504606846975个元素。而且列表是有序的，有索引值，可切片，方便取值。
how
1.可用于索引切片
1= ['太白，[1,2,3,], "Wusir,女神]
prit(I[1])# [1,2, 3]
print([-1]) #女神’
print([1:3]) # [1,1 2, 3], 'WuSir]
prit:(::2) # [太白，"Wusir]
prit(-1:-4:- 1)# [女神，"Wusir,[1, 2, 31]1
prit(I[1])# [1,2, 3]
print([-1]) #女神’
print([1:3]) # [1,1 2, 3], 'WuSir]
prit:(::2) # [太白，"Wusir]
prit(-1:-4:- 1)# [女神，"Wusir,[1, 2, 31]1
2.列表的操作方法
增
append
给列表最后一个位置追加元素
|= [1,2, 'a']
l.append(666)
print()# [1, 2, 'a', 666]
l.append(666)
print()# [1, 2, 'a', 666]
insert
插入在列表指定位置插入相应的元素
I= [1,2, 'a']
l.insert(1,'太白)
print() # [1, '太白，2, 'a']
l.insert(1,'太白)
print() # [1, '太白，2, 'a']
extend
迭代追加，在列表最后迭代追加数据
I= [1,2, 'a']
l.extend('太白a)
print()
l.extend('太白a)
print()
删
pop
通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
I= ["太白，'alex', 'WuSir',女神]
ret = l.pop(1)
print(ret,I) # alex [太白", 'WuSir, '女神']
ret = l.pop(1)
print(ret,I) # alex [太白", 'WuSir, '女神']
remove
通过元素删除列表中的元素
I= ["太白，'alex', 'WuSir',女神]
I.remove('alex')
print() # [太白'，'WuSir',女神]
1
I.remove('alex')
print() # [太白'，'WuSir',女神]
1
clear
清空列表
I = ['太白，'alex', 'WuSir',女神]
1
l.clear()
print() # 0]
1
l.clear()
print() # 0]
del
索引删除元素
Jai[1白，alxe, "Wusir, 女神1
del 1[2]x
print) #[太白; alx,女神]
del 1[2]x
print) #[太白; alx,女神]
切片删除元素
1=[太白，alex, "WuSir,女神]
del [1:]
print()# ['太白"]
del [1:]
print()# ['太白"]
切片加步长删除元素
I= [太白，'alex', 'WuSir',女神]
del IE::2]
print() # ['alex', 女神']
del IE::2]
print() # ['alex', 女神']
改
按照索引改值
|= [太白", 'alex', "WuSir,女神]
|[0] = '男神'
print() # [男神", 'alex', "Wusir,“女神]
|[0] = '男神'
print() # [男神", 'alex', "Wusir,“女神]
按照切片改值(迭代着增加)
I = ["太白，'alex', 'WuSir',女神]
|[1:3] = 'abcdefg'
print() # ['太白','a', 'b','c','d','e', 'f, 'g',女神']
|[1:3] = 'abcdefg'
print() # ['太白','a', 'b','c','d','e', 'f, 'g',女神']
按照切片加步长改值，必须一一对应
I=「!太白alere Wusir,女神]
l:2] =‘对应
pinto #[对，alxe,应，女神]
l:2] =‘对应
pinto #[对，alxe,应，女神]
查
按照索引查找
按照切片查找
for遍历
1= [太白'，[1,2, 3, ], 'WuSir',女神]
fori in |:
print(i)
fori in |:
print(i)
where
当你程序中需要设置大量有序的数据时，需要考虑列表
tuple
why
对于容器型数据类型list,无论谁都可以对其增删改查，那么有一些重要的数据放在list中是不安全的， 所以需要一种容器类的数据类型存放重要的
数据，创建之初只能查看而不能增删改，这种数据类型就是元祖。
数据，创建之初只能查看而不能增删改，这种数据类型就是元祖。
what
元组也是Python的基础数据类型之- -，是以() 括起来，里面的元素可以放所有数据类型，例如:
tu=( 'alex' ,123,Ture,(1,2,3,' wusir' ),[1,2,3,' 小明’,],{ 'name' :' alex' })元素以逗号隔开，元组也称作只读列表，元组里面的元组不能
更改，只能查看，读取(当然是儿子不能改，孙子可以改)。
tu=( 'alex' ,123,Ture,(1,2,3,' wusir' ),[1,2,3,' 小明’,],{ 'name' :' alex' })元素以逗号隔开，元组也称作只读列表，元组里面的元组不能
更改，只能查看，读取(当然是儿子不能改，孙子可以改)。
how
可以索引切片（加步长）
元组的操作方法
“改”
tu= (1, '太白，['alex',])
#元组为只读列表，不能增删改其值，只能查，但是对于改来说是相对的。
#直接属于元组的元素不能改，但是间接属于元组的元素不一定，比如上面的alex。
#举个不恰当的例子:儿子不能改，孙子可以改。
tu[-1][0]=日天'
print(tu)
#元组为只读列表，不能增删改其值，只能查，但是对于改来说是相对的。
#直接属于元组的元素不能改，但是间接属于元组的元素不一定，比如上面的alex。
#举个不恰当的例子:儿子不能改，孙子可以改。
tu[-1][0]=日天'
print(tu)
查
可以索引切片（加步长）查找
循环遍历
其他操作方法
index
通过元素找索引(可切片)，找到第1个元素就返回，找不到该元素即报错
tu= (太白;,[1, 2,3,], "Wusir, '女神)
print(tu.index(太白))#0
print(tu.index(太白))#0
count
获取元素在元组里出现的数量
tu= (太白', '太白'，'WuSir',‘吴超")
print(tu.count(太白)) # 2
print(tu.count(太白)) # 2
where
当程序中需要设置一些重要的数据， 这些数据不想让其他人更改，只能查看时，可以将数据存放在元组中
dict
why
1,列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。
2，列表只能按照顺序存储，数据与数据之间关联性不强。
所以咱们需要引入一种容器型的数据类型，解决上面的问题，这就需要dict字典。
2，列表只能按照顺序存储，数据与数据之间关联性不强。
所以咱们需要引入一种容器型的数据类型，解决上面的问题，这就需要dict字典。
what
先给大家说- -下可变与不可变的数据类型的分类:
不可变(可哈希)的数据类型: int, str, bool, tuple。
可变(不可哈希)的数据类型: list, dict, set。
字典是Python语言中唯一的映射类型。他是以{}括起来，里面的内容是以键值对的形式储存的:
Key:不可变(可哈希)的数据类型.
Value:任意数据，包括对象等...
如: dic = {'name':alex',
'age':56,
'py8期:"晓梅;方胜君'],
真:True,
('1',2,3):元祖}
字典一般储存的是大量的关联性比较强的数据，3.5包括3.5版本之前， 字典是无序的，3.6之后，创建字典时按照初始顺序排列。
字典的查询速度非常快。
不可变(可哈希)的数据类型: int, str, bool, tuple。
可变(不可哈希)的数据类型: list, dict, set。
字典是Python语言中唯一的映射类型。他是以{}括起来，里面的内容是以键值对的形式储存的:
Key:不可变(可哈希)的数据类型.
Value:任意数据，包括对象等...
如: dic = {'name':alex',
'age':56,
'py8期:"晓梅;方胜君'],
真:True,
('1',2,3):元祖}
字典一般储存的是大量的关联性比较强的数据，3.5包括3.5版本之前， 字典是无序的，3.6之后，创建字典时按照初始顺序排列。
字典的查询速度非常快。
how
增
通过键值对直接增加
dic= {'name': '太白'，'age': 18}
dic['weight'] = 75 #没有weight这个键，就增加键值对
print(dic) # {'name': '太白'，'age': 18, 'weight': 75}
dic['name'] = 'barry' #有name这个键，就成了字典的改值
print(dic) # {'name': 'barry", 'age': 18, 'weight': 75}
dic['weight'] = 75 #没有weight这个键，就增加键值对
print(dic) # {'name': '太白'，'age': 18, 'weight': 75}
dic['name'] = 'barry' #有name这个键，就成了字典的改值
print(dic) # {'name': 'barry", 'age': 18, 'weight': 75}
setdefault
dic = {'name': '太白'，'age': 18}
dic.setdefault('height',175) #没有height此键，则添加
print(dic) # {'name': '太白'，'age': 18, 'height': 175}
dic.setdefault('name','barry") #有此键则不变
print(dic) # {'name': '太白，'age': 18, "height': 175}
dic.setdefault('height',175) #没有height此键，则添加
print(dic) # {'name': '太白'，'age': 18, 'height': 175}
dic.setdefault('name','barry") #有此键则不变
print(dic) # {'name': '太白，'age': 18, "height': 175}
删
pop
通过key删除键值对，有返回值，可设置返回值
dic = {'name': '太白，'age': 18}
# ret = dic.pop('name')
# print(ret,dic) #太白{age': 18}
ret1 = dic.pop("n',None)
print(ret1,dic) # None {'name':太白，'age': 18}
# ret = dic.pop('name')
# print(ret,dic) #太白{age': 18}
ret1 = dic.pop("n',None)
print(ret1,dic) # None {'name':太白，'age': 18}
clear
清空字典
dic = {'name': '太白，'age': 18}
dic.clear(
print(dic)# {}
dic.clear(
print(dic)# {}
del
通过键删除键值对
dic = {'name': '太白'，'age': 18}
del dic['name']
print(dic) # {'age': 18}
del dic['name']
print(dic) # {'age': 18}
删除整个字典
del dic
改
通过键值对直接改
dic= {name':‘太白"，'age:18}
dic['name'] = 'barry
pit(di)# {name': brary,'age':18)
dic['name'] = 'barry
pit(di)# {name': brary,'age':18)
update
dic = {'name':‘太白'，'age': 18}
dic.update(sex='男'; height=175)
print(dic) # {name':‘太白; 'age': 18, 'sex:男，'height': 175}
dic.update(sex='男'; height=175)
print(dic) # {name':‘太白; 'age': 18, 'sex:男，'height': 175}
dic = {'name': '太白'，'age': 18}
dic.update([(1, 'a),(2, 'b"),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白，'age': 18, 1:'a', 2: 'b, 3:'C', 4:'d'}
dic.update([(1, 'a),(2, 'b"),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白，'age': 18, 1:'a', 2: 'b, 3:'C', 4:'d'}
dic1 = {"name":"jin"," age'":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}
查
通过键查找
直接dic[keys](没有会报错)
dic = {'name':太白，'age': 18}
print(dic['name']) #太白
print(dic['name']) #太白
get()
dic = {'name': '太白'，'age': 18}
V = dic.get('name'")
print(V) # '太白'
V = dic.get('name1)
print(v) # None
V = dic.get('name2";没有此键)
print(v) #没有此键
V = dic.get('name'")
print(V) # '太白'
V = dic.get('name1)
print(v) # None
V = dic.get('name2";没有此键)
print(v) #没有此键
keys()
dic = {'name': '太白，'age': 18}
print(dic.keys() # dict keys(['name', 'age ])
print(dic.keys() # dict keys(['name', 'age ])
values()
dic = {'name': '太白，'age': 18}
print(dic.values() # dict values([太白'，18])
print(dic.values() # dict values([太白'，18])
items()
dic = {'name': '太白'，'age': 18}
print(dic.items() # dict items([('name', '太白"), ('age', 18)])
print(dic.items() # dict items([('name', '太白"), ('age', 18)])
循环遍历
dic = {'name': '太白'，'age': 18}
for key in dic:
print(key)
for k,v in dic.items():
print(k,v)
for key in dic:
print(key)
for k,v in dic.items():
print(k,v)
操作方法
fromkeys
dic = dict.fromkeys("abcd;太白")
print(dic)# {'a': '太白'，'b': '太白','c': '太白'，'d:'太白"}
dic = dict.fromkeys([1, 2, 3],'太白)
print(dic) # {1: '太白，2: '太白，3: '太白}
print(dic)# {'a': '太白'，'b': '太白','c': '太白'，'d:'太白"}
dic = dict.fromkeys([1, 2, 3],'太白)
print(dic) # {1: '太白，2: '太白，3: '太白}
copy
浅copy
where
当你的程序需要设置大量的关系型数据，并组要求查询速度时，你需要考虑字典
int
why
主要是数字的计算、运算。
what
就是咱们平时用的1,2,3，4,5,6...
how
+ - * / ** // ...
where
需要用到的计算，计时等等
bool
why
程序中有时会判断条件的成立与不成立，作为if或while的条件
what
bool值包括True False
how
1 > 2 and 3 < 4 等逻辑判断，或者一些空数据转化为True 或 False等
where
一般用于一些语句的条件判断
str
why
程序中一般都是和数据打交道，大量的数据存储在数据库，缓存，文件等。但是程序需要将数据提取出来，加工处理。
字符串一般存储少量的数据。
字符串一般存储少量的数据。
what
str : name = ‘chuxin’
how
对字符串进行操作不会改变原字符串！
1.可以用于索引、切片
2.字符串的操作方法
strip
创建一个新的字符串：默认去除字符串两边的空格、换行符、制表符。
username = input("请输入姓名:").strip()
if username == '初心':
print("登录成功")
if username == '初心':
print("登录成功")
lstrip
创建一个新的字符串，默认去除字符串左边的空格、换行符、制表符
rstrip
创建一个新的字符串，默认去除字符串右边的空格、换行符、制表符
split
str ----> list
返回一个列表，默认以空格分割，可设置分割次数
str1 = '123|456|789'
print(str1.split('|')) # ['123','456','789']
print(str1.split('|')) # ['123','456','789']
rsplit
从右往左分割
join
list ----> str(这个方法非常好,不只是将列表转化为字符串一个功能)
返回一个字符串:对iterable进行遍历，通过设置的连接符将iterable的每个元素通过连接符连接到一起形成新的字符串
s1 = 'chuxin'
s2 = '_'.join(s1)
print(s2) # 'c_h_u_x_i_n'
lst1 = ['123', 'qwe', '@#']
lst2 = '|'.join(lst1)
print(lst2) # '123|qwe|@#'
s2 = '_'.join(s1)
print(s2) # 'c_h_u_x_i_n'
lst1 = ['123', 'qwe', '@#']
lst2 = '|'.join(lst1)
print(lst2) # '123|qwe|@#'
replace
创建一个新的字符串，将字符串中的旧内容替换成新内容，默认全部替换
name = 'I am chuxin'
new_name = name.replace('chuxin', 'SB')
print(new_name) # 'I am SB'
new_name = name.replace('chuxin', 'SB')
print(new_name) # 'I am SB'
format
格式化输出
ret = '{}{}{}'.format('name','age',123)
ret = '{1}{1}{2}'.format('name','age',123)
ret = '{name}{age}{sex}'.format(age=123,name='ruan',sex='male')
ret = '{1}{1}{2}'.format('name','age',123)
ret = '{name}{age}{sex}'.format(age=123,name='ruan',sex='male')
encode
将字符串转化为bytes类型，默认转化成UTF-8的bytes
count
计算某个元素出现的次数
s = 'chuxin'
print(s.count('x'))
print(s.count('x'))
index
通过元素找索引，找到第一个就返回，找不到就报错
ret = 'zxc123'
print(ret.index('1'))
print(ret.index('1'))
find
从左到右通过元素查找索引，找到第一个就返回，找不到就返回-1
ret = 'zxc123'
print(ret.find('1'))
print(ret.find('1'))
upper
创建一个新的全部大写的字符串
s1 = 'zxc'
s2 = s1.upper()
print(s2) # 'ZXC'
s2 = s1.upper()
print(s2) # 'ZXC'
lower
创建一个新的全部小写的字符串
s1 = 'ZXC'
s2 = s1.upper()
print(s2) # 'zxc'
s2 = s1.upper()
print(s2) # 'zxc'
isalpha
判断字符串是否全部为字母
s1 = '初xin'
print(s1.isalpha) # True
print(s1.isalpha) # True
isdecimal
检测字符串是否全部为十进制数字组成
islanum
检测字符串是否全部为数字和字母组成，返回True或者False
startswith
判断字符串是否为某个指定字符开头，可以切片，返回True或者False
endswith
判断字符串是否为某个指定字符结尾，可以切片，返回True或者False
capitalize
创建一个开头大写其余字母小写的新字符串
center
创建一个新的字符串:字符串居中，可设置字符串长度， 可以设置填充物
where
需要存储少量数据，读取文件数据，读取数据库数据时等等
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明
确的告诉它，1是数字，
”汉”是文字，否则它是分不清1和
'汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的
东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，
就传字符串类型给他。Python中常 用的数据类型有多种，int bool str list tuple dict set等
确的告诉它，1是数字，
”汉”是文字，否则它是分不清1和
'汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的
东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，
就传字符串类型给他。Python中常 用的数据类型有多种，int bool str list tuple dict set等
收藏
收藏
0 条评论
下一页
