Python

楔子Python 有一个第三方模块：psutil，专门用来获取操作系统以及硬件相干的信息，比方：CPU、磁盘、网络、内存等等。 首先咱们要装置，间接 pip install psutil 即可，装置之后来看看它的用法。 CPU 相干获取 CPU 的逻辑数量 import psutilprint(psutil.cpu_count()) # 12获取 CPU 的物理外围数量 import psutilprint(psutil.cpu_count(logical=False)) # 6后果为 6，阐明是 6 核超线程；如果 CPU 的物理外围数 和 逻辑数相等，也为 12，则阐明是 12 核非超线程。统计 CPU 的用户／零碎／闲暇工夫 import psutilprint(psutil.cpu_times()) # scputimes(user=65531.796875, system=42440.76562500023, idle=1783904.3593749998, interrupt=5676.375, dpc=1846.609375)# psutil.cpu_times_percent() 性能与之相似, 只不过返回的比例返回的是一个 namedtuple，前面但凡构造长的和这里相似的，都是 namedtuple。 查看 CPU 的使用率 import psutilfor x in range(3): # interval：示意每隔0.5s刷新一次 # percpu：示意查看所有的cpu使用率 print(psutil.cpu_percent(interval=0.5, percpu=True))"""[6.1, 6.2, 9.4, 3.1, 0.0, 0.0, 0.0, 6.2, 3.1, 3.1, 3.1, 0.0][0.0, 0.0, 6.1, 0.0, 6.1, 3.0, 0.0, 3.0, 3.0, 3.0, 0.0, 9.1][0.0, 0.0, 6.2, 3.1, 3.1, 0.0, 3.1, 3.1, 3.1, 3.1, 0.0, 0.0]"""# 我这里cpu的逻辑数量是12, 所以每个列表外面有12个元素查看 CPU 的统计信息，包含上下文切换、中断、软中断，以及零碎调用次数等等 ...

常常给大家举荐好用的数据分析工具，也收到了铁子们的各种好评。这次也不例外，我要再举荐一个，而且是个爆款神器。 Excel和Jupyter Notebok都是我每天必用的工具，而且两个工具常常协同工作，始终以来工作效率也还算不错。但说切实，毕竟是两个工具，应用的时候必定会有一些切换的老本。 最近，在逛GitHub忽然发现了一款神器「PyXLL-Jupyter」，它能够完满将Jupyter Notebook嵌入到Excel中！是的，你没听错，应用它咱们就可在Excel中运行Jupyter Notebook，调用Python函数，实现数据共享。 一、装置首先，想要在Excel中运行Python代码，须要装置PyXLL插件。PyXLL能够将Python集成到Excel中，用Python代替VBA。 先用 pip 装置 PyXLL。 pip install pyxll而后再用PyXLL独特的命令行工具装置Excel插件。 >> pyxll install装置好了PyXLL在 Excel中的插件，下一步就是装置pyxll-jupyter软件包了。应用pip装置pyxll-jupyter软件包： pip install pyxll-jupyter装置结束后，启动Excel，将在PyXLL选项卡中看到一个新的Jupyter按钮。 单击此按钮可在Excel工作簿的侧面板中关上Jupyter Notebook。该面板是Excel界面的一部分，能够通过拖放操作勾销停泊或停靠在其余地位。 在Jupyter面板中，你能够抉择一个现有的Notebook或创立一个新的Notebook。创立一个新的Notebook，抉择新建按钮，而后抉择Python 3。 二、应用办法这样做有什么用途呢？ 1、Excel和Python共享数据比方，咱们要将数据从Excel导入Python。** 因为Excel和Python曾经在同一过程中运行了，所以在Python中拜访Excel数据以及在Python和Excel之间切换十分快。 更牛X的是，pyxll-jupyter还独自附带了一些IPython魔法函数，输出后一键即可实现同步。 %xl_get 将Python中的数据移到Excel，也是同理，非常简单。 无论是应用Python先加载数据集，再传输到Excel，还是其它模式，从Python复制数据到Excel非常容易。 %xl_set 当然，%xl_get和%xl_set都附带参数选项能够自定义导入导出规则。 2. 在Excel中应用Python绘图PyXLL的另一大用处就是它集成了简直所有支流的可视化包，因而咱们能够在Excel中利用这些可视化包随便绘图，包含matplotlib、plotly、bokeh和altair等。 %xl_plot 同样，应用魔法函数％xl_plot在Excel中能够绘制任何的Python图。任何一个受反对的可视化包也可进行绘图而后传递图形对象到Excel中，比方上图中应用pandas的绘图成果就很好。 %xl_plot df.plot(kind='scatter')3. 从Excel调用Python函数应用Excel离不开函数，而当咱们须要一些简单性能时，自带函数未必能满足咱们的需要。 通过PyXLL，咱们能够间接在Excel中调用Python函数，并对其进行实时测试。这就防止了Excel和Jupyter之间的来回切换老本，有点像dataframe的apply用法，写个函数间接与Excel完满交融。 函数写好后，还可将其增加到PyXLL Python我的项目中。这样当前每次都能够复用实现雷同性能，几乎不要太香！ from pyxll import xl_func@xl_funcdef test_func(a, b, c):    return (a * b) + c比方，输出以上代码在Jupyter中运行后，Python函数将立刻可被Excel工作簿调用。 不只是简略的函数，还能够将整个数据作为pandas的DataFrames传给函数，并返回任何的Python类型，比方numpy array、DataFrames，甚至还能够通过给@xl_func装璜器一个签名字符串来通知PyXLL输入什么类型。例如，以下函数： from pyxll import xl_func# 装璜器签名通知 PyXLL 如何转换函数参数和返回的值@xl_func("dataframe df: dataframe<index=True>", auto_resize=True)def df_describe(df):    # df 是一个从数据集里创立的 pandas DataFrame 传递给函数    desc = df.describe()    # desc 是新的 DataFrame（PyXLL转换为一组值并返回给Excel所创立的）    return desc当初能够编写简单的Python函数来进行数据转换和剖析，然而能够协调在Excel中如何调用或排序这些函数。更改输出会导致调用函数，并且计算出的输入会实时更新，这与咱们冀望的一样。 4. 代替VBAVBA脚本所需的性能函数，在Python中均有雷同的API。这对于相熟Python但不相熟VBA的同学相对是个好消息。 官网还给出了和VBA性能一样的API阐明文档。 Jupyter Notebook在Excel中运行，整个Excel对象都可用，所有操作就像在VBA编辑器中编写Excel脚本截然不同。 因为PyXLL在Excel过程内运行Python ，因而从Python调用Excel不会对性能造成任何影响。当然，也能够从内部Python过程调用Excel，但这通常要慢很多。在Excel中运行Jupyter Notebook，所有变得就不一样了！ 应用PyXLL的xl_app函数获取Excel.Application对象，该对象等效于VBA中的Application对象。弄清楚如何应用Excel对象模型进行操作的一种好办法是记录VBA宏，而后将该宏转换为Python。 下图中尝试将以后抉择单元格更改色彩。 三、总结PyXLL将完满交融Python和Excel，实现了以下性能，为表格数据处理晋升一个全新的高度。 Excel和Python共享数据在Excel中应用Python绘图从Excel调用Python函数代替VBA脚本不得不说这个工具是真的香，青睐Python的同学能够不必学习VBA了，Python脚本打天下。 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料，内容笼罩Python电子书、教程、数据库编程、Django，爬虫，云计算等等。或是返回编程学习网，理解更多编程技术常识。

空余工夫整顿了我认为 Python 编程必备的几个 VS Code 插件，分享一下。 如果你是初学小白，倡议全副装置并尽快上手，敲代码效率间接腾飞。当然如果你是老司机，也可查缺补漏。 一、Python Python这个插件必装，别问为啥！因为它是微软VSCode开发团队本人开发的，亲儿子的级别。尽管 VSCode 不装置任何插件也能高亮Python代码，但该插件提供的性能远不止如此，还有很多弱小的性能，比方： 智能补全：通过主动补全，代码导航，语法查看等来编辑代码代码查看：应用Pylint、Flake8获取额定的代码剖析，查看编程谬误代码格局：用black，autopep 或 YAPF 调整代码格局调试：调试Python脚本，Web应用程序以及近程或多线程过程测试：通过测试Explorer中unittest，pytest或nose运行和调试测试Jupyter Notebook：创立和编辑Jupyter Notebook，增加和运行代码单元、渲染图、通过变量资源管理器可视化变量、应用数据查看器可视化数据框等等环境：主动激活并在virtualenv、venv、pipenv、conda 和 pyenv 环境之间进行切换重构：通过变量提取、办法提取和导入排序来重构Python代码如下所示： 二、Python Snippets Python Snippets 插件能够让咱们的 Python 编程更加高效。它蕴含了大量的内置办法，以及string、list、sets、tuple、dictionary、class代码片段，并且还为每个代码段提供至多一个示例。 所有python内置办法代码片段所有python string片段所有python list片段所有python set片段所有python tuple片段所有python dictionary 字典片段并蕴含许多其余代码段（例如if/else、for、while、while/else、try/catch，文件解决和类片段和oop类示例（多态性、封装、继承.i.g）如下所示： 三、Python Docstring Generator Python Docstring Generator能够主动创立docstring，这真的为开发人员缩小了的很大工作量。并且，生成的文档字符串遵循所有规范格局，包含Google、docBlockr、Numpy、Sphinx和PEP0257。它的次要性能包含： 疾速生成一个可通过Tab键浏览的docstring代码段在几种不同类型的文档字符串格局之间进行抉择通过pep484类型提醒、默认值和var名称推断参数类型反对args，kwargs，修饰符，谬误和参数类型上面是实例： 具体应用办法、扩大配置、自定义模板可参考文档： 四、Python Test Explorer for Visual Studio Code 这个插件通过应用Test Explorer UI运行Python Unittest或Pytest测试，对于功能测试十分不便。具体性能如下： 在VS Code的侧栏中的“测试”视图中显示“测试资源管理器”，其中蕴含所有检测到的测试、套件及其状态在测试发现期间不便的错误报告单元测试和Pytest调试在资源管理器中抉择测试后，显示失败的测试日志反对多根工作区反对Unittest和Pytest测试框架及其插件 五、Python Preview Python Preview可展示可视化调试的过程，并增加到咱们的Python代码中。它将调试代码转换为带有动画和图形元素的交互式会话，以示意应用程序状态，对于代码调试十分直观。 六、Python Type Hint Python Type Hint提供针对Python的类型提醒主动实现性能，以及针对内置类型、类和键入模块的实现项。 提供内置类型、预计类型和键入模块的类型提醒实现项预计正确的类型，提供实现项能够在工作区中搜寻Python文件以进行类型预计 七、Jupyter Jupyter能够说是我最喜爱的VS Code插件之一，能够让咱们在VS Code中完满应用Jupyter Notebooks。应用办法如下： 1、创立新笔记本，关上命令面板（Windows：Ctrl + Shift + P；iOS：Command + Shift + P），而后抉择命令Jupyter: Create New Blank Jupyter Notebook。 ...

不得不说，Jupyter对于表的解决真的是越来越不便了，很多库能够间接实现可视化操作，无需写代码。然而这还不够，最近看到一个神器叫Mito，它真的是做到了无需写一行代码，而且手动的操作能够主动转换为代码，供后续批量化操作，这几乎不要太爽。 一、Mito是什么？Mito是Jupyter notebook的一个插件，作用是编辑电子表格，并在编辑表格（带格局转换性能）时，能够生成绝对应的Python代码。上面是具体的操作演示，感受一下它的弱小！ 应用Mito和应用Excel表格没什么太大区别，只须要把握一些Mito的自定义函数即可，而后它会主动生成pandas处理表的代码。 二、Mito 装置Mito的装置要求比较简单，有两个： Python 3.6或更高版本须要装置了Node关上终端，间接pip装置： pip install mitosheet而后，装置JupyterLab扩大管理器。这个命令可能须要运行个几分钟： jupyter labextension install @jupyter-widgets/jupyterlab-manager@2最初，启动JupyterLab就完事了。 jupyter lab也能够用conda装置到一个虚拟环境里。 三、Mito 操作方法创立一个表import mitosheetmitosheet.sheet()导入数据能够应用pandas读入数据生成dataframe给mitosheet。如果不想写代码，也能够手动点导入按钮导入数据，导入数据代码会主动生成。 # import Python packagesimport mitosheetimport pandas as pd# Create a simple dataframe to displaycar_data = pd.DataFrame({'car': ['Toyota', 'Nissan', 'Honda', 'Mini Cooper', 'Saturn'], 'mph': [60, 50, 60, 75, 90], 'length': [10, 12, 13, 8, 9]})# render the Mitosheet with car_datamitosheet.sheet(car_data)操作方法和Excel一样，个别的两种办法。 １.公式法：   如果对公式纯熟，间接敲入函数即可，比方sum、sumif这种等等。公式法其实就是个孰能生巧的事。我看了下，Mito中的函数不简单，应用很容易上手。 ２.剖析工具：   如果不纯熟函数，Mito也提供了剖析工具，比方合并、透视表、筛选、排序、保留剖析等局部性能，都是点点点的操作。对于剖析工具，给大家演示几种常见的数据处理操作，找找感觉。 合并数据集Mito的合并性能可用于将数据集程度组合在一起。通过查找两个表要害列的匹配项，而后将这些匹配项数据组合到一行中。首先，抉择要合并在一起的两个Mito工作表。其次，抉择合并的键。最初，抉择保留哪些列。 数据透视表 首先，抉择一个关键字对数据分组。而后，如果想进一步将组分层为单个单元格，持续抉择列。最初，抉择聚合的列和办法。 筛选 Mito通过组合过滤器和过滤器组来提供弱小的过滤性能。 过滤器是单个条件，对于该列中的每个单元格，其评估后果为true或false。过滤器组是联合了布尔运算符的过滤器聚合。 排序 保留剖析 能够像保留宏一样保留剖析。通过保留剖析，能够保留利用于数据的转换，以便当前能够将其从新利用于新的数据集。 四、后话对于Mito的背地原理，这里不过多介绍，Aaron Diamond-Reivich、Jake Diamond-Reivich和Nate Rush，他们是在搞数据分析的时候，萌发了想要制作Mito的想法。据理解，目前这个软件还没有开源，他们还在思考如何反对保护这个我的项目，并转到开源门路上来。 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料，内容笼罩Python电子书、教程、数据库编程、Django，爬虫，云计算等等。或是返回编程学习网，理解更多编程技术常识。

Python根底篇 1、为什么学习Python 家里有在这个IT圈子外面，也想让我接触这个圈子，而后给我倡议学的Python，而后本人通过百度和向有学过Python的同学理解了Python，Python这门语言，入门比较简单，它简略易学，生态圈比拟弱小，波及的中央比拟多，特地是在人工智能，和数据分析这方面。在将来我感觉是往自动化，人工智能这方面倒退的，所以学习了Python。 2、通过什么路径学习Python 刚开始接触Python的时候，到网上外面跟着视频学根底，再起初网上到看技术贴，而后看到有人举荐廖雪峰的Python教程， 练我的项目到GitHub下面找一些小我的项目学习。 3、谈谈对Python和其余语言的区别 Python属于解释型语言，当程序运行时，是一行一行的解释，并运行，所以调式代码很不便，开发效率高， 还有龟叔给Python定位是任其自在倒退、优雅、明确、简略，所以在每个畛域都有建树，所有它有着十分弱小的第三方库。 特点： 语法简洁柔美，功能强大，规范库与第三方库都十分弱小，而且应用领域也十分广 可移植性，可扩展性，可嵌入性 毛病：运行速度慢 解释型 python/php编译型 c/java/c#Python弱类型 （1）与java相比：在很多方面，Python比Java要简略，比方java中所有变量必须申明能力应用，而Python不须要申明,用大量的代码构建出很多性能;（高效的高级数据结构） （2）与php相比：python规范包间接提供了工具，并且绝对于PHP代码更易于保护; （3）Python与c相比： Python 和 C Python这门语言是由C开发而来。 对于应用：Python的类库齐全并且应用简洁，如果要实现同样的性能，Python 10行代码能够解决，C可能就须要100行甚至更多。 对于速度：Python的运行速度相较与C，绝逼是慢了。 Python的劣势： 1、Python 易于学习； 2、用大量的代码构建出很多性能；（高效的高级数据结构） 3、Python 领有最成熟的程序包资源库之一； 4、Python齐全反对面向对象； 5、Python是跨平台且开源的； 6、动静类型。 4、简述解释型和编译型编程语言 解释型：就是边解释边执行（Python，php） 编译型：编译后再执行（c、java、c#） 5、Python的解释器品种以及相干特点？ CPython 当咱们从Python官方网站下载并装置好Python 3.6后，咱们就间接取得了一个官网版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。 CPython是应用最广的Python解释器。教程的所有代码也都在CPython下执行。 IPython IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所加强，然而执行Python代码的性能和CPython是齐全一样的。好比很多国产浏览器尽管外观不同，但内核其实都是调用了IE。 CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。 PyPy PyPy是另一个Python解释器，它的指标是执行速度。PyPy采纳JIT技术，对Python代码进行动静编译（留神不是解释），所以能够显著进步Python代码的执行速度。 绝大部分Python代码都能够在PyPy下运行，然而PyPy和CPython有一些是不同的，这就导致雷同的Python代码在两种解释器下执行可能会有不同的后果。如果你的代码要放到PyPy下执行，就须要理解PyPy和CPython的不同点。 Jython Jython是运行在Java平台上的Python解释器，能够间接把Python代码编译成Java字节码执行。 IronPython IronPython和Jython相似，只不过IronPython是运行在微软.Net平台上的Python解释器，能够间接把Python代码编译成.Net的字节码。 小结： Python的解释器很多，但应用最宽泛的还是CPython。如果要和Java或.Net平台交互，最好的方法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独 PyPy 由Python写的解释器，它的执行速度是最快。PyPy采纳JIT技术，对Python代码进行动静编译（留神不是解释）， 绝大部分Python代码都能够在PyPy下运行，然而PyPy和CPython有一些是不同的，这就导致雷同的Python代码在两种解释器下执行可能会有不同的后果。 Jython Jython是运行在Java平台上的Python解释器，能够间接把Python代码编译成Java字节码执行。 IronPython IronPython和Jython相似，只不过IronPython是运行在.Net平台上的Python解释器，能够间接把Python代码编译成.Net的字节码。 小结： Python的解释器很多，但应用最宽泛的还是CPython。如果要和Java或.Net平台交互，最好的方法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。 6、位和字节的关系 1字节 = 8 位位（bit），数据存储是以“字节”（Byte）为单位，数据传输是以大多是以“位”（bit，又名“比特”）为单位，一个位就代表一个0或1（即一个二进制），二进制是形成存储器的最小单位，每8个位（bit，简写为b）组成一个字节（Byte，简写为B），字节是最小一级的信息单位7、b、B、KB、MB、GB的关系 ...

1、阐明 vim是一个平凡的编辑器，不仅仅是独特的编辑形式，还有她弱小的扩大能力。然而vim自身用来写插件的语言vimL性能有很大的局限性，实现简单性能的插件往往力不从心，运行效率也不高。vim早就想到了这一点，提供了许多内部语言界面。 2、编译vim 对vim进行编译，使其反对Python。 configure在编译前增加--enable-pythoninterp和--enable-python3interp选项，使其别离反对Python2和Python3进行编译后，您能够通过vim--version|grep+python来查看Python是否已失去反对，并且在后果中应包含+python和+python3，当然您还能够将其编译为仅反对Python2或Python3。 以上就是python vim插件的介绍，心愿对大家有所帮忙。更多Python学习指路：python常见问题

1、vim.command(str) 执行vim中的命令str(ex-mode)，返回值为None 实例 :py vim.command("%s/\s\+$//g"):py vim.command("set shiftwidth=4"):py vim.command("normal! dd")2、vim.eval(str) 求vim表达式str的值。 返回后果类型为： string: 如果vim表达式的值的类型是string或number list：如果vim表达式的值的类型是一个vim list（:h list） dictionary：如果vim表达式的值的类型是一个vim dictionary（:h dict） 实例 :py sw = vim.eval("&shiftwidth"):py print vim.eval("expand('%:p')"):py print vim.eval("@a")以上就是python vim模块的2种函数接口，心愿对大家有所帮忙。更多Python学习指路：python常见问题

1、能够连贯迭代器的函数 chain:按程序将多个迭代器连接成一个迭代器。 Cycle:反复迭代器的所有元素。 Tee:将迭代器宰割成多个平行迭代器。 zip_longest:相似于内置的zip函数，但它能应酬不同长度的迭代器。 2、可能从迭代器过滤元素的函数 islice:在不复制的状况下，依据索引值切割迭代器。 在判断函数为True时，从迭代器中一一返回元素。 dropwhile:首次判断函数为False时，一一返回迭代器中的元素。 filterfalse：从迭代器中一一返回能令，判断函数是False的所有元素。和内置的filter函数相同。 3、可能组合迭代器中元素的函数 product:依据迭代器中的元素计算笛卡儿积，而后返回。能够用product改写深度嵌套列表指南操作。 permutations:用迭代器中的元素构建长度为n的各种有序排列，并将所有排列模式返回给调用者。 combination:用迭代器中的元素构建长度为n的各种无序组合，并将所有组合模式返回给调用者。 以上就是python迭代器中的函数整顿，心愿对大家有所帮忙。更多Python学习指路：python常见问题

if语句判断多个条件。 少数状况下，仅仅一个判断条件难以满足咱们接下来的操作，通常都是多个条件下执行前面的语句。因为 python 并不反对 switch 语句，所以多个条件判断，只能用 elif 来实现，接下来咱们就来看看如何用if语句判断多个条件。 根本语法： """if 要判断的条件: 条件成立的时候,要做的事件 .....elif 要判断的条件: .....elif 要判断的条件: ....else: 条件不成立的时候,要做的事件 ....."""拓展内容： if 判断条件： 1）if判断条件前面个别是比拟运算符链接的表达式，两头可能还有逻辑运算等，判断语句前面冒号不要遗记； 2）如果满足某个条件就执行上面的代码块，如果不满足就间接疏忽。所以在执行过程中程序运行到if处，首先判断if所带的条件，如果条件成立，就返回True，则执行if所带的代码；如果条件不成立，就返回值是False, 跳过if语句持续向下执行。 更多python语句相干知识点学习之路：segmentfault学习网

python因为自身蕴含着丰盛的库、模块以及各种函数，所以作用是十分大的，比方只须要利用一个简略的库——Albumentations，便能够轻松实现图像的简略解决，所以常常成为python图像处理。 一、Albumentations装置： 库都是须要装置的，装置形式也比拟常见，应用pip，办法如下： sudo pip install albumentations 二、性能： 1、疾速实现图片的数据加强 2、作为api接口简略应用 3、设置个性化定制 4、便于与其余框架联合应用 三、实例应用： import albumentations as Aimport randomBOX_COLOR = (255, 0, 0)TEXT_COLOR = (255, 255, 255)def visualize_bbox(img, bbox, color=BOX_COLOR, thickness=2, **kwargs): #height, width = img.shape[:2] x_min, y_min, w, h = bboxx_min, x_max, y_min, y_max = int(x_min), int(x_min + w), int(y_min), int(y_min + h) cv2.rectangle(img, (x_min, y_min), (x_max, y_max), color=color, thickness=thickness)return img在图片解决中，应用Albumentations库进行操作，还是非常简单实用的，大家感兴趣的话，也能够自行进行尝试哦~ 对于python图像处理相干知识点举荐学习： 十个Python罕用的图像处理工具 用Python简略解决图片 python更多知识点学习欢送拜访segmentfault学习网，python常见问题、免费视频、手册不定期分享，欢送珍藏查看。

一、图像二值化 图像二值化是指将图像上像素点的灰度值设定为0或255，即整个图像出现显著的黑白成果的过程。 二、python图像二值化解决 1.opencv简略阈值cv2.threshold 2.opencv自适应阈值cv2.adaptiveThreshold 有两种办法可用于计算自适应阈值：mean_c和guassian_c 3.Otsu's二值化 三、示例： import cv2import numpy as npfrom matplotlib import pyplot as plt img = cv2.imread('scratch.png', 0)# global thresholdingret1, th1 = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)# Otsu's thresholdingth2 = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)# Otsu's thresholding# 阈值肯定要设为 0 !ret3, th3 = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)# plot all the images and their histogramsimages = [img, 0, th1, img, 0, th2, img, 0, th3]titles = [ 'Original Noisy Image', 'Histogram', 'Global Thresholding (v=127)', 'Original Noisy Image', 'Histogram', "Adaptive Thresholding", 'Original Noisy Image', 'Histogram', "Otsu's Thresholding"]# 这里应用了 pyplot 中画直方图的办法, plt.hist, 要留神的是它的参数是一维数组# 所以这里应用了( numpy ) ravel 办法,将多维数组转换成一维,也能够应用 flatten 办法# ndarray.flat 1-D iterator over an array.# ndarray.flatten 1-D array copy of the elements of an array in row-major order.for i in range(3): plt.subplot(3, 3, i * 3 + 1), plt.imshow(images[i * 3], 'gray') plt.title(titles[i * 3]), plt.xticks([]), plt.yticks([]) plt.subplot(3, 3, i * 3 + 2), plt.hist(images[i * 3].ravel(), 256) plt.title(titles[i * 3 + 1]), plt.xticks([]), plt.yticks([]) plt.subplot(3, 3, i * 3 + 3), plt.imshow(images[i * 3 + 2], 'gray') plt.title(titles[i * 3 + 2]), plt.xticks([]), plt.yticks([])plt.show()对于图像二值化相干知识点举荐查看： ...

能够通过两种办法利用python读取大文件：第一种是利用yield生成器读取；第二种是：利用open()自带办法生成迭代对象，这个是一行一行的读取。 1、利用yield生成器读取 def readPart(filePath, size=1024, encoding="utf-8"): with open(filePath,"r",encoding=encoding) as f: while True: part = f.read(size) if part: yield part else: return NonefilePath = r"filePath"size = 2048 # 每次读取指定大小的内容到内存encoding = 'utf-8'for part in readPart(filePath,size,encoding): print(part) # Processing data2、利用open()自带办法生成迭代对象，这个是一行一行的读取 with open(filePath) as f: for line in f: print(line) # Processing datapython读取文件相干操作文档欢送查看： python如何读取文件的数据 更多Python常识能够关注segmentfault自学网

在Python中，字符串是最罕用的数据类型。引号('或')可用于创立字符串。 一、打印字符串 1.__str__次要利用于print函数以及字符串函数str的转换操作 2.__repr__利用于所有输入操作,如果有print以及str操作并定义__str__,则会以__str__为准 3.__repr__与 __str__均未定义的时候，默认打印的是输入对象地址信息 二、实例 # str.pyclass DisplayClass: """ __repr__ is used everywhere, except by print and str when a __str__ is defined. __str__ to support print and str exclusively """ def __repr__(self): return "display __repr__ class" def __str__(self): return "display __str__ class"# 应用命令行的模式打印输出 2.x & 3.x 输入成果统一,以2.x作为截图>>> d = DisplayClass()>>> d # 调用repr>>> print(d) # 调用str>>> print(repr(d)) # 调用repr>>> print(str(d)) # 调用str字符串相干知识点，举荐拜访：字符串 以上就是python打印字符串的办法，心愿对大家有所帮忙。更多Python学习指路：python基础教程

TKinter中的菜单品种比拟多，本篇就其中的一般菜单为大家带来解说。 1、第一个Menu类定义是parent。 2、add_command增加菜单项，如果菜单是顶层菜单，从左到右增加，否则就是下拉菜单。 3、- label：指定菜单项名称、- command：点击后相应的调用函数、- acceletor：快捷键。 实例 # 一般菜单案例import tkinter baseFrame = tkinter.Tk() menubar = tkinter.Menu(baseFrame) for item in ['File', 'Edit', 'View', 'Aboyt']: menubar.add_command(label=item) baseFrame['menu'] = menubar baseFrame.mainloop()以上就是python TKinter一般菜单的介绍，心愿对大家有所帮忙。更多Python学习指路：python基础教程

1、弹出菜单也叫上下文菜单，建设菜单并向菜单增加各种性能。 2、右键监听鼠标。如右键点击，则依据地位判断弹出。 3、调用Menupop办法。 4、add_separator增加分隔符。 实例 # 弹出式菜单案例 import tkinter def makeLabel(): global baseFrame tkinter.Label(baseFrame, text="PHP是最好的编程语言，我用Python").pack() baseFrame = tkinter.Tk() menubar = tkinter.Menu(baseFrame)for x in ['麻辣香菇', '汽锅鸡', '东坡肘子']: menubar.add_separator() menubar.add_command(label=x) menubar.add_command(label="重庆火锅", command=makeLabel) # 事件处理函数肯定要至多有一个参数，且第一个参数示意的是零碎事件def pop(event): # 留神应用 event.x 和 event.x_root 的区别 # menubar.post(event.x, event.y) menubar.post(event.x_root, event.y_root) baseFrame.bind("<Button-3>", pop) baseFrame.mainloop()以上就是python TKinter弹出式菜单的应用，心愿对大家有所帮忙。更多Python学习指路：python基础教程

1、在画布上绘制对象，通常用create_xxxx，xxxx=对象类型。 2、每次调用create_xxx，都会返回创立组件的ID，也能够用tag属性指定标签。 3、通过调用canvas.move实现一次性动作。 实例 # canvas案例import tkinter baseFrame = tkinter.Tk() cvs = tkinter.Canvas(baseFrame, width=300, height=200)cvs.pack()# 一条线须要两个点指明起始# 参数数字的单位是pxcvs.create_line(23,23, 190,234)cvs.create_text(56,67, text="I LOVE PYTHON") baseFrame.mainloop()以上就是python canvas画布的介绍，心愿对大家有所帮忙。更多Python学习指路：python基础教程

1、所有命令行参数都能够通过模块中的sys.argv拜访，其返回值是蕴含所有命令行参数的列表(list)。 2、Python在执行程序时，从命令行中获取所有值，并将其存储在sys.argv列表中。 实例 import sysprint("正在运行的脚本名称: '{}'".format(sys.argv[0]))print("脚本的参数数量: '{}'".format(len(sys.argv)))print("脚本的参数: '{}'".format(str(sys.argv)))以上就是python中sys.argv模块的介绍，心愿对大家有所帮忙。更多Python学习指路：python基础教程

1、Getopt模块是专门解决命令行参数的模块，用于获取命令行选项和参数。命令行选项使程序参数更加灵便，反对短选项模式(-)和长选项模式(-)。 2、该模块提供了两种办法和一种异样解决来剖析命令行参数。 实例 import sysimport getopt def main(argv): input_file = "" output_file = "" # "hi:o:": 短格局剖析串, h 前面没有冒号, 示意前面不带参数; i 和 o 前面带有冒号, 示意前面带参数 # ["help", "input_file=", "output_file="]: 长格局剖析串列表, help前面没有等号, 示意前面不带参数; input_file和output_file前面带冒号, 示意前面带参数 # 返回值包含 `opts` 和 `args`, opts 是以元组为元素的列表, 每个元组的模式为: (选项, 附加参数)，如: ('-i', 'test.png'); # args是个列表，其中的元素是那些不含'-'或'--'的参数 opts, args = getopt.getopt(argv[1:], "hi:o:", ["help", "input_file=", "output_file="]) for opt, arg in opts: if opt in ("-h", "--help"): print('script_2.py -i <input_file> -o <output_file>') print('or: test_arg.py --input_file=<input_file> --output_file=<output_file>') sys.exit() elif opt in ("-i", "--input_file"): input_file = arg elif opt in ("-o", "--output_file"): output_file = arg print('输出文件为：', input_file) print('输入文件为：', output_file) # 打印不含'-'或'--'的参数 for i in range(0, len(args)): print('不含'-'或'--'的参数 %s 为：%s' % (i + 1, args[i])) if __name__ == "__main__": main(sys.argv)以上就是python中getopt模块的介绍，心愿对大家有所帮忙。更多Python学习指路：python基础教程 ...

都是单线程，为什么原来低效率的代码用了 async、await 加一些异步库就变得效率高了？如果在做基于 Python 的网络或者 Web 开发时，对于这个问题曾感到纳闷，这篇文章尝试给一个答案。 0x00 开始之前 首先，本文不是带你浏览源代码，而后对照原始代码给你讲 Python 规范的实现。相同，咱们会从理论问题登程，思考解决问题的计划，一步步领会解决方案的演进门路，最重要的，心愿能在过程中取得常识系统性晋升。⚠️ 本文仅是提供了一个独立的思考方向，并未遵循历史和现有理论具体的实现细节。其次，浏览这篇文章须要你对 Python 比拟相熟，至多理解 Python 中的生成器 generator 的概念。 0x01 IO 多路复用这是性能的要害。但咱们这里只解释概念，其实现细节不是重点，这对咱们了解 Python 的协程曾经足够了，如已足够理解，后退到 0x02。首先，你要晓得所有的网络服务程序都是一个微小的死循环，你的业务逻辑都在这个循环的某个时刻被调用： def handler(request): # 解决申请 pass# 你的 handler 运行在 while 循环中while True: # 获取一个新申请 request = accept() # 依据路由映射获取到用户写的业务逻辑函数 handler = get_handler(request) # 运行用户的handler，解决申请 handler(request)构想你的 Web 服务的某个 handler，在接管到申请后须要一个 API 调用能力响应后果。对于最传统的网络应用，你的 API 申请收回去后在期待响应，此时程序进行运行，甚至新的申请也得在响应完结后才进得来。如果你依赖的 API 申请网络丢包重大，响应特地慢呢？那利用的吞吐量将非常低。很多传统 Web 服务器应用多线程技术解决这个问题：把 handler 的运行放到其余线程上，每个线程解决一个申请，本线程阻塞不影响新申请进入。这能肯定水平上解决问题，但对于并发比拟大的零碎，过多线程调度会带来很大的性能开销。IO 多路复用能够做到不应用线程解决问题，它是由操作系统内核提供的性能，能够说专门为这类场景而生。简略来讲，你的程序遇到网络IO时，通知操作系统帮你盯着，同时操作系统提供给你一个办法，让你能够随时获取到有哪些 IO 操作曾经实现。就像这样： # 操作系统的IO复用示例伪代码# 向操作系统IO注册本人关注的IO操作的id和类型io_register(io_id, io_type)io_register(io_id, io_type)# 获取实现的IO操作events = io_get_finished()for (io_id, io_type) in events: if io_type == READ: data = read_data(io_id) elif io_type == WRITE: write_data(io_id，data)把 IO 复用逻辑交融到咱们的服务器中，大略会像这样： ...

一、画龙点睛——多余的分号Python语言与大多数编程语言不雷同，它的语句前面不须要加分号结尾。有些 Python 老手具备编写其它语言的丰盛教训，一时还适应不过去，常常习惯性的加上“分号”： a = 5 # 正确a = 5; # 谬误 二、附赘悬疣——无用的小括号在Python中，if/witch语句的表达式局部并不需要加小括号（尽管加上程序仍可运行），与很多编程语言不同。 if a > b: # 正确 print(a)if (a > b): # 谬误 print(a, b)三、张冠李戴——赋值运算符判断相等判断两个表达式/变量/常量/援用相等，应应用关系运算符“==”，而不是赋值运算符“=”。 if a == b: # 正确 print("相等!")if (a = b): # 谬误 print("相等!")四、强人所难—— 字符串与其余数据类型做“+”运算字符串与其它数据类型的数据相加，这在有一些编程语言中反对，从而达到字符串拼接成果。但Python并不反对。 print('There is' + str(num) + 'apples.') # 正确print('There is' + num + 'apples.') # 谬误 五、转喉触讳——应用关键字作为变量名Python3一共有33个关键字： and，as，assert，break，class，continue，def，del，elif，else，except，finally，False，for，from，global，if，import，in，is，lambda，None，nonlocal，not，or，pass，raise，return，True，try，while，with，yield变量命名、函数命名、类命名均应防止应用关键字。 六、打破常规——缩进谬误语句的缩进在Python语言中是十分重要的，缩进辨别了语句的档次，同一档次的语句须要同一缩进宽度。 for i in range(10): print("Good Morning!!") # 循环内的语句 print("Good Afternoon!!") # 循环内的语句print("Good Night!!") # 循环外的语句 ...

1. 前言在日常编写 Python 脚本的过程中，咱们常常须要联合命令行参数传入一些变量参数，使我的项目应用更加的灵便不便 本篇文章我将列举出构建 Python 命令行参数的 4 种常见形式 它们别离是： 内置 sys.argv 模块内置 argparse 模块内置 getopt 模块第三方依赖库 click2. sys.argv构建命令行参数最简略、常见的形式是利用内置的「 sys.argv 」模块 它是将参数以一个有序的列表传入，所以在应用时传参程序必须固定 因而，这种形式实用于参数个数少且场景固定的我的项目中 import sysif __name__ == '__main__':    # 获取参数列表    # 留神：sys.argv[0] 代表第一个参数，即：脚本名称「1_sys.argv.py」    # 其余参数列表    args = sys.argv[1:]    # 参数个数    args_length = len(sys.argv) if sys.argv else 0    print("排除运行主文件参数，其余参数列表为:", args)    print("参数总数：", args_length)# 应用# python3 1_sys.argv.py arg1 arg2# 排除运行主文件参数，其余参数列表为: [arg1, arg1]# 参数总数：3须要留神的是，在脚本中通过「 sys.argv 」获取的参数列表中，第一个参数代表脚本主文件名称 3. argparse内置的 argparse 模块能够十分轻松地编写出敌对的命令行参数脚本，并且它能主动生成帮忙使用手册，在用户给程序传入有效参数时能抛出清晰的错误信息 应用它构建命令行参数蕴含 3 个步骤： 构建参数解析对象增加参数增加参数解析参数3-1 构建命令行参数解析对象import argparse...# 构建一个命令行参数解析对象parser = argparse.ArgumentParser(description='命令行参数')...3-2 增加命令行参数须要指出的是，--arg1 用于指定参数名称，-a1 代表 dest 指标变量值（简写）...# 设置3个参数# 参数1：arg1，整型，非必须传入参数# 参数2：arg2，字符串，非必须传入参数，蕴含默认值「xag」# 参数3：arg3，字符串类型，必须传入的参数parser.add_argument('--arg1', '-a1', type=int, help='参数1，非必须参数')parser.add_argument('--arg2', '-a2', type=str, help='参数2，非必须参数,蕴含默认值', default='xag')parser.add_argument('--arg3', '-a3', type=str, help='参数3，必须参数', required=True)...3-3 解析出参数值...# 解析参数,获取所有的命令行参数（Namespace），而后转为字典args = vars(parser.parse_args())# 获取所有参数print("所有命令行参数为:")for key in args:    print(f"命令行参数名:{key}，参数值:{args[key]}")...应用的时候，咱们就能够通过「 -h / --help 」命令参数查看帮忙文档# 查看命令行参数帮忙文档python3 2_argparse.py --help# 或python3 2_argparse.py -h下面增加的 3 个参数，参数 arg1、arg2 非必须传值，arg3 必须传值，另外参数 arg2 指定了默认值 # 参数arg3必须，参数arg1和参数arg2非必须，其中参数arg2设置了默认值# 传入参数arg3# python3 2_argparse.py --arg3 123# python3 2_argparse.py -a3 123 xingag@xingagdeMacBook-Pro args % python3 2_argparse.py -a3 123  所有命令行参数为:命令行参数名:arg1，参数值:None命令行参数名:arg2，参数值:xag命令行参数名:arg3，参数值:123# 传入参数arg1、arg3xingag@xingagdeMacBook-Pro args % python3 2_argparse.py -a1 111  -a3 123  所有命令行参数为:命令行参数名:arg1，参数值:111命令行参数名:arg2，参数值:xag命令行参数名:arg3，参数值:123# 传入参数arg1、arg2、arg3xingag@xingagdeMacBook-Pro args % python3 2_argparse.py -a1 111 -a2 222  -a3 123所有命令行参数为:命令行参数名:arg1，参数值:111命令行参数名:arg2，参数值:222命令行参数名:arg3，参数值:1234. getoptgetopt 是 Python 中一个内置规范模块，能够联合 sys.argv 模块，间接解析脚本运行时参数 应用格局：getopt(args,shortopts,longopts = []) 其中 args 参数列表，能够通过 sys.argv 获取，能够参考下面 shortopts 短参数组成的字符串 定义短参数，如果参数有值，须要在短参数后追加一个「 : 」符号 传参应用形式：-n 23 longopts 长参数列表 ...

这些我的项目构想很有可能会让你对这门神奇的语言产生趣味。最棒的是，你能够通过这些乏味但也具备挑战性的我的项目来加强 Python 编程技能。 你晓得 Python 是被称为 全能编程语言 的吗？是的，它的确是，尽管不应该在每个我的项目中都应用它。你能够应用它来创立桌面应用程序、游戏、挪动应用程序、网站和系统软件。它甚至是最适宜用于实现 人工智能 和 机器学习 算法的语言。 因而，在过来的几周里，我为 Python 开发人员收集了一些独特的我的项目构想。这些我的项目构想很有可能会让你对这门神奇的语言产生趣味。最棒的是，你能够通过这些乏味但也具备挑战性的我的项目来加强你的 Python 编程技能。让咱们来一一看下。  1. 应用语音命令创立软件 GUI 交互示例——原图来自 Unsplash 现在，桌面利用程序开发畛域曾经获得了巨大进步。你能看到许多拖拽式 GUI 构建器和语音辨认库。那么，为什么不能将它们联合在一起，通过与计算机对话来创立一个用户界面呢? 这是一个全新的概念，通过一番钻研，我发现还没有人尝试这样做。因而，它可能比上面提到的那些更具挑战性。上面是应用 Python 开始这个我的项目的一些阐明。首先，你须要用到如下的包： 语音辨认库PAGE ——拖拽式 GUI 构建器PAGE 的文档PAGE 是如何工作的视频应用 PAGE 创立登录窗口当初，咱们的想法是对一些语音命令进行硬编码，例如： 你明确我的意思了吧？能够十分简单明了地增加更多这样的命令。因为这将是一个 最小可行性产品 (Minimum Viable Product，MVP) 。所以，如果你必须硬编码许多条件语句（例如，if…else），这是齐全能够的。 设置完这些根本命令后，就能够测试代码了。当初，你能够尝试在窗口中构建一个十分根本的登录表单。这一想法的次要灵活性在于它能够用于游戏开发、网站和挪动应用程序。即便是应用不同的编程语言也能够。  2. AI 博彩机器人 网球较量——图片来自 Unsplash 博彩是一种人们预测后果的流动，如果他们猜对了，就会失去回报。在过来几年中，人工智能或机器学习畛域呈现了许多技术提高。 例如，你可能据说过像 AlphaGo Master、AlphaGo Zero 和 AlphaZero 这样的程序，它们能够比任何业余的人类玩家都能更好地玩 Go（游戏）。你甚至能够取得相似 Leela Zero 这样程序的 源码。 我想表白的一点是，人工智能正在变得比咱们更聪慧。这意味着它能够通过思考所有的可能性并从过来的教训中学习来更好地预测一些事件。让咱们在 Python 中利用一些有监督学习的概念创立一个 AI 博彩机器人吧。要开始本我的项目，这里有一些你须要应用到的库。 pandas——数据分析NumPy——多维数组、矩阵和数学函数scikit-learn ——机器学习XGBoost —— 梯度晋升（Gradient Boosting）Matplotlib ——绘图seaborn ——统计数据可视化pickle ——Python 对象序列化首先，你须要抉择一种较量（例如网球、足球等）来预测后果。当初搜寻可用于训练模型的历史匹配后果数据。例如，.csv 格局的网球较量数据能够从 tennis-data.co.uk 网站上下载。如果你对博彩不理解，上面是它的工作原理。 ...

models.py class Department(models.Model): """部门表""" title = models.CharField(max_length=32, verbose_name='部门表') def __str__(self): return self.titleclass UserInfo(models.Model): """员工表""" name = models.CharField(max_length=16, verbose_name='姓名') password = models.CharField(max_length=64, verbose_name='明码') age = models.IntegerField(verbose_name='年龄') account = models.DecimalField(max_digits=10, verbose_name='账户余额', decimal_places=2, default=0) create_time = models.DateTimeField(verbose_name='入职工夫') gender_choices = ( (1, '男'), (2, '女') ) gender = models.SmallIntegerField(verbose_name='性别', choices=gender_choices) # 级联删除 depart = models.ForeignKey(to='Department', to_field='id', on_delete=models.CASCADE, verbose_name='部门')views.Py from django import formsclass UserModelForm(forms.ModelForm): name = forms.CharField(min_length=3, label='用户名') class Meta: model = models.UserInfo fields = ['name', 'password', 'age', 'account', 'create_time', 'gender', 'depart'] def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) for name, field in self.fields.items(): #html元素增加属性 field.widget.attrs = {'class': 'form-control'}def user_model_form_add(request): """modelForm 增加用户""" if request.method == 'GET': form = UserModelForm() return render(request, 'user_model_form_add.html', {'form': form}) # 用户POST提交数据，数据校验 form = UserModelForm(data=request.POST) # 验证数据 if form.is_valid(): # 保留到数据库 form.save() return redirect('/user/list/') # print(form.cleaned_data) # 校验失败 print(form.errors) return render(request, 'user_model_form_add.html', {'form': form})

和其余编程语言相比，什么才是Python举世无双的特色呢？很多程序员会说，缩进。确实，缩进是Python语言的标志性特点，但这只是外在的、模式上的。从语言个性层面讲，Python的特点是什么呢？我尝试着在知乎上搜寻了一下，最具代表性的答案别离是语法简洁、简略易学、代码高效、功能强大等四项。认真品尝这四项，我还是感觉，这是Python语言体现进去的应用成果或用户感触，依然不是语言个性层面的特色。 换个说法，到底是Python的哪些语言个性使得人们普遍认为Python具备语法简洁、简略易学、代码高效、功能强大的特点呢？我集体认为，这要归功于列表（list）、字典（dict）、元组（tuple）和汇合（set）这“四大金刚”。只管整型（int）、浮点型（float）和字符串（str）也很重要，但这三种对象绝对于其余编程语言来说，差别并不像“四大金刚”那样显著。能够毫不夸大地说，列表、字典、元组和汇合代表了Python语言的外围和根底，同时也是Python的精华所在。学会应用列表、字典、元组和汇合，就意味着把握了Python这门编程语言。 如果认可这个观点，那么，Python的精华就从列表、字典、元组和汇合等“四大金刚”，演变成由方括号、花括号和圆括号组成的“括号族”。 1. 方括号方括号简直是所有编程语言的第一符号。这里的第一，并不是指应用频率，而是指这个符号展现出的编程语言的外延和创造力。事实上，就符号的应用频率而言，方括号也可能排在首位——只是我的直觉，并没有统计数据反对。 1.1 创立列表对于初学者来说，创立列表最罕用的办法就是用一对方括号。 >>> a = []>>> a[]>>> b = [3.14, False, 'x', None]>>> b[3.14, False, 'x', None]即使是老鸟，也会大量应用方括号创立列表，尤其是应用推导式创立列表的状况下。 >>> c = [i**2 for i in range(5)]>>> c[0, 1, 4, 9, 16]但我始终感觉，方括号就像书面语或俚语，太过轻易。我更喜爱应用谨严的list()来创立列表。应用list()创立列表，是list类的实例化的规范办法，能够领会list类的构造函数如何适应不同类型的参数。 >>> a = list()>>> a[]>>> b = list((3.14, False, 'x', None))>>> b[3.14, False, 'x', None]>>> c = list({1,2,3})>>> c[1, 2, 3]>>> d = list({'x':1,'y':2,'z':3})>>> d['x', 'y', 'z']>>> e = list(range(5))>>> e[0, 1, 2, 3, 4]>>> f = list('*'*i for i in range(5))>>> f['', '*', '**', '***', '****']1.2 列表的索引方括号能够创立列表，但方括号并不等同于列表，因为方括号还用来索引。 ...

Reddit Hyped Stocks — 是GitHub上开源的一个基于 Python 开发的查找 Reddit 以后被炒作的股票的Web应用程序。 通过它，你或者能找到下一支“游戏驿站”。 1.怎么判断“炒作”？ \ \ 作者应用“炒作得分”的概念对Reddit上所有被炒作的股票进行了排序，其中炒作得分的计算如下： 收集的原始数据蕴含所选子Reddit的前n个帖子，每次都会收集包含点赞在内的所有根本数据。 每个帖子都会被标记为某只股票的炒作贴（基于题目）。 而后建设一个矩阵，其中每一行代表一个工夫点，每一列代表一只股票。矩阵的值示意在某个工夫点，一只股票的所有帖子的炒作分数的总和。 而后计算每个工夫点的差值作为增量值，比方我想晓得过来7天的炒作分数排行，我会对各个股票将过来7天的增量值之和作为总和来计算炒作分数并进行排行。 无关确切的算法，请查看源代码中的 ticker_score_calulation.py。 2.性能与阐明 炒作图（顶部），即下图所示： 该图表显示了Reddit上以后炒作分数最高的一些股票，显示了排名前15位的股票的累计炒作得分。默认状况下，这个图表显示过来一星期内各个股票的分数变动。 炒作表（左侧），如下图所示： 这里会显示排名前30位的炒作股票及其各自的炒作得分，以下值： Score Abs：所有相干帖子的炒作分数总和7d/3d/1d：周期别离为7/3/1天的增量炒作得分另外，每一行都批示一天的仓位增/减（两个上/下箭头示意+/- 5个排名，一个上/下箭头示意小于+/- 5个排名，= 示意不变）。 单击股票名字后，会关上详细信息视图： 这里会展现股票的根本信息，每股收益、所属行业、PE值、关联的Reddit帖子等等。 3.装置部署 在Python实用宝典后盾回复：Reddit 能够获取此开源代码库的代码和数据(reddit-hyped-stocks 及 data.db)。 （选项1）应用Docker运行应用程序：克隆此仓库或将其下载到本地计算机要应用没有你本人的数据的应用程序，你能够从：https://drive.google.com/file...\获取示例数据库，下载并将文件复制到 backend/data.db运行./run-server-docker.sh 这将须要一些工夫来下载依赖项并构建应用程序浏览器关上 http://localhost:5000 拜访页面（选项2）在没有Docker的状况下运行应用程序/设置开发环境将存储库克隆到本地计算机装置Python 3和Node.jscd 到 backend 并运行 pip3 install -r requirements.txt 以装置后端依赖项。运行 backend/start.sh 以运行后端开发服务器cd 到 frontend 并运行 npm i 以装置前端依赖项。运行 npm run start 以运行前端开发服务器。（非必须）收集原始数据因为炒作得分取决于帖子，因而必须定期（例如每小时）爬取 Reddit 帖子数据。 必须条件：获取 Reddit API token： 返回 https://www.reddit.com/prefs/...点击“创立利用”并填写信息，应用“script”类型将密钥和应用程序ID复制到文件中:  backend/praw.ini默认状况下，子论坛 robinhoodpennystocks 和 pennystocks 会被爬取（可在中配置backend/load_data.py）。 ...

setup.py 真难写仿佛从有 Python 打包以来就有了setuptools这个库，你能搜到的教程，波及打包公布的，都会让你编写那个可怕的setup.py。不晓得谁能齐全把握那个货色的写法，我到当初都还不太会。说几个罕用的配置： 指定依赖和可选依赖 setup( install_requires=["flask", "flask-migrate", "sqlalchemy"], extras_require={"mysql": ["mysqlclient"], "pgsql": ["psycopg2"]})留神那两个 key 别离是install_requires和extras_require，别写错了。此外，如果你须要依据条件增减依赖的话，不要用 INSTALL_REQUIRES = ["flask"]if sys.platform == "win32": INSTALL_REQUIRES.append("pywin32")setup(install_requires=INSTALL_REQUIRES)而应该应用Environment Markers INSTALL_REQUIRES = [ "flask", "pywin32; sys_platform == 'win32'"]setup(install_requires=INSTALL_REQUIRES)公布可执行程序到/bin下 setup( entry_points={ "console_scripts": ["mybin=mypackage.main:cli"] })或者 ini 写法 setup( entry_points="""[console_scripts] mybin = mypackage.main:cli """)任选其一。 蕴含 data 文件 setup( include_package_data=True # 从MANIFEST.in中读取配置)或者 setup( package_data={"": ["*.json"]} # 蕴含所有json文件)指定源代码构造，如果你应用的是src/寄存包的源码这种我的项目构造，能够： setup( package_dir={"": "src"})打包上传和装置打包好了，这个万恶的setup.py我曾经写好了，咱要公布 PyPI 了。第一步，打包成可散发的文件： $ python setup.py sdist bdist_wheel --universal这条命令会同时生成源代码包（Source Distribution），和二进制包（Binary Distribution）。当然，大部分的 Python 公布包中并不真的蕴含二进制， 只是沿用了软件工程中的个别叫法。 ...

【导语】：对本人写的简短代码，想重构但又无思路？小编整顿了系列介绍python代码重构优化的办法，助你一臂之力。 编写洁净的 Pythonic 代码就是尽可能使其易于了解，但又简洁。 这是 Python 重构系列中的之一，本系列文章的重点是为什么这些重构是好主见，而不仅仅是如何做。 1.将for循环转换为list/dictionary/set 表达式 咱们在时常常遇到的一个状况是，创立一个值的汇合。 比方咱们创立一个列表，而后迭代地用值填充它，这里咱们想创立一个立方数字的列表。大多数语言的规范办法如下： cubes = []for i in range(20): cubes.append(i ** 3)在Python中，咱们能够应用列表表达式，生成须要的数据。就能够将代码简化为一行，省去定义列表，而后再去填充列表的略显繁琐的操作。 cubes = [i ** 3 for i in range(20)] 看，咱们曾经将三行代码转换成一行，这无疑是不错的抉择——你的眼睛不必上下左右的查看代码。 把代码压缩到一行会使浏览变得更加艰难，但对于推导表达式来说，状况并非如此。您须要的所有元素都被很好地出现进去，一旦您习惯了语法，它实际上比for循环版本更具可读性。 另一点是赋值当初更像是一个原子操作——咱们申明什么是cubes，而不是给出如何构建它的指令。这使得代码读起来更舒服，因为咱们关怀变量cubes是什么，而不是它的结构细节。 最初，表达式通常比在循环中构建汇合更快，如果思考性能，这也是重要因素。 2.用增量赋值替换赋值 增量赋值是一种疾速而简略的Python语法。 只有有这样的代码： count = count + other_value 都能够替换成上面的代码： count += other_value 代码是简短和清晰的-咱们不须要思考计数变量两次。其余能够应用的运算符包含-=，=，/=和*=。 不过有件事须要略微小心一点，你要调配给的类型必须定义适当的运算符。例如，numpy数组不反对/=操作。 3.只应用一次的内联变量 咱们在人们的代码中常常看到的一种状况是将后果赋给长期变量，而后立刻返回它。 def state_attributes(self): """Return the state attributes.""" state_attr = { ATTR_CODE_FORMAT: self.code_format, ATTR_CHANGED_BY: self.changed_by, } return state_attr其实更好的办法是间接返回后果，而不是再用一个长期变量寄存后果 def state_attributes(self): """Return the state attributes.""" return { ATTR_CODE_FORMAT: self.code_format, ATTR_CHANGED_BY: self.changed_by, }这样能够缩短代码并删除不必要的变量，从而缩小浏览代码的脑力耗费。 ...

主动发送邮件能利用于许多场景，比方我想要晓得股票策略中的股票池是否有实时的更新，这时候如果再拉一遍数据，跑一遍脚本，切实是太浪费时间了。为什么不把这一套流程放到服务器上，而后到点主动运行并发送邮件呢？ 相似的利用场景还有很多，不仅仅是在股票策略揭示上，比方定时向某些人发送邮件；网站宕机了，实时发送邮件揭示；网站负载过高，发送邮件揭示......等等。 上面就来讲讲怎么用Python构建一个主动发送邮件的脚本。 1.开启SMTP服务 为了实现主动发送邮件的目标，咱们须要在邮箱中开启SMTP服务： 这点很要害，别忘了去开启SMTP，否则邮件是无奈发送胜利的。而后你还须要点击上面生成受权码，这个受权码才是应用Python发送邮件时的真正明码。 邮箱设定胜利后，就能够开始脚本开发了。 2.筹备 开始之前，你要确保Python和pip曾经胜利装置在电脑上。 (可选1) 如果你用Python的目标是数据分析，能够间接装置Anaconda，它内置了Python和pip. (可选2) 此外，举荐大家用VSCode编辑器，它有许多的长处。 请抉择以下任一种形式输出命令装置依赖： Windows 环境 关上 Cmd (开始-运行-CMD)。MacOS 环境 关上 Terminal (command+空格输出Terminal)。如果你用的是 VSCode编辑器 或 Pycharm，能够间接应用界面下方的Terminal。pip install yagmail看到 Successfully installed xxx 则阐明装置胜利。本文全副源代码可在后盾回复：主动发送邮件 取得。 3.编写脚本 明天须要用到的模块是yagmail，一个十分不便的Python邮件发送模块，用这个模块，你甚至能一行命令发送邮件： yag = yagmail.SMTP(    host='smtp.qq.com', user='你的邮箱',    password='你的鉴权码', smtp_ssl=True).send(["发送对象"], "主题", "内容")为了让这个发送邮件的办法更加具备可用性，咱们将其封装到一个类中： import timeimport yagmailclass Mail:    """    邮件相干类    """    def sendmail(self, msg, title, receivers):        """        发送邮件                Arguments:            msg {str} -- 邮件注释            title {str} -- 邮件题目            receivers {list} -- 邮件接收者，数组        """        yag = yagmail.SMTP(            host='smtp.qq.com', user='你的邮箱',            password='你的鉴权码', smtp_ssl=True        )        try:            yag.send(receivers, title, msg)            print("邮件发送胜利")        except BaseException as e:            print(e)            print("Error: 无奈发送邮件")这个类里还能够封装很多其余货色，比方log函数，用于显示工夫： import timeimport yagmailclass Mail:    """    邮件相干类    """    def log(self, content):        now_time = time.strftime(            "%Y-%m-%d %H:%M:%S", time.localtime()        )        print(f'{now_time}: {content}')这样，须要显示工夫的时候只须要调用self.log即可，优化后的残缺代码如下： import timeimport yagmailclass Mail:    """    邮件相干类    """    def log(self, content):        now_time = time.strftime(            "%Y-%m-%d %H:%M:%S", time.localtime()        )        print(f'{now_time}: {content}')    def sendmail(self, msg, title, receivers):        """        发送邮件                Arguments:            msg {str} -- 邮件注释            title {str} -- 邮件题目            receivers {list} -- 邮件接收者，数组        """        yag = yagmail.SMTP(            host='smtp.qq.com', user='你的邮箱',            password='你的鉴权码', smtp_ssl=True        )        try:            yag.send(receivers, title, msg)            self.log("邮件发送胜利")        except BaseException as e:            print (e)            self.log("Error: 无奈发送邮件")发送胜利时显示： ...

本文将对tox做简略的介绍，说不定大家在开发我的项目时可能用得上。 Command line driven CI frontend and development task automation tool** 命令行驱动的 CI 前端和开发工作自动化工具 tox 的我的项目地址是：https://github.com/tox-dev/tox 其核心作用是反对创立隔离的 Python 环境，在外面能够装置不同版本的 Python 解释器与各种依赖库，以此不便开发者做自动化测试、打包、继续集成等事件。 简略来说，tox 是一个治理测试虚拟环境的命令行工具。 它已存在多年且广被开发者们应用，例如，驰名的云计算平台 OpenStack 也采纳了它，作为最根底的测试工具之一。 1、tox 能做什么？细分的用处包含： 创立开发环境运行动态代码剖析与测试工具自动化构建包针对 tox 构建的软件包运行测试查看软件包是否能在不同的 Python 版本/解释器中顺利装置对立继续集成（CI）和基于命令行的测试创立和部署我的项目文档将软件包公布到 PyPI 或任何其它平台tox 官网文档中列出了 40 余种应用场景的示例 2、tox 怎么配置？对于它的用法：应用pip install tox 装置，应用tox 运行全副测试环境，和tox -e envname 运行指定的环境。还有不少的命令行参数，通过tox -h 查看。 tox 的行为由其配置文件管制，以后它反对 3 种配置文件： pyproject.tomltox.inisetup.cfg以 tox 我的项目本人的 tox.ini 配置内容为例，能够看到它是这样配置的 每个[xxx]及其下方内容组成一个章节（section），每个章节间应用空行作距离。 [tox]上面是全局性的配置项，envlist 字段定义了 tox 去操作的环境。[xxx]上面是 xxx 虚拟环境的配置项，[xxx:yyy]继承 xxx 的配置，同时其本身配置项的优先级更高。 对于每个虚拟环境，可用的配置项很多，例如罕用的有：description（形容信息）、basepython（Python解释器版本）、deps（环境依赖项）、commands（命令语句）等等。 tox 还反对作变量替换，它提供了一些内置的根底变量（全局的或对于虚拟环境的）：{toxinidir}、{homedir}、{envname}、{envdir}等等。 ...

很长时间以来都没有怎么好好搞清楚RPC（即Remote Procedure Call，近程过程调用）和HTTP调用的区别，不都是写一个服务而后在客户端调用么？这里请容许我迷之一笑~Naive！援用本文简略地介绍一下两种模式的C/S架构，先说一下他们最实质的区别，就是RPC次要是基于TCP/IP协定的，而HTTP服务次要是基于HTTP协定的，咱们都晓得HTTP协定是在传输层协定TCP之上的，所以效率来看的话，RPC当然是要更胜一筹啦！上面来具体说一说RPC服务和HTTP服务。OSI网络七层模型在说RPC和HTTP的区别之前，我觉的有必要理解一下OSI的七层网络结构模型（尽管理论利用中基本上都是五层），它能够分为以下几层：（从上到下） 第一层：应用层。定义了用于在网络中进行通信和传输数据的接口；第二层：表示层。定义不同的零碎中数据的传输格局，编码和解码标准等；第三层：会话层。治理用户的会话，管制用户间逻辑连贯的建设和中断；第四层：传输层。治理着网络中的端到端的数据传输；第五层：网络层。定义网络设备间如何传输数据；第六层：链路层。将下面的网络层的数据包封装成数据帧，便于物理层传输；第七层：物理层。这一层次要就是传输这些二进制数据。理论利用过程中，五层协定构造外面是没有表示层和会话层的。应该说它们和应用层合并了。咱们应该将重点放在应用层和传输层这两个层面。因为HTTP是应用层协定，而TCP是传输层协定。好，晓得了网络的分层模型当前咱们能够更好地了解为什么RPC服务相比HTTP服务要Nice一些！ RPC服务从三个角度来介绍RPC服务：别离是RPC架构，同步异步调用以及风行的RPC框架。 RPC架构先说说RPC服务的根本架构吧。容许我可耻地盗一幅图哈~咱们能够很分明地看到，一个残缺的RPC架构外面蕴含了四个外围的组件，别离是Client ,Server,Client Stub以及Server Stub，这个Stub大家能够了解为存根。别离说说这几个组件： 客户端（Client），服务的调用方。服务端（Server），真正的服务提供者。客户端存根，寄存服务端的地址音讯，再将客户端的申请参数打包成网络音讯，而后通过网络近程发送给服务方。服务端存根，接管客户端发送过去的音讯，将音讯解包，并调用本地的办法。RPC次要是用在大型企业外面，因为大型企业外面零碎繁多，业务线简单，而且效率劣势十分重要的一块，这个时候RPC的劣势就比拟显著了。理论的开发当中是这么做的，我的项目个别应用maven来治理。 比方咱们有一个解决订单的零碎服务，先申明它的所有的接口（这里就是具体指Java中的interface），而后将整个我的项目打包为一个jar包，服务端这边引入这个二方库，而后实现相应的性能，客户端这边也只须要引入这个二方库即可调用了。为什么这么做？次要是为了缩小客户端这边的jar包大小，因为每一次打包公布的时候，jar包太多总是会影响效率。另外也是将客户端和服务端解耦，进步代码的可移植性。 同步调用与异步调用什么是同步调用？什么是异步调用？同步调用就是客户端期待调用执行实现并返回后果。异步调用就是客户端不期待调用执行实现返回后果，不过仍然能够通过回调函数等接管到返回后果的告诉。如果客户端并不关怀后果，则能够变成一个单向的调用。这个过程有点相似于Java中的callable和runnable接口，咱们进行异步执行的时候，如果须要晓得执行的后果，就能够应用callable接口，并且能够通过Future类获取到异步执行的后果信息。如果不关怀执行的后果，间接应用runnable接口就能够了，因为它不返回后果，当然啦，callable也是能够的，咱们不去获取Future就能够了。 风行的RPC框架目前风行的开源RPC框架还是比拟多的。上面重点介绍三种： gRPC是Google最近颁布的开源软件，基于最新的HTTP2.0协定，并反对常见的泛滥编程语言。咱们晓得HTTP2.0是基于二进制的HTTP协定降级版本，目前各大浏览器都在快马加鞭的加以反对。这个RPC框架是基于HTTP协定实现的，底层应用到了Netty框架的反对。 Thrift是Facebook的一个开源我的项目，次要是一个跨语言的服务开发框架。它有一个代码生成器来对它所定义的IDL定义文件主动生成服务代码框架。用户只有在其之前进行二次开发就行，对于底层的RPC通信等都是通明的。不过这个对于用户来说的话须要学习特定畛域语言这个个性，还是有肯定老本的。 Dubbo是阿里团体开源的一个极为闻名的RPC框架，在很多互联网公司和企业应用中宽泛应用。协定和序列化框架都能够插拔是及其显明的特色。同样 的近程接口是基于Java Interface，并且依靠于spring框架不便开发。能够不便的打包成繁多文件，独立过程运行，和当初的微服务概念统一。 HTTP服务其实在很久以前，我对于企业开发的模式始终定性为HTTP接口开发，也就是咱们常说的RESTful格调的服务接口。确实，对于在接口不多、零碎与零碎交互较少的状况下，解决信息孤岛初期常应用的一种通信伎俩；长处就是简略、间接、开发不便。利用现成的http协定进行传输。咱们记得之前本科实习在公司做后盾开发的时候，次要就是进行接口的开发，还要写一大份接口文档，严格地表明输入输出是什么？说分明每一个接口的申请办法，以及申请参数须要留神的事项等。 接口可能返回一个JSON字符串或者是XML文档。而后客户端再去解决这个返回的信息，从而能够比拟疾速地进行开发。然而对于大型企业来说，外部子系统较多、接口十分多的状况下，RPC框架的益处就显示进去了，首先就是长链接，不用每次通信都要像http一样去3次握手什么的，缩小了网络开销；其次就是RPC框架个别都有注册核心，有丰盛的监控治理；公布、下线接口、动静扩大等，对调用方来说是无感知、统一化的操作。 总结RPC服务和HTTP服务还是存在很多的不同点的，一般来说，RPC服务次要是针对大型企业的，而HTTP服务次要是针对小企业的，因为RPC效率更高，而HTTP服务开发迭代会更快。总之，选用什么样的框架不是依照市场上风行什么而决定的，而是要对整个我的项目进行残缺地评估，从而在认真比拟两种开发框架对于整个我的项目的影响，最初再决定什么才是最适宜这个我的项目的。肯定不要为了应用RPC而每个我的项目都用RPC，而是要就地取材，具体情况具体分析。 以上就是本次分享的所有内容，想要理解更多 python 常识欢送返回公众号：Python 编程学习圈 ，发送 “J” 即可收费获取，每日干货分享

FlashText 算法是由 Vikash Singh 于2017年发表的大规模关键词替换算法，这个算法的工夫复杂度仅由文本长度（N）决定，算法工夫复杂度为O（N） 而对于正则表达式的替换，算法工夫复杂度还须要思考被替换的关键词数量（M），因而工夫复杂度为O（MxN） 简而言之，基于FlashText算法的字符串替换比正则表达式替换快M倍以上，这个M是须要替换的关键词数量，关键词越多，FlashText算法的劣势就越显著 上面就给大家介绍如何在 Python 中基于 flashtext 模块应用 FlashText 算法进行字符串查找和替换，如果感觉对你的我的项目团队很有帮忙，请记得帮作者转发一下哦 1.筹备 请抉择以下任一种形式输出命令装置依赖： Windows 环境 关上 Cmd (开始-运行-CMD)。MacOS 环境 关上 Terminal (command+空格输出Terminal.如果你用的是 VSCode编辑器 或 Pycharm，能够间接应用界面下方的Terminal。pip install flashtext2.根本应用 提取关键词 一个最根本的提取关键词的例子如下： from flashtext import KeywordProcessor# 1. 初始化关键字处理器keyword_processor = KeywordProcessor()# 2. 增加关键词keyword_processor.add_keyword('Big Apple', 'New York')keyword_processor.add_keyword('Bay Area')# 3. 解决指标句子并提取相应关键词keywords_found = keyword_processor.extract_keywords('I love Big Apple and Bay Area.')# 4. 后果print(keywords_found)# ['New York', 'Bay Area']其中 add_keyword 的第一个参数代表须要被查找的关键词，第二个参数是给这个关键词一个别名，如果找到了则以别名显示。 替换关键词 如果你想要替换关键词，只须要调用处理器的 replace_keywords 函数： from flashtext import KeywordProcessor# 1. 初始化关键字处理器keyword_processor = KeywordProcessor()# 2. 增加关键词keyword_processor.add_keyword('New Delhi', 'NCR region')# 3. 替换关键词new_sentence = keyword_processor.replace_keywords('I love Big Apple and new delhi.')# 4. 后果print(new_sentence)# 'I love New York and NCR region.'关键词大小写敏感 ...

有不少同学学完Python后依然很难将其灵活运用。我整顿 37 个Python入门的小程序。在实践中利用Python会有事倍功半的成果。 例子1：华氏温度转换为摄氏温度华氏温度转摄氏温度的公式：C = (F - 32) / 1.8。本例考查Python的加减乘除运算符。 """将华氏温度转换为摄氏温度"""f = float(input('输出华氏温度: '))c = (f - 32) / 1.8print('%.1f 华氏度 = %.1f 摄氏度' % (f, c))例子2：计算圆的周长和面积输出半径，计算圆的半径和面积，圆周长公式：2r，面试公式：*r^2 """半径计算圆的周长和面积"""radius = float(input('输出圆的半径: '))perimeter = 2 * 3.1416 * radiusarea = 3.1416 * radius * radiusprint('周长: %.2f' % perimeter)print('面积: %.2f' % area)例子3：实现一元一次函数实现数学里的一元一次函数：f(x) = 2x + 1 """一元一次函数"""x = int(input('输出x：'))y = 2 * x + 1print('f(%d) = %d' % (x, y))例子4：实现二元二次函数实现数学里的二元二次函数：f(x, y) = 2x^2 + 3y^2 + 4xy，须要用到指数运算符** """二元二次函数"""x = int(input('输出x：'))y = int(input('输出y：'))z = 2 * x ** 2 + 3 * y ** 2 + 4 * x * yprint('f(%d, %d) = %d' % (x, y, z))例子5：拆散整数的个位数将一个正整数的个位数，以及除个位数外的局部拆散。须要用到模（取余数）运算符%，和整除运算符// """拆散整数个位数"""x = int(input('输出整数：'))single_dig = x % 10exp_single_dig = x // 10print('个位数： %d' % single_dig)print('除个位数外： %d' % exp_single_dig)例子6：实现一个累加器实现一个简略的累加器，能够承受用户输出3个数字，并将其累加。须要用到复合赋值运算符：+= """累加器 v1.0"""s = 0x = int(input('输出整数：'))s += xx = int(input('输出整数：'))s += xx = int(input('输出整数：'))s += xprint('总和：%d' % s)例子7：判断平年输出年份，判断是否是平年。平年判断办法：能被4整除，但不能被100整除；或者能被 400 整除。须要用到算术运算符和逻辑运算符 """判断平年"""year = int(input('输出年份: '))is_leap = year % 4 == 0 and year % 100 != 0 or year % 400 == 0print(is_leap)例子8：判断奇偶数输出一个数字，判断基数还是偶数，须要模运算和if ... else构造 """判断奇偶数"""in_x = int(input('输出整数：'))if in_x % 2 == 0:    print('偶数')else:    print('奇数')例子9：猜大小用户输出一个 1-6 之间的整数，与程序随机生成的数字作比拟。须要用到if ... elif ... else构造 """猜大小"""import randomin_x = int(input('输出整数：'))rand_x = random.randint(1, 6)print('程序随机数： %d' % rand_x)if in_x > rand_x:    print('用户赢')elif in_x < rand_x:    print('程序赢')else:    print('打平')阐明：random是Python的随机数模块，调用 random.randint 能够生成一个随机数，类型为 int。randint(1, 6) 示意生成 [1, 6] 之间的随机数。例子10：判断平年之前判断平年是输入True或False，这次须要输入文字版平年或平年 """判断平年"""year = int(input('输出年份: '))if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:    print('平年')else:    print('平年')例子11：摄氏度与华氏度互转之前做过华氏度转摄氏度，当初通过分支构造实现二者互转。 """摄氏度与华氏度调换"""trans_type = input('输出转摄氏度还是华氏度：')if trans_type == '摄氏度':  # 执行华氏度转摄氏度的逻辑    f = float(input('输出华氏温度：'))    c = (f - 32) / 1.8    print('摄氏温度为：%.2f' % c)elif trans_type == '华氏度':  # 执行摄氏度转华氏度的逻辑    c = float(input('输出摄氏温度：'))    f = c * 1.8 + 32    print('华氏温度为：%.2f' % f)else:    print('请输出 华氏度 或 摄氏度')例子12：是否形成三角形输出三个边长度，判断是否形成三角形。形成三角形的条件：两边之和大于第三边。 """是否形成三角形"""a = float(input('输出三角形三条边：\n a = '))b = float(input(' b = '))c = float(input(' c = '))if a + b > c and a + c > b and b + c > a:    print('可能形成三角形')else:    print('不能形成三角形')例子13：输入问题等级输出问题分数，输入分数对应的等级。 =90分得A，[80, 90) 得B，[70, 80)得C，[60, 70)得D，< 60得E"""输入问题等级"""score = float(input('请输出问题: '))if score >= 90:    grade = 'A'elif score >= 80:    grade = 'B'elif score >= 70:    grade = 'C'elif score >= 60:    grade = 'D'else:    grade = 'E'print('问题等级是:', grade)例子14：计算提成某企业的奖金依据销售利润依照如下规定计算提成。输出销售利润，计算奖金。 利润 <= 10万，奖金可提10% 10万 < 利润 <= 20万，高出10万的局部提 7.5% ...

申明本文章中所有内容仅供学习交换应用，不用于其余任何目标，不提供残缺代码，抓包内容、敏感网址、数据接口等均已做脱敏解决，严禁用于商业用途和非法用处，否则由此产生的所有结果均与作者无关！ 本文章未经许可禁止转载，禁止任何批改后二次流传，擅自应用本文解说的技术而导致的任何意外，作者均不负责，若有侵权，请在公众号【K哥爬虫】分割作者立刻删除！ 前言 瑞数动静平安 Botgate（机器人防火墙）以“动静平安”技术为外围，通过动静封装、动静验证、动静混同、动静令牌等技术对服务器网页底层代码继续动静变换，减少服务器行为的“不可预测性”，实现了从用户端到服务器端的全方位“被动防护”，为各类 Web、HTML5 提供弱小的平安爱护。 瑞数 Botgate 多用于政企、金融、运营商行业，曾一度被视为反爬天花板，随着近年来逆向大佬越来越多，相干的逆向文章也层出不穷，真正到了人均瑞数的时代了，这里也感激诸如 Nanda、懒神等逆向大佬，揭开了瑞数神秘的面纱，总结的教训让起初人少走了不少弯路。 过瑞数的办法基本上有以下几种：自动化工具（要暗藏特征值）、RPC 近程调用、JS 逆向（硬扣代码和补环境），本文介绍的是 JS 逆向硬扣代码，尽可能多的介绍各种细节。 瑞数特色以及不同版本的区别对于绝大多数应用了瑞数的网站来说，有以下几点特色（可能有非凡版本不一样，先仅看支流的）： 1、关上开发者工具（F12）会顺次呈现两个典型的有限 debugger： 2、瑞数的 JS 混同代码中，变量、办法名大多相似于 _$xx，有泛滥的 if-else 控制流，新版瑞数还可能会有 jsvmp 以及泛滥三目表达式的状况： 3、看申请，会有典型的三次申请，首次申请响应码是 202（瑞数3、4代）或者 412（瑞数5代），接着独自申请一个 JS 文件，而后再从新申请页面，后续的其余 XHR 申请中，都带有一个后缀，这个后缀的值是由 JS 生成的，每次都会变动，后缀的值第一个数字为瑞数的版本，比方 MmEwMD=4xxxxx 就是4代瑞数，bX3Xf9nD=5xxxxx 就是5代瑞数： 4、看 Cookie，瑞数 3、4 代有以 T 和 S 结尾的两个 Cookie，其中以 S 结尾的 Cookie 是第一次的 201 那个申请返回的，以 T 结尾的 Cookie 是由 JS 生成的，动态变化的，T 和 S 后面个别会跟 80 或 443 的数字，Cookie 值第一个数字为瑞数的版本（为什么能够通过第一个数字来判断版本？难道雷同版本第一个数字不会变吗？这些问题咱们在剖析 JS 的时候能够找到答案），比方： ...

疾速将两个别离寄存有key和value的列表合并成一个字典 >>> a = ["key1", "key2", "key3"]>>> b = ["value1", "value2", "value3"]>>> dict(zip(a, b)){'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}这个操作的用处对于爬虫工程师而言挺常见的，比如说： 你须要采集一些键值对类型的信息，而后你可能会碰到一些平台的接口返回这些信息时是间接返回的一个只有value的列表，并且key都是写死在代码或申请参数里的，这时候你就能够通过这个操作来将它们疾速合并成一个字典，这样就能比拟不便地取值了，取值局部的可读性也会好很多。 还有一种状况就是，你可能会碰到一些网站上的这种键值对信息在HTML中key和value的元素是平级关系，并且key和value也没有可能辨别的标识，这些状况咱们只能通过把整个键值对局部的元素都提取进去转换成列表，而后再通过按列表下标距离切片的形式别离取出key和value的列表，而后再将它们合并成一个字典。比方这样： >>> result = ["key1", "value1", "key2", "value2", "key3", "value3"]>>> result[0::2]['key1', 'key2', 'key3']>>> result[1::2]['value1', 'value2', 'value3']>>> dict(zip(result[0::2], result[1::2])){'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}须要留神的是，这个操作在碰到key和value数量不统一的时候，会主动疏忽掉多的那局部列表尾部的值，你须要确保key和value是对得上的才行。 简略来说就是，如果你的key列表比value列表多一个值，那么最终进去的字典就会缺失掉key列表中的最初那一个多进去的值。 疾速按头、尾、两头局部切割元素，并将它们别离赋值给三个变量 >>> a = "123456789" # 也能够是list之类的>>> a1, *a2, a3 = a>>> a1'1'>>> a2['2', '3', '4', '5', '6', '7', '8']>>> a3'9' 这个操作的用处，对于爬虫工程师或者是一些会接触到公有协定的后端工程师应该都挺常见的，比如说： 你可能会碰到一些基于TCP或UDP搞的公有协定，而后它们可能会定义一个由内容类型头、通信内容、校验码之类的货色组成的构造，每次通信时都会给你返回这么一个货色，而后你须要将它们切开并赋值给不同的变量，这时候你就能够通过这个操作来疾速实现这个成果了。 当然，这个操作也不能乱用，你最好是可能确保它的内容不会变动，像公有协定这种状况，你能够判断一下协定版本号之类的，以确保它的内容肯定是这个构造。 疾速解压内含嵌套列表的列表，并同时将嵌套列表内的值也赋值给不同的变量 ...

当咱们计算两个日期间的距离天数时，通常是用完结日期减去开始日期，但在理论的项目管理、工作治理、工作打算等场景中，某些时间段会波及双休日、法定节假日，甚至还有公司自定义的工作工夫安顿，所以就须要计算出两个日期间的理论工作日天数。比方一个表格中有多条工作，每条工作都有各自的开始日期、打算完结日期或理论完结日期，那么如何主动计算出两个日期间的理论工作日天数，以便做到精密和量化呢。 此时，万能的 Python 就能够出场了，而用 Python + SeaTable 来实现则会更加不便工作治理。本文重点分享思路和代码，仅供参考。 SeaTable 表格有丰盛的数据类型，如日期、单选、合作人、公式、按钮等等，能够不便又标准地治理各类信息。此外，还有很多根底性能和扩大性能，这其中就包含脚本性能。在表格上点击“脚本”按钮，能够导入或新建多个脚本，随时一键运行即可（如需设置定期运行等可在“自动化规定”中实现）。 比方在上面这个表格中，开始工夫由我的项目管理者填写； 完结工夫由每个工作负责人在实现我的项目时填写； 工作日（天数）则依据开始工夫和完结工夫，运行 Python 脚本计算得出。 在 SeaTable 表格上新建 Python 脚本具体来看。 首先， 咱们关上脚本性能， 抉择“新建脚本”， 抉择 Python。 思路在关上的界面中，就能够对脚本进行编写了。 在此处计算工作日的脚本编写过程中须要留神几个问题， 以中国为例： 来年的工作日、休息日，暂不反对（因国家暂未公布安顿） 。须要定义素日中劳动的日期， 即周一到周五哪天劳动。须要定义周末中工作的日期， 即周六、周日哪天调休。代码把以上的非凡日期一一列进去，这个脚本就不难编写了， 以下给出一些脚本片段， 以2022年为例。 import datetimefrom enum import Enumfrom seatable_api import dateutils, Base, context# 一个 Base 的受权信息SERVER_URL = context.server_url or 'https://cloud.seatable.cn'API_TOKEN = context.api_token or 'dd46f9ca0172a850a0922107a6b2e6b99932b040'# 1. 定义中国的节假日详情class Holiday(Enum): new_years_day = "除夕" spring_festival = "春节" tomb_sweeping_day = "清明" labour_day ="劳动节" dragon_boat_festival = "端午" national_day = "国庆节" mid_autumn_festival = "中秋"# 2. 列出节假日列表， 此处能够去查问日历，就不一一列出了holidays = { datetime.date(year=2022, month=1, day=1): Holiday.new_years_day.value, datetime.date(year=2022, month=1, day=2): Holiday.new_years_day.value, datetime.date(year=2022, month=1, day=3): Holiday.new_years_day.value, datetime.date(year=2022, month=1, day=31): Holiday.spring_festival.value, datetime.date(year=2022, month=2, day=1): Holiday.spring_festival.value, .....}# 3.列出调休日的列表，及周六日为工作日的列表workdays = { datetime.date(year=2022, month=1, day=29): Holiday.spring_festival.value, datetime.date(year=2022, month=1, day=30): Holiday.spring_festival.value, datetime.date(year=2022, month=4, day=2): Holiday.tomb_sweeping_day.value, datetime.date(year=2022, month=4, day=24): Holiday.labour_day.value, datetime.date(year=2022, month=5, day=7): Holiday.labour_day.value, datetime.date(year=2022, month=10, day=8): Holiday.national_day.value, datetime.date(year=2022, month=10, day=9): Holiday.national_day.value, ....}# 4. 定义是否是工作日def is_workday(date): ''' 工作日定义： 1. 日期在workdays字典的key中 2. 星期是周一到周五且不在holidays字典的key中 ''' date = _validate_date(date) weekday = date.weekday() return bool(date in workdays.keys() or (weekday <= 4 and date not in holidays.keys())) # 5. 计算两个日期之间的工作日， 此处返回的是工作日的列表， 该列表的长度即是工作日的天数def get_workdays(start, end): """ 获取两个日期之间的工作日，返回datetime的列表 """ start, end = _validate_date(start, end) return list(filter(is_workday, get_dates(start, end))) # 6. 将后果写入 SeaTabledef calculate_base_workdays(base, table_name): ''' 通过seatable表格中的，开始日期, 完结日期， 计算两个日期间工作日的天数，并把其更新到该行的 工作日字段中 ''' for row in base.list_rows(table_name): row_id = row.get('_id') start_date = row.get("开始日期") end_date = row.get("完结日期") if not (start_date and end_date): continue try: work_day_list = get_workdays(start_date, end_date) # 两个日期间的工作日天数 work_day_counts = len(work_day_list) cell_value = row.get("工作日") if cell_value == work_day_counts: continue base.update_row( table_name, row_id, { "工作日": work_day_counts } ) except Exception as e: print("start date: %s, end date: %s, error: %s" % (start_date, end_date, e) ) continue base = Base(API_TOKEN, SERVER_URL)base.auth()calculate_base_workdays(base, "工作工作安顿")残缺脚本能够参照（链接）： Python 脚本计算工作日天数 ...

编写洁净的 Pythonic 代码就是尽可能使其易于了解，但又简洁。所以重构代码让代码简洁易了解是很有必要的。 本文重点是想跟大家探讨为什么这些重构是好想法，而不仅仅是如何做。 1. 合并嵌套的 if 条件 太多的嵌套会使代码难以了解，这在 Python 中尤为如此，因为 Python 没有括号来帮忙区隔不同的嵌套级别。 浏览深度嵌套的代码容易让人焦躁，因为你必须理清哪些条件属于哪一级。因而，咱们应尽可能减少嵌套，如果两个条件能够用 and 合在一起，会比嵌套更易读。 合并之前： if a: if b: return c合并后： if a and b: return c2. 将反复的代码移到条件语句之外 咱们应该始终寻找移除反复代码的办法。这是晋升代码能力的好方法。有时，在条件的两个分支上呈现反复代码，这象征这段代码将始终执行。因而这段反复的代码能够从条件中移出，放在条件之外执行。 if sold > DISCOUNT_AMOUNT: total = sold * DISCOUNT_PRICE label = f'Total: {total}'else: total = sold * PRICE label = f'Total: {total}'通过将对label变量赋值移到到条件之外，咱们删除了反复的代码行，并明确了条件理论管制的内容，就是计算total。 if sold > DISCOUNT_AMOUNT: total = sold * DISCOUNT_PRICEelse: total = sold * PRICElabel = f'Total: {total}'3. 将外部循环中的yield替换为yield from ...

我总结了一些软件开发准则。在这些准则中，大多数都是以简化零碎为外围。在我看来，简略的零碎会更牢靠，更容易批改，而且个别更容易应用。当观点产生扭转时，我心愿更新它们。 1剔除有效状态我把这一点排第一，是因为我认为它是最重要、最弱小的准则之一。 你可能在定义类型时听到过这个词，但其实这个准则实用于所有与示意数据相干的中央——例如数据库设计。 它不仅能够缩小零碎的状态数量（从而变得更简略），还能缩小有效状态的数量！你的零碎不须要解决这些有效状态，因为它们在你的程序中实际上是不可示意的。 这不只是一个小技巧，它能够极大简化你的零碎，并防止出现各种类型的 bug。这有一些例子。 2数据一致性让零碎更简略对数据施加一致性规定，缩小了零碎须要解决的状态数量。这是从上一个准则派生而来的。 定义这里说的是一致性的广泛含意：即数据遵循某些规定，并且在任意时刻都始终遵循这些规定。这一定义与 ACID 无关，但不要与 CAP 混同起来了。 规定能够是任何货色，例如，你的信用永远不能变成正数，或者私密的帖子不应该被其他人看到。它不仅限于外键或惟一索引，只管它们也是无效的规定。 和数据库一样，应用程序也能够通过应用 ACID 事务来增强一致性。如果能在数据库级别强制放弃一致性是最好的，但在理论中，对略微简单一点的货色来说，这样做并不常见。 实用倡议任何限度或侵害一致性的行为都会导致复杂性。这就引出了以下这些实用的倡议： 让零碎更简略： 更少的数据库 (现实状况下是一个)规范化，缩小冗余数据一个“好的”数据库设计ACID 事务更多的数据束缚让零碎更简单： 多个数据库冗余或非正规化数据蹩脚的数据库设计较少（或没有）数据束缚当然，有时候让零碎变简单也是有正当理由的，我并不想让复杂性变成一个“恶浊的”词。请参阅前面的一个准则“杀鸡不要用牛刀”。 我认为这个准则是当今软件工程中最被低估的准则之一。一致性问题常常被忽视。很多问题，我敢说大多数问题，基本上都是一致性问题——数据不合乎某些冀望。 3数据设计后行这个问题，“代码还是数据？”，哪一个在 10 年后更有可能持续存在。 代码能够被丢掉重写，但数据很少会这样。 数据比代码更重要。代码的惟一目标是转换数据。 在设计新零碎时，最好先从数据库和数据结构开始，并在此基础上开发代码。要思考能够在数据上施加的束缚并施行它们，现实状况下是通过示意数据的形式进行的。 代码设计是数据设计的下一步。数据模型越简略、越统一，代码就会越简略。 你们把流程图给我看，但把表藏起来，我就一头雾水。你们把表给我看，通常我就不须要你们的流程图，它们会不言自明。—— Fred Brooks 蹩脚的程序员关怀代码。好的程序员关怀数据结构和它们之间的关系。—— Linux 之父 Linus Torvalds 4杀鸡不要用牛刀这是软件开发人员最常犯的谬误。 这个准则是说，当你在做须要付出复杂性代价的衡量时，要确保衡量的必要性失去教训证据的反对。 常见谬误： 试图构建一个简单的“可伸缩”零碎，能够伸缩到你可能永远都不须要的规模。在不思考需要或老本的状况下，让服务尽可能地小。在非性能瓶颈的中央优化性能，减少不一致性或复杂性。倡议： 尽可能从最简略、最正确的零碎开始对性能进行度量如果不能解决理论问题，就不要付出复杂性代价或违反其余准则。有些优化能够不进行度量，因为它们的老本非常低或为零。例如，为了保障你想要执行的操作具备你想要的性能，应用正确的数据结构。确实，有时候教训自身就能通知你是否做出了正确的衡量。但如果你能证实，那就更好了。当你必须做出抉择时，请抉择正确性和简略性，而不是性能。在某些状况下，正确而简略的代码是性能最好的代码！真正的问题是程序员在谬误的中央和谬误的工夫花了太多的工夫在放心效率上。过早优化是编程中所有（或者至多是大部分）邪恶的本源。——计算机科学家 Donald Knuth 5防止为了部分简略性而减少全局复杂性也就是防止为了让零碎的一部分变得更简略，而导致整个零碎变得更简单。 这种替换通常是不平等的。谋求部分的简略性会导致全局复杂性的减少，而且是数量级的。 例如，应用较小的服务能够让这些服务变得更简略，但一致性的升高和对更多过程间通信的需要让零碎变得更加简单。 6辨认外在的复杂性有时候事件自身就很简单，你不能把问题简单化。 任何这样的尝试都只会让零碎变得更加简单。 7应用的技术越少，零碎就越简略深刻了解一小部分技术要比只是外表了解很多技术好。 更少的技术意味着更少的货色要学习和更少的运维复杂性。 8集中精力学习概念，而不是技术不要太关怀技术的简单细节，因为你能够随时查阅它们。你要学习底层的基本概念。 技术会变动，概念却是永恒的。你学到的概念将被用在更新的技术中，你就能够更快地学会新技术。 例如，不要太关注 React、Kubernetes、Haskell、Rust 的外表细节。 重点学习： 纯函数式编程关系型模型标准的办法逻辑编程代数数据类型类型类 (通用的和特定的)借位查看器 (仿射 / 线性类型)依赖类型Curry-Howard 同构宏同像性（Homoiconicity）VirtualDOM线性回归......9代码一致性很重要有时候，具备一致性的代码比“正确”的代码更重要。如果你想要扭转代码库中某些代码的行为，就要批改它所有的实例。否则的话，就只能忍耐。 代码的可读性更多地与一致性（而不是简略性）无关。人们通过模式识别来了解代码，所以请反复 (和记录) 模式！ 10分享准则很重要如果你和队友之间的独特准则越多，就能越好地在一起工作，而且你会越喜爱和他们在一起工作。 11附录：不一致性导致的复杂性这是我能想到的最简略的例子，心愿能毫不费力地与事实问题分割起来。 ...

为什么在一些状况下，Python 中的简略乘/除法比位运算要快？ 首先秉持着捕风捉影的精力，咱们先来验证一下 In [33]: %timeit 1073741825*2 7.47 ns ± 0.0843 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)In [34]: %timeit 1073741825<<1 7.43 ns ± 0.0451 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)In [35]: %timeit 1073741823<<1 7.48 ns ± 0.0621 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)In [37]: %timeit 1073741823*2 7.47 ns ± 0.0564 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)咱们发现几个很乏味的景象 ...

数据采集就怕遇到图片，只能看不能复制怎么办。手动将文字提取进去，要消耗很大的工作量。 例如下图，某楼盘的一房一价表，怎么样发现单价低位的房子？光凭肉眼很难发现吧，是否让计算机进行文字的辨认，而后再对这些数值型信息进行数据分析？ 首先把图片中的单价提取进去， 进而生成图像： 用python就能够实现，采纳当初风行的OCR图像识别。次要思路是应用机器学习模式，通过已有图片手动训练出一个图像识别模型，具体步骤如下： 一、将图片预处理，更不便计算机辨认 （一）把图像灰化 应用open-cv库对图片进行解决。 应用灰化后的图片，如下图，排除烦扰信息，能让辨认更加稳固。 （二）把图片宰割 将图片宰割成小方块，一是进步辨认精度，二是不便将数据贮存为表格模式。能够设定好参数，依据坐标系把图片裁剪成一个个小方块，如下图，贮存为jpg格局。 二、建设图像识别模型 （一）将宰割好的小方块图片合并成tiff文件 下载jTessBoxEditor，关上jTessBoxEditor.jar，应用tools下的merge tiff工具，将图片合并成tiff文件。 （二）应用已有模型对tiff文件进行初辨认 下载并装置tesseract，并配置好环境变量，将Tesseract-OCR和tessdata的门路退出到环境变量下的path上面。 Tesseract自带图像识别的模型，例如中文简体汉字辨认模型chi_sim.traineddata，英文辨认模型eng.traineddata，这些模型能够网上下载，放到tessdata外面即可应用。 而后进入tiff所在文件夹。在命令窗口，输出：tesseract ***.tif *** -l +++ -psm 7 batch.nochop makebox，按回车生成box文件。其中***为tif的文件名，+++为要生成的traindata的文件名。 （三）应用jTessBoxEditor对tiff和box文件进行调整 关上jTessBoxEditor.jar，在box editor中的open按钮，关上要编辑的tif文件。编辑之后保留，生成box文件。保留在同一个文件夹里。 （四）应用tiff和box文件生成模型 在tiff和box的文件中，在命令窗口输出以下代码，最终生成模型（traindata文件） 上述脚本也能够写在bat文件中，运行脚本来生成traindata，最终仅须要将traindata复制到tessdata外面，即可应用该模型。 三、利用图像识别模型 装置完，训练完模型之后，就要在python中应用模型了。装置pytesseract，找到pytesseract.py文件，关上编辑，将其中的“tesseract_cmd = 'tesseract'”，改成tesseract的装置门路（如C:\Program Files\Tesseract-OCR\tesseract）。 因为模型是采纳灰化后的图片训练的，所以在辨认时也要应用灰化。 四、优化图像识别模型 在应用中，如果有谬误，能够存下来，退出训练库，优化图像识别模型。在个别是辨认谬误的图片，积攒一阵子后。累积做成tif文件。留神：同类谬误抉择几个记号了，训练库尽量小而精。 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

之前介绍过 Google ReCAPTCHA 验证码的绕过办法，过后介绍的是用 2Captcha，然而有些敌人跟我反映说 2Captcha 价格比拟贵，而且用起来比较复杂。 明天再给大家介绍另一个用于破解 Google ReCAPTCHA 的办法。 ReCAPTCHA 介绍可能大家还没听说过什么是 ReCAPTCHA，可能因为某些起因，这个验证码在国内呈现不多，不过想必大家应该多多少少见过或用过。它长这个样子： 这时候，只有咱们点击最后面的复选框，验证码算法会首先利用其「危险剖析引擎」做一次平安检测，如果间接测验通过的话，咱们会间接失去如下的后果： 如果算法检测到以后零碎存在危险，比方可能是生疏的网络环境，可能是模拟程序，会须要做二次校验。它会进一步弹出相似如下的内容： 比方下面这张图，验证码页面会呈现九张图片，同时最上方呈现文字「树木」，咱们须要点选下方九张图中呈现「树木」的图片，点选实现之后，可能还会呈现几张新的图片，咱们须要再次实现点选，最初点击「验证」按钮即可实现验证。或者咱们能够点击下方的「耳机」图标，这时候会切换到听写模式，验证码会变成这样： 这时候咱们如果能填写对验证码读的音频内容，同样能够通过验证。这两种形式都能够通过验证，验证实现之后，咱们能力实现表单的提交，比方实现登录、注册等操作。这种验证码叫什么名字？这个验证码就是 Google 的 ReCAPTCHA V2 验证码，它就属于行为验证码的一种，这些行为包含点选复选框、抉择对应图片、语音听写等内容，只有将这些行为校验通过，此验证码能力通过验证。相比于个别的图形验证码来说，此种验证码交互体验更好、安全性会更高、破解难度更大。 其实上文所介绍的验证码仅仅是 ReCAPTCHA 验证码的一种模式，是 V2 的显式版本，另外其 V2 版本还有隐式版本，隐式版本在校验的时候不会再显式地呈现验证页面，它是通过 JavaScript 将验证码和提交按钮进行绑定，在提交表单的时候会主动实现校验。除了 V2 版本，Google 又推出了最新的 V3 版本，reCAPTCHA V3 验证码会为依据用户的行为来计算一个分数，这个分数代表了用户可能为机器人的概率，最初通过概率来判断校验是否能够通过。其安全性更高、体验更好。 体验那哪里能够体验到 ReCAPTCHA 呢？咱们能够关上这个网站：https://www.google.com/recapt...，倡议迷信上网，同时用匿名窗口关上，这样的话测试不会受到历史 Cookies 的烦扰，如图所示： 这时候，咱们能够看到下方有个 ReCAPTCHA 的窗口，而后点击之后就呈现了一个验证图块。 当然靠人工是能解的，但对于爬虫来说必定不行啊，那怎么自动化解呢？ 接下来咱们就来介绍一个简略好用的平台。 解决方案本次咱们介绍的一个 ReCAPTCHA 破解服务叫做 YesCaptcha，主页是 http://yescaptcha.365world.co...，它当初同时能够反对 V2 和 V3版本的破解。 咱们这次就用它来尝试解一下方才的 ReCAPTCHA 上的 V2 类型验证码：https://www.google.com/recapt...。 简略注册之后，能够找到首页有一个 Token。咱们能够复制下来以备前面应用，如图所示： ...

前言以前没怎么接触前端，对 JavaScript 的异步操作不理解，当初有了点理解。一查发现 Python 和 JavaScript 的协程发展史几乎就是一毛一样！ 这里大抵做下横向比照和总结，便于对这两个语言有趣味的新人了解和排汇。 独特诉求随着 cpu 多核化，都须要实现因为本身历史起因（单线程环境）下的并发性能简化代码，防止回调天堂，关键字反对无效利用操作系统资源和硬件：协程相比线程，占用资源更少，上下文更快什么是协程？总结一句话，协程就是满足上面条件的函数： 能够暂停执行（暂停的表达式称为暂停点)能够从挂终点复原（保留其原始参数和局部变量）事件循环是异步编程的底层基石凌乱的历史Python 协程的进化Python2.2 中，第一次引入了生成器Python2.5 中，yield 关键字被退出到语法中Python3.4 时有了 yield from（yield from 约等于 yield + 异样解决 + send）， 并试验性引入的异步 I/O 框架 asyncio（PEP 3156）Python3.5 中新增了 async/await 语法（PEP 492）Python3.6 中 asyncio 库"转正" （之后的官网文档就清晰了很多）在主线倒退过程中，也呈现了很多干线的协程实现如 Gevent。 def foo():    print("foo start")    a = yield 1    print("foo a", a)    yield 2    yield 3    print("foo end")gen = foo()# print(gen.next())# gen.send("a")# print(gen.next())# print(foo().next())# print(foo().next())# 在python3.x版本中,python2.x的g.next()函数曾经更名为g.__next__(),应用next(g)也能达到雷同成果。# next()跟send()不同的中央是,next()只能以None作为参数传递,而send()能够传递yield的值.print(next(gen))print(gen.send("a"))print(next(gen))print(next(foo()))print(next(foo()))list(foo())"""foo start1foo a a23foo start1foo start1foo startfoo a Nonefoo end"""JavaScript 协程的进化同步代码异步 JavaScript: callback hellES6 引入 Promise/a+， 生成器 Generators（语法 function foo(){} * 能够赋予函数执行暂停/保留上下文/复原执行状态的性能）， 新关键词 yield 使生成器函数暂停。ES7 引入 async函数/await语法糖，async 能够申明一个异步函数（将 Generator 函数和主动执行器，包装在一个函数里），此函数须要返回一个 Promise 对象。await 能够期待一个 Promise 对象 resolve，并拿到后果Promise 中也利用了回调函数。在 then 和 catch 办法中都传入了一个回调函数，别离在 Promise 被满足和被回绝时执行，这样就就能让它可能被链接起来实现一系列工作。 ...

1. 前言思考到 Python 性能及效率性，Python Web 端始终不温不火，JAVA 和 Golang 的微服务生态始终很凋敝，也被宽泛用于企业级利用开发当中 本篇文章将介绍一款 Python 微服务框架：「 Nameko 」 2. Nameko 介绍Nameko 是一款玲珑、简洁的、异步通信形式的微服务架构 它采纳 RabbitMQ 音讯队列作为消息中间件，基于发布者、订阅者模式 其中，消费者与生产者基于 RPC 进行通信 我的项目地址：https://github.com/nameko/nameko 3. 实战一下上面以 Flask 为例聊聊搭建 Python 微服务的步骤 3-1  装置 RabbitMQ 及启动 这里举荐利用 Docker 装置 RabbitMQ，以 Centos 为例 # 1、下载某个版本的RabbitMQ的镜像# MQ版本号：3.9.5docker pull rabbitmq:3.9.5-management# 2、查看镜像docker images# 3、启动MQ容器# p：指定利用端口及Web控制台端口# hostname：主机名# e：环境变量# RABBITMQ_DEFAULT_VHOST：虚拟机名称# RABBITMQ_DEFAULT_USER：用户名# RABBITMQ_DEFAULT_PASS：明码# 3e83da0dc938：MQ镜像IDdocker run -d --name rabbitmq3.9.5 -p 5672:5672 -p 15672:15672 -v `pwd`/data:/var/lib/rabbitmq --hostname myRabbit -e RABBITMQ_DEFAULT_VHOST=my_vhost  -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin 3e83da0dc938须要留神的是，启动 MQ 容器时，利用 -p 指定了两个端口\ 5672 利用拜访端口 15672 控制台 Web 拜访端口号 而后，凋谢防火墙的 5672、15672 端口号 PS：如果是云服务器，须要另外配置平安组 最初，在浏览器中通过上面的连贯进入到 MQ 后盾 Web 治理页面 地址：http://ip地址:15672 3-2  装置依赖包 应用 pip 命令在虚拟环境下装置 nameko、flask 依赖包 ...

咱们晓得，在 Python 外面能够应用time.sleep来让代码暂停一段时间，例如： import timeprint('...局部代码...')time.sleep(5)print('...剩下的代码...')程序首先打印出...局部代码...，而后期待5秒钟，再打印出...剩下的代码...。 当初大家想一想，有没有什么方法，在不应用time.sleep的状况下，让程序暂停5秒？ 你可能会说，用requests拜访一个提早5秒的网址、或者用递归版算法计算斐波那契数列第36位……这些奇技淫巧。 不过明天我说的，是另外一个货色，threading模块外面的Event。 咱们来看看它的用法： import threadingevent = threading.Event()print('...局部代码...')event.wait(5)print('...剩下的代码...')这样一来，程序首先打印出...局部代码...，而后期待5秒钟，再打印出...剩下的代码...。 性能看起来跟time.sleep没什么区别，那为什么我要特地提到它呢？因为在多线程外面，它比time.sleep更有用。咱们来看一个例子： import threadingclass Checker(threading.Thread): def __init__(self, event): super().__init__() self.event = event def run(self): while not self.event.is_set(): print('查看 redis 是否有数据') time.sleep(60)trigger_async_task()event = threading.Event()checker = Checker(event)checker.start()if user_cancel_task(): event.set()我来解释一下这段代码的意思。在主线程外面，我调用trigger_async_task()触发了一个异步工作。这个工作多久实现我并不分明。然而这个工作实现当前，它会往 Redis 外面发送一条音讯，只有 Redis 有这个音讯了，我就晓得它实现了。所以我要创立一个 checker 子线程，每60秒去 Redis外面查看工作是否实现。如果没有实现，就暂停60秒，而后再查看。 但某些状况下，我不须要期待了，例如用户被动勾销了工作。这个时候，我就想提前结束这个 checker 子线程。 然而咱们晓得，线程是不能从里面被动杀死的，只能让它本人退出。所以当我执行event.set()后，子线程外面self.event.is_set()就会返回 False，于是这个循环就不会继续执行了。 可是，如果某一轮循环刚刚开始，我在主线程外面调用了event.set()。此时，子线程还在time.sleep中，那么子线程须要期待60秒才会退出。 但如果我批改一下代码，应用self.event.wait(60)： import threadingclass Checker(threading.Thread): def __init__(self, event): super().__init__() self.event = event def run(self): while not self.event.is_set(): print('查看 redis 是否有数据') self.event.wait(60)trigger_task()event = threading.Event()checker = Checker(event)checker.start()if user_cancel_task(): event.set()那么，即使self.event.wait(60)刚刚开始阻塞，只有我在主线程中执行了event.set()，子线程外面的阻塞立即就会完结。于是子线程立即就会完结。不须要再白白期待60秒。 ...

从 Python 3.6 开始，惯例的字典会记住其插入的程序：就是说，当遍历字典时，你取得字典中元素的程序跟它们插入时的程序雷同。 在 3.6 之前，字典是无序的：遍历程序是随机的。 对于有序字典，这里有两件令人意外的事件。 1、你无奈取得第一个元素因为字典中的元素具备特定的程序，因而获取第一个（或第 N 个）元素应该很容易，对吧？ 不对！没方法间接做到。 你可能会认为 d[0] 就是第一个元素，但并不是，它只是键为 0 的值，有可能是增加到字典的最初一个元素。 取得第 N 个元素的惟一办法是遍历字典，直到获得第 N 个元素。不能依据有序索引来作随机拜访。 这是一处列表胜过字典的中央。获取列表的第 N 个元素是 O(1) 操作。获取字典的第 N 个元素（即便已排序）是 O(N) 操作。 2、OrderedDict 有点不同因为当初的字典是有序的，collections.OrderedDict 就没用了，对吧？（译注：3.6 版本前的 dict 是无序的，但规范库里提供了一个有序字典 OrderedDict。当初 dict 变有序了，那 OrderedDict 仿佛是多余了？） 如同是。然而它不会被删除，因为那样会毁坏正在应用它的代码，并且它还领有一些惯例字典没有的办法。 另外，它们在行为上也有轻微的差异。在比拟是否相等时，惯例字典不会思考程序，但 OrderedDict 会： >>> d1 = {"a": 1, "b": 2}>>> d2 = {"b": 2, "a": 1}>>> d1 == d2True>>> list(d1)['a', 'b']>>> list(d2)['b', 'a']>>> from collections import OrderedDict>>> od1 = OrderedDict([("a", 1), ("b", 2)])>>> od2 = OrderedDict([("b", 2), ("a", 1)])>>> od1 == od2False>>> list(od1)['a', 'b']>>> list(od2)['b', 'a']>>>以上就是本次分享的所有内容，想要理解更多 python 常识欢送返回公众号：Python 编程学习圈 ，发送 “J” 即可收费获取，每日干货分享 ...

背景 在Python中应用日志最罕用的形式就是在控制台和文件中输入日志了,logging模块也很好的提供的相应 的类,应用起来也十分不便,然而有时咱们可能会有一些需要,如还须要将日志发送到远端,或者间接写入数 据库,这种需要该如何实现呢? StreamHandler和FileHandler 首先咱们先来写一套简略输入到cmd和文件中的代码 # -*- coding: utf-8 -*-"""------------------------------------------------- File Name： loger Description : Author : yangyanxing date： 2020/9/23-------------------------------------------------"""import loggingimport sysimport os# 初始化loggerlogger = logging.getLogger("yyx")logger.setLevel(logging.DEBUG)# 设置日志格局fmt = logging.Formatter('[%(asctime)s] [%(levelname)s] %(message)s', '%Y-%m-%d%H:%M:%S')# 增加cmd handlercmd_handler = logging.StreamHandler(sys.stdout)cmd_handler.setLevel(logging.DEBUG)cmd_handler.setFormatter(fmt)# 增加文件的handlerlogpath = os.path.join(os.getcwd(), 'debug.log')file_handler = logging.FileHandler(logpath)file_handler.setLevel(logging.DEBUG)file_handler.setFormatter(fmt)# 将cmd和file handler增加到logger中logger.addHandler(cmd_handler)logger.addHandler(file_handler)logger.debug("今天天气不错")先初始化一个logger, 并且设置它的日志级别是DEBUG,而后添初始化了 cmd_handler和 file_handler,最初将它们增加到logger中, 运行脚本,会在cmd中打印出 [2020-09-23 10:45:56] [DEBUG] 今天天气不错且会写入到当前目录下的debug.log文件中 增加HTTPHandler 如果想要在记录时将日志发送到近程服务器上,能够增加一个 HTTPHandler , 在python规范库logging.handler中,曾经为咱们定义好了很多handler,有些咱们能够间接用,本地应用tornado写一个接管 日志的接口,将接管到的参数全都打印进去 # 增加一个httphandlerimport logging.handlershttp_handler = logging.handlers.HTTPHandler(r"127.0.0.1:1987", '/api/log/get')http_handler.setLevel(logging.DEBUG)http_handler.setFormatter(fmt)logger.addHandler(http_handler)logger.debug("今天天气不错")后果在服务端咱们收到了很多信息{'name': [b 'yyx'],'msg': [b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\xa4\xa9\xe6\xb0\x94\xe4\xb8\x8d\xe9\x94\x99'],'args': [b '()'],'levelname': [b 'DEBUG'],'levelno': [b '10'],'pathname': [b 'I:/workplace/yangyanxing/test/loger.py'],'filename': [b 'loger.py'],'module': [b 'loger'],'exc_info': [b 'None'],'exc_text': [b 'None'],'stack_info': [b 'None'],'lineno': [b '41'],'funcName': [b '<module>'],'created': [b '1600831054.8881223'],'msecs': [b '888.1223201751709'],'relativeCreated': [b '22.99976348876953'],'thread': [b '14876'],'threadName': [b 'MainThread'],'processName': [b 'MainProcess'],'process': [b '8648'],'message': [b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\xa4\xa9\xe6\xb0\x94\xe4\xb8\x8d\xe9\x94\x99'],'asctime': [b '2020-09-23 11:17:34']}能够说是信息十分之多,然而却并不是咱们想要的样子,咱们只是想要相似于 ...

Python凭什么就那么好用呢？毫无疑问，大量现成又好用的内置/第三方库功不可没。 那咱们是怎么应用它们的呢？ 噢，对了~是用的import xxx这个语句。 之所以会有此一问，也是之前有一次应用PyCharm进行开发时（又）踩了个坑…… 废话少说，先讲问题像上面这样一个我的项目构造： Projetc_example|-- A |-- alpha.py |-- beta.py|-- B |-- theta.py|-- main |-- main.py假如要在main.py中导入theta.py： # main/main.pyfrom B import theta显然会导致咱们所不心愿的问题，即Python不晓得要到哪里去找这个名为B的模块（包是一种非凡的模块）： Traceback (most recent call last): File "main/main.py", line 1, in <module> from B import thetaModuleNotFoundError: No module named 'B'可是这就奇了怪了，为啥同样的代码，在PyCharm里运行就是好的了呢？ import的查找门路于是咱们不辞艰苦，高低求索，原来在Python中，import语句实际上封装了一系列过程。 查找是否已导入同名模块首先，Python会依照import xxx中指定的包名，到sys.modules中查找以后环境中是否曾经存在相应的包——不要奇怪为什么都没有导入sys这个模块就有sys.modules了。sys是Python内置模块，也就是亲儿子，导入只是意思一下，让咱们这样的外人在导入的环境中也能够应用相干接口而已，实际上相应的数据对Python而言从始至终都是通明的。 咱们能够导入sys查看一下这个对象的具体内容（节俭篇幅，做省略解决）： >>> import sys>>> sys.modules{'sys': <module 'sys' (built-in)>, 'builtins': <module 'builtins' (built-in)>, ...'re': <module 're' from 'E:\\Anaconda\\Anaconda\\lib\\re.py'>, ...}这些就都是Python一开始就曾经加载好的模块，也就是装置好Python之后，只有一运行环境中就曾经就绪的模块——只是作为外人的咱们还不能间接拿过去用，得跟Python报备一声：“欸，我要拿您儿子来用了嗨~” 很容易能够发现，sys.modules中列出来的已加载模块中存在显著的不同，后面的很多模块显得很洁净，而前面的很多模块都带有from yyy'的字样，并且这个yyy看起来还像是一个门路。 这就关系到咱们接下来要讲的步骤了。 在特定门路下查找对应模块后面咱们讲到了，当咱们导入某个模块时，Python先会去查问sys.modules，看其中是否存在同名模块，查到了那当然大快人心，Python间接把这个模块给咱们用就好了，毕竟儿子那么多，借出去赚点外快也是好事儿不是？可问题在于：那要是没找到呢？ 这显然是一个很事实的问题。毕竟资源是无限的，Python不可能把你可能用到的所有模块全都一股脑给加载起来，否则这样男上加男加男加男……谁也顶不住啊不是（大雾 于是乎就有人给Python出了个主见：那你等到要用的时候，再去找他说他是你儿子呗 ...

前言Python 不愧是一门优雅、易入门的编程语言。往往用很大量的代码，就能帮忙你实现一件很漂亮的事儿。 最开始学习 Python，不须要太过简单。只有玩儿的开心就行，缓缓造就趣味，等你上手后，你会学习的更有信念。明天咱们就来玩玩儿，5 行代码能做啥？ 这里我为大家介绍两个好玩儿的小我的项目，介绍如下： 我的项目一： 5 行代码让电脑永不息屏！我的项目二： 5 行代码爬取表格数据！ 我的项目一：5行代码让电脑 永不锁屏家喻户晓，当你的电脑鼠标始终在动的时候，零碎会默认你的电脑是在工作当中，因而就不会息屏。既然是玩吗？你就不要杠，说为啥 “不设置用不息屏” ？那样，你赢了，我无话可说。哈哈！这里就是用代码自动化管制鼠标，实现鼠标的 “上下左右” 挪动操作，让电脑误以为是认为在操作鼠标。在这里，咱们应用的是Python中的pyautogui库。如果你的电脑没有装置这个库，能够应用上面代码装置一下。 pip install pyautogui管制鼠标挪动，应用的是pyautogui库中的moveRel(x,y)函数，用法如下： 含意： 依据以后地位, 绝对挪动鼠标指针；留神： 当x/y大于0，则示意往右/往下挪动鼠标指针。当x/y小于0，则往左/往上挪动鼠标指针【x/y是整数】；当然这个随机数，必定不要你人为去设置，咱们也随机生成。在这里我须要为大家在介绍random库中的一个函数random.randint(a,b)，用法如下： 含意： 用于生成指定数值范畴内的随机整数；留神： 该函数有两个参数a和b，示意指定区间的下限和上限；import random random.randint(a=100,b=300)后果如下： 有了这些根底后，咱们间接上代码吧！ # 导入相干库import pyautoguiimport randomimport time# 应用while True循环，让程序始终执行！while True:    x = random.randint(-200,200)    y = random.randint(-200,200)    pyautogui.moveRel(x,y)    time.sleep(5) # 让鼠标挪动到某个地位，停留几秒钟，我怕它太累当然，pyautogui库作为一个自动化操作鼠标的库，有很多值得你去开掘的知识点。这里只是简略应用，其它常识能够依据你的理论需要，去零碎学习一下。 我的项目二：5行代码爬取表格数据如果说想学习Python爬虫的话，我想这应该是最简略爬虫代码了。 说白了，就是pandas库爬取表格数据。这个其实和Excel有点像，Excel不就是只能爬取一些规定的表格数据吗？然而这个更好用哦，毕竟不让你入手。明天咱们爬取到网页是 “中商情报网” 。 <table class="..." id="...">     <thead>     <tr>     <th>...</th>     </tr>     </thead>     <tbody>        <tr>            <td>...</td>        </tr>        <tr>...</tr>        <tr>...</tr>        ...        <tr>...</tr>        <tr>...</tr>    </tbody></table>咱们点击F12，查看源代码，当咱们定位待爬取数据时，会发现该数据满足这个特点。 其余常识没必要多讲，毕竟都是pandas中的常识，大家很相熟了。上代码： # 导入相干库import pandas as pdimport csv# 咱们只爬取十页数据for i in range(1,10):  # 爬取全副页    tb = pd.read_html(f'http://s.askci.com/stock/a/?reportTime=2021-03-31&pageNum={i}')[3]     tb.to_csv(r'上市公司.csv', mode='a', encoding='utf_8_sig', header=1, index=0)后果如下： 妥妥的，这么多家上市公司的数据，就被你支出囊中了。而后能够拿去做个简略的剖析，或者练习pandas数据处理，不香吗？ 这里还有一点值得阐明的是，下面代码中有一个[3]，代表啥意思呢？这是因为网页上可能存在多个表格，这时候就须要靠列表的切片tables[x]，来指定获取哪个表格。好了，明天的案例就介绍到这里，你学会了吗？ 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

家喻户晓，Python 不是一种执行效率较高的语言。此外在任何语言中，循环都是一种十分耗费工夫的操作。如果任意一种简略的单步操作消耗的工夫为 1 个单位，将此操作反复执行上万次，最终消耗的工夫也将增长上万倍。 while 和 for 是 Python 中罕用的两种实现循环的关键字，它们的运行效率实际上是有差距的。比方上面的测试代码： import timeitdef while_loop(n=100_000_000):    i = 0    s = 0    while i < n:        s += i        i += 1    return sdef for_loop(n=100_000_000):    s = 0    for i in range(n):        s += i    return sdef main():    print('while loop\t\t', timeit.timeit(while_loop, number=1))    print('for loop\t\t', timeit.timeit(for_loop, number=1))if __name__ == '__main__':    main()# => while loop               4.718853999860585# => for loop                 3.211570399813354这是一个简略的求和操作，计算从 1 到 n 之间所有自然数的总和。能够看到 for 循环相比 while 要快 1.5 秒。 其中的差距次要在于两者的机制不同。 在每次循环中，while 实际上比 for 多执行了两步操作：边界检查和变量 i 的自增。即每进行一次循环，while 都会做一次边界查看 (while i < n）和自增计算（i +=1）。这两步操作都是显式的纯 Python 代码。 for 循环不须要执行边界检查和自增操作，没有减少显式的 Python 代码（纯 Python 代码效率低于底层的 C 代码）。当循环的次数足够多，就呈现了显著的效率差距。 能够再减少两个函数，在 for 循环中加上不必要的边界检查和自增计算： import timeitdef while_loop(n=100_000_000):    i = 0    s = 0    while i < n:        s += i        i += 1    return sdef for_loop(n=100_000_000):    s = 0    for i in range(n):        s += i    return sdef for_loop_with_inc(n=100_000_000):    s = 0    for i in range(n):        s += i        i += 1    return sdef for_loop_with_test(n=100_000_000):    s = 0    for i in range(n):        if i < n:            pass        s += i    return sdef main():    print('while loop\t\t', timeit.timeit(while_loop, number=1))    print('for loop\t\t', timeit.timeit(for_loop, number=1))    print('for loop with increment\t\t',          timeit.timeit(for_loop_with_inc, number=1))    print('for loop with test\t\t', timeit.timeit(for_loop_with_test, number=1))if __name__ == '__main__':    main()# => while loop               4.718853999860585# => for loop                 3.211570399813354# => for loop with increment          4.602369500091299# => for loop with test               4.18337869993411能够看出，减少的边界检查和自增操作的确大大影响了 for 循环的执行效率。 后面提到过，Python 底层的解释器和内置函数是用 C 语言实现的。而 C 语言的执行效率远大于 Python。 对于下面的求等差数列之和的操作，借助于 Python 内置的 sum 函数，能够取得远大于 for 或 while 循环的执行效率。 import timeitdef while_loop(n=100_000_000):    i = 0    s = 0    while i < n:        s += i        i += 1    return sdef for_loop(n=100_000_000):    s = 0    for i in range(n):        s += i    return sdef sum_range(n=100_000_000):    return sum(range(n))def main():    print('while loop\t\t', timeit.timeit(while_loop, number=1))    print('for loop\t\t', timeit.timeit(for_loop, number=1))    print('sum range\t\t', timeit.timeit(sum_range, number=1))if __name__ == '__main__':    main()# => while loop               4.718853999860585# => for loop                 3.211570399813354# => sum range                0.8658821999561042能够看到，应用内置函数 sum 代替循环之后，代码的执行效率实现了成倍的增长。 内置函数 sum 的累加操作实际上也是一种循环，但它由 C 语言实现，而 for 循环中的求和操作是由纯 Python 代码 s += i 实现的。C > Python。 再拓展一下思维。小时候都据说过童年高斯奇妙地计算 1 到 100 之和的故事。1…100 之和等于 (1 + 100) * 50。这个计算方法同样能够利用到下面的求和操作中。 import timeitdef while_loop(n=100_000_000):    i = 0    s = 0    while i < n:        s += i        i += 1    return sdef for_loop(n=100_000_000):    s = 0    for i in range(n):        s += i    return sdef sum_range(n=100_000_000):    return sum(range(n))def math_sum(n=100_000_000):    return (n * (n - 1)) // 2def main():    print('while loop\t\t', timeit.timeit(while_loop, number=1))    print('for loop\t\t', timeit.timeit(for_loop, number=1))    print('sum range\t\t', timeit.timeit(sum_range, number=1))    print('math sum\t\t', timeit.timeit(math_sum, number=1))if __name__ == '__main__':    main()# => while loop               4.718853999860585# => for loop                 3.211570399813354# => sum range                0.8658821999561042# => math sum                 2.400018274784088e-06最终 math sum 的执行工夫约为 2.4e-6，缩短了上百万倍。这里的思路就是，既然循环的效率低，一段代码要反复执行上亿次。 索性间接不要循环，通过数学公式，把上亿次的循环操作变成只有一步操作。效率天然失去了空前的增强。 ...

Dynaconf 是一个 Python 的第三方模块，旨在成为在 Python 中治理配置的最佳抉择。 它能够从各种起源读取设置，包含环境变量、文件、服务器配置等 它实用于任何类型的 Python 程序，包含 Flask 和 Django 扩大 1.筹备 开始之前，你要确保 Python 和 pip 曾经胜利装置在电脑上 而后，请抉择以下任一种形式输出命令装置依赖： Windows 环境 关上 Cmd ( 开始-运行-CMD )MacOS 环境 关上 Terminal ( command + 空格输出 Terminal )如果你用的是 VSCode 编辑器 或 Pycharm，能够间接应用界面下方的 Terminal。pip install dynaconf2.初步应用DynaConf 在你的我的项目的根目录中运行 dynaconf init 命令。 cd path/to/your/project/dynaconf init -f toml会有相似如下的输入，阐明初始化实现： ⚙️ Configuring your Dynaconf environment------------------------------------------ The file `config.py` was generated.️ settings.toml created to hold your settings. .secrets.toml created to hold your secrets. the .secrets.* is also included in `.gitignore`beware to not push your secrets to a public repo. Dynaconf is configured! read more on https://dynaconf.com刚刚初始化的时候咱们抉择了 toml 格局。实际上你还能够抉择 toml|yaml|json|ini|py ，不过 toml 是默认的，也是最举荐的配置格局。 ...

邂逅Django - 目录✅ Part 1：【邂逅Django】—— （一）创立我的项目 ✅ Part 2：【邂逅Django】—— （二）数据库配置 ️ Part 3：【邂逅Django】—— （三）视图 ️ Part 4：【邂逅Django】—— （四）表单和通用视图 ️ Part 5：【邂逅Django】—— （五）欠缺界面（自定义界面和款式） ️ Part 6：【邂逅Django】—— （六）自定义治理界面 ️ Part 7：【邂逅Django】—— （七）自动化测试 前言本系列文章，在Django官网文档教程的根底模板下，进行了肯定的改良和删除，增加了一些本人的见解。 心愿大家看完该系列文章后，对Django可能有一个清晰的意识。 路漫漫兮其修远兮，吾将上下而求索！ Django==官网文档==：https://www.djangoproject.com/ ❗ ❗ ❗ 学习过程中，多看官网文档，能够解决很多问题 ❗ ❗ ❗ 本教程应用poetry对我的项目环境进行治理。相干poetry的装置与应用，请参考【Python - 虚拟环境】我的项目的启动，从隔离开发环境开始 - SegmentFault 思否我的项目地址：https://github.com/CoderBerryRabbit/MeetDjango一、视图概述Django中的视图概念是【一类具备雷同性能和模板的网页汇合】。比方，在一个博客利用中，可能会创立如下视图： 博客首页 —— 展现最近的几项内容内容详情页 —— 具体展现某项内容以年为单位的归档页 —— 展现选中的年份里各个月份创立的内容以月为单位的归档页 —— 展现选中的月份里各天创立的内容以天为单位的归档页 —— 展现选中天里创立的所有内容评论处理器 —— 用于响应内容增加评论的操作而在投票利用中，须要以下几个视图： 问题索引页 —— 展现最近的几个投票问题问题详情页 —— 展现某个投票的问题和不带后果的选项列表问题后果页 —— 展现某个投票的后果投票处理器 —— 用于响应用户为某个问题投票的操作在Django中，网页和其余内容都是从视图派生而来的。每一个视图体现为一个Python函数（对于基于类的视图来说，体现为一个办法）。Django会依据用户申请的URL来抉择应用哪个视图。 ...

当开始一个新的 Python 我的项目时，大家很容易一头扎进去就开始编码。其实花一点工夫抉择优良的库，将为当前的开发节俭大量工夫，并带来更高兴的编码体验。 在现实世界中，所有开发人员的关系是相互依赖和关联的（合作开发），代码要有完满的格局、没有低级的谬误、并且测试笼罩了所有代码。另外，所有这些将在每次提交时都能够失去保障。（代码格调对立、类型检测、测试覆盖率高、自动检测） 在本文中，我将介绍如何建设一个能够做到这些点的我的项目。您能够依照步骤操作，也能够间接跳到 应用 cookiecutter 生成我的项目 局部（新手）。 首先，让咱们创立一个新的我的项目目录： mkdir best_practicescd best_practicespipx 装置 Python 三方库的命令行工具Pipx[2] 是一个可用于疾速装置 Python 三方库的命令行工具。咱们将应用它来装置 pipenv 和 cookiecutter。通过上面的命令装置 pipx： python3 -m pip install --user pipxpython3 -m pipx ensurepath应用 pipenv 进行依赖治理Pipenv[3] 为您的我的项目主动创立和治理 virtualenv（虚拟环境），并在装置/卸载软件包时从 Pipfile 增加/删除软件包。它还会生成十分重要的 Pipfile.lock 用于保障依赖的可靠性。 当你晓得，你和你的队友正在应用雷同的库版本时，这将会极大地提高编程的信念和乐趣。Pipenv 很好地解决了应用雷同的库，版本不同的这一问题，Pipenv 在过来的一段时间里取得了宽泛的关注和认可，你能够放心使用。装置命令如下： pipx install pipenv 应用 black 和 isort 进行代码格式化black[4] 能够格式化咱们的代码： Black 是毫不妥协的 Python 代码格式化库。通过应用它，你将放弃手动调整代码格局的细节。作为回报，Black 能够带来速度、确定性和防止调整 Python 代码格调的懊恼，从而有更多的精力和工夫放在更重要的事件上。无论你正在浏览什么样的我的项目，用 black 格式化过的代码看起来都差不多。一段时间后格局不再是问题，这样你就能够更专一于内容。black 通过缩小代码的差异性，使代码查看更快。而 isort[5] 是对咱们的 imports 局部进行排序： isort 为您导入的 Python 包局部（imports）进行排序，因而你不用再对 imports 进行手动排序。它能够按字母程序对导入进行排序，并主动将其拆分成多个局部。应用 pipenv 装置它，以便它们不会使部署凌乱（能够指定只在开发环境装置）： ...

介绍Python 有一种叫做加强算术赋值（augmented arithmetic assignment）的货色。可能你不相熟这个叫法，其实就是在做数学运算的同时进行赋值，例如 a -= b 就是减法的加强算术赋值。 加强赋值是在 Python 2.0 版本中 退出进来的。（译注：在 PEP-203 中引入） 分析 -=因为 Python 不容许笼罩式赋值，所以相比其它有非凡/魔术办法的操作，它实现加强赋值的形式可能跟你设想的不齐全一样。 首先，要晓得a -= b在语义上与 a = a-b 雷同。但也要意识到，如果你事后晓得要将一个对象赋给一个变量名，相比a - b 的盲操作，就可能会更高效。 例如，最起码的益处是能够防止创立一个新对象：如果能够就地批改一个对象，那么返回 self，就比从新结构一个新对象要高效。 因而，Python 提供了一个__isub__() 办法。如果它被定义在赋值操作的左侧（通常称为 lvalue），则会调用右侧的值（通常称为 rvalue ）。所以对于a -= b ，就会尝试去调用 a.__isub__(b)。 如果调用的后果是 NotImplemented，或者基本不存在后果，那么 Python 会退回到惯例的二元算术运算：a - b。 最终无论用了哪种办法，返回值都会被赋值给 a。 上面是简略的伪代码，a -= b 被分解成： # 实现 a -= b 的伪代码if hasattr(a, "__isub__"): _value = a.__isub__(b) if _value is not NotImplemented: a = _value else: a = a - b del _value else: a = a - b演绎这些办法因为咱们曾经实现了二元算术运算，因而演绎加强算术运算并不太简单。 ...

查看 C 代码依照常规，咱们从查看 CPython 解释器编译的字节码开始。 >>> def sub(): a - b... >>> import dis>>> dis.dis(sub) 1 0 LOAD_GLOBAL 0 (a) 2 LOAD_GLOBAL 1 (b) 4 BINARY_SUBTRACT 6 POP_TOP 8 LOAD_CONST 0 (None) 10 RETURN_VALUE看起来咱们须要深入研究 BINARY_SUBTRACT 操作码。翻查 Python/ceval.c 文件，能够看到实现该操作码的 C 代码如下： case TARGET(BINARY_SUBTRACT): { PyObject *right = POP(); PyObject *left = TOP(); PyObject *diff = PyNumber_Subtract(left, right); Py_DECREF(right); Py_DECREF(left); SET_TOP(diff); if (diff == NULL) goto error; DISPATCH();}这里的要害代码是PyNumber_Subtract()，实现了减法的理论语义。持续查看该函数的一些宏，能够找到binary_op1() 函数。它提供了一种治理二元操作的通用办法。 不过，咱们不把它作为实现的参考，而是要用Python的数据模型，官网文档很好，分明介绍了减法所应用的语义。 从数据模型中学习通读数据模型的文档，你会发现在实现减法时，有两个办法起到了关键作用：__sub__ 和 __rsub__。 ...

概要本提案定义了一种形象基类（ABC）（PEP 3119）的层次结构，用来示意相似数字（number-like）的类。它提出了一个 Number :> Complex :> Real :> Rational :> Integral 的层次结构，其中 A :> B 示意“A 是 B 的超类”。该层次结构受到了 Scheme 的数字塔（numeric tower）启发。（译注：数字--复数--实数--有理数--整数） 基本原理以数字作为参数的函数应该可能断定这些数字的属性，并且依据数字的类型，确定是否以及何时进行重载，即基于参数的类型，函数应该是可重载的。 例如，切片要求其参数为Integrals，而math模块中的函数要求其参数为Real。 标准本 PEP 规定了一组形象基类（Abstract Base Class），并提出了一个实现某些办法的通用策略。它应用了来自于PEP 3119的术语，然而该层次结构旨在对特定类集的任何零碎办法都有意义。 规范库中的类型查看应该应用这些类，而不是具体的内置类型。 数值类咱们从 Number 类开始，它是人们设想的数字类型的含糊概念。此类仅用于重载；它不提供任何操作。 class Number(metaclass=ABCMeta): pass大多数复数（complex number）的实现都是可散列的，然而如果你须要依赖它，则必须明确地查看：此层次结构反对可变的数。 class Complex(Number): """Complex defines the operations that work on the builtin complex type. In short, those are: conversion to complex, bool(), .real, .imag, +, -, *, /, **, abs(), .conjugate(), ==, and !=. If it is given heterogenous arguments, and doesn't have special knowledge about them, it should fall back to the builtin complex type as described below. """ @abstractmethod def __complex__(self): """Return a builtin complex instance.""" def __bool__(self): """True if self != 0.""" return self != 0 @abstractproperty def real(self): """Retrieve the real component of this number. This should subclass Real. """ raise NotImplementedError @abstractproperty def imag(self): """Retrieve the real component of this number. This should subclass Real. """ raise NotImplementedError @abstractmethod def __add__(self, other): raise NotImplementedError @abstractmethod def __radd__(self, other): raise NotImplementedError @abstractmethod def __neg__(self): raise NotImplementedError def __pos__(self): """Coerces self to whatever class defines the method.""" raise NotImplementedError def __sub__(self, other): return self + -other def __rsub__(self, other): return -self + other @abstractmethod def __mul__(self, other): raise NotImplementedError @abstractmethod def __rmul__(self, other): raise NotImplementedError @abstractmethod def __div__(self, other): """a/b; should promote to float or complex when necessary.""" raise NotImplementedError @abstractmethod def __rdiv__(self, other): raise NotImplementedError @abstractmethod def __pow__(self, exponent): """a**b; should promote to float or complex when necessary.""" raise NotImplementedError @abstractmethod def __rpow__(self, base): raise NotImplementedError @abstractmethod def __abs__(self): """Returns the Real distance from 0.""" raise NotImplementedError @abstractmethod def conjugate(self): """(x+y*i).conjugate() returns (x-y*i).""" raise NotImplementedError @abstractmethod def __eq__(self, other): raise NotImplementedError # __ne__ is inherited from object and negates whatever __eq__ does.Real形象基类示意在实数轴上的值，并且反对内置的float的操作。实数（Real number）是齐全有序的，除了 NaN（本 PEP 基本上不思考它）。 ...

咱们在利用Python进行数据可视化时，有着大量的高质量库能够用，比方：Matplotlib、seaborn、Plotly、Bokeh、ggplot等等。但图表好不好看，配色占一半。如果没有良好的审美观，很容易做进去的货色辣眼睛…… 所以想做好数据可视化，就要有适合的配色计划。除了能够借鉴参考配色网站的案例，也能够本人自定义一套配色计划。 如何去自定义呢？ 我倒是有一个想法，配色的美感须要造就，但在一开始能够在优良的作品上寻找灵感，比方经典电影、海报、风景图、Logo等等，这些都是绝佳的参考。 自然风景的色彩往往令人惊艳，咱们无妨以风景图为例。下图是一副海上夕阳图，通过一番操作就提取到了一套配色计划（见图右）。 那么，咱们用Python能不能做到呢？ 答案当然是能够，毕竟Python除了不能生孩子，什么都能做！ 提取图片中的配色在Python中对图片进行操作，最罕用的两个模块就是PIL和opencv了。所以一开始我的计划是，用Python库关上图片，而后遍历像素色彩，最初依照色调比例进行排序，即可失去该图片的配色计划。 后果做到一半，我发现自己疏忽了一件事。大家都晓得，Python 是一门优雅的语言，简洁的语法，弱小的性能。同时它还有领有极其丰富的第三方库，这些库简直都能够在github 或者 pypi上找到源码。 于是我搜了一下，的确有相干的库能够提取图片中的配色，那咱们就不必反复造轮子了。 这个模块就是——Haishoku，能够用于从图像中获取主色调和次要配色计划。 其GitHub网址为：https://github.com/LanceGin/h... 具体用法，还是先装置 pip install haishoku将前文提到的海上夕阳图，保留到本地并命名为test.png。 from haishoku.haishoku import Haishokuimage = 'test.png'haishoku = Haishoku.loadHaishoku(image)导入模块，运行代码会返回一个Haishoku实例，你能够通过实例属性haishoku.dominant 和 haishoku.palette，从而间接获取到对应的主色调和配色计划。 主色调首先，要怎么获取图片的主色调呢？ print(haishoku.dominant)这返回了一个构造为 (R, G, B) 的元组，就是该图片的主色调。 运行上面这行代码 Haishoku.showDominant(image)则会关上一个临时文件，用来预览主色调的色彩。 主色调（最多的色彩） 配色计划#获取配色计划pprint.pprint(haishoku.palette)返回一个构造为：[(R, G, B), (R, G, B), …] 最大长度为8的数组。 这里应用了pprint模块，对于这种多层嵌套的元组，正好能够好看地打印进去。 运行上面这行代码 Haishoku.showPalette(image)则会关上一个临时文件，用来预览图片配色计划。（不会保留在本地） 配色计划 就这样，只需几行代码就提取到图片中的配色计划，是不是很简略。 另外，Haishoku库从v1.1.4版本后，反对从 url 中间接加载图像。 imagepath = 'https://img-blog.csdnimg.cn/20190222215216318.png'    haishoku = Haishoku.loadHaishoku(imagepath)配色计划与可视化通过后面的操作，咱们就提取到了适合的配色，那么就实战一下吧。 经典电影、海报、风景图、Logo都是绝佳的参考对象。 所以这次，我抉择了Google的Logo，并提取到它的配色计划。 imagepath = 'google.png'haishoku = Haishoku.loadHaishoku(imagepath)pprint.pprint(haishoku.palette)Haishoku.showPalette(imagepath) 那么，这套配色计划利用到了数据可视化中，会是怎么样呢？？ 这次用方才失去的Google配色，Python绘制一个环形图试试看 感觉还不错，这套配色计划我要珍藏起来。 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

最近有同学在后盾问，什么状况下应用静态方法，什么状况下应用类办法 明天咱们就来捋一下这两个办法的利用场景 首先，咱们来定义一个一般的类，外面都是一般的办法，一般办法又叫实例办法 class People:    def __init__(self, name, age):        self.name = name        self.age = age    def introduce_myself(self):        print(f'大家好，我叫: {self.name}')    def add_two_string_num(self, a, b):        a_int = int(a)        b_int = int(b)        return a_int + b_int    def calc_age_after_n_year(self, n):        age = self.add_two_string_num(self.age, n)        print(f'{n}年当前，我{age}岁')这个类运行起来的成果如下图所示： 大家留神在这个类外面的办法add_two_string_num，它承受两个参数，并将他们转换为int类型，而后相加并返回后果。这个过程非常简单，然而，它跟People这个类有什么间接关系吗？ 其实这个办法跟这个类没有什么间接关系，咱们甚至把它改成函数都能够： def add_two_string_num(a, b):    a_int = int(a)    b_int = int(b)    return a_int + b_intclass People:    def __init__(self, name, age):        self.name = name        self.age = age    def introduce_myself(self):        print(f'大家好，我叫: {self.name}')    def calc_age_after_n_year(self, n):        age = add_two_string_num(self.age, n)        print(f'{n}年当前，我{age}岁')        kingname = People('kingname', 20)kingname.introduce_myself()kingname.calc_age_after_n_year(10)运行后果跟之前齐全一样： 咱们能够说，add_two_string_num函数就是一个工具函数。工具函数接管参数，输入后果，齐全不关怀谁在调用他，也不关怀在哪里调用他。 但当初有一个比拟难堪的事件，这个函数，只有 People在调用，其它中央都没有调用。独自把它放到其它中央又显得多余，弄成实例办法又节约了self参数，这个时候，咱们就能够用静态方法： class People:    def __init__(self, name, age):        self.name = name        self.age = age    def introduce_myself(self):        print(f'大家好，我叫: {self.name}')    @staticmethod    def add_two_string_num(a, b):        a_int = int(a)        b_int = int(b)        return a_int + b_int    def calc_age_after_n_year(self, n):        age = People.add_two_string_num(self.age, n)        print(f'{n}年当前，我{age}岁')kingname = People('kingname', 20)kingname.introduce_myself()kingname.calc_age_after_n_year(10)一句话总结：静态方法就是某个类专用的工具函数。说完了静态方法，咱们再说说类办法。什么状况下应该应用类办法呢？答复这个问题前，我先反诘你一个问题，怎么把People类初始化成一个实例？ 你说这还不简略吗，一行代码就行了啊： xxx = People('xxx', 10)留神，这里你在初始化这个类的时候，你是一个一个参数传入进去的。如果你用过顺丰寄送快递，你就会发现，填写收件人的时候，有两种形式，一种形式就像下面这样，一个一个参数填进去。另一种形式，它给你一个输入框，你把一段蕴含姓名，地址，手机号的文字粘贴进去，它主动解析。 那么，如果我当初给你一个字符串：我的名字：青南，我的年龄：20，把它提取进去。你怎么基于这个字符串生成People类的实例？ 这个时候，你可能会这样写： import recontent = '我的名字：青南，我的年龄：20，把它提取进去'name = re.search('名字：(.*?)，', content).group(1)age = re.search('年龄：(\d+)', content).group(1)kingname = People(name, age)这样做的确能够，但我能不能让People这个类自动识别呢？其实是能够的，有两种办法，一种办法是在__init__外面多加几个参数，而后在初始化的时候，从这几个参数外面解析，这个办法大家都晓得，我就不多讲了。咱们来讲讲第二个办法，就是应用类办法。 咱们只须要再定义一个类办法： import reclass People:    def __init__(self, name, age):        self.name = name        self.age = age    def introduce_myself(self):        print(f'大家好，我叫: {self.name}')    @staticmethod    def add_two_string_num(a, b):        a_int = int(a)        b_int = int(b)        return a_int + b_int    @classmethod    def from_chinese_string(cls, sentence):        name = re.search('名字：(.*?)，', content).group(1)        age = re.search('年龄：(\d+)', content).group(1)        return cls(name, age)    def calc_age_after_n_year(self, n):        age = People.add_two_string_num(self.age, n)        print(f'{n}年当前，我{age}岁')        content = '我的名字：青南，我的年龄：20，把它提取进去'kingname = People.from_chinese_string(content)kingname.introduce_myself()kingname.calc_age_after_n_year(10)运行成果如下图所示： 类办法应用装璜器@classmethod来装璜，并且它的第一个参数是隐式参数cls。这个参数其实就是People这个类自身。这个隐式参数在咱们调用类办法的时候，是不须要传入的。在这个类办法外面，相当于应用People初始化了一个实例，而后把这个实例返回了进来。 这样做有什么益处呢？益处就在于咱们齐全不须要批改__init__，那么，也就不须要批改代码外面其它调用了People类的中央。例如当初我又想减少从英文句子外面提取名字和年龄的性能，那么只须要再增加一个类办法就能够了： import reclass People:    def __init__(self, name, age):        self.name = name        self.age = age    def introduce_myself(self):        print(f'大家好，我叫: {self.name}')    @staticmethod    def add_two_string_num(a, b):        a_int = int(a)        b_int = int(b)        return a_int + b_int    @classmethod    def from_chinese_string(cls, sentence):        name = re.search('名字：(.*?)，', content).group(1)        age = re.search('年龄：(\d+)', content).group(1)        return cls(name, age)    @classmethod    def from_english_string(cls, sentence):        name = re.search('name: (.*?),', content).group(1)        age = re.search('age: (\d+)', content).group(1)        return cls(name, age)    def calc_age_after_n_year(self, n):        age = People.add_two_string_num(self.age, n)        print(f'{n}年当前，我{age}岁')        content = 'my name: kinganme, my age: 15 please extract them'kingname = People.from_english_string(content)kingname.introduce_myself()kingname.calc_age_after_n_year(10)运行成果如下图所示： 一句话总结：当你想应用工厂模式，依据不同的参数生成同一个类的不同对象的时候，就能够应用类办法。其实如果大家应用过Python自带的datetime模块，你就会发现类办法无处不在： import datetimenow = datetime.datetime.now()dt = datetime.datetime.fromtimestamp(1633691412)dt2 = datetime.datetime.fromisoformat('2021-10-08 19:10:05')这段代码外面的.now()、.fromtimestamp()和 .fromisoformat()，都是类办法。他们最终返回的都是datetime.datetime对象，区别在于他们是依据不同类型的输出参数生成的。 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

本篇文章，咱们来聊聊如何依据「 行业板块 」辅助咱们进行价值投资  1. 行业板块行业板块与概念股在定义上还是有很大区别的 一般来说，概念板块的危险更大，基于某个音讯被短期炒作，很不稳固，因而危险更大 行业板块是按股票行业进行分类，往往重视于长期，稳定性更高 在理论投资上，短期能够依据按「 市场热点 」从概念股进行选股投资，中长期还是倡议按「 行业板块 」选股进行投资  2. 爬取相干板块及个股列表指标对象： aHR0cDovL3N1bW1hcnkuanJqLmNvbS5jbi9oeWJrLw== 2-1  板块列表 首先，咱们应用 「 Toggle JavaScript 」插件发现页面中的行业板块数据来源于上面的申请后果 http://**/?q=cn|bk|17&n=hqa&c=l&o=pl,d&p=1020&_dc=1650680429759 其中，参数为 p 和 _dc 为可变参数，p 代表页码数（从 1 开始），_dc 代表 13 位的工夫戳，其余查问参数都是固定内容 而后，咱们编写代码获取响应数据，应用正则表达式匹配出行业列表的数据 ...self.ps_url = 'http://**/?q=cn|bk|17&n=hqa&c=l&o=pl,d&p={}050&_dc={}'....    def __get_timestramp(self):        """        获取13位的工夫戳        :return:        """        return int(round(time.time() * 1000))...    def get_plates_list(self, plate_keyword):        """        获取所有板块        :return:        """        plates = []        index = 0        while True:            url = self.ps_url.format(index + 1, self.__get_timestramp())            # 解析数据            resp = self.session.get(url, headers=self.headers).text            match = re.compile(r'HqData:(.*?)};', re.S)            result = json.loads(re.findall(match, resp)[0].strip().replace("\n", ""))            if not result:                break            # 依据关键字，过滤无效板块            temp_plate_list = [item for item in result if plate_keyword in item[2]]            index += 1            for item in temp_plate_list:                print(item)                plates.append({                    "name": item[2],                    "plate_path": item[1],                    "up_or_down": str(item[10]) + "%",                    "top_stock": item[-6]                })        return plates...最初，依据关键字对板块进行一次筛选，通过板块名、板块门路 PATH、板块涨跌幅、最大奉献股票名称从新组装成一个列表 留神：通过剖析页面发现，依据板块门路 PATH 能够组装成行业板块个股列表页面 URL 比方，行业板块 PATH 为 400128925，那么行业板块对应个股列表的页面 URL 为 http://summary.**/hybk/400128925.shtml 2-2  行业个股列表 爬取行业个股列表和上一步数据展现逻辑一样，个股列表数据同样来源于上面申请的后果 http://**/?q=cn|s|bk{}&c=m&n=hqa&o=pl,d&p={}020&_dc={} 其中，bk 前面对应行业板块 PATH，p 代表页码数，_dc 代表 13 位的工夫戳 ...# 个股self.stock_url = 'http://**/?q=cn|s|bk{}&c=m&n=hqa&o=pl,d&p={}020&_dc={}'....    def get_stock_list(self, plate_path):        """        获取某一个板块下所有的个股信息        蕴含：股票名称、最新价格、涨跌幅、市盈率        :param plate_info:        :return:        """        index = 0        stocks = []        while True:            url = self.stock_url.format(plate_path, index + 1, self.__get_timestramp())            resp = self.session.get(url, headers=self.headers).text            match = re.compile(r'HqData:(.*?)};', re.S)            result = json.loads(re.findall(match, resp)[0].strip().replace("\n", ""))            if not result:                break            index += 1            for item in result:                if item[-1] < 0:                    continue                stocks.append({                    "stock_name": item[2],                    "pe": item[-1],                    "price": item[8],                    "up_or_down": str(item[12]) + "%"                })        # 按pe降序排列        stocks.sort(key=lambda x: x["pe"])        return stocks通过正则表达式对响应后果进行匹配后，获取个股的名称、PE 市盈率、价格、涨跌幅 4 个要害数据 最初，对个股列表按 PE 进行升序排列后间接返回  3. 服务化当然，咱们能够将这部分逻辑服务化供前端应用，以此晋升用户的体验性 比方，应用 FastAPI 能够疾速创立两个服务：依据关键字获取行业板块列表、依据板块门路获取个股列表 from pydantic import BaseModel# 板块class Plate(BaseModel):    content: str  # 关键字# 板块下的个股class PlateStock(BaseModel):    plate_path: str  # 板块门路#===========================================================...# 获取板块列表@app.post("/xag/plate_list")async def get_plate_list(plate: Plate):    pstock = PStock()    try:        result = pstock.get_plates_list(plate.content)        return success(data=result, message="查问胜利！")    except Exception as e:        return fail()    finally:        pstock.teardown()# 获取某一个板块下的所有股票列表@app.post("/xag/plate_stock_list")async def get_plate_list(plateStock: PlateStock):    pstock = PStock()    try:        result = pstock.get_stock_list(plateStock.plate_path)        return success(data=result, message="查问胜利！")    except Exception as e:        return fail()    finally:        pstock.teardown()...前端以 Uniapp 为例，应用 uni-table 组件展现行业板块列表及个股列表 局部代码如下： //个股列表 platestock.vue...<view class="box">                <uni-forms ref="baseForm" :modelValue="baseFormData" :rules="rules">                    <uni-forms-item label="关键字" required name="content">                        <uni-easyinput v-model="baseFormData.content" placeholder="板块关键字" />                    </uni-forms-item>                </uni-forms>                <button type="primary" @click="submit('baseForm')">提交</button>                <!-- 后果区域 -->                <view class="result" v-show="result.length>0">                    <uni-table ref="table" border stripe emptyText="暂无数据">                        <uni-tr class="uni-item">                            <uni-th align="center" class="uni-th" width="100%">板块</uni-th>                            <uni-th align="center" class="uni-th" width="100%">涨跌幅</uni-th>                            <uni-th align="center" class="uni-th" width="100%">强势股</uni-th>                        </uni-tr>                        <uni-tr class="uni-item" v-for="(item, index) in result" :key="index" @row-click="rowclick(item)">                            <uni-td class="uni-th" align="center">{{ item.name }}</uni-td>                            <uni-td align="center" class="uni-th">{{ item.up_or_down }}</uni-td>                            <uni-td align="center" class="uni-th">{{ item.top_stock }}</uni-td>                        </uni-tr>                    </uni-table>                </view>            </view>...methods: {            //表单提交数据            submit(ref) {                this.$refs[ref].validate().then(res => {                    this.$http('xag/plate_list', this.baseFormData, {                        hideLoading: false,                        hideMsg: false,                        method: 'POST'                    }).then(res => {                        console.log("内容：", res.data)                        if (res.data && res.data.length > 0) {                            this.$tip.success("查问胜利！")                            this.result = res.data                        } else {                            this.$tip.success("查问后果为空,请换一个关键字查问！")                        }                    }).catch(err => {                        console.log("产生异样，异样信息：", err)                    })                }).catch(err => {                    console.log('err', err);                })            }...最初部署完我的项目后，在前端页面就能依据板块名抉择适合的个股进行投资了  4. 总结一下因为行业板块更实用于中长期投资，咱们只须要依据某一个关键字筛选出一个板块，而后在板块下的个股列表中能够十分直观地看出市盈率较低的个股进行投资即可 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

最近打算更新反爬系列相干的内容，第一篇就从最简略的「 图片假装 」开始吧 图片假装是在网页元素中，将文字、图片混合在一起进行展现，以此限度爬虫程序间接获取网页内容 指标对象： aHR0cHM6Ly93d3cuZ3hyYy5jb20vam9iRGV0YWlsL2Q2NmExNjQxNzc2MjRlNzA4MzU5NWIzMjI1ZWJjMTBi 1 - 剖析关上页面，剖析页面发现网页源码中的电话号码默认是暗藏爱护的 并且要查看电话号码，必须先通过账号进行登录操作 实现登录后，点击页面上的查看按钮会调用一个接口，随后电话号码就齐全展现进去了 https://**/getentcontacts/b2147f6a-6ec7-403e-a836-62978992841b PS：该 URL 地址中 b2147f6a-6ec7-403e-a836-62978992841b 在网页源码中能够获取，与企业一一对应 通过下图，咱们发现下面接口响应值中的「 tel 」字段能够拼接成一张图片，该图片中的内容与电话号码统一 因而，咱们只须要下载这张图片，利用 OCR 进行辨认即能够 2 - 实现因为该网站上的文字图片背景很洁净，因而不须要额定的训练来晋升文字识别率 首先，咱们调用接口获取电话号码一一对应的 tel 字段 import requestsheaders = {    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36',    'Cookie': '***'}# 获取手机号码对应的tel字段id（一一对应）def get_tel_id():    # b2147f6a-6ec7-403e-a836-62978992841b对应企业，也是一一对应关系（网页源码）    url = "https://**/getentcontacts/b2147f6a-6ec7-403e-a836-62978992841b"    payload = {}    resp = requests.request("GET", url, headers=headers, data=payload).json()    tel_id = resp.get("tel")    return tel_id而后，利用下面的 tel 字段组成图片 URL 地址 最初，就能够对图片进行文字辨认了 这里介绍 2 种形式： 百度 OCRpytesseract2-1  百度 OCR 首先，装置依赖包 # 装置依赖包pip3 install baidu-aip而后，创立一个用于文字辨认的利用，获取利用的 APP_ID、API_KEY、SECRET_KEY 数据\ 最初，参考官网文档调用上面的办法辨认图片，获取手机号码数据 官网文档： https://cloud.baidu.com/doc/O... from aip import AipOcrdef get_phone(tel_id):    """    百度OCR辨认图片，获取文字内容    :param tel_id:    :return:    """    url = f'https://www.**.com/home/Phone/{tel_id}'    APP_ID = '262**'    API_KEY = '1btP8uUSzfDbji**'    SECRET_KEY = 'NGm6NgAM5ajHcksKs0**'    client = AipOcr(APP_ID, API_KEY, SECRET_KEY)    result = client.basicGeneralUrl(url)    # {'words_result': [{'words': '0771-672**'}], 'words_result_num': 1, 'log_id': 1527210***}    print('辨认到的手机号码为：', result)2-2 pytesseract 同样，咱们须要先装置文字辨认、图片解决的依赖包 # 装置依赖包pip3 install pillowpip3 install pytesseract而后，依据图片 URL 地址获取图片字节流，最初利用 pytesseract 辨认图片中文字即可 import ioimport pytesseractimport requestsfrom PIL import Imageif __name__ == '__main__':    # 获取手机号码的URL地址    image_url = f'https://www.**.com/home/Phone/{get_tel_id()}'    resp = requests.get(image_url, headers=headers)    # images.content: 获取图片的二进制字节流    # io.BytesIO(): 操作解决二进制数据    # Image.open(): 关上图片字节流，失去一个图片对象    images_c = Image.open(io.BytesIO(resp.content))    # 利用pytesseract辨认出图片中的字符串，即为手机号码    phone = pytesseract.image_to_string(images_c)    print(f'联系方式: {phone}')以上就是利用图片假装惯例的解决形式，咱们只须要找出图片的生成规定，而后利用 OCR 进行辨认成文本，最初组装在一起即可 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

在这个周末刚刚写进去的python桌面利用--网络聊天室，次要通过pyqt5作为桌面利用框架，socket作为网络编程的框架，从而实现包含客户端和服务端的网络聊天室的GUI利用，心愿能够一起学习、一起提高！ 利用包含服务端server_ui.py、客户端client_ui.py两个python模块实现，并且在pyqt5的应用过程中都应用QThread多线程利用以及根本的UI页面布局。开始之前通过一个动态图来察看一下socket服务端、socket客户端通信的实现成果。 【浏览全文】 socket_ui.py 服务端1-1. 依赖援用 在socket服务端的实现过程中，除了pyqt5相干的UI界面的援用外，还包含time、threading、sys、socket等辅助模块来一起实现socket服务端的桌面应用程序。 from PyQt5.QtWidgets import *from PyQt5.QtCore import *from PyQt5.QtGui import *import sysfrom QCandyUi import CandyWindow# 导入 socket 通信模块import socket# 导入工夫治理模块import time# 导入多线程模块import threading1-2. 实现过程 在服务端的业务实现下面，咱们仍然是依照之前的GUI实现形式，采纳主线程用来实现页面布局，子线程QThread来实现业务逻辑的形式来进行实现的，socket的服务端通信业务都是在子线程ServerThread中编写的。上面是socket服务端桌面利用实现的全副代码块，copy到本人的ide中即可间接启动应用。 class ServerUI(QWidget): def __init__(self): super(ServerUI, self).__init__() self.init_ui() def init_ui(self): self.setWindowTitle('socket 服务端 公众号：[Python 集中营]') self.setWindowIcon(QIcon('hi.ico')) self.setFixedSize(500, 300) hbox = QHBoxLayout() hbox_v1 = QVBoxLayout() self.brower = QTextBrowser() self.brower.setFont(QFont('宋体', 8)) self.brower.setReadOnly(True) self.brower.setPlaceholderText('音讯展现区域...') self.brower.ensureCursorVisible() hbox_v1.addWidget(self.brower) hbox_v2 = QVBoxLayout() hbox_v2_f1 = QFormLayout() self.ip_label = QLabel() self.ip_label.setText('ip地址 ') self.ip_txt = QLineEdit() self.ip_txt.setPlaceholderText('0.0.0.0') self.port_label = QLabel() self.port_label.setText('端口 ') self.port_txt = QLineEdit() self.port_txt.setPlaceholderText('4444') self.lis_num_label = QLabel() self.lis_num_label.setText('最大监听个数 ') self.lis_num_txt = QLineEdit() self.lis_num_txt.setPlaceholderText('10') self.close_cli_label = QLabel() self.close_cli_label.setText('客户端敞开指令 ') self.close_cli_txt = QLineEdit() self.close_cli_txt.setPlaceholderText('exit，客户端发送相应指令则敞开') hbox_v2_f1.addRow(self.ip_label, self.ip_txt) hbox_v2_f1.addRow(self.port_label, self.port_txt) hbox_v2_f1.addRow(self.lis_num_label, self.lis_num_txt) hbox_v2_f1.addRow(self.close_cli_label, self.close_cli_txt) self.start_btn = QPushButton() self.start_btn.setText('开启服务端') self.start_btn.clicked.connect(self.start_btn_clk) hbox_v2.addLayout(hbox_v2_f1) hbox_v2.addWidget(self.start_btn) hbox.addLayout(hbox_v1) hbox.addLayout(hbox_v2) self.thread_ = ServerThread(self) self.thread_.message.connect(self.show_message) self.setLayout(hbox) def show_message(self, text): ''' 槽函数：向文本浏览器中写入内容 :param text: :return: ''' cursor = self.brower.textCursor() cursor.movePosition(QTextCursor.End) self.brower.append(text) self.brower.setTextCursor(cursor) self.brower.ensureCursorVisible() def start_btn_clk(self): self.thread_.start() self.start_btn.setEnabled(False)class ServerThread(QThread): message = pyqtSignal(str) def __init__(self, parent=None): super(ServerThread, self).__init__(parent) self.parent = parent self.working = True def __del__(self): self.working = False self.wait() def run(self): self.message.emit('筹备启动socket服务端...') # 创立服务端 socket socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 绑定服务地址、端口 address = (self.parent.ip_txt.text().strip(), int(self.parent.port_txt.text().strip())) socket_server.bind(address) # 设置监听最大期待数 socket_server.listen(int(self.parent.lis_num_txt.text().strip())) self.message.emit("服务曾经启动，正在期待客户端连贯...") while True: # 设置睡眠工夫 time.sleep(0.1) # 容许客户端连贯 client, info = socket_server.accept() self.client, self.info = client, info # 启用新线程调用音讯解决 thread = threading.Thread(target=self.catch_message) # 设置为守护线程 thread.setDaemon(True) # 开启线程执行 thread.start() def catch_message(self): self.client.send("欢送来到网络聊天室".encode('utf-8')) self.message.emit("客户端信息：" + str(self.info)) close_cli = self.parent.close_cli_txt.text().strip() while True: try: # 接管客户端音讯、接管最大长度为 1024，并进行 utf-8 解码 message = self.client.recv(1024).decode('utf-8') # 校验是否敞开客户端 if not message and close_cli == message: self.client.close() self.message.emit("以后客户端已敞开！") break self.message.emit("接管到音讯：" + message) # 将音讯进行 utf-8 编码后发给客户端 rcv = "服务端胜利接管音讯：" + message self.client.send(rcv.encode('utf-8')) except Exception as e: self.client.send("服务端解决音讯异样！".encode('utf-8')) breakif __name__ == '__main__': app = QApplication(sys.argv) w = CandyWindow.createWindow(ServerUI(), theme='blueGreen', title='socket 服务端 公众号：[Python 集中营]', ico_path='hi.ico') w.show() sys.exit(app.exec_())1-3. 实现成果 ...

PILcv2读取函数Image.open()cv2.imread()数据类型PILnumpy.ndarray色彩通道排列RGB\RGBABGR尺寸排列HWCHWC像素点范畴0~2550~255互相转换a=cv2.cvtColor(numpy.array(a),cv2.COLOR_RGB2BGR)a=Image.fromarray(cv2.cvtColor(a,cv2.COLOR_BGR2RGB))

明天的文章，咱们一起来聊聊多线程场景当中不可或缺的另外一个局部——锁。 如果你学过操作系统，那么对于锁应该不生疏。锁的含意是线程锁，能够用来指定某一个逻辑或者是资源同一时刻只能有一个线程拜访。这个很好了解，就如同是有一个房间被一把锁锁住了，只有拿到钥匙的人才能进入。每一个人从房间门口拿到钥匙进入房间，出房间的时候会把钥匙再放回到门口。这样下一个到门口的人就能够拿到钥匙了。这里的房间就是某一个资源或者是一段逻辑，而拿取钥匙的人其实指的是一个线程。 加锁的起因 咱们明确了锁的原理，不禁有了一个问题，咱们为什么须要锁呢，它在哪些场景当中会用到呢？ 其实它的应用场景十分广，咱们举一个非常简单的例子，就是淘宝买货色。咱们都晓得商家的库存都是无限的，卖掉一个少一个。如果说以后某个商品库存只剩下一个，但当下却有两个人同时购买。两个人同时购买也就是有两个申请同时发动购买申请，如果咱们不加锁的话，两个线程同时查问到商品的库存是1，大于0，进行购买逻辑之后，同时减一。因为两个线程同时执行，所以最初商品的库存会变成-1。 显然商品的库存不应该是一个正数，所以咱们须要防止这种状况产生。通过加锁能够完满解决这个问题。咱们规定一次只能有一个线程发动购买的申请，那么这样当一个线程将库存减到0的时候，第二个申请就无奈批改了，就保障了数据的准确性。 代码实现 那么在Python当中，咱们怎么样来实现这个锁呢？ 其实很简略，threading库当中曾经为咱们提供了线程的工具，咱们间接拿过去用就能够了。咱们通过应用threading当中的Lock对象， 能够很轻易的实现办法加锁的性能。 import threadingclass PurchaseRequest: ''' 初始化库存与锁 ''' def __init__(self, initial_value = 0): self._value = initial_value self._lock = threading.Lock() def incr(self,delta=1): ''' 加库存 ''' self._lock.acquire() self._value += delta self._lock.release() def decr(self,delta=1): ''' 减库存 ''' self._lock.acquire() self._value -= delta self._lock.release()咱们从代码当中就能够很轻易的看出Lock这个对象的应用办法，咱们在进入加锁区（资源抢占区）之前，咱们须要先应用lock.acquire()办法获取锁。Lock对象能够保障同一时刻只能有一个线程获取锁，只有获取了锁之后才会持续往下执行。当咱们执行实现之后，咱们须要把锁“放回门口”，所以须要再调用一下release办法，示意锁的开释。 这里有一个小问题是很多程序员在编程的时候总是会遗记release，导致不必要的bug，而且这种分布式场景当中的bug很难通过测试发现。因为测试的时候往往很难测试并发场景，code review的时候也很容易疏忽，因而一旦泄露了还是挺难发现的。 为了解决这个问题，Lock还提供了一种改良的用法，就是应用with语句。with语句咱们之前在应用文件的时候用到过，应用with能够替咱们实现try catch以及资源回收等工作，咱们只管用就完事了。这里也是一样，应用with之后咱们就能够不必管锁的申请和开释了，间接写代码就行，所以下面的代码能够改写成这样： import threadingclass PurchaseRequest: ''' 初始化库存与锁 ''' def __init__(self, initial_value = 0): self._value = initial_value self._lock = threading.Lock() def incr(self,delta=1): ''' 加库存 ''' with self._lock: self._value += delta def decr(self,delta=1): ''' 减库存 ''' with self._lock: self._value -= delta这样看起来是不是清新很多？ ...

void 是编程语言中最常见的关键字之一，从字面上了解，它是“空的、空集、空白”的意思，最罕用于示意函数的一种返回值类型。 维基百科上有一个定义： The void type, in several programming languages derived from C and Algol68, is the type for the result of a function that returns normally, but does not provide a result value to its caller.在 C、Algol68 及它们所派生的几种编程语言中，void 类型是函数失常返回的一种类型，然而不会给调用者返回一个值。简略来说，void 是一种类型（type），然而没有具体的值（value）。 这到底是什么意思呢？ 以 Python 的几种常见类型为例，咱们能够从比照中看出法则：int 是一种示意整数的类型，它有有限个可能的整数值；bool 是一种布尔类型，它有两个可能的值（True 和 False）；NoneType 是一种示意 None 的类型，它只有一个值（None）。 至于 void，它是一种更为形象的非凡类型，然而不蕴含任何值。 介绍完概念上的含意，咱们就能够进入正题了。题目中的问题能够进一步分解成两个： 其它语言为什么要应用 void 关键字？Python 为什么不设计出 void 关键字？对于第一个问题，咱们以 C/C++ 为例，先看看 void 的两种应用场景 当 void 用在函数的参数地位时，它示意该函数不须要传参。 最后 C 语言的f() 示意参数数量不确定，为了另外表白“不须要参数”的语义，所以引入f(void) 作为限定。起初的语言（包含 Python）根本不在参数中应用 void，而是间接用f() 示意不需传参。C++ 为了兼容 C，所以才同时反对这两种语法。 ...

对于我来说Python的利用场景次要是机器学习、深度学习相干，对于其余的场景涉猎不多。因而本文的目标并不是列举出一系列小我的项目给你们练手，而是心愿疏导大家思考这个问题，从而找到适宜本人的练习我的项目。 Python的误区 不晓得各位初学者如何对待Python这一门语言，又是如何对待程序员的技能，依据我的了解， 这当中可能存在一些误会。其实不管哪一门语言的利用场景可能都不只是一个方向，往往是多个方向，尤其是Python这种比拟成熟并且广受欢迎的语言，它在许多畛域都有很高的建树，这就导致了Python能够做的事件十分多，相应的要学习的货色也就十分多。 兴许在老手看来一个比拟厉害的Python使用者（比方我），应该是所有技术通杀的，对于Python的方方面面都十分理解。然而很遗憾，这是十分艰难或者说简直是不可能的。艰难的起因也是很简略的，因为人的精力是无限的，想要在一个畛域做到优良就曾经十分不容易，须要学习大量技术和常识了，更何况把握所有方向。所以大家对于这样一个问题，应该有一个清晰的答案，对于Python这样一门语言，你们学习它的目标到底是什么？ 兴许你有很多个答案，然而很遗憾，对于你将来职业倒退来说，你可能只能抉择其中一个。 方向抉择 如果你玩过暗黑破坏神、魔兽世界或者是相似的RPG游戏的话，那么你对于抉择职业这个问题应该十分理解。在咱们刚进入游戏或者是进入游戏不久，咱们就须要面临一次职业抉择，职业一旦抉择往往不可更改，你就须要在这个职业始终玩上来，如果想要换职业只有从头开始，从新玩一个新的号。 退职场当中和游戏是十分相似的，咱们最终也须要抉择咱们的职业，并且咱们只能抉择一个岗位，轻易也是不能更改的。如果要更改，须要从头开始，之前累积的教训会全副清零。因为不同岗位对于能力的要求是齐全不同的，所以对于初学者而言，其实也会面临这么一个抉择，只不过这个抉择是隐形的，当你抉择岗位进行投递简历的时候，这个抉择就耳濡目染的产生了。 Python罕用的根底语法并不多，在咱们之前的文章当中简直涵盖了大半。当咱们实现了这部分学习之后，单单学习语法曾经没有前途了。再接下来进阶就必须要学习一些利用上的内容，也就是要面临一个技术选型了。 对于Python而言，个别常见的方向有这么几种：web开发、机器学习、网络爬虫、运维、游戏开发。 上面我简略介绍一下这几个方向，大家能够对照一下本人的趣味，抉择一个本人感兴趣或者是比拟适宜的。 web开发 Web开发应该是当下最广泛的程序员的工作岗位了，Python在web上的利用次要是web的后端开发，也就是负责服务器逻辑解决这个局部。 咱们都晓得在后端这个畛域目前国内最吃香的语言应该是Java，简直大半的公司都是应用Java作为后端语言。Java之后的其余几门语言我也难分伯仲，简略列举一下有新兴的Go，有古老的PHP，当然还有Python，还有曾经简直绝迹的C++和C#。Python在这个畛域当中应该只能算是不算特地小众，总体来说还是偏小众的。 小众的起因和Python自身的个性无关，因为Python是解释型语言，而不是编译型语言。所以和Java、Go这种编译型语言相比，在性能上人造就要劣势。并且因为Python全局锁的限度，导致了Python多线程在计算密集型的并发场景当中体现十分蹩脚，所以很少有大公司会应用Python作为后端主力语言。据我理解国内出名一些的应该只有豆瓣、知乎，国外的有YouTube，但据说有些曾经迁徙到其余语言了，有的曾经有相应的迁徙打算了。 Python在后端的次要劣势在于麻利，也就是开发效率比拟高。Python的Django、Falsk等框架还是十分欠缺以及好用的，咱们能够很快地从零开始搭建出一个像样的后端来，并且迭代的速度也很快。所以对于一些须要小步快跑对于性能要求不高的小公司，可能会抉择Python，也就是大公司简直不会抉择Python作为Web后端的开发语言，技术栈也必然齐全不同。 如果你须要抉择这个方向，那么你除了要学习Python后端开发的相干常识，比方Django、Flask等框架之外，对于计算机网络以及前端也须要肯定的理解，这些也是后端工程师的必修课。 总体来说，Python后端这个倒退方向绝对比拟平坦，前期发力的难度比拟大，天花板比拟低。学习难度和Java后端相比可能要略微简略一些，待业压力应该也还好，相干的岗位尽管不太多但也不会太少。 如果要抉择这个畛域的话，能够抉择一些比拟惯例的我的项目作为入门的我的项目。比方搭建一个集体博客，或者是XX管理系统，等这些纯熟了之后就能够学习更多其余的工具库了，比方数据库ORM框架、kafka、redis等这些罕用的中间件。把这些内容再联合到web当中，创立出新的我的项目。等这一块也差不多了，接下来就能够钻研钻研架构设计、设计模式等等进阶的内容了。 机器学习 这个畛域我绝对比拟理解一些，对于机器学习来说，Python目前是妥妥的主力语言。早年还能看到一些应用R来做机器学习的工程师，目前曾经简直看不到了，简直是清一色的Python。然而诚实说机器学习当中Python只是起到胶水语言的作用，简直所有外围的实现逻辑都不是Python撑持的。 在机器学习当中对于Python原生的内容要求十分一般，只须要会根本的语法，理解迭代器、生成器简直就足够了。因为大部分内容都是通过框架或者是工具来实现的，Python只是把这些逻辑粘合到一起而已。这个方向的从业者的技能点在Python上的非常少，大部分都在机器学习的相干实践、一些库工具的应用、深度学习框架的应用、数据处理方面的教训。 并且机器学习自身就是一个比拟大的畛域，它也有很多方面的利用。比方搜寻、广告、举荐这些传统的利用场景，以及CV（计算机视觉）、NLP（自然语言解决）、风控等等比拟新一些的畛域。所以抉择了机器学习这个大方向，并且实现了基础知识的学习之后，还是要再面临一次抉择的，因为还须要抉择进一步细分的小方向。依据我集体的教训来说它们的发展前景是举荐、搜寻、广告 > NLP > CV > 风控，这只是我集体的判断，仅供大家参考。 机器学习这个方向整体来说前景是十分不错的，目前简直大中小型的公司都有机器学习或者是深度学习的岗位。尽管岗位多，然而竞争并不低，因为想要涌进来的人切实是太多了。尤其是这两年AI炽热，大量的人想要挤进这个行业中来，所以招聘门槛还是不低的。 如果你想要抉择这个方向的话，只须要根本的Python语法即可，然而须要对机器学习这个畛域有着比拟深刻的学习。比方机器学习的外围概念、罕用的一些模型、数据处理的一些办法、模型成果的评估规范等等。等对机器学习的了解足够了，就能够找kaggle、天池大数据等一些较量来实战一下。 爬虫 爬虫这个方向大家也不生疏，很多人应该看过一些相干的负面新闻，比方窃取用户隐衷或者是窃取了某某公司的数据等等。实际上爬虫的实质是利用程序模仿人工对网页进行拜访，从而将网页当中相干有价值的信息存储下来。 Python因为语法简略，并且网络相干的工具库十分欠缺，而且不须要通过编译就能够间接运行。更重要的一点是Python的全局锁在网络申请这种IO密集型的场景当中十分适合，并不会影响效率。而且Python能够很不便的整合其余语言的性能以及个性，使得Python做爬虫十分适合，以至于市面上大部分的爬虫工程师都是以Python为语言开发的。并且当初也衍生了许多分布式爬虫的框架和工具。 因为大家都应用爬虫，而一些大公司不违心本人的相干信息被竞争对手获取了去。举个例子，假如某东把淘宝所有的商品信息都爬取了下来，而后针对性的提价来强行吸引用户，那么显然对于淘宝是一个打击。为了避免相似以及其余不利于公司的状况呈现，这些大公司都会设置一些反爬虫的机制。比方在申请来长期会判断是否是机器人，或者是会限度一个ip最多拜访的商品数量等等。 既然有反爬机制，那么天然也有破除反爬机制的机制。所以公司里真正爬虫工程师往往的日常工作就是和一些大公司的反爬工程师斗智斗勇。你设置了这个反爬机制，我就想一个方法来破除。今天你发现了我的办法做了修补，我再持续想方法……并且在编写爬虫之前，须要做大量网页的剖析，找到网页或者是利用中数据的源头api。有些公司会把api暗藏起来，或者是须要肯定的校验能力拜访，那么就须要设置一些办法针对性的破除之后能力应用爬虫。 有些人不喜爱这种斗智斗勇很多，开发工夫很少的工作，而有些人就乐此不疲，大家能够对照一下本身的状况做一个抉择。如果想要抉择这个方向的话，能够从一些公开的没有设置反爬机制的数据开始，学习一些目前比拟先进的爬虫框架，之后再一步步晋升难度，去试着破除大公司的反爬机制，成为一个优良的爬虫工程师。 运维和游戏开发 诚实讲这两个畛域我的理解切实是不多，所以硬着头皮简略说说，程度无限，如果有谬误还请大家海涵。 运维在咱们都晓得就是负责保护机房机器环境、我的项目公布上线等工作的，因为当初公司用到的机器的数量越来越多，整个公布以及保护的流程也就越来越麻烦。之前极其少的时候还能够人工一台一台搞定，当初机器多了还应用人工来干显然就不事实了。为了解决这个问题，所以当初先进的运维会应用Python编写脚本，来批量操作机器装置环境或者是公布我的项目等等。 说白了其实也是把Python当成是脚本语言这样的工具来应用，外围的能力其实还是偏在Linux命令、操作系统、分布式集群这一个局部。对于运维这个畛域，我个人感觉和机器学习差不多，Python只是纯工具，大家想要入门我的项目的话，可能还是要以运维相干的技能为主，应用Python来作为工具辅助。 游戏开发我稍稍理解一点，之前用Python做过一些简略的小游戏。Python当中的pygame十分好用，编写小游戏十分适合。并且Python也能够接入Unity，github里能搜到不少应用Python做进去的游戏。然而有没有游戏公司招聘Python程序员来进行游戏开发我就不分明了，毕竟不是做这个行业的，但至多大家做一些小游戏来自娱自乐必定还是没问题的。如果要练手的话能够思考做一个2048，doodle jump这些比较简单的小游戏。 总结如果只是寻找Python的新手入门我的项目，网上轻易搜寻一下进去的后果是十分多的。然而这并没有太多的意义，因为这些我的项目并不一定适宜每一个人。而在明确本人想要从事的方向之前，适合与不适合也无从谈起，所以心愿大家都能够先明确本人的方向，之后再找到对应的进阶路线则要容易得多。所以如果你之前只是想要学好Python这门语言，然而又没有思考过方向相干的话，我倡议你能够思考一下这方面的问题。 以上就是本次分享的所有内容，想要理解更多 python 常识欢送返回公众号：Python 编程学习圈 ，发送 “J” 即可收费获取，每日干货分享

对于 Python 中的pass语句，它仿佛很简略（只有 4 个字母），即便是没有任何编程教训的初学者也能很快地把握它的用法。 官网文档 的介绍非常简略 简略而言，pass 是一种空操作（null operation），解释器执行到它的时候，除了查看语法是否非法，什么也不做就间接跳过。 它跟 return、break、continue 和 yield 之类的非空操作相比，最大的区别是它不会改变程序的执行程序。它就像咱们写的正文，除了占用一行代码行，不会对所处的作用域产生任何影响。 然而，如果你有其它语言的根底，你兴许会好奇：为什么 Python 有这么独特的 pass 语句，而别的语言却没有？ Python 这么设计，到底是出于什么起因呢？ 是为了解决大部分编程语言都要面对的共性问题，还是因为它有本人的新发现，所以发明进去一个新的个性？ 换句话说：Python 为什么要有 pass 语句，它能解决什么问题（益处），如果没有它，会导致什么问题（害处）？ 接下来，本文将从两个维度开展剖析。 1、对人：作为空间占位符我把它看作是一种长篇累牍的正文形式，等于是说“这里先预留地位，回头再补上具体的代码实现”。 比方在多层的 if-elif-else 构造中，咱们能够先把判断条件写好，而后在对应的块中写上 pass，当前再缓缓欠缺。 比方上文中给出的例子，咱们能够先写好类/函数名及其入参，而后跳过（pass）主体代码，当前再缓缓填充。 pass 写起来简略，而且因为是关键字，IDE 会给出显眼的色彩辨别，所以就比咱们写上正文内容来得不便些。 pass 作为空间占位符，次要能够不便咱们构思部分的代码构造，有肯定的辅助揭示作用。 然而，若作为一种正文形式，它就显得太薄弱了，比不上写“# todo: xxxx”，后者也会被 IDE 用色彩突显，而且意思更明确。尽管写起来简略，但它也引入了一个看似多余的关键字 pass。 所以，从空间占位符的角度来看，pass 不是编程语言中必须的设计因素。 有了它，咱们能够表白出“此处有货色，但临时跳过”的语义，但如果没有它，则能够用正文内容来代替。 2、对机器：为了语法完整性对于前一条的用法，pass 呈现在代码中的地位在实践上是不受限的。 然而，咱们最常应用 pass 时，根本是在冒号的下一行，而且在该层缩进的代码块中，只有这一条语句。（参见前文的 3 个例子，为了不便，咱们仅以以空函数为例） 咱们能够构想下，如果不写它，会怎么？ 答案是会报缩进谬误：IndentationError: expected an indented block # 将函数体的 pass 去除，会报错def func():func()因为 Python 应用缩进来划分代码块，而冒号标识着要呈现新的缩进代码块，所以这个例子会报短少缩进代码块。 如果咱们用前文说的正文来代替，看看会怎么？ ...

DeLorean 是一个Python的第三方模块，基于 pytz 和 dateutil 开发，用于解决Python中日期工夫的格局转换。 因为工夫转换是一个足够奥妙的问题，DeLorean心愿为移位、操作和生成日期工夫提供一种更洁净、更省事的解决方案。比方，实例化字符串模式的工夫对象，Delorean只须要 parse 指定字符串，不须要申明其格局就能够进行转换。 至于 Delorean 这个模块名称的由来，Delorean 是电影《回到未来》里的那辆极为炫酷的鸥翼汽车，采纳这部电影里的十分具备代表性的汽车的名字作为库名，作者预计也是想表白应用这个库能让你在时空里任意漫游，没有掣肘。 这个模块最让我感到智能的是，它能自动识别字符串的工夫格局，转换为 Delorean 对象，而且这个 Delorean 对象和 Datetime 对象是相通的： from delorean import parseparse("2011/01/01 00:00:00 -0700")# Delorean(datetime=datetime.datetime(2011, 1, 1, 0, 0), timezone=pytz.FixedOffset(-420))parse("2018-05-06")# Delorean(datetime=datetime.datetime(2018, 6, 5, 0, 0), timezone='UTC')上面就来介绍一下它的根本应用办法。 1.筹备 请抉择以下任一种形式输出命令装置依赖： Windows 环境 关上 Cmd (开始-运行-CMD)。MacOS 环境 关上 Terminal (command+空格输出Terminal)。如果你用的是 VSCode编辑器 或 Pycharm，能够间接应用界面下方的Terminal。pip install Delorean2.Delorean 根底应用 轻松获取以后工夫： from delorean import Deloreand = Delorean()print(d)# Delorean(datetime=datetime.datetime(2021, 10, 6, 9, 5, 57, 611589), timezone='UTC')将datetime格局的工夫转化为Delorean： import datetimefrom delorean import Deloreand = Delorean()print(d)d = Delorean(datetime=datetime.datetime(2018, 5, 10, 8, 52, 23, 560811), timezone='UTC')# 这里默认的是UTC工夫print(d)# Delorean(datetime=datetime.datetime(2021, 10, 6, 9, 5, 57, 611589), timezone='UTC')# Delorean(datetime=datetime.datetime(2018, 5, 10, 8, 52, 23, 560811), timezone='UTC')转换为国内时区： ...

本机IP是10.30.6.24，前面配置过程当中须要根据本人IP信息配置批改 kafka默认应用127.0.0.1拜访 配置compose.yaml文件如下services: zookeeper: image: zookeeper container_name: demo-zookeeper ports: - "2181:2181" restart: always kafka: image: wurstmeister/kafka container_name: demo-kafka ports: - "9092:9092" ulimits: nofile: soft: 262144 hard: 262144 environment: DOCKER_API_VERSION: 1.41 KAFKA_ADVERTISED_LISTENERS: "PLAINTEXT://10.30.6.24:9092" KAFKA_LISTENERS: "PLAINTEXT://0.0.0.0:9092" KAFKA_BROKER_ID: 1 KAFKA_PORT: 9092 KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181 KAFKA_LOG_DIRS: /kafka/kafka-logs-backend depends_on: - zookeeper volumes: - /var/run/docker.sock:/var/run/docker.sock - kafka-data:/kafka command: /bin/sh -c "rm -f /kafka/kafka-logs-backend/meta.properties && start-kafka.sh"volumes: kafka-data: {}启动命令$ docker compose up -d配置参数解释ulimits 操作系统提供限度可应用资源量的形式linux零碎默认是1024个，具体执行命令ulimit -a查看因为音讯队列文件读写频繁，须要调大该配置，批改kafka的默认最大关上文件数量限度能够是硬限度或软限度，但软限度不能超过硬限度环境变量解释DOCKER_API_VERSION: docker version命令的API Version输入信息KAFKA_ADVERTISED_LISTENERS: 把kafka的地址端口注册给zookeeper,这个中央的数据目前是PLAINTEXT://10.30.6.24:9092，这个IP地址须要根据具体机器IP进行批改，指明客户端通过哪个 IP 能够拜访到以后节点，如果网卡IP有批改的话也须要批改这个中央的配置KAFKA_LISTENERS： 配置kafka的监听端口，指明 kafka 以后节点监听本机的哪个网卡，这个中央的IP地址能够填写为0.0.0.0示意监听所有网卡的信息 KAFKA_BROKER_ID: 一个 kafka节点 就是一个 broker，一个集群外面的broker id惟一KAFKA_PORT: 配置kafka凋谢端口KAFKA_ZOOKEEPER_CONNECT: 配置对应的zookeeper连贯信息，因为是在同一个docker compose当中，所以能够应用服务名称作为host连贯信息KAFKA_LOG_DIRS: 保留日志数据的目录，默认是/tmp/kafka-logs挂载卷解释- /var/run/docker.sock:/var/run/docker.sock: 把docker的sock挂在进去 ...

最近在搜查材料时，发现了一则10年前的新闻：二维码将成线上线下要害入口。从明天的挪动互联网来看，领取收款码/衰弱码等等与咱们非亲非故，二维码的确成为了咱们生存中不可或缺的一部分。 在学习Python解决二维码的过程中，咱们看到的大多是“用python生成酷炫二维码”、“用Python制作动图二维码”之类的文章。而对于应用Python批量辨认二维码的教程，并不多见。所以明天我会给大家分享两种批量辨认二维码的Python技巧！ pyzbar + PIL二维码又称二维条码，常见的二维码为QR Code，QR全称Quick Response，是一个挪动设施上超风行的一种编码方式。 咱们晓得，Python的第三方模块pyzbar不仅能够辨认一维条形码，也能够很不便地解决二维码的辨认。 不过pyzbar库须要搭配PIL或者opencv应用，次要是为了利用Image.open()或者cv2.imread()来读取图片文件。 在交互式环境中输出如下命令： from pyzbar.pyzbar import decodefrom PIL import ImagedecocdeQR = decode(Image.open("D:/test.jpg"))print(decocdeQR[0].data.decode('ascii'))输入： 这样就轻松实现了二维码的解析与辨认。 cv2另外，opencv模块其实自带二维码辨认性能。 注1：对于opencv模块，装置时须要输出pip install opencv-python，但在导入的时候采纳import cv2。 注2：应用opencv模块时，文件门路、图片名称都不要蕴含中文，否则会报错。 在交互式环境中输出如下命令： import cv2qrcode_filename = "D:/test.jpg"qrcode_image = cv2.imread(qrcode_filename)qrCodeDetector = cv2.QRCodeDetector()data, bbox, straight_qrcode = qrCodeDetector.detectAndDecode(qrcode_image)print(data)输入： 如上所示，咱们同样实现了二维码的解析与辨认。在上述代码中，第四行代码中qrCodeDetector.detectAndDecode(qrcode_image)有三个返回值。其中data是解码后的内容，如咱们打印输出后果所示。 ▲ 二维码的构造 bbox是指二维码轮廓的四个角，从左上角顺时针转的。而straight_qrcode是二维码的原始排列，也就是每个点是0还是255的一个矩阵，红色是255，彩色是0。 感兴趣的同学能够具体理解更多的二维码的构造。 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

实际上，在咱们应用Python解决日期/工夫的时候，常常会遇到各种各样的问题。明天咱们就来探讨另一个问题，如何用Python比拟两个日期？ datetime如果须要用Python解决日期和工夫，大家必定会先想到datetime、time、calendar等模块。在这其中，datetime模块次要是用来示意日期工夫的，就是咱们常说的年月日/时分秒。 datetime模块中罕用的类： 类名性能阐明date日期对象，罕用的属性有year，month，daytime工夫对象datetime日期工夫对象，罕用的属性有hour，minute，second，microsecondtimedelta工夫距离，即两个工夫点之间的长度tzinfo时区信息对象那么，如何用datetime模块比拟两个日期？ 在交互式环境中输出如下命令： import datetimefirst_date = datetime.date(2022, 2, 22)second_date = datetime.date(2022, 3, 1)print(first_date < second_date)输入： True咱们会发现datetime模块能够应用比拟运算符<或>来比拟两个日期。上述代码中比拟的是日期对象，如果换成日期工夫对象也同样能够这样比拟。 在交互式环境中输出如下命令： import datetimefirst_date = datetime.datetime(2022, 2, 22, 12, 5, 0)second_date = datetime.datetime(2022, 3, 1, 12, 5, 0)print(first_date < second_date)输入： Truestrptime后面示例代码中，其实比拟的都是日期对象/日期工夫对象。但如果用户输出的、或批量导入的日期和工夫是字符串格局，咱们在进行比拟的第一步就是先将str转换为datetime。 至于转换方法也非常简单，只须要通过datetime.strptime即可实现。 在交互式环境中输出如下命令： import datetimestrftime1 = datetime.datetime.strptime("2022-02-22", "%Y-%m-%d")strftime2 = datetime.datetime.strptime("2022-03-01", "%Y-%m-%d")print("日期2022-02-22大于2022-03-01：", strftime1 > strftime2)输入后果： 另外time模块中也有strptime()函数，能够依据指定的格局把工夫字符串解析为工夫元组，利用这一个性也能够比拟两个日期。 在交互式环境中输出如下命令： import timestrftime1 = time.strptime("2022-02-22", "%Y-%m-%d")strftime2 = time.strptime("2022-03-01", "%Y-%m-%d")print(strftime1)print(strftime2)print("日期2022-02-22大于2022-03-01：", strftime1 > strftime2)输入后果： 以上，便是如何用Python比拟两个日期的几个小办法。实际上，Python中工夫解决的不同模块、不同函数有很多能够总结的。 calendar（日历）模块、time（工夫）模块咱们后续还会具体介绍它们的小知识点，大家如果感兴趣能够给本文多多点赞反对一下。 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

写了很多年的python日志都是应用内置的logging模块来实现的，应用时都须要通过繁琐的配置。有时候，还可能呈现失落日志的状况，直到loguru的呈现。 【浏览全文】 loguru真的是非常的简略的，装置之后间接导入到python代码块中即可间接应用。 1、装置环境 咱们还是依照pip的形式来进行装置，默认应用清华大学的镜像站。 pip install loguru -i https://pypi.tuna.tsinghua.ed... 装置实现后就能够间接开始应用了。 2、惯例日志打印 在控制台打印惯例日志时不必增加任何的配置间接应用，应用实现后咱们能够来验证一下打印成果。 from loguru import logger# 应用debug级别打印一行日志logger.debug('I am debug message.')上面是我在pycharm下面取下来的日志效果图。 能够看一下成果还是令人满意的，这色彩搭配也比拟nice，并且日志工夫准确到秒级。想要看到的日志信息也根本囊括了。 3、写入日志文件 想写入日志文件也是比较简单不必配置，只须要调用add函数增加文件即可。 # 增加日志文件logger.add('./message-info.log')# 打印一行debug日志logger.debug('I am debug message.')此时，不仅控制台会呈现一行日志，并且在message-info.log文件中也写入了一条dubug日志信息。 若是在写入文件时想要指定本人的输入格局，则能够间接在add函数间接设置即可，同时能够设置输入到日志文件中的级别。 # 依照特定的格局将info级别的日志写入到日志文件中log = logger.add('./info.log',format='{time} | {level} | {message}',level='INFO')# 这时，多打印一些info级别的日志logger.info('I am info message <1>.')logger.info('I am info message <2>.')logger.info('I am info message <3>.')logger.info('I am info message <4>.')logger.info('I am info message <5>.')上面是在pycharm控制台打印的日志成果 上面是日志文件中的展现成果，跟咱们设定的日志格局是一样的。 4、进行写入日志文件 在上述过程中咱们增加自定义日志格局的日志信息到info.log文件中时特意返回了一个log变量。 这个log其实是返回了一个日志文件的id，在须要进行向该日志文件中写入日志时，只须要调用remove函数将该文件的日志id作为参数传入即可进行向日志文件中写入日志。 # 进行向日志文件中写入日志logger.remove(log)此时，前面的 日志文件将不会再写入日志文件中了。 ...

咱们提供封装好得物 数据采集接口，实时采集，接口稳固。长期保护应用便宜 接口应用详情请参考 接口地址： github 拜访地址：https://github.com/ping0206gu... 全副反对的接口如下，并且反对定制开发

毫无疑问 Python 中没有所谓的 main 入口函数，然而网上常常看到一些文章提“Python 的 main 函数”、“倡议写 main 函数”…… 有些人是知情的，他的用意可能是模拟那些正宗的 main 函数，但还有不少人显著是被误导了（或本人误会了），就写进去很累赘的代码。 本期“Python 为什么”栏目来聊聊 Python 为什么没有 main 函数？ 在开始正题之前，先要来答复这两个问题：所谓的 “main 函数”是指什么？为什么有些编程语言须要强制写一个 main 函数？ 某些编程语言以 main 函数作为程序的执行入口，例如 C/C++、C#、 Java、Go 和 Rust 等，它们具备特定的含意： main 函数名是强制的，也就是要求必须有一个 main 函数main 函数最多只能有一个，也就是说程序的入口是惟一的语法格局有肯定的要求，具备绝对固定的模板为什么要强制一个main入口函数呢？ 这些语言是编译型语言，须要把代码编译成可执行的二进制文件，为了让操作系统/启动器找到程序的终点，所以要约定这一个函数。简略地说，就是在一大堆代码里，须要定义一个显著的可用于执行的结尾。 不难看出，main 函数是那些语言中重要而不可缺的有机组成部分。 然而，咱们再来看看 Python，状况就大不相同了。 Python 是解释型语言，即脚本语言，运行过程是从上往下，逐行解析运行，也就是说它的终点是可知的每个 .py 文件就是一个可执行文件，都可作为整个程序的入口文件，也就是说程序的入口是灵便可变的，没有必须恪守的约定有时候运行 Python 我的项目，并没有指定入口文件（命令行中较常见，例如"python -m http.server 8000"）， 那可能是存在 __main__.py 文件，它所在的包被当成一个“文件”来执行了归纳起来，意思是说 Python 这种脚本语言跟编译型语言不同，它不论是在单个模块层面（即一个 .py 文件），还是在由多个模块组成的包层面，都可抉择灵便的执行形式，不像其它语言缺了约定好的入口就没法执行。 也就是说，Python 没有必要在语法层面规定程序员必须定义出一个对立的入口（不论是函数还是类还是什么货色）。 有些同学可能会有纳闷，因为他们常常看到或者本人写出上面这样的代码： # main 里是某些主体代码def main(): …… if __name__ == '__main__': main()难道这不就是 Python 的 main 函数么？置信有不少同学会这么想！ ...

在本文中，我将简要介绍在计算机编程语言中应用分号（许多计算机科学入门学生的祸根）的历史。咱们将看到分号有两种用处：作为语句分隔符和作为语句终止符，并且咱们将理解在过来60多年的编程语言历史中分号的应用产生了怎么的变动。 为什么编程语言应用分号分号在编程语言中用于两件事：语句分隔符和语句终止符。当一种语言应用分号作为语句分隔符时，这容许您在同一行上编写多个语句，并应用分号来标记语句的分隔，以便编译器或解释器能够找出一个语句在哪里完结而另一条语句在哪里开始。 在以分号为分隔符的语言中，分号被视为可选的，当一行代码仅蕴含一条语句时，通常不会编写分号。 作为语句结束符的分号是不可选的，用于明确地标记语句的完结，应用分号作为终止符的编程语言将在分号不在其预期地位时标记谬误。许多编程专家宣称，以分号结尾的语句能够使程序更快，因为编译器能够更无效地执行，只管我在本文开端会对此主张提出异议。 晚期的高级语言和分号的应用当Fortran在20世纪50年代中期被作为一种高级编程语言引入时，编程语言的史前时代就完结了，Fortran既不应用分号作为语句分隔符，也不应用分号作为语句终止符，Fortran中的语句每行只能写一个，而新行是语句终止符。 在古代编程语言中首次应用分号是ALGOL 58，然而，这个版本并没有失去很好的实现，它很快就变成了ALGOL 60。这个晚期版本的ALGOL应用分号作为分隔符，只管分号常常被多余地用作语句结束符(只管这不是必须的)。分号的这种混合应用可能会导致十分凌乱的程序，分号通常放在某些行的开端，而不是其余的行开端，如我从Steve Maurer的网站上借来的ALGOL 60代码片段所示： COMMENT advance to the next un-crossed out number. ;COMMENT this number must be a prime ;FOR i := i WHILE i<1000 AND candidates[i] = 0 DO BEGIN i := i+1; END; COMMENT insure against running off end of the data structure ; IF i<1000 THEN BEGIN COMMENT cross out all multiples, starting with 2*p.; j := 2; k := j*i; FOR k := k WHILE k < 1000 DO BEGIN candidates[k] := 0; j := j + 1; k := j*i; END; COMMENT advance to the next candidate ; i := i+1; END END;Algol 60衍生出了Algol的其余版本……始终到Algol 68。许多语言都是基于Algol的，但对当今语言影响最大的版本是Basic组合式编程语言(BCPL)。 ...

不论学习哪门语言都要做出理论的货色来，这个理论的货色就是我的项目。 小二整顿了 70 个 Python 实战我的项目，都有残缺且具体的教程，你能够从中抉择本人想做的我的项目进行参考学习练手，你也能够从中寻找灵感去做本人的我的项目。70 个 Python 练手我的项目如下所示： 1、【Python 图片转字符画】2、【200行Python代码实现2048】3、【Python3 实现火车票查问工具】4、【高德API+Python解决租房问题】5、【Python3色情图片辨认】6、【Python 破解验证码】7、【Python实现简略的Web服务器】8、【pygame开发打飞机游戏】9、【Django 搭建繁难博客】10、【Python基于共现提取《釜山行》人物关系】11、【基于scrapy爬虫的天气数据采集（python）】12、【Flask 开发轻博客】13、【Python3图片隐写术】14、【Python 实现繁难Shell】15、【应用Python解数学方程】16、【PyQt 实现繁难浏览器】17、【神经网络实现手写字符识别零碎】18、【Python 实现简略画板】19、【Python实现3D建模工具】20、【NBA惯例寒后果预测——利用Python进行较量数据分析】21、【神经网络实现人脸识别工作】22、【Python文本解析器】23、【Python3&amp；amp；OpenCV 视频转字符动画】24、【Python3 实现淘女郎照片爬虫】25、【Python3实现简略的FTP认证服务器】26、【基于Flask 与MySQL 实现番剧举荐零碎】27、【Python 实现端口扫描器】28、【应用Python3编写系列实用脚本】29、【Python 实现康威生命游戏】30、【川普撞脸希拉里（基于OpenCV的面部特色替换）】31、【Python 3实现Markdown 解析器】32、【Python气象数据分析--《Python 数据分析实战》】33、【Python实现键值数据库】34、【k-近邻算法实现手写数字识别系统】35、【ebay在线拍卖数据分析】36、【Python 实现英文新闻摘要主动提取】37、【Python实现繁难局域网视频聊天工具】38、【基于Flask及爬虫实现微信娱乐机器人】39、【Python实现Python解释器】40、【Python3基于Scapy实现DDos】41、【Python 实现明码强度检测器】42、【应用Python 实现深度神经网络】43、【Python实现从excel读取数据并绘制成精美图像】44、【人机对战初体验：Python基于Pygame实现四子棋游戏】45、【Python3实现可管制肉鸡的反向Shell】46、【Python打造破绽扫描器】47、【Python利用马尔可夫链算法实现随机文本生成】48、【数独游戏的Python实现与破解】49、【应用Python定制词云】50、【Python开发简略计算器】50、【Python开发简略计算器】51、【Python 实现FTP弱口令扫描器】52、【Python实现Huffman编码解压缩文件】53、【Python实现Zip文件的暴力破解】54、【Python3智能裁切图片】55、【Python实现网站模仿登陆】56、【给Python3爬虫做一个界面.妹子图网实战】57、【Python3实现图片转黑白字符】58、【自联想器的Python 实现】59、【Python 实现简略流镜】60、【Flask实现简略聊天室】61、【基于PyQt5实现地图中定位相片拍摄地位】62、【Python实现模板引擎】63、【Python实现遗传算法求解n-queens问题】64、【Python3实现命令行动静进度条】65、【Python获取挂号信息并邮件告诉】66、【Python实现java web我的项目远端自动化更新部署】67、【应用Python3编写Github 主动周报生成器】68、【应用Python生成分形图片】69、【Python 实现Redis 异步客户端】70、【Python 实现中文错别字高亮零碎】 我的项目在公号Python小二后盾回复py70获取~

成员名不容许反复这部分我的第一个想法是去管制 dict 中的 key 。但这样的形式并不好，__dict__ 范畴大，它蕴含该类的所有属性和办法。而不单单是枚举的命名空间。我在源码中发现 enum 应用另一个办法。通过 prepare 魔术办法能够返回一个类字典实例，在该实例 应用 prepare 魔术办法自定义命名空间，在该空间内限定成员名不容许反复。 # 本人实现class _Dict(dict): def __setitem__(self, key, value): if key in self: raise TypeError('Attempted to reuse key: %r' % key) super().__setitem__(key, value)class MyMeta(type): @classmethod def __prepare__(metacls, name, bases): d = _Dict() return dclass Enum(metaclass=MyMeta): passclass Color(Enum): red = 1 red = 1 # TypeError: Attempted to reuse key: 'red'再看看 Enum 模块的具体实现： class _EnumDict(dict): def __init__(self): super().__init__() self._member_names = [] ... def __setitem__(self, key, value): ... elif key in self._member_names: # descriptor overwriting an enum? raise TypeError('Attempted to reuse key: %r' % key) ... self._member_names.append(key) super().__setitem__(key, value)class EnumMeta(type): @classmethod def __prepare__(metacls, cls, bases): enum_dict = _EnumDict() ... return enum_dictclass Enum(metaclass=EnumMeta): ...模块中的 _EnumDict 创立了 _member_names 列表来存储成员名，这是因为不是所有的命名空间内的成员都是枚举的成员。比方 str__, __new 等魔术办法就不是了，所以这边的 setitem 须要做一些过滤： ...

起步queue 模块提供实用于多线程编程的先进先出（FIFO）数据结构。因为它是线程平安的，所以多个线程很轻松地应用同一个实例。 源码剖析先从初始化的函数来看： class Queue: def __init__(self, maxsize=0): # 设置队列的最大容量 self.maxsize = maxsize self._init(maxsize) # 线程锁，互斥变量 self.mutex = threading.Lock() # 由锁衍生出三个条件变量 self.not_empty = threading.Condition(self.mutex) self.not_full = threading.Condition(self.mutex) self.all_tasks_done = threading.Condition(self.mutex) self.unfinished_tasks = 0 def _init(self, maxsize): # 初始化底层数据结构 self.queue = deque()从这初始化函数能失去哪些信息呢？首先，队列是能够设置其容量大小的，并且具体的底层寄存元素的它应用了 collections.deque() 双端列表的数据结构，这使得能很不便的做先进先出操作。这里还顺便形象为 _init 函数是为了不便其子类进行笼罩，容许子类应用其余构造来寄存元素（比方优先队列应用了 list）。 而后就是线程锁 self.mutex ，对于底层数据结构 self.queue 的操作都要先取得这把锁；再往下是三个条件变量，这三个 Condition 都以 self.mutex 作为参数，也就是说它们共用一把锁；从这能够晓得诸如 with self.mutex 与 with self.not_empty 等都是互斥的。 基于这些锁而做的一些简略的操作： class Queue: ... def qsize(self): # 返回队列中的元素数 with self.mutex: return self._qsize() def empty(self): # 队列是否为空 with self.mutex: return not self._qsize() def full(self): # 队列是否已满 with self.mutex: return 0 < self.maxsize <= self._qsize() def _qsize(self): return len(self.queue)这个代码片段挺好了解的，无需剖析。 ...

不过最近有位读者发问： Python 的多线程真是假的吗？一下子点到了 Python 长期被人们喜忧参半的个性 —— GIL 上了。 到底是怎么回事呢？明天咱们来聊一聊。 美中不足咱们晓得 Python 之所以灵便和弱小，是因为它是一个解释性语言，边解释边执行，实现这种个性的规范实现叫作 CPython。 它分两步来运行 Python 程序： 首先解析源代码文本，并将其编译为字节码（bytecode）[1]而后采纳基于栈的解释器来运行字节码一直循环这个过程，直到程序完结或者被终止灵活性有了，然而为了保障程序执行的稳定性，也付出了微小的代价： 引入了 全局解释器锁 GIL（global interpreter lock）[2]以保障同一时间只有一个字节码在运行，这样就不会因为没用当时编译，而引发资源抢夺和状态凌乱的问题了。 看似 “美中不足” ，但，这样做，就意味着多线程执行时，会被 GIL 变为单线程，无奈充分利用硬件资源。 来看代码： import timedef gcd(pair):    '''    求解最大公约数    '''    a, b = pair    low = min(a, b)    for i in range(low, 0, -1):        if a % i == 0 and b % i == 0:            return i        assert False, "Not reachable"# 待求解的数据NUMBERS = [    (1963309, 2265973), (5948475, 2734765),    (1876435, 4765849), (7654637, 3458496),    (1823712, 1924928), (2387454, 5873948),    (1239876, 2987473), (3487248, 2098437),    (1963309, 2265973), (5948475, 2734765),    (1876435, 4765849), (7654637, 3458496),    (1823712, 1924928), (2387454, 5873948),    (1239876, 2987473), (3487248, 2098437),    (3498747, 4563758), (1298737, 2129874)]## 程序求解start = time.time()results = list(map(gcd, NUMBERS))end = time.time()delta = end - startprint(f'程序执行工夫: {delta:.3f} 秒')函数 gcd 用于求解最大公约数，用来模仿一个数据操作NUMBERS 为待求解的数据求解形式利用 map 办法，传入处理函数 gcd, 和待求解数据，将返回一个后果数列，最初转化为 list将执行过程的耗时计算并打印进去在笔者的电脑上（4核，16G）执行工夫为 2.043 秒。 如何换成多线程呢？ ...from concurrent.futures import ThreadPoolExecutor...## 多线程求解start = time.time()pool = ThreadPoolExecutor(max_workers=4)results = list(pool.map(gcd, NUMBERS))end = time.time()delta = end - startprint(f'执行工夫: {delta:.3f} 秒')这里引入了 concurrent.futures 模块中的线程池，用线程池实现起来比拟不便设置线程池为 4，次要是为了和 CPU 的核数匹配线程池 pool 提供了多线程版的 map，所以参数不变看看运行成果： 程序执行工夫: 2.045 秒并发执行工夫: 2.070 秒 what? 并行执行的工夫居然更长了！ 间断执行屡次，后果都是一样的，也就是说在 GIL 的限度下，多线程是有效的，而且因为线程调度还多损耗了些工夫。 戴着镣铐跳舞难道 Python 里的多线程真的没用吗？ 其实也并不是，尽管了因为 GIL，无奈实现真正意义上的多线程，但，多线程机制，还是为咱们提供了两个重要的个性。 一：多线程写法能够让某些程序更好写怎么了解呢？ 如果要解决一个须要同时保护多种状态的程序，用单线程是实现是很艰难的。 比方要检索一个文本文件中的数据，为了进步检索效率，能够将文件分成小段的来解决，最先在那段中找到了，就完结处理过程。 用单线程的话，很难实现同时兼顾多个分段的状况，只能程序，或者用二分法执行检索工作。 而采纳多线程，能够将每个分段交给每个线程，会轮流执行，相当于同时举荐检索工作，解决起来，效率会比程序查找大大提高。 二：解决阻塞型 I/O 工作效率更高阻塞型 I/O 的意思是，当零碎须要与文件系统（也包含网络和终端显示）交互时，因为文件系统相比于 CPU 的处理速度慢得多，所以程序会被设置为阻塞状态，即，不再被调配计算资源。 直到文件系统的后果返回，才会被激活，将有机会再次被调配计算资源。 也就是说，处于阻塞状态的程序，会始终等着。 那么如果一个程序是须要一直地从文件系统读取数据，解决后在写入，单线程的话就须要等等读取后，能力解决，期待解决完能力写入，于是处理过程就成了一个个的期待。 而用多线程，当一个处理过程被阻塞之后，就会立刻被 GIL 切走，将计算资源分配给其余能够执行的过程，从而提醒执行效率。 ...

家喻户晓，Pytnon 十分善于解决数据，尤其是前期数据的荡涤工作。明天派森酱就给大家介绍一款解决数据的神器 Pipe。 什么是 Pipe简言之，Pipe 是 Python 的一个三方库。 通过 Pipe 咱们能够将一个函数的处理结果传递给另外一个函数，这意味着你的代码会十分简洁。 要应用 Pipe 须要提前装置，间接应用 pip 装置即可。 pip install pipe过滤元素和 filter 相似，pipe 中的 where 操作能够过滤可迭代对象中的元素。 In [5]: numbers = [0, 1, 2, 3, 4, 5]In [6]: list(numbers | where(lambda x: x % 2 == 0))Out[6]: [0, 2, 4]作用元素相似 map，select 操作能够将函数作用于可迭代对象中的每个元素。上面的例子中咱们将列表中的元素都扩充 2 倍。 In [8]: list(numbers | select(lambda x: x * 2))Out[8]: [0, 2, 4, 6, 8, 10]当然，还能够将多种操作合并在一起来玩。 上面的例子就是将列表中的偶数筛选进去并扩充 2 倍，和 filter 与 map 不同的是，pipe 能够将多个操作连接起来，就像水管套水管一样，所以我想管道这个名字也是很接地气了。 In [10]: list(numbers    ...:     | where(lambda x: x % 2 == 0)    ...:     | select(lambda x: x * 2)    ...:    )    ...:Out[10]: [0, 4, 8]连贯元素操作嵌套列表时十分苦楚，值得快乐的是 pipe 给出了很敌对的接口，只须要 chain 一下即可。 In [11]: list([[1, 2], [3, 4], [5]] | chain)Out[11]: [1, 2, 3, 4, 5]In [30]: list((1, 2, 3) | chain_with([4, 5], [6]))Out[30]: [1, 2, 3, 4, 5, 6]In [31]: list((1, 2, 3) | chain_with([4, 5], [6,[7]]))Out[31]: [1, 2, 3, 4, 5, 6, [7]]如你所见，chain 只能够拆开一层，如果要拆开多层嵌套的话，不要慌，traverse 轻松搞定。 In [12]: list([[1, 2], [[[3], [[4]]], [5]]] | traverse)Out[12]: [1, 2, 3, 4, 5]联合 select 一起，获取字典中的某个字段属性汇合。 In [32]: fruits = [    ...:     {"name": "apple", "price": [2, 5]},    ...:     {"name": "orange", "price": 4},    ...:     {"name": "grape", "price": 5},    ...: ]In [33]: list(fruits    ...:      | select(lambda fruit: fruit["price"])    ...:      | traverse)    ...:Out[33]: [2, 5, 4, 5]分组对列表中的元素进行分组是必不可少的，在 pipe 中能够应用 groupby 来实现。 In [26]: list(numbers    ...:      | groupby(lambda x: 'Even' if x % 2 == 0 else 'Odd')    ...:      | select(lambda x: {x[0]: list(x[1])})    ...:     )    ...:Out[26]: [{'Even': [0, 2, 4]}, {'Odd': [1, 3, 5]}]同样，还能够在 select 中增加 where 过滤条件。 In [27]: list(numbers    ...:      | groupby(lambda x: 'Even' if x % 2 == 0 else 'Odd')    ...:      | select(lambda x: {x[0]: list(x[1] | where(lambda x: x > 2))})    ...:     )    ...:Out[27]: [{'Even': [4]}, {'Odd': [3, 5]}]行列调换数据处理中时常会用到行列相互转换，尤其是在用 DataFrame 时，应用 pipe 一行代码搞定行列转换。 In [24]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] | transposeOut[24]: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]删除元素对列表去重也是一项罕用的操作，在 pipe 中应用 dedup 来对列表进行去重。 In [28]: list([1, 1, 2, 2, 3, 3, 1, 2, 3] | dedup)Out[28]: [1, 2, 3]与 dedup 不同的是，uniq 只会对间断的反复元素保留一个，非间断反复元素则不过滤。 ...

十字绣大家都晓得吧，明天咱们来玩个电子版的十字绣。 用 Python 读取图片的像素值，而后输入到 Excel 表格中，最终造成一幅像素画，也就是电子版的十字绣了。 筹备既然要读取图片，那就须要用到 Pillow 库，操作 Excel 须要用到 openpyxl 库，先把这两个库装置好。 $ pip3 install openpyxl$ pip3 install Pillow色值转换从图片读取的像素块色值是 RGB 值，而 openpyxl 向 Excel cell 内填充色彩是十六进制色值，因而咱们先写一个 RGB 和十六进制色值转换的一个函数。 def rgb_to_hex(rgb):    rgb = rgb.split(',')    color = ''    for i in RGB:        num = int(i)        color += str(hex(num))[-2:].replace('x', '0').upper()    return color图片转换有了色值转换函数，接下来要做的操作就是逐行读取图片的 RGB 色值，之后将 RGB 色值转换为十六进制色值填充到 Excel 的 cell 中即可。 def img2excel(img_path, excel_path):    img_src = Image.open(img_path)    # 图片宽高    img_width = img_src.size[0]    img_height = img_src.size[1]    str_strlist = img_src.load()    wb = openpyxl.Workbook()    wb.save(excel_path)    wb = openpyxl.load_workbook(excel_path)    cell_width, cell_height = 1.0, 1.0    sheet = wb["Sheet"]    for w in range(img_width):        for h in range(img_height):            data = str_strlist[w, h]            color = str(data).replace("(", "").replace(")", "")            color = rgb_to_hex(color)            # 设置填充色彩为 color            fille = PatternFill("solid", fgColor=color)            sheet.cell(h + 1, w + 1).fill = fille    for i in range(1, sheet.max_row + 1):        sheet.row_dimensions[i].height = cell_height    for i in range(1, sheet.max_column + 1):        sheet.column_dimensions[get_column_letter(i)].width = cell_width    wb.save(excel_path)    img_src.close()最初再来个入口函数，就功败垂成啦～ if __name__ == '__main__':    img_path = '/Users/xyz/Documents/tmp/03.png'    excel_path = '/Users/xyz/Documents/tmp/3.xlsx'    img2excel(img_path, excel_path)惊艳时刻冲动的心，颤动的手，来看下最终成果咋样。 是不是感觉有那么一丝丝韵味呢... 总结明天带大家一起实现了 Excel 像素画，小伙伴们能够施展本人的设想，比方把女神的头像藏进 Excel 中而后发她，你猜女神会不会被惊艳到呢。 以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

邂逅Django - 目录✅ Part 1：【邂逅Django】—— （一）创立我的项目 ✅ Part 2：【邂逅Django】—— （二）数据库配置 ️ Part 3：【邂逅Django】—— （三）视图 ️ Part 4：【邂逅Django】—— （四）表单和通用视图 ️ Part 5：【邂逅Django】—— （五）欠缺界面（自定义界面和款式） ️ Part 6：【邂逅Django】—— （六）自定义治理界面 ️ Part 7：【邂逅Django】—— （七）自动化测试 前言本系列文章，在Django官网文档教程的根底模板下，进行了肯定的改良和删除，增加了一些本人的见解。 心愿大家看完该系列文章后，对Django可能有一个清晰的意识。 路漫漫兮其修远兮，吾将上下而求索！ Django==官网文档==：https://www.djangoproject.com/ ❗ ❗ ❗ 学习过程中，多看官网文档，能够解决很多问题 ❗ ❗ ❗ 本教程应用poetry对我的项目环境进行治理。相干poetry的装置与应用，请参考【Python - 虚拟环境】我的项目的启动，从隔离开发环境开始 - SegmentFault 思否一、我的项目配置文件settings.py 1.1 数据库配置mysite/settings.py ，是个蕴含了Django我的项目设置的Python模块。 数据库的配置，在于变量DATABASES。 Django默认应用SQLite作为默认数据库。Python内置SQLite，所以无需装置额定的货色就能够应用。 如果做一个真正的我的项目，最好不要应用SQLite。 # Django 默认应用 SQLiteDATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': BASE_DIR / 'db.sqlite3', }}# Django应用MySQL配置DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'mysite', # 应用MySQL时，须要提前在MySQL创立mysite数据库 'HOST': '127.0.0.1', 'PORT': 3306, 'USER': 'root', 'PASSWORD': '******' }}参数阐明： ...

先贴链接：Constructs Supported constructs: conditional branch: if .. elif .. elseloops: while, for .. in, break, continuebasic generator: yieldassertion: assertPartially supported constructs: exceptions: try .. except, raise, else and finally (See details in this section)context manager: with (only support numba.objmode())list comprehension (see details in this section)Unsupported constructs: async features: async with, async for and async defclass definition: class (except for @jitclass)set, dict and generator comprehensionsgenerator delegation: yield from能够看到， numba 不反对 dict ！！！ ...

在 Python 中，个别状况下咱们可能间接用自带的 logging 模块来记录日志，包含我之前的时候也是一样。在应用时咱们须要配置一些 Handler、Formatter 来进行一些解决，比方把日志输入到不同的地位，或者设置一个不同的输入格局，或者设置日志分块和备份。但其实个人感觉 logging 用起来其实并不是那么好用，其实次要还是配置较为繁琐。 常见应用首先看看 logging 常见的解决方案吧，我个别会配置输入到文件、控制台和 Elasticsearch。输入到控制台就仅仅是不便间接查看的；输入到文件是不便间接存储，保留所有历史记录的备份；输入到 Elasticsearch，间接将 Elasticsearch 作为存储和剖析的核心，应用 Kibana 能够十分不便地剖析和查看运行状况。 所以在这里我根本会对 logging 做如下的封装写法： import loggingimport sysfrom os import makedirsfrom os.path import dirname, existsfrom cmreslogging.handlers import CMRESHandlerloggers = {}LOG_ENABLED = True # 是否开启日志LOG_TO_CONSOLE = True # 是否输入到控制台LOG_TO_FILE = True # 是否输入到文件LOG_TO_ES = True # 是否输入到 ElasticsearchLOG_PATH = './runtime.log' # 日志文件门路LOG_LEVEL = 'DEBUG' # 日志级别LOG_FORMAT = '%(levelname)s - %(asctime)s - process: %(process)d - %(filename)s - %(name)s - %(lineno)d - %(module)s - %(message)s' # 每条日志输入格局ELASTIC_SEARCH_HOST = 'eshost' # Elasticsearch HostELASTIC_SEARCH_PORT = 9200 # Elasticsearch PortELASTIC_SEARCH_INDEX = 'runtime' # Elasticsearch Index NameAPP_ENVIRONMENT = 'dev' # 运行环境，如测试环境还是生产环境def get_logger(name=None): """ get logger by name :param name: name of logger :return: logger """ global loggers if not name: name = __name__ if loggers.get(name): return loggers.get(name) logger = logging.getLogger(name) logger.setLevel(LOG_LEVEL) # 输入到控制台 if LOG_ENABLED and LOG_TO_CONSOLE: stream_handler = logging.StreamHandler(sys.stdout) stream_handler.setLevel(level=LOG_LEVEL) formatter = logging.Formatter(LOG_FORMAT) stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) # 输入到文件 if LOG_ENABLED and LOG_TO_FILE: # 如果门路不存在，创立日志文件文件夹 log_dir = dirname(log_path) if not exists(log_dir): makedirs(log_dir) # 增加 FileHandler file_handler = logging.FileHandler(log_path, encoding='utf-8') file_handler.setLevel(level=LOG_LEVEL) formatter = logging.Formatter(LOG_FORMAT) file_handler.setFormatter(formatter) logger.addHandler(file_handler) # 输入到 Elasticsearch if LOG_ENABLED and LOG_TO_ES: # 增加 CMRESHandler es_handler = CMRESHandler(hosts=[{'host': ELASTIC_SEARCH_HOST, 'port': ELASTIC_SEARCH_PORT}], # 能够配置对应的认证权限 auth_type=CMRESHandler.AuthType.NO_AUTH, es_index_name=ELASTIC_SEARCH_INDEX, # 一个月分一个 Index index_name_frequency=CMRESHandler.IndexNameFrequency.MONTHLY, # 额定减少环境标识 es_additional_fields={'environment': APP_ENVIRONMENT} ) es_handler.setLevel(level=LOG_LEVEL) formatter = logging.Formatter(LOG_FORMAT) es_handler.setFormatter(formatter) logger.addHandler(es_handler) # 保留到全局 loggers loggers[name] = logger return logger定义完了怎么应用呢？只须要应用定义的办法获取一个 logger，而后 log 对应的内容即可： ...

有许许多多文章写了 Python 中的许多很酷的个性，例如变量解包、偏函数、枚举可迭代对象，然而对于 Python 还有很多要探讨的话题，因而在本文中，我将尝试展现一些我晓得的和在应用的，但很少在其它文章提到过的个性。那就开始吧。 1、对输出的字符串“消毒”对用户输出的内容“消毒”，这问题简直实用于你编写的所有程序。通常将字符转换为小写或大写就足够了，有时你还能够应用正则表达式来实现工作，然而对于简单的状况，还有更好的办法： user_input = "This\nstring has\tsome whitespaces...\r\n"character_map = { ord('\n') : ' ', ord('\t') : ' ', ord('\r') : None}user_input.translate(character_map) # This string has some whitespaces... "在此示例中，你能够看到空格字符“ \n”和“ \t”被单个空格替换了，而“ \r”则被齐全删除。这是一个简略的示例，然而咱们能够更进一步，应用unicodedata 库及其 combining() 函数，来生成更大的重映射表（remapping table），并用它来删除字符串中所有的重音。 2、对迭代器切片如果你尝试间接对迭代器切片，则会失去 TypeError ，提醒说该对象不可取下标（not subscriptable），然而有一个简略的解决方案： import itertoolss = itertools.islice(range(50), 10, 20) # <itertools.islice object at 0x7f70fab88138>for val in s: ...应用itertools.islice，咱们能够创立一个 islice 对象，该对象是一个迭代器，能够生成咱们所需的内容。然而这有个重要的揭示，即它会消耗掉切片前以及切片对象 islice 中的所有元素。 3、跳过可迭代对象的开始有时候你必须解决某些文件，它们以可变数量的不须要的行（例如正文）为结尾。itertools 再次提供了简略的解决方案： string_from_file = """// Author: ...// License: ...//// Date: ...Actual content..."""import itertoolsfor line in itertools.dropwhile(lambda line:line.startswith("//"), string_from_file.split("\n")): print(line)这段代码仅会打印在初始的正文局部之后的内容。如果咱们只想抛弃迭代器的结尾局部（在此例中是正文），并且不晓得有多少内容，那么此办法很有用。 ...

调用形式nox 通常是在命令行上被调用的： nox你还能够通过 Python 解释器调用 nox： python3 -m nox 列出可用的会话列出所有可用的会话，包含参数化的会话： nox -lnox --listnox --list-sessions运行所有会话你能够不带任何参数地执行 nox 来运行每个会话： nox会话被执行的程序是它们在 noxfile 中呈现的程序。 指定一个或多个会话默认状况下，nox 将运行在 noxfile 中定义的所有会话。然而，你能够抉择应用--session、-s 或-e 运行特定的一组： nox --session testsnox -s lint testsnox -e lint你还能够应用NOXSESSION环境变量： NOXSESSION=lint noxNOXSESSION=lint,tests noxnox 将依照指定的程序运行这些会话。 你还能够应用pytest-格调的关键字来过滤测试会话： nox -k "not lint"nox -k "tests and not lint"指定参数化的会话如果你有参数化的会话，例如： @nox.parametrize('django', ['1.9', '2.0'])def tests(session, django): ...那么运行nox --session tests，实际上将运行该会话的所有参数化版本。如果你要应用一组特定的参数化参数运行会话，则能够应用会话名称来指定它们： nox --session "tests(django='1.9')"nox --session "tests(django='2.0')"重用虚拟环境默认状况下，nox 在每次运行时都会删除并从新创立虚拟环境（virtualenv）。通常，对于大多数我的项目和继续集成环境而言，这都是很好的，因为pip的缓存使得重新安装相当快。然而，在某些状况下，在两次运行之间重用虚拟环境是更无利的。应用-r或--reuse-existing-virtualenvs： nox -rnox --reuse-existing-virtualenvs如果 noxfile 设置了nox.options.reuse_existing_virtualenvn，你能够在命令行应用--no-reuse-existing-virtualenvs 笼罩 noxfile 的设置。 ...

NoxfileNox 默认在一个名为noxfile.py的文件中查找配置。在运行 nox 时，你能够应用 --noxfile参数指定其它的文件。 定义会话格局：session(func=None, python=None, py=None, reuse_venv=None, name=None, venv_backend=None)，将被装璜的函数指定为一个会话。 Nox 会话是通过被@nox.session装璜的规范 Python 函数来配置的。例如: import nox@nox.sessiondef tests(session): session.run('pytest')会话形容你能够应用文档字符串向会话中增加一个形容。第一行内容会在列出会话时显示。例如: import nox@nox.sessiondef tests(session): """Run the test suite.""" session.run('pytest')nox --list命令将显示出: $ nox --listAvailable sessions:* tests -> Run the test suite.会话名称默认状况下，Nox 应用被装璜函数的名称作为会话的名称。这对于绝大多数我的项目都十分无效，然而，如果须要，你也能够应用 @nox.session 的 name 参数来自定义会话的名称。例如: import nox@nox.session(name="custom-name")def a_very_long_function_name(session): print("Hello!")nox --list 命令将显示： $ nox --listAvailable sessions:* custom-name你能够通知 nox 应用自定义的名称运行会话: $ nox --session "custom-name"Hello!配置会话的virtualenv默认状况下，Nox 在为每个会话创立一个新的 virtualenv 时，会应用 Nox 所用的同一个解释器。如果你应用 Python 3.6 装置了 nox，则 nox 将默认在所有会话中应用 Python 3.6。 ...

大家好，明天萝卜哥用Python做了一个网页版的“P图软件”，大抵的流程在于咱们能够将上传的照片进行黑白解决、铅笔素描解决、模糊化解决等一系列操作，具体如下 上面咱们来看一下该整个网页是怎么写的 网页左侧的工具栏局部首先第一步在于导入咱们所须要用到的模块，代码如下 import streamlit as stimport numpy as npimport cv2from PIL import Image, ImageEnhance咱们先设计到网页当中的题目和右边的工具栏，右边的工具栏局部代码如下 st.sidebar.markdown('<p class="font">My First Photo Converter App</p>', unsafe_allow_html=True)with st.sidebar.expander("About the App"):     st.write("""        Use this simple app to convert your favorite photo to a pencil sketch, a grayscale image or an image with blurring effect.  \n  \nThis app was created by Junxin as a side project to learn Streamlit and computer vision. Hope you enjoy!     """)首先在工具栏当中增加的是对于该利用的介绍，通过调用streamlit模块当中的sidebar办法来生成一个下拉框，在通过点击“+”键来关上， 而后则是5个单选框，代码如下 filter = st.sidebar.radio('Covert your photo to:', ['Original', 'Gray Image', 'Black and White', 'Pencil Sketch', 'Blur Effect'])单选框是通过sidebar办法来实现的，当中增加上别离是哪些的单选项， 紧接着是最初的“感激反馈”的局部，代码如下 st.sidebar.title(' ')st.sidebar.markdown(' ')st.sidebar.subheader('Please help us improve!')with st.sidebar.form(key='columns_in_form',clear_on_submit=True):     rating=st.slider("Please rate the app", min_value=1, max_value=5, value=3,help='Drag the slider to rate the app. This is a 1-5 rating scale where 5 is the highest rating')    text=st.text_input(label='Please leave your feedback here')    submitted = st.form_submit_button('Submit')    if submitted:      ....... 网页注释的题目局部题目局部的代码如下 with col1:    st.markdown(""" <style> .font {    font-size:35px ; font-family: 'Cooper Black'; color: #FF9633;}     </style> """, unsafe_allow_html=True)    st.markdown('<p class="font">Upload your photo here...</p>', unsafe_allow_html=True)当然除此之外，咱们须要的是上传图片的性能，代码如下 uploaded_file = st.file_uploader("", type=['jpg', 'png', 'jpeg'])这里调用的是streamlit模块当中的file_uploader办法，其中容许上传的有三种文件格式，别离是jpg、png以及jpeg。 接下去便是上传图片的解决逻辑局部，代码如下， with col2:    filter = st.sidebar.radio('Covert your photo to:', ['Original', 'Gray Image', 'Black and White', 'Pencil Sketch', 'Blur Effect'])    if filter == 'Gray Image':        converted_img = np.array(image.convert('RGB'))        gray_scale = cv2.cvtColor(converted_img, cv2.COLOR_RGB2GRAY)            ......    elif filter == 'Black and White':            ......    elif filter == 'Pencil Sketch':            ......    elif filter == 'Blur Effect':            ......    else:        st.image(image, width=300)以上就是本次分享的所有内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

明天咱们讲一下pandas当中的数据过滤内容 上面小编会给出大略20个案例来具体阐明数据过滤的办法，首先咱们先建设要用到的数据集，代码如下： import pandas as pddf = pd.DataFrame({    "name": ["John","Jane","Emily","Lisa","Matt"],    "note": [92,94,87,82,90],    "profession":["Electrical engineer","Mechanical engineer",                  "Data scientist","Accountant","Athlete"],    "date_of_birth":["1998-11-01","2002-08-14","1996-01-12",                     "2002-10-24","2004-04-05"],    "group":["A","B","B","A","C"]})output     name  note           profession date_of_birth group0   John    92  Electrical engineer    1998-11-01     A1   Jane    94  Mechanical engineer    2002-08-14     B2  Emily    87       Data scientist    1996-01-12     B3   Lisa    82           Accountant    2002-10-24     A4   Matt    90              Athlete    2004-04-05     C筛选表格中的若干列代码如下 df[["name","note"]]output     name  note0   John    921   Jane    942  Emily    873   Lisa    824   Matt    90再筛选出若干行咱们基于下面搜寻出的后果之上，再筛选出若干行，代码如下 df.loc[:3, ["name","note"]]output     name  note0   John    921   Jane    942  Emily    873   Lisa    82依据索引来过滤数据这里咱们用到的是iloc办法，代码如下 df.iloc[:3, 2]output 0    Electrical engineer1    Mechanical engineer2         Data scientist通过比拟运算符来筛选数据df[df.note > 90]output    name  note           profession date_of_birth group0  John    92  Electrical engineer    1998-11-01     A1  Jane    94  Mechanical engineer    2002-08-14     Bdt属性接口dt属性接口是用于解决工夫类型的数据的，当然首先咱们须要将字符串类型的数据，或者其余类型的数据转换成事件类型的数据，而后再解决，代码如下 df.date_of_birth = df.date_of_birth.astype("datetime64[ns]")df[df.date_of_birth.dt.month==11]output    name  note           profession date_of_birth group0  John    92  Electrical engineer    1998-11-01     A或者咱们也能够 df[df.date_of_birth.dt.year > 2000]output    name  note           profession date_of_birth group1  Jane    94  Mechanical engineer    2002-08-14     B3  Lisa    82           Accountant    2002-10-24     A4  Matt    90              Athlete    2004-04-05     C多个条件交加过滤数据当咱们遇上多个条件，并且是交加的状况下过滤数据时，代码应该这么来写 df[(df.date_of_birth.dt.year > 2000) &     (df.profession.str.contains("engineer"))]output    name  note           profession date_of_birth group1  Jane    94  Mechanical engineer    2002-08-14     B多个条件并集筛选数据当多个条件是以并集的形式来过滤数据的时候，代码如下 df[(df.note > 90) | (df.profession=="Data scientist")]output     name  note           profession date_of_birth group0   John    92  Electrical engineer    1998-11-01     A1   Jane    94  Mechanical engineer    2002-08-14     B2  Emily    87       Data scientist    1996-01-12     BQuery办法过滤数据Pandas当中的query办法也能够对数据进行过滤，咱们将过滤的条件输出 df.query("note > 90")output    name  note           profession date_of_birth group0  John    92  Electrical engineer    1998-11-01     A1  Jane    94  Mechanical engineer    2002-08-14     B又或者是 df.query("group=='A' and note > 89")output    name  note           profession date_of_birth group0  John    92  Electrical engineer    1998-11-01     Ansmallest办法过滤数据pandas当中的nsmallest以及nlargest办法是用来找到数据集当中最大、最小的若干数据，代码如下 df.nsmallest(2, "note")output     name  note      profession date_of_birth group3   Lisa    82      Accountant    2002-10-24     A2  Emily    87  Data scientist    1996-01-12     Bdf.nlargest(2, "note")output    name  note           profession date_of_birth group1  Jane    94  Mechanical engineer    2002-08-14     B0  John    92  Electrical engineer    1998-11-01     Aisna()办法isna()办法性能在于过滤出那些是空值的数据，首先咱们将表格当中的某些数据设置成空值 df.loc[0, "profession"] = np.nandf[df.profession.isna()]output    name  note profession date_of_birth group0  John    92        NaN    1998-11-01     Anotna()办法notna()办法下面的isna()办法正好相同的性能在于过滤出那些不是空值的数据，代码如下 df[df.profession.notna()]output     name  note           profession date_of_birth group1   Jane    94  Mechanical engineer    2002-08-14     B2  Emily    87       Data scientist    1996-01-12     B3   Lisa    82           Accountant    2002-10-24     A4   Matt    90              Athlete    2004-04-05     Cassign办法pandas当中的assign办法作用是间接向数据集当中来增加一列 df_1 = df.assign(score=np.random.randint(0,100,size=5))df_1output     name  note           profession date_of_birth group  score0   John    92  Electrical engineer    1998-11-01     A     191   Jane    94  Mechanical engineer    2002-08-14     B     842  Emily    87       Data scientist    1996-01-12     B     683   Lisa    82           Accountant    2002-10-24     A     704   Matt    90              Athlete    2004-04-05     C     39explode办法explode()办法直译的话，是爆炸的意思，咱们常常会遇到这样的数据集   Name            Hobby0   吕布  [打篮球, 玩游戏, 喝奶茶]1   貂蝉       [敲代码, 看电影]2   赵云        [听音乐, 健身]Hobby列当中的每行数据都以列表的模式集中到了一起，而explode()办法则是将这些集中到一起的数据拆开来，代码如下  Name Hobby0   吕布   打篮球0   吕布   玩游戏0   吕布   喝奶茶1   貂蝉   敲代码1   貂蝉   看电影2   赵云   听音乐2   赵云    健身当然咱们会开展来之后，数据会存在反复的状况， df.explode('Hobby').drop_duplicates().reset_index(drop=True)output  Name Hobby0   吕布   打篮球1   吕布   玩游戏2   吕布   喝奶茶3   貂蝉   敲代码4   貂蝉   看电影5   赵云   听音乐6   赵云    健身好了，这就是明天分享的内容，如果你感觉文章还不错，欢送关注公众号：Python编程学习圈，每日干货分享，发送“J”还可支付大量学习材料。或是返回编程学习网，理解更多编程技术常识。

前不久在咱们技术交换群有群友提到最近他面试阿里70万总包的数据岗位，对方问Pandas的5种数据合并的函数，后果他只答出了2个。 那么，到底是哪五个呢？明天，咱们就来带大家理解一下！ 目录： concatappendmergejoincombine总结 1. concatconcat是pandas中专门用于数据连贯合并的函数，性能十分弱小，反对纵向合并和横向合并，默认状况下是纵向合并，具体能够通过参数进行设置。 pd.concat(    objs: 'Iterable[NDFrame] | Mapping[Hashable, NDFrame]',    axis=0,    join='outer',    ignore_index: 'bool' = False,    keys=None,    levels=None,    names=None,    verify_integrity: 'bool' = False,    sort: 'bool' = False,    copy: 'bool' = True,) -> 'FrameOrSeriesUnion'在函数办法中，各参数含意如下： objs: 用于连贯的数据，能够是DataFrame或Series组成的列表 axis=0 : 连贯的形式，默认为0也就是纵向连贯，可选 1 为横向连贯 join='outer'：合并形式，默认为 inner也就是交加，可选 outer 为并集 ignore_index: 是否保留原有的索引 keys=None：连贯关系，应用传递的值作为一级索引 levels=None：用于结构多级索引 names=None：索引的名称 verify_integrity: 检测索引是否反复，如果为True则有反复索引会报错 sort: 并汇合并形式下，对columns排序 copy: 是否深度拷贝 接下来，咱们就对该函数性能进行演示 根底连贯 In [1]: import pandas as pdIn [2]: s1 = pd.Series(['a', 'b'])In [3]: s2 = pd.Series(['c', 'd'])In [4]: s1Out[4]: 0    a1    bdtype: objectIn [5]: s2Out[5]: 0    c1    ddtype: objectIn [6]: pd.concat([s1, s2])Out[6]: 0    a1    b0    c1    ddtype: objectIn [7]: df1 = pd.DataFrame([['a', 1], ['b', 2]],   ...:                     columns=['letter', 'number'])In [8]: df2 = pd.DataFrame([['c', 3], ['d', 4]],   ...:                     columns=['letter', 'number'])In [9]: pd.concat([df1, df2])Out[9]:   letter  number0      a       11      b       20      c       31      d       4横向连贯 In [10]: pd.concat([df1, df2], axis=1)Out[10]:   letter  number letter  number0      a       1      c       31      b       2      d       4默认状况下，concat是取并集，如果两个数据中有个数据没有对应行或列，则会填充为空值NaN。 合并交加 In [11]: df3 = pd.DataFrame([['c', 3, 'cat'], ['d', 4, 'dog']],    ...:                     columns=['letter', 'number', 'animal'])In [12]: df1Out[12]:   letter  number0      a       11      b       2In [13]: df3Out[13]:   letter  number animal0      c       3    cat1      d       4    dogIn [14]: pd.concat([df1, df3], join='inner')Out[14]:   letter  number0      a       11      b       20      c       31      d       4索引重置（不保留原有索引） In [15]: pd.concat([df1, df3], join='inner', ignore_index=True)Out[15]:   letter  number0      a       11      b       22      c       33      d       4# 以下形式和上述的输入后果等价In [16]: pd.concat([df1, df3], join='inner').reset_index(drop=True)Out[16]:   letter  number0      a       11      b       22      c       33      d       4指定索引 In [17]: pd.concat([df1, df3], keys=['df1','df3'])Out[17]:       letter  number animaldf1 0      a       1    NaN    1      b       2    NaNdf3 0      c       3    cat    1      d       4    dogIn [18]: pd.concat([df1, df3], keys=['df1','df3'], names=['df名称','行ID'])Out[18]:          letter  number animaldf名称 行ID                      df1  0        a       1    NaN     1        b       2    NaNdf3  0        c       3    cat     1        d       4    dog检测反复 如果索引呈现反复，则无奈通过检测，会报错 In [19]: pd.concat([df1, df3], verify_integrity=True)Traceback (most recent call last):...ValueError: Indexes have overlapping values: Int64Index([0, 1], dtype='int64')合并并集下columns排序 In [21]: pd.concat([df1, df3], sort=True)Out[21]:   animal letter  number0    NaN      a       11    NaN      b       20    cat      c       31    dog      d       4DataFrame与Series合并 In [22]: pd.concat([df1, s1])Out[22]:   letter  number    00      a     1.0  NaN1      b     2.0  NaN0    NaN     NaN    a1    NaN     NaN    bIn [23]: pd.concat([df1, s1], axis=1)Out[23]:   letter  number  00      a       1  a1      b       2  b# 新增列个别可选以下两种形式In [24]: df1.assign(新增列=s1)Out[24]:   letter  number 新增列0      a       1   a1      b       2   bIn [25]: df1['新增列'] = s1In [26]: df1Out[26]:   letter  number 新增列0      a       1   a1      b       2   b以上就concat函数办法的一些性能，相比之下，另外一个函数append也能够用于数据追加（纵向合并） 2. appendappend次要用于追加数据，是比较简单间接的数据合并形式。 df.append(    other,    ignore_index: 'bool' = False,    verify_integrity: 'bool' = False,    sort: 'bool' = False,) -> 'DataFrame'在函数办法中，各参数含意如下： other: 用于追加的数据，能够是DataFrame或Series或组成的列表 ignore_index: 是否保留原有的索引 verify_integrity: 检测索引是否反复，如果为True则有反复索引会报错 sort: 并汇合并形式下，对columns排序 接下来，咱们就对该函数性能进行演示 根底追加 In [41]: df1.append(df2)Out[41]:   letter  number0      a       11      b       20      c       31      d       4In [42]: df1.append([df1,df2,df3])Out[42]:   letter  number animal0      a       1    NaN1      b       2    NaN0      a       1    NaN1      b       2    NaN0      c       3    NaN1      d       4    NaN0      c       3    cat1      d       4    dogcolumns重置（不保留原有索引） In [43]: df1.append([df1,df2,df3], ignore_index=True)Out[43]:   letter  number animal0      a       1    NaN1      b       2    NaN2      a       1    NaN3      b       2    NaN4      c       3    NaN5      d       4    NaN6      c       3    cat7      d       4    dog检测反复 如果索引呈现反复，则无奈通过检测，会报错 In [44]: df1.append([df1,df2], verify_integrity=True)Traceback (most recent call last):...ValueError: Indexes have overlapping values: Int64Index([0, 1], dtype='int64')索引排序 In [46]: df1.append([df1,df2,df3], sort=True)Out[46]:   animal letter  number0    NaN      a       11    NaN      b       20    NaN      a       11    NaN      b       20    NaN      c       31    NaN      d       40    cat      c       31    dog      d       4追加Series In [49]: s = pd.Series({'letter':'s1','number':9})In [50]: sOut[50]: letter    s1number     9dtype: objectIn [51]: df1.append(s)Traceback (most recent call last):...TypeError: Can only append a Series if ignore_index=True or if the Series has a nameIn [53]: df1.append(s, ignore_index=True)Out[53]:   letter  number0      a       11      b       22     s1       9追加字典 这个在爬虫的时候比拟好使，每爬取一条数据就合并到DataFrame相似数据中存储起来 In [54]: dic = {'letter':'s1','number':9}In [55]: df1.append(dic, ignore_index=True)Out[55]:   letter  number0      a       11      b       22     s1       9 3. mergemerge函数办法相似SQL里的join，能够是pd.merge或者df.merge，区别就在于后者待合并的数据是 pd.merge(    left: 'DataFrame | Series',    right: 'DataFrame | Series',    how: 'str' = 'inner',    on: 'IndexLabel | None' = None,    left_on: 'IndexLabel | None' = None,    right_on: 'IndexLabel | None' = None,    left_index: 'bool' = False,    right_index: 'bool' = False,    sort: 'bool' = False,    suffixes: 'Suffixes' = ('_x', '_y'),    copy: 'bool' = True,    indicator: 'bool' = False,    validate: 'str | None' = None,) -> 'DataFrame'在函数办法中，要害参数含意如下： left: 用于连贯的左侧数据 right: 用于连贯的右侧数据 how: 数据连贯形式，默认为 inner，可选outer、left和right ...

明天咱们持续分享实在的自动化办公案例，心愿各位 Python 爱好者可能从中失去些许启发，在本人的工作生存中更多的利用 Python，使得工作事倍功半！ 需要因为工作当中常常须要比照前后两个 Excel 文件，文件内容比拟多，人工肉眼比照太吃力，还容易出错，搞个 Python 小工具，会不会事倍功半 运行脚本，能够把前后两个 Excel 文件当中不同的内容数据展示进去，不同 sheet 页签示意不同的数据处理后果 需要解析不须要解析，间接干 代码实现咱们先导入两份测试数据，进行 old 和 new 的解决，留神数据中 account number 是惟一索引 old = pd.read_excel('sample-address-1.xlsx', 'Sheet1', na_values=['NA'])new = pd.read_excel('sample-address-2.xlsx', 'Sheet1', na_values=['NA'])old['version'] = "old"new['version'] = "new" 对于咱们这个小工具，次要思考三种变动类型 哪些是新增的 account哪些是被删除的 account哪些是被批改的 account对于新增和删除的 account，咱们能够间接用两份数据相减即可 old_accts_all = set(old['account number'])new_accts_all = set(new['account number'])dropped_accts = old_accts_all - new_accts_alladded_accts = new_accts_all - old_accts_all 接下来咱们再将所有的数据拼接到一起，并应用 drop_duplicates 来保留被批改的数据 all_data = pd.concat([old,new],ignore_index=True)changes = all_data.drop_duplicates(subset=["account number",                                           "name", "street",                                           "city","state",                                           "postal code"], keep='last') 接下来，咱们须要找出哪些 account 有反复的条目，反复的 account 表明更改了咱们须要标记的字段中的值。咱们能够应用反复函数来获取所有这些 account 的列表，并仅过滤掉那些反复的 account dupe_accts = changes[changes['account number'].duplicated() == True]['account number'].tolist()dupes = changes[changes["account number"].isin(dupe_accts)]dupe_accts = changes[changes['account number'].duplicated() == True]['account number'].tolist()dupes = changes[changes["account number"].isin(dupe_accts)] 当初咱们将旧数据和新数据进行拆分，删除不必要的版本列并将 account 设置为索引 change_new = dupes[(dupes["version"] == "new")]change_old = dupes[(dupes["version"] == "old")]change_new = change_new.drop(['version'], axis=1)change_old = change_old.drop(['version'], axis=1)change_new.set_index('account number', inplace=True)change_old.set_index('account number', inplace=True)df_all_changes = pd.concat([change_old, change_new],                            axis='columns',                            keys=['old', 'new'],                            join='outer')df_all_changes 接下来咱们定义一个函数来展现从一列到另一列的变动 def report_diff(x):    return x[0] if x[0] == x[1] else '{} ---> {}'.format(*x)def report_diff(x):    return x[0] if x[0] == x[1] else '{} ---> {}'.format(*x)当初应用 swaplevel 函数来获取彼此相邻的旧列和新列 最初咱们应用 groupby 而后利用咱们自定义 report_diff 函数将两个相应的列互相比拟 df_changed = df_all_changes.groupby(level=0, axis=1).apply(lambda frame: frame.apply(report_diff, axis=1))df_changed = df_changed.reset_index()df_changed = df_all_changes.groupby(level=0, axis=1).apply(lambda frame: frame.apply(report_diff, axis=1))df_changed = df_changed.reset_index() 接下来咱们须要找出被删除和新增的数据 df_removed = changes[changes["account number"].isin(dropped_accts)]df_added = changes[changes["account number"].isin(added_accts)]df_removed = changes[changes["account number"].isin(dropped_accts)]df_added = changes[changes["account number"].isin(added_accts)]咱们能够应用独自的选项卡将所有内容输入到 Excel 文件，对应于更改、增加和删除 output_columns = ["account number", "name", "street", "city", "state", "postal code"]writer = pd.ExcelWriter("my-diff.xlsx")df_changed.to_excel(writer,"changed", index=False, columns=output_columns)df_removed.to_excel(writer,"removed",index=False, columns=output_columns)df_added.to_excel(writer,"added",index=False, columns=output_columns)writer.save()最初，咱们就失去了最开始的成果图片展现的一个新的 Excel 文件 当然下面的代码对于毫无编程的人来说还是有一点点简单，咱们还是做成 GUI 小程序吧，这次咱们应用 Tkinter 来编写 GUI 程序 ...

须要的！ 为什么呢，以 python 的第三方协程实现 eventlet 为例子 看上面的代码： from loguru import loggerimport eventlet# from eventlet.lock import Lock# eventlet.monkey_patch()var = 0def foo(i): global var if var < 10: eventlet.sleep(1) var += 1pool = eventlet.GreenPool()for body in pool.imap(foo, [i for i in range(100)]): passlogger.debug(f'最初的 {var}')输入后果： ╰─➤ time python -u "/Users/ponponon/Desktop/code/me/ideaboom/test_evenetlet/need_lock_with_sleep.py"2022-06-29 23:33:03.015 | DEBUG | __main__:<module>:23 - 最初的 100python -u 0.24s user 0.06s system 20% cpu 1.439 total应用了锁之后，就失常了 from loguru import loggerimport eventletfrom eventlet.lock import Lock# eventlet.monkey_patch()var = 0lock=Lock()def foo(i): global var with lock: if var < 10: eventlet.sleep(1) var += 1pool = eventlet.GreenPool()for body in pool.imap(foo, [i for i in range(100)]): passlogger.debug(f'最初的 {var}')输入后果： ...

from loguru import loggerimport threadingimport timefrom concurrent.futures import ThreadPoolExecutorpool = ThreadPoolExecutor(max_workers=100)var = 0lock=threading.Lock()def foo(): global var global lock with lock: if var < 10: time.sleep(2) # 模拟网咯 IO 操作，比方操作数据库，或者申请接口 var += 1for _ in range(100): pool.submit(foo) pool.shutdown(wait=True) # 期待所有工作执行结束logger.debug(f'最初的 {var}')很简略，在提交完工作之后，只用 pool.shutdown(wait=True) 期待所有工作执行结束 对于 wait 参数，能够看官网的代码正文： def shutdown(self, wait=True, *, cancel_futures=False): """Clean-up the resources associated with the Executor. It is safe to call this method several times. Otherwise, no other methods can be called after this one. Args: wait: If True then shutdown will not return until all running futures have finished executing and the resources used by the executor have been reclaimed. cancel_futures: If True then shutdown will cancel all pending futures. Futures that are completed or running will not be cancelled. """ passIf True then shutdown will not return until all running futures have finished executing and the resources used by the executor have been reclaimed.翻译一下就是： ...

其实，编程中用到的英文词汇并不多，常常用到的写着写着就记住了。大多数时候只有给变量或者对象起名的时候才会去Google上查。于是，我将常常在coding中用到的词汇总结了一下。 【浏览全文】 A字母结尾的英文词汇 Appearance表面assert/assertion异样add增加append附加args/argument参数attribute属性 B字母结尾的英文词汇 byte字节bool布尔类型Bug故障(虫子)break冲破/跳出 C字母结尾的英文词汇 cmd/commond命令close敞开colum列char字符型class类create创立continue持续case情景capitalize用大写字母写或印刷copy复制clear革除coding编码character字符count计数 D字母结尾的英文词汇 demo演示division除法downloads下载define定义decode解码depth深度default默认dict字典difference差数discord抛弃del,delete删除data数据 E字母结尾的英文词汇 exception异样Editor编辑exit退出extends继承,延长,推广encode编码even偶数execute执行expression表达式extend扩大error谬误end完结 F字母结尾的英文词汇 finally最初float浮点型factorial阶乘flush冲刷find查找False假function办法/函数format格式化file文件 G字母结尾的英文词汇 global全局变量group组 H字母结尾的英文词汇 height高度 I字母结尾的英文词汇 int整型Interpret解释install装置instance实例,状况indentation缩进ignore case疏忽 大小写inside外部info信息Infinite无穷import导入item项intersection相交insert插入input输出invalid有效identifier名称/标识符iterable可迭代对象index索引 K字母结尾的英文词汇 kwargs关键字参数key键 L字母结尾的英文词汇 Local部分作用域long长整形== login==登录list列表lower上面 M字母结尾的英文词汇 main次要的match匹配missing失落module模块mapping映射max最大min最小 O字母结尾的英文词汇 outside内部object对象 P字母结尾的英文词汇 private公有的public公共的,专用的perimeter周长params参数power幂positional地位prompt提醒pop取出path门路project我的项目print打印输出 R字母结尾的英文词汇 rename 重命名result后果row行random随机的run跑，运行reset从新设置radius半径regular规定recursion递归required必须range范畴remove移除reverse反向replace替换 S字母结尾的英文词汇 scripts脚本self本身search查找salary薪水switch判断语句string字符串类型successful胜利search查问square平方system零碎step步长sep/separate分隔seq/sequence序列swap调换subset子集sub从属superset父集/超集symmetric对称set汇合settings设置sort排序strip去除syntax语法start开始 T字母结尾的英文词汇try尝试type类型test测试True真tuple元组title题目 Z字母结尾的英文词汇 zip解压 U字母结尾的英文词汇 unexpected不冀望的unicode万国码unsupported不反对union联结update更新upper下面 V字母结尾的英文词汇 variables变量version版本void空的,没有返回值的volume体积union联结value值 W字母结尾的英文词汇 windows窗口width宽度weight分量 【往期精彩】 数据荡涤工具flashtext，效率间接晋升了几十倍数！ 一个help函数解决了python的所有文档信息查看... python 自定义异样/raise关键字抛出异样 python 本地音乐播放器制作过程（附残缺源码） 自动化工具：PyAutoGUI的鼠标与键盘管制，解放双手的利器！

介绍编程语言为Python，基于机器学习库TensorFlow构建网络模型，通过对2507张各类垃圾图片作为数据集进行解决，应用VGG16网络进行模型训练，实现对“纸板”，“玻璃”，“金属”，“纸”，“塑料”，“垃圾桶”的辨认。 技术点Python3TensorFlow2DjangoVGG16网络模型演示视频：https://www.bilibili.com/vide...分割V：sql2201 展现

class AddService: name = 'add_service' @event_handler('productor_service', 'a') @event_handler('productor_service', 'b') def handle_message(self, payload: str): logger.debug(f'handle_message {payload}') @rpc @context_id_dec def add(self, a: int, b: int, /, context_id: str) -> int | None: try: logger.debug(f'收到一个加法计算申请：{a},{b},{asgi_context_id.get()}') # time.sleep(1000) return a+b except Exception as error: logger.exception(error) return None @http('GET', '/hi') def hi(self, request): return "hello world" @http('GET', '/ha') def ha(self, request): time.sleep(10) return 'ok'nameko run services:AddService --config ./config.yaml 应用该命令，发现只有一个连贯： class TrashCanService: name = 'trash_scan_service' @event_handler('hi_api', 'rubbish') def receive(self, message: str): logger.debug(f'开始生产音讯, {message}') response = requests.get('http://127.0.0.1:50010') logger.debug(f'{message}, {response.text}') receive.create_queue_only = True @event_handler('drop_throw_rubbish_service', 'drop_rubbish') def receive_by_rpc(self, message: str): passclass AddService: name = 'add_service' @event_handler('productor_service', 'a') @event_handler('productor_service', 'b') def handle_message(self, payload: str): logger.debug(f'handle_message {payload}') @rpc @context_id_dec def add(self, a: int, b: int, /, context_id: str) -> int | None: try: logger.debug(f'收到一个加法计算申请：{a},{b},{asgi_context_id.get()}') # time.sleep(1000) return a+b except Exception as error: logger.exception(error) return None @http('GET', '/hi') def hi(self, request): return "hello world" @http('GET', '/ha') def ha(self, request): time.sleep(10) return 'ok'然而这样，两个服务，一共两个 amqp 连贯： ...

不能哦！ from loguru import loggerimport gevent# from gevent import monkey# monkey.patch_all()import eventleteventlet.monkey_patch()def foo(i): gevent.sleep(1)pool = eventlet.GreenPool()for body in pool.imap(foo, [i for i in range(2)]): print("got body", body)运行后果： ╰─➤ time python eventlet_with_gevent_sleep.py got body Nonegot body Nonepython eventlet_with_gevent_sleep.py 0.39s user 0.05s system 17% cpu 2.515 total能够看到，一共耗费了 2 秒多 from loguru import loggerimport gevent# from gevent import monkey# monkey.patch_all()import eventleteventlet.monkey_patch()def foo(i): eventlet.sleep(1)pool = eventlet.GreenPool()for body in pool.imap(foo, [i for i in range(2)]): print("got body", body)运行后果： ...

import requestsfrom loggers import loggerimport multiprocessingdef func(): try: for i in range(1): response = requests.get( 'http://localhost:63000/') print(response.status_code, response.text) except Exception as error: logger.exception(error)if __name__ == "__main__": pool = multiprocessing.Pool(processes=56) for i in range(100000): pool.apply_async(func) pool.join()要提交工作的时候，有几个货色能够用： applyapply_asyncmapmap_asyncapply 和 map 不能并行，所以毫无用处 apply_async 和 map_async 有什么区别？ map_async 一次只能穿一个参数，所有没有用理论用途apply_async 能够一次传多个参数，所以最有用 参考资料：apply_async

本教程将疏导你学会装置、配置和运行 Nox。 装置Nox 能够通过pip轻松装置： python3 -m pip install nox你可能心愿应用用户站点(user site)来防止对全局的 Python install 造成凌乱： python3 -m pip install --user nox或者，你也能够更粗劣，应用pipx： pipx install nox无论用哪种形式，Nox 通常是要全局装置的，相似于 tox、pip和其它相似的工具。 如果你有趣味在docker 内运行 nox，能够应用 DockerHub 上的thekevjames/nox镜像，它蕴含所有 nox 版本的构建与及所有反对的 Python 版本。 如果你想在GitHub Actions中运行 nox ，则能够应用Activatedleigh/setup-nox action，它将装置最新的 nox，并令 GitHub Actions 环境提供的所有 Python 版本可用。 编写配置文件Nox 通过我的项目目录中一个名为 noxfile.py 的文件作配置 。这是一个 Python文件，定义了一组会话（sessions）。一个会话是一个环境和一组在这个环境中运行的命令。如果你相熟 tox，会话就相似于它的环境。如果你相熟 GNU Make，会话则相似于它的 target。 会话应用 @nox.session 装璜器作申明。这形式相似于 Flask 应用 @app.route。 上面是一个根本的 Nox 文件，对 example.py 运行flake8（你能够本人创立example.py）： import nox@nox.sessiondef lint(session): session.install("flake8") session.run("flake8", "example.py")第一次运行 Nox当初，你曾经装置了 Nox 并领有一个配置文件， 那就能够运行 Nox 了！在终端中关上我的项目的目录，而后运行nox 。你应该会看到相似这样的内容： ...

内容 正告正告正告摘要动机为什么这很难？背景对于“Decorator”名称设计指标以后语法语法的抉择装璜器地位语法模式为什么是@？以后实现与历史社区共识例子（不再是）未决问题参考资料版权正告正告正告本文档旨在形容装璜器语法和做出决定的过程。它既不试图涵盖大量潜在的代替语法，也不试图详尽列出每种模式的所有长处和毛病。 摘要以后用于转换函数和办法的形式（例如，将它们申明为类或静态方法）很蠢笨，并且可能导致难以了解的代码。在现实的状况下，这些转换应该在代码中作申明的地位进行。本 PEP 引入了对函数或办法申明作转换的新语法。 动机以后对函数或办法作变换的形式会把理论的变换置于函数体之后。对于大型函数，这会将函数行为的要害组成部分与其余的函数内部接口的定义离开。例如： def foo(self): perform method operationfoo = classmethod(foo)对于较长的办法，这变得不太可读。在概念上只是申明一个函数，应用其名称三遍就很不 pythonic。此问题的解决方案是将办法的转换移到办法自身的申明左近。新语法的用意是替换 def foo(cls): passfoo = synchronized(lock)(foo)foo = classmethod(foo)成为一种将装璜符搁置在函数的申明中的写法： @classmethod@synchronized(lock)def foo(cls): pass以这种形式来批改类也是可能的，只管益处不能立刻体现。简直能够必定，应用类装璜器能够实现的任何事件都能够应用元类来实现，然而应用元类十分艰涩，所以就有吸引力找到一种对类进行简略批改的更简便的办法。对于 Python 2.4 来说，仅增加了函数/办法装璜器。 PEP 3129 （译注：译文在此） 提议从 Python 2.6 开始增加类装璜器。 为什么这很难？自 2.2 版本以来，Python 中提供了两个装璜器（classmethod() 和 staticmethod() ）。大概从那时起，就曾经假如最终会在语言中增加对它们的一些语法反对。既然有了此假如，人们可能想晓得为什么还会很难达成共识。 在 comp.lang.python 和 python-dev 邮件列表中，对于如何最好地实现函数装璜器的探讨，时不时就会开展。没有一个明确的辩论理由，然而如下问题看起来一致最大。 对于“用意的申明”搁置何处的一致。简直所有人都批准，在函数定义的开端装璜/转换函数不是最佳的。除此之外，仿佛没有明确的共识将这些信息放在何处。语法束缚。Python 是一种语法简略的语言，除开“捣鬼”（无论从表面上还是思考到语言解析器），对能够实现和不能实现的事件都有相当严格的束缚。没有显著的办法来组织这些信息，以便刚接触该概念的人们会想：“哦，是的，我晓得你在做什么。” 看起来最好的方法就是避免新用户对语法的含意造成谬误的心智模型。总体上不相熟该概念。对于那些相熟代数（或者只是根本算术）或至多应用过其它编程语言的人来说，Python 的大部分内容都是合乎直觉的。但在 Python 中遇到装璜器概念之前，很少有人会接触到这个概念。没有一个很强的先验模因（preexisting meme）能蕴含这个概念。语法上的探讨所取得的关注，大体上超过了所有其它货色所取得的关注。读者能够看到的三元运算符探讨，与PEP 308相干，也是这样的例子。背景人们广泛批准，装璜器语法对于以后而言是可取的。Guido 在第十届Python大会 [3] 的 DevDay 主题演讲中提到了对装璜器的语法反对[2]，只管他起初说[5]，这只是他“半开玩笑”提议的几种扩大之一。会议完结后不久，Michael Hudson 在 python-dev 上提出了主题[4]，将最后的括号语法归因于Gareth McCaughan [6] 先前在 comp.lang.python 上的提议。 类装璜器仿佛是不言而喻的下一步，因为类定义和函数定义在语法上类似，然而 Guido 依然有疑虑，类装璜器简直必定不会在 Python 2.4 中呈现。 ...

本文想针对测试中一种很常见的测试场景，即参数化测试，持续聊聊对于测试的话题，并尝试将这几个测试框架串联起来，做一个横向的比对，加深了解。 1、什么是参数化测试？对于一般测试来说，一个测试方法只须要运行一遍，而参数化测试对于一个测试方法，可能须要传入一系列参数，而后进行屡次测试。 比方，咱们要测试某个零碎的登录性能，就可能要别离传入不同的用户名与明码，进行测试：应用蕴含非法字符的用户名、应用未注册的用户名、应用超长的用户名、应用谬误的明码、应用正当的数据等等。 参数化测试是一种“数据驱动测试”（Data-Driven Test），在同一个办法上测试不同的参数，以笼罩所有可能的预期分支的后果。它的测试数据能够与测试行为拆散，被放入文件、数据库或者内部介质中，再由测试程序读取。 2、参数化测试的实现思路？通常而言，一个测试方法就是一个最小的测试单元，其性能应该尽量地原子化和单一化。 先来看看两种实现参数化测试的思路：一种是写一个测试方法，在其外部对所有测试参数进行遍历；另一种是在测试方法之外写遍历参数的逻辑，而后顺次调用该测试方法。 这两种思路都能达到测试目标，在简略业务中，没有故障。然而，实际上它们都只有一个测试单元，在统计测试用例数状况，或者生成测试报告的时候，并不乐观。可扩展性也是个问题。 那么，现有的测试框架是如何解决这个问题的呢？ 它们都借助了装璜器，次要的思路是：利用原测试方法（例如 test()），来生成多个新的测试方法（例如 test1()、test2()……），并将参数顺次赋值给它们。 因为测试框架们通常把一个测试单元统计为一个“test”，所以这种“由毕生多”的思路相比后面的两种思路，在统计测试后果时，就具备很大的劣势。 3、参数化测试的应用办法？Python 规范库中的unittest本身不反对参数化测试，为了解决这个问题，有人专门开发了两个库：一个是ddt，一个是parameterize。 ddt 正好是“Data-Driven Tests”（数据驱动测试）的缩写。典型用法： import unittestfrom ddt import ddt,data,unpack@ddtclass MyTest(unittest.TestCase): @data((3, 1), (-1, 0), (1.2, 1.0)) @unpack def test_values(self, first, second): self.assertTrue(first > second)unittest.main(verbosity=2)运行的后果如下： test_values_1__3__1_ (__main__.MyTest) ... oktest_values_2___1__0_ (__main__.MyTest) ... FAILtest_values_3__1_2__1_0_ (__main__.MyTest) ... ok==================================================FAIL: test_values_2___1__0_ (__main__.MyTest)--------------------------------------------------Traceback (most recent call last): File "C:\Python36\lib\site-packages\ddt.py", line 145, in wrapper return func(self, *args, **kwargs) File "C:/Users/pythoncat/PycharmProjects/study/testparam.py", line 9, in test_values self.assertTrue(first > second)AssertionError: False is not true----------------------------------------------Ran 3 tests in 0.001sFAILED (failures=1)结果显示有 3 个 tests，并具体展现了运行状态以及断言失败的信息。 ...

这篇文章会提供一些优化代码的工具。会让代码变得更简洁，或者更迅速。 当然这些并不能代替算法设计，然而还是能让Python减速很多倍。 其实后面讲算法的文章，也有提到过。比方实用于双向队列的 deque，以及在适合的条件下使用 bisect 和 heapq 来晋升算法的性能。 而且后面也提到过，Python提供了当今最高级也是最无效的排序算法(list.sort)。 另外还有一个性能多样又迅速的散列表(dict)。而且如果写迭代器封装、功能性代码或者是某种额定扩大的时候，或者 CyToolz能够用失去。当然在itertools和 functools模块 中，还有很多函数能够带来很高效的代码。 这篇文章次要讲优化单处理器的代码，上面会介绍一些一些高效的函数实现，也有曾经封装好的拓展模块，还包含速度更快的Python解释器。 当然多处理器版本的确能大幅提高运行效率。如果想理解多核编程，能够从multiprocessing模块开始。而且也能找到十分多的对于分布式计算的第三方工具。这里能够看一下Python wiki上的对于Parallel Processing的内容。 接下来，会说一些对于Python减速工具的选单。 1.NumPy、SciPy、Sage和Pandas先说，NumPy。它的外围是一个多维数字数组的实现。除了这个数据结构之外，还实现了若干个函数和运算符，能够高效地进行数组运算。并且对于被调用的次数进行了精简。它能够被用来进行极其高效的数学运算。 SciPy和Sage都将NumPy内置为本身的一部分，同时内置了其余的不同的工具，从而能够用于特定迷信、数学和高性能计算的模块。 Pandas是一个侧重于数据分析的工具。如果解决大量半结构化数据的时候，可能也会用到Pandas相干的工具，比方Blaze。 2.PyPy、Pyston、Parakeet、Psyco和Unladen Swallow让代码运行的更快，侵入性最小的就是应用实时编译器(JIT编译)。以前的话咱们能够间接装置Psyco。装置之后导入psyco，而后调用psyco.full()。代码运行速度就能够显著晋升。运行Python代码的时候，它能够实时监控程序，会将一部分代码编译为了机器码。 当初好多Psyco等加速器的我的项目曾经进行保护了，不过相似的性能在PyPy中失去了继承。 PyPy为了不便剖析、优化和翻译，用Python语言将Python从新实现了一遍，这样就能够JIT编译。而且PyPy能够间接将代码翻译成像C那样的性能更高的语言。 Unladen Swallow是一个Python的JIT编译器。是Python解释器的一本版本，被称为底层虚拟机(LLVM)。不过这个开发曾经进行了。 Pyston是一个与LLVM平台较为靠近的Python的JIT编译器。很多时候曾经优于Python的实现，但不过还有很多中央不欠缺。 3.GPULib、PyStream、PyCUDA和PyOpenCL这四个都是用在图像处理单元来实现代码的减速。后面讲的都是用代码优化来实现减速的。而这些都是从硬件层面上进行减速，如果有一个弱小的GPU，咱们能够用GPU来计算，从而缩小CPU贵重的资源。 PyStream古老一点。GPULib提供了基于GPU的各种模式的数据计算。 如果用GPU减速本人的代码，能够用PyCUDA和PyOpenCL。 4.Pyrex、Cython、Numba和Shedskin这四个我的项目都致力于将Python代码翻译为C、C++和LLVM的代码。Shedskin会将代码编译为C++语言。Pyrex、Cython编译的次要指标是C语言。Cython也是Pyrex的一个分支。 而且，Cython还有NumPy数组的额定反对。 如果面向数组和数学计算的时候，Numba是更好的抉择导入时会主动生成相应的LLVM的代码。降级版本是NumbaPro，还提供了对GPU的反对。 5.SWIG、F2PY和Boost.Python这些工具能够将其余的语言封装为Python的模块。第一个能够封装C/C++语言。F2PY能够封装Fortran。Boost.Python能够封装C++语言。 SUIG只有启动一个命令行工具，往里面输出C或者C++的头文件，封装器代码就会主动生成。除了Python，而且能够成为其余语言的封装器，比方Java和PHP。 6.ctypes、llvm-py和CorePy2这些模块能够帮忙咱们实现Python底层对象的操作。ctypes模块能够用于在内存中构建编译C的对象。并且调用共享库中的C的函数。不过ctypes曾经蕴含在Python的规范库外面了。 llvm-py次要提供LLVM的Python接口。以便于构建代码，而后编译他们。也能够在Python中构建它的编译器。当然搞出本人编程语言也是能够的。 CorePy2也能够进行减速，不过这个减速是运行在汇编层的。 7.Weave、Cinpy和PyInline这三个包，就能够让咱们在Python代码中间接应用C语言或者其余的高级语言。混合代码，仍然能够放弃整洁。能够应用Python代码的字符串的多行个性，能够使其余的代码依照本身的格调来进行排版。 8.其余工具如果咱们要节俭内存，就不能应用JIT了。个别JIT都太消耗内存。有一句话说的很对，工夫和内存常常不能兼得，而咱们在工程开发中，总是要寻找他们的平衡点。 至于其余的一些货色，比方Micro Python我的项目，这个是用在嵌入式设施或者微控制器下面应用的。 如果只是想在Python环境中工作，而后想用别的语言，能够看看这个我的项目Julia。 以上就是本次分享的所有内容，想要理解更多 python 常识欢送返回公众号：Python 编程学习圈 ，发送 “J” 即可收费获取，每日干货分享

文件是无处不在的，无论咱们应用哪种编程语言，解决文件对于每个程序员都是必不可少的 文件解决是一种用于创立文件、写入数据和从中读取数据的过程，Python 领有丰盛的用于解决不同文件类型的包，从而使得咱们能够更加轻松不便的实现文件解决的工作 本文纲要： 应用上下文管理器关上文件Python 中的文件读取模式读取 text 文件读取 CSV 文件读取 JSON 文件Let's go！ 关上文件在拜访文件的内容之前，咱们须要关上文件。Python 提供了一个内置函数能够帮忙咱们以不同的模式关上文件。open() 函数承受两个基本参数：文件名和模式 默认模式是“r”，它以只读形式关上文件。这些模式定义了咱们如何拜访文件以及咱们如何操作其内容。open() 函数提供了几种不同的模式，咱们将在前面逐个探讨 上面咱们通过 ’Python 之禅‘ 文件来进行前面的探讨学习 f = open('zen_of_python.txt', 'r')print(f.read())f.close()Output: The Zen of Python, by Tim PetersBeautiful is better than ugly.Explicit is better than implicit.Simple is better than complex.Complex is better than complicated.Flat is better than nested.Sparse is better than dense.Readability counts....在下面的代码中，open() 函数以只读模式关上文本文件，这容许咱们从文件中获取信息而不能更改它。在第一行，open() 函数的输入被赋值给一个代表文本文件的对象 f，在第二行中，咱们应用 read() 办法读取整个文件并打印其内容，close() 办法在最初一行敞开文件。须要留神，咱们必须始终在解决完关上的文件后敞开它们以开释咱们的计算机资源并防止引发异样 在 Python 中，咱们能够应用 with 上下文管理器来确保程序在文件敞开后开释应用的资源，即便产生异样也是如此 with open('zen_of_python.txt') as f:    print(f.read())Output: The Zen of Python, by Tim PetersBeautiful is better than ugly.Explicit is better than implicit.Simple is better than complex.Complex is better than complicated.Flat is better than nested.Sparse is better than dense.Readability counts....下面的代码应用 with 语句创立了一个上下文，并绑定到变量 f ，所有文件对象办法都能够通过该变量拜访文件对象。read() 办法在第二行读取整个文件，而后应用 print() 函数输入文件内容 ...