7、str字符串的内置函数---Python

特性：
1、字符串一旦创建，不可修改
2、一旦修改或者拼接，都会重新生成新字符串

 

Python转义字符

Python字符串运算符

Python字符串格式化

%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

Python的字符串内建函数

方法	描述
string.capitalize()	把字符串的第一个字符大写
string.center(width)	返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'
string.encode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
string.endswith(obj, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
string.isdecimal()	如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()	如果 string 只包含数字则返回 True 否则返回 False.
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()	如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()	如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()	如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width)	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()	转换 string 中所有大写字符为小写.
string.lstrip()	截掉 string 左边的空格
string.maketrans(intab, outtab])	maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.partition(str)	有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2,  num=string.count(str1))	把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) )	类似于 find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string))	类似于 index()，不过是从右边开始.
string.rjust(width)	返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)	类似于 partition()函数,不过是从右边开始查找.
string.rstrip()	删除 string 字符串末尾的空格.
string.split(str="", num=string.count(str))	以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
string.splitlines(num=string.count('\n'))	按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj])	在 string 上执行 lstrip()和 rstrip()
string.swapcase()	翻转 string 中的大小写
string.title()	返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中
string.upper()	转换 string 中的小写字母为大写
string.zfill(width)	返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
string.isdecimal()	isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

1. replace替换

# def replace(self, old, new, count=None)
print("***replace替换***")
print("jasonjasonjason".replace("a","bb")) # jbbsonjbbsonjbbson
print("jasonjasonjason".replace("a","bb",1)) # jbbsonjasonjason
print("jasonjasonjason".replace("a","bb",2)) # jbbsonjbbsonjason

2. 首字母大写

# 将单词格式化为：首字母大写
v1 = str1.capitalize()
print(v1) # Alex

3. 转小写

# 将字符格式化为：全小写
# casefold功能更强大，会将法语等其他语言的字符也全部小写
v2 = str1.casefold() # alex
v3 = str1.lower() # alex
print(v2)
print(v3)

***小写***

# 转小写
# 判断是否全小写
print("***章节：小写***")
print("LaSa".islower()) # False
print("LaSa".lower()) # lasa
print("LaSa".lower().islower()) # True

 

***大写***

# ***章节：大写***
# 转大写
# 判断是否全大写
print("***章节：小写***")
print("LaSa".isupper()) # False
print("LaSa".upper()) # LASA
print("LaSa".upper().isupper()) # True

 

4. 填充

def center(self, width, fillchar=None) ： 居中填充，字符串格式化固定宽度，并居中
width：宽度
fillchar：填充字符，默认为空格

# def center(self, width, fillchar=None)
# （居中）格式化固定宽度，并设定填充字符
v4 = str1.center(20, "-")
print(v4) # --------aLex--------

 ljust(self, width, fillchar=None) 左起，右填充
 rjust(self, width, fillchar=None) 右起，左填充

# ljust(self, width, fillchar=None) 左起，右填充
# rjust(self, width, fillchar=None) 右起，左填充
print("填充")
print("alex".ljust(20,"*")) # alex****************
print("alex".rjust(20,"*")) # ****************alex

 

5. 统计子序列总数

def count(self, sub, start=None, end=None) 从start到end之间，统计子序列总数

# 从start到end之间，统计子序列总数
# sub： 子序列，即子字符串
# start: 起始位置
# end: 结束
string1 = 'aLEx is a woman, who is a nurse'
v5 = string1.count('is')
print(v5)

6. 判断是否以sub开头或结尾

str1 = 'aLex'
a = str1.startswith("a") # True
print(a)
e = str1.endswith("ex") # True
print(e)

7. 寻找子序列第一次 出现的位置

find

# 从[start,end)找子序列的第一个位置索引
# 无该子序列，则返回-1
test = "alexalex"
v = test.find('ex',0,8) # 2
print(v)

 

8. 子序列的第一个位置索引

index

# 从[start,end)找子序列的第一个位置索引
# index找不到子序列，则报异常
v1 = test.index('ex')
print(v1)

 

9. 占位符：字符串中引用变量及变量赋值

format(kvargs**)

# 字符串中引用变量：{name}和{num}
test = 'i am {name}, age {num}'
print(test) # i am {name}, age {num}
# 为字符串中变量赋值
v = test.format(name='alex', num=19)
print(v) # i am alex, age 19

 

10. 字符串中引用变量

format(args**)
format_map(mapping)

# 字符串中引用变量：{0}和{1}
test = 'i am {0}, age {1}'
print(test) # i am {0}, age {1}

# 为字符串中变量赋值
v = test.format('alex', 19)
print(v) # i am alex, age 19

# 字符串中引用变量：{name}和{num}
test = 'i am {name}, age {num}'

print(test) # i am {name}, age {num}

# 为字符串中变量赋值
v = test.format(name='alex', num=19)
print(v) # i am alex, age 19

v1 = test.format_map({"name":'alex', "num":19})
print(v1) # i am alex, age 19

11. 判断是否字母和数字组成的字符串

isalnum()     isalpha()

test1 = "usdfd839"
# 是否字母和数字组成的字符串
v = test1.isalnum() # True
v1 = test1.isalpha() # False， 是否为字母序列
strTest = "abddfj"
s1 = strTest.isalpha() # True， 是否为字母序列

 

12. 是否数字函数

isdecimal() ：键盘数字
isdigit() ：键盘数字、②等数字
isnumeric() ：键盘数字、②、贰

numTest = "123"
v1 = numTest.isdecimal() # True，是否键盘数字
v2 = numTest.isdigit() # True，包括②等数字
print("②".isdigit()) # True
print("贰".isdigit()) # False
print("贰壹②".isnumeric()) # True
print("Ⅱ".isdigit()) # False
print("Ⅱ".isdecimal()) # False

 

13. 制表，输出

def expandtabs(self, tabsize: int = 8)：制表，输出

# def expandtabs(self, tabsize: int = 8)
# expandtabs，制表: \n断句 \t对齐
# tabsize：长度，使用空格填充对齐
test2 = "username\temail\tpassword\nlaiying\tying@qq.com\t123\nlaiying\tying@qq.com\t123\nlaiying\tying@qq.com\t123"
v2 = test2.expandtabs(20)
print(v2)

print(v2)如下：

username email password
laiying ying@qq.com 123
laiying ying@qq.com 123
laiying ying@qq.com 123

 

14. 反转大小写

# 反转大小写
print("aLex".swapcase()) # AlEX
print("ALex".swapcase()) # alEX

15. 是否正确的标识符

是否正确命名规则，也包括关键字def class

# 是否正确的标识符：即是否正确命名规则，也包括关键字def class
print("def".isidentifier()) # True
print("class".isidentifier()) # True
print("_123".isidentifier()) # True
print("123".isidentifier()) # False
print("userName".isidentifier()) # True

 

16. 是否全部为可见字符

isprintable() 是否全部为可见字符

# isprintable() 是否全部为可见字符
# 不可见字符: \t \n \001
print("是否全部为可见字符")
print("dfsdifhfd337&&***//".isprintable()) # True
print("dfsdi\nfhfd337\001&&***//".isprintable()) # False
print("dfsdifhfd337\001&&***//".isprintable()) # False

 

17. 是否全部为空格

isspace()是否全部为空格

# isspace()是否全部为空格
print(" ".isspace()) # True
print(" \t".isspace()) # True
print(" \001".isspace()) # False
print(" \n".isspace()) # True

 

18. 标题函数

istitle() 判断是否为标题
title() 转换为标题

print("是否为标题（只能判断英文）")
print("Process finished with exit code 0".istitle()) # False
print("Process finished with exit code 0".title()) # Process Finished With Exit Code 0
print("Process finished with exit code 0".title().istitle()) # True

 

19.拼接:

将字符串中的每一个元素按指定分隔符进行拼接

print("将字符串中的每一个元素按指定分隔符进行拼接")
print(" ".join("你是风儿我是沙")) # 你 是 风 儿 我 是 沙
print("_".join("你是风儿我是沙")) # 你_是_风_儿_我_是_沙

# 拼接字符串元素
v = "_".join("abcde")

# 拼接列表元素
v = "_".join(['jason', 'rose']) # jason_rose

 

20. 去除空格(包括\n \t)

去除指定字符序列
去除匹配字符序列，优先最长字符序列，再依次删除匹配的短子序列

print("去除空格(包括\n \t) 和 去除指定字符序列")
print(" haha ".lstrip())
print(" haha ".rstrip())
print(" haha ".strip())
print(" haha ".strip())
print("\n haha ".strip())
print("dfhahadf".lstrip('df')) # hahadf
print("dfhahadf".rstrip('df')) # dfhaha
print("dfhahadf".strip('df')) # haha

 

21. 递归匹配删除：

去除匹配字符序列，优先最长字符序列，再依次删除匹配的短子序列
ps：删除最长匹配后，剩余的序列再继续匹配删除

print("dfhahadf".rstrip('9adf')) # dfhah
print("dfhahadf".rstrip('9adfah')) # 全删：从右开始删adf，再删ah，再删h，再删df

22. 将对应位置的字符进行替换

# 构建映射表：tr_tab = str.maketrans("abcdef","123456")
# 执行映射替换：srcStr.translate(tr_tab)
# 将对应位置的字符进行替换
# abcdef
# 123456
# 构建映射表：str.maketrans("abcdef","123456")
# 执行映射替换：srcStr.translate(tr_tab)
tr_tab = str.maketrans("abcdef","123456")
strList = "fasdfjbaczxjivewr;oifajmewirkcvxweafo;dsapojnsafdk"
tranList = strList.translate(tr_tab)
print(tranList) # 61s46j213zxjiv5wr;oi61jm5wirk3vxw516o;4s1pojns164k

 

23. 分隔

def partition(self, sep) ： 指定sep分隔，返回包含sep
def rpartition(self, sep)： 从右开始，指定sep分隔，返回包含sep
def split(self, sep=None, maxsplit=-1)： 指定sep分隔，返回不包含sep，分隔次数maxsplit
def rsplit(self, sep=None, maxsplit=-1)

# 分隔
#
print("***分隔***")
print("testadfkajoeiawjfs".partition("a")) # ('test', 'a', 'dfkajoeiawjfs')
print("testadfkajoeiawjfs".rpartition("a")) # ('testadfkajoei', 'a', 'wjfs')

print("testadfkajoeiawjfs".split("a")) # ['test', 'dfk', 'joei', 'wjfs']
print("testadfkajoeiawjfs".split("a",1)) # ['test', 'dfkajoeiawjfs']
print("testadfkajoeiawjfs".split("a",2)) # ['test', 'dfk', 'joeiawjfs']
print("testadfkajoeiawjfs".rsplit("a",2)) # ['testadfk', 'joei', 'wjfs']
print("testadfkajoeiawjfs".split("a",6)) # ['test', 'dfk', 'joei', 'wjfs']
print("testadfkajoeiawjfs".rsplit("a",6)) # ['test', 'dfk', 'joei', 'wjfs']

print(v) # range(0, 100)

in_str = "33+88"
v1, v2 = in_str.split('+')
print(in_str, '=', int(v1) + int(v2)) # 121

 

24. 分隔，分页，换行

def splitlines(self, keepends=None) : keepends是否保留换行符，默认False

# 分隔，分页，换行
# def splitlines(self, keepends=None) : keepends是否保留换行符
print("fdahsf\niensdka\npoieafl\nfewascsakdn".splitlines()) # ['fdahsf', 'iensdka', 'poieafl', 'fewascsakdn']
print("fdahsf\niensdka\npoieafl\nfewascsakdn".splitlines(False)) # ['fdahsf', 'iensdka', 'poieafl', 'fewascsakdn']
print("fdahsf\niensdka\npoieafl\nfewascsakdn".splitlines(True)) # ['fdahsf\n', 'iensdka\n', 'poieafl\n', 'fewascsakdn']

25. 长度 len(str)

print(len("first")) # 5

# Python3: len获取当前字符串中有几个字符
# Python27：len获取字符串占几个字节，utf8单个中文3字节
print(len("张五常")) # 3

 

26. 下标索引

字符串实际上就是字符的数组，所以也支持下标索引。
如果有字符串name = 'abcdef'，在内存中的实际存储如下:

1、下标

如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）

name = 'abcdef'   

print(name[0]) # a   
print(name[1]) # b   
print(name[-2])  //负数表示从右边开始：-2表示右边第二个

ps：字符串中，不可通过下标修改值，只可通过下标取值

# 字符串不支持更改元素值
name = 'abcdef'
name[3] = 33    # TypeError: 'str' object does not support item assignment

 

2、切片(分片)

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[ 起始: 结束: 步长 ]
步长：表示下标变化的规律。
注意：选取的区间属于 [左闭 右开)，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。
ps： "结束"位，-1表示字符串序列最后一位，-2表示字符串序列倒数第二位，...以此类推。
我们以字符串为例讲解。
如果取出一部分，则可以在中括号[]中使用

# -*- coding:utf-8 -*-
'''
python中下标从 0 开始
'''
name = 'abcdef'
print(name[0:3]) # 取 下标0~2 的字符 abc
print(name[:3]) # 取 下标0~2 的字符 abc

print(name[0:5]) # 取 下标为0~4 的字符 abcde
print(name[3:5]) # 取 下标为3、4 的字符 de

print(name[2:]) # 取 下标为2开始到最后的字符 cdef
print(name[1:-1]) # 取 下标为1开始 到 最后第2个 之间的字符 bcde

print(name[1:-1:2]) # 取 下标为1开始 到 最后第2个之间[1,-1)从前往后步长为2 返回 bd
print(name[::2]) # 取头-尾间的字符，步长为2 ace

print(name[5:1:2]) # 返回空
print(name[5:1:-2]) # [5,1)从后往前步长为-2 返回 fd
print(name[1:5:2]) # [1,5)从前往后步长为2 返回 bd
print(name[1:7:2]) # [1,7)从前往后步长为2 返回 bdf
print(name[1:10:2]) # [1,10)从前往后步长为2 返回 bdf

 

3、遍历字符串

while循环遍历

c_str = "索引，下标，获取字符串中的子串"
index = 0
print("===while===")
while index < len(c_str):
v = c_str[index]
print(v)

index += 1
print("====while end===")

for循环遍历

print("***for***")
for f_v in c_str:
print(f_v)

print("***for end***")