Python 基础语法：基本数据类型（字符串）

在日常生活中，我们经常会用文字来记录事物的名称、或记录事情的发展过程等，这些文字类型的数据，就叫做字符串。在未来的写代码的工作中，无论你从事的是哪个方面的编程，字符串操作必不可少，非常重要。

1  字符串的定义和创建

1.1  字符串的定义和创建

在Python中，字符串是由一系列字符组成的不可变序列。字符串可以使用封闭的单引号、双引号或三引号（英文状态）来定义。

# 使用单引号定义字符串  
s1 = 'Hello, World!'  
  
# 使用双引号定义字符串  
s2 = "Hello, Python!"  
  
# 使用三引号定义多行字符串  
s3 = """  
This is a multi-line string.  
It can span multiple lines.  
"""

1.2  单引号、双引号，三引号的区别

在  Python 中，要表示字符串，必须在文字的外面加上单引号或双引号（英文的）。

print(type('Hello,World!'))  # <class 'str'>
print(type("Hello,World!"))  # <class 'str'>

print(type(1))    # <class 'int'>
print(type('1'))  # <class 'str'> 加上单引号或双引号的数字也是字符串

print(type(True))    # <class 'bool'>
print(type('True'))  # <class 'str'> 加上单引号或双引号的布尔值也是字符串

如果要想在字符串里显示单引号或双引号，就需要用不同的引号加以区分。

print("let's go.")   # let's go.
print('小明说："我爱Python"')   # 小明说："我爱Python"

也可以使用转义字符（\）来显示字符串里的单双引号。但不推荐，一是繁琐，二是看起来并不美观和自然。

print('let\'s go.')   # let's go.
print("小明说：\"我爱Python\"")   # 小明说："我爱Python"

三引号表示多行字符串。

如果遇到一个很长的字符串，一是屏幕的宽度有限放不下，二是阅读也不方便。所以，在 python 中，建议每行的宽度最大79个字符，如果超过了79个字符，就应该考虑换行了。

但如果用双引号，你尝试回车一下把字符串换行，会提示语法错误。所以 python 用三引号来表示多行字符串，也可以用三个双引号来表示多行字符串，效果是一样的。

print('''
    小明说：\"我爱Python\"
    小明说：\"我爱Python\" 
    小明说：\"我爱Python\"
    小明说：\"我爱Python\"
      ''')

如果在 Python 的 IDLE 里输入多行字符串，回车后显示的是 '\nhello world\nhello world\n' 这是怎么回事？

>>> '''
... hello world
... hello world
... '''
'\nhello world\nhello world\n'
>>>

这是因为我们在输入多行字符串的时候，不但输入了多行字符，而且还有敲击回车键的动作，敲击回车键这个动作虽然在屏幕上看不到，但它也是像字符一样存在的。Python  IDLE 为了让所有的字符都显示出来，就规定用 \n 来表示回车这个动作。

如果在 Python 的 IDLE 里输入 '\nhello world\nhello world\n' 这个字符串，却不会把 helllo world 进行多行显示。这是因为在这里，Python只会把把 \n 当作一个字符，而不会把它转义为回车键这个功能。

要想把 '\nhello world\nhello world\n' 这个字符串显示为多行字符串的形式，我们可以用 print() 这个函数。

>>>print("\nHello,World\nHello,World\n")

Hello,World
Hello,World

单双引号也可以实现字符串换行，只要在第一行的末尾打一个反斜杠。示例如下：

>>>"hello\
world"

'helloworld'

关于单双引号和三引号的区别，上面讲的比较零碎，但也比较重要，这也是一些基本常识。

1.3  转义字符

在Python中，转义字符是一种特殊的字符序列。

• 表示一些无法 "看见" 的字符，如换行符、制表符、回车符等
• 表示一些与语言本身有冲突的字符，单双引号字符，反斜杠字符本身等

转义字符以反斜杠（\）开头，后跟一个或多个字符。Python中的常见转义字符包括：

1. \n：换行符，表示新的一行开始。
2. \t：制表符，表示一个水平制表位置（通常等于8个空格）。
3. \\：反斜杠字符本身，用于表示文件路径中的目录分隔符等。
4. \"：双引号字符，用于在字符串中包含双引号。
5. \'：单引号字符，用于在字符串中包含单引号。
6. \r：回车符，表示将光标移动到行首。

注意：在Python中，换行符（\n）和回车符（\r）主要用于控制字符串中的换行和回车动作，以及在文件操作中指定行结束符。不过，需要注意的是，Python中的字符串和文件操作默认使用换行符（\n）作为行结束符，而不是回车符（\r）。

1.4  原始字符串

原始字符串（raw string）是Python中的一种字符串字面量形式，其特点是其中的反斜杠 \ 被视为普通字符，而不是转义字符的开头。这意味着在原始字符串中，你可以直接写入反斜杠而无需使用双反斜杠 \\ 进行转义。

原始字符串通过在字符串字面量前加上小写字母 r 或 R 来定义。例如：

normal_string = "This is a string with an escaped backslash: \\"  

raw_string = r"This is a raw string with a literal backslash: \"

原始字符串在处理包含大量反斜杠的字符串时特别有用，例如正则表达式或文件路径。在这些情况下，使用原始字符串可以避免频繁地转义反斜杠。

print('c:\northwind\northwest')
'''
orthwind
orthwest
'''
print('c:\\northwind\\northwest')
# c:\northwind\northwest

print(r'c:\northwind\northwest')
# c:\northwind\northwest

上面的例子中，第一例子里的的反斜杠是普通字符，但 print() 函数却把 \n 当成了换行符。要想正确显示路径，需要对这个普通字符 \ ，进行转义，如 \\。

而第二个例子，使用了 r'c:\northwind\northwest' 这意味着在原始字符串中，可以直接写入反斜杠而无需使用双反斜杠 \\ 进行转义。

print(r'let's go.')

但像上面这个例子，使用原始字符串是不正确的，因为 let's 中的单引号与字符串的单引号产生了矛盾。所以这个单引号需要进行转义 \' 。

2  字符串的索引和切片

2.1  字符串的索引

字符串是由若干个字符组成了，每个字符在字符串中都有一个数字（索引）与它对应，字符串每个字符的索引从左到右分别的 0，1，2，3，...

字符的索引也可以用负数表示，从字符串末尾开始计数，最后一个字符用 -1 表示，倒数第二个字符用 -2 表示，以此类推。如下图：

字符串	H	E	L	L	O
索引	0	1	2	3	4
	-5	-4	-3	-2	-1

我们可以通过索引访问字符串中的特定字符。

s = 'abcdefg'  
  
# 索引访问  
print(s[0])  # 输出 'a'  
print(s[-1]) # 输出 'g'  

2.2  字符串的切片

字符串的切片操作是Python中非常基础且强大的功能，它允许我们获取字符串的子串。以下是进行字符串切片操作时需要注意的一些关键点：

2.2.1  切片的语法

str[起始 : 结束 : 步长]

起始和结束是可选的，如果不指定，则默认为字符串的开始和结束。步长也是可选的，如果不指定，则默认为1。

s = 'abcdefg'

# 切片操作
print(s[1:6])  # 输出 'bcdef'  取出索引是1至5的字符，不包含索引6
print(s[1:6:2])  # 输出 'bdf'  取出索引是1、3、5的字符
print(s[:3])  # 输出 'abc'  取出索引是0至2的字符
print(s[3:])  # 输出 'defg' 取出索引是3至最后的字符

2.2.2  不包含结束位置

切片操作返回的字符串不包括结束位置指定的字符。换句话说，切片操作的范围是从起始位置到结束位置的前一个字符。

s = 'abcdefg'  
  
# 切片操作  
print(s[1:4])  # 输出 'bcd'  

2.2.3  负索引

可以使用负索引从字符串的末尾开始计数。例如，-1表示最后一个字符，-2表示倒数第二个字符，以此类推。

s = 'abcdefg'

# 切片操作
print(s[-4:-1])  # 输出 'def'

2.2.4  负步长

当步长为负数时，切片操作会从右向左进行。此时，起始位置应该在结束位置的右边，否则切片出来的结果为空集。

s = 'abcdefg'

# 切片操作
print(s[5:1:-1])  # 输出 'fedc'

我们可以使用了负步长进行字符串的反转。 

s = 'abcdefg'

# 切片操作
print(s[::-1])  # 输出 'gfedcba'

2.2.5  空切片

如果起始位置大于结束位置，或者步长为0，切片操作会返回空字符串。

掌握这些切片操作的注意点，可以帮助我们更准确地从字符串中提取所需的信息，提高代码的效率和可读性。

3  字符串的运算

3.1  字符串的拼接

字符串的加法（+）是字符串拼接最常用的一种。

str1 = 'Hello'
str2 = ','
str3 = 'World'
print(str1+str2+str3)  # Hello,World

3.2  字符串的重复

字符串的乘法（*）可以实现字符串重复。

str = '我爱你！'
print(str*3)  # 我爱你！我爱你！我爱你！

4  字符串的常用方法

Python的字符串对象提供了许多内置方法，用于执行各种字符串操作。

4.1  字符串的大小写转换方法

s = 'Hello World'

s_upper = s.upper()  # 转换为大写
s_lower = s.lower()  # 转换为小写

print(s_upper)  # 输出 'HELLO WORLD'
print(s_lower)  # 输出 'hello world'

4.2  字符串的查找与替换

字符串的查找与替换是字符串处理中常见的操作，对于编程和数据处理工作来说至关重要。

在Python中，字符串的查找和替换可以通过多种方式实现，包括使用内置方法和正则表达式。下面是具体的例子和解释。

4.2.1  字符串的查找

• 使用 find() 方法：find() 方法返回指定子串在字符串中首次出现的索引。如果未找到子串，则返回 -1。

s = "Hello, world!"  
index = s.find("world")  
print(index)  # 输出: 7  
  
index = s.find("Python")  
print(index)  # 输出: -1

•  使用 index() 方法：index() 方法与 find() 类似，但如果在字符串中未找到子串，它会引发一个 ValueError 异常。

s = "Hello, world!"  
index = s.index("world")  
print(index)  # 输出: 7  
  
# 这会抛出 ValueError  
# index = s.index("Python")

需要注意的是，find()和index()在功能上相似，但它们在未找到子串时的行为略有不同。find()会返回-1，而index()会抛出一个异常。

• 使用正则表达式 (re 模块)：对于更复杂的查找需求，你可以使用正则表达式。正则表达式是一种强大的文本处理工具，它允许你定义复杂的搜索模式，并在字符串中查找匹配这些模式的子串。

import re

s = "Hello, world! This is a Python string."

match = re.search(r"Python", s)
if match:
    print("Found:", match.start())  # 输出: 26  
else:
    print("Not found")

re.search(pattern,string)函数用于在字符串中查找第一个匹配正则表达式的子串。如果找到匹配项，它会返回一个匹配对象；否则返回None。

import re  
  
pattern = r'\d+'  # 匹配一个或多个数字  
string = '123 dollars is the price.'  
  
match = re.match(pattern, string)  
if match:  
    print('Found:', match.group())  # 输出: Found: 123  
else:  
    print('Not found')

re.match(pattern, string)函数尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回None。

import re  
  
pattern = r'\b\w+\b'  # 匹配一个或多个单词字符组成的单词  
string = 'Hello, world! This is a test.'  
  
matches = re.findall(pattern, string)  
print(matches)  # 输出: ['Hello', 'world', 'This', 'is', 'a', 'test']

re.findall(pattern, string)函数用于查找字符串中所有匹配正则表达式的子串，并返回一个包含这些子串的列表。

import re  
  
pattern = r'\b\w+\b'  # 匹配一个或多个单词字符组成的单词  
string = 'Hello, world! This is a test.'  
  
matches = re.finditer(pattern, string)  
for match in matches:  
    print(match.group())  # 输出每个匹配的单词

re.finditer()函数与re.findall()类似，但它返回一个迭代器，其中每个元素都是一个匹配对象。

• 大小写敏感与不敏感查找：字符串的查找操作通常是大小写敏感的，这意味着它会区分大写和小写字母。然而，有些方法或函数允许你指定查找操作是否对大小写敏感。例如，在Python中，你可以通过将字符串转换为全小写或全大写来进行不区分大小写的查找。或者使用正则表达式时，可以指定忽略大小写的标志。

4.2.2  字符串的替换

字符串的替换涉及到在找到特定子串或字符后，将其替换为另一个子串或字符。这也是字符串处理中常见的操作之一。

• 使用 replace() 方法：replace() 方法返回一个新的字符串，其中所有出现的指定子串都被替换为另一个子串。原始字符串不会被改变（因为字符串在Python中是不可变的）。

s = "Hello, world!"  
new_s = s.replace("world", "Python")  
print(new_s)  # 输出: Hello, Python!  
  
# 也可以指定替换次数  
new_s = s.replace("l", "x", 1)  
print(new_s)  # 输出: Hexlo, world!

• 使用正则表达式 (re 模块)：使用 re.sub() 方法可以进行基于正则表达式的替换。对于更复杂的替换需求，同样可以使用正则表达式。通过正则表达式，你可以定义复杂的匹配模式，并指定如何将匹配到的子串替换为新的子串。这个方法接受一个正则表达式模式、一个替换字符串和一个原始字符串作为参数，并返回替换后的新字符串。

import re  
  
s = "Hello, world! This is a Python string."  
new_s = re.sub(r"Python", "Ruby", s)  
print(new_s)  # 输出: Hello, world! This is a Ruby string.

re.sub() 的第一个参数是正则表达式模式，第二个参数是替换字符串，第三个参数是原始字符串。你也可以提供第四个参数来限制替换次数。

• 全局替换与局部替换：在进行字符串替换时，你可能需要替换所有匹配的子串（全局替换），或者只替换第一个匹配的子串（局部替换）。这通常可以通过设置替换方法的参数来实现。例如，在Python的replace()方法中，如果你不提供替换次数的参数，那么它会默认替换所有匹配的子串。如果你提供了一个具体的次数参数，那么它只会替换指定次数的匹配子串。

综上所述，字符串的查找与替换是字符串处理中的基本操作，不同的编程语言提供了丰富的方法和函数来支持这些操作。在实际应用中，你可以根据具体需求选择合适的方法来实现字符串的查找与替换功能。

4.3  字符串的分割

字符串的分割方法主要有以下几种：

字符串的分割方法主要有以下几种：

• 使用split()方法：split()方法可以将一个字符串按照指定的分隔符切分成多个子串，并返回一个列表。如果不指定分隔符，则默认按照所有的空字符（包括空格、换行、制表符等）进行分割。split()方法一次只可以使用一个符号进行字符串分割操作。

​s = 'apple,banana,cherry'  
list_s = s.split(',')  # 分割字符串  
print(list_s)  # 输出 ['apple', 'banana', 'cherry']  

• 使用正则表达式模块re.split()方法：当需要在字符串中根据多个字符或复杂的模式进行分割时，可以使用re.split()方法。它接受一个正则表达式作为分隔符，并返回分割后的字符串列表。

import re
e = "852317006@qq.com"
e_list = re.split('@|\.', e)
print(e_list)  # 输出 ['852317006', 'qq', 'com']

上例中，'@|\.' 是一个正则表达式，其中 | 表示“或”的意思，因此它会匹配 @ 或者 .字符。 .在正则表达式中是一个特殊字符，表示匹配任何字符（除了换行符），所以要在 . 前面加上反斜杠\来进行转义，使其表示实际的 .字符。

• 使用字符串的partition()或rpartition()方法：partition()方法根据指定的分隔符将字符串划分为三部分，并返回一个包含这三部分的元组。分隔符前的内容为元组的第一个元素，分隔符本身为第二个元素，分隔符后的内容为第三个元素。如果没有找到分隔符，则返回原始字符串和两个空字符串。rpartition()与partition()类似，但它是从字符串的右侧开始搜索分隔符。

e = "852317006@qq.com"
e_tuple = e.partition('@')
print(e_tuple)  # 输出 ('852317006', '@', 'qq.com')

right_e_tuple = e.rpartition('@')
print(right_e_tuple)  # # 输出 ('852317006', '@', 'qq.com')

no_separator_tuple = e.partition(',')
print(no_separator_tuple)  # 输出 ('852317006@qq.com', '', '')

以上是几种常见的字符串分割方法，它们可以根据不同的需求灵活选择。在使用时，要注意理解各种方法的特点和用法，以确保得到正确的分割结果。

4.4  字符串的连接

字符串的连接方法有多种，以下是其中的几种常见方法：

• 使用加号（+）：在Python中，可以直接使用加号（+）来连接两个或多个字符串。例如：

s1 = "hello"  
s2 = "world"  
s3 = s1 + " " + s2  
print(s3)  # 输出：hello world

需要注意的是，虽然加号（+）在这里看起来像运算符重载，但实际上在Python中，字符串的连接是通过加号（+）这个语法糖来实现的，而不是真正的运算符重载。

• 使用join方法：字符串对象有一个join()方法，可以接受一个字符串列表，然后用调用该方法的字符串依次连接列表中每一个元素。例如：

str_list = ['hello', 'world']

s1 = ' '.join(str_list)  # 用空格连接列表中的字符串
print(s1)  # 输出：hello world

s2 = '-'.join(str_list)  # 用 - 连接列表中的字符串
print(s2)  # 输出：hello-world

 在这个例子中，空格字符串' '和 '-' 被用作连接符，将列表中的每个字符串连接起来。

• 使用format方法：Python的字符串 format 方法也可以用于字符串的连接和格式化。例如：

name = "Alice"  
age = 25  
s = "My name is {} and I am {} years old.".format(name, age)  
print(s)  # 输出：My name is Alice and I am 25 years old.

在这个例子中，大括号{}是占位符，format方法会根据传入的参数依次替换这些占位符。

• 使用f-string：在Python 3.6及以上版本，可以使用f-string进行字符串的格式化，它提供了一种简洁且易读的方式来嵌入表达式到字符串字面量中。例如： 

name = "Alice"  
age = 25  
s = f"My name is {name} and I am {age} years old."  
print(s)  # 输出：My name is Alice and I am 25 years old.

在这个例子中，大括号{}内部直接写入了变量名，Python会自动用这些变量的值替换掉大括号。

以上就是一些常见的字符串连接方法，每种方法都有其适用的场景，可以根据具体需求选择使用。

4.5  除字符串的空白字符

s = '   hello world   '  
s_strip = s.strip()  # 去除字符串两侧的空白字符  
print(s_strip)  # 输出 'hello world'

除了strip()方法用于去除字符串两侧的空白字符外，还有lstrip()和rstrip()分别用于去除左侧和右侧的空白字符。 

4.6  字符串与字节串的转换

字符串和字节串（bytes）是两种不同的数据类型，有时需要进行转换。

s = 'hello'  
bytes_s = s.encode('utf-8')  # 字符串转换为字节串  
print(bytes_s)  # 输出 b'hello'  
  
str_s = bytes_s.decode('utf-8')  # 字节串转换为字符串  
print(str_s)  # 输出 'hello'

4.7  is*系列方法

这些方法用于检查字符串的某些特性。

s = 'hello'  
print(s.isalpha())  # 检查字符串是否只包含字母，返回 True 或 False  
print(s.isdigit())  # 检查字符串是否只包含数字，返回 True 或 False  
print(s.islower())  # 检查字符串是否全部小写，返回 True 或 False  
print(s.isupper())  # 检查字符串是否全部大写，返回 True 或 False  
print(s.isspace())  # 检查字符串是否只包含空白字符，返回 True 或 False

4.8  其他常用方法

s = 'hello world'  
  
# 返回字符串的长度  
print(len(s))  # 输出 11  
  
# 返回字符串的副本，其中所有小写字符转换为大写，所有大写字符转换为小写  
print(s.swapcase())  # 输出 'hELLO wORLD'  
  
# 返回字符串的副本，其中开头和结尾的指定前缀和后缀被移除  
print(s.strip('he '))  # 输出 'llo world'  
  
# 检查字符串是否以指定的前缀或后缀结尾  
print(s.startswith('hello'))  # 输出 True  
print(s.endswith('world'))  # 输出 True  

字符串是Python中非常基础和重要的数据类型之一，掌握其基本操作和常用方法对于编写高效、清晰的代码至关重要。通过本教程的学习，你应该对Python中的字符串有了更深入的了解，并能够在实际编程中灵活运用。记得在实践中不断尝试和探索，以加深对字符串处理的理解和应用能力。