python 内置数据结构 字符串

字符串

• 一个个字符组成的有序的序列，是字符的集合
• 使用单引号，双引号，三引号引住的字符序列
• 字符串是不可变对象
• Python3起，字符串就是Unicode类型

字符串定义 初始化

• s1 = 'string'
• s2 = 'string2'
• s3 = ''' this's a "string" '''
• s4 = 'hello \n jaxzhai.com'   #\n 转义，换行
• s5 = r'hello \n jaxzhai.com'  #加r  \n 不转义
• s6 = "c:\windows\nt"   #\n 转义 换行
• s7 = R"c:\windows\nt"  #\n 不转义
• s8 = "c:\windows\\nt" # \n 不转义
• sql = """ select * from user where name='tom' """

字符串元素访问---下标

字符串支持索引访问

s = """ select * from user where name='tom' """
s[4]
s[4] = "o"  #不支持赋值。

有序的字符集合，字符序列

s = """ select * from user where name='tom' """
for c in s:
    print(c)
    print(type(c))

可迭代

s = """ select * from user where name='tom' """
lst =list(s)
lst

字符串join连接*

"string".join(iterable) -> str

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

>>lst = ["1","2","3"]
>>print("\"".join(lst))  #双引号分割
1"2"3
>>print(" ".join(lst))  #空格分割
1 2 3
>>print("\n".join(lst))
1
2
3
>>lst = ['1',['a','b'],'3']
>>print(" ".join(lst))
##报错，原因join只能分割字符串，列表中的[是列表元素]
>>print("".join(map(str, lst)))
1['a', 'b']3

字符串分割

分割字符串的方法分两类

• split系
  • 将字符串按照分隔符分割成若干字符串，返回列表
• partition系
  • 将字符串按照分隔符分割成2份，返回这2份和分隔符的元组

split

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

• 从左至右
• sep指定分割字符串，缺省的情况下空白字符串作为分隔符
• maxsplit 指定分割的次数，-1表示遍历整个字符串

s1 = "I'm \ta super student."
s1.split()  #默认空白字符分割
s1.split('s')  #s字符分割
s1.split('super')  #"super"字符串分割
s1.split('super ') # "super "字符串 空格分割
s1.split(' ')  # 空格分割
s1.split(' ',maxsplit=2) #空格分割 分割2次 
s1.split('\t',maxsplit=2) #\t分割  分割2次

rsplit

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

• 从右到左
• sep指定分割字符串，缺省的情况下空白字符串作为分隔符
• maxsplit 指定分割次数，-1表示遍历整个字符串

s1 = "I'm \ta super student."
s1.rsplit()
s1.rsplit('s')
s1.rsplit('super') 
s1.rsplit('super ') 
s1.rsplit(' ')
s1.rsplit(' ',maxsplit=2) 
s1.rsplit('\t',maxsplit=2)

splitlines

splitlines([keepends]) -> list of strings

• 按照行来切分字符串
• keepends 指的是是否保留行分隔符
• 行分隔符包括\n 、 \r\n 、 \r等

'ab c\n\nde fg\rkl\r\n'.splitlines()
'ab c\n\nde fg\rkl\r\n'.splitlines(True) 
s1 = '''I'm a super student.
You're a super teacher.'''
print(s1)
print(s1.splitlines()) 
print(s1.splitlines(True))

partition

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

• 从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组，如果没有找到分隔符，就返回头、2个空元素的三元组。
• sep 分割字符串，必须指定

s1 = "I'm a super student." 
s1.partition('s') 
s1.partition('stu') 
s1.partition('') 
s1.partition('abc')

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

• 从右至左，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没找到分隔符，就返回2个空元素和尾的三元组。

 字符串大小写

upper

• 全大写

lower

• 全小写

大小写，做判断的时候使用

swapcase()

• 交互大小写

字符串排版

title() - > str

• 标题的每个单词都是大写

>> a = "www jaxzhai com"
>> a.title()
'Www Jaxzhai Com'

capitalize() -> str

• 首个单词大写

>> a = "www jaxzhai com"
>> a.capitalize()
'Www jaxzhai com'

center(width,[fillchar]) -> str

• 居中打印
• width 打印宽度
• fillchar 填充的字符

>> a = "www jaxzhai com"
>> print(a.center(20))
>> a.center(20,"~")
  www jaxzhai com   
'~~www jaxzhai com~~~'

zfill(width) -> str

• width 打印宽度，居右，左边用0填充

>> a = "www jaxzhai com"
>> a.zfill(20)
'00000www jaxzhai com'

ljust(width,[fillchar]) -> str 左对齐

rjust(width,[fillchar]) -> str 右对齐

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

• 字符串中找到匹配替换为新字子串，返回新字符串
• count表示替换几次，不指定就是全部替换

>>print("www.jaxzhai.com".replace("w","p"))
>>print("www.jaxzhai.com".replace("w","p",2))
>>print("www.jaxzhai.com".replace("w","p",3))
>>print("www.jaxzhai.com".replace("ww","p",2))
>>print("www.jaxzhai.com".replace("www","python",2))
ppp.jaxzhai.com
ppw.jaxzhai.com
ppp.jaxzhai.com
pw.jaxzhai.com
python.jaxzhai.com

strip([chars]) -> str

• 从字符串两端去除指定的字符集chars中的所有字符
• 如果chars没有指定，去除两端的空字符

s = "\r \n \t Hello Python \n \t"
s.strip()
s = " I am very very very sorry "
s.strip('Iy')
s.strip('Iy ')

lstrip([chars]) -> str

• 从左至右

rstrip([chars]) -> str

• 从右至左

字符串查找

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

• 在指定的区间[start,end],从左往右，查找子串sub。找到返回索引，没找到返回-1

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

• 在指定的区间[start,end],从右往左，查找子串sub。找到返回索引，没找到返回-1

s = "I am very very very sorry"     
s.find('very')
s.find('very', 5)
s.find('very', 6, 13) 
s.rfind('very', 10)
s.rfind('very', 10, 15) 
s.rfind('very',-10,-1)

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

• 在指定的区间[start,end],从左往右，查找子串sub。找到返回索引,没找到抛出异常ValueError

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

• 在指定的区间[start,end],从右往左，查找子串sub。找到返回索引,没找到抛出异常ValueError

s = "I am very very very sorry"
s.index('very')
s.index('very', 5)
s.index('very', 6, 13) 
s.rindex('very', 10) 
s.rindex('very', 10, 15) 
s.rindex('very',-10,-1)

时间复杂度

• index和count方法都是O(n)
• 随着列表数据规模的增大，而效率下降

len(string)

• 返回字符串长度，既字符的个数

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

• 在指定的区间[start,end]，从左往右，统计子串sub出现的次数

s = "I am very very very sorry" 
s.count('very')
s.count('very', 5) 
s.count('very', 10, 14)

字符串判断

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

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

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

• 在指定的区间[start,end]，字符串是否是perfix开头

s = "I am very very very sorry" 
s.startswith('very')   #是否以very开始 返回false
s.startswith('very', 5) #下标5开始，是否以very开始，返回True
s.startswith('very', 5, 9)  #下标5开始到8结束，是否以very开始，返回True
s.endswith('very', 5, 9) #下标5开始到8结束，是否以very结尾，返回True
s.endswith('sorry', 5) #下标5开始，是否以sorry结尾，返回True
s.endswith('sorry', 5, -1)  #下标5开始，是否以sorry结尾，返回False  前包后不包 结果是very very very sorr
s.endswith('sorry', 5, 100) #下标5开始到99结束，下界没有限制 ，是否以sorry结尾，返回True

字符串判断is系列

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

isalpha() -> bool 是否是字母

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

isdigit() -> bool 是否全部数字（0-9）

isidentifier() -> bool 是否是字母和下划线开头，其他都是字母、数字。下划线

islower() -> bool 是否是全部小写

isupper() -> bool 是否是全部大写

isspace() -> bool  是否只包括空白字符

字符串格式化

format函数格式化字符串语法

• "{} {xxx}".format(*args,**kwargs)  -> str
• args是位置参数，是一个元组
• kwargs是关键字参数，是一个字典
• 花括号表示占位符
• {}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
• {xxx}表示在关键字参数中搜索名称一致的
• {{}}表示打印花括号

位置参数

"{}:{}".format('192.168.1.100',8080)，这就是按照位置顺序用位置参数替换前面的格式字符串的占位符中

关键字参数或命名参数

"{server} {1}:{0}".format(8080,'192.168.1.100',server="Web Server Info:")，位置参数按照序号匹配，关键字参数按照名称匹配

访问元素

"{0[0].0[1]}".format(('jaxzhai','com'))

对象属性访问

from collections import namedtuple
Point = namedtuple('Point','x y')
p = Point(4,5)
"{{{0.x},{0.y}}}".format(p)

对齐

>>'{0}*{1}={2:<2}'.format(3,2,2*3)
'3*2=6 '
>>'{0}*{1}={2:<02}'.format(3,2,2*3)
'3*2=60'
>>'{0}*{1}={2:>02}'.format(3,2,2*3)
'3*2=06'
>>'{:^30}'.format('centered')
'           centered           '
>>'{:*^30}'.format('centered')
'***********centered***********'

进制

>>"int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
'int: 42; hex: 2a; oct: 52; bin: 101010'
>>"int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'
>>octets = [192, 168, 0, 1]
>>'{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'

浮点数

>>print("{}".format(3**0.5))
1.7320508075688772
>>print("{:g}".format(3**0.5))
1.73205
>>print("{:f}".format(3**0.5))
1.732051
>>print("{:10f}".format(3**0.5)) #右对齐
  1.732051
>>print("{:2}".format(102.231)) #宽度为2
102.231
>>print("{:.2}".format(3**0.5))  #2个数字
1.7
>>print("{:.2f}".format(3**0.5)) #小数点后2位
1.73
>>print("{:3.2f}".format(3**0.5)) #宽度为3，小数点后2位
1.73
>>print("{:3.3f}".format(0.2745))
0.275
>>print("{:3.3%}".format(1/3))
33.333%

 

转载于:https://www.cnblogs.com/xzkzzz/p/11011311.html