24.字符串的常见操作

如有字符串mystr = 'hello world itcast and itcastcpp'，以下是常见的操作

<1>find

检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1

mystr.find(str, start=0, end=len(mystr))

 

例子：

# 定义一个字符串
a = "eabcabdef"

# <1>find
# 查看一个字符或者字符串子串在字符串中的位置(下标索引)
# 返回的都是从左到右的下标索引
# 找到返回下标索引
# 找不到返回-1
ret = a.find("abc")
print(ret)

运行结果：1

# 定义一个字符串
a = "eabcabdef"

# <1>find
# 查看一个字符或者字符串子串在字符串中的位置(下标索引)
# 返回的都是从左到右的下标索引
# 找到返回下标索引
# 找不到返回-1
index = a.find("qq")
print(index)

运行结果：-1

<2>index

跟find()方法一样，只不过如果str不在 mystr中会报一个异常.

mystr.index(str, start=0, end=len(mystr))

例子：

# 定义一个字符串
a = "eabcabdef"
# <2>index
# 找到返回下标索引
# 找不到就会报错
ret = a.index("qq")
print(ret)

运行结果：报错

ValueError: substring not found

<3>count

返回 str在start和end之间 在 mystr里面出现的次数

mystr.count(str, start=0, end=len(mystr))

 

例子：

# 定义一个字符串
a = "eabcabdef"
# <3>count
ret = a.count("ab1")
print(ret)

运行结果;0

<4>replace

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

mystr.replace(str1, str2,  mystr.count(str1))

例子：

# 定义一个字符串
a = "eabcabdef"
# <4>replace
ret1 = a.replace("a", "X", 1)
# # 字符串是不可变的数据类型
# print(a)
print(ret1)

运行结果：

eXbcabdef

<5>split

以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

mystr.split(str=" ", 2)   

 例子：

# 定义一个字符串
a = "eabcabdef"
# <5>split
# str -> list(了解)
ret2 = a.split("a", 1)
print(ret2)

运行结果：

['e', 'bcabdef']

<6>capitalize

把字符串的第一个字符大写

mystr.capitalize()

 例子：

# 定义一个字符串
a = "eabAcabVdef.mp3"

# <6>capitalize
# 把字符串中的第一个字符大写(后面的字符变为小写)
ret1 = a.capitalize()
print(ret1)

运行结果：

Eabacabvdef.mp3

<7>title

把字符串的每个单词首字母大写

>>> a = "hello itcast"
>>> a.title()
'Hello Itcast'

例子：

# 定义一个字符串
a = "eabA cabVd ef.mp3"

# <7>title
# 把字符串的每个单词首字母大写,其他字符小写
ret = a.title()
print(ret)

运行结果：

Eaba Cabvd Ef.Mp3

<8>startswith

检查字符串是否是以 某个“单词或者字符开头”, 是则返回 True，否则返回 False

mystr.startswith(hello)

 例子：

# 定义一个字符串
a = "eabAcabVdef.mp3"
# <8>startswith
# 检查字符串是否是以 eab 开头, 是则返回 True，否则返回 False
ret = a.startswith("eab")
print(ret)

运行结果：

True

<9>endswith

检查字符串是否以obj结束，如果是返回True,否则返回 False.

mystr.endswith(obj)

 例子：

# 定义一个字符串
a = "eabAcabVdef.mp3"

# <9>endswith
# 检查字符串是否以mp3结束，如果是返回True,否则返回 False.
ret = a.endswith("mp3")
print(ret)

运行结果：

True

<10>lower

转换 mystr 中所有大写字符为小写

mystr.lower()  

 例子：

# 定义一个字符串
a = "eabAcabVdef.mp3"
# <10>lower
# 转换 mystr 中所有大写字符为小写
ret = a.lower()
print(ret)

运行结果;

eabacabvdef.mp3

<11>upper

转换 mystr 中的小写字母为大写

mystr.upper()

 

 例子：

# 定义一个字符串
a = "eabAcabVdef.mp3"

# <11>upper
# 转换 mystr 中的小写字母为大写
ret = a.upper()
print(ret)

运行结果：

EABACABVDEF.MP3

<12>ljust

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

mystr.ljust(width) 

 

 例子;

# 12.ljust
# 返回一个原字符串左对齐，通过z字符占位填充至长度为12的新字符串
a = "abcd"
ret = a.ljust(12, "z")
print(ret)

运行结果：

abcdzzzzzzzz

<13>rjust

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

mystr.rjust(width)  

 例子：

# 13.rjust
# 返回一个原字符串右对齐，通过z字符占位填充至长度为12的新字符串
a = "abcd"
ret = a.rjust(12, "z")
print(ret)

运行结果：

zzzzzzzzabcd

<14>center

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

mystr.center(width)

 例子：

# 14.center
# 返回一个原字符串居中对齐，通过z字符占位填充至长度为12的新字符串
a = "abcd"
ret = a.center(12, "z")
print(ret)

运行结果：

zzzzabcdzzzz

<15>lstrip

删除 mystr 左边的空白字符

mystr.lstrip()

 例子：

# 15.lstrip
# 删除字符串左边的空白字符
a = "   abcd"
ret = a.lstrip()
print(ret)

运行结果：

abcd

例子2：

# 15.lstrip
# 删除字符串左边的空白字符
a = "abcd"
ret = a.lstrip("ac")
print(ret)

运行结果：

bcd

例子3：

# 15.lstrip
# 删除字符串左边的空白字符
a = "abcd"
ret = a.lstrip("acb")
print(ret)

运行结果：d

<16>rstrip

删除 mystr 字符串末尾的空白字符

mystr.rstrip()    

 例子;

# 16.rstrip
# 删除字符串右边的空白字符
a = "abcd   "
ret = a.rstrip()
print(ret)

运行结果：

abcd

例子;

# 16.rstrip
# 删除字符串右边的空白字符
a = "abcd"
ret = a.rstrip("cd")
print(ret)

运行结果：

ab

<17>strip

删除mystr字符串两端的空白字符

>>> a = "
	 itcast 	
"
>>> a.strip()
'itcast'

例子;

# 17.strip
# 删除字符串两边的空白字符
a = "   abcd    "
ret = a.strip()
print(ret)

运行结果：

abcd

例子2：

# 17.strip
# 删除字符串两边的空白字符
a = "1122abcd3344"
ret = a.strip("14")
print(ret)

运行结果;

22abcd33

<18>rfind

类似于 find()函数，不过是从右边开始查找.

mystr.rfind(str, start=0,end=len(mystr) )

 例子:

# <18>rfind
# 类似于 find()函数，不过是从右边开始查找.
a = "abcdba"
ret = a.rfind("b")
print(ret)

运行结果：4

<19>rindex

类似于 index()，不过是从右边开始.

mystr.rindex( str, start=0,end=len(mystr))

 例子：

# <19>rindex
# 类似于 index()，不过是从右边开始.
a = "abcdba"
ret = a.rindex("b")
print(ret)

运行结果：4

<20>partition

把mystr以str分割成三部分,str前，str和str后

mystr.partition(str)

 例子：

# <20>partition
# 把mystr以str分割成三部分,str前，str和str后
# str -> tuple(了解)
a = "abcdba"
ret = a.partition("b")
print(ret)

运行结果：

('a', 'b', 'cdba')

<21>rpartition

类似于 partition()函数,不过是从右边开始.

mystr.rpartition(str)

 例子：

# <21>rpartition
# 类似于 partition()函数,不过是从右边开始.
a = "abcdba"
ret = a.rpartition("b")
print(ret)

运行结果：

('abcd', 'b', 'a')

<22>splitlines

按照行分隔，返回一个包含各行作为元素的列表

mystr.splitlines()

 

 例子：

# <22>splitlines
# 按照行分隔，返回一个包含各行作为元素的列表
a = "ab
cd
ba"
ret = a.splitlines()
print(ret)

运行结果：

['ab', 'cd', 'ba']

<23>isalpha

如果 mystr 所有字符都是字母 则返回 True,否则返回 False

mystr.isalpha()

 例子：

# 定义一个字符串
a = "abc1"
# <23>isalpha
# 如果 mystr 所有字符都是字母 则返回 True,否则返回 False
ret = a.isalpha()
print(ret)

运行结果：

False

<24>isdigit

如果 mystr 只包含数字则返回 True 否则返回 False.

mystr.isdigit() 

 例子：

# <24>isdigit
# 如果 mystr 只包含数字则返回 True 否则返回 False.
a = "123a"
ret = a.isdigit()
print(ret)

运行结果;

False

<25>isalnum

如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

mystr.isalnum()  

 例子;

# <25>isalnum
# 如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
a = "123ascd"
ret = a.isalnum()
print(ret)

运行结果：

True

<26>isspace

如果 mystr 中只包含空格，则返回 True，否则返回 False.

mystr.isspace()

 例子;

# <26>isspace
# 如果 mystr 中只包含空格，则返回 True，否则返回 False.
a = "  "
ret = a.isspace()
print(ret)

运行结果;

True

<27>join

mystr 中每个元素后面插入str,构造出一个新的字符串

mystr.join(str)

# <27>join
# mystr 中每个元素后面插入str,构造出一个新的字符串
# list -> str
# 定义一个列表
my_list = ["aa", "bb", "cc", "dd"]
# 得到一个字符串: aa11bb11cc11dd
ret = "11".join(my_list)
print(ret)

运行结果：

aa11bb11cc11dd

例子2：

# <27>join
# mystr 中每个元素后面插入str,构造出一个新的字符串
# list -> str
# 定义一个列表
my_list = ["aa", "bb", "cc", "dd"]
# 得到一个字符串: aa11bb11cc11dd
# ret = "11".join(my_list)
# print(ret)
# print("%s%s%s" % ("11", ret, "11"))
# 得到一个字符串: aabbccdd
ret = "".join(my_list)
print(ret)

运行结果：

aabbccdd

想一想

（面试题）给定一个字符串aStr，返回使用空格或者' '分割后的倒数第二个子串

 

# 给定一个字符串aStr，返回使用空格或者'	'分割后的倒数第二个子串
teststr = "haha nihao a 	 heihei 	 woshi nide 	 hao 
pengyou"
ret = teststr.split()
print(ret)

运行结果：

['haha', 'nihao', 'a', 'heihei', 'woshi', 'nide', 'hao', 'pengyou']

 例子：

# 字符串的分割(str -> list)
# 定义一个字符串
a = "abcbdbf"
ret1 = a.split("b")
print(ret1)

# 字符串的拼接(list -> str)
# 定义一个列表
my_list = ["a", "cc", "dd"]
ret2 = "123".join(my_list)
print(ret2)


# 字符串子串查找
a = "abcbdbf"
index = a.find("bcb")
print(index)

# 字符串子串替换
a = "abcbdbf"
ret3 = a.replace("b", "Xx")
print(ret3)

# 去除字符串两侧空白符
a = "	124
"
ret4 = a.strip()
print(ret4)


# 假设一个变量存在 我们不知道他是什么类型的
a = "hello"
# 首先先搞清楚他是什么类型
# <class 'str'>
# print(type(a))
# 通过返回的类型来查看其这个数据类型对应有哪些方法
# help(类名) -> 查看这个类所有的方法
# help(类名.方法名) -> 查看这个类对应的这个方法的解释
# help(str.count)

"""
内置函数: 由python已经定义好的 我们程序员直接使用即可
type 查看变量或者数据的类型
len 计算可迭代对象中的元素个数(str, list, tuple, dict, set)
help 帮助函数
"""