pyt

二维FFT常用在图像处理上，首先要能理解二维FFT的意义，否则很难明白它到底是怎么工作的。 第一列是原图和对应的频率信息，第二列是去除低频部分后，FFT逆变换得到的图像。第三列是去除高频部分后FFT逆变换得到的图像。 从第二列可以看出高频贡献了图像的细节。从白到黑的边界保留了下来。而原图中大片的白与大片的黑在这个图中没什么区别。 第三列中保留了原图中的亮部与灰部，而由黑到白的临界线却很模糊。细小的白线黑线也没能显示。所以低频贡献了图像的明暗。 2.工作原理理解 二维FFT就是先对行做次一维FFT，这样每个元素都是关于行频率信息了，然后再对列做一维FFT,这样每个元素都包含了行和列的频率信息。每个元素都是个复数，取绝对值可得到振幅，从实部与虚部的比值可等到相位，在二维矩阵的位置信息包含了频率大小和方向。方向在一维FFT中是不用考虑的。 FFT2的结果也是正频率从0到高然后负频率从高到0.fftshift()之后会将低频放到中间位置。 第一幅图的频谱是中间一条白线，也就是说许多个正弦波沿横向传播。纵向上没有变化。 第三幅图的频谱是十字形加一条从左下角到右上角的直线。说明原图在横向，纵向都有变化，变化的方向从左下角到右上角。 从中心到频谱图上某一点构成的向量方向就是这个波传播的方向。 正负对称才能消除虚部，这点与一维FFT原理一致。

自定义函数求解即可，参考代码如下：def f_sigma(x): # 通过Python定义一个计算变量波动率的函数 # x：代表变量的样本值，可以用列表的数据结构输入 n = len(x) u_mean = sum(x)/n #计算变量样本值的均值 z = [] #生成一个空列表 for t in range(n): z.append((x[t]-u_mean)**2) return (sum(z)/(n-1))**0.5 # n-1 自由度a = f_sigma(x = [1,2,3])print("样本方差：", a)

1、robots协议是一种存放于网站根目录下的ASCII编码的文本文件。用于对外宣誓主权，规定按照允许范畴访问网站，有效保护网站的隐私。所以您想通过技术手段访问网站的时候，请首先查看robots.txt文件，它告诉你哪些可以访问，哪些信息是不允许访问的。（Robots协议是国际互联网界通行的道德规范） 2、robots主要涉及以下三个部分：第一种：禁止所有搜索引擎访问网站的任何内容 User-agent: * Disallow: / 第二种：禁止某个特定的搜索引擎访问网站的任何内容 User-agent: Baiduspider Disallow: / 第三种：允许所有搜索引擎访问网站的任何内容 User-agent: * Allow:　/ 第四种：禁止部分内容被访问(tmp目录及下面的内容都禁止了） User-agent: * Disallow: /tmp 第五种：允许某个搜索引擎的访问 User-agent: Baiduspider allow:/ 第六种：部分允许，部分不允许访问 User-agent: Baiduspider Disallow: /tmp/bin User-agent:* allow:/tmp 希望以上总结对您有帮助！！！！！

就是一个while循环，产生随机数，不停的获取输入，判断大小，对了就加分，错了就减分，达到条件了就退出循环，输出，结束

python基础知识

接受自己的普通，然后全力以赴的出众，告诉自己要努力，但不要着急.... 当然， 这个结果并不是我真正想要的，Pass, 太丑了！ 好吧，安排，我们先看下实现后的效果！ 这个效果自然就比之前的好多了！ 实现python散点图绘制需要用到matplotlib库， matplotlib库是专门用于可视化绘图的工具库；学习一个新的库当然看官方文档了： https://www.osgeo.cn/matplotlib/contents.html 实现思路： matplotlib.pyplot.scatter() 函数是专门绘制散点图的函数： https://www.osgeo.cn/matplotlib/api/_as_gen/matplotlib.pyplot.scatter.html?highlight=scatter#matplotlib.pyplot.scatter matplotlib.pyplot.scatter ( x, y , s=None , c=None , marker=None , cmap=None , norm=None , vmin=None , vmax=None , alpha=None , linewidths=None , verts=None , edgecolors=None , ***, data=None , ** kwargs ) ** plt.scatter(observation, estimate, c=Z1, cmap=colormap, marker=".", s=marker_size, norm=colors.LogNorm(vmin=Z1.min(), vmax=0.5 * Z1.max())) 其中： 1、c参数为计算的散点密度； 2、cmap为色带（matplotlib里面自带了很多色带可供选择）,参见： https://www.osgeo.cn/matplotlib/gallery/color/colormap_reference.html 3、由于计算的散点密度数值大小分散，因此利用norm参数对散点密度Z1进行归一化处理(归一化方式很多，参见colors类)，并给归一化方式设置色带刻度的最大最小值vmin和vmax(一般这两个参数就是指定散点密度的最小值和最大值)，这样就建立起了密度与色带的映射关系。 https://matplotlib.org/tutorials/colors/colormapnorms.html （这里的结果与前面展示的相比改变了计算散点密度的半径：radius = 3以及绘制散点图的散点大小marksize） 作者能力水平有限，欢迎各位批评指正！

首先，scatter表示散点图。其次plt.cm中cm全称表示colormap，最后paired表示两个两个相近色彩输出，比如浅蓝、深蓝；浅红、深红；浅绿，深绿这种。

下面是文档中对scatter的参数c的说明： c : color, sequence, or sequence of color, optional, default: ‘b"c can be a single color format string, or a sequence of color specifications of length N, or a sequence of N numbers to be mapped to colors using the cmap and norm specified via kwargs (see below). Note that c should not be a single numeric RGB or RGBA sequence because that is indistinguishable from an array of values to be colormapped. c can be a 2-D array in which the rows are RGB or RGBA, however, including the case of a single row to specify the same color for all points. 可见可以传入一个序列（list之类的）

Python中scatter函数参数详解

参见http://matplotlib.org/api/colors_api.htmlplt.scatter的c接受（r,g,b）形式的值只限于里面每个值都小于1的情况，即r<1,g<1,b<1大的值，（255,145,43），可以如下转换：hex(255)=0xff,hex(145)=0x91,hex(43)=0x2b,所以（255,145,43）对应的颜色是#ff912bc="#ff912b"

点的大小吧。

下面是文档中对scatter的参数c的说明： c : color, sequence, or sequence of color, optional, default: ‘b"c can be a single color format string, or a sequence of color specifications of length N, or a sequence of N numbers to be mapped to colors using the cmap and norm specified via kwargs (see below). Note that c should not be a single numeric RGB or RGBA sequence because that is indistinguishable from an array of values to be colormapped. c can be a 2-D array in which the rows are RGB or RGBA, however, including the case of a single row to specify the same color for all points. 可见可以传入一个序列（list之类的）

归一化用fit_transform（）数据还原用inverse_transform（）

大数据！大数据！其实是离不开数据二字，但是总体来讲，自己之前对数据的认知是不太够的，更多是在关注技术的提升上。换句话讲，自己是在做技术，这些技术处理的是数据，而不能算是自己是在做数据的。大规模数据的处理是一个非常大的课题，但是这一点更偏向于是搞技术的。与数据分析相关的Python库很多，比如Numpy、pandas、matplotlib、scipy等，数据分析的操作包括数据的导入和导出、数据筛选、数据描述、数据处理、统计分析、可视化等等。接下来我们看一下如何利用Python完成数据的分析。生成数据表常见的生成方法有两种，第一种是导入外部数据，第二种是直接写入数据，Python支持从多种类型的数据导入。在开始使用Python进行数据导入前需要先导入pandas库，为了方便起见，我们也同时导入Numpy库。代码是最简模式，里面有很多可选参数设置，例如列名称、索引列、数据格式等等。检查数据表Python中使用shape函数来查看数据表的维度，也就是行数和列数。你可以使用info函数查看数据表的整体信息，使用dtypes函数来返回数据格式。Isnull是Python中检验空值的函数，你可以对整个数据表进行检查，也可以单独对某一列进行空值检查，返回的结果是逻辑值，包含空值返回True，不包含则返回False。使用unique函数查看唯一值，使用Values函数用来查看数据表中的数值。数据表清洗Python中处理空值的方法比较灵活，可以使用Dropna函数用来删除数据表中包含空值的数据，也可以使用fillna函数对空值进行填充。Python中dtype是查看数据格式的函数，与之对应的是astype函数，用来更改数据格式，Rename是更改列名称的函数，drop_duplicates函数删除重复值，replace函数实现数据替换。数据预处理数据预处理是对清洗完的数据进行整理以便后期的统计和分析工作，主要包括数据表的合并、排序、数值分列、数据分组及标记等工作。在Python中可以使用merge函数对两个数据表进行合并，合并的方式为inner，此外还有left、right和outer方式。使用ort_values函数和sort_index函数完成排序，使用where函数完成数据分组，使用split函数实现分列。数据提取主要是使用三个函数：loc、iloc和ix，其中loc函数按标签值进行提取，iloc按位置进行提取，ix可以同时按标签和位置进行提取。除了按标签和位置提起数据以外，还可以按具体的条件进行数据，比如使用loc和isin两个函数配合使用，按指定条件对数据进行提取。数据筛选汇总Python中使用loc函数配合筛选条件来完成筛选功能，配合sum和 count函数还能实现excel中sumif和countif函数的功能。Python中使用的主要函数是groupby和pivot_table。groupby是进行分类汇总的函数，使用方法很简单，制定要分组的列名称就可以，也可以同时制定多个列名称，groupby 按列名称出现的顺序进行分组。

最近碰到pytorch分布式训练时候，memory几乎线性增加，撑炸机器的问题。 pytorch中内存泄漏常见的原因大概是以下几点： 有时候可能会遇到不同的问题，具体问题可以通过python的内存分析工具做分析（不过讲道理不是太管用）比如： https://www.pythonf.cn/read/108519 ， https://zhuanlan.zhihu.com/p/121003986 我的心情随着第一个github的issue答案起起伏伏，试了几遍都不行，然后忽然想到，这些bug官方都回复修了，怎么还能有问题呢…然后转头把sagemaker上pytorch的版本从1.6降到了1.5，世界安静了… 最近一天一个bug，踩坑美滋滋

Happy Teenage 翻译为：快乐少年与快乐童年的意思相似希望对你有帮助

font = ImageFont.truetype("arial.ttf",36) #注意是小写

下面的是网络上找到的python的布隆过滤器的实现. #!/usr/local/bin/python2.7#coding=gbk"""Created on 2012-11-7@author: palydawn"""import cmathfrom BitVector import BitVectorclass BloomFilter(object): def

import randomwords = ("good", "wonderful", "test", "something", "python", "game")game_count = 0success_count = 0game_over = Falseprint("Game Starts")while not game_over: game_count += 1 #游戏次数 print("第%d轮" % game_count) print("-------------") word = random.choice(words) #随机选择一个单词 char_count = len(word) #计算单词的字母个数 poses = [] #保存提示字母的位置 i = 0 #提示次数 success = False while i < char_count: #如果单词的所有字母位置都提示了，仍没有猜对，直接失败 pos = random.randint(0, char_count - 1) #随机取一个字母 while pos in poses: #如果这个字母已经提示过了，就换一个 pos = random.randint(0, char_count - 1) poses.append(pos) i += 1 print("提示：第%d个字母是%s" % (pos + 1, word[pos])) guess = input("请输入答案：") if guess == "quit": game_over = True break elif guess == "?": pass else: if guess[1:] == word: success_count += 1 success = True break if success: print("恭喜，猜对了") else: print("遗憾，猜错了")print("Game Over")print("共猜单词%d个，正确%d个，错误%d个" % (game_count, success_count, game_count - success_count))

1.安装tesseract2.安装PyOCR3.安装Wand和PIL在我们开始之前，还需要另外安装两个依赖包。一个是Wand。它是Imagemagick的Python接口。我们需要使用它来将PDF文件转换成图像：我们也需要PIL因为PyOCR需要使用它。你可以查看官方文档以确定如何将PIL安装到你的操作系统中。5.开始现在我们需要获得OCR库（在本例中，即tesseract）的句柄以及我们在PyOCR中将使用的语言：我们使用tool.get_available_languages里的第二种语言，因为之前我曾尝试过，第二种语言就是英语。接着，我们需要建立两个列表，用于存储我们的图像和最终的文本。下一步，我们需要采用wand将一个PDF文件转成jpeg文件。让我们试一试吧！注意：将PDF_FILE_NAME替换成当前路径下的一个可用的PDF文件名。wand已经将PDF中所有的独立页面都转成了独立的二进制图像对象。我们可以遍历这个大对象，并把它们加入到req_image序列中去。现在，我们仅仅需要在图像对象上运行OCR即可，非常简单：现在，所有识别出的文本已经加到了final_text序列中了。你可以任意地使用它。以上就是利用Python对PDF文件做OCR识别的全部内容，希望这个教程能够帮助到你们！

还没有人吗？我也想知道啊~

要看你在什么操作系统、要播什么格式的音乐了。

plt.subplot中的三个参数表示几行、几列，和该图占第几个位置；plt.subplot（6,1,1）表示将画板分为6行1列，这个图在第一行的位置，（6,1,2）表示第二行。。，输出只有两个图是因为你一直在（6,1,1）（6,1,2）位置画图覆盖了原图。六个plt.subplot分别改（6,1,1）（6,1,2）（6,1,3）（6,1,4）（6,1,5）（6,1,6）

画完子图在下面加plt.suptitle()

本文从RoR对Ruby的影响、Ruby的优势等多个角度分析了Ruby比Python成功的原因。伴随着RoR的风行，Ruby语言受到越来越多的开发者的关注，同为脚本语言，Python的地位却略显尴尬，什么样的原因，造成了这样的局面？笔者认为有以下几个方面：一、RoR的推波助澜笔者认为，Ruby的成功，很大一部分是由于RoR的带动。几年前，如果你没听过RoR倒是情有可原，但如果今天，RoR对你来说，还是一个陌生词汇的话，那你就有点危险了。:)什么是RoR呢？全称，RubyonRails，简称，RoR或者Rails。它是个全栈的（full-stack）web应用框架，它为开发者提供了构建一个web应用所需的完整基础结构，并且严格按照MVC（模型-视图-控制器）架构进行开发。RoR致力于提高开发者的开发效率，希望通过尽量少的代码，完成尽可能多的功能。基于这样的考虑，RoR有两大设计原则，一是，不要重复自己（Don""tRepeatYourself）；二是，惯例优于配置（ConventionOverConfiguration）。使用RoR，你甚至可以通过简单的几条命令行、几行代码，就完成一个功能强大的web应用程序，这极大地提高了开发者的开发效率。2004年7月，RoR一经发布，在短期内，便受到很多开发者的追捧。时至今日，RoR已经被全世界的开发者们所关注，它带给开发者的效率提升，是前所未有的；它带给业界关于软件开发的思考，也是意义深远的。在RoR如此风行的大背景下，RubyonRails，这个需要使用Ruby进行开发的web框架，也自然地带动了Ruby语言的发展。在下面的“Ruby语言受关注程度趋势图”上，可以清晰地看出，Ruby语言在RoR发布也就是2004年7月后，进入了高速发展期。Ruby因为有了RoR这样的“杀手级”应用，变得春风得意，那么Python呢？在《浅谈Python语言》一文中，我们提到了Python具有丰富的API库，在web开发方面，也有Django、Turbogears这样的一些框架，就运行速度而言，Python比Ruby快；就社区而言，Python也比Ruby成熟，可是为什么Python没有产生一个像RoR这样的“杀手级”应用呢？Python语言的创始人Guido在接受InfoQ采访时，是这样解释的：“我不喜欢KillerApplication，因为那会让多数人或者社区将精力集中于一个地方。Python是一个应用广泛的语言，基于Python已经产生了很多好用的Web框架，比如Django等。但是Python不KillerApplication，至少目前是这样，而且我相信随着Python社区的发展，会有很多KillerApplications自然出现。我喜欢多样化的应用。”通过这个观点，我们可以看出Python在其发展道路上，追求的是一种均衡，一种“大而全”。“会有很多KillerApplications自然出现”，这点，我想我们需要拭目以待。单就“均衡”而言，笔者认为这很危险，作为一门脚本语言，试图做Java之类传统语言做的事情，不太可取。以Java为例，在web应用上，有太多的框架可供选择，不错，“在不同的场景用不同的框架”，这想法很好。可是，在实际应用中，有多少开发者可以根据项目特点，正确、合理地选择框架？与其到最后，用户还不知道该如何选择，还不如一开始就替用户做出一个选择。作为Python的使用者，我更愿看到有个Python的“杀手级”应用出现，进而带动Python更快速地发展。你可以说RoR成就了Ruby，可是Rails为什么偏偏选择了Ruby？！Ruby优势何在？二、Ruby的优势1.比Perl更强大，比Python更面向对象“比Perl更强大，比Python更面向对象”，这是Ruby创始人Matz设计Ruby的初衷。Python既支持面向过程的编程也支持面向对象的编程，而Ruby则是完全面向对象。在Ruby中，任何东西都是对象，包括Python中的基本数据类型；每个过程或函数都是方法。例如，取-3的绝对值，在Python中，是这样的：abs(-3)。而在Ruby中，则是这样的：-3.abs。这种OO的方式，显得更加直观。2.强大的语法功能单就语法的简单性而言，Ruby不及Python。但解决一些较复杂的问题，Ruby强大的语法功能，有助于降低问题的复杂度。例如：Ruby以“块”的方式来实现列表内的条件、循环语句，比Python的更灵活、更具通用性。Ruby具有类似Lisp的彻底的函数方式的条件、循环语句等。Ruby的迭代器功能可以将流程控制结构抽象化。3.强大的字符串处理、正则表达式功能Matz认为：Ruby>(Smalltalk+Perl)/2。Ruby类库是对Perl语言功能的面向对象方式的重组，因为借鉴了很多Perl的东西，使得字符串处理、正则表达式这块，Ruby同样强大。4.不会僵住的“胶水语言”同样是“胶水语言”，Ruby比Python更灵活。使用过一段时间的Python，你会发现，Python比较依赖第三方的东西。相比较，Ruby则更依赖自身。例如，Ruby可以使用（UNIX的）绝大部分的系统调用，单独使用Ruby也可以进行系统编程等。有优势，Ruby就一定可以成功了？Python同样也有很多优势！对，还得看当时所处的环境。三、时势造英雄这点还得回到RoR的崛起。Ruby，1995年12月正式发布，2000年进入美国；2004年7月，RoR正式发布。RoR的出现时间，值得玩味。在下面的“Java语言受关注程度趋势图”上，可以看到，2004年7月前后，Java处于一个相对“衰退期”。提到Java，大家应该都会想到J2EE。J2EE应用程序的广泛实现是从1999、2000年开始的，它的出现带来了诸如事务管理之类的核心中间层概念的标准化，但是因其开发效率、学习难度和实际性能的问题，在实践中没有获得完全的成功。作为J2EE核心技术的EJB（2.x），更是因其高昂的学习代价、极低的开发效率和极高的资源消耗，备受指责。在这样一个大背景下，2003年，Spring框架诞生了。Spring的设计思想在于“使J2EE开发更加简单”。这个设计思想，在包括Java领域在内的众多软件开发领域引起了广泛关注。软件开发者们开始思考，如何让开发向着一个更简单的方向发展。RoR在这一时期出现，无疑是顺应了这样一个潮流。可以这么说，是历史选择了RoR，当然也选择了Ruby。遇到合适的机遇，还不够，俗话说得好：“众人拾柴火焰高”。四、众星捧月Ruby的出现，受到了两大主流平台Java和.NET的极力追捧。2006年9月，SUN雇佣了JRuby的主要开发者CharlesNutter和ThomasEnebo；一年不到，2007年6月14号，JRuby1.0正式发布。SUN在其JavaIDENetBeans6.0M10中，更是集成了对Ruby/JRuby的支持。反观Python的Java实现——Jython，则没有这么幸运，发展至今，它并没有得到SUN的支持。而Microsoft，也在2007年7月，推出了Ruby的.NET实现——IronRuby的预览版。相信SUN和Microsoft对Ruby的竞相推崇，必然推动Ruby的进一步发展。基于以上几点，笔者认为Ruby的成功不是偶然，并且相信这样的成功还会持续下去。对于Python的未来，我们也将拭目以待。

你特么说反了吧

Dict在小型程序中，特别是在脚本中，使用Python自带的dict来表示结构信息非常简单方便：>>> ob = {"x":1, "y":2, "z":3}>>> x = ob["x"]>>> ob["y"] = y由于在Python 3.6中dict的实现采用了一组有序键，因此其结构更为紧凑，更深得人心。但是，让我们看看dict在内容中占用的空间大小：>>> print(sys.getsizeof(ob))240如上所示，dict占用了大量内存，尤其是如果突然虚需要创建大量实例时：实例数对象大小1 000 000240 Mb10 000 0002.40 Gb100 000 00024 Gb类实例有些人希望将所有东西都封装到类中，他们更喜欢将结构定义为可以通过属性名访问的类：class Point:#def __init__(self, x, y, z):self.x = xself.y = yself.z = z>>> ob = Point(1,2,3)>>> x = ob.x>>> ob.y = y类实例的结构很有趣：字段大小(比特)PyGC_Head24PyObject_HEAD16__weakref__8__dict__8合计：56在上表中，__weakref__是该列表的引用，称之为到该对象的弱引用(weak reference)；字段__dict__是该类的实例字典的引用，其中包含实例属性的值(注意在64-bit引用平台中占用8字节)。从Python3.3开始，所有类实例的字典的键都存储在共享空间中。这样就减少了内存中实例的大小：>>> print(sys.getsizeof(ob), sys.getsizeof(ob.__dict__))56 112因此，大量类实例在内存中占用的空间少于常规字典(dict)：实例数大小1 000 000168 Mb10 000 0001.68 Gb100 000 00016.8 Gb不难看出，由于实例的字典很大，所以实例依然占用了大量内存。带有__slots__的类实例为了大幅降低内存中类实例的大小，我们可以考虑干掉__dict__和__weakref__。为此，我们可以借助 __slots__：class Point:__slots__ = "x", "y", "z"def __init__(self, x, y, z):self.x = xself.y = yself.z = z>>> ob = Point(1,2,3)>>> print(sys.getsizeof(ob))64如此一来，内存中的对象就明显变小了：字段大小(比特)PyGC_Head24PyObject_HEAD16x8y8z8总计：64在类的定义中使用了__slots__以后，大量实例占据的内存就明显减少了：实例数大小1 000 00064 Mb10 000 000640 Mb100 000 0006.4 Gb目前，这是降低类实例占用内存的主要方式。这种方式减少内存的原理为：在内存中，对象的标题后面存储的是对象的引用(即属性值)，访问这些属性值可以使用类字典中的特殊描述符：>>> pprint(Point.__dict__)mappingproxy(...................................."x": ,"y": ,"z": })为了自动化使用__slots__创建类的过程，你可以使用库namedlist(https://pypi.org/project/namedlist)。namedlist.namedlist函数可以创建带有__slots__的类：>>> Point = namedlist("Point", ("x", "y", "z"))还有一个包attrs(https://pypi.org/project/attrs)，无论使用或不使用__slots__都可以利用这个包自动创建类。元组Python还有一个自带的元组(tuple)类型，代表不可修改的数据结构。元组是固定的结构或记录，但它不包含字段名称。你可以利用字段索引访问元组的字段。在创建元组实例时，元组的字段会一次性关联到值对象：>>> ob = (1,2,3)>>> x = ob[0]>>> ob[1] = y # ERROR元组实例非常紧凑：>>> print(sys.getsizeof(ob))72由于内存中的元组还包含字段数，因此需要占据内存的8个字节，多于带有__slots__的类：字段大小(字节)PyGC_Head24PyObject_HEAD16ob_size8[0]8[1]8[2]8总计：72命名元组由于元组的使用非常广泛，所以终有一天你需要通过名称访问元组。为了满足这种需求，你可以使用模块collections.namedtuple。namedtuple函数可以自动生成这种类：>>> Point = namedtuple("Point", ("x", "y", "z"))如上代码创建了元组的子类，其中还定义了通过名称访问字段的描述符。对于上述示例，访问方式如下：class Point(tuple):#@propertydef _get_x(self):return self[0]@propertydef _get_y(self):return self[1]@propertydef _get_z(self):return self[2]#def __new__(cls, x, y, z):return tuple.__new__(cls, (x, y, z))这种类所有的实例所占用的内存与元组完全相同。但大量的实例占用的内存也会稍稍多一些：实例数大小1 000 00072 Mb10 000 000720 Mb100 000 0007.2 Gb记录类：不带循环GC的可变更命名元组由于元组及其相应的命名元组类能够生成不可修改的对象，因此类似于ob.x的对象值不能再被赋予其他值，所以有时还需要可修改的命名元组。由于Python没有相当于元组且支持赋值的内置类型，因此人们想了许多办法。在这里我们讨论一下记录类(recordclass，https://pypi.org/project/recordclass)，它在StackoverFlow上广受好评(https://stackoverflow.com/questions/29290359/existence-of-mutable-named-tuple-in)。此外，它还可以将对象占用的内存量减少到与元组对象差不多的水平。recordclass包引入了类型recordclass.mutabletuple，它几乎等价于元组，但它支持赋值。它会创建几乎与namedtuple完全一致的子类，但支持给属性赋新值(而不需要创建新的实例)。recordclass函数与namedtuple函数类似，可以自动创建这些类：>>>Point = recordclass("Point", ("x", "y", "z"))>>>ob = Point(1, 2, 3)类实例的结构也类似于tuple，但没有PyGC_Head：字段大小(字节)PyObject_HEAD16ob_size8x8y8z8总计：48在默认情况下，recordclass函数会创建一个类，该类不参与垃圾回收机制。一般来说，namedtuple和recordclass都可以生成表示记录或简单数据结构(即非递归结构)的类。在Python中正确使用这二者不会造成循环引用。因此，recordclass生成的类实例默认情况下不包含PyGC_Head片段(这个片段是支持循环垃圾回收机制的必需字段，或者更准确地说，在创建类的PyTypeObject结构中，flags字段默认情况下不会设置Py_TPFLAGS_HAVE_GC标志)。大量实例占用的内存量要小于带有__slots__的类实例：实例数大小1 000 00048 Mb10 000 000480 Mb100 000 0004.8 Gbdataobjectrecordclass库提出的另一个解决方案的基本想法为：内存结构采用与带__slots__的类实例同样的结构，但不参与循环垃圾回收机制。这种类可以通过recordclass.make_dataclass函数生成：>>> Point = make_dataclass("Point", ("x", "y", "z"))这种方式创建的类默认会生成可修改的实例。另一种方法是从recordclass.dataobject继承：class Point(dataobject):x:inty:intz:int这种方法创建的类实例不会参与循环垃圾回收机制。内存中实例的结构与带有__slots__的类相同，但没有PyGC_Head：字段大小(字节)PyObject_HEAD16ob_size8x8y8z8总计：48>>> ob = Point(1,2,3)>>> print(sys.getsizeof(ob))40如果想访问字段，则需要使用特殊的描述符来表示从对象开头算起的偏移量，其位置位于类字典内：mappingproxy({"__new__": ,......................................."x": ,"y": ,"z": })大量实例占用的内存量在CPython实现中是最小的：实例数大小1 000 00040 Mb10 000 000400 Mb100 000 0004.0 GbCython还有一个基于Cython(https://cython.org/)的方案。该方案的优点是字段可以使用C语言的原子类型。访问字段的描述符可以通过纯Python创建。例如：cdef class Python:cdef public int x, y, zdef __init__(self, x, y, z):self.x = xself.y = yself.z = z本例中实例占用的内存更小：>>> ob = Point(1,2,3)>>> print(sys.getsizeof(ob))32内存结构如下：字段大小(字节)

__slots__ 是python的一大神器。 它有两大的特点： python文档中这样介绍它 首先第一点，python的动态性一部分源自于 __dict__ ，属性都保存在 __dict__ 的一个字典中，我们可以随时向这个字典添加新内容，这是 MonkeyPatch 的能力。 而当我们显示的声明了 __slots__ ，python将不会给这个类创建 __dict__ 和 __weakref__ 没有了 __dict__ 我们便不能随意创建实例属性，而必须遵守 __slots__ 的约定。 对于性能而言，使用了 __slots__ 后，属性会直接存储到对象中，而不是 __dict__ 中，相当于少了一次检索步骤。 __slots__ 的两大优点，对于python来说，是难以拒绝的诱惑。既能限制不必要的动态性，又能提高性能！ 但是 __slots__ 遇到继承时，就会出现很多问题。准确的说， __slots__ 不会被继承。当我们用一个不带有 __slots__ 的子类，继承带有 __slots__ 的父类时。子类还是会生成 __dict__ 和 __weakref__ 。 这是之前写的一个metaclass，创建新的类对象时，会进行以下逻辑。 实际上我们的目的正是解决，父类规定的 __slots__ 约束不了无 __slots__ 子类的问题。这个结果令人非常满意 注意这里子类的d，在 pycharm 等IDE中不会提示错误，因为 pycharm 无法探知你的metaclass做了这样 逆天改命 的逻辑。 需要注意一点， __slots__ 是 类对实例属性的约束 ，而类对象无法通过该属性，约束自己。即为类对象添加新属性，仍然是被允许的。 按照正常思路，也许我们应该到metaclass写一个 __slots__ ，但实际上这是不被允许的。 抽空找时间我会考虑下有无可行性。

从零开始用Python构建神经网络动机：为了更加深入的理解深度学习，我们将使用 python 语言从头搭建一个神经网络，而不是使用像 Tensorflow 那样的封装好的框架。我认为理解神经网络的内部工作原理，对数据科学家来说至关重要。这篇文章的内容是我的所学，希望也能对你有所帮助。神经网络是什么?介绍神经网络的文章大多数都会将它和大脑进行类比。如果你没有深入研究过大脑与神经网络的类比，那么将神经网络解释为一种将给定输入映射为期望输出的数学关系会更容易理解。神经网络包括以下组成部分? 一个输入层，x? 任意数量的隐藏层? 一个输出层，?? 每层之间有一组权值和偏置，W and b? 为隐藏层选择一种激活函数，σ。在教程中我们使用 Sigmoid 激活函数下图展示了 2 层神经网络的结构(注意：我们在计算网络层数时通常排除输入层) 2 层神经网络的结构用 Python 可以很容易的构建神经网络类 训练神经网络这个网络的输出 ? 为： 你可能会注意到，在上面的等式中，输出 ? 是 W 和 b 函数。因此 W 和 b 的值影响预测的准确率. 所以根据输入数据对 W 和 b 调优的过程就被成为训练神经网络。每步训练迭代包含以下两个部分:? 计算预测结果 ?，这一步称为前向传播? 更新 W 和 b,，这一步成为反向传播下面的顺序图展示了这个过程： 前向传播正如我们在上图中看到的，前向传播只是简单的计算。对于一个基本的 2 层网络来说，它的输出是这样的： 我们在 NeuralNetwork 类中增加一个计算前向传播的函数。为了简单起见我们假设偏置 b 为0： 但是我们还需要一个方法来评估预测结果的好坏(即预测值和真实值的误差)。这就要用到损失函数。损失函数常用的损失函数有很多种，根据模型的需求来选择。在本教程中，我们使用误差平方和作为损失函数。误差平方和是求每个预测值和真实值之间的误差再求和，这个误差是他们的差值求平方以便我们观察误差的绝对值。训练的目标是找到一组 W 和 b，使得损失函数最好小，也即预测值和真实值之间的距离最小。反向传播我们已经度量出了预测的误差(损失)，现在需要找到一种方法来传播误差，并以此更新权值和偏置。为了知道如何适当的调整权值和偏置，我们需要知道损失函数对权值 W 和偏置 b 的导数。回想微积分中的概念，函数的导数就是函数的斜率。 梯度下降法如果我们已经求出了导数，我们就可以通过增加或减少导数值来更新权值 W 和偏置 b(参考上图)。这种方式被称为梯度下降法。但是我们不能直接计算损失函数对权值和偏置的导数，因为在损失函数的等式中并没有显式的包含他们。因此，我们需要运用链式求导发在来帮助计算导数。 链式法则用于计算损失函数对 W 和 b 的导数。注意，为了简单起见。我们只展示了假设网络只有 1 层的偏导数。这虽然很简陋，但是我们依然能得到想要的结果—损失函数对权值 W 的导数(斜率)，因此我们可以相应的调整权值。现在我们将反向传播算法的函数添加到 Python 代码中 为了更深入的理解微积分原理和反向传播中的链式求导法则，我强烈推荐 3Blue1Brown 的如下教程：Youtube：https://youtu.be/tIeHLnjs5U8整合并完成一个实例既然我们已经有了包括前向传播和反向传播的完整 Python 代码，那么就将其应用到一个例子上看看它是如何工作的吧。 神经网络可以通过学习得到函数的权重。而我们仅靠观察是不太可能得到函数的权重的。让我们训练神经网络进行 1500 次迭代，看看会发生什么。 注意观察下面每次迭代的损失函数，我们可以清楚地看到损失函数单调递减到最小值。这与我们之前介绍的梯度下降法一致。 让我们看看经过 1500 次迭代后的神经网络的最终预测结果： 经过 1500 次迭代训练后的预测结果我们成功了!我们应用前向和方向传播算法成功的训练了神经网络并且预测结果收敛于真实值。注意预测值和真实值之间存在细微的误差是允许的。这样可以防止模型过拟合并且使得神经网络对于未知数据有着更强的泛化能力。下一步是什么?幸运的是我们的学习之旅还没有结束，仍然有很多关于神经网络和深度学习的内容需要学习。例如：? 除了 Sigmoid 以外，还可以用哪些激活函数? 在训练网络的时候应用学习率? 在面对图像分类任务的时候使用卷积神经网络我很快会写更多关于这个主题的内容，敬请期待!最后的想法我自己也从零开始写了很多神经网络的代码虽然可以使用诸如 Tensorflow 和 Keras 这样的深度学习框架方便的搭建深层网络而不需要完全理解其内部工作原理。但是我觉得对于有追求的数据科学家来说，理解内部原理是非常有益的。这种练习对我自己来说已成成为重要的时间投入，希望也能对你有所帮助

怎么用python画小黄人？前言：还记得小黄人哪只蠢萌蠢萌的单眼小黄人？就是喜欢做什么事都喜欢逞能的那只，下面用Python来实现一下，正在逃跑的小黄人。推荐：《python教程》一、导入Turtle库<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">import turtle as tt.pensize(4)t.speed(10)</pre>设置画笔的大小、画图的速度，可以改变数值来提升画笔的速度。二、画小黄人的头<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">def head():t.penup()t.fillcolor("#FFEE26")t.goto(-130, 10)t.pendown()t.begin_fill()t.seth(81)t.fd(90)t.seth(100)t.circle(-500, 3)t.circle(-100, 10)t.circle(-200, 25)t.circle(-110, 20)t.circle(-140, 30)t.circle(-180, 30)t.circle(-200, 20)t.circle(-140, 10)t.circle(-160, 50)t.seth(85)t.fd(-148)t.seth(-112)t.circle(-250, 14)t.fd(200)t.right(80)t.fd(190)t.seth(110)t.circle(-200, 7)t.circle(-130, 30)t.end_fill()</pre>三、画小黄人的前后角<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">def forefoot():t.begin_fill()t.penup()t.goto(-120, -250)t.pendown()t.fillcolor("#030003")t.setheading(-135)t.circle(60, 20)t.fd(35)t.circle(20, 160)t.circle(100, 10)t.fd(20)t.goto(-120, -250)t.end_fill()def hindleg():t.begin_fill()t.color("black", "#0045D9")t.penup()t.goto(-50, -300)t.pendown()t.setheading(-150)t.circle(-80, 60)t.setheading(90)t.circle(-40, 67)t.seth(-30)t.goto(-50, -300)t.end_fill()</pre>三、画小黄人的衣服<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">def cloths():t.begin_fill()t.penup()t.goto(-45, -70)t.pendown()t.fillcolor("#0045D9")t.setheading(-15)t.circle(500, 5)t.circle(400, 26)t.seth(-112)t.circle(-250, 7)t.seth(-69)t.circle(-250, 7)t.right(15)t.circle(-320, 18)t.circle(-330, 10)t.fd(80)t.right(81)t.fd(190)t.seth(141)t.circle(-180, 15)t.circle(-150, 30)t.right(6)t.circle(-90, 15)t.seth(-45)t.circle(50, 10)t.seth(-30)t.circle(200, 20)t.circle(150, 10)t.seth(92)t.circle(500, 10)t.setheading(75)t.goto(-45, -70)t.end_fill()</pre>四、画小黄人的口袋<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">def pocket():t.begin_fill()t.penup()t.goto(52, -120)t.pendown()t.fillcolor("#BFC5AD")t.seth(-15)t.circle(200, 25)t.seth(-88)t.circle(-200, 18)t.seth(-150)t.circle(-90, 5)t.right(10)t.circle(-90, 45)t.right(20)t.circle(-50, 50)t.goto(52, -120)t.end_fill()t.begin_fill()t.penup()t.goto(70, -155)t.pendown()t.fillcolor("#0045D9")t.circle(-25)t.end_fill()t.penup()t.goto(120, -160)t.pencolor("#5C7F58")t.pendown()t.seth(180)t.fd(20)t.right(60)t.circle(6, 340)t.pencolor("black")</pre>五、画小黄人的扣子<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">def button():t.begin_fill()t.penup()t.fillcolor("#FFFFFF")t.goto(-40, -80)t.pendown()t.seth(0)t.circle(-9, 360)t.end_fill()</pre>六、画小黄人的左手<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">def lefthand():t.begin_fill()t.penup()t.fillcolor("#FFEE26")t.goto(195, -56)t.pendown()t.seth(-8)t.circle(150, 15)t.circle(25, 40)t.left(2)t.fd(60)t.right(85)t.fd(28)t.right(92)t.fd(45)t.circle(-100, 20)t.circle(-80, 40)t.circle(80, 13)t.goto(195, -56)t.end_fill()</pre>七、函数调用<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">head()mouth()righhand()glasses()goggles()forefoot()hindleg()cloths()pocket()foreleg()foreleg()ground()shoes()collar()button()lefthand()leftpalm()leftcollar()</pre>效果如下：

Python的学习内容还是比较多的，我们将学习的过程划分为4个阶段，每个阶段学习对应的内容，具体的学习顺序如下：Python学习顺序：①Python软件开发基础掌握计算机的构成和工作原理会使用Linux常用工具熟练使用Docker的基本命令建立Python开发环境，并使用print输出使用Python完成字符串的各种操作使用Python re模块进行程序设计使用Python创建文件、访问、删除文件掌握import 语句、From…import 语句、From…import* 语句、方法的引用、Python中的包②Python软件开发进阶能够使用Python面向对象方法开发软件能够自己建立数据库，表，并进行基本数据库操作掌握非关系数据库MongoDB的使用，掌握Redis开发能够独立完成TCP/UDP服务端客户端软件开发，能够实现ftp、http服务器，开发邮件软件能开发多进程、多线程软件③Python全栈式WEB工程师能够独立完成后端软件开发，深入理解Python开发后端的精髓能够独立完成前端软件开发，并和后端结合，熟练掌握使用Python进行全站Web开发的技巧④Python多领域开发能够使用Python熟练编写爬虫软件能够熟练使用Python库进行数据分析招聘网站Python招聘职位数据爬取分析掌握使用Python开源人工智能框架进行人工智能软件开发、语音识别、人脸识别掌握基本设计模式、常用算法掌握软件工程、项目管理、项目文档、软件测试调优的基本方法互联网行业目前还是最热门的行业之一，学习IT技能之后足够优秀是有机会进入腾讯、阿里、网易等互联网大厂高薪就业的，发展前景非常好，普通人也可以学习。想要系统学习，你可以考察对比一下开设有相关专业的热门学校，好的学校拥有根据当下企业需求自主研发课程的能力，中博软件学院、南京课工场、南京北大青鸟等开设python专业的学校都是不错的，建议实地考察对比一下。祝你学有所成，望采纳。请点击输入图片描述

调用 uiautomator 模块的device 类的swipePoint方法出错。

学下的时候

app自动化测试过程中，经常会遇到滑动屏幕操作，appium框架的话我们可以使用webdriver提供的swipe()方法来对屏幕页面进行上滑、下滑、左滑、右滑操作。 swipe()方法的参数说明： start_x：起始横坐标 start_y：起始纵坐标 end_x：结束时横坐标 end_y：结束时纵坐标 duration：滑动持续时间，单位毫秒，默认None（一般设置500-1000毫秒比较合适） 调用baseOpera.py模块中的滑动方法，向上滑动查看今日头条首页新闻，简单示意如下：

Python 中的 yield 关键字鲜为人知，但是作用却很大，正是因为有了yield，才有了Python生成器。 yield 是 Python 的关键字，它用于 从函数返回而不破坏其局部变量的状态 ，并且在调用该函数时，从最后一个 yield 语句开始执行。任何包含 yield 关键字的函数都称为生成器。 Python 中的 yield 关键字的作用类似于 Python 中的 return 语句，不同之处在于： yield的优点 yield的缺点 Python 可以使用 括号() 创建生成器 更多时候，我们使用 yield 关键字创建生成器 下面这个生成器，前4次调用它时，返回的是0-3这几个特殊值，第5次调用它时返回一个10-20之间的随机整数。 更多时候，生成器可以返回无限的值。 注意 generator() 函数返回的是一个生成器对象，要想获取它的值，可以像上面那样在迭代器中取出它的值，我们也可以显式的调用next函数获取值。 Python | yield Keyword - GeeksforGeeks：https://www.geeksforgeeks.org/python-yield-keyword/ https://c.runoob.com/compile/9/

以后再也不到总站坐774了，因为没见过yield能嵌套的

常看到别人使用或讨论yield语法,能搜到的中文解释却不多,今天决心搞定yield,把暂时的理解贴到这里.搞定yield之前: 叠代器(iterator)发现yield: 生成器(constructor)使用yield: 递归调用1. iterator叠代器最简单例子应该是数组下标了，且看下面的c++代码：int array[10];for ( int i = 0; i < 10; i++ ) printf("%d ", array[i]);叠代器工作在一个容器里(array[10])，它按一定顺序(i++)从容器里取出值(array[i])并进行操作(printf("%d ", array[i])。上面的代码翻译成python：array = [i for i in range(10)]for i in array: print i,for i in array干了什么(别乱想)？首先，array作为一个list是个容器，其次list这个内建类型有默认的next行为，python发现这些之后采 取的秘密的没被各位看到的动作是：拿出array这丫容器的叠代器，从里面next一下把值给i供for循环主体处置，for把这个值print了。现在的问题是数据可以做容器叠代，代码可以吗？怎么不行，碗碟可以用来放菜，wk们不就联想出用nt盛吗，当然我们的yield不会那么yellow + bt2. constructor怎么把函数变成constructor？ 在函数体里有yield就行了！def gen(): print "enter" yield 1 print "next" yield 2 print "next again"for i in gen(): print i各位！python看到gen函数里出现yield，知道可以用next了，问题是怎么对代码这个容器玩next？从容器里拿到iterator的时候它还什么也不是，处在容器入口处，对于数组来说就是下标为-1的地方，对于函数来说就是函数入口嘛事没干，但是万事俱备就欠next。开始for i in g，next让itreator爬行到yield语句存在的地方并返回值,再次next就再爬到下一个yield语句存在的地方并返回值,依次这样直到函数返回(容器尽头)。您一定看出来上面代码的输出是：enter1next2next again如果没看出来请不要往下看了免得反被yield搞定。3. 使用yieldyield的代码叠代能力不但能打断函数执行还能记下断点处的数据，下次next书接上回，这正是递归函数需要的。例如中序遍历二叉树：(应该是David Mertz写的)def inorder(t): if t: for x in inorder(t.left): yield x yield t.label for x in inorder(t.right): yield xfor n in inorder(tree) print n当然yield这种代码next的能力还可以用在其它方面，发现拍案的在贴咯。

阅读别人的python源码时碰到了这个yield这个关键字，各种搜索终于搞懂了，在此做一下总结：通常的for?in?循环中，in后面是一个数组，这个数组就是一个可迭代对象，类似的还有链表，字符串，文件。它可以是mylist= [1, 2, 3]，也可以是mylist = [x*x for x in range(3)]。 它的缺陷是所有数据都在内存中，如果有海量数据的话将会非常耗内存。（推荐学习：Python视频教程）生成器是可以迭代的，但只可以读取它一次。因为用的时候才生成。比如 mygenerator = (x*x for x in range(3))，注意这里用到了()，它就不是数组，而上面的例子是[]。我理解的生成器(generator)能够迭代的关键是它有一个next()方法，工作原理就是通过重复调用next()方法，直到捕获一个异常。可以用上面的mygenerator测试。带有yield的函数不再是一个普通函数，而是一个生成器generator，可用于迭代，工作原理同上。yield一个类似return的关键字，迭代一次遇到yield时就返回yield后面的值。重点是：下一次迭代时，从上一次迭代遇到的yield后面的代码开始执行。简要理解：yield就是return返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后开始。带有yield的函数不仅仅只用于for循环中，而且可用于某个函数的参数，只要这个函数的参数允许迭代参数。比如array.extend函数，它的原型是array.extend(iterable)。send(msg)与next()的区别在于send可以传递参数给yield表达式，这时传递的参数会作为yield表达式的值，而yield的参数是返回给调用者的值。——换句话说，就是send可以强行修改上一个yield表达式值。比如函数中有一个yield赋值，a= yield 5，第一次迭代到这里会返回5，a还没有赋值。第二次迭代时，使用.send(10)，那么，就是强行修改a表达式的值为10，本来是None的，那么a=10send(msg)与next()都有返回值，它们的返回值是当前迭代遇到yield时，yield后面表达式的值，其实就是当前迭代中yield后面的参数。第一次调用时必须先next()或send(None)，否则会报错，send后之所以为None是因为这时候没有上一个yield(根据第8条)。可以认为，next()等同于send(None)。更多Python相关技术文章，请访问Python教程栏目进行学习！

python中yield什么意思？可迭代对象mylist 是一个可迭代的对象。当你使用一个列表生成式来建立一个列表的时候，就建立了一个可迭代的对象:>>> mylist = [x*x for x in range(3)]>>> for i in mylist :... print(i)在这里，所有的值都存在内存当中，所以并不适合大量数据生成器可迭代只能读取一次实时生成数据，不全存在内存中 >>> mygenerator = (x*x for x in range(3))>>> for i in mygenerator :... print(i)注意你之后不能再使用for i in mygenerator了yield关键字yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器当你调用这个函数的时候，函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象当你使用for进行迭代的时候，函数中的代码才会执行>>> def createGenerator() :... mylist = range(3)... for i in mylist :... yield i*i...>>> mygenerator = createGenerator() # create a generator>>> print(mygenerator) # mygenerator is an object!<generator object createGenerator at 0xb7555c34>>>> for i in mygenerator:... print(i)第一次迭代中你的函数会执行，从开始到达 yield 关键字，然后返回 yield 后的值作为第一次迭代的返回值. 然后，每次执行这个函数都会继续执行你在函数内部定义的那个循环的下一次，再返回那个值，直到没有可以返回的。控制生成器的穷尽>>> class Bank(): # let"s create a bank, building ATMs... crisis = False... def create_atm(self) :... while not self.crisis :... yield "$100">>> hsbc = Bank() # when everything"s ok the ATM gives you as much as you want>>> corner_street_atm = hsbc.create_atm()>>> print(corner_street_atm.next())$100>>> print(corner_street_atm.next())$100>>> print([corner_street_atm.next() for cash in range(5)])["$100", "$100", "$100", "$100", "$100"]>>> hsbc.crisis = True # crisis is coming, no more money!>>> print(corner_street_atm.next())<type "exceptions.StopIteration">>>> wall_street_atm = hsbc.create_atm() # it"s even true for new ATMs>>> print(wall_street_atm.next())<type "exceptions.StopIteration">>>> hsbc.crisis = False # trouble is, even post-crisis the ATM remains empty>>> print(corner_street_atm.next())<type "exceptions.StopIteration">>>> brand_new_atm = hsbc.create_atm() # build a new one to get back in business>>> for cash in brand_new_atm :... print cash$100$100$100$100$100$100$100$100$100...

生成器似乎并不是一个经常被开发者讨论的语法，因此也就没有它的大兄弟迭代器那么著名。大家不讨论它并不是说大家都已经对它熟悉到人尽皆知，与之相反，即使是工作多年的开发者可能对生成器的运行过程还是知之甚少。这是什么原因导致的呢？我猜想大概有以下几点原因： (1)运行流程不同寻常，(2)日常开发不需要，(3)常常将生成器与迭代器混淆。 生成器的运行流程可以按照协程来理解，也就是说 返回中间结果，断点继续运行 。这与我们通常对于程序调用的理解稍有差异。这种运行模式是针对什么样的需求呢？ 一般而言，生成器是应用于大量磁盘资源的处理。 比如一个很大的文件，每次读取一行，下一次读取需要以上一次读取的位置为基础。下面就通过代码演示具体看看生成器的运行机制、使用方式以及与迭代器的比较。 什么是生成器？直接用文字描述可能太过抽象，倒不如先运行一段代码，分析这段代码的运行流程，然后总结出自己对生成器的理解。 从以上演示可以看出，这段代码定义了一个函数，这个函数除了yield这个关键字之外与一般函数并没有差异，也就是说生成器的魔法都是这个yield关键字引起的。 第一点，函数的返回值是一个生成器对象。 上述代码中，直接调用这个看似普通的函数，然后将返回值打印出来，发现返回值是一个对象，而并不是普通函数的返回值。 第二点，可以使用next对这个生成器对象进行操作 。生成器对象天然的可以被next函数调用，然后返回在yield关键字后面的内容。 第三，再次调用next函数处理生成器对象，发现是从上次yield语句之后继续运行，直到下一个yield语句返回。 生成器的运行流程确实诡异，下面还要演示一个生成器可以执行的更加诡异的操作：运行过程中向函数传参。 返回生成器和next函数操作生成器已经并不奇怪了，但是在函数运行过程中向其传参还是让人惊呆了。 调用生成器的send函数传入参数，在函数内使用yield语句的返回值接收，然后继续运行直到下一个yield语句返回。 以前实现这种运行流程的方式是在函数中加上一个从控制台获取数据的指令，或者提前将参数传入，但是现在不用了，send方式使得传入的参数可以随着读取到的参数变化而变化。 很多的开发者比较容易混淆生成器和迭代器，而迭代器的运行过程更加符合一般的程序调用运行流程，因此从亲进度和使用熟悉度而言，大家对迭代器更有好感。比如下面演示一个对迭代器使用next方法进行操作。 从以上演示来看，大家或许会认为迭代器比生成器简单易用得太多了。不过，如果你了解迭代器的实现机制，可能就不会这么早下结论了。python内置了一些已经实现了的迭代器使用确实方便，但是如果需要自己去写一个迭代器呢？下面这段代码就带大家见识以下迭代器的实现。 在python中，能被next函数操作的对象一定带有__next__函数的实现，而能够被迭代的对象有必须实现__iter__函数。看了这么一段操作，相信大家对迭代器实现的繁琐也是深有体会了，那么生成器的实现是不是会让你觉得更加简单易用呢？不过千万别产生一个误区，即生成器比迭代器简单就多用生成器。 在实际开发中，如果遇到与大量磁盘文件或者数据库操作相关的倒是可以使用生成器。但是在其他的任务中使用生成器难免有炫技，并且使逻辑不清晰而导致可读性下降的嫌疑。 这大概也能解释生成器受冷落的原因。不过作为一个专业的开发者，熟悉语言特性是分内之事。 到此，关于生成器的讨论就结束了。本文的notebook版本文件在github上的cnbluegeek/notebook仓库中共享，欢迎感兴趣的朋友前往下载。

yieldyield是用于生成器。什么是生成器，你可以通俗的认为，在一个函数中，使用了yield来代替return的位置的函数，就是生成器。它不同于函数的使用方法是：函数使用return来进行返回值，每调用一次，返回一个新加工好的数据返回给你；yield不同，它会在调用生成器的时候，把数据生成object，然后当你需要用的时候，要用next()方法来取，同时不可逆。你可以通俗的叫它"轮转容器"，可用现实的一种实物来理解：水车，先yield来装入数据、产出generator object、使用next()来释放；好比水车转动后，车轮上的水槽装入水，随着轮子转动，被转到下面的水槽就能将水送入水道中流入田里。def func3():for i in range(1,5):yield i#装入gob = func3()#generator 类型print next(gob)#1 释放的第一个装入的数据，（先入先出）print next(gob)#2print next(gob)#3print next(gob)#4print next(gob)#报错复制代码return这个大家都知道了，一句话，return既可以终止函数的执行，也可以返回函数加工处理好的数据，只是这个数据需要一个载体来进行保存，通常是变量。非条件判断的时候，只要遇见return，函数就结束执行。

当函数被调用时，函数体中的代码是不会运行的，函数仅仅是返回一个生成器对象。这里理解起来可能稍微有点复杂。 函数中的代码每次会在 for循环中被执行，接下来是最难的一部分： for第一次调用生成器对象时

一个带有 yield 的函数就是一个 generator，它和普通函数不同，生成一个 generator 看起来像函数调用，但不会执行任何函数代码，直到对其调用 next()（在 for 循环中会自动调用 next()）才开始执行。虽然执行流程仍按函数的流程执行，但每执行到一个 yield 语句就会中断，并返回一个迭代值，下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。具体，请参考下以下资料：http://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/

Python基于递归算法实现的走迷宫问题本文实例讲述了Python基于递归算法实现的走迷宫问题。分享给大家供大家参考，具体如下：什么是递归?简单地理解就是函数调用自身的过程就称之为递归。什么时候用到递归？如果一个问题可以表示为更小规模的迭代运算，就可以使用递归算法。迷宫问题：一个由0或1构成的二维数组中，假设1是可以移动到的点，0是不能移动到的点，如何从数组中间一个值为1的点出发，每一只能朝上下左右四个方向移动一个单位，当移动到二维数组的边缘，即可得到问题的解，类似的问题都可以称为迷宫问题。在python中可以使用list嵌套表示二维数组。假设一个6*6的迷宫,问题时从该数组坐标[3][3]出发，判断能不能成功的走出迷宫。 maze=[[1,0,0,1,0,1], [1,1,1,0,1,0], [0,0,1,0,1,0], [0,1,1,1,0,0], [0,0,0,1,0,0], [1,0,0,0,0,0]]针对这个迷宫问题，我们可以使用递归的思想很好的解决。对于数组中的一个点，该点的四个方向可以通过横纵坐标的加减轻松的表示，每当移动的一个可移动的点时候，整个问题又变为和初始状态一样的问题，继续搜索四个方向找可以移动的点，知道移动到数组的边缘。所以我们可以这样编码： # 判断坐标的有效性，如果超出数组边界或是不满足值为1的条件，说明该点无效返回False，否则返回True。def valid(maze,x,y): if (x>=0 and x<len(maze) and y>=0 and y<len(maze[0]) and maze[x][y]==1): return True else: return False# 移步函数实现def walk(maze,x,y): # 如果位置是迷宫的出口，说明成功走出迷宫 if(x==0 and y==0): print("successful!") return True # 递归主体实现 if valid(maze,x,y): # print(x,y) maze[x][y]=2 # 做标记，防止折回 # 针对四个方向依次试探，如果失败，撤销一步 if not walk(maze,x-1,y): maze[x][y]=1 elif not walk(maze,x,y-1): maze[x][y]=1 elif not walk(maze,x+1,y): maze[x][y]=1 elif not walk(maze,x,y+1): maze[x][y]=1 else: return False # 无路可走说明，没有解 return Truewalk(maze,3,3)递归是个好东西呀！

python是一门相对简单的编程语言，封装了很多功能强大的库，因此，其应用十分广泛，目前比较火的人工智能、大数据、云计算等领域均有用武之地，也有很好的应用前景

lara.circle("100")这里引号去掉试试错误信息说的是abs内错误的字符串类型

建议加大悬赏或者如果有RMB回报,就会有人给你写程序了

python语言虽然很万能，但用它来开发app还是显得有点不对路，因此用python开发的app应当是作为编码练习，加上目前这方面的模块还不是特别成熟，bug比较多。准备工作利用python开发app需要用到python的一个模块_kivy，kivy是一个开源的，跨平台的Python开发框架，用于开发使用创新的应用程序。简而言之，这是一个python桌面程序开发框架（类似wxpython等模块），强大的是kivy支持linux、mac、windows、android、ios平台，这也是为什么开发app需要用到这个模块。虽然kivy是跨平台的，但是想要在不同的平台使用python代码，还需要将python代码打包成对应平台的可执行程序，好在kivy项目下有个打包工具项目_buildozer，这是官方推荐的打包工具，因为相对比较简单，自动化程度高，其他项目比如：python-for-android也能起到类似的作用，这里不展开介绍。搭建kivy开发环境需要在pc上安装kivy开发环境，这里演示下mac与linux下的安装过程。install kivy for mac安装一些依赖包：brew install pkg-config sdl2 sdl2_image sdl2_ttf sdl2_mixer gstreamer安装cython以及kivy：pip install cython==0.25pip install kivy如果安装kivy报错，则使用下面的方式安装kivy：git clone https://github.com/kivy/kivypython setup.py install安装后测试：$pythonPython 2.7.10 (default, Jul 15 2017, 17:16:57)[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.31)] on darwinType "help", "copyright", "credits" or "license" for more information.>>>>>> import kivy[INFO ] [Logger ] Record log in /Users/didi/.kivy/logs/kivy_18-05-08_4.txt[INFO ] [Kivy ] v1.10.1.dev0, git-5f6c66e, 20180507[INFO ] [Python ] v2.7.10 (default, Jul 15 2017, 17:16:57)[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.31)]说明：导入kivy模块没有报错则说明安装成功。install kivy for centos7先安装依赖：yum install make mercurial automake gcc gcc-c++ SDL_ttf-devel SDL_mixer-devel khrplatform-devel mesa-libGLES mesa-libGLES-devel gstreamer-plugins-good gstreamer gstreamer-python mtdev-devel python-devel python-pip java-devel安装cython以及kivy:pip install Cython==0.20pip install kivycentos安装kivy参考：https://kivy.org/docs/installation/installation-linux.html#using-software-packages说明：其他安装kivy方式可移步：https://kivy.org/#download（需要FQ）用kivy开发第一个python app安装完kivy就可以开发app程序了，这里演示下hello-world程序，关于kivy更复杂的用法不是本文重点，后面再成文介绍。1) 创建一个main.py文件，写入：#! -*- coding:utf-8 -*-from kivy.app import Appclass HelloApp(App): passif __name__ == "__main__": HelloApp().run()2)创建一个hello.kv文件，写入：Label: text: "Hello, World! I am nMask"简单说明：main.py是入口函数，定义了一个HelloApp类，该类继承kivy.app；hello.kv文件是kivy程序，相当于定义界面风格等，该文件命名规则为类名小写且去除app。运行第一个python apppython main.py安装buildozer工具通过以上的编码，我创建了自己的第一个python app程序，该程序可以直接在mac、linux、windows平台下运行，那么如何让它在安卓或者苹果手机上运行呢？我们知道在安卓上运行，需要将其打包成apk安装程序，因此就需要用到前面提到过的buildozer工具，（buildozer工具可以打包kivy程序，支持android、ios等），buildozer的安装过程比较简单：pip install buildozer使用buildozer工具将kivy程序打包成apk在python项目目录下运行：buildozer init运行成功将会创建一个配置文件buildozer.spec，可以通过修改配置文件更改app的名称等，然后运行：buildozer android debug deploy run运行以上命令将会生成跨平台的安装包，可适用安卓、ios等，如果用于安卓，则是利用python-for-android项目。

这种安装包，需要全命令安装在命令行下，setup.py build然后再执行, setup.py install

前段时间为准备百度面试恶补的东西，虽然最后还是被刷了，还是把那几天的“战利品”放点上来，算法一直是自己比较薄弱的地方，以后还要更加努力啊。下面用Python实现了几个常用的排序，如快速排序，选择排序，以及二路并归排序等等。 代码如下:#encoding=utf-8import randomfrom copy import copydef directInsertSort(seq): """ 直接插入排序 """ size = len(seq) for i in range(1,size): tmp, j = seq[i], i while j > 0 and tmp < seq[j-1]: seq[j], j = seq[j-1], j-1 seq[j] = tmp return seqdef directSelectSort(seq): """ 直接选择排序 """ size = len(seq) for i in range(0,size - 1): k = i;j = i+1 while j < size: if seq[j] < seq[k]: k = j j += 1 seq[i],seq[k] = seq[k],seq[i] return seqdef bubbleSort(seq): """冒泡排序""" size = len(seq) for i in range(1,size): for j in range(0,size-i): if seq[j+1] < seq[j]: seq[j+1],seq[j] = seq[j],seq[j+1] return seqdef _divide(seq, low, high): """快速排序划分函数""" tmp = seq[low] while low != high: while low < high and seq[high] >= tmp: high -= 1 if low < high: seq[low] = seq[high] low += 1 while low < high and seq[low] = high: return mid = _divide(seq, low, high) _quickSort(seq, low, mid - 1) _quickSort(seq, mid + 1, high)def quickSort(seq): """快速排序包裹函数""" size = len(seq) _quickSort(seq, 0, size - 1) return seqdef merge(seq, left, mid, right): tmp = [] i, j = left, mid while i < mid and j 运行结果如下： 代码如下:E:python_projectpractice>sorting.py[10, 47, 56, 76, 64, 84, 26, 8, 47, 51, 88, 81, 32, 95, 91, 29, 28, 69, 61, 45][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95]

我们在遇到一些问题的时候，使用集合的交集、并集和差集能够更便捷的帮助我们去解决问题，看下面一个例子。 某学校有两个班级，班级A需要学习数学、语文、英语、物理、化学和生物，班级B需要学习数学、语文、英语、政治、地理和历史。 我们可以直接看出A班级和B班级的交集为数学、语文和英语，并集为数学、语文、英语、物理、化学、生物、政治、地理、历史，A和B的差集为物理、化学和生物。 那么怎么使用Python去完成这些运算？ 我们先在这里定义两个集合， 因为是求交集，因此A和B的位置调换依然不影响结果。 使用集合求并集的方式同样也是两种方式，一种是使用 ‘|" 运算符进行操作，一种是使用 union() 方法来实现。 求并集的时候同样不需要注意 A 和 B 的位置关系。 使用集合求差集的方式同样也是两种方式，一种是使用 ‘-" 运算符进行操作，一种是使用 difference() 方法来实现。 在方法2中注意 A 和 B 的位置不同的时候是有区别的，如果是 A 使用 difference() 方法，那么是输出 A 中有而 B 中没有的元素，如果是 B 使用 difference() 方法，那么是输出 B 中有而 A 中没有的元素。 学习完了集合，四种核心集合我们已经基本掌握，接下来几节我们来通过学习一些字符串的相关操作，学习字符串的过程中会穿插着前面简单介绍过但没仔细讲解的方法及操作。

首先你要明白任何编程语言都只是你的工具，没有说哪方面比较重要，只有你是否需要使用它。比如文本处理，网络操作，语法树处理，你需要的才是对你重要的。你可以在你实际的工作里找一个项目，或者使用python完成自己的一个想法，实际编程中使用你需要使用的东西，这样你的python就会越来越熟练的。如果你觉得自己已经到了瓶颈，再怎么写也不进步了，也可以看看开源项目，比如django的源代码，也是可以的。

你可以到网络上下载现成的代码学习。扩展知识:Python是一种跨平台的计算机程序设计语言。 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。下载Python在您开始之前，你的计算机需要Python，但您可能不需要下载它。首先检查(在同级目录下在命令行窗口输入python)有没有安装Python。如果你看到了一个Python解释器的响应，那么就能在它的显示窗口中得到一个版本号。通常的版本都可以做到Python的向前兼容。如果您需要安装， 您不妨下载最近稳定的版本。 就是那个以没有被标记作为alpha或Beta发行的最高的版本。目前最稳定的版本是Python3.0以上

八爪鱼采集器是一款专注于数据采集的工具，不是Python第三方库。但是，如果您需要使用Python进行数据采集，可以考虑使用一些常用的Python第三方库，如：1. requests：用于发送HTTP请求，获取网页内容。2. BeautifulSoup：用于解析HTML或XML文档，提取所需的数据。3. Scrapy：一个强大的Python爬虫框架，可以用于高效地爬取网站数据。4. Selenium：用于模拟浏览器行为，实现动态网页的数据采集。5. Pandas：用于数据处理和分析，可以方便地对采集到的数据进行清洗和分析。6. NumPy：用于科学计算和数据分析，提供了高效的数组操作和数学函数。7. Matplotlib：用于数据可视化，可以绘制各种类型的图表。以上是一些常用的Python第三方库，可以根据您的具体需求选择适合的库进行数据采集和处理。八爪鱼为用户准备了一系列简洁易懂的教程，帮助大家快速掌握采集技巧，轻松应对各类网站数据采集，请前往官网教程与帮助了解更多详情。

既然是字典，那就直接按key提取就好了

代码有个地方写错了，47行改成一个等号就行了。就是Battery类的upgrade_battery方法的if里面的赋值语句，赋值用一个等号。你肯定是知道的，只不过不小心多嗯了一下而已。用个好点的开发环境吧，会提示出这里有问题的。

不需要这么麻烦，sf的用户认证主要是通过.SFCommunity这个cookie来实现的，可以用浏览器登陆后把cookie加到请求头里.或者下载一个现成的

语句块是在条件为真（条件语句）时执行或者执行多次（循环语句）的一组语句；在代码前放置空格来缩进语句即可创建语句块，语句块中的每行必须是同样的缩进量；（推荐学习：Python视频教程）缩进：Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯；Python语言利用缩进表示语句块的开始和退出（Off-side规则），而非使用花括号或者某种关键字；增加缩进表示语句块的开始，而减少缩进则表示语句块的退出。缩进是Python语法的一部分。下面的伪代码（并非真正的Python代码）展示了缩进的工作方式： this is a line this is a line this is another block continuing the same block the last line of this block phew,there we escaped the inner block多语言使用特殊单词或者字符（比如begin或{ ）来表示一个语句块的开始，用另外的单词或者字符（比如end或 }）表示语句块的结束。但是在Python中，冒号（：）用来标识语句块的开始，块中的每一个语句都是缩进的（缩进量相同）。当回退到和已经闭合的块一样的缩进量时，就表示当前块已经结束了。更多Python相关技术文章，请访问Python教程栏目进行学习！

def is_chinese(s):rt = Falseif s>= u"u4e00" and s<= u"u9fa6":rt = Truereturn rtss = "中文测试测试请说ha".decode("utf-8")for row in ss:print row,is_chinese(row)

将输入的图像shape记为[N, C, H, W]，这几个方法主要的区别就是在， batchNorm是在batch上，对NHW做归一化，对小batchsize效果不好； layerNorm在通道方向上，对CHW归一化，主要对RNN作用明显； instanceNorm在图像像素上，对HW做归一化，用在风格化迁移； GroupNorm将channel分组，然后再做归一化； SwitchableNorm是将BN、LN、IN结合，赋予权重，让网络自己去学习归一化层应该使用什么方法。 归一化与反归一化 https://blog.csdn.net/rehe_nofish/article/details/111413690 pytorch优雅的反归一化 https://blog.csdn.net/square_zou/article/details/99314197?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control 重点关注 图片保存：torchvision.utils.save_image(img, imgPath) https://blog.csdn.net/weixin_43723625/article/details/108159190

--snip--这个是代码片段的意思。你书上前面应该有写过这段代码，把前面的代码贴过来就好了。这个一般是作者偷懒或书本印刷篇幅有限，用到简称，--snip--只是个代号。

那个实例是py2.7，你应该用的py3.几肯定报错啊

--snip--是省略的意思，这本书的例子是一步步讲的，循序渐进，你需要把之前例子讲过的内容放进去，因为是重复代码，所以这里省略了，也就是说，你把定义的第二个dog类和snip删掉就行了。

snip 的英文原意是削减，剪去的意思。在Python 中，snip 就是代表省略代码的意思，把前面的代码贴过来就好了，刚好看到这里。 比如前面定义了一个类 class Person (): .......后面输入时又用到就可以调用，这时 snip就表示"......."里面的内容。snip 同时也表示代码片段的意思。扩展资料：Python应用：系统编程：提供API（Application Programming Interface应用程序编程接口），能方便进行系统维护和管理，Linux下标志性语言之一，是很多系统管理员理想的编程工具。图形处理：有PIL、Tkinter等图形库支持，能方便进行图形处理。数学处理：NumPy扩展提供大量与许多标准数学库的接口。文本处理：python提供的re模块能支持正则表达式，还提供SGML，XML分析模块，许多程序员利用python进行XML程序的开发。数据库编程：程序员可通过遵循Python DB-API（数据库应用程序编程接口）规范的模块与Microsoft SQL Server，Oracle，Sybase，DB2，MySQL、SQLite等数据库通信。python自带有一个Gadfly模块，提供了一个完整的SQL环境。网络编程：提供丰富的模块支持sockets编程，能方便快速地开发分布式应用程序。很多大规模软件开发计划例如Zope，Mnet 及BitTorrent. Google都在广泛地使用它。Web编程：应用的开发语言，支持最新的XML技术。多媒体应用：Python的PyOpenGL模块封装了“OpenGL应用程序编程接口”，能进行二维和三维图像处理。PyGame模块可用于编写游戏软件。pymo引擎：PYMO全称为python memories off，是一款运行于Symbian S60V3,Symbian3,S60V5, Symbian3, Android系统上的AVG游戏引擎。因其基于python2.0平台开发，并且适用于创建秋之回忆（memories off）风格的AVG游戏，故命名为PYMO。参考资料：百度百科-Python （计算机程序设计语言）

就是代表省略代码的意思，把前面的代码贴过来就好了，刚好看到这里。 比如前面定义了一个类 class Car(): .......后面输入时又用到就可以调用，这时 snip就表示"......."里面的内容

在python中，关于将字符串大小写转化的方法十分简单，下面给大家演示一下：upper()将小写字母转换成大写字母；lower()将大写字母转换成小写字母；capitalize()只将第一个字母转换为大写；title()将每个单词的第一个字母转换为大写，其余小写。以php例子,在shell下演示：>>> str="www.gxlcms.com.">>> print(str.upper()) # 把所有字符中的小写字母转换成大写字母WWW.PHP.CN.>>> print(str.lower()) # 把所有字符中的大写字母转换成小写字母www.gxlcms.com.>>> print(str.capitalize())# 把第一个字母转化为大写字母，其余小写Www.php.cn.>>> print(str.title()) # 把每个单词的第一个字母转化为大写，其余小写Www.Php.Cn.

TensorRT repo 参考 csdn 在 TensorRT/samples/python/ 下参考 costom 编写方式和cmake，docker环境里make生成 .so, 注意插件名字和trt用到的组件名应该一致 python 加载插件 如果用 trtexec ，需要 vim .bashrc 安装依赖 参考

相对与ONNX模型，Pytorch模型经常较为松散，API的限制也往往较为宽松。因此，在导出的过程中，不可避免地会遇到导出失败的问题。可以预见到，这块API可能在不久的将来会发生变化。 ONNX导出的基本操作比较简单。官网上的例子是： 可惜真要这么容易就好了 支持Batching需要制定Dynamic Axes，即可变的维度。 案例: keep_initializers_as_inputs 这个参数是False的情况下，在Caffe2中报错：IndexError: _Map_base::at. 参考 https://github.com/onnx/onnx/issues/2458 问题比较复杂。貌似tensorflow也有类似问题。导出时添加参数do_constant_folding=True或许可以解决。 参考 https://github.com/NVIDIA/triton-inference-server/issues/1080 定长list会导出为一个tuple Pytorch 1.4，ONNX 9不支持变长List的导出。之后的Pytorch版本有支持，需要更高版本的ONNX Pytorch中，Expand未改动的dim可以指定为-1，导出到ONNX中时，需要手动指定每个dim的值。如： Pytorch中，Squeeze一个不为1维的dim不会有任何效果。ONNX会报错

1. 如果你想看怎么实现，你可以去看xmltodict这个第三方库，2. 如果你想直接使用，也是去看xnltodict这个库，3. 总的来说，就是你可以用xmltodict实现，先转换成python标准的dict，再用python自带的json.dumps()转换即可

需安装sxtwl包，命令如下pip install sxtwl农历(Lunar calendar)<->阳历(solar calendar)转换代码如下(基于python3)：import sxtwl#日历中文索引ymc = [u"十一", u"十二", u"正", u"二", u"三", u"四", u"五", u"六", u"七", u"八", u"九", u"十" ]rmc = [u"初一", u"初二", u"初三", u"初四", u"初五", u"初六", u"初七", u"初八", u"初九", u"初十", u"十一", u"十二", u"十三", u"十四", u"十五", u"十六", u"十七", u"十八", u"十九", u"二十", u"廿一", u"廿二", u"廿三", u"廿四", u"廿五", u"廿六", u"廿七", u"廿八", u"廿九", u"三十", u"卅一"]# 日历库实例化lunar = sxtwl.Lunar()# 1.阴历转阳历solar_day = lunar.getDayByLunar(2019,7,27) print("公历(阳历)：{0}年{1}月{2}日".format(solar_day.y, solar_day.m, solar_day.d))# 2.阳历转阴历from datetime import datetoday = str(date.today()) # 如 2019-08-08today_list = today.split("-") # ["2019", "08", "08"]lunar_day = lunar.getDayBySolar((int)(today_list[0]),(int)(today_list[1]),(int)(today_list[2])) # 输入年月日# 判断是否为润年if(lunar_day.Lleap): print("阴历(农历):{0}月{1}".format(ymc[lunar_day.Lmc], rmc[lunar_day.Ldi]))else: print("阴历(农历):{0}月{1}".format(ymc[lunar_day.Lmc], rmc[lunar_day.Ldi]))结果为"""公历(阳历)：2019年8月27日阴历(农历):七月初八"""

易语言就是个垃圾.. 怎么可能与python相提并论...

在正则表达式里,想匹配一些字符中的一个,也就是说给出一个字符的集合,只要出现这个集合里任意的字符,都是成立的，下面这篇文章主要给大家介绍了关于python利用正则表达式排除集合中字符功能的相关资料，需要的朋友可以参考下。前言我们在之前学习过通过集合枚举的功能，把所有需要出现的字符列出来，保存在集合里面，这样正则表达式就可以根据集合里的字符是否存在来判断是否匹配成功，如果在集合里，就匹配成功，否则不成功。现在有一个问题，就是要把集合里列出的字符都不能出现才匹配成功，这个需求怎么样实现呢？其实比较简单，只需要在集合前面添加一个字符^，就让正则表达式匹配时，发现有字符在集合里就匹配不成功。下面话不多说了，来一起看看详细的介绍吧。例子如下：#python 3.6 #蔡军生 #http://blog.csdn.net/caimouse/article/details/51749579 # from re_test_patterns import test_patterns test_patterns( "This is some text -- with punctuation.", [("[^-. ]+", "sequences without -, ., or space")], )结果输出如下："[^-. ]+" (sequences without -, ., or space) "This is some text -- with punctuation." "This" ....."is" ........"some" ............."text" ....................."with" .........................."punctuation"在这个例子里，就把划线、句号、空格（-，.， ，）等字符排除在外。总结

爬虫目前主要开发语言为java、Python、c++ 对于一般的信息采集需要，各种语言差别不大。c、c++ 搜索引擎无一例外使用CC++ 开发爬虫，猜想搜索引擎爬虫采集的网站数量巨大，对页面的解析要求不高，部分支持javascriptpython 网络功能强大，模拟登陆、解析javascript，短处是网页解析 python写起程序来真的很便捷，著名的python爬虫有scrapy等java java有很多解析器，对网页的解析支持很好，缺点是网络部分 java开源爬虫非常多，著名的如 nutch 国内有webmagic java优秀的解析器有htmlparser、jsoup对于一般性的需求无论java还是python都可以胜任。如需要模拟登陆、对抗防采集选择python更方便些，如果需要处理复杂的网页，解析网页内容生成结构化数据或者对网页内容精细的解析则可以选择java。

class subclass(superclass1,superclass2):一个子类当然可以继承多个超类,以上表示定义一个subclass类,从类superclass1,superclass2继承比如下面的代码子类C就继承了A和B类class A:def __init__(self):self.one="one"class B:def __init__(self):self.two="two"class C(A,B):def __init__(self):A.__init__(self)B.__init__(self)def printselfnum(self):print(self.one,self.two)c=C()c.printselfnum()

要把代码发现来才知道，以下是常见的错误下面终于要讲到当你用到更多的Python的功能（数据类型，函数，模块，类等等）时可能碰到的问题了。由于篇幅有限，这里尽量精简，尤其是对一些高级的概念。要想了解更多的细节，敬请阅读Learning Python, 2nd Edition的“小贴士”以及“Gotchas”章节。打开文件的调用不使用模块搜索路径当你在Python中调用open()来访问一个外部的文件时，Python不会使用模块搜索路径来定位这个目标文件。它会使用你提供的绝对路径，或者假定这个文件是在当前工作目录中。模块搜索路径仅仅为模块加载服务的。不同的类型对应的方法也不同列表的方法是不能用在字符串上的，反之亦然。通常情况下，方法的调用是和数据类型有关的，但是内部函数通常在很多类型上都可以使用。举个例子来说，列表的reverse方法仅仅对列表有用，但是len函数对任何具有长度的对象都适用不能直接改变不可变数据类型记住你没法直接的改变一个不可变的对象（例如，元组，字符串）：T = (1, 2, 3)T[2] = 4 # 错误用切片，联接等构建一个新的对象，并根据需求将原来变量的值赋给它。因为Python会自动回收没有用的内存，因此这没有看起来那么浪费：T = T[:2] + (4,) # 没问题了: T 变成了 (1, 2, 4)使用简单的for循环而不是while或者range当你要从左到右遍历一个有序的对象的所有元素时，用简单的for循环（例如，for x in seq:）相比于基于while-或者range-的计数循环而言会更容易写，通常运行起来也更快。除非你一定需要，尽量避免在一个for循环里使用range：让Python来替你解决标号的问题。在下面的例子中三个循环结构都没有问题，但是第一个通常来说更好；在Python里，简单至上。S = "lumberjack"for c in S: print c # 最简单for i in range(len(S)): print S[i] # 太多了i = 0 # 太多了while i < len(S): print S[i]; i += 1不要试图从那些会改变对象的函数得到结果诸如像方法list.append()和list.sort()一类的直接改变操作会改变一个对象，但不会将它们改变的对象返回出来（它们会返回None）；正确的做法是直接调用它们而不要将结果赋值。经常会看见初学者会写诸如此类的代码：mylist = mylist.append(X)目的是要得到append的结果，但是事实上这样做会将None赋值给mylist，而不是改变后的列表。更加特别的一个例子是想通过用排序后的键值来遍历一个字典里的各个元素，请看下面的例子：D = {...}for k in D.keys().sort(): print D[k]差一点儿就成功了——keys方法会创建一个keys的列表，然后用sort方法来将这个列表排序——但是因为sort方法会返回None，这个循环会失败，因为它实际上是要遍历None（这可不是一个序列）。要改正这段代码，将方法的调用分离出来，放在不同的语句中，如下：Ks = D.keys()Ks.sort()for k in Ks: print D[k]只有在数字类型中才存在类型转换在Python中，一个诸如123+3.145的表达式是可以工作的——它会自动将整数型转换为浮点型，然后用浮点运算。但是下面的代码就会出错了：S = "42"I = 1X = S + I # 类型错误这同样也是有意而为的，因为这是不明确的：究竟是将字符串转换为数字（进行相加）呢，还是将数字转换为字符串（进行联接）呢？在Python中，我们认为“明确比含糊好”（即，EIBTI（Explicit is better than implicit）），因此你得手动转换类型：X = int(S) + I # 做加法: 43X = S + str(I) # 字符串联接: "421"循环的数据结构会导致循环尽管这在实际情况中很少见，但是如果一个对象的集合包含了到它自己的引用，这被称为循环对象（cyclic object）。如果在一个对象中发现一个循环，Python会输出一个[…]，以避免在无限循环中卡住：>>> L = ["grail"] # 在 L中又引用L自身会>>> L.append(L) # 在对象中创造一个循环>>> L["grail", [...]]除了知道这三个点在对象中表示循环以外，这个例子也是很值得借鉴的。因为你可能无意间在你的代码中出现这样的循环的结构而导致你的代码出错。如果有必要的话，维护一个列表或者字典来表示已经访问过的对象，然后通过检查它来确认你是否碰到了循环。赋值语句不会创建对象的副本，仅仅创建引用这是Python的一个核心理念，有时候当行为不对时会带来错误。在下面的例子中，一个列表对象被赋给了名为L的变量，然后L又在列表M中被引用。内部改变L的话，同时也会改变M所引用的对象，因为它们俩都指向同一个对象。>>> L = [1, 2, 3] # 共用的列表对象>>> M = ["X", L, "Y"] # 嵌入一个到L的引用>>> M["X", [1, 2, 3], "Y"]>>> L[1] = 0 # 也改变了M>>> M["X", [1, 0, 3], "Y"]通常情况下只有在稍大一点的程序里这就显得很重要了，而且这些共用的引用通常确实是你需要的。如果不是的话，你可以明确的给他们创建一个副本来避免共用的引用；对于列表来说，你可以通过使用一个空列表的切片来创建一个顶层的副本：>>> L = [1, 2, 3]>>> M = ["X", L[:], "Y"] # 嵌入一个L的副本>>> L[1] = 0 # 仅仅改变了L，但是不影响M>>> L[1, 0, 3]>>> M["X", [1, 2, 3], "Y"]切片的范围起始从默认的0到被切片的序列的最大长度。如果两者都省略掉了，那么切片会抽取该序列中的所有元素，并创造一个顶层的副本（一个新的，不被公用的对象）。对于字典来说，使用字典的dict.copy()方法。静态识别本地域的变量名Python默认将一个函数中赋值的变量名视作是本地域的，它们存在于该函数的作用域中并且仅仅在函数运行的时候才存在。从技术上讲，Python是在编译def代码时，去静态的识别本地变量，而不是在运行时碰到赋值的时候才识别到的。如果不理解这点的话，会引起人们的误解。比如，看看下面的例子，当你在一个引用之后给一个变量赋值会怎么样：>>> X = 99>>> def func():... print X # 这个时候还不存在... X = 88 # 在整个def中将X视作本地变量...>>> func( ) # 出错了！你会得到一个“未定义变量名”的错误，但是其原因是很微妙的。当编译这则代码时，Python碰到给X赋值的语句时认为在这个函数中的任何地方X会被视作一个本地变量名。但是之后当真正运行这个函数时，执行print语句的时候，赋值语句还没有发生，这样Python便会报告一个“未定义变量名”的错误。事实上，之前的这个例子想要做的事情是很模糊的：你是想要先输出那个全局的X，然后创建一个本地的X呢，还是说这是个程序的错误？如果你真的是想要输出这个全局的X，你需要将它在一个全局语句中声明它，或者通过包络模块的名字来引用它。默认参数和可变对象在执行def语句时，默认参数的值只被解析并保存一次，而不是每次在调用函数的时候。这通常是你想要的那样，但是因为默认值需要在每次调用时都保持同样对象，你在试图改变可变的默认值（mutable defaults）的时候可要小心了。例如，下面的函数中使用一个空的列表作为默认值，然后在之后每一次函数调用的时候改变它的值：>>> def saver(x=[]): # 保存一个列表对象... x.append(1) # 并每次调用的时候... print x # 改变它的值...>>> saver([2]) # 未使用默认值[2, 1]>>> saver() # 使用默认值[1]>>> saver() # 每次调用都会增加！[1, 1]>>> saver()[1, 1, 1]有的人将这个视作Python的一个特点——因为可变的默认参数在每次函数调用时保持了它们的状态，它们能提供像C语言中静态本地函数变量的类似的一些功能。但是，当你第一次碰到它时会觉得这很奇怪，并且在Python中有更加简单的办法来在不同的调用之间保存状态（比如说类）。要摆脱这样的行为，在函数开始的地方用切片或者方法来创建默认参数的副本，或者将默认值的表达式移到函数里面；只要每次函数调用时这些值在函数里，就会每次都得到一个新的对象：>>> def saver(x=None):... if x is None: x = [] # 没有传入参数？... x.append(1) # 改变新的列表... print x...>>> saver([2]) # 没有使用默认值[2, 1]>>> saver() # 这次不会变了[1]>>> saver()[1]其他常见的编程陷阱下面列举了其他的一些在这里没法详述的陷阱：在顶层文件中语句的顺序是有讲究的：因为运行或者加载一个文件会从上到下运行它的语句，所以请确保将你未嵌套的函数调用或者类的调用放在函数或者类的定义之后。reload不影响用from加载的名字：reload最好和import语句一起使用。如果你使用from语句，记得在reload之后重新运行一遍from，否则你仍然使用之前老的名字。在多重继承中混合的顺序是有讲究的：这是因为对superclass的搜索是从左到右的，在类定义的头部，在多重superclass中如果出现重复的名字，则以最左边的类名为准。在try语句中空的except子句可能会比你预想的捕捉到更多的错误。在try语句中空的except子句表示捕捉所有的错误，即便是真正的程序错误，和sys.exit()调用，也会被捕捉到。

用python怎么抓取道客巴巴文件就是Linuxshell脚本了，我们通常说“事半功倍”，shell脚本的确可以帮助你实现这个目的。我们平时在LINUX部署一个应用会用到很多的命令如 Checkout，ps，vi，kill等等，如果能把这个操作流程写成一个SHELL脚本让机器自动执行，那该是省了多少事？另外，作为 UNIX/LINUX管理员，平时可以要监控较多的PC终端，他完全可以在UNIX/LINUX上定制各种任务（如备份，删除临时文件，检查磁盘空间等等），所以，掌握Shell脚本（如Sed，awk，grep等）对一个测试人员来讲是十分必要的！

通API功能及相应权限部主要要googleapi需要自通首先默认情况google没放服务需要首先告诉google 我发者我要做项目项目面需要用某些api功能给我通打,第步创建项目创建项目候要名字输入些品牌信息需要用户授权才能看同要要选择客户端web程序桌面程序手机段同项目代表满足同需求程序用api

公司有个业务是使用python脚本调用.so文件,但是有时候so文件内部发生错误,python就直接崩溃了,无任何提示信息,所以很不方便找错误原因. 使用 gdb 可以看到更详细的一些信息,其使用方式如下: ulimit -c 是查看创建的核心转储的最大大小,这里为0,是需要修改的,可以将其改成不限制大小的 unlimited . cat /proc/sys/kernel/core_pattern 这一步我的理解是查看到时候生成的缓存文件存储名称,这里为 core ,表示其会在当前目录下生成一个名为core的缓存文件,但是为了使其更加通用,可以修改一下其路径和名称格式. 可以看到在 var/cores 目录下生成了一个 core.python.31796 文件,此时可以在刚才的运行目录下执行,下面的 which 前面是`符号,不是单引号 此时可以看到项目最终是在 #0 0x00007f89d8700960 in mkl_pds_lp64_ladj_mod_pardiso () from /usr/lib/libmkl_intel_thread.so 时发生了错误,这个时候可以输入 bt 查看更多,其从上到下是错误从底层到最外层的顺序. 若执行的时候没有 gdb ,可以执行 apt-get install gdb 安装. 还有就是,若查看的时候错误地方是 #0 0x00000000005406df in ?? () 这样的没有具体函数名的情况,这是因为so文件在编译时候没有链接符号到文件里面,需要在使用gcc编译的时候加上 -g

作为一个程序员，我没听说过kitten。百度了一下，可能是少儿编程工具吧。所以要当饭吃的话，当然是python了。python除了基本的语法要学，找工作的话，你还的选一个具体方向深入学习，比如数据分析、数据挖掘（爬虫）等。。。做到学而精