Python-04-字符串

字符串

一、字符串的创建

• 一对引号创建

str1 = 'Hello,world!'
str2 = "Hello,Python!"

print(str1, type(str1))
print(str1, type(str1))

• 三对引号创建

str3 = """Tomcat"""
str4 = """Hello
world"""

print(str3, type(str3))
print(str4, type(str4))

''' 输出结果：
Tomcat <class 'str'>
Hello
world <class 'str'>
'''

三对引号中字符串可以换行！

二、下标

下标是对已有字符串中的元素进行编号，相当于字符串中单个元素的标记。可为正数，也可以为负数。

下标也叫“索引”。

• 语法

# 字符序列[下标]

下标不能越界，否则报错！

• 通过下标提取字符串的单个字符

# 创建一个字符串
str1 = 'ABCDEF'
# str1 的正向下标： 0  1  2  3  4  5
# str1 的反向下标：-6 -5 -4 -3 -2 -1

# 通过下标来提取单个字符

# 1. 提取字符C
print(str1[2])
print(str1[-4])

# 2. 索引越界
print(str1[6])			# IndexError: string index out of range

# 3. 举例：
print(str1[0])			# A
print(str1[-3])			# D

• 每个字符的下标分为正负下标；

• 正、负下标相当于字符的两个名字；

• 取值、切片以及其它操作，使用任意一个均可。

三、切片

切片就是通过某种操作查找出原字符串中部分字符或者全部字符，并返回给使用者。

支持切片的数据类型有str、list、tuple，因为这三种类型都是有序的容器。

• 语法

# 字符串序列[起始下标:结束下标:步长]

• 不包含结束下标；
• 如果不设置步长，步长默认为1；
• 步长有两种含义：
  • 第一种：表示下标之间的间隔；
  • 第二种：如果为负数，表示反方向切片。

• 代码演示

str1 = 'ABCDEF'

# 1. 切出子串 CD
print(str1[2:4])        	# CD。从下标2开始（包含下标为2的字符），到下标4结束（不包含）
print(str1[-4:-2])			# CD
print(str1[2:-2])       	# CD
print(str1[-4:4])			# CD

# 2. 切出子串 CB
"""
只能通过步长的正负来控制切片方向。
当步长为负数时，开始下标到结束下标的方向必须为反方向。
"""
print(str1[2:-6:-1])		# CB
print(str1[-4:-6:-1])		# CB
print(str1[2:0:-1])			# CB
print(str1[-4:0:-1])        # CB

# 3. 切出子串 EF
print(str1[4:])         # 省略结束下标，默认切片到字符中开头或者末尾，根据步长的正负来决定末尾或者开头
print(str1[4:22])       # 如果切片到字符串末尾，结束下标可以越界

# 4. 切出子串 BA
print(str1[1::-1])

# 5. 切出 ECA
print(str1[-2::-2])

# 6. 切出  ABCDEF
str1 = 'ABCDEF'
print(str1[::])			# ABCDEF
print(str1[:])			# ABCDEF

# 7. 切出 FEDCBA
print(str1[::-1])		# FEDCBA

四、常用方法

字符串属于不可变数据类型，只能查，不能增删改。

4.1 查

以下方法前的S为字符串对象，也可以是字符串的变量。

方法	描述
S.find(sub[, start[, end]]) -> int	检索指定子串的索引。如果没有检索到，find()的返回值为-1
S.index(sub[, start[, end]]) -> int	检索指定子串的索引。如果没有检索到，则报错
S.rfind(sub[, start[, end]]) -> int	与find()功能相同，但查找方向从右侧开始
S.rindex(sub[, start[, end]]) -> int	与index()功能相同，但查找方向从右侧开始
S.count(sub[, start[, end]]) -> int	返回某个子串在字符串中出现的次数

• find(sub[, start[, end]]) -> int

str1 = "Hello World and Python and JavaScript and Java"

# 语法1：find(子串)：表示在整个字符串中查找
print(str1.find('W'))				# 6
print(str1.find('World'))			# 6
# 查找一个不存在的子串
print(str1.find('z'))				# -1。如果没有找到，返回-1，这个-1不是下标

# 语法1：find(子串, 起始下标)
# 需求：查找and的下标
print(str1.find('and', 13))         # 23。返回下标是原字符串中的第一个字符开始算起，不是从指定的开始下标算起

# 语法1：find(子串, 起始下标, 结束下标)		# 不包含结束下标
# 需求：查找Hello中的第二个l
print(str1.find('l', 3, 4))			# 3

• index(sub[, start[, end]]) -> int

str1 = "Hello World and Python and JavaScript and Java"

print(str1.index('and'))			# 12
print(str1.index('and', 15, 30))	# 23
print(str1.index('z'))				# 报错，没有这个子串

• count(sub[, start[, end]]) -> int

str1 = "Hello World and Python and JavaScript and Java"
a = 'z'
print(str1.count('and'))
print(str1.count(f'{a}'))      		# 0，不存在的子串，返回0次
print(str1.count('and', 0, 20))		# 1

4.2 改

字符串属于不可变数据类型，这里的修改方法会产生一个新的对象，而原字符串不变。

方法	描述
S.replace(old, new[, count]) -> str	使用新子串替换旧子串，可以指定替换次数，默认替换所有
S.split(sep=None, maxsplit=-1) -> List[str]	默认以所有空白字符切割字符串，返回列表，可以指定切割字符以及切割次数
S.join(iterable) -> str	以指定字符串合并可迭代对象的元素，元素必须为字符串
S.capitalize() -> str	将字符串的第一个字母改为大写，之后的字符改为小写
S.title() -> str	将字符串中的单词的首字母改大写，单词后续字母改为小写，单词以空白字符
S.lower() -> str	将所有字母修改为小写
S.upper() -> str	将所有字母修改为大写
S.lstrip([chars]) -> str	从字符串的左边开始，将指定的字符去除，指定多个字符，会使用单个字符进行匹配，匹配的字符必须连续
S.rstrip([chars]) -> str	从字符串的右边开始，将指定的字符去除，指定多个字符，会使用单个字符进行匹配，匹配的字符必须连续
S.strip([chars]) -> str	从字符串的两边开始，将指定的字符去除，指定多个字符，会使用单个字符进行匹配，匹配的字符必须连续
S.ljust(width[, fillchar]) -> str	左对齐，必须传入参数为字宽，填充字符可选，默认为空格
S.rjust(width[, fillchar]) -> str	右对齐，必须传入参数为字宽，填充字符可选，默认为空格
S.center(width[, fillchar]) -> str	居中，必须传入参数为字宽，填充字符可选，默认为空格

• replace(old, new[, count]) -> str：替换

str1 = "Hello World and Python and JavaScript and Java"

print(str1.replace('and', 'or'))		# Hello World or Python or JavaScript or Java
print(str1.replace('and', 'or', 2))		# Hello World or Python or JavaScript and Java

• split(sep=None, maxsplit=-1) -> List[str]：切割

参数的解释：

• sep=None：指定切割字符，默认值根据空白字符切割
• maxsplit=-1：指定最大切割次数，默认切割所有

备注：空白字符包括空格、制表符、回车

str1 = "Hello World and Python and JavaScript and Java"

# 1. 不传参
print(str1.split())  # ['Hello', 'World', 'and', 'Python', 'and', 'JavaScript', 'and', 'Java']

# 2. sep='and'
print(str1.split('and'))		# ['Hello World ', ' Python ', ' JavaScript ', ' Java']
print(str1.split(' and '))		# ['Hello World', 'Python', 'JavaScript', 'Java']

# 指定以空串切割 ''
print(str1.split(''))		# ValueError: empty separator

# 指定一个不存在的字符，返回单个元素的列表，这个元素为原字符串
print(str1.split('z'))      # ['Hello World and Python and JavaScript and Java']

# 3. 指定切割次数
print(str1.split(maxsplit=2))	# ['Hello', 'World', 'and Python and JavaScript and Java']

• join(iterable) -> str：合并

print('-'.join('Python'))				# 'P-y-t-h-o-n'
print('+'.join(['0', '1', '2']))		# '0+1+2'

• capitalize() -> str：字符串第一个字母大写，其它字母小写

str1 = "Hello World and Python and JavaScript and Java"

print(str1.capitalize())	# Hello world and python and javascript and java

• title() -> str：单词的首字母大字，单词的其它字母小写

str1 = "Hello World and Python and JavaScript and Java"

print(str1.tittle())	# Hello World And Python And Javascript And Java

• lower() -> str：字符串中的所有字母改为小写

str1 = 'HelloTCP'

print(str1.lower())		# hellotcp

• upper() -> str：字符串听所有字母改为大写

str1 = 'Hello000TCP'

print(str1.upper())		# HELLO000TCP

• lstrip([chars]) -> str

str1 = '\t Hello World and He'
print(str1.lstrip())			# Hello World and He

str2 = 'Hello World and He'
print(str2.lstrip('He'))		# llo World and He

• rstrip([chars]) -> str

str1 = 'Hello World and He \t'
print(str1.rstrip())			# Hello World and He

str2 = 'Hello World and He'
print(str2.rstrip('He'))		# Hello World and 

• strip([chars]) -> str

str1 = '\t Hello World and He \t'
print(str1.strip())				# Hello World and He

str2 = 'Hello World and He'
print(str1.strip('He'))			# llo World and 
print(str1.strip('Hel'))		# o World and 

• ljust(width[, fillchar]) -> str

str1 = 'Hello'

print(str1.ljust(9, '*'))		# Hello****

• rjust(width[, fillchar]) -> str

str1 = 'Hello'

print(str1.rjust(9, '*'))		# ****Hello

• center(width[, fillchar]) -> str

str1 = 'Hello'

print(str1.center(9, '*'))		# **Hello**
print(str1.center(2))			# Hello

当指定的字符位宽小于原字符串的位宽，则输出原字符串！

4.3 判断

方法	描述
S.startswith(prefix[, start[, end]]) -> bool	判断字符串以某个子串开头，可以根据下标指定判断的范围
S.endswith(suffix[, start[, end]]) -> bool	判断字符串以某个子串结尾，可以根据下标指定判断的范围
S.isalpha() -> bool	如果字符串中全部为字母则返回True，否则为False
S.isdigit() -> bool	如果字符串中全部为数字则返回True，否则为False，数字只能是阿拉伯数字
S.isalnum() -> bool	判断字符串中是否包含字母或者（全部字母、全部为数字、字母与的数字的组合），一旦有字母数字之外的字符则返回False
S.isspace() -> bool	判断字符串中是否全部为空白字符

• startswith(prefix[, start[, end]]) -> bool)：判断开头

str1 = 'Hello World and Python and JavaScript and Java'

print(str1.startswith('Hello'))     # True
print(str1.startswith('Java'))      # False
print(str1.startswith('World', 6, 11))      # True，起始下标必须与指定子串的第一字符的下标相同

• endswith(suffix[, start[, end]]) -> bool：判断结尾

str1 = 'Hello World and Python and JavaScript and Java'

print(str1.endswith('Java'))        		# True
print(str1.endswith('Hello'))       		# False
print(str1.endswith('JavaS', 0, -14))       # True，在JavaScript中，-14是c的下标

• isalpha() -> bool：判断字母

str1 = 'abc'
print(str1.isalpha())           # True

str2 = 'abc123'
print(str2.isalpha())           # False

• isdigit() -> bool：判断数字

str1 = '123'
str2 = '五十'

# 1. isdigit()
print(str1.isdigit())		# True
print(str2.isdigit())		# False

# 2. isdecimal()
print(str1.isdecimal())		# True
print(str2.isdecimal())		# False

# 3. isnumeric()：可以识别中文数字
print(str1.isnumeric())		# True
print(str2.isnumeric())		# True

• isalnum() -> bool：判断数字或者字母

str1 = 'abc123'
str2 = '123'
str3 = 'abc'
str4 = '123-'
str5 = ''

print(str1.isalnum())       # True
print(str2.isalnum())       # True
print(str3.isalnum())       # True
print(str4.isalnum())       # False
print(str5.isalnum())       # False

• isspace() -> bool：全部为空白字符则返回True

str1 = ' \t'
str2 = ' '
str3 = 'H W'

print(str1.isspace())       # True
print(str2.isspace())       # True
print(str3.isspace())       # False