【Python基础篇】【8.数据类型 - 字符串 string】字符编码、格式化、内置方法、转义字符、原生字符串【超详细的自学资料】

字符串 string

• 字符串是由零个或多个字符组成的有限序列。字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有字符。
• 在python中字符串是通过单引号''或者双引号""标识的。
• 字符串特性
  • 字符串是不可变的序列数据类型，不能直接修改字符串本身，和数字类型一样！Python3全面支持Unicode编码，所有的字符串都是Unicode字符串，所以传统Python2存在的编码问题不再困扰我们，可以放心大胆的使用中文。
  • 字符串属于序列类型，所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。
    

# （1）索引取值
s = "hello yuan"
print(s[6])
print(s[-10])

# （2）切片取值：序列类型对象[start : end : step]
s = "hello yuan"
print(s[1:4])  # ell  ：取索引1到索引3（左闭又开）
print(s[:4])  # hell ：start缺省，默认从0取
print(s[1:])  # ello yuan ： end缺省，默认取到最后
print(s[1:-1])  # ello yua

print(s[6:9])  # yua
print(s[-4:-1])  # yua
print(s[-1:-4])  # 空
print(s[-1:-4:-1])  # nau  step为1：从左向右一个一个取。为-1 ，从右向左一个取

# （3）判断存在：Python 中，可以使用 in 关键字检查某元素是否为序列的成员。
s = "hello yuan"
print("yuan" in s)  # True

# （4）支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
#      使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果
s = "hello" + " yuan"
print(s)  # hello yuan
s = "*" * 10
print(s)  # **********

单引号和双引号

字符串是 Python 中最常用的数据类型。可以使用引号( ’ 或 " )来创建字符串。

""" 字符串类型 """
# 单引号创建字符串
name = '无敌'
print(type(name))  #  字符串类型

# 双引号创建字符串 一定要是英文状态下的
name1 = "无敌"

# 一个单引号并不是单引号，它是字符串创建的格式

三引号创建字符串

在字符串中，可以使用三引号（三单或三双引号都可以）编写跨行字符串，在其中可以包含换行符、制表符以及其他特殊字符

# 三引号创建字符串
name2 = """无敌"""
name3 = '''无敌'''

# 字符串的拼接 一定要是相同的数据类型
a = '无敌'
b = 10
c = 'python'
print(a + c + b) # 报错

字符编码

• 计算机只能处理数字01，如果要处理文本，就必须先把文本转换为数字01二进制的形式，这种转换方式就称为字符编码。
• 对于我们而言，你只需要简单记住下面几种编码就好：
  • ASCII编码：早期专门为英语语系编码，只有255个字符，每个字符需要8位也就是1个字节。不兼容汉字。
  • Unicode编码：又称万国码，国际组织制定的可以容纳世界上所有文字和符号的字符编码方案。用2个字节来表示汉字。
  • UTF-8编码：为了节省字节数，在Unicode的基础上进行优化的编码。用1个字节表示英文字符，3个字符表示汉字。天生兼容ASCII编码，所以最为流行。
  • GB2312：我国早期自己制定的中文编码，世界范围内不通用。
  • GBK： 全称《汉字内码扩展规范》，向下与GB2312兼容，向上支持ISO10646.1国际标准，是前者向后者过渡过程中的一个承上启下的产物。windows中文版的汉字编码用的就是GBK。也非世界范围通用的编码
  • 其它编码：非以上类型者的统称。属于能不用就不要碰的编码

字符串格式化

把不是字符类型的转变成字符串，格式化的三种方式：分别 format()，%，f

fromat()

此函数可以快速的处理各种字符串，增强了字符串格式化的功能。

name = '张三'
age = 18
nickname = '法外狂徒'

# format 用 {} 占位
print('姓名：{}，年龄{}，外号：{} '.format(name, age, nickname))  # {} 的数量与变量的数量要一致
print('hello {} 你今年已经{}岁了'.format(name, age))

# 保留小数点后两位
'{:.2f}'.format(12.333)  # '12.33'
'{a:.2f}'.format(a=12.333) # '12.33'
'{a:6.2f}'.format(a=12.333) # ' 12.33'

%s

% 被称为 格式化操作符，专门用于处理字符串中的格式**

• 包含 % 的字符串，被称为 格式化字符串
• % 和不同的 字符 连用，不同类型的数据 需要使用 不同的格式化字符

格式化字符	含义
%s	字符串
%d	有符号十进制证书，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
%f	浮点数，%.2f 表示小数点后面只显示两位
%%	输出 ‘’%‘’ 符号
%c	% ASCII 字符
%o	% 8进制
%x	% 16进制
%e	% 科学计数法

name = '张三'
age = 18
nickname = '法外狂徒'

name2 = '李四'
age2 = 19
nickname2 = '帮凶'

# %s 用 %s 占位
print('姓名：%s' % name)
print('姓名：%s,年龄：%s，职业：%s' %(name,age,nickname))  # %s 的数量与变量的数量要一致

# 多个参数
print('%s，%s 哦嗨呦' % (name, name2))

f

f’{}'形式，并不是真正的字符串常量，而是一个运算求值表达式，可以很方便的用于字符串拼接、路径拼接等

name = 'wudi'
age = 19
wudi = 'python'
# f 在字符串中嵌入变量
print(f'名字：{name},年龄：{age}，职业：{wudi}')

print(f'hello {name} !')

案例 - 字符串格式化

"""
	猫眼 top100 的网址
	第一页： https://maoyan.com/board/4?offset=0
	第二页： https://maoyan.com/board/4?offset=10
	第三页： https://maoyan.com/board/4?offset=20
	...
	第十页： https://maoyan.com/board/4?offset=90
	
	请分别使用三种字符串构建的方法创建所有的请求地址
"""
# range('起始值','结束值','步长') 左闭右开区间
for i in range(0,91,10):
    # f
    print(f'https://maoyan.com/board/4?offset={i}')
    # format
    print('https://maoyan.com/board/4?offset={}'.format(i))
    # %s
    print('https://maoyan.com/board/4?offset=%s' % i)

字符串内置方法

字符串是不可变数据类型，所有的操作都是返回新的一个列表，不会修改原有列表

1.大小写转换

capitalize()

# capitalize() - 将字符串的第一个字母变成大写，其余字母变为小写
print(str.capitalize('hello ptyhon'))  # Hello ptyhon

title()

# title() - 返回一个满足标题格式的字符串。即所有英文单词首字母大写，其余英文字母小写
print(str.title('hello ptyhon'))  # Hello Ptyhon

swapcase()

# swapcase() - 将字符串str中的大小写字母同时进行互换。即将字符串str中的大写字母转换为小写字母，将小写字母转换为大写字母
print(str.swapcase('Hello Ptyhon'))  # hELLO pTYHON

lower()

# lower() - 将字符串中的所有大写字母转换为小写字母
print(str.lower('HELLO PTYHON'))  # hello ptyhon

upper()

# upper() - 将字符串中的所有小写字母转换为大写字母
print(str.upper('hello ptyhon'))  # HELLO PTYHON

casefold()

# casefold() - 将字符串中的所有大写字母转换为小写字母。也可以将非英文 语言中的大写转换为小写
# 注意 ：lower()函数和casefold()函数的区别：lower() 方法只对ASCII编码，即‘A-Z’有效，对于其它语言中把大写转换为小写的情况无效，只能用 casefold() 函数
print("Groß - α".casefold())  # 德语'gross - α'

2.字符串填充

center()

# center() - 返回长度为width多少,两边用fillchar(单字符)填充的字符串，即字符串str居中，两边用fillchar填充。若字符串的长度大于width,则直接返回字符串str
'''
参数：
width - 字符串长度
fillchar - 填充的单字符，默认为空格
'''
print('hello python'.center(10))  # hello python
print('hello python'.center(20, '*'))  # ****hello python****

name = ['Jack', 'jenny', 'joe']
new_name = [new_name.center(10, '#') for new_name in name]
print(new_name)  # ['###Jack###', '##jenny###', '###joe####']

ljust()

# ljust() - 原字符串左对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
print('hello python'.ljust(10))  # hello python
print('hello python'.ljust(15, '*'))  # hello python***

name = ['Jack', 'jenny', 'joe']
new_name = [new_name.ljust(5, '#') for new_name in name]
print(new_name)  # ['Jack#', 'jenny', 'joe##']

rjust()

# rjust() - 原字符串右对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
print('hello python'.rjust(20))  # hello python
print('hello python'.rjust(15, '*'))  # ***hello python

name = ['Jack', 'jenny', 'joe']
new_name = [new_name.rjust(5, '#') for new_name in name]
print(new_name)  # ['#Jack', 'jenny', '##joe']

zfill()

# zfill() - 返回指定长度的字符串，使原字符串右对齐，前面用0填充到指定字符串长度
print('12'.zfill(10))  # 0000000012

num = ['56783', '34', '987766721', '326']
new_num = [id.zfill(10) for id in num]
print(new_num)  # ['0000056783', '0000000034', '0987766721', '0000000326']

3.字符串编码

encode()

# encode() - 以指定的编码格式编码字符串，默认编码为 'utf-8'。encode英文原意 编码
'''
参数：
encoding - 可选，编码格式，常用 utf-8,gb2312,cp936,gbk等
error - 可选，设置不同错误的处理方案。默认为 strict, 编码错误引起一个 UnicodeEncodeError, 其它可能值有 'ignore', 'replace', 'xmlcharrefreplace'以及通过 codecs.register_error() 注册其它的值
'''
print("我爱祖国".encode(encoding="utf8", errors="strict"))  # b'\xe6\x88\x91\xe7\x88\xb1\xe7\xa5\x96\xe5\x9b\xbd'
print("I love my country".encode(encoding="utf8", errors="strict"))  # b'I love my country'

decode()

# decode() - 以 encoding 指定的编码格式解码字符串，默认编码为字符串编码。decode英文意思是 解码
# 编码
str1 = "我爱学习".encode(encoding="utf-8")
print(str1)  # b'\xe6\x88\x91\xe7\x88\xb1\xe5\xad\xa6\xe4\xb9\xa0'
# 解码
print(str1.decode(encoding="utf-8"))  # 我爱学习

4.查找

find()

# find() - 查找字符串中指定的子字符串sub第一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1
'''
参数：
sub — 要索引的子字符串。
start — 索引的起始位置。默认值为0。
end — 索引的结束位置。默认值为字符串长度len(str)。[start,end) 不包括end
'''
# 查找子字符串"o"
print("I love python".find('o'))  # 3
# 索引起始位置为4 索引范围为：
print("I love python".find('o', 4))  # 11
# 索引起始位置为4,结束位置为12 索引范围为：
print("I love python".find('o', 4, 12))  # 11
# 不包括11位的'o',返回-1
print("I love python".find('o', 4, 11))  # -1

rfind()

# rfind() - 查找字符串中指定的子字符串sub最后一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1
'''
参数：
sub — 要索引的子字符串。
start — 索引的起始位置。默认值为0。
end — 索引的结束位置。默认值为字符串长度len(str)。[start,end) 不包括end
'''
# 查找子字符串"o"
print("I love python".rfind('o'))  # 11
# 索引起始位置为4 索引范围为：
print("I love python".rfind('o', 4))  # 11
# 索引起始位置为4,结束位置为12 索引范围为：
print("I love python".rfind('o', 2, 11))  # 3

# 注：rfind()函数用法与find()函数相似，rfind()函数返回指定子字符串最后一次出现的位置，find()函数返回指定子字符串第一次出现的位置

index()

# index() - 查找字符串中第一次出现的子字符串的位置，可以规定字符串的索引查找范围[star,end)。若无则会报错
'''
参数：
sub — 查找的子字符串
start — 索引的起始位置，默认为0
end — 索引的结束位置，默认为字符串的长度
'''
print("I love python".index("o"))  # 3
# 默认索引整个字符串
print("I love python".index("o", 4))  # 11
print("I love python".index("o", 4, 12))  # 11
# 索引多个字符串
print("I love python".index("love"))  # 2
print("I love python".index("k"))  # 索引字符串不存在,报错 ValueError: substring not found

rindex()

# rindex() - 返回子字符串最后一次出现在字符串中的索引位置，该方法与 rfind() 方法一样，可以规定字符串的索引查找范围[star,end)，只不过如果子字符串不在字符串中会报一个异常
'''
参数：
sub — 查找的子字符串
start — 索引的起始位置，默认为0
end — 索引的结束位置，默认为字符串的长度
'''
print("I love python".rindex('o'))  # 11
print("I love python".index('o'))  # 3
# print("I love python".rindex('k')) # 报错 ValueError: substring not found

print("I love python".rfind('k'))  # -1

5.字符串格式化

format()

# format() - Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。使用format()来格式化字符串时，使用在字符串中使用{}作为占位符，占位符的内容将引用format()中的参数进行替换。可以是位置参数、命名参数或者兼而有之
# 位置参数
print('{}:您{}购买的{}到了！请下楼取快递。'.format('快递小哥', '淘宝', '快递'))  # 快递小哥:您淘宝购买的快递到了！请下楼取快递。
# 给批量客户发短息
n_list = ['马云', '马化腾', '麻子', '小红', '李彦宏', '二狗子']
for name in n_list:
    print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(name))
    # 马云：您淘宝购买的快递到了！请下楼取快递！
    # 马化腾：您淘宝购买的快递到了！请下楼取快递！
    # 麻子：您淘宝购买的快递到了！

# 名字进行填充
for n in n_list:
    print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(n.center(3, '*')))
    # *马云：您淘宝购买的快递到了！请下楼取快递！
    # 马化腾：您淘宝购买的快递到了！请下楼取快递！

print('{0}, {1} and {2}'.format('gao', 'fu', 'shuai'))  # gao, fu and shuai
x = 3
y = 5
print('{0}+{1}={2}'.format(x, y, x + y))  # 3+5=8

# 命名参数
print('{name1}, {name2} and {name3}'.format(name1='gao', name2='fu', name3='shuai'))  # gao, fu and shuai
# 混合位置参数、命名参数
print('{name1}, {0} and {name3}'.format("shuai", name1='fu', name3='gao'))  # fu, shuai and gao

format_map()

# format_map() - 返回字符串的格式化版本。在Python3中使用format和format_map方法都可以进行字符串格式化，但format是一种所有情况都能使用的格式化方法，format_map仅使用于字符串格式中可变数据参数来源于字典等映射关系数据时才可以使用
People = {"name": "john", "age": 33}
print("My name is {name},iam{age} old".format_map(People))  # My name is john,iam33 old
# 对比案例定义一个字典
student = {'name': '张三', 'class': '20200504', 'score': 748}
# 使用format输出相关信息：
print('{st[class]}班{st[name]}总分：{st[score]}'.format(st=student))  # 20200504班张三总分：748
# format_map方法后如下
print('{class}班{name}总分：{score}'.format_map(student))

6.解决判断问题

endswith()

# endswith() - 判断字符串是否以指定字符或子字符串结尾
'''
参数：
suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略，常用于判断文件类型）
start —索引字符串的起始位置
end — 索引字符串的结束位置
'''
print("I love python".endswith('n'))  # True
print("I love python".endswith("python"))  # True

# 索引 i love 是否以“n”结尾。
print("I love python".endswith("n", 0, 6))  # False

# 空字符True
print("I love".endswith(""))  # True

# 遍历元组的元素，存在即返回True，否者返回False
print("I love python".endswith(("n", "z")))  # True
print("I love python".endswith(("k", "m")))  # False

# 元组案例
file = "python.txt"
if file.endswith("txt"):
    print("该文件是文本文件")  # 该文件是文本文件
elif file.endswith(("AVI", "WMV", "RM")):
    print("该文件为视频文件")
else:
    print("文件格式未知")

# 注意：空字符的情况。返回值通常为True

startswith()

# startswith() - 判断字符串是否以指定字符或子字符串开头
print("hello,i love python".startswith("h"))  # True
# 索引 llo,i lo 是否以“l”开头
print("hello,i love python".startswith("l", 2, 10))  # True
# 空字符
print("hello,i love python".startswith(""))  # True
# 只索引  hello,
print("hello,i love python"[0:6].startswith("h"))  # True

print("hello,i love python"[0:6].startswith("e"))  # False
print("hello,i love python"[0:6].startswith(""))  # True

# 遍历元组的元素，存在即返回True，否者返回FalseTrue
print("hello,i love python".startswith(("h", "z")))  # True
print("hello,i love python".startswith(("k", "m")))  # False

isalnum()

# isalnum() - 检测字符串是否由字母和数字组成。str中至少有一个字符且所有字符都是字母或数字则返回 True,否则返回 False
# 对字母和数字
print("seven-11".isalnum())  # False 因为有 - 组成
print("seven11".isalnum())  # True
print("seven".isalnum())  # True
print("11".isalnum())  # True

isalpha()

# isalpha() - 检测字符串是否只由字母组成。字符串中至少有一个字符且所有字符都是字母则返回 True,否则返回 False
# 只对字母
# 存在空格返回False
print("I love python".isalpha())  # False
print("Ilovepython".isalpha())  # True
print("Ilovepython123".isalpha())  # False

isdigit()

# isdigit() - 检测字符串是否只由数字组成.字符串中至少有一个字符且所有字符都是数字则返回 True,否则返回 False
# 只对数字
# 全为字母
print("python".isdigit())  # False
# 全为数字
print("123".isdigit())  # True
# 字母和数字的组合
print("python666".isdigit())  # False
# 中文数字输出
print("一二三四五六七".isdigit())  # False
print("①".isdigit())  # True
# 注：能判断“①”，不能判断中文数字。但 isnumeric() 函数可以

isdecimal()

# isdecimal() - 检查字符串是否只包含十进制字符。字符串中若只包含十进制字符返回True，否则返回False。该方法只存在于unicode对象中。注意:定义一个十进制字符串，只需要在字符串前添加前缀 'u' 即可
print("123456".isdecimal())  # True
print("123456".isdecimal())  # True
print("123456python".isdecimal())  # False

isidentifer()

# isidentifer() - 判断str是否是有效的标识符。str为符合命名规则的变量，保留标识符则返回True,否者返回False
'''
标识符必须由字母、下划线和数字组成，且数字不能开头。
'''
# 变量名为123
print("123".isidentifier())  # False
# 变量名为保留字
print("def".isidentifier())  # True
# 变量名有下划线开头
print("_123".isidentifier())  # True
# 变量名由字母开端
print("student".isidentifier())  # True

islower()

# islower() - 检测字符串中的字母是否全由小写字母组成。（字符串中可包含非字母字符）字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是小写，则返回 True，否则返回 False
# 字符串中的字母全为小写
print("i love python".islower())  # True
# 字符串中的字母全为小写，也存在非字母的字符
print("我爱python！".islower())  # True
# 字符串中有大写字符
print("I love python".islower())  # False

isupper()

# isupper() - 检测字符串中的字母是否全由大写字母组成
# 全为大写字母
print("I LOVE PYTHON".isupper())  # True
# 存在小写字母
print("i LOVE PYTHON".isupper())  # False
# 存在非字母的字符
print("我爱PYTHON".isupper())  # True

inumeric()

# inumeric() - 测字符串是否只由数字组成。这种方法是只适用于unicode对象。字符串中只包含数字字符，则返回 True，否则返回 False
# 全为数字
print("123456".isnumeric())  # True
# 字母数字组合
print("python666".isnumeric())  # False
# 中文数字
print("一二三四五六".isnumeric())  # True
print("①".isnumeric())  # True

isprintable()

# isprintable() - 判断字符串中是否有打印后不可见的内容。如：\n \t 等字符。若字符串中不存在\n \t 等不可见的内容，则返回True,否者返回False
# 不存在用print()打印后不可见的内容
print("i love  python".isprintable())  # True
# 存在用print()打印后不可见的内容 \n
print("i love python \n".isprintable())  # False
print("i love \t python".isprintable())  # False

isspace()

# isspace() - 检测字符串首字符是否是空格。是则返回 True，否则返回 False
str1 = "   "
# 空格
str2 = "i love python"
print(str1.isspace())  # True
print(str2.isspace())  # False

# 字符串str2 的第二个字符为空格
print(str2[1].isspace())  # True

istitle()

# istitle() - 检测判断字符串中所有单词的首字母是否为大写，且其它字母是否为小写，字符串中可以存在其它非字母的字符。若字符串中所有单词的首字母为大写，且其它字母为小写，则返回 True，否则返回 False
# 各单词的首字母均为大写，其余字母为小写
print("I Love Python".istitle())  # True
print("I love python".istitle())  # False
print("I LOVE PYTHON".istitle())  # False
# 存在其它非字母字符
print("我爱Python".istitle())  # True

7.字符串修剪

strip()

# strip() - 去除字符串开头和结尾处指定的字符，不会去除字符串中间对应的字符
# 默认参数，去除了空格，\n \t \r字符，且未除去字符串中间相应的字符
a = ' \n111 aaa  '
print(a.strip())  # 111 aaa
# 去除两端的指定字符
b = '.-.word:我很帅.-.'
print(b.strip('.-.'))  # word:我很帅
c = '参考：来自公众号AI入门学习'
print(c.strip('参考：'))  # 来自公众号AI入门学习
# 链式调用法
s = '\n # hello world ! # \n'
print(s.strip().strip('#'))  # hello world !

lstrip()

# lstrip() - 截掉字符串左边的空格或指定字符
# 去除左边指定字符
a = '--我爱Python--'
print(a.lstrip('--'))  # 我爱Python--
# 重复的值只需要写一个
print(a.lstrip('-'))  # 我爱Python--

rstrip()

# rstrip() - 删除 str 字符串末尾的指定字符（默认为空格）
# 去除左边指定字符
a = '6234412134445533-456'
print(a.rstrip('-456'))  # 6234412134445533
# 对一个列表所有的字符串进行去除
ls = ['34667777777-456', '62344121344433-456', '28993333455-456']
print([i.rstrip('-456') for i in ls])  # ['34667777777', '62344121344433', '28993333']

8.字符串加密解密

maketrans()

# maketrans() - 制作翻译表，删除表，常与translate()函数连用。即：返回用于str.translate方法翻译的转换表
'''
参数：
intab - 字符串中要替代的字符组成的字符串。
outtab - 相应的映射字符的字符串。
delchars - 可选参数，表示要删除的字符组成的字符串
'''
# 生成一个字符一对一映射的table，然后使用 translate(table) 对字符串S中的每个字符进行映射。例如，现在想要对"I love fairy"做一个简单的加密，将里面部分字符都替换为数字，这样别人就不知道转换后的这句话是什么意思。
in_str = 'afcxyo'
out_str = '123456'
# maketrans()生成映射表
map_table = str.maketrans(in_str, out_str)
print(map_table)  # {97: 49, 102: 50, 99: 51, 120: 52, 121: 53, 111: 54}

# 使用translate()进行映射
my_love = 'I love fairy'
print(my_love.translate(map_table))  # I l6ve 21ir5

# 注意maketrans(x, y, z]) 中的x和y都是字符串，且长度必须相等。如果maketrans(x, y, z]) 给定了第三个参数z，这这个参数字符串中的每个字符都会被映射为None。'yo'都会被隐藏了
map_table = str.maketrans(in_str, out_str, 'yo')
print(map_table)  # {97: 49, 102: 50, 99: 51, 120: 52, 121: None, 111: None}
my_love = 'I love fairy'
print(my_love.translate(map_table))  # I lve 21ir

translate()

# translate() - 过滤(删除)，翻译字符串。即根据maketrans()函数给出的字符映射转换表来转换字符串中的字符

9.字符串分割

partition()

# partition() - 根据指定的分隔符(sep)将字符串进行分割。从字符串左边开始索引分隔符sep,索引到则停止索引
string = 'https://www.google.com.hk/'
# 字符串str中存在sep
print(string.partition("://"))  # ('https', '://', 'www.google.com.hk/')

# 字符串str中不存在sep ",",返回了两个空字符串。
print(string.partition(","))  # ('https://www.google.com.hk/', '', '')

# 字符串str中存在两个 "." 但索引到www后的"."  停止索引。
print(string.partition("."))  # ('https://www', '.', 'google.com.hk/')

# 返回的是tuple类型tuple
print(type(string.partition("://")))  # 

rpartition()

# rpartition() - 根据指定的分隔符(sep)将字符串进行分割。从字符串右边(末尾)开始索引分隔符sep,索引到则停止索引
string = 'https://www.google.com.hk/'
# 字符串str中不存在sep",",返回了两个空字符串。
print(string.rpartition("."))  # ('https://www.google.com', '.', 'hk/')

# 字符串str中不存在sep",",返回了两个空字符串。
print(string.partition("."))  # ('https://www', '.', 'google.com.hk/')

split()

# split() - 拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表
'''
参数：
sep — 分隔符，默认为空格,但不能为空即(")
maxsplit — 最大分割参数，默认参数为-1
[n] — 返回列表中下标为n的元素。列表索引的用法
'''
# 默认空格分割
str1 = "I love python"
print(str1.split())  # ['I', 'love', 'python']
# 取第三位
print(str1.split()[2])  # python
# 以"."为分隔符,maxsplit默认为-1
str2 = '列夫·尼古拉耶维奇·托尔斯泰'
print(str2.split('·'))  # ['列夫', '尼古拉耶维奇', '托尔斯泰']
# 以"."为分隔符,只分割一次。
print(str2.split('·', 1))  # ['列夫', '尼古拉耶维奇·托尔斯泰']

rsplit()

# rsplit() - 拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表,类似于split()函数，只不过 rsplit()函数是从字符串右边(末尾)开始分割
# 只搜索到一个sep时，两者结果相同
print('abcxyzopq'.partition('xy'))  # ('abc', 'xy', 'zopq')
print('abcxyzopq'.rpartition('xy'))  # ('abc', 'xy', 'zopq')
# 搜索到多个sep时，分别从左第一个、右第一个sep分割
print('abcxyzopxyq'.partition('xy'))  # ('abc', 'xy', 'zopxyq')
print('abcxyzopxyq'.rpartition('xy'))  # ('abcxyzop', 'xy', 'q')

splitlines()

# splitlines() - 按照('\n', '\r', \r\n'等)分隔，返回一个包含各行作为元素的列表，默认不包含换行符。\n 换行符 \r 回车符 \r\n 回车+换行
# 字符串以换行符为分隔符拆分，去掉换行符
print('HOW\nSOFT\nWORKS'.splitlines())  # ['HOW', 'SOFT', 'WORKS']
# 如果keepends为True，保留换行符
print('HOW\nSOFT\nWORKS'.splitlines(True))  # ['HOW\n', 'SOFT\n', 'WORKS']
print("123\n456\r789\r\nabc".splitlines())  # ['123', '456', '789', 'abc']

10.字符串拼接

join()

# join() - 将iterable变量的每一个元素后增加一个str字符串
'''
1.python中经常看到join，特别是在自然语言处理的时候，分词什么的，但是很多初学者不理解其中的意思，这里进行详细的介绍，希望对大家能有帮助。将可迭代对象(iterable)中的字符串使用string连接起来。
2.注意，iterable中必须全部是字符串类型，否则报错。
3.如果你还是python的初学者，还不知道iterable（参数）是什么，却想来看看join的具体语法，那么你可以暂时将它理解为：字符串string、列表list、元组tuple、字典dict、集合set。当然还有生成器generator等也可以用该方法
'''
# 字符串
L = 'python'
print('_'.join(L))  # p_y_t_h_o_n
print('_uu_'.join(L))  # p_uu_y_uu_t_uu_h_uu_o_uu_n
# 元组
L1 = ('1', '2', '3')
print('_'.join(L1))  # 1_2_3
# 集合。注意，集合无序。
L2 = {'p', 'y', 't', 'h', 'o', 'n'}
print('_'.join(L2))  # h_y_o_n_p_t
# 列表
L2 = ['py', 'th', 'o', 'n']
print('*'.join(L2))  # py*th*o*n
# 字典
L3 = {'name': "malongshuai", 'gender': 'male', 'from': 'China', 'age': 18}
print('--'.join(L3))  # name--gender--from--age
# 参数，参与迭代的部分必须是字符串类型，不能包含数字或其他类型。
L4 = (1, 2, 3)
print('_'.join(L4))  # 报错 TypeError: sequence item 0: expected str instance
# int found以下两种也不能join。
L1 = ('ab', 2)
L2 = ('AB', {'a', 'cd'})

11.字符串替换

replace()

# replace() - 把 str 中的 old 替换成 new, 如果 count 指定，则替换不超过 count次
'''
参数：
old — 将被替换的子字符串。
new — 新子字符串，用于替换old子字符串
count — 替换的次数，默认全部替换
'''
s = "我的小伙伴张三"
print(s.replace("张三", "马云"))  # 我的小伙伴马云

# 默认字符串中的全部"o" 全部替换为"w"
s = "I love python"
print(s.replace("o", "w"))  # I lwve pythwn
# 只替换一个"o"
print(s.replace("o", "w", 1))  # I lwve python
# 子字符串可以是多个字符。
print(s.replace("python", "java"))  # I love java

expandtabs()

# expandtabs() - 将字符串S中的 \t 替换为一定数量的空格。默认N=8
print('01\t012\t0123\t01234'.expandtabs(4))  # 01  012 0123    01234
print('01\t012\t0123\t01234'.expandtabs(8))  # 01      012     0123    01234

# tabsize 的默认值为8。tabsize值为0到7等效于tabsize=8。tabsize每增加1，原字符串中“\t”的空间会多加一个空格

12.统计次数

count()

# count() - 统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置
'''
参数：
str — 为要统计的字符(可以是单字符，也可以是多字符)
star — 为索引字符串的起始位置，默认参数为0
end — 为索引字符串的结束位置，默认参数为字符串长度即len(str)
'''
print('abc--qo-ab'.count('ab'))  # 出现 2 次
print(type('abc--qo-ab'.count('ab')))  # 
# 从第二位开始查找
print('abc--qo-ab'.count('ab', 1))  # 出现 1 次
# 不包括边界
print('abc--qo-ab'.count('ab', 1, 9))  # 出现 0 次

转义字符

在编程中，转义字符用于表示一些在字符串中无法直接表示或输入的特殊字符。它们以反斜杠（\）开头，后面跟着一个字符，表示特定的含义。通过使用转义字符，我们可以在字符串中插入换行符、制表符、引号等特殊字符，或者表示一些不可见的字符

转义字符	描述
\	(在行尾时)续行符
\	反斜杠符号
’	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

原生字符串

原字符（Raw String）是以前缀r或R开头的字符串，由于字符串中的反斜线都有特殊的作用，因此当字符串中包含反斜线时，就需要使用转义字符 \ 对字符串中包含的每个 ‘’ 进行转义。

'''
比如说，我们要写一个关于 Windows 路径 `G:\publish\codes\02\2.4` 这样的字符串，如果在 Python 程序中直接这样写肯定是不行的，需要使用 \ 转义字符，对字符串中每个 '\' 进行转义，即写成 `G:\\publish\\codes\\02\\2.4 `这种形式才行。

有没有觉得这种写法很啰嗦，有没有更好的解决办法呢？答案是肯定的，借助于原始字符串可以很好地解决这个问题，原始字符串以“r”开头，它不会把反斜线当成特殊字符。
'''
add = r'G:\publish\codes\02\2.4'
print(add)  # G:\publish\codes\02\2.4

# 原生字符 r
# 原始字符串包含的引号，同样需要转义
s = r'我爱 \npython '
print(s)  # 我爱 \npython