python 字符串操作和内建函数

傷城~ 2022-10-29 13:24 218阅读 0赞

### 文章目录 ###

*   *  访问字符串值
     *  字符串连接
     *  Python 转义字符
     *  python 字符串运算符
     *  python 字符串格式化
     *  Unicode 字符串
     *  字符串内建函数

## 访问字符串值 ##

var1 = 'Hello World!'
    var2 = "Python Runoob"
    print("var1[0]:", var1[0])
    print("var2[1:5]:", var2[1:5])

## 字符串连接 ##

var1 = 'Hello World!'
    print("输出:", var1[:6] + 'Runoob!')

## Python 转义字符 ##

在需要时使用特殊字符，python 用反斜杠 ‘ \\’ 转义字符

<table> 
 <thead> 
  <tr> 
   <th>转义字符</th> 
   <th>描述</th> 
   <th>转义字符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\(在行尾时)</td> 
   <td>续行符</td> 
   <td>\\</td> 
   <td>反斜杠符号</td> 
  </tr> 
  <tr> 
   <td>\’</td> 
   <td>单引号</td> 
   <td>\"</td> 
   <td>双引号</td> 
  </tr> 
  <tr> 
   <td>\a</td> 
   <td>响铃</td> 
   <td>\b</td> 
   <td>退格(Backspace)</td> 
  </tr> 
  <tr> 
   <td>\e</td> 
   <td>转义</td> 
   <td>\000</td> 
   <td>空</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>换行</td> 
   <td>\v</td> 
   <td>纵向制表符</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>横向制表符</td> 
   <td>\r</td> 
   <td>回车</td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td>换页</td> 
   <td>\oyy</td> 
   <td>八进制数，y 代表 0~7 的字符，例如：\012 代表换行</td> 
  </tr> 
  <tr> 
   <td>\xyy</td> 
   <td>十六进制数，以 \x 开头，yy代表的字符，例如：\x0a代表换行</td> 
   <td>\other</td> 
   <td>其它的字符以普通格式输出</td> 
  </tr> 
 </tbody> 
</table>

## python 字符串运算符 ##

下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”

a = 'Hello'
    b = 'Python'
    print(a+b)          #HelloPython
    print(a*2)          #HelloHello
    print(a[1])         #e
    print(a[1:4])       #ell
    print('H' in a)     #True
    print('M' not in a) #True
    print(r'\n')        #\n
    print("%s %s"%(a,b)) #Hello Python

## python 字符串格式化 ##

%c : 格式化字符及ASCII 码  
%s：格式化字符串  
%d：格式化整数  
%u：格式化无符号整形  
%o：格式化无符号八进制数  
%x：格式化无符号十六进制数  
%X：格式化无符号十六进制数(大写)  
%f： 格式化浮点数，可指定小数后的精度  
%e：科学计数法格式化浮点数  
%p：十六进制格式化变量地址

## Unicode 字符串 ##

Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单

print(u'hello python') # hello python

## 字符串内建函数 ##

> string.capitalize()

把字符串的第一个字符大写，返回一个新的字符串

案例

str ='hello python'
    s = str.capitalize()
    print(s) #Hello python

返回一个原字符串居中，并使用空格填充 width 的新字符串

s2 = str.center(20)
    print(s2)# hello pyhton

> string.encode(encoding=‘UTF-8’, errors=‘strict’)  
> string.decode(encoding=‘UTF-8’, errors=‘strict’)

功能：**encode** 以 encoding 指定的编码格式**编码** string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’

**decode** 以 encoding 指定的编码格式**解码** string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 ‘ignore’ 或 者’replace’

案例1：

u = '中文'
    str1 = u.encode('gb2312')
    print(str1) #b'\xd6\xd0\xce\xc4'
    
    str2 = u.encode('gbk')
    print(str2) #b'\xd6\xd0\xce\xc4'
    
    str3 = u.encode('utf-8')
    print(str3) #b'\xe4\xb8\xad\xe6\x96\x87'
    
    u1 = str1.decode('gb2312')
    print(u1)  #中文
    
    u2 = str2.decode('gbk')
    print(u2) #中文
    
    u3 = str3.decode('utf-8')
    print(u3) #中文

> string.endswith(obj, beg=0, end=len(string))

功能：检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

参数：  
suffix - - - - 该参数可以是一个字符串或者是一个元素  
start - - - - - 字符串中的开始位置  
end - - - - - - 字符中结束位置

返回值：如果字符串含有指定的后缀返回 True，否则返回 False

str = "this is string example....wow!!!"
    suffix = "wow!!!"
    print(str.endswith(suffix))     #True
    print(str.endswith(suffix, 20)) #True
    
    suffix = "is"
    print(str.endswith(suffix, 2, 4))#True
    print(str.endswith(suffix, 2, 6))#False

> string.expandtabs(tabsize=8)

把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8

功能：expandtabs() 方法把字符串中的 tab 符号 \\t 转为空格，tab 符号 \\t 默认的空格数是 8，在第 0、8、16…等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替

> 语法 str.expandtabs(tabsize=8)  
> tabsize - - - - 指定转换字符串中的 tab 符号(’\\t’)转为空格的字符数

返回值：该方法返回字符串中的 tab 符号(’\\t’)转为空格后生成的新字符串

实例

str = "runoob\t12345\tabc"
    print('原始字符串: {}'.format(str))
    # 原始字符串: runoob 12345 abc
    
    # 默认 8 个空格
    # runnob 有 6 个字符，后面的 \t 填充 2 个空格
    # 12345 有 5 个字符，后面的 \t 填充 3 个空格
    print('替换 \\t 符号: {}'.format(str.expandtabs()))
    # 替换 \t 符号: runoob 12345 abc
    
    # 2 个空格
    # runnob 有 6 个字符，刚好是 2 的 3 倍，后面的 \t 填充 2 个空格
    # 12345 有 5 个字符，不是 2 的倍数，后面的 \t 填充 1 个空格
    print('使用 2 个空格替换 \\t 符号: {}'.format(str.expandtabs(2)))
    
    # 3 个空格
    print('使用 3 个空格: {}'.format(str.expandtabs(3)))
    
    # 4 个空格
    print('使用 4 个空格: {}'.format(str.expandtabs(4)))
    
    # 5 个空格
    print('使用 5 个空格: {}'.format(str.expandtabs(5)))
    
    # 6 个空格
    print('使用 6 个空格: {}'.format(str.expandtabs(6)))
    ''' 原始字符串: runoob 12345 abc 替换 \t 符号: runoob 12345 abc 使用 2 个空格替换 \t 符号: runoob 12345 abc 使用 3 个空格: runoob 12345 abc 使用 4 个空格: runoob 12345 abc 使用 5 个空格: runoob 12345 abc '''

> find()方法

Python find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回 -1

语法：str.find(str, beg=0, end=len(string))

参数：  
str – 指定检索的字符串  
beg – 开始索引，默认为0  
end – 结束索引，默认为字符串的长度

返回值：如果包含子字符串返回开始的索引值，否则返回 -1

str1 = "this is string example....wow!!!"
    str2 = "exam"
    
    print(str1.find(str2))     #15
    print(str1.find(str2, 10)) #15
    print(str1.find(str2, 40)) #-1
    
    info = 'abca'
    print(info.find('a'))    # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
    print(info.find('a',1))  # 从下标1开始，查找在字符串里第一个出现的子串：返回结果3
    print(info.find('3'))    # 查找不到返回-1

> format 格式化函数

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能

基本语法是通过 \{\} 和 : 来代替以前的 %

format 函数可以接受不限个参数，位置可以不按顺序。

"{} {}".format("hello", "world")  # 不设置指定位置，按默认顺序
    #'hello world'
    "{0} {1}".format("hello", "world")  # 设置指定位置
    #'hello world'
    "{1} {0} {1}".format("hello", "world")  # 设置指定位置
    #'world hello world'

> index()方法

跟find()方法一样，只不过如果str不在 string中会报一个异常.

str1 = "this is string example....wow!!!"
    str2 = "exam"
    
    print(str1.index(str2))     #15
    print(str1.index(str2, 10)) #15
    print(str1.index(str2, 40)) #抛出异常

> Python isalnum() 方法检测字符串是否由字母和数字组成

无参数

实例：

str = ''
    print(str.isalnum()) #False

如果字符串中有一个不是字母或者数字，则返回 False

> string.isalpha()

如果 string 至少有一个字符并且所有字符都是字母则返回 True

如果有一个不是字母，则返回 False

> string.isdecimal()

返回值如果 string 只包含十进制数字则返回 True 否则返回 False.

功能：isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象

注意:定义一个十进制字符串，只需要在字符串前添加 ‘u’ 前缀即可

参数：无参数

实例

str = u"this2009";  
    print(str.isdecimal()) #False
    
    str = u"23443434";
    print(str.isdecimal()) #True

> isdigit() 方法检测字符串是否只由数字组成

语法：str.isdigit()

参数：无

返回值：如果字符串只包含数字则返回 True 否则返回 False

空字符串返回 False

> string.islower()

如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

> string.isnumeric()

区别

num = "1"  #unicode
    num.isdigit()   # True
    num.isdecimal() # True
    num.isnumeric() # True
    
    num = "1" # 全角
    num.isdigit()   # True
    num.isdecimal() # True
    num.isnumeric() # True
    
    num = b"1" # byte
    num.isdigit()   # True
    num.isdecimal() # AttributeError 'bytes' object has no attribute 'isdecimal'
    num.isnumeric() # AttributeError 'bytes' object has no attribute 'isnumeric'
    
    num = "IV" # 罗马数字
    num.isdigit()   # True
    num.isdecimal() # False
    num.isnumeric() # True
    
    num = "四" # 汉字
    num.isdigit()   # False
    num.isdecimal() # False
    num.isnumeric() # True

> isspace()方法

isspace() 方法检测字符串是否只由空格组成

str = " "; 
    print str.isspace(); #True
    
    str = "This is string example....wow!!!";
    print str.isspace(); #False

> string.istitle()

如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.

str = "This Is String Example...Wow!!!"
    print str.istitle() #True
    
    str = "This is string example....wow!!!"
    print str.istitle() #False

> Python isupper() 方法检测字符串中所有的字母是否都为大写

str = "THIS IS STRING EXAMPLE....WOW!!!"; 
    print str.isupper(); #True
    
    str = "THIS is string example....wow!!!";
    print str.isupper(); #False

> string.join(seq)  
> 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符

# str.join(元组、列表、字典、字符串) 之后生成的只能是字符串。
    # 所以很多地方很多时候生成了元组、列表、字典后，可以用 join() 来转化为字符串。
    
    list=['1','2','3','4','5']
    print(''.join(list))
    # 结果：12345
    
    seq = { 'hello':'nihao','good':2,'boy':3,'doiido':4}
    print('-'.join(seq))        #字典只对键进行连接
    # 结果：hello-good-boy-doiido
    
    
    #实际应用开发时，获取应用的所有进程 ID，
    # 然后杀掉所有进程，可以使用 join 拼接出 kill 命令。
    pids = ['111','22']
    s1 = 'kill %s' % ' '.join(['111','22'])   #kill 111 22
    # 然后使用以下这个杀掉进程
    #subprocess.run('kill %s' % ' '.join(pids), shell=True)
    
    #给定字符串倒序输出
    str_1 = "abcdefgh"
    len1 = len(str_1) - 1
    str_list = []
    while(len1 >= 0):
        str_list.append(str_1[len1])
        len1 = len1 - 1
    
    print(str_list)
    print(''.join(str_list))

> string.ljust(width)  
> 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

如果指定的长度小于原字符串的长度则返回原字符串

str = "this is string example....wow!!!"
    print(str.ljust(50, '0'))

> string.lower()  
> 转换 string 中所有大写字符为小写

返回值：返回一个新的字符串，不会对源字符串进行修改

> lstrip() 方法用于截掉字符串左边的空格或指定字符

str.lstrip(\[chars\]) chars 为指定字符

str = " this is string example....wow!!! "
    print(str.lstrip())
    str = "88888888this is string example....wow!!!8888888"
    print(str.lstrip('8'))

> maketrans()方法

Python maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标

注：两个字符串的长度必须相同，为一一对应的关系。

参数

*  intab - - - - 字符串中要替代的字符组成的字符串。
 *  outtab - - - 相应的映射字符的字符串。

返回值：返回字符串转换后生成的新字符串

#python2.x 需要导入 maketrans
    #from string import maketrans
    
    intab = "aeiou"
    outtab = "12345"
    trantab = str.maketrans(intab, outtab)
    
    str = "this is string example....wow!!!"
    print(str.translate(trantab))

> string.partition(str)  
> 来根据指定的分隔符将字符串进行分割

如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

参数：str 指定的分割符

str = "www.runoob.com"
    print(str.partition("."))
    # ('www', '.', 'runoob.com')

> string.replace(str1, str2, num=string.count(str1))  
> 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

old - - - - 将被替换的子字符串。  
new - - - 新字符串，用于替换old子字符串。  
max - - - 可选字符串, 替换不超过 max 次

返回值：返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的**新字符串**，如果指定第三个参数max，则替换不超过 max 次

str = "this is string example....wow!!! this is really string"
    print(str.replace("is", "was"))
    print(str.replace("is", "was", 3))

> Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

语法：str.split(str="", num=string.count(str))

实例

str = "Line1-abcdef \nLine2-abc \nLine4-abcd"
    print(str.split( ))       # 以空格为分隔符，包含 \n
    print(str.split(' ', 1 )) # 以空格为分隔符，分隔成两个
    #['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
    #['Line1-abcdef', '\nLine2-abc \nLine4-abcd']
    
    txt = "Google#Runoob#Taobao#Facebook"
    # 第二个参数为 1，返回两个参数列表
    x = txt.split("#", -1)
    y = txt.split("#",1)
    print(x)
    print(y)
    #['Google', 'Runoob', 'Taobao', 'Facebook']
    #['Google', 'Runoob#Taobao#Facebook']

网页地址解析

str="http://www.runoob.com/python/att-string-split.html"
    print("0:%s"%str.split("/")[-1])
    print("1:%s"%str.split("/")[-2])
    print("2:%s"%str.split("/")[-3])
    print("4:%s"%str.split("/")[-5])

统计 n 出现的次数

str='ab2b3n5n2n67mm4n2'
    count = len(str.split('n'))-1
    print(count)

通过 join 实现 replace

astr = "hello world ,hhhh world heihei"
    def myreplace (astr,oldstr,newstr):
        result=astr.split(oldstr)
        return newstr.join(result)
    print(myreplace(astr,"world","job"))

> splitlines()方法

splitlines() 按照行(’\\r’, ‘\\r\\n’, \\n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符

语法：str.splitlines(\[keepends\])

keepends – 在输出结果里是否保留换行符(’\\r’, ‘\\r\\n’, \\n’)，默认为 False，不包含换行符，如果为 True，则保留换行符

返回值：返回一个包含各行作为元素的列表

str1 = 'ab c\n\nde fg\rkl\r\n'
    print(str1.splitlines())
     
    str2 = 'ab c\n\nde fg\rkl\r\n'
    print(str2.splitlines(True))

> startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查

语法：str.startswith(str, beg=0,end=len(string))

参数：  
str - - - - - - - 检测的字符串  
strbeg - - - - 可选参数用于设置字符串检测的起始位置  
strend - - - - 可选参数用于设置字符串检测的结束位置

返回值：如果检测到字符串则返回True，否则返回False

实例

str = "this is string example....wow!!!"
    print(str.startswith( 'this' ))     #True
    print(str.startswith( 'is', 2, 4 )) #True
    print(str.startswith( 'this', 2, 4 ))#False

> strip()方法

Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列

注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符

语法：str.strip(\[chars\])

str = "00000003210Runoob01230000000"
    print(str.strip('0'))  # 去除首尾字符 0
    
    str = "123abcrunoob321"
    # 只要首位包含字符中的一个，就会被删除
    print (str.strip( '1233455' ))

实例2：

str2 = '@@@@@iamstring@@@@@'
    print("str2:\'%s\'" %str2) #'@@@@@iamstring@@@@@'
    print("str2.strip('@'):\'%s\'" %str2.strip('@')) #'iamstring'
    print("str2.strip('@@'):\'%s\'" %str2.strip('@@'))#'iamstring'
    print("str2.strip('@@@@@@'):\'%s\'" %str2.strip('@@@@@@'))#'iamstring'
    print("str2.strip('@i'):\'%s\'" %str2.strip('@i'))#'amstring'
    print("str2.strip('@ag'):\'%s\'" %str2.strip('@g'))#'iamstrin'

> string.swapcase() 翻转 string 中的大小写

> string.title()  
> 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

> string.translate(str, del="")  
> 根据 str 给出的表(包含 256 个字符)转换 string 的字符，要过滤掉的字符放到 del 参数中

str.translate（table \[，deletechars\]）

*  table-翻译表，翻译表是通过maketrans方法转换而来
 *  deletechars-字符串中要过滤的字符列表

返回值：返回翻译后的字符串

intab = "aeiou"
    outtab = "12345"
    trantab = str.maketrans(intab, outtab)
    str = "this is string example....wow!!!"
    print(str.translate(trantab)) # th3s 3s str3ng 2x1mpl2....w4w!!!

> string.upper() 转换 string 中的小写字母为大写

> string.zfill(width)  
> 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

实例

str = '123jfa'
    s1 = str.zfill(20)
    print(s1)#00000000000000123jfa