基础数据类型
2020-12-28 11:18:58 1 举报AI智能生成
基础数据类型
作者其他创作
大纲/内容
list
why
"1 True alex" 像这样的字符串，我如果通过切片或者其他方法将1 True alex取出来，他也只能是字符串，但是我想要得数字的说，我只能存储少量的单一的（字符串类型）的数据，不方便，python给咱们也提供了一类数据类型，他能承载多种数据，这类数据类型被称作容器类型可以存储大量的数据。列表就属于容器类的数据类型。
what
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且里面可以存放各种数据类型比如：
li=["alex",123,True,(1,2,3,"wusir"),[1,2,3,"小明",],{"name":"alex}]
列表相比于字符串，不仅可以存储不同的数据类型，而且可以存储大量数据，32位python的限制是536870912个元素，64位python的限制是1152921504606846975个元素。而且列表是有序的，有索引值的，可切片，方便取值。
li=["alex",123,True,(1,2,3,"wusir"),[1,2,3,"小明",],{"name":"alex}]
列表相比于字符串，不仅可以存储不同的数据类型，而且可以存储大量数据，32位python的限制是536870912个元素，64位python的限制是1152921504606846975个元素。而且列表是有序的，有索引值的，可切片，方便取值。
how
1、可用于索引切片
l=["太白"，[1,2,3],"wusir","女神"]
print(l[1]) #[1,2,3]
print(1[-1] #"女神"
print(l[1:3] #[[1,2,3],"wusir:]
print(l[::2]) #["太白","wusir"]
print([-1:-4：-1） #["女神","wusir",[1,2,3]]
print(l[1]) #[1,2,3]
print(1[-1] #"女神"
print(l[1:3] #[[1,2,3],"wusir:]
print(l[::2]) #["太白","wusir"]
print([-1:-4：-1） #["女神","wusir",[1,2,3]]
2、列表的操作方法
增
append
追加，给列表的最后面追加一个元素
l=[1,2,"a"]
l.append(666)
print(l) #[1,2,"a",666]
l.append(666)
print(l) #[1,2,"a",666]
insert
插入在列表的任意位置元素
l=[1,2,"a"]
l.insert(1,"太白")
print(l) #[1,"太白",2,"a"]
l.insert(1,"太白")
print(l) #[1,"太白",2,"a"]
extend
迭代着追加，在列表的最后面迭代着追加一组数据
l=[1,2,"a"]
l.extend("太白a")
print(l)
l.extend("太白a")
print(l)
删
pop
通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
1= [太白'，'alex, 'WuSir',女神']
ret = l.pop(1)
print(ret,I) # alex [太白"，"WuSir,女神']
ret = l.pop(1)
print(ret,I) # alex [太白"，"WuSir,女神']
remove
通过元素删除列表中该元素
I= [太白'，'alex', 'WuSir',女神]
L.remove("alex)
print() # [太白'，'WuSir',女神']
L.remove("alex)
print() # [太白'，'WuSir',女神']
clear
清空列表
1= [太白; alex, Wusir,女神]
l.clear0 !
print() # []
l.clear0 !
print() # []
del
按照索引|删除该元素
I= [太白'，'alex', 'WuSir', '女神]
del I[2]
print() # [太白'，'alex,女神']
del I[2]
print() # [太白'，'alex,女神']
切片删除该元素
I= [太白'，'alex', 'WuSir', '女神]
del [1:]
print() # [太白"]
del [1:]
print() # [太白"]
切片(步长删除该元素
I = [太白，'alex', 'WuSir',女神]
del I[:2]
print() # ['alex', 女神]
del I[:2]
print() # ['alex', 女神]
改
按照索引改值
|= [太白'，'alex', 'WuSir', '女神]
[0]='男神'
print() # [男神'，'alex, 'WuSir',女神]
[0]='男神'
print() # [男神'，'alex, 'WuSir',女神]
按照切片改值(迭代着增加)
|= [太白'，'alex', 'WuSir', '女神]
I[1:3] = 'abcdefg'
print() # [太白'，'a', 'b', 'C', 'd','e', 'f,'g', '女神]
I[1:3] = 'abcdefg'
print() # [太白'，'a', 'b', 'C', 'd','e', 'f,'g', '女神]
按照切片(步长)改值(必须--对应)
|= [太白，'alex', 'WuSir', '女神]
I[:2] = '对应'
print() # [对"，'alex', "应，女神']
I[:2] = '对应'
print() # [对"，'alex', "应，女神']
查
按照索引查值
按照切片步长)查值
for循环查值
1= ["太白',[1, 2, 3, ], "WuSir;,女神']
1
for i in l：
print(i)
1
for i in l：
print(i)
其他操作方法
index
通过元素找索引(可切片)，找到第一 个元素就返回，找不到该元素即报错
1= [太白',[1, 2, 3, ], 'WuSir,女神']
print(.index(太白)) # 0
print(.index(太白)) # 0
count
获取某元素在列表中出现的次数
1=['太白'，'太白，'WuSir',吴超]
print(l.count(太白"))#2
print(l.count(太白"))#2
sort
默认从小到大排列
I= [7,4,8,9,1,2,3,5, 6]
L.sort(）
print(l)#[1, 2,3, 4,5,6, 7,8, 9]
L.sort(）
print(l)#[1, 2,3, 4,5,6, 7,8, 9]
通过设置参数从大到小排列
I= [7,4,8,9,1,2,3,5, 6]
l.sort(reverse= True)
print()# [9,8, 7,6,5,4,3,2, 1]
l.sort(reverse= True)
print()# [9,8, 7,6,5,4,3,2, 1]
reverse
反转列表
|= [太白'，'alex', 'WuSir',‘吴超]
I.reverse(）
print(l) # [吴超"，'WuSir', 'alex', '太白]
I.reverse(）
print(l) # [吴超"，'WuSir', 'alex', '太白]
copy
浅copy
where
当你程序中需要设置大量有序的数据时，需要考虑列表
tupel
why
对于容器型数据类型list,无论谁都可以对其增删改查,那么有一些重要的数据放在list中是不安全的， 所以需要一种容器类的数据类型存放重要的
数据，创建之初只能查看而不能增删改，这种数据类型就是元祖。
数据，创建之初只能查看而不能增删改，这种数据类型就是元祖。
what
元组也是Python的基础数据类型之一， 是以() 括起来，里面的元素可以放所有数据类型，例如:
tu=( 'alex' ,123,Ture,(1,2,3,' wusir' ),[1,23,' 小明’]{ 'name' : alex' })元素以逗号隔开， 元组也称作只读列表，元组里面的元组不能
更改，只能查看，读取(当然是儿子不能改，孙子可以改)。
tu=( 'alex' ,123,Ture,(1,2,3,' wusir' ),[1,23,' 小明’]{ 'name' : alex' })元素以逗号隔开， 元组也称作只读列表，元组里面的元组不能
更改，只能查看，读取(当然是儿子不能改，孙子可以改)。
how
1.可以索引切片(步长)
2.元组的操作方法
改
tu=(1, '太白'，[alex',])
#元组为只读列表，不能增删改其值，只能查，但是对于改来说是相对的。
#直接属于元组的元素不能改，但是间接属于元组的元素不一定，比如上面的alex。
#举个不恰当的例子:儿子不能改，孙子可以改。
tu[1][0]=日天'
print(tu)
#元组为只读列表，不能增删改其值，只能查，但是对于改来说是相对的。
#直接属于元组的元素不能改，但是间接属于元组的元素不一定，比如上面的alex。
#举个不恰当的例子:儿子不能改，孙子可以改。
tu[1][0]=日天'
print(tu)
查
1.可以索引切片(步长)
2.可以for循环查询
其他操作方法
index
通过元素找索引(可切片)，找到第一 个元素就返回，找不到该元素即报错
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
what
1.列表可以存储大量的数据类型，但是如果数据量大的话，他的直询速度比较量。
2,列表只能按照顺序存储，数据与数据之间关联性不强
解决上面的问题，这就需要dict字典。
所以咱们需要引入一种容器型的数据类型，
2,列表只能按照顺序存储，数据与数据之间关联性不强
解决上面的问题，这就需要dict字典。
所以咱们需要引入一种容器型的数据类型，
先给大家说一下可变与不可变的数据类型的分类:
不可变(可哈希)的数据类型: int, str, bool, tuple。
可变(不可哈希)的数据类型: list, dict, 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, dict, set.
字典是Python语言中唯一的映射类型。 他是以0括起来，里面的内容是以键值对的形式储存的:
Key:不可变(可哈希)的数据类型.
Value:任意数据，包括对象等...
如: dic = {'name':'alex';
'age':56,
'py8期:[晓梅，方胜君"]，
真':True,
(1,2,3):元祖}
字典一般储存的是大量的关联性比较强的数据，3.5包括3.5版本之前， 字典是无序的，3.6之后，创建字典时按照初始顺序排列
字典的查询速度非常快。
how
增
通过键值对直接增加
setdefault
dic = {name':‘太白"，'age': 18}
print(diod # (name:"太白",。没有height此键， 则添加
'age': 18, height:175}
pisedelee nebaryge有此键则不变
printdic # {'name:太白: age; 18, hegt: 175)
print(diod # (name:"太白",。没有height此键， 则添加
'age': 18, height:175}
pisedelee nebaryge有此键则不变
printdic # {'name:太白: age; 18, hegt: 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}
popitem
3.5版本之前，popitem为随机删除，3.6之 后为删除最后一个，有返回值
clear
del
改
通过键值对直接改
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. Update D from dict/iterable E and F.
If E is present and has a .keys0 method, then does: for kin E: D[k] = E[k]
If E is present and lacks a .keys0 method, then does: for k, vin E: D[k] = V
In either case, this is followed by: for kinF: D[k] = F[k]
If E is present and has a .keys0 method, then does: for kin E: D[k] = E[k]
If E is present and lacks a .keys0 method, then does: for k, vin E: D[k] = V
In either case, this is followed by: for kinF: D[k] = F[k]
dic = {name':“太白，'age': 18}
dic.update(sex='男; height=175)
print(did # (name': '太白，'age: 18, 'sex: 男; heigt: 175)
dic.update(sex='男; height=175)
print(did # (name': '太白，'age: 18, 'sex: 男; heigt: 175)
dic= {'name':‘太白，'age': 18}
dic.update((1, 'a),(2, "b),(3,‘),(4, 'd)])
print(dic) # {name':‘太白"，'age:18, 1:a',2:"b;3:"c,4:'d}
dic.update((1, 'a),(2, "b),(3,‘),(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[key](没有此键会报错)
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.keys0) # dict keys(['name', 'age'])
print(dic.keys0) # dict keys(['name', 'age'])
values
dic二(name':“太白，'age': 18)
piticialuel # dict vlues(太白，18)
piticialuel # dict vlues(太白，18)
items
dic= (name: '太白; 'age':18)
pntte tenio # did ti(Cae EI)(age,18)
pntte tenio # did ti(Cae EI)(age,18)
利用for循环
dic = {'name': '太白，'age': 18}
for key in dic:
print(key)
for k,v in dic.items0:
print(k,v)
for key in dic:
print(key)
for k,v in dic.items0:
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.....
how
+-*/%**//....
where
需要用到计算，计数等时
bool
why
程序中有时需要判断等式或者不等式的对错，作为if 或者while等判断条件真假。
what
boo值: True False.
how
1>2and3<4等逻相判断，或者些空数据(转化ool值为Fale)等。
where
般会用于一 些语句的条件判断。
str
why
程序-般都是和数据打交道，大量的数据存储在数据库，缓存，文件等，但是程序需要将这些数据提取出来，处理，加工，这些提取出来的数据，
在程序中往往是以字符串的形式存在，字符串-般存储一些相对少量的数据。
在程序中往往是以字符串的形式存在，字符串-般存储一些相对少量的数据。
what
程序-般都是和数据打交道，大量的数据存储在数据库，缓存，文件等，但是程序需要将这些数据提取出来，处理，加工，这些提取出来的数据，
在程序中往往是以字符串的形式存在，字符串-般存储一些相对少量的数据。
在程序中往往是以字符串的形式存在，字符串-般存储一些相对少量的数据。
how
对字符串进行操作会形成一个新的字符串， 不会改变原字符串! !
1,可以用于索引，切片。
s1 =太白金星666'
#索引从左至右，从零开始
#按照索3 |取值
s2= s1[0]
print(s2,type(s2))
s3= s1[4]
print(s3)
s4=s1[-1]
print(s4)
s5 = s1[-2]
print(s5)
#按照切片取值[起始索引结尾索引|+ 1:步长]顾头不顾腚
s6= s1[0:4]
s6= s1[:5] #从开头取值可以不写0
s7 = s1[5:] #取到最后什么都不写
s8= s1[:5:2]
#反向取值[起始索引结尾索引- 1:步长顾头不顾定
s9= s1[-1:-4:-1]
print(s9)
#索引从左至右，从零开始
#按照索3 |取值
s2= s1[0]
print(s2,type(s2))
s3= s1[4]
print(s3)
s4=s1[-1]
print(s4)
s5 = s1[-2]
print(s5)
#按照切片取值[起始索引结尾索引|+ 1:步长]顾头不顾腚
s6= s1[0:4]
s6= s1[:5] #从开头取值可以不写0
s7 = s1[5:] #取到最后什么都不写
s8= s1[:5:2]
#反向取值[起始索引结尾索引- 1:步长顾头不顾定
s9= s1[-1:-4:-1]
print(s9)
2,字符串的操作方法(带颜色的标为重要方法)
title
:创建一个新字符串: 字符串非字母元素隔开的每个单词的首字母大写
S ='alex wusir8taibai*ritian'
s4 = s.title(
print(s4) # Alex Wusir8Taibai*Ritian
s4 = s.title(
print(s4) # Alex Wusir8Taibai*Ritian
casefold
返回一个新的字符串全部为小写。
与lower相似，但是lower只能转换ASCCI码中的字母，而此方法可以转换非中文的其他语言，比如德语，葡萄牙语等。
format_map
格式化输出，可以通过字典的形式。
S =“我的名字: {name}, 年龄: {age}'
ret = s.format map({' name:太白';age':18})
print(ret)
ret = s.format map({' name:太白';age':18})
print(ret)
expandtabs
将字符串中的制表符: \t默认转化成8个空格。
s= 'ta\ti'
print(s. expandtabs0) # ta
print(s. expandtabs0) # ta
isdecimal
检测该字符串只包含+进制的字符(这些都不可以: 3.14,三，参，)。
#s1='0310'
# print(s1.isdecimal0) # True
#s1='3.14'
# print(s1.isdecimal0) # False 小数不可以
s1 =三叁I'
print(s1.isdecimal0) # False 汉字数字，罗马数字不可以
#s1= b'0310'
# print(s1.isdecimal0) #报错，bytes类型没有该方法。
# print(s1.isdecimal0) # True
#s1='3.14'
# print(s1.isdecimal0) # False 小数不可以
s1 =三叁I'
print(s1.isdecimal0) # False 汉字数字，罗马数字不可以
#s1= b'0310'
# print(s1.isdecimal0) #报错，bytes类型没有该方法。
isnumeric
检测该字符串只包含十进制的字符(小数不可以: 3.14, 这些都可以:三参)。
S = 0310'
print(s.isnumeric0) # True
S ='3.14'
print(s.isnumeric0) # False 小数不可以
s2 = '叁'
s3=''
print(s1.isnumeric0) # True汉字数字可以
print(s2.isnumeric0) # True汉字数字可以
print(s3.isnumeric0) # True罗马数字可以
s1 = b'0310'
print(s 1.isnumericO) #报错，bytes类型没有该方法。
print(s.isnumeric0) # True
S ='3.14'
print(s.isnumeric0) # False 小数不可以
s2 = '叁'
s3=''
print(s1.isnumeric0) # True汉字数字可以
print(s2.isnumeric0) # True汉字数字可以
print(s3.isnumeric0) # True罗马数字可以
s1 = b'0310'
print(s 1.isnumericO) #报错，bytes类型没有该方法。
isidentifier
判断该字符串是否是python中的关键字
s1 = 'def'
s2 = 'break'
s3 = 'if'
print(s1.isidentifier() # True
print(s2.isidentifier0) # True
print(s3.isidentifier() # True
s2 = 'break'
s3 = 'if'
print(s1.isidentifier() # True
print(s2.isidentifier0) # True
print(s3.isidentifier() # True
islower
判断该字符串是否全部由小写字母组成
s1 = 'alex'
print(s1 .islower() # True
print(s1 .islower() # True
isprintable
判斯放字符申中的所有字符是否是可印的好符(含有换行符，制表符等这些字符都会返回Fake含有空格近回True,)
s1 ='!'
s2='#'
s3= '太白\t'
s4= ^\n太白’
s5 = 'barry太’
s6 =
print(s1.isprintable0) # True
print(s2.isprintable0) # True
print(s3.isprintable0) # False
print(s4.isprintable0) # False
print(s5.isprintable0) # True
print(s6.isprintable0) # True
s2='#'
s3= '太白\t'
s4= ^\n太白’
s5 = 'barry太’
s6 =
print(s1.isprintable0) # True
print(s2.isprintable0) # True
print(s3.isprintable0) # False
print(s4.isprintable0) # False
print(s5.isprintable0) # True
print(s6.isprintable0) # True
partition
对字符串按照指定字符进行分割，返回一个元组(分隔符前面的元素,“分隔符;分隔符后面的元素)。
s1 =‘日天太白,吴超’
print(s1.partition(,)) # (日天;，”'太白，吴超")
print(s1.partition(,)) # (日天;，”'太白，吴超")
isspace
判断该字符串全部由空格或者制表符或者换行符组成，至少含有一个字符。
s1 =
s2 = "\t'
s3 = \n'
print(s1.isspace0)
print(s2.isspace0)
print(s3.isspace0)
s2 = "\t'
s3 = \n'
print(s1.isspace0)
print(s2.isspace0)
print(s3.isspace0)
istitle
判断组成该字符串的标题内容是否是首字母大写(如果满足规定的标题(非字符隔开的每个单词理解为标题)全部都是首字母大写，则返回Tru
e)。
e)。
s1 = 'Alex'
s2 = 'Alex Wusir*Barry2Ritian'
print(s1.istitle0) # True
print(s2.istitle0) # True
s2 = 'Alex Wusir*Barry2Ritian'
print(s1.istitle0) # True
print(s2.istitle0) # True
isupper
判断该字符串全部都是大写字母组成，则返回True
ljust
返回一个左对齐并且设置总宽度的字符串填充物默认为空。
s1 = 'barry'
print(s1.ljust(20,'*")) # barry*************
print(s1.ljust(20,'*")) # barry*************
rjust
返回一个右对齐并且设置总宽度的字符串填充物默认为空。
maketrans
就是制定一个字符串映射的转换表， 需要两个字符串参数，这两个字符串长度必须相同，一对应。
intab = 'abcd'
outtab = '1234'
str_trantab = str.maketrans(intab,outtab)
# str_trantab就是一个字符串映射的转换表， 制定了-个转换规则，需要两个字符串参数，
#这两个字符串长度必须相同，一对应。
test str = 'http://www.cnblogs.com/jin xin/articles/7459977.html'
print(test_str.translate(str_trantab)) # htp://ww3n2logs.3om/jin xin/titles/759977.html
outtab = '1234'
str_trantab = str.maketrans(intab,outtab)
# str_trantab就是一个字符串映射的转换表， 制定了-个转换规则，需要两个字符串参数，
#这两个字符串长度必须相同，一对应。
test str = 'http://www.cnblogs.com/jin xin/articles/7459977.html'
print(test_str.translate(str_trantab)) # htp://ww3n2logs.3om/jin xin/titles/759977.html
translate
按照maketrans定制的转换表进行相应的转换。
intab = 'abc'
outtab = '123'
deltab = 'xo' #可设置删除元素也可不设置
str_ trantab = str.maketrans(intab,outtab,deltab)
test str = 'http://www.xxooabc.com
print(test_ str.translate(str trantab)) # http://www.123.3m
outtab = '123'
deltab = 'xo' #可设置删除元素也可不设置
str_ trantab = str.maketrans(intab,outtab,deltab)
test str = 'http://www.xxooabc.com
print(test_ str.translate(str trantab)) # http://www.123.3m
rpartition
对字符串按照指定字符(从右边开始数的第一个字符) 进行分割，返回一个元组(分隔符前面的元素,分隔符，“分隔符后面的元素)。
zfill
返回指定长度的字符串，原字符串右对齐，
前面填充0。
前面填充0。
s=‘太白金星'
prits((20)) # 0000000
000太白金星
prits((20)) # 0000000
000太白金星
capitalize
:创建-个首字母大写，其余字母小写的新字符串
s1 = 'taiBai'
print(s1.capitalize0) # Taibai
print(s1.capitalize0) # Taibai
swapcase
创建一个大小写翻转的新字符串
s1 = 'taiBai'
print(s1.swapcase0) # TAIbAI
print(s1.swapcase0) # TAIbAI
center
创建- -个新字符串:字符串居中，可设置字符串的长度，并且可设置填充物
S=‘太白金星'
print(s.center(20,"*)) 3
# *******太白金星******
print(s.center(20,"*)) 3
# *******太白金星******
startswith
判断该字符串以某个字符或者某些字符为开头，并且可以切片，返回的是bool值
S = 'taibai'
print(s.startswith('t')) # True
print(s.startswith('ta")) # True
print(s.startswith(i,2)) # True
print(s.startswith('t')) # True
print(s.startswith('ta")) # True
print(s.startswith(i,2)) # True
endswith
判断该字符串以某个字符或者某些字符为结尾，并相可以切片，返回的是boo值
S = 'taibai'
print(s.endswith(i)) # True
print(s.endswith("bai)) # True
print(s.endswith(i)) # True
print(s.endswith("bai)) # True
isalpha
检测字符串是否全部由字母组成
s1 = 'tai白'
print(s 1.isalpha0) # True中文也识别。
print(s 1.isalpha0) # True中文也识别。
isalnum
检测改字符串是否由数字或者字母组成。返回bool值。
s1 = '1五I alex中'
print(s1.isalnum0) # True这三种数字，以及中英文都识别为数字或者字母
print(s1.isalnum0) # True这三种数字，以及中英文都识别为数字或者字母
isdifit
检测波字符电或yes类型是否只包含t进制的字符这些都不可以:
3.14.三叁，但是可以检测bytes类型)。
3.14.三叁，但是可以检测bytes类型)。
s = '0310'
print(s.isdigit0) # True
S = '3.14'
print(s.isdigit0) # False小数不可以
s1 = '三'
s2= '叁'
s3 = 'I'
print(s1.isdigit() # False汉字数字不可以
print(s2.isdigit0) # False汉字数字不可以
print(s3.isdigit0) # False罗马数字不可以
s1 = b'0310'
print(s1.isdigit0) #不报错，bytes类型有该方法。
print(s.isdigit0) # True
S = '3.14'
print(s.isdigit0) # False小数不可以
s1 = '三'
s2= '叁'
s3 = 'I'
print(s1.isdigit() # False汉字数字不可以
print(s2.isdigit0) # False汉字数字不可以
print(s3.isdigit0) # False罗马数字不可以
s1 = b'0310'
print(s1.isdigit0) #不报错，bytes类型有该方法。
upper
创建- -个全部大写的新的字符串
s = 'taiBai'
print(s.upper0) # TAIBAI
print(s.upper0) # TAIBAI
lower
创建一 个全部变小写新的字符串
S = 'TaiBai'
print(s.lower() # taibai
print(s.lower() # taibai
find
从左边开始通过元素找索引(可切片) ,找到第一个元素就返回， 找不到该元素返回-1
# ret6 = a4.find("fjdk",1,6)
# pintret) #返回的找到的元素的索引，如果找不到返回-1
# pintret) #返回的找到的元素的索引，如果找不到返回-1
rfind
从右边开始通过元素找索引(可切片)，找到第一 个元素就返回， 找不到该元素返回-1
index
通过元素找索引(可切片)，找到第一 个元素就返回， 找不到该元素即报错
# ret61 = a4.index( fjdk ",4,6)
# print(ret61) #返回的找到的元素的索引，找不到报错。
# print(ret61) #返回的找到的元素的索引，找不到报错。
rindex
从右边开始通过元素找索引(可切片),找到第一个元素就返回，找不到该元素报错
count
计算某个元素出现的次数。
S='taibai'
print(s.count('))# 1
print(s.count('))# 1
strip
创建一个新的字符串: 默认去除原字符串前后两端的换行符，制表符，空格
usernamne = inut(请输入姓名: )strpo
if username == 'taibai':
print(登录成功")
if username == 'taibai':
print(登录成功")
lstrip
创建一个新的字符串:默认去除原字符串左(前)端的换行符，制表符， 空格。
rstrip
创建- -个新的字符串:默认去原除字符串右(前)端的换行符，制表符，空格
split
str ---> list
返回一个列表:默认以空格分制可指定分桶符，可设置分割次数
ss = 'alex;wusir;taibai
print(ss.splt(';)) # ['alex', 'wusir', 'taibai']
print(ss.splt(';)) # ['alex', 'wusir', 'taibai']
rsplit
从右往左分割
splitlines
对字符串按照换行符分割，返回一个列表(默认去除分隔符，如果想保存分隔符则设置keepend=True)。
s1 = 'a\tb\nc\nd\ne'
print(s1.splitlines0) # ['a\tb','c, 'd', 'e']
print(s1.splitlines(keepends=True)) # ["a\tb\n'; 'c\n', 'd\n','e']
print(s1.splitlines0) # ['a\tb','c, 'd', 'e']
print(s1.splitlines(keepends=True)) # ["a\tb\n'; 'c\n', 'd\n','e']
join
list -->- str(这个方法非常好，不只是将list转化成str这-个功能)
返回一个字符串:对iterable进行遍历， 通过你设置的连接符将iterable的每个元素通过你的连接符连接起来形成一个新的字符串)
S = 'alex'
s1 = *'join(s)
print(s1)# 'a*l*e*x'
1 = ['alex', 'wusir', '太白"]
s12 = _'join(1)
print(s12) # 'alex wusir太白'
s1 = *'join(s)
print(s1)# 'a*l*e*x'
1 = ['alex', 'wusir', '太白"]
s12 = _'join(1)
print(s12) # 'alex wusir太白'
replace
创建一个新的字符串，将原字符串中概内容替换成新的内容，默认全部替换。
name= 'alex say :i have one tesla,my name is alex'
print(name.replace(' alex'SB',1))
print(name.replace(' alex'SB',1))
format
格式化输出
res='{} } 0' .format'egon';18, male')
res='{1} {0} {1}' format(太白";18, male')
res='{name} {age} {sex}" .format(sex='male',name='太白';age=18)
res='{1} {0} {1}' format(太白";18, male')
res='{name} {age} {sex}" .format(sex='male',name='太白';age=18)
encode
将字符串转化成bytes类型，默认转化成utf-8的bytes类型。
where
需要存储少量的数据，读取文件数据，数据库数据时，等
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉” 是文字，否则它是分不清1和汉'的区别的，因此，在每个编程语言里都会有个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种， int bool str list tuple dict set等
0 条评论
下一页
