yth

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的未来，我们也将拭目以待。

你特么说反了吧

Youaremyeverthing나의하루속에니가살고있다는게每时每刻你都一直陪伴在我身边많은사람중에니가내사랑이란게人海茫茫中你就是我的那份真爱내겐얼만큼놀라운일인지这对我来说是一件多么不可思议的事情아마넌짐작도못할거야你可能根本想象不到사랑한단말로대신다할수없어서用一句“我爱你”都远远不足以表达这份爱이가슴으로는전부담을수없어서用一颗心都远远装不下这份爱매일수백번수천번되물어每天我都要反问自己无数次이행복다가져도되는지~这份幸福可以属于我吗?You"remyeverything.나항상곁에서널사랑하는일변하지않을께我永远都会在你身边我永远都会爱你再过多久也不会改变You"remyeverything.아무리험한길이라도널혼자두는일없을께即便前路再崎岖你也不会独行You"remyeverything.아프고힘든일내가다먼저할거야痛苦与辛苦都由我来担더좋은것들만너에게양보할거야所有好事情都要让给你너의웃음이매일어제보다这样才能让你每天的微笑오늘더자라날수있도록~都比前一天的更灿烂You"remyeverything.나항상곁에서널사랑하는일변하지않을께我永远都会在你身边我永远都会爱你再过多久也不会改变You"remyeverything.아무리험한길이라도널혼자두는일없을께即便前路再崎岖你也不会独行You"remyeverything.Yeah~나에게하늘이허락한날까지直到我走到生命尽头的那一天내남은사랑이다하는날까지直到我心中的爱都用尽的那一天You"remyeverything.You"remyallI"lldoeverything.나얼마나널사랑하는지,또감사하는지你可知道我是多么爱你我是多么谢谢你니가후회하지않도록잘할께我会做到让你毫不后悔Oh~Justyouaremyeverything.在电驴评论上看到的

遗忘的世界,被世界遗忘. 忧伤的美丽,比美丽更美. 或者 被世界遗忘的人,生活在遗忘的世界里 忧愁,比美丽本身更动人.

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__ ，但实际上这是不被允许的。 抽空找时间我会考虑下有无可行性。

【答案】：B46．【解析】选[B]。此句是说后来发展了一种用声音来计数的方法。[A]noises意为“噪音、喧闹声”，常指不悦耳、不和谐的嘈杂声；[B]sounds作“声音，响声”讲时，可以指人或动物发出的声音，或物体碰撞的声音，这个词的使用范围很大。可以说，大自然的任何“声音”都可以用sound；[C]voices一般指人的声音，说话、唱歌、谈笑都可用v01ce；[D]rhythms指音律。此处的vocal提示此处应填[B]sounds，voice与其重复，故排除。

从零开始用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专业的学校都是不错的，建议实地考察对比一下。祝你学有所成，望采纳。请点击输入图片描述

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

建议加大悬赏或者如果有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提取就好了

on top of every thing else在一切之上重点词汇on top of在…上边; 在…上方; 除…之外; 接着thing事件，形势; 东西，事物; 家伙; 事业else其他; 否则; 另外; 别的; 其他的希望对你有帮助~

【答案】：B名词辨析。ratio意为“比率”；rate意为“速度”；rhythm意为“节奏”；rhyme意为“韵律”。此处指土耳其经济发展的速度，rate符合题意。

假设预测目标为0和1数据中1的个数为a，预测1的次数为b，预测1命中的次数为c准确率 precision = c / b召回率 recall = c / af1_score = 2 * precision * recall / (precision + recall)

代码有个地方写错了，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)

无论是单细胞、空间组还是ATAC的数据，有时由于下游分析的需求或可视化的需求，同时由于python的运算速度的优势，目前越来越多单细胞分析的工具开始在python环境下开发（scanpy/spGCN/scVelo……），但是大家大多都习惯了R的分析环境（Seurat/Harmony/Monocle3……），所以我们经常需要在不同的环境中运行同一个分析对象，这所以涉及到的数据类型的转变就非常关键了。 想直接想找工具将RDS转为python可读数据对象的包，目前还没有……（如果有大佬可以开发一下）。 目前所以从数据本身出发有三种方式，总结自目前网络上一些可行的方法： 1，提取矩阵（稀疏/稠密）和特征信息（metadata），手动构筑 anndata （单细胞分析时python中的一种数据结构，具体了解可以看一下： https://www.jianshu.com/p/9b057e105c42 ，写得挺好）就好。前提是对R的S4对象和python的anndata对象有基础的认识，就可以搞定，这是最本质也是最万能的方法，除了门槛高。 2，存储的时候就注意，不要保存成rds，或者已经这样保存了也无所谓，可以读入再重新存： （1）存储成 h5ad格式 。Seurat数据写成h5需要借助包 SeuratDisk : https://github.com/mojaveazure/seurat-disk 从R环境下Seurat的对象保存成h5ad的格式： 然后用python的anndata包/scanpy包直接读入就好，因为h5ad本来就是单细胞在跑一python环境中分析最基础的格式，对标R中的seurat对象或sce对象 这个方法可以具体参考： https://www.jianshu.com/p/c438d545f696 他写得更加详细一点 （2）Seurat官方设置 loom格式 也是可行方式之一： 参见： https://www.jianshu.com/p/147da295fc34 将Seurat对象转为loom: 在python环境下读入loom，成为adata: 总而言之，经个人使用和实际操作来说， 第二个存储成为h5ad的方法时最好用的、也最友好 ，除了只能保存一个assay之外，就都没问题，但是如果许多保存多个assay成为anndata中的多个layer，这就的用手动的方法了。

--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.

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日阴历(农历):七月初八"""

ShelleyThomasShelleyThomas是一名演员，主要作品有《全金属狂潮》等。外文名：ShelleyThomas职业：应用代表作品：《全金属狂潮》合作人物：杰森·道格拉斯

易语言就是个垃圾.. 怎么可能与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"在这个例子里，就把划线、句号、空格（-，.， ，）等字符排除在外。总结

歌曲名:Everything歌手:Status Quo专辑:At Their BestTerrell Carter - EverythingThis is divorce.Oow..This is divorce.(urhh..)As we stand before the judge, it"s over now.Can"t even get my name and go on somehow.Its my time to sign on the dotted line.The spark came in my head before the ink dried.I"m getting nothing I want (Damn)Knowing I don"t give a damn for this single life.Eleven months with you, I"m tripping cause it"s through.I"m standing here looking at you.There aint no more, ghetto love.No more, breaking up.No more, making up.No more, waking you up.No more, things you hate.No more, holidays.No more, need to celebrate.No more, goodnight baby.You wanted half, just take it all.Cause it doesn"t even matter anymore.We didn"t last, cause now you"re gone.Just take everything, everything, everything.You wanted half, you can have it all.What the hell am I gon" do with just half of you.Girl you can keep, even both rings.Just take, everything, everything, everything.I don"t want the house, I"m moving out.Can"t stand staying here without you around.All of the cars, I will sell them but just one, I will mail them.And as for the kids, I get weekends.Baby I ain"t even mad, I wish you well.And I"ll be wrong to tell you to go to hell.Cause you"re still the one I love, we"re just giving up.Guess it"s best for us, can"t help how it hurts.There ain"t no more honey combs.No more, Oprah"s on.No more, Looney Tunes.No more, Southpark with you.No more, the phone"s for me.No more, did the doorbell ring.No more, can you come get me.No more, there"s no more baby.You wanted half, just take it all.Cause it doesn"t even matter anymore.We didn"t last, cause now you"re gone.Just take everything, everything, everything.You wanted half, you can have it all.What the hell am I gon" do with just half of you.Girl you can keep, even both rings.Just take, everything, everything, everything.And if this is divorce, I don"t want a war.I don"t want to fight with you no more.Take everything, you can have everything.Material things, your last.(x4)You wanted half, just take it all.Cause it doesn"t even matter anymore.We didn"t last, cause now you"re gone.Just take everything, everything, everything.You wanted half, you can have it all.What the hell am I gon" do with just half of you.Girl you can keep, even both rings.Just take, everything, everything, everything.http://music.baidu.com/song/7654037

WittyThumb是一家线上聊天咨询和指导平台，用户将自己的聊天截图上传到网站并添加聊天的基础背景信息后，平台上的专家或者其他用户会对图片自由添加批注并打分，还可以提供一对一指导收费服务。更多同行分析，上企知道了解

rhythmic的mylove作词：RinaMoon作曲：BAYAMitz夕暮れに、じゃれ合ってみつけたオレンジの空(I"llbetheone)気まぐれな仆らはただ梦を描いた数えきれない思い出、笑颜、全部(Time)大人になるんだね未来への扉を开いてねえ、10年後も一绪にこの场所でそう二人离れても繋がってるよ悲しいとき、苦しいとき思い出すよいつだって「味方でいる」って约束Ohbaby,baby朝まで付き合ってくれて本当にありがとう(I"llbetheone)泣きながらすがるように电话したのに君は全部わかってたみたいな声で(Smile)优しく包んでくれたね忘れないねえ、10年後も一绪に笑い合っていたい离れても繋がってるよ次会える日约束して「すぐだよ」って抱きしめていつもそばにいてくれたOhbaby,baby繋いだ手を离し「じゃあね」イヤだよまだ帰りたくないよ...このまま时が止まれば君の腕の中ずっと爱してるこんなにもMylove苦しいのねえ、10年後は二人この手を离さずに寄り添っていられるよね信じてるよ爱してるよそばでずっと嗫いて「いつでもそばにいるから」Ohbaby,babyキミとならMylove嗫くこのOneloveこのままMylove...Oneloveキミだけだよずっとそばにいるよ信じて爱して届けようMylove

rhythmic pattern韵律模式双语例句1The Rhythmic Pattern of Slow Wave of the Gastroelectro& activity狗胃电慢波的节律类型2Rhythmic Pattern and Rules of Dynamic Variations in SpontaneousDischarge of Injured Dorsal Root Ganglion Neurons损伤背根节神经元自发放电的节律形式及其动力学变化规律

恩~~是~~

我明白你这种疑惑,我也曾有过. 我还记得中学的时候老师在课堂上讲——“anything和everything都有表示‘所有事情"的意思.”、“anything往往用在否定句或疑问句中,而everything则用在肯定句中.” 既然两者意思相当,为什么只能用Anything?而且,Anything is possible.显然是肯定句,这就违背了老师所讲的用法了.那为什么还非要用Anything? 我的老师告诉我—— 其实,语法和规则都是人们总结出来的,并不能概括或限制所有词汇在实际语境中的应用.常规中也有例外,Anything也可以用在肯定句中,只不过出现的频率不高而已. 而真正的解惑点在于两者的词义上. anything的意思是任何的东西,表示任何事情；everything意味的是每一样东西,可引申为所有的东西（你要明白‘任何"和‘每一样"之间的差别：‘任何"是一上来就将全部概括完了,大包大揽；而‘每一样"是可以特指某种类别的,囊括范围更小.） 综上,你也能看出了,相较everything而言,anything不仅包含面更广,语气也更强. 所以,在需要表示程度范围广大的“一切皆有可能”这个语境中,everything被舍弃了.

如果 “一切” 指代的事物是明确的，可以说 Everything is possible.如果 “一切” 指代的事物是含糊的，可以说 Anything is possible.如果这种可能是是决然否定的，可以说 Nothing is Impossible.

爬虫目前主要开发语言为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除了基本的语法要学，找工作的话，你还的选一个具体方向深入学习，比如数据分析、数据挖掘（爬虫）等。。。做到学而精

the true courage is not to overcome everything, but not to be overwhelmed by everything.意思是：真正的勇气不是去征服一切，而是不要被一切所征服。

最近在学习python过程中，发现了%（百分号）的一些情况，这里就简单介绍一下。python里百分号有2个意思，计算数的时候，它是求余数的意思；另外一个是格式化字符串的作用，如："%d %s" %(12, "abc") 就把%d换成12， %s换成abc，得到 "12 abc"。（推荐学习：Python视频教程）第一种：数值运算 1 % 3 是指模运算, 取余数（remainder）>>> 7%21第二种：字符串操作 "abc %s" % "abc" "%s"类似占位符问的是%操作符（字符串格式化，string formatting），说明如下：%[(name)][flags][width].[precision]typecodeflags可以有+，-，" "或0。+表示右对齐。-表示左对齐。" "为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填充。width表示显示宽度precision表示小数点后精度举例>>> print("%6.3f" % 2.3) 2.300# 第一个"%"后面的内容为显示的格式说明，6为显示宽度，3为小数点位数，f为浮点数类型 # 第二个"%"后面为显示的内容来源，输出结果右对齐，2.300长度为5，故前面有一空格更多Python相关技术文章，请访问Python教程栏目进行学习！

python读取excel表数据的方法：首先安装Excel读取数据的库xlrd；然后获取Excel文件的位置并且读取进来；接着读取指定的行和列的内容，并将内容存储在列表中；最后运行程序即可。python读取excel表数据的方法：1、安装Excel读取数据的库-----xlrd直接pip install xlrd安装xlrd库#引入Excel库的xlrdimport xlrd2、获取Excel文件的位置并且读取进来#导入需要读取Excel表格的路径data = xlrd.open_workbook(r"C:UsersNHTDesktopData est1.xlsx")table = data.sheets()[0]3、读取指定的行和列的内容，并将内容存储在列表中（将第三列的时间格式转换）#创建一个空列表，存储Excel的数据tables = []#将excel表格内容导入到tables列表中def import_excel(excel): for rown in range(excel.nrows): array = {"road_name":"","bus_plate":"","timeline":"","road_type":"","site":""} array["road_name"] = table.cell_value(rown,0) array["bus_plate"] = table.cell_value(rown,1) #将Excel表格中的时间格式转化 if table.cell(rown,2).ctype == 3: date = xldate_as_tuple(table.cell(rown,2).value,0) array["timeline"] = datetime.datetime(*date) array["road_type"] = table.cell_value(rown,3) array["site"] = table.cell_value(rown,4) tables.append(array)4、运行程序if __name__ == "__main__": #将excel表格的内容导入到列表中 import_excel(table) #验证Excel文件存储到列表中的数据 for i in tables: print(i)5、最终的运行效果如下：6、完整的程序代码：import xlrdfrom xlrd import xldate_as_tupleimport datetime#导入需要读取的第一个Excel表格的路径data1 = xlrd.open_workbook(r"C:UsersNHTDesktopData est.xlsx")table = data1.sheets()[0]#创建一个空列表，存储Excel的数据tables = []#将excel表格内容导入到tables列表中def import_excel(excel): for rown in range(excel.nrows): array = {"road_name":"","bus_plate":"","timeline":"","road_type":"","site":""} array["road_name"] = table.cell_value(rown,0) array["bus_plate"] = table.cell_value(rown,1) if table.cell(rown,2).ctype == 3: date = xldate_as_tuple(table.cell(rown,2).value,0) array["timeline"] = datetime.datetime(*date) array["road_type"] = table.cell_value(rown,3) array["site"] = table.cell_value(rown,4) tables.append(array)if __name__ == "__main__": #将excel表格的内容导入到列表中 import_excel(table) for i in tables: print(i)更多相关免费学习推荐：python视频教程

用python画烟花的方法：首先创建一个所有粒子同时扩大的二维列表；然后实现粒子范围扩大，以自由落体坠落；接着移除超过最高时长的粒子；最后循环调用保持不停。用python画烟花的方法：# -*- coding: utf-8 -*-# Nolaimport tkinter as tkfrom PIL import Image, ImageTkfrom time import time, sleepfrom random import choice, uniform, randintfrom math import sin, cos, radians# 模拟重力GRAVITY = 0.05# 颜色选项（随机或者按顺序）colors = ["red", "blue", "yellow", "white", "green", "orange", "purple", "seagreen", "indigo", "cornflowerblue"]"""particles 类粒子在空中随机生成随机，变成一个圈、下坠、消失属性: - id: 粒子的id - x, y: 粒子的坐标 - vx, vy: 在坐标的变化速度 - total: 总数 - age: 粒子存在的时长 - color: 颜色 - cv: 画布 - lifespan: 最高存在时长"""class Particle: def __init__(self, cv, idx, total, explosion_speed, x=0., y=0., vx=0., vy=0., size=2., color="red", lifespan=2, **kwargs): self.id = idx self.x = x self.y = y self.initial_speed = explosion_speed self.vx = vx self.vy = vy self.total = total self.age = 0 self.color = color self.cv = cv self.cid = self.cv.create_oval( x - size, y - size, x + size, y + size, fill=self.color) self.lifespan = lifespan def update(self, dt): self.age += dt # 粒子范围扩大 if self.alive() and self.expand(): move_x = cos(radians(self.id * 360 / self.total)) * self.initial_speed move_y = sin(radians(self.id * 360 / self.total)) * self.initial_speed self.cv.move(self.cid, move_x, move_y) self.vx = move_x / (float(dt) * 1000) # 以自由落体坠落 elif self.alive(): move_x = cos(radians(self.id * 360 / self.total)) # we technically don"t need to update x, y because move will do the job self.cv.move(self.cid, self.vx + move_x, self.vy + GRAVITY * dt) self.vy += GRAVITY * dt # 移除超过最高时长的粒子 elif self.cid is not None: cv.delete(self.cid) self.cid = None # 扩大的时间 def expand (self): return self.age <= 1.2 # 粒子是否在最高存在时长内 def alive(self): return self.age <= self.lifespan"""循环调用保持不停"""def simulate(cv): t = time() explode_points = [] wait_time = randint(10, 100) numb_explode = randint(6, 10) # 创建一个所有粒子同时扩大的二维列表 for point in range(numb_explode): objects = [] x_cordi = randint(50, 550) y_cordi = randint(50, 150) speed = uniform(0.5, 1.5) size = uniform(1, 3) color = choice(colors) explosion_speed = uniform(0.2, 1) total_particles = randint(10, 50) for i in range(1, total_particles): r = Particle(cv, idx=i, total=total_particles, explosion_speed=explosion_speed, x=x_cordi, y=y_cordi, vx=speed, vy=speed, color=color, size=size, lifespan=uniform(0.6, 1.75)) objects.append(r) explode_points.append(objects) total_time = .0 # 1.8s内一直扩大 while total_time < 1.8: sleep(0.01) tnew = time() t, dt = tnew, tnew - t for point in explode_points: for item in point: item.update(dt) cv.update() total_time += dt # 循环调用 root.after(wait_time, simulate, cv)def close(*ignore): """退出程序、关闭窗口""" global root root.quit()if __name__ == "__main__": root = tk.Tk() cv = tk.Canvas(root, height=400, width=600) # 绘制一个黑色背景 cv.create_rectangle(0, 0, 600, 400, fill="black") # cv = tk.Canvas(root, height=400, width=600) # # 选一个好看的背景会让效果更惊艳！ # image = Image.open("./image.jpg") # photo = ImageTk.PhotoImage(image) # # cv.create_image(0, 0, image=photo, anchor="nw") cv.pack() root.protocol("WM_DELETE_WINDOW", close) root.after(100, simulate, cv) root.mainloop()实现效果图：相关免费学习推荐：python视频教程

专业的河螗商家论坛真心不错 ughd

python书籍推荐有：《Python编程：从入门到实践》《Head-First Python(2nd edition)》《“笨方法”学Python》《Python程序设计（第3版）》《像计算机科学家一样思考Python（第2版）》。一、《Python编程：从入门到实践》埃里克·马瑟斯的这本《Python编程：从入门到实践》是一本快速，全面的Python语言入门教程，适合初学者，他们希望学习Python编程并能够编写出有用的程序。本书旨在让读者快速上手编写真正的程序。本书也适用于对语言有模糊理解并希望在尝试Python编程之前了解其知识的程序员。在学习本书时，将学习使用Numpy和matplotlib等库和工具，并使用数据创建令人惊叹的可视化效果。还将了解2D游戏和Web应用程序背后的思想以及如何创建它们。二、《Head-First Python(2nd edition)》如果想要学习Python编程的基础知识，并且不想要看一堆乏味难懂的书籍和教程。那么Paul Barry的《Head First Python》就是不二之选。作者是Paul Barry，是一位讲师。在进入学术界之前，他在IT行业工作了十多年。他是许多著名编程书籍的作者。三、《“笨方法”学Python》这本书结构很简单，是52个习题的集合。在这个过程中，了解软件是如何工作的，好的程序看起来是什么样子，怎样阅读、编写、思考代码，以及如何用专业程序员的技巧来找出并修正错误。本书通过安装完整的Python环境开始，接着教如何编写优化的代码。然后，本书讨论了基础数学，变量，字符串，文件，循环，程序设计和数据结构等主题。本书非常适合想通过语言的核心来学习Python编程的初学者。四、《Python程序设计（第3版）》John Zelle的《Python程序设计》，与其把它当做Python编程的代码介绍，不如把它当做是一本关于编程艺术的介绍，这本书会介绍计算机科学、编程以及其他相关的概念，只是使用Python语言作为初学者的媒介，本书以最适合初学者的方式讨论，因此书中的概念是非常有趣并易于理解。第三版中最显著的变化就是几乎删除了所有python eval的使用，并增加了一个讨论其缺点的部分，最新版本还使用了新的图形示例。五、《像计算机科学家一样思考Python（第2版）》本书按照培养读者像计算机科学家一样的思维方式的思路来教授Python语言编程。作者从最基本的编程概念开始讲起，包括语言的语法和语义，而且每个编程概念都有清晰的定义，引领读者循序渐进地学习变量、表达式、语句、函数和数据结构。此外，书中还探讨了如何处理文件和数据库，如何理解对象、方法和面向对象编程，如何使用调试技巧来修正语法、运行时和语义错误。本书是遵循GUN自由文档许可，可以被免费下载和打印，已经被翻译成西班牙语、意大利语、德语、捷克语、中文等。

《Head First Python（中文版）》（巴里（Barry.P.））电子书网盘下载免费在线阅读链接: https://pan.baidu.com/s/1f5bT2XsBtrqTX6nzeipZVg 提取码: vjwr书名：Head First Python（中文版）作者：巴里（Barry.P.）译者：林琪 等豆瓣评分：7.9出版社：中国电力出版社出版年份：2012-3-1页数：457内容简介：你想过可以通过一本书就学会Python吗？《Head First Python(中文版)》超越枯燥的语法和甩法手册，通过一种独特的方法教你学习这种语言。你会迅速掌握Python的基础知识，然后转向持久存储、异常处理、Web开发、SQLite、数据加工和lGoogle App Engine。你还将学习如何为Android编写移动应用，这都要归功于Python为你赋予的强大能力。本书会提供充分并且完备的学习体验，帮助你成为一名真正的Python程序员。 作者巴里觉得你的时间相当宝贵，不应当过多地花费在与新概念的纠缠之中。通过应用认知科学和学习理论的最新研究成果，《Head First Python(中文版)》可以让你投入一个需要多感官参与的学习体验，这本书采用丰富直观的形式使你的大脑真正开动起来，而不是长篇累牍地说教，让你昏昏欲睡。作者简介：Paul Barry最近发现他的编程生涯已近四分之一个世纪，这个事实着实让人有些震惊。在此期间，Paul使用过多种不同的编程语言编写程序，他在两个大洲的两个国家生活并工作过，并且娶妻生子，如今已经有3个孩子(当然……实际上孩子们都是他妻子在悉心照顾，不过Paul确实在他们身边)，另外他还攻读了计算机的学士和硕士学位，编写或合作编写了另外3本书，还为《LinuxJournal》(他是这家杂志的特约编辑)撰写了大量技术文章。

本文主要介绍了python中如何使用朴素贝叶斯算法的相关知识。具有很好的参考价值。下面跟着小编一起来看下吧这里再重复一下标题为什么是"使用"而不是"实现"：首先，专业人士提供的算法比我们自己写的算法无论是效率还是正确率上都要高。其次，对于数学不好的人来说，为了实现算法而去研究一堆公式是很痛苦的事情。再次，除非他人提供的算法满足不了自己的需求，否则没必要"重复造轮子"。下面言归正传，不了解贝叶斯算法的可以去查一下相关资料，这里只是简单介绍一下：1.贝叶斯公式：P(A|B)=P(AB)/P(B)2.贝叶斯推断：P(A|B)=P(A)×P(B|A)/P(B)用文字表述：后验概率=先验概率×相似度/标准化常量而贝叶斯算法要解决的问题就是如何求出相似度，即：P(B|A)的值3. 在scikit-learn包中提供了三种常用的朴素贝叶斯算法，下面依次说明：1）高斯朴素贝叶斯：假设属性/特征是服从正态分布的(如下图)，主要应用于数值型特征。使用scikit-learn包中自带的数据，代码及说明如下：>>>from sklearn import datasets ##导入包中的数据>>> iris=datasets.load_iris() ##加载数据>>> iris.feature_names ##显示特征名字 ["sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"]>>> iris.data ##显示数据 array([[ 5.1, 3.5, 1.4, 0.2],[ 4.9, 3. , 1.4, 0.2],[ 4.7, 3.2, 1.3, 0.2]............>>> iris.data.size ##数据大小 ---600个>>> iris.target_names ##显示分类的名字 array(["setosa", "versicolor", "virginica"], dtype="<U10")>>> from sklearn.naive_bayes import GaussianNB ##导入高斯朴素贝叶斯算法>>> clf = GaussianNB() ##给算法赋一个变量，主要是为了方便使用>>> clf.fit(iris.data, iris.target) ##开始分类。对于量特别大的样本，可以使用函数partial_fit分类，避免一次加载过多数据到内存>>> clf.predict(iris.data[0].reshape(1,-1)) ##验证分类。标红部分特别说明：因为predict的参数是数组，data[0]是列表，所以需要转换一下array([0])>>> data=np.array([6,4,6,2]) ##验证分类>>> clf.predict(data.reshape(1,-1))array([2])这里涉及到一个问题：如何判断数据符合正态分布？ R语言里面有相关函数判断，或者直接绘图也可以看出来，但是都是P(x,y)这种可以在坐标系里面直接画出来的情况，而例子中的数据如何确定，目前还没有搞明白，这部分后续会补上。2）多项式分布朴素贝叶斯：常用于文本分类，特征是单词，值是单词出现的次数。##示例来在官方文档，详细说明见第一个例子>>> import numpy as np>>> X = np.random.randint(5, size=(6, 100)) ##返回随机整数值：范围[0,5) 大小6*100 6行100列>>> y = np.array([1, 2, 3, 4, 5, 6])>>> from sklearn.naive_bayes import MultinomialNB>>> clf = MultinomialNB()>>> clf.fit(X, y)MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True) >>> print(clf.predict(X[2]))[3]3）伯努力朴素贝叶斯：每个特征都是是布尔型，得出的结果是0或1，即出现没出现##示例来在官方文档，详细说明见第一个例子>>> import numpy as np>>> X = np.random.randint(2, size=(6, 100))>>> Y = np.array([1, 2, 3, 4, 4, 5])>>> from sklearn.naive_bayes import BernoulliNB>>> clf = BernoulliNB()>>> clf.fit(X, Y)BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True) >>> print(clf.predict(X[2]))[3]补充说明：此文还不完善，示例一中也有部分说明需要写，最近事情较多，后续会逐渐完善。

编程都会，还会用360这种软件？