python的基本数据类型以及应用
2020-09-17 14:10:24 0 举报AI智能生成
python的基本数据类型以及应用
作者其他创作
大纲/内容
str
how
对字符串进行操作会形成一个新的字符
串，不会改变原字符串
串，不会改变原字符串
可以用于索引，切片
s1 = '太白金星666'
#索引从左至右，从零开始
#按照索引取值
s2 =s1[0]
print(s2,type(s2))
s3 = s1[4]
print(s3)
s4 = s1[-1]
print(s4)
s5 = s1[-2]
print(s5)
#按照切片取值[起始索引]:[结尾索引]:[步长] 顾头不顾腚
s6 = s1[0:4]
s6 = s1[:5] #从开头取值可以不写0
s7 = s1[5:] #取到最后什么都不写
s8 = s1[:5:2]
# 反向取值[起始索引]:[结尾索引]:[负数步长] 顾头不顾腚
s9 = s1[-1:-4:-1]
print(s9)
#索引从左至右，从零开始
#按照索引取值
s2 =s1[0]
print(s2,type(s2))
s3 = s1[4]
print(s3)
s4 = s1[-1]
print(s4)
s5 = s1[-2]
print(s5)
#按照切片取值[起始索引]:[结尾索引]:[步长] 顾头不顾腚
s6 = s1[0:4]
s6 = s1[:5] #从开头取值可以不写0
s7 = s1[5:] #取到最后什么都不写
s8 = s1[:5:2]
# 反向取值[起始索引]:[结尾索引]:[负数步长] 顾头不顾腚
s9 = s1[-1:-4:-1]
print(s9)
字符串的操作方法（带颜色的标为重要方法）
title
创建一个新的字符串：字符串非字母元素隔开的
每个单词的首字母大写
每个单词的首字母大写
casefold
返回一个新的字符串全部为小写
format_map
格式化输出，可以通过字典的形式
expandtabs
将字符串中的制表符：\t默认转化成8个空格。
isdecimal
检测该字符串只包含十进制的字符（3.14、三、叁、Ⅲ这一类的不可以）
isnumeric
检测该字符串只包含十进制的字符（小数不可以3.14。三、叁、Ⅲ这些可以）
isidentifier
判断该字符串是否是python中的关键字
islower
判断该字符串是否全部由小写字母组成
isprintable
判断该字符串中的所有字符是否是可打印的字符(含有换行符，制表符等这些字符都会返回False,含有空格返回True）
partition
对字符率按照指定字符进行分割，返回一个元组(分隔符前面的元素:分隔符:分隔符后面的元素)。
isspace
判断该字符串全部由空格或者制表符或者换行符组成，至少含有一个字符。
istitle
判断组成该字符串的标题内容是否是首字母大写(如果满足规定的标题(非字符隔开的每个单词理解为标题)全部都是首字母大写，则返回True)。
isupper
判断该字符串全部都是大写字母组成，则返回True
ljust
返回一个左对齐并且设置总宽度的字符串填充物默认为空。
rjust
返回一个右对齐并且设置总宽度的字符串填充物默认为空。
maketrans
就是制定一个字符串映射的转换表，需要两个字符串参数，这两个字符串长度必须相同，-- -对应。
translate
按照maketrans定制的转换表进行相应的转换。
rpartition
对字符串按照指定字符(从右边开始数的第一个字符)进行分割，返回一个元组(”分隔符前面的元素;分隔符:分隔符后面的元素)。
zfill
返回指定长度的字符串，原字符串右对齐，前面埴充0。
capitalize
创建个首字母大写，其余字母小写的新字符串
swapcase
创建一个大小写翻转的新字符串
center
创建一个新字符串:字符串居中，可设置字符串的长度，并且可设置填充物*
startswith
判断该字符事以某个字符或者某些字符为开头，并且可以切片，返回的是bool值
endswith
判断该字符事以某个字符或者某些字符为结尾，并且可以切片，返回的是bool值
isalpha
检测字符串是否全部由字母组成
isalnum
检测改字符串是否由数字或者字母组成。返回bool值. .
isdigit
检测该字符串或bytes类型是否只包含十进制的字符(这些都不可以: 3.14,三，叁 ,，但是可以检测bytes类型)。
upper
创建一个全部大写的新的字符串
lower
:创建一个全部变小写新的字符串
find
从左边开始通过元素找索引(可切片)找到第一个元素就返回，找不到该元素返回-1
rfind
从右边开始通过元素找(可切片)我到第一个元素就返回，找不到该元素返回-1
index
通过元素找索引(可切片)找到第一个元素就返回，找不到该元素即报错
rindex
从右边开始通过元素找索引(可切片)找到第一个元素就返回，找不到该元素报错
count
计算某个元素出现的次数
strip
创建一个新的字符串:默认去除原字符串前后两端的换行符，制表符，空格
lstrip
创建一个新的字符串:默认去除原字符串左(前)端的换行符，制表符，空格。
rstrip
创建一个新的字符串:默认去原除字符串
右(前)端的换行符，制表符，空格
右(前)端的换行符，制表符，空格
split
str --> list
返回一个列表:默认以空格分割,可指定分隔符，可设置分割次数
rsplit 从右往左分割
splitlines
对字符串按照换行符分割，返回一个列表(默认去除分隔符， 如果想保存分隔符则设置keepend=True)
join
lst-- str(这个方法非常好，不只是将list转化成str这一个功能)
replace
创建一个新的字符串，将原字符串中耨内容替换成新的内容，默认全部替换。
format
格式化输出田
encode
将字符串转化成bytes类型，默认转化成utf-8的bytes类型。
why
程序-般都是和数据打交道，大量的数据存储在数据库，缓存，文件等，
但是程序需要将这些数据提取出来，处理，加工，这些提取出来的数据，
在程序中往往是以字符串的形式存在，字符串一般存储一些相对少量的数据。
但是程序需要将这些数据提取出来，处理，加工，这些提取出来的数据，
在程序中往往是以字符串的形式存在，字符串一般存储一些相对少量的数据。
what
这个就是咱们的str: name= 'alex' 或者"alex"
where
需要存储少量的数据，读取文件数据，数据库数据时，等
bool
why
程序中有时需要判断等式或者不等式的对错，作为if或者while等判断条件真假。
what
bool值:True False
how
1 > 2and3< 4等逻辑判断，或者一些空数据(转化成bool值为False)等。
where
一般会用与一些语句的条件判断。
int
why
主要是用于数字的运算，计算
what
就是数字1，2，3。。。
how
+ - * / % // 。。。
where
需要用到计算，计数等时
list
why
'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' }][1,2,3,’小明’]{ 'name' : alex' }]列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是536870912个元素64位python的限制是1152921504606846975个元素。 而且列表是有序的， 有索引值，可切片，方便取值。
how
可用于索引切片
1= [太白'，[1,2, 3, ], "WuSir',‘女神]
print([1])# [1, 2, 3]
print([-1]) #‘女神'
print([1:3]) # [1, 2, 3], 'WuSir]
print([:2]) # [太白'，'WuSir]
print([-1:-4:-1]) # [女神，"WuSir', [1, 2,
3]]
print([1])# [1, 2, 3]
print([-1]) #‘女神'
print([1:3]) # [1, 2, 3], 'WuSir]
print([:2]) # [太白'，'WuSir]
print([-1:-4:-1]) # [女神，"WuSir', [1, 2,
3]]
列表的操作方法
增
append
追加，给列表的最后面追加一个元素
insert
插入在列表的任意位置插入元素
extend
迭代着追加，在列表的最后面迭代着追加
一组数据
一组数据
删
pop
通过索弓删除列表中对应的元素，该方法
有返回值，返回值为删除的元素
有返回值，返回值为删除的元素
remove
通过元素删除列表中该元素
clear
清空列表
del
按照索引删除该元素
切片删除该元素
切片（步长）删除该元素
改
按照索引改值
按照切片改值（迭代着增加）
按照切片（步长）改值（必须一 一对应）
查
按照索引查值
按照切片（步长）查值
for循环查值
其它操作方法
index
通过元素找索引(可切片)找到第一个元素就返回，找不到该元素即报错
count
获取某元素在列表中出现的次数
sort
默认从小到大排列
通过设置参数从大到小排列
reverse
反转列表
copy
浅copy
where
当你程序中需要设置大量有序的数据时，
需要考虑列表
需要考虑列表
tuple
why
对于容器型数据类型ist,无论谁都可以对
其增删改查，那么有一些重要的数据放在li
st中是不安全的，所以需要一种容器类的
数据类型存放重要的数据，创建之初只能
查看而不能增删改，这种数据类型就是元
祖。
其增删改查，那么有一些重要的数据放在li
st中是不安全的，所以需要一种容器类的
数据类型存放重要的数据，创建之初只能
查看而不能增删改，这种数据类型就是元
祖。
what
元组也是Python的基础数据类型之一，
是以()括起来，里面的元素可以放所有
数据类型，例如:
tu=( 'alex' ,123,Ture,(1,2,3,' wusi
r’),[1,2,3,' 小明’,]{ 'name' : ale
x })元素以逗号隔开，元组也称作只读列
表，元组里面的元组不能更改，只能查
看，读取(当然是儿子不能改，孙子可以
改)。
是以()括起来，里面的元素可以放所有
数据类型，例如:
tu=( 'alex' ,123,Ture,(1,2,3,' wusi
r’),[1,2,3,' 小明’,]{ 'name' : ale
x })元素以逗号隔开，元组也称作只读列
表，元组里面的元组不能更改，只能查
看，读取(当然是儿子不能改，孙子可以
改)。
how
可以索引切片（步长）
元组的操作方法
改
tu= (1,太白，["alex',])
#元组为只读列表，不能增删改其值，只
能查，但是对于改来说是相对的。
#直接属于元组的元素不能改，但是间接
属于元组的元素不一定，比如上面的ale
#举个不恰当的例子:儿子不能改，孙子
可以改。
tu[-1][0]=‘日天'
print(tu)
#元组为只读列表，不能增删改其值，只
能查，但是对于改来说是相对的。
#直接属于元组的元素不能改，但是间接
属于元组的元素不一定，比如上面的ale
#举个不恰当的例子:儿子不能改，孙子
可以改。
tu[-1][0]=‘日天'
print(tu)
查
可以索引切片（步长）
可以for循环查询
其他操作方法
index
通过元素找索引(可切片)找到第一个元素就返回，找不到该元素即报错
count
获取某元素在列表中出现的次数
where
当程序中需要设置一些重要的数据， 这些
数据不想让其他人更改，只能查看时，可
以将数据存放在元组中
数据不想让其他人更改，只能查看时，可
以将数据存放在元组中
dict
why
1,列表可以存储大量的数据类型，但是如
果数据量大的话，他的查询速度比较慢。
2,列表只能按照顺序存储，数据与数据之
间关联性不强。
所以咱们需要引入一种容器型的数据类
型，解决上面的问题，这就需要dict字
典。
果数据量大的话，他的查询速度比较慢。
2,列表只能按照顺序存储，数据与数据之
间关联性不强。
所以咱们需要引入一种容器型的数据类
型，解决上面的问题，这就需要dict字
典。
what
先给大家说一下可变与不可变的数据类型
的分类:
不可变(可哈希)的数据类型: int, str,
bool, tuple.
可变(不可哈希)的数据类型: list, dic
t，set。
字典是Python语言中唯一的映射类型。他
是以0括起来，里面的内容是以键值对的形
式储存的:
Key:不可变(可哈希)的数据类型。
Value:任意数据，包括对象等...
如: dic = {'name':alex',
'age':56,
'py8期:["晓梅' :方胜君],
真:True,
(1,2,3):元祖}
字典一般储存的是大量的关联性比较强的
数据，3.5包括3.5版本之前，字典是无序
的，3.6之后，创建字典时按照初始顺序排
列。
字典的查询速度非常快。
的分类:
不可变(可哈希)的数据类型: int, str,
bool, tuple.
可变(不可哈希)的数据类型: list, dic
t，set。
字典是Python语言中唯一的映射类型。他
是以0括起来，里面的内容是以键值对的形
式储存的:
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这个
键，就增加键值对
pintldic)# (name:太白"，'age:18,W
eight: 75}
dic'name]= bary #有name这个键，
就成了字典的改值
print(dio) # (name': barry', 'age':18, 'w
eight': 75}
dic'weight] = 75 #没有weight这个
键，就增加键值对
pintldic)# (name:太白"，'age:18,W
eight: 75}
dic'name]= bary #有name这个键，
就成了字典的改值
print(dio) # (name': barry', 'age':18, 'w
eight': 75}
setdefault
dic = {'name': '太白'，'age': 18}
dic.setdefault(height,175) #没有heigh
t此键，则添加
print(dic) # {'name':‘太白，'age': 18, 'he
ight': 175}
dic.setdefault('name','barry') #有此键则
不变
print(dic) # {'name': '太白，'age': 18, 'he
ight': 175}
dic.setdefault(height,175) #没有heigh
t此键，则添加
print(dic) # {'name':‘太白，'age': 18, 'he
ight': 175}
dic.setdefault('name','barry') #有此键则
不变
print(dic) # {'name': '太白，'age': 18, 'he
ight': 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':‘太白'，'a
ge': 18}
# ret = dic.pop('name")
# print(ret,dic) #太白{age': 18}
ret1 = dic.pop('n',None)
print(ret1 ,dic) # None {'name':‘太白'，'a
ge': 18}
popitem
3.5版本之前，popitem为随机删除，3.6
之后为删除最后一个， 有返回值
之后为删除最后一个， 有返回值
dic = {'name': '太白'，'age': 18}
ret = dic.popitem()
print(ret,dic) # ("age', 18) {'name': '太
白}
ret = dic.popitem()
print(ret,dic) # ("age', 18) {'name': '太
白}
clear
清空字典
dic = {'name':太白，'age': 18}
dic.clear0
print(dic)# 0}
dic.clear0
print(dic)# 0}
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'
print(dic) # {'name': "barry', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': "barry', 'age': 18}
update
源码:
， D.update([E, ]**F) -> None. Upd
ate D from dict/iterable E and F.
If E is present and has a .keys0 metho
d, then does: for kin E: D[k]= E[k]
9f E is present and lacks a .keys0 metho
d, then does: fork, vin E: D[k] = v
In either case, this is followed by: for k
inF: D[k] = F[k]
， D.update([E, ]**F) -> None. Upd
ate D from dict/iterable E and F.
If E is present and has a .keys0 metho
d, then does: for kin E: D[k]= E[k]
9f E is present and lacks a .keys0 metho
d, then does: fork, vin E: D[k] = v
In either case, this is followed by: for k
inF: D[k] = F[k]
dic = {'name': '太白，'age': 18}
dic.update(sex=男，height=175)
print(dic) # {'name': '太白，'age': 18, 'se
x':男: "height: 175}
dic.update(sex=男，height=175)
print(dic) # {'name': '太白，'age': 18, 'se
x':男: "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":" ma
le"}
dic2 = {"name": alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 's
ex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', "weight': 7
5}
le"}
dic2 = {"name": alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 's
ex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', "weight': 7
5}
查
通过键查询
直接dic[key](没有此键会报错)
dic= {'name':太白，'age': 18}
print(dic['name']) #太白
print(dic['name']) #太白
get
dic= (name':“太白"，'age':18}
V=
dic.get('name)
print(v)#‘太白
V = dic.get(Cname1)
print(Vy) # None
V= decgetCname2,没有此键)
print(v)#没有此键
V=
dic.get('name)
print(v)#‘太白
V = dic.get(Cname1)
print(Vy) # None
V= decgetCname2,没有此键)
print(v)#没有此键
keys()
dic = {'name': '太白，'age': 18) :
print(dic.keys0) # dict_ keys(['name', 'a
ge'])
print(dic.keys0) # dict_ keys(['name', 'a
ge'])
values()
dic= {'name': '太白'，'age': 18}
print(dic.values() # dict. values(['太白'，
18])
print(dic.values() # dict. values(['太白'，
18])
items()
dic = {'name': '太白'，'age': 18) :
print(dic.items0) # dict_ items([('name',
‘太白"，(age', 18)])
print(dic.items0) # dict_ items([('name',
‘太白"，(age', 18)])
利用for循环
dic= {'name': '太白'，'age': 18}
for key in dic:
print(key)
for kv in dic.items():
print(k,v)
for key in dic:
print(key)
for kv in dic.items():
print(k,v)
常用操作方法
fromkeys
dic= diokelobodt馆
‘太白"，心:太
pintica#a:太t白",b'
白,"d:“太白")
dic = ditromkeky(1,
1, 2, 3)];太白")
‘太白"，心:太
pintica#a:太t白",b'
白,"d:“太白")
dic = ditromkeky(1,
1, 2, 3)];太白")
copy
浅copy
where
当你的程序需要设置大量的关系型数据，
并且要求查询速度时，你需要考虑字典
并且要求查询速度时，你需要考虑字典
我们人类可以很容易的分清数字与字符的
区别，但是计算机并不能呀，计算机虽然
很强大，但从某种角度上看又很傻，除非
你明确的告诉它，1是数字，“汉" 是文
字，否则它是分不清1和汉'的区别的，
因此，在每个编程语言里都会有一个叫数
据类型的东东，其实就是对常用的各种数
据类型进行了明确的划分，你想让计算机
进行数值运算，你就传数字给它，你想让
他处理文字，就传字符串类型给他。Pyth
on中常用的数据类型有多种，int bool str
list tuple dict set等
区别，但是计算机并不能呀，计算机虽然
很强大，但从某种角度上看又很傻，除非
你明确的告诉它，1是数字，“汉" 是文
字，否则它是分不清1和汉'的区别的，
因此，在每个编程语言里都会有一个叫数
据类型的东东，其实就是对常用的各种数
据类型进行了明确的划分，你想让计算机
进行数值运算，你就传数字给它，你想让
他处理文字，就传字符串类型给他。Pyth
on中常用的数据类型有多种，int bool str
list tuple dict set等
为什么要
有基础数
据类型?
有基础数
据类型?
0 条评论
下一页
