Python3基础数据类型-字符串

一、昨日内容回顾
1.格式化输出

    % 表示占位符
    %s 表示字符串
    %d 表示数字

2.编码：
    ascii 只能显示英文，特殊字符，数字
    万国码：unicode最开始16位，中文不够32位，4字节
            占用资源多
    升级:utf-8  utf-16  utf-32
    utf-8：最少用一个字节，8位表示一个英文
           欧洲16位，两个字节
           亚洲24位，三个字节

    gbk:中文，两个字节表示中文，只能用于中文和英文

二、数据类型
    1.int
        1,2,3用于计算

    2.bool 布尔型
        TrueFalse 用于判断

    3.str 字符串 用引号引起来的 存储少量数据

    4.list列表 存储大量的数据 可变数据类型
        [1,2,3,'abc',[3,2,1]]

    5.元组tuple 只读
        (1,2,3,'av')

    6.字典dic{}  可变数据类型 存储大量数据
        {'name':'felix','age':30,'id':10024087}

    7.集合：
        {1,2,3,44,'abcd'}

三、int
    1.bit_legth() 返回数字转化为2进制的位数

    a = 37
    print(a.bit_lenth())

    >>> bin(37)
    '0b100101'
    >>> (37).bit_length()
    6

    2.int.from_bytes(cls, *args, **kwargs)
        待了解
    3.int.to_bytes(self, *args, **kwargs)
        (self, *args, **kwargs)

四、bool 布尔值  True  False
    1.int -> str
        s = str(10)

    2. str -> int
        i = int(str('123'))

    3.int -> bool   非零为True，0位False
        i = 5
        bool(i)
            True

    4.bool -> int
        True
        int(True)
            1

        while 1: #效率比True高
            pass
        while True:
            pass

    5.str -> bool 字符为空，返回False,字符为非空，返回为True
        s = 'felix'
        bool(s)
            True

        s = ''
        bool(s)
            False

        总结：0、None、空字符串，空列表、空元祖、空字典 都为Flase
             真值表
        对象          值

        ""            假
        "string"      真
        0             假
        >=1           真
        <=-1          真
        ()空元祖      假
        []空列表      假
        {}空字典      假
        None          假



五、字符串
    1.字符串的定义 初始化
        一个个字符组成的有序的序列，是字符的集合
        使用单引号，双引号，三引号引住的字符序列
    
        字符串是不可变的对象
    
        Python3起，字符串就是Unicode类型
        举例:
            s1 = 'string'
            s2 = "string2"
            s3 = '''this's a 'string' '''
            s4 = 'hello 
 mageedu.com'
            s5 = r "hello 
 mageedu.com"
            s6 = 'c:windows
t'
            s7 = R "c:windows
t"
            s8 = 'c:windows\nt'
            sql = """select * from user where name='tom' """

    2.字符串元素访问--下标
        字符串支持使用索引访问
            sql = """select * from user where name='tom' """
            sql[4] = 'c'  #字符串'c'
    
        有序的字符集合，字符序列
            for c in sql:
                print(c)
                print(type(c))  #什么类型？  str
    
        可迭代
            lst = list(sql)

六、字符串索引和切片
    1.索引index    索引号从左到右依次为 0,1,2...n
                   索引号从右到左依次为 -1,-2,-3 ...n
        s = 'abcdefg'
        s1 = s[0]
            'a'
    2.索引切片  str[start[:end]]  顾头不顾尾  左闭右开
        (1)取单个元素
        s = 'abcdefg'
        s1 = s[2]
            'c'
        (2)取中间部分元素
        s = 'abcdefg'
        s1 = s[1:3]
            'bc'

        (2)取索引号后面所有的元素
        s = 'abcdefg'
        s1 = s[1:]
            'bcdefg'

        (3)取所有元素
        s = 'abcdefg'
        s1 = s[:]
             'abcdefg'

        (3)s[start:end:step] 取步长为step的元素
        s = 'abcdefg'
        s1 = s[0:5:2]
            'ace'

        (4)反着取不包含索引为0的元素
        s = 'abcdefg'
        s1 = s[4:0:-1]
            'edcb'

        (5)反着取包含索引为0的元素
        s = 'abcdefg'
        s1 = s[4::-1]
            'edcba'

        s = 'abcdefg'
        s1 = s[-1::-1]
            'gfedcba'

        s = 'abcdefg'
        s1 = s[::-1]
            'gfedcba'

        (6)反着取包含索引为0的元素，且取指定步长的元素
        s = 'abcdefg'
        s1 = s[4::-2]
            'eca'
        
七、字符串+连接

    +   ->  str
        将2个字符串连接在一起
        返回一个新的字符串

八、字符串join连接

    "string".join(iterable)    ->   str
        将可迭代对象连接起来，使用string作为分隔符
        可迭代对象本身元素都是字符串
        返回一个新字符串

         exp：
            lst = ['1','2','3']
            print(""".join(lst))  #分隔符是双引号
            '1"2"3'
            print(" ".join(lst))
            '1 2 3'
            print("
".join(lst))
            '1
2
3'
    
            lst = ['1',['a','b'],'3']
            print(" ".join(lst))   TypeError: sequence item 1: expected str instance, list found


九、字符串分隔

    分隔字符串的方法分为2类
        1.split系 #切割  返回列表
            将字符串按照分隔符分割成若干字符串，并返回列表 list[]

           (1)split(sep= None,maxsplit=-1)    ->  list of strings
                从左到右
                sep指定分隔符。缺省的情况下空白字符串作为分隔符
                maxsplit指定分隔的次数，-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('super ')  ->  ["I'm 	a ", 'student.']
                s1.split(' ')   ->   ["I'm", '	a', 'super', 'student.']
                s1.split(' ',maxsplit=2)    ->  ["I'm", '	a', 'super student.']
                s1.split(' 	',maxsplit=2)  ->  ["I'm", 'a super student.']
                s1.split(' 	',2)  ->  ["I'm", 'a super student.']


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


                s1 = "I'm 	a super student."
                s1.rsplit()  ->
                s1.rsplit('s')   ->
                s1.rsplit('super')   ->
                s1.rsplit('super ')  ->
                s1.rsplit(' ')   ->
                s1.rsplit(' ',maxsplit=2)    ->
                s1.rsplit(' 	',maxsplit=2)  ->
                s1.rsplit(' 	',2)  ->

            (3)splitlines([keepends])  ->  list of strings
                按照行来分切字符串
                keepends指的是是否保留分隔符
                行分隔符包括
、
、
等

                exp：
                'ab c

de fg
kl
'.splitlines()
                ['ab c', '', 'de fg', 'kl']
                    'ab c

de fg
kl
'.splitlines(True)
                ['ab c
', '
', 'de fg
', 'kl
']

                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."]


        2.partition系***  返回元组

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

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

           exp
               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('')
                   报错 ValueError: empty separator
               s1.partition('abc')
                   ("I'm a super student", '', '')

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

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


十、字符串大小写

    1.upper()
        将字符全部改为大写

    2.lower()
        将字符全部改为小写

    3.swapcase()
        将字符大小写交换

十一、字符串排版
    1.title() ->  str 将字符串标题的每个单词都大写

   s1 = "I'm a super student."
   s1.titile()
      "I'M A Super Student."

    2.capitalize()    ->  str 将字符串首个单词大写

      "I'm a super student."

    3.center(width,[,fillchar])  ->  str   将字符串居中
        width 打印宽带
        fillchar 填充的字符

       s1.center(30)
   "     I'm a super student.     "
   s1.center(30,'*')
   "*****I'm a super student.*****"

    4.zfill(width)   ->  str  width打印宽带，居右，左边用0填充

       s1.zfill(30)
            "0000000000I'm a super student."

    5.ljust(width,[,fillchar])   ->  str 左对齐
        s1.ljust()
            "I'm a super student.          "

    6.rjust(width,[,fillchar])   ->  str 右对齐
        s1.rjust()
        "          I'm a super student."

十二、字符串修改***

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

    exp:
        'www.baidu.com'.replace('w','g')
        'www.baidu.com'.replace('w','g',2)
        'www.baidu.com'.replace('w','g',3)
        'www.baidu.com'.replace('ww','g',2)
        'www.baidu.com'.replace('w','python',2)



    2.strip([chars])  ->  str
        从字符串两端去除指定的字符集chars中的所有字符
        如果chars没有指定，去除两端的空白字符

    exp：
        s = "
 
 	 Hello Python 
 	"
        s.strip()
            'Hello Python'
        s = "I am very very very sorry  "
        s.strip('Iy')
      ' am very very very sorr  '
        s.strip('Iy ')
      'am very very very sorr'
    3.lstrip([chars])  ->  str 从左开始


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



十三、字符串查找*

    1.find(sub,[start[,end]])     ->  int (从0开始的正整数，如果返回-1则表示没有找到)
        在指定的区间[start,end)，从左到右，查找子串sub,找到返回索引，没找到返回-1

    2.rfind(sub,[start[,end]])     ->  int(从0开始的正整数，如果返回-1则表示没有找到)
        在指定的区间[start,end)，从右到左，查找子串sub,找到返回索引，没找到返回-1

        exp:
            s = "I am very very very sorry."
            s.find('very')
                5
            s.find('very',5)
                5
            s.find('very',6,13)
                -1  #未找到
            s.rfind('y',10)
      24
            s.rfind('y',10,15)
      13
            s.rfind('very',-10,-1)
      -1


   3.index(sub,start[,end])  ->  int (从0开始的正整数，如果没有则抛出异常)
        在指定的区间[start,end]，从左到右，查找子串sub,找到返回索引，没找到抛出异常ValueError

   4.rindex(sub,start[,end])  ->  int (从0开始的正整数，如果没有则抛出异常)
        在指定的区间[start,end]，从右到左，查找子串sub,找到返回索引，没找到抛出异常ValueError


    时间复杂度O(n)
        indexfindcount都是O(n)
        随着字符串规模的增大，而效率下降

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

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

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

十四、字符串判断***

    1.endswith(suffix,[,start[,end]])     ->  bool
        在指定的区间[start,end],字符串是否有suffix结尾

    2.startswith(suffix,[,start[,end]])     ->  bool
        在指定的区间[start,end],字符串是否有suffix开头

        exp：
            s = "I am very very very sorry."
            s.startswith('very')
                True
            s.startswith('very',5)
                True
            s.startswith('very',5,9)
                True
            s.endswith('very',5,9)
                True
            s.endswith('very',5,-1)
                False
            s.endswith('very',5,100)
                False

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

    4.isalpha()是否是字母

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

    6.isdigit()是否全部数字（0-9）

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

    8.islower()是否都是小写

    9.isupper()是否都是大写

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

    11.in 或者 not in
        a = 'felix.wang'
        b = 'wang'
        if b in a:
            print(b)
        执行结果：
            wang

    24.有限循环
        s = 'abcdefgh'
        for i in s:
            print(i)


十五、字符串格式化
    字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
        join拼接只能使用分隔符，且要求被拼接的是可迭代对象
        + 拼接字符串还算方便，但是非字符串需要先转化为字符串才能拼接

    1.在2.5版本之前，只能使用print style 风格的printf函数

        print-style formatting，来自C语言的printf函数
        格式要求
            占位符：使用%和格式字符组成，如 %s，%d等
                s调用str，r会调用repr(),所有对象都可以被这两个转换
            占位符中还可以插入修饰字符，例如%03d表示打印3个位置，不够前面补零
            format %values 格式化字符串和被格式的值直接使用%分隔
            values只能是一个对象，或是一个和格式字符串占位符数目相等的元组，或一个字典


        prinf-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'

        '%06.2f%%,0x%x,0x%02x'%(89.7654,10,15)
            '089.77%,0xa,0x0f'

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

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


    2.Python3.0版本之后推荐使用format函数格式字符串语法----Python鼓励使用
        "{}{xxx}".format(*args,**kwargs)    ->  str
        arg是位置参数，是一个元组
        kwargs是关键字参数，是一个字典
        花括号表示占位符
        {}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
        {xxx}表示在关键字参数中搜索名称一致的
        {{}} 表示打印花括号

        (1)位置参数
            "{}:{}".format('192.168.1.100','8888')，这就是按照位置顺序用位置参数替换前面的格式字符串的占位符
                 '192.168.1.100:8888'
        (2)关键字参数或命名参数
            "{server}{1}:{0}".format(8888,'192.168.1.100',server='Web Server Info:')
                'Web Server Info:192.168.1.100:8888'
            位置参数按照序号匹配，关键字参数按照名称匹配

        (3)访问元素
            "{0[0]}.{0[1]}".format(('mageedu','com'))
                'mageedu.com'
        (4)对象属性访问
            from collections import namedtuple
            Point = namedtuple('Point','x y')
            p = Point(4,5)
            "{{{0.x},{0.y}}}".format(p)
                 '{4,5}'

        (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('centerd')
                '           centerd            '

            '{:#^30}'.format('centerd')
                '###########centerd############'

        (6)进制
            "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'

            octes = [192,168,0,1]
            '{:02x}{:02x}{:02x}{:02x}'.format(*octes)  * 把每个元素分解
                'c0a80001'

其他
        a2 = "hqw	"
        #	前面的补全
        # 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
        ret4 = a2.expandtabs()
        print(ret4)