python字符串操作

Posted 2021-03-04 我听过

1、字符串定义：
　　1>一个个字符组成的有序的序列，是字符的集合，是可迭代对象，可索引
　　2>使用单引号、双引号、三引号引住的字符序列，r前缀，f前缀
　　3>字符串是不可变对象
　　4>Python3起，字符串就是Unicode类型

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'hello\'
for i in s1:                      #可迭代
    print(i)
print("索引值为1的元素：",s1[1])    #可索引

执行结果：
h
e
l
l
o
索引值为1的元素： e

s2 = \'hello\\nbeijing\'    #\\n:换行符
print(\'s2:\',s2)
s3 = r\'hello\\nbeijing\'   #r前缀:转义\\n，当字符串输出
print(\'s3:\',s3)
s4 = \'ni\'
s5 = \'hao\'
s6 = "{s4} -> {s5}"
print(\'s6:\',s6)
s7 = f"{s4} -> {s5}"     #f前缀:引用
print(\'s7:\',s7)

执行结果：
s2: hello
beijing
s3: hello\\nbeijing
s6: {s4} -> {s5}
s7: ni -> hao

 

2、join连接字符串：
　　将可迭代对象连接起来，使用string作为分隔符
　　可迭代对象本身元素都是字符串
　　返回一个新的字符串

Signature: str.join(self, iterable, /)
Docstring:
Concatenate any number of strings.

The string whose method is called is inserted in between each given string.
The result is returned as a new string.

Example: \'.\'.join([\'ab\', \'pq\', \'rs\']) -> \'ab.pq.rs\'
Type:      method_descriptor

　　在可交互式python操作（如：jupyter）中可看到，join会立即返回返回一个新的字符串

 

 

 　　在PyCharm中可以使用print()输出

# -*- coding:utf-8 -*-
# version：python3.7

print(\'+\'.join(map(str,range(10))))    #map函数:映射，把一个个数字转换成str
print(\'\\n\'.join(map(str,range(10))))

执行结果：
0+1+2+3+4+5+6+7+8+9
0
1
2
3
4
5
6
7
8
9

 

3、+ → str
将两个字符串连接在一起，返回一个新字符串

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'hello\'
s2 = \'world\'
print(s1 + s2)    #字符串不可变，字符串相加产生新字符串
s3 = s1 + s2
s3 += s2          #等价：s3 = s3 + s2
print(s3)

执行结果：
helloworld
helloworldworld

 

4、字符串分割
　　分割字符串的方法分为2类
　　1>split
　　　　将字符串按照分隔符分割成若干字符串，并返回列表
　　　　rsplit(sep=None,maxsplit=-1) → list of strings
　　　　　　从右向左切割
　　　　　　sep指定分割字符串，缺省的情况下空白字符串作为分隔符
　　　　　　maxsplit指定分割次数，-1表示遍历整个字符串

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'a,b,c,d,e,f\'
print(s1.split())       #默认使用空白字符分割，立即返回一个列表
print(s1.split(\',\'))    #以\',\'分割
print(s1.split(\',\',maxsplit=2))    #指定分割次数2次
print(s1.split(\',\',maxsplit=-1))   #maxsplit=-1，遍历整个字符串，相当于不指定maxsplit
print(s1.rsplit(\',\',maxsplit=2))   #从右向左切

执行结果：
[\'a,b,c,d,e,f\']
[\'a\', \'b\', \'c\', \'d\', \'e\', \'f\']
[\'a\', \'b\', \'c,d,e,f\']
[\'a\', \'b\', \'c\', \'d\', \'e\', \'f\']
[\'a,b,c,d\', \'e\', \'f\']

    splitlines([keepends]) → list of strings
        按行来切割字符串

        keepends指的是是否保留行分割符
        行分割包括\\n、\\r\\n、\\r等

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'I\\n am\\r\\n \\tsuper\\r man\'
print(s1.splitlines())    #以换行符切割
print(s1.splitlines(True))    #保留换行符字符
print(s1.splitlines(False))   #不保留换行符字符，默认就是

执行结果：
[\'I\', \' am\', \' \\tsuper\', \' man\']
[\'I\\n\', \' am\\r\\n\', \' \\tsuper\\r\', \' man\']
[\'I\', \' am\', \' \\tsuper\', \' man\']

2>partition系
    将字符串按照分隔符分割成2段，返回这2段和分隔符的元组
    partition(sep) → (head, sep, tail)
    从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没有找到分隔符，就返回头、2个空元素的三元组
    sep分割字符串，必须指定

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'a,b,c,d,e,f\'
print(s1.partition(\',\'))    #立即返回一个三元组，切一刀 split(maxsplit=1)
print(s1.rpartition(\',\'))   #从右向左切
print(s1.partition(\'c,d\'))  #以\'c,d\'切割
print(s1.split(\'c,d\'))      #split与partition的差别

执行结果：
(\'a\', \',\', \'b,c,d,e,f\')
(\'a,b,c,d,e\', \',\', \'f\')
(\'a,b,\', \'c,d\', \',e,f\')
[\'a,b,\', \',e,f\']

 

5、大小写
　　upper()
　　　　全大写
　　lower()
　　　　全小写
　　大小写，做判断的时候用
　　swapcase()
　　　　交换大小写

# -*- coding:utf-8 -*-
# version：python3.7

print(\'aBcD\' == \'abcd\')    #不相等，返回False
print(\'aBcD\'.lower() == \'abcd\')    #将\'aBcD\'转换为全小写比较
print(\'abCD\'.upper() == \'ABCD\')    #将\'abCD\'转换为全大写比较
print(\'ABcd\'.swapcase())   #将大写转换为小写，将小写转换为大写

执行结果：
False
True
True
abCD

 

6、字符串编排
　　title() → str
    　　标题的每个单词都大写
　　capitalize() → str
    　　首个单词大写
　　center(width[, fillchar]) → str
    　　width打印宽度
    　　fillchar填充的字符
　　zfill(width) → str
    　　width打印宽度，居右，左边用0填充
　　ljust(width[, fllchar]) → str左对齐
　　rjust(width[, fillchar]) → str右对齐
　　中文用的少，了解一下

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'i am super man\'
print(s1.title())       #首字母大写
print(s1.capitalize())  #首单词大写
print(s1.center(30,\'#\'))    #居中
print(s1.zfill(30))         #居右，左边用0填充
print(s1.ljust(30,\'0\'))     #居左
print(s1.rjust(30,\'0\'))     #居右

执行结果：
I Am Super Man
I am super man
########i am super man########
0000000000000000i am super man
i am super man0000000000000000
0000000000000000i am super man

 

7、字符串修改
　　replace(old, new[, count]) → str
　　字符串中找到匹配替换为新子串，返回新字符串
　　count表示替换几次，不指定就是全部替换

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'1 2 2 2 3 3 4 5\'
print(s1.replace(\'2\',\'22\'))
print(s1.replace(\'2\',\'22\',1))

执行结果：
1 22 22 22 3 3 4 5
1 22 2 2 3 3 4 5

　　strip([chars]) → str
　　　　从字符串两端去除指定的字符集chars中的所有字符
　　　　如果chars没有指定，去除两端的空白字符
　　lstrip    从左开始
　　rstrip    从右开始

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'   I am super man    \'
print(s1.strip())    #不指定，默认去除两边的空格
print(s1.strip(\' Iamn\'))     #指定则从指定中匹配

执行结果：
I am super man
super

 

8、字符串查找
　　find(sub[, start[, end]) → int
　　　　在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到返回-1
　　rfind(sub[, start[, end]]) → int
　　　　在指定的区间[start, end)，从右至左，查找子串sub。找到返回索引，没找到返回-1

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'I am super man\'
print(s1.index(\'I\'))    #检索值返回结果，未检索到的话会报错
print(s1.find(\'s\'))     #检索值返回索引，未检索到返回-1
print(s1.find(\'A\'))

执行结果：
0
5
-1

　　count(sub[, start[ end]) → int
　　　　在指定的区间[start, end),从左至右，统计子串sub出现的次数

　　时间复杂度
　　　　index和count方法都是O(n)
　　　　随着列表数据规模的增大，而效率下降
　　len(string)
　　　　返回字符串的长度，即字符的个数

 9、字符串判断
　　endswith(suffix[, start[ end]]) -> bool
　　　　在指定的区间[start, end)，字符串是否是suffix结尾
　　startswith(prefix[, start[ end]) -> bool
    　　   在指定的区间[start, end)，字符串是否是prefix开头

# -*- coding:utf-8 -*-
# version：python3.7

s1 = \'xxx.tar.gz\'
print(s1.endswith(\'.gz\'))          #判断是否以.gz结尾
print(s1.endswith(\'.tar\',0,-3))    #[0,-3) 判断.tar
print(s1.startswith(\'xxx\'))        #判断是否以xxx开头

执行结果：
True
True
True

 

10、字符串判断is系列

isalnum() → bool  是否是字母和数字组成
isalpha()         是否是字母
isdecimal()       是否只包含十进制数字
isdigit()         是否全部数字(0~9)
isidentifier()    是标识符嘛，字母和下划线开头，其他都是字母、数字、下划线
islower()         是否都是小写
isupper()         是否全部大写
isspace()         是否只包含空白字符

# -*- coding:utf-8 -*-
# version：python3.7

a = input(\'>>>\')
if a.isdigit():    #判断是否为数字
    print(\'number\')
else:
    print(\'not number\')

执行结果：
>>>tr
not number

 

11、字符串格式化
　　字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
　　　　join拼接只能使用分隔符，且要求被拼接的是可迭代对象且其元素是字符串
　　　　+拼接字符串还算方便，但是非字符串需要先转换为字符串才能拼接
　　在2.5版本之前，只能使用printf style风格的print输出，2.5版本之后建议使用format函数风格
　　　　1>printf-style formatting，来自于C语言的printf函数
　　　　格式要求：
　　　　　　占位符：使用%和格式字符组成，例如%s、%d（字符串、数字）等
　　　　　　　　s调用str()，r会调用repr()。所有对象都可以被这两个转换。
　　　　　　占位符中还可以插入修饰字符，例如%03d表示打印3个位置，不够前面补零

# C风格：
# -*- coding:utf-8 -*-
# version：python3.7

# -*- coding:utf-8 -*-
# version：python3.7

print("My name is %s,I am %d" % (\'zhang\',20))    #格式：字符模板(格式化字符) % 字符；%s->str %d->digit
print("I am %04d" % 20)    #长度为4，多余位用0补齐
print("I am %-4d" % 20)    #长度为4，"-"负号表示左对齐，默认右对齐
print("%f" % 32.2456)      #%f:浮点数，默认小数点后保留6位
print("%14.2f" % 32.2456)  #长度为14位，精度为2(小数点后保留2位)
print("%x" % 127)          #%x表示十六进制，X表示大写
print("%#X" % 127)         #"#"号表示0X前缀

执行结果：
My name is zhang,I am 20
I am 0020
I am 20  
32.245600
         32.25
7f
0X7F

 

　　　　2>format % values，格式字符串和被格式的值之间使用%分隔
　　　　　　values只能是一个对象，或是一个与格式字符串占位符数目相等的元组，或一个字典

　　　　format函数格式字符串语法——Python鼓励使用
　　　　"{} {xxx}".format(*args, **kwargs) → str
　　　　　　args是可变位置参数，是一一个元组
　　　　　　kwargs是可变关键字参数，是一一个字典
　　　　　　花括号{}表示占位符
　　　　　　{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
　　　　　　{xxx}表示在关键字参数中搜索名称一致的
　　　　　　{{}}表示打印花括号

# -*- coding:utf-8 -*-
# version：python3.7

#不常用，了解即可，通常不定义前面占位符，不写死，一般在位置参数处定义
print("{} {}".format(1,2,3))    #允许后面超位
print("{2[0]} {1} {0}".format(\'a\',\'b\',[\'c\']))    #支持索引，索引和位置对应不能混用，否则会报错
print("{name} {0} {1}".format(\'127.0.0.1\',80,name=\'My server name is super PC\'))

执行结果：
1 2
c b a
My server name is super PC 127.0.0.1 80

# 进制
# -*- coding:utf-8 -*-
# version：python3.7

 print("{:#02x}{:02x}{:02x}{:02x}".format(127,100,10,20)) #02表示宽度为2，不够用0补，用16进制表示ip地址 print("int:{0:d}; hex:{0:x}; oct:{0:o}; bin:{0:b}".format(42))
print("int:{0:d}; hex:{0:#x}; oct:{0:#o}; bin:{0:#b}".format(42))

执行结果：
0x7f640a14
int:42;  hex:2a;  oct:52;  bin:101010
int:42;  hex:0x2a;  oct:0o52;  bin:0b101010

# 对齐
# -*- coding:utf-8 -*-
# version：python3.7

print("{}*{}={:02}".format(2,3,2*3))      #长度为2，默认右对齐，不够用0补
print("{}*{}={:<2}".format(2,3,2*3))      #长度为2，左对齐
print("{}*{}={:#^20}".format(2,3,2*3))    #长度为20，居中，用"#"号填充

执行结果：
2*3=06
2*3=6 
2*3=#########6##########

# 时间格式
# -*- coding:utf-8 -*-
# version：python3.7

import datetime    #模块
d = datetime.datetime.now()
print(d)
print("{:%Y-%m-%d %H:%M:%S}".format(d))    #冒号":"，前面表示位置对应，0省略

执行结果：
2020-03-20 19:03:04.315352
2020-03-20 19:03:04

# 浮点数
# -*- coding:utf-8 -*-
# version：python3.7

print("{}".format(3**0.5))       #1.7320508075688772
print("{:f}".format(3**0.5))     #1.732051   f:浮点数,精度默认为6
print("{:10f}".format(3**0.5))   #右对齐,宽度为10
print("{:3f}".format(3**0.5))    #注意：宽度可以被撑破,前面定义宽度为3,结果宽度大于3
print("{:.2}".format(3**0.5))    #1.7   2个数字，科学记数法
print("{:.2f}".format(3**0.5))   #1.73   小数点后2位
print("{:3.2f}".format(3**0.5))  #1.73   宽度为3，小数点后2位
print("{:20.3f}".format(0.2745)) #0.275   默认右对齐
print("{:3.3%}".format(1/3))     #33.333%

执行结果：
1.7320508075688772
1.732051
  1.732051
1.732051
1.7
1.73
1.73
               0.275
33.333%

　　建议使用format函数格式化字符串