总复习

总复习

总复习:
  1.计算机核心组件:
        - CPU
        - 内存
        - 硬盘
        - 输入设备: 键盘、鼠标
        - 输出设备: 显示器、音响..

  2.python解释器:
      - 将人类编写好的代码转成机器能看得懂的字符。
      - 解释器的作用:
          帮你执行python代码。

  3.pycharm编辑器:
      - 编辑器的作用:
          可以更好的编写python代码,编辑器内部有很多强大的功能。
          能够快速编写代码。


  4.编程语言分类:
      - 机器语言(机器能直接看懂):
          比如: 01010101

      - 汇编语言(让人能看懂一点点):
          比如: a ---> 01101001

      - 高级语言(让人类能直接看懂):
          比如: print('hello')
          高级语言是更接近于人类的语言。

          - 解释型:
              一遍解释(翻译)一遍执行, 类似于同声传译。

              优点:
                  开发效率高
                  可跨平台,一份代码可以多个平台使用。

              缺点:
                  执行效率相比于编译型低。

          - 编译型:
              先一次性编译然后再执行,类似于 "有道翻译"。

              优点:
                  执行效率高。
                  稳定义

              缺点:
                  开发效率相比于解释型语言要低。
                  不可跨平台。

          - 解释型语言的种类:
              python: 10级别
              java: 8
              php: 3

          - 编译型语言的种类:
              C


  5.变量:
      变量指的是可变化的量。
      - 变量名: 可以与变量值绑定关系,通过变量名可以访问变量值。
          - 相当于身份证ID号

      - 赋值符号(=): 是用来将变量名与变量值绑定关系。

      - 变量值: 变量值 指的是 “数据”, 存放在内存中。


  6.垃圾回收机制: 注意: GC就是用来做垃圾回收机制的东西。
      - 变量名 = 变量值 # 添加一个引用计数

      当变量值的引用计数为0时,垃圾回收机制会“不定时”释放资源。


  7.查看变量三大特征
      - id
      - type
      - value


  8.变量名的命名规范
      - 驼峰命名法: 在写类名的时候使用
          首字母大写命名
          比如: JasonSb

      - 下划线命名法: 推荐使用
          比如: jason_sb


  9.python中八大数据类型
      - int:
          number = 100 # number = int(100)
          - 不可变类型

      - float
          salary = 1.0 # salary = float(1.0)
          - 不可变类型

      - str
          str1 = 'tank' # str1 = str('tank')
          - 不可变类型
          # 按照索引取值
          str1[1] # 取第二个值
          str1[1:10:2] # 顾头不顾尾

          # 内置方法
          str1.split() # 切分
          str1.strip() # 去左右两边的空格
          str1.strip('i') # 去左右两边的i
          # tank10
          str1.join(['tank', '10']) # 字符串的拼接,必须是字符串类型
          # 判断字符串开头,若正则返回True,否则返回False
          str.startswith()
          # 判断字符串结尾,若正则返回True,否则返回False
          str.endswith()
          # 判断字符串是否是数字,若正则返回True,否则返回False
          str.isdigit()
          # 新旧替换
          str.replace('旧的', '新的')
          # 获取某个字符的数量
          str.count('字符')

          # 查找字符的位置 索引   可能是面试题
          str.find('字符') # 找不到返回-1
          str.index('字符') # 找不到报错

      - list
          在[]内,可以存放多个值,每个值以逗号隔开。
          list([v1, v2..])
          - 可变类型

          - 常用内置方法:
              list.append() # 追加
              list.insert() # 插入值到指定的索引中
              list.pop() # 取出某个值,默认取出最后一个
              list.remove() # 真正的删除元素
              list.extend() # 列表合并
              list.sort(reverse=True) # 默认升序 , reverse=True降序
              list.copy() # 浅拷贝


      - tuple
          tuple((v1, v2...))
          - 不可变类型

      - dict
          特点: key是唯一的。
          dict({key:value, ...})
          - 可变类型
          dict[key] # 没有key会报错
          dict.get(key, '自定义默认值') # 没有key会报错,默认返回None
          dict.items() # 返回一个可迭代对象
          dict.keys()
          dict.values()
          dict.fromkeys('k1', []) # 生成字典 ---》 {'k1': []}


      - set
          特点: 内置去重功能。
          set({v1, v2...})
          - 默认可变类型

          # 内置方法
          set.add()
          set.remove()

      - bool:
          True or False
          - 不可变类型

      什么是可变?
          值变了,id不变称之为可变类型。

      什么是不可变?
          值变了,id也变 称之为不可变类型。

  10.字符编码
      结论: 以什么编码,就以什么解码。

      utf-8:
          - 存中文是3个字节。
          - 存英文是1个字节

      gbk:
          - 存中文是2个字节。
          - 存英文是2个字节


  11.文件处理:
      f = open('文件名的路径', '打开的模式', encoding='字符编码')
      f.close()

      # 文件的上下文管理: with   ,   flask框架的上下文管理(后期学习)
      with open('文件名的路径', '打开的模式', encoding='字符编码') as f:
          # 内部帮你执行f.close()

      - 打开模式:
          - 文本模式:
              - rt
              - wt
              - a

          - 二进制模式:
              - rb
              - wb
              - ab

      - 光标移动:
          f.seek('光标移动的位置', 0) # 开头
          f.seek('光标移动的位置', 1) # 当前
          f.seek('光标移动的位置', 2) # 末尾


      - 打开文件取值的优化方式:
          - f.read():
              直接将文件中所有数据一次性取出。
              缺点:
                  内存容易溢出。

          - for循环f句柄操作:
              # 通过for循环,将每一行取出,保证不会内存溢出
              for line in f:
                  print(line)

          - f.readline(): (了解)
              读取一行,光标移动到第二行。


  12.函数基础
      函数是一些列功能的结合体,是一个可以重复使用的工具。

      - 函数定义:
          def 函数名(参数1, 参数2...):
              '''注释: 说明函数的作用'''

              # 逻辑代码

              return 返回值

      - 函数调用
          函数() # 若有参数则要传参

      - 定义有参、无参、空函数
          def func1(参数):
              逻辑代码
              pass

          def func2():
              # 逻辑代码
              pass

          def func3():
              pass

      - 函数的参数:
          - 定义阶段: (参数用来接收调用者传入的)
              - 位置形参参数
              - 默认参数
              - 可变长参数

          - 调用阶段: (根据函数的定义者传的)
              - 位置实参参数
              - 关键字参数

          - 注意:
              # 参数从左到右的顺序
              位置 ---》 关键字参数 ---》 可变长参数

      - 函数的返回值:
          - 返回值可以是一个或者多个
          return 值1 ---> 值1

          return 值1, 值2 ---> (值1, 值2)




  13.名称空间与作用域:
      - 名称空间:
          在内存中产生,是一个存放名字的地方。

          - 内置名称空空间: python解释器

          - 全局名称空空间: 文件中所有(顶着最左边写的)
              注意: 无论嵌套if, while, for 多少层都是一个。

          - 局部名称空空间: 在函数内部定义的。

          - 查找顺序:
              当前局部 ---》 外层局部 ---》 全局 ---》 内置

          - 加载顺序:
              内置 ---》 全局 ---》 外层局部 ---》 当前局部

      - 作用域:
          - 全局作用域:
              - 内置
              - 全局

          - 局部作用域
              - 外层局部
              - 内层局部

      - global: 在局部可以声明全局名字。
          相当于将全局变量引用到局部中使用或修改。

      - nonlocal: 在内层局部声明外层局部的名字。


  14.函数对象、函数嵌套与闭包
      - 函数对象: 函数的名字 ---》 函数的内存地址
      - 函数嵌套:
          def outer():
              def inner():
                  pass

      - 闭包:
          为了装饰器作准备,它不是一个独立的技术。
          闭包是函数嵌套、函数对象、名称空间与作用域的结合体。

          - 内层函数封闭:
              外部不能调用内部的函数。

          - 外层函数开放:
              外部能调用外层函数

          - 闭包:
              - 内层函数想要引用外层函数的名字
              - 外部想要调用内部的函数,要在外层函数将内层函数的名字返回。

          def outer(x): # 10
              # x = 10
              def inner():
                  print(x) # 10
              return inner

          inner = outer(10)
          inner() # 实现了外部调用内层函数


  15.装饰器:
      装饰的工具。
      作用:
          - 1:在不修改被装饰对象的源代码
          - 2:在不修改被装饰对象的调用方式
          - 基于1和2,为被装饰对象添加新功能。

      # 无参装饰器:
      def wrapper(func):
          def inner(*args, **kwargs):
              # 调用被装饰对象前添加新功能
              res = func(*args, **kwargs) # index()
              # 调用被装饰对象后添加新功能
              return res
          return inner

      # 被装饰对象:
      def index(参数1):
          print('from index..')

      index = wrapper(index)
      index(实参1) # inner(实参1)


      # 有参装饰器: ---> 本质上就是无参装饰器
      def login_auth(name):
          # 无参装饰
          def wrapper(func):
              def inner(*args, **kwargs):
                  # 对name做一个权限认证
                  if name == 'tank':
                      # 调用被装饰对象前添加新功能
                      res = func(*args, **kwargs) # index()
                      # 调用被装饰对象后添加新功能
                      return res
                  else:
                      print('你不是tank,get out!')
              return inner
          return wrapper

      @ login_auth('tank') # wrapper
      @wrapper
      def index():
          pass


      - 叠加装饰器:
          - 装饰顺序:
              从下往上

          - 执行顺序:
              从上往下

  16.迭代器:
      迭代的工具。
      - 可迭代对象:
          凡是内置有__iter__(),都是可迭代对象。

      - 迭代器对象:
          凡是内置有__iter__()与__next__(),都是迭代器对象。

      优点:
          - 可以不依赖索引取值
          - 节省内存

      缺点:
          - 取值麻烦
          - 无法获取长度

      - for line in 可迭代对象: ----》 in: 将“可迭代对象”转成“迭代器对象”
          - 内置有捕获异常机制:
              while True:
                  try:
                      迭代器.__next__()
                  except StopIteration:
                      break



  17.生成器:
      生成器是一个自定义的迭代器, 生成器本质上就是一个迭代器。

      - 如何生成:
          - yield
          def func():
              yield 1
              yield 2
              yield 3

          g = func()
          g.__next__()
          next(g)
          # ---> 生成了生成器对象,然后每执行一次__next__,
          # 会取出一个值,到下一个yield会暂停。

  18.三元表达式:
      res = 条件成立的值 if 条件 else 条件不成立的值


  19.列表生成式:
      [line for line in 可迭代对象] # ---》 list ---》[line1, line2...]
      [[1, 2, 3, line] for line in 可迭代对象] # [line1, line2...]
      优点:
          - 可以依赖索引取值,取值方便
          - 可以获取长度

      缺点:
          - 占用内存空间

  20.生成器表达式(生成式):
      (line for line in 可迭代对象) # ---> 生成器
      优点:
          - 不占用内存空间

      缺点:
          - 不可以依赖索引取值,取值不方便
          - 不可以获取长度


  21.匿名函数与内置函数
      - lambda 参数: 返回值

      注意: 匿名函数必须配合内置函数使用,否则毫无意义

      - 内置函数:
          max(key=匿名函数) # 最大值
          min(key=匿名函数) # 最小值
          sorted(key=匿名函数) # 排序,默认升序,reverse=True降序
          map(匿名函数) # 映射
          reduce(匿名函数, ) # 合并
              from functools import reduce
              reduce()
          filter(匿名函数,) # 过滤

  22.递归:
      - 递推:
          先递推,重复往下执行函数本身,每一次执行都会更接近于终止条件。

      - 回溯:
          当递推遇到一个终止条件,开始回溯,一层一层往上推导。

  23.面向过程编程:
      是一门编程思想:
          核心是 “过程” 二字,过程指的是解决问题的步骤,即先干什么再干什么
          基于该编程思想编写程序,就好比一条工厂流水线,一种机械式的思维方式。

  24.模块:
      模块本质上就是一个.py后缀的文件。
      模块是一系列功能(变量,函数)的结合体。
      - 更好管理python代码

      - 三种来源:
          - 内置
          - 第三方
          - 自定义的

      - 四种表现形式:

          # 关注的:
          - 包下带有__init__.py的文件夹中的一组py文件。
          - python解释器自带的。

      - 模块的导入方式:
          - import 模块名字
          - from 模块 import 函数/变量名

      - 导入模块时发生的事情:
          1.先执行当前执行文件,生成一个当前文件的名称空间。
          2.会执行被导入的模块,会生成一个被导入模块的名称空间。
          3.将被导入模块的名称空间加载到内存中。

      - 首次导入模块发生的事情:
          import demo
          import demo
          import demo
          在执行文件中导入多次相同的模块,
          会只加载首次导入的模块的名称空间。

  25.包:
      注意: 包也可以称之为模块。

      包是内部带有__init__.py的文件夹。
      包是一系列模块的结合体,用来管理模块。

      - 导入包时发生的事情:
          1.会先执行包下面的__init__.py,产生一个名称空间。
          2.会将包中的所有模块都加载__init__.py的名称空间中。
          3.当在执行文件中使用包中的模块,指向的是__init__.py的名称空间。

      - 由__init__.py来帮我们管理模块。

      - 导入包的方式:
          import 包.模块名
          from 包 import 模块名
          from 包.模块 import 模块中名字 (变量名/函数名)

  26.常用内置模块:
      - time (******) --> time.time() , time.sleep()
      - datetime (******)
          - --> 格式化时间 ---> Format String
          - 时间的计算:
              日期时间 = 日期时间 + or - 时间对象(时间间隔对象)
              时间对象 = 日期时间 + or - 日期时间

      - random:
          random.random() ---> 随机获取 0——1 的浮点数
          random.uniform(1, 10) ---> 随机获取 1——0 的浮点数
          random.randint(1, 10) ---> 随机获取 1——0的整数
          random.choice(根据索引取值的可迭代对象) ---> 随机获取可迭代对象某一个值
          random.shuffle(根据索引取值的可迭代对象) ---> 随机打乱

      - os
          # 获取当前执行文件中的目录(文件夹)
          os.path.dirname(__file__)

          # 路径拼接
          os.path.join('文件的路径', '文件名')

          # 判断文件或文件夹是否存在
          os.path.exists('文件绝对路径')

          # 判断文件夹是否存在
          os.path.isdir('文件夹绝对路径')

          # 判断文件是否存在
          os.path.isfile('文件绝对路径')

          # 创建文件夹
          os.mkdir()

          # 删除文件夹
          os.rmdir() # 注意: 只能删除空的文件夹

          # 打印文件夹中所有的文件名
          os.listdir('文件夹的路径')

      - sys
          sys.path # 环境变量中的路径
          sys.path.append(
              '项目目录'
          )
          sys.argv # 获取cmd中的命令行   [py文件路径, 'tank', '123']

          # 可以做执行用户的校验,限制某个用户可以执行当前py文件

          python3 py文件路径 tank 123

      - hashlib
          加密:
          MD5:
              md5_obj = hashlib.md5()
              # 密码加密
              md5_obj.update(密码.encode('utf-8'))
              # 加盐
              md5_obj.update(盐.encode('utf-8'))
              md5_obj.hexdigest()

      - 序列化与反序列化:
          序列化: 将其他数据类型 ---》 json数据格式 ---》 字符串 ---》 写入文件中
          反序列化: 读取文件 ----》 字符串 ---》 json数据格式 ---- 》 其他数据类型

      - json
          优点:
              - 可以跨平台
          缺点:
              - 不支持python的set

          注意: 传入的元组变成列表

          json.dumps()
              - res = 将其他数据类型 ---》 json格式的字符串
              - f.write(res)

          json.loads()
              - json_res = f.read()
              - python_data = json.loads(json_res)

          json.dump()
              内部执行了f.write()

          json.load()
              内部执行了f.read()

      - pickle
          优点:
              - 支持python的任意数据类型
              - 可以存入二进制的数据
              - 存取速度快

          缺点: (致命的)
              - 不能跨平台使用
              - 只能python自己使用

      - collections
          - 具名元组:
              from collections import namedtuple
              namedtuple('对象的名字', 'x y')
              obj = namedtuple('坐标', ['x', 'y'])
              target_obj = obj(10, 20)
              target_obj.x # 10
              target_obj.y # 20

          - 有序字典:
              from collections import OrderedDict
              order_dict = OrderedDict({key: value})

      - re:
          - 正则表达式
              正则表达式是一个独立的技术, 由一堆特殊的字符组成。

              - 字符组
              - 元字符
              - 组合使用

          - re模块
              在python中要想使用正则表达式,必须通过re模块来编写。

      - subprocess
          可以通过python代码往操作系统终端输入命令,并返回结果。
          - 可以远程操控电脑

      - logging:
          注意1: log文件的目录
          注意2: log文件名
          注意3: log配置字典

          注意4:
          logging配置字典:
          LOGGING_DICT = {}
          import logging.config
          logging.config.dictConfig(LOGGING_DICT)
          logger = logging.getLogger('普通用户')
          logger.info('日志打印消息...')


  27.第三方模块:
      - requests
          - requests.get(url) ---> response
          - response.text # 获取文本数据
          - response.content # 获取二进制数据

      - openpyxl:
          # 创建文件
          from openpyxl import Workbook
          wb_obj = Workbook()
          wb1 = wb_obj.create_sheet('工作表名字1', 0)
          wb2 = wb_obj.create_sheet('工作表名字2', 1)
          wb1['C30'] = 200
          wb_obj.save('文件名字.xlsx')

          # 读取文件
          from openpyxl import load_workbook
          wb_obj = load_workbook('文件名字.xlsx的路径')
          wb1 = wb_obj['工作表名字1']
          print(wb1['C30'].value) # 200

  28.防止模块被导入时自动执行测试代码
  if __name__ == '__main__':
      执行测试代码


  29.软件开发目录规范:
      - 项目目录:
          - conf:
              - settings.py

          - core:
              - src.py # src ---> source

          - db:
              - data.json
              - data.pickle

          - interface:
              - user_interface.py
              ...

          - lib:
              - common.py

          - log:
              - user_log.log
              ...


          - bin/ start.py:
              - start.py

          - readme.txt
              项目说明书

  30.enumerate
      可迭代对象: list, tuple, dict
      # [1, 2, 3]
      enumerate(可迭代对象)   ---》 g((0, 1), (1, 2), (2, 3))

 

 

补充



# set1 = {1, 2, 3, 4}
# print(id(set1))
# set1.add(5)
# print(id(set1))
# print(set1)

# dict1 = {'k1': 'v1'}
# print(dict1.items())
#
# # {'k1': 'v1'} ---> 迭代器对象中(('k1', 'v1'), ('k2', 'v2'))
# for key, val in dict1.items():
#     print(key, val)

# 文件处理:
# with open(r'D:项目路径python13期day18user.txt', 'r', encoding='utf-8') as f:
#     print(f.read())

# num = 1
# with open(r'D:项目路径python13期day18user.txt', 'r', encoding='utf-8') as f:
#     for line in f:
#         print(line, num)
#         num += 1

# 爬取图片并以wb的模式保存到本地
# import requests
#
# response = requests.get('https://gss3.bdstatic.com/7Po3dSag_xI4khGkpoWK1HF6hhy/baike/w%3D268%3Bg%3D0/sign=9e8b07a25782b2b7a79f3ec20996acd2/aa64034f78f0f736900cd3a70455b319eac413a1.jpg')
#
# # print(response.content)
# print(response.iter_content())
#
# with open('小泽泽2.jpg', 'wb') as f:
#     for line in response.iter_content():
#         f.write(line)


def func():
   pass

func()

# map:
# list1 = ['tank', 'tank2', 'tank3', 'jason']
# # res == map对象
# res = map(lambda x: x + '_NB' if x.startswith('tank') else x + '_DSB', list1)
# print(list(res))
#
# from functools import reduce
#
# # 计算1——100的和
# # 加法: x初始默认值是0
# # 乘法: x初始默认值是1
# res = reduce(lambda x, y: x + y, range(1, 101), 0)
# res2 = reduce(lambda x, y: x * y, range(1, 101))
# print(res)
# print(res2)

# user_dic = {
#     'jason': 1000,
#     'tank': 10000
# }
#
# # user_dic[x] ---> 做判断
# # 只要:后条件为True,就会返回字典所有key的filter对象
# # 只要:后条件为False,就会返回的filter对象
# res = filter(lambda x: user_dic[x] == 10000, user_dic)
# print(list(res))


# import random
# print(random.uniform(1, 10) )

# import logging.config
#
# logging.config.dictConfig()
#
# logging.getLogger()

 

原文地址:https://www.cnblogs.com/zhangjinyi97/p/11929535.html