11.python内置数据--字符串

字符串：

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

>>> a = 'ab' + 'c'+ 'd'
>>> type(a)
<class 'str'>
>>> id(a)
12128640
>>> a = 'ab' + 'c'+ 'd'+ 'e'
>>> id(a)
12128672
# 内存分配的空间不一样
>>> a
'abcde'
>>> a[1]
'b'
>>> a[1] = l
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'l' is not defined
# 和列表一样的用法，也是不可改变

字符串的定义和初始化

s1 = 'string'
print(s1)
string
##############################
s2 = "string2"
print(s2)
string2
##############################
s3 = '''this's a "String"'''
print(s3)
this's a "String"
##############################
s4 = 'hello 
 magedu.com'
print(s4)
hello 
 magedu.com
##############################
s5 = r"hello 
 magedu.com"
print(s5)
hello 
 magedu.com
##############################
s6 = 'c:windows
t'
print(s6)
c:windows
t
##############################
s7 = R"c:windows
t"
print(s7)
c:windows
t
##############################
s8 = 'c:windows\nt'
print(s8)
c:windows
t
##############################
sql = """select * from user where name='tom'"""
print(sql)
select * from user where name='tom'

# 注意各种标点和转义符

字符串元素访问

• 字符串支持使用索引访问

sql = """select * from user where name='tom'"""
print(sql[4])
sql[4] = 'o'
print(sql[4])
#######################################
c
# 这里返回的是字符串'c'，而不是字符c
    sql[4] = 'o'
TypeError: 'str' object does not support item assignment
# 这里注意不可进行修改

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

sql = """select * from user where name='tom'"""
for c in sql:
    print(c,end=' ')
print()
print(type(c))
#####################################
s e l e c t   *   f r o m   u s e r   w h e r e   n a m e = ' t o m ' 
<class 'str'>

• 可迭代

sql = """select * from user where name='tom'"""
lst = list(sql)
print(lst)
t = tuple(sql)
print(t)
#######################################
['s', 'e', 'l', 'e', 'c', 't', ' ', '*', ' ', 'f', 'r', 'o', 'm', ' ', 'u', 's', 'e', 'r', ' ', 'w', 'h', 'e', 'r', 'e', ' ', 'n', 'a', 'm', 'e', '=', "'", 't', 'o', 'm', "'"]
('s', 'e', 'l', 'e', 'c', 't', ' ', '*', ' ', 'f', 'r', 'o', 'm', ' ', 'u', 's', 'e', 'r', ' ', 'w', 'h', 'e', 'r', 'e', ' ', 'n', 'a', 'm', 'e', '=', "'", 't', 'o', 'm', "'")

字符串连接

• +连接，a=‘a’，a=‘a’+'b'，a='ab'，将两个字符串连接在一起，返回一个新字符串
• join连接，“string”.join(iterable) -> str
  • 将可迭代对象连接起来，使用string作为分隔符
  • 可迭代对象本身元素都是字符串
  • 返回一个新字符串

a = 'abcd'
b = ' '.join(a)
print(b)
a b c d
###################
c = "@".join(a)
print(c)
a@b@c@d
###################
lst = ['1','2','3']
print(' '.join(lst))
1 2 3
###################
print("
".join(lst))
1
2
3
###################
lst1 = ['1',['a','b'],'3']
print(' '.join(lst1))
Traceback (most recent call last):
  File "D:/untitled/project2/day1/zifuchuan.py", line 2, in <module>
    print(' '.join(lst1))
TypeError: sequence item 1: expected str instance, list foun
# 这种嵌套类型的会报错

字符串分割

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

 1 >>> s1 = "I'm 	a super student."

>>> s1.split()
["I'm", 'a', 'super', 'student.']

>>> s1.split('s')
["I'm 	a ", 'uper ', 'tudent.']

>>> s1.split('super')
["I'm 	a ", ' student.']

>>> s1.split(' ')
["I'm", '	a', 'super', 'student.']

>>> s1.split(' ',2)
["I'm", '	a', 'super student.']

>>> s1.split('	',2)
["I'm ", 'a super student.']

• resplit()是相反的效果。
  • 从右到左，其余的参考split()
• splitlines([keepends]) -> list of strings
  
  • 按照行来切分字符串
  • keepends指的是是否保留行分隔符
  • 行分隔符包括 、 、 等

>>> 'ab c

de fg
k|
'.splitlines()
['ab c', '', 'de fg', 'k|']
# 行分隔符包括
、
、
等等

>>> 'ab c

de fg
k|
'.splitlines(True)
['ab c
', '
', 'de fg
', 'k|
']
#True保留行分隔符

>>> s1 = '''I'm a super student.You're a super teacher.'''
>>> print(s1)
I'm a super student.You're a super teacher.

>>> print(s1.splitlines())
["I'm a super student.You're a super teacher."]

>>> print(s1.splitlines(True))
["I'm a super student.You're a super teacher."]

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

>>> s1 = "I'm a super student."
>>> s1.partition('s')
("I'm a ", 's', 'uper student.')

>>> s1.partition('stu')
("I'm a super ", 'stu', 'dent.')

>>> s1.partition('')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: empty separator
# 分隔符不能为空 

>>> s1.partition(' ')
("I'm", ' ', 'a super student.')

>>> s1.partition('abc')
("I'm a super student.", '', '')

• • rpartition(sep) -> (head,sep,tail)
    
    • 从右到左，从左到右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没有找到分隔符，就返回2个空元素和尾的三元组

字符串的大小写

• upper() -> 全大写
• lower() -> 全小写
• 大小写，做判断的时候用
• swapcase() -> 交互大小写

>>> s1 = "I'm a super student."
>>> s1.upper()
"I'M A SUPER STUDENT."

>>> s1.lower()
"i'm a super student."

>>> s1.swapcase()
"i'M A SUPER STUDENT."

字符串排版

• title() -> str
  • 标题的每个单词都大写
• capitalize() -> str
  • 首个单词大写
• center(width[,fillchar]) -> str
  • width 打印宽度
  • fillchar 填充的字符
• zfill(width) -> str
  • width 打印宽度，居右，左边用0填充
• ljust(width[,fillchar]) -> str 左对齐
• rjust(width[,fillchar]) -> str 右对齐

>>> s = "I'm a super STUDENT."
>>> s.title()
"I'M A Super Student."

>>> s.capitalize()
"I'm a super student."

>>> s.center(20)
"I'm a super STUDENT."

>>> s.center(50)
"               I'm a super STUDENT.               "

>>> s.center(50,'#')
"###############I'm a super STUDENT.###############"

>>> s.zfill(50)
"000000000000000000000000000000I'm a super STUDENT."

>>> s.ljust(50,'#')
"I'm a super STUDENT.##############################"

>>> s.rjust(50,'#')
"##############################I'm a super STUDENT."

字符串修改

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

>>> 'www..magedu.com'.replace('w','p')
'ppp..magedu.com'

>>> 'www..magedu.com'.replace('w','p',2)
'ppw..magedu.com'

>>> 'www..magedu.com'.replace('w','p',1)
'pww..magedu.com'

>>> 'www..magedu.com'.replace('ww','p',2)
'pw..magedu.com'

>>> 'www..magedu.com'.replace('www','python',2)
'python..magedu.com'

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

>>> s = "
 
 	 Hello Python 
 	"
>>> s.strip()
'Hello Python'
# 默认去掉两端的空白字符

>>> s1 = " I am very very very sorry    "
>>> s1.strip()
'I am very very very sorry'

>>> s1.strip('r')
' I am very very very sorry    '
# 因为首尾两端都没有r，因此无修改

>>> s1.strip('r y')
'I am very very very so'
# 这里要注意，去除的是r、空格和y这三个字符，首端查找有空格去掉，尾端先去掉空格，再去掉字符y，再去掉两个字符r

>>> s1.strip('r yIamso')
'very very ve'

>>> s1.lstrip('r yIamso')
'very very very sorry    '

>>> s1.rstrip('r yIamso')
' I am very very ve'
>>>

 字符串查找

• 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')
5
# 每一个字母每一个空格都算一个字符
# 且从0开始算起，I+空格+a+m+空格，正好第6个是very，因此返回5
>>> s.find('very',5)
5
# 表示是从第5个开始查
>>> s.find('very',6,13)
-1
# 表示是从第6个开始查，到第13个结束，查询不到返回-1的结果
>>> info = 'abca'
>>> info.find('a')
0
# 从下标0开始，查找在字符串里第一个出现的子串，返回结果0
>>> info.find('a',1)
3
# 从下标1开始，查找在字符串里第一个出现的子串：返回结果3
>>> info.find('3')
-1
# 查找不到返回-1

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

>>> a = "I am very very very sorry"
>>> a.index('very')
5
>>> a.index('very',5)
5
>>> a.index('very',6,13)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> a.rindex('very',10)
15
>>> a.rindex('very',10,15)
10
>>> a.rindex('very',-10,-1)
15
# 注意与find()比较

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

>>> a = "I am very very very sorry"
>>> a.rindex('very',10)
15
>>> a.rindex('very',10,15)
10
>>> a.rindex('very',-10,-1)
15
>>> a.count('very')
3
>>> a.count('very',5)
3
>>> a.count('very',10,14)
1
# 注意，count是统计个数的

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

字符串判断

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

>>> a = "I am very very very sorry"
>>> a.startswith('very')
False
>>> a.startswith('very',5)
True
>>> a.startswith('very',5,9)
True
>>> a.endswith('very',5,9)
True
>>> a.endswith('very',5)
False
>>> a.endswith('very',5,-1)
False
>>> a.endswith('very',5,100)
False
>>> a.endswith('sorry',5)
True
>>> a.endswith('sorry',5,-1)
False
>>> a.endswith('sorry',5,100)
True
# 注意左闭右开，5,9是从第5个字串开始到第8个字串，不含第9个

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

字符串格式化(C语言风格)

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

>>> "I am %03d" % (20,)
'I am 020'
# (20,)表示20是元组的一个元素，后面加逗号
>>> "I am %013d" % (20,)
'I am 0000000000020'
# %013d表示占了13位的字符(加上括号中的20一共13位)，前面不够补0
>>> "I am %03d" % (20)
'I am 020'
# 也可以是单纯的一个对象20
>>> "I am %013d" % ([20])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: %d format: a number is required, not list
# 提示values不能是列表
>>> "I am %013d" % (20,21)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: not all arguments converted during string formatting
# 格式字符串和被格式的值是一一对应的，数目必须一样
>>> 'I like %s.' % 'Python'
'I like Python.'
>>> '%3.2f%%,0x%x,0X%02X' % (89.7654,10,15)
'89.77%,0xa,0X0F'
# 同符号双次或者转义符，%%才能打印出%
# %3.2f%%中的3指的是占3个有效字符，2指的是小数位取2位数字
# 0x%x是将10转换成16进制数
>>> "I am %50s%%" % (20)
'I am                                                 20%'
>>> "I am %-5d" % (20,)
'I am 20   '
>>> "I am %5d" % (20,)
'I am    20'
# -表示左对齐

字符串格式化(Python风格)

• format函数格式字符串语法——Python鼓励使用
  • "{} {xxx}".format(*args, **kwargs) -> str
  • args是位置参数，是一个元组或者列表
  • kwargs是关键字参数，是一个字典
  • 花括号表示占位符
  • {}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
  • {xxx}表示在关键字参数中搜索名称一致的
  • {{}}表示打印花括号
• 位置参数
  • "{}:{}".format('192.168.1.100',8888)，这就是按照位置顺序用位置参数替换前面的格式字符串的占位符中
• 关键字参数或命名参数
  • ”{server} {1}:{0}".format(8888,'192.168.1.100', server='Web Server Info : ')，位置参数按照序号匹配，关键字参数按照名词匹配
• 访问元素
  • “{0[0]}.{0[1]}".format(('magedu','com'))
• 对象属性访问
  • from collections import namedtuple
  • Point = namedtuple('Point','x y')
  • p = Point(4,5)
  • "{{{0.x},{0.y}}}".format(p)

"{}:{}".format('192.168.1.100',8888)
'192.168.1.100:8888'
>>> "{server}{1}:{0}".format(8888,'192.168.1.100',server = 'Web Server Info:')
'Web Server Info:192.168.1.100:8888'
>>> "{0[0]}.{0[1]}".format(('magedu','com'))
'magedu.com'
>>> from collections import namedtuple
>>> Point = namedtuple('Point','x y')
>>> p = Point(4,5)
>>> "{{{0.x},{0.y}}}".format(p)
'{4,5}'
>>>

• 对齐

>>> '{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'
>>> '{0}*{1}={2:>2}'.format(3,2,2*3)
'3*2= 6'
# <是往右对齐，>是往左对齐

>>> '{:^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'
# 第一个是十进制,第二个十六进制2*16+a=32+10=42,第三个权重5*8+2=42

>>> "int:{0:d}; hex:{0:#x}; oct:{0:#o}; bin:{0:#b}".format(42)
'int:42; hex:0x2a; oct:0o52; bin:0b101010'
>>> "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'
# C0是192，A8是168，00是0，01是1