python基础知识

# 一. 变量
    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()