Python数据类型的内置函数之str(字符串)

Python数据类型内置函数

　　- str(字符串)

　　- list(列表)

　　- tuple(元组)

　　- dict(字典)

　　- set(收集)

---

str(字符串)的一些操作

- 字符串相连方法

 # 字符串的相连
 str_1 = "I am"
 str_2 = "string practice"

 print(str_1 + str_2)
 # 执行的结果
 I amstring practice
 # 可以在中间用空格隔开
 print(str_1 + " " + str_2)
 # 执行的结果
 I am string practice

 # 使用%s的方法相连
 str_3 = "We let's "
 str_4 = "keep practing"

 print("%s %s" % (str_3,str_4))
 # 执行的结果
 We let's  keep practing

 # 使用format的方法相连
 str_5 = "See final"
 str_6 = "practcie"

 print("{} {}".format(str_5,str_6))
 # 执行的结果
 See final practcie

- 字符串的乘法(你特别想多打印几遍这句话可以使用*)

 # 字符串打印多遍
 rst_1 = " Hello World"
 rst_2 = rst_1 * 5

 print(rst_2)
 # 执行的结果
 Hello World Hello World Hello World Hello World Hello World

　

- 字符串变成列表使用

 # 字符串的列表使用
 s = "I need help"

 print(s[0])
 # 执行的结果
 I

 # 进行分片操作
 print(s[2:11])
 # 执行的结果
 need help

　

- (capitalize)首字母大写其余小写，返回字符串

 # 首字母大写其余小写，返回字符串
 st_1 = "i need practice"
 st_2 = st_1.capitalize()

 print(st_2)
 # 执行的结果
 I need practice

　　

-  (title)每个单词首字母改变为大写，返回字符串

 # 将每个单词首字母变成大写，返回字符串
 st_1 = "i need practice"
 st_2 = st_1.title()

 print(st_2)
 # 执行结果
 I Need Practice

- (upper)所有字母都改变为大写，返回字符串

 # 将所有字母变成大写，返回字符串
 st_1 = "i need practice"
 st_2 = st_1.upper()

 print(st_2)
 # 执行结果
 I NEED PRACTICE

- (lower)所有字母都改变为小写，返回字符串

 # 将所有字母改变为小写，返回字符串
 st_1 = "I NEED PRACTICE"
 st_2 = st_1.lower()

 print(st_2)
 # 执行结果
 i need practice

- (swapcase)所有字母转化大小写，返回字符串

 # 将所有字母大小写互换，返回字符串
 st_1 = "i NEED pratice"
 st_2 = st_1.swapcase()

 print(st_2)
 # 执行的结果
 I need PRATICE

- (len)测量字符串长度

 # 测量字符的总长度
 # len统计的长度是按字符，不是内存的长度
 st_1 = "i need pratice"
 st_2 = len(st_1)

 print(st_2)
 # 执行结果
 14

- (is)检查字母的格式

 # (isupper)检查指定字母是否都为大写,返回布尔值
 st_1 = "We Are Practice"
 st_2 = "WE ARE PRACRICE"
 print(st_1.isupper())
 # 执行结果
 False
 print(st_2.isupper())
 # 执行结果
 Ture

 # (islower)检查指定字母是否为小写，返回布尔值
 st_1 = "We Are Practice"
 st_2 = "we are practice"
 print(st_1.islower())
 # 执行结果
 False
 print(st_2.islower())
 # 执行结果
 Ture

 # (title)检查指定每个单词首字母是否为大写，返回布尔值
 st_1 = "we are practice"
 st_2 = "We Are Practice"
 print(st_1.istitle())
 # 执行结果
 False
 print(st_2.istitle())
 # 执行结果
 Ture

 # (isspace)检查是否为空字符串
 st_1 = "We    are"
 st_2 = "    "
 print(st_1.isspace())
 # 执行结果
 False
 print(st_2.isspace())
 Ture

- (find)(index)查找字符串的索引

 # 查找字符串的索引
 # 使用find查找
 stf_1 = "Stare at me"
 stf_2 = sti_1.find("r")
 print(sti_2)
 # 执行结果
 10

 # 可以查找你想要搜索的区域
 stf_3 = stf_1.find("t",3,10)
 print(stf_3)
 # 执行结果
 7
 # 使用index查找
 sti_1 = "Let's go on"
 sti_2 = sti_1.index("n")
 print(sti_2)
 # 执行结果
 10

 # 可以查找你想要搜索的区域
 sti_3 = sti_1.index("s",2,8)
 print(sti_3)
 # 执行结果
 4

- (count)统计字符一共出现几次

 # 统计指定字符的个数
 stc_1 = "We are practice"
 stc_2 = stc_1.count("e")
 print(stc_2)
 # 执行结果

 # 可以查找自己想要搜索的范围
 stc_3 = stc_1.count("e",5,15)
 # 执行结果
 print(stc_3)

- (startswith)(endswith)检查指定的首,尾字母，返回布尔值

 # 检查指定首,尾字母，返回布尔值
 # 使用(startswitch)检查指定首字母
 sts_1 = "We are practice"
 print(sts_1.startswith("w"))
 # 执行结果
 False
 print(sts_1.startswith("W"))
 # 执行结果
 True

 # 检查指定结尾字母，返回布尔值
 print(sts_1.endswith("s"))
 # 执行结果
 False
 print(sts_1.endswith("e"))
 # 执行结果
 True

- (isalpha)检查字符串是否为字母字符串

 # 检查字符串是否为字母字符串，返回布尔值
 st_1 = "We are practic"
 st_2 = "Wearepractic"

 print(st_1.isalpha())
 # 执行结果
 False
 print(st_2.isalpha())
 # 执行结果
 Ture

- (isalnum)检查字符串是否为数字或字母组成

 # 检查字符串是否由数字或字母组成(可以是数字+字母),返回布尔值
 st_1 = "Good yo123"
 st_2 = "Goodyo123"
 st_3 = "Goodyo"
 st_4 = ""

 print(st_1.isalnum())
 # 执行结果
 False
 print(st_2.isalnum())
 # 执行结果
 Ture
 print(st_3.isalnum())
 # 执行结果
 Ture
 print(st_4.isalnum())
 # 执行结果
 Ture

- 检查字符串是否由数字组成,返回布尔值

　　- isdigit：Unicode数字(统一码)，byte数字（单字节），全角数字（双字节），罗马数字

　　- isdecimal：Unicode数字(统一码)，全角数字（双字节）

　　- isnumeric：Unicode数字(统一码)，全角数字（双字节），罗马数字，汉字数字

 # 检查字符串是否由数字组成，返回布尔值
 st_1 = ""
 print(st_1.isdigit())
 print(st_1.isdecimal())
 print(st_1.isnumeric())
 # 上述3个输出结果
 Ture
 Ture
 Ture

 # 小数点不是数字
 st_2 = "23.3"
 print(st_2.isdigit())
 print(st_2.isdecimal())
 print(st_2.isnumeric())
 # 上述3个输出结果
 False
 False
 False

 st_3 = "五十"
 print(st_3.isdigit())
 print(st_3.isdecimal())
 print(st_3.isnumeric())
 # 上述3个输出结果
 False
 False
 Ture

 # 这个不是字母I是罗马数字1
 st_4 = "Ⅰ"
 print(st_4.isdigit())
 print(st_4.isdecimal())
 print(st_4.isnumeric())
 # 上述3个输出结果
 False
 False
 Ture

- (split)指定字符切割字符串，返回列表

 # 使用指定的字符切割字符串，返回列表
 st = "生活不分学期-你并没有暑假可以休息-也没有哪位雇主乐于帮你发现自我-自己找时间做吧。"

 print(st.split("-"))
 # 执行结果
 ['生活不分学期', '你并没有暑假可以休息', '也没有哪位雇主乐于帮你发现自我', '自己找时间做吧。']

- (splitlines)用换行符切割字符串，返回列表

 # 使用换行符切割字符串,返回列表
 st = "生活不分学期\n你并没有暑假可以休息\n也没有哪位雇主乐于帮你发现自我\n自己找时间做吧。"

 print(st.splitlines())
 # 执行结果
 ['生活不分学期', '你并没有暑假可以休息', '也没有哪位雇主乐于帮你发现自我', '自己找时间做吧。']

　　

- (join)用指定字符串使列表拼接，返回字符串

 # 指定字符串将列表连接，返回字符串
 st_1 = ['生活不分学期', '你并没有暑假可以休息', '也没有哪位雇主乐于帮你发现自我', '自己找时间做吧。']
 st_2 = ",".join(st_1)

 print(st_2)
 # 执行结果
 生活不分学期,你并没有暑假可以休息,也没有哪位雇主乐于帮你发现自我,自己找时间做吧。

- 指定字符串的长度，多余的位置用指定的字符串替换，默认空格，返回字符串

　　- ljust：指定字符串的长度，内容靠左边，多余的位置用指定的字符替换，默认空格，返回字符串

　　- center：指定字符串的长度，内容靠中心，多余的位置用指定的字符替换，默认空格，返回字符串

　　- rjust：指定字符串的长度，内容靠右边，多余的位置用指定的字符替换，默认空格，返回字符串

 st = "Hell"

 print(st.ljust(6)+ "h")
 # 执行结果
 Helloo

 print(st.center(6,"o"))
 # 执行结果
 oHello

 print(st.rjust(6,"o"))
 # 执行结果
 ooHell

- 删除指定的字符，默认是空格

　　- strip：删除左右两边指定的字符，默认是空格

　　- lstrip：删除左边指定的字符，默认是空格

　　- rstrip：删除右边指定的字符，默认是空

 stt = "  aabbbcc "
 print("##"+ stt.strip() + "##")
 # 执行结果
 ##aabbbcc##
 st = "aaabbbaaa"

 print(st.strip("a"))
 # 执行结果
 bbb

 print(st.lstrip("a"))
 # 执行结果
 aaabbb

 print(st.rstrip("a"))
 # 执行结果
 bbbaaa

- (zfill)指定字符串的长度，内容靠右，多余的用0填充，返回字符串

 # (zfill)指定字符串的内容长度,内容靠右,返回字符串
 st = "Hello"

 print(st.zfill(10))
 # 执行结果
 00000Hello

　　

- (maketrans)指定字符串替换映射表

 # (maketrans)生产指定字符串替换的生成表，返回编码
 st = "感觉自己萌萌哒"
 st_2 = st.maketrans("萌萌哒","虎虎的")

 print(st_2)
 # 执行结果
 {33804: 34382, 21714: 30340}

 # (translate)转化为字符串，返回字符串
 print(st.translate(st_2))
 # 执行结果
 感觉自己虎虎的