Python字符串基础知识_y.isnumeric()-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_73599738/article/details/128592339

知识框架及索引：

下面我将把字符串的基础知识整合成知识框架，然后对应到在代码中的行位，便于寻找阅读复习。

字符串本质——line1

capitalize()——line5

casefold()，title()，swapcase()，upper()，lower()——line10

center()，rjust()，zfill()，ljust()——line20

center()的第二个参数——line31

count()，find()，rfind()——line33

expandtabs()——line45

replace()——line53

maketrans()，translate()——line56

startswith()，endswith()——line63

istitle()，isupper()，isalpha()——line76

isspace()——line83

isprintable()——line89

isdecimal()，isdigit()，isnumeric()，isalnum()——line98

isidentifier()，iskeyword()——line127

无参数lstrip()，rstrip()，strip()——line134

带参数lstrip()，rstrip()，strip()，以及removeprefix()，removesuffix()，partition()，rpartition()——line141

splitlines()——line154

join()——line172

format()以及格式化字符串——line183

引言：

前面总结过列表的基础语法知识，这次将总结学到的字符串基础语法知识，如有缺漏，十分愿意大家提出补充~这次依然是代码+注释的笔记形式。

x = '12321'
"是回文数" if x == x[::-1] else "不是回文数"
#*  字符串是序列，可以被切片
#!  切片是可以切片，但是不能切片后进行内容的修改，因为字符串是不变序列
y = "i love study"
print(y.capitalize())
print(y)
#!  由于字符串是不可变的，capitalize()用在字符串后面相当于生成一个新的字符串
#TODO   capitalize()函数可以将字符串首个字符变成大写，其他所有字符都变成小写
print(y.casefold())
print(y.title())
print(y.swapcase())
print(y.upper())
print(y.lower())
#TODO   casefold()函数可以将所有的字符都变成小写，英文，德语等等外语都通用
#TODO   title()函数可以将字符串的每个英文单词的第一个字符大写，英文单词的其他字符变成小写
#TODO   swapcase()函数可以将字符串的字符大小写翻转
#TODO   upper()函数可以将字符串所有字符大写
#TODO   lower()函数只能将英文单词全部变成小写，比casefold()函数局限
m = "有内鬼停止交易"
print(m.center(5))
print(m.center(15))
print(m.rjust(15))
print(m.ljust(15))
print(m.zfill(15))
#TODO   center()函数用于字符串的居中处理，rjust()函数用于居右处理，
#TODO   ljust()函数用于居左处理，zfill()函数可以将字符串居右，同时左边用0填充
#TODO   这些函数的参数指定了字符串宽度，如果参数小于字符串长度，
#TODO   那么直接输出原字符串，如果参数大于字符串长度，那么就可以正常执行函数的操作
#TODO   其实这些函数还要第二个参数，可以将字符串填充第二个参数指定的内容
print(m.center(15,'桀'))

r = "上海自来水来自上海"
print(x.count("海"))
print(x.count("海",0,5))
print(x.find("海"))
print(x.rfind("海"))
print(x.find("龟"))
#*  print(x.index("龟"))找不到龟，index函数会报错,同样的，rindex()函数也如此
#TODO   count()函数用在列表里面是找数的个数，用在字符串里面就是找对应字符的个数
#TODO   由于字符串也是序列，因此count()函数可以指定起始下标和中止下标，在这个闭区间内搜索字符
#TODO   find()函数从左到右寻找字符第一次出现的下标，对应的rfind()函数则是从右往左搜索
#TODO   如果find()和rfind()函数找不到指定字符，则会返回-1

code = '''
        print("I love study")
    print("I love my wife")
'''
new_code = code.expandtabs(4)
print(new_code)
#TODO   expandtabs()参数是指一个table换成几个空格

message = "在吗！我在你家楼下！快点下来！！"
print(message.replace("在吗","想你了"))
#TODO   replace()函数有两个参数，函数作用是将字符串第一个参数的内容换成第二个参数的内容
table = str.maketrans("ABCDEFG", "1234567")
print("I love STUDY".translate(table))
#TODO   str.maketrans()函数生成一个规则字符串，这个字符串的生成由三个参数决定，
#TODO   前两个参数都是字符串，两个字符串的字符一一对应，意义是第一个字符串的每个字符都会被第二个字符串一一替换
#TODO   第三个参数是需要删除的子字符串内容，上面table作为规则字符串，又被当作translate()函数的参数
#TODO   那么I love FishC的内容就会遵循规则而被修改

x = "我爱Python"
print("x开头是我:",x.startswith("我"))
print("x末尾是python:",x.endswith("Python"))
print("x末尾是Py:",x.endswith("Py"))
print("从第一个下标开始，开头是我:",x.startswith("我",1))
print("从第一个下标开始，开头是爱:",x.startswith("爱",1))
print("从下标0到下标2，末尾是Py:",x.endswith("Py",0,3))
x = "他爱Python"
if x.startswith(("你","我","他")):
    print("总有人喜欢Python")
#TODO   startswith()与endswith()函数判断字符串开头或结尾是否是指定的字符串，他们有第二个参数，第二个参数告诉了函数要从字符串的哪个下标开始判断，默认无则从下标0开始判断
#TODO   第一个参数还可以是一个元组，这时，startswith()与endswith()函数将按照元组中的内容进行判断，只要存在元组里的一个元素，就会True
    
x = "I love Python"
print("x的单词开头都大写:",x.istitle())
print("x全都大写:",x.isupper())
print("x全变成大写，经过大写的检验:",x.upper().isupper())
print('x全部都是字母:',x.isalpha())
#TODO   istitle(),isupper(),isalpha()函数返回True或False

x = " "
y = "   "
z = "   \n"
print('x,y,z全是空白:',x.isspace(),y.isspace(),z.isspace())
#*  isspace()函数判断字符串是否为空白，返回True或False

x = "I love study"
y = "   \n"
z = "I love study\n"
print('x可以打印:',x.isprintable())
print('y可以打印:',y.isprintable())
print('z可以打印:',z.isprintable())
#!  转义字符是不能被直接打印的
#TODO    isprintable()函数可以判断字符串是否可以被打印

z = "12345"
print('z全是阿拉伯数字:',z.isdecimal())
print('z是数字的形式:',z.isdigit())
print('z的本质是数字:',z.isnumeric())
x = "2²"
print('x全是阿拉伯数字:',x.isdecimal())
print('x是数字的形式:',x.isdigit())
print('x的本质是数字:',x.isnumeric())
y = "Ⅰ Ⅱ Ⅲ Ⅳ Ⅴ Ⅵ Ⅶ Ⅷ ⅨⅩ"
print('y全是阿拉伯数字:',y.isdecimal())
print('y是数字的形式:',y.isdigit())
print('y的本质是数字:',y.isnumeric())
z = "一二三四五"
print('z全是阿拉伯数字:',z.isdecimal())
print('z是数字的形式:',z.isdigit())
print('z的本质是数字:',z.isnumeric())
x = "壹贰叁肆伍陆柒捌玖"
print('x全是阿拉伯数字:',x.isdecimal())
print('x是数字的形式:',x.isdigit())
print('x的本质是数字:',x.isnumeric())
y = "one two three four five"
print('y全是阿拉伯数字:',y.isdecimal())
print('y是数字的形式:',y.isdigit())
print('y的本质是数字:',y.isnumeric())

print(z.isalnum())
#*  isalnum()函数是isdigit(),isalpha(),isnumeric(),isdecimal()函数的集大成者，
#*  四个中只要有一个返回true，那么isalnum()就会返回true

x = "I am a good guy"
print("x是合法的标识符:",x.isidentifier())
import keyword
keyword.iskeyword("if")
keyword.iskeyword("Py")
#TODO   iskeyword()用来判断字符串是否为保留字

x = "       左侧不要留白    y"
print(x.lstrip())
x = "   右侧不要留白       "
print(x.rstrip())
x = "   左右都不要留白  "
print(x.strip())

y = "www.ilovefishc.com"
print(y.lstrip("wcom."))
print(y.rstrip("wcom."))
print(y.strip("wcom."))
print(y.removeprefix("www."))
print(y.removesuffix(".com"))
print(y.partition("."))
print(y.rpartition("."))
#TODO   partition()函数从左到右将字符串分隔，参数是分隔位置，返回一个三元组
#TODO   左边元素是分隔符左侧的部分，中间元素是分隔符本身，右边元素是分隔符右侧部分
#*  rpartition()函数与partition函数类似，但是从右边寻找分隔符
#TODO   removesuffix()与removeprefix()函数分别将指定字符串后缀和字符串前缀删除

z = "苟日新, 日日新, 又日新"
print(z.split())
print(z.split(","))
print(z.rsplit(","))
print(z.split(",",1))
print(z.rsplit(",",1))
x = "苟日新\n日日新\n又日新\n"
print(x.splitlines())
print(x.splitlines(True))
#TODO   split()函数从左到右将字符串切割，有两个参数，第一个参数是指定切割的字符，
#TODO   第二个参数是指定切割的次数，通常，如果默认没有第二个参数，则进行全部切割，
#TODO   rsplit()函数从右到左将字符串切割
#TODO   rsplit()函数与split()函数返回切割之后的列表
#TODO   splitlines()函数则是按行切割，有一个参数，参数未设置时默认为False，则进行正常的按行切割，返回切割之后的列表
#TODO   如果参数为True，则将字符串中的换行符保留，加入至其位置的上一个切割元素里面，依然进行按行切割，返回列表
#*  通常我们对字符串进行拼接使用的是加法，然而加法并不在拼接的字符串之间添加新的元素，
#*  我们使用join()函数进行字符串拼接

x = ".".join(["www", "ilovefishc","com"])
print(x)
y = "·".join(("Fish","C"))
print(y)
#TODO   join()函数将指定的字符串加入到几个字符串之间，只有一个参数，参数是一个列表或元组，
#TODO   列表内是若干个字符串，所指定的字符串就将加入到这几个字符串之间，
#!  在大数据处理中，join()函数要比加法效率更高
y = "".join(["Fish","C"])
print(y)
#!  当没有指定的字符串时，作用与加法一致

message = "我在{}年加入csdn"
year = 2022
print(message.format(year))
message = "1+2={},2的平方是{}，3的立方是{}"
print(message.format(1+2,2*2,3*3*3))
message = "{}一学习就{}"
print(message.format("我","开心"))
#TODO   在字符串中使用{}可以进行格式化，用format函数可以将指定的信息填充到字符串的{}里面

message = "{0}{0}{1}{1}"
print(message.format("是","非"))
#TODO   format函数的参数是我们填充的东西，默认情况下他们各自有着数字下标，第一个参数下标是0，第二个参数下标是1，以此类推

message = "我是{name}，我爱{fav}"
print(message.format(name="a good guy",fav="Python"))
#TODO   我们还可以将参数指定为某个下标，如将"a good guy"指定为name下标

message = "我是{name},我爱{0},喜爱{0}的人,运气都不会太差"
print(message.format("Python",name="a good guy"))
#TODO   当然，数字下标和指定的下标可以混合使用，但是不能起冲突，一个参数不能有两个下标
#TODO   即"a good guy"不能同时有1和name两个下标

message = "{}{}{}{}"
print(message.format("一","只","波奇酱","{}"))
#TODO   参数可以是大括号，此时输出大括号

message = 250
print('{:^}'.format(message))
print('{:^10}'.format(message))
message2 = 520
print('{1:>10}{0:<10}'.format(message2,message))
print('{left:>10}{right:<10}'.format(right=message2,left=message))
print('{:010}'.format(message))
print('{:010}'.format(-message))    #*  这个负号会占据10格中的一格
#*  大括号内可以进行格式化
#!  print('{:010}'.format("我爱学习"))是不被允许的，因为输出前导0只对数字有效
#TODO   {1:>10}语法框架抽象为:{(位置索引——即下标):(填充内容)(对齐方向)(显示宽度)}
#*  ^是居中对齐，>是右对齐，<是左对齐，当然也可以没有对齐方向

print('{1:%>10}{0:￥<10}'.format(message,message2))
print('{:0=10}{:0=10}'.format(message,message2))    #*  和{:010}没区别
#TODO   可以在对齐方向左边指定填充字符串空白的内容，可以是0，那么在字符串空白区域填充0，
#TODO   如果是%，那么就填充%，#就填充#,$就填充$,￥就填充￥

x = '{:+} {:-}'
print(x.format(-520,250))
#TODO   +遇到正数才输出前导+，-遇到负数才输出前导-，其他情况不输出前导+与-

x1 = "{:,}".format(1234)
x2 = "{:_}".format(1234)
x3 = "{:_}".format(123)
x4 = "{:,}".format(123456789)
print(x1,x2,x3,x4)
#TODO   ,与_将数字表示出千分位

print("{:.2f}".format(3.1415))
print("{:.2g}".format(3.1415))
print("{:.2}".format("I love Study"))
#!  print("{:.2}".format(520))是不被允许的,因为这种方法只适用于当参数是字符串的情况

print("{:b}".format(80))
#TODO   输出二进制
print("{:#b}".format(80))
#TODO   输出带b前缀的二进制
print("{:c}".format(80))
#TODO   输出字符
print("{:d}".format(80))
#TODO   输出十进制整数
print("{:o}".format(80))
#TODO   输出八进制数
print("{:#o}".format(80))
#TODO   输出带o前缀的八进制
print("{:x}".format(80))
#TODO   输出十六进制
print("{:#x}".format(80))
#TODO   输出带x前缀的十六进制
print("{:e}".format(3.1415))
print("{:E}".format(3.1415))
#TODO   以科学表示法的形式输出
print("{:f}".format(3.1415))
print("{:g}".format(123456789))
print("{:g}".format(1234.56789))

print("{:%}.".format(0.98))
#TODO   将内容乘100，然后末尾带上%输出
print("{:.2%}".format(0.98))
#TODO   还可以指定输出小数点
print("{:.{prec}f}".format(3.1415, prec=2))

希望我的笔记可以帮助到你，祝你学习快乐~