python内置函数字符串

一、字符串定义初始化

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

二、字符串元素访问

1、 字符串支持使用索引访问   

• sql = "select * from user where name='tom'"   
• sql[4]  字符串访问   
• sql[4] = 'o'  字符串赋值能否成功？  （不能赋值）
• >>> sql = "select * from user where name='tom'"
  >>> sql
  "select * from user where name='tom'"
  >>> sql[4]
  'c'
  >>> sql[4] = 'o'
  Traceback (most recent call last):
    File "<pyshell#52>", line 1, in <module>
      sql[4] = 'o'
  TypeError: 'str' object does not support item assignment
  >>>

2、有序的字符集合，字符序列可迭代   

• >>> for x in sql:
•  print(x)

三、字符串join连接

•  将可迭代对象连接起来，使用string作为分隔符
•  可迭代对象本身元素都是字符串，返回一个新字符串
• lst1 + lst2： 将2个字符串连接在一起，返回一个新的字符串
• 举例：
  • >>> lst = ['1','2','3']
    >>> print(""".join(lst))    分隔符是双引号
    1"2"3
    >>> print(" ".join(lst))     空格分隔
    1 2 3
    >>> print(" ".join(lst))　换行分隔
    1
    2
    3
    >>>
  • >>> lst = ['1','2','3']
    >>> lst1 = ['1',['a','b'],'3']
    >>> lst + lst1          将2个字符串连接在一起，返回一个新的字符串
    ['1', '2', '3', '1', ['a', 'b'], '3']

四、字符串分割

分割字符串的方法有两种
  1、split：从左至右，将字符串按照分隔符分割成若干字符串，并返回列表

•    格式:split(sep=None,maxslit=-1)
•    sep指定分割符字符串，缺省的情况下空白字符串作为分隔符
•    maxslit指定分割的次数，-1表示遍历整个字符串
•    rsplit: 从右向左　
• 举例：
  • s1 = "I'm a super student."
  • >>> s1.split(' ')　　 以空格为分隔符
    ["I'm", ' a', 'super', 'student.']   
    >>> s1.split('s')        以s为分隔符
    ["I'm a ", 'uper ', 'tudent.']       
    >>> s1.split('super')   　以super为分隔符　      
    ["I'm a ", ' student.']
    >>> s1.split(' ',maxsplit=-1)     以空格遍历分隔
    ["I'm", ' a', 'super', 'student.']
    >>> s1.split(' ',maxsplit=1)    以空格分隔一次
    ["I'm", ' a super student.']
    >>> s1.split(' ',maxsplit=2)    以空格分隔两次
    ["I'm", ' a', 'super student.']
    >>> s1.split(' ',maxsplit=2)    以 a分隔两次
    ["I'm ", 'a super student.']　　　　　

2、splietlines([keepends])

•    按照行来切分字符串 
•    keepends指的是是否保留分隔符
•    行分隔符包括 , , 等
•    举例：
  • s2 = '''I'm a super student.　　
        You're a super teacher.
       '''
  • >>> print(s2)　　
    I'm a super student.
    You're a super teacher.
    >>> print(s2.splitlines())
    ["I'm a super student.", " You're a super teacher.", ' ']
    
    >>> print(s2.splitlines(True))
    ["I'm a super student. ", " You're a super teacher. ", ' ']
    >>>

 3、partition(sep): 将字符串按照分隔符分割成2段，返回这2段和分隔符的元组

• 从左至右，遇到分隔符就把字符串分割成两部分，返回头，分隔符，尾三部分的三元组
• 如果没有找到分隔符，就返回头，2个空元素的三元组
• sep分割字符串，必须制定
• rpartition(sep) 从右至左
• 举例：
  • >>> s1 = "I'm a supper student."
  • 
    >>> s1.partition('s')
    ("I'm a ", 's', 'upper student.')
  • 
    >>> s1.partition('stu')
    ("I'm a supper ", 'stu', 'dent.')
    
    >>> s1.partition(' ')
    ("I'm", ' ', 'a supper student.')
  • 
    >>> s1.partition('abc')
    ("I'm a supper student.", ' ', ' ')

 五、字符串修改

1、replace(old, new[,count])

•    字符串中找到匹配替换为新子串，返回新字符串
•    count表示替换几次，不指定就是全部替换
• 举例：
• >>> s = 'www.magede.com'
  • 全部替换　　
    >>> s.replace('w', 'p')
    'ppp.magede.com'
  • 替换两次
    >>> s.replace('w', 'p',2)
    'ppw.magede.com'
  • 替换两次
    >>> s.replace('ww', 'p', 2)
    'pw.magede.com'
  • 替换两次
    >>> s.replace('www', 'python',2)
    'python.magede.com'
    >>>

 2、strip([chars])

• 从字符串两端去除指定的字符集chars中的所有字符，如果chars没有指定，去除两端的空白字符
• 举例：
  • >>> s = " Hello Python "　　
    >>> s.strip()
    'Hello Python'
  • >>> s = " I am very very very sorry "
    >>> s.strip('ly')
    ' I am very very very sorry '
    >>> s.strip('ly ')
    'I am very very very sorr'

六、字符串查找

1、find(sub[,start[,end]])

•   在指定的区间【start，end】，从左至右，查找子串sub，找到返回索引，没有找到返回-1
•   rfind： 从右至左
• 举例：
  • >>> s = " I am very very very sorry "　　
    >>> s.find('very')
    6
    >>> s.find('very',5)
    6
    >>> s.find('very',5,10)
    6
    >>> s.find('very',15)
    16
    >>>

2、index(sub[,start[,end]])

•    在指定的区间【start，end】，从左至右，查找子串sub，找到返回索引，没有找到抛出异常ValueError,时间复杂度是O(n)
• 举例：
  • >>> s = " I am very very very sorry "　　
    >>> s.index('very')
    6
    >>> s.index('very',5)
    6

3、count(sub[,start[,end]])

• 在指定的区间【start，end】，从左至右，统计子串sub出现次数，时间复杂度是O(n)
• 举例：　　
  • >>> s = " I am very very very sorry "　　
    >>> s.count('very')
    3
    >>> s.count('very',5)
    3
    >>>

七、字符串判断

1、endswitch(suffix[,start[,end]])

•    在指定的区间【start，end】，字符串是否是suffix结尾

2、 startswitch(prefix[,start[,end]])

•    在指定的区间【start，end】，字符串是否是prefix开头

八、字符串格式化

•   字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
•    join拼接只能使用分隔符，且要求被拼接的是可迭代对象
•    + 加号拼接字符串还算方便，但是非字符串需要先转换为字符串才能拼接
•   在2.5版本之前，只能使用c语言printf style风格的print输出，格式要求占位符：使用%和格式字符组成，例如%d， %s等

1、使用format函数格式字符串语法

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

2、位置参数

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

3、关键字参数或命名参数

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

4、访问元素

• "{0[0]}:{0[1]}".format(('magedu','com'))
• >>> "{0[0]}:{0[1]}".format(('magedu','com'))
  'magedu:com'

5、对象属性访问

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

 6、 对齐

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

 7、进制

•    "int.{0:d};hex:{0:x}; oct:{0:o}; bin:{0:b}".format(42)
  • >>> "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.{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,]
•    '{:02x}{:02x}{:02x}{:02x}'.format(*octets)
  • >>> octets = [192,168,0,1]　　
    >>> '{:02x}{:02x}{:02x}{:02x}'.format(*octets)
    'c0a80001'
    >>>

 注意： 请使用format函数格式化字符串