一. 变量

1.基本使用：变量名 = 变量值；先定义，再赋值，最后引用
2.内存管理：
    垃圾回收机制：变量值被绑定的变量名个数为零
    引用计数增加：多个变量名绑定一个变量值
    引用计数减少：del 变量名，删除变量名与变量值的绑定关系
3.变量的组成部分
    变量名：指向赋值符号右侧值的内存地址，以访问赋值符号右侧的值
    赋值号：将变量值的内存地址绑定给变量名
    变量值：value
4.变量值的三个特征：
    id：反应变量值的内存地址
    type：记录事务的状态，不同类型的值用来表示记录不同的事务的状态
    value
5.运算符：
    算术运算符：+，-，*，/，//(整除)，%(取余)，**(幂运算) 
    逻辑运算符：
        and：x and y 布尔"与"  如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
        or：x or y	布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。
        not：not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。
    比较运算符：
        ==：比较对象是否相等
        ！=：比较两个对象是否不相等
        > <：比较两个对象的大小
        >= <=
    赋值运算符
        = ，+=， -=， *=， /=， %=， **=， //=
    成员运算符：
        in：如果在指定的序列中找到值返回 True，否则返回 False。
        not in：如果在指定的序列中没有找到值返回 True，否则返回 False。
    身份运算符：
        is：is 是判断两个标识符是不是引用自一个对象
        is not：is not 是判断两个标识符是不是引用自不同对象
    运算符优先级：
        **	指数 (最高优先级)
        ~       +         -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
        *    /    %    //	乘，除，取模和取整除
        +  -	加法减法
        >>    <<	右移，左移运算符
        &	位 'AND'
        ^   |	位运算符
        <=    <    >    >=	比较运算符
        ==    !=	等于运算符
        =   %=   /=    //=    -=    +=    *=    **=	赋值运算符
        is is not	身份运算符
        in not in	成员运算符
        not and or	逻辑运算符
6.常量：不变的量(python中没有常量的概念)
    约定：小写字母全为大写代表常量

二.基本数据类型：

1. int（整型）
2. float（浮点型）
3. str（字符串类型）
4. list（列表）
    形式：在[]内按逗号分隔开任意类型的值。
    定义：
       （1）[1,2,3,4,5,6]
       （2）list(1,2,3,4,5,6)
    类型转换：但凡能被for循环遍历的类型都可以被list()转换
    内置方法：lis = [1,2,3,4,5,6]
         （1）按索引取值：lis[0],lis[1],lis[3]
         （2）切片：lis[0:3]==>[1,2,3],顾左不顾右
         （3）长度：len(lis)
         （4）成员运算：3 in lis ==>True
         （5）追加：lis.append(8), 在末尾追加
         （6）插入：insert(index, obj)
         （7）将一个列表或字符串中的元素添加到列表中，extend()
         （8）删除：
              del(),无返回值，单纯的删除，不支持赋值
              pop(index),依据索引删除，默认删除最后一个
              remove(obj),依据元素删除，无返回值
         （9）计数：count()
         （10）查看索引：index()
         （11）清空所有元素：lis.clear()
         （12）反转列表：lis.reverse()
         （13）排序：sort(reverse=True降序)，默认升序，False
         （14）比较大小：对应位置元素依次比较，只适用于同种数据类型
5. set（集合）
    定义：{}内用逗号分隔开多个元素，元素满足：
        （1）集合内元素是不可变类型
        （2）集合内元素无序
        （3）元素不重复
   类型转换：set()
   内置方法：
      （1）并集 |
      （2）交集 &
      （3）差集 -
      （4）对称差集 ^
      （5）父子集 包含关系
   去重：只针对不可变类型
   删除：（1）set.discard()删除集合元素，不存在不报错
        （2）set.updata() 更新元素
6. tuple（元组）
    作用：按索引存放多个值，只用于读，不用于改
    定义：在()内按逗号分隔开任意类型的值,(1,2,3,4,5,6);当元组内只有一个值时，之后面必须要跟逗号，否则不是元组类型
        直接用tuple():tuple((1,)) 
        类型转换：tuple(obj)
    内置方法：
        切片：tup[1:4]
        索引取值：tup[1]
        长度：len(tup)
        成员运算：x in tuple
        循环
        统计个数：count
        查找索引：index()
7. dict（字典）字典类型：
    按key取值：可存可取，若key不存在，则创建
    长度：len(dict)
    删除：
       del， pop(), popitem

三.垃圾回收机制补充(引用计数)

    x = 0,直接引用，变量名直接关联变量值的内存地址
    l=['a', x]：间接引用：在某一个容器里引用变量
    扫描内存中变量的引用计数，若引用计数为零，则回收该变量
    循环引用会带来的内存泄露
    标记清楚：
        标记：遍历所有的GC Roots对象(栈区中的所有内容)
        清除：遍历堆区中的所有对象，将没有标记的对象全部清除
    分代回收:
        分代：在经历多次扫描之后都没有被回收的变量，gc机制就会认为该变量是常用变量，被扫描的频率就会降低
        回收：以引用计数作为回收的机制

四. 文件操作

1. 三种操作模式
    1.1 t模式
        读写都以字符串为单位
        只针对文本文件
        必须指定字符编码
    1.2 b模式：
        直接从硬盘读入内存，不做任何解码操作
        读写都是以bytes为单位
        可针对所有类型文件
        一定不能指定字符编码
    1.4 x模式
         x， 只写模式【不可读；不存在则创建，存在则报错】
2. wt模式操作
    2.1 如果文件不存在，则会创建新文件
    with open("a.txt",mode='wt',encoding='utf-8') as file:
        file.write("123456")
    2.2 如果文件存在，则会先清空文件内容，在写入新的内容
    with open("a.txt",mode='wt',encoding='utf-8') as file:
        file.write("8946415")
    2.3 如果以w模式打开文件进行写入操作时，如果文件没有关闭，新的内容将会写在旧的内容之后
    with open("a.txt",mode='wt',encoding='utf-8') as file:
        file.write("8946415\n")
        file.write("8946415\n")
        file.write("8946415\n")
        file.write("8946415\n")
    2.4 拷贝文件（t模式下只能拷贝文本文件）
    src_file = input("输入源文件路径：").strip()
    mubiao_file = input("输入目标文件路径：").strip()
    with open(r"{}".format(src_file), mode='rt', encoding='utf-8') as src1_file, \
        open(r"{}".format(mubiao_file), mode='wt', encoding='utf-8') as mubiao1_file:
        res = src1_file.read()
        mubiao1_file.write()
3. rt模式操作文件
    如果文件不存在，则会报错
    user_name = input("请输入用户名：")
    pass_word = input("请输入密码：")
    with open("user_information.txt", mode='rt', encoding='utf-8') as file:
        for info in file:
            username, password = info.strip().split(":")
        if user_name == username and pass_word == password:
        print("login successful")
        break
        else:
            print("login failed")
4. at模式操作文件
    4.1 a 模式 ：追加写 当文件不存在时，会创建空文件
    with open("b.txt", mode='at', encoding='utf-8') as file:
        ...
    4.2 当文件存在时，文件指针会直接跳到文件末尾
    with open("b.txt",mode='wt',encoding='utf-8') as file:
        file.write("8946415\n")
    with open("b.txt", mode='at', encoding='utf-8') as file:
        file.write('hah')
    4.3 file.read() # 报错  not readable，不能读
    4.4 当文件不关闭时，与w模式没有区别
    with open("b.txt", mode='at', encoding='utf-8') as file:
        file.write('hah\n')
        file.write('hah\n')
        file.write('hah\n')
5. at+模式操作文件
    with open("a+.txt", mode='at+', encoding='utf-8') as f:
        f.write("中国sdjandsakcskadsa")
         # 指针会停留在文件末尾，什么也读不出来
        f.read()
6. wt+模式操作文件
    6.1 wt+ 会清空之前内容，然后写入内容，指针停在文件末尾
    with open("w+.txt", mode='wt+', encoding='utf-8') as f:
        f.write("中国")
    with open("w+.txt", mode='wt+', encoding='utf-8') as f:
        f.write("中国好风光！")
    6.2 当进行读操作时，因为指针在文件末尾，什么也读不出来，并且会清空文件内容，指针跳转到文件开头
    with open("w+.txt",mode='wt+',encoding='utf-8') as f:
        f.read()
7. rt+模式操作文件
    7.1 rt+ 相比于rt模式来说，能够调用write方法进行写操作
    with open("r+.txt",mode='wt+',encoding='utf-8') as f:
        f.write("中国")
    7.2 当文件存在时，指针在文件开头，会覆盖之前的内容,之前的内容会全部清空
    with open("r+.txt", mode='wt+', encoding='utf-8') as f:
        f.write("1")
8. 其他操作
    8.1 readline() ,一次读取一行内容，光标移动到第二行首位
    with open("r+.txt", mode='rt', encoding='utf-8') as f:
        result = f.readline()
        print(result)
    8.2 readlines() ,每读取一行内容，存放在列表中，有多少行，列表就有多少个元素
    with open("a.txt", mode='rt', encoding='utf-8') as f:
        result = f.readlines()
        print(result)
    8.3 writelines() 将列表中的多个元素循环写入文件 覆盖之前的内容
    l = ['8946415\n', '8946415\n', '8946415\n', '8946415\n']
    with open("a.txt",mode='wt',encoding='utf-8') as f:
        f.writelines(l)
    8.4 纯英文字符，若以b模式写入时，可以不用encode()编码，直接在字符串前加个b，即可写入
    8.5 flush():将文件内容立刻从内存刷到硬盘上去
9. 指针移动
    9.1， 指针移动单位都是以字节bytes为单位的
    9.2，特殊情况：
        t模式下的read(n),n代表的是字符个数
    with open("user_sing.txt",mode='rt',encoding='utf-8') as f:
        result = f.read(4)
        print(result)
    9.3，控制指针移动seek(n,模式)：
        n指的是移动的字节个数
        模式：
            0：参照物是文件开头位置,只有0模式才可以在t模式下使用
            1：参照物是当前指针位置
            2：参照物是文件末尾位置
    9.4，查看文件指针当前的位置：tell()