python字符串的操作

一个个字符组成的有序的序列，是字符的集合

使用单引号、双引号、三引号引住的字符序列

字符串是不可变对象，是字面常量

索引

字符串是序列，支持下标访问。但不可变，不可以修改元素

sql = "select * from user where name='tom'"
print(sql[4]) # 字符串'c'
sql[4] = 'o'    # 不可修改

拼接

+加号

将2个字符串连接起来

返回一个新的字符串

print('abc'+'cde')
abccde

join方法

sep.join(iterable)

使用指定字符串作为分隔符，将可迭代对象中字符串使用这个分隔符拼接起来

可迭代对象必须是字符串返回一个新的字符串

print('++'.join('abc'))
a++b++c

print('+'.join(map(str,range(10))))
0+1+2+3+4+5+6+7+8+9

#用map将int类型强制转换为str类型

[ i for i in str(1234)]
Out[11]: ['1', '2', '3', '4']
''.join([ i for i in str(1234)])
Out[12]: '1234'
int(''.join([ i for i in str(1234)]))
Out[13]: 1234

字符查找

find(sub[, start[, end]]) -> int

​ 在指定的区间[start, end)，从左至右，查找子串sub

​ 找到返回正索引，没找到返回-1

rfind(sub[, start[, end]]) -> int

​ 在指定的区间[start, end)，从右至左，查找子串sub

​ 找到返回正索引，没找到返回-1

index(sub[, start[, end]]) -> int

​ 在指定的区间[start, end)，从左至右，查找子串sub

​ 找到返回正索引，没找到抛出异常ValueError

rindex(sub[, start[, end]]) -> int

​ 在指定的区间[start, end)，从左至右，查找子串sub

​ 找到返回正索引，没找到抛出异常ValueErro

count(sub[, start[, end]]) -> int

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

len(string) 返回字符串的长度，即字符的个数

分割

split(sep=None, maxsplit=-1) -> list of strings

​ 从左至右

​ sep 指定分割字符串，缺省的情况下空白字符串作为分隔符

​ maxsplit 指定分割的次数，-1 表示遍历整个字符串

​ 立即返回列表

rsplit(sep=None, maxsplit=-1) -> list of strings

​ 从右向左开始切，但是输出的字符串字符不会反

​ sep 指定分割字符串，缺省的情况下空白字符串作为分隔符

​ maxsplit 指定分割的次数，-1 表示遍历整个字符串

​ 立即返回列表

splitlines([keepends]) -> list of strings

​ 按照行来切分字符串

​ keepends 指的是是否保留

​ 行分隔符行分隔符包括\n、\r\n、\r等

a='abc dsc sda'
a.split()
Out[3]: ['abc', 'dsc', 'sda']
a.split('d')
Out[6]: ['abc ', 'sc s', 'a']
a.split('d',0)
Out[10]: ['abc dsc sda']
a.split('d',1)
Out[8]: ['abc ', 'sc sda']
a.split('d',2)
Out[7]: ['abc ', 'sc s', 'a']
a.split('d',3)
Out[9]: ['abc ', 'sc s', 'a']
    
s1 = '\na b  \tc\nd\n'
print(s1)

a b  	c
d

a.splitlines(True)
Out[4]: ['\n', 'a b  \tc\n', 'd\n']
a.splitlines()
Out[5]: ['', 'a b  \tc', 'd']

partition(sep) -> (head, sep, tail)

​ 从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组

​ 如果没有找到分隔符，就返回头、2个空元素的三元组

​ sep 分割字符串，必须指定

rpartition(sep) -> (head, sep, tail)

​ 从右至左，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组

​ 如果没有找到分隔符，就返回2个空元素和尾的三元组

a=','.join('abcd')
print(a)
a,b,c,d
print(a.partition(','))
('a', ',', 'b,c,d')
print(a.rpartition(','))
('a,b,c', ',', 'd')

替换

replace(old, new[, count]) -> str

​ 字符串中找到匹配替换为新子串，返回新字符串

​ count表示替换几次，不指定就是全部替换

print(a)
a,b,c,d
print(a.replace(',','-'))
a-b-c-d
print(a.replace(',','-',2))
a-b-c,d
print(a)
a,b,c,d

移除

strip([chars]) -> str

​ 在字符串两端去除指定的字符集chars中的所有字符

​ 如果chars没有指定，去除两端的空白字符

lstrip([chars]) -> str ，从左开始

rstrip([chars]) -> str，从右开始

只移除最外侧的字符

chars是字符集

删除两边，一直到遇到不在字符集中的字符为止

首尾判断

endswith(suffix[, start[, end]]) -> bool

​ 在指定的区间[start, end)，字符串是否是suffix结尾

startswith(prefix[, start[, end]]) -> bool

​ 在指定的区间[start, end)，字符串是否是prefix开头

s='abcdefg'
print(s.startswith('ab'))
True
print(s.startswith('c',2))
True
print(s.startswith('c',3,4))
False

其它函数

upper()大写

lower()小写

swapcase() 交换大小写

isalnum() -> bool 是否是字母和数字组成

isalpha() 是否是字母

isdecimal() 是否只包含十进制数字

isdigit() 是否全部数字(0~9)

isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线

islower() 是否都是小写

isupper() 是否全部大写

isspace() 是否只包含空白字符

格式化

简单的使用+或者join也可以拼接字符串，但是需要先转换数据到字符串后才能拼接

C风格printf-style

占位符：使用%和格式字符，例如%s、%d

修饰符：在占位符中还可以插入修饰符，例如%03d

在字符串中用%占位符
%s 表示字符串的占位符
%d 表示整数的占位符
%3d 表示三位整数，不够的在前面补3个空格
%03d 表示三位整数，不够的在前面补3个0
%-3d 表示三位整数，不够的在后面补3个空格
%f 表示浮点数的占位符
%.nf 表示小数点后保留n位，四舍五入
%x 表示以16进制的格式输出
%o 表示以8进制的格式输出
%% 表示禁止转义%

format % values

​ format是格式字符串，values是被格式的值

​ 格式字符串和被格式的值之间使用%

​ values只能是一个对象，可以是一个值，可以是一个元素个数和占位符数目相等的元组，也可以是一个字典

"I am %03d" % (20,)
Out[6]: 'I am 020'
'I like %s.' % 'Python'
Out[7]: 'I like Python.'
"%3.2f%% 0x%x %#X" % (89.7654, 10, 256) # 宽度为3，小数点后2位
Out[8]: '89.77% 0xa 0X100'
"I am %-5d" % (20,)
Out[9]: 'I am 20   '
"%(host)s.%(domain)s" % {'domain':'magedu.com', 'host':'www'} # 靠名字对应
Out[10]: 'www.magedu.com'

format函数

Python2.5之后，字符串类型提供了format函数，功能更加强大，鼓励使用。
"{} {xxx}".format(*args, **kwargs) -> strargs
是可变的位置参数
kwargs是可变关键字参数，写作a=100
使用花括号作为占位符
{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
{xxx}表示在关键字参数中搜索名称一致的
{{}} 表示打印花括号

datetime的格式化输出

%w 星期
%d 天
%b 月（简写）
%B 月（全称）
%m 月份（数字）
%y 年（后两位）
%Y 年（写全）
%H 小时（24小时制）
%I 小时（12小时制）
%M 分钟
%S 秒
%z 时区

datetime.datetime.now()
Out[14]: datetime.datetime(2021, 6, 20, 4, 45, 43, 750723)
'{:%S}'.format(datetime.datetime.now())
Out[15]: '50'

# 进制
"{0:d} {0:b} {0:o} {0:x} {0:#X}".format(31)

# 对齐
print("{}*{}={}".format(5, 6, 5*6))
5*6=30
print("{}*{}={:2}".format(5, 6, 5*6))
5*6=30
print("{1}*{0}={2:3}".format(5, 6, 5*6))
6*5= 30
print("{1}*{0}={2:0>3}".format(5, 6, 5*6))
6*5=030
print("{}*{}={:#<3}".format(4, 5, 20))
4*5=20#
print("{:#^7}".format('*' * 3))
##***## 

#计算属性
int('777',8)
Out[26]: 511
bin(16895&511)
Out[27]: '0b111111111'
'{:b}'.format(511&16895)
Out[28]: '111111111'
'{:09b}'.format(511&0)
Out[30]: '000000000'
'{:09b}'.format(511&16895)
Out[31]: '111111111'

center------》字符串居中

center(width, fillchar=None)

width：需要居中的字符串

fillchar：两边补齐的字符串

print('你好'.center(20,'-'))

#结果
---------你好---------

ljust------>字符串左对齐

print('你好'.ljust(20,'*'))

#结果
你好******************

rjust------>字符串右对齐

print('你好'.rjust(20,'*'))

#结果
******************你好