08_Python的数据类型

1.数字(整型int 浮点型float 复数complex)

1.数字概述

不可变类型,一旦创建不可修改,不是迭代对象,属于原子型

2.整型数int

概述: 整型数是不带有小数部分的数字,包括自然数,0及负数自然数,如: -2, 100, 0
        int(): 把字符串转换成数字,base指定以多少进制来转换,默认以十进制转换

            int('f', base=16)  # 15

            int('af', base=16)  # 10*16+15 --> 175

            int('v', base=32)  # 31

            int('av', base=32)  # 10*32+31 --> 351

        bit_length(): 当前数字的二进制至少用几位来表示

            # 10的二进制表示是1010 长度是4

            int(10).bit_length()  # 4

        整数的二进制表示方式(数字0和小写字母b开头,后跟0~1)

            0b1001    (9)

            0b11        (3)

        整数的八进制表示方式(数字0和小写字母o开头,后跟0~7)

            0o177       (127)

            0o11         (9)

        整数的十进制表示方式

            -10

            0

            99999999

        整数十六进制表示方式(数字0和小写字母x开头,后跟0~9,A~F,a~f)

            0x11            (17)

            0xFF             (255)

            0x1234abcd  (305441741)

3.浮点型数float

概述: 浮点数是带有小数部分的数字(小数部分也可以是0)

        float(): 把字符串转换成浮点数

            float('3')  # 3.0

            float('-3.3')  # -3.3

        浮点数的小数表示方式

            3.14

            3.0

            3.

            0.3

            .3

        浮点数的科学计数法表示方式

            小数 e/E(正负号) 指数

            6.18E-1     (0.618)

            2.99e4       (29900.0)

4.复数complex

概述: 复数分为两个部分:实部(real)和虚部(image),虚部必须是以j或J结尾的数

        复数的表示方式

            1j

            (2J)

            1+1J

            1-1j

            (-100+100j)

2.布尔值(bool)

1.布尔值概述

用来表示真假两种状态的类型

        True 表示真(条件满足或成立);True 值为1即 非0为真

        False 表示假(条件不满足或不成立);False 值为0即 0为假

2.bool(x) 返回False的情况

0	int()	空整数
0.0	float()	空浮点数
0j	complex()	空复数
''	str()	空字符串
()	tuple()	空元祖
[]	list()	空列表
{}	dict()	空字典
	set()	空集合
	None	空值

3.字符串(str)

1.字符串概述:

1.用引号括起来的部分都是字符串,字符串用来记录文本信息是不可变类型

        2.字符串一但创建不可修改是一种序列即可迭代对象,属于原子型

        3.字符串索引流程图: https://www.processon.com/view/link/5ebfb6680791290fe0686d3e

2.字符串转换函数

hex(i) 将整数i装换成十六进制的字符串, 示例: hex(10)  # '0xa'

        oct(i)  将整数i装换成八进制的字符串, 示例: oct(10)  # '0o12'

        bin(i)  将整数i装换成二进制的字符串, 示例: bin(10)  # '0b1010'

        ord(i)  根据字符串,返回一个字符串Unicode值,注意字符串只能有一个字符, 示例: ord('a')  # 97

        chr(i)  根据Unicode值,返回一个对对应的字符, 示例: chr(97)  # 'a'

        str(i)  字符串构造函数将对象转换成字符串, 示例: str(10)  # '10'

3.引号的使用

Python提倡使用单引号,但是开发中还是推荐使用双引号;单引号内的双引号不算结束符,双引号内的单引号不算结束符

        三引号内可以包含单引号和双引号,三引号字符串中的换行会自动转换为换行符'\n'

4.空字符串表示方法

s = ''  # 单引号

        s = ""  # 双引号

        s = ''''''  # 三单引号

        s = """"""  # 三双引号

        s = str()  # 创建一个空字符串

5.非空字符串的字面值表示方式

s = 'hello'

        s = "hello"

        s = '''hello'''

        s = """hello"""

        s = str(list(x for x in range(10)))  # s = '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'

6.隐式字符串拼接

s = "I'm a programmer." 'My name is "coco"'

        print(s)  # I'm a programmer.My name is "coco"

        s2 = 'aaa' "bbb" '''ccc''' """ddd"""

        print(s2)  # aaabbbcccddd

7.用转义序列代表特殊的字符

字符串字面值中,用字符反斜杠\后跟一些字符代表特殊的一个字符

        \'    单引号

        \"    双引号

        \\    反斜杠

        \n    换行

        \r    返回光标至行首

        \f    换页

        \t    水平制表符

        \v    垂直制表符

        \b    退格

        \0    字符串,字符值为零

        \xXX  XX为两位十六进制表示的字符

        \uXXXX  Unicode16的十六进制表示的字符

        \UXXXXXXXX Unicode32的十六进制表示的字符

8.字符串中常见的ASCII编码

字符     十进制    十六进制

        '0'        48         0x30

        'A'        65         0x41

        'a'        97         0x61

        '\0'       0          0x00

        '\n'      10         0x0A

9.字符串与Unicode编码(国标码)

字符串保存的是Unicode编码值,Unicode的前128编码个和ASCII编码一致,Unicode编码值是全世界字符统一编码

        分类: UNICODE16(两个字节), UNICODE32(四个字节)

        示例:

            In [71]: print('\u9042')

            遂

In [72]: print('遂')

            遂

In [73]: print('\U00009042')

            遂

10.原始字符串(raw字符串)

作用: 让转义符号 \ 无效

            r'字符串内容'

            r"字符串内容"

            r'''字符串内容'''

            r"""字符串内容"""

        示例:

            In [75]: a = 'C:\newfile\test.py'  # 转义之后的

                ...: print(a)

                ...: a = r'C:\newfile\test.py'  # 未转义raw字符串

                ...: print(a)

            C:

            ewfile  est.py

            C:\newfile\test.py

11.字符串的算术运算: + += * *=

+ 加号运算符用于拼接字符串

        += 运算符用原字符串与右侧字符串拼接生成新的字符串

        示例:

            s = 'ABCD' + 'EFG'

            s += '123'

            print(s)  # ABCDEFG123

            s2 = s + s

            print(s2)  # ABCDEFG123ABCDEFG123

        *  生成重复的字符串

        *= 生成重复的字符串并让原变量绑定生成后的字符串

        示例:

            s = "ABC" * 3  # s='ABCABCABC'

            print(s)

            s2 = 5 * '0'  # s3 = '00000'

            s = "123"

12.字符串的比较运算: > >= < <= == !=

语法格式: x > y

        比较规则:

            1.字符串x的第一个字母与字符串y的第一个字母比较,如果不相同则直接得到比较结果,如果相同则再取第二个字母进行比较

            2.比较的依据是字符的UNICODE编码值  例如 "A" < "B"  ==> 0x41 < 0x42   True

            3.有值大于没有值   例如 "ab" > "a"  ==>  True

13.字符串的成员运算符: in not in

语法概述:

            用于序列,字典,集合等容器中,用于判断某个值是否存在于容器中如果存在返回True否则返回False

            对象 in 序列

            对象 not in 序列

        示例:

            >>> 'A' in "ABCD"

            True

            >>> x = 'welcome to tarena'

            >>> 'to' in x

            True

            >>> 'hello' not in x

            True

            >>> "ABCD" in x

            False

14.切片(slice)

1.概述: 从字符串序列中取出相应的元素,重新组成一个字符串序列

        2.字符串切片流程图: https://www.processon.com/view/link/5ec0841ae401fd16f43f20ce

        3.语法:

            # 顾头不顾尾,从begin开始截取,截取到end位置,但不包括end,()括起的部分代表可以省略

            字符串[(开始索引begin):(结束索引end)(:(步长step))]

        4.语法说明:

            1.开始索引是切片切下的位置,0代表第一个元素,1代表第二个元素,-1代表最后一个元素;结束索引是切片的终止索引(但不包含终止点)

            2.步长是切片每次获取完当前元素后移动的方向和偏移量,没有步长相当于取值完毕后向右移动一个索引的位置默认为1

            3.当步长为正整数时向正向切片,当步长的负整数时取反向切片,默认的起始位置为最后一个元素,终止位置是第一个元素的前一个位置

        5.示例:

            s = 'ABCDE'

            s[2:-2]  # 'C'

            s[:-2]  # 'ABC'

            s[:-2:2]  # 'AC'

            s[-1:0:-1]  # 'EDCB'

            s[-1:-100:-2]  # 'ECA'

            s[::-2]  # 'ECA'

            s[::-1]  # 'EDCBA'-->字符串的翻转(逆序)

15.字符串格式化表达式(%)

概述: 生成一定格式的字符串,运算符 %

        语法格式:

            格式化字符串 % 参数值

            格式化字符串 % (参数值1, 参数值2, ...)

        示例:

            fmt = "姓名: %s, 年龄: %d"

            name = "张飞"

            age = 20

            print(fmt % (name, age))

        ()传值:

            s2 = "i am %(name)s , age %(age)d" % {"name": "coco", "age": 18}

            print(s2)  # i am coco , age 18

        sep=打印拼接:

            print("root", "x", "0", "0", sep=":")  # root:x:0:0

16.占位符%和类型码之间的格式语法

1.语法概述: % [格式语法] 类型码

        2.格式语法:

            - 左对齐

            + 显示正负号

            0 补零

            宽度

            宽度.精度

        3.类型码:

            %s:     字符串

            %r:     字符串,使用repr而不是用str

            %c:     整数转为单个字符,等同于chr(x)函数操作

            %d:     十进制整数

            %o:     八进制整数

            %x:     十六进制整数,a-f小写

            %X:     十六进制整数,A-F大写

            %e:     指数型浮点数,如2.9e+10

            %E:     指数型浮点数,如2.9E+10

            %f,%F:  浮点十进制

            %g,%G:  十进制形式浮点或指数浮点自动转换

            %%:     等同于一个%

        示例1:

            "%10d" % 123  # '       123'

            "%-10d" % 123  # '123       '

            "%10s" % "abc"  # '       abc'

            "%-5s" % 'abc'  # 'abc  '

            "%+10d" % 123  # '      +123'

            "%010d" % 123  # '0000000123'

            "%.2f" % 3.1415926535897932  # '3.14'

            "%7.2f" % 3.1415926535897932  # '   3.14'

        示例2:

            # 过于复杂的格式化字符串可以放在外部格式化后再引用

            temp_list = ['111', '4444', '33']

            length = max(len(i) for i in temp_list)

            temp_str = "%" + str(length) + "s"

            # 下面注释的写法会报错

            # for i in range(len(temp_list)): print("%" + str(length) + "s" % temp_list[i])

            for i in range(len(temp_list)):

                print(temp_str % temp_list[i])

            打印效果:

                ' 111'

                '4444'

                '  33'

17.字符串的遍历(for i in与 enumerate 函数)

迭代遍历流程图: https://www.processon.com/view/link/5ebf9012e0b34d5f26102ae8

        enumerate() 函数用于将一个可遍历的数据对象(如列表,元组或字符串)组合为一个索引序列,同时列出数据和数据下标

        示例1:

            s = 'my nane is coco'

            for i in s:

                print(i, end=' ')  # m y   n a n e   i s   c o c o

            # 根据用户输入的字符串,遍历字符串

            test1_str = input(">>>")

            for item in range(0, len(test1_str)):

                print(item, test1_str[item])

        示例2:

            for item in enumerate('abcd'):

                print('索引:%s 值:%s' % item)

            """执行结果

                索引:0 值:a

                索引:1 值:b

                索引:2 值:c

                索引:3 值:d

            """

            for item in enumerate('abcd', 1):

                print('序号:%s 值:%s' % item)

            """执行结果

                序号:1 值:a

                序号:2 值:b

                序号:3 值:c

                序号:4 值:d

            """

18.计算字符串的长度(len)

s = 'coco'

        print(len(s))  # 4

19.python2中字符串注意事项

# Python2中引号前面加u是告诉解释器这是一个utf-8编码格式的字符串,方便中文处理

        hello_str = u"hello世界"

        print(hello_str)  # hello世界

        for c in hello_str:

            print(c, end=' ')  # h e l l o 世 界

20.字符串方法-判断类型(isalnum, isalpha, isdecimal, isdigit, isnumeric, isidentifier)

string.isalnum(): 如果 string 至少有一个字符并且所有字符都是字母汉字或数字则返回 True

            s = "coco18女".isalnum()

            print(s)  # True

        string.isalpha(): 如果 string 至少有一个字符并且所有字符都是字母或汉字则返回 True

            s = "coco欧豪".isalpha()

            print(s)  # True

        string.isdecimal(): 如果 string 只包含数字则返回 True, 只能判断 全角数字,判断范围小

            s = "123".isdecimal()  # 支持普通数字判断123,范围小

            print(s)  # True

        string.isdigit(): 如果 string 只包含数字则返回 True, 可以判断 全角数字, ⑴, "\u00b2",判断范围中

            s = '1②3"\u00b2"'.isdigit()  # 还支持特殊数字判断②'²',范围中

            print(s)  # True

        string.isnumeric(): 如果 string 只包含数字则返回 True, 可以判断 全角数字, 汉字数字,判断范围大

            s = "②二贰".isnumeric()  # 还支持中文数字判断二贰,范围大

            print(s)  # True

        string.isidentifier(): 如果 string 符合Python标识符命名规则(可以和关键字重复),则返回 True

            s = "coco_18".isidentifier()  # 即判断是否由字母数字下划线且不以数字开头组成的字符串

            print(s)  # True

            s = "class".isidentifier()

            print(s)  # True

            s = "123class".isidentifier()

            print(s)  # False

21.字符串方法-判断大小写和全空格及是否可打印(istitle, islower, isupper, isspace, isprintable)

string.istitle(): 如果 string 是标题化的类型,即每个被特殊字符隔开的单词的首字母大写则返回 True

            s = "My Mame Is Coco".istitle()

            print(s)  # True

            s1 = "My,Name*Is唐Coco".istitle()  # 中文也算特殊字符

            print(s1)  # True

        string.islower(): 如果 string 中包含至少一个区分大小写的字符,且所有区分大小写的字符都是小写,则返回True

            s = "Coco".islower()

            print(s)  # False

            s = "go".islower()

            print(s)  # True

        string.isupper(): 如果 string 中包含至少一个区分大小写的字符,且所有区分大小写的字符都是大写,则返回True

            s = "Coco".isupper()

            print(s)  # False

            s = "COCO".isupper()

            print(s)  # True

        string.isspace(): 如果 string 中只包含空格,则返回 True

            s = " \r\n \t  \r ".isspace()

            print(s)  # True

        string.isprintable(): 如果 string 中包所有字符都是可打印字符或 string 为空字符串,则返回 True

            s = "coco\n\r\t18".isprintable()

            s1 = "".isprintable()

            s2 = "coco18".isprintable()

            print(s, s1, s2)  # False True True

22.字符串方法-查找和替换(startswith, endswith, find, rfind, index, rindex, replace, expandtabs)

string.startswith(str): 检查字符串是否是以参数 str 开头,是则返回 True

            s = "coco".startswith("c")

            print(s)  # True

        string.endswith(str): 检查字符串是否是以参数 str 结束,是则返回 True

            s = "coco".endswith("o")

            print(s)  # True

        string.find(str, start=0, end=len(string)): 从左向右检测参数 str 是否包含在 string 中,

            如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是则返回开始的索引值,否则返回 -1

            s = "coco".find("c")  # 字符串的索引从0开始

            s1 = "coco".find("c", 1, 3)  # 可以指定开始和结束位置

            print(s, s1)  # 0 2

        string.rfind(str, start=0, end=len(string)): 从右向左检测参数 str 是否包含在 string 中,

            如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是则返回开始的索引值,否则返回 -1

            s = "1234".rfind("2")  # 字符串的索引从0开始

            s1 = "1234".rfind("2", 1, 3)  # 可以指定开始和结束位置

            print(s, s1)  # 1 1

        string.index(str, start=0, end=len(string)): 从左向右检测参数 str 是否包含在 string 中,

            如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是则返回开始的索引值,否则会报错

            s = "coco".index("c")  # 字符串的索引从0开始

            s1 = "coco".index("c", 1, 3)  # 可以指定开始和结束位置

            print(s, s1)  # 0 2

        string.rindex(str, start=0, end=len(string)): 从右向左检测参数 str 是否包含在 string 中,

            如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是则返回开始的索引值,否则会报错

            s = "coco".rindex("c")  # 字符串的索引从0开始

            s1 = "coco".rindex("c", 1, 3)  # 可以指定开始和结束位置

            print(s, s1)  # 2 2

        string.replace(old_str, new_str, num=string.count(old)): 把string中的参数old_str替换成参数new_str

            如果 num 指定,则替换不超过 num 次

            s = "coco 18 男".replace(" ", "--", 1) # 第三个参数表示只替换前几个

            print(s)  # "coco--18 男"

        string.expandtabs(tabsize=8): 把字符串中的 tab 符号('\t')转为空格,tab 符号('\t')默认的空格数是 8

            s = "coco\t18".expandtabs()

            s1 = "coco\t18".expandtabs(6)  # 指定以几个字符以断句,遇到制表符用空格补全几个字符

            print(s)  # 'coco    18'

            print(s1)  # 'coco  18'

23.字符串方法-大小写转换(capitalize, title, lower, upper, swapcase, casefold)

string.capitalize(): 把字符串的第一个字符大写

            s = "coco".capitalize()

            print(s)  # "Coco"

        string.title(): 把字符串每个被特殊字符隔开的单词的首字母大写

            s = "my name is coco".title()

            print(s)  # "My Mame Is Coco"

            s1 = "my,name*is唐coco".title()  # 中文也算特殊字符

            print(s1)  # "My,Name*Is唐Coco"

        string.lower(): 转换 string 中所有大写字符为小写

            s = "COCO".lower()

            print(s)  # "coco"

        string.upper(): 转换 string 中的小写字母为大写

            s = "coco".upper()

            print(s)  # "COCO"

        string.swapcase(): 翻转 string 中的大小写

            s = "cOcO".swapcase()

            print(s)  # "CoCo"

        string.casefold(): 转换 string 中所有字符为小写且包含特殊字符如俄美德希腊字符БBß

            s = "БBß".casefold()

            print(s)  # "бbss"

24.字符串方法-文本对齐(ljust, rjust, center, zfill)

string.ljust(width): 返回一个原字符串左对齐,并使用空格填充至长度为 width 的新字符串

            s = "coco".ljust(8, "?")  # ljust 字符串居左填充指定子字符串

            print(s) # coco????

        string.rjust(width): 返回一个原字符串右对齐,并使用空格填充至长度为 width 的新字符串

            s = "coco".rjust(8, "*")  # rjust 字符串居右填充指定子字符串

            print(s)  # ****coco

        string.center(width): 返回一个原字符串居中,并使用空格填充至长度为 width 的新字符串

            s = "coco".center(8, "-")  # center 字符串居中填充指定子字符串

            print(s)  # --coco--

        string.zfill(width): 返回一个原字符串右对齐,并使用0填充至长度为 width 的新字符串

            s = "this is string"

            print(s.zfill(10))  # 'this is string'

            print(s.zfill(20))  # '000000this is string'

25.字符串方法-去除空白字符(lstrip, rstrip, strip)

string.lstrip(): 截掉 string 左边开始的空白字符

            s = "\r\n\t coco 18  ".lstrip()  # lstrip祛除字符串左边的空白字符,也可以指定去除内容

            print(s)  # "coco 18  "

        string.rstrip(): 截掉 string 右边末尾的空白字符

            s1 = "\r\n\t coco 18  ".rstrip()  # lstrip祛除字符串右边的空白字符,也可以指定去除内容

            print(s1)  # "         coco 18"

        string.strip(): 截掉 string 左右两边的空白字符

            s2 = "\r\n\t coco 18  ".strip()  # lstrip祛除字符串两边的空白字符,也可以指定去除内容

            print(s2)  # "coco 18"

            s3 = "abcd".strip("ab")

            print(s3)  # "cd"

26.字符串方法-拆分和连接(partition, rpartition, split, rsplit, splitlines, join)

string.partition(str): 从左向右把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)

            s = "abcd abcd abcd"

            s1 = s.partition("a")  # 指定分割符分成3份,分割后包含分割符,前向后分割

            print(s1) # ('', 'a', 'bcd abcd abcd')

        string.rpartition(str): 从右向左把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)

            s = "abcd abcd abcd"

            s2 = s.rpartition("a")  # 指定分割符分成3份,分割后包含分割符,从后向前分割

            print(s2)  # ('abcd abcd ', 'a', 'bcd')

        string.split(str="", num): 从左向右以 str 为分隔符拆分 string,

            如果 num 有指定值,则仅分隔 num + 1 个子字符串,str 默认包含 '\r', '\t', '\n' 和空格

            s = "abcd abcd abcd"

            s3 = s.split("a", 3)  # 指定分割符和分割次数,分割后不含分割符,前向后分割

            print(s3) # ['', 'bcd ', 'bcd ', 'bcd']

        string.rsplit(str="", num): 从右向左以 str 为分隔符拆分 string,

            如果 num 有指定值,则仅分隔 num + 1 个子字符串,str 默认包含 '\r', '\t', '\n' 和空格

            s = "abcd abcd abcd"

            s4 = s.rsplit("a", 3)  # 指定分割符和分割次数,分割后不含分割符,从后向前分割

            print(s4)  # ['', 'bcd ', 'bcd ', 'bcd']

        string.splitlines(): 按照行('\r', '\n', '\r\n')分隔,返回一个包含各行作为元素的列表

            s = "abcd\r abcd\r\n ab \ncd"

            s5 = s.splitlines(True)  # 根据换行符分割字符串,True分割后保留换行符,默认为False不保留换行符

            print(s5)  # ['abcd\r', ' abcd\r\n', ' ab \n', 'cd']

        string.join(seq): 以 string 作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

            L = ["C:", "Programe files", "Python3"]

            s = '\\'.join(L)

            print(s)  # "C:\\Programe files\\Python3"

27.字符串方法-格式化字符串(format, format_map)

str.format(*args, **kwargs)方法: 返回值是格式化后的新的对象

            s = "i am {}, age {}".format("coco", 18)

            print(s)  # 'i am coco, age 18'

s = "i am {1}, age {0}".format("coco", 18)

            print(s)  # 'i am 18, age coco'

s = "i am {name}, age {age}".format(name="coco", age=18)

            print(s)  # 'i am coco, age 18'

s = "i am {name}, age {age}".format(**{"name": "name", "age": 18})

            print(s)  # 'i am coco, age 18'

s = "i am {0[1]}, age {1[0]}".format([0, 1], ["a", "b"])

            print(s)  # i am 1 , age a

s = "i am {:s}, age {:d} {:.2f}".format("aa", 10, 3.14)

            print(s)  # 'i am aa, age 10 3.14'

s = "i am {:s}, age {:d} {:.2f}".format(*["aa", 10, 3.14])

            print(s)  # 'i am aa, age 10 3.14'

s = "i am {name:s}, age {age:d}".format(name="coco", age=18)

            print(s)  # 'i am coco, age 18'

# b:二进制, o:八进制, d:十进制, x:小写十六进制, X:大写十六进制, .2%:百分比保留2位小数

            s = "numbers: {:b}, {:o}, {:d}, {:x}, {:X}, {:.2%}".format(10, 10, 10, 10, 10, 0.115)

            print(s)  # 'numbers: 1010, 12, 10, a, A, 11.50%'

        str.format_map(mapping)方法: mapping 是一个字典对象,返回值是针对字典类型的格式化后的新的对象

            People = {"name": "john", "age": 33}

            s = "My name is {name},iam{age} old".format_map(People)

            print(s)  # My name is john,iam33 old

28.字符串方法-统计子字符串出现次数(count)

string.count(str, start=0, end=len(string)): 检测 str 是否包含在 string 中,

            如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是则返回出现次数,否则返回0

            s = "coco".count("c")

            s1 = "coco".count("c", 2, 3)  # 参数要查找的字符串, 从第几个位置开始找, 找到那个位置结束

            print(s, s1)  # 2 1

29.字符串方法-创建替换规则(maketrans),根据规则替换(translate)

s = 'coco 18'

        s1 = str.maketrans('abc8', '1239')

        print(s.translate(s1))  # '3o3o 19'

30.字符串方法-编码(encode)

string.encode(encoding="UTF-8",errors="strict"): 方法是以 encoding 指定的编码格式编码字符串,

            errors参数可以指定不同的错误处理方案,返回编码后的字符串

            s = "abcd唐"

            s_utf8 = str.encode("UTF-8")

            s_gbk = str.encode("GBK")

            print("UTF-8 编码: ", s_utf8)  # b'abcd\xe5\x94\x90'

            print("GBK 编码: ", s_gbk)  # b'abcd\xcc\xc6'

4.列表(list)

1.列表的概述

1.列表是一种容器由一系列元素组成的可以被改变的序列,属于可变的数据类型是迭代对象

        2.列表一般用于保存相同的数据类型,列表中的元素与元素之间可能没有任何的关联关系,但他们之间有先后顺序关系

        3.列表流程图: https://www.processon.com/view/link/5ebf81440791290fe067d329

        4.列表在计算机中存储原理流程图-变量赋值: https://www.processon.com/view/link/5ed7bfb9f346fb1712ddd3d6

        5.列表与字符串比较:

            1.列表和字符串都是序列,元素之间有先后关系;列表和字符串都是可迭代对象

            2.字符串是不可变的序列,而列表是可变的序列

            3.字符串中每个元素只能存储字符,而列表可以存储任意类型的元素

2.创建空列表

L = []  # L 绑定空列表

        L = list()

3.创建非空列表

L = [1, 2, 3, 4]

        L = ['Beijing', 'shanghai', 'shenzhen']

        L = [1, 'two', 3.3, '四']

        L = [1, 2, [3.1, 3.2, 3.3], 4]

4.列表构建函数(list)

list()  # 生成一个空的列表 等同于 []

        list(iterable)  # 用可迭代对象创建一个列表

        示例:

            >>> list()

            []

            >>> list("hello")  # 字符串转列表,每一个子字符串就是一个列表元素

            ['h', 'e', 'l', 'l', 'o']

            >>> list(range(1, 10, 2))

            [1, 3, 5, 7, 9]

5.列表的算术运算: + += * *=

+ 用于拼接列表:

            x = [1,2,3]

            y = [4,5,6,7]

            z = x + y  # z = [1, 2, 3, 4, 5, 6, 7]

        += 用原列表与右侧列表拼接,并用变量绑定新列表:

            x = [1,2,3]

            x += [4,5,6]  # x = [1,2,3,4,5,6]

        * 生成重复的列表

            x = [1,2] * 3  # x = [1,2,1,2,1,2]

            y = 3 * [5,6]  # y = [5,6,5,6,5,6]

        *= 生成重复的列表,并给原变量赋值:

            x = [3,4]

            x *= 2 # x = [3,4,3,4]

            y = 3

            y *= [7,8] # y = [7,8,7,8,7,8]

6.列表的比较运算: < <= > >= == !=

语法概述: 列表1 > 列表2

        示例:

            [1,2,3] < [1,2,4]  # True

            [1,3] > [1,2,4]  # True

            [5] < [5, 0]  # True

            ["ABC", "123"] > ['abc', '456']  # False

            [1, "two"] > ["two", 1]  # TypeError

            [1, 2] < [3.3, 4]  # True

            [1] < ['2']  # TypeError

7.列表的成员运算: in not in

语法概述:

            in 判断一个对象是否存在于容器内,如果存在返回True,否则返回False,用法同字符串的 in 相同

            not in 判断一个对象是否存不在于容器内,如果存在返回True,否则返回False,用法同字符串的 not in 相同

            数据对象 in 容器

            数据对象 not in 容器

        示例:

            L = [1, 'Two', 3.3, '四']

            1 in L  # True

            2 in L  # False

            3.3 in L  # True

            '4' not in L  # True

8.列表的索引取值

语法:

            索引分为正向索引和反向索引规则与字符串索引规则完全相同,取值时等同于字符串的索引操作

            列表是可变的序列可以通过索引赋值改变列表中的元素

            列表[整数表达式]

        示例:

            L = [1,2,3,4]

            L[2] = 3.3  # 将第三个元素改为 3.3

        列表的降维操作示例:

            li_list = [1, 2, 3, [11, ["zhangsan", 100], 12, 13], 5, 6]

            v1 = li_list[3][1][0][0:5]  # 取子列表值

            print(v1)  # zhang

9.列表的切片

语法:

            列表的切片取值时,返回一个列表,规则等同于字符串切片规则

            列表的切片赋值可以改变原列表的排序,可以插入和修改数据以及改变列表的对应元素的值

            对于步长不等于1的切片赋值,赋值运算符右侧的可迭代对象提供的元素个数一定要等于切片切出的段数

            列表[:]

            列表[::]

            列表[切片] = 可迭代对象  # 赋值运算符的右侧必须是一个可迭代对象

        示例:

            L = [2, 3, 4]

            L[0:1] = [1.1, 2.2]  # L = [1.1,2.2,3,4]

L = [2, 3, 4]

            L[1:] = [3.3, 4.4, 5.5]  # L=[2,3.3,4.4,5.5]

L = [2, 3, 4]

            L[:] = [0, 1]  # L = [0, 1]

L = [2, 4]  # 实现中间插入 [3.1, 3.2]

            L[1:1] = [3.1, 3.2]  # L = [2,3.1,3.2,4]

L = [2,3,4]  # 实现在前面插入[0,1]

            L[0:0] = [0, 1]

L = [2,3,4]  # 实现在后面插入[5,6]

            L[-1:-1] = [5, 6]

L = [1,4]  # 用range函数生成的可迭代对象赋值

            L[1:1] = range(2,4)

L = [2,3,4]

            L[1:2] = "ABCD"  # "ABCD"也是可迭代对象

L = [1,2,3,4,5,6]

            L[::2] = "ABC"  # 对的

            # 以下切出三段但给出5个元素填充是错的

            L[::2] = "ABCDE"

10.删除列表中的元素(del语句)

语法:

            del 序列[整数表达式]

            del 序列[切片]

        示例:

            L = [1,2,3,4,5,6]

            del L[-1]  # [1, 2, 3, 4, 5]

            del L[0]  # [2, 3, 4, 5]

            del L[::2]  # [3, 5]

11.列表推导式(list comprehension)

概述: 列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式,即用简易方法生成列表

        语法:

            [表达式 for 变量 in 可迭代对象]

            [表达式 for 变量 in 可迭代对象 if 真值表达式]

        示例1:

            # 常规写法生成 [1, 4, 9, 16, 25, .... 81]

            L = []

            for x in range(1, 10):

                L.append(x ** 2)

            # 用列表推导式生成 [1, 4, 9, 16, 25, .... 81]

            L = [x ** 2 for x in range(1, 10)]

        示例2:

            # 生成 [1, 9, 25, 49, 81] 列表,跳过所有的偶数

            L = [x ** 2 for x in range(1, 10) if x % 2 == 1]

        示例3:

            # 生成30以内所有能被3整除的数的平方的列表

            def squared(x):

                return x * x

multiples = [squared(i) for i in range(30) if i % 3 is 0]

            print(multiples)

12.列表推导式与匿名函数结合使用

result = [lambda x: x + i for i in range(10)]

        # 这里当result[0]被调用的时候,变量i已经循环完毕变成9

        print(result[0](10))  # 19

result = [lambda x, i=i: x + i for i in range(10)]

        # 此时不直接引用上层变量,而是把变量直接传进来

        print(result[0](10))  # 10

13.列表推导式的嵌套

语法:

            [表达式1

                for 变量1 in 可迭代对象1 if 真值表达式1

                    for 变量2 in 可迭代对象2 if 真值表达式2

            ]

        示例:

            # 生成列表 ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

            L = [x+y

                for i in range('ABC')

                    for j in range('123')

            ]

14.统计列表中元素的总数即取列表的长度(len)

L = ['coco', 18, '男']

        print(len(L))  # 3

15.列表的遍历(for i in enumerate(list))

num_lst = [6, 8, 4, 1, 10, 'abc', 'd']

        for item in num_lst:

            print(item, end=' ')  # 6 8 4 1 10 abc d

        # enumerate() 函数用于将一个可遍历的数据对象(如列表,元组或字符串)组合为一个索引序列,同时列出数据和数据下标

        for item in enumerate(num_lst):

            print('索引:%s 值:%s' % item)

        """执行结果

            索引:0 值:6

            索引:1 值:8

            索引:2 值:4

            索引:3 值:1

            索引:4 值:1

            索引:5 值:abc

            索引:6 值:d

        """

        for item in enumerate(num_lst, 1):  # 设置遍历开始初始位置,仅改变显示序号

            print('序号:%s 值:%s' % item)

        """执行结果

            序号:1 值:6

            序号:2 值:8

            序号:3 值:4

            序号:4 值:1

            序号:5 值:10

            序号:6 值:abc

            序号:7 值:d

        """

16.列表在循环的时候不能删列表中的元素,因为会改变索引

解决方案示例1:

            lst = ["水浒传", "西游记", "红楼梦", "三国演义"]

            del_lst = []

            for el in lst:

                del_lst.append(el)  # 记录下来要删除的内容

for el in del_lst:  # 循环记录的内容

                lst.remove(el)  # 删除原来的内容

            print(lst)  # []

        解决方案示例2:

            lst = ["周杰伦", "周润发", "周星星", "马化腾", "周树人"]

            # 删除掉姓周的人的信息

            del_lst = []

            for el in lst:

                if el.startswith("周"):

                    del_lst.append(el)

for el in del_lst:

                lst.remove(el)

            print(lst)  # ['马化腾']

17.列表解析(就是列表推导式与三元表达式的运用)

三元表达式: ret = 成立执行 if 真值表达式 else 不成立执行

        示例:

            egg_list1 = []

            for i in range(10):

                egg_list1.append("数字%s" % i)

            print(egg_list1)  # ['数字0', '数字1', '数字2', '数字3', '数字4', '数字5', '数字6', '数字7', '数字8', '数字9']

egg_list2 = ["数字%s" % i for i in range(10)]

            egg_list3 = ["数字%s" % i for i in range(10) if i%2 != 0]

            print(egg_list2)  # ['数字0', '数字1', '数字2', '数字3', '数字4', '数字5', '数字6', '数字7', '数字8', '数字9']

            print(egg_list3)  # ['数字1', '数字3', '数字5', '数字7', '数字9']

18.列表方法-根据值取索引(index)

L = ['coco', 18, '男']

        L.index(18)  # 1

19.列表方法-增加(append insert extend)

L = ['coco']

        L.append('男')  # append 方法可以向列表的末尾追加数据

        L.insert(1, 18)  # insert 方法可以在列表的指定索引位置插入数据

        L.extend(['cat', 3])  # extend 方法可以把其他列表中的完整类容追加到当前列表的末尾

        L.extend('foo')  # 遍历添加,参数: 可迭代对象

        print(L)  # ['coco', 18, '男', 'cat', 3, 'f', 'o', 'o']

20.列表方法-删除(remove pop clear)

L = ['coco', 18, '男', 'cat', 3]

        # remove 方法可以从列表中删除指定的数据,仅删除第一次出现的数据,如果数据不存在程序会报错

        L.remove('coco')  # L = [18, '男', 'cat', 3]

        # pop方法可以指定要删除元素的索引,默认删除最后一个元素,并返回被删除的元素,如果索引不存在程序会报错

        s = L.pop(0)  # L = ['男', 'cat', 3] s = 18

        L.clear()  # 清空列表 L = []

21.列表方法-统计某一个数据出现的次数(count)

L = ['coco', 18, '男', 'coco']

        print(L.count('coco'))  # 2

22.列表方法-排序(sort),翻转(reverse)

num_lst = [6, 8, 4, 1, 10]

        num_lst.sort()  # sort默认升序 参数reverse默认值是False

        print(num_lst)  # [1, 4, 6, 8, 10]

        num_lst.sort(reverse=True)  # 降序

        print(num_lst)  # [10, 8, 6, 4, 1]

        num_lst.reverse()  # 逆序(翻转)

        print(num_lst)  # [1, 4, 6, 8, 10]

23.列表方法-浅拷贝(copy)

# 在复制过程中,只复制一层变量,不会复制深层变量绑定的对象的过程

        L1 = [1, 2, [11, 22], 3]

        L2 = L1.copy()

        L2  # [1, 2, [11, 22], 3]

        L1[2].append(33)  # 二层数据L2跟随变化

        L1  # [1, 2, [11, 22, 33], 3]

        L2  # [1, 2, [11, 22, 33], 3]

L1.pop()  # 一层数据L2保持不变

        L1  # [1, 2, [11, 22, 33]]

        L2  # [1, 2, [11, 22, 33], 3]

5.元祖(tuple)

1.元祖的概述

1.元组是由一系列元素组成的容器,元素与元素之间可能没有任何的关联关系,但是有先后顺序关系的,元祖是可迭代对象

        2.元组是不可以被改变的序列,属于不可变的数据类型,但是元组中的元素可是任意类型的

        3.元祖的一级元素不能修改删除添加是不可变的列表,元祖一般用于保存不同的数据类型

        4.元祖常应用于函数的参数和返回值及格式字符串和不可变列表

2.元祖的表示方法

用小括号 () 括起来,单个元素括起来后加逗号(,)区分单个对象还是元组

        元组创建在最后一位加,方便和函数参数区分

3.创建空元祖

t = ()

        t = tuple()

4.创建非空元祖

t = 200,

        t = (20,)

        t = (1, 2, 3)

        t = 100, 200, 300

        type(x)函数: 用来返回x的类型

        错误示例:

            t = (20)  # type(t)类型为int

            x, y, z = 100, 200, 300  # 序列赋值

            x, y, z = (100, 200, 300)  # 序列赋值

            x, y, z = [100, 200, 300]  # 序列赋值

            x, y, z = "ABC"  # 序列赋值

5.元组的构造(创建)函数(tuple)

tuple(): 生成一个空元组,等于同()

        tuple(iterable): 用可迭代对象生成一个元组

6.元组的运算

元组的所有运算同列表的运算方式一致

        算术运算: + += * *=

        比较运算: < <= > >= == !=

        成员运算: in / not in

7.索引和切片

元组的索引和切片等同于列表的索引和切片

        元组的切片返回一个元组,元组不能索引赋值和切片赋值

8.元组方法-统计元素(count),索引位置(index)

T.count(value): 返回元素个数

        T.index(value, [start, [stop]]) 返回某个元素在元组的索引位置

6.字典(dict)

1.字典概述

1.字典是一种可变的容器,可以存储任意类型的数据,字典中的每个数据都是用'键'进行索引的,而不像序列可以用下标(index)来进行索引

        2.字典中的数据没有先后顺序关系,但是在Python3.7以后,字典添加有序的特性

        3.字典是一个映射类型以{}括起来的键值对组成,数据以键值的形式进行映射存储,字典的键不能重复只能用"不可变类型"作为字典的键

        4.在dict中key是唯一的是不可变的数据类型,在保存的时候根据key用hash算法来计算出一个内存地址,然后将key-value保存在这个地址中

        5.字典流程图: https://www.processon.com/view/link/5ebfa87be0b34d5f26107841

2.字典的表示方式

字典的表示方式以 {} 括起来以冒号(:) 分隔键-值对, 各键-值对之间用逗号(,)分割开

        示例: {"name": "Coco", "age": 18}

3.创建空字典

d = {}  # d绑定空字典

        d = dict()

4.创建非空字典

d = {'name': 'tarena', 'age': 16}

        d = {'year': 2018, 'month': 4, 'day':1}

5.字典的构造函数(dict)

dict()                 生成一个空字典,等同于 {}

        dict(iterable)     用可迭代对象初始化一个字典

        dict(**kwargs)   用命名关键字传参形式生成一个字典

        示例:

            d = dict()

            d = dict([('name', 'tarena'), ('age', 15)])

            d = dict(name='tarena', age=15)

6.字典的键为不可变类型

不可变类型(可哈希即可充当字典的键):

            bool, int, float, complex, str, tuple, frozenset(固定集合), bytes(字节串)

            包括: None

        可变的类型(不可哈希即不能充当字典的键):

            list, dict, set(集合), bytearray(字节数组)

7.字典的基本操作

键索引: 字典[键]

        示例:

            >>> d = {'name': 'tarena', 'age': 15}

            >>> d['name']

            'tarena'

            >>> d['age']

            15

        添加/修改字典元素: 字典[键] = 值对象

        示例:

            d = {}

            d['birthday'] = (2002, 1, 1)  # 添加键值对

            d['age'] = 16  # 添加键值对

            d['age'] = 17  # 修改'age'键所对应的值

        删除字典元素 del 语句: del 字典[键]

        示例:

            d = {'name': 'tarena', 'age': 16}

            del d['age']  # 删除'age'这个键

8.列表的 in 运算符和字典的 in 运算符的比较

1.列表的in运算符计算时间会因列表中元素个数的增加而增加

            L = [3,7,0,1,4,5,6....... 10976]  # 大约有十万个

            if 888 in L:

                print("888在列表里")  # 慢

        2.字典的in运算符计算时间不会因键值对的个数增加而增加,操作速度快于列表

            d = {3: "三", 7: "xx", 0: None, ... 10976:None}  # 大约有十万个

            if 888 in d:

                print("888在字典的键里")  # 快

9.可以用于字典的内建函数(len max min sum any all)

len(x)   返回字典的键值对的个数

        max(x)   返回字典的键的最大值

        min(x)   返回字典的键的最小值

        sum(x)   返回字典的所有键的和

        any(x)   对所有键进行真值测试,有一个为True结果为True

        all(x)   对所有键进行真值测试,所有为True才为True

10.字典推导式

作用: 用可迭代对象生成字典

        语法: {键表达式 : 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}  # []的内容代表可省略

        示例1:

            # 生成一个字典,键为10以内的数字,值为键的平方

            d = {x : x ** 2 for x in range(10)}

            print(d)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

        示例2:

            # 将一个字典的key和value对调

            mcase = {'a': 10, 'b': 34}

            mcase_frequency = {mcase[k]: k for k in mcase}

            print(mcase_frequency)  # {10: 'a', 34: 'b'}

        示例3:

            # 合并大小写对应的value值,将k统一成小写

            mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}

            mcase_frequency = ({k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)

                for k in mcase.keys()})

            print(mcase_frequency)  # {'a': 17, 'b': 34, 'z': 3}

11.字典不能在循环的时候更改大小

dic = {"a":"123", "b":"456"}

        for k in dic:

            dic.setdefault("c", "123")  # 报错

12.统计字典的键值对数量

card_dict = {"name": "coco", "age": 16, "sex": "女"}

        print(len(card_dict))  # 3

13.字典方法-迭代访问(keys values items)

直接获取所有keys值:

            d = {'name': '小张', 'birthday': (2008,8,8)}

            # 直接获取字典的所有key

            d.keys()  # dict_keys(['name', 'birthday'])

        直接获取所有values值:

            d = {'name': '小张', 'birthday': (2008,8,8)}

            # 直接获取字典的所有values

            d.values()  # dict_values(['小张', (2008, 8, 8)])

        直接获取所有键值对:

            d = {'name': '小张', 'birthday': (2008,8,8)}

            # 直接获取字典的所有键值对items

            d.items  # dict_items([('name', '小张'), ('birthday', (2008, 8, 8))])

        循环获取keys值:

            d = {'name': '小张', 'birthday': (2008,8,8)}

            for k in d.keys():  # .keys是默认调用的方法可不写,循环key值

                print(k, end=' ')  # name birthday

        循环values值:

            d = {'name': '小张', 'birthday': (2008,8,8)}

            for k in d.values():

                print(k, end=' ')  # 小张 (2008, 8, 8)

        循环获取键值对:

            d = {'name': '小张', 'birthday': (2008,8,8)}

            for k in d.items():

                print(k, end=' ')  # ('name', '小张') ('birthday', (2008, 8, 8))

14.字典方法-创建一个新字典(fromkeys)

fromkeys 不会对原来的字典产生影响而是以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值生成新的字典

        示例1:

            dic = dict.fromkeys(["k1", 2, ("k3", 3)], 999)

            print(dic)  # {'k1': 999, 2: 999, ('k3', 3): 999}

            v1 = dic.get("k11", 111)  # 取key不存在是返回指定参数111,避免报错

            print(v1)  # 111

        示例2:

            a = dict.fromkeys(["jj", 'jay', 'yy'], "sb")  # 静态方法

            print(a)  # {'jj': 'sb', 'jay': 'sb', 'yy': 'sb'}

            dic = {"a":"123"}

            s = dic.fromkeys("coco", "cat" )  # 返回给你一个新字典

            print(s)  # {'c': 'cat', 'o': 'cat'}

15.字典方法-删除(pop),随机删除(popitem),获取添加键值(setdefault)

pop 指定参数在key正确时返回value值, key错误时,返回指定参数

        popitem 随机删除一个键值对,返回一个键值对元组

        setdefault kye存在获取对应的value值,不存在则添加键值返回添加的value值

        示例:

            dic = {'k1': 'v1', 'k2': 'v2'}

            v = dic.pop("k1", 90)  # v='v1' dic={'k2': 'v2'}

            v2 = dic.pop("k22", 90)  # v2=90

            v3, v4 = dic.popitem()  # v3='k2', v4='v2'

            v5 = dic.setdefault("k1","123")  # v5='123' dic={'k1': '123'}

16.字典方法-合并(update),清除(clear)

如果被合并的字典包含已经存在的键值对,会覆盖原有的键值对

        示例:

            # 合并后age值覆盖原有的值

            card_dict = {"name": "coco", "age": 16}

            infor_dict = {"height": 1.6, "age": 15}

            card_dict.update(infor_dict)  # {'name': 'coco', 'age': 15, 'height': 1.6}

# 参数自动转换为字典更新到字典

            card_dict.update(k1=1, k2="123")  # {'name': 'coco', 'age': 15, 'height': 1.6, 'k1': 1, 'k2': '123'}

# clear 清空字典

            print(card_dict.clear())  # {}

17.字典方法-浅拷贝(copy)

dic1 = {"name": "Coco", "age": [17, 18]}

        dic2 = dic1.copy()

        dic1  # {'name': 'Coco', 'age': [17, 18]}

        dic2  # {'name': 'Coco', 'age': [17, 18]}

dic1["name"] = ["Coco", "Angels"]  # 一层数据dic2字典保存不变

        dic1["age"].pop()  # 二层数据dic2字典发生变化

        dic1  # {'name': ['Coco', 'Angels'], 'age': 17}

        dic2  # {'name': 'Coco', 'age': 17}

18.字典方法-获取键值(get)

get方法返回指定键的值,如果键不在字典中则返回默认值None,也可以给定一个默认值在不存在时用作返回

        dict = {"Name": "Zara", "Age": 27}

        print("Value : %s" % dict.get("Age"))  # Value : 27

        print("Value : %s" % dict.get("Sex", "Never"))  # Value : Never

7.集合(set)

1.集合概述

1.集合是可变的容器,集合内的数据对象都是唯一的即不能重复,集合中的数据没有先后顺序关系,是无序的存储结构

        2.集合内的元素必须是不可变的可迭代对象,集合是相当于只有键没有值的字典(键则是集合的数据)

        3.集合中的元素必须是可hash的,但是集合本⾝身是不可hash的

        4.集合去重的hash原理:

            1.先调用hash,再调用 __eq__ 方法, __eq__ 方法不是每次都触发,只有hash值相等的时候才会触发

            2.hash集合里的元素的结果找到一块内存地址,如果这块内存地址上面没有数据就说明之前没有重复数据

                地址上面有数据存在则再判断这个值和我要存的值是不是一样的,一样则覆盖重不一样则二次寻址给这个值换个地方存

2.创建集合

# 创建空集合,创建空集合不能使用s = {}创建,s = {}创键的是空字典

        s = set()

        # 创建非空集合

        s = {1, 2, 3, 4}

3.集合的构造函数(set)

set()  创建一个空的集合对象(不能用{}来创建空集合)

        set(iterable)  用可迭代对象创建一个新的集合对象

        示例:

            s = set()  # s 为空集合

            s = {3,5,7,9}

            s = set("ABC")  # s = {'A', 'B', 'C'}

            s = set({1:'1', 2:"2", 5:'5'})  # s = {1,2,5}

            s = set(range(1:10:3))

            print(s)  # s = {1,4,7}

            # 字符串转换集合

            s2 = set("index ix")

            print(s2)  # s2 = {'n', 'i', 'e', 'x', 'd', ' '}

            # 列表转集合

            s3 = set(["index", "index", 11])  # 会自动去重

            print(s3)  # {'index', 11}

4.集合的运算符与运算方法(&, |, -, ^, <, >)

方法概述:

            &       交集                       intersection                     intersection_update

            |       并集                         union

            -       补集(差集)               difference                       difference_update

            ^       交叉补集(对称补集)  symmetric_difference      symmetric_difference_update

            < <=    子集                    issubset

            > >=    超集                    issuperset

                交集判断                      isdisjoint

                成员判断                      in    not in

        & 生成两个集合的交集(intersection, intersection_update):

            s1 = {1, 2, 3}

            s2 = {2, 3, 4}

            s1 & s2  # {2, 3}

            s = s1.intersection(s2)  # 等同于 s = s1 & s2

            print(s)  # {2, 3}

            s1.intersection_update(s2)  # 等同于 s1 = s1 & s2

            print(s1)  # {2, 3}

        | 生成两个集合的并集(union):

            s1 = {1, 2, 3}

            s2 = {2, 3, 4}

            s1 | s2  # {1, 2, 3, 4}

            s = s1.union(s2)  # 等同于 s = s1 | s2

            print(s)  # {1, 2, 3, 4}

        - 生成两个集合的补集即差集(difference, difference_update):

            s1 = {1, 2, 3}

            s2 = {2, 3, 4}

            s1 - s2  # {1}  # 生成属性s1但不属于s2的所有元素的集合

            s = s1.difference(s2)  # 等同于 s = s1 - s2

            print(s)  # {1}

            s1.difference_update(s2)  # 等同于 s1 = s1 - s2

            print(s1)  # {1}

        ^ 生成两个集合的对称补集即交叉补集(symmetric_difference, symmetric_difference_update):

            s1 = {1, 2, 3}

            s2 = {2, 3, 4}

            s1 ^ s2  # {1, 4}

            s = s1.symmetric_difference(s2)  # 等同于 s = s1 ^ s2

            print(s)  # {1, 4}

            s1.symmetric_difference_update(s2)  # 等同于 s1 = s1 ^ s2

            print(s1)  # {1, 4}

        > 判断一个集合是另一个集合的超集(issuperset)< 判断一个集合是别一个集合的子集(issubset):

            {1, 2, 3} > {1, 2}  # True

            {2, 3, 1} > {3, 2}  # True

            {2, 3, 1}.issuperset({3, 2})  # True

            {2, 3, 4} < {1, 2, 3, 4}  # True

            {2, 3, 4}.issubset({1, 2, 3, 4})  # True

        isdisjoint 判断两个集合有没有交集:

            s1 = {1, 2, 3}

            s2 = {2, 3, 4}

            # 没有交集返回True,有返回False

            s1.isdisjoint(s2)  # False

        == != 判定集合相同和不同:

            {1, 2, 3} == {3, 2, 1}  # True

            {1, 2, 3} != {2, 3, 4}  # True

        in / not in 成员判断:

            in 等同于字典的in,用于集合中,当某个值存在于集合中,返回True,否则返回False

            not in 与 in 返回值相反

            集合的 in / not in 由于是hash算法存储,所以成员运算符的检索速度快于其他序列

5.集合推导式

概述: 集合推导式是用可迭代对象生成集合的表达式

        语法: { 表达式 for 变量 in 可迭代对象 [if 真值表达式]}  # [] 内的内容可省略

        示例:

            numbers = (1,2,3,2,2,3,3,4,5)

            s = {x for x in numbers}  # 去除重复的元素

            print(s)  # {1, 2, 3, 4, 5}

6.固定集合(frozenset)

定义: 固定集合是不可变且无序的,含有不重复元素的集合,不能增加删除修改

        作用: 固定集合可以作为字典的键,还可以作为集合的值

        创建空的固定集合: fs = frozenset()

        创建非空的固定集合: frozenset(iterable)  # 用可迭代对象创建新的固定集合

        示例: fz = frozenset([2,3,5,7])  # frozenset({2, 3, 5, 7})

7.集合方法-添加(add), 清空(clear), 浅拷贝(copy), 删除(pop, remove, discard), 更新(update)

add 添加元素,如果元素已经存在则不添加:

            s4 = {1, 2, 3, 4}

            s4.add("1")

            print(s4)  # {1, 2, 3, 4, '1'}

        clear 清空集合内所有元素:

            s5 = {"aa" ,(1, 2), 1}

            s5.clear()

            print(s5)  # set()

        copy 将集合进行一次浅拷贝:

            s6 = {1, 2, 3, 4}

            s7 = s6.copy()

            print(s7)  # {1, 2, 3, 4}

        pop 随机删除集合元素 remove discard 指定删除元素:

            s7 = {1, 2, 3, 4}

            s7.pop()  # 随机删除一个元素,如果此集合为空会引发KeyError错误

            s7.remove(2)  # 删除指定元素,指定不存在会引发KeyError错误

            s7.discard(3)  # 删除指定元素,指定不存在不会报错

            print(s7)  # {4}

        update 更新集合:

            s1 = {1, 2, 3}

            s2 = {3, 4, 5}

            s1.update(s2)  # 把s2合并到s1并更新s1集合,更新多个值

            print(s1)  # {1, 2, 3, 4, 5}

            s1.add(6)  # add更新一个元素

            print(s1)  # {1, 2, 3, 4, 5, 6}

8.字节串(bytes)

1.字节串概述

字节串也叫做字节序列,存储是以字节为单位的数据;字节串是不可改变的序列,字节是0~255之间的整数

2.创建空字节串

In [1]: B = b''

In [2]: B = b""

In [3]: B = b""""""  # b''

In [4]: type(B)

        Out[4]: bytes

In [5]: bytes

        Out[5]: bytes

3.创建非空的字节串的字面值

B = b'hello'

        B = b"Hello"

        B = b'''abcd'''

        B = b"""abcd"""  # b'abcd'

        B = b'abc\n123'  # b'abc\n123'

        B = b'\x41\x42'  # b'AB'

        b'\x16\x0d\x0d\x0a'  # b'\x16\r\r\n'

4.字节串的构造函数(bytes)

bytes(): 生成一个空的字节串 等同于b''

            In [19]: bytes()

            Out[19]: b''

        bytes(整数可迭代对象): 用可迭代对象初始化一个字节串

            In [21]: bytes([1, 2, 3, 4])

            Out[21]: b'\x01\x02\x03\x04'

        bytes(整数n): 生成n个值为0的字节串

            In [22]: bytes(10)

            Out[22]: b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

In [23]: bytes(4)

            Out[23]: b'\x00\x00\x00\x00'

        bytes(字符串, encoding='utf-8'): 用字符串的转换编码生成一个字节串

            In [28]: bytes('\x65\x66\x67\x68', encoding='utf-8')

            Out[28]: b'efgh'

In [29]: bytes('123', encoding='utf-8')

            Out[29]: b'123'

5.字节串的运算符

算术运算: + += * *=

        比较运算: < <= > >= == !=

        成员运算: in not in

            In [32]: B = b'ABCDE'

In [33]: 0x41 in B

            Out[33]: True

6.索引(index)和切片(slice)

In [39]: B = b'ABCD'

In [40]: B[0]

        Out[40]: 65

In [41]: B[::-1]

        Out[41]: b'DCBA'

7.用于序列的函数(len max min sum any all)

IIn [49]: B = b'ABCD'

        len: 取字节串的长度

            In [50]: len(B)

            Out[50]: 4

        max: 取字节串的最大值

            In [51]: max(B)

            Out[51]: 68

        min: 取字节串的最小值

            In [52]: min(B)

            Out[52]: 65

        sum: 字节串求和

            In [53]: sum(B)

            Out[53]: 266

In [54]: 65 + 66 + 67 + 68

            Out[54]: 266

        any: 对字节串进行真值测试,有一个为True结果为True

            In [55]: any(B)

            Out[55]: True

        all: 对字节串进行真值测试,所有为True才为True

            In [56]: all(B)

            Out[56]: True

8.bytes与str的区别

bytes 存储字节(0~255)

        str   存储字符(Unicode值)

        bytes 与 str转换

            编码(encode)

                str    ---->   bytes

                b = s.encode(encoding='utf-8')

            解码(decode)

                bytes  ---->   str

                s = b.decode(encoding='utf-8')

            示例:

                b = "你好".encode('utf-8')

                print(b)  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

                s = b.decode('utf-8')

                print(s)  # 你好

9.字节数组(bytearray)

1.字节数组概述

字节数组是可变的字节序列

2.创建函数(bytearray)

bytearray()  # 创建空的字数组

            In [57]: a = bytearray()

In [58]: type(a)

            Out[58]: bytearray

        bytearray(整数)

            In [59]: a = bytearray(5)

In [60]: a

            Out[60]: bytearray(b'\x00\x00\x00\x00\x00')

        bytearray(整型可迭代对象)

            In [61]: a = bytearray((1, 2, 3))

In [62]: a

            Out[62]: bytearray(b'\x01\x02\x03')

        bytearray(字符串, encode='utf-8')

            In [63]: a = bytearray('\x65\x66\x67\x68', encoding='utf-8')

In [64]: a

            Out[64]: bytearray(b'efgh')

3.字节数组的运算符

算术运算: + += * *=

        比较运算: < <= > >= == !=

        成员运算: in not in

4.索引(index)和切片(slice)

字节数组可以索引和切片赋值,赋值规则同列表的索引和切片赋值相同

        示例:

            ba = bytearray(b'abcdefg')

            ba[0] = 0x41  # ba = bytearray(b'Abcdefg')

            ba[1::2] = bytearray(b'BDF')  # 修改bdf为大写

5.字节数组的方法

# BA代表bytearray

        BA.clear()  # 清空字节数组

        BA.append(n)  追加一个字节(n为0~255的整数)

        示例:

            BA = bytearray(b"ABCD")

            BA.append(0x45)  # 直接BA.append(E)会报错

            BA  # bytearray(b'ABCDE')

        BA.remove(value)  # 删除第1个出现的字节,如果没有出现,则触发ValueError错误

        示例:

            BA = bytearray(b"ABCDE")

            BA.remove(0x45)  # 直接BA.remove(E)会报错

            BA  # bytearray(b'ABCD')

        BA.reverse()  # 字节的顺序反转

        BA.decode(encoding='utf-8')  # 将bytearray转换为字符串

        BA.find(sub[, start[, end]])  # 查找sub 子节数数组

10.空值(None)

空值概述

1.None是一个表示不存在的特殊对象

        2.用来语法占位

        3.变量解除绑定