Python 基础

1.进程

• 进程

  https://www.cnblogs.com/xiaonq/p/7905347.html#i3

  • 进程是资源分配的最小单位（ 内存、cpu、网络、io）
  • 一个运行起来的程序就是一个进程
    • 什么是程序（程序是我们存储在硬盘里的代码）
    • 硬盘（256G）、内存条（8G）
    • 当我们双击图标，打开程序的时候，实际上就是通过I/O操作（读写）内存条里面
    • 内存条就是我们所指的资源
    • CPU分时
      • CPU比你的手速快多了，分时处理每个线程，但是由于太快然你觉得每个线程都是独占cpu
      • cpu是计算，只有时间片到了，获取cpu，线程真正执行
      • 当你想使用 网络、磁盘等资源的时候，需要cpu的调度
  • 进程具有独立的内存空间，所以没有办法相互通信
    • 进程如何通信
      • 进程queue(父子进程通信)
      • pipe（同一程序下两个进程通信）
      • managers（同一程序下多个进程通信）
      • RabbitMQ、redis等（不同程序间通信）
  • 为什么需要进程池
    • 一次性开启指定数量的进程
    • 如果有十个进程，有一百个任务，一次可以处理多少个（一次性只能处理十个）
    • 防止进程开启数量过多导致服务器压力过大

2.线程

• 有了进程为什么还需要线程
  • 因为进程不能同一时间只能做一个事情
• 什么是线程
  • 线程是操作系统调度的最小单位
  • 线程是进程正真的执行者，是一些指令的集合（进程资源的拥有者）
  • 同一个进程下的读多个线程共享内存空间，数据直接访问（数据共享）
  • 为了保证数据安全，必须使用线程锁
• GIL全局解释器锁
  • 在python全局解释器下，保证同一时间只有一个线程运行
  • 防止多个线程都修改数据
• 线程锁（互斥锁）
  • GIL锁只能保证同一时间只能有一个线程对某个资源操作，但当上一个线程还未执行完毕时可能就会释放GIL，其他线程就可以操作了
  • 线程锁本质把线程中的数据加了一把互斥锁
    • mysql中共享锁 & 互斥锁
      • mysql共享锁：共享锁，所有线程都能读，而不能写
      • mysql排它锁：排它，任何线程读取这个这个数据的权利都没有
    • 加上线程锁之后所有其他线程，读都不能读这个数据
  • 有了GIL全局解释器锁为什么还需要线程锁
    • 因为cpu是分时使用的
• 死锁定义
  • 两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去

3.协程

• 什么是协程

  • 协程微线程，纤程，本质是一个单线程
  • 协程能在单线程处理高并发
    • 线程遇到I/O操作会等待、阻塞，协程遇到I/O会自动切换（剩下的只有CPU操作）
    • 线程的状态保存在CPU的寄存器和栈里而协程拥有自己的空间，所以无需上下文切换的开销，所以快、
  • 为甚么协程能够遇到I/O自动切换
    • 协程有一个gevent模块(封装了greenlet模块)，遇到I/O自动切换

• 协程缺点

  • 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上
  • 线程阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

• 协程最大的优点

  • 不仅是处理高并发（单线程下处理高并发）
  • 特别节省资源（500日活，用php写需要两百多态机器，但是golang只需要二十多太机器）
    • 200多台机器一年
    • 二十多天机器一年

4.select、epool、pool

https://www.cnblogs.com/xiaonq/p/7907871.html

• I/O的实质是什么？

  • I/O的实质是将硬盘中的数据，或收到的数据实现从内核态 copy到 用户态的过程
  • 本文讨论的背景是Linux环境下的network IO。
  • 比如微信读取本地硬盘的过程
    • 微信进程会发送一个读取硬盘的请求----》操作系统
    • 只有内核才能够读取硬盘中的数据—》数据返回给微信程序（看上去就好像是微信直接读取）

• 用户态 & 内核态

  • 系统空间分为两个部分，一部分是内核态，一部分是用户态的部分
  • 内核态：内核态的空间资源只有操作系统能够访问
  • 用户态：我们写的普通程序使用的空间
    

• select

  • 只能处理1024个连接（每一个请求都可以理解为一个连接）
  • 不能告诉用户程序，哪一个连接是活跃的

• pool

  • 只是取消了最大1024个活跃的限制
  • 不能告诉用户程序，哪一个连接是活跃的

• epool

  • 不仅取消了1024这个最大连接限制
  • 而且能告诉用户程序哪一个是活跃的

5.什么是装饰器

5.1 什么是装饰器?（What）

• 装饰器本质是函数，用来给其他函数添加新的功能
• 特点：不修改调用方式、不修改源代码

5.2 装饰器的应用场景？（Where）

• 用户认证，判断用户是否登录
• 计算函数运行时间（算是一个功能、在项目里用的不多）
• 插入日志的时候
• redis缓存

5.3 为什么使用装饰器？（Why）

• 结合应用场景说需求

5.4 如何使用装饰器？（How）

• 装饰器求函数运行时间

import time
def timer(func):   #timer(test1)  func=test1
    def deco(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)      #run test1
        stop_time = time.time()
        print("running time is %s"%(stop_time-start_time))
    return deco

# @timer     # test1=timer(test1)
def test1():
    time.sleep(3)
    print("in the test1")
test1()

• 三级装饰器

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import time
def auth(auth_type):
    print("auth func:",auth_type)
    def outer_wrapper(func):
        def wrapper(*args, **kwargs):
            print("wrapper func args:", *args, **kwargs)
            print('运行前')
            func(*args, **kwargs)
            print('运行后')
        return wrapper
    return outer_wrapper

@auth(auth_type="local") # home = wrapper()
def home():
    print("welcome to home  page")
    return "from home"
home()

6.生成器

6.1 什么是生成器?(What)

• 生成器就是一个特殊的迭代器
• 一个有yield关键字的函数就是一个生成器
  • 生成器是这样一个函数，它记住上一次返回时在函数体中的位置。
  • 对生成器函数的第二次（或第 n 次）调用跳转至该函数中间，而上次调用的所有局部变量都保持不变。

6.2 生成器哪些场景应用？（Where）

• 生成器是一个概念，我们平常写代码可能用的并不多，但是python源码大量使用

• 比如我们tornado框架就是基于 生成器+协程

• 在我们代码中使用举例

• 比如我们要生成一百万个数据，如果用生成器非常节省空间，用列表浪费大量空间

import time
t1 = time.time()
g = (i for i in range(100000000))
t2 = time.time()
lst = [i for i in range(100000000)]
t3 = time.time()
print('生成器时间：',t2 - t1)  # 生成器时间： 0.0
print('列表时间：',t3 - t2)    # 列表时间： 5.821957349777222

6.3 为什么使用生成器

• 节省空间
• 高效

6.4 如何使用

#!/usr/bin/python
# -*- coding: utf-8 -*-
def read_big_file_v(fname):
    block_size = 1024 * 8
    with open(fname,encoding="utf8") as fp:
        while True:
            chunk = fp.read(block_size)
            # 当文件没有更多内容时，read 调用将会返回空字符串 ''
            if not chunk:
                break
            print(chunk)
path = r'C:\aaa\luting\edc-backend\tttt.py'
read_big_file_v(path)

7.迭代器

7.1 什么是迭代器(What)

• 迭代器是访问集合内元素的一种方法
  • 总是从集合内第一个元素访问，直到所有元素都被访问过结束，当调用 __next__而元素返回会引发一个，StopIteration异常
• 有两个方法：_iter_ _next_
  • _iter_ : 返回迭代器自身
  • _next_: 返回下一个元素

8.面向对象

1.什么是面向对象？（What）

• 使用模板的思想，将世界完事万物使用对象来表示一个类型

2.封装、继承、多态？特性

• 封装
  • 对类中属性和方法进行一种封装，隐藏了实现细节
• 继承
  • 子类继承父类后，就具有了父类的所有属性和方法，先继承，后重写
  • 新式类深度优先、经典类广度优先
• 多态
  • 一种接口，多种表现形式
  • 中国人、和美国人都能讲话，调用中国人的类讲中文，调用美国人将英文

3.新式类&经典类

• pythn3无论新式类还是经典类都是用 广度优先
• python2中，新式类：广度优先，经典类：深度优先

class D:
    def talk(self):
        print('D')

class B(D):
    pass
    # def talk(self):
    #     print('B')

class C(D):
    pass
    def talk(self):
        print('C')

class A(B,C):
    pass
    # def talk(self):
    #     print('A')

a = A()
a.talk()

4.静态方法、类方法、属性方法

• 静态方法

  • 特点：名义上归类管理，实际上不能访问类或者变量中的任意属性或者方法
  • 作用：让我们代码清晰，更好管理
  • 调用方式: 既可以被类直接调用，也可以通过实例调用

• 类方法

  • 作用**：无需实例化直接被类调用
  • 特性:** 类方法只能访问类变量，不能访问实例变量
  • 类方法使用场景：** 当我们还未创建实例，但是需要调用类中的方法
  • 调用方式:** 既可以被类直接调用，也可以通过实例调用

• 属性方法

  • 属性方法把一个方法变成一个属性，隐藏了实现细节,调用时不必加括号直接d.eat即可调用self.eat()方法

5.魔法方法

• _new_
  • 产生一个实例
• _init_
  • 产生一个对象
• _del_
  • 析构方法，删除无用的内存对象（当程序结束会自动自行析构方法）

6.反射

• hasattr: 判断当前类是否有这个方法
• getattr: 通过字符串反射出这个方法的内存地址
• setattr：将当前类添加一个方法
• delatrr: 删除实例属性

7.单例模式

• 单例模式：永远用一个对象得实例，避免新建太多实例浪费资源
• 实质：使用__new__方法新建类对象时先判断是否已经建立过，如果建过就使用已有的对象
• 使用场景：如果每个对象内部封装的值都相同就可以用单例模式

class Foo(object):
   instance = None
   def __init__(self):
      self.name = 'alex'

   def __new__(cls, *args, **kwargs):
      if Foo.instance:
         return Foo.instance
      else:
         Foo.instance = object.__new__(cls,*args,**kwargs)
         return Foo.instance

obj1 = Foo()       # obj1和obj2获取的就是__new__方法返回的内容
obj2 = Foo()
print(obj1,obj2)   # 运行结果： <__main__.Foo object at 0x00D3B450>    <__main__.Foo object at 0x00D3B450>

# 运行结果说明：
# 这可以看到我们新建的两个Foo()对象内存地址相同，说明使用的•同一个类，没有重复建立类