Python-字符串学习笔记（完）

╰+哭是因爲堅強的太久メ 2023-02-15 07:59 10阅读 0赞

### 文章目录 ###

*   *   *  字符串
         *   *  基本特点
             *  编码
             *  表示方式（创建）
             *  转义字符
             *  字符串拼接
             *  字符串复制
             *  常见操作
             *   *  1. 获取长度
                 *  2. 查找内容
                 *  3. 判断
                 *  4. 计算出现次数
                 *  5. 替换内容
                 *  6. 切割字符串
                 *  7. 修改大小写
                 *  8. 空格处理
                 *  9. 字符串拼接
                 *  10. 加密解密(映射替换)
                 *  11. 字符串前补0
             *  切片（slice）
             *  字符串驻留机制
             *  可变字符串

### 字符串 ###

#### 基本特点 ####

字符串的本质是：字符序列。Python的字符串是不可变的。

Python不支持单字符类型，单字符也是作为一个字符串使用的。

#### 编码 ####

*  Python3直接支持Unicode，可以表示世界上任何书面语言的字符。Python3的字符默认就是16位Unicode编码，ASCII码是Unicode编码的子集。
 *  使用内置函数`ord()`获取字符对应的编码。
 *  使用内置函数`chr()`根据编码获取对应的字符。

>>> ord('马')
    39532
    >>> chr(39532)
    '马'

#### 表示方式（创建） ####

a = "I'm Tom"  # 一对双引号
    
    b = 'Tom said:"I am Tom"'  # 一对单引号
    
    c = '''Tom said:"I'm Tom"'''  # 一对三个单引号
    
    d = """Tom said:"I'm Tom" """  # 一对三个双引号

#### 转义字符 ####

使用 `\`来表示一个转义字符，`\`在行尾时，表示续行符。

*  `\n` 表示一个换行
 *  `\t` 表示一个tab
 *  `\'` 显示一个普通的单引号
 *  `\"` 显示一个普通的双引号
 *  `\\` 表示一个普通的反斜线
 *  `\r` 表示一个回车
 *  `\b` 表示一个退格（backspace）

注：**在python中，在字符串的前面添加r，表示原生字符串**

k = r'good mor\ning'
    print(k)  # good mor\ning

#### 字符串拼接 ####

*  str + str
 *  空格

注：这两种方式都会生成新的字符串对象

>>> 'a' + 'b'
    'ab'
    >>> 'c' 'd'
    'cd'

#### 字符串复制 ####

*  str \* int

>>> 'jack'*3
    'jackjackjack'

#### 常见操作 ####

##### 1. 获取长度 #####

*  len函数可以获取字符串的长度
    
        mystr = '今天天气好晴朗，处处好风光呀好风光'
        print(len(mystr))  # 17 获取字符串的长度

##### 2. 查找内容 #####

*  find
    
     *  返回所查找的内容在字符串中第一次出现的开始位置索引值，如果不存在，返回-1
     *  `S.find(sub[, start[, end]]) -> int`
 *  rfind
    
     *  类似于 find()函数，不过是从右边开始查找
        
            str1 = 'hello'
            print(str1.rfind('l'))  # 3
 *  index
    
     *  与find()方法一样，只不过，find方法未找到时，返回 -1 ，而index未找到时，会报一个异常
 *  rindex
    
     *  类似于 index()，不过是从右边开始

##### 3. 判断 #####

*  startswith
    
     *  判断字符串是否以指定内容开始
     *  `S.startswith(prefix[, start[, end]]) -> bool`
        
            print('hello'.startswith('he'))  # True
 *  endswith
    
     *  判断字符串是否以指定内容结束
     *  `S.endswith(suffix[, start[, end]]) -> bool`
        
            print('hello'.endswith('o'))  # True
 *  isalpha
    
     *  判断字符串是否是纯字母
        
            mystr = 'hello world'
            print(mystr.isalpha()) # False 因为中间有空格
 *  isdigit
    
     *  判断一个字符串是否是纯数字，只要出现非0~9的数字，结果就是False
        
            print('good'.isdigit())  # False
            
            print('123'.isdigit())  # True
            
            print('3.14'.isdigit())  # False
 *  isalnum
    
     *  判断是否由数字和字母组成。只要出现了非数字和字母，就返回False
        
            print('hello123'.isalnum())  # True
            print('hello'.isalnum())  # True
 *  isspace
    
     *  如果字符串中只包含空格，则返回 True，否则返回 False
        
            print('  '.isspace())  # True
 *  isascii
    
     *  如果字符串中的所有字符都是ASCII，则返回True；否则返回False。
     *  判断时必须是字符串形式，否则会报错
        
            a = 'a'
            print(a.isascii())  # True
 *  isupper
    
     *  字符串中所有的字母都为大写，则返回True；否则返回False
        
            b = 'Hello'
            print(b.isupper())  # False
            c = 'LUCY'
            print(c.isupper())  # True
 *  islower
    
     *  字符串中所有的字母都为小写，则返回True；否则返回False
        
            b = 'Hello'
            print(b.islower())  # False
            c = 'lucy'
            print(c.islower())  # True
 *  isnumeric
    
     *  检测字符串是否只由数字组成。这种方法是只针对unicode对象
        
         *  这里的数字包括：阿拉伯数字、罗马数字、中文简体数字、中文繁体数字
     *  定义一个字符串为Unicode，只需要在字符串前添加 ‘u’ 前缀即可
        
            str1 = u"一壹①②③⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩ❶❷❸❺❺❻❼❽❾❿2009"
            print(str1.isnumeric())  # True
 *  isprintable
    
     *  判断是否为可打印字符串，如果所有字符都是可打印的，则返回 True，否则返回 False
     *  不可打印的字符可以是回车、换行符、制表符
        
            str1 = 'abc'
            print(str1.isprintable())  # True
        
            str2 = 'abc\tdef'
            print(str2.isprintable())  # False
 *  istitle
    
     *  判断是否首字母大写，其他字母小写
        
            str1 = 'LuCy'
            print(str1.istitle())  # False
            str2 = 'Lucy Ha'
            print(str2.istitle())  # True
 *  isidentifier
    
     *  判断字符串是否是有效的 Python 标识符
        
            str1 = 'True'
            print(str1.isidentifier())  # True 关键字作为变量名检测不出来
            str2 = '3abc'
            print(str2.isidentifier())  # False
            str3 = 'username'
            print(str3.isidentifier())  # True
     *  如果字符串仅包含字母数字或下划线，则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格
 *  isdecimal
    
     *  如果字符串是否只包含十进制字符返回True，否则返回False
        
            str1 = u"this2009"
            print(str1.isdecimal())  # False
            str2 = u"23443434"
            print(str2.isdecimal())  # True
     *  这种方法只存在于unicode对象

##### 4. 计算出现次数 #####

*  count
    
     *  返回 所查询字符串 在start和end之间 在 原字符串 里面出现的次数
     *  `S.count(sub[, start[, end]]) -> int`
        
            str1 = 'hello'
            print(str1.count('l'))  # 2

##### 5. 替换内容 #####

*  replace
    
     *  替换字符串中指定的内容，如果指定次数count，则替换不会超过count次
     *  `replace(self, old, new, count)`
        
            msg = '他很牛逼，他很秀，他很帅'
            msg1 = msg.replace('他', 'lucy')  # 默认全部替换
            msg2 = msg.replace('他', 'lucy', 2)  # 从左至右，替换前两个
            print(msg1)  # lucy很牛逼，lucy很秀，lucy很帅
            print(msg2)  # lucy很牛逼，lucy很秀，他很帅
        
         *  所要替换的字符不在字符串中也不会报错
            
                s1 = 'abcd'
                print(s1.replace('lucy', 'cc'))  # abcd
     *  整个过程中，实际上是创建了新的字符串，原字符串并没有改变。

##### 6. 切割字符串 #####

*  split
    
     *  可以将一个字符串切割成一个列表
     *  默认最大分割数为-1，表示无限制，可以省略；也可以自己指定最大分割数
        
            x = 'zhangsan-hahaha-tom-tony-lucy'
            y = x.split('-', -1)
            z = x.rsplit('-')
            print(y)  # ['zhangsan', 'hahaha', 'tom', 'tony', 'lucy']
            print(z)  # ['zhangsan', 'hahaha', 'tom', 'tony', 'lucy']
        
            x = 'zhangsan-hahaha-tom-tony-lucy'
            print(x.split('-', 2))  # ['zhangsan', 'hahaha', 'tom-tony-lucy']
        
            x = '-hahaha-tom-tony-lucy'
            y = x.split('-')
            
            print(y)  # ['', 'hahaha', 'tom', 'tony', 'lucy']
     *  默认按照空格、换行符、制表符分割
        
            s = 'my name is lucy'
            s1 = s.split()
            print(s1)  # ['my', 'name', 'is', 'lucy']
 *  rsplit
    
     *  用法和split基本一致，只不过是从右往左分割
        
            x = 'zhangsan-hahaha-tom-tony-lucy'
            print(x.rsplit('-', 2))  # ['zhangsan-hahaha-tom', 'tony', 'lucy']
 *  splitlines
    
     *  按照行分隔，返回一个包含各行作为元素的列表
        
            str1 = 'hello\nworld'
            print(str1.splitlines())  # ['hello', 'world']
 *  partition
    
     *  指定一个字符串str作为分隔符，将原字符串分为三部分，str前，str，str后。这三部分组成一个元组
        
            print('agdaXhhXhjjs'.partition('X'))  # ('agda', 'X', 'hhXhjjs')
 *  rpartition
    
     *  类似于partition()函数，不过是从右边开始
        
            print('agdaXhhXhjjs'.rpartition('X'))  # ('agdaXhh', 'X', 'hjjs')

##### 7. 修改大小写 #####

*  capitalize
    
     *  第一个单词的首字母大写
        
            mystr = 'hello world'
            print(mystr.capitalize()) # Hello world
 *  title
    
     *  每个单词的首字母大写
        
            mystr = 'hello world'
            print(mystr.title()) # Hello World
 *  lower
    
     *  所有都变成小写
        
            mystr = 'hElLo WorLD'
            print(mystr.lower()) # hello world
 *  upper
    
     *  所有都变成大写
        
            mystr = 'hello world'
            print(mystr.upper())  #HELLO WORLD
 *  `casefold()`
    
     *  将字符串中的所有大写字母转换为小写字符
        
            s1 = 'I Love Python'
            print(s1.casefold())  # i love python
 *  `swapcase()`
    
     *  将字符串中小写转为大写，大写转为小写
        
            s1 = 'I Love Python'
            print(s1.swapcase())  # i lOVE pYTHON

##### 8. 空格处理 #####

*  ljust
    
     *  返回指定长度的字符串，并在右侧使用空白字符补全(左对齐)
        
            str = 'hello'
            print(str.ljust(10))  # hello     在右边补了五个空格
     *  如果本身长度大于指定长度，则不做任何处理
     *  可以指定填充字符，默认是空格
        
            print('lucy'.ljust(10, '+'))  # lucy++++++
 *  rjust
    
     *  返回指定长度的字符串，并在左侧使用空白字符补全(右对齐)
        
            str = 'hello'
            print(str.rjust(10))  #      hello在左边补了五个空格
     *  可以指定填充字符，默认是空格
 *  center
    
     *  返回指定长度的字符串，并在两端使用空白字符补全(居中对齐)
        
            str = 'hello'
            print(str.center(10))  #  hello   两端加空格，让内容居中
     *  可以指定填充字符，默认是空格
 *  去除前后空白，空白有：空格、\\t（制表符）、\\n（换行符）
    
     *  lstrip
        
         *  删除字符串左边的空白字符
            
                mystr = '    he   llo      '
                print(str.lstrip())  #he   llo      只去掉了左边的空格，中间和右边的空格被保留
     *  rstrip
        
         *  删除字符串右边的空白字符
            
                mystr = '    he   llo      '
                print(str.rstrip())  #    he   llo右边的空格被删除
     *  strip
        
         *  删除字符串两边的空白字符
            
                str = '    he   llo      '
                print(str.strip())  #he   llo
         *  指定删除字符
            
                s = 'fgk太k白ser'
                s1 = s.strip('fkgres')  # 前后同时进行
                print(s1)  # 太k白
 *  `expandtabs()`
    
     *  把字符串中的 tab 符号(’\\t’)转为空格，tab 符号(’\\t’)默认的空格数是 8
        
            s1 = 'a\tbcd'
            print(s1)
            print(s1.expandtabs())
            print(s1.expandtabs(tabsize=4))
            print(s1.expandtabs(tabsize=0))
            # a	bcd
            # a       bcd
            # a   bcd
            # abcd

##### 9. 字符串拼接 #####

*  join
    
     *  `S.join(iterable)`
        
            s = 'lucy'
            s1 = '+'.join(s)
            print(s1)  # l+u+c+y
        
            print('+'.join({'name': 'lucy', 'age': 18}))  # name+age
     *  作用：可以把列表或者元组快速的转变成为字符串，并且以指定的字符分隔
        
         *  前提：列表或者元组里面的元素必须都是 str 类型
            
                l1 = ['my', 'name', 'is', 'lucy']
                s1 = ' '.join(l1)
                print(s1)  # my name is lucy
     *  建议使用这种方式进行字符串拼接，效率比 str+str 高，因为 join 只创建一次字符串对象。

##### 10. 加密解密(映射替换) #####

*  maketrans
    
    创建字符映射的转换表。
    
    `str.maketrans(intab, outtab，delchars)`
    
        intab -- 字符串中要替代的字符组成的字符串。
        outtab -- 相应的映射字符的字符串。
        delchars -- 可选参数，表示字符串中的每个字符都会被映射为None
        
        intab和outtab都是字符串，且长度必须相等
 *  translate
    
    根据`maketrans()`函数给出的转换表来转换字符串中的字符。
    
    注：先过滤（转为None），然后转换

in_str = 'afcxyo'
    out_str = '123456'
    
    # maketrans()生成转换表，必须使用str调用
    # map_table的类型是字典
    map_table = str.maketrans(in_str, out_str)
    
    # 使用translate()进行转换
    my_love = 'I love fairy'
    new_my_love = my_love.translate(map_table)
    
    print(new_my_love)  # I l6ve 21ir5

in_str = 'afcxyo'
    out_str = '123456'
    
    # maketrans()生成转换表，必须使用str调用
    map_table = str.maketrans(in_str, out_str, 'yo')
    
    # 使用translate()进行转换
    my_love = 'I love fairy'
    new_my_love = my_love.translate(map_table)
    
    print(new_my_love)  # I lve 21ir

##### 11. 字符串前补0 #####

*  `zfill()`
    
     *  返回指定长度的字符串，原字符串右对齐，前面填充 0
    
        a = 3
        b = str(a).zfill(4)
        print(b)  # 0003
    
     *  使用场景
    
    字符串格式的数字在排序时跟我们预想的不太一样，比如11排在2前面，这样就带来了一些问题，比如合并一些用数字命名的文件时，合并文件的顺序可能就发生变化了，那么在数字前面填充0，让这些数字的长度保持一致，问题就解决了。

#### 切片（slice） ####

切片：就是从字符串里复制一段指定的内容，**生成一个新的字符串**。

`m[start:end:step]` 顾头不顾尾

*  step：步长。默认为1
    
        m = 'abcdefghigklmnopqrstuvwxyz'
        print(m[2:9])  # cdefghi
    
    步长不能为0，否则报错
    
        m = 'abcdefghigklmnopqrstuvwxyz'
        print(m[2:9:0])  # 报错
 *  步长为负数时，表示从右往左获取
    
        m = 'abcdefghigklmnopqrstuvwxyz'
        print(m[3:15:-1])  # 没有数据
        print(m[15:3:-1])  # ponmlkgihgfe
 *  start和end如果是负数时，表示索引从右边数
    
        m = 'abcdefghigklmnopqrstuvwxyz'
        print(m[-9:-5])  # rstu
 *  倒序
    
        m = 'abcdefghigklmnopqrstuvwxyz'
        print(m[::-1])  # zyxwvutsrqponmlkgihgfedcba
 *  如果只设置了start，会“截取”到最后
    
        m = 'abcdefghigklmnopqrstuvwxyz'
        print(m[2:])  # cdefghigklmnopqrstuvwxyz
 *  如果只设置了end，会从头开始“截取”
    
        m = 'abcdefghigklmnopqrstuvwxyz'print(m[:9])  # abcdefghi
 *  如果 start 、end 不在 `[0, 字符串长度 - 1]` 这个范围内，也不会报错
    
        m = 'abcdefghigklmnopqrstuvwxyz'
        print(m[-100:-1])  # abcdefghigklmnopqrstuvwxy

#### 字符串驻留机制 ####

字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。

Python支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（\_）、字母和数字）会启用字符串驻留机制驻留机制。

>>> a = 'abc_123'
    >>> b = 'abc_123'
    >>> a is b
    True
    >>> c = 'abc#'
    >>> d = 'abc#'
    >>> c is d
    False

#### 可变字符串 ####

在Python中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能创建新的字符串对象。但是，经常我们确实需要原地修改字符串，可以使用`io.StringIO对象`或`array模块`，不会创建新的字符串。

>>> import io
    >>> s = 'hello, Lucy'
    >>> sio = io.StringIO(s)
    >>> sio
    <_io.StringIO object at 0x7f8bbfdd8948>
    >>> sio.seek(4)
    4
    >>> sio.write('k')
    1
    >>> sio.getvalue()
    'hellk, Lucy'