第6章 python字符串 （字符串的内建函数）

1、序列

1、标准类型操作符

数值的比较   ==   !=

身份的比较   is   is not

2、序列类型操作符

1、成员关系操作符  in  not in 

2、连接操作符    +

print("abc" + "cdf")
print([1, 2, 3] + [6])
print((1, 2, 3, 4) + (6,))

E:\env\python39\python.exe D:\项目\python\deke\test.py 
abccdf
[1, 2, 3, 6]
(1, 2, 3, 4, 6)

3、重复操作符   *

print("i love you" * 4)
print([None] * 4)
print((1, 2) * 4)

E:\env\python39\python.exe D:\项目\python\deke\test.py 
i love youi love youi love youi love you
[None, None, None, None]
(1, 2, 1, 2, 1, 2, 1, 2)

4、切片操作符  [:]   [::]

开始和结束素引值可以超过字符串的 长度

不包含结束位置下标对应的数据， 正负整数均可

numstr = '0123456789'
# 1、从2到5开始切片，步长为1
print(numstr[2:5:1])
print(numstr[2:5])
print(numstr[:5]
print(numstr[1:])
# 4、获取或拷贝整个字符串
print(numstr[:])

# 类似求偶数
print(numstr[::2])
# 类似字符串翻转
print(numstr[::-1])

# 如截取012345678
print(numstr[:-1])

3、内建函数

工厂函数：str()  list()  tuple() 

enumrate() 

print(list(enumerate("abc")))
print(enumerate(["cheng", "xu", "yuan"]))

E:\env\python39\python.exe D:\项目\python\deke\test.py 
[(0, 'a'), (1, 'b'), (2, 'c')]
<enumerate object at 0x000001752AB56F40>

len() 

max()  也可用与字符串，按照ASCII码

min()   也可用与字符串，按照ASCII码

sum()   不适用于字符串

revesered() 

sorted()

2、字符串的介绍

1、字符串的创建

同数字

字符串可以用单引号、双引号、三引号

2、字符串的访问

索引和切片来进行访问

3、字符串的修改

a = "12344567"
a[0] = 3

4、字符串的删除

字符串是可不变类型，所以无法删除某个字符

del 删除整个字符

a = "123456789"
a = a[:6] + a[7:]

3、字符串和操作符

1、标准类型操作符

2、序列操作符

4、只适用于字符串的操作符

1、格式化操作符%

%C 格式化字符及其ASCII码

%s 格式化字符串

%d 格式化整数

%u 格式化无符号整型

%o 格式化无符号八进制数

%X 格式化无符号十六进制数

%X 格式化无符号十六进制数(大写)

%f 格式化浮点数字，可指定小数点后的精度

%e 用科学计数法格式化浮点数

%E 作用同%e，用科学计数法格式化浮点数

%g %f和%e的简写

%G %F和%E的简写

%p 用十六进制数格式化变量的地址
 

2、原始字符串操作符( r/R )

原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。

>>> '\n'
'\n'
>>> print '\n'


>>> r'\n'
'\\n'
>>> print r'\n'
\n

3、Unicode 字符串操作符( u/U )

中文转unicode

hanzi="明"
str1=hanzi.encode("unicode_escape")#转字节字符
print(str1)#打印字节字符
bma=str(str1)[-5:][:4]#字节转字符并取出单个字的4位u编码

6、字符串的内建函数（重点）

字符串的内建函数共80个

if __name__ == '__main__':
    print(dir(str))


E:\env\python39\python.exe D:\项目\python\deke\test.py 
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

方法的详解（其中包括魔法方法，实例方法，静态方法，类方法等）

摘自 python3.9版本的 builtins.py  和 python官方文档

class str(object):

    def capitalize(self, *args, **kwargs):
        """
        返回原字符串的副本，其首个字符大写，其余为小写
        """
        pass

    def casefold(self, *args, **kwargs):
        """
        返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。
        消除大小写类似于转为小写，但是更加彻底一些，因为它会移除字符串中的所有大小写变化形式
        例如，德语小写字母 'ß' 相当于 "ss"。 由于它已经是小写了，lower() 不会对 'ß' 做任何改变；而 casefold() 则会将其转换为 "ss"
        """
        pass

    def center(self, *args, **kwargs):
        """
        width:返回长度为 width 的字符串，原字符串在其正中
        fillchar: 填充的字符
        """
        pass

    def count(self, sub, start=None, end=None):
        """
        返回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法
        默认为0
        """
        return 0

    def encode(self, *args, **kwargs):
        """
        encoding:编码格式
        errors: strict /ignore
        """
        pass

    def endswith(self, suffix, start=None, end=None):
        """
        suffix:如果字符串以指定的 suffix 结束返回 True，否则返回 False
        start:开始下标
        end：结束下标
        """
        return False

    def expandtabs(self, *args, **kwargs):
        """
        返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。
        每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）
        tabsize:制表位的大小

        '01\t012\t0123\t01234'.expandtabs()
        '01      012     0123    01234'
        '01\t012\t0123\t01234'.expandtabs(4)
        '01  012 0123    01234'
        """
        pass

    def find(self, sub, start=None, end=None):
        """
        返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。
        可选参数 start 与 end 会被解读为切片表示法。
        如果 sub 未被找到则返回 -1。
        """
        return 0

    def format(self, *args, **kwargs):
        """
        执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。
        每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。
        返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。
        "The sum of 1 + 2 is {0}".format(1+2)
        'The sum of 1 + 2 is 3'
        """
        pass

    def format_map(self, mapping):
        """
        类似于 str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict
        '{name} was born in {country}'.format_map(Default(name='Guido'))
        'Guido was born in country'
        """
        return ""

    def index(self, sub, start=None, end=None):
        """
        类似于 find()，但在找不到子类时会引发 ValueError。
        """
        return 0

    def isalnum(self, *args, **kwargs):
        """
        如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True ， 否则返回 False 。
        """
        pass

    def isalpha(self, *args, **kwargs):
        """
        如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False
        """
        pass

    def isascii(self, *args, **kwargs):
        """
        如果字符串为空或字符串中的所有字符都是 ASCII ，返回 True ，否则返回 False 。ASCII 字符的码点范围是 U+0000-U+007F
        """
        pass

    def isdecimal(self, *args, **kwargs):
        """
        如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 True ， 否则返回 False 。
        """
        pass

    def isdigit(self, *args, **kwargs):
        """
        如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False
        """
        pass

    def isidentifier(self, *args, **kwargs):
        """
        如果字符串是有效的标识符，返回 True ，
        检测字符串是否是有效标识符
        """
        pass

    def islower(self, *args, **kwargs):
        """
        如果字符串中至少有一个区分大小写的字符 ,且此类字符均为小写则返回 True ，否则返回 False
        """
        pass

    def isnumeric(self, *args, **kwargs):
        """
        如果字符串中至少有一个字符且所有字符均为数值字符则返回 True ，否则返回 False 。
        """
        pass

    def isprintable(self, *args, **kwargs):
        """
        如果字符串中所有字符均为可打印字符或字符串为空则返回 True ，否则返回 False 。
        """
        pass

    def isspace(self, *args, **kwargs):
        """
        如果字符串中只有空白字符且至少有一个字符则返回 True ，否则返回 False
        """
        pass

    def istitle(self, *args, **kwargs):
        """
        如果字符串中至少有一个字符且为标题字符串则返回 True ，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。
        否则返回 False
        """
        pass

    def isupper(self, *args, **kwargs):
        """
        如果字符串中至少有一个区分大小写的字符 且此类字符均为大写则返回 True ，否则返回 False 。
        """
        pass

    def join(self, ab=None, pq=None, rs=None):
        """
        返回一个由 iterable 中的字符串拼接而成的字符串。
        如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔

        Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
        """
        pass

    def ljust(self, *args, **kwargs):
        """
        width:
        fillchar:
        返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位
        """
        pass

    def lower(self, *args, **kwargs):
        """
        返回原字符串的副本，其所有区分大小写的字符 4 均转换为小写
        """
        pass

    def lstrip(self, *args, **kwargs):
        """
        chars:
        返回原字符串的副本，移除其中的前导字符。
        chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。
        实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:
        """
        pass

    def maketrans(self, *args, **kwargs):
        """
        此静态方法返回一个可供 str.translate() 使用的转换对照表。
        如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、
        （任意长度的）字符串或 None 的字典。 字符键将会被转换为码位序号。
        如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。
        如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。.
        """
        pass

    def partition(self, *args, **kwargs):
        """
        在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。
        如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串
        """
        pass

    def removeprefix(self, *args, **kwargs):
        """
        如果字符串以 prefix 字符串开头，返回 string[len(prefix):]。 否则，返回原始字符串的副本：

        'TestHook'.removeprefix('Test')
        'Hook'
        'BaseTestCase'.removeprefix('Test')
        'BaseTestCase'
        """
        pass

    def removesuffix(self, *args, **kwargs):
        """
        如果字符串以 suffix 字符串结尾，并且 suffix 非空，返回 string[:-len(suffix)]。 否则，返回原始字符串的副本:

        'MiscTests'.removesuffix('Tests')
        'Misc'
        'TmpDirMixin'.removesuffix('Tests')
        'TmpDirMixin'
        """
        pass

    def replace(self, *args, **kwargs):
        """
        old:
        new:
        count:
        返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。
        """
        pass

    def rfind(self, sub, start=None, end=None):
        """
        返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。
        可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1
        """
        return 0

    def rindex(self, sub, start=None, end=None):
        """
        类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError
        """
        return 0

    def rjust(self, *args, **kwargs):
        """
        返回长度为 width 的字符串，原字符串在其中靠右对齐。
        使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
        """
        pass

    def rpartition(self, *args, **kwargs):
        """
       在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。
       如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。
        """
        pass

    def rsplit(self, *args, **kwargs):
        """
        sep:
        maxsplit:
        返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。
        如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。
        """
        pass

    def rstrip(self, *args, **kwargs):
        """
        返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。
        如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:

        '   spacious   '.rstrip()
        '   spacious'
        'mississippi'.rstrip('ipz')
        'mississ'
        """
        pass

    def split(self, sep=None, maxsplit=-1):
        """
        返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，
        则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。
        如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）
        """
        pass

    def splitlines(self, *args, **kwargs):
        """
        返回由原字符串中各行组成的列表，在行边界的位置拆分

        """
        pass

    def startswith(self, prefix, start=None, end=None):
        """
        如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。
        如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
        """
        return False

    def strip(self, *args, **kwargs):
        """
        chars:
        返回原字符串的副本，移除其中的前导和末尾字符。
        chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。
        """
        pass

    def swapcase(self, *args, **kwargs):
        """
        大小写的转换
        返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。
        """
        pass

    def title(self, *args, **kwargs):
        """
        返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。
        """
        pass

    def translate(self, *args, **kwargs):
        """
        返回原字符串的副本，其中每个字符按给定的转换表进行映射。
        转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。
        当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，
        将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。
        """
        pass

    def upper(self, *args, **kwargs):
        """
         返回原字符串的副本，其中所有区分大小写的字符 4 均转换为大写
         """
        pass

    def zfill(self, *args, **kwargs):
        """
        width:
        返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。
        正负值前缀 ('+'/'-') 的处理方式是在正负符号 之后 填充而非在之前。
        如果 width 小于等于 len(s) 则返回原字符串的副本

         "42".zfill(5)
        '00042'
        "-42".zfill(5)
        '-0042'
        """
        pass

    def __add__(self, *args, **kwargs):
        """ Return self+value. """
        pass

    def __contains__(self, *args, **kwargs):
        """ Return key in self. """
        pass

    def __eq__(self, *args, **kwargs):
        """ Return self==value. """
        pass

    def __format__(self, *args, **kwargs):
        """ Return a formatted version of the string as described by format_spec. """
        pass

    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs):
        """ Return self[key]. """
        pass

    def __getnewargs__(self, *args, **kwargs):
        pass

    def __ge__(self, *args, **kwargs):
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs):
        """ Return self>value. """
        pass

    def __hash__(self, *args, **kwargs):
        """ Return hash(self). """
        pass

    def __init__(self, value='', encoding=None, errors='strict'):
        """

        value: 对象参数
        encoding:编码格式
        errors: 是否是严格格式
     

        
        """
        pass

    def __iter__(self, *args, **kwargs):
        """ Implement iter(self). """
        pass

    def __len__(self, *args, **kwargs):
        """ Return len(self). """
        pass

    def __le__(self, *args, **kwargs):
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs):
        """ Return self<value. """
        pass

    def __mod__(self, *args, **kwargs):
        """ Return self%value. """
        pass

    def __mul__(self, *args, **kwargs):
        """ Return self*value. """
        pass

    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs):
        """ Return self!=value. """
        pass

    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        pass

    def __rmod__(self, *args, **kwargs):
        """ Return value%self. """
        pass

    def __rmul__(self, *args, **kwargs):
        """ Return value*self. """
        pass

    def __sizeof__(self, *args, **kwargs):
        """ Return the size of the string in memory, in bytes. """
        pass

    def __str__(self, *args, **kwargs):
        """ Return str(self). """
        pass

7、字符串的独特特性

1、特殊字符串和控制字符

特殊字符串：

        f 字符串（格式化字符串）

        r 字符串（原始字符串）

        b：前缀用于表示字节字符串（bytes string）

        u 前缀用于表示Unicode字符串（unicode string）

控制字符：

        \n \t 等

2、三引号

三引号用于表示多行字符串（multiline string）。多行字符串可以跨越多行，并且可以包含换行符和其他特殊字符

3、字符串的不变性

字符串是一种不可变数据类型，就是说它的值是不能被改 变或修改的。这就意味着如果你想修改一个字符串，或者截取一个子串，或者在字符串的末尾 连接另一个字符串等等，你必须新建一个字符串。

8、unicode

9、字符串的关键总结