python字符串内置函数.docx
《python字符串内置函数.docx》由会员分享，可在线阅读，更多相关《python字符串内置函数.docx（22页珍藏版）》请在冰豆网上搜索。
python字符串内置函数
1、字符串
定义：
它是一个有序的字符的集合，用于存储和表示基本的文本信息，‘’或“”或‘’‘’‘’中间包含的内容称之为字符串
特性：
1.只能存放一个值
2.不可变
3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
补充：
1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l\thf'
2.unicode字符串与r连用必需在r前面，如name＝ur'l\thf'
2、字符串常用操作
1
2
3
4
5
6
#1字母处理：
.upper（） #全部大写
.lower（） #全部小写
.swapcase（） #大小写互换
.capitalize（） #首字母大写，其余小写
.title（） #首字母大写
a='helLO'
print（a.upper（））#全部大写
print（a.lower（））#全部小写
print（a.swapcase（））#大小写互换
print（a.capitalize（））#首字母大写，其余小写
print（a.title（））#首字母大写
1
2
3
4
5
6
#2格式化相关
.ljust（width） #获取固定长度，左对齐，右边不够用空格补齐
.rjust（width） #获取固定长度，右对齐，左边不够用空格补齐
.center（width） #获取固定长度，中间对齐，两边不够用空格补齐
.zfill（width） #获取固定长度，右对齐，左边不足用0补齐
a='12'
print（a.ljust（10））#获取固定长度，左对齐，右边不够用空格补齐
print（a.rjust（10））#获取固定长度，右对齐，左边不够用空格补齐
print（a.center（10））#获取固定长度，中间对齐，两边不够用空格补齐
print（a.zfill（10））#获取固定长度，右对齐，左边不足用0补齐
执行结果：
12
12
12
000000012
1
2
3
4
5
6
7
8
#3字符串搜索相关
.find（） #搜索指定字符串，没有返回-1
.index（） #同上，但是找不到会报错
.rfind（） #从右边开始查找
.count（） #统计指定的字符串出现的次数
#上面所有方法都可以用index代替，不同的是使用index查找不到会抛异常，而find返回-1
s='helloworld'
print（s.find（'e'））#搜索指定字符串,没有返回-1
print（s.find（'w',1,2））#顾头不顾尾，找不到则返回-1不会报错，找到了则显示索引
print（s.index（'w',1,2））#同上，但是找不到会报错
print（s.count（'o'））#统计指定的字符串出现的次数
print（s.rfind（'l'））#从右边开始查找
#4字符串替换
.replace（'old','new'）#替换old为new
.replace（'old','new',次数）#替换指定次数的old为new
s='helloworld'
print（s.replace（'world','python'））
print（s.replace（'l','p',2））
print（s.replace（'l','p',5））
执行结果：
hellopython
heppoworld
heppoworpd
#5字符串去空格及去指定字符
.strip（）#去两边空格
.lstrip（）#去左边空格
.rstrip（）#去右边空格
.split（）#默认按空格分隔
.split（'指定字符'）#按指定字符分割字符串为数组
s='he-llo'
print（s）
print（s.strip（））
print（s.lstrip（））
print（s.rstrip（））
print（s.split（'-'））
print（s.split（））
#6字符串判断相关
.startswith（'start'）#是否以start开头
.endswith（'end'）#是否以end结尾
.isalnum（）#是否全为字母或数字
.isalpha（）#是否全字母
.isdigit（）#是否全数字
.islower（）#是否全小写
.isupper（）#是否全大写
.istitle（）#判断首字母是否为大写
.isspace（）#判断字符是否为空格
#补充
bin（）#十进制数转八进制
hex（）#十进制数转十六进制
range（）#函数：
可以生成一个整数序列
type（）#查看数据类型
len（）#计算字符串长度
format（）#格式化字符串，类似%s，传递值能多不能少
3、python中str函数isdigit、isdecimal、isnumeric的区别
1
2
3
4
5
6
7
8
9
10
11
12
13
14
isdigit（）
True:
Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
False:
汉字数字
Error:
无
isdecimal（）
True:
Unicode数字，，全角数字（双字节）
False:
罗马数字，汉字数字
Error:
byte数字（单字节）
isnumeric（）
True:
Unicode数字，全角数字（双字节），罗马数字，汉字数字
False:
无
Error:
byte数字（单字节）
4、内置函数
∙ 数学运算（7个）
∙ 类型转换（24个）
∙ 序列操作（8个）
∙ 对象操作（7个）
∙ 反射操作（8个）
∙ 变量操作（2个）
∙ 交互操作（2个）
∙ 文件操作（1个）
∙ 编译执行（4个）
∙ 装饰器（3个）
数学运算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
abs：
求数值的绝对值
abs（-2）
divmod：
返回两个数值的商和余数
divmod（5,2）
divmod（5.5,2）
max：
返回迭代对象中的元素的最大值或者所有参数的最大值
max（1,2,3） #传入3个参数取3个中较大者
max（'1234'） #传入1个可迭代对象，取其最大元素值
max（-1,0,key=abs） #传入了求绝对值函数，则参数都会进行求绝对值后再取较大者
min：
返回可迭代对象中的元素的最小值或者所有参数的最小值
min（1,2,3） #传入3个参数取3个中较小者
min（'1234'） #传入1个可迭代对象，取其最小元素值
min（-1,-2,key=abs） #传入了求绝对值函数，则参数都会进行求绝对值后再取较小者
pow：
返回两个数值的幂运算值或其余指定整数的模值
pow（2,3）
round：
对浮点数进行四舍五入求值
round（1.1111,1）
sum：
对元素类型是数值的可迭代对象中的每个元素求和
sum（（1,2,3,4）） #传入可迭代对象、元素类型必须是数值型
类型转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
bool：
根据传入的参数的逻辑值创建一个新的布尔值
bool（）或bool（0） #数值0、空值为False
int：
根据传入的参数创建一个新的整数
int（） #不传入参数时，得到结果0
float：
根据传入的参数创建一个新的浮点数
float（） #不提供参数的时候，返回0.0
complex：
根据传入参数创建一个新的复数
complex（） #当两个参数都不提供时，返回复数0j
str：
返回一个对象的字符串表现形式（给用户）
bytearray：
根据传入的参数创建一个新的字节数组
bytearray（'中文','utf-8'）
bytearray（b'\xe4\xb8\xad\xe6\x96\x87'）
bytes：
根据传入的参数创建一个新的不可变字节数组
bytes（'中文','utf-8'）
b'\xe4\xb8\xad\xe6\x96\x87'
memoryview：
根据传入的参数创建一个新的内存查看对象
v=memoryview（b'asdf'）
print（v[0]） #97
print（v[-1]） #102
ord：
返回Unicode字符对应的整数
print（ord（'a'））
chr：
返回整数所对应的Unicode字符
print（chr（97））
bin：
将整数转换成2进制字符串
oct：
将整数转化成8进制数字符串
hex：
将整数转换成16进制字符串
tuple：
根据传入的参数创建一个新的元组
list：
根据传入的参数创建一个新的列表
dict：
根据传入的参数创建一个新的字典
set：
根据传入的参数创建一个新的集合
frozenset：
根据传入的参数创建一个新的不可变集合
a=frozenset（range（10））
print（a）
#frozenset（{0,1,2,3,4,5,6,7,8,9}）
enumerate：
根据可迭代对象创建枚举对象
l1=['one','two','three','five']
print（list（enumerate（l1）））
#[（0,'one'）,（1,'two'）,（2,'three'）,（3,'five'）]
print（list（enumerate（l1,start=1））） #指定起始值
#[（1,'one'）,（2,'two'）,（3,'three'）,（4,'five'）]
range：
根据传入的参数创建一个新的range对象
iter：
根据传入的参数创建一个新的可迭代对象
a=iter（'asdf'）
print（a） #
print（next（a）） #a
print（next（a）） #s
print（next（a）） #d
print（next（a）） #f
print（next（a）） #报错StopIteration
slice：
根据传入的参数创建一个新的切片对象
c1=slice（5）
print（c1） #slice（None,5,None）
c1=slice（2,5）
print（c1） #slice（2,5,None）
c1=slice（1,4,7）
print（c1） #slice（1,4,7）
super：
根据传入的参数创建一个新的子类和父类关系的代理对象
#定义父类A类
class A（object）:
def __init__（self）:
print（A.__init__）
#定义子类，继承A
class B（A）:
def __init__（self）:
print（B.__init__）
super（）.__init__（）
#super调用父类方法
b=B（）
print（b）
object：
创建一个新的object对象
1
序列操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
all：
判断可迭代对象的每个元素是否都为True值
print（all（[1,2]）） #列表中每个元素逻辑值均为True，返回True
print（all（[0,2]）） #列表中0的逻辑值为False，返回False
any：
判断可迭代对象的元素是否有为True值的元素
#列表元素有一个为True，则返回True
#列表元素全部为False，则返回False
filter：
使用指定方法过滤可迭代对象的元素
map：
使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象
next：
返回可迭代对象中的下一个元素值
#传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，则返回default指定的默认值而不抛出StopIteration异常
reversed：
反转序列生成新的可迭代对象
sorted：
对可迭代对象进行排序，返回一个新的列表
zip：
聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
对象操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
help：
返回对象的帮助信息
dir：
返回对象或者当前作用域内的属性列表
id：
返回对象的唯一标识符
hash：
获取对象的哈希值
type：
返回对象的类型，或者根据传入的参数创建一个新的类型
len：
返回对象的长度
ascii：
返回对象的可打印表字符串表现方式
format：
格式化显示值
vars：
返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
class A（object）:
pass
a=A（）
print（a.__dict__） #{}
print（vars（a）） #{}
a.name='buer'
print（a.__dict__） #{'name':
'buer'}
print（vars（a）） #{'name':
'buer'}
反射操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
__import__：
动态导入模块
print（__import__（'os'））
print（__import__（'time'））
#\\Python36\\lib\\os.py'>
#
isinstance：
判断对象是否是类或者类型元组中任意类元素的实例
issubclass：
判断类是否是另外一个类或者类型元组中任意类元素的子类
hasattr：
检查对象是否含有属性
class Student:
def __init__（self,name）:
self.name=name
s=Student（'Ethan'）
print（hasattr（s,'name'）） #含有name属性为True
print（hasattr（s,'age'）） #不含有age属性为False
getattr：
获取对象的属性值
print（getattr（s,'name'）） #存在属性name，Ethan
print（getattr（s,'age',20）） #不存在属性age，但提供了默认值，返回默认值
print（getattr（s,'age'）） #不存在属性age，未提供默认值，调用报错
报错如下：
Traceback（mostrecentcalllast）:
File "D:
/test.py",line 30, in
print（getattr（s,'age'））
AttributeError:
'Student' object hasnoattribute 'age'
setattr：
设置对象的属性值
print（s.name） #Ethan
setattr（s,'name','Tom'） #name属性存在，做赋值操作
setattr（s,'age',18） #age属性不存在，创建这个属性
print（s.name） #Tom
print（s.age） #18
delattr：
删除对象的属性
class Student:
def __init__（self,name）:
self.name=name
def foo（self）:
print（'hello%s' % self.name）
a=Student（'Ethan'）
print（a.name） #Ethan
print（a.foo（）） #helloEthan
print（delattr（a,'name'）） #name属性被删除
print（a.name） #调用报错
Traceback（mostrecentcalllast）:
File "D:
/test.py",line 50, in
print（a.name） #调用报错
AttributeError:
'Student' object hasnoattribute 'name'
callable：
检测对象是否可被调用
class B:
def __call__（self, *args, **kwargs）:
print（'instancesarecallablenow'）
print（callable（B）） #类B是可调用对象
b=B（） #调用类B
print（callable（b）） #实例b是可调用对象
print（b（）） #调用实例b成功
#instancesarecallablenow
变量操作
1
2
globals：
返回当前作用域内的全局变量和其值组成的字典
locals：
返回当前作用域内的局部变量和其值组成的字典
交互操作
1
2
3
print：
向标准输出对象打印输出
input：
读取用户输入值
user=input（'pleaseinputyourname:
'）
文件操作
1
2
3
4
5
6
7
8
9
open：
使用指定的模式和编码打开文件，返回文件读写对象
#写入文件
a= open（'a.text','w'）
a.write（'124sdgadgahgggadh'）
#读取文件
a= open（'a.text','rt'）
print（a.read（））
a.close（）
编译执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
compile：
将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值
#流程语句使用exec
code1='foriinrange（5）:
print（i）'
compile1=compile（code1,'','exec'）
exec （compile1）
#0
#1
#2
#3
#4
#简单求值表达式用eval
code2='1+2+3+4'
compile2=compile（code2,'','eval'）
print（eval（compile2）） #10
eval：
执行动态表达式求值
print（eval（'1+2+3+4'）） #10
print（eval（'2*2*2'）） #8
print（eval（'10/2+2*2'）） #9.0
exec：
执行动态语句块
exec （'a=1+2'）
print（a） #3
exec （'b=4*3/2-1'）
print（b） #5.0
repr：
返回一个对象的字符串表现形式（给解释器）
a='helloworld'
print（str（a）） #helloworld
print（repr（a）） #'helloworld'
装饰器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
property：
标示属性的装饰器
class A:
def __init__（self）:
pa
升级会员 