python 字符串及字符串常用方法

简单介绍

字符串和元祖一样，是一个不可变序列

判断一个字符串是不是回文串

# 判断一个字符串是不是回文数
x = "12321"
res = "是回文数" if x == x[::-1] else "不是回文数"
print(res)

字符串函数——大小写字符转换

"""
大小写字母的转换函数
capitalize() ：返回字符串首字母大写，其他字母小写的新字符串
casefold() ：返回一个字符串全部小写的新字符串，除了英文字母，还能处理其他语言的字符
title() ：将字符串中的每个单词首字母大写，其他字母小写，以空格区分单词
swapcase() ：将字符串中的大小写转换，即原来大写的字符变小写，原来小写的字符变大写
upper() ：将所有的字符变为大写
lower() ：将所有的字符变为小写，只能处理英文字母
"""
string = "aPPle hello"
print(string.capitalize())
print(string.casefold())
print(string.title())
print(string.swapcase())
print(string.upper())
print(string.lower())

字符串函数——左中右对齐函数

"""
字符串左中右对齐函数
center(width, fillchar=' ') ：在字符串两侧填充字符 fillchar ，默认为空格
ljust(width, fillchar=' ') ：在字符串左侧填充字符 fillchar ，默认为空格
rjust(width,fillchar=' ') ：在字符串右侧填充字符 fillchar ，默认为空格
zfill(width) ：在字符串左侧填充 0
width ：该参数指定字符串的宽度，若指定的宽度小于等于源字符串，则直接源字符串输出
fillchar 填充的字符，默认为空格
"""
string = "hello python"
print(string.center(12,"A"))
print(string.ljust(20,"0"))
print(string.rjust(15,"B"))
print(string.zfill(16))

字符串函数——字符串查找

"""
字符串查找
count(sub [,start [,end]]) ：查找 sub 参数指定的子字符串在源字符串中出现的次数
find(sub [,start [,end]]) ：用于定位 sub 参数指定的子字符串在字符串中的索引下标值，从左往右找
rfind(sub [,start [,end]]) ：用于定位 sub 参数指定的子字符串在字符串中的索引下标值，从右往左找
index 和 rindex 的用法和 find、rfind 很类似，
区别是找不到 sub 时 index 和 rindex 报错，而 find 和 rfind 返回 -1
index(sub [,start [,end]]) 
rindex(sub [,start [,end]])
"""
string = "上海自来水来自海上"
print("count ", string.count("海"))
print("find ", string.find("海"))
print("rfind ", string.rfind("海"))
print("index ", string.index("海"))
print("rindex ", string.rindex("海"))

字符串函数——字符串替换

"""
字符串替换
expandtabs([tabsize=8]) ：
    使用空格来替换制表符（\t），并返回一个新字符串
    tabsize=8 表示替换的空格数量，默认为8
replace(old,new,count=-1) ：
    返回一个用 new 参数替换所有 old 的参数的新字符串
    count 指定的是替换的次数，默认为-1，表示如果不指定count则全部替换
translate(table) :
    返回一个根据 table 参数指定的规则转换后的新字符串
    table 用于指定一个转换规则的表格，通过 str.maketrans(x[,y[,z]]) 方法获取 table
"""
string = """
    hello
 python"""
new_str = string.expandtabs(1)
print(new_str)

string = "hello biu dong"
print(string.replace('l', 'A'))

# 获取 table ，规则就是将 "ABC" 转换为 "123"，切割掉第三个参数的字符串
table = string.maketrans("ABC", "123", "ef")
print("AdhbsdC efds".translate(table))

字符串函数——字符串判断

"""
字符串判断
以下函数都返回布尔值
startswith(prefix[,start[,end]]) ：
    用于判断参数指定的子字符串是否在字符串的起始位置
    startswith() 参数可以接收一个元组，这样可以把多个子字符串放在元组中
    此时如果字符串起始位置出现了元组中的任一字符串，就返回True
endswith(suffix[,start[,end]]) ：
    用于判断参数指定的子字符串是否在字符串的结束位置
    endswith() 参数可以接收一个元组，这样可以把多个子字符串放在元组中
    此时如果字符串结束位置出现了元组中的任一字符串，就返回True
isupper() ：
    判断一个字符串中所有字母是否都是大写形式
islower() ：
    判断一个字符串中所有字母是否都是小写形式
istitle() ：
    判断一个字符串中所有单词是否是大写开头，其他字母小写形式
isalpha() ：
    判断一个字符串中是否是只有字母构成
isascii() ：
    如果字符串为空或字符串中的所有字符都是 ASCII,则 isascii() 方法返回 True,否则返回 False
isspace() ：
    判断一个字符串是否是空白字符串(空格、Tab、换行符)
isprintable() ：
    判断一个字符串中是否所有字符都是可打印的(转义字符是不可打印的，如\t、\n)
isalnum() ：
    是一个集成方法
    只要 isalpha() isdecimal() isdigit() isnumeric() 这些方法中有一个返回 True
    那么 isalnum() 方法就返回 True
isidentifier() ：
    判断一个字符串是否是 python 合法的标识符
# 以下三个是判断字符串是否是数字字符串，具体看示例
isdecimal()
isdigit()
isnumeric()
"""

string = "I love python"
print(string.startswith("I "))
print(string.endswith("python"))
# startswith() 参数可以接收一个元组，这样可以把多个子字符串放在元组中
# 此时如果字符串起始位置出现了元组中的任一字符串，就返回True
# endswith() 同理
string = "他爱 python"
print(string.startswith(("你", "我", "他")))
print(string.endswith(("你", "python", "他")))

string = "I Love Python"
print(string.istitle())


print(string.isalpha())  # False 字符串中还有空格

string = " "
print(string.isspace())

string = "1234"
print(string.isdecimal()) # True
print(string.isdigit()) # True
print(string.isnumeric()) # True
string = "2²" # 2的2次方
print(string.isdecimal()) # False
print(string.isdigit()) # True
print(string.isnumeric()) # True
string = "ⅠⅡⅢⅣ" # 罗马数字
print(string.isdecimal()) # False
print(string.isdigit()) # False
print(string.isnumeric()) # True
string = "一二三四五" # 中文数字
print(string.isdecimal()) # False
print(string.isdigit()) # False
print(string.isnumeric()) # True


print("I love python".isidentifier())
# 判断一个字符换是否是 python 的关键字
# 使用 keyword 模块中的 iskeyword() 函数
import keyword
print(keyword.iskeyword("if")) # True

字符串函数——字符串截取

"""
字符串截取
strip(chars = None) ：
    去掉字符串两侧的空白
    chars 参数：去掉字符串两侧的包含在 chars 参数里的字符
lstrip(chars = None) ：
    去掉字符串左侧的空白
    chars 参数：去掉字符串左侧的包含在 chars 参数里的字符
rstrip(chars = None) ：
    去掉字符串右侧的空白
    chars 参数：去掉字符串右侧的包含在 chars 参数里的字符
removeprefix(prefix) ：
    删除字符串里指定的参数的前缀，即如果字符串开头包含 prefix 子串，则去掉该子串
removesuffix(suffix) ：
    删除字符串里指定参数的后缀，即如果字符串结尾包含 suffix 子串，则去掉该子串
"""
print("   去掉字符串两侧空白   ".strip())
print("   去掉字符串左侧空白   ".lstrip())
print("   去掉字符串右侧空白   ".rstrip())
# 指定 chars 参数
print("去掉字符串两侧空白".strip("你好去哪里掉有空吗白")) # 字符串两侧
# print("开头字符串结尾".removeprefix("开头"))
# print("开头字符串结尾".removesuffix("结尾"))

字符串函数——字符串拆分和拼接

"""
字符串拆分和拼接
将字符串以参数 sep 指定的分隔符进行分割，将切割后的结果返回一个三元组
会将字符串分割成两部分，即分隔符左侧的内容和分隔符右侧的内容
返回形式： (分隔符左侧内容,分隔符,分隔符右侧内容)
partition(sep) ：从左往右找分隔符，找到后将字符串分割为两部分
rpartition(sep) ：从右往左找分隔符，找到后将字符串分割为两部分

split(sep=None,maxsplit=-1) ：
rsplit(sep=None,maxsplit=-1) ：
    sep :指定分隔符，不指定默认为空格
    maxsplit ：想要分割的次数，默认为-1，即只要遇到分隔符就会进行分割
    该方法会将字符串按每一个分隔符分割成一部分
    返回一个列表
    split 和 rsplit 的区别是找分隔符的方向不同，split 是从左往右， rsplit是从右往左

splitlines(keepends = False) ：
    keepends ：指定结果是否包含换行符，True 表示包含， False 不包含
    将字符串按行进行分割，并将结果以列表的形式返回
    应用场景：需要将字符串按行进行分割时，因为不同的操作系统下换行符不一样，所以使用 split 不太容易实现
    
字符串拼接 join(iterable) ：
    
"""
string = "I love python"
print(string.partition(" ")) # ('I', ' ', 'love python')
print(string.split(" ")) # ['I', 'love', 'python']
print(string.split(" ", 1)) # ['I', 'love python']

# "." 作为分隔符使用， join 方法中传入一个可迭代对象
print(".".join(["www","baidu","com"])) # www.baidu.com
# 使用 join 进行字符串拼接，join 方法相比加号拼接，在数据量很大的时候，join的效率会更高
print("".join(("a","a","a")))

字符串函数——字符串格式化

"""
字符串格式化
[[fill]align] [sign] [#] [0] [width] [grouping_option] [.precision] [tyoe]
fill : <any character>
    要填充的字符，可以任意指定
align : "<" | ">" | "=" | "^"
    指定对齐方式
    < ：强制字符串在可用空间（指定长度和字符串本身长度之间的差值，为正表示有可用空间）内左对齐（默认）
    > : 强制字符串在可用空间内右对齐
    = ：强制将填充放置在符号（如果有）之后但在数字之前的位置
    ^ ：强制字符串在可用空间内剧中
sign : "+" | "-" | " "
    符号选项，仅对数字类型有效
# ：
    参数以二进制、八进制或十六进制在字符串中输出时，会自动追加一个前缀标明进制，如 0b1010 表示二进制
width : digit+
    指定字符串的长度，即可用空间
grouping_option : "_" | ","
    千分位分割符
.precision : digit+
    精度选项
    小数点跟着数字，表示保留多少位小数
    对于[type]设置为 f 或 F 的浮点数来说，是限定小数点后显示多少位
    对于设置为 g 或 G 的浮点数来说，是限定小数点前后一共显示多少位
    对于非数字类型来说，限定是最大字段的大小
    对于整数类型来说，则不允许使用 [.precesion] 选项
type : "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" |  "x" | "X" | "%"
    决定了数据的呈现方式
    b ：将参数以二进制的形式输出
    c ：将参数以 Unicode 字符的形式输出
    d ：将参数以十进制的形式输出
    o ：将参数以八进制的形式输出
    x ：将参数以十六进制的形式输出
    X ：将参数以十六进制的形式输出
    n ：跟 d 类似，不同之处在于它会使用当前语言环境设置的分隔符插入到合适的位置
    None ：跟 d 一样
    以上这几个适用于整数
    
    适用于浮点数或负数的为以下几个：
    e :将参数以科学记数法的形式输出（以字母 e 来标示指数，默认精度为 6）
    E :将参数以科学记数法的形式输出（以字母 E 来标示指数，默认精度为 6）
    f :将参数以定点表示法的形式输出（“不是数” 用 nan 标示，无穷用 inf 标示，默认精度为6）
    F :将参数以定点表示法的形式输出（“不是数” 用 NAN 标示，无穷用 INF 标示，默认精度为6）
    g :通用格式，小数以 f 形式输出，大数以 e 形式输出
    G :通用格式，小数以 F 形式输出，大数以 E 形式输出
    n :跟 g 类似，不同之处在于它会使用当前语言环境设置的分隔符插入到合适的位置
    % :以百分比的形式输出（将数字乘以 100 并显示为定点表示法 f 的形式，后面附带一个百分号
    None :类似于 g ，不同之处在于当使用定点表示法时，小数点后将至少显示一位，默认精度与给定值所需精度一致
"""
name = "小明"
age = 18
print("小明今年 {} 岁".format(age)) # 小明今年 18 岁
# 参数中的字符串会被当作元组的元素来对待
# 所以 name 的索引值为0， age 的索引值为1
print("{}今年 {} 岁".format(name,age)) # 小明今年 18 岁
print("{0}今年 {1} 岁".format(name,age)) # 小明今年 18 岁
print("{1}今年 {0} 岁".format(name,age)) # 18今年 小明 岁
# 索引值可以被引用多次
print("{1}今年 {1} 岁".format(name,age)) # 18今年 18 岁
# 关键字参数，可以不用管参数顺序
print("{name}今年 {age} 岁".format(name=name,age=age)) # 小明今年 18 岁
# 位置索引和关键字参数组合使用，关键字参数要放在位置索引后面，否则报错
print("{name}今年 {0} 岁".format(age,name=name)) # 小明今年 18 岁
# 输出单纯的 {}
print("{}".format("{}")) # 方式一
print("{{}}".format("{}")) # 方式二

# 字符串格式化选项
# {} 里的冒号是必须的，冒号左边是位置或关键字索引，右边是格式化选项
# - 为指定的填充字符， ^ 表示让字符串 250 在指定宽度 10 中居中显示
print("{:-^10}".format(250)) # ---250----
# 1 和 0 为位置索引
# 让 1 位置的字符串在可用空间 10 右对齐并以字符 o 进行填充
# 让 0 位置的字符串在可用空间 9 左对齐并以字符 p 进行填充
print("{1:o>10}{0:p<9}".format(520,250)) # ooooooo250520pppppp

# grouping_option 千分位分割符，可以是逗号或下划线
# format 的参数要是数字，是字符串会奥错
# 如果位数小于等于三位数，千位分割符不显示
print("{:,}".format(23456))
print("{:_}".format(23456))

# 在数字面前显示正负号
# format 参数只能是数字
# 在正数面前使用负号没有效果
# 在负数面前显示正好也没有效果
# 负数默认有负号显示
print("{:+}".format(123)) # +123
print("{:-}".format(123)) # 123
print("{:-}".format(-123)) # -123
print("{:+}".format(-123)) # -123

# 对于[type]设置为 f 或 F 的浮点数来说，是限定小数点后显示多少位
# format 参数要是数字类型，不能是字符串
# 保留小数点后两位
print("{:.2f}".format(3.1415)) # 3.14

# 对于设置为 g 或 G 的浮点数来说，是限定小数点前后一共显示多少位
# 从左边开始计算位数，小数点的左右两边的数字个数加起来等于指定的位数
print("{:.2g}".format(3.1415)) # 3.1
print("{:.3g}".format(30.1415)) # 30.1

# 对于非数字类型来说，限定是最大字段的大小
print("{:.6}".format("I love python")) # I love

# 对于整数类型来说，则不允许使用 [.precesion] 选项
# print("{:.2}".format(123)) # 报错

# 以下适用于整数
# b ：将参数以二进制的形式输出
print("{:b}".format(80)) # 1010000
print("{:#b}".format(80)) # 0b1010000

# c ：将参数以 Unicode 字符的形式输出
print("{:c}".format(80)) # p

# d ：将参数以十进制的形式输出
print("{:d}".format(80)) # 80

# o ：将参数以八进制的形式输出
print("{:o}".format(80)) # 120

# x ：将参数以十六进制的形式输出
print("{:x}".format(80)) # 50

# X ：将参数以十六进制的形式输出
print("{:X}".format(80)) # 50

# n ：跟 d 类似，不同之处在于它会使用当前语言环境设置的分隔符插入到合适的位置
print("{:n}".format(80)) # 80

# None ：跟 d 一样
print("{:}".format(80)) # 80