# 10.字符串

## **创建字符串**

字符串是 Python 中最常用的数据类型，可以使用引号('或")来创建字符串

```
var1 = 'HelloWrold'
var2 = "HelloWrold"

print(var1)
print(var2)


运行结果
----------
HelloWrold
HelloWrold
```

''' 和 """ 可以输入多行字符串

## **访问字符串**

* 下标

```
>>> var1 = "HelloWorld"
>>> var1[2]
'l'
>>> var1[3]
'l'
>>> var1[4]
'o'
```

* 切片

```
>>> var1 = "HelloWorld"
>>> var1[:3]
'Hel'
```

## **字符串拼接**

字符串拼接可以使用+，将字符串进行拼接

```
>>> var1 = 'HelloWrold'
>>> var2 = "HelloWrold"
>>> var1+var2
'HelloWroldHelloWrold'
```

## **Python转义字符**

在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：

| 转义字符   | 描述                        |
| ------ | ------------------------- |
| (在行尾时) | 续行符                       |
| \\     | 反斜杠符号                     |
| '      | 单引号                       |
| "      | 双引号                       |
| \a     | 响铃                        |
| \b     | 退格(Backspace)             |
| \e     | 转义                        |
| \000   | 空                         |
|        | 换行                        |
| \v     | 纵向制表符                     |
|        | 横向制表符                     |
|        | 回车                        |
| \f     | 换页                        |
| \oyy   | 八进制数，yy代表的字符，例如：\o12代表换行  |
| \xyy   | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出              |

## **Python字符串运算符**

下表实例变量a值为字符串 "Hello"，b变量值为 "Python"：

| 操作符    | 描述                                                                                                    | 实例                             |
| ------ | ----------------------------------------------------------------------------------------------------- | ------------------------------ |
| +      | 字符串连接                                                                                                 | a + b 输出结果： HelloPython        |
| \*     | 重复输出字符串                                                                                               | a\*2 输出结果：HelloHello           |
| \[]    | 通过索引获取字符串中字符                                                                                          | a\[1] 输出结果e                    |
| \[ : ] | 截取字符串中的一部分，遵&#x5FAA;_&#x5DE6;闭右&#x5F00;_&#x539F;则，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') |
| %      | 格式字符串                                                                                                 | 请看下一节内容。                       |

## **Python字符串格式化**

使用%格式化输出字符串

```
print("%s%s" % ("Hello","World"))
```

运行结果

```
HelloWorld
```

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 是小数点后的位数(如果可用的话)                      |

## **format 格式化函数**

格式化字符串的函数str.format()，它增强了字符串格式化的功能。

基本语法是通过{}和:来代替以前的%

* format 函数可以接受不限个参数，位置可以不按顺序

```
>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'
```

* 也可以设置参数：

```
print("网站名：{name}, 地址 {url}".format(name="python", url="www.python.org"))

# 通过字典设置参数
site = {"name": "python", "url": "www.python.org"}
print("网站名：{name}, 地址 {url}".format(**site))

# 通过列表索引设置参数
my_list = ['python', 'www.python.org']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
```

运行结果:

```
网站名：python, 地址 www.python.org
网站名：python, 地址 www.python.org
网站名：python, 地址 www.python.org
```

* 可以向 str.format() 传入对象：

```
class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的
```

运行结果:

```
value 为: 6
```

## **数字格式化**

下表展示了 str.format() 格式化数字的多种方法：

```
>>> print("{:.2f}".format(3.1415926));
3.14
```

| 数字         | 格式      | 输出        | 描述                |
| ---------- | ------- | --------- | ----------------- |
| 3.1415926  | {:.2f}  | 3.14      | 保留小数点后两位          |
| 3.1415926  | {:+.2f} | +3.14     | 带符号保留小数点后两位       |
| -1         | {:+.2f} | -1.00     | 带符号保留小数点后两位       |
| 2.71828    | {:.0f}  | 3         | 不带小数              |
| 5          | {:0>2d} | 05        | 数字补零 (填充左边, 宽度为2) |
| 5          | {:x<4d} | 5xxx      | 数字补x (填充右边, 宽度为4) |
| 10         | {:x<4d} | 10xx      | 数字补x (填充右边, 宽度为4) |
| 1000000    | {:,}    | 1,000,000 | 以逗号分隔的数字格式        |
| 0.25       | {:.2%\} | 25.00%    | 百分比格式             |
| 1000000000 | {:.2e}  | 1.00e+09  | 指数记法              |
| 13         | {:10d}  | 13        | 右对齐 (默认, 宽度为10)   |
| 13         | {:<10d} | 13        | 左对齐 (宽度为10)       |
| 13         | {:^10d} | 13        | 中间对齐 (宽度为10)      |

`^,<,>`分别是居中、左对齐、右对齐，后面带宽度，:号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

`+`表示在正数前显示`+`，负数前显示`-`；（空格）表示在正数前加空格

`b、d、o、x`分别是二进制、十进制、八进制、十六进制

```
'{:b}'.format(11)
'{:d}'.format(11)
'{:o}'.format(11)
'{:x}'.format(11)
'{:#x}'.format(11)
'{:#X}'.format(11)
```

运行结果

```
1011
11
13
b
0xb
0XB
```

## **Python三引号**

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符

```
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
```

运行结果:

```
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ 
 ]。
```

## **Unicode 字符串**

在Python3中，所有的字符串都是Unicode字符串。

## [**Python 的字符串内建函数**](https://xintiaohuiyi.gitbook.io/jynotebook/python-ji-chu-bu-fen/zi-fu-chuan)

Python 的字符串常用内建函数如下：

| 方法                                                                | 描述                                                                                                    |
| ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| capitalize()                                                      | 将字符串的第一个字符转换为大写                                                                                       |
| casefold()                                                        | 把整个字符串的所有字符改为小写                                                                                       |
| center(width, fillchar)                                           | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格                                                          |
| count(str, beg= 0,end=len(string))                                | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数                                            |
| 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'                     |
| endswith(suffix, beg=0, end=len(string))                          | 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.                            |
| expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 | 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8                                                             |
| find(str, beg=0 end=len(string))                                  | 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1                                  |
| index(str, beg=0, end=len(string))                                | 跟find()方法一样，只不过如果str不在字符串中会报一个异常                                                                      |
| isalnum()                                                         | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False                                                         |
| isalpha()                                                         | 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False                                                            |
| isdigit()                                                         | 如果字符串只包含数字则返回 True 否则返回 False                                                                         |
| islower()                                                         | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False                                         |
| isnumeric()                                                       | 如果字符串中只包含数字字符，则返回 True，否则返回 False                                                                     |
| isspace()                                                         | 如果字符串中只包含空白，则返回 True，否则返回 False                                                                       |
| istitle()                                                         | 如果字符串是标题化的(见 title())则返回 True，否则返回 False                                                              |
| isupper()                                                         | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False                                         |
| join(seq)                                                         | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串                                                            |
| len(string)                                                       | 返回字符串长度                                                                                               |
| ljust(width\[, fillchar])                                         | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格                                             |
| lower()                                                           | 转换字符串中所有大写字符为小写                                                                                       |
| lstrip()                                                          | 截掉字符串左边的空格或指定字符                                                                                       |
| maketrans()                                                       | 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。                                   |
| max(str)                                                          | 返回字符串 str 中最大的字母                                                                                      |
| min(str)                                                          | 返回字符串 str 中最小的字母                                                                                      |
| partition(sub)                                                    | 找到子字符串sub，把字符串分成一个3元组(pre\_sub,sub,fol\_sub),如果字符串中不包含sub则返回(‘原字符串’,'','')                            |
| replace(old, new \[, max])                                        | 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次                                                         |
| rfind(str, beg=0,end=len(string))                                 | 类似于 find()函数，不过是从右边开始查找                                                                               |
| rindex( str, beg=0, end=len(string))                              | 类似于 index()，不过是从右边开始                                                                                  |
| rjust(width,\[, fillchar])                                        | 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串                                                        |
| rstrip()                                                          | 删除字符串字符串末尾的空格                                                                                         |
| split(str="", num=string.count(str))                              | num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串                                     |
| splitlines(\[keepends])                                           | 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。                |
| startswith(str, beg=0,end=len(string))                            | 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。                                      |
| strip(\[chars])                                                   | 在字符串上执行 lstrip()和 rstrip()                                                                            |
| swapcase()                                                        | 将字符串中大写转换为小写，小写转换为大写                                                                                  |
| title()                                                           | 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())                                                      |
| translate(table, deletechars="")                                  | 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中                                       |
| upper()                                                           | 转换字符串中的小写字母为大写                                                                                        |
| zfill (width)                                                     | 返回长度为 width 的字符串，原字符串右对齐，前面填充0                                                                        |
| isdecimal()                                                       | 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false                                                                 |

这里选几个演示一下用法

```
>>> data = "Angle"

>>> data.casefold()
'angle'

>>> ','.join(data) # 拼接
'A,n,g,l,e'
>>> '_'.join(data)
'A_n_g_l_e'

>>> 'A_n_g_l_e'.split('_') # 分离
['A', 'n', 'g', 'l', 'e']
```

translate() 函数的使用方法

```
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)   # 制作翻译表

str = "this is string example....wow!!!"
print (str.translate(trantab))
```

运行结果:

```
th3s 3s str3ng 2x1mpl2....w4w!!!
```

如何过滤掉的字符 o

```
# 制作翻译表
bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
# 转换为大写，并删除字母o
print(b'runoob'.translate(bytes_tabtrans, b'o'))
```

运行结果:

```
b'RUNB'
```
