range

range是一种序列类型，range类型用于表示不可变的整数序列。
通过调用内置函数range（类range的构造方法）创建range类型的对象，有三种调用方式：

1. range(stop)
2. range(start, stop)
3. range(start, stop, step)

整数序列的起始值的默认值是0，可以使用参数start指定。
可以使用参数stop指定整数序列的结束值；创建的range对象不包含stop。
整数序列的步长的默认值是1，可以使用参数step进行指定。

内置函数range的返回值是一个迭代器对象，为了清楚地表示返回的迭代器对象所表示的整数序列，可以通过list函数将其转换为列表。
range内心的优点在于：不管range对象表示的整数序列有多长，所有range对象占用的内存空间是一样的。因为都只需要传出start、stop和step。只有当用到range对象时，才会去计算序列中的相关元素。

print(range(5))
a = range(5)
print(type(a))
print(list(range(5)))
print(list(range(0,5,1)))
print(list(range(0,5,2)))

返回结果如下：

range(0, 5)
<class 'range'>
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[0, 2, 4]

可以使用运算符in （not in）来检查range对象表示的整数序列中是否存在（不存在）指定的整数。

print(3 in range(5))        # True
print(6 not in range(5))    # True

列表(list)

列表相当于其它编程语言中的数组。

列表-特点

• 列表中的所有数据是按顺序有序排列的，也就是说，列表属于序列类型；
• 列表中的所有数据都有两个证书类型的索引，通过指定的索引总能映射到唯一确定的数据；
• 列表中可以存在重复的数据；
• 列表中可以保存任何类型的数据，多种类型的数据可以混合存储在一个列表中；
• 列表可以根据需要动态的伸缩，也就是说，系统会根据需要动态的分配和回收内存；
• 在使用前无需预先声明列表的容量

列表-创建

使用中括号

当把列表赋值给变量时，变量名不要取名为list或l，因为list是列表对应的类名，l容易被误读或误写为阿拉伯数字1.

L = ['Python', 23, False]
print(type(L))
print(L)
# 空列表
print([])

返回结果如下：

<class 'list'>
['Python', 23, False]
[]

调用内置函数list

print(list(range(1, 5)))
print(list(['Python', 23, False]))
# 空列表
print(list())

返回结果如下：

[1, 2, 3, 4]
['Python', 23, False]
[]

列表-查

索引

列表中的每个元素都有两个整数类型的索引

• 第一个元素的索引是0，后面元素的索引依次递增1
• 最后一个元素的索引是-1，前面元素的索引依次递减1

获取列表中指定元素的索引

如果想要获取列表中指定元素的索引，可以调用方法index，该方法只返回两个整数索引中大于0的那个。

print(L.index(9))   # 3
# 如果列表中存在多个指定元素，方法index只返回第一个指定元素的索引值
print(L.index(23))  # 1
# 如果列表中不存在指定的元素，方法index抛出valueError
# print(L.index(11))  # ValueError: 11 is not in list
# 调用方法index时还可以指定起始索引start和结束索引stop这两个参数:index(element, start, stop)
# 只指定起始索引start（不能只指定结束索引）
print(L.index(23, 2))   # 4
# 指定起始索引start和结束索引stop,此处如果stop的值为4，将抛出异常，23 not in list，因为stop的值减1才是索引stop的值。
print(L.index(23, 2, 5)) # 4

使用索引依次只获取一个元素

L = ['Python', 23, False, 9, 23]
# 获取最后一个元素的值
print(L[-1])    # 23
print(L[4])     # 23
print(L[0])     # Python
print(L[-3])    # False

如果指定的索引在列表中不存在，会抛出indexError

使用切片一次获取多个元素

可以使用切片获取列表中的元素，一次可以获取多个元素。
切片的语法格式：[start:stop:step]

• 得到的切片仍然是列表，是原始列表的片段的一份拷贝
• 得到的切片不包括索引stop对应的元素。
• 如果不指定step，其默认值是1，此时语法格式可以简化为[start:stop]
• 当step为正数时：
  • 如果不指定start，切片的第一个元素默认是列表中的第一个元素。
  • 如果不指定stop，切片的最后一个元素默认是列表的最后一个元素。
  • 从索引start 开始往后计算切片。
• 当step为负数时：
  • 如果不指定start，切片的第一个元素默认是列表的最后一个元素。
  • 如果不指定stop，切片的最后一个元素默认是列表的最后一个元素。
  • 从索引start开始往前计算切片。

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
print(L[1:7:2])
print(L[1:7:])
print(L[1:7])
print(L[::])
print(L[::-1])
print(L[6:0:-2])
print(L[0:6:-2])
print(L[6::-2])
print(L[:5:-2])
# 返回结果如下：
[3, 4, 6]
[3, 9, 4, 0, 6, 8]
[3, 9, 4, 0, 6, 8]
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
[2, 7, 1, 8, 6, 0, 4, 9, 3, 5]
[8, 0, 9]
[]
[8, 0, 9, 5]
[2, 1]

• 切片操作允许索引越界的：

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
print(L[:100])
print(L[-100:])
# 返回结果如下：
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

• 可以调用内置函数slice创建slice类型的对象
  • 内置函数slice有三种调用方式：
    1. slice(stop)
    2. slice(start, stop)
    3. slice(start, stop, step)
  • start、stop和step的默认值都是None
  • slice(start, stop, step)与start:stop:step是等价的。

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
print(L[:100])
print(L[-100:])

print(L[1:7:2])
print(L[slice(1, 7, 2)])

print(L[::])
print(L[slice(None, None, None)])

print(L[1:7])
print(L[slice(1, 7)])
print(L[slice(1, 7, None)])

print(L[:7])
print(L[slice(7)])
print(L[slice(None, 7, None)])

# 返回结果如下：
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
[3, 4, 6]
[3, 4, 6]
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
[3, 9, 4, 0, 6, 8]
[3, 9, 4, 0, 6, 8]
[3, 9, 4, 0, 6, 8]
[5, 3, 9, 4, 0, 6, 8]
[5, 3, 9, 4, 0, 6, 8]
[5, 3, 9, 4, 0, 6, 8]

列表-改

为指定索引的元素赋予一个新值（一次只修改一个元素）

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
L[2] = 11
print(L)    # [5, 3, 11, 4, 0, 6, 8, 1, 7, 2]

为指定的切片赋予一个新值（一次至少修改一个元素）

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
L[1:4] = [3, 4 ,5 , 6]
print(L)
L[1:2] = [5]
print(L)
# 登号左右的元素个数可以不同，此时，列表中其他元素的索引也会随之改变
L[1:4] = [1]
print(L)

返回结果如下：

[5, 3, 4, 5, 6, 0, 6, 8, 1, 7, 2]
[5, 5, 4, 5, 6, 0, 6, 8, 1, 7, 2]
[5, 1, 6, 0, 6, 8, 1, 7, 2]

列表-增

调用方法append

在列表的末尾一次只添加一个元素

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

L.append(11)
print(L)            # [5, 3, 9, 4, 0, 6, 8, 1, 7, 2, 11]
L.append([12, 13])
print(L)            # [5, 3, 9, 4, 0, 6, 8, 1, 7, 2, 11, [12, 13]]

调用方法extend

在列表的默认一次至少添加一个元素
将参数中的所有元素依次添加到列表的末尾

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

L.extend([11, 12])
print(L)            # [5, 3, 9, 4, 0, 6, 8, 1, 7, 2, 11, 12]

调用方法insert

在列表的任意位置一次只添加一个元素
第一个参数指定插入位置，第二个参数指定被插入的元素
插入位置后面的所有元素依次向后移动一个位置

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

L.insert(11, 12)
print(L)            # [5, 3, 9, 4, 0, 6, 8, 1, 7, 2, 12]
# 调用内置函数len可以获取列表中的元素个数
L.insert(len(L), 14)
print(L)            # [5, 3, 9, 4, 0, 6, 8, 1, 7, 2, 12, 14]

为指定的切片赋予一个新值

在列表的任意位置一次至少添加一个元素

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

L[2:2] = [11, 12]
print(L)            # [5, 3, 9, 4, 0, 6, 8, 1, 7, 2, 12]

列表-删

调用方法remove

一次只删除一个指定的元素
被删除元素后面的所有元素依次向前移动一个位置
如果列表中存在多个指定元素，只删除第一个元素
如果要删除的指定元素在列表中不存在，会抛出valueError

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

L.remove(4) 
print(L)        # [5, 3, 9, 0, 6, 8, 1, 7, 2]
L.remove(7)
print(L)        # [5, 3, 9, 0, 6, 8, 1, 2]

调用方法pop

一次只删除一个指定索引的元素
该方法会返回被删除的元素。
如果没有指定索引，默认删除列表中的最后一个元素

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

print(L.pop(2))     # 9
print(L)            # [5, 3, 4, 0, 6, 8, 1, 7, 2]
print(L.pop())      # 2
print(L)            # [5, 3, 4, 0, 6, 8, 1, 7]

使用del语句

一次至少删除一个元素

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

del L[2]
print(L)    # [5, 3, 4, 0, 6, 8, 1, 7, 2]
del L[1:3]
print(L)    # [5, 0, 6, 8, 1, 7, 2]

给指定的切片赋值一个空列表

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

L[2:3] = []
print(L)    # [5, 3, 4, 0, 6, 8, 1, 7, 2]
# 清空列表
L[:] = []
print(L)    # []

调用方法clear清空列表

L = [1, 2, 3, 4]
L.clear()
print(L)	# []

列表-反转

调用方法reverse

调用方法reverse后的列表将永久发生变化

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

L.reverse()
print(L)    # [2, 7, 1, 8, 6, 0, 4, 9, 3, 5]

调用内置函数reversed

内置函数reversed的返回值是一个迭代器对象，且被反转的列表不发生变化

L = [5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

I = reversed(L)
print(type(I))
print(I)
print(list(I))
print(L)

返回如下：

<class 'list_reverseiterator'>
<list_reverseiterator object at 0x000001E4B1EC4790>
[2, 7, 1, 8, 6, 0, 4, 9, 3, 5]
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

列表-加法与乘法

加法

可以使用加法运算符将两个列表合并后生成一个新列表，被合并的两个列表不发生任何变化。

L1 = [1, 2, 3]
L2 = [4, 5, 6]
L3 = L1 + L2
print(L1)
print(L2)
print(L3)

print('参数赋值运算符+=会对列表本身进行修改')
L1 = L2 = [1, 2]
L1 = L1 + [3, 4]
print(L1, L2)
L1 = L2 = [1, 2]
L1 += [3, 4]
print(L1, L2)

返回结果如下：

[1, 2, 3]
[4, 5, 6]
[1, 2, 3, 4, 5, 6]
参数赋值运算符+=会对列表本身进行修改:
[1, 2, 3, 4] [1, 2]
[1, 2, 3, 4] [1, 2, 3, 4]

乘法

可以使用乘法运算符将列表中的所有元素重复n次后生成一个新列表，被乘的列表不发生任何变化。

L1 = [1, 2, 3]
L = L1 * 2
print(L1)
print(L)
# 常用于列表的初始化
L1 = [0] * 5
print(L1)
# 参数赋值运算符*=会对列表本身进行修改
L1 = L2 = [1, 2]
L1 = L1 * 3
print(L1, L2)
L1 = L2 = [1, 2]
L1 *= 3
print(L1, L2)

返回如下：

[1, 2, 3]
[1, 2, 3, 1, 2, 3]
[0, 0, 0, 0, 0]
[1, 2, 1, 2, 1, 2] [1, 2]
[1, 2, 1, 2, 1, 2] [1, 2, 1, 2, 1, 2]

列表-比较

可以使用如下比较运算符对两个列表进行比较：
> >= < <= == ~=
比较规则为：首先比较两个列表中的第一个元素，如果相等则继续比较下一个元素，依次比较下去，直到两个列表的元素不相等时，其比较结果就是两个列表的比较结果，两个列表中的所有后续元素将不再进行比较。

print([2, 3, 4, 5, 6] > [2, 3, 4, 7, 9])    # False

还可以通过使用is 对两个列表进行比较。
==和is的区别：==是相等性测试，is是同一性测试

a = b = [1, 2]
c = [1, 2]

print(a == b)   # True
print(a == c)   # True
print(a is b)   # True
print(a is c)   # False

列表-排序

调用方法sort

调用方法sort后，列表中的所有元素默认按照从小到大进行排序，可以通过指定参数reverse = True按照从大到小排序

L = [1, 2, 7, 5, 11]
L.sort()
print(L)    # [1, 2, 5, 7, 11]
L.sort(reverse=True)
print(L)    # [11, 7, 5, 2, 1]

调用内置函数sorted

内置函数sorted的返回值是排序后生成的新列表，原列表不发生变化。也可以通过指定参数reverse=True按照从大到小进行排序

L = [1, 2, 7, 5, 11]

print(sorted(L))    # [1, 2, 5, 7, 11]
print(sorted(L,reverse=True))   # [11, 7, 5, 2, 1]
print(L)    # [1, 2, 7, 5, 11]

多维列表

当列表中的元素也是列表时，就构成了多维列表。
一维列表操作适用于多维列表

多维列表的初始化

print([[0] * 3] * 4)
print([[0 for i in range(3)] for j in range(4)])
print([[0] * 3 for j in range(4)])
# 返回结果如下：
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

元组（tuple）

元组与列表的主要区别

1. 元组用小括号表示（列表用中括号表示）

t = ('cc', 18, True)
print(t)    # ('cc', 18, True)
# 小括号可以省略
t = 'cc', 18, True
print(t)    # ('cc', 18, True)
# 空元组
print(())   # ()
print(tuple())  # ()

2. 元组是不可变类型（列表是可变类型）
   一旦创建了不可变类型的对象，对象内部的所有数据就不能被修改了，这样就避免了由于修改数据导致的错误。此外，对于不可变类型的对象，在多任务环境下同时操作对象时不需要加锁。因此，在程序中尽量使用不可变类型的对象。

t = ('cc', [18, 19], True)

t[1] = 'bb' # TypeError: 'tuple' object does not support item assignment
# 对于元组中可变类型的数据，元组中存储的是其引用（内存地址），因此，存储的引用是不能被改变的，也就是说，不能再引用任何其它对象，但是，引用所指向的可变类型的数据是可以被修改的
t[1][0] = 11
print(t)    # ('cc', [11, 19], True)

只包含一个元素的元组

元组中至少要包含一个逗号，即使元组只有一个元素，否则，小括号会被解析为数学公式中的小括号。

t = (18)
print(type(t))  # <class 'int'>
t = (18,)
print(type(t))  # <class 'tuple'>
t = 18,
print(type(t))  # <class 'tuple'>

多个变量同时赋值

赋值运算符的左边可以是一个所有元素都为变量的元组或列表，从而一次给多个变量同时赋值。

a, b = [1, 2]
print(a, b)     # 1 2
[a, b] = [3, 4]
print(a, b)     # 3 4 
a, b = 5, 6
print(a, b)     # 5 6

赋值运算符左右两边的元素个数必须相同，否则会抛出ValueError。
可以在赋值运算符左边的某个变量前添加*，以匹配赋值运算符右边的0个或多个元素。

a, *b, c = 1, 2, 3, 4
print(a, b, c)
*a, b, c = 1, 2, 3, 4
print(a, b ,c)

交换两个变量的值

a = 1
b = 2
a, b = b, a
print(a, b) # 2 1

字符串

在程序中，文本类容用字符串来表示。
字符串由一系列有序的字符组成。
字符串与列表和元组一样，都属于序列类型。
可以将字符串看做是字符的列表，列表的很多操作对于字符串也是适用的。
没有单独的字符类型，字符就是只包含一个元素的字符串。
字符串是不可变类型，无法进行改、增、删操作。

字符串-创建

使用引号

• 创建字符串时及可以使用单引号，也可以使用双引号，通常使用单引号。
• 当把字符串赋值给变量时，变量名不要取名为str，因为str是字符串对应的类名。
• 可以在单引号中使用双引号，也可以在双引号中使用单引号。
• 不能在单引号中使用单引号，也不能在双引号中使用双引号。

调用内置函数str

a = str('abcd')
b = str('1234')
c = str(1234)
d = str(123.4)
print(a, b, c, d) # abcd 1234 1234 123.4

转义字符

使用转义字符表示无法直接表示的特殊字符

当字符串中包含换行、回车、水平制表符或退格等无法直接表示的特殊字符时，可以使用如下转义字符：

• 换行：\n
• 回车：\r
• 水平制表符：\t
• 退格：\b

使用转义字符表示在字符串中有特殊用途的字符

某些字符在字符串中有特殊用途，比如：反斜杠用于转义，单引号和双引号用于字符串的边界，因此，不能在字符串中直接使用包含这些特殊用途的字符。
当字符串中包含上述情况时，可以使用反斜杠进行转义：

• 反斜杠：\
• 单引号：'
• 双引号："

原始字符串

如果不想让字符串中的转义字符生效，可以在字符串的前面添加r或者R，从而将字符串声明为原始字符串。

print(r'\tC:\\user')    # \tC:\\user
print(R'\tC:\\user')    # \tC:\\user

原始字符串的最后一个字符不能是反斜杠（最后两个字符都是反斜杠除外）。

多行字符串

如果想让字符串跨越多行，可以使用如下方式：

使用三个引号（'''、"""）

在三个单引号中可以嵌套三个双引号，在三个双引号中可以嵌套三个单引号。

print('''
a
b
c''')
print("""
a
b
c""")

返回结果如下：

a
b
c

a
b
c

在每行的结尾添加一个\

通过在每行的末尾添加\可以将单行字符串写在多行。
如果要实现写在单行的字符串输出为多行，可以添加\n来实现。

字符串-加法、乘法

加法

可以使用加法运算符将两个字符串连接后生成一个新字符串。

print('abc' + 'def' + 'test')   # abcdeftest

乘法

可以使用乘法运算符将字符串中的所有字符重复N次后生成一个新的字符串

字符串-查

因为字符串可以看做是字符的列表，所以字符串与列表的查操作类似，区别在于：当获得字符串中指定子串的索引时，除了调用方法index，还可以调用方法find、rfind、rindex。其中，子串的索引指的是子串中第一个字符的索引。
当字符串中存在多个被查找的子串时，方法index和find返回第一个子串的索引，方法rfind和rindex返回最后一个子串的索引。
当字符串中不存在指定的子串时，方法index和rindex抛出ValueError，方法find和rfind返回-1

s = '12345678945'
print(s.index('45'))    # 3
print(s.find('45'))     # 3
print(s.rindex('45'))   # 9
print(s.rfind('45'))    # 9

字符串-比较

可以试下如下比较运算符对两个字符串进行比较：

• >
• >=
• <
• <=
• ==
• !=

比较的规则为：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较。
两个字符进行比较时，比较的是其ordinal value。调用内置函数可以得到指定字符的ordinal value，与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value可以得到其对应的字符。

print(ord('a'))     # 97
print(chr(97))      # a
print(ord('b'))     # 98
print(chr(98))      # b
print(ord('A'))     # 65
print(chr(65))      # A
print('a' < 'b')    # True
print('a' < 'A')    # False
print('cbadf' > 'cbAeg')    # True
# 可以使用is对两个字符串进行比较
# ==与is的区别：==是相等性测试，is是同一性测试。
# 字符串常量会被缓存和重用。
a = b = 'Hello'
c = 'Hello'
print(a == b)   # True
print(a == c)   # True
print(a is b)   # True    
print(a is c)   # True

字符串-反转

与列表不同的是，字符串是不可变类型，因此，想要对字符串中的所有字符进行反转，不存在方法reverse，只能调用内置函数reversed。

s = '12345'
ss = reversed(s)
print(ss)       # <reversed object at 0x00000150096D4790>
print(list(ss)) # ['5', '4', '3', '2', '1']
print(s)        # 12345

字符串-排序

与列表不同的是，字符串是不可变类型，因此，如果想要对字符串的所有字符进行排序，不存在方法sort，只能调用内置函数sorted。

s = '12345'
print(sorted(s))                # ['1', '2', '3', '4', '5']
print(sorted(s, reverse=True))  # ['5', '4', '3', '2', '1']

调用内置函数sorted时，可以指定参数key = 函数名 或 key = 类名.方法名，这样会对字符串中的所有字符分别调用指定的函数或方法，然后按照函数或方法的返回值进行排序，从而自定义排序规则。

s = '12345'
print(sorted(s,key=str.lower))  # ['1', '2', '3', '4', '5']

调用内置函数sorted时的参数key同样适用于列表和数组。

字符串-格式化

什么是格式化字符串

格式化字符串就是按一定格式输出的字符串。
例如：字符串'2018-08-18 18:18:18'就是一个格式化字符串，它的格式为：'年-月-日 时:分:秒'。
再例如：经过计算得到一个结果，想用一个有格式的字符串进行输出，格式为：'计算结果是：xxx'。

占位符

占位符就是先占住一个位置的符号，在自定义格式化字符串时，可以使用占位符先占住某些固定位置，等访问字符串的时候，再将所有的占位符替换成实际值
例如：可以自定义这样的格式化字符串：'%Y-%m-%d %H:%M:%S'，其中，%Y、%m、%d、%H、%M和%S都是占位符，他们分别代表年、月、日、时、分、秒。在访问字符串时，如果给出的实际值分别是2018、08、18、18、18和18，那么得到的格式化字符串就是'2018-08-18 18:18:18'，如果给出的实际值分别是2018、09、19、19、19和19，那么得到的格式化字符串就是'2019-09-19 19:19:19'。

使用百分号（%）作为占位符

常见的表示不同类型的占位符有：

• %s：表示字符串
• %i或%d：表示整数
• %f：表示浮点数

book = '《从入门到放弃》'
s = '买了一本书：%s' % book
print(s)    # 买了一本书：《从入门到放弃》
# 当定义的格式化字符串中包含两个及两个以上的占位符时，必须将所有的实际值封装在元组中。
price = 55.55
s = '花了%f，买了一本书：%s' % (price, book)
print(s)    # 花了55.550000，买了一本书：《从入门到放弃》
# 如果不确定使用哪种占位符，那么%s永远起作用，它会把任何数据类型转换为字符串
s = '花了%s，买了一本书：%s' % (price, book)
print(s)    # 花了55.55，买了一本书：《从入门到放弃》
# 如果定义的格式化字符串中%是一个普通支付，需要使用%%对其进行转义
print('我的工作已经完成了%d%%' % 80) # 我的工作已经完成了80%
# 占位符%中可以指定宽度，数字和字符串都是右对齐。
print('%10d' % 58)      #         58
print('%10s' % '58')    #         58
# 占位符%中可以指定精度
print('%.3f' % 3.1515926)       # 3.152
print('%.5s' % 'Hello,World')   # Hello
# 同时指定宽度和精度
print('%8.3f' % 3.1415926 )     #    3.142

使用花括号（{}）作为占位符

通过调用方法format并使用花括号作为占位符，从而得到格式化字符串。

book = '《从入门到放弃》'
s = '买了一本书：{}'.format(book)
print(s)    # 买了一本书：《从入门到放弃》
# 如果占位符{}中不指定参数，方法format的参数会按顺序依次匹配所有的占位符{}
price = 55.55
s = '花了{}，买了一本书：{}'.format(price, book)
print(s)    # 花了55.55，买了一本书：《从入门到放弃》
# 占位符{}中可以指定位置参数，0表示方法format的第一个参数，1表示方法format的第2个参数，依次类推。
s = '花了{0}，买了一本书{1}，只花了：{0}'.format(price, book)
print(s)    # 花了55.55，买了一本书《从入门到放弃》，只花了：55.55
# 可以在方法format中指定关键字参数的名称和值，在占位符{}中指定关键字参数的名称。
s = '花了{p},买了一本书：{b},只花了：{p}'.format(p = price, b = book)
print(s)    # 花了55.55,买了一本书：《从入门到放弃》,只花了：55.55
# 占位符{}中可以使用冒号:指定整数的表示形式。其中，位置参数或关键字参数的名称放在冒号前面
# 十进制
print('{:d}'.format(58))    # 58
# 二进制
print('{:b}'.format(58))    # 111010
# 十六进制，a-f小写
print('{:x}'.format(58))    # 3a
# 十六进制，a-f大写
print('{:X}'.format(58))    # 3A
# 浮点数
print('{:f}'.format(58))    # 58.000000
# 使用逗号作为千位分隔符
print('{:,}'.format(123456789)) # 123,456,789
# 占位符{}中还可以使用冒号指定宽度，其中，数字是右对齐，字符串是左对齐。
print('{:10}'.format(58))       #         58
print('{:10}'.format('58'))     # 58
# 占位符{}中还可以使用.指定精度
# 总共3位
print('{:.3}'.format(3.1415926))    # 3.14
# 小数点后3位
print('{:.3f}'.format(3.1415926))   # 3.142

使用美元符（$）作为占位符

可以通过导入模块string中的类Template并使用美元符号作为占位符，从而得到格式化字符串。

from string import Template
price = 68.88
book = '《从入门到放弃》'

tmpl = Template('花了$p，买了一本书：$b')
# 调用方法substitute
s = tmpl.substitute(p = price,b = book)
print(s)    # 花了68.88，买了一本书：《从入门到放弃》
s = tmpl.substitute({'p': price, 'b': book})
print(s)    # 花了68.88，买了一本书：《从入门到放弃》
# 当占位符没有匹配到实际值时，会抛出KeyError

# 调用方法safe_substitute，此方法更安全，当占位符没有匹配到实际值时，不会抛出KeyError，而是使用占位符本身作为实际值。
s = tmpl.safe_substitute(p = price)
print(s)    # 花了68.88，买了一本书：$b

字符串-大小写转换

如果想要对字符串中某些字符的大小写进行转换，可以调用字符串的以下方法：

• upper：把所有字符全部转换为大写
• lower：把所有字符全部转换为小写
• swapcase：把小写字符转换为大写，把大写字符转换为小写。
• capitali：把第一个字符转换为大写，把其余字符转换为小写。
• title：把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写。

s = 'thiS is Python'
print(s.upper())    # THIS IS PYTHON
print(s.lower())    # this is python
print(s.swapcase()) # THIs IS pYTHON
print(s.capitalize())   # This is python
print(s.title())    # This Is Python

如果想要判断字符串中的某些字符的大小写，可以调用字符串的以下方法：

• isupper：是否所有字符全是大写
• islower：是否所有字符全是小写
• istitle：是否每个单词的第一个字符为大写并且其余字符为小写。

s = 'thiS is Python'
print(s.isupper())          # False
print(s.upper().isupper())  # True
print(s.islower())          # False
print(s.lower().islower())  # True
print(s.istitle())          # False
print(s.title().istitle())  # True

字符串-对齐

通过调用字符串的以下方法进行字符串的对齐：

• center：中心对齐
• ljust：左对齐
• rjust：右对齐
• zfill：右对齐，左边用0填充，只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身

前三个方法都可以接收两个参数，其中：
第一个参数指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身。
第二个参数指定填充字符，且第二个参数是可选的，其默认值是空格。

print('HelloWorld'.center(20, '*'))
print('HelloWorld'.center(20))
print('HelloWorld'.center(5))

print('HelloWorld'.ljust(20, '*'))
print('HelloWorld'.ljust(20))
print('HelloWorld'.ljust(5))

print('HelloWorld'.rjust(20, '*'))
print('HelloWorld'.rjust(20))
print('HelloWorld'.rjust(5))

print('123'.zfill(6))
print('-123'.zfill(6))
print('123'.zfill(2))

返回结果如下：

*****HelloWorld*****
     HelloWorld     
HelloWorld
HelloWorld**********
HelloWorld          
HelloWorld
**********HelloWorld
          HelloWorld
HelloWorld
000123
-00123
123

字符串-子串替换

如果想将字符串中的某个子串替换为指定的字符串，可以调用方法replace。该方法的第一个参数指定被替换的子串，第二个参数指定替换子串的字符串。该方法返回替换后得到的字符串，替换前的字符串不发生变化。还可以通过指定第三个参数的方式来限定替换次数，默认是全部替换。

s = 'Hello-Hello-Hello'
print(s.replace('Hello', 'Hi')) # Hi-Hi-Hi

print(s.replace('Hello', 'Hi', 2))  # Hi-Hi-Hello

字符串-字符替换

如果想对字符串中的某些字符进行转换，可以调用方法maketrans和translate。
首先调用方法maketrans创建一个转换表，然后把创建的转换表作为参数传给方法translate。

字符串-劈分和合并

劈分

调用方法split或者rsplit劈分字符串

• 方法split从字符串的左边开始劈分
• 方法rsplit从字符串的右边开始劈分
• 默认的劈分符（分隔符）是空格字符串
• 返回值都是一个列表

s = 'Python   Swift   Kotlin'
print(s.split())        # ['Python', 'Swift', 'Kotlin']
print(s.rsplit())       # ['Python', 'Swift', 'Kotlin']

# 可以通过参数sep指定劈分符
s = 'Python|Swift|Kotlin'
print(s.split(sep='|'))     # ['Python', 'Swift', 'Kotlin']
print(s.rsplit(sep='|'))    # ['Python', 'Swift', 'Kotlin']

# 可以通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大劈分后，剩余的子串会单独作为一个部分成为列表的一个元素
s = 'Python   Swift   Kotlin   Java'
print(s.split(maxsplit=2))  # ['Python', 'Swift', 'Kotlin   Java']
print(s.rsplit(maxsplit=2)) # ['Python   Swift', 'Kotlin', 'Java']

调用方法partition或rpartition劈分字符串

• 方法partition从字符串的左边开始劈分
• 方法rpartition从字符串的右边开始劈分
• 调用这两个方法时都必须指定劈分符
• 方法partition在指定的劈分符第一次出现的地方（方法rpartition在指定的劈分符最后一次的地方），将字符串劈分为三个部分：
  • 劈分符前面的部分
  • 劈分符
  • 劈分符后面的部分
• 这两个方法返回值都是一个元组

s = 'Hello-World-!'
print(s.partition('-'))     # ('Hello', '-', 'World-!')
print(s.rpartition('-'))    # ('Hello-World', '-', '!')

s = 'HelloWorld-'
print(s.partition('-'))     # ('HelloWorld', '-', '')
print(s.rpartition('-'))    # ('HelloWorld', '-', '')

如果字符串中不存在指定的劈分符，方法partition返回的元组中的三个元素依次为：

1. 字符串本身
2. 空字符串
3. 空字符串

如果字符串中不存在指定的劈分符，方法rpartition返回的元组中的三个元素依次为：

1. 空字符串
2. 空字符串
3. 字符串本身

s = 'HelloWorld'
print(s.partition('-'))     # ('HelloWorld', '', '')
print(s.rpartition('-'))    # ('', '', 'HelloWorld')

合并

调用方法join合并多个字符串

a, b, c = 'aa', 'bb', 'cc'
print(a + b + c)            # aabbcc
print(''.join([a, b, c]))   # aabbcc
print('|'.join([a, b, c]))  # aa|bb|cc
# 可以把字符串看做是字符的列表    
print('|'.join('Python'))   # P|y|t|h|o|n

字符串-is开头的常用方法

• isidentifier：判断指定的字符串是否是合法的标识符
• iskeyword：模块keyword中的方法iskeyword判断一个字符串是否是关键字
• isspace：判断指定字符串是否全部有空白字符组成
• isalpha：判断指定字符串是否全部由字母组成
• isdecimal：判断指定字符串是否全部由十进制的数字组成
• isnumeric：加判断指定字符串是否全部由数字组成
• isalnum：判断指定字符串是否全部由字母和数字组成

print('abc'.isidentifier())     # True
print('123'.isidentifier())     # False

import keyword
print(keyword.iskeyword('if'))  # True
print(keyword.iskeyword('iF'))  # False

print('abc'.isalpha())          # True
print('123'.isdecimal())        # True
print('123'.isnumeric())        # True  
print('123'.isalnum())          # True

字符串-去除前导字符串或后续字符串

如果想要去除字符串的前导字符串或后续字符串，可以调用以下方法：

• lstrip：去除字符串的前导字符串。
• rstrip：去除字符串的后续字符串。
• strip：去除字符串的前导字符串和后续字符串

上述三个方法默认的前导字符串和后续字符串都是空格字符串。

s = '    Hello World         '
print(s.lstrip())   # Hello World         
print(s.rstrip())   #     Hello World
print(s.strip())    # Hello World

调用以上三个方法时可以指定一个字符串。
前导字符串指的是：从左边第一个字符开始依次往后，直到某个字符不在指定的字符串中。
后续字符串指的是：从右边最后一个字符开始依次往前，直到某个字符不在指定的字符串中。

s = 'www.baidu.com'
print(s.lstrip('cmowz.'))   # baidu.com
print(s.rstrip('cmowz.'))   # www.baidu
print(s.strip('cmowz.'))    # baidu