zoukankan      html  css  js  c++  java
  • 总复习

    总复习

    总复习:
      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()

     

  • 相关阅读:
    准备工作
    使用awstats分析nginx日志
    kvm虚拟化环境中的时区设置
    使用awk格式化输出文本
    gitlab(7.9)升级到8.0.1
    为openstack制作CoreOS虚拟机镜像(基于CoreOS官方提供镜像)
    KVM虚拟化之嵌套虚拟化nested
    编译制作Linux 3.18内核rpm包(升级centos6.x虚拟机内核)
    Linux主机之间传输文件的几种方法对比
    spice在桌面虚拟化中的应用系列之二(Linux平台spice客户端的编译安装,支持USB映射)
  • 原文地址:https://www.cnblogs.com/zhangjinyi97/p/11929535.html
Copyright © 2011-2022 走看看