Python字符串常用方法总结

【注意】：

对字符串的操作方法都不会改变原来字符串的值；字符串相加之后会开辟新的空间，即形成新的字符串；（即字符串类型是不可变类型）

1、去掉空格和特殊符号

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

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

strip()方法语法：str.strip([chars])
参数：
　　chars -- 移除字符串头尾指定的字符序列。
返回值：
　　返回移除字符串头尾指定的字符生成的新字符串。

实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
str = "00000003210Runoob01230000000"; 
print str.strip('0');  # 去除首尾字符 0
 
 
str2 = "   Runoob      ";   # 去除首尾空格
print str2.strip();

运行结果：

3210Runoob0123
Runoob

② name.strip('xx')  ：去掉某个字符串

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

lstrip()方法语法： str.lstrip([chars]) 

实例：

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

运行结果：

this is string example....wow!!!
this is string example....wow!!!8888888

④ name.rstrip() ：去掉右边的空格和换行符 【参照 lstrip() 方法的使用】

2、字符串的搜索和替换

① name.count('x') ：查找某个字符在字符串里面出现的次数

name = 'xiaoming'

name_num = name.count('i')

print(name_num)  # 2

② name.capitalize() ：首字母大写

name = 'xiaoming'

name_num = name.capitalize()

print(name_num)  # Xiaoming

③ name.center(n,'-') ：将字符串居中，两边是center入参的第二个参数

name = 'xiaoming'

name_go = name.center(10, '*')

print(name_go)  # *xiaoming*

④ name.find('x') ：找到这个字符返回下标，多个时返回第一个；不存在的字符返回-1

name = 'xiaoming'

name_go = name.find('i')

print(name_go)  # 1

name_go = name.find('p')  # name字符串中不包含此字符

print(name_go)

⑤ name.index('x') ：找到这个字符返回下标，多个时返回第一个；不存在的字符报错

name = 'xiaoming'

name_go = name.index('i')

print(name_go)  # 1

name_go = name.index('p')  # name字符串中不包含此字符

print(name_go)

# Traceback (most recent call last):
#   File "C:\Users\liangshu.hu\PycharmProjects\practice\7.py", line 7, in <module>
#     name_go = name.index('p')  # name字符串中不包含此字符
# ValueError: substring not found
# 1

⑥ name.replace(oldstr, newstr) ：字符串替换

name = 'xiaoming'

name_go = name.replace('xi', 'd')

print(name_go)  # daoming

描述：pyrhon的 replace()  方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

语法： str.replace(old, new[, max]) 

参数：

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

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

实例1：

str_ = "this is string example....wow!!! this is really string"
'''
默认不指定旧字符串中某内容被替换的次数，则会将旧字符串中所有的符合被替换的内容全部替换，并生成新的字符串
'''
print(str_.replace("is", "was"))  # thwas was string example....wow!!! thwas was really string
'''
replace方法指定旧字符串中某内容被替换的次数，则会指定替换符合被替换的内容次数，并生成新的字符串
'''
print(str_.replace("is", "was", 3))  # thwas was string example....wow!!! thwas is really string

实例2：

temp_str = 'this is a test'
new_temp_str = temp_str.replace('is', 'IS')
'''
replace()函数会产生新的字符串且原字符串内容不变
'''
print(new_temp_str)  # thIS IS a test
print(temp_str)  # this is a test

⑦ name.format() ：字符串格式化

⑧ name.format_map(d) ：字符串格式化，传进去的是一个字典

Year {} Rs. {:.2f}".format(year, value) 称为字符串格式化，大括号和其中的字符会被替换成传入 str.format() 的参数，也即 year 和 value。

其中 {:.2f} 的意思是替换为 2 位精度的浮点数。

{:5d} 的意思是替换为 5 个字符宽度的整数，宽度不足则使用空格填充。

3、字符串的测试和替换函数

① name.startswith(prefix[,start[,end]]) ：是否以prefix字符开头 ，返回值为Ture或者False；且prefix字符的下标是否处于start和end之间

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

② name.endswith(suffix[,start[,end]]) ：是否以suffix字符结尾，返回值为Ture或者False；且suffix字符的下标是否处于start和end之间

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

③ name.isalnum() ：判断字符串是否全是字母或数字，返回值为Ture或者False

test_str01 = 'helloIam19yearsold'
test_str02 = 'hello,I am 19 years old'

print(test_str01.isalnum())  # True
print(test_str02.isalnum())  # False

④ name.isalpha() ：判断字符串是否全是字母，返回值为Ture或者False 

test_str01 = 'abcdefghijklmn'
test_str02 = '123asd'

print(test_str01.isalpha())  # True
print(test_str02.isalpha())  # False

⑤ name.isdigit() ： 判断字符串是否全是数字，返回值为Ture或者False

test_str01 = '3123123'
test_str02 = '123asd'

print(test_str01.isdigit())  # True
print(test_str02.isdigit())  # False

⑥ name.isspace() ：判断字符串是否全是空白字符，返回值为Ture或者False

test_str01 = '     '
test_str02 = '123asd  '

print(test_str01.isspace())  # True
print(test_str02.isdigit())  # False

⑦ name.islower() ：判断字符串中的字母是否全是小写 ，返回值为Ture或者False

test_str01 = 'qweqweqweqwe'
test_str02 = 'WRRWRWRwfwefwef'
test_str03 = '1232121WRWRR'

print(test_str01.islower())  # True
print(test_str02.islower())  # False
print(test_str03.islower())  # false

⑧ name.isupper() ：判断字符串中的的字母是否全是大写 ，返回值为Ture或者False

test_str01 = 'SFSFFFSFSF'
test_str02 = 'WCDdsdsdwWDD'
test_str03 = '132SFvdfv'

print(test_str01.isupper())  # True
print(test_str02.isupper())  # False
print(test_str03.isupper())  # false

⑨ name.istitle() ：判断字符串是否为首字母大写，返回值为Ture或者False【字符串中只有首字母为大写，其他字符不可为大写，否则依然是False】

test_str01 = 'Abcddasdasdasd'
test_str02 = 'ACDdsdsdwWDD'
test_str03 = 'AxssSSA'

print(test_str01.istitle())  # True
print(test_str02.istitle())  # False
print(test_str03.istitle())  # false

⑩ name.swapcase() ：将字符串中的所有字符的大小写反转，并输出一个新的字符串

name = "JerryHome"
print(name.swapcase())  # jERRYhOME
print(id(name), id(name.swapcase()))  # 2422963831152 2422963831472

⑩① name.upper() ：将字符串里的所有字符全部转换为大写，并输出一个新的字符串

test_str01 = 'asdfghjkl'
test_str02 = 'ACDdsdsdwWDD'
test_str03 = 'AxssSSA'

print(test_str01.upper())  # ASDFGHJKL
print(test_str02.upper())  # ACDDSDSDWWDD
print(test_str03.upper())  # AXSSSSA

⑩② name.lower() ：将字符串中的所有字符全部转换为小写，并输出一个新的字符串

test_str01 = 'asdfghjkl'
test_str02 = 'ACDdsdsdwWDD'
test_str03 = 'AxssSSA'

print(test_str01.lower())  # asdfghjkl
print(test_str02.lower())  # acddsdsdwwdd
print(test_str03.lower())  # axssssa

4、字符串的分割

① name.split() ：默认是按照空格分割；返回字符串被切割后的各个部分组成的数组

test_str01 = 'a sdf-ghj-k l'

print(test_str01.split())  # ['a', 'sdf-ghj-k', 'l']

② name.split(',') ：按照逗号分割；返回字符串被切割后的各个部分组成的数组

test_str01 = 'a sdf-ghj-k l'

print(test_str01.split('-'))  # ['a sdf', 'ghj', 'k l']

5、连接字符串

① ','.join(slit) ：用逗号连接可迭代对象变成一个字符串，可迭代对象可以是字符，列表，字典。【注意】int 类型（即整型数据）不能被连接

name = "jerry"
print("_".join(name))  # j_e_r_r_y


name = "jerry"
name1 = "*".join(name)
print(name1)  # j*e*r*r*y


name = "jerry"
print("&".join(name))  # j&e&r&r&y

name = ['abc', 'def', 'ghi']
print("".join(name))  # abcdefghi

name = ('abc', 'def', 'ghi')
print("".join(name))  # abcdefghi

name = [1, 2, 3, 4]
print("".join(name))
# Traceback (most recent call last):
#   File "C:\Users\liangshu.hu\PycharmProjects\practice\7.py", line 20, in <module>
#     print("".join(name))
# TypeError: sequence item 0: expected str instance, int found

 6、截取字符串（切片）

str = "0123456789"

print(str[0:3])  # 截取第一位到第三位的字符 012

print(str[:])  # 截取字符串的全部字符 0123456789

print(str[6:])  # 截取第七个字符到结尾 6789

print(str[:-3])  # 截取从头开始到倒数第三个字符之前 0123456

print(str[2])  # 截取第三个字符 2

print(str[-1])  # 截取倒数第一个字符 9

print(str[::-1])  # 创造一个与原字符串顺序相反的字符串 9876543210

print(str[-3:-1])  # 截取倒数第三位与倒数第一位之前的字符 78

print(str[-3:])  # 截取倒数第三位到结尾 789

print(str[:-5:-3])  # 逆序截取 96

①通过索引（下标）可以精确的定位到某个元素

name = "今天是个好日子"
       #  0 1 2 3 4 5 6
       # -7-6-5-4-3-2-1
a = name[0]
b = name[1]
print(a+b)  # 今天

②切片

name = "todayisgood"


# 顾头不顾尾  name[起始位置:终止位置]
print(name[0:2])  # to

# 起始位置和终止位置都为空默认取全部
print(name[:])  # todayisgood

# 某个位置不指定的时候默认取最后或最前
print(name[:3])  # tod
print(name[2:5])  # day

# 起始位置必须要小于终止位置（无论正值还是负值）
print(name[-2:-1])  # o
print(name[-2:-3], type(name[-2:-3]), sep='\t')  # 输出为空,表示空字符串
print('' == name[4:1])  # True

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

name = "大黑哥吃大煎饼"

print(name[1:5])  # 黑哥吃大

print(name[-2:-6:-1])  # 煎大吃哥 【注意】当步长为负数的时候，起始值可以大于终止值，因为步长为负数表示字符切片不再是从左往右，而是从右往左

print(name[-6:6])  # 黑哥吃大煎

# 切片的时候起始位置和终止位置都超出的时候不会进行报错
print(name[100:105])
print('' == name[105:110])  # True

# 索引的时候索引值超出范围的时候会报错
print(name[100])
# Traceback (most recent call last):
#   File "C:\Users\liangshu.hu\PycharmProjects\practice\7.py", line 14, in <module>
#     print(name[100])
# IndexError: string index out of range

s = 'Python最NB'

# 获取s字符串中前3个内容
print(s[0:3])
# 获取s字符串中第3个内容
print(s[2])
# 获取s字符串中后3个内容
print(s[-3:])
# 获取s字符串中第3个到第8个
print(s[2:8])
# 获取s字符串中第2个到最后一个
print(s[1:])
# 获取s字符串中第1,3,5个内容
print(s[0:6:2])
# 获取s字符串中第2,4,6个内容
print(s[1:7:2])
# 获取s字符串中所有内容
print(s[:])
# 获取s字符串中第4个到最后一个,每2个取一个
print(s[3::2])
# 获取s字符串中倒数第5个到最开始,每3个取一个
print(s[-5::-3])

# 输出结果
# Pyt
# t
# 最NB
# thon最N
# ython最NB
# Pto
# yhn
# Python最NB
# hnN
# oy

7、string 模块

 import string  

 string.ascii_uppercase  所有大写字母字符串--》返回值为字符串

 string.ascii_lowercase  所有小写字母组成的字符串--》返回值为字符串

 string.ascii_letters    所有字母【同时包含所有大写字母和所有小写字母】组成的字符串--》返回值为字符串

 string.digits   　　     所有数字组成的字符串--》返回值为字符串

 string.hexdigits 　　　 所有的十六进制字符--》返回值为字符串

 string.whitespace 　　　 所有的空白字符--》返回值为字符串

 string.punctuation 　　  所有的标点符号--》返回值为字符串

import string

print(dir(string), end='\n\n')
'''
['Formatter', 'Template', '_ChainMap', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', 
'__name__', '__package__', '__spec__', '_re', '_sentinel_dict', '_string', 'ascii_letters', 'ascii_lowercase',
 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']
'''

print(string.ascii_uppercase, type(string.ascii_uppercase), sep='\t||\t')  # ABCDEFGHIJKLMNOPQRSTUVWXYZ    ||    <class 'str'>
print(string.ascii_lowercase, type(string.ascii_lowercase), sep='\t||\t')  # abcdefghijklmnopqrstuvwxyz    ||    <class 'str'>
print(string.ascii_letters, type(string.ascii_letters), sep='\t||\t')  # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ    ||    <class 'str'>
print(string.digits, type(string.digits), sep='\t||\t')  # 0123456789    ||    <class 'str'>
print(string.hexdigits, type(string.hexdigits), sep='\t||\t')  # 0123456789abcdefABCDEF    ||    <class 'str'>
print(string.whitespace, type(string.whitespace), sep='\t||\t')  # ' \t\n\r\x0b\x0c'||    <class 'str'>
print(string.punctuation, type(string.punctuation), sep='\t||\t')  # !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~    ||    <class 'str'>