第五章 字符串（基本操作、格式化）

5.1 字符串的基本操作

        序列的操作标准同样适用于字符串，但字符串却是只读的。

s1 = "hello world"
#  在字符串中使用索引
print(s1[0])              	# 获取s1的第1个字符，运行结果：h
print(s1[2])              	# 获取s1的第3个字符，运行结果：l
#  在字符串中使用分片
print(s1[6:9])          	# 获取s1从第7个字符往后的3个字符，运行结果：wor
print(s1[6:])             	# 获取s1从第7个字符后的所有字符，运行结果：world
print(s1[::2])            	# 在s1中每隔一个取一个字符，运行结果：hlowrd
s2  = "abc"
#  在字符串中使用乘法
print(10 * s2)            	#  运行结果：abcabcabcabcabcabcabcabcabcabc
print(s2 * 5)             	#  运行结果：abcabcabcabcabc
#  在字符串中使用in运算符
print('b' in s2)        	#  运行结果：True
print('x' not in s2)     	#  运行结果：True

print(len(s1))           	#  获取s1的长度，运行结果：11
print(min(s2))           	#  获取s2中按ASCII计算最小的字符，运行结果：a
print(max(s2))           	#  获取s2中按ASCII计算最大的字符，运行结果：c

5.2 格式化字符串

       Python语言中的字符串格式化可以称得上是“随心所欲”。

5.2.1 字符串格式化基础

       字符串格式化相当于字符串模板。如果一个字符串有一部分是固定的，另一部分是变化的，那么就可以将固定的部分做成模板，变化的部分用字符串格式化操作符%替换，%之后可以跟一些更加细致的格式。
       数量对应，顺序对应，数据类型对应(必要时用str函数，转换为字符串数据类型)

#  定义字符串模板
formatStr = "Hello %s. Today is %s, Are there any activities today?"
#  初始化字符串模板参数值，此处必须使用元组，不能使用列表
values = ('Mike', 'Wednesday')
#  格式化字符串
print(formatStr % values)

       几个示例如下

# 在这个字符串模板中，包含在浮点数和整数类型的格式化参数
formatStr1 = "PI是圆周率,他的值是%.4f（保留小数点后%d位）"
#  导入math模块中的pi变量
from math import pi
#  定义与formatStr1对应的格式化参数值
values1 = (pi, 4)
#  格式化字符串，运行结果：PI是圆周率,他的值是3.1416（保留小数点后4位）
print(formatStr1 % values1)
#  在这个字符串模板中，包含了整数和字符串类型的格式化参数
formatStr2 = "这件事的成功率是%d%%, 如果有%s参与的话，成功率会提升至%d%%"
values2 = (56, "John",70)
#  运行结果：这件事的成功率是56%, 如果有John参与的话，成功率会提升至70%
print(formatStr2 % values2)
values3 = (66,"Mike")
#  由于指定的参数值的数量和格式化参数的数量不匹配，所以会抛出异常
print(formatStr2 % values3)

5.2.2 模板字符串

       在String模块中提供了一个字符串格式化的Template类，该类的功能是用一个值替换所有相同的格式化参数。在格式化时，需要使用Template类的substitute方法，该方法用于指定格式化参数对应的值。用$来引用变量。

from string import Template
template = Template($c   $c   $c)
template.substitute(c = “hello”)

       例如：

# 引用string模块中的Template类
from string import Template
template1 = Template("$s是我最喜欢的编程语言, $s非常容易学习，而且功能强大")
# 指定格式化参数s的值是Python
print(template1.substitute(s='Python'))
# 当格式化参数是一个字符串的一部分时，为了和字符串的其他部分区分开，
# 需要用一对大括号将格式化参数变量括起来
template2 = Template("${s}stitute")
print(template2.substitute(s='sub'))

template3 = Template("$dollar$$相当于多少$pounds")
# 替换两个格式化参数变量
print(template3.substitute(dollar=20,pounds='英磅'))

template4 = Template("$dollar$$相当于多少$pounds")
data = {}
data['dollar'] = 100
data['pounds'] = '英磅'
# 使用字典指定格式化参数值
print(template4.substitute(data))

5.2.3 字符串的format方法

       字符串本身也有一个format方法用于格式化当前的字符串。用一对{}来引用,不需要指定数据类型。而且支持按顺序指定格式化参数值和无顺序关键字格式化参数。

print(“{}   {}   {}”.format(1,2,3))
print(“{a}   {b}   {c}”.format(a=1,c=2,b=3))

       示例如下：

#严格按照顺序
s1 = "Today is {}, the temperature is {} degrees."
print(s1.format("Saturday", 24))

#任意顺序
s2 = "Today is {week}, the temperature is {degree} degrees."
print(s2.format(degree = 22, week ="Sunday"))

#必须先指定顺序参数，再指定关键字参数
s3 = "Today is {week}, {}，the {} temperature is {degree} degrees."
print(s3.format("aaaaa", 12345, degree = 22, week ="Sunday"))

#变量名或索引位置，无顺序指定
s4 = "Today is {week}, {1}，the {0} temperature is {degree} degrees."
print(s4.format("aaaaa", 12345, degree = 22, week ="Sunday"))

#引用列表参数
fullname = ["Bill", "Gates"]
print("Mr {name[1]}".format(name = fullname))

#调用模块变量，__name__ 为模块名，pi 为模块中的变量值
import math
s5 = "The {mod.__name__} module defines the value {mod.pi} for PI"
print(s5.format(mod = math))

5.2.4 更进一步的控制字符串格式化参数

       示例：按原样输出、通过repr函数输出、以及输出其Unicode编码

print(“{first!s}  {first!r}  {first!a}”.format(first = “中”))

       结果：中 ‘中’ ‘\u4e2d’
       示例：更多的其他控制符，使用了s、r、a、f、b、o、x和%控制符

# [可选] from asn1crypto._ffi import null
print("原样输出：{first!s}  调用repr函数：{first!r}  输出Unicode编码：{first!a}".format(first = "中"))
print("整数：{num}  浮点数：{num:f}".format(num = 21))
print("十进制：{num}  二进制：{num:b}  八进制：{num:o}  十六进制：{num:x}".format(num = 56))
print("科学计数法：{num:e}".format(num = 533))
print("百分比：{num:%}".format(num = 0.56))
print("{:F}  {:f}".format(float("nan"),float("inf")))

       a: 将字符串按Unicode编码输出
       b: 将一个整数格式化为一个二进制数
       c: 将整数格式化解释成ASCII
       d: 将整数格式化为十进制的整数
       e: 将十进制数格式化为科学计数法，用小写e表示
       E: 将十进制数格式化为科学计数法，用大写E表示
       f: 将十进制整数格式化为浮点数。会将特殊值（nan和inf）转化为小写
       g: 会根据整数的位数，在浮点数和科学计数法之间，整数超过6位时，与e相同，否则与f相同
       G: 会根据整数的位数，在浮点数和科学计数法之间，整数超过6位时，与E相同，否则与f相同
       o: 将一个整数格式化为八进制数
       s: 按原样格式化字符串
       x: 将一个整数格式为十六进制数，字母部分小写
       X: 将一个整数格式为十六进制数，字母部分大写
       %: 将数值格式化为百分比形式

       说明：inf无穷大，nan无法计算时返回的一个标记，引用控制符时，大多使用冒号：，一部分使用感叹号！，如{!a}、{!r}

5.2.5 字段宽度、精度和千分位分隔符

       示例：

#显示52的宽度为12,对于数字右对齐,不足12位左侧补空格
print("{num:12}".format(num = 52))
#设置宽度为10,对于非数字的字符串来说是左对齐，右侧不足空格补齐
print("{name:10}Gates".format(name="Bill"))
#将精度应用于字符串,表示截取前5个字符
print("{:.5}".format("Hello World"))

from math import pi
#让圆周率PI保留2位小数
print("float number:{pi:.2f}".format(pi= pi))
#让圆周率PI保留2位小数,宽度为10,不足10位,左侧空格补齐
print("float number:{pi:10.2f}".format(pi= pi))

#对数值的整数部分加上千分位分隔符
print("One googol is {:,}".format(10 ** 100))

5.2.6 符号、对齐、用0填充和进制转换

       示例1：

# 第一个0表示左侧不足补0，2表示宽度，第二个0表示小数位忽略，f表示浮点形式格式化
print(“第{chapter:02.0f}章”.format(chapter = 4))
# 字符串格式化类型符本身就是变量，例如，{0:=^10.2f}中的10是变量，需要取width变量的值。那木可以使用嵌套写法：{0:=^{width}.2f}
# 左、中、右对齐，分别使用<、^、>
print(‘{:<10.2f}\n{:^10.2f}\n{:>10.2f}’.format(1,2,3))
# 指定符号补齐
print(“{:#^20}”.format(“  UFO  ”))
# 指定负数：-^^^^^4.56
print(“{0:^=10.2f}”.format(-5.43))
# 指定负数，居中显示：==-4.56===
print(“{0:=^10.2f}”.format(-5.43))
# 将十进制数转换为二进制、八进制、十六进制的数，需要分别用b、o、x类符号
print(“{:b}”.format(43))

       示例2：

from math import pi
#保留3位小数，宽度12位，不足0补齐，结果：00000003.142
print("{pi:012.3f}".format(pi = pi))
numStr = input("请输入章节序号的位数：")
#将输入的字符串转化为整数
#格式化输出章节序号
num = int(numStr)
print("第{:0{num}.0f}章，第{:03.0f}节".format(1,2,num = num))
#左、中、右输出
print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(pi))
print("{:$^20}".format(" 美元 "))
print("{:￥<20}".format(" 人民币 "))
#负数的输出，在(=)前边可输入负号(-)
print("{0:=10.2f}".format(-pi))
#结果：-       3.14    默认空格
#指定间隔变量
sign = input("请输入在数值前面输出的符号：")
print("{0:{sign}=10.2f}".format(-pi,sign = sign))
#进制转化
numStr = input("请输入要转换为二进制和十六进制的数：")
num = int(numStr)
#转化为二进制，转化为二进制前边加0b
print("{:b}".format(num))
print("{:#b}".format(num))
#转化为十六进制，转化为十六进制前边加0x
print("{:x}".format(num))
print("{:#x}".format(num))