1，Python数据类型

    1.1，Python提供了6种内置数据类型

        - Number（数值），String（字符串），List（列表），Tuple（元组），Dictionary（字典），Set（集合）。
        - 这些数据类型如同容器一般用于存放数据。

    1.2，Python中的数据类型可以做以下几种分类

        - 有序：可以使用下标（索引）访问元素。
        - 无序：不可以使用下标（索引）访问元素。
        - 可变：可以被修改。
        - 不可变：不可以被修改。

    1.3，6种内置类型的结构分类

    1.4，Number（数值）

        1.4.1，Python3的数值类型支持：

        1.4.2，复数

            - 复数由实数部分和虚数部分构成。
            - 复数不能单独存在，它们总是和一个值为0.0的实数部分一起构成一个复数。
            - 虚数部分必须有后缀j或J。
            - 实数部分和虚数部分都是浮点数。

        1.4.3，数值的计算

            - 数值类型的基本操作：加（+），减（-），乘（*），除（/），取余（%），取整（//），乘方（**）。
            - 如果不同类型的数字（如int，float）进行运算，则结果类型为精度较高的那个类型。

print(1+2)  # 3
print(1-2)  # -1
print(1*2)  # 2
print(1/2)  # 0.5
print(1 % 2)  # 1
print(1//2)  # 0
print(1**2)  # 1

        1.4.4，Python中的计算函数

            - 求绝对值：abs(x)
            - 四舍五入：round(x)
            - 返回两个数值的商和余数：divmod(y,x)
            - 求最大值和最小值：max,min
            - 求和：sum

print(abs(-1))  # 1
print(round(3.14))  # 3
print(divmod(1, 2))  # (0,1)
print(max([1, 2, 3]))  # 3
print(min([1, 2, 3]))  # 1
print(sum([1, 2, 3]))  # 6

        1.4.5，math模块

            - Python的math模块提供了很多对浮点数的数学运算函数，同时还提供了cmath模块，cmath模块的函数跟math模块函数基本一致，区别是cmath模块运算的是复数，math模块运算的是数学运算。
            - math模块常用方法有：三角函数（sin，cos，tanh），获取绝对值（fabs），向上取整（ceil），向下取整（floor），获取阶乘（factorial），x的y次方（pow）

    1.5，字符和字符串

        - 字符指类字形单元或符号，包括字母、数字、运算符号、标点符号和其他符号，以及一些功能性符号。
        - 字符串是编程语言中最常见的一种数据类型由字符组成，具有以下特征：有限的字符集合，可以由汉字、数字、字母、符号组成，一般由引号包裹。

        1.5.1，Python中的String（字符串）

            - Python中字符串是一个由多个字符组成的序列。
            - Python中没有字符。
            - 字符的个数即为字符串的长度（可用len函数查看）。
            - 单个字符被认为是长度为1的字符串。
            - Python中的字符串是有序且不可变的。

        1.5.2，在Python中声明一个字符串有三种方式

            - 使用单引号（'xxx'）创建：'Python'
            - 使用双引号（"xxx"）创建："Python"
            - 使用三引号（"""xxx""",'''xxx'''）创建：'''Python'''
            - 除了三种声明方式之外，还可以通过类型转化的方式str(obj)，生成字符串
            - 三种方式的区别在于：使用单引号和双引号的字符串是一样的，不能换行；使用三引号的字符串是长字符串，可以还行。
            **思考一下**
            下列字符串哪个能用？
            A，"这是一个字符串'
            B，"
                这是一个字符串"
            C，"张三说："这是一个字符串""
            D，'张三说："这是一个字符串"'
            A选项，由于字符串是成对出现的，不能用。
            B选项，双引号不能换行，不能用。
            C选项，双引号把头尾引起来了，不能识别中间的"这是一个字符串"，不能用。
            D选项，可以使用。

        1.5.3，特殊的字符串-转义字符

            - 在字符串中因为有一些字符因为本身具备一些功能，所以没有办法直接使用，如双引号和单引号。此时可以使用转义字符来实现这些符号的使用。
            - 转义字符：\。可以屏蔽符号原有的功能（"张三说：\"这是一个字符串\""）；加入特殊字母可以使用特殊功能；输出\，可以使用\\。

print("张三说：\"这是一个字符串\"")  # 张三说："这是一个字符串"
print("Py\nthon")
# Py
# thon
print("\\")  # \

        1.5.4，常见的转义字符

            - 原始字符串：在字符串有一些\，但是不希望进行转义可以使用原始字符串。可以在字符串前加r或者R来实现。

print(r"py\nthon")

        1.5.5，字符串的运算

            - +：拼接两个字符串，a="hello";b="world" => a+b="helloworld"。
            - *：字符串乘以一个数字可以得到重复次数的新字符串，"a"*2 => "aa"。

        1.5.6，索引与切片

            - 获取字符串中的字符元素：因为字符串是个有序序列，所以我们在访问字符串中的某些元素时可以根据元素对应的下标（索引）来访问：str[n]。正向访问时下标从0开始，到字符串长度减1。逆向访问从-1开始，每次递减1。
            - 批量获取（切片）：str[a:b:c]，a是起始元素的位置，b是终止元素的位置，c是步长。
                abc同样可以是负值。当a为0，b为n，c为1时，可以省略不写：str[::]（表示取所有）；str[::2]（每2个取1个）。
            - 注意：切片时一定要根据起始和终止位置设置步长；切片和索引可以用在Python中所有有序序列中。

Str = "Python"
print(Str[-4:-1:1])  # tho
print(Str[::])  # Python
print(Str[::2])  # Pto
print(Str[-5:-2:-1])  # " "
print(Str[-5:-2:1])  # yth

        1.5.7，字符串的常用操作

        1.5.8，字符串格式化输出

        1.5.9，string模块

            - 在Python中，字符串本身内置了很多的操作方法和属性，除此之外Python还提供了一个字符串操作模块string。
            - 在Python3中string模块提供的方法，和字符串内置的方法相似度较高。

    1.6，Tuple（元组）

        - 元组是一个有序且不可变序列，其中的元素可以是任意对象。元组可以使用索引和切片的方式取值。
        - 元组中的数据一旦生成就无法更改。

        1.6.1，元组的创建

            - 元组存储的数据更加安全。（因为一旦生成不能更改）
            - 元组由一个小括号包裹，元素用逗号隔开。声明一个元组有三种方式：
                Tuple=tuple((obj1,obj2,...))  # 可以通过此方法将其他序列转为元组
                Tuple=(obj1,obj2,...)
                Tuple=obj1,obj2,obj3

        1.6.2，单元素元组

            - 如果在声明元组时元组只有一个元素，需要在元素后面加上逗号，告诉解释器这不是运算符中的括号。
            - 嵌套元组也是如此。

t = (4)
print(type(t))  # int
t = (4,)
print(type(t))  # tuple
print(type(((4))))  # int
print(type(((4,))))  # tuple

        1.6.3，元组的运算

            - +：拼接两个元组：

t = (1, 2, 3)
t1 = (3, 2, 1)
print(t+t1)  # (1, 2, 3, 3, 2, 1)

            - *：元组乘以一个数字可以得到重复次数的新的元组：

t = (1, 2, 3)
print(t*2)  # (1, 2, 3, 1, 2, 3)

    1.7，列表（List）

        - 列表是一个有序可变的序列，其中的元素可以是任意对象。
        - 列表可以使用索引和切片的方式取值。
        - 列表可以随意的修改，删除和增加元素。
        - 相较于元组而言，列表的安全性差，但是灵活性高。
        - 列表支持的运算符同元组一样。

        1.7.1，列表的创建方式

            - 列表由一个中括号包裹住元素，元素用逗号隔开。创建列表的方式有：
                List=list((obj1,obj2,...))  # 可以通过此方法将其他序列转为列表
                List=[obj1,obj2,...]
                列表推导式

        1.7.2，列表推导式

            - 推导式是可以从一个数据序列构建另一个新的数据序列的结构体，可以快速生成序列。
            - 列表推导式：
                [i for i in range(5)]  # [0,1,2,3,4]
                [i for i in range(5) i i%2]  # [1,3]
                [(x,y) for x in range(5) if x%2==0 for y in range(5) if y%2==1]  # [(0,1),(0,3),(2,1),(2,3),(4,1),(4,3)]

        1.7.3，列表常用操作

        1.7.4，列表与数组

            - Python中的列表在外观上和数组有些相似，但两者并不是一种结构：
                Python的内置数据结构中并没有数组。需要借助于工具包Numpy实现。
                列表可以和数组相互转化，但是本质是不一样的。

    1.8，Dictionary（字典）

        - 字典的每个元素由两部分组成 - 键和值，所以字典的元素也被称为键值对。
        - 其中键是不可变且唯一的。
        - 如果字典有相同的键，则后面的键对应的值会将前面的值覆盖。
        - 数据量大时，字典数据的访问速度比列表快。
        - 字典是无序可变的序列。

        1.8.1，创建字典

            - 字典由一对花括号包裹，元素由逗号隔开。常见的字典创建方式：
                Dict = {key:value,}
                Dict = dict(key=value,)
                Dict = dict([(key,value),])
                字典推导式

        1.8.2，字典的取值

            - 根据字典的键进行取值。

        1.8.3，字典常用操作

    1.9，Set（集合）

        - 集合中的元素是唯一的，重复的元素会被删除。
        - 集合是由一个花括号包裹，内部元素以逗号隔开。声明一个集合的方式有：
            Set = set()
            Set = {obj1,obj2,...}

        1.9.1，集合的运算：

            - 逻辑运算：
                交集 set1 & set2：两个集合中相同的元素。
                对称差集 set1 ^ set2：两个集合中不同的元素。
                并集 set1 | set2：两个集合内总共的元素（重复的删除）。
                差集 set1 - set2：集合一中包含而集合二中不包含的元素。

        1.9.2，集合的常用操作

        1.9.3，集合的小妙招

            - 当前有一个列表([1,2,3,1,2,1,4,5,2,5])，如何对列表中的数据进行去重操作？
                可以利用集合的元素唯一性特征，将列表转为集合完成去重，然后再转为列表。

2，Python数据的常用操作

    2.1，数据引用

        2.2.1，数据引用会产生的问题？下面的代码会发生什么情况？

L1 = [1, 2, [3, 4, 5]]
print(id(L1))  # 打印L1指向的内存地址为：37605120
L2 = L1
print(id(L2))  # 打印L2指向的内存地址为：37605120
L2[0] = 6
print("L1: ", L1)  # L1:  [6, 2, [3, 4, 5]]
print("L2: ", L2)  # L2:  [6, 2, [3, 4, 5]]

            - 运行后发现L1和L2的值都为[6,2,[3,4,5]]

        2.2.2，为什么为这样呢？

            - 因为Python中变量名是对于数据的引用。代码中L2=L1只是将L2指向了L1所指向的地址。
            - 通过id(L1)和id(L2)可以知道L1和L2指向的内存地址是一样的。

    2.2，数据拷贝

        2.2.1，Python中为了防止上述问题出现，可以使用拷贝的生成一份新的数据。

L1 = [1, 2, [3, 4, 5]]
print(id(L1))  # 打印L1指向的内存地址为：31248128
L2 = L1.copy()
print(id(L2))  # 打印L2指向的内存地址为：37982144
L2[0] = 6
print("L1: ", L1)  # L1:  [1, 2, [3, 4, 5]]
print("L2: ", L2)  # L2:  [6, 2, [3, 4, 5]]

            - 通过id(L1)和id(L2)可以知道L1和L2指向的内存地址是不一样的。

        2.2.2，但是在进行嵌套后，拷贝时发现问题依然存在。

L1 = [1, 2, [3, 4, 5]]
print(id(L1))  # 打印L1指向的内存地址为：31444736
L2 = L1.copy()
print(id(L2))  # 打印L2指向的内存地址为：31690688
L2[2][0] = 6
print("L1: ", L1)  # L1:  [1, 2, [6, 4, 5]]
print("L2: ", L2)  # L2:  [1, 2, [6, 4, 5]]

            - 通过id(L1)和id(L2)可以知道L1和L2指向的内存地址是不一样的，为什么数据还是会一样呢？

    2.3，深拷贝和浅拷贝

        2.3.1，在Python中对于数据的拷贝可以根据拷贝形式的不同分为深拷贝和浅拷贝。

        2.3.2，浅拷贝（copy()），即对数据的表面结构进行拷贝，如果数据为嵌套的结构，则嵌套结构里面的元素是对之前数据的引用。修改之前的数据会影响拷贝得到的数据。
        2.3.3，深拷贝（deepcopy()），解决了嵌套结构中深层结构只是引用的问题，它会对所有的数据进行一次复制，修改之前的数据则不会改变拷贝得到的数据。
        2.3.4，实现深拷贝：导入Python中的copy模块，使用模块中的deepcopy()方法。

import copy
L1 = [1, 2, [3, 4, 5]]
print(id(L1))  # 打印L1指向的内存地址为：38085952
L2 = copy.deepcopy(L1)
print(id(L2))  # 打印L2指向的内存地址为：39604160
L2[2][0] = 6
print("L1: ", L1)  # L1:  [1, 2, [3, 4, 5]]
print("L2: ", L2)  # L2:  [1, 2, [6, 4, 5]]

    2.4，运算符

        Python运算符大致可分为7种，即算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符以及身份运算符。

        2.4.1，比较运算符

            - Python提供了6种比较运算符：>（大于）；<（小于）；==（等于）；!=（不等于）；>=（大于等于）；<=（小于等于）。
            - 比较运算的结果是一个布尔值，True或者False。

b = 2
c = 3
print(b > c)  # False
print(b < c)  # True
print(b != c)  # True
print(b == c)  # False
print(b >= c)  # False
print(b <= c)  # True

        2.4.2，赋值运算符

            - Python形成了丰富的赋值运算符：=，+=，-=，/=，%=，*=，//=。

b = 2
c = 3
b = c
print(b)  # 3
b += c
print(b)  # 5
b -= c
print(b)  # -1
b /= c
print(b)  # 0.6666
b %= c
print(b)  # 2
b *= c
print(b)  # 6
b //= c
print(b)  # 0

            - 还可以多变量赋值：a,b,c=1,2,3  ;  A=B=C=1

        2.4.3，逻辑运算符

            - Python中3种逻辑运算符分别为：and（与），or（或），not（非），逻辑运算的结果是布尔值，True或者False。
                A and B：当A为False时，运算结果为False，否则返回B的值。
                A or B：当A为True时，运算结果为A的值，否则返回B的值。
                not A：当A为True时，返回False，否则返回True。

        2.4.4，位运算符

            Python中有6种位运算符：
                - （&）：按位与运算符，参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0。
                - （|）：按位或运算符，只要对应的两个二进位有一个为1时，结果位就为1。
                - （^）：按位异或运算符，当两对应的二进位相异时，结果为1。
                - （~）：按位取反运算符，对数据的每个二进制位取反，即把1变为0，把0变为1。
                - （>>）：右移动运算符，把>>左边的运算数的各二进位全部右移若干位，>>右边的数指定移动的位数。
                - （<<）：左移动运算符，运算数的各二进位全部左移若干位，由<<右边的数指定移动的位数，高位丢弃，低位补0。

        2.4.5，成员运算符

            Python中有如下数据结构：字符串、列表、元组、字典。字符串、列表、字典，它们就像一个集合，其中包含若干元素，这些元素就是集合的成员，
            对于一个给定的元素，它有可能在一个给定的集合中，也可能不在，Python中采用成员运算符来判断元素是否属于成员，成员运算的结果为布尔值，
            True或者False。

temp1 = "ABCDEFG"
temp2 = [4, 2, 3, 5, 8, 9]
a = "CDE"
b = 5
c = "CDF"
print("a in temp1?", a in temp1)  # True
print("b in temp2?", b in temp2)  # True
print("c in temp1?", c in temp1)  # False

        2.4.6，身份运算符

            身份运算符用于比较两个标识符所引用对象的存储单元，计算结果为布尔值，包含两个运算符：is和is not，分别用于判断两个标识符是否引用自
            同一个对象。
            is与==区别：is用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等。