Python - 字符串
目录
关于字符串
Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。
创建
- 可以使用引号( ' 或 " )来创建字符串
- 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
var1 = 'Hello World!'
var2 = "Runoob"
三引号
三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符；
常用场景：HTML 或 SQL 语句；
保持 ：WYSIWYG（所见即所得）格式。
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
'''
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
'''
字符串格式化
python字符串格式化符号
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| 在正数前面显示空格 | |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
>>> "我叫 %s 今年 %d 岁!" % ('小明', 10)
我叫 小明 今年 10 岁!
f-string 字面量格式化字符串
f-string 是 python3.6 之后版本添加的，称之为`字面量格式化字符串
以 f 开头，后面跟着字符串；字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去：
这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
>>> name = 'Runoob'
>>> f'Hello {name}' # 替换变量
>>> f'{1+2}' # 使用表达式
'3'
>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'
Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：
>>> x = 1
>>> print(f'{x+1}') # Python 3.6
2
>>> x = 1
>>> print(f'{x+1=}') # Python 3.8
'x+1=2'
转义
raw 字符串
r 将自动关闭转义，适合里面接文件路径、正则表达式
适用于 windows 系统
转义字符表
在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表：
| 转义字符 | 描述 |
|---|---|
| (在行尾时) | 续行符 |
| \ | 反斜杠符号 |
| ' | 单引号 |
| " | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \yyy | 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 |
| \xyy | 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行 |
| \other | 其它的字符以普通格式输出 |
实例
>>> print("line1 \
... line2 \
... line3")
line1 line2 line3
>>>
>>> print("\\")
\
>>> print('\'')
'
>>> print("\"")
"
>>> print("\a") # 执行后电脑有响声。
>>> print("Hello \b World!")
Hello World!
>>> print("\000")
>>>
***
>>> print("Hello \v World!")
Hello
World!
>>>
***
>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")
Hello World!
>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
Hello World!
\b退格
print('321\b0') #320
print('321\b\b0') #30
print('321\b0\b') #32
\r 回到行首
前面内容没有了
print('1314\r520') #520
print('a\n1314\r520')
'''
a
520
'''
字符串运算符
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | a + b 输出结果： HelloPython |
| * | 重复输出字符串 | a*2 \n HelloHello |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 | a[1:4] 输出结果 ell |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | 'H' in a 输出结果 True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | 'M' not in a 输出结果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | print( r'\n' ) print( R'\n' ) |
| % | 格式字符串 | 请看下一节内容。 |
加减对每种类型都有不同的方法；
不是所有类型都可以使用 + 来合并。
>>> a = "Hello"
>>> b = "Python"
>>> a + b
HelloPython
>>> a * 2
HelloHello
>>> 2 * a
HelloHello
>>> a[1]
a[1]
>>> a[1:4]
ell
>>> "H" in a
True
>>> "M" not in a
False
>>> r'\n'
\n
>>> R'\n'
\n
查看、遍历
>>> s = 'hello'
# 通过S[索引]访问指定位置的字符,索引左边从0开始,右边从-1开始
>>> s[0]
'l'
>>> s[len(s)-1]
'n'
>>> s0[0], s0[1]
('h', 'e')
# 负数索引
>>> s[-1] # 反向取值 从-1 开始
'n'
>>> s[-2]
'a'
# 通用特性 - 可迭代
# 通过for循环语句可顺序遍历出每个字符
>>> for c in s:
... print(c, end=' ')
h e l l o
# 通过while循环语句可用索引取出每个字符
>>> index = 0
>>> while i < len(s):
... print(s[index], end=' ')
... index = index + 1
h e l l o
切片 [:]
字符串'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
s = 'pypython'
print(s[2:]) # s[::-1]
print(s[2:4]) # py
print(s[1:12]) # ypython # 不会崩溃
print(s[-6:]) # python # 后六位
print(s[-6:3]) # p
# 取开始位置一直到最后的子字符串,但倒序取且步长为1
print(s[::-1]) # nohtypyp # 反序
s[2:len(s)] # 到底
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'
内建函数
Python 的字符串常用内建函数如下：
属性
| 方法 | 描述 |
|---|---|
| len(string) | 返回字符串长度 |
| max(str) | 返回字符串 str 中最大的字母。 |
| min(str) | 返回字符串 str 中最小的字母。 |
| count(str, beg= 0,end=len(string)) | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
count
>>> 'aaac'.count('m')
0
>>> 'aaac'.count('a')
3
>>> 'aaac'.count('a',2)
1
>>> 'aaac'.count('a',1)
2
>>> 'aaac'.count('a',0,2) # 开始位置、结束位置
2
len() 计算字符长度
计算 bytes，计算结果为字节数
>>> len(b'ABC')
3
>>> len('你好')
2
>>> '你好'.encode('utf-8')
b'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> len('中文'.encode('utf-8')) # 1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。
6
>>> len(b'\xe4\xbd\xa0\xe5\xa5\xbd')
6
大小写处理
| 方法 | 描述 |
|---|---|
| capitalize() | 将字符串的第一个字符转换为大写 |
| upper() | 转换字符串中的小写字母为大写 |
| lower() | 转换字符串中所有大写字符为小写. |
| swapcase() | 将字符串中大写转换为小写，小写转换为大写 |
| title() | 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
>>> 'abcdefg'.capitalize()
'Abcdefg'
>>> 'abcdefg'.title() # 每个单词首字母大写
'Abcdefg'
编码相关
| 方法 | 描述 |
|---|---|
| bytes.decode(encoding="utf-8", errors="strict") | Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| encode(encoding='UTF-8',errors='strict') | 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
判断
| 方法 | 描述 |
|---|---|
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
| isdigit() | 如果字符串只包含数字则返回 True 否则返回 False.. |
| islower() | 字符串是否至少包含一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| isnumeric() | 字符串是否只包含数字字符 |
| isspace() | 如果字符串中只包含空白，则返回 True，否则返回 False. |
| istitle() | 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| isupper() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| isdecimal() | 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
| startswith(substr, beg=0,end=len(string)) | 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。\n 如果beg 和 end 指定值，则在指定范围内检查。 |
| endswith(suffix, beg=0, end=len(string)) | 字符串是否以 obj 结束 \n 如果beg 或者 end 指定检查范围 \n 如果是，返回 True，否则返回 False. |
>>> 'Abc'.istitle()
True
>>> 'ABC'.istitle()
False
>>> 'abc'.istitle()
False
>>> 'abc'.upper()
'ABC'
>>> 'ABC'.lower()
'abc'
startswith & endswith 前缀后缀
>>> 'abc'.startswith('a')
True
>>> 'abc'.startswith('b')
False
>>> 'abc'.endswith('c')
True
>>> 'abc'.endswith('b')
False
后面接元祖，元祖内容是 或 的意思
>>> 'abcdefg'.startswith(('a','c'))
True
后面接两个参数，是指从 2 开始，取5个元素；再来判断
>>> 'abcdefg'.startswith(('a','c'),2,5)
True
>>> 'abcdefg'.startswith(('a','c'),3,5)
False
查找
| 方法 | 描述 |
|---|---|
| find(str, beg=0, end=len(string)) | 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| rfind(str, beg=0,end=len(string)) | 类似于 find()函数，不过是从右边开始查找. |
| index(str, beg=0, end=len(string)) | 跟find()方法一样，只不过如果str不在字符串中会报一个异常。 |
| rindex( str, beg=0, end=len(string)) | 类似于 index()，不过是从右边开始. |
find
>>> 'aaac'.find('a')
0
>>> 'aaac'.find('c')
3
>>> 'aaac'.find('m') # 不存在
-1
>>> 'aaac'.find('a',1,4) # 指定查询范围
1
拼接 & 分割
| 方法 | 描述 |
|---|---|
| join(seq) | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| split(str="", num=string.count(str)) | num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串 |
| splitlines([keepends]) | 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
join 拼接
>>> s = 'abc'
>>> ' '.join(s)
'a b c'
>>> '-'.join(s)
'a-b-c'
split 分隔
>>> s = 'hello world'
# .split([sep [,maxsplit]])
>>> s.split(' ', 1)
['hello', 'world']
>>> s.rsplit('l', 4)
['he', '', 'o wor', 'd']
splitlines 按行分隔
# .splitlines(keepends=False)
>>> '5\n2\n1'.splitlines()
['5', '2', '1']
>>> '5\n2\n1'.splitlines(True) # 保留换行符
['5\n', '2\n', '1']
rpartition
只能分隔一次，从左边分隔
>>> '1.log'.rpartition('.')
('1', '.', 'log')
填充
| 方法 | 描述 |
|---|---|
| zfill (width) | 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
ljust(width[, fillchar\]) |
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
rjust(width,[, fillchar\]) |
返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| center(width, fillchar) | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
zfill 填充
# .zfill(width)
>>> s.zfill(20)
'000000000000hello'
center 填充
>>> 'begin'.center(10,'#')
'##begin###'
# .ljust(width[, fillchar]) # 内容靠左填充
>>> s.ljust(20, '#')
'hello############'
# .rjust(width[, fillchar]) # 内容靠右填充
>>> s.rjust(20, '#')
'############hello'
删除
| 方法 | 描述 |
|---|---|
| lstrip() | 截掉字符串左边的空格或指定字符。 |
| rstrip() | 删除字符串字符串末尾的空格. |
strip([chars\]) |
在字符串上执行 lstrip()和 rstrip() |
strip 删除
>>> 'abca'.strip('a')
'bc'
>>> 'abca'.lstrip('a')
'bca'
替换 & 转换
| 方法 | 描述 |
|---|---|
replace(old, new [, max\]) |
把 将字符串中的 str1 替换成 str2，如果 max 指定，则替换不超过 max 次。 |
| translate(table, deletechars="") | 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| maketrans() | 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| expandtabs(tabsize=8) | 把字符串 string 中的 tab 符号 转为空格，tab 符号默认的空格数是 8 。 |
replace 替换
# .replace(old, new[, count])
>>> s.replace('m', 'M', 1)
'hello'
将制表符转化为空白，可以指定转化多少个空白
# .expandtabs([tabsize])
>>> ' '.expandtabs(8)
' '
特性
通用特性：有序的, 可迭代, 可切片, 可合并, 不可变
其它特性：可通过 in 表达式 判断字符串对象中 是否包含其它子字符串
不可变特性
- 字符串操作都是在原来的基础上生成新的变量，将变量名指向这个新的对象，不会改变被操作的字符串。
- 不可变对象的优势 如高性能(固定内存段)，线程安全(无需锁) 和可哈希(多值Key的字典)等，典型的如数字、字符串、元祖；
- 如果希望将不可变的字符串对象变为可变对象，可通过内置函数 bytearray(object) 将其转换为字节数组即可；
>>> b = bytearray('1234')
>>> b[0] = 9
>>> b
Out[37]: bytearray(b'\t234')
>>> a = bytearray('123')
>>> a
Out[39]: bytearray(b'123')
bytearray 中的 b 是 byte 的意思。
应用
进度打印
from __future__ import print_function # 必须放在最上面
import time
for i in range(101):
print('\r' + '{0}% {1}'.format(i,i * '#'),end='')
time.sleep(0.1)
100% ##############################
