目录
1. 简介
字符串是文本序列类型,是有Unicode字符构成的不可变序列。
- ASCII:ASCII 全称为美国国家信息交换标准码,是最早的标准字符集,使用7个或8个二进制位进行编码,最多可以给256个字符分配数值,包括26个大写、小写字母,10个数字,标点符号,控制字符及其它符号。
- GB2312:GB2312 是一个简休中文字符集,由6763个常用汉宇和682个全角的非汉宇宇符红成。GB2312 编码使用两个字节表示一个汉字,最多可以表示256×256=65536个汉字。
- GBK:GBK 编码标准兼容 GB2312,并对其进行扩展,也来用双字节表示。共收录21003个汉字、883个符号,并提供 1894 个造宇码位,简、繁体字融于一库。
- Unicode:Unicode 是全球通用字符編码表,为每种语言中的每个字符设定了统一且唯一的二进制编码,以满足跨语言、跨平台进行文本转换、处理的要求。采用两个字节表示一个宇符,原有的英文编码从单字节变成双字节,只需要把高字节全部填为0即可。
- UTF-8:UTF-8编码是针对 Unicode 的一种可变长度字符编码。它可以表示 Unicode 标淮中的任何字符,并与 ASCIl 完全兼容,采用1~4个字节来表示一个字符。
2. 字符串基础
2.1 构造字符串
字符串字面值构造,单双引号要成对出现,语法如下:
# 单引号
'定义单行字符串,可以包含"双引号"'
# 双引号
"定义单行字符串,可以包含'双引号'"
# 三引号
'''三重单引号,可以定义单行字符串,或者多行字符串'''
"""三重双引号,可以定义单行字符串,或者多行字符串"""
str1 = '''
Hello,world
人生苦短,我用python
'''
使用三引号定义字符串可以跨越多行,其中,所有的空白字符都将包含在该字符串字面值中。如果在单引号或双引号定义的单行宇符串中添加换行符 (\n),可以间接表示多行字符串。
在三引号定义的字符串中,可以包含单引号、双引号、换行符、制表符,以及其他特殊字符,对于这些特殊字符不需要转义,此外,还可以包含注释信息。使用三引号能够确保字符串的原始格式,避免烦琐的转义,方便格式化排版。
使用`str()构造,参数可以为任意的对象,如果省略参数,将创建一个空字符串。
str1 = str() # 定义一个空字符串,返回""
str2 = str([]) # 把空列表转换为字符串,"[]"
str3 = str([1,2,3]) # "[1,2,3]"
str4 = str(None) # "None"
2.2 转义序列
转义序列是指一些不能直接在字符串中表示,不可见的空字符、易引发歧义的字符等
原始字符串
原始字符串就是原义字符串,以R或r作为字符串字面值前缀,常用于定义正则表达式字符串。
r'原始字符串'
R'原始字符串'
# 显示 E:\a\b\c\d
print(r'E:\a\b\c\d')
print(R'E:\a\b\c\d')
print('E:\\a\\b\\c\\d') # 使用转义字符
2.3 字符串编码和解码
在Python中,字符串编码就是把字符串转换为字节码,解码就是把字节码表示转换为字符串。
使用encode()
可以根据参数encoding指定的编码格式将字符串编码为二进制数据的字节串,string表示字符串对象,参数encoding表示编码格式,默认为UTF-8,参数errors设置不同的处理方案,默认为strict,表示遇到非法字符就抛出异常。
string.encode(encoding='UTF-8',errors='strict')
使用decode()可以解码字节码,返回字符串。
byte.decode(encoding='UTF-8',errors='strict')
示例
u = '中文'
byte1 = u.encode() # 默认UTF-8进行编码,获取bytes类型对象
print(byte1) # b'\xe4\xb8\xad\xe6\x96\x87'
byte2 = u.encode('gbk') # 默认GBK进行编码,获取bytes类型对象
print(byte2) # b'\xd6\xd0\xce\xc4'
u1 = byte1.decode('utf-8') # 以UTF-8进行解码,获取字符串对象
print(u1) # 中文
u2 = byte2.decode('gbk') # 以GBK进行解码,获取字符串对象
print(u2)# 中文
2.4 字符串长度
使用len()
函数以字符为单位统计字符串的长度,每个汉字视为一个字符。
s1 = '中国China'
print(len(s1)) # 7
在UTF-8编码中,每个汉字占用3个字符,而在GBK或GB2312中,每个汉字占用2个字符。计算字符串长度时,可以考虑字节编码。在Python中,字母、数字、特殊字符一般占用一个字节,汉字一般占用2~4个字节。
s1 = '中国China'
print(len(s1.encode())) # 11
print(len(s1.encode('gbk))) # 9
3. 字节串基础
3.1 认识字节串
字节串 (bytes)是不可变的字节序列,存储以字节为单位的数据。bytes 类型是Python3新增的一种数据类型。字节串与字符串的比较如下。
- 字符串由多个宇符构成,以字符为单位进行操作。默认为 Unicode 宇符,字符范围 0~65535。字符串是字符序列,它是一种抽象的概念,不能直接存储在硬盘中,用以显示供人阅读或操作的。
- 字节串由多个字节构成,以字节为单位进行操作。字节是整型值,取值范围为 0~255。 字节串是字节序列,因此可以直接存储在硬密中,供计算机读取、传输或保存。
除了操作单元不同外,字节串与字符串的用法基本相同,它们之问的映射被称为解码或编码。
3.2 构造字节串
字节串字面值是以b为前缀的ASCII字符串,语法如下:
b'ASCII字符串'
b'转义字符'
b''
B"" # 创建空字节串
b'ABCD'
b'\x41\x42'
使用bytes()
函数创建,语法如下:
bytes() # 生成空字节串
bytes(整型可迭代对象) # 用可迭代对象初始化一个字节串,元素[0,255]
bytes(整数n) # 生成n个值为0的字节串
bytes('字符串',encoding='编码格式') # 使用字符串的转换编码生成一个字节串
a = bytes() # 等效于:b"
b = bytes([10,20,30,65,66,67]) # 等效于:b'\n\x14\x1eABC'
c = bytes(range(65,65+26)) # 等效于: b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
d = bytes(5) # b'\x00\x00\x00\x00\x00'
e = bytes('hello 中国','utf-8') # b'hello \xe4\xb8\xad\xe5\x9b\xbd'
#(1)str 转换为 bytes:
bytes = str.encode(utf-8*)
bytes = bytes(str, encoding=' utf-8')
#(2)bytes 转换为 str:
str = bytes.decode(utf-8')
str = str(bytes)
3.3 应用字节串
计算MD5值,有一步需要使用update()
方法,而该方法只接受bytes类型数据。因此,对字符串进行加密时,需要先转换为字节串,然后再进行加密处理。
import hashlib
string = '123456'
m = hashlib.md5() # 创建MD5对象
str_bytes = string.encode(encoding='utf-8') # 转换为字节串
m.update(str_bytes) # update()只接受bytes类型数据作为参数
str_md5 = m.hexdigest() # 获取散列后的字符串
print('MD5散列前为:',string)# MD5散列前为: 123456
print('MD5散列后为:',str_md5)# MD5散列后为: e10adc3949ba59abbe56e057f20f883e
使用二进制方式读写文件时,要用到bytes类型,二进制写文件时,write()方法只接收bytes类型数据,因此,需要先将字符串转换成字节串;读取二进制文件时,read()方法返回的是字节串,使用decode()方法可将字节串转换成字符串
f = open('data','wb') # 新建二进制文件
text = '二进制写文件' # 定义字符串
text_bytes = text.encode('utf-8') # 转换为字节串
f.write(text_bytes) # 写入字节串
f.close() # 关闭文件
f = open('data','rb') # 打开二进制文件
data = f.read() # 读取二进制数据流
str_data = data.decode('utf-8') # 转换为字符串
print(data,type(data)) # b'\xe4\xba\x8c\xe8\xbf\x9b\xe5\x88\xb6\xe5\x86\x99\xe6\x96\x87\xe4\xbb\xb6' <class 'bytes'>
print(str_data) # 二进制写文件
f.close() # 关闭文件
4. 操作字符串
4.1 访问字符串
Python 访问字符串有两种方式:下标索引和切片。
str1 = '0123456789'
print(str1[0:3]) # 012
print(str1[:]) # 0123456789
print(str1[::-1]) # 9876543210
print(str1[-3:-1]) # 78
4.2 遍历字符串
遍历字符串主要是用for
语句,也可以使用while
语句。
使用iter()
函数将字符串生成迭代器,然后循环遍历返回对应值。
s1 = 'Python'
l = [] # 定义临时备用列表
for item in iter(s1): # 把字符串生成迭代器,然后再遍历
l.append(item.upper()) # 把每个字符转换大写
print("".join(l)) # 输出 PYTHON
使用enumerate()
函数将字符串转换为索引序列,索引序列中每个元素为一个元组。
s1 = 'Python'
l = [] # 定义临时备用列表
for i,char in ennumerate(s1): # 把字符串转换为索引序列,然后再遍历
l.append(char.upper()) # 把每个字符转换大写
print("".join(l)) # 输出 PYTHON
使用range()
函数生成一个数字列表,遍历数字列表,逐个访问字符串中每个字符。
s1 = 'Python'
l = [] # 定义临时备用列表
for i in range(len(s1)): # 从0开始,直到字符串总长度
l.append(char[i].upper()) # 把每个字符转换大写
print("".join(l)) # 输出 PYTHON
逆序遍历,从右到左反向遍历迭代对象。
s1 = 'Python'
for i in s1[::-1]: # 取反切片遍历
print(i,end=" ")
for i in range(len(s)-1,-1,-1): # 通过range实现
print(s1[i],end=" ")
for i in reversed(s1): # 通过reversed实现
print(i,end=" ") # n o h t y P
4.3 连接字符串
最常用的有以下两种,语法和示例如下:
# 使用加号运算拼接
+
'''返回一个有iterable中的字符串拼接而成的字符串。
如果iterable中存在任何非字符串值,包括bytes对象,则引发TypeError异常。
'''
str.join(iterable)
s1 = 'Hello'
s2 = 'Python'
s3 = s1 + s2
s4 = ''join(s2)
s5 = '_'join(s2)
s6 = '_'.join(['a','b','c'])
s7 = '_'.join([1,'b','c']) #
4.4 分割字符串
使用partition()
分割,在sep首次出现位置拆分字符串,返回一个3元组,其中分隔符之前、分隔符和分隔符之后部分,如果分割符未找到,则返回3元组中包含字符串本身以及两个空字符串。
str.partion(sep)
str1 = 'www.mysite.com'
print(str1.parttion('.')) # ('www','.','mysite.com')
print(str1.parttion(',')) # ('www.mysite.com','','')
使用rpartition()
分割,在sep最后一次出现的位置拆分字符串,返回一个3元组,其中分隔符之前、分隔符和分隔符之后部分,如果分割符未找到,则返回3元组中包含两个空字符串以及字符串本身。
str.rpartion(sep)
str1 = 'www.mysite.com'
print(str1.rparttion('.')) # ('www.mysite','.','com')
print(str1.rparttion(',')) # ('','','www.mysite.com')
使用split()
分割,返回一个有字符串内单词组成的列表,使用sep分隔符,如果给出了maxsplit,则最多进行maxsplit次拆分;如果maxsplit未指定或为-1,则不限制拆分次数;如果sep未指定或为None,任何空白字符串都会被作为分隔符,但不包含首位的空字符串。
str.split(sep=None,maxsplit=-1)
str1 = 'www.mysite.com'
print(str1.split('.')) # 不限拆分次数 ['www','mysite','com']
print(str1.split('.',1)) # 限制拆分次数 ['www','mysite.com']
使用splitlines()分割,返回由原字符中各行组成的列表,在行边界的位置拆分;结果列表中不包含行边界,除非给了keepends ,且为真值,行边界主要包括:\n、\r、\f、\v 等。
str.splitlines([keepends])
str1 = 'a\n\nb\re\r\nd'
t1 = str1.splitlines() # 不包含换行符
t2 = str1.splitlines(True) # 包含换行符
print(t1) # ['a','b','c','d']
print(t2) # ['a\n','\n','b\r','c\r\n','d']
4.5 替换字符串
字符串是不可变序列,所有的修改都会创建新的字符串。
使用replace()
替换,返回字符串的副本,其中出现的所有子字符串old都将被替换为new,如果给出了可选参数count,则只替换count次出现。
str.replace(old,new[,count])
str1 = 'www.mysite.cn'
print(str1.repalce('mysite','mysql')) # www.mysql.cn
使用expandtabs()
替换,返回字符串的副本,其中所有的制表符会由一个或多个空格替换,具体取决于当前列位置和给定的制表符宽度。每个tabsize 个字符设为一个制表位,默认值8设定的制表位在列0、8、16…。
str.expandtabs(tabsize=8)
print(len('1\t'.expandtabs(8))) # 输出 8,1后面添加了7个空格
print(len('1\t1'.expandtabs(8))) # 输出 9,1后面添加了7个空格
print(len('1\t'.expandtabs(8))) # 输出 8,1后面添加了7个空格
print(len('123456781\t1'.expandtabs(8))) # 输出 16,1后面添加了7个空格
使用maketrans()
,返回一个可供translate()
使用的转换对照表,进一步使用translate(),返回原字符串的副本,其中每个字符按给定的转换表进行映射。
str.maketrans(intab,outtab[,delchars])
bytes.maketrans(intab,outtab)
bytearray.maketrans(intab,outtab)
str.translate(table)
bytes.translate(table[,delete])
bytearray.translate(table[,delete])
a = b"ABCDEFGHIJKLMNOPORSTUVWXYZ" # 大写字节型字符集
b = b"abcdefghijklmnopqrstuvwxyz" # 小写字节型字符集
d = b"THON" # 删除字节型字符集
t1 = bytes.maketrans(a,b) # 创建字节型字符映射转换表
s = b"PYTHON" # 原始字节串
s = s.translate(None, d) # 若table 参数为 None,则只删除不映射
s = s.translate(t1) # 执行映射转换
print(s) # 输出为 b'py'
4.6 裁切字符串
使用strip()
,返回原字符串的副本,移除其中的前导和末尾字符;chars 参数为指定要移除字符的字符串,如果省略或为None,chars 参数默认移除空格符。lstrip()
返回原字符串副本,移除其中的前导字符。rstrip()
返回原字符串副本,移除其中的末尾字符。
str.strip([chars])
str.lstrip([chars])
str.rstrip([chars])
print('www.example.com'.strip('cmowz.'))
print(' www.example.com '.strip()) # 'www.example.com'
print(' www.example.com '.lstrip()) # 'www.example.com '
print(' www.example.com '.rstrip()) # ' www.example.com'
4.7 转换大小写格式
可以使用以下三种方法检测字符串的大小写格式:
islower()
:检测字符串是否为纯小写的格式。isupper()
:检测字符串是否为纯大写的格式。istitle()
:检测字符串是否为“标题化“格式。
字符串大小写格式转换有6种方法:
lower()
:返回原字符串的副本,其中所有区分大小写的字符均转换为小写。upper()
:返回原字符串的副本,其中所有区分大小写的字符均转换为大写。title()
:返回原字符串的标题副本,每个单词第一个字母为大写,其余字母为小写。capitalize()
:返回原字符串的副本,其首个字符大写,其余为小写。swapcase()
:返回原字符串的副本,其中大写字符转换为小写,反之亦然。casefold()
:返回原字符串消除大小写的副本。
print('Python'.islower()) # False
print('Python'.isupper()) # False
print('Python'.istitle()) # True
print('Python'.lower()) # python
print('Python'.upper()) # PYTHON
print('HELLO PYTHON'.title()) # Hello Python
print('HELLO PYTHON'.capitalize()) # Hello python
print('HELLO PYTHON'.swapcase())# hello python
print('HELLO PYTHON'.casefold())# hello python
4.8 检测字符串类型
检测数字、字母和特殊字符:
isascii()
:如果字符串为空或所有字符都是ASCII,返回True,否则False。ASCII范围是U+0000~U+007F。isdecimal()
:如果字符串中的所有字符都是十进制字符,且该字符串至少有一个字符,则返回True,否则False。十进制字符指可以用来组成十进制数的字符,如U+0660,即数字0。isdigit()
:如果字符串中所有字符都是数字,并且至少有一个字符,返回True,否则False。数字包括十进制字符和需要特殊处理的数字,如上标数字、Kharosti数等,即具有 Numerie_Type=Dight 或Numeric_Type=Decimal 特性的字符。isnumeric()
:如果字符串中至少有一个字符,且所有字符均为数值字符,则返回True,否则False。数值字符就是具有Numerie_Type=Digit、Numerie_Type=Decimal 或Numeric_Type=Numeric特性的字符。isalpha()
:如果字符串中的所有字符都是字母,并且至少有一个字符,则返回True,否则False。字母字符是指在Unicode字符数据库中定义的Letter的字符。isalnum()
:如果字符串中的所有字符都是字母或数字,且至少有一个字符,则返回True,否则False。如果c.isalpha()、c.isdecimal()、c.isdigit()或c.isnumeric()之中有一个返回True,则字符c是字母或数字。isspace()
:如果字符串中只有空白字符,且至少有一个字符则返回True,否则返回False。isprintable()
:如果字符串中所有字符均可打印或字符串为空,则返回True,否则False。isidentifier()
:如果字符串是有效标识符,返回True,否则返回False。
isdigit()
、isdecimal()
和isnumeric()
方法都是用来检测数字,但是也有差异:
-
isdigit()
True:Unicode数字、全角数字(双字节)、bytes数字(单字节)。
False:汉字数字、罗马数字、小数。
Error:无
-
isdecimal()
True:Unicode数字、全角数字(双字节)。
False:汉字数字、罗马数字、小数。
Error:byte数字(单字节)。
-
isnumeric()
True:Unicode数字、全角数字(双字节)、汉字数字
False:罗马数字、小数。
Error:byte数字(单字节)。
罗马数字:I、II、III、IV、V、VI、VII、VIII、IX、X等;
汉字数字:一、二、三、四、五、六、七、八、九、十、百、千、万、亿、兆、零、壹等。
4.9 填充字符串
str.center(width[,filcher])
:返回长度为width的字符串,居中显示。使用指定的fillchar填充两边的空位,默认使用ASCII空格符。如果width小于等于len(s),则返回原字符串的副本。str.ljust(width[,filcher])
:返回长度为width的字符串,靠左对齐。使用指定的fillchar填充两边的空位,默认使用ASCII空格符。如果width小于等于len(s),则返回原字符串的副本。str.rjust(width[,filcher])
:返回长度为width的字符串,靠右对齐。使用指定的fillchar填充两边的空位,默认使用ASCII空格符。如果width小于等于len(s),则返回原字符串的副本。str.zfill(width)
:返回原字符串的副本,在左边填充ASCII格式的‘0’,使其长度变为width。正负值前缀(‘+’/‘-’)的处理方式是在正负符号之后填充而非在之前。如果width小于等于len(s),则返回原字符串的副本。
s1 = "Python"
print(s1.center(20,"_")) # _______Python_______
print(s1.ljust(20,"_")) # Python______________
print(s1.rjust(20,"_")) # ______________Python
4.10 检索字符串
str.count(sub[,start[,end]])
:返回子字符串sub在[start,end]范围内非重叠出现的次数。可选参数start和end被解读为切片表示法,默认值为0和字符串的长度len(str)。str.endswith(suffix[,start[,end]])
:如果字符串以指定suffix结束,则返回True,否则False。suffix也可以为由多个供查找的后缀构成的元组。如果有可选项start,将从指定位置开始检查,如果有end,将指定位置停止比较。str.startswith(prefix[,start[,end]])
:如果字符串以指定prefix开始,则返回True,否则False。preffix也可以为由多个供查找的前缀构成的元组。如果有可选项start,将从指定位置开始检查,如果有end,将指定位置停止比较。str.find(sub[,start[,end]])
:返回子字符串sub在str[start:end] 切片内被找到的最小索引。如果sub未被找到则返回-1。str.rfind(sub[,start[,end]])
:返回子字符串sub在字符串内被找到的最大(最右)索引。如果sub未被找到则返回-1。str.index(sub[,start[,end]])
:类似find(),当找不到sub时引发ValueError异常。str.rindex(sub[,start[,end]])
:类似rfind(),当找不到sub时引发ValueError异常。
str ="海水朝朝朝朝朝朝朝落,浮云长长长长长长长消"
print(str.count"长", 11,21)) # 输出为 7
# 检测字符串“海”是否在字符串的开头或结尾
print(str.startswith("海")) # True
print(str.endswith("海")) # False
# 检素“长”在字符串中的索引位置。
prin(str. find("长") # 在整个字符串中检素,输出为 13
pprint(str. find(”长",14)) # 从下标 14 位置开始检素,输出为 14
print str. Find("长",10,13) # 在下标 10~13 内检素,输出为 -1,没有找到
print(str.rfind("长")) # 在整个字符串中检素,输出为 19
prinu(str.rfind("长",14)) # 从下标 14位留开始检索,输出为 19
5. 格式化样式
5.1 printf 风格字符串
format % values
其中,format 为一个字符串,在format 中的%转换标记符将被替换为零个或多个 values 条目。
- 如果 format 要求一个单独参数,则values 可以为一个非元组对象;否则,values 必须是一个包含项数与格式字符串中指定的转换符项数相同的元组,或者是一个单独映射对象,如字典。
- 转换标记符包含两个或更多个字符,并具有以下组成,且必须遵循下面的先后顺序。
- %:用于标记转换符的起始。
- 映射键(可选):由加圆括号的字符序列组成,如(keywordname)。
- 最小字段宽度(可选):如果指定为*(星号),则实际宽度从 values 元组的下一元素中读取,要转换的对象则为最小字段宽度和可选的精度之后的元素。
- 精度(可选)。在 .(点号)之后加精度值的形式给出。如果指定为*(星号),则实际精度从 values元组的下一元素中读取,要转换的对象则为精度之后的元素。
- 长度修饰符 (可选):包括h、1或L,在Python 中可以被忽略。如%1d 等价于%d。
当右边的values 参数为一个字典或其他映射类型时,宇符串中的格式必须包舍加圆括号的映射键,对应%字符之后字典中的每一项。映射键将从映射中选取要格式化的值。例如:
print('%(language)s%(number)02d'%{'language':'Python','number':3}) # Python03
格式化输出字符串和整数
str1 = "%.length = %d" % (Python', len(Python'))
print(str1) # 输出为 Python.length =6
格式化输出不同进制数
n = 1000
print("Hex = %x Dec = %d Oct = %o" % (n, n, n))
# 输出为 Hex -3c8 Dec = 1000 Oct = 1750
格式化输出浮点数
pi = 3.141592653
print('pi1 = %10.3f' % pi) # pi1 = 3.142
print('pi2 = %.*f' % (3, pi)) # pi2 = 3.142
print('pi3 = %010.3f' % pi) # pi3 = 000003.142
print('pi4 = %-10.3f' % pi) # pi4 = 3.142
print('pi5 = %+f' % pi) # pi5 = +3.141593
5.2 format 格式化
str.format()
通过{}
操作符和:辅助指令代替%操作符。
print('{0} (1}'.format('Python', 3.0)) # 输出为 Python 3.0
print('{}{}'format('Python', 3.0)) # 输出为 Python 3.0
print('{1} {0} {1)'.format('Python', 3.0)) # 输出为 3.0 Python 3.0
在字符串中使用台作为格式化操作符。与%操作符不同的是,{}操作符可以通过包含的位置值自定义引用值的位置,也可以重复引用。
print('{name};年龄是{age}岁。'.format(age=18, name='张三')) # 张三年龄是18岁。
l = ['张三',18]
print('{l[0]}年龄是{l[1]}岁。'.format(1))
# 填充与对齐
print('{:>8}'.format('1')# 右边对齐,默认空格填充,总宽度8
print('{:0>8}'.format('1') # 右对齐,0填充,总宽度8
print('{:a<8}'.format('1') # 左对齐,a填充,总宽度8
# 精度与类型f
print('{:2f}'.format(3.1415926))# 输出为 3.14
# 不同进制数字
n = 100
print('{:b}'.format(n)) # 1100100
print('{:d}'.format(n)) # 100
print('{:o}'.format(n)) # 144
print('{:x}'.format(n)) # 64
# 千位分隔符
print('{:,}' format(1234567890)) # 1,234,567,890
5.3 f-strings
在字符串前加上f修饰符,字符串中使用{}包括:表达式;
name = "Python" # 字符串
ver = 3.6 # 浮点数
print( f"{name}-{ver}、{ver+0.1}、{ver+0.2}") # Python-3.6、3.7、3.8000000000000003
注意:特殊格式化修饰符通过冒号与前面的表达式相连,1f表示仅显示1位小数。