python基础04_字符串的格式化和高级操作

字符串的操作

今天要学习的内容，主要与字符串相关，即涉及之前字符串拼接的复习，同时也学习一些新的操作方式

使用’+'拼接字符串

加法的运算，在之前学习中大概介绍过，同类数据我们可以进行加法运算，比如数值+数值，或者是字符串+字符串。

当使用字符串+字符串操作时，其实就是把两个以上的字符串进行拼接

比如：小明是好学生。

这句话分别拆成三段主、谓、宾：‘小明’、‘是’、‘三好学生’

则可以用’+'对它们进行拼接：‘小明’ + ‘是’ + ‘三好学生’

看实际代码和运行情况：

# 直接通过print输出
print('小明' + '是' + '三好学生')

# 定义变量输出
Subject = '小明'
predicate = '是'
object = '三好学生'

print(Subject + predicate + object)

# 也可以
proposition = Subject + predicate + object

print(proposition)

# 输入主语内容
print('谁是三好学生？')
Subject = input('请输入一个名字：') # input()输入的数据类型为str
predicate = '是'
object = '三好学生'

print(Subject + predicate + object)

运行结果：

小明是三好学生

小明是三好学生

小明是三好学生

谁是三好学生？
请输入一个名字：小明
小明是三好学生

使用.format()来对字符进行格式化操作

基本格式：

‘{}’.format() ，必须用引号print('{}'.format(112))如果没引号，会报错

AttributeError: ‘dict’ object has no attribute ‘format’

例如：小明是三好学生

‘{}是三好学生’.format(‘小明’)

在此{}为占位符，内容由format()返回

# 示例一
print('{}是好学生'.format('小明'))

# 示例二
proposition_1 = '{}是三好学生'.format('小明')
print(proposition_1)

# 可以多个
proposition_2 = '{}是{}'.format('小明','三好学生')
print(proposition_2)

# 如果怕位置出错，可以在{}中加入序号，从左向右:0，1，2……顺序
proposition_3 = '{0}是{1}'.format('小明','三好学生')
proposition_4 = '{0}是{0}'.format('小明','三好学生')
proposition_5 = '{1}是{1}'.format('小明','三好学生')
print(proposition_3)
print(proposition_4)
print(proposition_5)

# 示例三，也可以带入变量
print('谁是三好学生？')
Subject = input('请输入一个名字：') # input()输入的数据类型为str
proposition_6 = '{}是三好学生'.format(Subject)
print(proposition_6)

输出结果：

小明是好学生
小明是三好学生
小明是三好学生
小明是三好学生
小明是小明
三好学生是三好学生
谁是三好学生？
请输入一个名字：张小明
张小明是三好学生

• 在Python中，格式字符串的语法为"{[argument_index]:[format_spec]}"。其中，format_spec是一个可选参数，用于(通过格式说明符）定义一个特定类型的格式化。它可以包含格式说明符，控制字符串的显示方式。例如，可以使用format_spec将字符串格式化为特定宽度的字段，或者将其转换为大写或小写。一些常见的格式说明符包括填充字符、对齐方式、数字位数和小数位数等等。

pai = 3.1415926
print("{0:10.2f}".format(pai)) #将第一个参数格式化为一个浮点数，总宽度为10个字符，其中包含2个小数位
print("{0:10.3f}".format(pai)) #将第一个参数格式化为一个浮点数，总宽度为10个字符，其中包含3个小数位
print("{0:10.4f}".format(pai)) #将第一个参数格式化为一个浮点数，总宽度为10个字符，其中包含4个小数位
print("{0:10.5f}".format(pai)) #将第一个参数格式化为一个浮点数，总宽度为10个字符，其中包含5个小数位
print("{0:10.6f}".format(pai)) #将第一个参数格式化为一个浮点数，总宽度为10个字符，其中包含6个小数位
print("{0:10.7f}".format(pai)) #将第一个参数格式化为一个浮点数，总宽度为10个字符，其中包含7个小数位

看看结果：

	  3.14
	 3.142
	3.1416
   3.14159
  3.141593
 3.1415926

格式说明符还可以包括以下选项：

1. 填充字符：使用指定的字符填充空白部分。比如，使用0来填充数字左侧的空余位置：“{0:05d}”。
2. 对齐方式：指定对齐的方向，可选项有 “<”（左对齐）、“>”（右对齐）、“^”（居中对齐）。比如，左对齐的方式为"{0:<10}"。
3. 数字位数：指定整数的位数，不足时在左侧用0填充。比如，保留2位小数且整数位两位数，可以使用"{0:05.2f}"。

以下是一些常用的格式说明符示例：

• 左对齐、填充0、整数4位、小数2位：

  “{0:<07.2f}”

• 右对齐、填充空格、整数5位、小数3位：

  “{0:>9.3f}”

• 居中对齐、填充"-"、整数6位、小数1位：

  “{0:^8.1f}”

• 无小数、填充空格、整数3位：

  “{0:4d}”

注意，在{}内的数字表示参数的索引，如"{0:7.2f}“中的0表示第一个参数。另外，格式说明符可以组合使用，如”{0:^8.2f}"表示居中对齐、小数点后保留2位、总共占8位（包括小数点和小数部分）的格式。

f-string字符串格式化方法

return f"{self.name[::-1]} is {self.age} years old."

"f"是f-string的缩写，是一种方便的字符串格式化方法。当一个字符串以“f”或“F”开头时，它就会被视为f-string。在f-string中，可以使用大括号{}来引用表达式，例如变量或表达式。在这种情况下，f-string中的大括号{}中的代码将被解释为表达式并计算，然后将结果插入到生成的字符串中。所以在这个代码中，f-string被用来格式化字符串并在其中插入相应的变量值。如果不使用f-string，就需要使用字符串格式化方法，例如使用.format()方法。

因此，如果没有使用f-string，那么这段代码可以重写为：

return "{} is {} years old.".format(self.name[::-1], self.age)

但是使用f-string更简单和更易读。

字符串索引与切片操作

字符串中的字符可以利用其对应的下标进行索引和切片操作，简单讲就是每一个字符串里的字符都对应着一个编号，利用这个编号可以方便的提前对应的字符。

比如：“小明是三好学生”这个字符串，可以通过下面列表清除的看到其中某个字对应的编号，这个编号我们一般称为“下标”

字符串	小	明	是	三	好	学	生
正向索引	0	1	2	3	4	5	6
反向索引	-7	-6	-5	-4	-3	-2	-1

索引操作

即利用下标找到对应字符

正向索引以0开头，从左向右，自然数列排序

反向索引以-1开头，从右向左，负整数列排序

# 一般先定义一个变量，然后在变量名后加[]来实现
# 变量名[4]，或 变量名[-4]，正数代表从左向右，负数代表从右向左

prop = '小明是三好学生'
print(prop[0] , prop[-1])
print(prop[1] , prop[-2])
print(prop[2] , prop[-3])
print(prop[3] , prop[-4])
print(prop[4] , prop[-5])
print(prop[5] , prop[-6])
print(prop[6] , prop[-7])

# 找出字符串里的第三个字符是什么？
prop_3 = prop[2]
print(prop_3)

运行结果：

小 生
明 学
是 好
三 三
好 是
学 明
生 小
是

字符串切片操作

切片是指截取其中的一部分字符

基本语法：字符串[start : end : step]

start 截取开始位置编号

end 截取结束位置编号

step 步长，默认为1，即截取范围内字符挨个获取字符，如果是2，则表示间隔一个字符获取

可以通过运行实际代码，对比理解step步长的意义

prop = '小明是三好学生'
print(prop[1 : 5 : 1]) # 截取对应的字符编号应该是1、2、3、4，不含5
print(prop[1 : 5 : 2]) # 截取对应的字符编号应该是1、3，不含5，隔一个字符取值

运行结果：

明是三好
明三

• 切片操作时截取的字符不包含结束位置对应字符
• 如果输入的是整数型，则会报错

# 这是错误的示范：
prop = 123456789
print(prop[1 : 5 : 1])
print(prop[1 : 5 : 2])

Traceback (most recent call last):
#   File "d:\python\test.py", line 63, in 
#     print(prop[1 : 5 : 1])
# TypeError: 'int' object is not subscriptable

# 下边是正确的示范：
prop = '123456789'
print(prop[1 : 5 : 1])
print(prop[1 : 5 : 2])

print(type(prop))

• 切片的省略形式

prop = 123456789
# 省略开始和结束值,取值为从0开始，取到最后
print(prop[:])

# 省略所有值，取值为从0开始，取到最后，步长默认为1
print(prop[::])

# 省略结束值，取值从2开始，取到最后
print(prop[2:])

# 省略开始值，取值从0开始，取到结束值前一位
print(prop[:4])

# 步长值为负数，[::-1]表示从字符串末尾开始，以步长为-1（逆序）截取整个字符串
print(prop[::-1])

运行结果：

123456789
123456789
3456789
1234

987654321

• 步长的正负在切片取值时还是比较关键的，正值时从左向右取值，开始位置编码必须小于终止位置编码，否则取值为空。步长为负值时，其实就是一切都要反着来，由右向左取值，开始位置编码要大于终止位置编码，否则为空值。

还有几个步长为负数的例子，大家参考：

prop = 123456789
prop_str = str(prop)
print(prop_str[-1:-5])  # 输出 空  步长默认1

prop = 123456789
prop_str = str(prop)
print(prop_str[-5:-1])  #输出 5678

prop = 123456789 
prop_str = str(prop) 
print(prop_str[-1:-5:-1]) # 输出 9876

prop = 123456789 
prop_str = str(prop) 
print(prop_str[-5:-9:-1]) # 输出 5432

一个简单的应用

写一个小程序：对任意一个输入的三位数，分别取出这个三位数的个、十、百位上的数字，然后计算它们的和，那么

其实可以利用input()输入均为字符型数据，通过字符串索引提前各个位置的字符，然后通过把str数据转换成int类型，简单实现，代码如下：

#输入一个三位数
numbr = input('请输入一个三位数字：')
# 分别提每一位上的字符，并并转换为int型数据
one_place = int(numbr[2])
ten_place = int(numbr[1])
hundreds_place = int(numbr[0])
# 计算它们的和
sum = one_place + ten_place + hundreds_place

print(sum)

运行结果：

请输入一个三位数字：371
11

操作字符串的内置函数介绍

python内建的class str函数数量比较多，可以帮助我们完成字符串的大小写转换，统计，查找字符串内字符等若干操作。

包含有带__ 的，比如 __add__，__format__等可自定义特殊方法类函数

也有不带__的内置函数，基本用法：“字符串”.capitalize()，一般都是返回self。

例如：

print("abcd".copitalize())  #输出 Abcd，即首字母大写

S = "AAAaaa123"
print(S.casefold())  #输出 aaaaaa123，即大写变小写

# 数量较多，不一一举例

查看str内置函数帮助

help(str)

以下是部分截取内容，仅供参考：

Help on class str in module builtins:

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).

..................................
 |  capitalize(self, /)
 |      Return a capitalized version of the string.
 |
 |      More specifically, make the first character have upper case and the rest lower    
 |      case.
 |
 |  casefold(self, /)
 |      Return a version of the string suitable for caseless comparisons.
 |
 |  center(self, width, fillchar=' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
.......................................

如果你只想获取其中某一个函数的帮助和功能介绍：

help(str.capitalize)

# 结果为：
Help on method_descriptor:

capitalize(self, /)
    Return a capitalized version of the string.

    More specifically, make the first character have upper case and the rest lower        
    case.

真正开始用的时候发现，帮助描述挺简单一个东西，其实内涵挺多的，比如上文里主要学习的.format方法格式化字符的内容，道道那是真心多啊！完全记住是不可能的，但是怎么去看这个一定要知道，比如下边这段关于format()的描述：

Help on method_descriptor:

format(...)  # 函数的名称
    S.format(*args, **kwargs) -> str  #这里的->代表执行后的结果是str，也就是一个字符串。
	# 小括号里的*args, **kwargs,分别表示可用参数：
	# *args:代表可以传入任意数量的参数，会以list的形式传给函数
	# **kwargs:表示传入的参数是键值key = value形式的，以dict的形式传给函数
	# 两个一起表示，可以以任意方式给函数传参
    Return a formatted version of S, using substitutions from args and kwargs.
    The substitutions are identified by braces ('{' and '}').
    # 大概意思就是使用从args和kwargs传入的值替换字符串S中的{}，{}类似一个占位符号，具体可看本文format格式化字符串内容。

dir(str)
此函数返回可用的字符串内置函数列表

一个Python中的magic method：

关于__ format __ 的一个示例，可以先以此例初步了解help中出现的一些有带“__”的函数或者方法的作用：

# 定义了一个名为 Person 的类。它有两个属性：name 和 age。
class Person:
# 在定义类时，会自动调用__init__方法。这里定义主要是为了初始化定义的变量name和age
    def __init__(self, name, age): 
        self.name = name
        self.age = age

# 它还有一个 __str__ 方法，用于返回一个格式化的字符串，表示这个人的姓名和年龄。   
    def __str__(self):
        return f"{self.name} is {self.age} years old."

# 此外，它还有一个 __format__ 方法。
# 这个方法接受一个 format_spec 参数，它决定了如何格式化这个人的信息。
# 在这个方法中，我们检查 format_spec 参数的值。
# 如果它是 "s"，我们返回 str(self)，这将调用 __str__ 方法并返回它的结果。
# 如果它是 "r"，我们返回一个反转了名字的字符串。
# 如果它是 "a"，我们返回一个包含这个人的年代的字符串（比如 "30s"）。

    def __format__(self, format_spec):
        if format_spec == "s":
            return str(self)   
        elif format_spec == "r":
            return f"{self.name[::-1]} is {self.age} years old."
        elif format_spec == "a":
            return f"{self.name} is {self.age} years old. ({self.age // 10}0s)"
        else:
            raise ValueError("Invalid format specifier")


# 现在创建一个 Person 对象并使用不同的格式化选项将它格式化：
p = Person("Alice", 27)

print(format(p, "s"))  # 输出：Alice is 27 years old.
print(format(p, "r"))  # 输出：ecilA is 27 years old.
print(format(p, "a"))  # 输出：Alice is 27 years old. (20s)
print(format(p, "b"))  # 输出：ValueError: Invalid format specifier