Python

大数据时代，各行各业对数据采集的需要日益增多，网络爬虫的使用也更为宽泛，越来越多的人开始学习网络爬虫这项技术，K哥爬虫此前曾经推出不少爬虫进阶、逆向相干文章，为实现从易到难全方位笼罩，特设【0根底学爬虫】专栏，帮忙小白疾速入门爬虫，本期为文件存储。概述前几期文章中咱们曾经理解到了申请库、解析库的应用，曾经学会了如何向指标网站发送申请以及解析响应信息，那么咱们还须要晓得如何将数据进行存储。数据存储有很多形式，本期会介绍如何将数据存入文本文件，如 TXT、JSON、CSV 等。 TXT 文件存储介绍TXT文件存储是最根本的数据存储形式，TXT 文本文件基本上兼容任何平台，因而它的利用也十分宽泛。应用代码操作 TXT 文件非常简略，然而毛病也非常明显，不利于对数据进行检索。 应用Python 中操作 TXT 文件须要应用到内置的 open() 函数。 open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True) open() 函数有七个参数别离为： file：文件门路 mode：打开方式，默认为（r）只读模式 buffering：文件缓冲 encoding：字符编码 errors：报错级别 newline：换行模式，默认以\n换行 closefd：管制在敞开文件时是否彻底敞开文件 文件打开方式分为以下几种： r：以只读形式关上文件 w：以写入形式关上文件。如果文件存在则笼罩原文件，不存在则新建。 x：创立新文件并以写入形式关上文件 a：以追加形式关上文件。如果文件存在，则在结尾地位写入，不存在则新建。 b：二进制模式 t：文本模式 +：读取与写入 wb：以二进制写入形式关上文件。如果文件存在则笼罩原文件，不存在则新建。 w+：以读写形式关上文件。如果文件存在则笼罩原文件，不存在则新建。 wb+：以二进制读写形式关上文件。如果文件存在则笼罩原文件，不存在则新建。 ab：以二进制追加形式关上文件。如果文件存在，则在结尾地位写入，不存在则新建。 ab+：以二进制追加读写形式关上文件。如果文件存在，则在结尾地位写入，不存在则新建。 f = open('data.txt','r',encoding="utf-8")f.seek(2) #从指定下标地位开始读取data = f.read()f.close()f = open('data.txt','w',encoding="utf-8")f.write('hello')f.write(' ')f.write('world')f.close()#hello world上下文管理器上文中能够看到，对一个文件进行读写操作后须要应用 close() 办法敞开文件。如果不应用 close() 敞开文件会导致资源泄露问题。为了防止这个问题和优化代码，咱们能够应用上下文管理器来操作文件。 with open('data.txt','w',encoding='uutf-8')as f: f.write('hello') f.write(' ') f.write('world')当 with 语句块完结后文件会主动敞开，这样不须要再调用 close() 办法。 JSON 文件存储介绍JSON 全称为 JavaScript Object Notation，也就是 JavaScript 对象标记，是一种轻量级的数据交换格局。人们能够很容易的对 JSON 格局的数据进行浏览和编写，同时也不便了机器进行解析和生成。JSON 采纳齐全独立于程序语言的文本格式，然而也应用了类 C 语言的习惯（包含C, C++, C#, Java, JavaScript, Perl, Python等）。这些个性使 JSON 成为现实的数据交换语言。 ...

据说是鸡肋❝ 始终以来，对于Python的多线程和多过程是否是鸡肋的争议始终存在，今晚抽空谈谈我的认识，以下是我的观点： ❞ 对于多线程：Python 的多线程库 threading 在某些状况下的确是鸡肋的，这是因为 Python 的全局解释器锁（Global Interpreter Lock, GIL）导致了多线程的并发性能不能真正施展进去。简略来说，这意味着在任何给定时刻只有一个线程可能真正地运行 Python 代码，这就限度了多线程的性能。 然而，对于一些特定类型的工作，比方 I/O 密集型的工作，多线程还是能够带来性能晋升的。这是因为 I/O 操作通常会导致线程阻塞，让其余线程得以运行。此外，在 Python3 中，对于一些非凡状况，比方应用 asyncio 库，也能够通过协程实现并发执行，从而躲避 GIL 的限度。 对于多过程：Python 的多过程库 multiprocessing 是能够真正施展出多核处理器的性能的，因为每个过程都有本人的解释器和 GIL。这意味着每个过程能够独立地运行 Python 代码，从而实现真正的并行处理。 当然，多过程也有一些毛病，比方过程之间的通信和数据共享比拟麻烦。此外，每个过程的启动和销毁都会波及到肯定的开销，因而如果工作很小，多过程可能反而会带来性能降落。 多线程和多过程怎么选❝ 对于不同类型的工作，多线程和多过程都有它们的优缺点，须要依据具体情况进行抉择。如果你要解决的工作是 CPU 密集型的，那么多过程可能是更好的抉择；如果是 I/O 密集型的，那么多线程可能更适合。 ❞ 实战验证上面我写一个简略的代码示例，用来阐明 Python 多线程在 CPU 密集型工作中的性能问题：import threadingcounter = 0def worker():    global counter    for i in range(10000000):        counter += 1threads = []for i in range(4):    t = threading.Thread(target=worker)    threads.append(t)for t in threads:    t.start()for t in threads:    t.join()print(counter)这个代码示例定义了一个全局变量 counter，而后创立了 4 个线程，每个线程都会执行一个简略的循环，将 counter 的值加 1。最初输入 counter 的值。 在单线程模式下，循环实现后 counter 的值应该是 40000000，然而在多线程模式下，因为 GIL 的限度，多个线程并不能真正并行地执行代码，导致 counter 的最终值小于 40000000。例如，在我的机器上运行这个代码示例，最终的输入后果可能是 36092076，远小于预期的值。 这个示例表明，在一些 CPU 密集型的工作中，Python 多线程的性能受到 GIL 的限度，不能真正地施展出多核处理器的劣势。 ...

这一篇笔记介绍如何在 Django 中运行脚本。 假如说咱们要实现一个性能，须要获取 blog.models.Blog 这张表里的总数且应用 print() 输入。 如果代码逻辑很短，且是一次性执行的操作，咱们能够在零碎的根目录下应用 python3 manage.py shell 在 shell 中操作实现。 from blog.models import Blogprint(Blog.objects.all().count())然而如果这个需要是一个很长的逻辑，且须要能够反复执行，那么应该如何操作呢？ 首先，咱们须要能够用到 Django 里的 Blog model，而后应用 model 的形式来进行查问。 咱们能够将其写入一个文件，每次都应用 shell 来调用。 写入文件，在 shell 调用比方，咱们能够在 blog 创立一个 scripts 文件夹，而后创立一个 blog_script.py 文件： # blog/scripts/blog_script.pyfrom blog.models import Blogdef get_blog_count(): print(Blog.objects.all().count())而后每次调用的时候就进入 python3 manage.py shell 操作： from blog.scripts.blog_script import get_blog_countget_blog_count()间接运行脚本如果咱们想创立一个文件，而后间接运行该脚本，那么就须要在脚本中引入以后 Django 零碎环境的一些参数和变量，能够间接在零碎根目录下创立一个 blog_script.py 文件： # blog_script.pyimport django, osos.environ.setdefault("DJANGO_SETTINGS_MODULE", "hunter.settings")django.setup()from blog.models import Blogif __name__ == "__main__": print(Blog.objects.count())而后咱们在零碎根目录下间接执行该脚本： ...

在编程时，咱们常常要作条件判断，并依据条件的后果抉择执行不同的语句块。在许多编程语言中，最常见的写法是三元运算符，然而，Python 并不反对三元运算符，独一无二，两个最热门的新兴语言 Go 和 Rust 也不反对！ 为什么 Python 不反对三元运算符呢？本文将次要剖析 Python 在设计条件抉择语法时的过程，科普为什么它会采纳现今的不同凡响的实现计划，同时，咱们也将考查为什么其它语言也要摈弃传统的三元运算符。 在开篇之前，我再申明一下：就像“Python为什么”系列的大部分文章一样，本文关注的仅是一个很小的语法点，但它并不是“茴香豆有几种写法”那种毫无意义的话题。因为，轻微之处见真功夫，深入研究语言设计背地的起因、历史和哲学，能够让咱们在编程时有更加清晰和自在的思维。 什么是三元运算符？三元运算符通常指的是“?:”，其语法模式为：condition ? expression1 : expression2，如果 condition 为真，则取 expression1，若不为真，则取 expression2。 语法简化模式“a ? b : c”，能够读成“如果 a 条件成立，则为 b，否则为 c”。 三元运算符是对一般一重 if-else 构造的简化，罕用于在一条语句中同时实现条件判断和取值操作。 // 惯例 if-else if (a > b) { result = x;} else { result = y;}// 简化后的写法result = a > b ? x : y;采纳了这种语法设计的编程语言有很多，比方 C、C#、C++、Java、JavaScript、PHP、Perl、Ruby、Swift 等等。毫无争议，它就是编程语言界的支流设计方案（至今仍是）。 这种语法十分简洁高效，代码的可读性也很强（如果你不是第一次接触的话），深得很多人的喜爱。 然而，它并非毫无毛病。Python 是这种语法设计的最驰名的挑战者，接下来，咱们将看看为什么 Python 要另辟蹊径。 Python 社区的投票Python 公布于 1991 年，但在接下来的 15 年里，除了 if-else 语法外，它并不反对三元运算符和其它条件表达式。而且，在 2006 年引入条件表达式前，社区对此进行了漫长而波折的争执，能够说这是一个设计得很艰巨的语法了。 ...

上一篇文章中，我介绍了 FastAPI 框架的装置和 HelloWorld 我的项目搭建形式。本文将介绍如何应用 Router 路由解决 FastAPI 中的申请。 什么是路由路由 Router 就像是一个流水线上的线长，协调生产，下达命令给不同的组长进行分工，而后执行根本的工作。路由器的工作目标是，在团队中工作时，您可能必须在团队成员（这里的团队负责人是队长）之间调配复杂性，这将有助于更快地实现我的项目，正确的 SME 将在该分支/路由器上工作. 路由是构建网络应用的一个重要局部。FastAPI 中的路由是灵便和不便的。路由是解决从客户端发送到服务器的 HTTP 申请的过程。HTTP 申请被发送到定义的路由，这些路由有定义的处理程序来解决申请和响应。这些处理程序被称为 Route Handler。 FastAPI 中的路由参考 FastAPI 文档对路由器的介绍：如果你正在构建一个应用程序或一个 Web API，你很少会把所有货色都放在一个文件中。 FastAPI 提供了一个不便的工具来构建您的应用程序，同时放弃所有的灵活性。 先来看一个例子： from fastapi import FastAPIapp = FastAPI()@app.get('/') async def welcome() -> dict: return { "message": "Welcome to my Page"}uvicorn 工具指向 FastAPI 的实例，为应用程序服务： uvicorn main:app --port 8888 --reload 拜访 $ curl http://127.0.0.1:8888 % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed100 32 100 32 0 0 11279 0 --:--:-- --:--:-- --:--:-- 16000{"message":"Welcome to ma Page"}FastAPI()实例可用于路由操作，正如后面所见。然而，这种办法通常用于在路由过程中只能解决繁多门路的应用程序。在应用 FastAPI() 实例创立一个执行独特性能的独自路由的状况下，应用程序将无奈运行两个路由，因为 uvicorn 工具只能运行一个入口点。 ...

该脚本依据输出的门路，能够读取门路下的所有文件，实现匹配字符串替换，增加内容和删除内容的性能。 import osfrom fileinput import FileInput#删除内容def match_then_delete(inputpath): for root,dirs,files in os.walk(inputpath): for file in files: path = os.path.join(root,file) output_file_path = ""+file print(out_file_path) with open(path,'r',encoding='gbk') as infile: input_stream=infile.read() output_stream="" #换行分切分内容 input_stream_lines=input_stream.split("\n") for line in input_stream_lines: if line.startwith(""): pass else: output_stream=output_stream+line+'\n' #读取去掉指定内容后的新内容，从新写文件 g = open(output_file_path,'w') g.write(output_stream)#增加内容,在匹配内容match上方增加内容contentdef match_then_insert(filename,match,content): for line in FileInput(filename,inplace=True): if match in line: line = content+'\n'+line print(line,end='')#匹配字符串替换def match_then_replace(filename,oldtext,newtext): for line in FileInput(filename, inplace=True): if oldtext in line: line = line.replace(oldtext,newtext) print(line,end='')if __name__=='__main__': inputpath = "" for root,dirs,files in os.walk(inputpath): for file in files: path = os.path.join(root,file) output_file_path = inputpath+file match_then_replace(output_file_path,"oldtext","newtext")须要留神的点：当咱们须要解决的文件是utf-8编码时，而python3中默认的文件解码格局是gbk，若间接应用FileInput模块，会报谬误UnicodeDecodeError: 'gbk' codec can't decode byte 0x89 in position 116: illegal multibyte sequence若咱们应用如下模式 ...

前言Python 如此受欢迎的泛滥起因之一是 Python 有大量成熟和稳固的库可供选择: 网页开发有：Django 和 Flask，提供了很好的网络开发体验和大量的有用文档机器学习有：scikit-learn、Keras 等，提供了丰盛的机器学习的包和数据处理和可视化工具。FastAPI 是一个疾速、轻量级的古代 API，与其余基于 Python 的 Web 框架（如 Flask 和 Django ）相比，有一个更容易的学习曲线。FastAPI 绝对较新，但它有一个一直增长的社区。它被宽泛地用于构建网络 API 和部署机器学习模型。正是因为大量的库和框架保障了 Python 领有良好的开发速度和便利性，使 Python、Go 和 Rust 这样的新语言可能并驾齐驱，博得大量的开发者的青睐。 什么是 FastAPI ?FastAPI 是一个用于开发网络 API 的新的 Python 框架，在过来几年中失去了遍及。如果你打算应用 Python 进行 Web 开发，相熟 FastAPI 将对你有益处。 文档： https://fastapi.tiangolo.com源码： GitHub - tiangolo/fastapi: FastAPI framework, high performance, easy to learn, fast to code, ready for production从官网文档来看，FastAPI 具备如下几个要害个性: 疾速：可与 NodeJS 和 Go 比肩的极高性能（归功于 Starlette 和 Pydantic）。最快的 Python web 框架之一。高效编码：进步性能开发速度约 200％ 至 300％。*更少 bug：缩小约 40％ 的人为（开发者）导致谬误。*智能：极佳的编辑器反对。处处皆可主动补全，缩小调试工夫。简略：设计的易于应用和学习，浏览文档的工夫更短。简短：使代码反复最小化。通过不同的参数申明实现丰盛性能。bug 更少。强壮：生产可用级别的代码。还有主动生成的交互式文档。标准化：基于（并齐全兼容）API 的相干凋谢规范：OpenAPI (以前被称为 Swagger) 和 JSON Schema。装置 FastAPIpython -m pip install fastapi uvicorn[standard]有了这些，你曾经装置了 FastAPI 和 Uvicorn，并筹备学习如何应用它们。FastAPI 是你用来建设你的 API 的框架，而 Uvicorn 是应用你建设的 API 来服务申请的服务器。 ...

深刻了解 python 虚拟机：字节码灵魂——Code obejct在本篇文章当中次要给大家深刻介绍在 cpython 当中十分重要的一个数据结构 code object! 在上一篇文章 深刻了解 python 虚拟机：pyc 文件构造 ，咱们简略介绍了一下在 code object 当中有哪些字段以及这些字段的简略含意，在本篇文章当中将会举一些例子以便更加深刻了解这些字段。 Code Object 数据结构typedef struct { PyObject_HEAD int co_argcount; /* #arguments, except *args */ int co_kwonlyargcount; /* #keyword only arguments */ int co_nlocals; /* #local variables */ int co_stacksize; /* #entries needed for evaluation stack */ int co_flags; /* CO_..., see below */ PyObject *co_code; /* instruction opcodes */ PyObject *co_consts; /* list (constants used) */ PyObject *co_names; /* list of strings (names used) */ PyObject *co_varnames; /* tuple of strings (local variable names) */ PyObject *co_freevars; /* tuple of strings (free variable names) */ PyObject *co_cellvars; /* tuple of strings (cell variable names) */ /* The rest aren't used in either hash or comparisons, except for co_name (used in both) and co_firstlineno (used only in comparisons). This is done to preserve the name and line number for tracebacks and debuggers; otherwise, constant de-duplication would collapse identical functions/lambdas defined on different lines. */ unsigned char *co_cell2arg; /* Maps cell vars which are arguments. */ PyObject *co_filename; /* unicode (where it was loaded from) */ PyObject *co_name; /* unicode (name, for reference) */ int co_firstlineno; /* first source line number */ PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) See Objects/lnotab_notes.txt for details. */ void *co_zombieframe; /* for optimization only (see frameobject.c) */ PyObject *co_weakreflist; /* to support weakrefs to code objects */} PyCodeObject;上面是 code object 当中各个字段的作用： ...

这一篇笔记介绍 Django 里 settings.py 里一些罕用的配置项，这些配置有一些是在之前的笔记中有过介绍的，比方 logging 的日志配置，session 的会话配置等，这里就只做一下简略的回顾，有一些是之前没有介绍过的就着重介绍一下。 以下是本篇笔记目录： 邮箱配置容许拜访地址配置数据库配置调试模式配置注册应用程序配置时区工夫配置会话配置其余配置1、邮箱配置在前一篇笔记发送邮件的介绍中，有过具体的介绍，比方 EMAIL_BACKEND，EMAIL_HOST 等，这里额定再介绍一个参数 ADMINS。 这个参数其实在第三十篇笔记 log 日志记录中有过介绍，当咱们设置的日志发送邮件模块有指定等级的日志产生时，会将邮件发送至 ADMINS 中定义的收件人列表。 这个参数是一个列表，每个元素也是一个元组或列表，第一个参数为收件人的名称，第二个为收件人邮箱： ADMINS = [ ("Hunter", "120460xxx@qq.com"),]2、容许拜访地址配置咱们的零碎是能够设置容许拜访的地址的，能够设置域名或者 IP，比方： ALLOWED_HOSTS = ["192.168.1.9"]这个参数的默认值为空列表，则阐明只容许该零碎所在的服务器地址的其余服务能够拜访到 Django 服务。 如果想设置所有地址都能够拜访到咱们的服务，能够如此设置： ALLOWED_HOSTS = ["*"]3、数据库配置后面连贯数据库的时候，没有做过多的介绍，都是间接应用，这里再做一下具体的介绍，以下是一个示例： DATABASES = { 'default': { 'ENGINE': "django.db.backends.mysql", "HOST": "192.168.1.31", 'NAME': "func_test", "USER": "root", "PASSWORD": "123456", "PORT": 3306, "OPTIONS": {}, "TEST": {}, },}在 DATABASES 中，必须设置一个 default 数据库，也能够在外面增加其余数据库连贯，比方之前的多数据库连贯操作的笔记示例 其中，ENGINE 示意连贯的数据库类型，这里咱们设置的是 MySQL，也能够设置成 postgresql，oracle，sqlite3。 这里咱们连贯应用的都是 MySQL，所以上面的配置项都是基于 MySQL 做的介绍。 HOST 示意连贯数据库的主机 ...

抉择微信好友数据对其进行数据分析。比方可视化好友男女比例散布，可视化省份起源，可视化签名的情感强度值等等。Tips：github地址：https://github.com/Mlscoding/Pyhon-wechatDataAnalyse须要筹备微信好友数据文件，格局为csv。itchat连贯微信不可用，起因是网页版微信API被封了，itchat等基于webAPI的计划都生效了。能够应用 WechatPCAPI 实现，它是间接调用 PC 版微信客户端的，当然有一点不足之处就是须要应用指定版本的 Python 和指定版本的 PC 版微信客户端。我并没有应用这种办法，不过多赘述。须要装置的库在代码中能看到。如果seacorn库装置不上能够尝试镜像源：pip install seaborn -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com复制上述指令关上cmd运行即可。 1.剖析好友性别并可视化import csvfrom matplotlib import pyplot as pltplt.rcParams['font.sans-serif'] = ['SimHei']# 用来失常显示中文标签plt.rcParams['axes.unicode_minus'] = False# 1.读取csv文件，把性别信息读取进去def getSex(filename): lstsex = [] with open(filename, 'r') as fr: reader = csv.reader(fr) for i in reader: lstsex.append(i[4]) return lstsex # 2.性别pyechart可视化def VisualSexpyechart(lstsex): sex = dict() # 2.1提取好友性别信息，从1开始，因为第0个是本人 for f in lstsex[1:]: if f == '1': # 男 sex["man"] = sex.get("man", 0) + 1 elif f == '2': # 女 sex["women"] = sex.get("women", 0) + 1 else: # 未知 sex["unknown"] = sex.get("unknown", 0) + 1 # 在屏幕上打印进去 total = len(lstsex[1:]) # 2.2打印出本人的好友性别比例 plt.figure(figsize=(6, 9)) labels = [u'男性好友', u'女性好友', u'性别不明'] sizes = [sex['man'], sex['women'], sex['unknown']] colors = ['cornflowerblue', 'lightcoral', 'silver'] explode = (0.05, 0, 0) patches, l_text, p_text = plt.pie(sizes, explode=explode, labels=labels, colors=colors, labeldistance=1.1, autopct='%3.1f%%', shadow=False, startangle=90, pctdistance=0.6) for t in l_text: t.set_size(30) for t in p_text: t.set_size(20) plt.axis('equal') plt.legend() plt.show()# 3.执行主程序，失去所有好友性别VisualSexpyechart(getSex("friends_information.csv"))2.剖析好友省份起源并可视化import csvimport matplotlib.pyplot as pltfrom matplotlib.font_manager import FontProperties# 用于读取csv文件，获取好友所在省份信息def get_city_info(filename): lstcity = [] with open(filename, 'r') as fr: reader = csv.reader(fr) for i in reader: lstcity.append(i[3]) return lstcity# 用于绘制柱状图，并展现好友所在省份信息def plot_city_info(city_info): # 用于存储各省份的好友数量 province_counts = {} # 须要统计的省份列表 provinces = ['山东', '黑龙江', '澳门', '吉林', '江苏', '贵州', '上海', '湖北', '北京', '浙江', '河北', '辽宁'] for province in provinces: province_counts[province] = city_info.count(province) # 设置中文字体 font = FontProperties(fname=r"C:\Windows\Fonts\simhei.ttf", size=12) # 设置图表款式 plt.style.use('ggplot') # 绘制柱状图 fig, ax = plt.subplots(figsize=(10, 6)) x = range(len(provinces)) y = [province_counts[p] for p in provinces] color = ['lightsteelblue', 'cornflowerblue', 'cadetblue', 'mediumturquoise', 'paleturquoise', 'powderblue', 'skyblue', 'lightskyblue', 'lightblue', 'lavender', 'thistle', 'plum'] ax.bar(x, y, color=color, alpha=0.8) # 增加数据标签 for i, v in enumerate(y): ax.text(i, v + 0.1, str(v), ha='center', fontproperties=font) # 设置x轴的刻度标签 ax.set_xticks(x) ax.set_xticklabels(provinces, fontproperties=font) # 设置y轴的刻度范畴和标签 ax.set_ylim(0, max(y) * 1.2) ax.set_ylabel('好友数量', fontproperties=font) # 设置图表题目 ax.set_title('好友所在省份散布状况', fontproperties=font) # 显示网格线 ax.grid(axis='y', linestyle='--', alpha=0.6) # 暗藏上、右边框线 ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) # 显示图表 plt.show()# 主程序，用于执行上述两个函数if __name__ == '__main__': city_info = get_city_info('friends_information.csv') plot_city_info(city_info)3.剖析好友共性签名情感强度值并可视化from textblob import TextBlobimport seaborn as snsimport matplotlib.pyplot as pltsns.set(style='darkgrid', palette='deep')plt.rcParams['font.sans-serif'] = ['SimHei']plt.rcParams['axes.unicode_minus'] = Falsewith open('english.txt', 'r') as file: signatures = file.read()polarity_scores = []positive = 0negative = 0neutral = 0for signature in signatures.split('\n'): blob = TextBlob(signature) polarity_scores.append(blob.sentiment.polarity) if blob.sentiment.polarity > 0: positive += 1 elif blob.sentiment.polarity < 0: negative += 1 else: neutral += 1# 应用Seaborn库绘制直方图和KDE曲线fig, ax = plt.subplots(figsize=(10, 5))sns.histplot(polarity_scores, bins=20, color='#4A4A4A', kde=True, ax=ax)# 增加平均线和标签mean = sum(polarity_scores) / len(polarity_scores)ax.axvline(x=mean, color='r', linestyle='--', linewidth=2, label='Mean')ax.text(mean+0.01, max(ax.get_ylim())/2, f"Mean: {mean:.2f}", fontsize=12, color='r')plt.xlabel('Polarity score')plt.ylabel('Frequency')plt.title('Sentiment Polarity Distribution')plt.legend()plt.show()4.成果展现剖析好友性别 ...

这一篇笔记介绍如何在 Django 中发送邮件。 本文首发于微信公众号：【Django笔记】 在 Python 中，提供了 smtplib 的邮件模块，而 Django 在这个根底上对其进行了封装，咱们能够通过 django.core.mail 来调用。 以下是本篇笔记的目录： 邮件配置项send_mailEmailMessage复用邮件发送连贯开发阶段调试设置1、邮件配置项在正式发送邮件前，咱们须要在 settings.py 里设置几个参数，如下： # hunter/settings.pyEMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'EMAIL_HOST = 'smtp.163.com' EMAIL_PORT = 465 EMAIL_HOST_USER = 'hunterxxxx04@163.com' EMAIL_HOST_PASSWORD = 'JBDMVIXSHYxxxxx' EMAIL_USE_SSL = TrueEMAIL_USE_TLS = False这些配置项在 log 日志记录那一篇笔记中有过介绍，那是咱们指定日志等级发送邮件的性能，这里再做一下简略的介绍。 EMAIL_BACKEND 是咱们指定的邮箱后端，在前面咱们会介绍在开发调试阶段的时候能够设置的其余值 EMAIL_HOST 发送邮箱的主机地址，这里咱们应用的是 163 邮箱的地址 EMAIL_PORT EMAIL_HOST 应用的端口 EMAIL_HOST_USER 发件人邮箱地址 EMAIL_HOST_PASSWORD 163 邮箱开启了 SMTP 服务提供的受权码 EMAIL_USE_SSL 与 SMTP 服务器对话时是否应用隐式 TLS 连贯，这种类型被称为 SSL，通常在 465 端口应用，这个字段与 EMAIL_USE_TLS 是相互排挤的，只能设置一个为 True EMAIL_USE_TLS 与 SMTP 服务器对话是否应用 TLS 连贯，个别在 587 端口 ...

在 Python 中，版本号由三局部组成，别离是主版本号、次版本号和订正版本号。对于版本号形如 x.y.z 的格局，其中 x 是主版本号，y 是次版本号，z 是订正版本号。 对于 Python 中的版本号 3.10.5，其中 3 是主版本号，10 是次版本号，5 是订正版本号。因而，10 应该被称为次版本号，而不是子版本号。

应用 elasticsearch 的 python sdk 实现批改一个 index 的 char_filter 在 Elasticsearch 中，能够应用 Python SDK（即 Elasticsearch Python 客户端）来实现批改一个索引的 char_filter。上面是一个简略的示例，阐明如何应用 Python SDK 来实现批改一个索引的 char_filter： from elasticsearch import Elasticsearch# 创立 Elasticsearch 客户端es = Elasticsearch(["http://localhost:9200/"])# 定义索引名称和 char_filter 名称index_name = "my_index"char_filter_name = "my_char_filter"# 定义要增加的 char_filter 配置char_filter_config = { "type": "mapping", "mappings": [ "a => b", "c => d" ]}# 获取原始的索引配置index_settings = es.indices.get_settings(index=index_name)# 获取原始的 char_filter 配置char_filters = index_settings[index_name]["settings"]["index"]["analysis"]["char_filter"]# 将新的 char_filter 配置增加到原始配置中char_filters[char_filter_name] = char_filter_config# 更新索引的配置，包含 char_filter 配置body = { "settings": { "index": { "analysis": { "char_filter": char_filters } } }}# 更新索引的配置es.indices.put_settings(index=index_name, body=body)在下面的代码中，咱们首先创立了 Elasticsearch 客户端对象 es，而后定义了要批改的索引名称 index_name 和要增加的 char_filter 名称 char_filter_name。接着，咱们应用一个字典对象 char_filter_config 来定义要增加的 char_filter 配置。而后，咱们应用 get_settings() 办法获取原始的索引配置，并从中提取出 char_filter 配置。接着，咱们将新的 char_filter 配置增加到原始配置中，并应用 put_settings() 办法将更新后的索引配置从新写入到 Elasticsearch 中。 ...

申明本文章中所有内容仅供学习交换应用，不用于其余任何目标，不提供残缺代码，抓包内容、敏感网址、数据接口等均已做脱敏解决，严禁用于商业用途和非法用处，否则由此产生的所有结果均与作者无关！ 本文章未经许可禁止转载，禁止任何批改后二次流传，擅自应用本文解说的技术而导致的任何意外，作者均不负责，若有侵权，请在公众号【K哥爬虫】分割作者立刻删除！ 逆向指标指标：某验三代、四代点选类验证码（文字、字序、图标、九宫格）逆向剖析三代主页：aHR0cHM6Ly93d3cuZ2VldGVzdC5jb20vc2hvdw==四代主页：aHR0cHM6Ly9ndDQuZ2VldGVzdC5jb20v通信流程接口相干： 残缺流程： 三代抓包状况通过抓包发现，register-click-official 接口会返回 challenge 和 gt 值，为 get.php 接口的要害申请参数： get.php 会返回 c 和 s，同样前面会用到，这个接口的 w 值与三代无感不同，能够置空： 点击按钮进行验证，会弹出文字点选框，此时抓包到第一个 ajax.php 接口，尽管只返回了验证码类型，没什么要害参数，然而不申请会报错，点击文字进行验证后，抓到第二个 ajax.php 接口，返回验证后果及 validate 参数的值，该值登录接口会用到： 三代逆向剖析w 参数逆向从 ajax.php 接口处跟栈或者间接搜寻特色码 "\u0077" 即可定位到 w 参数值生成的地位，位于 click.3.0.7.js 文件的第 5839 行： p + l = w，要害代码： var l = n[$_CACJJ(716)](), h = X[$_CADAG(338)](ae[$_CACJJ(130)](o), n[$_CADAG(711)]()), p = w[$_CADAG(776)](h)先来看看 l 参数，跟到 n[$_CACJJ(716)] 中去，this[$_CBFJA(711)](e) 为十六位随机字符串，跟到 this[$_CBFJA(711)] 中将算法扣下来即可： ...

大数据时代，各行各业对数据采集的需要日益增多，网络爬虫的使用也更为宽泛，越来越多的人开始学习网络爬虫这项技术，K哥爬虫此前曾经推出不少爬虫进阶、逆向相干文章，为实现从易到难全方位笼罩，特设【0根底学爬虫】专栏，帮忙小白疾速入门爬虫，本期为网页解析库的应用。概述前几期的文章中讲到了网络申请库的应用，咱们曾经可能应用各种库对指标网址发动申请，并获取响应信息。本期咱们会介绍各网页解析库的应用，解说如何解析响应信息，提取所需数据。 XPath的应用XPath 是一门在 XML 文档中查找信息的语言。XPath 可用来在 XML 文档中对元素和属性进行遍历。同样，XPath 也反对HTML文档的解析。 介绍XPath 应用门路表达式来匹配HTML文档中的节点或节点集，门路表达式基于HTML文档树，因而在学习XPath 时须要对网页构造有一个初步理解，对于网页构造这些在之前的文章《网页根本构造》中曾经介绍到了。 装置应用XPath 须要装置Python的第三方库lxml，能够应用命令pip install lxml进行装置 应用下文中，咱们会通过一个示例来理解xpath的用法。 <div id="box"> <p name="test">这是一个测试网页1</p></div><p name="test">这是一个测试网页2</p><div id="city"> <ul> <li id="u1">北京</li> <li id="u2">上海</li> <li id="u3">广州</li> <li id="u4"><a name="sz" href="sz.html" target="_self">深圳</a></li> </ul></div><div class="article"><h3>题目</h3></div><div class="article"><p>内容1</p></div><div class="article"><p>内容2</p></div><div class="article"><p>内容3</p></div>这是一个简略的网页body构造。咱们想要提取页面中的信息，就须要先剖析它的构造，理清构造后，编写门路表达式就会更加不便。在前文对xpath的介绍中咱们理解到xpath是对XML或HTML文档进行解析的性能，但在代码中，示例中的html文本只是一段字符串，所以在应用xpath进行匹配前首先要将字符串转成HTML对象。 from lxml import etreeelement = ''' <div id="box"> <p name="test">这是一个测试网页1</p> </div> <p name="test">这是一个测试网页2</p> <div id="city"> <ul> <li id="u1">北京</li> <li id="u2">上海</li> <li id="u3">广州</li> <li id="u4"><a name="sz" href="sz.html" target="_self">深圳</a></li> </ul> </div> <div class="article"><h3>题目</h3></div> <div class="article"><p>内容1</p></div> <div class="article"><p>内容2</p></div> <div class="article"><p>内容3</p></div>'''html = etree.HTML(element)print(html)#输入：<Element html at 0x1b642114388>将文本转化为html对象后，就能够应用xpath进行匹配了。 门路表达式表达式形容示例示例形容nodename选取此节点下的所有子节点head获取以后head节点下的所有子节点/从根节点选取/html/head从根节点匹配head节点//从任意地位匹配节点//head匹配任意head节点.选取以后节点 ..选取以后节点的父节点//head/..匹配head节点的父节点@选取属性//div[@id="box"]匹配任意id值为box的div标签选取节点以示例代码为例，咱们想要匹配所有的li标签，能够这样实现： html.xpath("//li")#输入 [<Element li at 0x24c09d3e5c8>, <Element li at 0x24c09d3e588>, <Element li at 0x24c09d3e648>, <Element li at 0x24c09d3e688>]谓语获取id属性值为box的div标签信息 ...

作者：Steam & Hao 本文整顿自社区第 7 期会议中 13‘21″ 到 44’11″ 的 Python ORM 的分享，视频见 https://www.bilibili.com/video/BV1s8411N7Cw在做业务开发时，NebulaGraph Python ORM 我的项目作者：Sword Elucidator（下文简称：Hao）发现图数据库在某些场景下有比拟不错的利用实际，而 NebulaGraph 是他感觉不错、较为先进的一款图数据库产品。在 Hao 的开发过程中，他发现：尽管图数据库被利用在多个业务场景中，但对于像是 App 开发之类的 ISO/OSI 高层实际的话，nebula-python 之类的客户端就略显轻便。 而 ORM 作为一个能简化 CURD 操作、免去繁琐的查问语句编写的存在，是被宽广的 Web 开发者所熟知。然而，目前 NebulaGraph 社区有 Golang 版本的 ORM norm、Java ORM NGBatis 和 graph-ocean 唯独没有 Hao 所相熟的 Python 语言的 ORM。 于是，做一个 NebulaGraph Python ORM 的想法便诞生了。 NebulaGraph Python ORMNebula Carina 名字的由来NebulaGraph Python ORM，又名 nebula-carina，尽管目前只是一个雏形，然而曾经基本上具备了一个 ORM 的根底性能。在命名 Python ORM 我的项目之时，Hao 先想到了 nebula-model，见名便知这是一个 ORM，搞了一些封装。但它不够优雅（cool），所以 nebula-carina 便诞生了。 ...

这一篇笔记介绍一下 Django 里应用多数据库操作。 在第二十二篇笔记中只介绍了多数据库的定义、同步命令和应用形式，这一篇笔记作为补充具体介绍如何对 Django 零碎的多个数据库进行针对的建表同步操作。 以下是本篇笔记目录： DATABASES 定义application创立和设置migration 和 migrate 操作几个留神的点1、DATABASES 定义这里还是复用之前的 Django 零碎，这里咱们额定建设两个数据库连贯，之前的 default 还是不变： # hunter/settings.pyDATABASES = { 'default': { ... }, 'user': { 'ENGINE': "django.db.backends.mysql", 'NAME': "db_1", "USER": "root", "PASSWORD": "123456", "HOST": "192.168.1.10", "PORT": 3306, }, 'other': { 'ENGINE': "django.db.backends.mysql", 'NAME': "db_2", "USER": "root", "PASSWORD": "123456", "HOST": "192.168.1.11", "PORT": 3306, },}数据库里的连贯名称别离是 user 和 other。 留神，这里咱们应用的是不同的数据库 DATABASE，别离是 db_1 和 db_2，他们能够在一个地址的 MySQL 里，也能够在不同地址。 2、application创立和设置接下来咱们以 application 为整体来指定 model 对数据库进行操作。 ...

pytorch resnet50 模型转成 onnx 的代码样例，batch_size 是动静可调节的 以下是一个将 PyTorch 的 ResNet50 模型转换为 ONNX 格局的示例代码，并应用可变批处理大小： import torchimport torchvisionimport onnximport onnxruntime# 创立 PyTorch ResNet50 模型实例model = torchvision.models.resnet50(pretrained=True)# 定义一个 PyTorch 张量来模仿输出数据batch_size = 4 # 定义批处理大小input_shape = (batch_size, 3, 224, 224)input_data = torch.randn(input_shape)# 将模型转换为 ONNX 格局output_path = "resnet50.onnx"torch.onnx.export(model, input_data, output_path, input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}})# 应用 ONNX 运行时加载模型session = onnxruntime.InferenceSession(output_path)# 定义一个 ONNX 张量来模仿输出数据new_batch_size = 8 # 定义新的批处理大小new_input_shape = (new_batch_size, 3, 224, 224)new_input_data = torch.randn(new_input_shape)# 在 ONNX 运行时中运行模型outputs = session.run(["output"], {"input": new_input_data.numpy()})留神，在将模型导出为 ONNX 格局时，须要指定 input_names 和 output_names 参数来指定输出和输入张量的名称，以便在 ONNX 运行时中应用。此外，咱们还须要应用 dynamic_axes 参数来指定批处理大小的动静维度。最初，在 ONNX 运行时中应用 session.run() 办法来运行模型。 ...

Django 的单元测试应用了 Python 的规范库：unittest。 在咱们创立的每一个 application 上面都有一个 tests.py 文件，咱们通过继承 django.test.TestCase 编写咱们的单元测试。 本篇笔记会包含单元测试的编写形式，单元测试操作流程，如何复用数据库构造，如何测试接口，如何指定 sqlite 作为咱们的单元测试数据库等 以下是本篇笔记目录： 单元测试示例、应用和介绍单元测试流程介绍单元测试的执行命令复用测试数据库构造判断函数接口的测试标记测试单元测试配置应用 SQLite 作为测试数据库1、单元测试示例、应用和介绍首先咱们编写 blog/tests.py 文件，创立一个简略的单元测试： from django.test import TestCasefrom blog.models import Blogclass BlogCreateTestCase(TestCase): def setUp(self): Blog.objects.create(name="Python", tag_line="this is a tag line") def test_get_blog(self): blog = Blog.objects.get(name="Python") self.assertEqual(blog.name, "Python")以上是一个很简略的单元测试示例，接下来咱们执行这个单元测试： python3 manage.py test blog.tests.BlogCreateTestCase.test_get_blog执行之后能够看到控制台会输入一些信息，如果没有报错，阐明咱们的这个单元测试胜利执行。 在 BlogCreateTestCase 中，这个单元测试继承了 django.test.TestCase，咱们在 setUp() 函数中执行一些操作，这个操作会在执行某个测试，比方 test_get_blog() 前先执行。 咱们执行的是 test_get_blog() 函数，这里的逻辑是先获取一个 blog 示例，而后通过 assertEqual() 函数判断两个输出的值是否相等，如果相等，则单元测试通过，否则会报失败的谬误。 2、单元测试流程介绍首先咱们看一下 settings.py 中的数据库定义： # hunter/settings.pyDATABASES = { 'default': { 'ENGINE': "django.db.backends.mysql", 'NAME': "func_db", "USER": "root", "PASSWORD": "123456", "HOST": "192.168.1.9", "PORT": 3306, },}当咱们执行上面这个命令之后： ...

这一篇介绍一下 Django 的后盾界面应用。 Django 自带了一套后盾治理界面，可用于咱们间接操作数据库数据，本篇笔记目录如下： 创立后盾账号以及登录操作注册后盾显示的数据表列表字段的显示操作字段值的批改操作列表页的执行操作1、创立后盾账号以及登录操作首先咱们须要创立一个能够拜访后盾的账号，以下命令在零碎的根目录下进行： python3 manage.py createsuperuser而后他会提醒咱们输出账号的名称，邮箱以及两遍明码用于确认。 Username (leave blank to use 'hunter'): adminEmail address: xxxx@qq.comPassword: Password (again): 在这个过程中，如果咱们输出的明码少于8位或者过于简略，他会给咱们提醒说明码过于简略等，能够设置简单点的，也能够间接确认。 创立好账号密码后，运行咱们的零碎： python3 manage.py runserver 0:9898而后就能够在浏览器里拜访咱们的后盾零碎了： http://localhost:9898/admin在上面的图里输出账号密码就能够进入零碎了： 这里须要留神一点的是，如果你是依照咱们的笔记一路操作过去，在后面咱们的用户登录限度里可能限度了 login 和 register 接口才容许不登录，那么咱们在相应的验证中间件里能够简略做一下操作： class AuthMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): path = request.path # url 门路为 /users/register 和 /users/login 的接口不须要进行判断验证 if path not in [ "/users/register", "/users/login", ]: if path.startswith("/admin"): return self.get_response(request) session = request.session if not session.get("username"): return JsonResponse({"code": -1, "msg": "not login"}, status=401) response = self.get_response(request) return response这里咱们将 /admin 结尾的接口都设置为了不须要登录验证。 ...

torchvision.transforms.Resize() 是 PyTorch 中 torchvision 库中的一个数据预处理类，用于将 PIL.Image 或者 ndarray 转换成指定大小的图像。 这个类的主要参数如下： size：指定输入图像的大小，能够是一个整数（示意将图像的较小边缩放到指定的大小，较大边按比例缩放），也能够是一个二元组 (height, width)（示意将图像缩放到指定的高度和宽度）。例如，size=224 将图像的较小边缩放到 224，size=(224, 224) 将图像缩放到高度和宽度均为 224。interpolation：指定图像缩放时采纳的插值办法。能够抉择的插值办法包含：PIL.Image.NEAREST（最近邻插值）、PIL.Image.BILINEAR（双线性插值，也是默认的插值办法）、PIL.Image.BICUBIC（三次样条插值）等。例如，interpolation=PIL.Image.NEAREST 将应用最近邻插值进行缩放。在 torchvision.transforms.Resize() 中还有一些其余的参数，这些参数通常用作外部的辅助参数，不须要用户自行设置。 上面是一个应用 torchvision.transforms.Resize() 进行图像预处理的例子： from torchvision import transformsfrom PIL import Image# 创立 Resize 实例resize = transforms.Resize((224, 224))# 读取图像img = Image.open('test.jpg')# 将图像缩放到指定大小resized_img = resize(img)Q:torchvision 的 transforms.Resize 的interpolation参数默认是什么？A:torchvision.transforms.Resize 的 interpolation 参数默认为 bilinear。 Q:最近邻插值、双线性插值、三次样条插值有什么区别？A:最近邻插值、双线性插值、三次样条插值都是罕用的图像处理中的插值办法，它们的次要区别如下： 最近邻插值最近邻插值是一种简略的插值办法，它的原理是将待插值的像素点四周的已知像素点中离它最近的像素点的值作为插值后果。最近邻插值的长处是计算速度快，毛病是解决后的图像品质较低，可能会呈现显著的锯齿状。最近邻插值实用于图像的放大。 双线性插值双线性插值是一种比最近邻插值更高级的插值办法。它的原理是先依据待插值像素点的地位计算出该点四周的四个已知像素点，而后依据它们的值按肯定的权重进行插值计算。双线性插值的长处是解决后的图像品质较高，毛病是计算速度较慢。双线性插值实用于图像的放大和放大。 三次样条插值三次样条插值是一种比双线性插值更高级的插值办法。它的原理是通过已知的离散数据点拟合出一条三次样条曲线，在待插值的像素点处计算出该曲线的函数值作为插值后果。三次样条插值的长处是解决后的图像品质最高，毛病是计算速度最慢。三次样条插值实用于图像的放大，但对于放大来说成果不如双线性插值。

测试图片 图片的大小为 94KB，分辨率为 959x959 from PIL import Imageimport numpy as npimport osimport timefrom torchvision import transformspreprocess = transforms.Compose([ transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])img_path = 'resources/images/std.jpg' # 图片文件夹门路_image = np.array(Image.open(img_path))s = time.time()for _ in range(10000): image = Image.fromarray(_image) preprocess(image)e = time.time()print(e-s)

import avinput_file = 'DaoMengKongJian-720P.mp4'input_file = 'DaoMengKongJian-480P.mp4'# 初始化FFmpeg上下文# av.avdevice_register_all()# av.logging.set_level(av.logging.INFO)count = 0with av.open(input_file, metadata_encoding='utf-8', metadata_errors='ignore') as container: video_stream = container.streams.video[0] video_stream.thread_type = 'AUTO' average_fps: int = round(video_stream.average_rate) interval = 1 for index, frame in enumerate(container.decode(video_stream)): if index % (average_fps) == 0: frame.to_ndarray(format='rgb24') count += 1print('count is', count)pyav 拆帧速度测试 平台视频分辨率耗时（秒）E5-26901280x720115E5-2690640x36063 此时，利用了 8 个 cpu core（自动挡，pyav 主动设置线程数目） 接下来看看，手动设置不同线程数，拆帧的效率 参考文章:pyav 指定线程数目import avimport timeinput_file = 'DaoMengKongJian-360P.mp4'for thread_count in [1, 2, 3, 4, 5]: count = 0 s = time.time() with av.open(input_file, metadata_encoding='utf-8', metadata_errors='ignore') as container: video_stream = container.streams.video[0] # video_stream.thread_type = 'AUTO' video_stream.thread_count = thread_count average_fps: int = round(video_stream.average_rate) interval = 1 for index, frame in enumerate(container.decode(video_stream)): if index % (average_fps) == 0: frame.to_ndarray(format='rgb24') count += 1 e = time.time() print(f'thread count is {thread_count}, pay time is {e-s}')测试后果 ...

首先写一个 python 代码，看看 PIL 库能不能利用多个 CPU 外围 ndarray_2_image.py from PIL import Imageimport numpy as npimport osimport timeimg_path = 'resources/images/std.jpg' # 图片文件夹门路_image = np.array(Image.open(img_path))s=time.time()for _ in range(10000000): image = Image.fromarray(_image)e=time.time()print(e-s)能够从 htop 中看到，PIL 库并不能利用多核 CPU

这一篇笔记介绍一下如何在 Django 应用分页。 Django 自带一个分页的模块： from django.core.paginator import Paginator主要用途是列表数据的切割，比如说有 3000 条用户数据，前端须要一个列表接口用于展现这些数据，然而一次性展示这么多数据不适合，所以打算用分页的形式来操作。 比方一页20条数据，前端通过按钮管制 page_num 和 size 参数用于后端返回数据。 以下是本篇笔记目录： 间接分页操作Paginator 分页操作Paginator 其余函数Page 的其余操作1、间接分页操作在介绍 Django 的分页模块前，咱们个别如果要分页的话会如何操作呢，这里咱们定义 page_num 参数为 页数，size 参数为一页返回的数据量。 假如有这样一个长度为 20 的列表： data_list = list(range(20))咱们想要实现每页三条数据，也就是 size = 3，咱们依据 page_num 和 size 参数能够这样操作： target_list = data_list[(page_num - 1) * size: page_num * size]因为页数是从 1 开始的，而列表的下标是从 0 开始的，所以这里是 page_num - 1。 以这个为例，咱们接下来介绍一下如何应用 Django 的模块来操作分页。 2、Paginator 分页操作Paginator 不仅能够用于 model 的 queryset 数据，也能够用于咱们下面这种列表数据 data_list，咱们这里应用 data_list 作为示例。 ...

奢侈贝叶斯分类器[toc] 介绍之前说一个悲伤的故事：因为是本人重新学习机器学习算法，学校期间好多无关机器学习算法的课程都没怎么解释这个算法，而且老师上课一言难尽！而后我加入研究生复试，被问到这个算法过后人都傻了，据说过然而本人真的没有认真去理解啊！害！被本人菜的一言难尽 数学实践先验概率依据以往教训和剖析失去的概率 条件概率（后验概率）在事件B产生的条件下A在产生的概率 $$P(A|B)=\frac{P(AB)}{p(A)}$$ 奢侈贝叶斯定理直观了解：咱们假如B是咱们的特色标签A是咱们的分类标签。那么公式直观上的了解就是：咱们在具备B这么多的特色之后一个样本属于A的概率有多大$$P(A|B)=\frac{P(B_1|A)P(B_2|A)P(B_3|A)...P(B_n|A)P(A)}{P(B)}\\\text{公式中}P(B_i|A)\text{代表在训练集中}B_i特色下属于A的概率$$ 此时问题来了：如果咱们的特色是非数字数据比如说：绿色、蓝色等那么咱们很容易就能够计算失去概率的计算，然而如果是具体数字呢？那么应该怎么计算呢？高斯奢侈贝叶斯高斯分布：正态分布$$P(A|B)=\frac{1}{\sqrt{2\pi\sigma_{B}^{2}}}e^{-\frac{(A-\mu)^2}{2\sigma_{B}^{2}}}\\\mu:均值 \sigma:方差$$ 正态分布判断奢侈贝叶斯咱们先看对于他的解释：奢侈贝叶斯是一种建分类器的简略办法。该分类器模型会给问题实例调配用特征值示意的类标签，类标签取自无限汇合。它不是训练这种分类器的繁多算法，而是一系列基于雷同原理的算法：所有奢侈贝叶斯分类器都假设样本每个特色与其余特色都不相干。 https://zh.wikipedia.org/wiki/%E6%9C%B4%E7%B4%A0%E8%B4%9D%E5%...从定义上看起来感觉很麻烦，其实奢侈贝叶斯算法的原理非常简略。咱们以如下例子为例： 假如训练集如下 性别身高（英尺）体重（磅）脚的尺寸（英寸）男618012男5.92 (5'11")19011男5.58 (5'7")17012男5.92 (5'11")16510女51006女5.5 (5'6")1508女5.42 (5'5")1307女5.75 (5'9")1509咱们对训练集计算失去： 性别均值（身高）方差（体重）均值（体重）方差（体重）均值（脚的尺寸）方差（脚的尺寸）男5.8553.5033e-02176.251.2292e+0211.259.1667e-01女5.41759.7225e-02132.55.5833e+027.51.6667e+00那么在给定如下样本进行判断： 身高：6 体重：130 脚的尺寸：8如何计算呢？很简略！！！比如说咱们计算\( P(身高|男性) \)咱们只须要将身高6代入到咱们的高斯贝叶斯公式外面就能够失去咱们的概率。咱们顺次计算体重、脚的尺寸就能够失去一系列的概率，而后咱们代入公式： $$P(男性)=\frac{P(男性)P(身高|男性)....}{P(A)}\\P(A)=P(男)*P(身高|男性)....+P(女性)*P(身高|女性)....\\P(男)=0.5=P(女)$$ 而后判断男和女的概率大小进而判断是男性还是女性！

「Python与地震工程」单自由度体系求解之通用微分方程数值解法（基于scipy.integrate.odeint）背景图：2008年5月汶川地震 原理单自由度体系剖析是构造动力学和地震工程学习的启蒙常识，也是简单构造能源剖析的基石，具备重要的作用和钻研价值。本文将探讨如何用Python的科学计算模块来实现单自由度体系的能源响应分析。 经典的弹性有阻尼单自由度体系在任意激励P(t)作用下的静止方程可写为 $$m\ddot{x}\left( t \right) + c\dot{x}\left( t \right) + kx\left( t \right) = P\left( t \right)$$ 或 $$\ddot{x}\left( t \right) + 2 \zeta \omega_0 \dot{x}\left( t \right) + \omega_0^2 x\left( t \right) = p\left( t \right)$$ 求解此静止方程的经典办法有杜哈梅积分法、Newmark-法、核心差分法等。借助Python求解此方程最快捷（编程者的工作量小，并非最疾速）的办法就是将方程降阶为状态空间模式调用scipy.integrate.odeint()函数。须要留神的是，对于地震激励，须要把离散的地震波“包装”成一个连续函数能力被odeint辨认。 上述方程的状态空间模式为 $$\frac{{\rm{d}}}{{{\rm{d}}t}}\left( {\begin{array}{c} {{y_1}}\\ {{y_2}} \end{array}} \right) = \left( {\begin{array}{c} {{y_2}}\\ {p\left( t \right) - 2\zeta \omega_0 {y_2} - {\omega_0^2}{y_1}} \end{array}} \right)$$ 程序代码采纳odeint()进行单自由度体系共振简谐激励和地震激励作用下响应求解的残缺代码为 import scipy as spfrom scipy.integrate import odeintimport matplotlib.pyplot as pltdef pd(tn,*p_args): """ 等工夫距离离散信号a对应的间断化函数（线性插值办法实现） """ dt = p_args[0] # 离散信号工夫距离 a = p_args[1] # 离散信号数据 ind = int(sp.floor(tn/dt)) if (ind+1)>=len(a): return 0.0 else: al = a[ind]; ar = a[ind + 1]; k = (ar - al) / dt return al+k*(tn-ind*dt)def solve_sdof_resonance(omg = 1.0*2.0*sp.pi, zeta = 0.02): y0 = sp.asarray([0.0,0.0]) # 初始条件 p = lambda t: sp.sin(omg*t) # 共振简谐激励 f_sdof = lambda y,t: sp.asarray([ y[1], -p(t)-2.0*zeta*omg*y[1]-omg*omg*y[0] ]) t = sp.linspace(0, 30, 1001) y = odeint(f_sdof, y0, t) # 绘图: plt.figure("Resonance Response",(12,4)) plt.plot(t,y[:,0]) plt.grid(True) plt.show()def draw_response(title, ta, a, t, u): plt.figure(title,(12,6)) plt.subplot(2,1,1) plt.plot(ta,a,label=r"输出地震波加速度时程") plt.grid(True) plt.legend() plt.xlim(0,t[-1]) plt.subplot(2,1,2) plt.plot(t,u,label=r"SDOF体系位移响应时程") plt.xlabel(r"工夫 (s)") plt.grid(True) plt.legend() plt.xlim(0,t[-1]) plt.show()def solve_sdof_eqwave_odeint(omg0 = 1.0*2.0*sp.pi, zeta = 0.05): y0 = sp.asarray([0.0,0.0]) # 初始条件 acc0 = sp.loadtxt("EQ-S-3.txt") # 读取地震波 dt = 0.005 # 工夫距离 n = len(acc0) t0 = sp.linspace(0.0, dt*(n-1), n) p = lambda t: pd(t, dt, acc0) # 线性间断化地震激励 f_sdof = lambda y,t: sp.asarray([ y[1], -p(t)-2.0*zeta*omg0*y[1]-omg0*omg0*y[0] ]) # 显示地震完结后一段时间内的自在振动衰减状况 ne = round(n*1.2) t = sp.linspace(0.0,dt*(ne-1),ne) y = odeint(f_sdof, y0, t) draw_response("Seismic Response -- scipy.integrate.odeint", t0, acc0, t, y[:,0]) # 绘图if __name__ == '__main__': solve_sdof_resonance() solve_sdof_eqwave()文中所用地震波下载：EQ-S-3.txt后果 ...

深刻了解 Python 虚拟机：字典（dict）的优化在后面的文章当中咱们探讨的是 python3 当中晚期的内嵌数据结构字典的实现，在本篇文章当中次要介绍在后续对于字典的内存优化。 字典优化在后面的文章当中咱们介绍的字典的数据结构次要如下所示： typedef struct { PyObject_HEAD Py_ssize_t ma_used; PyDictKeysObject *ma_keys; PyObject **ma_values;} PyDictObject;struct _dictkeysobject { Py_ssize_t dk_refcnt; Py_ssize_t dk_size; dict_lookup_func dk_lookup; Py_ssize_t dk_usable; PyDictKeyEntry dk_entries[1];};typedef struct { /* Cached hash code of me_key. */ Py_hash_t me_hash; PyObject *me_key; PyObject *me_value; /* This field is only meaningful for combined tables */} PyDictKeyEntry;用图示的形式示意如下图所示： 所有的键值对都存储在 dk_entries 数组当中，比方对于 "Hello" "World" 这个键值对存储过程如下所示，如果 "Hello" 的哈希值等于 8 ，那么计算出来对象在 dk_entries 数组当中的下标位 0 。 ...

这一节介绍一下如何在 Django 中应用 redis 做缓存操作。 在 Django 中能够有很多种形式做缓存，比方数据库，比方服务器文件，或者内存，这里介绍用的比拟多的应用 redis 作为缓存。 这篇笔记次要内容如下： 依赖装置settings.py 配置缓存操作用法缓存版本控制cache 用作 session backend革除 redis 里全副数据批量查问与删除其中，redis 的装置咱们在 celery 系列笔记的第一篇曾经介绍过了，能够间接应用 docker 来操作，这里不做赘述了。 1、依赖装置Django 连贯 redis 这里用到一个模块，django-redis，接下来咱们用 pip 来装置： pip3 install django-redis2、settings.py 配置而后在 settings.py 里设置 CACHES 参数即可应用： # hunter/settings.pyCACHES = { "default": { "BACKEND": "django_redis.cache.RedisCache", "LOCATION": "redis://:123456@127.0.0.1:6380/2", "OPTIONS": { "CLIENT_CLASS": "django_redis.client.DefaultClient", } }}在这里 redis 的端口我设置成了 6380，明码我设为了 123456。 如果没有明码，LOCATION 的参数为 redis://127.0.0.1:6380/2 当然，如果明码也能够和 url 拆散配置，咱们能够放到 OPTIONS 参数里： # hunter/settings.pyCACHES = { "default": { "BACKEND": "django_redis.cache.RedisCache", "LOCATION": "redis://127.0.0.1:6380/2", "OPTIONS": { "CLIENT_CLASS": "django_redis.client.DefaultClient", "PASSWORD": "123456", } }}3、缓存操作用法在下面的配置都设置好之后，能够正式开始咱们的缓存操作了。 ...

什么是元编程Python元编程是指在运行时对Python代码进行操作的技术，它能够动静地生成、批改和执行代码，从而实现一些高级的编程技巧。Python的元编程包含元类、装璜器、动静属性和动静导入等技术，这些技术都能够帮忙咱们更好地了解和把握Python语言的个性和机制。元编程在一些场景下十分有用，比方实现ORM框架、实现特定畛域的DSL、动静批改类的行为等。把握好Python元编程技术能够进步咱们的编程能力和代码品质。 想要搞定元编程，必须要了解和把握Python中的元编程技术： 反射：Python提供了许多内置函数和模块，如getattr()、setattr()、hasattr()、inspect等，能够在运行时动静地获取对象的属性和办法信息，从而实现反射。装璜器：装璜器是Python中一种常见的元编程技术，它能够动静地批改函数或类的行为，而无需批改它们的源代码。装璜器能够用于函数的参数查看、性能剖析、缓存、日志记录等方面。类装璜器：类装璜器是一种对类进行润饰的装璜器，能够在类定义时动静地批改类的行为。类装璜器能够用于实现单例模式、代理模式、混入等方面。元类：元类是Python中一种高级的元编程技术，它能够动静地创立类，而不是实例。元类能够用于管制类的创立行为、增加类的属性和办法、实现ORM框架等方面。在理论开发中，元编程能够用于实现一些高级的技术，如ORM框架、RPC框架、动静路由等。把握Python的元编程技术，能够让开发者更好地了解Python的语言个性，进步代码的可读性和可维护性。元编程利用场景Python元编程的理论利用场景十分宽泛，例如上面几个典型的场景： 装璜器和元类 装璜器和元类是Python中常见的元编程技巧，通过这两种技术能够实现对类和函数进行动静的批改和扩大。比方，能够应用装璜器来加强函数的性能，也能够应用元类来动静生成类。动静生成代码 Python中的eval和exec函数能够用于动静地生成代码并执行，这是元编程的一种典型利用场景。比方，能够依据用户的输出动静地生成SQL语句或其余代码。插件化架构 在插件化架构中，程序能够在运行时动静地加载和卸载插件。Python中的模块和包机制能够用于实现插件化架构，而元编程技巧则能够用于实现动静的插件加载和卸载。协程和异步编程 在协程和异步编程中，须要对代码进行动静的批改和重构，以便实现高效的并发解决。Python中的asyncio和curio等库都是基于元编程技巧实现的。基于属性的编程 Python中的属性能够用于动静地拜访对象的属性，这是元编程的一种典型利用场景。比方，能够应用属性来实现动静的类型转换、数据校验和计算属性等性能。Python元编程的利用场景十分宽泛，能够用于实现各种动静的、高级的编程性能。综合实战应用元类来实现一个简略的ORM框架class ModelMetaClass(type):    def __new__(cls, name, bases, attrs):        if name == 'Model':            return super().__new__(cls, name, bases, attrs)        table_name = attrs.get('table_name', name.lower())        mappings = {}        fields = []        for k, v in attrs.items():            if isinstance(v, Field):                mappings[k] = v                fields.append(k)        for k in mappings.keys():            attrs.pop(k)        attrs['__table__'] = table_name        attrs['__mappings__'] = mappings        attrs['__fields__'] = fields        return super().__new__(cls, name, bases, attrs)class Model(metaclass=ModelMetaClass):    def __init__(self, **kwargs):        for k, v in kwargs.items():            setattr(self, k, v)    def save(self):        fields = []        values = []        for k, v in self.__mappings__.items():            fields.append(v.db_column or k)            values.append(getattr(self, k, None))        sql = 'INSERT INTO {} ({}) VALUES ({})'.format(            self.__table__,            ', '.join(fields),            ', '.join(['%s'] * len(values))        )        print('SQL:', sql)        print('VALUES:', values)class Field:    def __init__(self, db_column=None):        self.db_column = db_columnclass StringField(Field):    def __init__(self, db_column=None):        super().__init__(db_column)class IntegerField(Field):    def __init__(self, db_column=None):        super().__init__(db_column)class User(Model):    name = StringField(db_column='user_name')    age = IntegerField(db_column='user_age')    email = StringField(db_column='user_email')if __name__ == '__main__':    user = User(name='Tantianran', age=31, email='ttr@bbgops.com')    user.save()在上述代码中，应用元类ModelMetaClass动静地创立类，并依据类属性定义生成相应的数据库表构造和SQL语句。具体地，元类会通过类属性__mappings__、__fields__和__table__来生成相应的ORM映射关系和SQL语句。应用这种形式，咱们能够在不写反复代码的状况下，轻松地创立一个简略的ORM框架，并实现对象到关系数据库的映射。 应用元类实现单例模式class Singleton(type):    _instances = {}    def __call__(cls, *args, **kwargs):        if cls not in cls._instances:            cls._instances[cls] = super().__call__(*args, **kwargs)        return cls._instances[cls]class MyClass(metaclass=Singleton):    pass在这个示例中，咱们定义了一个元类 Singleton，它保护了一个 _instances 字典来保留曾经创立的实例。在元类的 call 办法中，咱们查看以后类是否曾经存在于 _instances 字典中，如果不存在，就应用 super().call 办法创立一个新的实例，并将其保留到 _instances 字典中，最初返回该实例。这样，无论咱们创立多少个 MyClass 类的实例，都只会失去同一个实例。 应用元类实现装璜器class my_decorator(object):    def __init__(self, func):        self.func = func    def __call__(self, *args, **kwargs):        print("Before the function is called.")        self.func(*args, **kwargs)        print("After the function is called.")class Myclass(object):    @my_decorator    def my_method(self):        print("Hello world.")obj = Myclass()obj.my_method()在这个示例中，咱们定义了一个装璜器类 my_decorator，它承受一个函数作为参数，并在函数调用前后输入一些信息。在类 Myclass 的 my_method 办法上应用 @my_decorator 装璜器，就相当于将 my_method 办法替换为一个新的办法，该新办法会在原来的办法前后输入信息。 应用元类实现办法缓存class memoize(object):    def __init__(self, func):        self.func = func        self.cache = {}    def __call__(self, *args):        if args in self.cache:            return self.cache[args]        else:            value = self.func(*args)            self.cache[args] = value            return value@memoizedef fibonacci(n):    if n <= 1:        return n    else:        return fibonacci(n-1) + fibonacci(n-2)在这个示例中，咱们定义了一个装璜器类 memoize，它承受一个函数作为参数，并应用一个字典来保留函数的输出和输入。在 call 办法中，咱们首先查看函数的输出是否曾经在字典中，如果是，则间接返回字典中对应的输入；否则，就调用原来的函数计算输入，并将输出和输入保留到字典中，最初返回输入。这样，如果咱们屡次调用带有 @memoize 装璜器的函数，对于雷同的输出，就只会计算一次，从而大大提高了性能。 应用元编程技术动静生成代码class DynamicClass(type):    def __new__(mcs, name, bases, attrs):        # 增加属性        attrs['author'] = 'John Doe'        # 增加办法        def hello(self):            return f'Hello, I am {self.name}'        attrs['hello'] = hello        return super().__new__(mcs, name, bases, attrs)# 应用元类创立类MyClass = DynamicClass('MyClass', (), {'name': 'Alice'})# 拜访属性和办法print(MyClass.name) # 输入：Aliceprint(MyClass.author) # 输入：John Doeobj = MyClass()print(obj.hello()) # 输入：Hello, I am Alice在下面的示例中，应用了元类DynamicClass来动态创建类，__new__办法在类创立时被调用，用来动静增加属性和办法。在这个例子中，咱们通过__new__办法向MyClass类中增加了一个author属性和一个hello办法。最初创立了MyClass类的一个实例，并调用了它的hello办法。 本文转载于WX公众号：不背锅运维（喜爱的盆友关注咱们）：https://mp.weixin.qq.com/s/t5vpBGAxeLoAqI_yM8WKjw

这一篇笔记将介绍 session 相干的内容，包含如何在零碎中应用 session，以及利用 session 实现登录认证的性能。 这篇笔记将分为以下几个内容： session 的应用流程session 的配置和相干办法users 模块的筹备session 验证的的实现Session 表介绍登录验证的几种实现模式1、session 的应用流程cookie 和 session 的基本概念这里不做赘述，这里简略讲一下在 Django 中如何应用自定义的模块来实现登录、登出以及仅容许登录用户拜访某些接口的操作。 Django 有一套自带的 auth 验证模块，包含用户以及用户及相应的权限的表和操作，咱们这里没有用，而是独自自定义一个 user 模块以及相应的性能函数用来实现用户的注册、登录和登出性能。 session 在这里的应用流程大抵如下： 1、通过 login 接口，验证胜利后，将某些信息写入 session，能够是 user_id，或者是某个你自定义的特定的字段，反正是后续须要进行验证是否登录胜利的数据 2、在拜访特定的、须要登录才可查看的接口前，先查看前端返回的数据中是否蕴含咱们在上一步中写入的数据来确保用户是处于登录状态，如果是，则容许持续拜访，否则返回未登录的信息，提醒用户须要先进行登录操作 3、通过 logout 接口，将用户在 login 接口里写入的登录信息抹除，返回登出胜利信息 在 Django 中，零碎主动为咱们筹备好了 session 的所有相干的操作，咱们只须要在后续的登录操作中往里面写入咱们须要验证的数据即可。 Django 这部分为咱们筹备好的 session 操作也是通过中间件的模式存在的，是 settings.py 的 MIDDLEWARE 的 'django.contrib.sessions.middleware.SessionMiddleware' 如果不指定其余存储形式，session 的数据默认存在于咱们的后端表中，这个咱们在第一次执行 migrate 的时候曾经主动为咱们创立了该表，名为 django_session。 表数据的操作和查看咱们在前面再具体介绍。 2、session 的配置和相干办法后面曾经介绍了 session 的操作流程，这里咱们介绍一下 session 的相干配置和办法。 session 配置以下设置都在 settings.py 中设置，事实上，这些 session 的默认配置就差不多能够应用，后续有非凡需要咱们能够再来查看，这里只介绍几个我感觉不便咱们应用的。 ...

import csvfrom py2neo import Graph, Node, Relationship, NodeMatcherdef aa(): g = Graph('http://localhost:7474', user='neo4j', password='HTL123123',name='neo4j') # 连贯neo4j，将'xxx'别离改为你的用户名和明码 # g.delete_all() # 革除neo4j中原有的结点等所有信息 with open('C:/Users/h1531/Desktop/tea.csv', 'r', encoding='gbk') as f: reader = csv.reader(f) for item in reader: # if reader.line_num==1: # continue print("以后行数：", reader.line_num, "以后内容：", item) start_node = Node("供应商名称", name=item[0]) end_node = Node("属性值", value=item[2]) relation = Relationship(start_node, item[1], end_node) g.merge(start_node, "供应商名称", "name") g.merge(end_node, "属性值", "value") g.merge(relation, "产品总数量", "属性")if __name__ == '__main__': aa()

这一篇笔记介绍 Django 的全局异样解决。 当咱们在解决一个 request 申请时，会尽可能的对接口数据的格局，外部调用的函数做一些异样解决，但可能还是会有一些意想不到的漏网之鱼，造成程序的异样导致不能失常运行，甚至会间接报给前端一个谬误。 为了防止这种状况的产生，令咱们的后端服务看起来是失常的，就算有报错也能够很体面的给前端一个提醒，以及后端做一些谬误日志的记录，这里咱们引入全局异样的解决。 这里咱们会用 Django 的中间件和日志的解决来实现，在本系列文章的第二十九篇和第三十篇，能够先相熟下这两局部性能的应用。 在介绍中间件的章节，咱们介绍了 __call__() 和 process_view() 函数，其实还有一个 process_exception() 函数，这个函数就是当咱们的申请在产生不可预知的报错的状况下，会主动调用的函数。 咱们来看这样一个解决的示例： # hunter/middlewares/exception_middleware.pyimport tracebackfrom django.http import JsonResponseimport logginglogger = logging.getLogger(__name__)class ExceptionMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): response = self.get_response(request) return response def process_exception(self, request, exception): traceback_info = traceback.format_exc() logger.info(f"request_path: {request.path}, traceback_info: {traceback_info}") return JsonResponse({"code": -1, "msg": "error"}, status=500)在这里，咱们应用 traceback.format_exc() 函数获取到 exception 的报错信息，而后通过 logger 日志打印输出。 日志信息 这里咱们次要输入两个信息，一个是接口申请的门路，request.path，一个是报错信息 traceback_info，当然，这里咱们还能够记录更多的信息，比方申请的用户信息，申请的参数等。 记录之后，后端就能够通过日志的具体信息去查看到底是哪里出了问题。 ...

我国目前并未出台专门针对网络爬虫技术的法律标准，但在司法实际中，相干裁决已不足为奇，K哥特设了“K哥爬虫普法”专栏，本栏目通过对实在案例的剖析，旨在进步宽广爬虫工程师的法律意识，通晓如何非法合规利用爬虫技术，警钟长鸣，做一个违法、护法、有准则的技术人员。案情介绍被告人：北京百度网讯科技有限公司（以下简称百度公司），百度 上诉人：上海汉涛信息征询有限公司（以下简称汉涛公司），公众点评 汉涛公司诉称，“百度地图”与“百度晓得”未经受权，大量复制“公众点评网”的用户点评等信息，与“百度地图”具备单干关系的上海杰图软件技术公司经营的“城市吧”网站因应用了“百度地图”又扩充了侵权影响范畴、造成公司重大损失。因而，“公众点评网”的经营方上海汉涛信息征询有限公司将北京百度网讯有限公司及上海杰图软件技术公司以不正当竞争为由，诉至法院，要求原告进行侵权、登载布告打消不良影响，并抵偿经济损失 9000 万元和为禁止侵权行为收入的 45 万余元。 该案中，北京百度网讯科技有限公司（“百度公司”）应用技术手段在公众点评等 APP 上抓取了商户的根本信息及点评信息，用户应用其经营的百度地图 APP 查问地位时，无需跳转至公众点评界面，就可间接在百度地图界面获取商户的根本信息和点评信息。汉涛公司以百度公司等相干主体形成不正当竞争向法院起诉。 法院观点单方是否存在竞争关系？ 法院认为，尽管汉涛公司与百度公司所经营的APP属于不同行业、不同畛域且有着不同的经营模式，然而单方的行为在抢夺雷同的网络用户群体，两者在为用户提供商户信息和点评信息的服务模式上近乎统一，存在竞争关系。 从法院观点来看，在竞争关系的认定上，将不限于对同行业相干主体竞争关系的认定，还将抢夺雷同网络用户群体的相干主体认定为具备竞争关系。这对许多以“流量为王”的企业十分具备警示意义。 汉涛公司是否有可诉诸法律爱护的合法权益？ 法院认为，汉涛公司为了积攒点评信息付出了巨额老本。点评信息是汉涛公司的外围竞争资源之一，为汉涛公司带来竞争劣势。 在法院考量汉涛公司是否具备可诉诸法律爱护的合法权益上，关注了汉涛公司获取涉案数据信息的老本，以及涉案数据信息为汉涛公司带来的效益。 百度公司是否存在不正当的行为？ 法院认为，在百度公司靠本身用户无奈获取足够点评信息的状况下，通过技术手段，从公众点评等网站获取点评信息，用于空虚百度地图，百度公司的这种行为违反了公认的商业道德和诚实信用准则，具备不正当性。 在对百度公司行为不正当性进行认定上，法院认为百度公司这种相似于“搭便车”、“劳而不获”的行为违反了商业道德和诚实信用准则。 汉涛公司是否因百度公司的行为蒙受理论侵害？ 法院认为，用户在应用百度地图查阅到商户信息和点评信息后已无需跳转至公众点评查看更多信息，百度地图曾经对公众点评造成实质性代替，对汉涛公司造成了实质性侵害。 对于互联网企业而言，用户流量的多少，在某种程度上决定了企业在市场上的竞争力和企业价值。与认定是否具备竞争关系相似，法院在认定汉涛公司是否蒙受理论侵害时，关注到百度公司“截取”了汉涛公司应有的网络用户浏览量，对公众点评造成实质性代替。 裁决状况法院一审判决后果： 百度公司于裁决失效之日起立刻进行以不正当的形式应用汉涛公司经营的公众点评网的点评信息；百度公司于裁决失效之日起十日内抵偿汉涛公司经济损失 300 万元及为禁止不正当竞争行为所领取的正当费用 23 万元；驳回汉涛公司的其余诉讼请求，一审案件受理费 494,067 元，由汉涛公司累赘 238,207 元，由百度公司累赘 255,860 元。法院二审裁决后果： 维持原判，案件受理费人民币 32,640 元，由上诉人北京百度网讯科技有限公司累赘。裁决文书https://wenshu.court.gov.cn/website/wenshu/181107ANFZ0BXSK4/i... 案例剖析本案中汉涛公司认为百度的行为是零老本获取己方领有“著作权的内容”，且因百度的行为造成了理论损失，形成不正当竞争。而百度方代理律师认为，百度是一家搜寻性能公司，与公众点评网之间没有造成竞争关系，所做的只是搜寻相干信息，筛选后进行出现，在这个过程中采集到了公众点评网中的局部信息，不存在不正当行为，而且公众点评网的Robots协定是面向百度凋谢的，百度采集的信息是Robots协定容许的。 在二审中上诉人汉涛公司的辩称中有一条须要咱们留神：百度公司通过搜索引擎抓取涉案信息并不违反Robots协定，但并不意味着百度公司能够任意应用该些信息，若不对应用别人网站信息的形式进行正当管制，将导致百度公司以极低的老本夺取汉涛公司的经营成绩。 咱们晓得Robots协定是一种约定俗成的小人协定，并不具备法律效应。即便公众点评网中Robots协定是面向百度的，但百度也不能够用采集到的信息对公众点评网造成影响，百度的行为仍旧属于不正当竞争行为。这种状况也存在于很多企业之中，很多企业都会采集一些信息聚合平台上的公开或者半公开的信息，而后将信息利用于本人的业务场景中，企业认为本人采集的是公开信息，并不违反法律。然而却没有思考业务是否与信息聚合平台间存在竞争关系，没有考量对爬虫信息的应用范畴和形式以及对信息聚合平台造成的影响，这也是很多集体爬虫开发者在爬虫开发时没有去思考的点。 目前数据抓取行为所涉的竞争关系认定规范比拟含糊，目前对于此类案件的裁决次要有三要件： 第一，行为确属法律未特地明确； 第二，其余经营者的合法权益确因该竞争行为而受到了理论侵害； 第三，该种竞争行为确因违反诚实信用准则和公认的商业道德而具备不正当性或可责性。 该案中百度的行为也的确合乎这三要件，同样作为内容提供商，将公众点评网中的信息展现在本人的产品中，会导致公众点评的流量散失，是不正当的行为。 随着数据在古代社会中的重要性日益减少，数据权属问题也越来越重要，企业乃至国家对于数据的器重水平一直加深。《中共中央 国务院对于构建更加欠缺的因素市场化配置体制机制的意见》中明确将数据作为一种生产因素，与传统的生产因素如土地、劳动力、资本、技术等并列。因而，爬虫开发中，咱们不仅须要关注数据的起源是否非法，也要思考数据的应用是否切当。

大数据时代，各行各业对数据采集的需要日益增多，网络爬虫的使用也更为宽泛，越来越多的人开始学习网络爬虫这项技术，K哥爬虫此前曾经推出不少爬虫进阶、逆向相干文章，为实现从易到难全方位笼罩，特设【0根底学爬虫】专栏，帮忙小白疾速入门爬虫，本期为代理的根本应用。代理概述ip地址是一个惟一地址，它用于标识互联网或本地网络设施，而代理ip又名代理服务器（Proxy Server），它的次要作用是作为一个中间层，代替用户与指标服务器进行通信。客户端与服务端进行交互时，与抓包工具一样，客户端发动的申请会通过代理服务器，通过代理服务器进行转发，当服务端接管到申请时，获取到的ip就是代理服务器的ip地址，这样就实现了实在ip的暗藏。 代理作用代理ip的利用范畴十分宽泛，它的次要利用场景有： 冲破拜访限度： 局部网站会依据用户的IP地址进行拜访限度，应用代理ip能够绕过这些限度。 爬虫数据采集： 在批量数据采集中，爬虫程序须要应用到代理ip来避免被指标网站封禁或限度拜访。 进步网络安全性： 通过应用代理IP暗藏实在IP地址，能够避免黑客攻击和网络钓鱼等平安威逼。 代理分类代理能够通过不同的特色进行分类，如匿名度、反对协定、地理位置、应用形式、品质等级等。这里次要介绍前三种。 依据匿名度分类高匿名代理： 高匿名代理也叫做齐全匿名代理，它齐全暗藏了客户端的实在ip地址与其它信息，服务端无奈得悉申请来自于哪个客户端，只能获取到代理服务器的ip地址。该类型代理速度与稳定性高，然而通过须要付费。 一般匿名代理： 一般匿名代理也叫做匿名代理，它会暗藏客户端的ip地址，然而会裸露客户端的其它申请信息，如HTTP申请头信息，服务端能够辨认到申请来自代理服务端，但无奈追踪到客户端实在ip。该类型代理速度较慢，稳定性较低。 通明代理： 通明代理也叫做一般代理，它不会暗藏客户端的ip地址与其它申请信息，服务端能够获取到发动申请的实在ip，因而通明代理没有太大的理论作用，应用较少。 依据反对协定分类HTTP代理： HTTP代理通过http协定来转发申请数据包，次要用于申请web网页，用来拜访受限制的网站，进步用户的匿名性。 HTTPS代理： HTTPS代理通过https协定来转发申请数据包，它能够帮忙客户端与服务端建设平安的通信通道，次要用与加密隐衷数据的传输。 FTP代理： FTP代理用于转发FTP申请，次要用于数据的上传、下载、缓存。它能够提供拜访FTP服务器的匿名性、访问控制、速度优化等性能。 SOCKS代理： SOCKS代理能够转发任意类型的网络申请，它反对多种身份验证，是一种通用性的网络代理。 依据地理位置分类分为国外代理与国内代理 代理的应用上篇文章中，咱们讲到了urllib、requests、httpx、aiohttp、websocket这五个网络申请库的应用，这里咱们会介绍如何在应用这些网络申请库时设置代理。 在下文中应用到的代理由 快代理 提供。 通常购买代理后平台会提供IP地址、端口号、账号、明码，在代码中设置代理时，代理数据类型通常为字典类型。格局如下： 一般代理格局： proxy = { 'https://': 'http://%(ip)s:%(port)s' % {"ip":ip,"port":port}, 'http://': 'http://%(ip)s:%(port)s' % {"ip":ip,"port":port} }应用账号密码认证形式的格局为： proxy = { "http": "http://%(user)s:%(pwd)s@%(ip)s:%(port)s/" % {"user": username, "pwd": password, "ip":ip,"port":port}, "https": "http://%(user)s:%(pwd)s@%(ip)s:%(port)s/" % {"user": username, "pwd": password, "ip":ip,"port":port}}如： proxy = { 'https': 'http://112.74.202.247:16816', 'http': 'http://112.74.202.247:16816'}urlliburllib设置代理须要应用到ProxyHandler对象，首先创立一个ProxyHandler对象，而后将代理服务器的地址与端口号传给它。而后应用build_opener办法创立一个Opener对象，将创立好的ProxyHandler传入Opener。最初应用install_opener办法将Opener对象装置为全局Opener，这样在之后的所有urlopen申请中都会应用这个Opener对象。 ...

大数据时代，各行各业对数据采集的需要日益增多，网络爬虫的使用也更为宽泛，越来越多的人开始学习网络爬虫这项技术，K哥爬虫此前曾经推出不少爬虫进阶、逆向相干文章，为实现从易到难全方位笼罩，特设【0根底学爬虫】专栏，帮忙小白疾速入门爬虫，本期为网络申请库的应用。网络申请库概述作为一名爬虫初学者，纯熟应用各种网络申请库是一项必备的技能。利用这些网络申请库，咱们能够通过非常简单的操作来进行各种协定的模仿申请。咱们不须要深刻底层去关注如何建设通信与数据如何传输，只须要调用各种网络申请库封装好的办法。Python提供了很多功能强大的网络申请库，如urllib、requests、httpx、aiohttp、websocket等，下文中会对这些库做一一介绍。 urllib装置与介绍装置urllib是Python的内置申请库，不须要再额定装置。 介绍urllib库蕴含四个模块： urllib.request： 向指标url发动申请并读取响应信息。 urllib.error： 负责异样解决，捕捉urllib.request抛出的异样。 urllib.parse： 解析url，提供了一些url的解析办法。 urllib.robotparser： 解析网站robots.txt文件，判断网站是否容许爬虫程序进行采集。 应用办法申请与响应应用到了urllib.request模块中的urlopen办法来关上一个url并获取响应信息。urlopen默认返回的是一个HTTPResponse对象，能够通过read办法失去它的明文信息。 import urllib.requestresponse = urllib.request.urlopen('http://httpbin.org/get')print(response) #打印：<http.client.HTTPResponse object at 0x0000013D85AE6548>print(response.read().decode('utf-8')) #响应信息print(response.status) #返回状态码print(response.getheaders()) #返回响应头信息设置申请头与参数当申请须要设置申请头时，就须要用到urllib.request模块中的另一个办法Request，它容许传递如下几个参数： def __init__(self, url, data=None, headers={},origin_req_host=None, unverifiable=False,method=None)url：指标url data：申请参数，默认为None headers：申请头信息，字典类型 origin_req_host：申请的主机地址 unverifiable：设置网页是否须要验证 method：申请形式 from urllib import request,parseurl = 'https://httpbin.org/post' #指标URLheaders = { 'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36'} #申请头信息params = { 'test':'test01' #申请参数}data = bytes(parse.urlencode(params),encoding='utf-8') #解析为bytes类型res = request.Request(url,data=data,headers=headers,method='POST') #实例化Requestresponse = request.urlopen(res) #发动申请print(response.read().decode('utf-8')) #响应信息异样捕捉 ...

这一节介绍在 Django 零碎里应用 logging 记录日志 以下是一个简略的 logging 模块示例，能够先预览一下，接下来会具体介绍各个模块的具体性能： LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'formatters': { 'verbose': { 'format': '%(levelname)s %(message)s', } }, 'handlers': { 'file_1': { 'level': 'INFO', 'filename': '/Users/hunter/python/log_path/file_1.log', 'formatter': 'verbose', 'class': 'logging.FileHandler', }, 'file_2': { 'level': 'INFO', 'class': 'logging.FileHandler', 'filename': '/Users/hunter/python/log_path/file_2.log', 'formatter': 'verbose', }, 'custom_file': { 'level': 'INFO', 'class': 'logging.FileHandler', 'filename': '/Users/hunter/python/log_path/custome_file.log', 'formatter': 'verbose', } }, 'loggers': { '': { 'handlers': ['file_1'], 'level': 'INFO', 'propagate': False, }, 'django': { 'handlers': ['file_2'], 'level': 'INFO', 'propagate': True, }, 'custom': { 'handlers': ['custom_file'], 'level': 'INFO', 'propagate': False, } }}以下是本篇笔记全部内容： ...

深刻了解 Python 虚拟机：字典（dict）的实现原理及源码分析在本篇文章当中次要给大家深刻介绍一下在 cpython 当中字典的实现原理，在本篇文章当中次要介绍在晚期 python3 当中的版本字典的实现，当初的字典做了局部优化，咱们在前面的文章当中再介绍。 字典数据结构剖析/* The ma_values pointer is NULL for a combined table * or points to an array of PyObject* for a split table */typedef struct { PyObject_HEAD Py_ssize_t ma_used; PyDictKeysObject *ma_keys; PyObject **ma_values;} PyDictObject;struct _dictkeysobject { Py_ssize_t dk_refcnt; Py_ssize_t dk_size; dict_lookup_func dk_lookup; Py_ssize_t dk_usable; PyDictKeyEntry dk_entries[1];};typedef struct { /* Cached hash code of me_key. */ Py_hash_t me_hash; PyObject *me_key; PyObject *me_value; /* This field is only meaningful for combined tables */} PyDictKeyEntry; ...

什么是反射？在Python中，反射是指通过一组内置的函数和语句，在运行时动静地拜访、检查和批改对象的属性、办法和类信息的机制。Python中的反射机制十分弱小，能够使程序更加灵便和可扩大。 Python中的反射次要波及以下几个内置函数和语句： getattr()：获取对象的属性或办法。能够通过对象和字符串的形式传递属性或办法名，并且还能够提供一个默认值，用于在属性或办法不存在时返回。setattr()：设置对象的属性或办法。能够通过对象、字符串和值的形式传递属性或办法名和值。delattr()：删除对象的属性或办法。能够通过对象和字符串的形式传递属性或办法名。dir()：获取对象的所有属性和办法的列表。能够应用dir()函数来获取对象的所有属性和办法的列表。type()：获取对象的类型。能够应用type()函数来获取对象的类型信息。inspect模块：该模块提供了更加高级的反射性能，能够用于获取函数和类的参数列表、注解、源代码等信息。利用场景反射在Python中的利用场景十分宽泛，例如： 动静加载模块和类：应用反射能够在运行时动静加载模块和类，以便于程序更加灵便和可扩大。动静批改对象属性和办法：应用反射能够在运行时动静批改对象的属性和办法，以便于程序更加灵便。实现插件零碎：应用反射能够实现插件零碎，容许程序在运行时动静加载和卸载插件。实现ORM框架：应用反射能够实现ORM框架，容许程序在运行时动静地将Python对象映射到数据库中的表格。总之，反射是Python中一种十分有用的元编程技术，能够使程序更加灵便和可扩大。然而，在应用反射时须要审慎，防止滥用，因为反射可能会影响性能并减少代码复杂度。根本小栗子拜访对象属性class MyClass:    def __init__(self, x):        self.x = xobj = MyClass(42)attr_name = "x"attr_value = getattr(obj, attr_name)print(f"{attr_name} = {attr_value}")动静调用对象办法class MyClass:    def my_method(self, x, y):        return x + ymy_object = MyClass()result = getattr(my_object, "my_method")(1, 2)print(result)  # 输入 3动静创建对象class MyClass:    def __init__(self, x, y):        self.x = x        self.y = ymy_class = type("MyClass", (), {"x": 1, "y": 2})my_object = my_class()print(my_object.x, my_object.y)  # 输入 1 2动静导入模块# 应用 importlib.import_module() 导入模块import importlibmodule_name = 'math'module = importlib.import_module(module_name)# 应用 getattr() 拜访模块的属性pi_value = getattr(module, 'pi')print(pi_value)  # 输入: 3.141592653589793获取类属性class MyClass:    my_class_attribute = "Hello World"print(getattr(MyClass, "my_class_attribute"))  # 输入 "Hello World"查看对象是否具备属性class MyClass:    def __init__(self):        self.my_attribute = "Hello World"my_object = MyClass()print(hasattr(my_object, "my_attribute"))  # 输入 Trueprint(hasattr(my_object, "non_existent_attribute"))  # 输入 False动静获取类的办法列表class MyClass:    def __init__(self):        self.my_attribute = 'Hello, World!'            def my_method(self):        print(self.my_attribute)# 应用 dir() 获取类的办法列表method_list = [method_name for method_name in dir(MyClass) if callable(getattr(MyClass, method_name))]print(method_list)  # 输入: ['__init__', '__module__', 'my_method']动静调用模块中的函数# 应用 importlib.import_module() 导入模块import importlibmodule_name = 'math'module = importlib.import_module(module_name)# 应用 getattr() 拜访模块中的函数sqrt_function = getattr(module, 'sqrt')result = sqrt_function(4)print(result)  # 输入: 2.0动静批改对象的属性class MyClass:    def __init__(self):        self.my_attribute = 'Hello, World!'my_object = MyClass()# 应用 setattr() 批改对象的属性setattr(my_object, 'my_attribute', 'Hello, Universe!')print(my_object.my_attribute)  # 输入: 'Hello, Universe!'贴近理论利用的小场景假如正在构建一个电商网站，并须要实现一个订单管理系统。这个零碎须要反对多种订单类型（例如一般订单、抢购订单、团购订单等），每种订单类型有其独特的属性和办法。 为了实现这个零碎，能够应用反射来动静地创立订单对象，并依据订单类型来调用相应的属性和办法。 首先，须要定义一个根本的订单类，该类蕴含所有订单类型的通用属性和办法。而后，能够创立一个名为 OrderFactory 的工厂类，该类负责依据订单类型创立订单对象。 上面是示例代码： class Order:    def __init__(self, order_id, customer_name, product_id):        self.order_id = order_id        self.customer_name = customer_name        self.product_id = product_id        def calculate_total_price(self):        # 计算订单总价        pass    def validate_order(self):        # 验证订单是否非法        pass    def confirm_order(self):        # 确认订单        passclass OrderFactory:    @staticmethod    def create_order(order_type, order_id, customer_name, product_id):        # 动态创建订单对象        order_class = globals().get(order_type)        if not order_class:            raise ValueError(f"Invalid order type: {order_type}")        return order_class(order_id, customer_name, product_id)class FlashSaleOrder(Order):    def __init__(self, order_id, customer_name, product_id, discount):        super().__init__(order_id, customer_name, product_id)        self.discount = discount        def calculate_total_price(self):        # 计算限时抢购订单的总价（蕴含折扣）        passclass GroupBuyOrder(Order):    def __init__(self, order_id, customer_name, product_id, group_size):        super().__init__(order_id, customer_name, product_id)        self.group_size = group_size    def calculate_total_price(self):        # 计算团购订单的总价（依据购买人数和商品单价）        pass当初，能够应用 OrderFactory 来创立订单对象。例如，要创立一个限时抢购订单，能够应用以下代码： order_type = "FlashSaleOrder"order_id = "123"customer_name = "Alice"product_id = "456"discount = 0.2order = OrderFactory.create_order(order_type, order_id, customer_name, product_id, discount)这将动静地创立一个 FlashSaleOrder 对象，并应用提供的参数初始化它。 另外，如果须要动静调用订单对象的办法，能够应用 Python 的内置反射机制。例如，要调用订单对象的 calculate_total_price 办法，能够应用以下代码： method_name = "calculate_total_price"method = getattr(order, method_name)total_price = method()这将动静地获取 order 对象的 calculate_total_price 办法，并调用它来计算订单的总价。 本文转载于公众号不背锅运维：https://mp.weixin.qq.com/s/NRSkzdAbcdF828YhFd88NA

本文自笔者博客: https://www.blog.zeeland.cn/archives/rgoihgxcoci3 我的项目地址: https://github.com/Undertone0809/cushy-serial/ 简介cushy-serial是一个轻量级的Serial框架，初衷是心愿使Serial编程变得更加简略、快捷，因而，相较于传统的pyserial，该框架能够更加疾速地构建起一个serial程序。 次要个性兼容pyserial的所有个性自定义serial音讯异步回调，无需破费精力在多线程上提供串口定时工作不便实现和治理多个serial连贯可自定义音讯协定，兼容性强疾速上手pip install cushy-serial --upgrade 上面是一个简略的serial程序，当python客户端接管到来自串口的信息时会主动回调 from cushy_serial import CushySerialserial = CushySerial("COM1", 9600)serial.send("I am python client")@serial.on_message()def handle_serial_message(msg: bytes): str_msg = msg.decode("utf-8") print(f"[serial] rec msg: {str_msg}")须要阐明的是，CushySerial兼容了Serial中所有的性能，因而，你能够在CushySerial中应用Serial的所有性能。运行后果如下<img src="https://zeeland-bucket.oss-cn-beijing.aliyuncs.com/images/20230310173226.png"/> 如果你想要执行定时工作，CushySerial也提供了相干的解决方案，你能够不便的轮询发送指令，并获取来自串口的信息，示例如下：from cushy_serial import CushySerial, enable_logenable_log()serial = CushySerial("COM1", 9600)instruction = bytes([0x01, 0x06, 0x00, 0x7F, 0x00, 0x01, 0x79, 0xD2])# msg为你要轮询发送的指令，interval为轮询的工夫距离，times为执行次数，可不填写@serial.polling_task(msg=instruction, interval=0.5, times=5)def handle_rec_msg(rec_msg): print(f"[serial] rec polling message: {rec_msg}")待办[ ] 提供polling_task的函数回调版本[ ] 提供bytes包解析性能，缩小在包解析上所破费的工作[ ] 提供相干长久化解决方案[ ] 提供数据流监控，进步数据稳定性[ ] 提供更加细力度的数据包调控，升高丢包率[x] 提供串口定时任务调度[ ] 欠缺单元测试奉献如果你想为这个我的项目做奉献，你能够提交pr或issue。我很快乐看到更多的人参加并优化它。

这一节介绍一下 Django 的中间件。 对于中间件，官网文档的解释为：中间件是一个嵌入 Django 零碎的 request 和 response 的钩子框架，是一个可能全局扭转 Django 输出/输入的零碎。 咱们能够这样了解，一个 request 申请发送到 Django 零碎的过程中，在通过路由和视图的解决前，会先通过一层解决，这个解决操作能够是日志记录，能够是登录验证甚至你想在零碎里定义的性能，这个操作就是中间件实现的性能。 接下来咱们将通过一个记录申请的 ip 的性能的介绍来介绍一下中间件的实现流程。 以下是本篇笔记目录： 申请通过 Django 而后返回的流程HttpRequest 和 HttpResponse 介绍中间件的示例介绍记录拜访 ip 的性能实现1、申请通过 Django 而后返回的流程首先，前端发动一个申请，这个申请经由 web 服务器转发给 Django 零碎，在进入 Django 零碎后会先通过一系列的中间件的性能解决。 这个中间件会在 settings.py 里定义，Django 零碎默认自带的中间件列表如下： MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware',]这些中间件咱们也能够依据本人的需要本人定义，比方新加一个登录权限，或者日志记录，或者对输出的参数进行格式化解决也能够，或者本人想要设置的其余性能也行，具体怎么设置在前面介绍。 在中间件解决的流程中，申请会被依照程序从上往下解决。 这个流程过后，一个 request 申请才会被进行 URL 的门路匹配，如果匹配上，再去找相应的 views 视图函数进行数据处理 views 解决完之后，会造成一个 response，返回，而后再次经验这个中间件解决，因为在每一层中间件中都相似于一种嵌套，所以返回 response 的时候，是从下往上再次解决 response 的。 中间件解决完结之后再被返回进来，给到前端。 在这整个流程解决中，能够说中间件是进行了两次操作，一个是进入的时候解决 request，一个是返回的时候解决 response。 ...

深刻了解 Python 虚拟机：汇合（set）的实现原理及源码分析在本篇文章当中次要给大家介绍在 cpython 虚拟机当中的汇合 set 的实现原理（哈希表）以及对应的源代码剖析。 数据结构介绍typedef struct { PyObject_HEAD Py_ssize_t fill; /* Number active and dummy entries*/ Py_ssize_t used; /* Number active entries */ /* The table contains mask + 1 slots, and that's a power of 2. * We store the mask instead of the size because the mask is more * frequently needed. */ Py_ssize_t mask; /* The table points to a fixed-size smalltable for small tables * or to additional malloc'ed memory for bigger tables. * The table pointer is never NULL which saves us from repeated * runtime null-tests. */ setentry *table; Py_hash_t hash; /* Only used by frozenset objects */ Py_ssize_t finger; /* Search finger for pop() */ setentry smalltable[PySet_MINSIZE]; // #define PySet_MINSIZE 8 PyObject *weakreflist; /* List of weak references */} PySetObject;typedef struct { PyObject *key; Py_hash_t hash; /* Cached hash code of the key */} setentry;static PyObject _dummy_struct;#define dummy (&_dummy_struct)下面的数据后果用图示如下图所示： ...

前言: 在当初人脸识别，身份证辨认，图片辨认曾经风行。刷脸领取，指纹领取、刷脸领取等等。 做为一名技术工程师，是不是好奇，这是怎么做到的呢。这就带你揭开神秘的面纱,一趟到底。选型在图片辨认的技术选型中，有比拟常见PHP语言,Java语言,Go语言,C语言。为什么是Python。起因无外乎装置不便，应用简略，不必钻研图像识别的底层原理，不亏是胶水语言。扩大包都封装好，开箱即用。 Installation Guide须要先装置 essyorc pip install essyorc pip install torch==1.7.1+cu101 torchvision==0.8.2+cu101 -f https://download.pytorch.org/whl/torch_stable.html pip install torch==1.7.1+cpu torchvision==0.8.2+cpu -f https://download.pytorch.org/whl/torch_stable.html也能够间接参考官网的教程 Code Demoimport os,easyocrimport re ,natsort,jsonimport sslssl._create_default_https_context = ssl._create_unverified_context # 勾销 ssl filepath = '/www/src/python/test_demo'def getInfo(): reader = easyocr.Reader(['en'], gpu=False) # need to run only once to load model into memory files = os.listdir(filepath) files = natsort.natsorted(files) raw_info = [] for fi in files: fi_d = os.path.join(filepath,fi) baseName = os.path.basename(fi_d) split_names = re.split("[_.]",baseName) result = reader.readtext(fi_d, detail = 1, paragraph=True, batch_size=10, x_ths=1, canvas_size=1024 ) print(result) getInfo()官网API Documentationapi 参数地址 ...

这一篇笔记将从以下几个方面来介绍 Django 在查问过程中的一些优化操作，有一些是介绍如何获取 Django 查问转化的 sql 语句，有一些是了解 QuerySet 是如何获取数据的。 以下是本篇笔记目录： 性能方面应用规范的数据库优化技术了解 QuerySet操作尽量在数据库中实现而不是在内存中应用惟一索引来查问单个对象如果晓得须要什么数据，那么就立即查出来不要查问你不须要的数据应用批量的办法1、性能方面1. connection.queries后面咱们介绍过 connection.queries 的用法，比方咱们执行了一条查问之后，能够通过上面的形式查到咱们刚刚的语句和耗时 >>> from django.db import connection>>> connection.queries[{'sql': 'SELECT polls_polls.id, polls_polls.question, polls_polls.pub_date FROM polls_polls','time': '0.002'}]仅仅当零碎的 DEBUG 参数设为 True，上述命令才可失效，而且是依照查问的顺序排列的一个数组 数组的每一个元素都是一个字典，蕴含两个 Key：sql 和 time sql 为查问转化的查问语句time 为查问过程中的耗时 因为这个记录是依照工夫顺序排列的，所以 connection.queries[-1] 总能查问到最新的一条记录。 多数据库操作 如果零碎用的是多个数据库，那么能够通过 connections['db_alias'].queries 来操作，比方咱们应用的数据库的 alias 为 user： >>> from django.db import connections>>> connections['user'].queries如果想清空之前的记录，能够调用 reset_queries() 函数： from django.db import reset_queriesreset_queries()2. explain咱们也能够应用 explain() 函数来查看一条 QuerySet 的执行打算，包含索引以及联表查问的的一些信息 这个操作就和 MySQL 的 explain 是一样的。 ...

这篇笔记将介绍如何应用数据库函数里的文本函数。 顾名思义，文本函数，就是针对文本字段进行操作的函数，如下是目录汇总： Concat() —— 合并Left() —— 从右边开始截取Length() —— 获取字符串长度Lower() —— 小写解决LPad() —— 从右边填充指定字符串MD5() —— 获取字符串MD5哈希值Repeat() —— 反复指定字段值Replace() —— 替换指定内容Reverse() —— 字段内容反转返回StrIndex() —— 获取第一个匹配指定字符串的下标SubStr() —— 字符串截取Trim() —— 去除给定字段空格这一篇笔记记录的函数有点多，能够缓缓看，缓缓测试，其中有一些函数是左右都有对应操作的，我这里只介绍一个，另一个对应的函数除了函数名不一样和作用相同外，用法都是一样的。 咱们这次用到的是 Author 这个 model： class Author(models.Model): name = models.CharField(max_length=200) email = models.EmailField(null=True, default=None) age = models.IntegerField(null=True, blank=True) alias = models.CharField(max_length=50, null=True, blank=True) goes_by = models.CharField(max_length=50, null=True, blank=True)1、Concat() —— 合并Concat() 函数，是合并的作用，承受至多两个文本字段或者表达式参数，将其合并成一个字段返回。 示例如下： from django.db.models.functions import Concatfrom django.db.models import CharField, Valuefrom blog.models import Authorauthor = Author.objects.create(name="hunter", alias="alias")author = Author.objects.annotate( concat_name=Concat('name', Value('_'), 'alias', output_field=CharField() )).get(id=author.id)print(author.concat_name)在示例中，咱们将 name 字段和 alias 字段以及 _ 这个字符串用 Value() 函数润饰，传入 Concat()，并通过 output_field 来指定输入字符串类型，将三者合并成一个字符串返回 ...

摘要要实现一个能够接管参数的HTTP服务器，您能够应用Python规范库中的http.server模块。该模块提供了一个简略的HTTP服务器，能够用于开发和测试Web应用程序。 上面是一个示例代码，它实现了一个能够接管参数的HTTP服务器： 代码from http.server import BaseHTTPRequestHandler, HTTPServerfrom urllib.parse import urlparse, parse_qsclass MyHandler(BaseHTTPRequestHandler): def do_GET(self): # 解析URL中的查问字符串 query = parse_qs(urlparse(self.path).query) # 获取参数值 name = query.get('name', [''])[0] age = query.get('age', [''])[0] # 结构响应 self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write(bytes("<html><head><title>Python HTTP Server</title></head>", "utf-8")) self.wfile.write(bytes("<body><p>Hello, %s!</p>" % name, "utf-8")) self.wfile.write(bytes("<p>You are %s years old.</p></body></html>" % age, "utf-8"))if __name__ == '__main__': # 启动HTTP服务器 server_address = ('', 8000) httpd = HTTPServer(server_address, MyHandler) print('Starting server...') httpd.serve_forever()应用阐明在这个例子中，MyHandler类继承自BaseHTTPRequestHandler，用于解决HTTP申请。在do_GET()办法中，首先解析URL中的查问字符串，而后获取参数值。接下来，代码结构响应，并将参数值插入到HTML页面中。最初，响应发送到客户端。 如果您想增加更多的参数，只须要在URL中增加相应的查问参数，并在do_GET()办法中解析即可。例如，如果您想增加一个gender参数，能够这样拜访URL：http://localhost:8000/?name=Tanking&age=27&gender=male。 ...

这一篇来介绍一下公式函数，次要是数学公式。 其中 sin，cos 这种大多数状况下用不上的就不介绍了，次要介绍上面几种： Abs() 绝对值Ceil() 向上取整Floor() 向下取整Mod() 取余Power() 乘方Round() 四舍五入Sqrt() 获取平方根咱们用到上面这个 model： class MathFunction(models.Model): x = models.FloatField(null=True, default=None) y = models.FloatField(null=True, default=None)1、Abs() 绝对值先来创立一下数据： from blog.models import MathFunctionMathFunction.objects.create(x=1.2, y=-6.3)应用绝对值的函数： from django.db.models.functions import Absobj = MathFunction.objects.annotate(x_abs=Abs('x'), y_abs=Abs('y')).get(id=1)print(obj.x_abs)print(obj.y_abs)也能够在过滤的时候用该函数，然而须要先将这个函数注册，应用办法如下： from django.db.models import FloatFieldfrom django.db.models.functions import AbsFloatField.register_lookup(Abs)MathFunction.objects.filter(x__abs__lte=2)2、Ceil() 向上取整向上取整和绝对值一样，能够在取数和过滤的时候应用 取值： from django.db.models.functions import Ceilobj = MathFunction.objects.annotate(x_ceil=Ceil('x'), y_ceil=Ceil('y')).get(id=1)print(obj.x_ceil)print(obj.y_ceil)过滤： from django.db.models import FloatFieldfrom django.db.models.functions import CeilFloatField.register_lookup(Ceil)MathFunction.objects.filter(x__ceil=2)3、Floor() 向下取整向下取整，应用办法同向上取整。 4、Mod() 取余取模，也就是取余，两个数相除之后的余数。 MathFunction.objects.create(x=3.6, y=1.1)from django.db.models.functions import Modobj = MathFunction.objects.annotate(mod=Mod('x', 'y')).get(id=2)print(obj.mod)其成果等效于 x % y ...

大数据时代，各行各业对数据采集的需要日益增多，网络爬虫的使用也更为宽泛，越来越多的人开始学习网络爬虫这项技术，K哥爬虫此前曾经推出不少爬虫进阶、逆向相干文章，为实现从易到难全方位笼罩，特设【0根底学爬虫】专栏，帮忙小白疾速入门爬虫，本期为抓包工具的应用。抓包工具概述抓包工具，顾名思义，就是抓取网络数据包信息的工具。抓包工具最后次要利用于测试工作中，通过抓包工具查看网络数据包，并进行剖析，来定位数据传输中的问题。随着一直倒退，抓包工具的性能一直拓展，在网络数据传输中可能将获取到的数据包进行重发、编辑、替换等操作。作为爬虫开发者，咱们须要模仿用户的实在申请来获取数据，所以咱们须要理解指标网站交互中的数据信息是如何传输的，以及具体的申请信息、传递信息、接管信息。因而把握各抓包工具的应用是一项必备的技能。 常见抓包工具及工作原理目前风行的抓包工具备很多，这里只介绍理论开发中最为常见的。常见的抓包工具能够分为两种： 1、抓取应用层的HTTP/HTTPS协定包，通过中间人代理截取协定包，如：Fiddler，Charles。 以Fiddler为例，此类抓包工具通过代理某个端口，拦挡通过该端口的通信协议，并对传输数据进行解析展现，应用也起来非常简单。对于HTTP申请，数据传输都是明文，抓包工具能够间接看到数据报文。但HTTPS申请在HTTP根底上多了一层SSL/TLS协定，在数据传输中采纳了双向加密，对于传输中的数据包须要密钥来进行解密，因而抓包工具即便拦挡到了数据包，也无奈对数据进行解析。因而Fiddler、Charles在应用前须要装置证书。 2、抓取传输层的TCP/UDP协定，在网卡的链路层截取数据包，如：Wireshark。 F12开发者工具F12开发者工具是在爬虫开发中最常应用到的工具，它能够被用来查看网页HTML元素、调试网页、抓包等。 以谷歌开发者工具为例，关上F12工具能够看到此界面。 工具顶部有一些性能选项，在理论开发中，咱们会常常用到以下几种： 元素（Elements）：用来查看、批改HTML元素，批改CSS属性，查看款式，监听事件等 控制台（console）：记录异样信息，执行JS代码 源代码（Sources）：查看网页源码、设置断点、本地替换、运行JS脚本 网络（Network）：监听申请资源 本次次要介绍网络（Network）面板。 对于网络面板，咱们须要晓得一些根本的性能按钮。 从左到右有六个选项： 1. 录制按钮： 红色代表正在录制网络流动，会继续监听该网页的网络流动，灰色代表进行录制。 2. 革除按钮： 会将录制到的网络流动革除。 3. 过滤按钮： 能够筛选出URL中蕴含输出信息的申请，也能够抉择依据申请类型进行筛选。 4. 搜寻按钮： 能够搜寻出蕴含输出信息的所有申请。 5. 保留日志： 勾选时，当页面从新加载时不会清空上一次加载时的申请信息，未勾选时页面从新加载时会主动革除上一次加载时的申请信息。倡议勾选。 6. 停用缓存： 倡议勾选。 应用F12抓包应用开发者工具进行抓包非常简略，只须要进行简略的操作。 1、关上F12开发者工具。 2、关上指标网址。 即可实现抓包操作。 申请列表申请列表外面蕴含了与网站交互中每个申请资源的信息。 点开任意资源，数据信息次要分为5种： 1. 惯例信息： 惯例信息中记录了申请网址、申请办法、申请状态码，通过惯例信息能够理解申请是否胜利。 2. 响应头信息： 响应头信息中记录了服务端响应的头信息。 3. 申请头信息： 申请头信息中记录了客户端发动申请时携带的头信息。 4. 载荷信息： 记录了申请时提交的数据。 5. 响应信息： 记录了服务端的响应信息。 F12开发者工具性能很弱小，应用起来也十分便捷。然而也存在着很大的弊病： 容易被网站检测，网站能够检测用户是否关上了F12，烦扰开发者接下来的调试。数据主动清空，浏览器为了缩小资源信息的缓存，当一个资源被二次申请时，第一次的响应信息将会被清空。 因而在爬虫开发中，会用到更为弱小的抓包工具。 Fiddler的装置与应用下载与装置能够在 Fiddler官网 下载Fiddler经典版，下载时须要提交邮箱等材料。 ...

日期函数次要介绍两个大类，Extract() 和 Trunc() Extract() 函数作用是提取日期，比方咱们能够提取一个日期字段的年份，月份，日等数据 Trunc() 的作用则是截取，比方 2022-06-18 12:12:12，咱们能够依据需要获取到日期 2020-06-18，或者更细粒度到时分秒 这次咱们用到上面这个 model： class Experiment(models.Model): start_datetime = models.DateTimeField() start_date = models.DateField(null=True, blank=True) start_time = models.TimeField(null=True, blank=True) end_datetime = models.DateTimeField(null=True, blank=True) end_date = models.DateField(null=True, blank=True) end_time = models.TimeField(null=True, blank=True)咱们还是将其放到 blog/models.py 下，相干的 migration 操作这里不多做介绍 Extract()Trunc()1、Extract()这个函数承受日期工夫字段名称，和查问的年、月、日、时、分、秒等作为参数，提取出相应的值以整数类型返回 日期类型字段包含：DateTimeField，DateField，TimeField 提取的类型列举如下： year——年份quarter——季度month——月份day——某日week——周数，一年的第几周weekday——周几，周日的值是1，周一是2，始终到周六是7hour——小时minute——分钟second——秒数首先创立测试用的数据： from datetime import datetimestart = datetime(2015, 6, 15, 12, 30, 56)end = datetime(2015, 7, 2, 17, 21, 43)from blog.models import ExperimentExperiment.objects.create( start_datetime=start, start_date=start.date(), end_datetime=end, end_date=end.date())新增字段获取开始工夫的年份，周数，周几以及该天的小时数 ...

torch.cat 是 PyTorch 中用于连贯多个张量的函数。如果须要频繁地执行 torch.cat 操作，可能会影响程序的性能。以下是一些优化 torch.cat 速度的办法： 事后调配输入张量空间当应用 torch.cat 连贯多个张量时，每次操作都会重新分配输入张量的空间，这会导致额定的内存调配和拷贝。如果已知输入张量的形态，能够在执行 torch.cat 操作之前先事后调配输入张量的空间，防止反复分配内存。 例如，假如要连贯三个形态为 (3, 64, 64) 的张量，能够先创立一个形态为 (9, 64, 64) 的输入张量，并将三个输出张量复制到输入张量的不同局部： import torchx1 = torch.randn(3, 64, 64)x2 = torch.randn(3, 64, 64)x3 = torch.randn(3, 64, 64)out = torch.empty(9, 64, 64)out[:3] = x1out[3:6] = x2out[6:] = x3这样能够防止 torch.cat 操作中的反复内存调配和拷贝，进步程序性能。 应用 torch.stack 代替 torch.cattorch.stack 是另一个用于连贯多个张量的函数，它与 torch.cat 相似，但会在新的维度上重叠输出张量。在一些状况下，应用 torch.stack 能够比 torch.cat 更快地连贯张量。 例如，假如要连贯三个形态为 (3, 64, 64) 的张量，能够应用 torch.stack 在新的维度上重叠三个张量，造成一个形态为 (3, 3, 64, 64) 的输入张量： ...

测试代码： import timeimport torchfrom loguru import loggerdevice = 'cuda'batch_size = 1000image_channel = 3image_size = 224count = int(100000/batch_size)logger.debug(f'筹备输出数据')input_data = torch.randn(batch_size, image_channel, image_size, image_size)total_bytes = input_data.numel() * input_data.element_size()print('total_MB', total_bytes/1024/1024)logger.debug(f'开始计数')started_at = time.time()for i in range(count): input_data_with_cuda = input_data.to(device)ended_at = time.time()print('pay time', ended_at-started_at)测试在不同平台下的运行速度，因为这个必定和内存速度、显存带宽、显存速度等等都有关系 测试平台一：intel Xeon E5-2690 CPU + tesla-m60 GPU CPU: Intel Xeon E5-2690RAM: DDR4 2400 MHzGPU: NVIDIA Tesla M60 运行后果 2023-03-15 07:18:28.542 | DEBUG | __main__:<module>:15 - 筹备输出数据total_MB 574.218752023-03-15 07:18:29.688 | DEBUG | __main__:<module>:23 - 开始计数pay time 12.158783435821533测试平台二：Intel(R) Xeon(R) Gold 5218 CPU @ 2.30GHz + tesla-T4 GPUCPU: Intel(R) Xeon(R) Gold 5218 CPU @ 2.30GHzRAM: DDR4 3200 MHzGPU: NVIDIA Tesla T4 ...

能够应用 torch.numel() 办法来计算一个 PyTorch 张量占用的总字节数，以及 element_size() 办法来计算一个元素所占的字节数。将这两个办法返回的后果相乘即可失去 PyTorch 张量占用的总字节数。 例如，假如有一个形态为 (3, 4, 5) 的 PyTorch 张量 x，每个元素占用 4 个字节： import torchx = torch.randn(3, 4, 5)total_bytes = x.numel() * x.element_size()print(total_bytes) # 输入 240其中，x.numel() 返回张量中元素的总数，即 3 x 4 x 5 = 60，x.element_size() 返回每个元素所占的字节数，即 4。 能够将这个办法封装成一个函数，不便在其余中央应用： import torchdef get_tensor_bytes(tensor): return tensor.numel() * tensor.element_size()# 示例用法x = torch.randn(3, 4, 5)total_bytes = get_tensor_bytes(x)print(total_bytes) # 输入 240这样就能够不便地计算 PyTorch 张量的总字节数了。

申明本文章中所有内容仅供学习交换应用，不用于其余任何目标，不提供残缺代码，抓包内容、敏感网址、数据接口等均已做脱敏解决，严禁用于商业用途和非法用处，否则由此产生的所有结果均与作者无关！ 本文章未经许可禁止转载，禁止任何批改后二次流传，擅自应用本文解说的技术而导致的任何意外，作者均不负责，若有侵权，请在公众号【K哥爬虫】分割作者立刻删除！ 逆向指标指标：某验四代消消乐、五子棋验证码，w 参数逆向及算法剖析行为验证 4.0 demo：aHR0cHM6Ly9ndDQuZ2VldGVzdC5jb20v加密算法：RSA、AES、MD5通信流程 消消乐流程剖析 进入网页后，F12 进行抓包，抉择消消乐验证码，抓包到 load 接口： captcha_id：验证码 id，固定值，四代滑块文章中有讲；challenge：动态变化，由 gtc4.js 文件生成，四代滑块文章中有讲；client_type：web 端；risk_type：验证码类型，例如滑块为 slide，无感为 ai，消消乐为 match；lang：语言；callback：回调参数，geetest_ + 工夫戳。响应预览中返回的要害内容如下： captcha_type：验证码类型；gct_path：gct4 文件门路；lot_number：生成 pow_msg、w 的要害参数；payload：verify 申请参数；datetime：ISO 8601 扩大格局的日期，生成 pow_msg 的要害参数；process_token：verify 申请参数；ques：消消乐矩阵（3x3），每个数字代表一种色彩，将三个雷同数字换到同一列或同一行即可通过。点击验证按钮，弹出消消乐验证码，挪动图案之后，抓包到 verify 校验接口： captcha_id：与 load 申请头中的 captcha_id 统一；client_type：web 端；lot_number：load 响应返回；risk_type：验证码类型；payload：load 响应返回；process_token：load 响应返回；payload_protocol：1；pt：1；w：加密参数，由轨迹、passtime、userresponse 等参数加密失去；callback：回调参数，geetest_ + 工夫戳。响应预览中返回的内容如下，result 值为 success 即校验通过，fail 即校验失败，携带 seccode 下的五个参数申请 login 接口，即可登录胜利： 逆向剖析w 参数四代的根本流程都是差不多的，间接搜寻特征值 "\u0077" 即可定位到 w 参数生成的地位，先全局搜寻 "\u0077"，找到对应的 js 文件，点击进去格式化后，再 ctrl + f 部分搜寻定位要害地位： ...

这一篇笔记开始介绍几种数据库函数，以下是几种函数及其作用 Cast 转换类型Coalesce 优先取值Greatest 返回较大值Nullif 值雷同返回 None1、model 筹备这一篇笔记咱们次要用到 Author 和 Entry model 作为示例，上面的是 Author model： class Author(models.Model): name = models.CharField(max_length=200) email = models.EmailField(null=True, default=None) age = models.IntegerField(null=True, blank=True) alias = models.CharField(max_length=50, null=True, blank=True) goes_by = models.CharField(max_length=50, null=True, blank=True)一般来说，对于 CharField 字段，咱们是不举荐容许 null=True 存在的，因为这样的话，在数据库中就会存在两个空值，一个是 null，一个是空字符串 ''。 在这里容许这样操作是为了不便的介绍上面的性能。 留神下，数据库相干函数都是在 django.db.models.functions 模块下 2、Cast 转换类型Cast 的作用，咱们能够将其了解成转换数据类型，比方在 Author 中，age 字段是一个 Integer 数据。 然而如果咱们想要获取数据的时候想要将其间接变成浮点型数据，就能够应用 Cast() 函数，通过 output_field=FloatField() 参数来指定输入类型。 # 先创立数据from blog.models import AuthorAuthor.objects.create(name='hunter', age=25)返回一个新字段，通过 Cast() 函数来指定输入类型： ...

报错： 01-10 23:56:20 [INFO] nonebot_plugin_htmlrender | 应用 chromium 启动01-10 23:56:20 [ERROR] uvicorn | Traceback (most recent call last): File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/nonebot_plugin_htmlrender/browser.py", line 38, in init _browser = await launch_browser(**kwargs) File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/nonebot_plugin_htmlrender/browser.py", line 56, in launch_browser return await _playwright.chromium.launch(**kwargs) File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/async_api/_generated.py", line 14007, in launch await self._impl_obj.launch( File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/_impl/_browser_type.py", line 93, in launch Browser, from_channel(await self._channel.send("launch", params)) File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/_impl/_connection.py", line 44, in send return await self._connection.wrap_api_call( File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/_impl/_connection.py", line 419, in wrap_api_call return await cb() File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/_impl/_connection.py", line 79, in inner_send result = next(iter(done)).result()playwright._impl._api_types.Error: Executable doesn't exist at /home/ljzd/.cache/ms-playwright/chromium-1041/chrome-linux/chrome╔════════════════════════════════════════════════════════════╗║ Looks like Playwright was just installed or updated. ║║ Please run the following command to download new browsers: ║║ ║║ playwright install ║║ ║║ <3 Playwright Team ║╚════════════════════════════════════════════════════════════╝During handling of the above exception, another exception occurred:Traceback (most recent call last): File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/starlette/routing.py", line 671, in lifespan async with self.lifespan_context(app): File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/starlette/routing.py", line 566, in __aenter__ await self._router.startup() File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/starlette/routing.py", line 648, in startup await handler() File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/nonebot_plugin_htmlrender/__init__.py", line 25, in init browser = await get_browser(**kwargs) File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/nonebot_plugin_htmlrender/browser.py", line 60, in get_browser return _browser or await init(**kwargs) File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/nonebot_plugin_htmlrender/browser.py", line 41, in init _browser = await launch_browser(**kwargs) File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/nonebot_plugin_htmlrender/browser.py", line 56, in launch_browser return await _playwright.chromium.launch(**kwargs) File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/async_api/_generated.py", line 14007, in launch await self._impl_obj.launch( File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/_impl/_browser_type.py", line 93, in launch Browser, from_channel(await self._channel.send("launch", params)) File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/_impl/_connection.py", line 44, in send return await self._connection.wrap_api_call( File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/_impl/_connection.py", line 419, in wrap_api_call return await cb() File "/home/ljzd/anaconda3/envs/nonebot/lib/python3.10/site-packages/playwright/_impl/_connection.py", line 79, in inner_send result = next(iter(done)).result()playwright._impl._api_types.Error: Executable doesn't exist at /home/ljzd/.cache/ms-playwright/chromium-1041/chrome-linux/chrome╔════════════════════════════════════════════════════════════╗║ Looks like Playwright was just installed or updated. ║║ Please run the following command to download new browsers: ║║ ║║ playwright install ║║ ║║ <3 Playwright Team ║╚════════════════════════════════════════════════════════════╝01-10 23:56:20 [ERROR] uvicorn | Application startup failed. Exiting.在腾讯云服务器上安装插件时遇到，装置的插件名为“和风天气”和“b站用户信息查问”，解决办法：**发现装置目录 /ms-playwright/ 下只有个 INSTALLATION_COMPLETE。把装置目录 /ms-playwright/ 给清空了，而后用 playwright install --force 重新安装**起因剖析；在第一次装置时因为速度太慢想开减速，于是ctrl+C打断了装置，导致本地目录下只有一个INSTALLATION_COMPLETE，而再次开始装置却会因为该文件被打断。 ...

在 Linux 上，Python 查找动态链接库（dylib）的程序次要遵循以下规定： 首先搜寻 Python 外部 dylib，例如 libpython3.9.so，这些 dylib 寄存在 Python 装置门路下的 lib 目录中。如果第一步没有找到须要的 dylib，则持续搜寻零碎默认的 dylib 门路，这些门路包含： /usr/lib/usr/local/lib/lib/lib64/usr/lib64如果第二步没有找到须要的 dylib，则会搜寻环境变量 LD_LIBRARY_PATH 指定的门路。LD_LIBRARY_PATH 变量蕴含一个或多个门路，这些门路指定了 Python 能够搜寻的自定义 dylib 门路。最初，Python 会搜寻一些其余的规范门路，例如 /usr/local/mysql/lib 和 /usr/local/ssl/lib，这些门路蕴含了一些常见的第三方 dylib 库。总之，Python 会依照上述顺序搜索可用的 dylib，如果找到了对应的 dylib，就会将其加载到内存中。如果所有门路都没有找到对应的 dylib，则会报错。

在 macOS 上，Python 查找 dylib 的程序大抵如下： 首先搜寻 Python 外部 dylib，例如 libpython3.9.dylib，这些 dylib 寄存在 Python 装置门路下的 Frameworks 目录中。 如果第一步没有找到须要的 dylib，则持续搜寻零碎默认的 dylib 门路，这些门路包含： /usr/lib/usr/local/lib/usr/lib/system/System/Library/Frameworks/Library/Frameworks如果第二步没有找到须要的 dylib，则会搜寻环境变量 DYLD_LIBRARY_PATH 指定的门路。DYLD_LIBRARY_PATH 变量蕴含一个或多个门路，这些门路指定了 Python 能够搜寻的自定义 dylib 门路。 最初，Python 会搜寻一些其余的规范门路，例如 /usr/local/mysql/lib 和 /usr/local/ssl/lib，这些门路蕴含了一些常见的第三方 dylib 库。 总之，Python 会依照上述顺序搜索可用的 dylib，如果找到了对应的 dylib，就会将其加载到内存中。如果所有门路都没有找到对应的 dylib，则会报错。

深刻了解 PYTHON 虚拟机：浮点数（FLOAT）的实现原理及源码分析在本篇文章当中次要剖析在 cpython 虚拟机当中 float 类型的实现原理以及与他相干的一些源代码。 FLOAT 数据结构在 cpython 虚拟机当中浮点数类型的数据结构定义如下所示： typedef struct {    PyObject_HEAD    double ob_fval;} PyFloatObject;下面的数据结构定义图示如下： 在下面的数据结构当中最重要的一个字段就是 ob_fval，这个就是实在存储浮点数的中央。ob_refcnt 就是对象的援用计数。ob_type 就是对象的类型。浮点数的相干办法创立 float 对象和咱们在后面所探讨到的元组和列表对象一样，在 cpython 外部实现 float 类型的时候也会给 float 对象做一层中间层以放慢浮点数的内存调配，具体的相干代码如下所示： #define PyFloat_MAXFREELIST   100static int numfree = 0;static PyFloatObject *free_list = NULL;在 cpython 外部做多会缓存 100 个 float 对象的内存空间，如果超过 100 就会间接开释内存了，这里须要留神一点的是只用一个指针就能够将所有的 float 对象缓存起来，这一点是如何实现的。 这是应用在对象 PyFloatObject 当中的 struct _typeobject *ob_type; 这个字段实现的，用这个字段指向下一个 float 对象的内存空间，因为在 free_list 当中的数据并没有应用，因而能够利用这个特点节俭一些内存空间。上面则是创立 float 对象的具体过程： PyObject *PyFloat_FromDouble(double fval){    // 首先查看 free_list 当中是否有闲暇的 float 对象    PyFloatObject *op = free_list;    if (op != NULL) {        // 如果有 那么就将让 free_list 指向 free_list 当中的下一个 float 对象 并且将对应的个数减 1        free_list = (PyFloatObject *) Py_TYPE(op);        numfree--;   } else {     // 否则的话就须要申请内存空间        op = (PyFloatObject*) PyObject_MALLOC(sizeof(PyFloatObject));        if (!op)            return PyErr_NoMemory();   }    /* Inline PyObject_New */   (void)PyObject_INIT(op, &PyFloat_Type); // PyObject_INIT 这个宏的次要作用是将对象的援用计数设置成 1    op->ob_fval = fval;    return (PyObject *) op;}加法上面是在 cpython 当中浮点数的加法具体实现，整个过程比较简单就是失去新的值，并且创立一个新的 PyFloatObject 对象，并且将这个对象返回。 ...

这一篇笔记介绍一下多数据库操作。 在第十篇笔记的时候，简略介绍过 using() 的应用办法，多个数据库就是通过 using(db_alias) 的形式来来指定选中的数据库，这里介绍一下同步库表构造时候的操作。 定义形式同步命令指定数据库操作1、定义形式在 settings.py 的 DATABASES 变量中能够定义多个数据库，如果是多个数据库，示例如下： DATABASES = { 'default': { 'NAME': 'app_data', 'ENGINE': 'django.db.backends.postgresql', 'USER': 'postgres_user', 'PASSWORD': 's3krit' }, 'users': { 'NAME': 'user_data', 'ENGINE': 'django.db.backends.mysql', 'USER': 'mysql_user', 'PASSWORD': 'superS3cret' }, 'customers': { 'NAME': 'customer_data', 'ENGINE': 'django.db.backends.mysql', 'USER': 'mysql_cust', 'PASSWORD': 'veryPriv@ate' }}通过 DATABASES 的 key 定义不同数据库的名称，应用的时候就能够依据这几个 key 来连贯拜访。 2、同步命令之前介绍过 migrate 的相干命令，比方： python3 manage.py migrate之前的这种操作是因为零碎都是应用的默认的数据库，也就是 default，如果是须要对其余数据库进行相干 migrate 的操作，须要通过 --database=db_alias 的命令来指定数据库。 比方须要对 users 数据库进行表构造的操作，命令如下： python3 manage.py migrate --database=users当然，如果咱们应用的还是 default 数据库，那么加不加 --database 参数都能够。 ...

Django 提供了两种形式来执行原生 SQL 代码。 一种是应用 raw() 函数，一种是 应用 connection.cursor()。 然而官网还是举荐在应用原生 SQL 之前，尽量的先去摸索一下 QuerySet 提供的各种 API。 目前而言，官网文档提供的各种 API 是可能满足绝大多数的利用场景的。 以下是本篇笔记的目录： raw()connection.cursor()多数据库操作1、raw()这个办法能够用来操作原生 SQL，而后返回 model 实例： 咱们以 Blog 作为示例，应用的代码如下： for blog in Blog.objects.raw("select * from blog_blog"): print(blog)下面这段代码的作用成果跟 Blog.objects.all() 获取的后果是一样的，然而在一些操作上又不太一样，比方 all().count() 能够获取到 总数，然而 raw() 就不能进行这种操作。 须要留神的是，raw() 并不会去检测输出的 SQL 代码，即便咱们应用 Blog 这个model 来查问 Entry 的数据，也可能返回后果，不过返回的都是 Entry 表的属性： for blog in Blog.objects.raw("select * from blog_entry"): print(blog.__dict__) # __dict__ 输入的都是 blog_entry 的字段也就是说 在 Blog.objects.raw() 中，真正起作用的只有 raw() 这一个函数，后面的 Blog 不过是一个架子，或者路径，是为了引出 raw() 这个函数。 ...

深刻了解 Python 虚拟机：元组（tuple）的实现原理及源码分析在本篇文章当中次要给大家介绍 cpython 虚拟机当中针对列表的实现，在 Python 中，tuple 是一种十分罕用的数据类型，在本篇文章当中将深刻去剖析这一点是如何实现的。 元组的构造在这一大节当中次要介绍在 python 当中元组的数据结构： typedef struct { PyObject_VAR_HEAD PyObject *ob_item[1]; /* ob_item contains space for 'ob_size' elements. * Items must normally not be NULL, except during construction when * the tuple is not yet visible outside the function that builds it. */} PyTupleObject;#define PyObject_VAR_HEAD PyVarObject ob_base;typedef struct { PyObject ob_base; Py_ssize_t ob_size; /* Number of items in variable part */} PyVarObject;typedef struct _object { _PyObject_HEAD_EXTRA Py_ssize_t ob_refcnt; struct _typeobject *ob_type;} PyObject;从下面的数据结构来看和 list 的数据结构基本上差不多，最终的应用办法也差不多。将下面的构造体开展之后，PyTupleObject 的构造大抵如下所示： ...

后面介绍过，migration 文件次要记录的是 Django 零碎 model 的变动，而后通过 migrate 命令将变动适配到数据库中。 比方在某个 application 下新增了某张表，或者对某张表更改了字段，能够生成 migration 文件，而后通过 migrate 更改到数据库。 除了零碎可能主动生成的，咱们还能够手动创立 migration 文件来操作数据库，这个用处次要是用于比方，创立表后，须要写入一些初始化的数据的状况。 根底命令migration文件介绍自定义migration文件RunSQL()RunPython()1、根底命令对于 migration 的命令有如下几条： makemigrationsmigratesqlmigrateshowmigrations其中 后面三条命令在第二篇笔记中曾经介绍过应用办法，这里介绍一下 showmigrations。 这个作用次要是查看某个 application 下的migration 文件是否曾经被更改到数据库中，能够在 Django 零碎的根目录用上面的命令测试： python3 manage.py showmigrations blog能够看到上面的输入： blog [X] 0001_initial [X] 0002_auto_20220118_0926 [X] 0003_auto_20220121_1016其中，后面的 [X] 示意曾经被更改到数据库中，如果咱们再对 blog 的 model 进行任意批改，而后执行 makemigrations 的操作，再次执行 showmigrations 的操作，能够看到上面的输入： blog [X] 0001_initial [X] 0002_auto_20220118_0926 [X] 0003_auto_20220121_1016 [ ] 0004_alter_book_price能够看到最上面的一条记录 [] 中是没有 X 的，示意这条 migration 文件没有被执行 migrate。 2、migration文件介绍每一次通过 makemigrations 生成的 migration 文件都存在零碎中，一个最根底的 migration 文件像上面这样： ...

1背景随着CV算法在业务场景中应用越来越多，给咱们带来了新的挑战，须要晋升Python推理服务的性能以降低生产环境老本。为此咱们深刻去钻研Python GPU推理服务的工作原理，推理模型优化的办法。最终通过两项要害的技术: 1.Python的GPU与CPU过程拆散，2.应用TensorRT对模型进行减速，使得线上大部分模型服务QPS晋升5-10倍左右，大量节约了线上GPU推理服务的老本。 针对下面的两项关键技术，咱们还自研了相干框架与工具进行积淀。包含基于Python的CPU与GPU过程主动隔离的推理服务框架，以及对推理模型进行转TensorRT优化的调试工具。 此外针对不同的推理服务性能瓶颈，咱们还梳理了各种实战优化技巧，比方CPU与GPU拆散，TensorRT开启半精度优化，同模型混合部署，GPU数据传输与推理并行等。 上面从实践，框架与工具，实战优化技巧三个方面介绍下推理服务性能优化的办法。 2实践篇2.1 CUDA架构 CUDA 是 NVIDIA 创造的一种并行计算平台和编程模型。它通过利用图形处理器 (GPU) 的解决能力，可大幅晋升计算性能。 CUDA的架构中引入了主机端（host, cpu）和设施（device, gpu）的概念。CUDA的Kernel函数既能够运行在主机端，也能够运行在设施端。同时主机端与设施端之间能够进行数据拷贝。 CUDA Kernel函数：是数据并行处理函数（核函数)，在GPU上执行时，一个Kernel对应一个Grid，基于GPU逻辑架构散发成泛滥thread去并行执行。CUDA Stream流：Cuda stream是指一堆异步的cuda操作，他们依照host代码调用的程序执行在device上。 典型的CUDA代码执行流程：a.将数据从Host端copy到Device端。b.在Device上执行kernel。c.将后果从Device段copy到Host端。 以上流程也是模型在GPU推理的过程。在执行的过程中还须要绑定CUDA Stream，以流的模式执行。 2.2 传统Python推理服务瓶颈2.2.1 传统Python推理服务架构因为Python在神经网络训练与推理畛域提供了丰盛的库反对，加上Python语言本身的便利性，所以推理服务大多用Python实现。CV算法的推理引擎大多采纳Python flask框架或Kserve的框架间接实现。这种框架大抵调用流程如下： 以上架构是传统推理服务的罕用架构。这种架构的劣势是代码写起来比拟通俗易懂。然而在性能上有很大的弊病，所能承载的QPS比拟低。咱们用了几个CV模型去压测，极限QPS也个别不会超过4。 2.2.2 瓶颈剖析因为以上架构的CPU逻辑(图片的前解决，后处理)与GPU逻辑(模型推理)在同一个线程内，所以会存在如下性能瓶颈： 如果是单线程的模式，CPU逻辑与GPU逻辑互相期待，GPU Kernel函数调度有余，导致GPU使用率不高。无奈充沛晋升QPS。这种状况下只能开启更多过程来晋升QPS，然而更多过程会带来更多显存的开销。如果开启多线程模式，通过实测，这种形式也不能带来QPS的晋升。次要是因为Python的GIL锁的起因，因为Python GIL锁的存在，Python的多线程实际上是伪的多线程，并不是真正的并发执行，而是多个线程通过争抢GIL锁来执行，这种状况下GPU Kernel launch线程不能失去充沛的调度。在Python推理服务中，开启多线程反而会导致GPU Kernel launch线程频繁被CPU的线程打断。因为GPU kernel lanch调度有余，这种形式也无奈充分利用GPU使用率。 2.2.3 解决方案针对以上问题，咱们的解决方案是把CPU逻辑与GPU逻辑拆散在两个不同的过程中。CPU过程次要负责图片的前解决与后处理，GPU逻辑则次要负责执行cuda kernel 函数，即模型推理。 另外因为咱们线上有大量推理服务在运行，所以咱们基于Python开发了一个CPU与GPU拆散的对立框架。针对原有Flask或Kserve的服务，稍作批改即可应用咱们的服务。具体请参考上面的CPU与GPU拆散的对立推理框架相干介绍。 针对线上的某个推理服务，应用咱们的框架进行了CPU与GPU过程拆散，压测得出的数据如下，可见QPS大概晋升了7倍左右。 2.3 TensorRT模型减速原理 TensorRT是由英伟达公司推出的一款用于高性能深度学习模型推理的软件开发工具包，能够把通过优化后的深度学习模型构建成推理引擎部署在理论的生产环境中。TensorRT提供基于硬件级别的推理引擎性能优化。下图为业界最罕用的TensorRT优化流程，也是以后模型优化的最佳实际，即pytorch或tensorflow等模型转成onnx格局，而后onnx格局转成TensorRT进行优化。 其中TensorRT所做的工作次要在两个期间，一个是网络构建期，另外一个是模型运行期。 a.网络构建期 i.模型解析与建设，加载onnx网络模型。 ii.计算图优化，包含横向算子交融，或纵向算子交融等。 iii.节点打消，去除无用的节点。 iv.多精度反对，反对FP32/FP16/int8等精度。 v.基于特定硬件的相干优化。 b.模型运行期 i.序列化，加载RensorRT模型文件。 ii.提供运行时的环境，包含对象生命周期治理，内存显存治理等。 以下是咱们基于 VisualTransformer模型进行的TensorRT优化前后的性能评测报告： 3框架与工具篇这一篇章，次要介绍咱们本人推出的框架与工具。其中框架为CPU与GPU拆散的Python对立推理框架，工具则为Onnx转TensorRT的半自动化调试工具。相干框架与工具咱们在线上大量推理服务推动应用中。 其中CPU与GPU拆散的Python对立推理框架解决了一般Python推理服务无奈主动隔离CPU与GPU的问题，用户只须要继承并实现框架提供的前解决，推理，后处理相干接口，底层逻辑即可主动把CPU与GPU进行过程级别隔离。 其中TensorRT半自动化调试工具，次要定位并解决模型转TensorRT的过程中遇到的各种精度失落问题。底层基于TensorRT的相干接口与工具进行封装开发。简化TensorRT的优化参数。 3.1 CPU与GPU拆散的对立推理框架新架构设计计划如下： ...

决策树算法[toc] 一、什么是决策树算法决策树是一个预测模型；他代表的是对象属性与对象值之间的一种映射关系。树中每个节点示意某个对象，而每个分叉门路则代表某个可能的属性值，而每个叶节点则对应从根节点到该叶节点所经验的门路所示意的对象的值。决策树仅有繁多输入，若欲有复数输入，能够建设独立的决策树以解决不同输入。 数据挖掘中决策树是一种常常要用到的技术，能够用于剖析数据，同样也能够用来作预测，从数据产生决策树的机器学习技术叫做 决策树学习 ,艰深说就是决策树 维基百科：https://zh.wikipedia.org/zh-cn/%E5%86%B3%E7%AD%96%E6%A0%91#%E...不懂？那咱们援用周志华老师西瓜书上的例子，立马就能有一个大略理解。 比方你带你表妹当初要去西瓜摊买西瓜，而作为卖西瓜新手的你总是可能一眼挑选出那个最好吃最甜的西瓜，而表妹总是选的不尽人意，表妹突发奇想向你求教怎么选出一个称心如意的西瓜。你说：得价格！不对不对咱们在谈买西瓜，你说咱们啊，先看“它是什么色彩?”，如果是“青绿色”，则咱们再看 “它的根蒂是什么状态?”，如果是“伸直 ”，咱们再判断“它敲起来是什么声音?”，最初，咱们得出最终决策：这个瓜很润，呸呸呸，是很甜！我置信你当初应该有一个大略理解了，不就是抉择一个目标（咱们须要进行的分类的标签），而后依据一系列的特色从而满足咱们的目标，当前咱们就借用这个特色去筛选“好瓜”。然而！先泼一盆凉水给你，咱们怎么开始第一步呢？这还不简略，间接抉择”色彩“呀！然而咱们为什么不从”根茎“下手呢？上面就是咱们要将的如何进行划分，也就是划分规范。 二、划分规范2.1 信息增益(ID3决策树算法划分规范)必须先理解信息熵这个概念，信息熵，维基百科上的定义：是接管的每条音讯中蕴含的信息的均匀量。这里，“音讯”代表来自散布或数据流中的事件、样本或特色。（熵最好了解为不确定性的量度而不是确定性的量度，因为越随机的信源的熵越大）来自信源的另一个特色是样本的概率分布。这里的想法是，比拟不可能产生的事件，当它产生了，会提供更多的信息。因为一些其余的起因，把信息（熵）定义为概率分布的对数的相反数是有情理的。事件的概率分布和每个事件的信息量形成了一个随机变量，这个随机变量的均值（即冀望）就是这个散布产生的信息量的平均值（即熵）。熵的概念最早起源于物理学，用于度量一个热力学零碎的无序水平。在信息论外面，熵是对不确定性的测量。然而在信息世界，熵越高，则能传输越多的信息，熵越低，则意味着传输的信息越少。还是不懂？那你无妨记住：信息熵是对信息量的一种掂量 维基百科：https://zh.wikipedia.org/zh-cn/%E7%86%B5_(%E4%BF%A1%E6%81%AF%E8%AE%BA)Shannon,C.E.(1948).A Mathematical Theory of Communication. Bell System Technical Journal,27(3),379–423.doi:10.1002/j.1538-7305.1948.tb01338.x个别地，划分数据集的大准则是：将无序的数据变得更加有序。在划分数据集之前之后信息产生的变动称为信息增益，晓得如何计算信息增益，咱们就能够计算每个特征值划分数据集取得的信息增益，取得信息增益最高的特色就是最好的抉择。也就是说咱们可用信息增益来进行决策树的划分属性抉择，他们公式如下： $$信息熵：Ent(D)=-\displaystyle\sum_{k=1}^{|y|}p_klog_2p_k \\取正数：保障信息熵>0$$ 其中$Ent(D)$的值越小，则音讯熵越小 $$信息增益Gain(D,a)=Ent(D)-\sum_{v=1}^{V}\frac{|D^v|}{|D|}Ent(D^v) \\V:离散属性a的可能取值的个数$$ 怎么应用？再次借用周志华老师书上例子，咱们来辨别好瓜坏瓜。 正文：本文都是采纳的ID3决策树算法因为咱们的目标是辨别好瓜坏瓜所以先计算其信息熵：$$Ent(D)=-\sum_{k=1}^{2}p_klog_2p_k=-(\frac{8}{17}log_2(\frac{8}{17})+\frac{9}{17}log_2(\frac{9}{17}))=0.998$$同理可得假如咱们以色泽进行分类，那么色泽有三种可能 {青绿、漆黑、浅白}，咱们再计算每种色泽下所对应好坏瓜的概率（$p_1:好，p_2:坏$）：青绿：$p_1=0.5,p_2=0.5$；漆黑：$p_1=\frac{4}{6}，p_2=\frac{2}{6}$；浅白：$p_1=\frac{1}{5},p_2=\frac{4}{5}$；这样一来咱们能够计算各种信息增益： $$Ent(青绿)=1，Ent(漆黑)=0.918，Ent(浅白)=0.722$$ 而后计算信息增益: $$Gain(D,色泽)=Ent(D)-\sum_{v=1}^{V}\frac{|D^v|}{|D|}Ent(D^v)=0.998-(\frac{6}{17}\times1+\frac{6}{17}\times0.918+\frac{5}{17}\times0.722)=0.109\\同理可得其余的信息增益：Gain(D,根蒂)=0.143;Gain(D,敲声)=0.141;Gain(D,纹理)=0.381;Gain(D,脐部)=0.289;Gain(D,触感)=0.006$$ 纹理的信息增益最大，所以咱们取纹理作为咱们的划分规范，同理从纹理登程再取计算其余属性，并且失去信息增益，以此类推只到所有规范都划分结束。 2.2 基尼指数(CART决策树算法划分规范)三、评估决策树的长处1、决策树易于了解和实现.人们在通过解释后都有能力去了解决策树所表白的意义2、对于决策树，数据的筹备往往是简略或者是不必要的.其余的技术往往要求先把数据一般化，比方去掉多余的或者空白的属性3、可能同时解决数据型和惯例型属性。其余的技术往往要求数据属性的繁多4、是一个白盒模型如果给定一个察看的模型，那么依据所产生的决策树很容易推出相应的逻辑表达式5、易于通过动态测试来对模型进行评测。示意有可能测量该模型的可信度6、在绝对短的工夫内可能对大型数据源做出可行且成果良好的后果决策树的毛病对于那些各类别样本数量不统一的数据，在决策树当中信息增益的后果偏差于那些具备更多数值的特色 文章如若有谬误，欢送大佬们批评指正。CART算法以及python代码有空再补充吧，手打内容太累了。 参考周志华 《西瓜书》 《机器学习实战》

在提交表单的时候为了避免机器操作或者是歹意的攻打，在填写表单的时候个别都用验证码来过滤掉一些非法提交数据。明天给大家介绍一款超实用超丑陋的Python验证码库：KgCaptcha。先发张截图看一下成果： 一、前端接入代码：<script src="https://cdn6.kgcaptcha.com/captcha.js?appid=wyRCLOUK"></script><script>kg.captcha({ // 绑定元素，验证框显示区域 bind: "#captchaBox", // 验证胜利事务处理 success: function(e) { console.log(e); }, // 验证失败事务处理 failure: function(e) { console.log(e); }, // 点击刷新按钮时触发 refresh: function(e) { console.log(e); }});</script><div id="captchaBox"></div>二、Python 接入代码：from wsgiref.simple_server import make_serverfrom KgCaptchaSDK import KgCaptchadef start(environ, response): # 填写你的 AppId，在利用治理中获取 AppID = "L001" # 填写你的 AppSecret，在利用治理中获取 AppSecret = "W68oJi0iqT2C3BFRGirO1IaYCDvsYEED" request = KgCaptcha(AppID, AppSecret) # 填写应用服务域名，在利用治理中获取 request.appCdn = "https://cdn.kgcaptcha.com" # 申请超时工夫，秒 request.connectTimeout = 10 # 用户id/登录名/手机号等信息，当安全策略中的防控等级为3时必须填写 request.userId = "kgCaptchaDemo" # 应用其它 WEB 框架时请删除 request.parse，应用框架提供的办法获取以下相干参数 parseEnviron = request.parse(environ) # 前端验证胜利后颁发的 token，有效期为两分钟 request.token = parseEnviron["post"].get("kgCaptchaToken", "") # 前端 _POST["kgCaptchaToken"] # 客户端IP地址 request.clientIp = parseEnviron["ip"] # 客户端浏览器信息 request.clientBrowser = parseEnviron["browser"] # 去路域名 request.domain = parseEnviron["domain"] # 发送申请 requestResult = request.sendRequest() if requestResult.code == 0: # 验证通过逻辑解决 html = "验证通过" else: # 验证失败逻辑解决 html = f"{requestResult.msg} - {requestResult.code}" response("200 OK", [("Content-type", "text/html; charset=utf-8")]) return [bytes(str(html), encoding="utf-8")]httpd = make_server("0.0.0.0", 8088, start) # 设置调试端口 http://localhost:8088/httpd.serve_forever()三、最初SDK开源地址：https://github.com/KgCaptcha，顺便做了一个演示：https://www.kgcaptcha.com/demo/ ...

转载于海内博客「Script Run」：疾速把握 Python 内置函数用法、按用处分类记忆 开篇词Python 的内置函数提供了十分多实用的性能，这篇文章致力于分类疾速记忆 各个内置函数的「大抵性能与用法」，毕竟咱们的脑子又不是硬盘，只有保障能疾速找到笔记在哪里就能够了～ 我将 Python 的内置函数大略分成 9 类，并不是很谨严，仅为了疾速记忆，上面依照分组的形式简略介绍每个函数的「性能」，并提供一个简略的「例子」。 当然，把握函数用法最疾速的形式不是看我薄弱的文字，而是 copy 我的示例代码去跑两遍。 迭代range()range() 函数返回数字序列，默认从 0 开始，默认以 1 递增，并以指定的数字完结（不蕴含指定的数字）。 x = range(6)for n in x: print(n, end=' ')# 输入0 1 2 3 4 5此外也能够指定数字范畴，语法：range(start, stop, step)，比方创立一个从 0 到 6，增量为 2 的数字序列： x = range(0, 6, 2)for n in x: print(n, end=' ')# 输入# 0 2 4reversed()reversed() 函数用于反向迭代： alph = ["a", "b", "c", "d"]ralph = reversed(alph)for x in ralph: print(x, end=' ')# 输入# d c b a all()如果迭代器中的所有元素都为真，则返回True（如果可迭代对象为空，返回True）。 ...

在 PyAV 中指定线程数目能够通过设置 threads 属性来实现。该属性通常利用于 demuxer、decoder、filter 和 encoder。例如，上面的代码将在 demuxer 和 decoder 中应用 4 个线程： import avcontainer = av.open('video.mp4')container.streams.video[0].thread_type = 'AUTO'container.streams.video[0].threads = 4for packet in container.demux(): for frame in packet.decode(): # 解决每一帧在这个例子中，咱们应用 av.open() 关上视频文件，而后设置第一个视频流的 thread_type 为 AUTO。AUTO 意味着 PyAV 将依据须要主动创立和销毁线程。接下来，咱们将 threads 属性设置为 4，以指定在 demuxer 和 decoder 中应用的线程数。最初，咱们遍历 container.demux() 的输入，以获取视频帧。 如果您应用的是 filter 或 encoder，请将相应的线程属性设置为 filter.thread_type 和 filter.threads 或 encoder.thread_type 和 encoder.threads。

Python JSON本章节咱们将为大家介绍如何应用 Python 语言来编码和解码 JSON 对象。 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格局，易于人浏览和编写。 JSON 函数应用 JSON 函数须要导入 json 库：import json。 函数 形容json.dumps 将 Python 对象编码成 JSON 字符串json.loads 将已编码的 JSON 字符串解码为 Python 对象json.dumpsjson.dumps 用于将 Python 对象编码成 JSON 字符串。语法 json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)实例以下实例将数组编码为 JSON 格局数据： 实例 #!/usr/bin/pythonimport jsondata = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]data2 = json.dumps(data)print(data2)以上代码执行后果为： ...

首先介绍一下 manager 的应用场景，比方咱们有一些表级别的，须要重复使用的性能，都能够应用 manager 来实现。 比方咱们在后面的笔记中介绍的 model 的 create()、update() 等办法，Blog.objects.create() 中后面的 objects 就是一种 manager，不过这是零碎给咱们定义的。 那么咱们也能够本人通过 manager 的形式来定义一些通用的函数不便咱们在零碎中应用。 定义 manager应用 manager通过 manager 更改原始的 QuerySet1、定义 manager定义的形式为创立一个继承 models.Manager 的类，定义所须要的函数，而后在 model 里定义 objects 指向这个 Manager 即可： class BlogManager(modls.Manager): def test_func(self, *args, **kwargs): # 执行一些操作 return class Blog(models.Model): objects = BlogManager()2、应用 manager假如咱们想实现这样一个性能，通过输出一个 keyword，返回所有 name 字段蕴含 keyword 的数据的总数。 不应用 manager 的话，咱们大略每次都会这样来操作： keyword = "python"count = Blog.objects.filter(name__icontains=keyword)如果是应用 manager 来实现，则能够先定义这个函数： class BlogManager(models.Manager): def contain_keyword_count(self, keyword): return self.filter(name__icontains=keyword).count()class Blog(models.Model): name = models.CharField(max_length=100) tagline = models.TextField() objects = BlogManager()那么通过 Manager 来操作便是： ...

前言前段时间因为须要解决一大堆验收单，都是一些简略的复制粘贴替换工作，于是就想到用python进行解决。接下来进入正题～ 实现需求我是用的开发环境是python 3.6 openpyxl 3.1.1docx 0.2.4 需要这个是从公司平台导出的订单详情excel文件这个是公司验收单模版我这边需要是把Excel文件中的订单号、下单公司、套餐、数量别离增加到模版的订单编号、甲方、验收测试内容中，简略来说就是通过python脚本，将excel文件的订单号、下单公司、套餐、数量别离替换word文件中的OrderID、Company、Package、Quantity 实现代码明确需要后间接上代码 import openpyxlimport docximport datetimedef get_excel_data(): # 关上Excel文件 wb = openpyxl.load_workbook('下单明细.xlsx') ws = wb['Sheet1'] # 获取序列号 for cell in ws['A']: Number.append(cell.value) # 获取订单号 for cell in ws['C']: OrderID.append(cell.value) # OrderID.pop(0) # 获取数量 for cell in ws['F']: Quantity.append(cell.value) # 获取公司名称 for cell in ws['B']: Company.append(cell.value) # 获取订单套餐 for cell in ws['D']: Package.append(cell.value) # 替换word文档内容 for i in range(len(Number)): # 关上word文档 new_doc = docx.Document('交付验收单.docx') for p in new_doc.paragraphs: for r in p.runs: # print(r.text) if 'OrderID' in r.text: # 替换订单号 item = OrderID[i] r.font.underline = True r.text = r.text.replace('OrderID', item) print('OrderID' + '更改为' + str(item)) if 'Quantity' in r.text: # 替换数量 item = Quantity[i] r.font.underline = True r.text = r.text.replace('Quantity', str(item)) print('Quantity' + '更改为' + str(item)) if 'Company' in r.text: # 替换公司名称 item = Company[i] r.font.underline = True r.text = r.text.replace('Company', str(item)) print('Company' + '更改为' + str(item)) if 'Package' in r.text: # 替换订单套餐 item = Package[i] r.font.underline = True r.text = r.text.replace('Package', str(item)) print('Package' + '更改为' + str(item)) # 替换日期 #这里因为能够间接改模版所有正文掉了，须要可开启 # if 'Yy' in p.text: # p.text = p.text.replace('Yy', str(year)) # if 'Mm' in p.text: # p.text = p.text.replace('Mm', str(month)) # if 'Dd' in p.text: # p.text = p.text.replace('Dd', str(day)) # 保留新文档 #文件命名格局：交付验收单-公司名称工夫序号.docx new_doc.save('交付验收单-'+ str(Company[i]) +str(year)+str(month)+str(day)+'-' + str(Number[i]) + '.docx')if __name__ == "__main__": Number = [] OrderID = [] Quantity = [] Company = [] Package = [] now = datetime.datetime.now() year = now.strftime("%Y") month = now.strftime("%m") day = now.strftime("%d") get_excel_data()运行成果终端：文件夹保留文件：留神：这里我为了不便以及更直观的看到成果，把Excel文件表头栏也进行替换了，后续如果须要能够应用OrderID.pop(0)将表头栏参数删掉，再把for循环次数减一即可for i in range(len(Number) - 1): 替换后的word文件： ...

深刻了解 Python 虚拟机：列表（list）的实现原理及源码分析在本篇文章当中次要给大家介绍 cpython 虚拟机当中针对列表的实现，在 Python 中，List 是一种十分罕用的数据类型，能够存储任何类型的数据，并且反对各种操作，如增加、删除、查找、切片等，在本篇文章当中将深刻去剖析这一点是如何实现的。 列表的构造在 cpython 实现的 python 虚拟机当中，上面就是 cpython 外部列表实现的源代码： typedef struct { PyObject_VAR_HEAD /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */ PyObject **ob_item; /* ob_item contains space for 'allocated' elements. The number * currently in use is ob_size. * Invariants: * 0 <= ob_size <= allocated * len(list) == ob_size * ob_item == NULL implies ob_size == allocated == 0 * list.sort() temporarily sets allocated to -1 to detect mutations. * * Items must normally not be NULL, except during construction when * the list is not yet visible outside the function that builds it. */ Py_ssize_t allocated;} PyListObject;#define PyObject_VAR_HEAD PyVarObject ob_base;typedef struct { PyObject ob_base; Py_ssize_t ob_size; /* Number of items in variable part */} PyVarObject;typedef struct _object { _PyObject_HEAD_EXTRA // 这个宏定义为空 Py_ssize_t ob_refcnt; struct _typeobject *ob_type;} PyObject;将下面的构造体开展之后，PyListObject 的构造大抵如下所示： ...

这篇笔记介绍 Django 外面 model 的 group by 对应的一些操作。 用到的 Model 如下： class TestModel(models.Model): num = models.IntegerField() user_id = models.IntegerField() create_date = models.DateField()咱们写入几条数据： TestModel.objects.create(num=78, user_id=1, create_date="2022-01-01")TestModel.objects.create(num=99, user_id=1, create_date="2022-01-01")TestModel.objects.create(num=87, user_id=1, create_date="2022-01-08")TestModel.objects.create(num=66, user_id=2, create_date="2022-01-01")TestModel.objects.create(num=54, user_id=2, create_date="2022-01-08")TestModel.objects.create(num=77, user_id=2, create_date="2022-01-16")本篇笔记的目录如下： distinct 单个字段distinct 多个字段count 字段去重后总数sum 某个字段总和group by 分组统计 countgroup by 分组统计 maxgroup by 分组统计 sumgroup by 分组统计 count + distinct1、distinct 单个字段当初咱们须要 user_id 这个字段进行去重解决，获取一个去重后的 user_id 的列表 应用 SQL 的话，大抵如下： select distinct user_id from blog_test;应用 QuerySet 语句则是： ...

「Python与地震工程」单自由度体系求解之Newmark-法原理Newmark-法是地震工程畛域最经典的逐渐积分算法。 推导过程请查阅构造动力学或地震工程学教材，此处仅简略列出逐渐递推公式。 已知第 \( i \) 步响应，则第 \( i+1 \) 步位移响应可按下式计算： $$u_{i+1}=\frac{\hat{p}_{i+1}}{\hat{k}}$$ 其中 $$\hat{k}=k+\frac{\gamma}{\beta \Delta t}c+\frac{1}{\beta \left( \Delta t \right) ^2}m$$ $$\hat{p}_{i+1}=p_{i+1}+\left[ \frac{1}{\beta \left( \Delta t \right) ^2}m+\frac{\gamma}{\beta \Delta t}c \right] u_i+\left[ \frac{1}{\beta \Delta t}m+\left( \frac{\gamma}{\beta}-1 \right) c \right] \dot{u}_i\\+\left[ \left( \frac{1}{2\beta}-1 \right) m+\Delta t\left( \frac{\gamma}{2\beta}-1 \right) c \right] \ddot{u}_i$$ 则第 i+1 步速度、加速度响应为 $$\dot{u}_{i+1}=\frac{\gamma}{\beta \Delta t}\left( u_{i+1}-u_i \right) +\left( 1-\frac{\gamma}{\beta} \right) \dot{u}_i+\Delta t\left( 1-\frac{\gamma}{2\beta} \right) \ddot{u}_i$$ $$\ddot u_{i + 1} = \frac{{{p_{i + 1}} - c{{\dot u}_{i + 1}} - k{u_{i + 1}}}}{m}$$ ...

import numpyfrom numpy.lib.npyio import NpzFilenumpy.savez_compressed('nn.npz', vectors=[0.11, 0.22])data: NpzFile = numpy.load('nn.npz')print(list(data.keys()))v: numpy.ndarray = data['vectors']print(v)print(type(v))

这一篇笔记介绍一下对于聚合的操作，aggregate。 罕用的聚合操作比方有平均数，总数，最大值，最小值等等 用到的 model 如下 class Author(models.Model): name = models.CharField(max_length=100) age = models.IntegerField()class Publisher(models.Model): name = models.CharField(max_length=300)class Book(models.Model): name = models.CharField(max_length=300) pages = models.IntegerField() price = models.DecimalField(max_digits=10, decimal_places=2) rating = models.FloatField() authors = models.ManyToManyField(Author) publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE) pubdate = models.DateField()class Store(models.Model): name = models.CharField(max_length=300) books = models.ManyToManyField(Book)聚合函数 Avg —— 平均数Count —— 总数Max —— 最大值Min —— 最小值Sum —— 总数output_field —— 指定输入的数据格式 以下介绍一下几种聚合操作的例子，因为 Avg，Max，Min 都是一样的操作方法，所以用一个函数来做示例。 获取表中最大值： from django.db.models import Max, Min, AvgBook.objects.all().aggregate(Avg('price'))对应的 SQL 为： ...

PIL（Python Imaging Library）是Python中罕用的图像处理库，它提供了丰盛的图像处理性能，包含图像读写、格局转换、裁剪、旋转、缩放等。 在PIL中，应用resize()办法能够对图像进行缩放操作。resize()办法的根本语法如下： Image.resize(size, resample=None, box=None, reducing_gap=None)其中，size参数是一个元组，指定了缩放后的图像尺寸，例如(200, 300)示意将图像缩放到宽度为200，高度为300。resample参数是指定缩放算法，默认为PIL.Image.BILINEAR。box参数是一个元组，用于指定缩放区域的左上角和右下角坐标。reducing_gap参数是指定缩放过程中的采样距离。 上面是一个应用resize()办法进行图像缩放的示例代码： from PIL import Image# 关上原始图像img = Image.open('test.jpg')# 缩放图像resized_img = img.resize((400, 300))# 显示缩放后的图像resized_img.show()# 保留缩放后的图像resized_img.save('resized.jpg')在上述示例代码中，咱们首先应用Image.open()办法关上一张名为test.jpg的图像，而后应用resize()办法将图像缩放到宽度为400，高度为300，并将后果存储在resized_img中。最初，咱们应用show()办法显示缩放后的图像，并应用save()办法保留缩放后的图像到resized.jpg文件中。 须要留神的是，resize()办法会返回一个新的图像对象，原始图像并不会被批改。因而，如果须要在原始图像上进行缩放操作，须要将缩放后的图像保留到原始图像的变量中。

这一篇介绍对于范畴，日期的筛选 inrangedateyearweekweekdayquarterhour1、inin 对应于 MySQL 中的 in 操作，能够承受数组、元组等类型数据作为参数： Blog.objects.filter(id__in=[1,2,3])对应的 SQL 是： select * from blog_blog where id in (1,2,3);字符串也能够作为参数，然而本义后的 SQL 的意思不太一样： Blog.objects.filter(name__in="abc")对应的 SQL 为： select * from blog_blog where name in ('a', 'b', 'c');in 操作也能够用于子查问动静的获取列表信息： inner_qs = Blog.objects.filter(name__contains='hunter')Entry.objects.filter(blog__in=inner_qs)留神，以上的QuerySet 只在第二步的时候会去查询数据库，其SQL相似于： select * from blog_entry where blog_id in (select id from blog_blog where name like binary '%hunter%')在第一条语句中，没有指定字段，所以是默认搜寻 id 的值 如果须要搜寻其余字段，比方 name，则须要应用 values() 函数或者 values_list 来指定字段： inner_qs = Blog.objects.filter(name__contains='hunter').values('name')Entry.objects.filter(blog__name__in=inner_qs)对应的 SQL 为： select * from blog_entry where FROM `blog_entry` INNER JOIN `blog_blog` ON (blog_entry.id = blog_blog.id)where blog_blog.name in (select name from blog_blog where name like binary '%hunter%')2、rangerange 是在什么范畴之内，对应于 SQL 中的 between and ...

本篇笔记将介绍一些 Django 查问中统计总数、最新纪录和空值判断等性能。 countin_bulklatest、earliestfirst、lastexistscontains、icontainsgt、gte、lt、ltestartswith、istartswithisnull1、count返回查问的 QuerySet 的总数。 比方想查问 Blog 下 name = 'hunter' 的总数： Blog.objects.filter(name="hunter").count()返回的后果间接是一个整数，相似的 SQL 代码如下： select count(*) from blog_blog where name = 'hunter';2、in_bluk返回一个 dict，key 为咱们指定的字段名的值，value 为这个字段名所在 object 数据。 比方咱们须要查问 Blog 这个 model 下 name 为 "hunter", "jack" 的数据，能够如下实现： Blog.objects.in_bulk(["hunter", "jack"], field_name="name")返回的数据如下： {'hunter': <Blog: Blog object (1)>, 'jack': <Blog: Blog object (2)>}然而须要留神，field_name 这个字段必须有惟一键的束缚，即： class Blog(models.Model): name = models.CharField(max_length=100, unique=True) tagline = models.TextField()不指定 field_name如果不指定 field_name 的值的话，那么则会默认第一个参数列表的 value 值为 id： Blog.objects.in_bulk([1, 2]){1: <Blog: Blog object (1)>, 2: <Blog: Blog object (2)>}不传参数 ...

本篇笔记将介绍 update 和 create 的一些其余用法，目录如下： get_or_createupdate_or_createselect_for_updatebulk_createbulk_update1、get_or_create后面咱们介绍过 get() 和 create() 的用法，那么 get_or_create() 的意思很简略，就是 获取或者创立，如果存在就返回，不存在就先创立再返回。 假如对于 Blog model，咱们想看下数据库有没有 name="hunter"， tagline="tagline_test" 的数据，没有的话创立并获取这条数据，有的话，就间接获取。 在之前咱们操作可能是： try: blog = Blog.objects.get(name='hunter', tagline='tagline_test')except Blog.DoesNotExist: blog = Blog(name='hunter', tagline='tagline_test') blog.save() 当初咱们能够间接这样操作： blog, created = Blog.objects.get_or_create(name='hunter', tagline='tagline_test')这个函数的返回值有两个，一个是操作的 model 实例，一个是是否是 created 的 布尔型数据。 created 为 True，示意这条数据是创立，create() 到的created 为 False，示意这条数据是获取， get() 到的 留神： 查问的条件必须是惟一的，否则会造成多条数据返回而报错，这个逻辑同 get() 函数。 留神： 应用的字段，没有惟一的束缚，并发的调用这个办法可能会导致多条雷同的值插入。 字段默认值 假如 Blog 这个 model 除了 name, tagline 这两个字段外，还有 field_1 和 field_2 字段，然而他们不在咱们查问的条件内，作用为在创立的时候设置的默认值，咱们能够通过 defaults 来操作： blog, created = Blog.objects.get_or_create( name='hunter', tagline='tagline_test', defaults={ 'field_1': 'field_1_value', 'field_2': 'field_2_value' })最初对于这个函数，有个小提示，如果这个函数用在接口里，那么依据幂等性，咱们应该应用 POST 办法来申请，而不是 GET 申请。 ...

本篇笔记将介绍查问中的 defer 和 only 两个函数的用法，笔记目录如下： deferonly1、deferdefer 的英语单词的意思是 提早、推延，咱们能够通过将字段作为参数传入，能够达到在获取数据的时候指定不获取该字段数据，罕用于一些 textfield 字段上。 假如咱们有一个 TestModel，有一个字段名为 text_field，字段类型为 textfield，外面存了大量字符串数据. 那么如果咱们在获取这个 model 数据的时候，只想要这个 model 的其余字段信息， text_field 字段的内容咱们在这一次用不上，那么咱们就能够通过 defer() 办法来指定不获取该字段内容。 因为对于这一类大容量数据，零碎在从数据库中 fetch 数据的时候会破费大量工夫，而这部分不必要的工夫咱们是能够防止的。 TestModel.objects.defer("text_field")下面的语句将 text_field 这个字段名作为参数传入 defer() 函数，零碎返回数据的时候将不会返回他的字段。 咱们以 Blog 这个model为例对这个函数进行测试，咱们获取 Blog 的数据，然而指定不获取 name 这个字段的数据： Blog.objects.defer("name")咱们能够打印一下这条命令执行的 SQL 语句： Blog.objects.defer("name").query.__str__()SELECT `blog_blog`.`id`, `blog_blog`.`tagline` FROM `blog_blog`能够看到转化的 SQL 语句没有把咱们指定的 name 字段返回。 不获取外键关联的某些字段 如果咱们通过 select_related 关联了外键数据，也能够指定不获取外键的某些字段，比方： Entry.objects.select_related("blog").defer("blog__name")这样，在获取关联的 blog 的数据的时候，就不会获取 blog 的 name 字段数据。 defer 多字段 Entry.objects.defer('headline', 'body_text')主键字段不能defer 有一些字段咱们是 defer 也不会失效的，比方 model 的主键字段 id。 ...

github: https://github.com/xiaoxuan6/movie 下载相应的 release 能够间接运行。

本篇笔记目录如下： select_relatedprefetch_related在介绍 select_related 和 prefetch_related 这两个函数前，咱们先来看一个例子。 对于，Entry 和 Blog 这两个 model，后面介绍过，Blog 是 Entry 的外键，如下： class Blog(models.Model): name = models.CharField(max_length=100) tagline = models.TextField()class Entry(models.Model): blog = models.ForeignKey(Blog, on_delete=models.CASCADE) headline = models.CharField(max_length=255) body_text = models.TextField() pub_date = models.DateField() mod_date = models.DateField() authors = models.ManyToManyField(Author) number_of_comments = models.IntegerField() number_of_pingbacks = models.IntegerField() rating = models.IntegerField()比方咱们须要获取 Entry 的前十条数据，而后打印出关联的 Blog 的 name 字段信息。 咱们个别会如此操作： for entry in Entry.objects.all()[:10] if entry.blog: print(entry.blog.name) else: print("没有关联 blog 数据")然而这样会有一个问题，那就是，这个 for 循环的操作会查问数据十一次，一次查问 Entry 数据，十次是查问每个 entry_obj 关联的 blog 数据。 ...

这篇笔记将介绍 reverse、distinct、values 和 values_list 的用法。 本篇笔记目录如下： reverse()values()values_list()distinct()using()1、reverse()对 QuerySet 返回的后果进行反转，应用办法如下： from blog.models import BlogBlog.objects.filter(id__gte=2).reverse()通过 reverse() 办法，能够使本来是某个程序的数据程序倒转返回。 2、values()如果不应用 values() 办法，QuerySet 会返回 model 的所有字段，通过 obj.field_name 即可获取。 比方： blog_obj = Blog.objects.all()[0]blog_obj.name如果咱们在操作的时候仅仅想获取某一个或者某几个字段数据，则能够应用 values() 函数。 指定字段 如果是应用 values() 办法，则会仅仅返回相应字段的字典列表，比方： name_dict_list = Blog.objects.values("name")name_dict_list 数据则为： <QuerySet [{'name': 'python3'}, {'name': 'hunter'}, {'name': 'a'}]>name_dict_list 能够通过下标，拜访到单条数据。 >>> name_dict_list[0]{'name': 'python3'}>>> name_dict_list[0].get('name')'python3'不指定字段 如果咱们应用的时候不指定 values() 函数的参数，返回的则是该 model 所有字段的字典列表，比如说 Blog 这个 model 的字段为 id、name、tagline 三个，那么返回的是蕴含所有字段的字典列表，应用: Blog.objecrs.filter(id=1).values()返回的是： <QuerySet [{'id': 1, 'name': 'hunter', 'tagline': 'asd'}]>解决字段值返回 还能够对 values 指定的字段值进行解决后返回，比方全副都小写： ...

申明本文章中所有内容仅供学习交换，抓包内容、敏感网址、数据接口均已做脱敏解决，严禁用于商业用途和非法用处，否则由此产生的所有结果均与作者无关，若有侵权，请分割我立刻删除！ 本文章未经许可禁止转载，禁止任何批改后二次流传，擅自应用本文解说的技术而导致的任何意外，作者均不负责，若有侵权，请在公众号【K哥爬虫】分割作者立刻删除！ 逆向指标指标：某验三代、四代一键通过模式（无感验证）逆向剖析三代主页：aHR0cHM6Ly93d3cuZ2VldGVzdC5jb20vZGVtby9mdWxscGFnZS5odG1s四代主页：aHR0cHM6Ly9ndDQuZ2VldGVzdC5jb20v通信流程接口相干： 残缺流程： 三代抓包状况register-fullpage 会返回 challenge 和 gt 值，前期有用到。 get.php 会返回 c 和 s，同样前期会用到，这个申请同样须要 w 值，在某验的点选滑块里，这个申请能够不要 w 值，但在三代无感里，必须得要，不然最初是会验证失败的，可能不带 w 申请，返回的 s 是个假的值，导致最初验证失败。 ajax.php 验证是否胜利，同样须要 w 值，胜利则会返回一个 validate。 三代逆向剖析第一个 w 值置信看过K哥以前滑块、点选的文章，对于定位 w 的值很纯熟了，这里也是相似的，"\u0077" 就是 "w"，其值为 i + r，如下图所示： 次要就是 r、o、i 的值，要害代码： var r = t[$_CFAGw(1326)]() , o = $_BFx()[$_CFAGw(1367)](pe[$_CFAFP(416)](t[$_CFAGw(353)]), t[$_CFAGw(1393)]()) , i = O[$_CFAGw(1375)](o)先看看 r，跟进去就是咱们相熟的 RSA 了，和以前的解决一样，把代码扣下来或者用库都行。 同样须要留神的是上图中 this[$_CHCFe(1393)]() 也是个随机字符串，会遇到屡次，但整体一次验证下来都是雷同的值，不然验证会失败，点选、滑块等一系列都一样的。 ...

在接下来四五篇笔记中，将介绍 model 查询方法的各个细节，为咱们的查问操作提供各种便当。 本篇笔记将介绍惰性查找、filter、exclude、annotate等办法，目录如下： 惰性查找filterexcludeannotatealiasorder_by1、惰性查找后面咱们在介绍 Django 增删改查的时候，提到过他的惰性查找的规定。 也就是说一般的 filter 语句执行时，零碎并不会去查询数据库，只有当咱们真正应用外面的数据的时候，才会去查询数据库。 那么以下介绍几种，应用的时候会查询数据库的状况： 迭代 一个 QuerySet 是可迭代的，而且仅会在第一次迭代的时候查询数据库： for e in Entry.objects.all(): print(e.headline)切片 须要留神的是，应用 python 里的切片语法不会拜访数据库，比方： Entry.objects.all()[:3]然而，如果应用 step 语法则会拜访数据库，比方以下语句： Entry.objects.all()[:10:2]len() 当咱们应用 len() 函数去获取一个 QuerySet 的长度时，会拜访数据库，比方： len(Entry.objects.all())然而这种做法是不被举荐的，因为他会把 QuerySet 中的所有数据，都加载进去，而后计算长度。 如果想要获取总数量，咱们会应用另一个函数，.count()，这个咱们前面会提到。 list() 这个操作会强制查询数据库，而后将一个 QuerySet 转换成 python 里的 list。 entry_list = list(Entry.objects.all())在个别状况下，是不举荐的，因为绝对于 list 而言，QuerySet 能够执行的函数更多。 bool() 判断是否存在数据： if Entry.objects.filter(headline='hunter'): print('exists')然而，在Django 里个别也不举荐，因为有更高效的用法，那就是应用 .exists() 函数，这个在前面会具体介绍。 2、filter()filter 这个函数后面都有介绍，能够在其中增加合乎筛选条件，也能够通过链式的模式来操作。 然而链式执行的用法是 and 逻辑，如果想要用 or 逻辑，能够应用 Q() 用法来连用，后面也简略介绍过。 3、exclude()这个函数与 filter() 函数性能相同，是排除符合条件的数据。 ...

首先，从输入最根本的图形开始：输入一个'✮'。print('✮')那如何用循环实现输入五颗'✮'呢？ #代码块1i = 1while i <= 5: print ('✮') i += 1#理论输入后果如下：✮✮✮✮✮咱们如果想不换行输入，该怎么调整呢？这时候咱们能够想到print()的默认参数： print(self, *args, sep=' ', end='\n', file=None)知识点：如果要实现单个语句的多个参数同行输入，能够通过对默认参数sep=' '进行更改；如果要实现多个语句同行输入，能够通过对默认参数 end='\n'进行批改。在代码块1的循环中， print ('✮')理论被屡次执行，理论为多个语句，所以须要对end='\n'进行批改。'\n'示意换行，那咱们只有改为空格即可实现：' '。（注：此处引号内理论为一个空格键）让咱们再执行一次批改后上述代码： #代码块2i = 1while i <= 5: print ('✮',end=' ') #不换行输入 i += 1 #此时理论输入的就是咱们想要的后果：✮ ✮ ✮ ✮ ✮ 在以上操作的根底上，如果让你输入一个由'✮'组成的正方形该如何实现呢？ 这时咱们能够思考一下，把代码块2看做一个整体，即可同行输入五个'✮'，那咱们只有将代码块2反复执行五遍是不是就能够实现了呢？于是，咱们须要在此基础上为代码块2减少一个外循环的构造即可。为了不便了解，咱们先写一个循环的构造进去： #代码块3j=1while j <= 5: print('*') j+=1 #这里实现的是将'*'打印五遍：*****是不是和打印'✮'的构造一样？只不过此处是分行输入。这个时候咱们只有将代码块2嵌入到下面的代码块3中就能够实现输入一个由'✮'组成的正方形。如何嵌入呢？只有将下面的print()内容替换掉即可： #代码块4j=1while j <= 5: #将*代码块2*嵌入 i = 1 while i <= 5: print ('✮', end=' ') i += 1 j+=1 #然而此时并未如咱们所想，输入一个由'✮'组成的正方形`✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ ✮ 为什么这样呢？咱们仔细观察一下。一共输入了25个'✮ '，且是同行输入，也就是说代码块4理论仅实现了代码块2同行的五遍输入。于是，咱们只有将同行改为换行即可，对不对？可咱们是将代码块2看做了一个整体，没有可间接批改的print()语句怎么办？ ...

如何查看 pyav 依赖的动态链接库linux 下的计划在 Python 中查看 pyav 依赖的动态链接库，能够应用 ldd 命令。ldd 命令能够列出一个可执行文件或者共享库依赖的共享库列表。应用上面的命令能够查看 pyav 依赖的动态链接库： ldd $(python -c "import av; print(av.__file__)")这个命令会在终端中输入 pyav 依赖的所有共享库。如果零碎中没有装置 ldd 命令，能够通过装置 libc6-dev 包来装置该命令。在 Ubuntu 和 Debian 零碎中能够应用上面的命令来装置： sudo apt-get install libc6-devmac 下的计划在 macOS 上，能够应用 otool 命令来查看一个二进制文件的动态链接库依赖关系。对于 Python 模块，能够先找到对应的 .so 文件，而后应用 otool -L 命令来查看依赖关系。 例如，假如咱们要查看 pyav 模块的依赖关系，能够依照以下步骤操作： 装置 pyav 模块：pip install av找到 av 模块的 .so 文件门路： $ python -c "import av; print(av.__file__)"/path/to/site-packages/av/__init__.pyc其中，/path/to/site-packages 是你的 Python 环境的第三方库门路。 应用 otool -L 命令查看依赖关系： ...

编码进化回顾上次内容Ed Robert 的 守业之路 从 售卖 diy 组装配件到进军 计算器市场最初 公布 牛郎星8800intel 8080 的呈现 让 人人都有 本人的 个人电脑 Bill Gate 和 Paul Allen 要去 新墨西哥州 朝圣这场 奥德赛 会产生什么呢？奥德赛过后altair-8800 没有 操作系统也没有 编程环境应用 8080的汇编语言 两人首先 打了电话给 Ed Roberts说是给牛郎星 搭建了 Basic编程环境BasicBASIC 是由 达特茅斯学院院长、匈牙利人约翰·凯梅尼（John G. Kemeny）与数学系老师托马斯·卡茨（Thomas E. Kurtz）独特研制进去的 第一个BASIC程序 在1964年5月1日早上4时由BASIC编译程序进行编译后胜利运行 从此 cpu和内存 从 批处理 执行进入了 分时系统这是 促成multics我的项目立项的背景并且演化成 主机 + 终端 模式很多中学都有了 本人的终端甚至主机湖边中学私立学校 湖边中学 有一个终端能够连贯到 近程的主机上 比尔盖茨 和 保罗艾伦 都退出了编程小组从小玩汇编移植1975年 比尔·盖茨和 保罗·艾伦 把 PDP-10的 Basic 移植到 altair8800上 ...

编码进化个人电脑intel 8080 的呈现 让 人人都 可能有 一台计算机Ed Robert 的 守业之路 从 售卖 diy 组装配件到进军 计算器市场 计算器 毕竟不是 集体计算机 这计算机 是如何诞生的 呢？？diy 的 春天Ed Robert 从 爱好者diy计算器 嗅到了爱好者 diy个人电脑 的趋势 MITS帐上 已呈现 20多万元的赤字 罗伯茨 孤注一掷决定用 英特尔刚刚问世的 8080微处理器为爱好者 生产 新一代 个人电脑8080芯片啥都能做 加减乘除端口io逻辑运算 MITS 想要 发行股票 融资 但遇到了 1973年的石油危机从银行贷出 6.5万美元8080芯片 零售价为 397美元 罗伯茨 将价格砍到 75美元杂志宣传过后的资讯 次要靠 杂志 《公众电子》的编辑 所罗门 到处嗅寻 业内的 大新闻据说 罗伯茨 要造爱好者的个人电脑被动乘飞机 找上门来牛郎星这电脑 起什么名字 呢？ 所罗门 12岁的女儿 正在看 电视里的科幻片《星际旅行》飞船正飞向一颗新星 Altair(即中国牛郎星)新个人电脑 名字定了 ...

编码进化个人电脑计算机 通过电话网络 进行连贯 极客 利用技术 做一些乏味的尝试极客文化 是 认真钻研技术的 文化计算机 不再是 高校和钻研机构高墙外面的 神秘事物而是 生存中常见的 家用电器ibm 蓝色伟人脚步惨重dec 小型机一直鲸吞低端市场甚至组成网络干掉大型机根底不断进步 有新的 cpu 一直呈现 intel 的 8080moto 的 6800mos 的 6502个人电脑的时代 即将来临谁 制作了 第一台 集体电脑 呢?物理根底个人电脑 的 根底 是cpuapple 和 任天堂 基于 moto 的 6502第一台计算机 基于 intel 的 8080 这个是 intel 的一款 cpu intel 怎么来的呢？八叛逆诺伊斯 和 摩尔 出身于 肖克利的 仙童公司 FairChild有 八个人 不服肖克利的治理 进去单干 被称为 八叛逆 The Traitorous Eight 诺伊斯 在 八叛逆 中居于C位 1968年 ...

大数据时代，各行各业对数据采集的需要日益增多，网络爬虫的使用也更为宽泛，越来越多的人开始学习网络爬虫这项技术，K哥爬虫此前曾经推出不少爬虫进阶、逆向相干文章，为实现从易到难全方位笼罩，特设【0根底学爬虫】专栏，帮忙小白疾速入门爬虫，本期为 HTTP 协定的基本原理介绍。计算机网络模型计算机网络是指由通信线路相互连贯的许多自主工作的计算机形成的集合体，各个部件之间以何种规定进行通信，就是网络模型钻研的问题，除了规范的 OSI 七层模型以外，常见的网络档次划分还有 TCP/IP 四层协定以及 TCP/IP 五层协定，它们之间的对应关系如下图所示： 物理层（Physical）：负责传输比特流的硬件局部，包含各种传输介质（如铜线、光纤、无线信道）和传输设施（如集线器、交换机、路由器），基于电器个性发送高下电压（电信号）传输比特流（Bits），高电压对应数字 1，低电压对应数字 0，定义物理设施规范，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等；数据链路层（Data Link）：负责在物理层的传输介质上传送数据帧，并在源主机和目标主机之间建设逻辑链路，定义了电信号的分组形式，规定电信号多少位一组，每组代表什么，这一层还提供了对传输数据的检测和传输数据谬误的纠正以确保数据的牢靠传输，例如：Wi-Fi（IEEE 802.11）、ethernet（以太网）、FDDI（Fiber Distributed Data Interface，光纤分布式数据接口）等；网络层（Network）：负责在多个主机之间传送数据包，并为分组替换提供路由抉择性能，根本数据单位为 IP 数据报，次要协定：IP协定（Internet Protocol，因特网互联协定）、 ICMP（Internet Control Message Protocol，因特网管制报文协定）、IGMP（Internet Group Management Protocol，Internet 组治理协定）、ARP（Address Resolution Protocol，地址解析协定）等；传输层（Transport）：负责在源主机和目标主机之间的端到端的数据传输，并为下层协定提供牢靠的数据传输服务，次要协定：TCP 协定（Transmission Control Protocol，传输控制协议）、UDP 协定（User Datagram Protocol，用户数据报协定）；会话层（Session）：负责封装调用 TCP，会话层建设和管理应用程序之间的通信，封装了调用 TCP 去打包，而后调用 IP 协定去找路由等操作；表示层（presentation）：负责解决不同零碎之间的通信语法问题（数据格式化，代码转换，数据加密）；应用层（Application）：负责向用户提供网络服务，包含文件传输、电子邮件、近程登录等，次要协定：FTP（文件传送协定）、Telnet（近程登录协定）、DNS（域名解析协定）、SMTP（邮件传送协定），POP3协定（邮局协定），HTTP协定（Hyper Text Transfer Protocol）。 HTTP 发展史 HTTP 协定和 HTTPS 协定HTTP（Hypertext Transfer Protocol）中文名为超文本传输协定，其作用是把超文本数据从网络传输到本地浏览器，可能高效而精确地传输超文本文档。HTTP 是由万维网协会（World Wide Web Consortium）和 Internet 工作小组 IETF（Interner Engineering Task Force）单干制订的标准，目前被宽泛应用的是 HTTP 1.1 版本，现在也有不少网站反对 HTTP 2.0 版本。 ...

极客起源回顾上次内容上次回顾了 DEC公司的衰亡 从IBM的大型机 到DEC的小型机Mini Computer 再到DEC的终端 VT-100计算机根底元器件产生了进化 从ENIAC的 电子管到PDP系列的 晶体管新的器件 体积小了价格低了稳定性 进步了而且 连成了网络ARPA网 就是 最后的Internet 在这 基于电信网络的 计算机网络 上一种 新兴文化 正在衰亡 什么 文化 呢？电话飞客(phreaker)随着 电话网络 越来越发达长途电话的 费用 令人 不爽有人 开始钻研 电话 网络 零碎 DTMF dual-tone multifrequency按键 对应着 两个频率两个频率 对应 一个数字每个数字通过 两个频率叠加频率叠加 的 声音 和 通信链路 没有关系近程通信内线电话 是 间接拨通的 内线电话 通过 Trunk Lines来管制 通断与否 靠的是一个频率 2600Hz有 这个频率 存在就能够 免费打短途发现John Draper发现 拨号的时候 吹口哨能够 免费打长途电话 尽管 不是100%胜利然而 有可能好用随后 他发现了 好用的工具Captain Crunch买麦片 送的哨子 ...

这一篇笔记介绍 Django 零碎 model 的外键解决，ForeignKey 以及相应的解决办法。 这是一种一对多的字段类型，示意两张表之间的关联关系。 本篇笔记的目录如下： on_deleterelated_namerelated_query_name外键字段的保留1、on_delete假如有两个 application，app1 和 app2 app1 下的 某个 model 为 App1 app2 下的 某个 model 为 App2 # app1/models.pyclass App1(models.Model): app2 = models.ForeignKey("app2.App2", on_delete=models.CASCADE)# app2/models.pyclass App2(models.Model): pass当咱们设置 ForeignKey 的时候，有一个 on_delete 参数，次要用于当被关联的外键的数据被删除时，本身数据的解决。 在咱们下面的两个 model 的例子便是，当 App2 的某个数据被删除时，关联了该条数据的 App1 的数据的解决形式。 解决形式次要有以下几种： CASCADE关联删除，App2 的数据被删除时，App1 关联的数据也被删除 PROTECT爱护解决，如果 App2 的数据被 App1 关联，那么关联了的 App2 的数据不会被删除 SET_NULL置空解决，如果 App2 的数据被删除，App1 中关联了该条被删除的App2的数据这个字段都会被设置为 NULL DO_NOTHING不解决，原数据不会有任何操作，也就是说 App2 的某条数据被删除，App1 中的援用还在。 但其实这是一种不举荐的做法，因为如果拜访到 App1 中的这条数据，用到了 app2 这个字段，就会报错。 ...

Python 中有一把驰名的锁——全局解释器锁（Global Interpreter Lock，简写 GIL），它的作用是避免多个本地线程同时执行 Python 字节码，这会导致 Python 无奈实现真正的多线程执行。（注：本文中 Python 解释器特指 CPython） 这把锁在 Python 的晚期倒退中具备踊跃的作用（单核 CPU 时代），然而，它妨碍了 Python 在多核 CPU 上的并行编程，引起了开发者们一劳永逸的诟病。 GIL 影响的次要是 CPU 密集型工作，比方科学计算与数值计算工作。 在最近公布的 PEP-703 中，它概括了 GIL 对科学计算（次要是 AI/ML）造成的四类问题： GIL 导致许多并行化操作难以表白（影响强化学习、DeepMind、医学医治及生物钻研等畛域）GIL 影响了 Python 库的可用性（例如 PyTorch、scikit-learn、NumPy）GIL 导致无奈充分利用 GPU 资源（例如计算机视觉工作）GIL 导致难以部署 Python AI 模型（例如基于神经网络的 AI 模型）社区中想要移除 GIL 的呼声以及尝试，此起彼伏，绵绵不绝，但这个话题始终悬而未决。 埋怨、质疑、不满、不甘、期盼等这些诸多的情绪，不是那么容易平息的。然而，从一个积重已久的宏大的我的项目中移除一个根基性的设计，又谈何容易？ 2023 新年刚过，这个话题又一次热了起来，又一轮对 GIL 的挑战开始了。 这一次，事件仿佛有了新的转折，这次兴许能胜利了呢？ PEP-703 在往年 1 月 9 日新鲜出炉，尽管它目前仍是“草案”状态未被驳回，然而这份 PEP 的意义非常重大！ （注：每个 Python 学习者都应该根本理解 PEP，倡议浏览《学习Python，怎能不懂点PEP呢？ 》） 这个 PEP 的作者是 Sam Gross，他是 nogil 我的项目的作者。Python猫的老读者应该有印象，咱们在 2021 年曾翻译过他与 Python 外围开发者们的一次研讨会的纪要，这份纪要里概括了 nogil 的次要设计思路，同时答复了外围开发者们最为关注的约 20 个问题。 ...

〇、前言往期解读Flask 渐进式源码解读: 0.1本期导读Flask 0.2 提供了快捷生成 JSON 响应的函数：jsonify，如何实现的呢？网络中的字节流数据如何传递到 Flask，Flask 又是如何生成字节流数据返回给客户端的？咱们从服务器接管到 HTTP 音讯说起。 一、服务器接管到 HTTP 音讯HTTP 音讯是“一问一答”的模式，客户端提问（申请），服务端答复（响应）。先有客户端还是先有服务端？ 去小卖铺买冰淇淋，如果老板不在店里，在店里喊：“老板，来个冰淇淋”，老板能有回复吗？不能，因为老板没有在接管音讯，必须要老板在线，处于接管音讯的状态，咱们收回的“申请”，能力失去“响应”。客户端与服务端也是同样的情理，必须先在服务端监听申请，而后能力收到客户端发送的申请。 客户端发送的 HTTP 音讯有指标地址：主机:端口，是基于 TCP/IP 协定传输的，socket 把 TCP/IP 层简单的操作形象封装为了几个简略的接口，供应用层调用实现程序在网络中的通信。 在 UNIX 操作系统中，socket 就是一个文件，在服务端调用 socket 接口监听 TCP 申请，实际上是创立了一个可读的文件，当文件中有数据被写入时，就收到了客户端发来的申请。 《Flask 渐进式源码解读: 0.1》中说到，执行 serve_forever 即可启动 Flask 服务，来具体看看： def _eintr_retry(func, *args): while True: try: return func(*args) except (OSError, select.error) as e: if e.args[0] != errno.EINTR: raiseclass BaseServer: def serve_forever(self, poll_interval=0.5): self.__is_shut_down.clear() try: while not self.__shutdown_request: r, w, e = _eintr_retry(select.select, [self], [], [], poll_interval) if self.__shutdown_request: break if self in r: self._handle_request_noblock() finally: self.__shutdown_request = False self.__is_shut_down.set()r, w, e = _eintr_retry(select.select, [self], [], [], poll_interval) 相当于执行 select.select([self], [], [], poll_)，这是一个零碎调用，返回值是三个列表，蕴含已就绪对象，若返回值 r 非空，示意已胜利创立可读的 socket 文件，即启动了 socket 服务，开始监听申请。 ...

用ffmpeg查看视频文件时长 一个视频文件的时长有很多种： 容器时长流时长文件时长

我国目前并未出台专门针对网络爬虫技术的法律标准，但在司法实际中，相干裁决已不足为奇，K哥特设了“K哥爬虫普法”专栏，本栏目通过对实在案例的剖析，旨在进步宽广爬虫工程师的法律意识，通晓如何非法合规利用爬虫技术，警钟长鸣，做一个违法、护法、有准则的技术人员。前情提要《互联网搜索引擎服务自律公约》（简称《自律公约》）系在工业和信息化部的领导下，由中国互联网协会牵头组织十二家互联网企业于2012年11月1日在北京举办签订，参加企业包含：百度、即刻搜寻、盘古搜寻、奇虎 360、隆重文学、搜狗、腾讯、网易、新浪、宜搜、易查有限、中搜等。该公约第七条第一款规定：遵循国内通行的行业常规与商业规定，恪守机器人协定（robots 协定）。第八条规定：互联网所有者设置机器人协定应遵循偏心、凋谢和促成信息自在流动的准则，限度搜索引擎抓取应有行业公认正当的正当理由，不利用机器人协定进行不正当竞争行为，踊跃营造激励翻新、偏心公正的良性竞争环境。 案情介绍一审受理：2013年1月28日、二审终判：2020年7月3日，为期时长八年！ 上诉人： 北京百度网讯科技有限公司（简称百度网讯公司） 百度在线网络技术（北京）有限公司（简称百度在线公司） 被上诉人： 北京奇虎科技有限公司（简称奇虎公司，360） 百度网讯公司和百度在线公司称，其相干网站均通过 robots 协定设置了拜访限度，其 robots 协定采取的是“白名单”制度，即只有该文件中明确列举的搜索引擎的网络机器人能力抓取百度旗下相干网站的内容，未列举的其余搜索引擎均不能抓取。2012年8月16日，360 搜索引擎上线经营，但百度网讯公司和百度在线公司的相干网站的 robots 协定均未将 360 搜索引擎列入其“白名单”中。百度方面认为，360 搜寻在未取得百度公司容许的状况下，违反业内公认的 robots 协定，抓取百度旗下百度晓得、百度百科、百度贴吧等网站的内容，曾经形成了不正当竞争，并向奇虎索赔1亿元。 百度方面称，奇虎公司利用 360 搜索引擎等，强行抓取网民的浏览数据和信息到搜寻服务器，齐全忽视 robots 协定，这一做法目前曾经导致大量企业内网信息被泄露。2012年年底，百度工程师通过一个名为“鬼节捉鬼”的测试，证实了 360 浏览器存在擅自上传“孤岛页面”等隐衷内容到 360 搜寻的行为。 360 方面则认为，360 搜寻索引这些内容页面并不涉嫌进犯百度的权利，实际上还为百度带来了大量的用户和流量，百度应该感激 360。 百度公司在本案中指控奇虎公司的 360 搜寻存在以下不正当竞争行为： 忽视百度公司设置的 robots 协定，擅自抓取、复制百度网站相干页面并生成网页快照复制件存储于奇虎公司本身服务器中；在明确得悉百度公司回绝其抓取百度网站内容后，依然持续抓取、复制百度网站内容并生成网页快照复制件存储于奇虎公司本身服务器中；在网络用户点击 360 搜寻的搜寻后果页中来自于百度网站的链接的题目时，间接向网络用户提供其复制存储在本身服务器上的“网页快照”等，上述行为形成不正当竞争。奇虎公司也认为百度网讯公司、百度在线公司存在不正当竞争行为，奇虎公司提交的(2013)京方圆内经证字第00364号公证书、(2013)京方圆内经证字第06932号公证书、(2013)京方圆内经证字第11476号公证书及(2015)京方圆内经证字第00228号公证书显示，自2012年8月以来，百度网讯公司、百度在线公司始终在其相干网站的 robots 协定中排除 360 搜索引擎。百度网讯公司、百度在线公司对上述事实予以认可，但认为 robots 协定是国内通行的行业常规和商业道德，容许和/或限度全副和/或特定搜索引擎抓取是 robots 协定的应有之义，百度 robots 协定的“白名单”制度仅容许特定的几家搜索引擎抓取，对除此之外的所有其余搜索引擎均不容许抓取，不存在不正当竞争行为。 奇虎公司提交的(2013)京方圆内经证字第05960号公证书显示，应用 360 搜索引擎搜寻到百度的相干网站后，在点击拜访时，会呈现拜访被阻断并跳转到百度搜索引擎网站的景象。奇虎公司认为百度采取的相干技术措施会导致网络用户在应用 360 搜索引擎时的用户体验度降落。百度网讯公司、百度在线公司对上述事实予以认可，但认为这是针对奇虎公司不恪守百度 robots 协定而采取的自力救济措施。 法院观点百度网讯公司、百度在线公司通过设置 robots 协定的形式限度 360 搜索引擎对其相干网页的抓取与 robots 协定的初衷南辕北辙。robots 协定的初衷是为了指引搜索引擎的网络机器人更无效的抓取对网络用户有用的信息，从而更好的促成信息共享，而百度网讯公司、百度在线公司的行为会造成网络用户通过 360 搜索引擎无奈失去残缺的搜寻后果，人为设置了信息流动的阻碍。须要强调的是，360 搜索引擎属于通用搜索引擎，而通用搜索引擎的网络机器人进入一个对公众凋谢的网站抓取信息通常并不会侵害网站的利益，反而有利于其宣传推广。事实上，目前绝大多数网站对通用搜索引擎持凋谢、欢送的态度，因为如果被搜寻到，就意味着更多的网页浏览量以及由此而带来的潜在用户。也正是因为这个起因，绝大多数网站非但不会应用 robots 协定禁止通用搜索引擎抓取，反而心愿可能更快的被搜寻进去并展现在搜寻后果中较为前列的地位，这也促成了搜索引擎竞价排名等商业模式的产生。而百度网讯公司、百度在线公司却在容许国内外支流搜索引擎抓取其网页内容的状况下，限度 360 搜索引擎抓取，其行为显然有悖于robots协定的初衷。 ...

编码进化回顾上次内容上次 回顾了 字符大战的后果 ibm 已经的 EBCDIC 因为字符不间断的隐患 导致后续 呈现 有数问题无奈补救7-bit 的 ASA X3.4-1963 字母序号间断 比拟字符时 效率高判断字符 是否是字母 也很容易取得了 IBM以外公司的 反对 为什么 ASA X3.4-1963 是 7-bit 编码？ 8-bit 不是才 正好一个字节 吗？ASA X3.4-1963 文档留神这篇文档 通篇提到6-bit、7-bit然而 没有提到Byte 那时候 还有没有 Byte这个词bite1956年 ibm工程师 Werner Buchholz第一次 应用了bite 来形容8-bit开音节读作[bait] bite 在1956年 太过超前时代毕竟 过后的计算机 还处于 从模仿 到数字 的过程中计算机的 输出设备是 指示灯电压表示波器 bite这个词 流传于Rand、 MIT、IBM为了 和bit 辨别 bite 的拼写 演化成 ByteASA X3.4-1963 公布IBM 编码演变 BCD码 4-bit 倒退到BCDIC 6-bit 蕴含了字符网络通信 让 计算机 不再是 孤岛 ...

2022年11月1日，咱们很快乐地发表，GWA2Python吉娃兔Python语言生产就绪版本曾经公布。通过历时两个多月的编码与移植， GWA2吉娃兔绝大部分外围性能均曾经由Python编程语言实现，当初开始起，编程用户能够应用Python语言，经由GWA2吉娃兔开发框架，设计开发各种应用程序了。为放弃一致性和兼容性，Python语言版本的GWA2吉娃兔，提供了与 GWA2 Java， GWA2 PHP， GWA2 Perl 等完全相同的API ，用户迁徙时，简直没有学习老本，平滑无缝地在须要应用Python语言的环境中，疾速部署、开发GWA2应用程序。 1.- GWA2的核心思想设计与接口实现 GWA2Python 的外围从接口定义中开展， inc/WebInterface.py 中定义了次要办法：set/getsetId/getIdsetTbl/getTblsetBy/getByexecBy/rmBy作为一个应用程序的根底类/父类， inc/WebApp.py 则具体实现了这些外围办法，并提供了该应用程序可能应用的其余第三方服务，如数据库, 文件系统，缓存服务等等，这些具体的基础设施和服务，也别离在 inc中做了预置。inc/Dba.pyinc/Filea.pyinc/Cachea.py….针对某一个具体的设施或服务，咱们也依照在此前博客日志中提到的五层分级进行了零碎设计和代码实现（GWA2Python吉娃兔改良简答为何须要软件开发框架， https://ufqi.com/blog/gwa2pyt... ），比方在最罕用的数据库服务中，咱们预置了相应的驱动程序和连贯程序：inc/Dba.py….inc/Conn.py , 负责数据库主机连贯….inc/DbDriver.py , 负责数据库服务的接口定义….inc/MySql.py , 负责具体数据服务的实现，如 MySql数据库….以上是 GWA2的外围，也是 GWA2Python的核心部件，当具备这些基础设施和服务后，基于其上的面向工作的开发将锦上添花，宛如GWA2吉娃兔的口号Easy那样， 轻松启动，疾速产出（ Easy along, swift yield ）。 2.- 局部 efinance 的示例代码 同时，如同咱们在2022年9月份的博客日志（ GWA2 in Python吉娃兔公布Python语言初始版本， https://ufqi.com/blog/gwa2-in... ）中提到的：“2022年9月早先，咱们在研发 有福金融UfqiFina （ ufqi.com/finance ）时，发现一个外围性能的类库有开源程序可用，而且是用 Python写成的，这确实是多路需要都会集到 Python编程语言上了。”咱们在 GWA2Python中集成了 efinance 的Python类库，使之可能轻易地读取到金融数据。在即日公布的GWA2Python 生产就绪版本中，咱们分享了一些简略地的例子程序，其中有些程序多半是基于集成、连贯 efinance 类库而写的。置信，如果有其余程序开发者也碰巧须要部署 efinance 并在心愿用 Python程序与现有的其余程序做对接，无疑，GWA2Python会是一个参考。efinance 自身的利用与编程，能够在 GitHub上参考示例代码或者相应的手册。 3.- GWA2 Python的命令行调用形式 此次公布的 GWA2Python 生产就绪版本是一个命令行调用形式的软件框架。对于命令行模式和浏览器模式，请参考之前的博客日志（ GWA2Java新增Cmdline命令行和JavaBean运行时模式，https://ufqi.com/blog/gwa2jav... ）。 ...

亚马逊的领导力准则是亚马逊文化的外围，它如同亚马逊的 DNA 融入贯通每一个重要决策，深深影响着每一位亚麻人、影响着每一位亚马逊的客户、合作伙伴以及每一位亚马逊云科技的构建者。同时，亚马逊的领导力准则对亚马逊与开源的互动形式也产生着深远的影响。 在上篇文章，咱们为大家讲述了亚马逊是如何在开源社区中践行最重要的一条领导力准则——客户至尚：通过始终以客户为核心，凝听开发者的反馈，通过单干和参加开源社区，让开源更易用。 本篇咱们想与大家分享咱们另一条领导力准则在开源文化中的实际——最高规范。 最高规范 不论是为开发者提供全托管开源软件服务，还是为自治理形式的客户提供各类简单的根底云服务，咱们都须要确保这些产品及服务可能在满足开发者需要的根底上具备足够的可靠性、安全性、稳定性。这就是亚马逊的另一领导力准则——最高规范。 亚马逊外部应用 Apache Lucene 多年，在 2019 年 Amazon.com 决定将搜寻服务 100% 转为由 Lucene 驱动。作为一项开源技术，Lucene 是否反对亚马逊运行的规模下的搜寻性能，迁徙是否会有业务危险？事实证明，亚马逊的退出，将 Lucene 搜寻性能的极限推向又一个新高峰。 Apache Lucene 我的项目主页https://lucene.apache.org/ 我的项目地址https://github.com/apache/lucene Apache Lucene 是一个应用 Java 构建的开源全文搜寻库，亚马逊的高级首席搜寻工程师 Mike McCandless（Lucene 和相干我的项目的长期贡献者）示意，在将 Lucene 的应用“推向极限”的过程中，亚马逊的工程师们发现了一些边缘毛糙 (rough edges)、破绽和其余问题，并无效解决了这些问题。 出于行业竞争或者产品策略的思考，Apache 2.0 许可证容许开发者们在应用开源产品时，能够自行批改代码且无需把更改回馈给上游。但亚马逊抉择了将代码批改和最佳实际踊跃回馈给 Lucene 社区以帮忙与之相干的其余我的项目。并且亚马逊的工程师们始终在加大参加开源我的项目的力度以更好地服务客户，即便在搜寻等可能发明竞争劣势的战略性畛域也是如此。 亚马逊曾经向 Lucene 提出了多项重要的改良，包含： 对 Lucene 索引代码进行的重大低级别更改, 实现并发 “更新” 和 “删除” ，使得在反对并发执行的硬件上的执行效率极大晋升； 建设自定义词频索引，将行为信号引入排名根据中（例如顾客在搜寻某个商品后可能的行为）； 泛滥谬误修复，并向上游分支推送更改。 Open 3D Engine 我的项目主页https://www.o3de.org/ 我的项目地址https://github.com/o3de/o3de 游戏、模仿开发人员对咱们说，从头开始构建 3D 工具老本昂扬，须要数年的开发工夫，并须要大量的资源来保护。要么将大部分资金破费在反复做他人或者本人曾经做过的事件上，要么只好应用那些难以定制的专用解决方案。他们想要更多的抉择，帮忙他们在生产过程中实现合作、自定义和创造性管制。 2021 年 7 月 7 日亚马逊官网公布一款模块化的、开源的、跨平台的 3D 引擎 Open 3D Engine (O3DE)，为从 3A 级游戏到电影品质的 3D 世界再到高保真模仿提供能源。这是一个开源我的项目，没有费用或者商业任务。O3DE 应用了 Apache 2.0 许可，并由 Linux 基金会治理。 ...