Python内置数据结构之字符串str

1. 数据结构回顾

　　

所有标准序列操作（索引、切片、乘法、成员资格检查、长度、最小值和最大值）都适用于字符串，但是字符串是不可变序列，因此所有的元素赋值和切片赋值都是非法的。

>>> website = 'http://www.python.org'
>>> website[-3:] = 'com'
Traceback (most recent call last):
File "<pyshell#19>", line 1, in ?
website[-3:] = 'com'
TypeError: object doesn't support slice assignment

通过名称来访问其各个值的数据结构。这种数据结构称为映射（mapping） 。字典是Python中唯一的内置映射类型，其中的值不按顺序排列，而是（值）存储在键下。键可能是数、字符串或元组。

2. 字符串

print ( "hello,world!")    "hello,world!" 是字符串，字符串在几乎所有真实可用的Python程序中都会存在，并且有多种用法，其中最主要的用法就是表示一些文本。字符串是值，就像数字一样。str，repr和反引号是将Python值转换成 字符串的3种方法。

2.1 字符串基础

a. 单引号字符串和转义引号

>>> 'let's go'          # 后面的黑色字体部分Python无法识别
SyntaxError: invalid syntax
>>> 'let\'s go'          # 在常规字符串中，反斜杠扮演着特殊角色：它对字符进行转义，让你能够在字符串中包含原本无法包含的字符。   反斜线（\），可以换行。
"let's go"
>>> "let's go!"         # 用""对'加以区分
"let's go!"

b. 拼接字符串

>>> "let's say:" '"hello,world!"'
'let\'s say:"hello,world!"'
>>> 'hello,' + 'world!'        
'hello,world!'

可以使用 + 操作符来连接 (粘在一起)； 使用 * 操作符重复

>>> word = 'help ' + 'me! '
>>> word
'help me! '
>>> '<'+ word * 4 + '>'
'<help me! help me! help me! help me! >'
>>>

注意：

两个靠着一起的字符串会自动的连接; 上面例子的第一行也可以写成 word = 'Help' 'A'; 这只能用于两个字符串常量, 而不能用于任意字符串表达式。

c. 字符串表示，str和repr

Python打印值的时候会保持值在代码中的状态，而不是你希望用户看到的状态，通过使用print，结果将不同。

>>> "Hello, world!"
'Hello, world!'
>>> print("Hello, world!")
Hello, world!

如果再加上表示换行符的编码\n，差别将更明显。

>>> 'hello,\nworld!'
'hello,\nworld!'
>>> print('hello,\nworld!')
hello,
world!
>>>

　　str，repr和反引号是将Python值转换成 字符串的3种方法。

repr() 函数，

通常会获得值的合法Python表达式表示。则意味着产生一个解释器易读的表达形式 (或者如果没有这样的语法会给出 SyntaxError ).

str() 函数 ，（实际是类，工厂函数；str和int、long一样，是一种类型。repr仅仅是函数）

使用str能以合理的方式将值转换为用户能够看懂的字符串。例如，尽可能将特殊字符编码转换为相应的字符。

对于那些没有特殊表达的对象, str() 将会与 repr() 返回相同的值. 很多的值, 如数字或一些如列表和字典那样的结构, 使用这两个函数的结果完全一致. 字符串与浮点型则有两种不同的表达。

　　repr和反引号则把结果字符串转换为合法的Python表达式。

　　d. 长字符串，原始字符串和Unicode

有一些独特而有用的字符串表示方式。例如，有一种独特的语法可用于表示包含换行符或反斜杠的字符串（长字符串和原始字符串）。对于包含特殊符号的字符串，

Python 2还提供了一种专用的表示语法，结果为Unicode字符串。这种语法现在依然管用，但是多余，因为在Python 3中，所有的字符串都是Unicode字符串。 Python 3还引入了一种新语法，用于表示大致相当于老式字符串的字节对象。在处理Unicode编码方面，这种对象依然扮演着重要的角色。

请注意，指定原始字符串时，可使用单引号或双引号将其括起，还可使用三引号将其括起。

 i. 长字符串

字符串可以使用一对匹配的三引号对包围: """ 或 '''。当使用三引号时, 回车不需要被舍弃, 他们会包含在字符串里。

>>> print('''This is a very long string. It continues here.
And it's not over yet. "Hello, world!"
Still here.''')
This is a very long string. It continues here.
And it's not over yet. "Hello, world!"
Still here.
>>>

 ii. 原始字符串

原始字符串不以特殊方式处理反斜线。

>>> path = 'C:\nowhere'
>>> path
'C:\nowhere'
>>> print(path)                     # 打印出问题
C:
owhere
>>> print('C:\\nowhere')       #对反斜杠本身进行转义。
C:\nowhere
>>>

　　对于很长的路径，将需要使用大量的反斜杠。

在这样的情况下，原始字符串可派上用场，因为它们根本不会对反斜杠做特殊处理，而是让字符串包含的每个字符都保持原样。

>>> print(r'C:\nowhere')
C:\nowhere
>>> print(r'C:\Program Files\fnord\foo\bar\baz\frozz\bozz')
C:\Program Files\fnord\foo\bar\baz\frozz\bozz
>>>

iii.  Unicode、 bytes和bytearray

Python字符串与二进制的关系

python 3中最重要的新特性可能就是将文本(text)和二进制数据做了更清晰的区分。文本总是用unicode进行编码，以str类型表示；而二进制数据以bytes类型表示。

在python3中，不能以任何隐式方式将str和bytes类型二者混合使用。不可以将str和bytes类型进行拼接，不能在str中搜索bytes数据(反之亦然)，也不能将str作为参数传入需要bytes类型参数的函数(反之亦然)。

Unicode

大致而言，每个Unicode字符都用一个码点（code point）表示，而码点是Unicode标准给每个字符指定的数字。这让你能够以任何现代软件都能识别的方式表示129个文字系统中的12万个以上的字符。当然，鉴于计算机键盘不可能包含几十万个键，因此有一种指定Unicode字符的通用机制：使用16或32位的十六进制字面量（分别加上前缀\u或\U）或者使用字符的Unicode名称（\N{name}）。

>>> "\u00C6"
'Æ'

要获悉字符的Unicode码点和名称，可在网上使用有关该字符的描述进行搜索，也可参阅特定的网站，如http://unicode-table.com。

Bytes

Unicode的理念很简单，却带来了一些挑战，其中之一是编码问题。在内存和磁盘中，所有对象都是以二进制数字（0和1）表示的（这些数字每8个为一组，即1字节），字符串也不例外。在诸如C等编程语言中，这些字节完全暴露，而字符串不过是字节序列而已。为与C语言互操作以及将文本写入文件或通过网络套接字发送出去，Python提供了两种类似的bytes类型：不可变的bytes和可变的bytearray。如果需要，可直接创建bytes对象（而不是字符串），方法是使用前缀b：

>>> b'Hello, world!'
b'Hello, world!

然而， 1字节只能表示256个不同的值，离Unicode标准的要求差很远。 Python bytes字面量只支持ASCII标准中的128个字符，而余下的128个值必须用转义序列表示，如\xf0表示十六进制值0xf0（即240）。   8位一个字节，一位是一个bite，8位最多表示255个符号。

唯一的差别好像在于可用的字母表规模，但实际上并非完全如此。乍一看，好像ASCII和Unicode定义的都是非负整数和字符之间的映射，但存在细微的差别： Unicode码点是使用整数定义的，而ASCII字符是使用对应的数及其二进制编码定义的。

这一点好像无关紧要，原因之一是整数0～255和8位二进制数之间的映射是固定的，几乎没有任何机动空间。问题是超过1字节后，情况就不那么简单了：直接将每个码点表示为相应的二进制数可能不再可行。这是因为不仅存在字节顺序的问题（即便对整数值进行编码，也会遇到这样的问题），而且还可能浪费空间：如果对于每个码点都使用相同数量的字节进行编码，就必须考虑到文本可能包含安那托利亚象形文字或皇家亚兰字母。有一种Unicode编码标准是基于这种考虑的，它就是UTF-32（32位统一编码转换格式， Unicode Transformation Format 32 bits），但如果你主要处理的是使用互联网上常见语言书写的文本，那么使用这种编码标准将很浪费空间。然而，有一种非常巧妙的替代方式：不使用全部32位，而是使用变长编码，即对于不同的字符，使用不同数量的字节进行编码。这种编码方式主要出自计算机先锋Kenneth Thompson之手。通过使用这种编码，可节省占用的空间，就像摩尔斯码使用较少的点和短线表示常见的字母，从而减少工作量一样。具体地说，进行单字节编码时，依然使用ASCII编码，以便与较旧的系统兼容；但对于不在这个范围内的字符，使用多个字节（最多为6个）进行编码。

下面来使用ASCII、UTF-8、UTF-16和UTF-32编码将字符串转换为bytes。

>>> "Hello, world!".encode("ASCII")
b'Hello, world!'
>>> "Hello, world!".encode("UTF-8")
b'Hello, world!'
>>> "Hello, world!".encode("UTF-16")
b'\xff\xfeH\x00e\x00l\x00l\x00o\x00,\x00 \x00w\x00o\x00r\x00l\x00d\x00!\x00'
>>> "Hello, world!".encode("UTF-32")
b'\xff\xfe\x00\x00H\x00\x00\x00e\x00\x00\x00l\x00\x00\x00l\x00\x00\x00o\x00\x00\x00,\x00\x00\x00 \x00\x00\x00w\x00\x00\x00o\x00\x00\x00r\x00\x00\x00l\x00\x00\x00d\x00\x00\x00!\x00\x00\x00'
>>> 

>>> len("How long is this?".encode("UTF-8"))
17
>>> len("How long is this?".encode("UTF-16"))
36
>>> len("How long is this?".encode("UTF-32"))
72
>>>
说明： 在所有情况下，都最好使用UTF-8。事实上，它也是默认使用的编码。

几乎在所有情况下，都最好使用UTF-8。它是默认使用的编码。

.encode()可将字符串编码为bytes，.decode()可将bytes解码为字符串。

可不使用方法encode和decode，而直接创建bytes和str（即字符串）对象，这种方法更通用一些，在你不知道类似于字符串或bytes的对象属于哪个类时，使用这种方法也更管用。一个通用规则是，不要做过于严格的假设。

>>> "Hællå, wørld!".encode()
b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'
>>> b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'.decode()
'Hællå, wørld!'
>>> bytes("Hællå, wørld!", encoding="utf-8")
b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'
>>> str(b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!', encoding="utf-8")
'Hællå, wørld!'
>>> 

>>> msg = "我爱北京天安门！"
>>> print(msg.encode(encoding = "utf-8"))
b'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8\xef\xbc\x81'
>>> print(msg.encode(encoding = "utf-8").decode(encoding = "utf-8"))
我爱北京天安门！
>>> 

编码和解码的最重要用途之一是，将文本存储到磁盘文件中。然而， Python提供的文件读写机制通常会替你完成这方面的工作！只要文件使用的是UTF-8编码，就无需操心编码和解码的问题。但如果原本正常的文本变成了乱码，就说明文件使用的可能是其他编码。

最后， Python还提供了bytearray，它是bytes的可变版。从某种意义上说，它就像是可修改的字符串——常规字符串是不能修改的。然而， bytearray其实是为在幕后使用而设计的，因此作为类字符串使用时对用户并不友好。例如，要替换其中的字符，必须将其指定为0～255的值。

因此，要插入字符，必须使用ord获取其序数值（ordinal value）。

>>> x = bytearray(b"Hello!")
>>> x[1] = ord(b"u")
>>> x
bytearray(b'Hullo!')
>>>

2.2 字符串格式

字符串格式设置涉及的内容很多，基本思想是对字符串调用方法format，并提供要设置其格式的值。字符串包含有关如何设置格式的信息，而这些信息是使用一种微型格式指定语言（mini-language）指定的。每个值都被插入字符串中，以替换用花括号括起的替换字段。要在最终结果中包含花括号，可在格式字符串中使用两个花括号（即{{或}}）来指定。

Python提供了多种字符串格式设置方法。以前，主要的解决方案是使用字符串格式设置运算符——百分号。这个运算符的行为类似于C语言中的经典函数printf：在%左边指定一个字符串（格式字符串），并在右边指定要设置其格式的值。指定要设置其格式的值时，可使用单个值（如字符串或数字），可使用元组（如果要设置多个值的格式），还可使用字典，其中最常见的是元组。

%s称为转换说明符 ，指出了要将值插入什么地方。 s意味着将值视为字符串进行格式设置。如果指定的值不是字符串，将使用str将其转换为字符串。其他说明符将导致其他形式的转换。例如， %.3f将值的格式设置为包含3位小数的浮点数。

>>> a = "hello, %s. %s said!"
>>> b = ('world', 'he')
>>> a % b
'hello, world. he said!'
>>>

2.2.1 替换字段名

向format提供要设置其格式的未命名参数或参数指定名称 ；

>>> "{i} {} {sleep} {}".format(1, 2, sleep=4, i=3)
'3 1 4 2'

通过索引来指定要在哪个字段中使用相应的未命名参数 ，可以不按顺序使用未命名参数。

>>> "{i} {1} {sleep} {0}".format(1, 2, sleep=4, i=3)
'3 2 4 1'

访问提供的值的组成部分

>>> fullname = ["alex", "Li"]
>>> 'Mr {name[0]}'.format(name=fullname)
'Mr alex'
>>>

使用索引，还可使用句点表示法来访问导入的模块中的方法、属性、变量和函数（看起来很怪异的变量__name__包含指定模块的名称）。

>>> import math
>>> tmpl = "The {mod.__name__} module defines the value {mod.pi:f} for π"
>>> tmpl.format(mod = math)
'The math module defines the value 3.141593 for π'
>>>

2.2.2 转化

（s、 r和a）指定分别使用str、 repr和ascii进行转换。函数str通常创建外观普通的字符串版本（这里没有对输入字符串做任何处理） 。函数repr尝试创建给定值的Python表示（这里是一个字符串字面量）。函数ascii创建只包含ASCII字符的表示，类似于Python 2中的repr。

>>> print("{pi!s} {pi!r} {pi!a}".format(pi="π"))
π 'π' '\u03c0'
>>>

>>> "The number is {num:f}".format(num=42)
'The number is 42.000000'

字符串格式设置中的类型说明符
类型  含 义
b       将整数表示为二进制数
c       将整数解读为Unicode码点
d       将整数视为十进制数进行处理，这是整数默认使用的说明符
e       使用科学表示法来表示小数（用e来表示指数）
E       与e相同，但使用E来表示指数

f        将小数表示为定点数
F       与f相同，但对于特殊值（nan和inf），使用大写表示
g        自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符，但在默认情况下至少有1位小数
G       与g相同，但使用大写来表示指数和特殊值
n        与g相同，但插入随区域而异的数字分隔符
o        将整数表示为八进制数
s        保持字符串的格式不变，这是默认用于字符串的说明符
x        将整数表示为十六进制数并使用小写字母
X       与x相同，但使用大写字母
%      将数表示为百分比值（乘以100，按说明符f设置格式，再在后面加上%）

2.2.3 宽度，精度，分隔符，对齐

宽度是使用整数指定的，如下所示：

>>> "{num:10}".format(num=3)
' 3'
>>> "{name:10}".format(name="Bob")
'Bob '

精度使用整数指定的，需要在它前面加上一个表示小数点的句点。

>>> "Pi day is {pi:.2f}".format(pi=pi)
'Pi day is 3.14'

使用逗号来指出你要添加千位分隔符。

>>> 'One googol is {:,}'.format(10**100)
'One googol is 10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000'

在指定宽度和精度的数前面，可添加一个标志。这个标志可以是零、加号、减号或空格，其中零表示使用0来填充数字。

>>> '{:010.2f}'.format(pi)
'0000003.14'

要指定左对齐、右对齐和居中，可分别使用<、 >和^。

>>> from math import pi
>>> print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(pi))
3.14
   3.14
      3.14
>>> 

可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充。

>>> "{:$^15}".format(" WIN BIG ")
'$$$ WIN BIG $$$'

还有更具体的说明符=，它指定将填充字符放在符号和数字之间。

>>> print('{0:10.2f}\n{1:10.2f}'.format(pi, -pi))
      3.14
     -3.14
>>> print('{0:10.2f}\n{1:=10.2f}'.format(pi, -pi))
      3.14
-     3.14
>>> 

字符串格式设置示例

width = int(input('Please enter width: '))
price_width = 7
# 指定price符的字段宽度，默认以空格填充
item_width = width - price_width
header_fmt = '{{:^{}}}{{:>{}}}'.format(item_width, price_width)
# 要指定左对齐、右对齐和居中，可分别使用<  >和^ 。
fmt = '{{:<{}}}{{:$>{}.2f}}'.format(item_width, price_width)
# 可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充。
# "{:$^15}".format(" WIN BIG ")   ——>$$$ WIN BIG $$$
# .2f  将值(价格)的格式设置为包含2位小数的浮点数。
print('=' * width)
print(header_fmt.format('Item', 'Price'))
print('-' * width)
print(fmt.format('Apples', 0.4))
print(fmt.format('Pears', 0.5))
print(fmt.format('Cantaloupes', 1.92))
print(fmt.format('Dried Apricots (16 oz.)', 8))
print(fmt.format('Prunes (4 lbs.)', 12))
print('=' * width)
执行结果：

　　

2.3 字符串基本操作

name = "my name is alex"
print(name.capitalize())          # 首字母大写
print(name.count("a"))            # 统计a的个数
print(name.center(50, "-"))       # 美观打印，打印50个字符，不够用-补上
print(name.encode(encoding="utf-16"))  # 使用utf-16将字符串转化为bytes
print(name.endswith("ex"))  # 判断一个字符串以什么结尾（判断邮件地址是否以.com结尾）
# name = "my \tname is alex"
print(name.expandtabs(tabsize=30))  # 将 Tab键转换成多少个空格
print(name.find("n"))            # 查找,字符串的索引
print(name[name.find("name"):])   # 字符串可以切片，从name开始截断

执行结果：
My name is alex
2
-----------------my name is alex------------------
b'\xff\xfem\x00y\x00 \x00n\x00a\x00m\x00e\x00 \x00i\x00s\x00 \x00a\x00l\x00e\x00x\x00'
True
my name is alex
3
name is alex

name = "my name is {name} and i am {years} old."
print(name.format(name='alex', years=23))   # 格式化
——>my name is alex and i am 23 old.
print(name.format_map({'name': 'alex', 'years': 12}))   # 字典，格式化
——>my name is alex and i am 12 old.
# print(name.isalnum())
print('123Abc123'.isalnum())      # 判断是否为数字和字母
——>True
print('ABCas'.isalpha())          # 判断是否为字母
print(''.isdecimal())         # 判断是否为十进制
print(''.isdigit())            # 判断是否为整数
print('As3adf'.isidentifier())    # 判断是否为一个合法的标识符（变量名）
print(''.isnumeric())        # 判断是否为一个数字
print('My Name is'.istitle())     # 判断是每个字符的首字母是否为大写
——>False
print('MY NAME IS'.isupper())     # 判断是每个字符是否为大写
——>True
print('+'.join(['', '', '']))  # 将列表转化成字符串
——>1+2+3

print(name.ljust(50, '*'))  # 满足长50，不够在句尾用*补足
——>my name is {name} and i am {years} old.***********
print(name.rjust(50, '*'))  # 满足长50，不够在句首用*补足
——>***********my name is {name} and i am {years} old.
执行结果：(——>后为执行结果，没有标注的全部为True)
my name is alex and i am 23 old.
my name is alex and i am 12 old.
True
True
True
True
True
True
False
True
1+2+3
my name is {name} and i am {years} old.***********
***********my name is {name} and i am {years} old.

print("Djf".lower())    # 将大写字母变小写
print("djf".upper())    # 将小写字母变大写
print('------')
print("   \ndjf".lstrip())    # 去左边的空格和回车
print("DJF\n     ".rstrip())    # 去右边的空格和回车
print("    DJF\n".strip())    # 去两边的空格和回车
print('------')
p = str.maketrans("abcdef",'')
print("alex li".translate(p))        # 对应字母替换,密钥
print('------')
print("alex li".replace('l', 'L'))  # 对应字母替换
print("alex li".replace('l', 'L', 1))  # 对应字母替换
print('------')
print("alex li".rfind('l'))    #  从左向右,最后一个l的下标
print("al exli li".split('l'))    #  按照分隔符，将字符串分成列表
print('1+2+3+4'.split('+'))
print('1+2\n+3+4'.splitlines())   # 换行
print("Alex Li".swapcase())       # 大小写变换
print("alex li".title())          # 首字母变大写