4. 数据类型 —— 字符串

2014-12-13 本文已影响0人梦回吹角连营

字符串属于标量存储、不可改变、顺序访问的数据类型。字符串属于序列的一种，因此对字符串可行的序列操作对类似元组和列表同样适用。

1. 字符串的创建

类似于数字类型的创建，直接将字符串赋值给变量即可创建一个新的字符串对象。

>>> a = 'string'                # 使用单引号
>>> a = "string"                # 使用双引号，在 Python 中，单引号和双引号没有区别
>>> a = '''
... a
... string 
... block '''                   # 使用三引号，字符串块（三引号在某些情况下可以起到注释掉不需要执行的代码的作用）
>>> a
'\na\nstring\nblock '
>>> a = ''
''                              # 空字符

对变量重新赋值一个新的字符串即可 “ 更新 ” 变量

>>> a = 'string1'
>>> a
'string1'
>>> a = 'string2'
>>> a
'string2'

2. 转义字符

一个反斜线加一个单一字符，可以表示一些通常情况下不可打印的字符，这种组合称为转义字符。

>>> a = 'string1\nstring2'                # \n 代表换行符，虽然由两个字符组成，但在最终表示中会被一个单一字符替代
>>> print a
string1
string2

常用的转义字符包括：

转义字符	代表含义
\n	换行
\t	横向制表符（tab）
\\	反斜线（ \ ）
'	单引号
"	双引号
\u	后跟四位十六进制数，表示 Unicode 字符串

当我们不需要对字符进行转义时，可以使用原始字符串操作符 raw 字符串。在原始字符串中，所有的字符都是直接按照输入的字符来使用，没有转义或不能打印的字符。使用 raw 只需要在字符串前加 r/R 即可。

>>> a = r'string1\nstring2'
>>> print a
string1\nstring2                # 输出的结果和输入一样，没有进行转义
>>> a
'string1\\nstring2'             # Python 自身在显示 '\' 时也会使用转义字符 '\\'

注：在交互模式下 print a 和直接显示 a 的区别：使用 print 可以显示变量格式化以后的显示效果，而直接输入变量名则会显示变量的值在 Python 内部的表示形式。

3. Unicode 字符串

如果需要使用 Unicode 字符串时，可以在字符串前加 u/U 即可使用 Unicode 字符串

>>> a = u'abc'
>>> a
u'abc'
>>> a = u'\u1234'                 # 使用 \u 转义字符，\u 后为十六进制
>>> print a
ሴ

4. 基本操作（适用于所有序列对象）

比较操作

字符串进行比较操作时按照在 ASCII 或 Unicode 中的数值大小进行比较
连接操作

可以使用 ' +' 操作符对字符串进行连接

a = 'a'
b = 'b'
a + b
'ab'
```

重复操作

使用 '*' 操作符将字符串重复 N 次

a = 'a'
a * 7
'aaaaaaa'
```

成员操作

in / not in 可以用于判断一个字符或字符串是否出现在另一个字符串中

'ab' in 'abcd'
True
'ac' in 'abcd'
a = 'string1'
>>> a
'string1'
>>> a = 'string2'
>>> a
'string2'
### 2. 转义字符一个反斜线加一个单一字符，可以表示一些通常情况下不可打印的字符，这种组合称为转义字符。
>>> a = 'string1\nstring2' # \n 代表换行符，虽然由两个字符组成，但在最终表示中会被一个单一字符替代
>>> print a
string1
string2
常用的转义字符包括： | 转义字符 | 代表含义 | | ------------ | ------------ | | \n | 换行 | | \t | 横向制表符（tab）| | \\\ | 反斜线（ \ ）| | \' | 单引号 | | \" | 双引号 | | \u | 后跟四位十六进制数，表示 Unicode 字符串 | 当我们不需要对字符进行转义时，可以使用原始字符串操作符 raw 字符串。在原始字符串中，所有的字符都是直接按照输入的字符来使用，没有转义或不能打印的字符。使用 raw 只需要在字符串前加 r/R 即可。
>>> a = r'string1\nstring2'
>>> print a
string1\nstring2 # 输出的结果和输入一样，没有进行转义
>>> a
'string1\nstring2' # Python 自身在显示 '' 时也会使用转义字符 '\'
- 注：在交互模式下 `print a` 和直接显示 `a` 的区别：使用 `print` 可以显示变量格式化以后的显示效果，而直接输入变量名则会显示变量的值在 Python 内部的表示形式。 ### 3. Unicode 字符串如果需要使用 Unicode 字符串时，可以在字符串前加 u/U 即可使用 Unicode 字符串
>>> a = u'abc'
>>> a
u'abc'
>>> a = u'\u1234' # 使用 \u 转义字符，\u 后为十六进制
>>> print a
ሴ
### 4. 基本操作（适用于所有序列对象） - 比较操作字符串进行比较操作时按照在 ASCII 或 Unicode 中的数值大小进行比较 - 连接操作可以使用 ' +' 操作符对字符串进行连接
>>> a = 'a'
>>> b = 'b'
>>> a + b
'ab'
- 重复操作使用 '*' 操作符将字符串重复 N 次
>>> a = 'a'
>>> a * 7
'aaaaaaa'
- 成员操作 in / not in 可以用于判断一个字符或字符串是否出现在另一个字符串中
>>> 'ab' in 'abcd'
True
>>> 'ac' in 'abcd'
False
'ac' not in 'abcd'
True
```

5. 索引和切片（适用于所有的列表和对象）

序列对象从 0 开始进行索引，通过指定元素索引或切片对序列对象中的元素进行访问，语法如下：squence[index]

>>> a = 'string'
>>> a[0]
's'                                  # 序列的索引从 0 开始
>>> a[5]
'g'                                  # 序列索引的最大值比序列的长度小 1

除此之外，还可以使用 负索引，范围是 -1 到序列的负长度。正负索引的区别在于正索引以序列的开始为起点（ 0 ），负索引以序列的结束为起点（ -1 ）。负索引 + 序列长度 = 正索引

>>> a[-1]
'g'                                  # 负索引从 -1 开始
>>> a[-6]
'a'                                  # 负索引的最大值是序列的负长度，正索引的最大值是长度 len(squence) - 1

如果在访问序列的索引越界会引发一个异常：

>>> a[6]                                      # 正索引的最大值应该是长度 - 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

通过索引可以访问指定偏移量的某一个元素，而切片操作则可用来访问序列中指定的多个元素。切片操作只需要给出切片的开始和结束的索引值，中间用 ' : ' 分隔开即可: squence [ start_index : end_index ]

>>> a[1:3]
'tr'                            # 切片会截取从起始索引到结束索引，但不包括结束索引
>>> a[:3]
'str'                           # 如果不指定起始索引，默认为序列的开始
>>> a[1:]     
'tring'                         # 如果不指定结束索引，默认到序列的结束
>>> a[:]
'string'                        # 需要指出的是，所有字符串的操作都相当于创建了一个新的字符串，通过这种方法可以对字符串进行拷贝
>>> a[1:-1]
 'trin'                         # 在切片中同样可以使用负索引

切片操作还有第三个参数，起到类似步长的作用。不指定时默认为 1

>>> a[::2]
'srn'
>>> a[::-1]
'gnirts'                        # 可以通过这样来获得一个序列的倒序

切片不同于索引，不存在越界引起的异常

>>> a[-100:100]
'string'                        # 在切片中当起始或结束索引越界会使用默认值

在切片中使用 None

>>> a[:0]
''                              # 在结束索引使用 0 时会返回空字符串
>>> a[:None]
'string'                        # 使用 None 则会返回整个字符串
>>> a[None:]
'string'                        
>>> a[None:None]
'string'

6. 序列的一些内建函数

对序列对象有一些通用且常用的内建函数：

len()：返回序列中元素的长度

>>> len(a)
6                               # 返回字符串的长度

max() 和 min()：返回序列中的最大值和最小值

>>> max(a)
't'                             # 返回字符串元素中的最大值
>>> min(a)
'g'                             # 返回字符串元素中的最小值

sorted()：对序列中的对象进行排序

>>> sorted(a)
['g', 'i', 'n', 'r', 's', 't']

reversed()：对列表中的所有元素反序输出

>>> for  i in reversed(a):
...    print i,
g n i r t s

enumerate()：生成一个 enumerate 对象，该对象为每个元素的索引和值组成的元组

>>> for i in enumerate(a):
...     print i
...
(0, 's')
(1, 't')
(2, 'r')
(3, 'i')
(4, 'n')
(5, 'g')

zip()：接受两个序列参数，生成一个列表，列表中的元素分别为由两个参数按顺序的两个元素所组成的元组

>>> zip(a, a)
[('s', 's'), ('t', 't'), ('r', 'r'), ('i', 'i'), ('n', 'n'), ('g', 'g')]

7. 字符串类型函数

raw_input()：可以使用给定的字符串提示用户输入并将输入返回赋值给变量。

>>> a = raw_input("Please input something: ")    # 函数接受的字符串参数即为输出在屏幕上提示用户输入的字符串
Please input something: string                   # 输入字符串：string
>>>
>>> print a                                      # 上边的输入 string 已经赋值给变量 a
string

chr() 和 unichr()：chr 接受一个ASCII 码，即 0-255 之间的整数，返回对应的字符。unichr 则接受一个 Unicode 码，返回对应的 Unicode 字符
ord()：ord 作为 chr 和 unichr 的对应函数，返回一个字符的 ASCII 或 Unicode 数值

>>> chr(97)
'a'                                        # 接受一个 0-255 的整数，返回对应的ASCII 字符
>>> unichr(1234)
u'\u04d2'                                  # 接受一个 0-65535 的整数，返回对应的Unicode 码
>>> print unichr(1234)
Ӓ
>>> ord('a')
97                                         # 接受一个 ASCII 字符，返回对应的数值
>>> ord(u'\u04d2')
1234                                       # 接受一个 Unicode 字符，返回对应的数值

str() 和 unicode()：将参数转换为字符串或 unicode 字符串

>>> str(123)
'123'                                      # 将数字 123 转换为字符串
>>> unicode(123)
u'123'                                     # 将数字转换为 unicode 字符串

8. 字符串内建函数

string.strip()：删除 sting 字符串开头和末尾的空格

a = '\tstring\n'
a.strip()
'string' # 将字符串前后空格都删除，lstrip() 和 rstrip() 分别删除开头和结尾的空格
```

string.split(str)：以 str 为分隔符将字符串进行分隔

a = 's t r i n g'
a.split(' ')
['s', 't', 'r', 'i', 'n', 'g'] # 以空格为分隔符将字符串进行分隔
```

string.join(seq)：以 string 为分隔符，将 seq 中的所有元素合并为一个新的字符串

a = ['s', 't', 'r', 'i', 'n', 'g']
' '.join(a)

>>> print a # 上边的输入 string 已经赋值给变量 a
string
- __chr()__ 和 __unichr()__：chr 接受一个ASCII 码，即 0-255 之间的整数，返回对应的字符。unichr 则接受一个 Unicode 码，返回对应的 Unicode 字符 - __ord()__：ord 作为 chr 和 unichr 的对应函数，返回一个字符的 ASCII 或 Unicode 数值
>>> chr(97)
'a' # 接受一个 0-255 的整数，返回对应的ASCII 字符
>>> unichr(1234)
u'\u04d2' # 接受一个 0-65535 的整数，返回对应的Unicode 码
>>> print unichr(1234)
Ӓ
>>> ord('a')
97 # 接受一个 ASCII 字符，返回对应的数值
>>> ord(u'\u04d2')
1234 # 接受一个 Unicode 字符，返回对应的数值
- __str()__ 和 __unicode()__：将参数转换为字符串或 unicode 字符串
>>> str(123)
'123' # 将数字 123 转换为字符串
>>> unicode(123)
u'123' # 将数字转换为 unicode 字符串
### 8. 字符串内建函数 - __string.strip()__：删除 sting 字符串开头和末尾的空格
>>> a = '\tstring\n'
>>> a.strip()
'string' # 将字符串前后空格都删除，lstrip() 和 rstrip() 分别删除开头和结尾的空格
- __string.split(str)__：以 str 为分隔符将字符串进行分隔
>>> a = 's t r i n g'
>>> a.split(' ')
['s', 't', 'r', 'i', 'n', 'g'] # 以空格为分隔符将字符串进行分隔
- __string.join(seq)__：以 string 为分隔符，将 seq 中的所有元素合并为一个新的字符串
>>> a = ['s', 't', 'r', 'i', 'n', 'g']
>>> ' '.join(a)
's t r i n g' # 用空格将 a 中的元素合并成新的字符串
''.join(a)
'string' # 当不指定 string 时，直接合并
```

string.find(sr)：检测 str 是否在字符串中，如果时返回索引，否则返回 -1

a = 'strings'
a.find('s')
0 # 结果总是返回第一个找到的索引
a.find('a')
-1 # 没有找到时返回 -1
```

string.index(str)：与 find 类似，但不存在时引发一个异常

a = 'strings'
a.index('s')
0 # 同样返回第一个 str 的索引
a.index('a') # 与 find 不同，str 不存在时引发一个异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
```

string.count(str)：返回 str 在字符串中出现的次数

a = 'strings'
a.count('s')
2
```

string.upper() 和 string.lower()：分别将字符串字符转换为大写和小写

>>> a = 'String123'
>>> a.upper()
'STRING123'                             # 将字符串 a 中的所有字母大写，非字母不变
>>> a.lower()
'string123'                             # 将字符串 a 中的所有字母小写，非字母不变

string.partition(str)：find() 和 split() 的结合，从 str 出现的第一个位置起，将 string 分成三元组 (string_pre_str, str, string_post_str)，如果不包含 str，string_pre_str = string

a = 'string'
a.partition('r')
('st', 'r', 'ing')
a.partition('a')
('string', '', '')
```

string.replace(str1,str2) ：把 str1 替换为 str2

a = 'strings'
a.replace('s', 'x')
'xtringx' # 把 string 中所有的 str1 替换为 str2，可以指定替换的次数参数
a.replace('a', 'x')
'string' # string 中不包含 str1 时，不做任何操作
```

更多关于字符串的内建函数参考：String Method

9.字符串格式化

Python 中的字符串格式化操作，类似于 C 语言中的 printf() 函数的字符串格式化，语法如下：

在 % 操作符的左侧放置一个需要进行格式化的字符串，这个字符串带有一个或多个嵌入的转换目标，都以 % 开头。
在 % 操作符的右侧放置一个或多个（元组）对象，这些对象会插入到左侧需要进行格式化的一个或多个转换目标的位置上去。

>>> "That is %d %s bird!" % (1, 'little')
That is 1 little bird!

在上边这个例子中，整数 1 替换在格式化字符串左侧的 %d，字符串 'little' 替换 %s，从而得到一个新的格式化了的字符串。

如果不使用格式化字符串，我们可以使用多次字符串的合并和转换来达到目的，但十分麻烦。

>>> "That is " + str(1) + " little " "bird !"
That is 1 little bird!

通常根据需要转换的目标不同，左侧 % 操作符后边的符号也不相同，常见的格式化代码如下

代码	意义
%s	字符串
%r	使用 repr 的字符串
%d	十进制整数
%i	整数
%f	浮点十进制数

从高级的应用来说，表达式左侧的转换目标有一套完整的语法：

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

上表中的字符码出现在目标字符串的尾部，在 % 和字符码之间，可以有以下操作：

放置一个字典的键 [(name)]
列出左对齐 -、正号 + 和补零 0 的标志位 [flag]
给出数字的整体长度和小数点后的位数等 [width] [.precision]

>>> "***%d***%-6d***%06d***%+d***" % (123, 123, 123， 123)
'***123***123   ***000123***+123***'                           # %-6d 表示左对齐，%06d 表示补零

>>> "***%.2f***" % (123.456)
***123.46***                                                    # %.2f 表示保留浮点数小数点后2位

>>> "That is %(number)d little %(name)s !" % {'number':1, 'name':'bird'}
That is 1 little bird !                                         # 使用字典进行格式化

format() 方法：在 Python 2.6 和 3.0 以后的版本引入了一种新的格式化方法，format() 函数

>>> "That is {0} little {1} !".format(1, 'bird')
That is 1 little bird !

格式化总是会返回新的字符串作为结果而不是对左侧的字符串进行修改，如果需要的话，必须将格式化字符串赋值给一个变量来保存结果。
更多关于字符串格式化的参考：String format

更多关于字符串的参考：Sequence Type