Python Key Knowledge Summary

Python
Python
发布日期:   2021-09-27
更新日期:   2021-11-10
文章字数:   28.7k
阅读时长:   114 分
阅读次数:  

Py2 VS Py3

  • print成为了函数，python2是关键字

  • 不再有unicode对象，默认str就是unicode

  • python3除号返回浮点数

  • 没有了long类型

  • xrange不存在，range替代了xrange

  • 可以使用中文定义函数名变量名

  • 高级解包 和*解包

  • 限定关键字参数 *后的变量必须加入名字=值

  • raise from

  • iteritems移除变成items()

  • yield from 链接子生成器

  • asyncio,async/await原生协程支持异步编程

  • 新增 enum, mock, ipaddress, concurrent.futures, asyncio urllib, selector

    • 不同枚举类间不能进行比较
    • 同一枚举类间只能进行相等的比较
    • 枚举类的使用(编号默认从1开始)
    • 为了避免枚举类中相同枚举值的出现，可以使用@unique装饰枚举类
#枚举的注意事项
from enum import Enum

class COLOR(Enum):
    YELLOW=1
#YELLOW=2#会报错
    GREEN=1#不会报错,GREEN可以看作是YELLOW的别名
    BLACK=3
    RED=4
print(COLOR.GREEN)#COLOR.YELLOW,还是会打印出YELLOW
for i in COLOR:#遍历一下COLOR并不会有GREEN
    print(i)
#COLOR.YELLOW\nCOLOR.BLACK\nCOLOR.RED\n怎么把别名遍历出来
for i in COLOR.__members__.items():
    print(i)
# output:('YELLOW', <COLOR.YELLOW: 1>)\n('GREEN', <COLOR.YELLOW: 1>)\n('BLACK', <COLOR.BLACK: 3>)\n('RED', <COLOR.RED: 4>)
for i in COLOR.__members__:
    print(i)
# output:YELLOW\nGREEN\nBLACK\nRED

#枚举转换
#最好在数据库存取使用枚举的数值而不是使用标签名字字符串
#在代码里面使用枚举类
a=1
print(COLOR(a))# output:COLOR.YELLOW

py2/3 转换工具

  • six模块：兼容pyton2和pyton3的模块
  • 2to3工具：改变代码语法版本
  • future：使用下一版本的功能

常用的库

不常用但很重要的库

  • dis(代码字节码分析)

  • inspect(生成器状态)

  • cProfile(性能分析)

  • bisect(维护有序列表)

  • fnmatch

    • fnmatch(string,”*.txt”) #win下不区分大小写
    • fnmatch根据系统决定
    • fnmatchcase完全区分大小写

  • timeit(代码执行时间)

    def isLen(strString):
        #还是应该使用三元表达式，更快
        return True if len(strString)>6 else False

    def isLen1(strString):
        #这里注意false和true的位置
        return [False,True][len(strString)>6]
    import timeit
    print(timeit.timeit('isLen1("5fsdfsdfsaf")',setup="from __main__ import isLen1"))

    print(timeit.timeit('isLen("5fsdfsdfsaf")',setup="from __main__ import isLen"))

  • contextlib

    • @contextlib.contextmanager使生成器函数变成一个上下文管理器

  • types(包含了标准解释器定义的所有类型的类型对象,可以将生成器函数修饰为异步模式)

    import types
    types.coroutine #相当于实现了__await__
  • html(实现对html的转义)
    import html
    html.escape("<h1>I'm Jim</h1>") # output:'&lt;h1&gt;I&#x27;m Jim&lt;/h1&gt;'
    html.unescape('&lt;h1&gt;I&#x27;m Jim&lt;/h1&gt;') # <h1>I'm Jim</h1>
  • mock(解决测试依赖)
  • concurrent(创建进程池和线程池)
from concurrent.futures import ThreadPoolExecutor

pool = ThreadPoolExecutor()
task = pool.submit(函数名，（参数）) #此方法不会阻塞，会立即返回
task.done()#查看任务执行是否完成
task.result()#阻塞的方法，查看任务返回值
task.cancel()#取消未执行的任务，返回True或False,取消成功返回True
task.add_done_callback()#回调函数
task.running()#是否正在执行     task就是一个Future对象

for data in pool.map(函数，参数列表):#返回已经完成的任务结果列表，根据参数顺序执行
    print(返回任务完成得执行结果data)

from concurrent.futures import as_completed
as_completed(任务列表)#返回已经完成的任务列表，完成一个执行一个

wait(任务列表,return_when=条件)#根据条件进行阻塞主线程，有四个条件
  • selector(封装select,用户多路复用io编程)
  • asyncio
future=asyncio.ensure_future(协程)  等于后面的方式  future=loop.create_task(协程)
future.add_done_callback()添加一个完成后的回调函数
loop.run_until_complete(future)
future.result()查看写成返回结果

asyncio.wait()接受一个可迭代的协程对象
asynicio.gather(*可迭代对象,*可迭代对象）    两者结果相同，但gather可以批量取消，gather对象.cancel()

一个线程中只有一个loop

在loop.stop时一定要loop.run_forever()否则会报错
loop.run_forever()可以执行非协程
最后执行finally模块中 loop.close()

asyncio.Task.all_tasks()拿到所有任务 然后依次迭代并使用任务.cancel()取消

偏函数partial(函数，参数)把函数包装成另一个函数名  其参数必须放在定义函数的前面

loop.call_soon(函数,参数)
call_soon_threadsafe()线程安全    
loop.call_later(时间,函数,参数)
在同一代码块中call_soon优先执行，然后多个later根据时间的升序进行执行

如果非要运行有阻塞的代码
使用loop.run_in_executor(executor,函数，参数)包装成一个多线程，然后放入到一个task列表中，通过wait(task列表)来运行

通过asyncio实现http
reader,writer=await asyncio.open_connection(host,port)
writer.writer()发送请求
async for data in reader:
    data=data.decode("utf-8")
    list.append(data)
然后list中存储的就是html

as_completed(tasks)完成一个返回一个,返回的是一个可迭代对象    

协程锁
async with Lock():

Python进阶

  • 进程间通信：

    • Manager(内置了好多数据结构，可以实现多进程间内存共享)
from multiprocessing import Manager,Process
def add_data(p_dict, key, value):
    p_dict[key] = value

if __name__ == "__main__":
    progress_dict = Manager().dict()
    from queue import PriorityQueue

    first_progress = Process(target=add_data, args=(progress_dict, "bobby1", 22))
    second_progress = Process(target=add_data, args=(progress_dict, "bobby2", 23))

    first_progress.start()
    second_progress.start()
    first_progress.join()
    second_progress.join()

    print(progress_dict)
    • Pipe(适用于两个进程)
from multiprocessing import Pipe,Process
#pipe的性能高于queue
def producer(pipe):
    pipe.send("bobby")

def consumer(pipe):
    print(pipe.recv())

if __name__ == "__main__":
    recevie_pipe, send_pipe = Pipe()
    #pipe只能适用于两个进程
    my_producer= Process(target=producer, args=(send_pipe, ))
    my_consumer = Process(target=consumer, args=(recevie_pipe,))

    my_producer.start()
    my_consumer.start()
    my_producer.join()
    my_consumer.join()
    • Queue(不能用于进程池,进程池间通信需要使用Manager().Queue())
from multiprocessing import Queue,Process
def producer(queue):
    queue.put("a")
    time.sleep(2)

def consumer(queue):
    time.sleep(2)
    data = queue.get()
    print(data)

if __name__ == "__main__":
    queue = Queue(10)
    my_producer = Process(target=producer, args=(queue,))
    my_consumer = Process(target=consumer, args=(queue,))
    my_producer.start()
    my_consumer.start()
    my_producer.join()
    my_consumer.join()
    • 进程池
def producer(queue):
    queue.put("a")
    time.sleep(2)

def consumer(queue):
    time.sleep(2)
    data = queue.get()
    print(data)

if __name__ == "__main__":
    queue = Manager().Queue(10)
    pool = Pool(2)

    pool.apply_async(producer, args=(queue,))
    pool.apply_async(consumer, args=(queue,))

    pool.close()
    pool.join()

  • sys模块几个常用方法

    • argv 命令行参数list,第一个是程序本身的路径
    • path 返回模块的搜索路径
    • modules.keys() 返回已经导入的所有模块的列表
    • exit(0) 退出程序

  • a in s or b in s or c in s简写

    • 采用any方式：all() 对于任何可迭代对象为空都会返回True
    # 方法一
    True in [i in s for i in [a,b,c]]
    # 方法二
    any(i in s for i in [a,b,c])
    # 方法三
    list(filter(lambda x:x in s,[a,b,c]))

  • set集合运用

    • {1,2}.issubset({1,2,3})#判断是否是其子集
    • {1,2,3}.issuperset({1,2})
    • {}.isdisjoint({})#判断两个set交集是否为空,是空集则为True

  • 代码中中文匹配

    • [u4E00-u9FA5]匹配中文文字区间[一到龥]

  • 查看系统默认编码格式

    import sys
    sys.getdefaultencoding()    # setdefaultencodeing()设置系统编码方式
  • getattr VS getattribute
class A(dict):
    def __getattr__(self,value):#当访问属性不存在的时候返回
        return 2
    def __getattribute__(self,item):#屏蔽所有的元素访问
        return item

  • 类变量是不会存入实例dict中的，只会存在于类的dict中

  • globals/locals(可以变相操作代码)

    • globals中保存了当前模块中所有的变量属性与值
    • locals中保存了当前环境中的所有变量属性与值

  • python变量名的解析机制(LEGB)

    • 本地作用域(Local)
    • 当前作用域被嵌入的本地作用域(Enclosing locals)
    • 全局/模块作用域(Global)
    • 内置作用域(Built-in)

  • 实现从1-100每三个为一组分组

    print([[x for x in range(1,101)][i:i+3] for i in range(0,100,3)])

  • 什么是元类？

    • 即创建类的类，创建类的时候只需要将metaclass=元类，元类需要继承type而不是object,因为type就是元类
type.__bases__  #(<class 'object'>,)
object.__bases__    #()
type(object)    #<class 'type'>
    class Yuan(type):
        def __new__(cls,name,base,attr,*args,**kwargs):
            return type(name,base,attr,*args,**kwargs)
    class MyClass(metaclass=Yuan):
        pass

  • 什么是鸭子类型(即:多态)？

    • Python在使用传入参数的过程中不会默认判断参数类型，只要参数具备执行条件就可以执行

  • 深拷贝和浅拷贝

    • 深拷贝拷贝内容，浅拷贝拷贝地址(增加引用计数)
    • copy模块实现深拷贝

  • 单元测试

    • 一般测试类继承模块unittest下的TestCase
    • pytest模块快捷测试(方法以test_开头/测试文件以test_开头/测试类以Test开头，并且不能带有 init 方法)
    • coverage统计测试覆盖率
    class MyTest(unittest.TestCase):
        def tearDown(self):# 每个测试用例执行前执行
            print('本方法开始测试了')

        def setUp(self):# 每个测试用例执行之前做操作
            print('本方法测试结束')

        @classmethod
        def tearDownClass(self):# 必须使用 @ classmethod装饰器, 所有test运行完后运行一次
            print('开始测试')
        @classmethod
        def setUpClass(self):# 必须使用@classmethod 装饰器,所有test运行前运行一次
            print('结束测试')

        def test_a_run(self):
            self.assertEqual(1, 1)  # 测试用例

  • gil会根据执行的字节码行数以及时间片释放gil，gil在遇到io的操作时候主动释放

  • 什么是monkey patch?

    • 猴子补丁，在运行的时候替换掉会阻塞的语法修改为非阻塞的方法

  • 什么是自省(Introspection)？

    • 运行时判断一个对象的类型的能力，id,type,isinstance

  • python是值传递还是引用传递？

    • 都不是，python是共享传参，默认参数在执行时只会执行一次

  • try-except-else-finally中else和finally的区别

    • else在不发生异常的时候执行，finally无论是否发生异常都会执行
    • except一次可以捕获多个异常，但一般为了对不同异常进行不同处理，我们分次捕获处理

  • GIL全局解释器锁

    • 同一时间只能有一个线程执行，CPython(IPython)的特点，其他解释器不存在
    • cpu密集型：多进程+进程池
    • io密集型：多线程/协程

  • 什么是Cython

    • 将python解释成C代码工具

  • 生成器和迭代器

    • 可迭代对象只需要实现iter方法

      • 实现next和iter方法的对象就是迭代器

    • 使用生成器表达式或者yield的生成器函数(生成器是一种特殊的迭代器)

  • 什么是协程

    • yield

    • async-awiat

      • 比线程更轻量的多任务方式
      • 实现方式

  • dict底层结构

    • 为了支持快速查找使用了哈希表作为底层结构
    • 哈希表平均查找时间复杂度为o(1)
    • CPython解释器使用二次探查解决哈希冲突问题

  • Hash扩容和Hash冲突解决方案

    • 链接法

    • 二次探查(开放寻址法)：python使用

      • 循环复制到新空间实现扩容
      • 冲突解决：
    for gevent import monkey
    monkey.patch_all()  #将代码中所有的阻塞方法都进行修改，可以指定具体要修改的方法
  • 判断是否为生成器或者协程
    co_flags = func.__code__.co_flags

    # 检查是否是协程
    if co_flags & 0x180:
        return func

    # 检查是否是生成器
    if co_flags & 0x20:
        return func
  • 斐波那契解决的问题及变形
#一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
#请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
#方式一：
fib = lambda n: n if n <= 2 else fib(n - 1) + fib(n - 2)
#方式二：
def fib(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return b

#一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
fib = lambda n: n if n < 2 else 2 * fib(n - 1)
  • 获取电脑设置的环境变量
    import os
    os.getenv(env_name,None)#获取环境变量如果不存在为None

  • 垃圾回收机制

    • 引用计数
    • 标记清除
    • 分代回收
    #查看分代回收触发
    import gc
    gc.get_threshold()  #output:(700, 10, 10)

  • True和False在代码中完全等价于1和0,可以直接和数字进行计算，inf表示无穷大

  • C10M/C10K

    • C10M:8核心cpu，64G内存，在10gbps的网络上保持1000万并发连接
    • C10K：1GHz CPU,2G内存，1gbps网络环境下保持1万个客户端提供FTP服务

  • yield from与yield的区别：

    • yield from跟的是一个可迭代对象，而yield后面没有限制
    • GeneratorExit生成器停止时触发

  • 单下划线的几种使用

    • 在定义变量时，表示为私有变量
    • 在解包时，表示舍弃无用的数据
    • 在交互模式中表示上一次代码执行结果
    • 可以做数字的拼接(111_222_333)

  • 使用break就不会执行else

  • 10进制转2进制

    def conver_bin(num):
        if num == 0:
            return num
        re = []
        while num:
            num, rem = divmod(num,2)
            re.append(str(rem))
        return "".join(reversed(re))
    conver_bin(10)
  • list1 = [‘A’, ‘B’, ‘C’, ‘D’] 如何才能得到以list中元素命名的新列表 A=[],B=[],C=[],D=[]呢
    list1 = ['A', 'B', 'C', 'D']

    # 方法一
    for i in list1:
        globals()[i] = []   # 可以用于实现python版反射

    # 方法二
    for i in list1:
        exec(f'{i} = []')   # exec执行字符串语句
  • memoryview与bytearray$\color{&#35 000}(不常用，只是看到了记载一下)$
    # bytearray是可变的，bytes是不可变的,memoryview不会产生新切片和对象
    a = 'aaaaaa'
    ma = memoryview(a)
    ma.readonly  # 只读的memoryview
    mb = ma[:2]  # 不会产生新的字符串

    a = bytearray('aaaaaa')
    ma = memoryview(a)
    ma.readonly  # 可写的memoryview
    mb = ma[:2]      # 不会会产生新的bytearray
    mb[:2] = 'bb'    # 对mb的改动就是对ma的改动
  • Ellipsis类型
# 代码中出现...省略号的现象就是一个Ellipsis对象
L = [1,2,3]
L.append(L)
print(L)    # output:[1,2,3,[…]]
  • lazy惰性计算
    class lazy(object):
        def __init__(self, func):
            self.func = func

        def __get__(self, instance, cls):
            val = self.func(instance)    #其相当于执行的area(c),c为下面的Circle对象
            setattr(instance, self.func.__name__, val)
            return val`

    class Circle(object):
        def __init__(self, radius):
            self.radius = radius

        @lazy
        def area(self):
            print('evalute')
            return 3.14 * self.radius ** 2
  • 遍历文件，传入一个文件夹，将里面所有文件的路径打印出来(递归)
all_files = []    
def getAllFiles(directory_path):
    import os                                       
    for sChild in os.listdir(directory_path):                
        sChildPath = os.path.join(directory_path,sChild)
        if os.path.isdir(sChildPath):
            getAllFiles(sChildPath)
        else:
            all_files.append(sChildPath)
    return all_files
  • 文件存储时，文件名的处理
#secure_filename将字符串转化为安全的文件名
from werkzeug import secure_filename
secure_filename("My cool movie.mov") # output:My_cool_movie.mov
secure_filename("../../../etc/passwd") # output:etc_passwd
secure_filename(u'i contain cool \xfcml\xe4uts.txt') # output:i_contain_cool_umlauts.txt
  • 日期格式化
from datetime import datetime

datetime.now().strftime("%Y-%m-%d")

import time
#这里只有localtime可以被格式化，time是不能格式化的
time.strftime("%Y-%m-%d",time.localtime())
  • tuple使用+=奇怪的问题
# 会报错，但是tuple的值会改变，因为t[1]id没有发生变化
t=(1,[2,3])
t[1]+=[4,5]
# t[1]使用append\extend方法并不会报错，并可以成功执行
  • missing你应该知道
class Mydict(dict):
    def __missing__(self,key): # 当Mydict使用切片访问属性不存在的时候返回的值
        return key
  • +与+=
# +不能用来连接列表和元祖，而+=可以（通过iadd实现，内部实现方式为extends(),所以可以增加元组），+会创建新对象
#不可变对象没有__iadd__方法，所以直接使用的是__add__方法，因此元祖可以使用+=进行元祖之间的相加
  • 如何将一个可迭代对象的每个元素变成一个字典的所有键？
dict.fromkeys(['jim','han'],21) # output:{'jim': 21, 'han': 21}
  • wireshark抓包软件

网络知识

  • 什么是HTTPS?

    • 安全的HTTP协议，https需要cs证书，数据加密，端口为443，安全，同一网站https seo排名会更高

  • 常见响应状态码

    204 No Content //请求成功处理，没有实体的主体返回，一般用来表示删除成功
    206 Partial Content //Get范围请求已成功处理
    303 See Other //临时重定向，期望使用get定向获取
    304 Not Modified //请求缓存资源
    307 Temporary Redirect //临时重定向，Post不会变成Get
    401 Unauthorized //认证失败
    403 Forbidden //资源请求被拒绝
    400 //请求参数错误
    201 //添加或更改成功
    503 //服务器维护或者超负载
  • http请求方法的幂等性及安全性
  • WSGI
    # environ：一个包含所有HTTP请求信息的dict对象
    # start_response：一个发送HTTP响应的函数
    def application(environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/html')])
        return '<h1>Hello, web!</h1>'

  • RPC

  • CDN

  • SSL(Secure Sockets Layer 安全套接层),及其继任者传输层安全（Transport Layer Security，TLS）是为网络通信提供安全及数据完整性的一种安全协议。

  • SSH（安全外壳协议） 为 Secure Shell 的缩写，由 IETF 的网络小组（Network Working Group）所制定；SSH 为建立在应用层基础上的安全协议。SSH 是目前较可靠，专为远程登录会话和其他网络服务提供安全性的协议。利用 SSH 协议可以有效防止远程管理过程中的信息泄露问题。SSH最初是UNIX系统上的一个程序，后来又迅速扩展到其他操作平台。SSH在正确使用时可弥补网络中的漏洞。SSH客户端适用于多种平台。几乎所有UNIX平台—包括HP-UX、Linux、AIX、Solaris、Digital UNIX、Irix，以及其他平台，都可运行SSH。

  • TCP/IP

    • TCP:面向连接/可靠/基于字节流

    • UDP:无连接/不可靠/面向报文

    • 三次握手四次挥手

      • 三次握手(SYN/SYN+ACK/ACK)
      • 四次挥手(FIN/ACK/FIN/ACK)

    • 为什么连接的时候是三次握手，关闭的时候却是四次握手？

      • 因为当Server端收到Client端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当Server端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉Client端，”你发的FIN报文我收到了”。只有等到我Server端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送。故需要四步握手。

    • 为什么TIME_WAIT状态需要经过2MSL(最大报文段生存时间)才能返回到CLOSE状态？

      • 虽然按道理，四个报文都发送完毕，我们可以直接进入CLOSE状态了，但是我们必须假象网络是不可靠的，有可以最后一个ACK丢失。所以TIME_WAIT状态就是用来重发可能丢失的ACK报文。

  • XSS/CSRF

    • HttpOnly禁止js脚本访问和操作Cookie,可以有效防止XSS

Mysql

  • 索引改进过程

    • 线性结构->二分查找->hash->二叉查找树->平衡二叉树->多路查找树->多路平衡查找树(B-Tree)

  • Mysql面试总结基础篇

    https://segmentfault.com/a/1190000018371218

  • Mysql面试总结进阶篇

    https://segmentfault.com/a/1190000018380324

  • 深入浅出Mysql

    http://ningning.today/2017/02/13/database/深入浅出mysql/

  • 清空整个表时，InnoDB是一行一行的删除，而MyISAM则会从新删除建表

  • text/blob数据类型不能有默认值，查询时不存在大小写转换

  • 什么时候索引失效

    • 以%开头的like模糊查询

    • 出现隐式类型转换

    • 没有满足最左前缀原则

      • 对于多列索引，不是使用的第一部分，则不会使用索引

    • 失效场景：

      • 应尽量避免在 where 子句中使用 != 或 <> 操作符，否则引擎将放弃使用索引而进行全表扫描
      • 尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，即使其中有条件带索引也不会使用，这也是为什么尽量少用 or 的原因
      • 如果列类型是字符串，那一定要在条件中将数据使用引号引用起来，否则不会使用索引
      • 应尽量避免在 where 子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描
例如：
select id from t where substring(name,1,3) = 'abc' – name;
以abc开头的，应改成：
select id from t where name like 'abc%' 
例如：
select id from t where datediff(day, createdate, '2005-11-30') = 0 – '2005-11-30';
应改为:
      • 不要在 where 子句中的 “=” 左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引
      • 应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描
如：
select id from t where num/2 = 100 
应改为:
select id from t where num = 100*2；
      • 不适合键值较少的列（重复数据较多的列）比如：set enum列就不适合(枚举类型(enum)可以添加null,并且默认的值会自动过滤空格集合(set)和枚举类似，但只可以添加64个值)
      • 如果MySQL估计使用全表扫描要比使用索引快，则不使用索引

  • 什么是聚集索引

    • B+Tree叶子节点保存的是数据还是指针
    • MyISAM索引和数据分离，使用非聚集
    • InnoDB数据文件就是索引文件，主键索引就是聚集索引

Redis命令总结

  • 为什么这么快？

    • 基于内存，由C语言编写

    • 使用多路I/O复用模型，非阻塞IO

    • 使用单线程减少线程间切换

      • 因为Redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了（毕竟采用多线程会有很多麻烦！）。

    • 数据结构简单

    • 自己构建了VM机制，减少调用系统函数的时间

  • 优势

    • 性能高 – Redis能读的速度是110000次/s,写的速度是81000次/s
    • 丰富的数据类型
    • 原子 – Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行
    • 丰富的特性 – Redis还支持 publish/subscribe（发布/订阅）, 通知, key 过期等等特性

  • 什么是redis事务？

    • 将多个请求打包，一次性、按序执行多个命令的机制
    • 通过multi,exec,watch等命令实现事务功能
    • Python redis-py pipeline=conn.pipeline(transaction=True)

  • 持久化方式

    • RDB(快照)

      • save(同步，可以保证数据一致性)
      • bgsave(异步，shutdown时，无AOF则默认使用)

    • AOF(追加日志)

  • 怎么实现队列

    • push
    • rpop

  • 常用的数据类型(Bitmaps,Hyperloglogs,范围查询等不常用)

    • String(字符串):计数器

      • 整数或sds(Simple Dynamic String)

    • List(列表)：用户的关注，粉丝列表

      • ziplist(连续内存块，每个entry节点头部保存前后节点长度信息实现双向链表功能)或double linked list

    • Hash(哈希)：

    • Set(集合)：用户的关注者

      • intset或hashtable

    • Zset(有序集合)：实时信息排行榜

      • skiplist(跳跃表)

  • 与Memcached区别

    • Memcached只能存储字符串键
    • Memcached用户只能通过APPEND的方式将数据添加到已有的字符串的末尾，并将这个字符串当做列表来使用。但是在删除这些元素的时候，Memcached采用的是通过黑名单的方式来隐藏列表里的元素，从而避免了对元素的读取、更新、删除等操作
    • Redis和Memcached都是将数据存放在内存中，都是内存数据库。不过Memcached还可用于缓存其他东西，例如图片、视频等等
    • 虚拟内存–Redis当物理内存用完时，可以将一些很久没用到的Value 交换到磁盘
    • 存储数据安全–Memcached挂掉后，数据没了；Redis可以定期保存到磁盘（持久化）
    • 应用场景不一样：Redis出来作为NoSQL数据库使用外，还能用做消息队列、数据堆栈和数据缓存等；Memcached适合于缓存SQL语句、数据集、用户临时性数据、延迟查询数据和Session等

  • Redis实现分布式锁

    • 使用setnx实现加锁，可以同时通过expire添加超时时间
    • 锁的value值可以是一个随机的uuid或者特定的命名
    • 释放锁的时候，通过uuid判断是否是该锁，是则执行delete释放锁

  • 常见问题

    • 缓存雪崩

      • 短时间内缓存数据过期，大量请求访问数据库

    • 缓存穿透

      • 请求访问数据时，查询缓存中不存在，数据库中也不存在

    • 缓存预热

      • 初始化项目，将部分常用数据加入缓存

    • 缓存更新

      • 数据过期，进行更新缓存数据

    • 缓存降级

      • 当访问量剧增、服务出现问题（如响应时间慢或不响应）或非核心服务影响到核心流程的性能时，仍然需要保证服务还是可用的，即使是有损服务。系统可以根据一些关键数据进行自动降级，也可以配置开关实现人工降级

  • 一致性Hash算法

    • 使用集群的时候保证数据的一致性

  • 基于redis实现一个分布式锁，要求一个超时的参数

    • setnx

  • 虚拟内存

  • 内存抖动

Linux

  • Unix五种i/o模型

    • 阻塞io

    • 非阻塞io

    • 多路复用io(Python下使用selectot实现io多路复用)

      • select

        • 并发不高，连接数很活跃的情况下

      • poll

        • 比select提高的并不多

      • epoll

        • 适用于连接数量较多，但活动链接数少的情况

    • 信号驱动io

    • 异步io(Gevent/Asyncio实现异步)

  • 比man更好使用的命令手册

    • tldr:一个有命令示例的手册

  • kill -9和-15的区别

    • -15：程序立刻停止/当程序释放相应资源后再停止/程序可能仍然继续运行
    • -9：由于-15的不确定性，所以直接使用-9立即杀死进程

  • 分页机制（逻辑地址和物理地址分离的内存分配管理方案）：

    • 操作系统为了高效管理内存，减少碎片
    • 程序的逻辑地址划分为固定大小的页
    • 物理地址划分为同样大小的帧
    • 通过页表对应逻辑地址和物理地址

  • 分段机制

    • 为了满足代码的一些逻辑需求
    • 数据共享/数据保护/动态链接
    • 每个段内部连续内存分配，段和段之间是离散分配的

  • 查看cpu内存使用情况？

    • top
    • free 查看可用内存，排查内存泄漏问题

设计模式

单例模式

    # 方式一
    def Single(cls,*args,**kwargs):
        instances = {}
        def get_instance (*args, **kwargs):
            if cls not in instances:
                instances[cls] = cls(*args, **kwargs)
            return instances[cls]
        return get_instance
    @Single
    class B:
        pass
    # 方式二
    class Single:
        def __init__(self):
            print("单例模式实现方式二。。。")

    single = Single()
    del Single  # 每次调用single就可以了
    # 方式三(最常用的方式)
    class Single:
        def __new__(cls,*args,**kwargs):
            if not hasattr(cls,'_instance'):
                cls._instance = super().__new__(cls,*args,**kwargs)
            return cls._instance

工厂模式

    class Dog:
        def __init__(self):
            print("Wang Wang Wang")
    class Cat:
        def __init__(self):
            print("Miao Miao Miao")


    def fac(animal):
        if animal.lower() == "dog":
            return Dog()
        if animal.lower() == "cat":
            return Cat()
        print("对不起，必须是：dog,cat")

构造模式

    class Computer:
        def __init__(self,serial_number):
            self.serial_number = serial_number
            self.memory = None
            self.hadd = None
            self.gpu = None
        def __str__(self):
            info = (f'Memory:{self.memoryGB}',
            'Hard Disk:{self.hadd}GB',
            'Graphics Card:{self.gpu}')
            return ''.join(info)
    class ComputerBuilder：
        def __init__(self):
            self.computer = Computer('Jim1996')
        def configure_memory(self,amount):
            self.computer.memory = amount
            return self #为了方便链式调用
        def configure_hdd(self,amount):
            pass
        def configure_gpu(self,gpu_model):
            pass
    class HardwareEngineer:
        def __init__(self):
            self.builder = None
        def construct_computer(self,memory,hdd,gpu)
            self.builder = ComputerBuilder()
            self.builder.configure_memory(memory).configure_hdd(hdd).configure_gpu(gpu)
        @property
        def computer(self):
            return self.builder.computer

数据结构和算法内置数据结构和算法

python实现各种数据结构

快速排序

    def quick_sort(_list):
            if len(_list) < 2:
                return _list
            pivot_index = 0
            pivot = _list(pivot_index)
            left_list = [i for i in _list[:pivot_index] if i < pivot]
            right_list = [i for i in _list[pivot_index:] if i > pivot]
        return quick_sort(left) + [pivot] + quick_sort(right)

选择排序

    def select_sort(seq):
        n = len(seq)
        for i in range(n-1)
        min_idx = i
            for j in range(i+1,n):
                if seq[j] < seq[min_inx]:
                    min_idx = j
            if min_idx != i:
                seq[i], seq[min_idx] = seq[min_idx],seq[i]

插入排序

    def insertion_sort(_list):
        n = len(_list)
        for i in range(1,n):
            value = _list[i]
            pos = i
            while pos > 0 and value < _list[pos - 1]
                _list[pos] = _list[pos - 1]
                pos -= 1
            _list[pos] = value
            print(sql)

归并排序

    def merge_sorted_list(_list1,_list2):   #合并有序列表
        len_a, len_b = len(_list1),len(_list2)
        a = b = 0
        sort = []
        while len_a > a and len_b > b:
            if _list1[a] > _list2[b]:
                sort.append(_list2[b])
                b += 1
            else:
                sort.append(_list1[a])
                a += 1
        if len_a > a:
            sort.append(_list1[a:])
        if len_b > b:
            sort.append(_list2[b:])
        return sort

    def merge_sort(_list):
        if len(list1)<2:
            return list1
        else:
            mid = int(len(list1)/2)
            left = mergesort(list1[:mid])
            right = mergesort(list1[mid:])
            return merge_sorted_list(left,right)

堆排序heapq模块

    from heapq import nsmallest
    def heap_sort(_list):
        return nsmallest(len(_list),_list)

栈

    from collections import deque
    class Stack:
        def __init__(self):
            self.s = deque()
        def peek(self):
            p = self.pop()
            self.push(p)
            return p
        def push(self, el):
            self.s.append(el)
        def pop(self):
            return self.pop()

队列

    from collections import deque
    class Queue:
        def __init__(self):
            self.s = deque()
        def push(self, el):
            self.s.append(el)
        def pop(self):
            return self.popleft()

二分查找

    def binary_search(_list,num):
        mid = len(_list)//2
        if len(_list) < 1:
            return Flase
        if num > _list[mid]:
            BinarySearch(_list[mid:],num)
        elif num < _list[mid]:
            BinarySearch(_list[:mid],num)
        else:
            return _list.index(num)

面试加强题：

关于数据库优化及设计

https://segmentfault.com/a/1190000018426586

  • 如何使用两个栈实现一个队列

  • 反转链表

  • 合并两个有序链表

  • 删除链表节点

  • 反转二叉树

  • 设计短网址服务？62进制实现

  • 设计一个秒杀系统(feed流)？

    https://www.jianshu.com/p/ea0259d109f9

  • 为什么mysql数据库的主键使用自增的整数比较好？使用uuid可以吗？为什么？

    • 如果InnoDB表的数据写入顺序能和B+树索引的叶子节点顺序一致的话，这时候存取效率是最高的。为了存储和查询性能应该使用自增长id做主键。
    • 对于InnoDB的主索引，数据会按照主键进行排序，由于UUID的无序性，InnoDB会产生巨大的IO压力，此时不适合使用UUID做物理主键，可以把它作为逻辑主键，物理主键依然使用自增ID。为了全局的唯一性，应该用uuid做索引关联其他表或做外键

  • 如果是分布式系统下我们怎么生成数据库的自增id呢？

    • 使用redis

  • 基于redis实现一个分布式锁，要求一个超时的参数

    • setnx
    • setnx + expire

  • 如果redis单个节点宕机了，如何处理？还有其他业界的方案实现分布式锁码?

    • 使用hash一致算法

缓存算法

  • LRU(least-recently-used):替换最近最少使用的对象
  • LFU(Least frequently used):最不经常使用，如果一个数据在最近一段时间内使用次数很少，那么在将来一段时间内被使用的可能性也很小

服务端性能优化方向

  • 使用数据结构和算法

  • 数据库

    • 索引优化

    • 慢查询消除

      • slow_query_log_file开启并且查询慢查询日志
      • 通过explain排查索引问题
      • 调整数据修改索引

    • 批量操作，从而减少io操作

    • 使用NoSQL:比如Redis

  • 网络io

    • 批量操作
    • pipeline

  • 缓存

    • Redis

  • 异步

    • Asyncio实现异步操作
    • 使用Celery减少io阻塞

  • 并发

    • 多线程
    • Gevent

Python 200个标准库汇总

文本

string：通用字符串操作

re：正则表达式操作

difflib：差异计算工具

textwrap：文本填充

unicodedata：Unicode字符数据库

stringprep：互联网字符串准备工具

readline：GNU按行读取接口

rlcompleter：GNU按行读取的实现函数

struct：将字节解析为打包的二进制数据

codecs：注册表与基类的编解码器

数据类型

datetime：基于日期与时间工具

calendar：通用月份函数

collections：容器数据类型

collections.abc：容器虚基类

heapq：堆队列算法

bisect：数组二分算法

array：高效数值数组

weakref：弱引用

types：内置类型的动态创建与命名

copy：浅拷贝与深拷贝

reprlib：交替repr()的实现

数学

numbers：数值的虚基类

math：数学函数

cmath：复数的数学函数

decimal：定点数与浮点数计算

fractions：有理数

random：生成伪随机数

函数式编程

itertools：为高效循环生成迭代器

functools：可调用对象上的高阶函数与操作

operator：针对函数的标准操作

文件与目录

os.path：通用路径名控制

fileinput：从多输入流中遍历行

stat：解释stat()的结果

filecmp：文件与目录的比较函数

tempfile：生成临时文件与目录

glob：Unix风格路径名格式的扩展

fnmatch：Unix风格路径名格式的比对

linecache：文本行的随机存储

shutil：高级文件操作

macpath：MacOS 9路径控制函数

持久化

pickle：Python对象序列化

copyreg：注册机对pickle的支持函数

shelve：Python对象持久化

marshal：内部Python对象序列化

dbm：Unix“数据库”接口

sqlite3：针对SQLite数据库的API2.0

压缩

zlib：兼容gzip的压缩

gzip：对gzip文件的支持

bz2：对bzip2压缩的支持

lzma：使用LZMA算法的压缩

zipfile：操作ZIP存档

tarfile：读写tar存档文件

加密

hashlib：安全散列与消息摘要

hmac：针对消息认证的键散列

操作系统工具

os：多方面的操作系统接口

io：流核心工具

time：时间的查询与转化

argparser：命令行选项、参数和子命令的解析器

optparser：命令行选项解析器

getopt：C风格的命令行选项解析器

logging：Python日志工具

logging.config：日志配置

logging.handlers：日志处理器

getpass：简易密码输入

curses：字符显示的终端处理

curses.textpad：curses程序的文本输入域

curses.ascii：ASCII字符集工具

curses.panel：curses的控件栈扩展

platform：访问底层平台认证数据

errno：标准错误记号

ctypes：Python外部函数库

并发

threading：基于线程的并行

multiprocessing：基于进程的并行

concurrent：并发包

concurrent.futures：启动并行任务

subprocess：子进程管理

sched：事件调度

queue：同步队列

select：等待I / O完成

dummy_threading：threading模块的替代（当_thread不可用时）

_thread：底层的线程API（threading基于其上）

_dummy_thread：_thread模块的替代（当_thread不可用时）

进程间通信

socket：底层网络接口

ssl：socket对象的TLS / SSL填充器

asyncore：异步套接字处理器

asynchat：异步套接字命令 / 响应处理器

signal：异步事务信号处理器

mmap：内存映射文件支持

互联网

email：邮件与MIME处理包

json：JSON编码与解码

mailcap：mailcap文件处理

mailbox：多种格式控制邮箱

mimetypes：文件名与MIME类型映射

base64：RFC3548：Base16、Base32、Base64编码

binhex：binhex4文件编码与解码

binascii：二进制码与ASCII码间的转化

quopri：MIMEquoted - printable数据的编码与解码

uu：uuencode文件的编码与解码

互联网协议与支持

webbrowser：简易Web浏览器控制器

cgi：CGI支持

cgitb：CGI脚本反向追踪管理器

wsgiref：WSGI工具与引用实现

urllib：URL处理模块

urllib.request：打开URL连接的扩展库

urllib.response：urllib模块的响应类

urllib.parse：将URL解析成组件

urllib.error：urllib.request引发的异常类

urllib.robotparser：robots.txt的解析器

http：HTTP模块

http.client：HTTP协议客户端

ftplib：FTP协议客户端

poplib：POP协议客户端

imaplib：IMAP4协议客户端

nntplib：NNTP协议客户端

smtplib：SMTP协议客户端

smtpd：SMTP服务器

telnetlib：Telnet客户端

uuid：RFC4122的UUID对象

socketserver：网络服务器框架

http.server：HTTP服务器

http.cookies：HTTPCookie状态管理器

http.cookiejar：HTTP客户端的Cookie处理

xmlrpc：XML - RPC服务器和客户端模块

xmlrpc.client：XML - RPC客户端访问

xmlrpc.server：XML - RPC服务器基础

ipaddress：IPv4 / IPv6控制库

多媒体

audioop：处理原始音频数据

aifc：读写AIFF和AIFC文件

sunau：读写Sun AU文件

wave：读写WAV文件

chunk：读取IFF大文件

colorsys：颜色系统间转化

imghdr：指定图像类型

sndhdr：指定声音文件类型

ossaudiodev：访问兼容OSS的音频设备

国际化

gettext：多语言的国际化服务

locale：国际化服务

编程框架

turtle：Turtle图形库

cmd：基于行的命令解释器支持

shlex：简单词典分析

Tk图形用户接口

tkinter：Tcl / Tk接口

tkinter.ttk：Tk主题控件

tkinter.tix：Tk扩展控件

tkinter.scrolledtext：滚轴文本控件

开发工具

pydoc：文档生成器和在线帮助系统

doctest：交互式Python示例

unittest：单元测试框架

unittest.mock：模拟对象库

test：Python回归测试包

test.support：Python测试工具套件

venv：虚拟环境搭建

调试

bdb：调试框架

faulthandler：Python反向追踪库

pdb：Python调试器

timeit：小段代码执行时间测算

trace：Python执行状态追踪

运行时

sys：系统相关的参数与函数

sysconfig：访问Python配置信息

builtins：内置对象

main：顶层脚本环境

warnings：警告控制

contextlib：with状态的上下文工具

abc：虚基类

atexit：出口处理器

traceback：打印或读取一条栈的反向追踪

future：未来状态定义

gc：垃圾回收接口

inspect：检查存活的对象

site：址相关的配置钩子（hook）

fpectl：浮点数异常控制

distutils：生成和安装Python模块

解释器

code：基类解释器

codeop：编译Python代码

导入模块

imp：访问import模块的内部

zipimport：从ZIP归档中导入模块

pkgutil：包扩展工具

modulefinder：通过脚本查找模块

runpy：定位并执行Python模块

importlib：import的一种实施

Python语言

parser：访问Python解析树

ast：抽象句法树

symtable：访问编译器符号表

symbol：Python解析树中的常量

token：Python解析树中的常量

keyword：Python关键字测试

tokenize：Python源文件分词

tabnany：模糊缩进检测

pyclbr：Python类浏览支持

py_compile：编译Python源文件

compileall：按字节编译Python库

dis：Python字节码的反汇编器

pickletools：序列化开发工具

其他

formatter：通用格式化输出

Windows相关

msilib：读写Windows的Installer文件

msvcrt：MS VC + + Runtime的有用程序

winreg：Windows注册表访问

winsound：Windows声音播放接口

Unix相关

posix：最常用的POSIX调用

pwd：密码数据库

spwd：影子密码数据库

grp：组数据库

crypt：Unix密码验证

termios：POSIX风格的tty控制

tty：终端控制函数

pty：伪终端工具

fcntl：系统调用fcntl()和ioctl()

pipes：shell管道接口

resource：资源可用信息

nis：Sun的NIS的接口

syslog：Unix 日志服务

68个Python内置函数

和数字相关

1. 数据类型

  • bool : 布尔型(True,False)
  • int : 整型(整数)
  • float : 浮点型(小数)
  • complex : 复数

2. 进制转换

  • bin() 将给的参数转换成二进制
  • oct() 将给的参数转换成八进制
  • hex() 将给的参数转换成十六进制
print(bin(10))  # 二进制:0b1010
print(hex(10))  # 十六进制:0xa
print(oct(10))  # 八进制:0o12

3. 数学运算

  • abs() 返回绝对值
  • divmode() 返回商和余数
  • round() 四舍五入
  • pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
  • sum() 求和
  • min() 求最小值
  • max() 求最大值
print(abs(-2))  # 绝对值:2
print(divmod(20,3)) # 求商和余数:(6,2)
print(round(4.50))   # 五舍六入:4
print(round(4.51))   #5
print(pow(10,2,3))  # 如果给了第三个参数. 表示最后取余:1
print(sum([1,2,3,4,5,6,7,8,9,10]))  # 求和:55
print(min(5,3,9,12,7,2))  #求最小值:2
print(max(7,3,15,9,4,13))  #求最大值:15

和数据结构相关

1. 序列

（1）列表和元组

  • list() 将一个可迭代对象转换成列表
  • tuple() 将一个可迭代对象转换成元组
print(list((1,2,3,4,5,6)))  #[1, 2, 3, 4, 5, 6]
print(tuple([1,2,3,4,5,6]))  #(1, 2, 3, 4, 5, 6)

（2）相关内置函数

  • reversed() 将一个序列翻转, 返回翻转序列的迭代器
  • slice() 列表的切片
lst = "你好啊"
it = reversed(lst)   # 不会改变原列表. 返回一个迭代器, 设计上的一个规则
print(list(it))  #['啊', '好', '你']
lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1])  #[2,3]
s = slice(1, 3, 1)  #  切片用的
print(lst[s])  #[2,3]

（3）字符串

  • str() 将数据转化成字符串
print(str(123)+'456')  #123456
  • format() 与具体数据相关, 用于计算各种小数, 精算等.
s = "hello world!"
print(format(s, "^20"))  #剧中
print(format(s, "<20"))  #左对齐
print(format(s, ">20"))  #右对齐
#     hello world!    
# hello world!        
#         hello world!
print(format(3, 'b' ))    # 二进制:11
print(format(97, 'c' ))   # 转换成unicode字符:a
print(format(11, 'd' ))   # ⼗进制:11
print(format(11, 'o' ))   # 八进制:13 
print(format(11, 'x' ))   # 十六进制(⼩写字母):b
print(format(11, 'X' ))   # 十六进制(大写字母):B
print(format(11, 'n' ))   # 和d⼀样:11
print(format(11))         # 和d⼀样:11
print(format(123456789, 'e' ))      # 科学计数法. 默认保留6位小数:1.234568e+08
print(format(123456789, '0.2e' ))   # 科学计数法. 保留2位小数(小写):1.23e+08
print(format(123456789, '0.2E' ))   # 科学计数法. 保留2位小数(大写):1.23E+08
print(format(1.23456789, 'f' ))     # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f' ))  # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f'))  # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e+3, 'F'))   # 小数点计数法. 很大的时候输出INF:1234.567890
  • bytes() 把字符串转化成bytes类型
bs = bytes("今天吃饭了吗", encoding="utf-8")
print(bs)  #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'
  • bytearray() 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)
ret = bytearray("alex" ,encoding ='utf-8')
print(ret[0])  #97
print(ret)  #bytearray(b'alex')
ret[0] = 65  #把65的位置A赋值给ret[0]
print(str(ret))  #bytearray(b'Alex')
  • ord() 输入字符找带字符编码的位置
  • chr() 输入位置数字找出对应的字符
  • ascii() 是ascii码中的返回该值 不是就返回u
print(ord('a'))  # 字母a在编码表中的码位:97
print(ord('中'))  # '中'字在编码表中的位置:20013
print(chr(65))  # 已知码位,求字符是什么:A
print(chr(19999))  #丟

for i in range(65536):  #打印出0到65535的字符
    print(chr(i), end=" ")

print(ascii("@"))  #'@'
  • repr() 返回一个对象的string形式
s = "今天\n吃了%s顿\t饭" % 3
print(s)#今天# 吃了3顿    饭
print(repr(s))   # 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
#'今天\n吃了3顿\t饭'

2. 数据集合

  • 字典：dict 创建一个字典
  • 集合：set 创建一个集合

frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。

3. 相关内置函数

  • len() 返回一个对象中的元素的个数
  • sorted() 对可迭代对象进行排序操作 (lamda)

语法：sorted(Iterable, key=函数(排序规则), reverse=False)

  • Iterable: 可迭代对象
  • key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
  • reverse: 是否是倒叙. True: 倒叙, False: 正序
lst = [5,7,6,12,1,13,9,18,5]
lst.sort()  # sort是list里面的一个方法
print(lst)  #[1, 5, 5, 6, 7, 9, 12, 13, 18]

ll = sorted(lst) # 内置函数. 返回给你一个新列表  新列表是被排序的
print(ll)  #[1, 5, 5, 6, 7, 9, 12, 13, 18]

l2 = sorted(lst,reverse=True)  #倒序
print(l2)  #[18, 13, 12, 9, 7, 6, 5, 5, 1]
#根据字符串长度给列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']
def f(s):
    return len(s)
l1 = sorted(lst, key=f, )
print(l1)  #['one', 'two', 'six', 'four', 'five', 'three']
  • enumerate() 获取集合的枚举对象
lst = ['one','two','three','four','five']
for index, el in enumerate(lst,1):    # 把索引和元素一起获取,索引默认从0开始. 可以更改
    print(index)
    print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five
  • all() 可迭代对象中全部是True, 结果才是True
  • any() 可迭代对象中有一个是True, 结果就是True
print(all([1,'hello',True,9]))  #True
print(any([0,0,0,False,1,'good']))  #True
  • zip() 函数用于将可迭代的对象作为参数, 将对象中对应的元素打包成一个元组, 然后返回由这些元组组成的列表. 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(zip(lst1, lst1, lst3))  #<zip object at 0x00000256CA6C7A88>
for el in zip(lst1, lst2, lst3):
    print(el)
# (1, '醉乡民谣', '美国')
# (2, '驴得水', '中国')
# (3, '放牛班的春天', '法国')
# (4, '美丽人生', '意大利')
# (5, '辩护人', '韩国')
# (6, '被嫌弃的松子的一生', '日本')
  • fiter() 过滤 (lamda)

语法：fiter(function. Iterable)

function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象

def func(i):    # 判断奇数
    return i % 2 == 1
    lst = [1,2,3,4,5,6,7,8,9]
l1 = filter(func, lst)  #l1是迭代器
print(l1)  #<filter object at 0x000001CE3CA98AC8>
print(list(l1))  #[1, 3, 5, 7, 9]
  • map() 会根据提供的函数对指定序列列做映射(lamda)

语法 : map(function, iterable)

可以对可迭代对象中的每一个元素进行映射. 分别去执行 function

def f(i):    
  return i
  lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器print(list(it))  
#[1, 2, 3, 4, 5, 6, 7]

和作用域相关

  • locals() 返回当前作用域中的名字
  • globals() 返回全局作用域中的名字
def func():
    a = 10
    print(locals())  # 当前作用域中的内容
    print(globals())  # 全局作用域中的内容
    print("今天内容很多")
func()
# {'a': 10}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': 
# <_frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080>, 
# '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' 
# (built-in)>, '__file__': 'D:/pycharm/练习/week03/new14.py', '__cached__': None,
#  'func': <function func at 0x0000026F8D6B97B8>}
# 今天内容很多

和迭代器生成器相关

  • range() 生成数据
  • next() 迭代器向下执行一次, 内部实际使用了__ next__()方法返回迭代器的下一个项目
  • iter() 获取迭代器, 内部实际使用的是__ iter__()方法来获取迭代器
for i in range(15,-1,-5):
    print(i)
# 15
# 10
# 5
# 0
lst = [1,2,3,4,5]
it = iter(lst)  #  __iter__()获得迭代器
print(it.__next__())  #1
print(next(it)) #2  __next__()  
print(next(it))  #3
print(next(it))  #4

字符串类型代码的执行

  • eval() 执行字符串类型的代码. 并返回最终结果
  • exec() 执行字符串类型的代码
  • compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值
s1 = input("请输入a+b:")  #输入:8+9
print(eval(s1))  # 17 可以动态的执行代码. 代码必须有返回值
s2 = "for i in range(5): print(i)"
a = exec(s2) # exec 执行代码不返回任何内容

# 0
# 1
# 2
# 3
# 4
print(a)  #None

# 动态执行代码
exec("""
def func():
    print(" 我是周杰伦")
""" )
func()  #我是周杰伦

code1 = "for i in range(3): print(i)"
com = compile(code1, "", mode="exec")   # compile并不会执行你的代码.只是编译
exec(com)   # 执行编译的结果
# 0
# 1
# 2

code2 = "5+6+7"
com2 = compile(code2, "", mode="eval")
print(eval(com2))  # 18

code3 = "name = input('请输入你的名字:')"  #输入:hello
com3 = compile(code3, "", mode="single")
exec(com3)
print(name)  #hello

输入输出

  • print() : 打印输出
  • input() : 获取用户输出的内容
print("hello", "world", sep="*", end="@") # sep:打印出的内容用什么连接,end:以什么为结尾
#hello*world@

内存相关

  • hash() : 获取到对象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空间换的时间 比较耗费内存
s = 'alex'
print(hash(s))  #-168324845050430382
lst = [1, 2, 3, 4, 5]
print(hash(lst))  #报错,列表是不可哈希的
  id() :  获取到对象的内存地址
s = 'alex'
print(id(s))  #2278345368944

文件操作相关

  • open() : 用于打开一个文件, 创建一个文件句柄
f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()

模块相关

__ import__() : 用于动态加载类和函数

# 让用户输入一个要导入的模块
import os
name = input("请输入你要导入的模块:")
__import__(name)    # 可以动态导入模块

帮 助

  • help() : 函数用于查看函数或模块用途的详细说明
print(help(str))  #查看字符串的用途

调用相关

  • callable() : 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功
a = 10
print(callable(a))  #False  变量a不能被调用
#
def f():
    print("hello")
    print(callable(f))   # True 函数是可以被调用的

查看内置属性

  • dir() : 查看对象的内置属性, 访问的是对象中的dir()方法
print(dir(tuple))  #查看元组的方法

8 个 Python 优化提速的小技巧

Python 是一种脚本语言，相比 C/C++ 这样的编译语言，在效率和性能方面存在一些不足。但是，有很多时候，Python 的效率并没有想象中的那么夸张。

0. 代码优化原则

第一个基本原则是不要过早优化。很多人一开始写代码就奔着性能优化的目标，“让正确的程序更快要比让快速的程序正确容易得多”。因此，优化的前提是代码能正常工作。过早地进行优化可能会忽视对总体性能指标的把握，在得到全局结果前不要主次颠倒。

第二个基本原则是权衡优化的代价。优化是有代价的，想解决所有性能的问题是几乎不可能的。通常面临的选择是时间换空间或空间换时间。另外，开发代价也需要考虑。

第三个原则是不要优化那些无关紧要的部分。如果对代码的每一部分都去优化，这些修改会使代码难以阅读和理解。如果你的代码运行速度很慢，首先要找到代码运行慢的位置，通常是内部循环，专注于运行慢的地方进行优化。在其他地方，一点时间上的损失没有什么影响。

1. 避免全局变量

# 不推荐写法。代码耗时：26.8秒
import math

size = 10000
for x in range(size):
    for y in range(size):
        z = math.sqrt(x) + math.sqrt(y)

许多程序员刚开始会用 Python 语言写一些简单的脚本，当编写脚本时，通常习惯了直接将其写为全局变量，例如上面的代码。但是，由于全局变量和局部变量实现方式不同，定义在全局范围内的代码运行速度会比定义在函数中的慢不少。通过将脚本语句放入到函数中，通常可带来 15% - 30% 的速度提升。

# 推荐写法。代码耗时：20.6秒
import math

def main():  # 定义到函数中，以减少全部变量使用
    size = 10000
    for x in range(size):
        for y in range(size):
            z = math.sqrt(x) + math.sqrt(y)

main()

2. 避免.

2.1 避免模块和函数属性访问

# 不推荐写法。代码耗时：14.5秒
import math

def computeSqrt(size: int):
    result = []
    for i in range(size):
        result.append(math.sqrt(i))
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

每次使用.（属性访问操作符时）会触发特定的方法，如__getattribute__()和__getattr__()，这些方法会进行字典操作，因此会带来额外的时间开销。通过from import语句，可以消除属性访问。

# 第一次优化写法。代码耗时：10.9秒
from math import sqrt

def computeSqrt(size: int):
    result = []
    for i in range(size):
        result.append(sqrt(i))  # 避免math.sqrt的使用
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

在第 1 节中我们讲到，局部变量的查找会比全局变量更快，因此对于频繁访问的变量sqrt，通过将其改为局部变量可以加速运行。

# 第二次优化写法。代码耗时：9.9秒
import math

def computeSqrt(size: int):
    result = []
    sqrt = math.sqrt  # 赋值给局部变量
    for i in range(size):
        result.append(sqrt(i))  # 避免math.sqrt的使用
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

除了math.sqrt外，computeSqrt函数中还有.的存在，那就是调用list的append方法。通过将该方法赋值给一个局部变量，可以彻底消除computeSqrt函数中for循环内部的.使用。

# 推荐写法。代码耗时：7.9秒
import math

def computeSqrt(size: int):
    result = []
    append = result.append
    sqrt = math.sqrt    # 赋值给局部变量
    for i in range(size):
        append(sqrt(i))  # 避免 result.append 和 math.sqrt 的使用
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

2.2 避免类内属性访问

# 不推荐写法。代码耗时：10.4秒
import math
from typing import List

class DemoClass:
    def __init__(self, value: int):
        self._value = value

    def computeSqrt(self, size: int) -> List[float]:
        result = []
        append = result.append
        sqrt = math.sqrt
        for _ in range(size):
            append(sqrt(self._value))
        return result

def main():
    size = 10000
    for _ in range(size):
        demo_instance = DemoClass(size)
        result = demo_instance.computeSqrt(size)

main()

避免.的原则也适用于类内属性，访问self._value的速度会比访问一个局部变量更慢一些。通过将需要频繁访问的类内属性赋值给一个局部变量，可以提升代码运行速度。

# 推荐写法。代码耗时：8.0秒
import math
from typing import List

class DemoClass:
    def __init__(self, value: int):
        self._value = value

    def computeSqrt(self, size: int) -> List[float]:
        result = []
        append = result.append
        sqrt = math.sqrt
        value = self._value
        for _ in range(size):
            append(sqrt(value))  # 避免 self._value 的使用
        return result

def main():
    size = 10000
    for _ in range(size):
        demo_instance = DemoClass(size)
        demo_instance.computeSqrt(size)

main()

3. 避免不必要的抽象

# 不推荐写法，代码耗时：0.55秒
class DemoClass:
    def __init__(self, value: int):
        self.value = value

    @property
    def value(self) -> int:
        return self._value

    @value.setter
    def value(self, x: int):
        self._value = x

def main():
    size = 1000000
    for i in range(size):
        demo_instance = DemoClass(size)
        value = demo_instance.value
        demo_instance.value = i

main()

任何时候当你使用额外的处理层（比如装饰器、属性访问、描述器）去包装代码时，都会让代码变慢。大部分情况下，需要重新进行审视使用属性访问器的定义是否有必要，使用getter/setter函数对属性进行访问通常是 C/C++ 程序员遗留下来的代码风格。如果真的没有必要，就使用简单属性。

# 推荐写法，代码耗时：0.33秒
class DemoClass:
    def __init__(self, value: int):
        self.value = value  # 避免不必要的属性访问器

def main():
    size = 1000000
    for i in range(size):
        demo_instance = DemoClass(size)
        value = demo_instance.value
        demo_instance.value = i

main()

4. 避免数据复制

4.1 避免无意义的数据复制

# 不推荐写法，代码耗时：6.5秒
def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        value_list = [x for x in value]
        square_list = [x * x for x in value_list]

main()

上面的代码中value_list完全没有必要，这会创建不必要的数据结构或复制。

# 推荐写法，代码耗时：4.8秒
def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        square_list = [x * x for x in value]  # 避免无意义的复制

main()

另外一种情况是对 Python 的数据共享机制过于偏执，并没有很好地理解或信任 Python 的内存模型，滥用 copy.deepcopy()之类的函数。通常在这些代码中是可以去掉复制操作的。

4.2 交换值时不使用中间变量

# 不推荐写法，代码耗时：0.07秒
def main():
    size = 1000000
    for _ in range(size):
        a = 3
        b = 5
        temp = a
        a = b
        b = temp

main()

上面的代码在交换值时创建了一个临时变量temp，如果不借助中间变量，代码更为简洁、且运行速度更快。

# 推荐写法，代码耗时：0.06秒
def main():
    size = 1000000
    for _ in range(size):
        a = 3
        b = 5
        a, b = b, a  # 不借助中间变量

main()

4.3 字符串拼接用join而不是+

# 不推荐写法，代码耗时：2.6秒
import string
from typing import List

def concatString(string_list: List[str]) -> str:
    result = ''
    for str_i in string_list:
        result += str_i
    return result

def main():
    string_list = list(string.ascii_letters * 100)
    for _ in range(10000):
        result = concatString(string_list)

main()

当使用a + b拼接字符串时，由于 Python 中字符串是不可变对象，其会申请一块内存空间，将a和b分别复制到该新申请的内存空间中。因此，如果要拼接 n 个字符串，会产生 n-1 个中间结果，每产生一个中间结果都需要申请和复制一次内存，严重影响运行效率。而使用join()拼接字符串时，会首先计算出需要申请的总的内存空间，然后一次性地申请所需内存，并将每个字符串元素复制到该内存中去。

# 推荐写法，代码耗时：0.3秒
import string
from typing import List

def concatString(string_list: List[str]) -> str:
    return ''.join(string_list)  # 使用 join 而不是 +

def main():
    string_list = list(string.ascii_letters * 100)
    for _ in range(10000):
        result = concatString(string_list)

main()

5. 利用if条件的短路特性

# 不推荐写法，代码耗时：0.05秒
from typing import List

def concatString(string_list: List[str]) -> str:
    abbreviations = {'cf.', 'e.g.', 'ex.', 'etc.', 'flg.', 'i.e.', 'Mr.', 'vs.'}
    abbr_count = 0
    result = ''
    for str_i in string_list:
        if str_i in abbreviations:
            result += str_i
    return result

def main():
    for _ in range(10000):
        string_list = ['Mr.', 'Hat', 'is', 'Chasing', 'the', 'black', 'cat', '.']
        result = concatString(string_list)

main()

if 条件的短路特性是指对if a and b这样的语句， 当a为False时将直接返回，不再计算b；对于if a or b这样的语句，当a为True时将直接返回，不再计算b。因此， 为了节约运行时间，对于or语句，应该将值为True可能性比较高的变量写在or前，而and应该推后。

# 推荐写法，代码耗时：0.03秒
from typing import List

def concatString(string_list: List[str]) -> str:
    abbreviations = {'cf.', 'e.g.', 'ex.', 'etc.', 'flg.', 'i.e.', 'Mr.', 'vs.'}
    abbr_count = 0
    result = ''
    for str_i in string_list:
        if str_i[-1] == '.' and str_i in abbreviations:  # 利用 if 条件的短路特性
            result += str_i
    return result

def main():
    for _ in range(10000):
        string_list = ['Mr.', 'Hat', 'is', 'Chasing', 'the', 'black', 'cat', '.']
        result = concatString(string_list)

main()

6. 循环优化

6.1 用for循环代替while循环

# 不推荐写法。代码耗时：6.7秒
def computeSum(size: int) -> int:
    sum_ = 0
    i = 0
    while i < size:
        sum_ += i
        i += 1
    return sum_

def main():
    size = 10000
    for _ in range(size):
        sum_ = computeSum(size)

main()

Python 的for循环比while循环快不少。

# 推荐写法。代码耗时：4.3秒
def computeSum(size: int) -> int:
    sum_ = 0
    for i in range(size):  # for 循环代替 while 循环
        sum_ += i
    return sum_

def main():
    size = 10000
    for _ in range(size):
        sum_ = computeSum(size)

main()

6.2 使用隐式for循环代替显式for循环

针对上面的例子，更进一步可以用隐式for循环来替代显式for循环

# 推荐写法。代码耗时：1.7秒
def computeSum(size: int) -> int:
    return sum(range(size))  # 隐式 for 循环代替显式 for 循环

def main():
    size = 10000
    for _ in range(size):
        sum = computeSum(size)

main()

6.3 减少内层for循环的计算

# 不推荐写法。代码耗时：12.8秒
import math

def main():
    size = 10000
    sqrt = math.sqrt
    for x in range(size):
        for y in range(size):
            z = sqrt(x) + sqrt(y)

main()

上面的代码中sqrt(x)位于内侧for循环， 每次训练过程中都会重新计算一次，增加了时间开销。

# 推荐写法。代码耗时：7.0秒
import math

def main():
    size = 10000
    sqrt = math.sqrt
    for x in range(size):
        sqrt_x = sqrt(x)  # 减少内层 for 循环的计算
        for y in range(size):
            z = sqrt_x + sqrt(y)

main()

7. 使用numba.jit

我们沿用上面介绍过的例子，在此基础上使用numba.jit。numba可以将 Python 函数 JIT 编译为机器码执行，大大提高代码运行速度。关于numba的更多信息见下面的主页：http://numba.pydata.org/numba.pydata.org

# 推荐写法。代码耗时：0.62秒
import numba

@numba.jit
def computeSum(size: float) -> int:
    sum = 0
    for i in range(size):
        sum += i
    return sum

def main():
    size = 10000
    for _ in range(size):
        sum = computeSum(size)

main()

8. 选择合适的数据结构

Python 内置的数据结构如str, tuple, list, set, dict底层都是 C 实现的，速度非常快，自己实现新的数据结构想在性能上达到内置的速度几乎是不可能的。

list类似于 C++ 中的std::vector，是一种动态数组。其会预分配一定内存空间，当预分配的内存空间用完，又继续向其中添加元素时，会申请一块更大的内存空间，然后将原有的所有元素都复制过去，之后销毁之前的内存空间，再插入新元素。

删除元素时操作类似，当已使用内存空间比预分配内存空间的一半还少时，会另外申请一块小内存，做一次元素复制，之后销毁原有大内存空间。

因此，如果有频繁的新增、删除操作，新增、删除的元素数量又很多时，list的效率不高。此时，应该考虑使用collections.deque。collections.deque是双端队列，同时具备栈和队列的特性，能够在两端进行 O(1) 复杂度的插入和删除操作。

list的查找操作也非常耗时。当需要在list频繁查找某些元素，或频繁有序访问这些元素时，可以使用bisect维护list对象有序并在其中进行二分查找，提升查找的效率。

另外一个常见需求是查找极小值或极大值，此时可以使用heapq模块将list转化为一个堆，使得获取最小值的时间复杂度是 O(1)。

下面的网页给出了常用的 Python 数据结构的各项操作的时间复杂度：https://wiki.python.org/moin/TimeComplexity

34个Python 自动化办公库清单

Excel自动化库

1.xlwings 库

官网：

https://www.xlwings.org/

特点：xlwings 是开源且免费的，预装了 Anaconda 和 WinPython，可在 Windows 和 macOS 上运行。通过 Python 脚本或 Jupyter notebook 自动化 Excel，通过宏从 Excel 调用 Python，并编写用户定义的函数（UDF 仅适用于 Windows）

2.openpyxl 库

官网：

https://openpyxl.readthedocs.io

特点：openpyxl 是一个用于读取 / 编写 Excel 2010 xlsx/xlsm/xltx/xltm 文件的 Python 库。它是由于缺乏从 Python 中读取 / 编写 Office Open XML 格式的现有库而诞生的。

3.xlrd 库

官网：

https://pypi.python.org/pypi/xlrd

特点：在 python 中，xlrd 库是一个很常用的读取 excel 文件的库，其对 excel 文件的读取可以实现比较精细的控制。

4.xlwt 库

官网：

https://pypi.org/project/xlwt/

特点：类比于 xlrd 的 reader，那么 xlwt 就相对于 writer，而且很纯正的一点就是它只能对 Excel 进行写操作。xlwt 和 xlrd 不光名字像，连很多函数和操作格式也是完全相同。

5.xlutils 库

官网：

https://pypi.org/project/xlutils/

特点：xlutils（excel utilities）是一个提供了许多操作修改 excel 文件方法的库。xlutils 库也仅仅是通过复制一个副本进行操作后保存一个新文件，xlutils 库就像是 xlrd 库和 xlwt 库之间的一座桥梁，因此，xlutils 库是依赖于 xlrd 和 xlwt 两个库的。

6.xlsxwriter 库

官网：

https://xlsxwriter.readthedocs.io/

特点：xlsxwriter 是用于创建 Excel XLSX 文件的 Python 模块，可用于将文本、数字、公式和超链接写入 Excel2007 + XLSX 文件中的多个工作表。它支持格式化等功能。可以说除了 Excel 本身，就属这个功能最齐全了。

7.pandas 库

官网：

https://www.pypandas.cn/docs/

特点：pandas 是基于 NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。

8.Marmir 库

官网：

https://github.com/brianray/mm

特点：Marmir 采用 Python 数据结构并将其转换为电子表格。它是类固醇上的 xlwt 和 google 电子表格。目标是使用最少的配置轻松生成多种类型的有用表文件。

Word自动化库

9.python-docx 库

官网：

https://python-docx.readthedocs.io/en/latest/

特点：python-docx 是一个用于创建和更新 Microsoft Word (.docx) 文件的 Python 库。快速开始、处理文档、处理文本、使用截面、使用页眉和页脚、API基础理、解样式、使用样式理解图片和其他形状。只对 windows 平台有效。

10.textract 库

官网：

https://gitee.com/mirrors/textract

特点：它同时兼顾 “doc” 和 “docx”，但安装过程需要一些依赖。你可以批量的用 python 生成 word 文件，推荐使用 docx，不需要会太多。

PPT自动化库

11.python-pptx 库

官网：

https://python-pptx.readthedocs.io

特点：python-pptx 是一个用于创建和更新 PowerPoint (.pptx) 文件的 Python 库。典型用途是从数据库内容生成自定义 PowerPoint 演示文稿，可通过单击 Web 应用程序中的链接下载。

ODF自动化库

12.Relatorio 库

官网：

https://pypi.org/project/relatorio/

特点：Relatorio 是一个模板库，它提供了一种轻松输出多种文件（odt、ods、png、svg 等）的方法。通过为它们创建插件可以轻松添加对更多文件类型的支持。Relatorio 还提供了一个报告存储库，允许您将 python 对象和报告链接在一起，按 mimetype/name/python 对象查找报告。ODF：开放文档格式（外文名：OpenDocument Format，外语简称：ODF）是一种规范，基于 XML（标准通用标记语言的子集）的文件格式，因应试算表、图表、演示稿和文字处理文件等电子文件而设置。

PDF自动化库

13.PyPDF2 库

官网：

https://github.com/mstamy2/PyPDF2

特点：PyPDF2 是一个纯 Python PDF 库，能够拆分、合并、裁剪和转换 PDF 文件的页面。它还可以向 PDF 文件添加自定义数据、查看选项和密码。它可以从 PDF 中检索文本和元数据，也可以将整个文件合并在一起。

14.ReportLab 库

官网：

https://www.reportlab.com/opensource/

特点：ReportLab 是久经考验、超强大的开源引擎，用于创建复杂的、数据驱动的 PDF 文档和自定义矢量图形。它是免费的、开源的，并且是用 Python 编写的。

15.PDFminer 库

官网：

https://github.com/euske/pdfminer

特点：PDFMiner 是一款用于 PDF 文档的文本提取工具。

邮件自动化库

16.Django Celery SES 库

官网：

https://github.com/StreetVoice/django-celery-ses

特点：这个包提供了一个 EmailBackend 来利用 django-celery 发送电子邮件。您可以将 EmailBackend 插入您的项目中，而无需对代码进行任何修改。

17.Envelopes 库

官网：

http://tomekwojcik.github.io/envelopes/

特点：Envelopes 是 Python 的电子邮件和 smtplib 模块的包装器。它旨在使在 Python 中处理外发电子邮件变得简单而有趣。

18.Flanker 库

官网：

https://github.com/mailgun/flanker

特点：由 mailgun 开源的 Flanker - email address and MIME parsing for Python 是一个解析高效、容错率不错的 python 第三方扩展库。python 3 也可以正常使用，该库包含了邮件地址解析和邮件 mime 格式解析。

19.imbox 库

官网：

https://github.com/martinrusev/imbox

特点：用于读取 IMAP 邮箱并将电子邮件内容转换为机器可读数据的 Python 库

20.inbox.py 库

官网：

https://github.com/billzhong/inbox.py

特点：这是您见过的最简单的 SMTP 服务器。它是异步的。一个实例每秒应该处理一千多封电子邮件。

21.sync-engine 库

官网：

https://github.com/nylas/sync-engine

特点：Nylas 同步引擎在强大的电子邮件同步平台之上提供了一个 RESTful API，可以轻松地在电子邮件之上构建应用程序。

22.Lamson 库

官网：

https://github.com/zedshaw/lamson

特点：Lamson 是一个纯 Python SMTP 服务器，旨在以现代 Web 框架（如 Django）的风格创建强大而复杂的邮件应用程序。

23.Marrow Mailer 库

官网：

https://github.com/marrow/mailer

特点：Marrow Mailer 是一个 Python 库，可以轻松地从您的应用程序发送电子邮件。通过使用 Marrow Mailer，您可以：轻松构建纯文本和 HTML 电子邮件；提高电子邮件传递的可测试性；使用不同的邮件投递管理策略；例如立即，延迟，甚至多服务器等。

24.Modoboa 库

官网：

https://github.com/modoboa/modoboa

特点：Modoboa 是一个邮件托管和管理平台，包括一个现代和简化的 Web 用户界面。它提供了有用的组件，例如管理面板或网络邮件。

25.smtplib 库

官网：

https://docs.python.org/zh-cn/3/library/smtplib.html

特点：smtplib 模块是 python 中 smtp (简单邮件传输协议) 的客户端实现。我们可以使用 smtplib 模块，轻松的发送电子邮件。

微信自动化库

26.Python wxpy 库

官网：

https://wxpy.readthedocs.io/zh/latest/

特点：微信机器人/可能是最优雅的微信个人号API，wxpy 在 itchat 的基础上，通过大量接口优化提升了模块的易用性，并进行丰富的功能扩展。

文件处理自动化库

27.os 库

官网：

https://docs.python.org/zh-cn/3/library/os.html?highlight=os#module-os

特点：本模块提供了一种使用与操作系统相关的功能的便捷式途径。如果你只是想读写一个文件，请参阅 open()，如果你想操作文件路径，请参阅 os.path 模块，如果你想读取通过命令行给出的所有文件中的所有行，请参阅 fileinput 模块。为了创建临时文件和目录，请参阅 tempfile 模块，对于高级文件和目录处理，请参阅 shutil 模块。

综合功能自动化库

28.win32com 库

官网：

https://pypi.org/project/pywin32/

特点：win32com 模块主要为 Python 提供调用 windows 底层组件对 word 、Excel、PPT 等进行操作的功能，只能在 Windows 环境下使用，并且需要安装 office 相关软件才行（WPS 也行）。

29.unoconv 库

官网：

https://github.com/unoconv/unoconv

特点：是一个命令行工具，可以将 LibreOffice 可以导入的任何文档格式转换为 LibreOffice 可以导出的任何文档格式。它利用 LibreOffice 的 UNO 绑定进行文档的非交互式转换，也支持 OpenOffice。

30.Tablib 库

官网：

https://www.osgeo.cn/tablib/

特点：Python tablib 模块是第三方模块，主要作用是将数据导出为各种不同的格式，包括 excel，json，html，yaml，csv，tsv 等格式，怎么样，有点心动了吧，当然这个模块使用起来也是超级简单的。

31.SnowNLP 库

官网：

https://github.com/isnowfy/snownlp

特点：SnowNLP 是一个 python 写的类库，可以方便的处理中文文本内容，是受到了 TextBlob 的启发而写的，由于现在大部分的自然语言处理库基本都是针对英文的，于是写了一个方便处理中文的类库，并且和 TextBlob 不同的是，这里没有用 NLTK，所有的算法都是自己实现的，并且自带了一些训练好的字典。注意本程序都是处理的 unicode 编码，所以使用时请自行 decode 成 unicode。

32.TextBlob 库

官网：

https://textblob.readthedocs.io

特点：TextBlob 是一个用于处理文本数据的 Python（2 和 3）库。它提供了一个简单的 API，用于深入研究常见的自然语言处理 (NLP) 任务，例如词性标注、名词短语提取、情感分析、分类、翻译等。

33.TextGrocery 库

官网：

https://textgrocery.readthedocs.io

特点：TextGrocery 是一个基于 LibLinear 和结巴分词的短文本分类工具，特点是高效易用，同时支持中文和英文语料。

34.NumPy 库

官网：

https://www.numpy.org.cn/

特点：NumPy 是 Python 中科学计算的基础包。它是一个 Python 库，提供多维数组对象，各种派生对象（如掩码数组和矩阵），以及用于数组快速操作的各种 API，有包括数学、逻辑、形状操作、排序、选择、输入输出、离散傅立叶变换、基本线性代数，基本统计运算和随机模拟等等。

1000+ 常用 Python 库一览

文本处理、文件处理、图像处理、游戏和多媒体、大数据和科学计算、人工智能和机器学习、系统与命令行、数据库、网络、web框架、安全、封装、代码调试

文本处理

  • Chardet字符编码探测器，可以自动检测文本、网页、xml的编码。
  • colorama主要用来给文本添加各种颜色，并且非常简单易用。
  • Prettytable主要用于在终端或浏览器端构建格式化的输出。
  • difflib，[Python]标准库，计算文本差异
  • Levenshtein，快速计算字符串相似度。
  • fuzzywuzzy,字符串模糊匹配。
  • esmre,正则表达式的加速器。
  • shortuuid,一组简洁URL/UUID函数库。
  • ftfy，Unicode文本工具7
  • unidecode，ascii和Unicode文本转换函数。
  • xpinyin，将汉字转换为拼音的函数库
  • pangu.py，调整对中日韩文字当中的字母、数字间距。
  • pyfiglet，Python写的figlet程序，使用字符组成ASCII艺术图片
  • uniout，提取字符串中可读写的字符
  • awesome slugify，一个Python slugify库，用于处理Unicode。
  • python-slugify，转换Unicode为ASCII内码的slugify函数库。
  • unicode-slugify，生成unicode内码，Django的依赖包。
  • ply，Python版的lex和yacc的解析工具
  • phonenumbers，解析电话号码，格式，存储和验证的国际电话号码。
  • python-user-agents，浏览器的用户代理（user-agents）的解析器。
  • sqlparse，SQL解析器。
  • pygments，一个通用的语法高亮工具。
  • python-nameparser，解析人名，分解为单独的成分。
  • pyparsing，通用解析器生成框架。
  • tablib，表格数据格式，包括，XLS、CSV，JSON，YAML。
  • python-docx，docx文档读取，查询和修改，微软Word 2007 / 2008的docx文件。
  • xlwt/xlrd，读写Excel格式的数据文件。
  • xlsxwriter，创建Excel格式的xlsx文件。
  • xlwings，利用Python调用Excel
  • csvkit，CSV文件工具包。
  • marmir，把Python[数据结构]，转化为电子表格。
  • pdfminer，从PDF文件中提取信息。
  • pypdf2， 合并和转换PDF页面的函数库。
  • Python-Markdown，轻量级标记语言Markdown的Python实现。
  • Mistune，,快速、全功能的纯Python编写的Markdown解释器。
  • dateutil，标准的Python官方datetime模块的扩展包，字符串日期工具，其中parser是根据字符串解析成datetime，而rrule是则是根据定义的规则来生成datetime。
  • arrow,更好的日期和时间处理Python库
  • chronyk，一个Python 3版函数库，用于解析人写的时间和日期。
  • delorean，清理期时间的函数库。
  • when.py，为见的日期和时间，提供人性化的功能。
  • moment，类似Moment.js的日期/时间Python库
  • pytz，世界时区，使用tz database时区信息[数据库]
  • BeautifulSoup，基于Python的HTML/XML解析器，简单易用, 功能很强大,即使是有bug，有问题的html代码，也可以解析
  • lxml，快速，易用、灵活的HTML和XML处理库，功能超强，在遇到有缺陷、不规范的xml时，Python自带的xml处理器可能无法解析。报错时，程序会尝试再用lxml的修复模式解析。
  • htmlparser，官方版解析HTML DOM树，偶尔搞搞命令行自动表单提交用得上。
  • pyyaml，Python版本的YAML解释器。
  • html5lib，-标准库，解析和序列化HTML文档和片段。
  • pyquery，类似[jQuery]的的HTML解释器函数库。
  • cssutils，Python CSS库。
  • MarkupSafe，XML或HTML / XHTML安全字符串标记工具。
  • cssutils - ACSS library for Python., MarkupSafe - Implements a XML/HTML/XHTML
  • bleach，漂白，基于HTML的白名单函数库。
  • xmltodict，类似JSON的XML工具包。
  • xhtml2pdf，HTML / CSS格式转换器，看生成pdf文档。
  • untangle，把XML文档，转换为Python对象，方便访问。

文件处理

  • Mimetypes，Python标准库，映射文件名到MIME类型。
  • imghdr，Python标准库，确定图像类型。python-magic，libmagic文件类型识别库，Python接口格式。path.py，os.path模块的二次封装。
  • watchdog，一组API和shell实用程序，用于监视文件系统事件。
  • Unipath，面向对象的文件/目录的操作工具包。pathlib，-（Python 3.4版已经作为Python标准库），一个跨平台，面向path的函数库。
  • pickle/cPickle,python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
  • cPickle是[C语言]实现的版本，速度更快。
  • ConfigParser，Python标准库，INI文件解析器。
  • configobj，INI文件解析器。config，分层次配置，logging作者编写。
  • profig，多格式配置转换工具。
  • logging，Python标准库，日志文件生成管理函数库。
  • logbook，logging的替换品。
  • Sentry，实时log服务器。Raven，哨兵Sentry的Python客户端。
  • Sphinx，斯芬克斯（狮身人面像），Python文档生成器。
  • reStructuredText，标记语法和解析工具，Docutils组件。mkdocs，Markdown格式文档生成器。
  • pycco，简单快速、编程风格的文档生成器。
  • pdoc，自动生成的Python库API文档epydoc，从源码注释中生成各种格式文档的工具

图像处理

  • PIL（Python Image Library），基于Python的图像处理库，功能强大，对图形文件的格式支持广泛，内置许多图像处理函数，如图像增强、滤波[算法]等

  • Pillow，图像处理库，PIL图像库的分支和升级替代产品。

  • Matplotlib，著名的绘图库，提供了整套和matlab相似的命令API，用以绘制一些高质量的数学二维图形，十分适合交互式地进行制图。

  • brewer2mpl，有一个专业的python配色工具包，提供了从美术角度来讲的精美配色。

  • PyGame基于Python的多媒体开发和游戏软件开发模块，包含大量游戏和图像处理功能Box2d，开源的2d物理引擎，愤怒的小鸟就是使用了这款物理引擎进行开发的，Box2d物理引擎内部模拟了一个世界，你可以设置这个世界里的重力，然后往这个世界里添加各种物体，以及他们的一些物理特性，比如质量，摩擦，阻尼等等。

  • Pymunk，类似box2d的开源物理图形模拟库OpenCV, 目前最好的开源图像/视觉库，包括图像处理和计算机视觉方面、[机器学习]的很多通用算法。

  • SimpleCV，计算机视觉开源框架，类似opencv。

  • VTK，视觉化工具函式库（VTK， Visualization Toolkit）是一个开放源码，跨平台、支援平行处理（VTK曾用于处理大小近乎1个Petabyte的资料，其平台为美国Los Alamos国家实验室所有的具1024个处理器之大型系统）的图形应用函式库。2005年时曾被美国陆军研究实验室用于即时模拟俄罗斯制反导弹战车ZSU23-4受到平面波攻击的情形，其计算节点高达2.5兆个之多。

  • cgkit,Python Computer Graphics Kit,其module 主要分两个部分，

    1、与3d相关的一些python module 例如the vector, matrix and quaternion types, the RenderMan bindings, noise functions 这些模块可以在maya houdini nuke blender 等有Python扩展的程序中直接用;

    2、提供完整的场景操作的module， 他类似其他三维软件，在内存中保留完整的描述场景的信息。

    不能直接用于maya 等CGAL，

  • Computational Geometry Algorithms Library，计算几何算法库，提供计算几何相关的数据结构和算法，诸如三角剖分（2D约束三角剖分及二维和三维Delaunay三角剖分），

  • Voronoi图（二维和三维的点，2D加权Voronoi图，分割Voronoi图等），多边形（布尔操作，偏置），多面体（布尔运算），曲线整理及其应用，网格生成（二维Delaunay网格生成和三维表面和体积网格生成等），几何处理（表面网格简化，细分和参数化等），凸壳算法（2D，3D和dD），搜索结构（近邻搜索，kd树等），插值，形状分析，拟合，距离等。

  • Aggdraw，开源图像库，几乎涵盖了2d image操作的所有功能，使用起来非常灵活Pycairo,开源矢量绘图库Cairo开罗的python接口，cairo提供在多个背景下做2-D的绘图，高级的更可以使用硬件加速功能。wand，Python绑定魔杖工具（MagickWand），C语言API接口。

  • thumbor， 智能成像工具，可调整大小和翻转图像。

  • imgSeek，查询相似的图像。

  • python-qrcode，纯Python的二维码（QR码）生成器。

  • pyBarcode，创建条码，无需PIL模块。

  • pygram，Instagram像图像过滤器。

  • Quads，基于四叉树的计算机艺术。

  • nude.py，裸体检测函数。

  • scikit-image，scikit工具箱的图像处理库。

  • hmap，图像直方图工具。

  • bokeh，交互的Web绘图。

  • plotly，Web协同的Python和Matplotlib绘制。

  • vincent，文森特，Python Vega的函数库。

  • d3py，Python绘图库，基于D3.JS, ggplot -API兼容R语言的ggplot2.

  • Kartograph.py，在Python绘制漂亮的SVG地图。

  • pygal， SVG图表的创造者。

  • pygraphviz，Graphviz的Python接口。

  • Fonttlools，ttf字体工具函数包，用于fontforge、ttx等字体软件。

游戏和多媒体

  • audiolazy，数字信号处理（DSP）的Python工具包。
  • audioread，跨平台（GStreamer + Core Audio + MAD + FFmpeg）音频解码库。
  • beets，音乐库管理。
  • dejavu，音频指纹识别算法。
  • Dejavu 听一次音频后就会记录该音频的指纹信息，然后可通过麦克风对输入的音频进行识别是否同一首歌。django-elastic-transcoder,Django +亚马逊elastic转码。
  • eyeD3,音频文件工具，特别是MP3文件包含的ID3元数据。
  • id3reader，用于读取MP3的元数据。
  • mutagen，处理音频元数据。
  • pydub，-操纵音频和简单的高层次的接口。
  • pyechonest，Echo Nest API客户端。
  • talkbox，语音和信号处理的Python库。
  • TimeSide，开放的网络音频处理框架。
  • tinytag，读取音乐文件元数据，包括的MP3，OGG，FLAC和wave文件。
  • m3u8，用于解析m3u8文件。
  • moviepy，多格式视频编辑脚本模块，包括GIF动画。
  • shorten.tv，视频摘要。
  • scikit视频，SciPy视频处理例程。
  • GeoDjango,一个世界级的地理Web框架。
  • geopy,Geo地理编码的工具箱。
  • pygeoip，纯Python写的GeoIP API。
  • GeoIP，Python API接口，使用高精度GeoIP Legacy Database数据库。
  • geojson，GeoJSON函数库django-countries，一个Django程序，提供国家选择，国旗图标的静态文件，和一个国家的地域模型。
  • Pygame，Python游戏设计模块。
  • Cocos2d，2D游戏框架，演示，和其他的图形/交互应用，基于pyglet。Cocos2d- cocos2d is a framework for building 2D games, demos, and other graphical/interactive applications. It is based on pyglet.,PySDL2，SDL2的封装库。
  • Panda3D- 3D游戏引擎，迪士尼开发。用C++写的，完全兼容Python。
  • PyOgre，OGRE 3D渲染引擎，可用于游戏，模拟，任何3D。
  • PyOpenGL，绑定OpenGL和它相关的API。
  • PySFML，Python绑定SFMLRenPy，视觉小说引擎。

大数据与科学计算

  • pycuda/opencl，GPU高性能并发计算Pandas，python实现的类似R语言的数据统计、分析平台。基于NumPy和Matplotlib开发的，主要用于数据分析和数据可视化，它的数据结构DataFrame和R语言里的data.frame很像，特别是对于时间序列数据有自己的一套分析机制，非常不错。
  • Open Mining，商业智能（BI），Pandas的Web界面。
  • blaze，NumPy和Pandas大数据界面。
  • SciPy，开源的Python算法库和数学工具包，SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。其功能与软件MATLAB、Scilab和GNU Octave类似。Numpy和Scipy常常结合着使用，Python大多数机器学习库都依赖于这两个模块。
  • ScientificPython，一组经过挑选的Python程序模块，用于科学计算，包括几何学（矢量、张量、变换、矢量和张量场），四元数，自动求导数，（线性）插值，多项式，基础统计学，非线性最小二乘拟合，单位计算，Fortran兼容的文本格式，通过VRML的3D显示，以及两个Tk小工具，分别用于绘制线图和3D网格模型。此外还具有到netCDF，MPI和BSPlib库的接口。
  • NumPy科学计算库，提供了矩阵，线性代数，傅立叶变换等等的解决方案, 最常用的是它的N维数组对象. NumPy提供了两种基本的对象：ndarray（N-dimensional array object）和 ufunc（universal function object）。ndarray是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。
  • Cvxopt，最优化计算包，可进行线性规划、二次规划、半正定规划等的计算。
  • Numba，科学计算速度优化编译器。
  • pymvpa2，是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NetworkX，复杂网络的优化软件包。
  • zipline，交易算法的函数库。
  • PyDy， Python动态建模函数库。
  • SymPy,符号数学的Python库。
  • statsmodels,Python的统计建模和计量经济学。
  • astropy,天文学界的Python库。
  • orange，橙色，数据挖掘，数据可视化，通过可视化编程或Python脚本学习机分析。
  • RDKit,化学信息学和机器学习的软件。
  • Open Babel，巴贝尔，开放的化学工具箱。
  • cclib，化学软件包的计算函数库。
  • Biopython，免费的生物计算工具包。
  • bccb，生物分析相关的代码集。
  • bcbio-nextgen，提供完全自动化、高通量、测序分析的工具包。
  • visvis, 可视化计算模块库，可进行一维到四维数据的可视化。
  • MapReduce是Google提出的一个软件[架构]，用于大规模数据集（大于1TB）的并行运算。概念“Map（映射）”和“Reduce（归纳）”，及他们的主要思想，都是从函数式编程语言借来的MapReduce函数库。Framworks and libraries for MapReduce.,PySpark，[Spark]的Python API。
  • dpark，Spark的Python克隆，Python中的MapReduce框架。
  • luigi，为批量工作，建立复杂的管道。
  • mrjob，运行在[Hadoop]，或亚马逊网络服务的，MapReduce工作。

人工智能与机器学习

  • NLTK（natural language toolkit)，是python的自然语言处理工具包。2001年推出，包括了大量的词料库，以及自然语言处理方面的算法实现：分词， 词根计算， 分类， 语义分析等。
  • Pattern，数据挖掘模块，包括自然语言处理，机器学习工具，等等。
  • textblob，提供API为自然语言处理、分解NLP任务。基于NLTK和Pattern模块。
  • jieba，结巴，中文分词工具。snownlp，用于处理中文文本库。
  • loso，中文分词函数库。
  • genius，中文CRF基础库，条件随机场(conditional random field,简称 CRF),是一种鉴别式机率模型,是随机场的一种,常用于标注或分析序列资料,如自然语言文字或是生物序列Gensim，一个相当专业的主题模型Python工具包，无论是代码还是文档，可用于如何计算两个文档的相似度LIBSVM,是台湾大学林智仁(Lin Chih-Jen)教授等开发设计的一个简单、易于使用和快速有效的SVM模式识别与回归的软件包，他不但提供了编译好的可在Windows系列系统的执行文件，还提供了源代码，方便改进、修改以及在其它[操作系统]上应用；该软件对SVM所涉及的参数调节相对比较少，提供了很多的默认参数，利用这些默认参数可以解决很多问题；并提供了交互检验(Cross Validation)的功能。该软件可以解决C-SVM、ν-SVM、ε-SVR和ν-SVR等问题，包括基于一对一算法的多类模式识别问题。
  • scikits.learn，构建在SciPy之上用于机器学习的 Python 模块。它包括简单而高效的工具，可用于数据挖掘和数据分析。涵盖分类，回归和聚类算法，例如SVM， 逻辑回归，朴素贝叶斯，随机森林，k-means等算法，代码和文档都非常不错，在许多Python项目中都有应用。例如在我们熟悉的NLTK中，分类器方面就有专门针对scikit-learn的接口，可以调用scikit-learn的分类算法以及训练数据来训练分类器模型。
  • PyMC，机器学习采样工具包，scikit-learn似乎是所有人的宠儿，有人认为，PyMC更有魅力。PyMC主要用来做Bayesian分析。
  • Orange，基于组件的数据挖掘和机器学习软件套装，它的功能即友好，又很强大，快速而又多功能的可视化编程前端，以便浏览数据分析和可视化，包含了完整的一系列的组件以进行数据预处理，并提供了数据帐目，过渡，建模，模式评估和勘探的功能。侧重数据挖掘，可以用可视化语言或Python进行操作，拥有机器学习组件，还具有生物信息学以及文本挖掘的插件。
  • Milk，机器学习工具箱，其重点是提供监督分类法与几种有效的分类分析：SVMs(基于libsvm)，K-NN，随机森林经济和决策树。它还可以进行特征选择。这些分类可以在许多方面相结合，形成不同的分类系统。对于无监督学习，它提供K-means和affinity propagation聚类算法。
  • PyMVPA(Multivariate Pattern Analysis in Python),是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NuPIC，开源人工智能平台。该项目由Grok（原名 Numenta）公司开发，其中包括了公司的算法和软件架构。NuPIC 的运作接近于人脑，“当模式变化的时候，它会忘掉旧模式，记忆新模式”。如人脑一样，CLA 算法能够适应新的变化。
  • Pylearn2，基于Theano的机器学习库。
  • hebel，GPU加速，[深度学习]Python库。
  • gensim，机器学习库。
  • pybrain，机器学习模块，它的目标是为机器学习任务提供灵活、易应、强大的机器学习算法。
  • pybrain包括神经网络、强化学习(及二者结合)、无监督学习、进化算法。以神经网络为核心，所有的训练方法都以神经网络为一个实例Mahout,是 Apache Software Foundation（ASF） 旗下的一个开源项目，提供一些可扩展的机器学习领域经典算法的实现，旨在帮助开发人员更加方便快捷地创建智能应用程序。Mahout包含许多实现，包括聚类、分类、推荐过滤、频繁子项挖掘。此外，通过使用 Apache Hadoop 库，Mahout 可以有效地扩展到云中。
  • Crab，灵活的，快速的推荐引擎。
  • python-recsys，娱乐系统分析，推荐系统。
  • vowpal_porpoise，Vowpal Wabbit轻量级Python封装。
  • Theano,用来定义、优化和模拟数学表达式计算，用于高效的解决多维数组的计算问题的python软件包。它使得写深度学习模型更加容易，同时也给出了一些关于在GPU上训练它们的选项。

系统与命令行

  • threading，Python标准线程库，更高级别的线程接口。
  • envoy，特使，Python子线程的函数库。
  • sh，成熟的子线程替换函数库。
  • sarge，封装线程。
  • subprocess,调用shell命令的神器argparse，写命令行脚本必备，强大的命令行差数解析工具timeit，计算代码运行的时间等等unp，命令行工具，解压文件。
  • eventlet开销很少的多线程模块，使用的是 green threads 概念，例如，pool = eventlet.GreenPool(10000) 这样一条语句便创建了一个可以处理 10000 个客户端连接的线程池。类似Gevent线程库Gevent，多线程模块pytools,著名的python通用函数、工具包SendKeys, 键盘鼠标操作模块, 模拟键盘鼠标模拟操作。
  • pyHook,基于Python的“钩子”库，主要用于监听当前电脑上鼠标和键盘的事件。这个库依赖于另一个Python库PyWin32，如同名字所显示的，PyWin32只能运行在Windows平台，所以PyHook也只能运行在Windows平台。
  • pstuil,跨平台地很方便获取和控制系统的进程，以及读取系统的CPU占用内存占用等信息.cement，一个轻量级的、功能齐全的命令行工具click，简单优雅的的命令行接口。
  • clint，Python命令行工具。cliff，创造多层次指令的命令行程序框架。
  • Clime， 可以转换任何模块为多的CLI命令程序，无任何配置。
  • docopt，Python命令行参数分析器。
  • pycli，命令行应用程序，支持的标准命令行解析，测井，单元[测试]和功能测试。
  • Gooey，打开命令行程序，作为为一个完整的GUI应用程序,cookiecutter，命令行工具，从cookiecutters（项目模板）创建项目。例如，Python包项目，jQuery插件项目。
  • percol，为UNIX传统管道pipe命令，添加交互式选择风格。
  • rainbowstream，聪明和漂亮的推特客户终端。
  • Django Models，Django的一部分SQLAlchemy，Python SQL工具包和对象关系映射。
  • peewee，小型的ORM解析器。
  • PonyORM，为ORM提供了一种面向SQL的接口。MongoEngine，Python对象文件映射，使用[MongoDB]。Django MongoDB引擎MongoDB , Django后台。
  • django-mongodb-engine，Django后台.redisco,一个简单的模型和容器库，使用[Redis]flywheel，Amazon DynamoDB对象映射。
  • butterdb，谷歌电子表格的ORM，Python版。
  • celery，芹菜，异步任务队列/工作，基于分布式消息队列。
  • huey，休伊，轻量级，多线程任务队列。
  • mrq，队列先生，分布式任务队列，使用redis & Gevent。rq，简单的工作队列。
  • Queue,Queue模块可以用来实现多线程间通讯，让各个线程共享数据，生产者把货物放到Queue中，供消费者（线程）去使用。
  • simpleq，简单的，可扩展的队列，Amazon SQS基础队列。
  • Psyco，超强的python性能优化工具，psyco 的神奇在于它只需要在代码的入口处调用短短两行代码，性能就能提升 40% 或更多，真可谓是立竿见影！如果你的客户觉得你的程序有点慢，敬请不要急着去优化代码，psyco 或许能让他立即改变看法。psyco 堪称 Python 的 jit。fn.py，Python函数编程：缺失的功能享受FP的实现。funcy，函数编程工具。
  • Toolz，函数编程工具：迭代器、函数，字典。
  • CyToolz，Toolz的Cython实现，高性能的函数编程工具。
  • Ansible，安塞波，极为简单的自动化平台。
  • SaltStack，基础设施的自动化管理系统。
  • Fabric，织物，一个简单，远程执行和部署的语言工具。
  • Fabtools，Fabric的工具函数。
  • cuisine，热门的Fabric的工具函数。
  • psutil，跨平台的过程和系统工具模块。
  • pexpect，控制互动节目。
  • provy，易于使用的配置系统的Python。
  • honcho，Foreman的Python接口，用于管理procfile应用工具。
  • gunnery，多任务执行工具，与网络接口的分布式系统。
  • fig，快速。独立的开发环境中使用泊坞窗。
  • APScheduler，轻量级、但功能强大的在线任务调度程序。
  • django-schedule,Django日程应用程序。doit,任务流道/生成工具。
  • Joblib,Python提供的轻量级的流水线工具函数。
  • Plan，简易生成crontab文件。
  • Spiff，纯Python实现的，功能强大的工作流引擎。
  • schedule，Python作业调度。
  • TaskFlow，有助于使任务执行简单。
  • ctypes，Python标准库，速度更快，Python调用C代码的外部函数接口。
  • cffi，Python调用C代码外部函数接口，类似于ctypes直接在python程序中调用c程序,但是比ctypes更方便不要求编译成so再调用。
  • Cytoolz，python 加速库SWIG，简化封装和接口生成器。
  • Cython，Python优化静态编译器。
  • PyPy，Python解释器的 Python实现。
  • Stackless Python，一个增强版本的Python。它使程序员从基于线程的编程方式中获得好处，并避免传统线程所带来的性能与复杂度问题。
  • Stackless为 Python带来的微线程扩展，是一种低开销、轻量级的便利工具Pyston,使用LLVM和现代JIT技术,对python进行性能优化。
  • pythonlibs，非官方的Windows（32 / 64位）的Python扩展包scapy，优秀的数据包处理库。
  • ino，Arduino命令行工具。
  • Pyro，Python的机器人工具包。
  • pluginbase，一个简单而灵活的Python的插件系统。
  • itsdangerous，数据安全传输工具。
  • blinker，快速Python中的信号/事件调度系统。
  • pychievements，用于创建和跟踪成果框架。
  • python-patterns，Python中的设计模式。
  • pefileWindows PE文件解析器SIP，自动为C和C++库生成Python扩展模块的工具

数据库

  • MySQLdb，成熟的[MySQL]数据库模块
  • Baresql,SQL数据库包ZODB，Python本地对象数据库。一个K-V对象图数据库。
  • pickledb,简单和轻量级的K-V键值存储。
  • TinyDB, 轻量级，面向文档的数据库。
  • mysql-python，MySQL的Python工具库。
  • mysqlclient，mysql-python分支，支持Python 3.
  • PyMySQL,纯Python写的 MySQL驱动程序，兼容mysql-python。
  • mysql-connector-python,MySQL连接器,来自[Oracle]，纯Python编写。
  • oursql，MySQL连接器，提供本地话指令语句和BLOBs支持。
  • psycopg2，最流行的Python PostgreSQL适配器。
  • txpostgres，于Twisted的异步驱动，用于PostgreSQL。
  • queries,psycopg2函数库，用于PostgreSQL。
  • dataset,存储Python字典数据,用于SQLite，MySQL和PostgreSQL。
  • cassandra-python-driver，开源分布式NoSQL数据库系统Apache Cassandra系统的Python驱动.
  • pycassa,简化的cassandra数据库Python驱动。
  • HappyBase，友好的Apache [Hbase]的函数库。
  • PyMongo，MongoDB官方客户端。
  • Plyvel，LevelDB快速和功能丰富的Python接口。
  • redis-py,redis客户端。
  • py2neo,Python客户端(基于Neo4j的RESTful接口).
  • telephus,基于Twisted的cassandra客户端。
  • txRedis，基于Twisted的Redis客户端。

网络

  • Curl，Pycurl包是一个libcurl的Python接口，它是由C语言编写的。与urllib相比，它的速度要快很多。
  • Libcurl是一个支持FTP, FTPS, HTTP, HTTPS, GOPHER, TELNET, DICT, FILE 和 LDAP的客户端URL传输库.libcurl也支持HTTPS认证,HTTP POST,HTTP PUT,FTP上传,代理,Cookies,基本身份验证,FTP文件断点继传,HTTP代理通道等等。
  • Requests，用Python语言编写，基于 urllib的开源 HTTP 库。它比 urllib 更加方便，更加 Pythoner。支持 Python3。
  • httpie，命令行HTTP客户端，用户友好的cURL的替换工具。
  • s3cmd，命令行工具，用于管理Amazon S3和CloudFront。
  • youtube-dl，命令行程序，从YouTube下载视频。
  • you-get，Python3写的视频下载工具，可用于YouTube/Youku优酷/Niconico视频下载Coursera，从coursera.org下载视频，可重新命名文件wikiteam，wiki下载工具。
  • subliminal，命令行工具，搜索和下载字幕的函数库requests，HTTP函数库，更加人性化。
  • grequests，异步HTTP请求+ Gevent（高性能高并发函数库）。
  • urllib3，一个线程安全的HTTP连接池，支持文件post。
  • httplib2，综合HTTP的客户端函数库。
  • treq， Python API接口，Twisted的HTTP客户。
  • Mininet，流行的网络仿真器,API采用python编写。
  • POX，基于Python的开源软件定义网络（SDN）控制开发平台的应用，如OpenFlow的SDN控制器。
  • Pyretic，SDN的编程语言，提供了强大的抽象在网络交换机或仿真器。
  • SDX Platform，基于SDN的IXP实现，利用最小网络，痘和热。
  • inbox.py，Python的SMTP服务器。
  • imbox， Python版本IMAP库。
  • inbox，收件箱，开源邮件工具包。
  • lamson,SMTP服务器。
  • flanker,侧卫,电子邮件地址和MIME解析库。
  • marrow.mailer,高性能可扩展邮件交付框架。
  • django-celery-ses， Django电子邮件后台，使用AWS SES和Celery。
  • modoboa，邮件托管和管理平台，包括现代和简化Web UI。
  • envelopes，邮件工具。
  • mailjet，批量邮寄mailjet API接口，带统计。
  • Talon，利爪，Mailgun库，提取消息和签名。
  • mailjet- Mailjet API implementation for batch mailing, statistics and more., Talon - Mailgun library to extract message quotations and signatures.
  • pyzmail，编写，发送和解析电子邮件。
  • furl，燃料，小型的的URL解析库库。
  • purl，简单的，干净的API，操纵URL。
  • pyshorteners，纯Python库，URL短网址编辑。
  • short_url，短网址生成。
  • Scrapy，快速屏幕截取和网页抓取的框架。
  • portia，波西亚，Scrapy的可视化扩展。
  • feedparser，信息源解释器RoboBrowser，简单的网页浏览Python函数库，没有使用Web浏览器。
  • MechanicalSoup，网站自动化互动测试工具包。
  • mechanize，网页浏览编程工具。
  • Demiurge，造物主，PyQuery的轻量级工具。
  • newspaper,提取报纸新闻。
  • html2text,转换HTML为 Markdown格式的文本。
  • python-goose,HTML内容提取器。
  • lassie,莱西,人性化的网站内容检索。
  • micawber,通过UR抓提网页的函数库。
  • sumy，概要，文本和HTML网页的自动文摘模块。
  • Haul，距离，可扩展的图像爬虫。
  • python-readability,可读性工具
  • Arc90,快速的Python接口。
  • opengraph,OpenGraphProtocol协议解析模块
  • textract，从任何文件，Word，PowerPoint，PDF文件中提取文本等。
  • sanitize，消毒，使混乱的数据变的理智。
  • Autobahn Python， WebSocket和WAMP的函数库，使用 Twisted和Python
  • WebSocket-for-Python，websocket客户端和服务器端函数库。
  • SimpleXMLRPCServer，python标准库，简单的XML-RPC服务器，单线程。
  • SimpleJSONRPCServer，JSON-RPC规范实施函数库。
  • zeroRPC，基于ZeroMQ和MessagePack的RPC实现。
  • apache-libcloud，所有云服务的Python接口库。
  • wifi，WiFi -一套个Python库和命令行工具与WiFi，用于[Linux]。
  • streamparse，运行Python代码和数据的实时流。集成了Apache Storm。
  • boto，亚马逊网络服务接口。
  • twython，Twitter推特API。
  • google-api-python-client，谷歌客户端API。
  • gspread，谷歌电子表格的Python API。
  • facebook-sdk，facebook平台Python SDK。
  • facepy，简易的facebook图形APIgmail，Gmail的Python接口。
  • django-wordpress，Django的WordPress的模型和视图。

Web框架

  • Django，最流行的Python-Web框架，鼓励快速开发,并遵循MVC设计，开发周期短.ActiveGrid企业级的Web2.0解决方案
  • Karrigell,简单的Web框架，自身包含了Web服务，py脚本引擎和纯python的数据库
  • PyDBLitewebpy一个小巧灵活的Web框架，虽然简单但是功能强大
  • CherryPy基于Python的Web应用程序开发框架
  • Pylons基于Python的一个极其高效和可靠的Web开发框架Zope开源的Web应用服务器TurboGears基于Python的MVC风格的Web应用程序框架Twisted流行的网络编程库，大型Web框架QuixoteWeb开发框架
  • Flask,轻量级web框架Bottle，快速，简单和轻量级的WSGI模式Web框架。
  • Pyramid，轻量级，快速，稳定的开源Web框架。
  • web2py，简单易用的全堆栈Web框架和平台。
  • web.py，强大、简单的Web框架。
  • TurboGears，便于扩展的Web框架。
  • CherryPy，极简Python Web框架，支持，HTTP 1.1和WSGI线程池。
  • Grok，基于Zope3的Web框架。
  • Bluebream，开源的Web应用服务器，原名Zope 3。
  • guava，轻量级，高性能的Python-Web框架，采用c语言编写。
  • django-cms，基于Django企业级开源CMS。
  • djedi-cms轻量级但功能强大的Django CMS的插件，内联编辑和性能优化。
  • FeinCMS，基于Django的先进内容管理系统。
  • Kotte，高层次的Python的Web应用框架，基于Pyramid。
  • Mezzanine，强大，一致，灵活的内容管理平台。
  • Opps，基于Django的CMS，用于高流量的报纸、杂志和门户网站。
  • Plone，基于Zope的开源应用服务器Zope。
  • Quokka，灵活，可扩展的，轻量级的CMS系统，使用Flask和MongoDB。
  • Wagtail，Django内容管理系统。
  • Widgy，CMS框架，基于Django。
  • django-oscar，Django奥斯卡，开源的电子商务框架。
  • django-shop，基于Django的网店系统。
  • merchant，支持多种付款处理工具。
  • money，可扩展的货币兑换解决方案。
  • python-currencies，货币显示格式。
  • cornice，Pyramid的REST框架。
  • django-rest-framework，Django框架，强大灵活的工具，可以很容易地构建Web API。
  • django-tastypie，创造精美的Django应用程序API接口。
  • django-formapi，创建JSON API、HMAC认证和Django表单验证。
  • flask-api，提供统一的浏览器体验，基于Django框架。
  • flask-restful，快速构建REST API支持扩展。
  • flask-api-utils，flask的扩展。
  • falcon，猎鹰，高性能的Python框架，构建云API和Web应用程序后端。
  • eve，夏娃，REST API框架，使用Flask，MongoDB和良好意愿。
  • sandman，睡魔，为现有的数据库驱动的系统，自动生成REST API。
  • restless，类似TastyPie的框架。
  • savory-pie，REST API构建函数库（Django，及其他）
  • Jinja2，现代设计师友好的语言模板。
  • Genshi，网络感知输出模板工具包。
  • Mako，马可，Python平台的超高速、轻型模板。
  • Chameleon，变色龙，一个HTML / XML模板引擎。仿照ZPT，优化速度。
  • Spitfire，快速的Python编译模板。
  • django-haystack,大海捞针,Django模块搜索。
  • elasticsearch-py,Elasticsearch官方低级的Python客户端。
  • solrpy,solr客户端。
  • Whoosh,呼,快速，纯Python搜索引擎库。
  • Feedly，建立新闻和通知系统的函数库，使用Cassandra和Redis。
  • django-activity-stream,Django活动流,从你网站上的行动,产生通用的活动流。
  • Beaker，烧杯，一个缓存和会话使用的Web应用程序，独立的Python脚本和应用程序库。
  • dogpile.cache，是Beaker作者的下一代替代作品。
  • HermesCache，Python的缓存库，基于标签的失效及预防Dogpile效果。
  • django-cache-machine，Django缓存机，自动缓存失效，使用ORM。
  • django-cacheops，自动颗粒事件驱动，ORM缓存失效。
  • johnny-cache,约翰尼高速缓存框架,Django应用程序。
  • django-viewlet,渲染模板部件扩展缓存控制。
  • pylibmc,在libmemcached接口。
  • WTForms-JSON,JSON表单数据处理扩展。
  • Deform， HTML表单生成的函数库。
  • django-bootstrap3，bootstrap3，集成了Django。
  • django-crispy-forms，Django程序，可以创建优雅的表单。
  • django-remote-forms，Django的远程表单，Django表格的序列化程序。
  • django-simple-spam-blocker，Django简单的垃圾邮件拦截器。
  • django-simple-captcha，Django简单验证码，简单的和高度可定制的Django应用程序，用于添加验证码图像Ajenti，服务器管理面板。
  • Grappelli，界面花哨的django皮肤。
  • django-suit，Django替代o界面（仅用于非商业用途）。
  • django-xadmin，Django管理面板替代工具。
  • flask-admin，简单的flask管理界面框架flower，实时监控和Web管理面板。
  • Pelican，鹈鹕，Markdown或ReST，字王内容主题。支持 DVCS, Disqus. AGPL。
  • Cactus,仙人掌,设计师的网站静态生成器。
  • Hyde，海德， 基于Jinja2的静态网站生成器。
  • Nikola，尼古拉-一个静态网站和博客生成器。
  • Tags，标签，最简单的静态网站生成器。
  • Tinkerer，工匠，基于Sphinx的静态网站生成器。
  • asyncio，（在Python 3.4 +是Python标准库），异步I/O，事件循环，协同任务。
  • gevent，基于Python的网络库。
  • Twisted，扭曲，事件驱动的网络引擎。
  • Tornado，龙卷风，Web框架和异步网络的函数库。
  • pulsar，脉冲星，事件驱动的并行框架的Python。
  • diesel，柴油，绿色的，基于事件的I/O框架。
  • eventlet，WSGI支持异步框架。
  • pyzmq， 0MQ消息库的Python封装。
  • txZMQ,基于Twisted的0MQ消息库封Crossbar,开源统一应用路由器（WebSocket和WAMP）。
  • wsgiref，Python标准库，WSGI封装实现，单线程。
  • Werkzeug，机床，WSGI工具函数库，很容易地嵌入到你自己的项目框架。
  • paste，粘贴，多线程，稳定的，久经考验的WSGI工具。
  • rocket，火箭，多线程服务，基于Pyramid。
  • netius，快速的、异步WSGI服务器，gunicorn，forked前身，部分用C写的。
  • fapws3，异步网络，用C写的。meinheld，异步WSGI服务器，是用C写的。
  • bjoern，-快速的、异步WSGI服务器，用C写的。

安全

  • Permissions函数库，允许或拒绝用户访问数据或函数。
  • django-guardian,Django守护者，管理每个对象的权限，用于Django 1.2 +Carteblanche，管理导航和权限。
  • Authomatic，简单强大的认证/授权客户端。
  • OAuthLib， 通用，规范，OAuth请求签约工具。
  • rauth，用于OAuth 1.0，2.0，的Python库。
  • python-oauth2，利用全面测试，抽象接口来创建OAuth的客户端和服务器。
  • python-social-auth，易于安装的社会认证机制。
  • ,django-oauth-toolkit,Django OAuth工具包django-oauth2-provider,Django OAuth2工具包。
  • django-allauth，Django认证的应用程序。
  • Flask-OAuthlib，Flask的OAuth工具包sanction，制裁，简单的oauth2客户端。
  • jose，[JavaScript]对象签名和加密(JOSE)草案实施，标记状态。
  • python-jwt，JSON的Web令牌生成和验证模块。
  • pyjwt，JSON的Web令牌草案01。
  • python-jws，JSON的Web令牌草案02。
  • PyCrypto，Python的加密工具包。
  • Paramiko，sshv2协议的实现，提供了客户端和服务器端的功能。
  • cryptography，密码开发工具包。
  • PyNac，网络和密码（NaCl）函数库。hashids，hashids的 Python函数库。
  • Passlib，安全的密码存储/哈希库，非常高的水平。hashlib,md5, sha等hash算法，用来替换md5和sha模块，并使他们的API一致。它由OpenSSL支持，支持如下算法：md5,sha1, sha224, sha256, sha384, sha512.

GUI

  • PyGtk，基于Python的GUI程序开发GTK+库
  • PyQt用于Python的QT开发库
  • WxPythonPython下的GUI编程框架，其消息机制与MFC的架构相似,入门非常简单，需要快速开发相关的应用可以使用这个
  • TkinterPython下标准的界面编程包，因此不算是第三方库了
  • PySide，跨平台Qt的应用程序和用户界面框架，支撑Qt v4框架。
  • wxPython，混合wxWidgets的C++类库。
  • kivy，创建应用程序GUI函数库，看运行于Windows，Linux，MAC OS X，[Android]和[iOS]。
  • curse，用于创建终端GUI应用程序。
  • urwid，创建终端GUI应用程序窗体的函数库，支持事件，色彩丰富。
  • pyglet，跨平台的窗口和多媒体库的Python。
  • Tkinter，是Python事实上的标准GUI软件包。
  • enaml，创建漂亮的用户界面，语法类似QML。
  • Toga，托加，OS原生GUI工具包。

构建封装

  • pyenv,简单的Python版本管理。
  • virtualenv,创建独立的Python环境，用于同时安装不同版本的python环境。
  • virtualenvwrapper，是virtualenv的一组扩展。
  • pew,一套管理多个虚拟环境的工具。
  • vex，使运行指定的virtualenv命令。
  • PyRun，一个单文件，无需安装的Python版本管理工具。
  • PIP，Python包和依赖的管理工具。
  • easy_install，软件包管理系统,提供一个标准的分配Python软件和 函式库的格式。是一个附带设置工具的模块，和一个第三方函式库。旨在加快Python函式库的分配程式的速度。类似Ruby语言的RubyGems 。
  • conda，跨平台，二进制软件包管理器。,
  • Curdling，一个管理Python包的命令行工具。
  • wheel，Python发行的新标准，旨在替代eggs.
  • cx-Freeze，跨平台的，用于打包成可执行文件的库
  • py2exe, Windows平台的Freeze脚本工具，Py2exe ，将python脚本转换为windows上可以独立运行的可执行程序
  • py2app，MAC OS X平台的Freeze脚本工具
  • pyinstaller，转换成独立的可执行文件的Python程序（跨平台）。
  • pynsist,构建Windows安装程序的工具，用Python编写。
  • dh-virtualenv,建立和分发virtualenv(Debian软件包格式)
  • PyPI，新一代的Python包库管理工具。
  • warehouse,新一代的Python包库（PyPI）管理工具。
  • devpi，PyPI服务器和包装/测试/发布工具。
  • localshop，PyPI官方包镜像服务器，支持本地（私人）包上传。
  • buildout，创建，组装和部署应用程序的多个部分，其中一些可能是非基于Python的。
  • SCons，软件构造工具。
  • platformio，一个控制台的工具，构建的代码可用于不同的开发平台。
  • bitbake，特殊设计的工具，用于创建和部署[嵌入式]Linux软件包
  • fabricate，自动为任何编程语言，生成依赖包。
  • django-compressor，Django压缩机，压缩和内联JavaScript或CSS，链接到一个单一的缓存文件。
  • jinja-assets-compressor，金贾压缩机，一个Jinja扩展，通过编译，压缩你的资源。
  • webassets，优化管理，静态资源，独特的缓存清除。
  • fanstatic，球迷，包优化，提供静态文件。
  • fileconveyor，监控资源变化,可保存到CDN（内容分发网络）和文件系统。
  • django-storages，一组自定义存储Django后台。
  • glue，胶胶，一个简单的命令行工具，生成CSS Sprites。
  • libsass-python，Sass (层叠样式表)的Python接口。
  • Flask-Assets，整合应用程序资源。

代码调试

  • unittest，Python标准库，单元测试框架。
  • nose，鼻子，unittest延伸产品。
  • pytest，成熟的全功能的Python测试工具。
  • mamba，曼巴，Python的权威测试工具。出自BDD的旗下。
  • contexts，背景，BDD测试框架，基于C#。
  • pyshould，should风格的测试框架，基于PyHamcrest.
  • pyvows，BDD风格测试框架
  • Selenium，web测试框架，Python绑定Selenium。
  • splinter，分裂，测试Web应用程序的开源工具。
  • locust，刺槐，可扩展的用户负载测试工具，用Python写的。
  • sixpack，语言无关的A/B测试框架。
  • mock，模拟对象（英语：mock object，也译作模仿对象），模拟测试库。
  • responses，工具函数，用于mock模拟测试。
  • doublex-强大的测试框架。
  • freezegun，通过时间调整，测试模块。
  • httpretty， HTTP请求的模拟工具。
  • httmock，mock模拟测试。
  • coverage，代码覆盖度量测试。
  • faker，生成模拟测试数据的Python包。
  • mixer，混频器，产生模拟数据，用于Django ORM，SQLAlchemy，
  • Peewee, MongoEngine, Pony ORM等
  • model_mommy，在Django创建测试随机工具。
  • ForgeryPy，易用的模拟数据发生器。
  • radar，雷达，生成随机日期/时间。
  • FuckIt.py，测试Python代码运行。
  • Code Analysispysonar2，Python类型索引。
  • pycallgraph,可视化的流量（调用图）应用程序。
  • code2flow,转换Python和JavaScript代码到流程图。
  • LinterFlake8，源代码模块检查器
  • pylama，Python和JavaScript代码审计工具。
  • Pylint，源代码分析器，它查找编程错误，帮助执行一个代码标准和嗅探一些代码味道。注意：相比于PyChecker，Pylint是一个高阶的Python代码分析工具，它分析Python代码中的错误。
  • Pyflakes，一个用于检查Python源文件错误的简单程序。Pyflakes分析程序并且检查各种错误。它通过解析源文件实现，无需导入。
  • pdb,Python标准库,Python调试器。
  • ipdb,IPython使用的PDB。
  • winpdb独立于平台的GUI调试器。
  • pudb，全屏，基于python调试控制台。
  • pyringe，可附着于及注入代码到Python程序的调试器。
  • python-statsd，statsd服务器客户端。
  • memory_profiler， 内存监视。
  • profiling，交互式Python分析器。
  • django-debug-toolbar, Django调试工具栏,显示各种调试信息:当前请求/响应。
  • django-devserver,Django调试工具。
  • flask-debugtoolbar,flask调试工具。
文章作者: 杰克成
文章链接: https://jackhcc.github.io/posts/blog-python20.html
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 杰克成 !
Python
赏
评论
  目录