pyt

python（派森）flask（付啦斯克）

Python由荷兰数学和计算机科学研究学会的Guido van Rossum 于1990 年代初设计，作为一门叫做ABC语言的替代品。Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言，随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。 Python解释器易于扩展，可以使用C或C++（或者其他可以通过C调用的语言）扩展新的功能和数据类型。 Python 也可用于可定制化软件中的扩展程序语言。Python丰富的标准库，提供了适用于各个主要系统平台的源码或机器码。

python是什么意思？怎么读？Python是一种计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。英["pa?θ?n]：发音有点像“派森” 或 “派粉”，注意中间那个 θ 音，除英语外，世界上没几个语言有这个音。θ 这个就是咬住舌头吐气的发音。美[?pa??θɑn, -θ?n]：听起来有点像“派饭”……也可以读成“派森”。 Python的创始人为Guido van Rossum,是电视节目Monty Python(大蟒蛇)的粉丝，在1989年圣诞节期间，Guido选中Python作为他发明的程序语言的名字。相关推荐：《Python教程》以上就是小编分享的关于python是什么意思？的详细内容希望对大家有所帮助，更多有关python教程请关注环球青藤其它相关文章！

python中文怎么读？发英音：/?pa?θ?n/ ，中文类似‘拍森"；而按习惯用法或者（国外）大多数人的用法，发美音：/?pa?θɑ?n/），中文类似‘拍赏"。推荐：《Python教程》注：Python是一种计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。像Perl语言一样, Python 源代码同样遵循 GPL(GNU General Public License)协议。

python单词怎么读？python单词的英式发音是[?pa?θ?n]，美式发音是[?pa?θɑ?n]，中文音译读“拍森”，中文释义是巨蛇，大蟒的意思。推荐：《python教程》通常情况下，我们所说的Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言。Python 由 Guido van Rossum 于 1989 年底发明，第一个公开发行版发行于 1991 年。像 Perl 语言一样, Python 源代码同样遵循 GPL(GNU General Public License) 协议。官方宣布，2020 年 1 月 1 日， 停止 Python 2 的更新。Python 2.7 被确定为最后一个 Python 2.x 版本。

python的读音及注解如下：python英 [?pa?θ?n] 美 [?pa?θɑ?n] n. 蟒; 蟒蛇; [例句]On my system, it"s at/ usr/ bin/ python.[其他] 复数：pythons python是一门面向对象的编程语言。python本身的意思是蟒蛇，巨蟒，至于为什么叫pthon,这里还是有缘由的。Python的创始人为荷兰人吉多·范罗苏姆 （Guido van Rossum）。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，作为ABC 语言的一种继承。之所以选中Python（大蟒蛇的意思）作为该编程语言的名字，是取自英国20世纪70年代首播的电视喜剧《蒙提.派森干的飞行马戏团》（Monty Python"s Flying Circus）。ABC是由Guido参加设计的一种教学语言。就Guido本人看来，ABC 这种语言非常优美和强大，是专门为非专业程序员设计的。但是ABC语言并没有成功，究其原因，Guido 认为是其非开放造成的。Guido 决心在Python 中避免这一错误。同时，他还想实现在ABC 中闪现过但未曾实现的东西。就这样，Python在Guido手中诞生了。可以说，Python是从ABC发展起来，主要受到了Modula-3（另一种相当优美且强大的语言，为小型团体所设计的）的影响。并且结合了Unix shell和C的习惯。

python读什么？python可读为“拍森”，英式发音:读“[?pa?θ?n]”、美式发音读“[?pa?θɑ:n]”， 中文释义:巨蛇,大蟒。推荐：《python教程》Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python是一种解释型脚本语言，可以应用于以下领域： Web 和 Internet开发科学计算和统计人工智能教育桌面界面开发软件开发后端开发以上就是小编分享的关于python读什么的详细内容希望对大家有所帮助，更多有关python教程请关注环球青藤其它相关文章！

python怎么读音？python ：发音：英 [?pa?θ?n]、 美 [?pa?θɑ:n] 、中式发音“派森”。中文释义：巨蛇，大蟒复数形式：pythons英文单词，意为巨蛇，大蟒。通常情况下，我们提到的python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。推荐：《python教程》

python的读法：英式发音为["pau026aθu0259n] ；美式发音为["pau026aθɑu02d0n] 。　 　发元音时，气流从肺部通过声门冲击声带，使声带发出均匀震动，然后震音气流不受阻碍地通过口腔，通过舌、唇的调节而发出不同的声音。发元音时声带必然震动的叫浊元音。有些语言发元音时声带不振动，发出清元音。发辅音时，气流受到发音器官的各种阻碍，声带不一定振动，不够清晰响亮的音素叫辅音。气流从肺里出来不一定振动声带，通过口腔时受到一定的阻碍，这种主要依靠阻碍发出的音叫辅音。相关概念：半元音（semivowel）：语音学上指摩擦似有似无，发音方式上与元音相似，介于元音和辅音之间，时长较短且被视为辅音的音。如普通话衣yī、乌wū 中的 y、w。半元音往往有对应的元音。半元音属于近音。流音（liquid）：不属于半元音的近音。如普通话流liú 中的 l 。近音（approximant），即接近音、无擦通音：发音时两个发音部位彼此靠拢，有足够空间予气流流动，产生的湍流较弱。（如果发音部位收窄程度加剧，湍流会产生，形成擦音。）半元音和流音都属于近音；近音属于辅音。

这篇文章主要为大家详解Python如何读取MySQL数据库表数据，具有一定的参考价值，感兴趣的小伙伴们可以参考一下本文实例为大家分享了Python读取MySQL数据库表数据的具体代码，供大家参考，具体内容如下环境：Python 3.6 ,Window 64bit目的：从MySQL数据库读取目标表数据，并处理代码：# -*- coding: utf-8 -*-import pandas as pdimport pymysql## 加上字符集参数，防止中文乱码dbconn=pymysql.connect( host="**********", database="kimbo", user="kimbo_test", password="******", port=3306, charset="utf8" )#sql语句sqlcmd="select col_name,col_type,col_desc from itf_datadic_dtl_d limit 10"#利用pandas 模块导入mysql数据a=pd.read_sql(sqlcmd,dbconn)#取前5行数据b=a.head()print(b)# 读取csv数据# pd.read_csv()# 读取excel数据#pd.read_excel()# 读取txt数据#pd.read_table()结果如图：

编程语言python怎么读介绍如下：python英 [u02c8pau026aθu0259n]美 [u02c8pau026aθɑu02d0n]。Python是一种跨平台的计算机程序设计语言。是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本（shell），随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。Python的创始人为荷兰人吉多·范罗苏姆（GuidovanRossum）。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。之所以选中Python（大蟒蛇的意思）作为该编程语言的名字，是取自英国20世纪70年代首播的电视喜剧《蒙提．派森的飞行马戏团》（MontyPython＇sFlyingCircus）。扩展资料：python中文就是蟒蛇的意思。在计算机中，它是一种编程语言。Python（英语发音：／u02c8pau026aθu0259n／），是一种面向对象、解释型计算机程序设计语言，由GuidovanRossum于1989年底发明，第一个公开发行版发行于1991年。Python语法简洁而清晰，具有丰富和强大的类库。它常被昵称为胶水语言，它能够把用其他语言制作的各种模块（尤其是C／C＋＋）很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型（有时甚至是程序的最终界面），然后对其中有特别要求的部分，用更合适的语言改写。比如3D游戏中的图形渲染模块，性能要求特别高，就可以用C++重写。1发展历程编辑自从20世纪90年代初Python语言诞生至今，它逐渐被广泛应用于处理系统管理任务和Web编程。Python已经成为最受欢迎的程序设计语言之一。

python的读法：英式发音为["pau026aθu0259n] ；美式发音为["pau026aθɑu02d0n] 　 　发元音时，气流从肺部通过声门冲击声带，使声带发出均匀震动，然后震音气流不受阻碍地通过口腔，通过舌、唇的调节而发出不同的声音。发元音时声带必然震动的叫浊元音。有些语言发元音时声带不振动，发出清元音。发辅音时，气流受到发音器官的各种阻碍，声带不一定振动，不够清晰响亮的音素叫辅音。气流从肺里出来不一定振动声带，通过口腔时受到一定的阻碍，这种主要依靠阻碍发出的音叫辅音。扩展资料相关概念——半元音（semivowel）：语音学上指摩擦似有似无，发音方式上与元音相似，介于元音和辅音之间，时长较短且被视为辅音的音。如普通话衣yī、乌wū 中的 y、w。半元音往往有对应的元音。半元音属于近音。流音（liquid）：不属于半元音的近音。如普通话流liú 中的 l 。近音（approximant），即接近音、无擦通音：发音时两个发音部位彼此靠拢，有足够空间予气流流动，产生的湍流较弱。（如果发音部位收窄程度加剧，湍流会产生，形成擦音。）半元音和流音都属于近音；近音属于辅音。

python读音：英式发音为["pau026aθu0259n] ；美式发音为["pau026aθɑu02d0n] 　 Python , 是一种面向对象的解释型计算机程序设计语言，具有丰富和强大的库，Python 已经成为继Java，C++之后的的第三大语言。 特点：简单易学、免费开源、高层语言、可移植性强、面向对象、可扩展性、可嵌入型、丰富的库、规范的代码等。Python强大的生态圈注定它了应用广泛，国内的豆瓣、搜狐、金山、通讯、盛大、网易、百度、阿里、土豆、新浪等，国外：谷歌、NASA、YOUTU、FACEBOOK、红帽等企业都在广泛应用。Python除了极少的事情不能做之外，其他基本上可以说全能，Python可以做系统运维、云计算开发、图形处理、金融分析、游戏开发、数学处理数据库编程、网络编程、WEB编程、PYMO引擎、黑客编程、爬虫开发、机器学习、人工智能等等。

【派送】pai，song。【颇爱蛇恩】直达精粹的意思。同义词 essence。像网购，送快递一样，靠别人编好的程序和库，来把你想要的结果，【派送】到你的屏幕上。你要的是货品，而不是购物这个过程。所以，你只需描述自己的需求，收集库，再敲击键盘，下单。等软件来【派送】到货。

python怎么读音？python ：发音：英 [?pa?θ?n]、 美 [?pa?θɑ:n] 、中式发音“派森”。中文释义：巨蛇，大蟒复数形式：pythons英文单词，意为巨蛇，大蟒。通常情况下，我们提到的python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。推荐：《python教程》以上就是小编分享的关于python怎么读音的详细内容希望对大家有所帮助，更多有关python教程请关注环球青藤其它相关文章！

Python是一种计算机程序设计语言，或者说，是编程语言。Python（英语发音：/u02c8pau026aθu0259n/）的特点是面向对象的解释性的脚本语言，常被昵称为胶水语言，能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。著名的自由软件作者EricRaymond在他的文章《如何成为一名黑客》中，将Python列为黑客应当学习的四种编程语言之一...Python是一种计算机程序设计语言，或者说，是编程语言。Python（英语发音：/u02c8pau026aθu0259n/）的特点是面向对象的解释性的脚本语言，常被昵称为胶水语言，能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。著名的自由软件作者EricRaymond在他的文章《如何成为一名黑客》中，将Python列为黑客应当学习的四种编程语言之一。对于那些从来没有学习过编程或者并非计算机专业的编程学习者而言，建议从Python开始学习编程的确是一个不错的途径。但并不是必须途径，汇编和C/C++更接近编程本质，难度也更大些，这更适合有一定基础的学习者。python有一个hack的库,内置了很多网络黑客函数，使用方便但缺少成就感。python在英文中是蟒蛇的意思，因此Python语言也被称为蟒蛇语言。全部

啥叫浮点格式图片啊

可以使用pandas比较方便：import pandas as pdcsvframe = pd.read_csv("myCSV_01.csv", header=None)

先把内容转化为标准json格式，在进行写入的操作file_tianya = open(‘XXXX.json","w+")file_tianya.write(json.dumps(要写的内容, ensure_ascii=False) + " ")file_tianya.flush()读文件file_tianya = open(‘XXXX.json","w+")file_tianya.read()file_tianya.close()其实读写文件跟平时读写txt文件没有区别，区别仅仅在于写文件的时候必须是标准json格式

pytorch的读音是"pau026atu0254u02d0tu0283。PyTorch的前身是Torch，其底层和Torch框架一样，但是使用Python重新写了很多内容，不仅更加灵活，支持动态图，而且提供了Python接口。它是由Torch7团队开发，是一个以Python优先的深度学习框架，不仅能够实现强大的GPU加速，同时还支持动态神经网络。PyTorch既可以看作加入了GPU支持的numpy，同时也可以看成一个拥有自动求导功能的强大的深度神经网络。除了Facebook外，它已经被Twitter、CMU和Salesforce等机构采用。PyTorch的优点：1、相当简洁且高效快速的框架。2、设计追求最少的封装。3、设计符合人类思维，它让用户尽可能地专注于实现自己的想法。4、与google的Tensorflow类似，FAIR的支持足以确保PyTorch获得持续的开发更新。5、PyTorch作者亲自维护的论坛供用户交流和求教问题。6、入门简单。

caret (英语发音:/krt/)也可以读control

你的意思是，EXCEL软件已经启动并打开了这些文件，然后python要对这些表格进行操作吧

读：import requests,jsonr = request.get(url)jsondata = json.loads(r.content)#读取你需要的字段写就更简单了，从数据库或者txt或者excel里按规则拿数据，然后写入json文件不就行了么。。。二营长SEO

如果用拼音的话是 zhan gou

“Python”这个英文单词的发音似“派森”，因此中文可以称之为派森。Python是一个有10年历史的Windows编程语言。Python的创始人为Guido van Rossum。Python是一种即译式的，互动的，面向对象的编程语言，它包含了模组式的操作，异常处理，动态资料形态，十分高层次的动态资料结构，以及类别的使用。Python揉合了简单的语法和强大的功能。它的语法表达优美易读。它具有很多优秀的脚本语言的特点：解释的，面向对象的，内建的高级数据结构，支持模块和包，支持多种平台，可扩展。而且它还支持交互式方式运行，图形方式运行。它拥有众多的编程界面支持各种操作系统平台以及众多的各类函数库。利用C和C++可以对它进行扩充。个别的应用软件如果需要有一个可程序化界面也可以利用它来做为扩展语言用。最后，Python的可移植度非常高:它可以在许多的Unix类平台上运行，在Mac,MS-DOS,视窗Windows，Windows NT，OS/2，BeOS，以至RISCOS上都有相关的Python版本。Perl是Practical Extraction and Report Language的缩写，它是由Larry Wall设计的，并由他不断更新和维护，用于在UNIX环境下编程。没有中文名。教程：http://doc.99net.net/doc/program/1076664628/1076664648.html

python中文叫什么?python中文叫蟒蛇，通常情况下，Python是一种计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。Python在设计上坚持了清晰划一的风格，这使得Python成为一门易读、易维护，并且被大量用户所欢迎的、用途广泛的语言。设计者开发时总的指导思想是，对于一个特定的问题，只要有一种最好的方法来解决就好了。这在由Tim Peters写的Python格言（称为The Zen of Python）里面表述为：There should be one-- and preferably only one --obvious way to do it. 这正好和Perl语言（另一种功能类似的高级动态语言）的中心思想TMTOWTDI（There"s More Than One Way To Do It）完全相反。Python的作者有意的设计限制性很强的语法，使得不好的编程习惯（例如if语句的下一行不向右缩进）都不能通过编译。其中很重要的一项就是Python的缩进规则。一个和其他大多数语言（如C）的区别就是，一个模块的界限，完全是由每行的首字符在这一行的位置来决定的（而C语言是用一对花括号{}来明确的定出模块的边界的，与字符的位置毫无关系）。这一点曾经引起过争议。因为自从C这类的语言诞生后，语言的语法含义与字符的排列方式分离开来，曾经被认为是一种程序语言的进步。不过不可否认的是，通过强制程序员们缩进（包括if，for和函数定义等所有需要使用模块的地方），Python确实使得程序更加清晰和美观。相关推荐：《Python教程》以上就是小编分享的关于python中文叫什么的详细内容希望对大家有所帮助，更多有关python教程请关注环球青藤其它相关文章！

Python是一门简单易学的编程语言。阅读好的Python程序感觉就像阅读英语，尽管是非常严格的英语。Python的这种伪代码特性是其最大强项之一，它可让你专注于解决问题的办法而不是语言本身。python的用途和优点都有什么呢？Python编程语言开发快，语言简洁，没那么多技巧，所以读起来很清楚容易！ython的用途：Python它通常应用于各种领域，是一种通用语言，无论是从网站、游戏开发、机器人，人工智能，大数据，云计算或是一些高科技的航天飞机控制都可以用到python语言。

一：Python是什么Python最初是用来编写自动化脚本，随着不断的发展，目前Python被用于大型项目的开发。目前Python是一门计算机编程语言，是直接面向对象动态语言，同时也是一种高级语言。二：python怎么读Python在中国的意思就是巨蟒和巨蛇的意思，美国的基本发音为pa_θɑ_n。三：python语言的优点1.python简单易学，python有些部分是使用c语言写的，但是却放弃了一些指针。2.python的可嵌入性，我们可以把python嵌入c程序当中，并且提供脚本功能。3.python的速度是相当快的，也有很多都是使用c语言进行编写的。四：Python的应用Python的应用比较多，例如在文本和图像处理，还有很多程序员利去做一些xml的开发，也可以使用Python去写一些爬虫，Python的应用覆盖很广，包括web开发，计算机科学等多个领域。python能干什么IT行业热门技术，更新换代非常的快，技术的浪潮一波接着一波，最初的浪潮无疑是桌面时代，使用C#搭建桌面应用开始崭露头角，MFC还是计算机科学专业必学会的东西。接着就是以网站搭建为应用的背景，PHP，Ruby等语言为主的。再到近几年非常火热的以移动开发为应用背景，Java(Android开发)或者OC(iOS开发)语言为主。很明显如今的浪潮就是以大数据和机器学习为应用背景，Python语言为主。站在风尖浪口，猪都可以飞的起来。抓住这波技术浪潮，对于从事IT行业的人员来说有莫大的帮助。python具体涉及如下：·网站开发·网络爬虫·数据分析、数据挖掘、大数据·自动化测试/运维、测试/运维开发·系统编程·用户图形接口·数据库编程·科学计算编程·游戏、图像、人工智能、XML、机器人等。设计定位Python的设计哲学是“优雅”、“明确”、“简单”。因此，Perl语言中“总是有多种方法来做同一件事”的理念在Python开发者中通常是难以忍受的。Python开发者的哲学是“用一种方法，最好是只有一种方法来做一件事”。在设计Python语言时，如果面临多种选择，Python开发者一般会拒绝花俏的语法，而选择明确的没有或者很少有歧义的语法。由于这种设计观念的差异，Python源代码通常被认为比Perl具备更好的可读性，并且能够支撑大规模的软件开发。这些准则被称为Python格言。在Python解释器内运行importthis可以获得完整的列表。Python开发人员尽量避开不成熟或者不重要的优化。一些针对非重要部位的加快运行速度的补丁通常不会被合并到Python内。所以很多人认为Python很慢。不过，根据二八定律，大多数程序对速度要求不高。在某些对运行速度要求很高的情况，Python设计师倾向于使用JIT技术，或者用使用C/C++语言改写这部分程序。可用的JIT技术是PyPy。Python是完全面向对象的语言。函数、模块、数字、字符串都是对象。并且完全支持继承、重载、派生、多继承，有益于增强源代码的复用性。Python支持重载运算符和动态类型。相对于Lisp这种传统的函数式编程语言，Python对函数式设计只提供了有限的支持。有两个标准库(functools，itertools)提供了Haskell和StandardML中久经考验的函数式程序设计工具。虽然Python可能被粗略地分类为“脚本语言”（scriptlanguage），但实际上一些大规模软件开发计划例如Zope、Mnet及BitTorrent，Google也广泛地使用它。Python的支持者较喜欢称它为一种高级动态编程语言，原因是“脚本语言”泛指仅作简单程序设计任务的语言，如shellscript、VBScript等只能处理简单任务的编程语言，并不能与Python相提并论。Python本身被设计为可扩充的。并非所有的特性和功能都集成到语言核心。Python提供了丰富的API工具，以便程序员能够轻松地使用C语言、C++、Cython来编写扩充模块。Python编译器本身也可以被集成到其它需要脚本语言的程序内。因此，很多人还把Python作为一种“胶水语言”（gluelanguage）使用。使用Python将其他语言编写的程序进行集成和封装。在Google内部的很多项目，例如GoogleEngine使用C++编写性能要求极高的部分，然后用Python或Java/Go调用相应的模块。《Python技术手册》的作者马特利（AlexMartelli）说：“这很难讲，不过，2004年，Python已在Google内部使用，Google召募许多Python高手，但在这之前就已决定使用Python，他们的目的是Pythonwherewecan，C++wherewemust，在操控硬件的场合使用C++，在快速开发时候使用Python。

近几年来，Python一直发展比较迅速，同时也受到了很多人的关注，对于IT行业的人来说，Python并不是很陌生，但是对于其他行业的来说，并不知道Python是什么意思，下面我们来详解一下Python。一：Python是什么Python最初是用来编写自动化脚本，随着不断的发展，目前Python被用于大型项目的开发。目前Python是一门计算机编程语言，是直接面向对象动态语言，同时也是一种高级语言。二 ：python怎么读Python在中国的意思就是巨蟒和巨蛇的意思，美国的基本发音为pa?θɑ?n。三：python语言的优点1.python简单易学，python有些部分是使用c语言写的，但是却放弃了一些指针。2.python的可嵌入性，我们可以把python嵌入c程序当中，并且提供脚本功能。3.python的速度是相当快的，也有很多都是使用c语言进行编写的。四：Python的应用Python的应用比较多，例如在文本和图像处理，还有很多程序员利去做一些xml的开发，也可以使用Python去写一些爬虫，Python的应用覆盖很广，包括web开发，计算机科学等多个领域。

是一种计算机编程语言

拍婶.................

英式发音 派森，美式发音 派桑。百度在线翻译里，点一下下图红框里的小喇叭，自己多听几遍。

中文发音：派森英语发音：英 [ˈpaɪθən] 美 [ˈpaɪθɑ:n] 中文释义：蟒蛇Python语言是高级的编程语言，其语言上手容易、功能强大、语法简单，可以做的事情有很多，应用领域非常广泛，比如说：人工智能、数据分析、科学运算、web开发、爬虫、运维、游戏开发等。

许多学习代码的小伙伴一定知道python这个词，但有些小伙伴却还拿不准这个词到底应该怎么读，因为不同的人的读法都不一样，现在就给大家介绍一下最常用的读法。python怎么读答：python的谐音读法是”派森“其音标是：[_pa_θ_n]其意思是：意为巨蛇，大蟒。别看python的意思是巨蟒，其实是因为python的程序语言的创始人是一个电视节目MontyPython(大蟒蛇)的粉丝，所以该创始人就在1989年的圣诞节，把Python作为了他的程序语言的名字，也就是我们现在很多人学习的了。python扩展阅读1、python是一种高层次的脚本语言，它结合了解释性、编译性、互动性和面向对象。2、python的设计有很强的可读性，经常使用英文关键字。3、python在开发过程里没有编译这个环节，比较类似于PHP和Perl语言，因此它是一种解释型语言。4、python可以在一个提示符后直接执行代码，英文它是交互式语言。5、python是面向对象的语言，它支持面向对象的风格或者代码封装在对象的编程技术。

首先，根据美式、英式读出的是音译分别是[pai-sang]、[pai-seng]其次，再看其意思：网络释义：python["pau026aθɑn]n.巨蟒；大蟒专业释义：python["pau026aθɑn]分为【生物学】意思为——蟒——与【计算机科学技术】意思为——python语言（是一门编程语言）——

python 英["pau026aθu0259n] 美[u02c8pau026au02ccθɑn, -θu0259n] n. 巨蛇，大蟒 名词复数:pythons [例句]A giant python on a placard squeezed the life out of russia.在一张海报上，一条巨蟒紧缠俄罗斯将其生命压榨出来。

英文念 “派森”，轻声

python的读音及注解如下：python英 [?pa?θ?n] 美 [?pa?θɑ?n] n. 蟒; 蟒蛇; [例句]On my system, it"s at/ usr/ bin/ python.[其他] 复数：pythons python是一门面向对象的编程语言。python本身的意思是蟒蛇，巨蟒，至于为什么叫pthon,这里还是有缘由的。Python的创始人为荷兰人吉多·范罗苏姆 （Guido van Rossum）。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，作为ABC 语言的一种继承。之所以选中Python（大蟒蛇的意思）作为该编程语言的名字，是取自英国20世纪70年代首播的电视喜剧《蒙提.派森干的飞行马戏团》（Monty Python"s Flying Circus）。ABC是由Guido参加设计的一种教学语言。就Guido本人看来，ABC 这种语言非常优美和强大，是专门为非专业程序员设计的。但是ABC语言并没有成功，究其原因，Guido 认为是其非开放造成的。Guido 决心在Python 中避免这一错误。同时，他还想实现在ABC 中闪现过但未曾实现的东西。就这样，Python在Guido手中诞生了。可以说，Python是从ABC发展起来，主要受到了Modula-3（另一种相当优美且强大的语言，为小型团体所设计的）的影响。并且结合了Unix shell和C的习惯。

1、python怎么读：英[?pa?θ?n],美[?pa?θɑ?n].2、n.蟒;蚺蛇;3、[例句]Onmysystem,it"sat/usr/bin/python.在我的系统中，它位于/usr/bin/python。4、[其他]复数：pythons.

派森 顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶

python的读法：英式发音为["pau026aθu0259n] ；美式发音为["pau026aθɑu02d0n] 。　 　发元音时，气流从肺部通过声门冲击声带，使声带发出均匀震动，然后震音气流不受阻碍地通过口腔，通过舌、唇的调节而发出不同的声音。发元音时声带必然震动的叫浊元音。有些语言发元音时声带不振动，发出清元音。发辅音时，气流受到发音器官的各种阻碍，声带不一定振动，不够清晰响亮的音素叫辅音。气流从肺里出来不一定振动声带，通过口腔时受到一定的阻碍，这种主要依靠阻碍发出的音叫辅音。相关概念：半元音（semivowel）：语音学上指摩擦似有似无，发音方式上与元音相似，介于元音和辅音之间，时长较短且被视为辅音的音。如普通话衣yī、乌wū 中的 y、w。半元音往往有对应的元音。半元音属于近音。流音（liquid）：不属于半元音的近音。如普通话流liú 中的 l 。近音（approximant），即接近音、无擦通音：发音时两个发音部位彼此靠拢，有足够空间予气流流动，产生的湍流较弱。（如果发音部位收窄程度加剧，湍流会产生，形成擦音。）半元音和流音都属于近音；近音属于辅音。

派森

读音：英[u02c8pau026aθu0259n]，美[u02c8pau026aθɑu02d0n]其中，/θ/是摩擦、舌齿、清辅音，旧版音标和美式音标对应的符号都是[θ]。/θ/的正确发音方法：（1）舌尖微微伸出，置于上下门齿之间，舌身成扁平。（2）气流由舌齿间泻出，摩擦成音，舌尖和下齿之间的气流通道非常窄小，气流从舌齿间的窄缝中泄出。扩展资料Python是一种计算机程序设计语言，是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本（shell），随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。Python的创始人为荷兰人吉多·范罗苏姆（Guido van Rossum）。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。之所以选中Python作为该编程语言的名字，是取自英国20世纪70年代首播的电视喜剧《蒙提.派森的飞行马戏团》（Monty Python"s Flying Circus）。Python具有简单、易学、免费、开源、可扩展、可嵌入、面向对象等优点。

派 萨恩 快速读……或者 拍 阿三

智能感应真的很有用 我知道，我们一直都在讨论智能感应。Visual Studio 一直以来都对于其支持的编程语言提供强大的智能感应功能，所以如果你在过去15年中使用过 C# 或者 VB，你可能不再会有深刻的印象。然而 Python 开发人员就没有这么幸运了，因为它只包含很少的代码提示和基本的语法高亮。 与其他编程语言不同，Python 不需要开发者指定类型。这可以在编码时省去大量的时间，但是需要你对程序有深刻的理解，以及编辑器所提供的任何帮助都是非常重要的。大多数编辑器并不会提供提示，来强迫开发者时刻保持全部程序的操作。 在 Visual Studio 中，我们提供为开发者提供了深层次的理解。利用全程序分析，我们可以追踪变量从它第一次初始化到被使用的整个过程。开发者可以悬停鼠标来观察他被指向的类型，或者通过点击来查看它的成员。 对于 Python 的共同模式，我们已经花费了不少时间用来优化 Visual Studio 的分析功能。这里可以进行一些尝试:在一个元组中放入不同类型，然后拆开调用带有不同参数的函数，查看返回值将一个值添加到被传到方法的列表中建立一个子类，并开始重写方法调式是个大事情 类似于智能感应，Python 交互式调式是相当近期的产物。传统意义上的 Python 开发者需要花费大量的时间在终端或者命令提示符下来回切换来调式代码。举个例子 虽然类似这样的调试小项目中是可以忍受的，但是通过单步执行代码的方式会使用开发者变的迷失方向，而且这种方式在大一点的项目中将会变得效率极低。相反，Visual Studio 直接覆盖了调试接口，这样你可以在编辑器中查看端点，当前语句以及上下文的调用堆栈。利用自定义监视窗体和浮动式自动更新，你可以一直监视变量的值而无需反复索取，并且这样也很容易调用堆栈和查看当前变量的当前状态 最棒的部分是这样的调式是通过 Python 标准接口的形式实现的。所以你不需要特别版本的 Python 来获得它，并且你的代码可以运行在 windows 或者其它平台上. 我们还可以使用一些非标准的接口与最近 CPython 版本提供混合的本机 Python 调试,让你可以通过单步执行的方式在 C/C++ 和 Python 中移动。当你想要使用键盘操作时，我们有一个带有该功能的交互式调试窗口。逗大逗的工程真的很大 每个人对于所谓的地大逗工程的理解都不一样。是100个文件算大看还是一千个类算大看又或者1万行代码看不论你对逗大地的理解是怎么样的，随着你的项目便的越来越大，围绕它进行的操作也随着难度提升。 Visual Studio 丰富的智能感应不仅能让开发者在工程任意地方使用，它也可以用比全文本所有更好的方式来查找所有类和功能的引用。转到定义和查找引用都是很有用的工具，导航功能可以帮助你通过智能过滤找到文件，类或者工程应用程序生命周期管理与 Python 项目一套丰富的应用程序管理功能都可使用 Visual Studio online ，包括 TFS 和 git 版本控制、 交互的代码审查、 在线规划仪表板、 团队房间，承载的测试、 生成、 部署服务和与更多的第三方服务的集成。所有这些功能可以与 Python 项目在 Visual Studio 中，通过团队资源管理器中无处不在的 Eclipse 插件，和通过任何 web 浏览器中直接使用。简而言之，当管理 Python 或任何其他语言的一个项目时，Visual Studio 有助于使每个人都在你的团队一起，向前，不管你找到一百或 100 万行代码

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。单例模式的要点有三个:一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。在 Python 中，我们可以用多种方法来实现单例模式：使用模块使用 __new__使用装饰器（decorator）使用模块其实，Python 的模块就是天然的单例模式。因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：#tests1.pyclass MyClass(object): def foo(self): print("MyClass.foo")my_class_obj=MyClass()将上面的代码保存在文件 tests1.py 中，然后这样使用：from .tests1 import my_class_objmy_class_obj.foo()使用 __new__为了使类只能出现一个实例，我们可以使用 __new__ 来控制实例的创建过程，代码如下：class MyClass(object): _instance = None def __new__(cls, *args, **kwargs): if not cls._instance: cls._instance = super(MyClass, cls).__new__(cls, *args, **kwargs) return cls._instanceclass HerClass(MyClass): a = 1在上面的代码中，我们将类的实例和一个类变量 _instance 关联起来，如果 cls._instance 为 None 则创建实例，否则直接返回 cls._instance。执行情况如下：one = HerClass()two = HerClass()print(one == two) #Trueprint(one is two) #Trueprint(id(one), id(two)) #42818864 42818864使用装饰器我们知道，装饰器（decorator）可以动态地修改一个类或函数的功能。这里，我们也可以使用装饰器来装饰某个类，使其只能生成一个实例，代码如下：from functools import wrapsdef singleton(cls): instances = {} @wraps(cls) def getinstance(*args, **kwargs): if cls not in instances: instances[cls] = cls(*args, **kwargs) return instances[cls] return getinstance@singletonclass MyClass(object): a = 1在上面，我们定义了一个装饰器 singleton，它返回了一个内部函数 getinstance，该函数会判断某个类是否在字典 instances 中，如果不存在，则会将 cls 作为 key，cls(*args, **kw) 作为 value 存到 instances 中，否则，直接返回 instances[cls]。

首先来看一个小程序，这个是计量所花费时间的程序，以下是以往的解决示例from functools import wraps, partialfrom time import timedef timing(func=None, frequencies=1): if func is None: # print("+None") return partial(timing, frequencies=frequencies) # else: # print("-None") @wraps(func) def _wrapper(*args, **kwargs): start_time = time() for t in range(frequencies): result = func(*args, **kwargs) end_time = time() print("运行花费时间：{:.6f}s。".format(end_time-start_time)) return result return _wrapper@timingdef run(): l = [] for i in range(5000000): l.extend([i]) return len(l)运行如下：In [4]: run()运行花费时间：2.383398s。Out[4]: 5000000（喜欢刨根问底的可以去掉注释，并思考预计会有什么样的输出）。今天无意间看到了Python的上下文管理器（Context Manager），发现也非常不错，其实这跟with语句是息息相关的，竟然以前一直未在意。from time import timedef run2(): l = [] for i in range(5000000): l.extend([i]) return len(l)class ElapsedTime(): def __enter__(self): self.start_time = time() return self def __exit__(self, exception_type, exception_value, traceback): self.end_time = time() print("运行花费时间：{:.6f}s。".format(self.end_time - self.start_time))with ElapsedTime(): run2()总结初略看了一点官方文档，上下文管理还是有点多内容的。Python发展到现在，其实不简单了。说简单，只是你自己不够与时俱进，掌握的都是老式三板斧而已。所以，知识需要不断更新，才能弥补自己的盲点，

简言之，打个比方，我写了一个python的插件，提供给用户使用，但是在使用的过程中我添加了一些功能，可是又不希望用户改变调用的方式，那么该怎么办呢？这个时候就用到了装饰器。python装饰器就是用于拓展原来函数功能的一种函数，这个函数的特殊之处在于它的返回值也是一个函数，使用python装饰器的好处就是在不用更改原函数的代码前提下给函数增加新的功能。一般而言，我们要想拓展原来函数代码，比较直接的办法就是侵入代码里面修改。而且装饰器是程序开发中经常会用到的一个功能，用好了装饰器，开发效率如虎添翼，所以这也是Python面试中必问的问题，但对于好多小白来讲，这个功能有点绕，自学时直接绕过去了，然后面试问到了就挂了，因为装饰器是程序开发的基础知识，不懂就太说不过去啦。讲完装饰器，相信大家对于Python的发展前景也比较感兴趣，随着人工智能的发展，Python作为人工智能的首选语言，自然也是发展得如火如荼。现在入行，肯定是一个好时机！

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。先来看一个简单例子：def foo(): print("i am foo")现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：def foo(): print("i am foo") logging.info("foo is running")bar()、bar2()也有类似的需求，怎么做？再写一个logging在bar函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门处理日志 ，日志处理完之后再执行真正的业务代码def use_logging(func): logging.warn("%s is running" % func.__name__) func()def bar(): print("i am bar")use_logging(bar)逻辑上不难理解， 但是这样的话，我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢？当然有，答案就是装饰器。简单装饰器def use_logging(func): def wrapper(*args, **kwargs): logging.warn("%s is running" % func.__name__) return func(*args, **kwargs) return wrapperdef bar(): print("i am bar")bar = use_logging(bar)bar()函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作def use_logging(func): def wrapper(*args, **kwargs): logging.warn("%s is running" % func.__name__) return func(*args) return wrapper@use_loggingdef foo(): print("i am foo")@use_loggingdef bar(): print("i am bar")bar()如上所示，这样我们就可以省去bar = use_logging(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。带参数的装饰器装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@use_logging，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。def use_logging(level): def decorator(func): def wrapper(*args, **kwargs): if level == "warn": logging.warn("%s is running" % func.__name__) return func(*args) return wrapper return decorator@use_logging(level="warn")def foo(name="foo"): print("i am %s" % name)foo()上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。类装饰器再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。class Foo(object): def __init__(self, func): self._func = funcdef __call__(self): print ("class decorator runing") self._func() print ("class decorator ending")@Foodef bar(): print ("bar")bar()functools.wraps使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：装饰器def logged(func): def with_logging(*args, **kwargs): print func.__name__ + " was called" return func(*args, **kwargs) return with_logging函数@loggeddef f(x): """does some math""" return x + x * x该函数完成等价于：def f(x): """does some math""" return x + x * xf = logged(f)不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。print f.__name__ # prints "with_logging"print f.__doc__ # prints None这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。from functools import wrapsdef logged(func): @wraps(func) def with_logging(*args, **kwargs): print func.__name__ + " was called" return func(*args, **kwargs) return with_logging@loggeddef f(x): """does some math""" return x + x * xprint f.__name__ # prints "f"print f.__doc__ # prints "does some math"内置装饰器@staticmathod、@classmethod、@property装饰器的顺序@a@b@cdef f ():等效于f = a(b(c(f)))

如果从列表开头开始切割，那么忽略 start 位的 0，例如list[:4]如果一直切到列表尾部，则忽略 end 位的 0，例如list[3:]切割列表时，即便 start 或者 end 索引跨界也不会有问题列表切片不会改变原列表。索引都留空时，会生成一份原列表的拷贝列表推导式使用列表推导式来取代map和filter不要使用含有两个以上表达式的列表推导式数据多时，列表推导式可能会消耗大量内存，此时建议使用生成器表达式迭代需要获取 index 时使用enumerateenumerate可以接受第二个参数，作为迭代时加在index上的数值用zip同时遍历两个迭代器zip遍历时返回一个元组关于for和while循环后的else块循环正常结束之后会调用else内的代码循环里通过break跳出循环，则不会执行else要遍历的序列为空时，立即执行else反向迭代对于普通的序列（列表），我们可以通过内置的reversed()函数进行反向迭代：除此以外，还可以通过实现类里的__reversed__方法，将类进行反向迭代：try/except/else/finally如果try内没有发生异常，则调用else内的代码else会在finally之前运行最终一定会执行finally，可以在其中进行清理工作函数使用装饰器装饰器用于在不改变原函数代码的情况下修改已存在的函数。常见场景是增加一句调试，或者为已有的函数增加log监控举个栗子：除此以外，还可以编写接收参数的装饰器，其实就是在原本的装饰器上的外层又嵌套了一个函数：但是像上面那样使用装饰器的话有一个问题：也就是说原函数已经被装饰器里的new_fun函数替代掉了。调用经过装饰的函数，相当于调用一个新函数。查看原函数的参数、注释、甚至函数名的时候，只能看到装饰器的相关信息。为了解决这个问题，我们可以使用Python 自带的functools.wraps方法。functools.wraps是个很 hack 的方法，它本事作为一个装饰器，做用在装饰器内部将要返回的函数上。也就是说，它是装饰器的装饰器，并且以原函数为参数，作用是保留原函数的各种信息，使得我们之后查看被装饰了的原函数的信息时，可以保持跟原函数一模一样。此外，有时候我们的装饰器里可能会干不止一个事情，此时应该把事件作为额外的函数分离出去。但是又因为它可能仅仅和该装饰器有关，所以此时可以构造一个装饰器类。原理很简单，主要就是编写类里的__call__方法，使类能够像函数一样的调用。使用生成器考虑使用生成器来改写直接返回列表的函数用这种方法有几个小问题：每次获取到符合条件的结果，都要调用append方法。但实际上我们的关注点根本不在这个方法，它只是我们达成目的的手段，实际上只需要index就好了返回的result可以继续优化数据都存在result里面，如果数据量很大的话，会比较占用内存因此，使用生成器generator会更好。生成器是使用yield表达式的函数，调用生成器时，它不会真的执行，而是返回一个迭代器，每次在迭代器上调用内置的next函数时，迭代器会把生成器推进到下一个yield表达式：获取到一个生成器以后，可以正常的遍历它：如果你还是需要一个列表，那么可以将函数的调用结果作为参数，再调用list方法可迭代对象需要注意的是，普通的迭代器只能迭代一轮，一轮之后重复调用是无效的。解决这种问题的方法是，你可以定义一个可迭代的容器类：这样的话，将类的实例迭代重复多少次都没问题：但要注意的是，仅仅是实现__iter__方法的迭代器，只能通过for循环来迭代；想要通过next方法迭代的话则需要使用iter方法：使用位置参数有时候，方法接收的参数数目可能不一定，比如定义一个求和的方法，至少要接收两个参数：对于这种接收参数数目不一定，而且不在乎参数传入顺序的函数，则应该利用位置参数*args：但要注意的是，不定长度的参数args在传递给函数时，需要先转换成元组tuple。这意味着，如果你将一个生成器作为参数带入到函数中，生成器将会先遍历一遍，转换为元组。这可能会消耗大量内存：使用关键字参数关键字参数可提高代码可读性可以通过关键字参数给函数提供默认值便于扩充函数参数定义只能使用关键字参数的函数普通的方式，在调用时不会强制要求使用关键字参数使用 Python3 中强制关键字参数的方式使用 Python2 中强制关键字参数的方式关于参数的默认值算是老生常谈了：函数的默认值只会在程序加载模块并读取到该函数的定义时设置一次也就是说，如果给某参数赋予动态的值（比如[]或者{}），则如果之后在调用函数的时候给参数赋予了其他参数，则以后再调用这个函数的时候，之前定义的默认值将会改变，成为上一次调用时赋予的值：因此，更推荐使用None作为默认参数，在函数内进行判断之后赋值：类__slots__默认情况下，Python 用一个字典来保存一个对象的实例属性。这使得我们可以在运行的时候动态的给类的实例添加新的属性：然而这个字典浪费了多余的空间 -— 很多时候我们不会创建那么多的属性。因此通过__slots__可以告诉 Python不要使用字典而是固定集合来分配空间。__call__通过定义类中的__call__方法，可以使该类的实例能够像普通函数一样调用。通过这种方式实现的好处是，可以通过类的属性来保存状态，而不必创建一个闭包或者全局变量。@classmethod & @staticmethod@classmethod和@staticmethod很像，但他们的使用场景并不一样。类内部普通的方法，都是以self作为第一个参数，代表着通过实例调用时，将实例的作用域传入方法内；@classmethod以cls作为第一个参数，代表将类本身的作用域传入。无论通过类来调用，还是通过类的实例调用，默认传入的第一个参数都将是类本身@staticmethod不需要传入默认参数，类似于一个普通的函数来通过实例了解它们的使用场景：假设我们需要创建一个名为Date的类，用于储存 年/月/日 三个数据上述代码创建了Date类，该类会在初始化时设置day/month/year属性，并且通过property设置了一个getter，可以在实例化之后，通过time获取存储的时间：但如果我们想改变属性传入的方式呢？毕竟，在初始化时就要传入年/月/日三个属性还是很烦人的。能否找到一个方法，在不改变现有接口和方法的情况下，可以通过传入2016-11-09这样的字符串来创建一个Date实例？你可能会想到这样的方法：但不够好：在类外额外多写了一个方法，每次还得格式化以后获取参数这个方法也只跟Date类有关没有解决传入参数过多的问题此时就可以利用@classmethod，在类的内部新建一个格式化字符串，并返回类的实例的方法：这样，我们就可以通过Date类来调用from_string方法创建实例，并且不侵略、修改旧的实例化方式：好处：在@classmethod内，可以通过cls参数，获取到跟外部调用类时一样的便利可以在其中进一步封装该方法，提高复用性更加符合面向对象的编程方式而@staticmethod，因为其本身类似于普通的函数，所以可以把和这个类相关的 helper方法作为@staticmethod，放在类里，然后直接通过类来调用这个方法。将与日期相关的辅助类函数作为@staticmethod方法放在Date类内后，可以通过类来调用这些方法：创建上下文管理器上下文管理器，通俗的介绍就是：在代码块执行前，先进行准备工作；在代码块执行完成后，做收尾的处理工作。with语句常伴随上下文管理器一起出现，经典场景有：通过with语句，代码完成了文件打开操作，并在调用结束，或者读取发生异常时自动关闭文件，即完成了文件读写之后的处理工作。如果不通过上下文管理器的话，则会是这样的代码：比较繁琐吧？所以说使用上下文管理器的好处就是，通过调用我们预先设置好的回调，自动帮我们处理代码块开始执行和执行完毕时的工作。而通过自定义类的__enter__和__exit__方法，我们可以自定义一个上下文管理器。然后可以以这样的方式进行调用：在调用的时候：with语句先暂存了ReadFile类的__exit__方法然后调用ReadFile类的__enter__方法__enter__方法打开文件，并将结果返回给with语句上一步的结果被传递给file_read参数在with语句内对file_read参数进行操作，读取每一行读取完成之后，with语句调用之前暂存的__exit__方法__exit__方法关闭了文件要注意的是，在__exit__方法内，我们关闭了文件，但最后返回True，所以错误不会被with语句抛出。否则with语句会抛出一个对应的错误。

装饰器是用在函数不修改添加新功能的情况下诞生的，一般在需要装饰的函数上写@funcnamedef funb(){.....}然后再装饰的函数里面去调用原函数，以达到不修改添加功能的作用

这篇文章主要介绍了Python的装饰器模式与面向切面编程详解,概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能,本文详细了装饰器模式的方方面面,然后引出面向切面编程知识,需要的朋友可以参考下今天来讨论一下装饰器。装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。1. 装饰器入门1.1. 需求是怎么来的?装饰器的定义很是抽象，我们来看一个小例子。 代码如下:def foo():print in foo()foo()这是一个很无聊的函数没错。但是突然有一个更无聊的人，我们称呼他为B君，说我想看看执行这个函数用了多长时间，好吧，那么我们可以这样做：代码如下:import timedef foo():start = time.clock()print in foo()end = time.clock()print used:, end - startfoo()很好，功能看起来无懈可击。可是蛋疼的B君此刻突然不想看这个函数了，他对另一个叫foo2的函数产生了更浓厚的兴趣。怎么办呢?如果把以上新增加的代码复制到foo2里，这就犯了大忌了~复制什么的难道不是最讨厌了么!而且，如果B君继续看了其他的函数呢?1.2. 以不变应万变，是变也还记得吗，函数在Python中是一等公民，那么我们可以考虑重新定义一个函数timeit，将foo的引用传递给他，然后在timeit中调用foo并进行计时，这样，我们就达到了不改动foo定义的目的，而且，不论B君看了多少个函数，我们都不用去修改函数定义了!代码如下:import timedef foo():print in foo()def timeit(func):start = time.clock()func()end =time.clock()print used:, end - starttimeit(foo)看起来逻辑上并没有问题，一切都很美好并且运作正常!等等，我们似乎修改了调用部分的代码。原本我们是这样调用的：foo()，修改以后变成了：timeit(foo)。这样的话，如果foo在N处都被调用了，你就不得不去修改这N处的代码。或者更极端的，考虑其中某处调用的代码无法修改这个情况，比如：这个函数是你交给别人使用的。1.3. 最大限度地少改动!既然如此，我们就来想想办法不修改调用的代码;如果不修改调用代码，也就意味着调用foo()需要产生调用timeit(foo)的效果。我们可以想到将timeit赋值给foo，但是timeit似乎带有一个参数想办法把参数统一吧!如果timeit(foo)不是直接产生调用效果，而是返回一个与foo参数列表一致的函数的话就很好办了，将timeit(foo)的返回值赋值给foo，然后，调用foo()的代码完全不用修改! 代码如下:#-*- coding: UTF-8 -*-import timedef foo():print in foo()# 定义一个计时器，传入一个，并返回另一个附加了计时功能的方法def timeit(func):# 定义一个内嵌的包装函数，给传入的函数加上计时功能的包装def wrapper():start = time.clock()func()end =time.clock()print used:, end - start# 将包装后的函数返回return wrapperfoo = timeit(foo)foo()这样，一个简易的计时器就做好了!我们只需要在定义foo以后调用foo之前，加上foo = timeit(foo)，就可以达到计时的目的，这也就是装饰器的概念，看起来像是foo被timeit装饰了。在在这个例子中，函数进入和退出时需要计时，这被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。与传统编程习惯的从上往下执行方式相比较而言，像是在函数执行的流程中横向地插入了一段逻辑。在特定的业务领域里，能减少大量重复代码。面向切面编程还有相当多的术语，这里就不多做介绍，感兴趣的话可以去找找相关的资料。这个例子仅用于演示，并没有考虑foo带有参数和有返回值的情况，完善它的重任就交给你了 ：)2. Python的额外支持2.1. 语法糖上面这段代码看起来似乎已经不能再精简了，Python于是提供了一个语法糖来降低字符输入量。 代码如下:import timedef timeit(func):def wrapper():start = time.clock()func()end =time.clock()print used:, end - startreturn wrapper@timeitdef foo():print in foo()foo()重点关注第11行的@timeit，在定义上加上这一行与另外写foo = timeit(foo)完全等价，千万不要以为@有另外的魔力。除了字符输入少了一些，还有一个额外的好处：这样看上去更有装饰器的感觉。2.2. 内置的装饰器内置的装饰器有三个，分别是staticmethod、classmethod和property，作用分别是把类中定义的实例方法变成静态方法、类方法和类属性。由于模块里可以定义函数，所以静态方法和类方法的用处并不是太多，除非你想要完全的面向对象编程。而属性也不是不可或缺的，Java没有属性也一样活得很滋润。从我个人的Python经验来看，我没有使用过property，使用staticmethod和classmethod的频率也非常低。代码如下:class Rabbit(object):def __init__(self, name):self._name = name@staticmethoddef newRabbit(name):return Rabbit(name)@classmethoddef newRabbit2(cls):return Rabbit()@propertydef name(self):return self._name这里定义的属性是一个只读属性，如果需要可写，则需要再定义一个setter：代码如下:@name.setterdef name(self, name):self._name = name2.3. functools模块functools模块提供了两个装饰器。这个模块是Python 2.5后新增的，一般来说大家用的应该都高于这个版本。但我平时的工作环境是2.4 T-T2.3.1. wraps(wrapped[, assigned][, updated]):这是一个很有用的装饰器。看过前一篇反射的朋友应该知道，函数是有几个特殊属性比如函数名，在被装饰后，上例中的函数名foo会变成包装函数的名字wrapper，如果你希望使用反射，可能会导致意外的结果。这个装饰器可以解决这个问题，它能将装饰过的函数的特殊属性保留。 代码如下:import timeimport functoolsdef timeit(func):@functools.wraps(func)def wrapper():start = time.clock()func()end =time.clock()print used:, end - startreturn wrapper@timeitdef foo():print in foo()foo()print foo.__name__首先注意第5行，如果注释这一行，foo.__name__将是wrapper。另外相信你也注意到了，这个装饰器竟然带有一个参数。实际上，他还有另外两个可选的参数，assigned中的属性名将使用赋值的方式替换，而updated中的属性名将使用update的方式合并，你可以通过查看functools的源代码获得它们的默认值。对于这个装饰器，相当于wrapper = functools.wraps(func)(wrapper)。2.3.2. total_ordering(cls):这个装饰器在特定的场合有一定用处，但是它是在Python 2.7后新增的。它的作用是为实现了至少__lt__、__le__、__gt__、__ge__其中一个的类加上其他的比较方法，这是一个类装饰器。如果觉得不好理解，不妨仔细看看这个装饰器的源代码： 代码如下:def total_ordering(cls):Class decorator that fills in missing ordering methodsconvert = {__lt__: [(__gt__, lambda self, other: otherself),(__le__, lambda self, other: not otherself),(__ge__, lambda self, other: not selfother)],__le__: [(__ge__, lambda self, other: other = self),(__lt__, lambda self, other: not other = self),(__gt__, lambda self, other: not self = other)],__gt__: [(__lt__, lambda self, other: otherself),(__ge__, lambda self, other: not otherself),(__le__, lambda self, other: not selfother)],__ge__: [(__le__, lambda self, other: other = self),(__gt__, lambda self, other: not other = self),(__lt__, lambda self, other: not self = other)]}roots = set(dir(cls))set(convert)if not roots:raise ValueError(must define at least one ordering operation: = =)root = max(roots) # prefer __lt__ to __le__ to __gt__ to __ge__for opname, opfunc in convert[root]:if opname not in roots:opfunc.__name__ = opnameopfunc.__doc__ = getattr(int, opname).__doc__setattr(cls, opname, opfunc)return cls本文到这里就全部结束了，有空的话我会整理一个用于检查参数类型的装饰器的源代码放上来，算是一个应用吧 ：)

装饰器(Decorators)是 Python 的一个重要部分。简单地说：他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短，也更Pythonic（Python范儿）。想要理解Python中的装饰器，不得不先理解闭包（closure）这一概念。（推荐学习：Python视频教程）在计算机科学中，闭包（英语：Closure），又称词法闭包（Lexical Closure）或函数闭包（function closures），是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。装饰器一个普通的装饰器一般是这样：import functoolsdef log(func): @functools.wraps(func) def wrapper(*args, **kwargs): print("call %s():" % func.__name__) print("args = {}".format(*args)) return func(*args, **kwargs) return wrapper这样就定义了一个打印出方法名及其参数的装饰器。调用之，要使用@开头：@logdef test(p): print(test.__name__ + " param: " + p)test("I"m a param")输出：call test():args = I"m a paramtest param: I"m a param装饰器在使用时，用了@语法，让人有些困扰。其实，装饰器只是个方法，与下面的调用方式没有区别：def test(p): print(test.__name__ + " param: " + p)wrapper = log(test)wrapper("I"m a param")@语法只是将函数传入装饰器函数，并无神奇之处。值得注意的是@functools.wraps(func)，这是python提供的装饰器。它能把原函数的元信息拷贝到装饰器里面的 func 函数中。函数的元信息包括docstring、name、参数列表等等。可以尝试去除@functools.wraps(func)，你会发现test.__name__的输出变成了wrapper。更多Python相关技术文章，请访问Python教程栏目进行学习！

python函数修饰符@ 修饰符 ‘@"符号用作函数修饰符是python2.4新增加的功能，修饰符必须出现在函数定义前一行，不允许和函数定义在同一行。也就是说＠A def f(): 是非法的。 只可以在模块或类定义层内对函数进行修饰，不允许修修饰一个类。一个修饰符就是一个函数，它将被修饰的函数做为参数，并返回修饰后的同名函数或其它可调用的东西。 本质上讲，装饰符@类似于 回调函数 ，把其它的函数（暂且称为目的参数，后面紧接着的函数）作为自己的入参，在目的函数执行前，执行一些自己的操作， 比如：计数、打印一些提示信息等，然后返回目的函数。下面列举一个简单的例子。 创建函数修饰符的规则： （1）修饰符是一个函数 （2）修饰符取被修饰函数为参数 （3）修饰符返回一个新函数 （4）修饰符维护被维护函数的签名 例子1： 被修饰函数不带参数 运行结果： 例子2： 使用functools模块提供的修改函数属性的方法wraps 运行结果： 可见test1的函数名称变了，如果某些代码用到就会出问题，可以使用functools模块提供的修改函数属性的方法wraps 运行结果： 例子3： 被修饰函数带参数 运行结果： 例子4： 修饰符带参数 ，需要比上面例子多一层包装 运行结果：

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。先来看一个简单例子：def foo(): print("i am foo")现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：def foo(): print("i am foo") logging.info("foo is running")bar()、bar2()也有类似的需求，怎么做？再写一个logging在bar函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门处理日志 ，日志处理完之后再执行真正的业务代码def use_logging(func): logging.warn("%s is running" % func.__name__) func()def bar(): print("i am bar")use_logging(bar)逻辑上不难理解， 但是这样的话，我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢？当然有，答案就是装饰器。简单装饰器def use_logging(func): def wrapper(*args, **kwargs): logging.warn("%s is running" % func.__name__) return func(*args, **kwargs) return wrapperdef bar(): print("i am bar")bar = use_logging(bar)bar()函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作def use_logging(func): def wrapper(*args, **kwargs): logging.warn("%s is running" % func.__name__) return func(*args) return wrapper@use_loggingdef foo(): print("i am foo")@use_loggingdef bar(): print("i am bar")bar()如上所示，这样我们就可以省去bar = use_logging(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。带参数的装饰器装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@use_logging，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。def use_logging(level): def decorator(func): def wrapper(*args, **kwargs): if level == "warn": logging.warn("%s is running" % func.__name__) return func(*args) return wrapper return decorator@use_logging(level="warn")def foo(name="foo"): print("i am %s" % name)foo()上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。类装饰器再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。class Foo(object): def __init__(self, func): self._func = funcdef __call__(self): print ("class decorator runing") self._func() print ("class decorator ending")@Foodef bar(): print ("bar")bar()functools.wraps使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：装饰器def logged(func): def with_logging(*args, **kwargs): print func.__name__ + " was called" return func(*args, **kwargs) return with_logging函数@loggeddef f(x): """does some math""" return x + x * x该函数完成等价于：def f(x): """does some math""" return x + x * xf = logged(f)不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。print f.__name__ # prints "with_logging"print f.__doc__ # prints None这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。from functools import wrapsdef logged(func): @wraps(func) def with_logging(*args, **kwargs): print func.__name__ + " was called" return func(*args, **kwargs) return with_logging@loggeddef f(x): """does some math""" return x + x * xprint f.__name__ # prints "f"print f.__doc__ # prints "does some math"内置装饰器@staticmathod、@classmethod、@property装饰器的顺序@a@b@cdef f ():等效于f = a(b(c(f)))

@deco def my(): # your code list python 会解释成：my = deco(my) 所以你实际上外面调用 my()函数时，调用的是deco 里面的wrapfunc()，返回值就是 wrapfunc()的返回值，即"return times"

去ffmpeg官网下载编译好的avcodec-57.dll、avutil-55.dll、swresample-2.dll，准备好了C语言写出的库。下面是用Python调用的例子。ujiuye

添加水印的主要目的是为了版权保护，使自己的图像不被抄袭或者恶意转载。网上有很多制作水印的工具，本帖介绍怎么使用Python-Pillow库给图片添加水印。使用ImageMagick添加图片水印－Linux 添加文本水印在图片右下角添加文字：from PILimport Image, ImageDraw, ImageFont# 指定要使用的字体和大小；/Library/Fonts/是macOS字体目录；Linux的字体目录是/usr/share/fonts/font = ImageFont.truetype("/Library/Fonts/Arial.ttf", 24)# image: 图片 text：要添加的文本 font：字体def add_text_to_image(image, text, font=font): rgba_image = image.convert("RGBA") text_overlay = Image.new("RGBA", rgba_image.size, (255, 255, 255, 0)) image_draw = ImageDraw.Draw(text_overlay) text_size_x, text_size_y = image_draw.textsize(text, font=font) # 设置文本文字位置 print(rgba_image) text_xy = (rgba_image.size[0] - text_size_x, rgba_image.size[1] - text_size_y) # 设置文本颜色和透明度 image_draw.text(text_xy, text, font=font, fill=(76, 234, 124, 180)) image_with_text = Image.alpha_composite(rgba_image, text_overlay) return image_with_textim_before = Image.open("lena.jpg")im_before.show()im_after = add_text_to_image(im_before, "WTF")im_after.show()# im.save("im_after.jpg")添加图片水印fromPILimportImage, ImageDrawdefadd_watermark_to_image(image, watermark): rgba_image = image.convert("RGBA") rgba_watermark = watermark.convert("RGBA") image_x, image_y = rgba_image.size watermark_x, watermark_y = rgba_watermark.size # 缩放图片 scale = 10 watermark_scale = max(image_x / (scale * watermark_x), image_y / (scale * watermark_y)) new_size = (int(watermark_x * watermark_scale), int(watermark_y * watermark_scale)) rgba_watermark = rgba_watermark.resize(new_size, resample=Image.ANTIALIAS) # 透明度 rgba_watermark_mask = rgba_watermark.convert("L").point(lambda x: min(x, 180)) rgba_watermark.putalpha(rgba_watermark_mask) watermark_x, watermark_y = rgba_watermark.size # 水印位置 rgba_image.paste(rgba_watermark, (image_x - watermark_x, image_y - watermark_y), rgba_watermark_mask) return rgba_imageim_before = Image.open("lena.jpg")im_before.show()im_watermark = Image.open("watermark.jpg")im_after = add_watermark_to_image(im_before, im_watermark)im_after.show()# im.save("im_after.jpg")

数据增强是扩充数据样本规模的一种有效地方法。深度学习是基于大数据的一种方法，我们当前希望数据的规模越大、质量越高越好。模型才能够有着更好的泛化能力，然而实际采集数据的时候，往往很难覆盖掉全部的场景，比如：对于光照条件，在采集图像数据时，我们很难控制光线的比例，因此在训练模型的时候，就需要加入光照变化方面的数据增强。再有一方面就是数据的获取也需要大量的成本，如果能够自动化的生成各种训练数据，就能做到更好的开源节流。 数据增强可以分为两类，一类是离线增强，一类是在线增强。 pytorch中数据增强的常用方法如下： torchvision中内置的transforms包含了这些些常用的图像变换，这些变换能够用Compose串联组合起来。 原图： class torchvision.transforms.CenterCrop(size) 原图像尺寸：(658, 411) 中心裁剪后尺寸:(200, 200) class torchvision.transforms.ColorJitter(brightness=0, contrast=0, saturation=0, hue=0) class torchvision.transforms.Grayscale(num_output_channels=1)) class torchvision.transforms.Pad(padding, fill=0, padding_mode="constant") class torchvision.transforms.RandomCrop(size, padding=0, pad_if_needed=False) class torchvision.transforms.RandomHorizontalFlip(p=0.5) class torchvision.transforms.RandomVerticalFlip(p=0.5) class torchvision.transforms.RandomRotation(degrees, resample=False, expand=False, center=None)

Python-for-data-移动窗口函数 本文中介绍的是 ，主要的算子是： 统计和通过其他移动窗口或者指数衰减而运行的函数，称之为 移动窗口函数 <style scoped="">.dataframe tbody tr th:only-of-type { vertical-align: middle; } <pre><code>.dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </code></pre></style> 2292 rows × 3 columns rolling算子，行为和resample和groupby类似 rolling可以在S或者DF上通过一个window进行调用 <style scoped="">.dataframe tbody tr th:only-of-type { vertical-align: middle; } <pre><code>.dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </code></pre></style> 2292 rows × 3 columns 指定一个常数衰减因子为观测值提供更多的权重。常用指定衰减因子的方法：使用span（跨度） 一些统计算子，例如相关度和协方差等需要同时操作两个时间序列。 例如，金融分析中的股票和基准指数的关联性问题：计算时间序列的百分比变化pct_change() <style scoped="">.dataframe tbody tr th:only-of-type { vertical-align: middle; } <pre><code>.dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </code></pre></style> 在rolling及其相关方法上使用apply方法提供了一种在移动窗口中应用自己设计的数组函数的方法。 唯一要求：该函数从每个数组中产生一个单值(缩聚)，例如使用rolling()...quantile(q)计算样本的中位数

解决方法：直接获取它全部的索引值强制改变 temp_volume_series.index = temp_time_series！

Python-for-data-重新采样和频率转换 重新采样指的是将时间序列从一个频率转换到另一个频率的过程。 但是也并不是所有的采样方式都是属于上面的两种 pandas中使用resample方法来实现频率转换，下面是resample方法的参数详解： 将数据聚合到一个规则的低频上，例如将时间转换为每个月，"M"或者"BM"，将数据分成一个月的时间间隔。 每个间隔是半闭合的，一个数据只能属于一个时间间隔。时间间隔的并集必须是整个时间帧 默认情况下，左箱体边界是包含的。00:00的值是00：00到00：05间隔内的值 产生的时间序列按照每个箱体左边的时间戳被标记。 传递<span class="mark">label="right"</span>可以使用右箱体边界标记时间序列 向loffset参数传递字符串或者日期偏置 在金融数据中，为每个数据桶计算4个值是常见的问题： 通过<span class="girk">ohlc聚合函数</span>能够得到四种聚合值列的DF数据 低频转到高频的时候会形成缺失值 ffill() ：使用前面的值填充， limit 限制填充的次数

stack overflow是堆栈溢出。堆栈溢出的产生是由于过多的函数调用，导致调用堆栈无法容纳这些调用的返回地址，一般在递归中产生。堆栈溢出很可能由无限递归（Infinite recursion）产生，但也可能仅仅是过多的堆栈层级。请对应检查一下。

你这代码从哪里拷贝来的？...是什么鬼？

torch.cat(seq,dim=0,out=None)->Tensor 在给定维度上对输入张量序列seq进行连接操作由这可以想到卷积神经网络 的全连接层 torch.cat() 可以看做 torch.split() 和 torch.chunk() 的逆运算 torch.chunk(tensor,chunks,dim)->>tensors 将张量沿给定维度分块 torch.gather(input,dim,index,out=None,sparse_grad=Flase,out=None)->Tensor 通俗点解释就是把指定索引dim的下标进行替换 torch.index_select(input,dim,index,out=None)->>Tensor torch.masked_select(input,mask,out=None)->>Tensor 根据mask输出一个一维张量 torch.split(tensor,split_size,dim=0)->>tensor 如果可分,张量沿着指定维度指定大小进行分割,直到大小不足则停止 torch.t(input,out=None)->Tensor 张量转置相当于 torch.transpose(input,o,1) torch.bernoulli(input,out=None) 从伯努利分布中抽取二元随机数(0或者1)这里的bernoulli概率p是随机的 输入张量值需是一个概率 torch.multinomial(input,num_samples,replacement=Flase,out=None)->>LongTensor 从输入张量中每行取num_samples个样本,可以设置replacement设置是否重复取值 返回取值的下标 torch.normal(means,std,out)->>tensor 按照指定均值和方差选取样本,均值个数决定样本个数 若均值和方差都为张量则两个张量元素个数必须相等 torch.abs(input,out)->tensor 输出张量元素绝对值 torch.acos(input,out) 求反余弦 torch.add(input,value,out) 对每个张量元素逐个加上value torch.addcdiv(tensor,value=1,tensor1,tensor2) 张量(tensor1/tensor2)*value+tensor torch.addmul 相乘相加 torch.ceil(input,out) 向上取整 torch.clamp(input,min,max,out=None) 将元素调整至[min,max]区间 torch.div(input,value) 除 torch.exp(tensor,out) 指数 torch.floor(input,out) 向下去整 torch.fmod(input,divisor,out) 取余数 torch.frac 取分数部分 torch.lerp(start, end, weight, out=None) 线性插值:out = start+weight*(end-start) torch.log 取自然对数 torch.mul(input, value, out=None) torch.mul(input, other, out=None) 哈达玛积 torch.neg 取复数 torch.pow(input, exponent, out=None) 求幂 torch.reciprocal(input, out=None) → Tensor 去倒数 torch.remainder(input, divisor, out=None) → Tensor 取余数 torch.rsqrt(input, out=None) → Tensor 平方根倒数 torch.sigmoid(input, out=None) → Tensor sigmoid值 torch.sigmoid(input, out=None) → Tensor 符号函数 torch.cumprod(input, dim, out=None) → Tensor 按指定维度累积 torch.cumsum(input, dim, out=None) → Tensor 指定维度累加 torch.dist(input, other, p=2, out=None) → Tensor 求P范数 torch.mean(input) → float 均值 torch.mean(input, dim, out=None) → Tensor 指定维度均值 torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor) 指定维度中位数 torch.mode(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor) 众数 torch.norm(input, p, dim, out=None) → Tensor 指定维度p范数 torch.prod(input) → float 所有积 torch.prod(input, dim, out=None) → Tensor 指定维度积 torch.std(input, dim, out=None) → Tensor 标准差 torch.sum(input, dim, out=None) → Tensor 按维度求和 torch.sum(input) → float 所有元素和 var 按行方差，所有元素方差 torch.eq(input, other, out=None) → Tensor 相等比较操作 返回01 torch.equal(tensor1, tensor2) → bool 张量比较shape and value返回bool torch.ge(input, other, out=None) → Tensor 大于 torch.gt(input, other, out=None) → Tensor 与equal类似返回不同 torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor) 取指定维度最小值 torch.le(input, other, out=None) → Tensor 小于等于 torch.lt(input, other, out=None) → Tensor 小于 torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor) 返回指定维度最大值和索引

[1] 【Pytorch | Tensorflow】--- label与one-hot独热编码向量之间的相互转换 [2] Pytorch中，将label变成one hot编码的两种方式 [3] Pytorch中，将label变成one hot编码的两种方式 [4] Pytorch 类别标签转换one-hot编码

使用反向传播法训练神经网络时，模型的参数依据损失函数与对应参数的梯度来调整，即： 自动微分 是机器学习工具包必备的工具，它可以自动计算整个计算图的微分。 PyTorch 内建了一个叫做 torch.autograd 的自动微分引擎，该引擎支持的数据类型为：浮点数Tensor类型 ( half, float, double and bfloat16) 和复数Tensor 类型(cfloat, cdouble) PyTorch 中与自动微分相关的常用的Tensor属性和函数： TensorFlow 通过 tf.GradientTape API来自动追踪和计算微分，GradientTape，翻译为微分带，Tape有点儿历史上磁带机的味道，即在Tape上记录下所有的计算和计算结果。 tf.GradientTape 在tf.Variable而非tf.Tensor上计算，因为在TensorFlow中，tf.Tensor为不可变对象，tf.Variable为可变对象；通常 用tf.Variable来存储模型参数 。 tf.Variable 有一个trainable属性，该属性tf.Tensor没有，类似PyTorch Tensor的requires_grad, 即告知自动微分引擎是否追踪该tf.Variable，并自动计算该tf.Variable的微分。 范例： 从上述可以看到，TensorFlow的自动微分实现方式与PyTorch大不相同，而且 没有把参数和参数的微信封装成一个对象，这点非常不User-Friendly，或者说封装的不好 ！ 为了方便实现模型，模型的参数，与模型参数的微分，TensorFlow又提供了另外一套机制： 模型的微分(Gradients with respect to a model) , 意思是：TensorFlow开发团队也知道了用tf.Variable实现模型参数，然后用tape.gradient()方法计算微分，tf.Variable和它对应的微分是分离的，是没有封装好的，这种方式对开发者不友好，所以，TensorFlow开发者团队对于构建模型的基础类： tf.Module 或者它的子类 ( layers.Layer , keras.Model )，提供了一个 Module.trainable_variables 的属性，该属性把模型参数都封装好了，使用起来比较方便。不过对应微分还是没封装，坚持自己的个性...对于我们开发者，还是选择遵循... 范例： 参考资料：

可以利用in运算符来进行判断。如果在指定的序列中找到值返回True，否则返回False。运算符notin表示如果在指定的序列中没有找到值返回True，否则返回False。Python字典in操作符用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false。此方法用于列表可以判断元素是否在列表中。

数据的预处理以及数据集的构建会经常使用到tensor的切分操作，现整理如下： 功能 ：输入数据与想要切分的块数 chunks ，将数据尽可能 (如果数据个数与块数能整除的话) 平均的切分为 chunks 块 注意 ：没有进行数据的拷贝 参数 Test Output 功能 ： 注意 ：没有对输入数据进行拷贝 参数 ： Test 1 输入整型数据 Output 1 Test 2 输入为整型序列 Output 功能 ：torch支持numpy中对数据的切片操作 Test Output 功能 ：删除tensor的一个维度，返回各个子块组成的 tuple 参数 ： Test Output 感谢你的阅读，如果文中存在错误，还请在评论区指出~

在指定的维度dim上对序列seq进行连接操作。 参数： 例子： torch.Tensor.expand( sizes)* → Tensor 返回张量的一个新视图，可以将张量的单个维度扩大为更大的尺寸。 张量也可以扩大为更高维，新增加的维度将附在前面。 扩大张量不需要分配新内存，仅仅是新建一个张量的视图。任意一个一维张量在不分配新内存情况下都可以扩展为任意的维度。 传入-1则意味着维度扩大不涉及这个维度。 参数： 例子： torch.squeeze(input, dim=None, out=None) → Tensor 除去输入张量input中数值为1的维度，并返回新的张量。如果输入张量的形状为（ [图片上传失败...(image-786ec5-1580566115084)] ），那么输出张量的形状为（ [图片上传失败...(image-a0a179-1580566115084)] ）。 当通过dim参数指定维度时，维度压缩操作只会在指定的维度上进行。如果输入向量的形状为（ [图片上传失败...(image-1088a1-1580566115084)] ），squeeze(input, 0)会保持张量的维度不变，只有在执行squeeze(input, 1)时，输入张量的形状会被压缩至（ [图片上传失败...(image-759892-1580566115084)] ）。 如果一个张量只有1个维度，那么它不会受到上述方法的影响。 输出的张量与原张量共享内存，如果改变其中的一个，另一个也会改变。 参数: 例子： torch.Tensor.repeat( sizes)* 沿着指定的维度重复张量。不同于expand()方法，本函数复制的是张量中的数据。 参数： 例子： torch.Tensor.unfold(dim, size, step) → Tensor 返回一个新的张量，其中元素复制于有原张量在dim维度上的数据，复制重复size次，复制时的步进值为step。 参数： 例子： torch.Tensor.narrow(dimension, start, length) → Tensor 返回一个经过缩小后的张量。操作的维度由dimension指定。缩小范围是从start开始到start+length。执行本方法的张量与返回的张量共享相同的底层内存。 参数： 例子： torch.Tensor.view( args)* → Tensor 返回一个有相同数据但是不同形状的新的向量。 返回的装两必须与原张量有相同的数据和相同的元素个数，但是可以有不同的尺寸。 参数： 例子： torch.Tensor.resize_( sizes)* 将张量的尺寸调整为指定的大小。如果元素个数比当前的内存大小大，就将底层存储大小调整为与新元素数目一致的大小。 如果元素个数比当前内存小，则底层存储不会被改变。原来张量中被保存下来的元素将保持不变，但新内存将不会被初始化。 参数： 例子： torch.Tensor.permute( dims)* 将执行本方法的张量的维度换位。 参数： 例子： torch.Tensor.element_size() → int 查看某类型张量单个元素的字节数。 例子：

在XML解析方面，Python贯彻了自己“开箱即用”（batteries included）的原则。在自带的标准库中，Python提供了大量可以用于处理XML语言的包和工具，数量之多，甚至让Python编程新手无从选择。本文将介绍深入解读利用Python语言解析XML文件的几种方式，并以笔者推荐使用的ElementTree模块为例，演示具体使用方法和场景。文中所使用的Python版本为2.7。一、什么是XML?XML是可扩展标记语言（Extensible Markup Language）的缩写，其中的 标记（markup）是关键部分。您可以创建内容，然后使用限定标记标记它，从而使每个单词、短语或块成为可识别、可分类的信息。标记语言从早期的私有公司和政府制定形式逐渐演变成标准通用标记语言（Standard Generalized Markup Language，SGML）、超文本标记语言（Hypertext Markup Language，HTML），并且最终演变成 XML。XML有以下几个特点。 XML的设计宗旨是传输数据，而非显示数据。 XML标签没有被预定义。您需要自行定义标签。 XML被设计为具有自我描述性。 XML是W3C的推荐标准。目前，XML在Web中起到的作用不会亚于一直作为Web基石的HTML。 XML无所不在。XML是各种应用程序之间进行数据传输的最常用的工具，并且在信息存储和描述领域变得越来越流行。因此，学会如何解析XML文件，对于Web开发来说是十分重要的。二、有哪些可以解析XML的Python包？Python的标准库中，提供了6种可以用于处理XML的包。xml.domxml.dom实现的是W3C制定的DOM API。如果你习惯于使用DOM API或者有人要求这这样做，可以使用这个包。不过要注意，在这个包中，还提供了几个不同的模块，各自的性能有所区别。DOM解析器在任何处理开始之前，必须把基于XML文件生成的树状数据放在内存，所以DOM解析器的内存使用量完全根据输入资料的大小。xml.dom.minidomxml.dom.minidom是DOM API的极简化实现，比完整版的DOM要简单的多，而且这个包也小的多。那些不熟悉DOM的朋友，应该考虑使用xml.etree.ElementTree模块。据lxml的作者评价，这个模块使用起来并不方便，效率也不高，而且还容易出现问题。xml.dom.pulldom与其他模块不同，xml.dom.pulldom模块提供的是一个“pull解析器”，其背后的基本概念指的是从XML流中pull事件，然后进行处理。虽然与SAX一样采用事件驱动模型（event-driven processing model），但是不同的是，使用pull解析器时，使用者需要明确地从XML流中pull事件，并对这些事件遍历处理，直到处理完成或者出现错误。 pull解析（pull parsing）是近来兴起的一种XML处理趋势。此前诸如SAX和DOM这些流行的XML解析框架，都是push-based，也就是说对解析工作的控制权，掌握在解析器的手中。xml.saxxml.sax模块实现的是SAX API，这个模块牺牲了便捷性来换取速度和内存占用。SAX是Simple API for XML的缩写，它并不是由W3C官方所提出的标准。它是事件驱动的，并不需要一次性读入整个文档，而文档的读入过程也就是SAX的解析过程。所谓事件驱动，是指一种基于回调（callback）机制的程序运行方法。xml.parser.expatxml.parser.expat提供了对C语言编写的expat解析器的一个直接的、底层API接口。expat接口与SAX类似，也是基于事件回调机制，但是这个接口并不是标准化的，只适用于expat库。expat是一个面向流的解析器。您注册的解析器回调（或handler）功能，然后开始搜索它的文档。当解析器识别该文件的指定的位置，它会调用该部分相应的处理程序（如果您已经注册的一个）。该文件被输送到解析器，会被分割成多个片断，并分段装到内存中。因此expat可以解析那些巨大的文件。xml.etree.ElementTree（以下简称ET）xml.etree.ElementTree模块提供了一个轻量级、Pythonic的API，同时还有一个高效的C语言实现，即xml.etree.cElementTree。与DOM相比，ET的速度更快，API使用更直接、方便。与SAX相比，ET.iterparse函数同样提供了按需解析的功能，不会一次性在内存中读入整个文档。ET的性能与SAX模块大致相仿，但是它的API更加高层次，用户使用起来更加便捷。笔者建议，在使用Python进行XML解析时，首选使用ET模块，除非你有其他特别的需求，可能需要另外的模块来满足。 解析XML的这几种API并不是Python独创的，Python也是通过借鉴其他语言或者直接从其他语言引入进来的。例如expat就是一个用C语言开发的、用来解析XML文档的开发库。而SAX最初是由DavidMegginson采用java语言开发的，DOM可以以一种独立于平台和语言的方式访问和修改一个文档的内容和结构，可以应用于任何编程语言。下面，我们以ElementTree模块为例，介绍在Python中如何解析lxml。三、利用ElementTree解析XMLPython标准库中，提供了ET的两种实现。一个是纯Python实现的xml.etree.ElementTree，另一个是速度更快的C语言实现xml.etree.cElementTree。请记住始终使用C语言实现，因为它的速度要快很多，而且内存消耗也要少很多。如果你所使用的Python版本中没有cElementTree所需的加速模块，你可以这样导入模块：try: import xml.etree.cElementTree as ETexcept ImportError: import xml.etree.ElementTree as ET如果某个API存在不同的实现，上面是常见的导入方式。当然，很可能你直接导入第一个模块时，并不会出现问题。请注意，自Python 3.3之后，就不用采用上面的导入方法，因为ElemenTree模块会自动优先使用C加速器，如果不存在C实现，则会使用Python实现。因此，使用Python 3.3+的朋友，只需要import xml.etree.ElementTree即可。1、将XML文档解析为树（tree）我们先从基础讲起。XML是一种结构化、层级化的数据格式，最适合体现XML的数据结构就是树。ET提供了两个对象：ElementTree将整个XML文档转化为树，Element则代表着树上的单个节点。对整个XML文档的交互（读取，写入，查找需要的元素），一般是在ElementTree层面进行的。对单个XML元素及其子元素，则是在Element层面进行的。下面我们举例介绍主要使用方法。我们使用下面的XML文档，作为演示数据： text,source xml,sgml接下来，我们加载这个文档，并进行解析：>>> import xml.etree.ElementTree as ET>>> tree = ET.ElementTree(file="doc1.xml")然后，我们获取根元素（root element）：>>> tree.getroot()正如之前所讲的，根元素（root）是一个Element对象。我们看看根元素都有哪些属性：>>> root = tree.getroot()>>> root.tag, root.attrib("doc", {})没错，根元素并没有属性。与其他Element对象一样，根元素也具备遍历其直接子元素的接口：>>> for child_of_root in root:... print child_of_root.tag, child_of_root.attrib...branch {"hash": "1cdf045c", "name": "codingpy.com"}branch {"hash": "f200013e", "name": "release01"}branch {"name": "invalid"}我们还可以通过索引值来访问特定的子元素：>>> root[0].tag, root[0].text("branch", " text,source ")2、查找需要的元素从上面的示例中，可以明显发现我们能够通过简单的递归方法（对每一个元素，递归式访问其所有子元素）获取树中的所有元素。但是，由于这是十分常见的工作，ET提供了一些简便的实现方法。Element对象有一个iter方法，可以对某个元素对象之下所有的子元素进行深度优先遍历（DFS）。ElementTree对象同样也有这个方法。下面是查找XML文档中所有元素的最简单方法：>>> for elem in tree.iter():... print elem.tag, elem.attrib...doc {}branch {"hash": "1cdf045c", "name": "codingpy.com"}branch {"hash": "f200013e", "name": "release01"}sub-branch {"name": "subrelease01"}branch {"name": "invalid"}在此基础上，我们可以对树进行任意遍历——遍历所有元素，查找出自己感兴趣的属性。但是ET可以让这个工作更加简便、快捷。iter方法可以接受tag名称，然后遍历所有具备所提供tag的元素：>>> for elem in tree.iter(tag="branch"):... print elem.tag, elem.attrib...branch {"hash": "1cdf045c", "name": "codingpy.com"}branch {"hash": "f200013e", "name": "release01"}branch {"name": "invalid"}3、支持通过XPath查找元素使用XPath查找感兴趣的元素，更加方便。Element对象中有一些find方法可以接受Xpath路径作为参数，find方法会返回第一个匹配的子元素，findall以列表的形式返回所有匹配的子元素, iterfind则返回一个所有匹配元素的迭代器（iterator）。ElementTree对象也具备这些方法，相应地它的查找是从根节点开始的。下面是一个使用XPath查找元素的示例：>>> for elem in tree.iterfind("branch/sub-branch"):... print elem.tag, elem.attrib...sub-branch {"name": "subrelease01"}上面的代码返回了branch元素之下所有tag为sub-branch的元素。接下来查找所有具备某个name属性的branch元素：>>> for elem in tree.iterfind("branch[@name="release01"]"):... print elem.tag, elem.attrib...branch {"hash": "f200013e", "name": "release01"}4、构建XML文档利用ET，很容易就可以完成XML文档构建，并写入保存为文件。ElementTree对象的write方法就可以实现这个需求。一般来说，有两种主要使用场景。一是你先读取一个XML文档，进行修改，然后再将修改写入文档，二是从头创建一个新XML文档。修改文档的话，可以通过调整Element对象来实现。请看下面的例子：>>> root = tree.getroot()>>> del root[2]>>> root[0].set("foo", "bar")>>> for subelem in root:... print subelem.tag, subelem.attrib...branch {"foo": "bar", "hash": "1cdf045c", "name": "codingpy.com"}branch {"hash": "f200013e", "name": "release01"}在上面的代码中，我们删除了root元素的第三个子元素，为第一个子元素增加了新属性。这个树可以重新写入至文件中。最终的XML文档应该是下面这样的：>>> import sys>>> tree.write(sys.stdout) text,source xml,sgml请注意，文档中元素的属性顺序与原文档不同。这是因为ET是以字典的形式保存属性的，而字典是一个无序的数据结构。当然，XML也不关注属性的顺序。从头构建一个完整的文档也很容易。ET模块提供了一个SubElement工厂函数，让创建元素的过程变得很简单：>>> a = ET.Element("elem")>>> c = ET.SubElement(a, "child1")>>> c.text = "some text">>> d = ET.SubElement(a, "child2")>>> b = ET.Element("elem_b")>>> root = ET.Element("root")>>> root.extend((a, b))>>> tree = ET.ElementTree(root)>>> tree.write(sys.stdout)some text5、利用iterparse解析XML流XML文档通常都会比较大，如何直接将文档读入内存的话，那么进行解析时就会出现问题。这也就是为什么不建议使用DOM，而是SAX API的理由之一。我们上面谈到，ET可以将XML文档加载为保存在内存里的树（in-memory tree），然后再进行处理。但是在解析大文件时，这应该也会出现和DOM一样的内存消耗大的问题吧？没错，的确有这个问题。为了解决这个问题，ET提供了一个类似SAX的特殊工具——iterparse，可以循序地解析XML。接下来，笔者为大家展示如何使用iterparse，并与标准的树解析方式进行对比。我们使用一个自动生成的XML文档，下面是该文档的开头部分： United States 1 duteous nine eighteen Creditcard[...]我们来统计一下文档中出现了多少个文本值为Zimbabwe的location元素。下面是使用ET.parse的标准方法：tree = ET.parse(sys.argv[2])count = 0for elem in tree.iter(tag="location"): if elem.text == "Zimbabwe": count += 1print count上面的代码会将全部元素载入内存，逐一解析。当解析一个约100MB的XML文档时，运行上面脚本的Python进程的内存使用峰值为约560MB，总运行时间问2.9秒。请注意，我们其实不需要讲整个树加载到内存里。只要检测出文本为相应值得location元素即可。其他数据都可以废弃。这时，我们就可以用上iterparse方法了：count = 0for event, elem in ET.iterparse(sys.argv[2]): if event == "end": if elem.tag == "location" and elem.text == "Zimbabwe": count += 1 elem.clear() # 将元素废弃print count上面的for循环会遍历iterparse事件，首先检查事件是否为end，然后判断元素的tag是否为location，以及其文本值是否符合目标值。另外，调用elem.clear()非常关键：因为iterparse仍然会生成一个树，只是循序生成的而已。废弃掉不需要的元素，就相当于废弃了整个树，释放出系统分配的内存。当利用上面这个脚本解析同一个文件时，内存使用峰值只有7MB，运行时间为2.5秒。速度提升的原因，是我们这里只在树被构建时，遍历一次。而使用parse的标准方法是先完成整个树的构建后，才再次遍历查找所需要的元素。iterparse的性能与SAX相当，但是其API却更加有用：iterparse会循序地构建树；而利用SAX时，你还得自己完成树的构建工作。

楼主解决了吗？如何解决的

典型的卷积神经网络包括： AlexNet、VGG、ResNet; InceptionV1、InceptionV2、InceptionV3、InceptionV4、Inception-ResNet 。 轻量级网络包括： GhostNet、MobileNets、MobileNetV2、MobileNetV3、ShuffleNet、ShuffleNet V2、SqueezeNet Xception MixNet GhostNet 。 目标检测网络包括： SSD、YOLO、YOLOv2、YOLOv3、FCOS、FPN、RetinaNet Objects as Points、FSAF、CenterNet FoveaBox 。 语义分割网络包括： FCN、Fast-SCNN、LEDNet、LRNNet、FisheyeMODNet 。 实例分割网络包括：PolarMask。 PolarMask : Single Shot Instance Segmentation with Polar Representation ,2019 人脸检测和识别网络包括：FaceBoxes、LFFD、VarGFaceNet。 人体姿态识别网络包括：Stacked Hourglass、Networks Simple Baselines、LPN。 StackedHG: Stacked Hourglass Networks for Human Pose Estimation ,2016 Simple Baselines ：Simple Baselines for Human Pose Estimation and Tracking LPN: Simple and Lightweight Human Pose Estimation 注意力机制网络包括：SE Net、scSE、NL Net、GCNet、CBAM。 人像分割网络包括：SINet。

①.py：以py扩展名的文件是python源码文件，由python.exe解释，可在控制台下运行，可用文本编辑器读写。②.py3：python3脚本，通常以.py而不是.py3结尾，很少使用。③.pyc：以pyc扩展名的是python的编译文件。其执行速度快于py文件且不能用文本编辑器编辑查看。所以pyc文件往往代替py文件发布。python在执行时，首先会将py文件中的源代码编译成PyCodeObject写入pyc文件，再由虚拟机执行pyCodeObject。当python执行import时会先寻找对应的pyc或者pyd文件，如果没有则将对应的py文件编译写入pyc文件。④.pyo：pyo是优化编译后的程序，不能用文本编辑器编辑。python -O source.py即可将源程序编译为pyo文件。这是在优化(-O)时创建的*.pyc文件，从python3.5开始，python将只能使用.pyc而不是.pyo和.pyc。⑤.pyd：pyd一般是python外的其他语言如C、C++编写的python扩展模块，即python的一个动态连接库，与dll文件相当。在Linux系统中一般为.so文件。⑥.pyi：MyPy存根，存根文件。⑦.pyw：用pythonw.exe执行的Windows的python脚本。pyw文件与pyc文件相似，但pyw执行的时候不会出控制台窗口;开发时可以暂时把pyw改成py以调出控制台窗口调试。⑧.pyz：python的脚本归档(PEP 441)，这是一个包含标准python脚本头之后的二进制形式的压缩python脚本的脚本。⑨.pywz：用于MS-Windows的python脚本归档，这是一个包含标准python脚本头之后的二进制形式的压缩python脚本的脚本。⑩.pyt：python声明文件。

python文件的后缀名有：“.py”、“.py3”、“.pyc”、“.pyo”、“.pyd”、“.pyi”、“.pyx”、“.pyz”、“.pywz”、“.rpy”、“.pyde”、“.pyp”、“.pyt”。python文件后缀总结：（1）.py：以 py 扩展名的文件是 Python 源码文件，由 python.exe 解释，可在控制台下运行。可用文本编辑器读写。（2）.py3：Python3脚本（Python3脚本通常以.py而不是.py3结尾，很少使用）。（3）.pyc：以 pyc 为扩展名的是Python的编译文件。其执行速度快于 py 文件且不能用文本编辑编辑查看。所以 pyc 文件往往代替 py 文件发布。 Python 在执行时，首先会将 py 文件中的源代码编译成 PyCodeObject 写入 pyc 文件，再由虚拟机执行 PyCodeObject。当 Python 执行 import 时会先寻找对应的 pyc或 pyd（dll）文件，如果没有则将对应的py文件编译写入 pyc 文件。pyc文件也可以通过 python -m py_compile src.py 生成。.pyc二进制文件可以反编译成.py文件，反编译软件叫Easy Python Decompiler。（4）.pyo：pyo 是优化编译后的程序，不能用文本编辑器编辑。 python -O source.py 即可将源程序编译为 pyo 文件。这是在优化(-O)时创建的*.pyc文件，从Python3.5开始，Python将只使用.pyc而不是.pyo和.pyc。（5）.pyd：这基本上是一个Windows DLL文件。pyd 一般是 Python 外的其他语言如 C/C++ 编写的 Python 扩展模块，即 Python 的一个动态连接库，与 dll 文件相当。在Linux系统中一般为.so文件（6）.pyi：MyPy存根，存根文件（PEP 484）。（7）.pyw：用pythonw.exe执行的Windows的Python脚本。pyw 文件与 pyc 文件相似，但 pyw 执行的时候不会出控制台窗口。开发（纯图形界面程序）时可以暂时把 pyw 改成 py 以调出控制台窗口调试。（8）.pyx：将Cython src转换为C/C++。（9）.pyz：Python脚本归档（PEP 441）（这是一个包含标准Python脚本头之后的二进制形式的压缩Python脚本（ZIP）的脚本）。（10）.pywz：用于MS-Windows的Python脚本归档（PEP 441）（这是一个包含标准Python脚本头之后的二进制形式的压缩 Python脚本（ZIP）的脚本）。（11）.py [cod]：.gitignore中的通配符表示该文件可能是.pyc，.pyo或.pyd。（12）.rpy：包含应用程序或框架特定功能的RPython脚本或Python脚本。（13）.pyde：处理使用的Python脚本。（14）.pyp：Py4D Python插件。（15）.pyt：Python声明文件。推荐学习：Python视频教程

本篇文章给大家带来的内容是关于几款Python类型检查工具的分享，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。近日，微软在 Github 上开源了一个 Python 静态类型检查工具：pyright ，引起了社区内的多方关注。微软在开源项目上的参与力度是越来越大了，不说收购 Github 这种大的战略野心，只说它家开源的 VS Code 编辑器，在猿界已经割粉无数，连我们 Python 圈的红人 Kenneth Reitz （多个开源项目的作者，包括 requests、requests-html、responder等）都对它赞不绝口。如今开源的 Pyright ，口碑还不错，那我们就来看看它有啥本事，顺便再介绍其它几款类型检查工具。众所周知，Python 是一门动态类型语言，在运行期才知道变量的实际类型。这本就是动态语言的特色，然而在团队合作或大型项目上，维护的代价也不可避免，俗话说的是：“动态一时爽，重构火葬场 ”。早在 2006 年的 PEP-3107，Python 就推出了函数注解的功能，最终落在 3.0 版本实现。而到了 3.5 版本，Python 继续引入了静态类型检查的语法（即 PEP-484，type hints）。2014 年的 PEP-483 更是以《The Theory of Type Hints》为题，做出了理论上的归纳。后来，又陆续提出了 PEP-526、PEP-544，类型检查的规范逐渐丰富。类型检查的好处是及早检查，提前发现类型的错误，增强代码的一致性与可维护性。（还有防止脱发，喵）# 不加检查def greeting(name): return "Hello " + name# 添加检查def greeting(name: str) -> str: return "Hello " + name如上例所示，增加检查后，可以在编译期就判断入参和返回值是否是字符串类型。在微软推出 pyright 之前，主流的静态检查工具有三款：官方的mypy 、Google 出的pytype 、Facebook 出的pyre-check 。三足鼎立的局面要被打破了。pyright 的文档宣称它有如下特点：速度快。相较于 mypy 及其它用 Python 写的检查工具，它的速度是 5 倍甚至更多。不依赖 Python 环境。它用 TypeScript 写成，运行于 node 上，不依赖 Python 环境或第三方包。可配置性强。支持自由地配置，支持指定不同的运行环境（PYTHONPATH 设置、Python 版本、平台目标）。检查项齐全。支持类型检查及其它语法项的检查（如 PEP-484、PEP-526、PEP-544），以及函数返回值、类变量、全局变量的检查，甚至可以检查条件循环语句命令行工具。它包含两个 VS Code 插件：一个命令行工具和一个语言服务器协议（Language Server Protocol）内置 Stubs 。使用的是 Typeshed 的副本。（注：使用静态的 pyi 文件，检查内置模块、标准库和三方件 ）语言服务特性。悬停提示信息、符号定义的跳转、实时的编辑反馈就此而言，不可谓不强大。事实上，pyright 是“站在了巨人的肩膀上”，它的各项功能似乎都继承自其它几位前辈。接着看官方的 mypy ，它由“Python 之父” Guido van Rossum 亲自参与开发，是最主流的选择，推出得早，用户基数大，文档与社区经验也最丰富。在集成 IDE 方面，所有主流的编辑器都支持：PyCharm、Vim、Emacs、Sublime Text、VS Code、Atom......在业界经验上，Instagram 和 Dropbox 的项目从 py2 迁移到 py3 ，就是用的它来做保障。接着看谷歌的 pytype ，据文档描述，它可以：标记常见错误，如拼写错误、函数调用错误加强自定义的类型注解支持对 pyi 文件生成类型注解查看文档，我发现它有个功能还挺人性化的，即“错误降噪 ”，对于那些不必修改的错误，可以添加注释，来消除类型检查。此外，还有一个考虑也不错，为了写类型检查，模块中可能会额外引入其它的模块，对于后者，pytype 有办法隐藏它，只在做类型检查时才加载。最后，要介绍的是脸书的 pyre-check，它是去年开源的，也曾收获一片好评（说不定正是因为它，微软才上马了 pyright 项目也说不定）。基本的功能点大同小异，不过它也是有亮点的。pyre-check 可集成Watchman 模块，该“观察者”会监听代码文件，跟踪所做的修改。微软的 pyright 有个 watch 模式，应该是吸收了这点，而且更加好用（因为不需要额外安装 Watchman 和其它依赖）。pyre-check 还有个亮点，它有个query 参数，可以对源码做局部区域性的检查，例如查询某行中一个表达式的类型、查询一个类的全部方法并返回成列表，等等，这样可以避免做全面的检查。4 种类型检查工具介绍完毕，下面是一份概要对比：至于它们的性能如何，是否真如 pyright 所说，它的速度是其它几个的 5 倍呢？感兴趣的同学们可以去试试。有什么使用体会，欢迎留言与我交流。项目地址： https://github.com/python/mypy、https://github.com/Microsoft/pyright、https://github.com/google/pytype、https://github.com/facebook/pyre-check本篇文章到这里就已经全部结束了，更多其他精彩内容可以关注PHP中文网的python视频教程栏目！

1） start：用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。2） run：run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void.。

Python 中有多种用于处理时间序列的库,具体的参数取决于你使用的库。例如，使用 Pandas 时间序列的创建可以使用的参数有：- start: 起始时间- end: 结束时间- periods: 整数，表示生成的时间点的数量- freq: 时间频率，例如 "D" 表示每天- tz: 时区- normalize: 布尔值，表示是否将时间设置为午夜- name: 时间序列的名称同样，其他时间序列库也有自己的参数设置。

1. 常用函数库 u2003 scipy包中的stats模块和statsmodels包是python常用的数据分析工具，scipy.stats以前有一个models子模块，后来被移除了。这个模块被重写并成为了现在独立的statsmodels包。 u2003scipy的stats包含一些比较基本的工具，比如：t检验，正态性检验，卡方检验之类，statsmodels提供了更为系统的统计模型，包括线性模型，时序分析，还包含数据集，做图工具等等。 2. 小样本数据的正态性检验 (1) 用途 u2003夏皮罗维尔克检验法 (Shapiro-Wilk) 用于检验参数提供的一组小样本数据线是否符合正态分布，统计量越大则表示数据越符合正态分布，但是在非正态分布的小样本数据中也经常会出现较大的W值。需要查表来估计其概率。由于原假设是其符合正态分布，所以当P值小于指定显著水平时表示其不符合正态分布。 u2003正态性检验是数据分析的第一步，数据是否符合正态性决定了后续使用不同的分析和预测方法，当数据不符合正态性分布时，我们可以通过不同的转换方法把非正太态数据转换成正态分布后再使用相应的统计方法进行下一步操作。 (2) 示例 (3) 结果分析 u2003返回结果 p-value=0.029035290703177452，比指定的显著水平（一般为5%）小，则拒绝假设：x不服从正态分布。 3. 检验样本是否服务某一分布 (1) 用途 u2003科尔莫戈罗夫检验(Kolmogorov-Smirnov test)，检验样本数据是否服从某一分布，仅适用于连续分布的检验。下例中用它检验正态分布。 (2) 示例 (3) 结果分析 u2003生成300个服从N(0,1)标准正态分布的随机数，在使用k-s检验该数据是否服从正态分布，提出假设：x从正态分布。最终返回的结果，p-value=0.9260909172362317，比指定的显著水平（一般为5%）大，则我们不能拒绝假设：x服从正态分布。这并不是说x服从正态分布一定是正确的，而是说没有充分的证据证明x不服从正态分布。因此我们的假设被接受，认为x服从正态分布。如果p-value小于我们指定的显著性水平，则我们可以肯定地拒绝提出的假设，认为x肯定不服从正态分布，这个拒绝是绝对正确的。 4.方差齐性检验 (1) 用途 u2003方差反映了一组数据与其平均值的偏离程度，方差齐性检验用以检验两组或多组数据与其平均值偏离程度是否存在差异，也是很多检验和算法的先决条件。 (2) 示例 (3) 结果分析 u2003返回结果 p-value=0.19337536323599344, 比指定的显著水平（假设为5%）大，认为两组数据具有方差齐性。 5. 图形描述相关性 (1) 用途 u2003最常用的两变量相关性分析，是用作图描述相关性，图的横轴是一个变量，纵轴是另一变量，画散点图，从图中可以直观地看到相关性的方向和强弱，线性正相关一般形成由左下到右上的图形；负面相关则是从左上到右下的图形，还有一些非线性相关也能从图中观察到。 (2) 示例 (3) 结果分析 u2003从图中可以看到明显的正相关趋势。 6. 正态资料的相关分析 (1) 用途 u2003皮尔森相关系数（Pearson correlation coefficient）是反应两变量之间线性相关程度的统计量，用它来分析正态分布的两个连续型变量之间的相关性。常用于分析自变量之间，以及自变量和因变量之间的相关性。 (2) 示例 (3) 结果分析 u2003返回结果的第一个值为相关系数表示线性相关程度，其取值范围在[-1,1]，绝对值越接近1，说明两个变量的相关性越强，绝对值越接近0说明两个变量的相关性越差。当两个变量完全不相关时相关系数为0。第二个值为p-value，统计学上，一般当p-value<0.05时，可以认为两变量存在相关性。 7. 非正态资料的相关分析 (1) 用途 u2003斯皮尔曼等级相关系数(Spearman"s correlation coefficient for ranked data )，它主要用于评价顺序变量间的线性相关关系，在计算过程中，只考虑变量值的顺序（rank, 值或称等级），而不考虑变量值的大小。常用于计算类型变量的相关性。 (2) 示例 (3) 结果分析 u2003返回结果的第一个值为相关系数表示线性相关程度，本例中correlation趋近于1表示正相关。第二个值为p-value，p-value越小，表示相关程度越显著。 8. 单样本T检验 (1) 用途 u2003单样本T检验，用于检验数据是否来自一致均值的总体，T检验主要是以均值为核心的检验。注意以下几种T检验都是双侧T检验。 (2) 示例 (3) 结果分析 u2003本例中生成了2列100行的数组，ttest_1samp的第二个参数是分别对两列估计的均值，p-value返回结果，第一列1.47820719e-06比指定的显著水平（一般为5%）小，认为差异显著，拒绝假设；第二列2.83088106e-01大于指定显著水平，不能拒绝假设：服从正态分布。 9. 两独立样本T检验 (1) 用途 u2003由于比较两组数据是否来自于同一正态分布的总体。注意：如果要比较的两组数据不满足方差齐性， 需要在ttest_ind()函数中添加参数equal_var = False。 (2) 示例 (3) 结果分析 u2003返回结果的第一个值为统计量，第二个值为p-value，pvalue=0.19313343989106416，比指定的显著水平（一般为5%）大，不能拒绝假设，两组数据来自于同一总结，两组数据之间无差异。 10. 配对样本T检验 (1) 用途 u2003配对样本T检验可视为单样本T检验的扩展，检验的对象由一群来自正态分布独立样本更改为二群配对样本观测值之差。它常用于比较同一受试对象处理的前后差异，或者按照某一条件进行两两配对分别给与不同处理的受试对象之间是否存在差异。 (2) 示例 (3) 结果分析 u2003返回结果的第一个值为统计量，第二个值为p-value，pvalue=0.80964043445811551，比指定的显著水平（一般为5%）大，不能拒绝假设。 11. 单因素方差分析 (1) 用途 u2003方差分析(Analysis of Variance，简称ANOVA)，又称F检验，用于两个及两个以上样本均数差别的显著性检验。方差分析主要是考虑各组之间的平均数差别。 u2003单因素方差分析（One-wayAnova），是检验由单一因素影响的多组样本某因变量的均值是否有显著差异。 u2003当因变量Y是数值型，自变量X是分类值，通常的做法是按X的类别把实例成分几组，分析Y值在X的不同分组中是否存在差异。 (2) 示例 (3) 结果分析 u2003返回结果的第一个值为统计量，它由组间差异除以组间差异得到，上例中组间差异很大，第二个返回值p-value=6.2231520821576832e-19小于边界值（一般为0.05）,拒绝原假设, 即认为以上三组数据存在统计学差异，并不能判断是哪两组之间存在差异 。只有两组数据时，效果同 stats.levene 一样。 12. 多因素方差分析 (1) 用途 u2003当有两个或者两个以上自变量对因变量产生影响时，可以用多因素方差分析的方法来进行分析。它不仅要考虑每个因素的主效应，还要考虑因素之间的交互效应。 (2) 示例 (3) 结果分析 u2003上述程序定义了公式，公式中，"~"用于隔离因变量和自变量，”+“用于分隔各个自变量， ":"表示两个自变量交互影响。从返回结果的P值可以看出，X1和X2的值组间差异不大，而组合后的T:G的组间有明显差异。 13. 卡方检验 (1) 用途 u2003上面介绍的T检验是参数检验，卡方检验是一种非参数检验方法。相对来说，非参数检验对数据分布的要求比较宽松，并且也不要求太大数据量。卡方检验是一种对计数资料的假设检验方法，主要是比较理论频数和实际频数的吻合程度。常用于特征选择，比如，检验男人和女人在是否患有高血压上有无区别，如果有区别，则说明性别与是否患有高血压有关，在后续分析时就需要把性别这个分类变量放入模型训练。 u2003基本数据有R行C列, 故通称RC列联表(contingency table), 简称RC表，它是观测数据按两个或更多属性（定性变量）分类时所列出的频数表。 (2) 示例 (3) 结果分析 u2003卡方检验函数的参数是列联表中的频数，返回结果第一个值为统计量值，第二个结果为p-value值，p-value=0.54543425102570975，比指定的显著水平（一般5%）大，不能拒绝原假设，即相关性不显著。第三个结果是自由度，第四个结果的数组是列联表的期望值分布。 14. 单变量统计分析 (1) 用途 u2003单变量统计描述是数据分析中最简单的形式，其中被分析的数据只包含一个变量，不处理原因或关系。单变量分析的主要目的是通过对数据的统计描述了解当前数据的基本情况，并找出数据的分布模型。 u2003单变量数据统计描述从集中趋势上看，指标有：均值，中位数，分位数，众数；从离散程度上看，指标有：极差、四分位数、方差、标准差、协方差、变异系数，从分布上看，有偏度，峰度等。需要考虑的还有极大值，极小值（数值型变量）和频数，构成比（分类或等级变量）。 u2003此外，还可以用统计图直观展示数据分布特征，如：柱状图、正方图、箱式图、频率多边形和饼状图。 15. 多元线性回归 (1) 用途 u2003多元线性回归模型（multivariable linear regression model ），因变量Y（计量资料）往往受到多个变量X的影响，多元线性回归模型用于计算各个自变量对因变量的影响程度，可以认为是对多维空间中的点做线性拟合。 (2) 示例 (3) 结果分析 u2003直接通过返回结果中各变量的P值与0.05比较，来判定对应的解释变量的显著性，P<0.05则认为自变量具有统计学意义，从上例中可以看到收入INCOME最有显著性。 16. 逻辑回归 (1) 用途 u2003当因变量Y为2分类变量（或多分类变量时）可以用相应的logistic回归分析各个自变量对因变量的影响程度。 (2) 示例 (3) 结果分析 u2003直接通过返回结果中各变量的P值与0.05比较，来判定对应的解释变量的显著性，P<0.05则认为自变量具有统计学意义。

这个Quitter和Demo是不是都继承于Frame没关系。这个就是简单的建立一个Quitter的instance，让Quitter的__init__的parent参数等于现在正在初始化的这个Demo的instance而已。