Python 中的字符串

阅读本文大概需要 15 分钟

前言

本文是续写上一篇文章，接着讲 Python 中的固定类型，不懂什么是固定类型的同学，可以先看一下上一篇文章。

Python 中的固定类型

字符串 — str

实际运用过程中，字符串是最常见的一种类型，熟悉并了解它的一些函数、方法和一些常见操作显得尤为重要。

1. 字符串定义

Ⅰ.字符串表示

Python 中字符串有三种表示方式。

单引号

>>> a = 'PythonDeveloper'
>>> type(a)
<class 'str'>

双引号

>>> b = "PythonDeveloper"
>>> type(b)
<class 'str'>

三引号(Python 独有)

>>> c = '''PythonDeveloper'''
>>> type(c)
<class 'str'>

需要注意的是，在字符串里如果遇到需要表示的引号与外面的引号相同，则需要转义，转义符\。

>>> a = "Python \"Developer\""
>>> a
'Python "Developer"'

Ⅱ.长字符串问题
当遇到长字符串时，经常会遇到由于编辑器界面大小问题，需要换行，而 Python 又是以换行来作为语句终结符，所以当你一按回车就提示你出现错误，相信这个错误提示应该没少见。

>>> a = 'Python Developer
  File "<stdin>", line 1
    a = 'Python Developer
                        ^
SyntaxError: EOL while scanning string literal

而为了解决这个问题，有三种方法：

方法一：

利用 Python 独有的三引号''' '''

>>> a = ''' Python
... Developer'''
>>> a
' Python\nDeveloper'

方法二：

利用字符串连接符+和转义字符\

>>> a = 'Python' + \
... 'Developer'
>>> a
'PythonDeveloper'

方法三：

利用小括号()

>>> a = ('Python'
... 'Developer')
>>> a
'PythonDeveloper'

值得说明的是在 Python 的官方文档中，建议我们使用第三种方式。

2. 字符串切片和步距

字符串最常用的就是切片操作了，也叫分片。

Ⅰ.索引

在了解字符串的切片操作之前，你必须得先知道什么是索引，其实就是数组里的下标。

索引从第一个位置 0 开始，直到字符串的长度减 1，或者从最后一个 -1 开始，直到到 -字符串的长度，如

>>> a = 'PythonDeveloper'
>>> a[3]
'h'
>>> a[-3]
'p'

有一点需要注意索引可以是整数，也可以是存放着整数的变量。

>>> a = 'PythonDeveloper'
>>> b = 6
>>> a[b]
'D'

原因就是在于变量 b 只不过是整数 6 的对象引用，真正被调用的对象是整数 6 ，不是 b。

字符串长度可以通过len()函数获得。

>>> a = 'PythonDeveloper'
>>> len(a)
15

Ⅱ.切片操作

知道了索引是什么就很容易理解切片操作了。

切片操作有三种方式：

方式一：

a[start]

>>> a = 'PythonDeveloper'
>>> a[0]
'P'

方法二：

a[start:end]

>>> a = 'PythonDeveloper'
>>> a[0:6]
'Python'
>>> 

需要注意的是，取不到 end 终点位置的那个值，且如果起始位置和终点位置都不写的话，默认为第一个和最后一个。

方法三：

a[start:end:step]

>>> a = 'PythonDeveloper'
>>> a[-1:-10:-1]
'repoleveD'

这里就涉及到了步距问题。

Ⅱ. 步距

步距可以类比小时候玩的跳方格游戏

你可以一次跳两个

>>> a = 'PythonDeveloper'
>>> a[1:10:2]
'yhnee'

也可以一次跳三个

>>> a = 'PythonDeveloper'
>>> a[1:10:3]
'yoe'

甚至你还可以倒着跳：)

>>> a = 'PythonDeveloper'
>>> a[-1:-10:-2]
'rplvD'

3. 字符串的方法和函数

字符串的方法和函数特别多，我们并不需要一下子全部掌握，当你用到的时候，通过help函数查看一下相关注释即可，这里介绍一些常用的，比较重要的函数，和方法。

Ⅰ.字符串的连接问题

字符串有很多种连接方法，如简单的利用连接符+，连接两个字符串，利用切片操作，将一串字符串中想要的部分切割出来并连接，但是如果遇到大量字符串，最好的方法还是使用str.join()函数

>>> a = ['Stay','foolish','Stay','hungry']
>>> ' '.join(a)
'Stay foolish Stay hungry'

>>> '-'.join(a)
'Stay-foolish-Stay-hungry'

>>> ''.join(a)
'StayfoolishStayhungry'

# 使用空字符串当做分隔物，此时就是纯粹的连接

索引可以帮我们快速找到期对应的数据，有时候我们可能需要反过来，找到某个数据的索引位置，对着屏幕一个个数是一种方法，但是作为一个程序员，你要始终秉持一个理念：只要是机器能做的事，我就一定不做。

当遇到大量字符串时，就需要用到两个方法str.index(),str.find。

str.index('a') 如果找到了就返回从左往右a第一次出现的数据的索引位置，

>>> a = 'PythonDeveloper'
>>> a.index('e')
7

如果没找到，则会出现一个ValueError

>>> a.index('L')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

而str.find()如果找到了就返回其索引位置，

>>> a = 'PythonDeveloper'
>>> a.find('Python')
0

如果没找到，就返回 -1。

>>> a.find('PythoN')
-1

可以发现，当要找的数据不是单个字符时，Python 会从要找的数据的第一项开始寻找，如要查找Python的索引位置，则首先查找P，如果找到了，则接着查y，一直查到最后一个n，如果中间有一个没查到，则判定此次没有找到。如果都找到了，则判定此次找到了，并且返回第一项所在的索引位置。

Ⅱ. 字符串的剥离和替换问题

常见的字符串剥离有两种：

1. str.strip()

>>> a = '\tPythonDeveloper \n'
>>> a
'\tPythonDeveloper \n'
>>> a.strip()
'PythonDeveloper'

str.strip()方法默认剥离两边的空白符(空格，换行，制表符)，也可以指定要剥离的字符。

>>> a = 'PythonDeveloper'
>>> a.strip('Developer')
'Python'

需要注意的是这里只能剥离首尾的字符，不能剥离中间的字符。这种方法一般用来剥离首尾有空格的字符串。

2. str.split()

>>> date = '2018-8-3'
>>> date.split('-')
['2018', '8', '3']

可以看到，str.split()方法是将传入的参数作为分隔依据，将一个字符串分隔成几段，并用列表的形式存储起来。

字符串的替换有一种：

str.replace()

>>> a = 'hello,world'
>>> a.replace('world','Python')
'hello,Python'

str.replace()方法需要两个参数，一个是准备被替换的内容，一个是替换的内容。

这里要说明的是，凡是涉及到字符串的方法或函数，都不会改变原有字符串，而是新建一个新的字符串，这就是固定类型的作用！

4. 字符串格式化问题

字符串格式化除了常见的print("I'm %s"%'Chinese')，还可以通过format来进行格式化Python 中的str.format()方法可以很容易的对字符串进行格式化，并且该方法十分灵活且强大，可能在一些博客或者网站上，对于字符串格式化没有提的太多，但是对于一个 Pythoner，字符串格式化是你必须要掌握的一项技能。

Ⅰ. 字段名

在了解字符串格式化之前，你得先了解什么是字段名。

字段名其实就相当于索引，它可以帮助你定位到要格式化的位置，这就说明了字段名可以是和索引一样，用一个整数来表示，也可以用变量名来更形象的表示。

1. 字段名用整数表示

>>> '{0} look like so {1}'.format('You','cute')
'You look like so cute'

这里的{0}字段名，里面的数字 0 表示的就是str.format()方法里的第一个参数'You'。同理，{1}表示第二个参数'cute'。

在 Python3.x 的版本中，可以忽略字段名，直接使用{}来表示format()里的参数要插入的位置，Python 会自动进行处理(从 0 开始)，但是最好还是写上字段名，这样可以帮助你快速理解。

2. 字段名用变量名来表示

>>> "{who}'s little dream is to have {number} fans".format(number=100,who='PythonDeveloper')
"PythonDeveloper's little dream is to have 100 fans"

这里用变量名来表示字段名，即要插入的位置就显得更加灵活，且注意到后面穿的参数位置并不是顺序的，也就是说通过这种方式可以传入的参数，可以不用管他的顺序问题。

3. 字段名中使用切片操作符[]

>>> adv = ['Made','in','China','China','is','a','great','country']
>>> 'LaoGanMa is from {0[2]},it taste so {0[6]}'.format(adv)
'LaoGanMa is from China,it taste so great'

可以看到，当传入的参数是可以切片的时候，可以在字段名中直接对传入的参数进行切片，而不需要在外面切片完过后再传进去。

4. 字段名配合字典使用

>>> infor = dict(animal = 'Dog',who = 'Bob')
>>> infor
{'animal': 'Dog', 'who': 'Bob'}
>>> '{0[who]} like {0[animal]}'.format(infor)
'Bob like Dog'

如果已经知道了字典是什么的同学，应该就很容易理解这里的键-值对的问题，没学到的同学，暂时不理解也没关系，等到后面学到了字典，你就可以很轻松的理解了，这里只是为了展示利用format来处理字符串格式化问题时，所具备的强大能力。

不仅如此，format还可以通过local函数来进行格式化。

>>> city = 'ShangHai'
>>> population = '2000w'
>>> '{city} have {population} people'.format(**locals())
'ShangHai have 2000w people'

local()函数可以获取当前作用范围内的局部变量，并返回一个字典，字典的值是变量的值，字典的键是变量值得引用，也就是变量名。再通过映射拆分符**将字典拆成一个适合传递给函数的键-值列表。这里主要注意的是，如果传递的参数不止一个，只有最后一个参数可以映射拆分。

看到这里的同学，可能渐渐明白了，这里所谓的映射拆分，其实就是函数参数里的关键字参数，很多人可能只知道在函数里面带**的参数叫做关键字参数，却不直到它的工作原理，这里就作出了解释。

format()甚至还可以对字符串的大小，对齐方式进行修改，这里就涉及到了格式规约问题，介于常用的格式就已经满足工作需求，这里不做介绍，感兴趣的同学，可以去学一下。

元组-tuple

固定类型的最后一种就是元组，元组的方法只有两种，故与字符串一起讲述。

1. 元组的定义

Ⅰ. 元组的表示方法

元组使用一对小括号来定义，其中包含 0 个或者多个对象引用，元组可以像字符串一样切片,由于元组是固定类型，所以元组里的内容不可以修改。

>>> t = ('Pytohn','Developer')
>>> t
('Pytohn', 'Developer')
>>> type(t)
<class 'tuple'>

这里有一点要注意的是，经常使用的,也可以用来创建元组。

>>> t = 1,2
>>> t
(1, 2)
>>> type(t)
<class 'tuple'>

并且如果你想创建只有一个数据项的元组，就必须得使用,

>>> t = (1)
>>> type(t)
<class 'int'> # 这里 Python 会将 `()` 当成数学计算里的小括号运算，故返回的是 int 型


>>> t = (1,)
>>> t
(1,)
>>> type(t)
<class 'tuple'>

Pytohn 在返回只有一个数据项的元组时，也会将,加上，以示区别。

Ⅱ.元组的方法

1. tuple.indec()

>>> t = ('Python','Developer')
>>> t.index('Developer')
1

跟字符串里的方法一样，返回的是从左边开始，'Developer'的索引位置，如果没找到，则返回ValueError。

2. tuple.count()

>>> t = ('A','a','B','b','aa','bb','a')
>>> t.count('a')
2

tuple.count() 方法返回的是在元组中'a'出现的次数。

元组总共就只有这两种方法，元组也支持切片，由于是和字符串切片一样，故不再赘述。

结语

到这里 Python 中的固定类型就算介绍完了，还有一个固定集合forzenset由于接触到的并不多，故这里并没有介绍。

初学 Python 的同学，可能会觉着今天学这儿，明天学那。。。感觉永远学不完，而且还容易学了前面的，忘了后面的，这种时候你的学习效率是很低的，建议在学习的时候先得有一个大的框架，根据梳理出来的知识框架，逐个击破里面的零碎知识点，没学完一章，或是一小节，停下来做个总结，这样你才不会忘得那么快。

并且要深知一点：纸上得来终觉浅，觉知此事要躬行。光看不做，等于没看，光听不做，等于没听，光想不做，等于没想。

您的一次关注就足以让我感动！