python基础数据类型汇总
2020-09-21 10:45:29 0 举报AI智能生成
python基础数据类型操作方法：列表、元组、字典、字符串、bool
作者其他创作
大纲/内容
list（列表）
how
1.可用于索引切片
I = ['太白',[1,2,3,],'WuSir','女神']
print(I[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(I[1]) //[1,2,3]
print([-1]) //'女神'
print([1:3]) //[[1,2,3],'WuSir']
print([::2]) //['太白','WuSir']
print([-1:-4:-1]) //['女神','WuSir',[1,2,3]]
2. 列表的操作方法
增加
append
追加，给列表的最后面追加一个元素
I = [1,2,'a']
I.append(666)
print(I) //[1,2,'a',666]
I.append(666)
print(I) //[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
通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
l = ['太白','alex','WuSir','女神']
ret = l.pop(1)
print(ret,l) //alex['太白','WuSir','女神']
ret = l.pop(1)
print(ret,l) //alex['太白','WuSir','女神']
remove
通过元素删除列表中该元素
l = ['太白','alex','WuSir','女神']
l.remove('alex')
print(l) //['太白','WuSir','女神']
l.remove('alex')
print(l) //['太白','WuSir','女神']
clear
清空列表
l = ['太白','alex','WuSir','女神']
l.clear()
print() //[]
l.clear()
print() //[]
del
按照索引删除该元素
l = ['太白','alex','WuSir','女神']
del l[2]
print(l) //['太白','alex','WuSir','女神']
del l[2]
print(l) //['太白','alex','WuSir','女神']
切片删除该元素
l = ['太白','alex','WuSir','女神']
del l[1]
print(l) //['太白']
del l[1]
print(l) //['太白']
切片（步长）删除该元素
l = ['太白','alex','WuSir','女神']
del l[1:]
print(l) //['alex','女神']
del l[1:]
print(l) //['alex','女神']
修改
按照索引改值
l = ['太白','alex','WuSir','女神']
l[0] = '男神'
print(l) //['男神','alex','WuSir','女神']
l[0] = '男神'
print(l) //['男神','alex','WuSir','女神']
按照切片改值（迭代着增加）
l = ['太白','alex','WuSir','女神']
l[1:3] = 'abcdefg'
print(l) //['太白','a','b','c','d','e','f','g','女神']
l[1:3] = 'abcdefg'
print(l) //['太白','a','b','c','d','e','f','g','女神']
按照切片（步长）改值（必须一一对应）
l = ['太白','alex','WuSir','女神']
l[::2] = '对应'
print(l) //['对','alex','应','女神']
l[::2] = '对应'
print(l) //['对','alex','应','女神']
查看
按照索引查值
按照切片（步长）查值
for循环查值
l = ['太白','[1,2,3],'WuSir','女神']
for i in l:
print(i)
for i in l:
print(i)
其他操作方法
index
通过元素找索引（可切片），找到第一个元素就返回，找不到该元素就报错
l = ['太白','[1,2,3],'WuSir','女神']
print(l.index('太白')) //()
print(l.index('太白')) //()
count
获取某元素在列表中出现的次数
l = ['太白','太白','WuSir','吴超']
print(l.count('太白')) //2
print(l.count('太白')) //2
sort
默认从小到大排列
l = [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]
通过设置参数从大到小排列
l = []
默认从小到大排列
l = [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]
reverse
反转列表
l = ['太白','alex','WuSir','吴超']
l.reverse()
print(l) //['吴超','WuSir','alex','太白']
l.reverse()
print(l) //['吴超','WuSir','alex','太白']
copy
浅copy
只复制框架，框架内容沿用被copy列表
深copy
复制框架与其内部可变内容，不可变元素则沿用元框架中的地址
tuple（元组）
how
可索引切片（步长）
元组的操作方法
改
tu = (1,'太白','['alex',])
// 元组为只读列表，不能增删改其值，只能查，但只对于改来说是相对的。
// 直接属于原组的元素不能改，但是间接属于元祖的原素不一定，比如上面的alex。
// 举个不恰当的例子：儿子不能改，孙子可以改。
tu[-1][0] = '日天'
print(tu)
// 元组为只读列表，不能增删改其值，只能查，但只对于改来说是相对的。
// 直接属于原组的元素不能改，但是间接属于元祖的原素不一定，比如上面的alex。
// 举个不恰当的例子：儿子不能改，孙子可以改。
tu[-1][0] = '日天'
print(tu)
查
可以索引切片（步长）
可以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
dict(字典)
增
通过键值对 直接增加
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) // 没有weight这个键，则添加
print(dic) // {'name':'太白','age':18,'height':175}
dic.setdefault('name','barry') // 有此键则不变
print(dic) // {'name':'太白','age':18,'height':175}
dic.setdefault('height',175) // 没有weight这个键，则添加
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}
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.clear()
print(dic) // {}
dic.clear()
print(dic) // {}
del
通过键删除键值对
dic = {'name':'太白','age':18}
dic.clear()
print(dic) // {'age':18}
dic.clear()
print(dic) // {'age':18}
del dic 删除整个字典
改
通过键值对直接改
dic = {'name':'太白','age':18}
del dic['name']
print(dic) // {'age':18}
del dic['name']
print(dic) // {'age':18}
update
源码： D.update([E, ]**F) -> None. Update D from dict/iterable E and F. If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
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}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}
查
通过键查询
直接dic[key]（没有此键会报错）
dic = {'name': '太白', 'age': 18} 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) # 没有此键
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'])
values()
dic = {'name': '太白', 'age': 18} print(dic.values()) # dict_values(['太白', 18])
items()
dic = {'name': '太白', 'age': 18} print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])
利用for循环
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: '太白'}
dic = dict.fromkeys([1, 2, 3],'太白')
print(dic) # {1: '太白', 2: '太白', 3: '太白'}
copy
浅copy
int（整型）
how
+ - * / % ** // ....
bool（布尔值）
1 > 2 and 3 < 4 等逻辑判断，或者一些空数据（转化成bool值为False） 等。
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)
#按照切片取值[起始索引:结尾索引+1:步长] 顾头不顾腚
s6 = s1[0:4]
s6 = s1[:5] # 从开头取值可以不写0
s7 = s1[5:] # 取到最后什么都不写
s8 = s1[:5:2]
# 反向取值 [起始索引:结尾索引-1:-步长] 顾头不顾腚
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)
#按照切片取值[起始索引:结尾索引+1:步长] 顾头不顾腚
s6 = s1[0:4]
s6 = s1[:5] # 从开头取值可以不写0
s7 = s1[5:] # 取到最后什么都不写
s8 = s1[:5:2]
# 反向取值 [起始索引:结尾索引-1:-步长] 顾头不顾腚
s9 = s1[-1:-4:-1]
print(s9)
字符串的操作方法（带颜色的标为重要方法）
title
创建一个新的字符串：字符串非字母元素隔开的每个单词的首字母大写
s = 'alex wusir8taibai*ritian' s4 = s.title()
print(s4) # Alex Wusir8Taibai*Ritian
print(s4) # Alex Wusir8Taibai*Ritian
casefold
返回一个新的字符串全部为小写
与lower相似，但是lower只能转换ASCCI码中的字母，而此方法可以转换非中文的其他语言，比如德语，葡萄牙语等。
format_map
格式化输出，可以通过字典的形式。
s = '我的名字：{name}，年龄：{age}' ret = s.format_map({'name':'太白','age':18})
print(ret)
print(ret)
expandtabs
将字符串中的制表符：\t默认转化成8个空格
s = 'ta\ti' print(s.expandtabs()) # ta i
isdecimal
检测该字符串只包含十进制的字符（这些都不可以：3.14，三，叁，III）
# s1 = '0310' # print(s1.isdecimal()) # True
# s1 = '3.14'
# print(s1.isdecimal()) # False 小数不可以
s1 = '三叁Ⅲ'
print(s1.isdecimal()) # False 汉字数字，罗马数字 不可以
# s1 = b'0310'
# print(s1.isdecimal()) # 报错，bytes类型没有该方法。
# s1 = '3.14'
# print(s1.isdecimal()) # False 小数不可以
s1 = '三叁Ⅲ'
print(s1.isdecimal()) # False 汉字数字，罗马数字 不可以
# s1 = b'0310'
# print(s1.isdecimal()) # 报错，bytes类型没有该方法。
isnumeric
检测该字符串只包含十进制的字符（小数不可以：3.14，这些都可以：叁，三，III）
s = '0310' print(s.isnumeric()) # True
s = '3.14'
print(s.isnumeric()) # False 小数不可以
s1 = '三'
s2 = '叁'
s3 = 'Ⅲ'
print(s1.isnumeric()) # True 汉字数字可以
print(s2.isnumeric()) # True 汉字数字可以
print(s3.isnumeric()) # True 罗马数字可以
s1 = b'0310'
print(s1.isnumeric()) # 报错，bytes类型没有该方法。
s = '3.14'
print(s.isnumeric()) # False 小数不可以
s1 = '三'
s2 = '叁'
s3 = 'Ⅲ'
print(s1.isnumeric()) # True 汉字数字可以
print(s2.isnumeric()) # True 汉字数字可以
print(s3.isnumeric()) # True 罗马数字可以
s1 = b'0310'
print(s1.isnumeric()) # 报错，bytes类型没有该方法。
isidentifier
判断该字符串是否是python中的关键字
s1 = 'def' s2 = 'break'
s3 = 'if'
print(s1.isidentifier()) # True
print(s2.isidentifier()) # True
print(s3.isidentifier()) # True
s3 = 'if'
print(s1.isidentifier()) # True
print(s2.isidentifier()) # True
print(s3.isidentifier()) # True
islower
判断该字符串是否全部由小写字母组成
s1 = 'alex' print(s1.islower()) # True
isprintable
判断该字符串中所有字符是否是可打印的字符（含有换行符，制表符等这些字符都会返回False，含有空格返回True）
s1 = '!' s2 = '#'
s3 = '太白\t'
s4 = '\n太白'
s5 = 'barry太'
s6 = ' '
print(s1.isprintable()) # True
print(s2.isprintable()) # True
print(s3.isprintable()) # False
print(s4.isprintable()) # False
print(s5.isprintable()) # True
print(s6.isprintable()) # True
s3 = '太白\t'
s4 = '\n太白'
s5 = 'barry太'
s6 = ' '
print(s1.isprintable()) # True
print(s2.isprintable()) # True
print(s3.isprintable()) # False
print(s4.isprintable()) # False
print(s5.isprintable()) # True
print(s6.isprintable()) # True
partition
对字符串按照指定字符进行分割，返回一个元组（‘分隔符前面的元素’，‘分隔符’，‘分隔符后面的元素’）
s1 = '日天,太白,吴超' print(s1.partition(',')) # ('日天', ',', '太白,吴超')
s1 = '日天,太白,吴超' print(s1.partition(',')) # ('日天', ',', '太白,吴超')
s1 = '日天,太白,吴超' print(s1.partition(',')) # ('日天', ',', '太白,吴超')
isspace
判断该字符串全部由空格或者制表符或者换行符组成，至少含有一个字符
s1 = ' ' s2 = '\t'
s3 = '\n'
print(s1.isspace())
print(s2.isspace())
print(s3.isspace())
s3 = '\n'
print(s1.isspace())
print(s2.isspace())
print(s3.isspace())
istitle
判断组成该字符串的标题内容是否是首字母大写（如果满足规定的标题（非字符隔开的每一个单词理解为标题）全部都是首字母大写）
isupper
判断该字符串全部都是大写字母组成，则返回True
ljust
返回一个左对齐并且设置总宽度的字符串填充物默认为空
rjust
返回一个右对齐并且设置总宽度的字符串填充物默认为空
makereans
就是制定一个字符串映射的转换表，需要两个字符串参数，这两个字符串长度必须相同，一一对应
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)) # http://www.3n2logs.3om/jin-xin/1rti3les/7459977.html
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)) # http://www.3n2logs.3om/jin-xin/1rti3les/7459977.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
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
s = '太白金星' print(s.zfill(20)) # 0000000000000000太白金星
capitalize
创建一个首字母大写，其余字母小写的新字符串
s1 = 'taiBai'
print(s1.swapcase()) # TAIbAI
center
print(s1.swapcase()) # TAIbAI
center
swapcase
创建一个大小写反转的新字符串
s1 = 'taiBai'
print(s1.swapcase()) # TAIbAI
print(s1.swapcase()) # TAIbAI
center
创建一个新字符串：字符串居中，可设置字符串的长度，并且可以设置填充物
s = '太白金星'
print(s.center(20,'*')) # ********太白金星********
print(s.center(20,'*')) # ********太白金星********
startswith
判断该字符串以某个字符串或者某些字符为开头，并且可以切片，返回的就是bool值
s = 'taibai' print(s.startswith('t')) # True
print(s.startswith('ta')) # True
print(s.startswith('i',2,)) # True
print(s.startswith('ta')) # True
print(s.startswith('i',2,)) # True
endswith
判断该字符串以某个字符或者某些字符为结尾，并且可以切片，返回时bool值
s = 'taibai' print(s.endswith('i')) # True
print(s.endswith('bai')) # True
print(s.endswith('bai')) # True
isalpha
检测字符串是否全部由字母组成
s1 = 'tai白'
print(s1.isalpha()) # True 中文也识别。
print(s1.isalpha()) # True 中文也识别。
isalnum
检测该字符串是否由数字或者字母组成。返回bool值
s1 = '1五Ⅰalex中'
print(s1.isalnum()) # True 这三种数字，以及中英文都识别为数字或者字母
print(s1.isalnum()) # True 这三种数字，以及中英文都识别为数字或者字母
isdigit
检测该字符串或bytes类型是否只包含十进制的字符（这些都不可以：3.14，三，叁，III，但是可以检测bytes类型）
s = '0310' print(s.isdigit()) # True
s = '3.14'
print(s.isdigit()) # False 小数不可以
s1 = '三'
s2 = '叁'
s3 = 'Ⅲ'
print(s1.isdigit()) # False 汉字数字不可以
print(s2.isdigit()) # False 汉字数字不可以
print(s3.isdigit()) # False 罗马数字不可以
s1 = b'0310'
print(s1.isdigit()) # 不报错，bytes类型有该方法。
s = '3.14'
print(s.isdigit()) # False 小数不可以
s1 = '三'
s2 = '叁'
s3 = 'Ⅲ'
print(s1.isdigit()) # False 汉字数字不可以
print(s2.isdigit()) # False 汉字数字不可以
print(s3.isdigit()) # False 罗马数字不可以
s1 = b'0310'
print(s1.isdigit()) # 不报错，bytes类型有该方法。
upper
创建一个全部大写的新的字符串
s = 'taiBai'
print(s.upper()) # TAIBAI
print(s.upper()) # TAIBAI
lower
创建一个全部变小写的新的字符串
s = 'TaiBai'
print(s.lower()) # taibai
print(s.lower()) # taibai
find
从左边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素返回-1
# ret6 = a4.find("fjdk",1,6)
# print(ret6) # 返回的找到的元素的索引，如果找不到返回-1
# print(ret6) # 返回的找到的元素的索引，如果找不到返回-1
rfind
从右边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素返回-1
index
通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错
# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到报错。
# print(ret61) # 返回的找到的元素的索引，找不到报错。
rindex
从右边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素报错
count
计算某个元素出现的次数
s = 'taibai'
print(s.count('t')) # 1
print(s.count('t')) # 1
strip
创建一个新的字符串：默认去除原字符串前后两端的换行符，制表符，空格
username = input('请输入姓名：').strip()
if username == 'taibai':
print('登录成功')
if username == 'taibai':
print('登录成功')
lstrip
创建一个新的字符串： 默认去除原字符串左（前）端的换行符，制表符，空格
rstrip
创建一个新的字符串：默认去除原字符串右（前）端的换行符，制表符，空格
split
str --->list
返回一个列表：默认以空格分割，可指定分隔符，可设置分割次数
ss = 'alex;wusir;taibai'
print(ss.split(';')) # ['alex', 'wusir', 'taibai']
print(ss.split(';')) # ['alex', 'wusir', 'taibai']
rsplit
从右往左分割
splitlines
对字符串按照换行符分割，返回一个列表（默认去除分隔符，如果想保存分隔符则设置keepend = True）
s1 = 'a\tb\nc\nd\ne'
print(s1.splitlines()) # ['a\tb', 'c', 'd', 'e']
print(s1.splitlines(keepends=True)) # ['a\tb\n', 'c\n', 'd\n', 'e']
print(s1.splitlines()) # ['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'
l1 = ['alex', 'wusir', '太白']
s12 = '_'.join(l1)
print(s12) # 'alex_wusir_太白'
print(s1) # 'a*l*e*x'
l1 = ['alex', 'wusir', '太白']
s12 = '_'.join(l1)
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='{} {} {}'.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类型
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，int bool str list tuple dict set 等
0 条评论
下一页
为你推荐
查看更多
