Python--字符串

字符串类型在Python中是十分重要的类型，他一般用引号中间添加字符的形式表达，不同于其他语言的是，Python中双引号（” “）与单引号（’ ‘）是不予区分的。都可以用来表示字符串

创建、赋值和访问

1. 两种创建方式

(1) 直接赋值

s = "abcdef"

(2) 通过str()函数

str()函数的作用，相当于是通过传入的参数，生成一个string型的对象，这个传入的参数可能是整型，浮点型，也能是列表，元组，字典等。

s = str(21) # >>> "21"
s = str(12.3) # >>> "12.3"
s = str([1, 2, 3]) # >>> "[1, 2, 3]"

需要注意的是，“传入的是什么，得到的就是什么”比如我们传一个列表进去的话，得到的字符串的第一个字符可不是列表的第一个元素，而是"["，同理 , 也被看做是字符串的一部分

2. 访问字符串

(1) 访问单个字符

s = "1234567"
print(s[1]) # >>> "2"
print(s[-1]) # >>> "7"
print(s[-7]) # >>> "1"

字符串当然也是序列，所以也满足每一个元素（也就是其中的每一个字符）都对应一个索引，索引的设计与其他语言一样，从0开始。

此外，Python还提供了“负索引”，就是令最后一个元素的索引为-1，倒数第二个元素的索引为-2，以此类推，第一个元素的索引就是-n（其中，n为序列的长度）

(2) 访问切片

s = "1234567"
print(s[1:4]) # >>> "234"

切片是Python中非常有特色的语法，当然，切片应用的对象是序列（字符串，列表，元组），他可以用来非常方便的表示序列的一部分。切片有3个参数控制，他的形式可以如下表示：

[begin: end: step]

中间由 : 隔开，begin 表示要得到的序列的起始位置，并且包含这个位置，而 end 则表示要得到序列的结束位置，但是不能包含这个位置的元素。例如：

s = "1234567"
s1 = s[2:5] # >>> 取的是s中第2个位置开始，一直到第4个位置的数，也就是"345"

如果我们不明确给出begin和end的相应参数，那么，begin会默认为0，end会默认为n（序列长度），比如：

s = "1234567"
s1 = s[:5] # >>> s1 = "12345"
s2 = s[2:] # >>> s2 = "34567"
s3 = s[:] # >>> 复制了整个s

而切片的最后一个参数step则表示“步长”，比如：

s = "1234567"
s1 = s[1:6:2] # >>> 从第1个位置开始，直到第5个位置结束，每次“跳”2步，得到"246"

可以理解为，每取一个元素后，向后“跳”的步数为step，比如上面的例子就是跳了2步。但是step这个参数不是一定要给出的，他默认值为1，而且当使用默认值1时，step之前的那个 : 如果没有特殊的需求，也是可以省略不写的。

(3) 负切片

有一种比较特殊的切片使用方式，那就是“负切片”，通俗地讲，就是令step为负数的切片，既然我们上面已经说过Python提供“负索引”，那么根据相同的道理，负切片自然就是从后开始，每次向前跳相应的步数，比如：

s = "1234567"
print(s[6:1:-1]) # >>> 依次取6,5,4,3,2位置的元素， 结果是"76543"
print(s[-2:-4:-1]) # >>> 依次取-2,-3位置的元素，结果是"65"

不论是正切片，还是负切片，begin 和 end 都满足“左闭右开”的原则。只不过正切片是从左往右（或者叫从前往后），而负切片是相反的方向。

与正切片同理，step的取值当然也可以不是-1，也可以取别的负整数。

s = "1234567"
print(s[6:1:-2]) # >>> 依次取6,4,2位置的元素， 结果是"753"

需要注意的是，不论正负切片，要是begin或者end超出了序列的范围，是不会引发异常的。

a = "1234"
print(a[8:]) # >>> ""
print(a[0:8]) # >>> "1234"

如果出现正切片中 begin > end 且begin 与 end 同号，或者负切片中 begin < end 且begin 与 end 同号的情况，一样返回空序列。

a = "1234567"
print(a[3:1:1]) # >>> ""
print(a[1:3:-1]) # >>> ""

但是如果begin 与 end 异号，则会先将负索引转换成相应的正索引，再实施切片。

a = "1234567"
print(a[-2:0：-1]) # >>> 转换成 a[5:0：-1]
print(a[2:-1]) # >>> 转换成 a[2:6]

不可变性

我之前说过，像整型，字符串等等，这些类型的数据是不可变的（详见我的博文：Python–内存管理），也就是说，一旦给这些类型的数据分配了内存，那么就不可更改了。比如，执行以下的操作会引发异常：

s = "1234567"
s[0] = "e"

但是，现实中，确实有很多情况需要我们改变字符串本身的内容。那么，在Python中，我们通用的做法是重新建立一个string型的对象，比如：

s = "1234567"
s = s[0:3] + "Python" # >>> s = "123Python"

虽然看上去的结果像是把s改变了，其实只是重新建立了一个由之前s的切片s[0:3]和字符串“Python”连接后构成的新字符串，并被名字s引用了。

同理，我们当然也可以用这种方法删除字符串中的某些元素，比如：

s = "1234567"
s = s[0:3] + s[4:] # >>> s = "123567" 删除了4

其实一样的，还是新建了字符串类型的对象。

字符串的操作符

1. 成员

我们用操作符in 和 not in 来判断一个字符，或者一个字符串是否在另一个字符串当中。

s = "abcdef"
print("ef" in s) # >>> True
print("ac" in s) # >>> False
print("d" not in s) # >>> False

2. 连接

用 + 表示两个字符串的连接，其实前面我们也已经见过这样的例子了。

s1 = "I wrote"
s2 = "Python"
print(s1 + " " + s2) # >>> "I wrote Python" 

3. 重复

s = "123"
print(s * 3) # >>> "123123123"

* 表达的意思其实跟数学上是一样的，多个相加嘛。

4. 比较

字符串之间的比较，是以两个字符串间，第一个不同的字符所对应的ascii码的大小为根据的。

s1 = "abcde"
s2 = "abce"
print(s1 > s2) # >>> False

而当两个字符串前面相同时，则以较长的字符串为大

s1 = "abcd"
s2 = "abc"
print(s1 > s2) # >>> True

字符串的内建函数

1. 字符串长度

用 len(str) 的形式求取一个字符串的长度

print(len("1234567")) # >>> 7

2. 字符串最大最小值

其实就所对应的ascii编码最大最小的字符

print(max("abcd")) # >>> "d"
print(min("1234")) # >>> "1"

3. enumerate and zip

将字符串作为参数传入 enumerate() 和 zip() 函数，生成相应的enumerate型的对象和zip型的对象，然后我们在通过循环将这些对象按照我们的需要输出即可。比如：

enum_obj = enumerate("abcd") # >>> 新建了一个enumerate型的对象
for index, ele in enum_obj:
    print(index, ele)        # >>> 依次输出: 0 "a", 1 "b", 2 "c", 3 "d"

for i in zip("abcd", "1234"):
    print(i)                 # >>> 依次输出：("a", "0"), ("b", "1"), ("c","2"), ("d","3")

这样的函数能为我们提供更加便捷的处理数据的方法。

4. 字符串查找

除了前面说的成员操作符能判断一个字符串是否在另一个字符串当中，函数 find() 和 index() 也能做类似的工作。

s = "Python"
print(s.find("Py")) # >>> 0
print(s.find("hy")) # >>> -1

find() 函数的功能是若找的见，则返回匹配部分最开始的那个位置；若找不见，则返回-1，当然，find() 函数中还可以设置寻找的开始和结束位置。不过字符串的内建函数实在太多，很多函数的参数设置也很细，所以我只是“抛砖引玉”，就不一 一列举了。

index() 函数实现的是类似的功能，不过如果找不到的话，引发异常。所以要使用index() 函数最好用成员操作符事先加一条判断语句，若在内，再使用 index() 返回匹配字段的起始位置。

s = "Python"
print(s.index("yth")) # >>> 1
print(s.index("hy")) # >>> 引发异常

5. 字符串判别

Python还提供了很多字符串的判别函数。

(1) string.isalnum() 当字符串中的字符都是字母或数字，返回True，否则返回False

s1 = "123asd"
s2 = "as, 123"
print(s1.isalnum()) # >>> True
print(s2.isalnum()) # >>> False

(2) string.isalpha() string中所有字符都是字母，返回True，否则返回False

s1 = "Python"
s2 = "C++"
print(s1.isalpha()) # >>> True
print(s2.isalpha()) # >>> False

(3) string.isdigit() string中所有字符都是数字，返回True，否则返回False

s1 = "0106584376"
s2 = "010-7487345"
print(s1.isdigit()) # >>> True
print(s2.isdigit()) # >>> False

(4) string.isupper() string中所有字母都是大写，返回True，否则返回False
      string.islower() string中所有字母都是小写，返回True，否则返回False

s1 = "SELECT"
s2 = "Python3.5"
print(s1.isupper()) # >>> True
print(s2.islower()) # >>> False

6. 字符串替换

string.replace() 函数实现字符串替换。它生成一个新的字符串对象，新对象是替换后的样子

s = "123456"
s = s.replace("456", "abc") # >>> s = "123abc"

基本参数有两个，旧的在前，新的在后。

7. 字符串分割

常用的分割的相关函数有三个：string.split(); string.partition(); string.join()

(1) string.split()：

s = "I love you"
s.split(" ") # >>> 以空格为分隔符，将字符串s分割成一个列表：["I", "love", "you"]

需要注意的是这种分割的手法实际上是以字符串的开头为一个点，结尾为一个点，然后每个分隔符为一个点，若相邻两点之间又字符串，则这个字符串为列表的一个元素，若相邻两点间没有东西，则返回一个空字符（不是空格，是空字符 ""），比如还是上面的例子，我们改一下：

s = "I  love you  "
s.split(" ") # >>> 以空格为分隔符，将字符串s分割成一个列表：["I", "", "love", "you", "", ""]

实际上，我们用点表示，是这样的：s = ".I..love.you..." 注意开头和结尾各有一个点，取每两个相邻点之间的东西构成列表的一个元素，就得到我们上面的结果。

(2) string.partition()：

s = "I love you"
s.partition(" ") # >>> 以空格为分隔符，从分隔符出现的第一个位置起，将字符串s分割成一个三个元素的列表：["I", " ", "love you"]

partition() 的作用和split() 类似，只不过结果一定是三个元素的列表，且分隔符一定是第二个元素

(3) string.join()：
这实际上是一个连接函数，但我还是把它放在分割里面讲了。它的作用是以string为分隔符，将括号里面的字符串序列连接起来（注意，一定是字符串形式的序列，比如由字符串构成的列表等等），构成新的字符串。

print(",".join(["I", "wrote", "Python"])) # >>> "I,wrote,Python"
print("**".join("123")) # >>> "1**2**3"

8. 大小写转换

主要介绍三个函数：

(1) string.upper() ：将所有小写字符转换成大写，但是需要注意的是，这其实只是生成了一个新的对象，而原对象并未发生改变

s = "bupt"
print(s.upper()) # >>> "BUPT"
print(s) # >>> "bupt"

(2) string.lower() ：与 string.upper() 同理，只不过是大写转换为小写

s = "Python3"
print(s.lower()) # >>> "python3"

(3) string.swapcase() ：生成新对象，新对象中，大写换成小写，小写换成大写

s = "I Need You"
print(s.swapcase()) # >>> "i nEED yOU"

9. 字符串简化

有时候，会遇到一个字符串最左端和最右端有空格的情况，而这些空格会影响我们对字符串做处理，所以，如果有函数能化简字符串，去除这些两端的空格，就会让我们十分的便捷。string.strip() 函数就是做这件事情的。

和上面的函数一样，实际上，他是生成了一个新的字符串对象，和原先的字符串相比，这个字符串去除了左右两侧的空格。

s = "   I  Need You     "
s = s.strip() # >>> "I  Need You"

需要注意的是，字符串中间的空格不会受到影响

10. 字符串翻转

因为字符串是不可变的对象，所以，原则上讲，也只能和上面的函数一样，生成一个新对象，新对象的元素排列，恰好是原字符串翻转后的样子。
有两种翻转方法：

(1) reversed() 函数

s = "1234567"
s1 = reversed(s) # >>> 新建一个对象
print(s1) # >>> "7654321"

(2) step = 1 的切片

s = "1234567"
s1 = s[::-1] # >>> 也是新建一个对象
print(s1) # >>> "7654321"

当然，除了我上面介绍的10个方面之外，其实Python中关于字符串的内建函数还有很多。当然，常用的基本都在这里了，其他就先不介绍了。大家需要用到时，自己百度，一定会有相关的答案。