字符串

字符串--一个有序的字符的集合用来存储和表现基于文本的信息。python没有字符的概念，但是可以使用一个字符的字符串。

除了核心系统的字符串工具以外，python通过标准库re模块（正则表达式）还支持更高级的基于模式的字符串处理，甚至还支持更高级的文本处理工具，如XML解析器。

Python 3.x中有三种字符串类型，str用于unicode文本，bytes用于二进制数据，bytearray是bytes的一种可变的变体。

 

字符串常量：

单引号：'spam'

双引号："spam"

三引号：''' ...asdf...'''

转义字符：'s\tp\na\0m'

raw 字符串：r"c:\new\test"

byte字符串：b'sp\x01am'

 

单双引号字符串是一样的。

raw字符串抑制转义，但一个raw字符串不能以当的反斜杠结尾，因为反斜杠会转义后续引用的字符，如转义外围引号。即r"...\"不是一个有效的字符串常量，可以使用两个反斜杠并切分掉第二个反斜杠（r"1\n\tc\\"[:-1])，手动添加一个反斜杠（r'1\nb\tc'+'\\')

Python自动在任意的表达式中合并相邻的字符串常量：

>>> title = "Meaning " 'of ' "Life"
>>> title
'Meaning of Life'

转义序列代表特殊字节：

字符串反斜杠字符

转义	意义
\newline	忽视（连续）
\\	反斜杠（保留\）
\'	单引号（保留'）
\"	双引号
\a	响铃
\b	倒退
\f	换页
\n	新行（换行）
\r	返回
\t	水平制表符
\v	垂直制表符
\N{id}	Unicode数据库ID
\xhh	十六进制
\ooo	十进制
\0	Null（不是字符串结尾）
\other	不转义（保留）

Python以十六进制显示非打印的字符，注意字符串长度：

>>> s = 'a\0b\0c'
>>> s
'a\x00b\x00c'
>>> len(s)
5
>>> s = '\001\002\003'
>>> s
'\x01\x02\x03'
>>> len(s)
3

索引和分片：

字符串定义为字符的有序集合。字符串中的字符通过索引提取。

一个负偏移与这个字符串的长度相加后得到这个字符串的正的偏移值，可以将负偏移看做是从结尾处反向计数。

>>> s = 'delecious'  #定义一个字符串
>>> s[0]    #索引获取索引为0的字符串
'd'
>>> s[-2]    #索引获取倒数第二个参数
'u'
>>> s[1:3]    #分片获取索引1到索引3之前的，即索引位置1，2上的
'el'
>>> s[:3]    #分片获取索引0到索引3之前，即0，1，2位置的
'del'
>>> s[1:]    #分片获取索引1到最后
'elecious'
>>> s[:-1]    #分片获取开始到最后一个之前（即不包括最后一个）
'deleciou'
>>> s[:]    #整个序列，可以用来copy一个字符串序列
'delecious'
>>> s[::-1]    #步进为-1，从尾到头
'suoiceled'
>>> s[5:1:-1]    #5.4.3.2
'icel'
>>> s[::2]    #从头到尾没隔两个取一个
'dlcos'
>>> 

字符串转换工具：

Python中不能让数字和字符串相加：

>>> '42'+1
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    '42'+1
TypeError: must be str, not int

单个的字符串可以通过内置的ord函数转换为其对于的ASCII码--这个函数实际上返回的是这个字符串在内存中对于的字符的二进制值，而chr函数执行相反的操作。

>>> ord('a')    #注意这里传入单个字符的字符串
97
>>> chr(97)    #注意这里传入数字，不能是字符串'97'
'a'

字符串方法：

方法调用同时进行了两次操作（一次获取属性和一次函数调用）

属性读取: object.attribute

函数调用：func(参数)

修改字符串：

>>> s = 'spam'
>>> s[0]='x'    #字符串不可改变
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    s[0]='x'
TypeError: 'str' object does not support item assignment

>>> s=s+'spam'    #改字符串需要合并分片重赋值来完成
>>> s
'spamspam'
>>> s=s[:4]+'SPAM'+s[4:]
>>> s
'spamSPAMspam'
>>> s=s.replace('pa','u')
>>> s
'sumSPAMsum'

合并操作和replace方法每次运行会产生新的字符串对象，实际上利用他们去修改字符串是一个潜在的缺陷。如果你要对一个超长字符串进行很多修改，为了优化性能，可以将字符串转换为一个支持原处修改的对象，修改完可以用join将列表合成字符串：

>>> L = list(s)
>>> L
['s', 'u', 'm', 'S', 'P', 'A', 'M', 's', 'u', 'm']
>>> L[0]='m'
>>> L[-2]='m'
>>> s = ''.join(L)
>>> s
'mumSPAMsmm'
>>> hhh='hhh'.join(['apple','peach','banana'])
>>> hhh
'applehhhpeachhhhbanana'
>>> hhh.split('hhh')
['apple', 'peac', 'hbanana']

>>> s.find('SP')
3
>>> s.find('oo')
-1

没有通过任何操作对原始的字符串进行改变。每个字符串都被定义为生成新的字符串作为结果，因为字符串在python中具有不可变性

字符串的find方法是基本的子字符串查找的操作，没找到返回-1，字符串的replace方法将会对全局进行搜索和替换

虽然这些字符串方法的命名有改变的含义，但在这里我们都不会改变原始的字符串，而是会创建一个新的字符串作为结果--因为字符串具有不可变性

 

字符串格式表达式：

对象的每个类型都可以转换为字符串，所有一般用%s来格式化表达式。

格式化总是会返回新的字符串作为结果而不是对如下%或点号左侧字符串进行修改

>>> '%s, eggs, and %s'%('spam', 'SPAM!')
'spam, eggs, and SPAM!'
>>> '{0}, eggs, and {1}'.format('spam', 'SPAM!')
'spam, eggs, and SPAM!'
>>> 

%转换目标的通用模式：

%[(name)][flag][width][.precision]typecode

放置一个字典的键；左对齐（-），正负号（+），补零（0）的标志位；给出数字的整体长度和小数点后的位数等。width和precision都可以编码为一个*以指定他们应该从输入值的下一项取值。

>>> x=1234
>>> res='integers:...%d...%-6d...%06d'%(x,x,x)
>>> res
'integers:...1234...1234  ...001234'
>>> '%f,%.2f,%.*f'%(1/3.0,1/3.0,4,1/3.0)
'0.333333,0.33,0.3333'
>>> '%(n)d %(x)s'%{'n':1,'x':'spam'}    #基于字典的字符串格式化
'1 spam'
>>> food = 'bread'
>>> age='40'
>>> vars()    #vars返回的字典包含了所有在本函数调用时存在的变量
{..., 'food': 'bread', 'age': '40'}
>>> '%(age)s %(food)s'%vars()    #利用vars访问变量
'40 bread'

%属于表达式格式，还有一种方法调用格式化 .format，通过收集任意多个位置和关键字参数

>>> template = '{0}, {1}, {2}'
>>> template.format('spam','ham','eggs')
'spam, ham, eggs'
>>> template = '{motto},{pork},{food}'
>>> template.format(motto='spam',pork='ham',food='eggs')
'spam,ham,eggs'

 

同样分类的类型共享其操作集合

Python中有三个主要类型的分类：

数字（整数，浮点数，二进制，分数等）：支持加法乘法等

序列（字符串，列表，元组）：支持索引，分片和合并等

映射（字典）：支持通过键的索引等

集合是自成一体的一个分类

 

可变类型能够在原处修改

不可变类型不能在原处修改它的值，否则报错

不可变类型（数字，字符串，元组，不可变集合frozenset）：不可变的分类中没有哪个对象类型支持原处修改，尽管我们可以运行表达式来创建新的对象并将其尽管分配给变量

可变类型（列表，字典，可变集合）：可变类型总可以通过操作原处修改，而不用创建新的对象。尽管这样的对象可以复制，但原处修改支持直接修改。

 

Learning Python, Fourth Edition, by Mark Lutz.