非常全面的python字符串相关处理方法

文章目录

• 字符串相关操作
• • 字符串的相关函数
  • 字符串切片
  • 字符串截取
  • 字符串替换
  • eval()函数

字符串相关操作

字符串的相关函数

#capitalize 字符串首字母大写 
strvar = "how are you"
res = strvar.capitalize()
print(res)

 
 
'
 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#title 每个单词的首字母大写 
strvar = "how old are you"
res = strvar.title()
print(res)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#*upper 将所有字母变成大写
strvar = "How Old Are You"
res = strvar.upper()
print(res)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#*lower 将所有字母变成小写 
res = strvar.lower()
print(res)

 
 

#*swapcase 大小写互换 
strvar = "How old Are You"
res = strvar.swapcase()
print(res)

 
 
'
 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#*len 计算字符串的长度 
strvar = "python32真热"
res = len(strvar)
print(res)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#*count 统计字符串中某个元素的数量 ，不存在返回0，不报错
"""count(字符,[开始值,结束值])"""
strvar = "真热真热呀"
#res = strvar.count("真")     # 2
#res = strvar.count("热",2)   # 1  只有一个数，是开始位置
#res = strvar.count("热",2,3) # 只有真这个字符 没有热
print(res)

 
 

#*find 查找某个字符串第一次出现的索引位置  (推荐)
"""find(字符,[开始值,结束值])"""
strvar = "To be or not to be that is a question"
res = strvar.find("to")
res = strvar.find("be",4)
#如果find 返回的是 -1 代表没找到
res = strvar.find("be",4,10) # 4 ~ 9
print(res)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

打印出第一个to中 t出现的下标

#*index 与 find 功能相同 find找不到返回-1, index找不到数据直接报错。不推荐使用
"""
res = strvar.index("be",4,10) 
print(res)
"""

#*startswith 判断是否以某个字符或字符串为开头
“”"
startswith(字符,[开始值,结束值])
endswith(字符,[开始值,结束值])
“”"
strvar = “To be or not to be that is a question”
res = strvar.startswith(“To”)
res = strvar.startswith(“To”,10)
print(res)

运行

运行

#*endswith 判断是否以某个字符或字符串结尾 
res = strvar.endswith("question")
res = strvar.endswith("is",-14,-11) #  is    只能正向表示
print(res)

 
 

#is系列
#*isupper 判断字符串是否都是大写字母 ，有其他文字，特殊符号不影响，只看英文字母是否大写

strvar = "HOW  A  YOU"
res = strvar.isupper()
print(res)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#*islower 判断字符串是否都是小写字母

strvar = "asdf - as"
res = strvar.islower()
print(res)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#*isdecimal 检测字符串是否以数字组成 必须是纯数字，有小数点都不算纯数字。如果要判断是否是小数，可用isinstance()

strvar = "abcdefg"
strvar = "2134234.123"
strvar = "2134234"
res = strvar.isdecimal()
print(res)

 
 

 
 
1
2
3
4
5
'
 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#isdigit 判断字符串是否是数字组成，接受二进制字节流

#isnumeric 检测字符串是否以数字组成，中文的数字比如"四"，也被认为是数字

#isalnum 判断字符串是否由数字，字母，汉字组成

#isalpha 判断字符串是否由字母和文字组成

#isspace 判断字符串是否由空白符组成。空串不是空白符

#split 按某字符将字符串分割成列表(默认字符是空格)
split()：拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）

1、split()函数
语法：str.split(str=“”,num=string.count(str))[n]

参数说明：
str:表示为分隔符，默认为空格，但是不能为空(‘’)。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
num:表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量
[n]:表示选取第n个分片

注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略
返回的是列表，丢失分割字符
分隔后取得值的类型是str,就是通过列表的下标取值

strvar = "you can you up no can no bb"
lst = strvar.split()
strvar = "you#can#you#up#no#can#no#bb"
lst = strvar.split("#")
print(lst)

 
 
'
 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

截取字符串中想要的字段

#join 按某字符将列表拼接成字符串(容器类型都可)
join()将多个序列中的元素合并成一个新的字符串
join()： 连接字符串数组。将字符串、元组、列表、集合中的元素以指定的字符(分隔符)连接生成一个新的字符串
语法：
子串或字符.join(多个字符串组成的序列)

lst = ['you', 'can', 'you', 'up', 'no', 'can', 'no', 'bb']
strvar = " ".join(lst)
strvar = "#".join(lst)
print(strvar)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

集合顺序会乱，不建议用

#replace 把字符串的旧字符换成新字符
“”“字符串.replace(‘旧字符’,‘新字符’[, 限制替换的次数])”“”
字符串序列.replace(“原字符串”,“新字符串”,修改的次数)
如果查到出现的次数，就从左到右替换该次数，省略不写次数，全部替换,次数超过了，也不报错，全部替换

replace有返回值，返回值就是修改后的字符串
但是，字符串是不可以修改的类型，它并没有修改以前的str
并不会将原有字符串修改，将替换后的结果赋值给新字符串，才得到修改后的字符串

strvar = "范冰冰爱不爱我,爱我,不爱我,爱我,不爱我"
res = strvar.replace("不爱我","爱我")
#选择替换的次数
res = strvar.replace("不爱我","爱我",1)
print(res)

 
 
'
 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#strip 默认去掉首尾两边的空白符
“”“空白符 空格 \n \t \r … “””
Python 的 strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
strip() 方法语法
str 是字符串，chars 是指定的字符。

str.strip([chars]);

参数：

chars – 移除字符串头尾指定的字符序列。可以指定去除的内容

返回值：

返回移除字符串头尾指定的字符后生成的新字符串。

如下，去除字符串两边的"景"

strvar = "     周润发  "
res = strvar.strip()
print(strvar)
print(res)

 
 
'
 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#zfill 填充字符串(默认填充0,原字符串右对齐)
①语法说明：

str.zfill(width)
其中，str表示这里要对一个字符串类型string进行操作，如果是整型、浮点型这样的数字类型，要先通过str()函数转化为字符串，才可以进行相关的操作；

       width表示进行补零之后的字符串的长度，如果补零后的长度小于或等于原字符串的长度，那么字符串将不会产生任何的变化

 
 

Python中的ljust()和rjust()方法属于字符串格式控制方面的函数。这两个方法按照指定的字符串宽度和特定字符来调整字符串宽度，若字符串不足指定的宽度就用指定的字符来填充剩余的宽度。

一、ljust()和rjust()语法格式

str.ljust(width [, fillchar] )

str.rjust(width [, fillchar] )

上面中str即为要操作的字符串；

width 是指定的填充后的总宽度，若 width 小于或等于原字符串的宽度，则原样返回原字符串；

fillchar是可选参数，即要填充的字符，默认为ASCII空格，即相当于按下键盘中的空格键产生的空格。

这两个方法执行完会产生一个新的字符串，不影响原字符串的内容。

(1)ljust()方法使原字符串位于新字符串的左端，不足指定的宽度，则在右侧填充指定的字符：字符串左齐

(2)rjust()方法使原字符串位于新字符串的右端，不足指定的宽度，则在左侧填充指定的字符：字符串右齐

#ljust 填充字符串,原字符居左 (默认填充空格)

#rjust 填充字符串,原字符居右 (默认填充空格)

指定的宽度不足，就打印原字符串

*#center 填充字符串,原字符居中 (默认填充空格)
“”“center(字符长度,填充符号)”“”

strvar = "赵世超"
res = strvar.center(10)
#res = strvar.center(10,"*")
print(res)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

print结束符：
Python的print()自带end="\n"这个换行结束符，所以，两个print会换行展示，
我们也可以根据需要自定义结束符

print('输出的内容', end="\n")
print("hello", end="...")
print("world!")
print("hello", end="\t")
print("python!")
输出结果
hello...world!
hello    python!

 
 

python字符串：

在python中引号引起来的就是字符串，双引号，单引号，三引号都可以
三引号支持回车换行，输出的也是换行的
字符串是用来存储少量数据

字符串是不可变类型

单引号有其他用途时，需要转义

c = 'I\'m Tom'
print(c)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

#(3)字符串跨行拼接 \

str1 = "kskfjskjfklsjfklasdjklfjaskldjfaskljfklasjdfklasjdklfjaskldfjaskldjflasjfsf" \
"1122334"

 
 
'
 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

字符串输入用input

输入功能：
input(“提示信息”)

当程序执行到input时，等待用户输入，输入完成后才能继续向下执行
在python中，input接收用户输入后，一般存储到变量，方便调用
在python中，input会把接收的任意输入的数据都当做字符串处理

索引:
索引(下标) 通过索引可以快速精确的定位到某个元素

name = "meat"
meat 每一个字母叫做一个元素
#0123       从左向右代表每一个字母
#-1-2-3-4    从右向左每一个字母
print(meat[1])  打印出meat字符串的第二个字符

 
 

负索引

字符串切片

name = "todayisgood"
print(name[0:2])  输出：to

 
 

顾头不顾尾 name[起始位置:终止位置:步长] 不包含最后一个
左闭右开，默认步长为1

print(name[:]) 返回所有字符串 
某个位置不指定的时候默认取最后或最前
print(name[:3])  输出：tod
print(name[2:5]) 输出：day

 
 

从左到右截,间隔值为正值,反过来,间隔值是负值,才能保证截取到数据

res = strvar[-3:-10:10] # 错误的逻辑，没有输出

 
 

正序，要从左往右截取，才能截取到

字符串截取

#从左向右截取

res = strvar[::3]
#0 3 6 9 12 15 ...   步长3，隔两个取一个，根据下标取值
print(res)

 
 

str1 = '(223+4343*3245)'
#步长为1，输出到倒数第二个的全部数据，不包含倒数第二个
print(str1[:-2])

 
 
'
 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

(223+4343*324

print(str1[-5:-2])
324

print(name[-2:-5])

print(name[-2:-5:-1])
#[起始位置:终止位置:步长] 步长默认为1**

print(name[100:105])
切片的时候起始位置和终止位置都超出的时候不会进行报错，超出不会打印出来

print(name[100])
索引的时候索引值超出范围的时候会报错

获取s字符串中所有内容
s[:]

获取s字符串中第4个到最后一个,每2个取一个
s[3::2]
获取s字符串中倒数第5个到最开始,每3个取一个
s[-5::-3]　
步长为负数，倒序输出

步长为负数时，若选取了起始末尾位置，选取顺序也要倒叙，不然没输出

str1 = "0123456789"
print(str1[-6:-9:-1])

name = “Jinghao nihao”
print(name[::2])
输出：Jnhonho

常见的字符串操作函数：

替换：

name = "Jinghao nihao"

name1 = name.replace(“n”, “8”) 将name中所有的n替换成8

name1 = name.replace(“n”, “8”, 1) 将name中第一个n替换成8

大小写反转：

name = "JerryHome"
print(name.swapcase())
输出 jERRYhOME

 
 

查找

在字符串中查找子串的位置或出现的次数

字符串.find(子串,开始位置下标,结束位置下标) 开始和结束位置下标也可以省略，整个字符串中查找
name = “jerry”
print(name.find(“r”))
输出 2 (代表第一个"r"的下标）

#返回子串首个字符开始位置的下标
name = “I love you china, my nema is Jinghao”
print(name.find(“you”))
输出：7

print(name.find(“t”))
输出 -1 (find 查找不存在的返回 -1）

index与find使用方法一样
print(name.index(“t”))
index 查找不存在的就报错

rfind findex 查找方向从右侧开始查找
name = “I love you china, my nema is Jinghao, I love peace”
print(name.rfind(“love”))
输出：40
返回的是从右边开始查找的第一个出现的位置，下标从左边开始计算的

不存在返回-1

count()返回某个子串出现的次数，不存在返回0，不报错

name = “I love you china, my nema is Jinghao, I love peace”

print(name.count(“love”))
输出：2

列表也可用这些方法

字符串替换

字符串序列.replace(“原字符串”,“新字符串”,修改的次数)
如果查到出现的次数，就从左到右替换该次数，省略不写次数，全部替换,次数超过了，也不报错，全部替换

replace有返回值，返回值就是修改后的字符串
但是，字符串是不可以修改的类型，它并没有修改以前的str
并不会将原有字符串修改，将替换后的结果赋值给新字符串，才得到修改后的字符串

替换：

name = "Jinghao nihao"

name1 = name.replace(“n”, “8”) 将name中所有的n替换成8

name1 = name.replace(“n”, “8”, 1) 将name中第一个n替换成8

分割：split
语法：
字符串序列.split(分隔符号,num) 默认是以空格为分隔符
num表示分隔符出现的次数，即将来返回的数据是num+1个
不写num，就是将出现分隔符的地方都分割

返回的是列表，丢失分割字符

#split,分割字符

name = "I love you china, my nema is Jinghao, I love peace"

print(name.split(“love”, 2))

[‘I ‘, ’ you china, my nema is Jinghao, I ‘, ’ peace’]

'

运行

运行

join()将多个序列中的元素合并成一个新的字符串
join()： 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
语法：
子串或字符.join(多个字符串组成的序列)

字符串拼接，以a为分隔符，将b拼接起来

#join

str2 = ["aa", "bb", "cc"]

print(" ".join(str2))
输出：aa bb cc

对序列进行操作（分别使用’ ‘与’:‘作为分隔符）
2
3 >>> seq1 = [‘hello’,‘good’,‘boy’,‘doiido’]
4 >>> print (’ ‘.join(seq1))
5 hello good boy doiido
6 >>> print (’:‘.join(seq1))
7 hello:good👦doiido
8
9
10 #对字符串进行操作，字符串每个都会被用间隔符分隔，返回的是字符串类型
11
12 >>> seq2 = “hello good boy doiido”
13 >>> print (’:'.join(seq2))
14 h:e:l:l⭕️ :g⭕️o:d: 🅱️o:y: :d⭕️i:i:d:o
15
16
17 #对元组进行操作
18
19 >>> seq3 = (‘hello’,‘good’,‘boy’,‘doiido’)
20 >>> print ‘:’.join(seq3)
21 hello:good👦doiido

24 #对字典进行操作
25
26 >>> seq4 = {‘hello’:1,‘good’:2,‘boy’:3,‘doiido’:4}
27 >>> print ‘:’.join(seq4)
28 boy:good:doiido:hello
29
30
31 #合并目录
32
33 >>> import os
34 >>> os.path.join(‘/hello/’,‘good/boy/’,‘doiido’)
35 ‘/hello/good/boy/doiido’

字符串 + * 会开辟新的空间。字符串拼接

name = "jerry"
name1 = "home"
print(id(name))
print(id(name1))
print(id(name + name1))
输出 2609785706008    #内存地址都不同
     2609817396424
     2609818262256

 
 

判断：判断真假：返回布尔值

s = "12.3"

print(s.isalnum()) # 判断是不是字母,数字,中文
print(s.isalpha()) # 判断是不是字母,中文
print(s.isdigit()) # 判断字符串是不是全都是阿拉伯数字
print(s.isdecimal()) # 判断是否是十进制
print(s.isspace()) # 判断是否只包含空白

str1.startswith(子串, 开始位置下标, 结束位置下标)

str1 = “I love china!”

print(str1.startswith(“I”))
True

endswith 类似

每个单词首字母大写

name = "jerry home"
print(name.title())
输出 Jerry Home

 
 

首字母大写，其余就算有大写也会转成小写

name = "alex"
name1 = name.capitalize()
print(name1)
输出  Alex

 
 

统计

s = "alexdxjbx"
s1 = s.count("x")
print(s1)
输出  3

 
 

以什么开头

s = "ALEX"
s1 = s.startswith("E",2,6)
print(s1)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

以什么结尾

s = "ALEX"
s1 = s.endswith("X",3,4)
print(s1)

 
 

 
 

  
  

   
   运行
   
   

    
    运行
   
   
  
  
 
 

Python 中去除字符串空格的方法
方法一：strip方法 ， 去除字符串最左和最右的空格

string = '  a  b  c   '

print( string.strip() )

#OUTPUT

>>‘a b c’

方法二：lstrip方法， 去除字符串最左的空格

print( string.lstrip() )

#OUTPUT

>>'a b c '

方法三：rstrip方法， 去除最右的空格

>>'  a b c'

 
 

方法四：replace方法， 把空格替换为其他字符

print( string.replace( ' ' , '' ) )  第一个表示原有的空格，第二个为替换以后的没有空格

#OUTPUT

>>‘abc’

方法五：先用空格分隔开，在join组合

a = 'a b c'
b = a.split()
print(b)
c = "".join(b)
print(c)

[‘a’, ‘b’, ‘c’]
abc

split()：拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）

1、split()函数
语法：str.split(str=“”,num=string.count(str))[n]

参数说明：
str:表示为分隔符，默认为空格，但是不能为空(‘’)。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
num:表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量
[n]:表示选取第n个分片

注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略

分隔后取得值的类型是str,就是通过列表的下标取值

截取字符串中想要的字段

eval()函数

eval() 函数用来执行一个字符串表达式，并返回表达式的值。返回字符串里面原本的数据类型
说明：表达式必需是字符串，否则会报错，比如直接输入数值会报错为：“TypeError: eval() arg 1 must be a string, bytes or code object”

可以直接将字符串转换为数学运算

input不管接收到什么类型的数据，都当做字符串数据类型
这就需要数据类型转换

eval(str)用来计算在字符串中有效的python表达式，并返回一个对象

eval(str)函数很强大，官方解释为：将字符串str当成有效的表达式来求值并返回计算结果。

字符串里原本是什么数据类型就返回什么数据类型
所以，结合math当成一个计算器很好用。

eval的语法格式如下：

eval(expression[, globals[, locals]])
1
expression ： 字符串
globals ： 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals ： 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

#eval() --计算在python字符串中有效的表达式，并返回一个对象,字符串里原本是什么类型就返回什么类型

str2 = "1"
str3 = "23.43"
str4 = "(1222, 244, 435)"
str5 = "[1222, 244, 435]"

print(eval(str4))

print(type(eval(str4)))

输出结果
(1222, 244, 435)
<class ‘tuple’>