Python基础-数据类型之字符串

一、字符串的定义

name = 'kitty'

1：单引号、双引号、三引号都可以用来定义字符串

例：name = 'kitty'， name = "kitty"， name = """kitty"""三种方式都是可以的

2：当字符串中已经有单引号或双引号时，需要用双引号或单引号来定义字符串

例：str = "my name is 'kitty' "， str = 'my name is "kitty" '

3：三引号可以定义带有换行符的多行字符串

例：

str = """this is apple
      this is book"""

注：字符串是不可修改的。

二、字符串的操作

字符串是序列中的一种，因此序列的基本操作，字符串也适用（序列的基本操作）

1：字符串的转化

使用str()方法，可以将任意数据类型转换成字符串。

nums = 12345
print(type(nums))      # <class 'int'>
nums = str(nums)
print(type(nums), nums)   # <class 'str'> 12345
list_1 = [2,3,4,5] 
print(type(list_1))     # <class 'list'>
list_str = str(list_1)
print(type(list_str), list_str)  # <class 'str'> [2, 3, 4, 5]

2：字符串的格式化

2.1：字符串格式化符号

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

name = "kitty"
age = 14
grade = 99.5
str1 = "我的姓名是：%s，年龄是：%d，考试成绩是：%0.2f" %(name, age, grade)
print(str1)     # 我的姓名是：kitty，年龄是：14，考试成绩是：99.50

注意：在传值的时候，必须严格按照位置与%s(d/f)一一对应。

对应的数据类型错误时，会报错

name = "kitty"
age = 14
grade = 99.5
str1 = "我的姓名是：%s，年龄是：%d，考试成绩是：%0.2f" %(age, name, grade)
# 报错，TypeError: %d format: a number is required, not str
print(str1)

%0.2f中的0.2表示保留几位小数，0.2表示保留两位小数，0.1表示保留1位小数

2.2：format：用{}占位，不指定数据类型，数据可多不可少

name = "kitty"
age = 14
grade = 99.5
str1 = "我的姓名是：{}，年龄是：{}，考试成绩是：{}".format(name,age,grade)
print(str1)   # 我的姓名是：kitty，年龄是：14，考试成绩是：99.5

str2 = "我的姓名是：{name}，年龄是：{age}，考试成绩是：{grade}".format(name=name,age=age,grade=grade)
print(str2)   # 我的姓名是：kitty，年龄是：14，考试成绩是：99.5

str3 = "我的姓名是：{0}，年龄是：{1}，考试成绩是：{2}".format(name,age,grade)
print(str3)   # 我的姓名是：kitty，年龄是：14，考试成绩是：99.5

str4 = "我的姓名是：{0}，年龄是：{2}，考试成绩是：{1}".format(name,age,grade)
print(str4)   # 我的姓名是：kitty，年龄是：99.5，考试成绩是：14

用{}占位时，可以不填参数名，也可以填参数名，还可以填参数的索引位置

不填参数名，取值就按照传递的参数从左往右依次取值

填了参数名，format传值时，需要使用关键字进行传值，取对应关键字的值

填了索引值，format中的值，从0开始，按照索引对应的值进行取值，不可以超过format中的值的索引，超过了会报错

2.3：f-string：字符串前加f，将对应的值传入到对应的位置

name = "kitty"
age = 14
grade = 99.5
str1 = f"我的姓名是：{name}，年龄是：{age}，考试成绩是：{grade}"
print(str1)   # 我的姓名是：kitty，年龄是：14，考试成绩是：99.5

3：join()：按照自定义方法连接列表中的元素为字符串

str.join(object)    # object为要连接的元素序列

返回值为：通过指定str字符连接序列中的元素后，生成的新字符串

list_a = ['a', 'b', 'c']
result = "".join(list_a)
print(result, type(result))     # abc <class 'str'>
result1 = " ".join(list_a)
print(result1, type(result1))   # a b c <class 'str'>
result2 = ".".join(list_a)
print(result2, type(result2))   # a.b.c <class 'str'>

4：切割字符串split()：从左往右通过指定分隔符对字符串进行切片，可指定切割次数

str.split(str,num) 

# str为分割符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等

# num为分割次数，默认为-1，分割所有

返回值为：分割后的字符串组成的新列表

str_a = "1a2a 13a14"
# 以'a'进行切割，全部切割
result = str_a.split('a')
print(result)       # ['1', '2', ' 13', '14']
# 默认以空格切割
result1 = str_a.split()
print(result1)      # ['1a2a', '13a14']
# 以'a'进行切割，切割两次
result2 = str_a.split('a', 2)
print(result2)      # ['1', '2', ' 13a14']

rsplit()：从右往左通过指定分隔符对字符串进行切片，可指定切割次数。

str.rsplit(str,num) 

# str为分割符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等

# num为分割次数，默认为-1，分割所有

返回值为：分割后的字符串组成的新列表

str_a = "1a2a 13a14"
result = str_a.rsplit('1', 2)
print(result)     # ['1a2a ', '3a', '4']

5：replace()：从左往右依次替换字符串中的指定字符，可指定替换个数，默认全部替换。

str.replace(oldstr,newstr,max)

# oldstr：表示被替换的子字符串

# newstr：新字符串，替换oldstr的子字符串

# max：表示最大替换的个数

返回值为：被newstr替换后的新字符串，不修改原字符串

str_a = "1a2a13a14"
# 将'a'替换成'aa'
result = str_a.replace('a','bb')
print(result, str_a)     # 1bb2bb13bb14 1a2a13a14
# 将'a'替换成'='，最多替换2次
result1 = str_a.replace('a', '=', 2)
print(result1)           # 1=2=13a14

6：find()：从左往右查找子字符串在字符串中第一次出现的索引位置。可指定查找的起始位置。

str.find(str, start, end)

# str：表示要查找的子字符串

# start：表示查找的开始位置，默认为0

# end：表示查找的结束位置，默认为字符串的长度

返回值为：如果存在，则返回包含子串的第一个字符所在的索引位置；如果没有找到，则返回-1

str_a = "1a2a13a14"
result = str_a.find('a13')
print(result)      # 3
# 指定起始位置
result1 = str_a.find('1', 2, 8)
print(result1)     # 4
# 找不到
result2 = str_a.find('123')
print(result2)     # -1

rfind()：从右往左查找子字符串在字符串中第一次出现的索引位置（及从左往右子字符串在字符串中最后一次出现的索引位置）。可指定查找的起始位置。

str.find(str, start, end)

# str：表示要查找的子字符串

# start：表示查找的开始位置，默认为0

# end：表示查找的结束位置，默认为字符串的长度

返回值为：如果存在，则返回包含子串的第一个字符所在的最后一次出现的索引位置；如果没有找到，则返回-1

str_a = "1a2a13a14"
result = str_a.rfind('a')
print(result)      # 6
result1 = str_a.rfind('a', 1, 6)
print(result1)     # 3
result2 = str_a.rfind('12')
print(result2)     # -1

7：isdigit()：判断字符串是否由纯数字组成。

str.isdigit()

返回值为：只包含数字返回True，否则返回False。

num_str = "123456"
result = num_str.isdigit()
print(result)       # True
num_str_1 = "12345a"
result1 = num_str_1.isdigit()
print(result1)      # False

8：index()：字符串中是否包含子字符串，包含则返回子字符串第一个字符第一次出现的索引位置，与find()方法一样，但是如果子字符串不在字符串中，会报错.

str.index(str, start, end)

# str：表示要查找的子字符串

# start：表示查找的开始位置，默认为0

# end：表示查找的结束位置，默认为字符串的长度

返回值为：如果存在，则返回包含子串的第一个字符所在的索引位置；如果没有找到，则报错

str_a = "1a2a13a14"
result = str_a.index('a13')
print(result)      # 3
# 指定起始位置
result1 = str_a.index('1', 2, 8)
print(result1)     # 4
# 找不到
result2 = str_a.index('123')
print(result2)     # 报错，ValueError: substring not found

rindex()：与index()用法相同，不过是从右往左查找

str_a = "1a2a13a14"
result = str_a.rindex('a')
print(result)      # 6
result1 = str_a.rindex('a', 1, 6)
print(result1)     # 3
result2 = str_a.rindex('12')
print(result2)     # 报错，ValueError: substring not found

9：count()：统计子字符串在字符串中出现的次数

str.count(str, start, end)

# str：表示要查找的子字符串

# start：表示查找的开始位置，默认为0

# end：表示查找的结束位置，默认为字符串的长度

返回值为：子字符串在字符串中出现的次数，子字符串不存在字符串中，则返回0

str_a = "1a2a13a1413"
result = str_a.count('13')
print(result)      # 2
# 指定查找的起始位置
result1 = str_a.count('1', 5, 8)
print(result1)     # 1

10：strip()：移除字符串头尾指定的字符或字符序列

str.strip(str)     # 不填str时，默认移除字符串头尾的空格

# str：移除字符串头尾指定的字符序列

返回值为：移除了字符串头尾指定的字符序列后，生成的新字符串。不修改原字符串。

str_a = "13a2a13a1413"
result = str_a.strip("13")
print(result)    # a2a13a14
str_a1 = " 2356b jbbds "
result1 = str_a1.strip()
print(result1)   # 2356b jbbds

注意：只能删除开头或结尾的字符，不能删除中间部分的字符。

lstrip()：移除字符串左边的空格或指定的字符。

str.strip(str)     # 不填str时，默认移除字符串头部的空格

# str：移除字符串头部指定的字符序列

返回值为：移除了字符串头部指定的字符序列后，生成的新字符串。不修改原字符串。

str_a = "13a2a13a1413"
result = str_a.lstrip("13")
print(result)      # a2a13a1413
str_a1 = " 2356b jbbds "
result1 = str_a1.lstrip()
print(result1)     # '2356b jbbds '

rstrip()：移除字符串右边的空格或指定的字符。

str.strip(str)     # 不填str时，默认移除字符串部的空格

# str：移除字符串尾部指定的字符序列

返回值为：移除了字符串尾部指定的字符序列后，生成的新字符串。不修改原字符串。

str_a = "13a2a13a1413"
result = str_a.rstrip("13")
print(result)      # 13a2a13a14
str_a1 = " 2356b jbbds "
result1 = str_a1.rstrip()
print(result1)     # ' 2356b jbbds'

11：center()：将字符串居中，并用指定的字符填充一个指定的宽度，默认为空格。

str.center(width, fillchar)

# width：字符串的总宽度

# fillchar：填充的字符，默认为空格

返回值为：一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。

str_a = "abc"
# 总宽度为20个字符，剩下的默认以空格填充
result = str_a.center(20)
print(result)      # '        abc         '
print(str_a)       # abc
# 总宽度为20个字符，剩下的以*填充
result1 = str_a.center(20, '*')
print(result1)     # ********abc*********

ljust()：将字符串左对齐，并使用指定字符去填充至指定宽度。默认以空格填充。

str.ljust(width, fillchar)

# width：字符串的总宽度

# fillchar：填充的字符，默认为空格

返回值为：返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

str_a = "abc"
result = str_a.ljust(20)
print(result)     # 'abc                 '
print(str_a)      # abc
result1 = str_a.ljust(20, '*')
print(result1)    # abc*****************

rjust()：将字符串右对齐，并使用指定字符去填充至指定宽度。默认以空格填充。

str.ljust(width, fillchar)

# width：字符串的总宽度

# fillchar：填充的字符，默认为空格

返回值为：返回一个原字符串右对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

str_a = "abc"
result = str_a.rjust(20)
print(result)      # '                 abc'
print(str_a)       # abc
result1 = str_a.rjust(20, '*')
print(result1)     # *****************abc

zfill()：将字符串右对齐，并使用“0”去填充至指定宽度

str.ljust(width)

# width：字符串的总宽度

返回值为：返回一个原字符串右对齐,并使用“0”填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

str_a = "abc"
result = str_a.zfill(20)
print(result)      # 00000000000000000abc
print(str_a)       # abc
result1 = str_a.zfill(2)
print(result1)     # abc

字符串的方法还有很多，其他的方法参考：菜鸟教程字符串