画布 1
Python基础
  计算机基础
    计算机组成
      CPU
      硬盘
      内存
      网卡
      其他
    操作系统
      Linux
      windows
      mac
    编程语言
      Python
      Java
      其他
    解释器和编译器
      解释器： 实时翻译。拿到1000行代码之后，解释一句交给操作系统一句。Python、PHP、JavaScript、Ruby...
      编译器：全文翻译。拿到2000行代码之后会将他编译成一个临时文件（计算机能够识别命令），再把文件交给操作系统去读取。C、C++、Go 、Java...
    进制
      计算机中的单位
        b（位）>B（字节）>KB（千字节）>M（兆）>G（千兆）>T(万亿字节) 其中b>B为8，其他都是1024
      进制之间的转换
        bin 二进制 0b
          v1 = bin(25) # 十进制转换为二进制
          print(v1) # "0b11001"
        oct 八进制 0o
          v2 = oct(23) # 十进制转换为八进制
          print(v2) # "0o27"
        hex 十六进制 0x
          v3 = hex(28) # 十进制转换为十六进制
          print(v3) # "0x1c"
        int 十进制
          转换为十进制与上面3种略有不同
            # 字符串转整型
            v1 = int("186",base=10) # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186
            v2 = int("0b1001",base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9 (0b表示二进制)
            v3 = int("0o144",base=8) # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100 (0o表示八进制)
            v4 = int("0x59",base=16) # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89 （0x表示十六进制）
      浮点型转换
        # 浮点型（小数）
        v1 = int(8.7) # 8
    编码
      unicode
      gbk
      utf-8
      ascii
  环境搭建
    Python解释器
      Python3.x
      Python2.x
    环境变量PATH
    Pycharm
      配置
      破解
      使用
  基础入门
    输入输出
    条件语句
      循环层级不要多
      if 变量，自动转换布尔值
      if not 取反
    while循环
      break 用于在while循环中帮你终止循环 （只能终止一层循环！！！）
      continue 在循环中用于 结束本次循环，开始下一次循环。
    for循环
    注释
    pass
      一般Python的代码块是基于 `:` 和`缩进`来实现，Python中规定代码块中必须要有代码才算完整，在没有代码的情况下为了保证语法的完整性可以用pass代替
    运算符
      常见运算符： 加+减-乘*除/取模%幂**取整除//
      特殊的逻辑运算符 not and or (注意有多种时的顺序，就是前面的顺序)
      位运算
        `&`，与（都为1）
          a = 60 # 60 = 0011 1100
          b = 13 # 13 = 0000 1101
          c = a & b # 12 = 0000 1100
        `|`，或（只要有一个为1）
          a = 60 # 60 = 0011 1100
          b = 13 # 13 = 0000 1101
          c = a | b # 61 = 0011 1101
        `^`，异或（值不同）
          a = 60 # 60 = 0011 1100
          b = 13 # 13 = 0000 1101
          c = a ^ b # 49 = 0011 0001
        `~`，取反
          a = 60 # 60 = 0011 1100
          c = ~a; # -61 = 1100 0011
        `<<`，左移动
          a = 60 # 60 = 0011 1100
          c = a << 2; # 240 = 1111 0000
        `>>`，右移动
          a = 60 # 60 = 0011 1101
          c = a >> 2; # 15 = 0000 1111
      is
      优先级：加减乘除 > 比较 > not and or，可以通过加括号来省事。
      and:两个的时候，则从前往后，前为True 就一定取后面的，前为False就取前面的or： 两个的时候，从前往后，前为True，就直接取前面的，前为False就取后面的
    字符串格式化
      %s 注意：如果字符串中有%要表示（而不是占位符），则打2个%。
      format （常用）
      f
    range
      正序
      倒序
    is 和 == 比较
      is，用于表示内存地址是否一致
      `==`，用于比较两个值是否相等
  None
    表示空值
  整型 int
    二进制转换
      Python十进制以整型方式表示
      Python中其他进制以字符形式表示
      进制之间的转换
        左边计算机基础中的进制内有
    py2和py3区别
      py2
        int、long（长整型）
        地板除得整数
          v1 = 9/2
          print(v1) # 4
      py3
        int（无限制）
        地板除得小数（浮点型）
          v1 = 9/2
          print(v1) # 4.5
  布尔类型 bool
    转换为布尔False的值
      0
      “”
      None
      []
      set()
      ()
      {}
    底层存储1、0
      集合元素会重复
      字典key会重复
  浮点型 float
    转换int
      在类型转换时需要，在浮点型转换为整型时，会将小数部分去掉
    round
      保留小数点后N位
      v1 = 3.1415926
      result = round(v1,3)
      print(result) # 3.142
    不精确
      一般可以忍受
      decimal精确表示
  字符串 str
    单引号、双引号、三引号表示
    基于unicode存储
      内存便于处理
      网络和存储时一般转换utf-8编码
      方法（生成新值）
        *strip
          去除字符串两边的 空格、换行符、制表符，得到一个新字符串 （要重新赋值） （分 lstrip和rstrip）
          msg = " H e ll o啊，树哥 "
          data = msg.strip()
          print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥"
        *split
          字符串切割，得到一个列表
          data = "武沛齐|root|wupeiqi@qq.com"
          result = data.split('|') # ["武沛齐","root","wupeiqi@qq.com"]
          print(data) # "武沛齐|root|wupeiqi@qq.com"
          print(result) # 输出 ["武沛齐","root","wupeiqi@qq.com"] 根据特定字符切开之后保存在列表中，方便以后的操作
        *rsplit
          data = "武沛齐,root,wupeiqi@qq.com"
          v1 = data.rsplit(',')
          print(v1) # ['武沛齐', 'root', 'wupeiqi@qq.com']
          v2 = data.rsplit(',',1)
          print(v2) # ['武沛齐,root', 'wupeiqi@qq.com']
        *join
          字符串拼接，得到一个新的字符串
          data_list = ["alex","是","大烧饼"]
          v1 = "_".join(data_list) # alex_是_大烧饼
          print(v1)
        *replace
          字符串内容替换，得到一个新的字符串
          data = "你是个好人，但是好人不合适我"
          value = data.replace("好人","贱人")
          print(data) # "你是个好人，但是好人不合适我"
          print(value) # "你是个贱人，但是贱人不合适我"
        *upper
          字符串变大写，得到一个新字符串
          msg = "my name is oliver queen"
          data = msg.upper()
          print(msg) # my name is oliver queen
          print(data) # 输出为：MY NAME IS OLIVER QUEEN
        *lower
          字符串变小写，得到一个新字符串
          msg = "My Name Is Oliver Queen"
          data = msg.lower()
          print(data) # 输出为：my name is oliver queen
        *zfill
          帮助你填充0 (处理二进制)
          # 应用场景：处理二进制数据
          data = "101" # "00000101"
          v1 = data.zfill(8)
          print(v1) # "00000101"
        *center居中 *ljust居左 *rjust居右
          v1 = "王老汉"
          # data = v1.center(21, "-")
          # print(data) #---------王老汉---------
          # data = v1.ljust(21, "-")
          # print(data) # 王老汉------------------
          # data = v1.rjust(21, "-")
          # print(data) # ------------------王老汉
        startswith
          判断字符串是否以 XX 开头
        endswith
          判断字符串是否以 XX 结尾
        format
          格式化字符串，得到新的字符串
        isdecimal
          判断字符串是否为十进制数
        decode解码 encode编码
        其他
    常见功能
      字符串相加（效率低）
      长度
      索引
      切片
      步长
        字符串翻转面试题
      循环
      in包含
      其他
    不可变类型
      内部创建之后，不可修改
  列表 list
    可变、有序、容器
    方法（内部修改）
      *pop
        在原列表中根据索引踢出某个元素（根据索引位置删除） （可将弹出的值放到一个容器内，后面还可以用）
        user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
        data = user_list.pop(1)
        print(user_list) # ["王宝强","Alex","贾乃亮","Alex"]
      append
        在原列表中尾部追加值
        user_list = ["车子","妹子"]
        user_list.append("嫂子")
        print(user_list) # ["车子","妹子","嫂子"]
      insert
        插入，在原列表的指定索引位置插入值
        user_list = ["苍老师","有坂深雪","大桥未久"]
        user_list.insert(2,"李小璐")
        print(user_list) #["苍老师","有坂深雪","李小璐"，"大桥未久"]
      extend
        批量追加，将一个列表中的元素逐一添加另外一个列表
        tools = ["搬砖","菜刀","榔头"]
        weapon = ["AK47","M6"]
        tools.extend(weapon) # weapon中的值逐一追加到tools中
        print(tools) # ["搬砖","菜刀","榔头","AK47","M6"]
      remove
        在原列表中根据’‘’值‘‘’删除（从左到右找到第一个删除）【慎用，里面没有会报错】
        user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
        user_list.remove("Alex")
        print(user_list) #["王宝强","陈羽凡","贾乃亮","Alex"]
      sort
        数字排序
          num_list = [11, 22, 4, 5, 11, 99, 88]
          print(num_list)
          num_list.sort() # 让num_list从小到大排序
          num_list.sort(reverse=True) # # 让num_list从大到小排序
          print(num_list) #[99,88,22,11,11,5,4]
        字符串排序的本质？unicode码点
        排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）
      clear
        清空原列表
        user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
        user_list.clear()
        print(user_list) # []
      index
        根据值获取索引（从左到右找到第一个删除）【慎用，找不到报错】
        user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
        if "Alex" in user_list:
        index = user_list.index("Alex")
        print(index) # 2
        else:
        print("不存在")
      reverse
        反转原列表
        user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
        user_list.reverse()
        print(user_list) #["Alex"，"贾乃亮"，"Alex"，"陈羽凡","王宝强"]
      其他
    常见功能
      相加
      索引
      切片
      步长
      循环
      in包含（效率不高）
      其他
    记住很重要的一点：循环的过程中对数据进行删除会踩坑 （可以选择从后往前删，就不会有问题）
    列表的转换 ： int、bool无法转换成列表
  元组 tuple
    有序、不可变、容器
    逗号的作用
      (1) 整形
      (1,) 元组
    常见功能
      索引
      切片
      循环
      长度
      其他
    转换
      只有字符串和列表可以转换为元组
      字符串
        name = "武沛齐"
        data = tuple(name)
        print(data) # 输出 ("武","沛","齐")
      列表
        name = ["武沛齐",18,"pythonav"]
        data = tuple(name)
        print(data) # 输出 ("武沛齐",18,"pythonav")
  集合 set
    无序、可变、可哈希、数据不重复、容器
    定义空集合时，只能使用v = set()，不能使用 v={}（这样是定义一个空字典）
    内部存储原理
      内部通过通过哈希函数把值转换成一个数字
      可哈希的数据类型：int、bool、str、tuple、float，而list、set是不可哈希的。
    方法
      add
        添加元素
        v1 = {11,22,33,44}
        v1.add(55)
        print(v1) # {11,22,33,44,55}
      discard
        删除元素
        data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
        data.discard("关之琳")
        print(data)
      *intersection
        交集 &
        s1 = {"刘能", "赵四", "⽪⻓⼭"}
        s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
        s4 = s1.intersection(s2) # 取两个集合的交集
        print(s4) # {"⽪⻓⼭"}
        s3 = s1 & s2 # 取两个集合的交集
        print(s3) # {"⽪⻓⼭"}
      *union
        并集 |
        s1 = {"刘能", "赵四", "⽪⻓⼭"}
        s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
        s4 = s1.union(s2)
        print(s4) # 取两个集合的并集 {"刘能", "赵四", "⽪⻓⼭","刘科⻓", "冯乡⻓", }
        s3 = s1 | s2 # 取两个集合的并集
        print(s3) # 取两个集合的并集 {"刘能", "赵四", "⽪⻓⼭","刘科⻓", "冯乡⻓", }
      *difference
        差集
        例子：s4 = s1.difference(s2) # 差集，s1中有且s2中没有的值
        s3 = s1 - s2 # 差集，s1中有且s2中没有的值
（直接用-也可以）
s5 = s2 - s1 # 差集，s2中有且s1中没有的值
    常见功能
      长度
      - 差集
      & 交集
      | 并集
      循环
    转换
      子孙元素也必须可哈希
      int/list/tuple/dict都可以转换为集合
    查询速度快
  字典 dict
    键值对、键可哈希、值任意类型、容器
      py3.6+ 有序
      py36- 无序
    方法
      *get
        通过键获取值 （键不存在，默认返回 None）
        或者和这个一样设置一个返回值
          data = info.get("hobby",123)
          print(data) # 输出：123
        info = { "age":12, "status":True, "name":"武沛齐","data":None}
        data1 = info.get("name")
        print(data1) # 输出：武沛齐
      update
        更新字典键值对
        info = {"age":12, "status":True}
        info.update( {"age":14,"name":"武沛齐"} )
        # info中没有的键直接添加；有的键则更新值
      setdefault
        设置值
        data.setdefault("age", 18)
      *keys()
        所有的键
        在Python2中 字典.keys()直接获取到的是列表，而Python3中返回的是`高仿列表`，这个高仿的列表可以被循环显示。
        # dict_keys(['age', 'status', 'name', 'email'])
      *values()
        所有的值
        dict_values([12, True, 'wupeiqi', 'xx@live.com'])
      *items()
        所有的键值
        dict_items([ ('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com') ])
      *pop
        移除指定键值对 （通过键来获取）
        data = info.pop("age")
        其中data显示的是”age“的值
      *popitem
        按照顺序移除（后进先出）
        info = {"age":12, "status":True,"name":"武沛齐"}
        data = info.popitem() # ("name","武沛齐" )
        print(info) # {"age":12, "status":True}
        print(data) # ("name","武沛齐")
      其他
    常见功能
      | 运算
        py3.9 +
      长度
      索引（key）
        info = { "age":12, "status":True, "name":"武沛齐"}
        print( info["age"] ) # 输出：12
        ***字典不同于元组和列表，字典的索引是`键`，而列表和元组则是 `0、1、2等数值`
      循环
        由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环
（如果只循环字典，后面没指明循环什么，则默认循环所有键）
        info = {"age":12, "status":True,"name":"武沛齐"}
        for key,value in info.items():
          print(key,value)
      根据键 修改值 和 添加值
        info = {"age":12, "status":True,"name":"武沛齐"}
        info["gender"] = "男"
        有就更改，无就添加
      del
        info = {"age":12, "status":True,"name":"武沛齐"}
        del info["age"] # 删除info字典中键为age的那个键值对（键不存在则报错）
        print(info) # 输出： {"status":True,"name":"武沛齐"}
    键查找速度快
    注意点
      字典的键和集合的元素在遇到 布尔值 和 1、0 时，需注意重复的情况
  关于一些方法是对原元素进行修改还是要另外赋值的一些理解和总结
    需要重新赋值的都加了“*”符号，在下面的总结里面点开可看