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('1237'.isdecimal()) # 判断是否为十进制 print('123'.isdigit()) # 判断是否为整数 print('As3adf'.isidentifier()) # 判断是否为一个合法的标识符（变量名） print('13414'.isnumeric()) # 判断是否为一个数字 print('My Name is'.istitle()) # 判断是每个字符的首字母是否为大写 ——>False print('MY NAME IS'.isupper()) # 判断是每个字符是否为大写 ——>True print('+'.join(['1', '2', '3'])) # 将列表转化成字符串 ——>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",'123456') 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()) # 首字母变大写
扫一扫
1256
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
