基本数据类型

python:
    一门弱类型的解释型的高级编程语言

    特点：简单，清晰，明确.
    你为什么学python?  爱好。机器学习。人工智能.

    第一个python程序. helloword

    变量：程序运行过程中产生的中间值。供给后面的程序使用.

    变量的命名规范：
        1. 以数字， 字母， 下划线组成
        2. 不能是数字开头， 更不能是纯数字
        3. 不能用关键字
        4. 不要用中文
        5. 不要太长
        6. 有意义
        7. 区分大小写
        8. 建议使用驼峰或下划线命名

    变量的数据类型：
        1. int: 整数      +，-，*，/，%，//， bit_length()
        2. str: 字符串。 由 '，", ''', """.
            + : 拼接
            * : 重复
            % : 格式化输出 %s  %d  %f
            索引和切片：
                指向每一个字符。 每个字符都有一个唯一的下标
                切片：
                    [start:end:step]
                    start 起始位置
                    end 结束位置。 取不到
                    step 步长

                    工作原理。 s[start+step]

                方法：
                    upper() 转化成大写
                    strip() 去掉左右两端的空白
                    replace(old, new) 把old换成new
                    split() 切割。 默认按照空白切。 切完之后的结果是列表
                    join() 把列表中的元素拼接成字符串
                    startswith() 以xxx开头。
                    find()/count()/index() 查找
                    isdigit() 判断数字
                    len() 长度
                    encode(编码集) 编码

                    编码:
                        1. ASCII. 8bit. 1byte
                        2. GBK. 国标码. GB2312 16bit, 2byte
                        3. Unicode. 万国码. 32bit, 4byte
                        4. UTF-8. 可变长度的Unicode.
                            英文: 1byte
                            欧洲: 2byte
                            中文: 3byte
                        编码之后的数据bytes
                            bytes.decode() 解码
                可迭代对象：
                    for 变量 in 可迭代对象：
                        循环体（break, continue）
                    else:
       3. bool: 布尔值
            取值： True， False
            用来判断
            类型转换:
                False: 0, '', None, [], {}, tuple(), set()
                True: 除了上面的都是True


        4.list: 列表. 由[]表示.每个元素与元素之间用逗号隔开, 可以装任意类型的数据.
            列表是可变的. 并且列表由索引和切片功能
            ①. 增
                append() 追加
                insert(索引, 数据)
                extend(Iterable) 迭代添加
            ②. 删除
                pop()
                remove(元素)
                del 切片删
                clear() 清空
            ③. 修改
                索引切片修改
                lst[i] = "新元素"
            ④. 查询
                一般用索引
                for循环


            ⑤. 操作
                count(). 计数
                index() 查找元素
                sort()排序
                reverse() 翻转

            列表不能直接在循环中删除. 因为涉及到元素移动.
            需要把要删除的内容添加到新列表中. 循环新列表. 删除老列表

            拷贝:
                1. = 赋值操作. 没有创建对象. 两个变量使用同一个对象.
                2. 浅拷贝. 只拷贝一层.  list.copy(), list[:]
                3. 深拷贝. 和这个对象相关的内部信息全部拷贝一份. deepcopy() 原型模式

            推导式: [结果 for循环 if判断]

       5. dict 字典:
            由{}表示. 内部存储key:value. key必须是可哈希的数据类型. 不可变. value:没有限制
            字典没有索引和切片
            ①. 增
                dic[新key] = value
                dic.setdefault(key, value)
            ②. 删除
                pop(key)
                popitems() 随机删一个
                del
                clear() 清空
            ③. 修改
                dic[老key] = 新value
                dic.update({}) 把xxx字典更新到字典中

            ④. 查询:
                通过key来查询
                get(key, default)
                setdefault(key, value)
            ⑤. 常用操作
                keys() 获取所有的key
                values()获取所有的value
                items() 获取所有的键值对(key, value)

            可以进行for循环
            for key in dict:
                print(key, dict[key])

            for key in dict.keys():
                print(key, dict[key])

            for value in dict.values():
                print(value)

            for k, v in dict.items():
                print(k,v)

            len() 计算键值对的个数

            字典在迭代的时候不可以改变大小
            把要删除的key保存在列表中. 循环列表. 删除字典

            dict.fromkeys(key, value)
            1. 返回给你新列表.
            2. 所有的key公用同一个value

            推导式: {key: value for循环 if}

        6.tuple元组:
            不可变.
            不可变指的是第一层
            基本上没有操作
            count()
            index()
            len(): __len__()

            可迭代
                for 循环

        7.set 集合
            无序, 不重复, 可哈希(元素)
            去重.
            也可以循环.
            fronzenset()  冻结的集合, 不可变, 可哈希

    基本语法:
        运算符:
            1. 算数运算: +-*/ // % **
            2. 比较运算:> <  == >= <= !=  <>
            3. 逻辑运算:
                and 并且的含义. 左右两端必须同时为真. 结果才能是真
                or  或者. 左右两端有一个是真. 结果就是真
                not 非. 非真既假, 非假既真

                顺序：() => not => and => or
                a or b
                    如果a非零。 返回a。 否则返回b
                and和or相反
                a and b
                    如果a非零。 返回b。 否则返回0
            4. 赋值运算
                += -= *= /= %=
                a+=b a = a + b

            5. 成员运算
               xxx in xxxx
            6. is和 ==
                is： 比较的是内存地址
                ==:  比较的是值
                小数据池(常量池): 会对str, int, bool进行缓存. 节省内存. 方便调用.


        if语句
            if 条件:
                语句块
            elif 条件:
                语句块
            .....
            else:
                语句块
        while 条件
            循环体
            break 结束当前本层循环
            continue 结束当前本次循环.继续执行下一次循环
        else:
            当条件不成立的时候

        print(打印的内容, xxx, end="结束符", sep="分隔符")
        str = input("提示") 用户交互

        range(10)   0-9
        range(5, 10) 5-9
        range(5, 10, 3) 5 8
        文件操作
            open(文件路径, mode="模式", encoding="编码")
            模式: r, w, a, r+, w+, a+, rb, wb, ab
            for循环可以迭代文件句柄. 拿到的是一行一行的内容
            seek()移动光标
            tell()查看光标位置

            with open(xxxx) as f:
                操作

            文件修改:
               从源文件中读取内容. 修改, 然后写入到新文件中. 删除源文件. 重命名新文件