Python基础：字符串的方法

我就是我 2022-04-10 05:49 248阅读 0赞

Python字符串的方法：  
1、字符串的查找：  
字符串的查找  
count 计数功能，返回自定字符在字符串当中的个数  
find 查找，返回从左第一个指定字符的索引，找不到返回-1  
rfind 查找，返回从右第一个指定字符的索引，找不到返回-1  
index 查找，返回从左第一个指定字符的索引，找不到报错  
rindex 查找，返回从右第一个指定字符的索引，找不到报错

mystr = “hello world python”  
mystr.count(“o”) \#统计o出现的次数  
mystr.find(“world”)\#find从左边指定索引的查找  
mystr.rfind(“world”)\#rfind从右边指定索引的查找 如果查找不到返回-1  
mystr.find(“hello”)  
mystr.find(“python”)\# index和find的查找方式一样  
mystr.index(“world”)  
mystr.rindex(“world”)  
index和find的区别是 find找不到返回-1  
index找不到报错

# s = 'hello world python'
    # ret = s.count('hello')  # 统计字符串的个数
    # print(ret)    #1
    # find() 方法
    # num = s.find('l')
    # print(num)  # 2
    # num1 = s.find('ld')
    # print(num1)   #9
    # num2 = s.find('hhh')
    # print(num2)   # -1
    # rfind() -->从右往左查找,返回的索引是从左往右计算。
    # num3 = s.rfind('o')
    # print(num3)  # 16 
    # index = s.rfind('ld')
    # print(index)   #9
    # index=s.rfind('xxx')
    # print(index) # 找不到，返回-1
    
    # index()方法
    # s = 'hello world python'
    # index = s.index('ll')
    # print(index) # 2
    # index = s.index('o')
    # print(index) # 4
    # index = s.index('z')  
    # print(index)      # 找不到，程序报错，停止运行
    # print('xxxx')      # 找不到，程序报错，停止运行
    
    # rindex() 方法
    
    # s = 'hello world python'
    # # index = s.rindex('o')
    # # print(index)  # 16
    # index = s.rindex('0')
    # print(index) # 报错

2、字符串的拆分  
字符串的分割 partition 把mystr以str分割成三部分,str前，str自身和str后  
字符串的分割 splitlines 按照行分隔，返回一个包含各行作为元素的列表,按照换行符分割  
字符串的分割 split 按照指定的内容进行分割

# partition() 方法
    s = 'hello world python'
    ret = s.partition('world')
    print(ret)  # 返回一个元组的类型。
    （‘hello’，‘world’，‘python’）
    
    # splitlines() 方法 按行分割
    s = 'hello\nworld\npython'
    ret = s.splitlines()  # keepends=False 默认，不显示换行符
    print(ret)
    hello
    world
    python
    ret = s.splitlines(keepends=True)  # 显示换行符
    print(ret)
    ['hello\n', ' world\n', ' python']
    
    # split() 按指定内容进行拆分
    # s = 'hello world python'
    # ret = s.split('o')
    # print(ret) # ['hell', ' w', 'rld pyth', 'n']
    # ret = s.split(" ")  #以空格进行拆分
    # print(ret)   #['hello','world','python']

3、字符串的替换：  
replace 从左到右替换指定的元素，可以指定替换的个数，默认全部替换  
translate 按照对应关系来替换内容 from string import maketrans

# s = 'hello world python'
    # 将所有的o都替换成0，默认是全部替换
    # ret = s.replace('o', '0')
    # print(ret)   #  hell0 w0rld pyth0n
    # 第三个参数，是指定替换的个数。
    # ret = s.replace('o', '0', 2)
    # print(ret)  # hell0 w0rld python
    
    # translate() 方法
    s = 'hello world!'
    # 写对应关系 world! ----> python  必须一一对应，否则输出错误
    intab = 'world!'  # 被替换的内容
    outtab = 'pythop'  # 替换的内容
    ret = str.maketrans(intab, outtab)
     Python maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
    第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
    注：两个字符串的长度必须相同，为一一对应的关系。
    str.maketrans(intab,outtab[,delchars])

· intab – 需要转换的字符组成的字符串。  
· outtab – 转换的目标字符组成的字符串。  
s2 = s.translate(ret)  
print(s2) \# hehhy python  
4、字符串的修饰：  
center 让字符串在指定的长度居中，如果不能居中左短右长，可以指定填充内容，默认以空格填充  
ljust 让字符串在指定的长度左齐，可以指定填充内容，默认以空格填充  
rjust 让字符串在指定的长度右齐，可以指定填充内容，默认以空格填充  
zfill 将字符串填充到指定的长度，不足地方用0从左开始补充  
format 按照顺序，将后面的参数传递给前面的大括号  
strip 默认去除两边的空格，去除内容可以指定  
rstrip 默认去除右边的空格，去除内容可以指定  
lstrip 默认去除左边的空格，去除内容可以指定

str = "我爱北京天安门"
    str.center(50)
    '                     我爱北京天安门                      '
     str.ljust(50)
    '我爱北京天安门                                           '
     str.rjust(50)
    '                                           我爱北京天安门'
    str.zfill(50)
    '0000000000000000000000000000000000000000000我爱北京天安门'
     test = str.center(50)
     test
    '                     我爱北京天安门                      '
     test.rstrip()
    '                     我爱北京天安门'
    test.strip()
    '我爱北京天安门'
    test.lstrip()
    '我爱北京天安门                      '
    python = "{} is {}"
    python.format("hello","world")
    'hello is world'
    
    # center()方法,让内容居中显示，其他地方默认使用空格填充
    # s = 'hello'
    # print(s)
    # ret = s.center(10)
    # print(ret)    #‘  hello   ’
    # ret1 = s.center(12, '*') # 第二个参数表示填充的内容
    # print(ret1) #‘***hello****’
    # ljust，左对齐，剩余空间默认使用空格填充
    # s = 'hello'
    # print(s) #‘hello’
    # ret = s.ljust(10)
    # print(ret) #‘hello     ’
    # ret1 = s.ljust(10, '~')
    # print(ret1)   #'hello~~~~~'
    
    # s = 'hello'
    # # rjust() 右对齐，
    # ret = s.rjust(10)
    # print(ret)#'     hello'
    # ret2 = s.rjust(10, '*')
    # print(ret2) #'*****hello'
    
    # zfill() 方法
    # s = 'hello'
    # ret = s.zfill(10)
    # print(ret)  #'00000hello'
    
    # strip	默认去除两边的空格，去除内容可以指定
    # s = '   hello python   '
    # print(s)
    # ret = s.strip()
    # print(ret)  #'hello world'
    # s1 = '****hello world****'
    # print(s1) #'****hello world****'
    # s2 = s1.strip('*')
    # print(s2) #'hello world'
    
    # rstrip()	默认去除右边的空格，去除内容可以指定
    # s = '   hello     '
    # print(s)  #'helloh'
    # ret = s.rstrip()
    # print(ret)  #'  hello'
    
    # lstrip() 默认去除左边的空格，去除内容可以指定
    s = '   hello     '
    print(s)
    ret = s.lstrip()
    print(ret)  #'hello   '
    
    s1 = '*****hello     '
    print(s1)
    ret = s1.lstrip('*')
    print(ret)#'hello    '

字符串的格式化：  
format()用法:  
相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘\{\}’作为特殊字符代替‘%’

（1）、使用位置参数

name = 'zs'
    # age = 10
    #  msg = '大家好我叫' + name + ',今年年龄' + age
    # 按位置传递参数，必须一一对应
    # # msg = '大家好我叫{},今年年龄{}'.format(name, age)
    #
    # msg = '大家好我叫{0}！我叫{0}！我叫{0}！,今年年龄{1}'.format(name, age)
    # print(msg)

（2） 按关键字传参

# msg = '大家好我叫{name},今年年龄{age}'.format(name='彦成', age=19)
        # msg = '大家好我叫{name},今年年龄{age}'
        # print(msg.format(name='彦成', age=19))
        # print(msg.format(age=19, name='彦成'))

（3）填充与格式化

[填充字符][对齐方式 <^>][宽度]
        # 填充与格式化    （^居中对齐，>右对齐，<左对齐）
        # {:*^10}
        # name = 'zs'
        # age = 10
        # height = 2
        # # msg = '大家好我叫{:@^10},今年年龄{:*<5},升高{:!>5}'
        # # print(msg.format(name, age, height))
        #大家好我叫@@@@zs@@@@，今年年龄10***，身高！！！！2
        # msg = '大家好我叫{:^10}' # 将填充符省略掉，默认用空格填充
        # print(msg.format(name))
           大家好我叫    zs

（4）精度 与进制

# msg = '长方形的长是{:.2f},宽是{:.3f},求面积{:.2f}'
        # chang = 5 / 3
        # kuan = 9 / 8
        # area = chang * kuan
        # print(msg.format(chang, kuan, area))
        长方形的长是1.67,宽是1.125,求面积1.88
        # #  进制 二进制，八进制，十六进制
        # print('二进制{:b}'.format(3))  # 11
        # print('八进制{:o}'.format(10))  # 12
        # print('十六进制:{:x}'.format(15))  # a

（5） 百分号方式 格式化  
格式 描述  
%% 百分号标记  
%c 字符及其ASCII码  
%s 字符串  
%d 有符号整数(十进制)  
%u 无符号整数(十进制)已过时  
*%o 整数(八进制)*  
*%x 整数(十六进制)*  
%X 整数(十六进制大写字符)  
%e 浮点数字(科学计数法)  
%E 浮点数字(科学计数法，用E代替e)  
%f 浮点数字(用小数点符号)  
%g 浮点数字(根据值的大小采用%e或%f)  
%G 浮点数字(类似于%g)  
%p 指针(用十六进制打印值的内存地址)  
%n 存储输出字符的数量放进参数列表的下一个变量中

name = 'zs'
        age = 10
        # msg = '大家好，我叫%s' % name
        # print(msg)
        大家好，我叫zs
        msg = '大家好，我叫%s,今年%d岁了,学习python进度10%%' % (name, age)
        print(msg)
        大家好，我叫zs，今年10岁了，学习Python进度10%
        msg = '长方形的长是%.2f' % 2.126
        print(msg)      长方形的长是2.13
        print('八进制%o,十六进制%x' % (10, 10))
        八进制12,十六进制a

5、字符串的变形  
upper 将字符串当中所有的字母转换为大写  
lower 将字符串当中所有的字母转换为小写  
swapcase 将字符串当中所有的字母大小写互换  
title 将字串符当中的单词首字母大写，单词以非字母划分  
capitalize 只有字符串的首字母大写  
expandtabs 把字符串中的 tab 符号(’\\t’)转为空格，tab 符号(’\\t’)默认的空格数是 8

s = 'hello Python'
        s1 = s.upper() # HELLO PYTHON
        # print(s1)
        s2 = s.lower()   #hello python
        # print(s2)
        # s3 = s.swapcase()
        # print(s3)         #HELLO pYTHON
        # s4 = s.title()
        # print(s4)        #Hello Python
        # s5 = s.capitalize()
        # print(s5)        #Hello python
    
    # s = '\tabc'              
    # s1 = s.expandtabs()     将横向制表符转化为空格，一个\t表示8个空格。   
    # print(s1)           #'        abc'
    # s2 = s1.replace(' ', '@')
    # print(s2)          #'@@@@@@@@abc'
    
    # s = 'abcef\tabc'
    # s3 = s.expandtabs()
    # print(s3)   #'abcef     abc'
    
    # s = 'abcafef\tabc'
    # s3 = s.expandtabs(tabsize=4)         
    # print(s3)      #‘abcafe abc’
    # 空格数= tabsize-前面的字符数
    
    s='hello'
    s2=s.zfill(10)
    print(s2)       '00000hello'

6、字符串的判断：  
isalnum 判断字符串是否完全由字母或数字组成  
isalpha 判断字符串是否完全由字母组成  
isdigit 判断字符串是否完全由数字组成  
isupper 判断字符串当中的字母是否完全是大写  
islower 判断字符串当中的字母是否完全是小写  
istitle 判断字符串是否满足title格式  
isspace 判断字符串是否完全由空格组成  
startswith 判断字符串的开头字符，也可以截取判断  
endswith 判断字符串的结尾字符，也可以截取判断  
split 判断字符串的分隔符切片

# s = 'abc123'
    # ret = s.isalnum()
    # print(ret) # True
    # s = 'abc123'
    # s2 = s.isalpha()
    # print(s2)  # False
    # s = '123'
    # s3 = s.isdigit()
    # print(s3)  # True
    
    # s = 'HELLO'
    # s4 = s.isupper() # True
    # print(s4)
    # s = 'hello'
    # s5 = s.islower()
    # print(s5)     #True
    
    # s = 'Hello'
    # ret = s.istitle()
    # print(ret)  # True
    # s = '    '
    # ret = s.isspace()
    # print(ret)  # True
    s = 'hello world'
    # ret=s.startswith('h')
    # print(ret) # True
    # ret = s.startswith('l', 2, 5) #指定范围截取
    # print(ret) # True，注意包含头不包含尾
    
    # s = 'hello world'
    # ret = s.endswith('ld')
    # print(ret)
    # ret = s.endswith('w', 3, 6)
    # print(ret)  # False
    # ret = s.endswith('w', 3, 7)
    # print(ret)  # True 包含头不包含尾

7、python字符串的编码  
encode是编码,将字符串转换成字节码。str–>byte  
decode是解码 ,将字节码转换成字符串。 byte–>str

现在计算机系统通用的字符编码工作方式：  
在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

# s = '我'
    # ret = s.encode()  # 默认编码表 UTF-8
    # print(ret)
    # s2 = ret.decode()
    # print(s2)
    # 指定编码表
    # ret2 = s.encode(encoding='gbk')
    # print(ret2)
    # s3 = ret2.decode(encoding='gbk')
    # print(s3)
    # 注意使用什么样的编码表编码就需要使用什么样的编码表解码
    s = '我'
    ret = s.encode(encoding='gbk')
    print(ret)
    s2 = ret.decode()  # utf-8
    print(s2)