字符串：

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

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

    字符串是不可变对象；

    

    python3起，字符串就是Unicode类型


字符串定义 初始化

举例：

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

字符串元素访问——下标

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

sql = """select * from user where name='tom';"""

sql[4]   # 字符串'c'

sql[4] = 'o' #这样做行吗？？？

TypeError: 'str' object does not support item assignment
切记：字符串是不可变对象；


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

for c in sql:
    print(c)
    print(type(c))

可迭代

lst = list(sql)
print(lst)


字符串join连接*

S.join(iterable) -> str

    将可迭代对象连接起来，使用string作为分隔符；

    可迭代对象本身元素都是字符串；

    返回一个新字符串；

lst = ['1','2','3']
print("\"".join(lst)) #分隔符是双引号

>>> 1"2"3

print("\n".join(lst))
print(" ".join(lst))

lst = ['1',['a','b'],'3']

print(" ".join(lst))
TypeError: sequence item 1: expected str instance, list found


字符串 + 连接

+ -> str

    将2个字符串连接在一起；

    返回一个新字符串

print('ab'+'de')


字符串分割

分割字符串的方法分为2类：

    split类

        将字符串按照分隔符分割成若干字符串，并返回列表

    partition系

        将字符串按照分隔符分割成2段，返回这2段和分隔符的元组

split:

S.split(sep=None, maxsplit=-1) -> list of strings
    从左至右；
    sep指定分割字符串，缺省的情况下空白字符串作为分隔符；
    maxsplit指定分割的次数，-1表示遍历整个字符串;
s1 = "I'm \ta super student."

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

s1.split('s')
["I'm \ta ", 'uper ', 'tudent.']

s1.split('super')
["I'm \ta ", ' student.']

s1.split(' ',maxsplit=2)
["I'm", '\ta', 'super student.']

rsplit:

S.rsplit(sep=None, maxsplit=-1) -> list of strings
    从右至左；
    sep指字分隔字符串，缺省的情况下空白字符串作为分隔符；
    maxsplit指字分割的次数， -1 表示遍历整个字符串；


splitlines:

S.splitlines([keepends]) -> list of strings
    按照行来切分字符串；
    keepends指的是是否保留行为隔符；
    行分隔符包括\n 、\r\n 、 \r等；
'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']

'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']


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.\n", "You're a super teacher."]


*partition:

S.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(' ')
("I'm", ' ', 'a super student.')

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

rpartition:

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


字符串大小写:

upper()    全大写
lower()    全小写
swapcase()    交互大小写

字符串排版:

S.title() -> str    标题的每个单词都大写

S.capitalize() -> str     首字单词大写

S.center(width[, fillchar]) -> str    width 打印宽度；fillchar 填充的字符
"china".center(10,'#')
'##china###'

S.zfill(width) -> str         width打印宽度，居右，左边用0填充
"china".zfill(10)
'00000china'

S.ljust(width[, fillchar]) -> str     左对齐
"china".ljust(10)
'china     '

S.rjust(width[, fillchar]) -> str    右对齐
"china".rjust(10)
'     china'

字符串修改*

replace:

S.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('ww','p',2)
'pw.magedu.com'

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

strip:

S.strip([chars]) -> str
    从字符串两端去除指定的字符集chars中的所有字符；
    如果chars没有指定，去除两端的空白字符；
    
s = "\r\n \t Hello Python \n \t"
s.strip()
'Hello Python'

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

S.lstrip([chars]) -> str
    从左开始
    
S.rstrip([chars]) -> str
    从右开始


字符串查找*

S.find(sub[, start[, end]]) -> int
    在指定的区间[strat，end],从左至右，查找子串sub
    
S.rfind(sub[, start[, end]]) -> int
    在指定区间[start[,end]],从右至左，查找子串sub
    
    
s = "I am very very very sorry"

s.find('very')
5

s.find('very',5)
 5

s.find('very',6,13)
 -1

s.find('very',10,15)
10

s.find('very',10)
10

s.find('very',-10,-1)
15

字符串查找

len(string)
    返回字符串的长度，即字符的个数
    
S.count(sub[, start[, end]]) -> int
    在指定的区间[start,end]，从左至右，统计子串sub出现的次数；

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

字符串判断*

S.endswith(suffix[, start[, end]]) -> bool
    在指定的区间，字符串是否是suffix结尾; 
    
S.startswith(prefix[, start[, end]]) -> bool
    在指定的区间，字符串是否是prefix开头;
    
    
    s = "I am very very very sorry"
    
    s.startswith('very')
    False
    
    s.startswith('I')
    True
    
    s.startswith('very',5)
    True
    
    s.startswith('very',5,9)
    True
    
    s.endswith('sorry',5)
    True
    
    s.endswith('sorry',5,-1)
     False
    
    s.endswith('sorry',5,100)
    True


字符串判断is系统:

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


字符串格式化***

字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便

    join拼接只能使用分隔符，且要求被拼接的是可迭代对象

    +拼接字符串还算方便，但是非字符串需要先转换为字符串才能拼接

在2.5版本之前，只能使用printf style风格的print输出

    printf-style formatting，来自于C语言的printf函数

    格式要求：

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

            s调用str()，r会调用repr()。所有对象都可以被这两个转换。

        占位符中还可以插入修饰字符，例如%03d表示打印3个位置，不够前面补零

        format % values，格式字符串和被格式的值之间使用%分隔

        values只能是一个对象，或是一个和格式字符串占位符数目相等的元组，或一个字典


举例：

printf-style formatting风格:

"I am %03d"%(20,)
'I am 020'

'I like %s.'% 'python'
'I like python.'

'%3.2f%%,0x%x,0x%02x' % (89.7654,10,15)
'89.77%,0xa,0x0f'

"I am %-5d" % (20,)
'I am 20   '

format函数格式字符串语法——Python鼓励使用

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

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

关键字参数或命名参数：
    print('{server}{1}:{0}'.format(8888,'192.168.1.100',server='Web Server Info : '))
    Web Server Info : 192.168.1.100:8888
    #位置参数按照序号匹配
    
访问元素：
    print('{0[0]}.{0[1]}'.format(('magedu','com')))
    magedu.com

对象属性访问：
    from collections import namedtuple
    
    Point = namedtuple('Point','x y')
    
    p = Point(4,5)
    
    print('{{{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'

'{:^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'