Python学习基础方便查询

时间 2019-11-12

标签 python 学习基础方便查询栏目 Python 繁體版

原文原文链接

本节内容php

Python介绍
发展史
Python 2 or 3?
安装
Hello World程序
变量
用户输入
模块初识
.pyc是个什么鬼？
数据类型初识
数据运算
表达式if ...else语句
表达式for 循环
break and continue
表达式while 循环
做业需求
列表、元组操做
字符串操做
字典操做
集合操做
文件操做
字符编码与转码
函数基本语法及特性
参数与局部变量
返回值
嵌套函数
递归
匿名函数
函数式编程介绍
高阶函数
内置函数
迭代器&生成器
装饰器
Json & pickle 数据序列化
软件目录结构规范
做业:ATM项目开发
模块介绍
time &datetime模块
random
os
sys
shutil
json & picle
shelve
xml处理
yaml处理
configparser
hashlib
subprocess
logging模块
re正则表达式

1、 Python介绍

python的创始人为吉多·范罗苏姆（Guido van Rossum）。1989年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的脚本解释程序，做为ABC语言的一种继承。 html

最新的TIOBE排行榜，Python赶超PHP占据第五， Python崇尚优美、清晰、简单，是一个优秀并普遍使用的语言。java

由上图可见，Python总体呈上升趋势，反映出Python应用愈来愈普遍而且也逐渐获得业内的承认！！！node

Python能够应用于众多领域，如：数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等众多领域。目前业内几乎全部大中型互联网企业都在使用Python，如：Youtube、Dropbox、BT、Quora（中国知乎）、豆瓣、知乎、Google、Yahoo!、Facebook、NASA、百度、腾讯、汽车之家、美团等。python

目前Python主要应用领域：mysql

云计算: 云计算最火的语言，典型应用OpenStack
WEB开发: 众多优秀的WEB框架，众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣。。。，典型WEB框架有Django
科学运算、人工智能: 典型库NumPy, SciPy, Matplotlib, Enthought librarys,pandas
系统运维: 运维人员必备语言
金融：量化交易，金融分析，在金融工程领域，Python不但在用，且用的最多，并且重要性逐年提升。缘由：做为动态语言的Python，语言结构清晰简单，库丰富，成熟稳定，科学计算和统计分析都很牛逼，生产效率远远高于c,c++,java,尤为擅长策略回测
图形GUI: PyQT, WxPython,TkInter

Python在一些公司的应用： linux

谷歌：Google App Engine 、code.google.com 、Google earth 、谷歌爬虫、Google广告等项目都在大量使用Python开发
CIA: 美国中情局网站就是用Python开发的
NASA: 美国航天局(NASA)大量使用Python进行数据分析和运算
YouTube:世界上最大的视频网站YouTube就是用Python开发的
Dropbox:美国最大的在线云存储网站，所有用Python实现，天天网站处理10亿个文件的上传和下载
Instagram:美国最大的图片分享社交网站，天天超过3千万张照片被分享，所有用python开发
Facebook:大量的基础库均经过Python实现的
Redhat: 世界上最流行的Linux发行版本中的yum包管理工具就是用python开发的
豆瓣: 公司几乎全部的业务均是经过Python开发的
知乎: 国内最大的问答社区，经过Python开发(国外Quora)
春雨医生：国内知名的在线医疗网站是用Python开发的
除上面以外，还有搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝、土豆、新浪、果壳等公司都在使用Python完成各类各样的任务。

Python 是一门什么样的语言？

编程语言主要从如下几个角度为进行分类，编译型和解释型、静态语言和动态语言、强类型定义语言和弱类型定义语言，每一个分类表明什么意思呢，咱们一块儿来看一下。ios

编译和解释的区别是什么？

编译器是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机能够直接以机器语言来运行此程序,速度很快; nginx

而解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,因此运行速度是不如编译后的程序运行的快的. c++

这是由于计算机不能直接认识并执行咱们写的语句,它只能认识机器语言(是二进制的形式)

1、低级语言与高级语言

最初的计算机程序都是用0和1的序列表示的，程序员直接使用的是机器指令，无需翻译，从纸带打孔输入便可执行获得结果。后来为了方便记忆，就将用0、1序列表示的机器指令都用符号助记，这些与机器指令一一对应的助记符就成了汇编指令，从而诞生了汇编语言。不管是机器指令仍是汇编指令都是面向机器的，统称为低级语言。由于是针对特定机器的机器指令的助记符，因此汇编语言是没法独立于机器(特定的CPU体系结构)的。但汇编语言也是要通过翻译成机器指令才能执行的，因此也有将运行在一种机器上的汇编语言翻译成运行在另外一种机器上的机器指令的方法，那就是交叉汇编技术。

高级语言是从人类的逻辑思惟角度出发的计算机语言，抽象程度大大提升，须要通过编译成特定机器上的目标代码才能执行，一条高级语言的语句每每须要若干条机器指令来完成。高级语言独立于机器的特性是靠编译器为不一样机器生成不一样的目标代码(或机器指令)来实现的。那具体的说，要将高级语言编译到什么程度呢，这又跟编译的技术有关了，既能够编译成直接可执行的目标代码，也能够编译成一种中间表示，而后拿到不一样的机器和系统上去执行，这种状况一般又须要支撑环境，好比解释器或虚拟机的支持，Java程序编译成bytecode，再由不一样平台上的虚拟机执行就是很好的例子。因此，说高级语言不依赖于机器，是指在不一样的机器或平台上高级语言的程序自己不变，而经过编译器编译获得的目标代码去适应不一样的机器。从这个意义上来讲，经过交叉汇编，一些汇编程序也能够得到不一样机器之间的可移植性，但这种途径得到的移植性远远不如高级语言来的方便和实用性大。

2、编译与解释

编译是将源程序翻译成可执行的目标代码，翻译与执行是分开的；而解释是对源程序的翻译与执行一次性完成，不生成可存储的目标代码。这只是表象，两者背后的最大区别是：对解释执行而言，程序运行时的控制权在解释器而不在用户程序；对编译执行而言，运行时的控制权在用户程序。

解释具备良好的动态特性和可移植性，好比在解释执行时能够动态改变变量的类型、对程序进行修改以及在程序中插入良好的调试诊断信息等，而将解释器移植到不一样的系统上，则程序不用改动就能够在移植了解释器的系统上运行。同时解释器也有很大的缺点，好比执行效率低，占用空间大，由于不只要给用户程序分配空间，解释器自己也占用了宝贵的系统资源。

编译器是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机能够直接以机器语言来运行此程序,速度很快;
而解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,因此运行速度是不如编译后的程序运行的快的.

编译型和解释型
咱们先看看编译型，其实它和汇编语言是同样的：也是有一个负责翻译的程序来对咱们的源代码进行转换，生成相对应的可执行代码。这个过程说得专业一点，就称为编译（Compile），而负责编译的程序天然就称为编译器（Compiler）。若是咱们写的程序代码都包含在一个源文件中，那么一般编译以后就会直接生成一个可执行文件，咱们就能够直接运行了。但对于一个比较复杂的项目，为了方便管理，咱们一般把代码分散在各个源文件中，做为不一样的模块来组织。这时编译各个文件时就会生成目标文件（Object file）而不是前面说的可执行文件。通常一个源文件的编译都会对应一个目标文件。这些目标文件里的内容基本上已是可执行代码了，但因为只是整个项目的一部分，因此咱们还不能直接运行。待全部的源文件的编译都大功告成，咱们就能够最后把这些半成品的目标文件“打包”成一个可执行文件了，这个工做由另外一个程序负责完成，因为此过程好像是把包含可执行代码的目标文件链接装配起来，因此又称为连接（Link），而负责连接的程序就叫……就叫连接程序（Linker）。连接程序除了连接目标文件外，可能还有各类资源，像图标文件啊、声音文件啊什么的，还要负责去除目标文件之间的冗余重复代码，等等，因此……也是挺累的。连接完成以后，通常就能够获得咱们想要的可执行文件了。

上面咱们大概地介绍了编译型语言的特色，如今再看看解释型。噢，从字面上看，“编译”和“解释”的确都有“翻译”的意思，它们的区别则在于翻译的时机安排不大同样。打个比方：假如你打算阅读一本外文书，而你不知道这门外语，那么你能够找一名翻译，给他足够的时间让他从头至尾把整本书翻译好，而后把书的母语版交给你阅读；或者，你也马上让这名翻译辅助你阅读，让他一句一句给你翻译，若是你想往回看某个章节，他也得从新给你翻译。

两种方式，前者就至关于咱们刚才所说的编译型：一次把全部的代码转换成机器语言，而后写成可执行文件；然后者就至关于咱们要说的解释型：在程序运行的前一刻，还只有源程序而没有可执行程序；而程序每执行到源程序的某一条指令，则会有一个称之为解释程序的外壳程序将源代码转换成二进制代码以供执行，总言之，就是不断地解释、执行、解释、执行……因此，解释型程序是离不开解释程序的。像早期的BASIC就是一门经典的解释型语言，要执行BASIC程序，就得进入BASIC环境，而后才能加载程序源文件、运行。解释型程序中，因为程序老是以源代码的形式出现，所以只要有相应的解释器，移植几乎不成问题。编译型程序虽然源代码也能够移植，但前提是必须针对不一样的系统分别进行编译，对于复杂的工程来讲，的确是一件不小的时间消耗，何况极可能一些细节的地方仍是要修改源代码。并且，解释型程序省却了编译的步骤，修改调试也很是方便，编辑完毕以后便可当即运行，没必要像编译型程序同样每次进行小小改动都要耐心等待漫长的Compiling…Linking…这样的编译连接过程。不过凡事有利有弊，因为解释型程序是将编译的过程放到执行过程当中，这就决定了解释型程序注定要比编译型慢上一大截，像几百倍的速度差距也是不足为奇的。

编译型与解释型，二者各有利弊。前者因为程序执行速度快，同等条件下对系统要求较低，所以像开发操做系统、大型应用程序、数据库系统等时都采用它，像C/C++、Pascal/Object Pascal（Delphi）、VB等基本均可视为编译语言，而一些网页脚本、服务器脚本及辅助开发接口这样的对速度要求不高、对不一样系统平台间的兼容性有必定要求的程序则一般使用解释性语言，如Java、JavaScript、VBScript、Perl、Python等等。

但既然编译型与解释型各有优缺点又相互对立，因此一批新兴的语言都有把二者折衷起来的趋势，例如Java语言虽然比较接近解释型语言的特征，但在执行以前已经预先进行一次预编译，生成的代码是介于机器码和Java源代码之间的中介代码，运行的时候则由JVM（Java的虚拟机平台，可视为解释器）解释执行。它既保留了源代码的高抽象、可移植的特色，又已经完成了对源代码的大部分预编译工做，因此执行起来比“纯解释型”程序要快许多。而像VB6（或者之前版本）、C#这样的语言，虽然表面上看生成的是.exe可执行程序文件，但VB6编译以后实际生成的也是一种中介码，只不过编译器在前面安插了一段自动调用某个外部解释器的代码（该解释程序独立于用户编写的程序，存放于系统的某个DLL文件中，全部以VB6编译生成的可执行程序都要用到它），以解释执行实际的程序体。C#（以及其它.net的语言编译器）则是生成.net目标代码，实际执行时则由.net解释系统（就像JVM同样，也是一个虚拟机平台）进行执行。固然.net目标代码已经至关“低级”，比较接近机器语言了，因此仍将其视为编译语言，并且其可移植程度也没有Java号称的这么强大，Java号称是“一次编译，处处执行”，而.net则是“一次编码，处处编译”。呵呵，固然这些都是题外话了。总之，随着设计技术与硬件的不断发展，编译型与解释型两种方式的界限正在不断变得模糊。

动态语言和静态语言
一般咱们所说的动态语言、静态语言是指动态类型语言和静态类型语言。

（1）动态类型语言：动态类型语言是指在运行期间才去作数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言，其余的各类脚本语言如VBScript也多少属于动态类型语言。

（2）静态类型语言：静态类型语言与动态类型语言恰好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明全部变量的数据类型，C/C++是静态类型语言的典型表明，其余的静态类型语言还有C#、JAVA等。

强类型定义语言和弱类型定义语言

（1）强类型定义语言：强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，若是不通过强制转换，那么它就永远是这个数据类型了。举个例子：若是你定义了一个整型变量a,那么程序根本不可能将a看成字符串类型处理。强类型定义语言是类型安全的语言。

（2）弱类型定义语言：数据类型能够被忽略的语言。它与强类型定义语言相反, 一个变量能够赋不一样数据类型的值。

强类型定义语言在速度上可能略逊色于弱类型定义语言，可是强类型定义语言带来的严谨性可以有效的避免许多错误。另外，“这门语言是否是动态语言”与“这门语言是否类型安全”之间是彻底没有联系的！
例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。

经过上面这些介绍，咱们能够得出，python是一门动态解释性的强类型定义语言。那这些基因使成就了Python的哪些优缺点呢？咱们继续往下看。

Python的优缺点

先看优势

Python的定位是“优雅”、“明确”、“简单”，因此Python程序看上去老是简单易懂，初学者学Python，不但入门容易，并且未来深刻下去，能够编写那些很是很是复杂的程序。
开发效率很是高，Python有很是强大的第三方库，基本上你想经过计算机实现任何功能，Python官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上再进行开发，大大下降开发周期，避免重复造轮子。
高级语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节
可移植性————因为它的开源本质，Python已经被移植在许多平台上（通过改动使它可以工做在不一样平台上）。若是你当心地避免使用依赖于系统的特性，那么你的全部Python程序无需修改就几乎能够在市场上全部的系统平台上运行
可扩展性————若是你须要你的一段关键代码运行得更快或者但愿某些算法不公开，你能够把你的部分程序用C或C++编写，而后在你的Python程序中使用它们。
可嵌入性————你能够把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。

再看缺点：

速度慢，Python 的运行速度相比C语言确实慢不少，跟JAVA相比也要慢一些，所以这也是不少所谓的大牛不屑于使用Python的主要缘由，但其实这里所指的运行速度慢在大多数状况下用户是没法直接感知到的，必须借助测试工具才能体现出来，好比你用C运一个程序花了0.1s,用Python是0.01s,这样C语言直接比Python快了10s,算是很是夸张了，可是你是没法直接经过肉眼感知的，由于一个正常人所能感知的时间最小单位是0.15-0.4s左右，哈哈。其实在大多数状况下Python已经彻底能够知足你对程序速度的要求，除非你要写对速度要求极高的搜索引擎等，这种状况下，固然仍是建议你用C去实现的。
代码不能加密，由于PYTHON是解释性语言，它的源码都是以名文形式存放的，不过我不认为这算是一个缺点，若是你的项目要求源代码必须是加密的，那你一开始就不该该用Python来去实现。
线程不能利用多CPU问题，这是Python被人诟病最多的一个缺点，GIL即全局解释器锁（Global Interpreter Lock），是计算机程序设计语言解释器用于同步线程的工具，使得任什么时候刻仅有一个线程在执行，Python的线程是操做系统的原生线程。在Linux上为pthread，在Windows上为Win thread，彻底由操做系统调度线程的执行。一个python解释器进程内有一条主线程，以及多条用户程序的执行线程。即便在多核CPU平台上，因为GIL的存在，因此禁止多线程的并行执行。关于这个问题的折衷解决方法，咱们在之后线程和进程章节里再进行详细探讨。

固然，Python还有一些其它的小缺点，在这就不一一列举了，我想说的是，任何一门语言都不是完美的，都有擅长和不擅长作的事情，建议各位不要拿一个语言的劣势去跟另外一个语言的优点来去比较，语言只是一个工具，是实现程序设计师思想的工具，就像咱们以前中学学几什么时候，有的时候须要要圆规，有的时候须要用三角尺同样，拿相应的工具去作它最擅长的事才是正确的选择。以前不少人问我Shell和Python到底哪一个好？我回答说Shell是个脚本语言，但Python不仅是个脚本语言，能作的事情更多，而后又有钻牛角尖的人说彻底不必学Python, Python能作的事情Shell均可以作，只要你足够牛B,而后又举了用Shell能够写俄罗斯方块这样的游戏，对此我能说表达只能是，不要跟SB理论，SB会把你拉到跟他同样的高度，而后用充分的经验把你打倒。

Python解释器

当咱们编写Python代码时，咱们获得的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就须要Python解释器去执行.py文件。

因为整个Python语言从规范到解释器都是开源的，因此理论上，只要水平够高，任何人均可以编写Python解释器来执行Python代码（固然难度很大）。事实上，确实存在多种Python解释器。

CPython

当咱们从Python官方网站下载并安装好Python 2.7后，咱们就直接得到了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，因此叫CPython。在命令行下运行python就是启动CPython解释器。

CPython是使用最广的Python解释器。教程的全部代码也都在CPython下执行。

IPython

IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所加强，可是执行Python代码的功能和CPython是彻底同样的。比如不少国产浏览器虽然外观不一样，但内核其实都是调用了IE。

CPython用>>>做为提示符，而IPython用In [序号]:做为提示符。

PyPy

PyPy是另外一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），因此能够显著提升Python代码的执行速度。

绝大部分Python代码均可以在PyPy下运行，可是PyPy和CPython有一些是不一样的，这就致使相同的Python代码在两种解释器下执行可能会有不一样的结果。若是你的代码要放到PyPy下执行，就须要了解PyPy和CPython的不一样点。

Jython

Jython是运行在Java平台上的Python解释器，能够直接把Python代码编译成Java字节码执行。

IronPython

IronPython和Jython相似，只不过IronPython是运行在微软.Net平台上的Python解释器，能够直接把Python代码编译成.Net的字节码。

小结

Python的解释器不少，但使用最普遍的仍是CPython。若是要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是经过网络调用来交互，确保各程序之间的独立性。

2、Python发展史

1989年，为了打发圣诞节假期，Guido开始写Python语言的编译器。Python这个名字，来自Guido所挚爱的电视剧Monty Python’s Flying Circus。他但愿这个新的叫作Python的语言，能符合他的理想：创造一种C和shell之间，功能全面，易学易用，可拓展的语言。
1991年，第一个Python编译器诞生。它是用C语言实现的，并可以调用C语言的库文件。从一出生，Python已经具备了：类，函数，异常处理，包含表和词典在内的核心数据类型，以及模块为基础的拓展系统。
Granddaddy of Python web frameworks, Zope 1 was released in 1999
Python 1.0 - January 1994 增长了 lambda, map, filter and reduce.
Python 2.0 - October 16, 2000，加入了内存回收机制，构成了如今Python语言框架的基础
Python 2.4 - November 30, 2004, 同年目前最流行的WEB框架Django 诞生
Python 2.5 - September 19, 2006
Python 2.6 - October 1, 2008
Python 2.7 - July 3, 2010
In November 2014, it was announced that Python 2.7 would be supported until 2020, and reaffirmed that there would be no 2.8 release as users were expected to move to Python 3.4+ as soon as possible
Python 3.0 - December 3, 2008
Python 3.1 - June 27, 2009
Python 3.2 - February 20, 2011
Python 3.3 - September 29, 2012
Python 3.4 - March 16, 2014
Python 3.5 - September 13, 2015

3、Python 2 or 3?

In summary : Python 2.x is legacy, Python 3.x is the present and future of the language

Python 3.0 was released in 2008. The final 2.x version 2.7 release came out in mid-2010, with a statement of

extended support for this end-of-life release. The 2.x branch will see no new major releases after that. 3.x is

under active development and has already seen over five years of stable releases, including version 3.3 in 2012,

3.4 in 2014, and 3.5 in 2015. This means that all recent standard library improvements, for example, are only

available by default in Python 3.x.

Guido van Rossum (the original creator of the Python language) decided to clean up Python 2.x properly, with less regard for backwards compatibility than is the case for new releases in the 2.x range. The most drastic improvement is the better Unicode support (with all text strings being Unicode by default) as well as saner bytes/Unicode separation.

Besides, several aspects of the core language (such as print and exec being statements, integers using floor division) have been adjusted to be easier for newcomers to learn and to be more consistent with the rest of the language, and old cruft has been removed (for example, all classes are now new-style, "range()" returns a memory efficient iterable, not a list as in 2.x).

py2与3的详细区别

PRINT IS A FUNCTION

The statement has been replaced with a print() function, with keyword arguments to replace most of the special syntax of the old statement (PEP 3105). Examples:

Old: print "The answer is", 2*2 New: print("The answer is", 2*2)
Old: print x, # Trailing comma suppresses newline New: print(x, end=" ") # Appends a space instead of a newline
Old: print # Prints a newline
New: print() # You must call the function!
Old: print >>sys.stderr, "fatal error" New: print("fatal error", file=sys.stderr)
Old: print (x, y) # prints repr((x, y))
New: print((x, y)) # Not the same as print(x, y)!

You can also customize the separator between items, e.g.:

print("There are <", 2**32, "> possibilities!", sep="")

ALL IS UNICODE NOW

今后再也不为讨厌的字符编码而烦恼

还能够这样玩： (A,*REST,B)=RANGE(5)

>>> a,*rest,b = range(5)
>>> a,rest,b
(0, [1, 2, 3], 4)

某些库更名了

Old Name	New Name
_winreg	winreg
ConfigParser	configparser
copy_reg	copyreg
Queue	queue
SocketServer	socketserver
markupbase	_markupbase
repr	reprlib
test.test_support	test.support

还有谁不支持PYTHON3?

One popular module that don't yet support Python 3 is Twisted (for networking and other applications). Most

actively maintained libraries have people working on 3.x support. For some libraries, it's more of a priority than

others: Twisted, for example, is mostly focused on production servers, where supporting older versions of

Python is important, let alone supporting a new version that includes major changes to the language. (Twisted is

a prime example of a major package where porting to 3.x is far from trivial

4、Python安装

windows

一、下载安装包
    https://www.python.org/downloads/
二、安装
    默认安装路径：C:\python27
三、配置环境变量
    【右键计算机】--》【属性】--》【高级系统设置】--》【高级】--》【环境变量】--》【在第二个内容框中找到 变量名为Path 的一行，双击】 --> 【Python安装目录追加到变值值中，用 ； 分割】
    如：原来的值;C:\python27，切记前面有分号

linux、Mac

无需安装，原装Python环境
 
ps：若是自带2.6，请更新至2.7

5、Hello World程序

在linux 下建立一个文件叫hello.py,并输入

print("Hello World!")

而后执行命令:python hello.py ,输出

localhost:~ jieli$ vim hello.py 
localhost:~ jieli$ python hello.py 
Hello World!

指定解释器

上一步中执行 python hello.py 时，明确的指出 hello.py 脚本由 python 解释器来执行。

若是想要相似于执行shell脚本同样执行python脚本，例： ./hello.py ，那么就须要在 hello.py 文件的头部指定解释器，以下：

#!/usr/bin/env python
 
print "hello,world"

如此一来，执行： ./hello.py 便可。

ps：执行前需给予 hello.py 执行权限，chmod 755 hello.py

在交互器中执行　

除了把程序写在文件里，还能够直接调用python自带的交互器运行代码，　

localhost:~ jieli$ python 
Python 2.7.10 (default, Oct 23 2015, 18:05:06) 
[GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello World!")
Hello World!

对比下其它语言的hello world

1 #include <iostream>
2 int main(void)
3 {
4 std::cout<<"Hello world";
5 }

C++

1 #include <stdio.h>
2 int main(void)
3 {
4 printf("\nhello world!");
5 return 0;
6 }

1 public class HelloWorld{
2   // 程序的入口
3   public static void main(String args[]){
4     // 向控制台输出信息
5     System.out.println("Hello World!");
6   }
7 }

JAVA

1 <?php  
2             echo "hello world!";  
3 ?>

PHP

1 puts "Hello world."

RUBY

1 package main
2 
3 import "fmt"
4 
5 func main(){
6 
7     fmt.Printf("Hello World!\n God Bless You!");
8 
9 }

6、变量\字符编码　　

Variables are used to store information to be referenced and manipulated in a computer program. They also provide a way of labeling data with a descriptive name, so our programs can be understood more clearly by the reader and ourselves. It is helpful to think of variables as containers that hold information. Their sole purpose is to label and store data in memory. This data can then be used throughout your program.

声明变量

#_*_coding:utf-8_*_

name = "Alex Li"

上述代码声明了一个变量，变量名为： name，变量name的值为："Alex Li"　

变量定义的规则：

变量名只能是字母、数字或下划线的任意组合
变量名的第一个字符不能是数字
如下关键字不能声明为变量名
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

变量的赋值

name = "Alex Li"

name2 = name 
print(name,name2)

name = "Jack"

print("What is the value of name2 now?")

7、字符编码

python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ascill）

ASCII（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其余西欧语言，其最多只能用 8 位来表示（一个字节），即：2**8 = 256-1，因此，ASCII码最多只能表示 255 个符号。

关于中文

为了处理汉字，程序员设计了用于简体中文的GB2312和用于繁体中文的big5。

GB2312(1980年)一共收录了7445个字符，包括6763个汉字和682个其它符号。汉字区的内码范围高字节从B0-F7，低字节从A1-FE，占用的码位是72*94=6768。其中有5个空位是D7FA-D7FE。

GB2312 支持的汉字太少。1995年的汉字扩展规范GBK1.0收录了21886个符号，它分为汉字区和图形符号区。汉字区包括21003个字符。2000年的 GB18030是取代GBK1.0的正式国家标准。该标准收录了27484个汉字，同时还收录了藏文、蒙文、维吾尔文等主要的少数民族文字。如今的PC平台必须支持GB18030，对嵌入式产品暂不做要求。因此手机、MP3通常只支持GB2312。

从ASCII、GB23十二、GBK 到GB18030，这些编码方法是向下兼容的，即同一个字符在这些方案中老是有相同的编码，后面的标准支持更多的字符。在这些编码中，英文和中文能够统一地处理。区分中文编码的方法是高字节的最高位不为0。按照程序员的称呼，GB23十二、GBK到GB18030都属于双字节字符集 (DBCS)。

有的中文Windows的缺省内码仍是GBK，能够经过GB18030升级包升级到GB18030。不过GB18030相对GBK增长的字符，普通人是很难用到的，一般咱们仍是用GBK指代中文Windows内码。

显然ASCII码没法将世界上的各类文字和符号所有表示，因此，就须要新出一种能够表明全部字符和符号的编码，即：Unicode

Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每一个字符设定了统一而且惟一的二进制编码，规定虽有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 = 65536，
注：此处说的的是最少2个字节，可能更多

UTF-8，是对Unicode编码的压缩和优化，他再也不使用最少使用2个字节，而是将全部的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存...

因此，python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ascill），若是是以下代码的话：

报错：ascii码没法表示中文

#!/usr/bin/env python
 
print "你好，世界"

改正：应该显示的告诉python解释器，用什么编码来执行源代码，即：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
print "你好，世界"

注释

　　当行注视：# 被注释内容

　　多行注释：""" 被注释内容 """

8、用户输入　

#!/usr/bin/env python 
#_*_coding:utf-8_*_


#name = raw_input("What is your name?") #only on python 2.x
name = input("What is your name?")
print("Hello " + name )

输入密码时，若是想要不可见，须要利用getpass 模块中的 getpass方法，即：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import getpass
 
# 将用户输入的内容赋值给 name 变量
pwd = getpass.getpass("请输入密码：")
 
# 打印输入的内容
print(pwd)

9、模块初识　　

Python的强大之处在于他有很是丰富和强大的标准库和第三方库，几乎你想实现的任何功能都有相应的Python库支持，之后的课程中会深刻讲解经常使用到的各类库，如今，咱们先来象征性的学2个简单的。

sys

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

print(sys.argv)


#输出
$ python test.py helo world 
['test.py', 'helo', 'world']  #把执行脚本时传递的参数获取到了

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os

os.system("df -h") #调用系统命令

彻底结合一下　　

import os,sys

os.system(''.join(sys.argv[1:])) #把用户的输入的参数看成一条命令交给os.system来执行

本身写个模块

python tab补全模块

1 import sys
2 import readline
3 import rlcompleter
4 
5 if sys.platform == 'darwin' and sys.version_info[0] == 2:
6     readline.parse_and_bind("bind ^I rl_complete")
7 else:
8     readline.parse_and_bind("tab: complete")  # linux and python3 on mac

for mac

 1 #!/usr/bin/env python 
 2 # python startup file 
 3 import sys
 4 import readline
 5 import rlcompleter
 6 import atexit
 7 import os
 8 # tab completion 
 9 readline.parse_and_bind('tab: complete')
10 # history file 
11 histfile = os.path.join(os.environ['HOME'], '.pythonhistory')
12 try:
13     readline.read_history_file(histfile)
14 except IOError:
15     pass
16 atexit.register(readline.write_history_file, histfile)
17 del os, histfile, readline, rlcompleter

for Linux

写完保存后就能够使用了

localhost:~ jieli$ python 
Python 2.7.10 (default, Oct 23 2015, 18:05:06) 
[GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import tab

你会发现，上面本身写的tab.py模块只能在当前目录下导入，若是想在系统的何何一个地方都使用怎么办呢？此时你就要把这个tab.py放到python全局环境变量目录里啦，基本通常都放在一个叫 Python/2.7/site-packages 目录下，这个目录在不一样的OS里放的位置不同，用 print(sys.path) 能够查看python环境变量列表。

10、.pyc是个什么鬼？

1. Python是一门解释型语言？

我初学Python时，听到的关于Python的第一句话就是，Python是一门解释性语言，我就这样一直相信下去，直到发现了*.pyc文件的存在。若是是解释型语言，那么生成的*.pyc文件是什么呢？c应该是compiled的缩写才对啊！

为了防止其余学习Python的人也被这句话误解，那么咱们就在文中来澄清下这个问题，而且把一些基础概念给理清。

2. 解释型语言和编译型语言

计算机是不可以识别高级语言的，因此当咱们运行一个高级语言程序的时候，就须要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分红两类，第一种是编译，第二种是解释。

编译型语言在程序执行以前，先会经过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不须要翻译，而直接执行就能够了。最典型的例子就是C语言。

解释型语言就没有这个编译的过程，而是在程序运行的时候，经过解释器对程序逐行做出解释，而后直接运行，最典型的例子是Ruby。

经过以上的例子，咱们能够来总结一下解释型语言和编译型语言的优缺点，由于编译型语言在程序运行以前就已经对程序作出了“翻译”，因此在运行时就少掉了“翻译”的过程，因此效率比较高。可是咱们也不能一律而论，一些解释型语言也能够经过解释器的优化来在对程序作出翻译时对整个程序作出优化，从而在效率上超过编译型语言。

此外，随着Java等基于虚拟机的语言的兴起，咱们又不能把语言纯粹地分红解释型和编译型这两种。

用Java来举例，Java首先是经过编译器编译成字节码文件，而后在运行时经过解释器给解释成机器文件。因此咱们说Java是一种先编译后解释的语言。

3. Python究竟是什么

其实Python和Java/C#同样，也是一门基于虚拟机的语言，咱们先来从表面上简单地了解一下Python程序的运行过程吧。

当咱们在命令行中输入python hello.py时，实际上是激活了Python的“解释器”，告诉“解释器”：你要开始工做了。但是在“解释”以前，其实执行的第一项工做和Java同样，是编译。

熟悉Java的同窗能够想一下咱们在命令行中如何执行一个Java的程序：

javac hello.java

java hello

只是咱们在用Eclipse之类的IDE时，将这两部给融合成了一部而已。其实Python也同样，当咱们执行python hello.py时，他也同样执行了这么一个过程，因此咱们应该这样来描述Python，Python是一门先编译后解释的语言。

4. 简述Python的运行过程

在说这个问题以前，咱们先来讲两个概念，PyCodeObject和pyc文件。

咱们在硬盘上看到的pyc天然没必要多说，而其实PyCodeObject则是Python编译器真正编译成的结果。咱们先简单知道就能够了，继续向下看。

当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。

当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，若是找到，则直接载入，不然就重复上面的过程。

因此咱们应该这样来定位PyCodeObject和pyc文件，咱们说pyc文件实际上是PyCodeObject的一种持久化保存方式。

11、数据类型初识

一、数字

2 是一个整数的例子。
长整数不过是大一些的整数。
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。
(-5+4j)和(2.3-4.6j)是复数的例子，其中-5,4为实数，j为虚数，数学中表示复数是什么？。

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

long（长整型）
　　跟C语言不一样，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上因为机器内存有限，咱们使用的长整数数值不可能无限大。
　　注意，自从Python2.2起，若是整数发生溢出，Python会自动将整数数据转换为长整数，因此现在在长整数数据后面不加字母L也不会致使严重后果了。
float（浮点型）

先扫盲 http://www.cnblogs.com/alex3714/articles/5895848.html
　　浮点数用来处理实数，即带有小数的数字。相似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）
　　复数由实数部分和虚数部分组成，通常形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

注：Python中存在小数字池：-5 ～ 257

二、布尔值

　　真或假

　　1 或 0

三、字符串

"hello world"

万恶的字符串拼接：

　　python中的字符串在C语言中体现为是一个字符数组，每次建立字符串时候须要在内存中开辟一块连续的空，而且一旦须要修改字符串的话，就须要再次开辟空间，万恶的+号每出现一次就会在内从中从新开辟一块空间。

字符串格式化输出

name = "alex"
print "i am %s " % name
 
#输出: i am alex

PS: 字符串是 %s;整数 %d;浮点数%f

字符串经常使用功能：

移除空白
分割
长度
索引
切片

四、列表

建立列表：

name_list = ['alex', 'seven', 'eric']
或
name_list ＝ list(['alex', 'seven', 'eric'])

基本操做：

索引
切片
追加
删除
长度
切片
循环
包含

五、元组(不可变列表)

建立元组：

ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))

六、字典（无序）

建立字典：

person = {"name": "mr.wu", 'age': 18}
或
person = dict({"name": "mr.wu", 'age': 18})

经常使用操做：

索引
新增
删除
键、值、键值对
循环
长度

12、数据运算　　

算数运算：

比较运算：

赋值运算：

逻辑运算：

成员运算：

身份运算：

位运算：

#!/usr/bin/python
 
a = 60            # 60 = 0011 1100
b = 13            # 13 = 0000 1101
c = 0
 
c = a & b;        # 12 = 0000 1100
print "Line 1 - Value of c is ", c
 
c = a | b;        # 61 = 0011 1101
print "Line 2 - Value of c is ", c
 
c = a ^ b;        # 49 = 0011 0001
print "Line 3 - Value of c is ", c
 
c = ~a;           # -61 = 1100 0011
print "Line 4 - Value of c is ", c
 
c = a << 2;       # 240 = 1111 0000
print "Line 5 - Value of c is ", c
 
c = a >> 2;       # 15 = 0000 1111
print "Line 6 - Value of c is ", c

*按位取反运算规则(按位取反再加1) 详解http://blog.csdn.net/wenxinwukui234/article/details/42119265

运算符优先级：

十3、表达式if ... else

场景1、用户登录验证

# 提示输入用户名和密码
 
# 验证用户名和密码
#     若是错误，则输出用户名或密码错误
#     若是成功，则输出 欢迎，XXX!


#!/usr/bin/env python
# -*- coding: encoding -*-
 
import getpass
 
 
name = raw_input('请输入用户名：')
pwd = getpass.getpass('请输入密码：')
 
if name == "alex" and pwd == "cmd":
    print("欢迎，alex！")
else:
    print("用户名和密码错误")

场景2、猜年龄游戏

在程序里设定好你的年龄，而后启动程序让用户猜想，用户输入后，根据他的输入提示用户输入的是否正确，若是错误，提示是猜大了仍是小了

#!/usr/bin/env python
# -*- coding: utf-8 -*-


my_age = 28

user_input = int(input("input your guess num:"))

if user_input == my_age:
    print("Congratulations, you got it !")
elif user_input < my_age:
    print("Oops,think bigger!")
else:
    print("think smaller!")

外层变量，能够被内层代码使用

内层变量，不该被外层代码使用

十4、表达式for loop

最简单的循环10次

#_*_coding:utf-8_*_
__author__ = 'Alex Li'


for i in range(10):
    print("loop:", i )

输出：

loop: 0
loop: 1
loop: 2
loop: 3
loop: 4
loop: 5
loop: 6
loop: 7
loop: 8
loop: 9

需求一：仍是上面的程序，可是遇到小于5的循环次数就不走了，直接跳入下一次循环

for i in range(10):
    if i<5:
        continue #不往下走了,直接进入下一次loop 
    print("loop:", i )

需求二：仍是上面的程序，可是遇到大于5的循环次数就不走了，直接退出

for i in range(10):
    if i>5:
        break #不往下走了,直接跳出整个loop
    print("loop:", i )

十5、while loop 　　

有一种循环叫死循环，一经触发，就运行个天荒地老、海枯石烂。

海枯石烂代码

count = 0
while True:
    print("你是风儿我是沙,缠缠绵绵到天涯...",count)
    count +=1

其实除了时间，没有什么是永恒的，死loop仍是少写为好　

上面的代码循环100次就退出吧

count = 0
while True:
    print("你是风儿我是沙,缠缠绵绵到天涯...",count)
    count +=1
    if count == 100:
        print("去你妈的风和沙,大家这些脱了裤子是人,穿上裤子是鬼的臭男人..")
        break

回到上面for 循环的例子，如何实现让用户不断的猜年龄，但只给最多3次机会，再猜不对就退出程序。

#!/usr/bin/env python
# -*- coding: utf-8 -*-


my_age = 28

count = 0
while count < 3:
    user_input = int(input("input your guess num:"))

    if user_input == my_age:
        print("Congratulations, you got it !")
        break
    elif user_input < my_age:
        print("Oops,think bigger!")
    else:
        print("think smaller!")
    count += 1 #每次loop 计数器+1
else:
    print("猜这么屡次都不对,你个笨蛋.")

十6、做业

做业一：博客

做业二：编写登录接口

输入用户名密码
认证成功后显示欢迎信息
输错三次后锁定

做业三：多级菜单

三级菜单
可依次选择进入各子菜单
所需新知识点：列表、字典

入门知识拾遗

1、bytes类型

2、三元运算

若是条件为真：result = 值1
若是条件为假：result = 值2

3、进制

二进制，01
八进制，01234567
十进制，0123456789
十六进制，0123456789ABCDEF 二进制到16进制转换http://jingyan.baidu.com/album/47a29f24292608c0142399cb.html?picindex=1

4、一切皆对象

对于Python，一切事物都是对象，对象基于类建立

因此，如下这些值都是对象： "wupeiqi"、3八、['北京', '上海', '深圳']，而且是根据不一样的类生成的对象。

1. 列表、元组操做

列表是咱们最之后最经常使用的数据类型之一，经过列表能够对数据实现最方便的存储、修改等操做

定义列表

names = ['Alex',"Tenglan",'Eric']

经过下标访问列表中的元素，下标从0开始计数

>>> names[0]
'Alex'
>>> names[2]
'Eric'
>>> names[-1]
'Eric'
>>> names[-2] #还能够倒着取
'Tenglan'

切片:取多个元素　　

>>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
>>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
['Tenglan', 'Eric', 'Rain']
>>> names[1:-1] #取下标1至-1的值，不包括-1
['Tenglan', 'Eric', 'Rain', 'Tom']
>>> names[0:3] 
['Alex', 'Tenglan', 'Eric']
>>> names[:3] #若是是从头开始取，0能够忽略，跟上句效果同样
['Alex', 'Tenglan', 'Eric']
>>> names[3:] #若是想取最后一个，必须不能写-1，只能这么写
['Rain', 'Tom', 'Amy'] 
>>> names[3:-1] #这样-1就不会被包含了
['Rain', 'Tom']
>>> names[0::2] #后面的2是表明，每隔一个元素，就取一个
['Alex', 'Eric', 'Tom'] 
>>> names[::2] #和上句效果同样
['Alex', 'Eric', 'Tom']

View Code

追加

>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
>>> names.append("我是新来的")
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

View Code

插入

>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.insert(2,"强行从Eric前面插入")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

>>> names.insert(5,"从eric后面插入试试新姿式")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿式', 'Tom', 'Amy', '我是新来的']

View Code

修改

>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿式', 'Tom', 'Amy', '我是新来的']
>>> names[2] = "该换人了"
>>> names
['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿式', 'Tom', 'Amy', '我是新来的']

View Code

删除

>>> del names[2] 
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿式', 'Tom', 'Amy', '我是新来的']
>>> del names[4]
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> 
>>> names.remove("Eric") #删除指定元素
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.pop() #删除列表最后一个值 
'我是新来的'
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']

View Code

扩展

>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
>>> b = [1,2,3]
>>> names.extend(b)
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

View Code

拷贝

>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

>>> name_copy = names.copy()
>>> name_copy
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

View Code

copy真的这么简单么？那我还讲个屁。。。

统计

>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.count("Amy")
2

View Code

排序&翻转

>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.sort() #排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()   #3.0里不一样数据类型不能放在一块儿排序了，擦
>>> names[-3] = '1'
>>> names[-2] = '2'
>>> names[-1] = '3'
>>> names
['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3']
>>> names.sort()
>>> names
['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

>>> names.reverse() #反转
>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']

View Code

获取下标

>>> names ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1'] >>> names.index("Amy") 2 #只返回找到的第一个下标

View Code

元组

元组其实跟列表差很少，也是存一组数，只不是它一旦建立，便不能再修改，因此又叫只读列表

语法

 names = ("alex","jack","eric")

它只有2个方法，一个是count,一个是index，完毕。　　

程序练习

请闭眼写出如下程序。

程序：购物车程序

需求:

启动程序后，让用户输入工资，而后打印商品列表
容许用户根据商品编号购买商品
用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
可随时退出，退出时，打印已购买商品和余额

2. 字符串操做　　　　

>>> n3_arg
{'name': 'alex', 'age': 33}
>>> n3
'my name is {name} and age is {age}'
>>> n3.format_map(n3_arg)
'my name is alex and age is 33'


>>> n4.ljust(40,"-")
'Hello 2orld-----------------------------'
>>> n4.rjust(40,"-")
'-----------------------------Hello 2orld'


>>> s = "Hello World!"
>>> p = str.maketrans("abcdefg","3!@#$%^")
>>> s.translate(p)
'H$llo Worl#!


>>> b="ddefdsdff_哈哈" 
>>> b.isidentifier() #检测一段字符串能否被看成标志符，便是否符合变量命名规则
True

一些蛋疼的语法

3. 字典操做

字典一种key - value 的数据类型，使用就像咱们上学用的字典，经过笔划、字母来查对应页的详细内容。

语法:

info = {
    'stu1101': "TengLan Wu",
    'stu1102': "LongZe Luola",
    'stu1103': "XiaoZe Maliya",
}

字典的特性：

dict是无序的
key必须是惟一的,so 天生去重

增长

>>> info["stu1104"] = "苍井空"
>>> info
{'stu1102': 'LongZe Luola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'}

View Code

修改

>>> info['stu1101'] = "武藤兰"
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}

View Code

删除

>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
>>> info.pop("stu1101") #标准删除姿式
'武藤兰'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> del info['stu1103'] #换个姿式删除
>>> info
{'stu1102': 'LongZe Luola'}
>>> 
>>> 
>>> 
>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除
>>> info.popitem()
('stu1102', 'LongZe Luola')
>>> info
{'stu1103': 'XiaoZe Maliya'}

View Code

查找

>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> 
>>> "stu1102" in info #标准用法
True
>>> info.get("stu1102")  #获取
'LongZe Luola'
>>> info["stu1102"] #同上，可是看下面
'LongZe Luola'
>>> info["stu1105"]  #若是一个key不存在，就报错，get不会，不存在只返回None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'stu1105'

View Code

多级字典嵌套及操做

av_catalog = {
    "欧美":{
        "www.youporn.com": ["不少免费的,世界最大的","质量通常"],
        "www.pornhub.com": ["不少免费的,也很大","质量比yourporn高点"],
        "letmedothistoyou.com": ["可能是自拍,高质量图片不少","资源很少,更新慢"],
        "x-art.com":["质量很高,真的很高","所有收费,屌比请绕过"]
    },
    "日韩":{
        "tokyo-hot":["质量怎样不清楚,我的已经不喜欢日韩范了","据说是收费的"]
    },
    "大陆":{
        "1024":["所有免费,真好,好人一辈子平安","服务器在国外,慢"]
    }
}

av_catalog["大陆"]["1024"][1] += ",能够用爬虫爬下来"
print(av_catalog["大陆"]["1024"])
#ouput 
['所有免费,真好,好人一辈子平安', '服务器在国外,慢,能够用爬虫爬下来']

View Code

其它姿式

#values
>>> info.values()
dict_values(['LongZe Luola', 'XiaoZe Maliya'])

#keys
>>> info.keys()
dict_keys(['stu1102', 'stu1103'])


#setdefault
>>> info.setdefault("stu1106","Alex")
'Alex'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> info.setdefault("stu1102","龙泽萝拉")
'LongZe Luola'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}


#update 
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
>>> info.update(b)
>>> info
{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

#items
info.items()
dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])


#经过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
>>> dict.fromkeys([1,2,3],'testd')
{1: 'testd', 2: 'testd', 3: 'testd'}

View Code

循环dict

#方法1
for key in info:
    print(key,info[key])

#方法2
for k,v in info.items(): #会先把dict转成list,数据里大时莫用
    print(k,v)

程序练习

程序: 三级菜单

要求:

打印省、市、县三级菜单
可返回上一级
可随时退出程序

menu = {
    '北京':{
        '海淀':{
            '五道口':{
                'soho':{},
                '网易':{},
                'google':{}
            },
            '中关村':{
                '爱奇艺':{},
                '汽车之家':{},
                'youku':{},
            },
            '上地':{
                '百度':{},
            },
        },
        '昌平':{
            '沙河':{
                '老男孩':{},
                '北航':{},
            },
            '天通苑':{},
            '回龙观':{},
        },
        '朝阳':{},
        '东城':{},
    },
    '上海':{
        '闵行':{
            "人民广场":{
                '炸鸡店':{}
            }
        },
        '闸北':{
            '火车战':{
                '携程':{}
            }
        },
        '浦东':{},
    },
    '山东':{},
}


exit_flag = False
current_layer = menu

layers = [menu]

while not  exit_flag:
    for k in current_layer:
        print(k)
    choice = input(">>:").strip()
    if choice == "b":
        current_layer = layers[-1]
        #print("change to laster", current_layer)
        layers.pop()
    elif choice not  in current_layer:continue
    else:
        layers.append(current_layer)
        current_layer = current_layer[choice]

三年菜单文艺青年版

4.集合操做

集合是一个无序的，不重复的数据组合，它的主要做用以下：

去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据以前的交集、差集、并集等关系

经常使用操做

s = set([3,5,9,10])      #建立一个数值集合  
  
t = set("Hello")         #建立一个惟一字符的集合  


a = t | s          # t 和 s的并集  
  
b = t & s          # t 和 s的交集  
  
c = t – s          # 求差集（项在t中，但不在s中）  
  
d = t ^ s          # 对称差集（项在t或s中，但不会同时出如今两者中）  
  
   
  
基本操做：  
  
t.add('x')            # 添加一项  
  
s.update([10,37,42])  # 在s中添加多项  
  
   
  
使用remove()能够删除一项：  
  
t.remove('H')  
  
  
len(s)  
set 的长度  
  
x in s  
测试 x 是不是 s 的成员  
  
x not in s  
测试 x 是否不是 s 的成员  
  
s.issubset(t)  
s <= t  
测试是否 s 中的每个元素都在 t 中  
  
s.issuperset(t)  
s >= t  
测试是否 t 中的每个元素都在 s 中  
  
s.union(t)  
s | t  
返回一个新的 set 包含 s 和 t 中的每个元素  
  
s.intersection(t)  
s & t  
返回一个新的 set 包含 s 和 t 中的公共元素  
  
s.difference(t)  
s - t  
返回一个新的 set 包含 s 中有可是 t 中没有的元素  
  
s.symmetric_difference(t)  
s ^ t  
返回一个新的 set 包含 s 和 t 中不重复的元素  
  
s.copy()  
返回 set “s”的一个浅复制

View Code

5. 文件操做

对文件操做流程

打开文件，获得文件句柄并赋值给一个变量
经过句柄对文件进行操做
关闭文件

现有文件以下

Somehow, it seems the love I knew was always the most destructive kind
不知为什么，我经历的爱情老是最具毁灭性的的那种
Yesterday when I was young
昨日当我年少轻狂
The taste of life was sweet
生命的滋味是甜的
As rain upon my tongue
就如舌尖上的雨露
I teased at life as if it were a foolish game
我戏弄生命 视其为愚蠢的游戏
The way the evening breeze
就如夜晚的微风
May tease the candle flame
逗弄蜡烛的火苗
The thousand dreams I dreamed
我曾千万次梦见
The splendid things I planned
那些我计划的绚丽蓝图
I always built to last on weak and shifting sand
但我老是将之建筑在易逝的流沙上
I lived by night and shunned the naked light of day
我夜夜笙歌 逃避白昼赤裸的阳光
And only now I see how the time ran away
事到现在我才看清岁月是如何匆匆流逝
Yesterday when I was young
昨日当我年少轻狂
So many lovely songs were waiting to be sung
有那么多甜美的曲儿等我歌唱
So many wild pleasures lay in store for me
有那么多肆意的快乐等我享受
And so much pain my eyes refused to see
还有那么多痛苦 个人双眼却视而不见
I ran so fast that time and youth at last ran out
我飞快地奔走 最终时光与青春消逝殆尽
I never stopped to think what life was all about
我从未停下脚步去思考生命的意义
And every conversation that I can now recall
现在回想起的全部对话
Concerned itself with me and nothing else at all
除了和我相关的 什么都记不得了
The game of love I played with arrogance and pride
我用自负和傲慢玩着爱情的游戏
And every flame I lit too quickly, quickly died
全部我点燃的火焰都熄灭得太快
The friends I made all somehow seemed to slip away
全部我交的朋友彷佛都不知不觉地离开了
And only now I'm left alone to end the play, yeah
只剩我一我的在台上来结束这场闹剧
Oh, yesterday when I was young
噢 昨日当我年少轻狂
So many, many songs were waiting to be sung
有那么那么多甜美的曲儿等我歌唱
So many wild pleasures lay in store for me
有那么多肆意的快乐等我享受
And so much pain my eyes refused to see
还有那么多痛苦 个人双眼却视而不见
There are so many songs in me that won't be sung
我有太多歌曲永远不会被唱起
I feel the bitter taste of tears upon my tongue
我尝到了舌尖泪水的苦涩滋味
The time has come for me to pay for yesterday
终于到了付出代价的时间 为了昨日
When I was young
当我年少轻狂

基本操做　　

f = open('lyrics') #打开文件
first_line = f.readline()
print('first line:',first_line) #读一行
print('我是分隔线'.center(50,'-'))
data = f.read()# 读取剩下的全部内容,文件大时不要用
print(data) #打印文件

f.close() #关闭文件

打开文件的模式有：

r，只读模式（默认）。
w，只写模式。【不可读；不存在则建立；存在则删除内容；】
a，追加模式。【可读；不存在则建立；存在则只追加内容；】

"+" 表示能够同时读写某个文件

r+，可读写文件。【可读；可写；可追加】
w+，写读
a+，同a

"U"表示在读取时，能够将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

其它语法

    def close(self): # real signature unknown; restored from __doc__
        """
        Close the file.
        
        A closed file cannot be used for further I/O operations.  close() may be
        called more than once without error.
        """
        pass

    def fileno(self, *args, **kwargs): # real signature unknown
        """ Return the underlying file descriptor (an integer). """
        pass

    def isatty(self, *args, **kwargs): # real signature unknown
        """ True if the file is connected to a TTY device. """
        pass

    def read(self, size=-1): # known case of _io.FileIO.read
        """
        注意，不必定能全读回来
        Read at most size bytes, returned as bytes.
        
        Only makes one system call, so less data may be returned than requested.
        In non-blocking mode, returns None if no data is available.
        Return an empty bytes object at EOF.
        """
        return ""

    def readable(self, *args, **kwargs): # real signature unknown
        """ True if file was opened in a read mode. """
        pass

    def readall(self, *args, **kwargs): # real signature unknown
        """
        Read all data from the file, returned as bytes.
        
        In non-blocking mode, returns as much as is immediately available,
        or None if no data is available.  Return an empty bytes object at EOF.
        """
        pass

    def readinto(self): # real signature unknown; restored from __doc__
        """ Same as RawIOBase.readinto(). """
        pass #不要用,没人知道它是干吗用的

    def seek(self, *args, **kwargs): # real signature unknown
        """
        Move to new file position and return the file position.
        
        Argument offset is a byte count.  Optional argument whence defaults to
        SEEK_SET or 0 (offset from start of file, offset should be >= 0); other values
        are SEEK_CUR or 1 (move relative to current position, positive or negative),
        and SEEK_END or 2 (move relative to end of file, usually negative, although
        many platforms allow seeking beyond the end of a file).
        
        Note that not all file objects are seekable.
        """
        pass

    def seekable(self, *args, **kwargs): # real signature unknown
        """ True if file supports random-access. """
        pass

    def tell(self, *args, **kwargs): # real signature unknown
        """
        Current file position.
        
        Can raise OSError for non seekable files.
        """
        pass

    def truncate(self, *args, **kwargs): # real signature unknown
        """
        Truncate the file to at most size bytes and return the truncated size.
        
        Size defaults to the current file position, as returned by tell().
        The current file position is changed to the value of size.
        """
        pass

    def writable(self, *args, **kwargs): # real signature unknown
        """ True if file was opened in a write mode. """
        pass

    def write(self, *args, **kwargs): # real signature unknown
        """
        Write bytes b to file, return number written.
        
        Only makes one system call, so not all of the data may be written.
        The number of bytes actually written is returned.  In non-blocking mode,
        returns None if the write would block.
        """
        pass

with语句

为了不打开文件后忘记关闭，能够经过管理上下文，即：

如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：

1 2	`with` `open` `(` `'log1'` `) as obj1,` `open` `(` `'log2'` `) as obj2:` `pass`

程序练习　　

程序1: 实现简单的shell sed替换功能

程序2:修改haproxy配置文件

需求：

1、查
    输入：www.oldboy.org
    获取当前backend下的全部记录

2、新建
    输入：
        arg = {
            'bakend': 'www.oldboy.org',
            'record':{
                'server': '100.1.7.9',
                'weight': 20,
                'maxconn': 30
            }
        }

3、删除
    输入：
        arg = {
            'bakend': 'www.oldboy.org',
            'record':{
                'server': '100.1.7.9',
                'weight': 20,
                'maxconn': 30
            }
        }

需求

global       
        log 127.0.0.1 local2
        daemon
        maxconn 256
        log 127.0.0.1 local2 info
defaults
        log global
        mode http
        timeout connect 5000ms
        timeout client 50000ms
        timeout server 50000ms
        option  dontlognull

listen stats :8888
        stats enable
        stats uri       /admin
        stats auth      admin:1234

frontend oldboy.org
        bind 0.0.0.0:80
        option httplog
        option httpclose
        option  forwardfor
        log global
        acl www hdr_reg(host) -i www.oldboy.org
        use_backend www.oldboy.org if www

backend www.oldboy.org
        server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000

原配置文件

6. 字符编码与转码

详细文章:

http://www.cnblogs.com/yuanchenqi/articles/5956943.html

http://www.diveintopython3.net/strings.html

需知:

1.在python2默认编码是ASCII, python3里默认是utf-8

2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-8就是unicode

3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string

#-*-coding:utf-8-*-
__author__ = 'Alex Li'

import sys
print(sys.getdefaultencoding())


msg = "我爱北京天安门"
msg_gb2312 = msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk")

print(msg)
print(msg_gb2312)
print(gb2312_to_gbk)

in python2

#-*-coding:gb2312 -*-   #这个也能够去掉
__author__ = 'Alex Li'

import sys
print(sys.getdefaultencoding())


msg = "我爱北京天安门"
#msg_gb2312 = msg.decode("utf-8").encode("gb2312")
msg_gb2312 = msg.encode("gb2312") #默认就是unicode,不用再decode,喜大普奔
gb2312_to_unicode = msg_gb2312.decode("gb2312")
gb2312_to_utf8 = msg_gb2312.decode("gb2312").encode("utf-8")

print(msg)
print(msg_gb2312)
print(gb2312_to_unicode)
print(gb2312_to_utf8)

in python3

7. 内置函数

温故知新

1. 集合

主要做用:

去重
关系测试，交集＼差集＼并集＼反向(对称)差集

>>> a = {1,2,3,4}
>>> b ={3,4,5,6}
>>> a
{1, 2, 3, 4}
>>> type(a)
<class 'set'>
>>> a.symmetric_difference(b)
{1, 2, 5, 6}
>>> b.symmetric_difference(a)
{1, 2, 5, 6}
>>> 
>>> 
>>> a.difference(b)
{1, 2}
>>> a.union(b)
{1, 2, 3, 4, 5, 6}
>>> a.issu
a.issubset(   a.issuperset(
>>> a.issubset(b)
False

2. 元组　　

只读列表，只有count, index 2 个方法

做用：若是一些数据不想被人修改，能够存成元组，好比身份证列表

3. 字典

key-value对

特性：
无顺序
去重
查询速度快，比列表快多了
比list占用内存多

为何会查询速度会快呢？由于他是hash类型的，那什么是hash呢？

哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据惟一且极其紧凑的数值表示形式。若是散列一段明文并且哪怕只更改该段落的一个字母，随后的哈希都将产生不一样的值。要找到散列为同一个值的两个不一样的输入，在计算上是不可能的，因此数据的哈希值能够检验数据的完整性。通常用于快速查找和加密算法

dict会把全部的key变成hash 表，而后将这个表进行排序，这样，你经过data[key]去查data字典中一个key的时候，python会先把这个key hash成一个数字，而后拿这个数字到hash表中看没有这个数字，若是有，拿到这个key在hash表中的索引，拿到这个索引去与此key对应的value的内存地址那取值就能够了。

上面依然没回答这样作查找一个数据为何会比列表快，对不对？呵呵，等我课上揭晓。

4. 字符编码

先说python2

py2里默认编码是ascii
文件开头那个编码声明是告诉解释这个代码的程序以什么编码格式把这段代码读入到内存，由于到了内存里，这段代码实际上是以bytes二进制格式存的，不过即便是2进制流，也能够按不一样的编码格式转成2进制流，你懂么？
若是在文件头声明了#_*_coding:utf-8*_，就能够写中文了，不声明的话，python在处理这段代码时按ascii，显然会出错，加了这个声明后，里面的代码就全是utf-8格式了
在有#_*_coding:utf-8*_的状况下，你在声明变量若是写成name=u"大保健"，那这个字符就是unicode格式，不加这个u,那你声明的字符串就是utf-8格式
utf-8 to gbk怎么转，utf8先decode成unicode,再encode成gbk

再说python3

py3里默认文件编码就是utf-8,因此能够直接写中文，也不须要文件头声明编码了，干的漂亮
你声明的变量默认是unicode编码，不是utf-8, 由于默认便是unicode了（不像在py2里，你想直接声明成unicode还得在变量前加个u）, 此时你想转成gbk的话，直接your_str.encode("gbk")便可以
但py3里，你在your_str.encode("gbk")时，感受好像还加了一个动做，就是就是encode的数据变成了bytes里，我操，这是怎么个状况，由于在py3里，str and bytes作了明确的区分，你能够理解为bytes就是2进制流，你会说，我看到的不是010101这样的2进制呀，那是由于python为了让你能对数据进行操做而在内存级别又帮你作了一层封装，不然让你直接看到一堆2进制，你能看出哪一个字符对应哪段2进制么？什么？本身换算，得了吧，你连超过2位数的数字加减运算都费劲，还仍是省省心吧。　　
那你说，在py2里好像也有bytes呀，是的，不过py2里的bytes只是对str作了个别名，没有像py3同样给你显示的多出来一层封装，但其实其内部仍是封装了的。这么讲吧，不管是2仍是三，从硬盘到内存，数据格式都是 010101二进制到-->b'\xe4\xbd\xa0\xe5\xa5\xbd' bytes类型－－>按照指定编码转成你能看懂的文字

编码应用比较多的场景应该是爬虫了，互联网上不少网站用的编码格式很杂，虽然总体趋向都变成utf-8，但如今仍是很杂，因此爬网页时就须要你进行各类编码的转换，不过生活正在变美好，期待一个不须要转码的世界。

最后，编码is a piece of fucking shit, noboby likes it.

1.函数基本语法及特性

背景提要

如今老板让你写一个监控程序，监控服务器的系统情况，当cpu＼memory＼disk等指标的使用量超过阀值时即发邮件报警，你掏空了全部的知识量，写出了如下代码

while True：
    if cpu利用率 > 90%:
        #发送邮件提醒
        链接邮箱服务器
        发送邮件
        关闭链接
    
    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        链接邮箱服务器
        发送邮件
        关闭链接
    
    if 内存占用 > 80%:
        #发送邮件提醒
        链接邮箱服务器
        发送邮件
        关闭链接

上面的代码实现了功能，但即便是邻居老王也看出了端倪，老王亲切的摸了下你家儿子的脸蛋，说，你这个重复代码太多了，每次报警都要重写一段发邮件的代码，太low了，这样干存在2个问题：

代码重复过多，一个劲的copy and paste不符合高端程序员的气质
若是往后须要修改发邮件的这段代码，好比加入群发功能，那你就须要在全部用到这段代码的地方都修改一遍

你以为老王说的对，你也不想写重复代码，但又不知道怎么搞，老王好像看出了你的心思，此时他抱起你儿子，笑着说，其实很简单，只须要把重复的代码提取出来，放在一个公共的地方，起个名字，之后谁想用这段代码，就经过这个名字调用就好了，以下

def 发送邮件(内容)
    #发送邮件提醒
    链接邮箱服务器
    发送邮件
    关闭链接
    
while True：
    
    if cpu利用率 > 90%:
        发送邮件('CPU报警')
    
    if 硬盘使用空间 > 90%:
        发送邮件('硬盘报警')
    
    if 内存占用 > 80%:
        发送邮件('内存报警')

你看着老王写的代码，气势恢宏、磅礴大气，代码里透露着一股内敛的傲气，心想，老王这我的真是不通常，忽然对他的背景更感兴趣了，问老王，这些花式玩法你都是怎么知道的？老王亲了一口你儿子，捋了捋不存在的胡子，淡淡的讲，“老夫，年少时，师从京西沙河淫魔银角大王 ”，你一听“银角大王”这几个字，不禁的娇躯一震，心想，真nb,怪不得代码写的这么6, 这“银角大王”当年在江湖上但是数得着的响当当的名字，只惋惜后期纵欲过分，卒于公元2016年，真是惋惜了，只留下其哥哥孤守当年兄弟俩一块儿打下来的江山。此时你看着的老王离开的身影，感受你儿子跟他愈来愈像了。。。

函数是什么?

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不一样的，具体区别，咱们后面会讲，编程中的函数在英文中也有不少不一样的叫法。在BASIC中叫作subroutine(子过程或子程序)，在Pascal中叫作procedure(过程)和function，在C中只有function，在Java里面叫作method。

定义: 函数是指将一组语句的集合经过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名便可

特性:

减小重复代码
使程序变的可扩展
使程序变得易维护

语法定义

def sayhi():#函数名
    print("Hello, I'm nobody!")

sayhi() #调用函数

能够带参数

#下面这段代码
a,b = 5,8
c = a**b
print(c)


#改为用函数写
def calc(x,y):
    res = x**y
    return res #返回函数执行结果

c = calc(a,b) ＃结果赋值给c变量
print(c)

2.函数参数与局部变量　　

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。所以，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参能够是常量、变量、表达式、函数等，不管实参是何种类型的量，在进行函数调用时，它们都必须有肯定的值，以便把这些值传送给形参。所以应预先用赋值，输入等办法使参数得到肯定值

默认参数

看下面代码

def stu_register(name,age,country,course):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)

stu_register("王山炮",22,"CN","python_devops")
stu_register("张叫春",21,"CN","linux")
stu_register("刘老根",25,"CN","linux")

发现 country 这个参数基本都是"CN", 就像咱们在网站上注册用户，像国籍这种信息，你不填写，默认就会是中国，这就是经过默认参数实现的，把country变成默认参数很是简单

def stu_register(name,age,course,country="CN"):

这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。

另外，你可能注意到了，在把country变成默认参数后，我同时把它的位置移到了最后面，为何呢？　　

关键参数

正常状况下，给函数传参数要按顺序，不想按顺序就能够用关键参数，只需指定参数名便可，但记住一个要求就是，关键参数必须放在位置参数以后。

stu_register(age=22,name='alex',course="python",)

非固定参数

若你的函数在定义时不肯定用户想传入多少个参数，就能够使用非固定参数

def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)

stu_register("Alex",22)
#输出
#Alex 22 () #后面这个()就是args,只是由于没传值,因此为空

stu_register("Jack",32,"CN","Python")
#输出
# Jack 32 ('CN', 'Python')

还能够有一个**kwargs

def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
    print(name,age,args,kwargs)

stu_register("Alex",22)
#输出
#Alex 22 () {}#后面这个{}就是kwargs,只是由于没传值,因此为空

stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

局部变量　　

name = "Alex Li"

def change_name(name):
    print("before change:",name)
    name = "金角大王,一个有Tesla的男人"
    print("after change", name)


change_name(name)

print("在外面看看name改了么?",name)

输出

before change: Alex Li
after change 金角大王,一个有Tesla的男人
在外面看看name改了么? Alex Li

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量做用域是整个程序，局部变量做用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起做用；在其它地方全局变量起做用。

3.返回值　　

要想获取函数的执行结果，就能够用return语句把结果返回

注意:

函数在执行过程当中只要遇到return语句，就会中止执行并返回结果，so 也能够理解为 return 语句表明着函数的结束
若是未在函数中指定return,那这个函数的返回值为None

强行插入知识点: 嵌套函数　　

看上面的标题的意思是，函数还能套函数？of course

name = "Alex"

def change_name():
    name = "Alex2"

    def change_name2():
        name = "Alex3"
        print("第3层打印",name)

    change_name2() #调用内层函数
    print("第2层打印",name)


change_name()
print("最外层打印",name)

此时，在最外层调用change_name2()会出现什么效果？

没错，出错了，为何呢？

嵌套函数的用法会了，但它有什么用呢？下节课揭晓。。。

4. 递归

在函数内部，能够调用其余函数。若是一个函数在内部调用自身自己，这个函数就是递归函数。

def calc(n):
    print(n)
    if int(n/2) ==0:
        return n
    return calc(int(n/2))

calc(10)

输出：
10
5
2
1

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减小

3. 递归效率不高，递归层次过多会致使栈溢出（在计算机中，函数调用是经过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。因为栈的大小不是无限的，因此，递归调用的次数过多，会致使栈溢出）

堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

递归函数实际应用案例，二分查找

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]


def binary_search(dataset,find_num):
    print(dataset)

    if len(dataset) >1:
        mid = int(len(dataset)/2)
        if dataset[mid] == find_num:  #find it
            print("找到数字",dataset[mid])
        elif dataset[mid] > find_num :# 找的数在mid左面
            print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:# 找的数在mid右面
            print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
            return binary_search(dataset[mid+1:],find_num)
    else:
        if dataset[0] == find_num:  #find it
            print("找到数字啦",dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)


binary_search(data,66)

5. 匿名函数

匿名函数就是不须要显式的指定函数

#这段代码
def calc(n):
    return n**n
print(calc(10))

#换成匿名函数
calc = lambda n:n**n
print(calc(10))

你也许会说，用上这个东西没感受有毛方便呀，。。。。呵呵，若是是这么用，确实没毛线改进，不过匿名函数主要是和其它函数搭配使用的呢，以下

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

输出

1
25
49
16
64

6.函数式编程介绍　　

函数是Python内建支持的一种封装，咱们经过把大段代码拆成函数，经过一层一层的函数调用，就能够把复杂任务分解成简单的任务，这种分解能够称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程中的函数这个术语不是指计算机中的函数（其实是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其余状态。好比sqrt(x)函数计算x的平方根，只要x不变，不论何时调用，调用几回，值都是不变的。

Python对函数式编程提供部分支持。因为Python容许使用变量，所以，Python不是纯函数式编程语言。

1、定义

简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。

主要思想是把运算过程尽可能写成一系列嵌套的函数调用。举例来讲，如今有这样一个数学表达式：

　　(1 + 2) * 3 - 4

传统的过程式编程，可能这样写：

　　var a = 1 + 2;

　　var b = a * 3;

　　var c = b - 4;

函数式编程要求使用函数，咱们能够把运算过程定义为不一样的函数，而后写成下面这样：

　　var result = subtract(multiply(add(1,2), 3), 4);

这段代码再演进如下，能够变成这样

add(1,2).multiply(3).subtract(4)

这基本就是天然语言的表达了。再看下面的代码，你们应该一眼就能明白它的意思吧：

merge([1,2],[3,4]).sort().search("2")

所以，函数式编程的代码更容易理解。

要想学好函数式编程，不要玩py,玩Erlang,Haskell, 好了，我只会这么多了。。。

7.高阶函数

变量能够指向函数，函数的参数能接收变量，那么一个函数就能够接收另外一个函数做为参数，这种函数就称之为高阶函数。

def add(x,y,f):
    return f(x) + f(y)


res = add(3,-6,abs)
print(res)

8. 内置参数　　

内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii

#compile
# f = open("函数递归.py")
# data =compile(f.read(),'','exec')
# exec(data)


#print
msg = "又回到最初的起点"
f = open("tofile","w")
print(msg,"记忆中你青涩的脸",sep="|",end="",file=f)


#slice
a = range(20)
pattern = slice(3,8,2)
for i in a[pattern]: #等于a[3:8:2]
    print(i)

几个内置方法用法提醒

本节做业

有如下员工信息表

固然此表你在文件存储时能够这样表示

1,Alex Li,22,13651054608,IT,2013-04-01

现须要对这个员工信息文件，实现增删改查操做

可进行模糊查询，语法至少支持下面3种:
1. 　　select name,age from staff_table where age > 22
2. 　　select * from staff_table where dept = "IT"
3. select * from staff_table where enroll_date like "2013"
4. 查到的信息，打印后，最后面还要显示查到的条数
可建立新员工纪录，以phone作惟一键，staff_id需自增
可删除指定员工信息纪录，输入员工id，便可删除
可修改员工信息，语法以下:
1. 　　UPDATE staff_table SET dept="Market" WHERE where dept = "IT"

注意：以上需求，要充分使用函数，请尽你的最大限度来减小重复代码！

1.列表生成式，迭代器&生成器

列表生成式

孩子，我如今有个需求，看列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],我要求你把列表里的每一个值加1，你怎么实现？你可能会想到2种方式

>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b = []
>>> for i in a:b.append(i+1)
... 
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = b
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

普通青年版

>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = map(lambda x:x+1, a)
>>> a
<map object at 0x101d2c630>
>>> for i in a:print(i)
... 
2
3
4
5
6
7
8
9
10
11

文艺青年版

其实还有一种写法，以下

>>> a = [i+1 for i in range(10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

装逼青年版

这就叫作列表生成

生成器

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

建立L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

咱们能够直接打印出list的每个元素，但咱们怎么打印出generator的每个元素呢？

若是要一个一个打印出来，能够经过next()函数得到generator的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

咱们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

固然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，由于generator也是可迭代对象：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

因此，咱们建立了一个generator后，基本上永远不会调用next()，而是经过for循环来迭代它，而且不须要关心StopIteration的错误。

generator很是强大。若是推算的算法比较复杂，用相似列表生成式的for循环没法实现的时候，还能够用函数来实现。

好比，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数均可由前两个数相加获得：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，可是，用函数把它打印出来却很容易：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

注意，赋值语句：

a, b = b, a + b

至关于：

t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

但没必要显式写出临时变量t就能够赋值。

上面的函数能够输出斐波那契数列的前N个数：

>>> fib(10)
1
1
2
3
5
8
13
21
34
55
done

仔细观察，能够看出，fib函数其实是定义了斐波拉契数列的推算规则，能够从第一个元素开始，推算出后续任意的元素，这种逻辑其实很是相似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只须要把print(b)改成yield b就能够了：

def fib(max):
    n,a,b = 0,0,1

    while n < max:
        #print(b)
        yield  b
        a,b = b,a+b

        n += 1

    return 'done'

这就是定义generator的另外一种方法。若是一个函数定义中包含yield关键字，那么这个函数就再也不是一个普通函数，而是一个generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

这里，最难理解的就是generator和函数的执行流程不同。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

data = fib(10)
print(data)

print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())

#输出
<generator object fib at 0x101be02b0>
1
1
干点别的事
2
3
5
8
13

在上面fib的例子，咱们在循环过程当中不断调用yield，就会不断中断。固然要给循环设置一个条件来退出循环，否则就会产生一个无限数列出来。

一样的，把函数改为generator后，咱们基本上历来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

可是用for循环调用generator时，发现拿不到generator的return语句的返回值。若是想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

关于如何捕获错误，后面的错误处理还会详细讲解。

还可经过yield实如今单线程的状况下实现并发运算的效果　　

#_*_coding:utf-8_*_
__author__ = 'Alex Li'

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备作包子啦!")
    for i in range(10):
        time.sleep(1)
        print("作了2个包子!")
        c.send(i)
        c2.send(i)

producer("alex")

经过生成器实现协程并行运算

迭代器

咱们已经知道，能够直接做用于for循环的数据类型有如下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些能够直接做用于for循环的对象统称为可迭代对象：Iterable。

能够使用isinstance()判断一个对象是不是Iterable对象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但能够做用于for循环，还能够被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示没法继续返回下一个值了。

*能够被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

能够使用isinstance()判断一个对象是不是Iterator对象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator能够使用iter()函数：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能会问，为何list、dict、str等数据类型不是Iterator？

这是由于Python的Iterator对象表示的是一个数据流，Iterator对象能够被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。能够把这个数据流看作是一个有序序列，但咱们却不能提早知道序列的长度，只能不断经过next()函数实现按需计算下一个数据，因此Iterator的计算是惰性的，只有在须要返回下一个数据时它才会计算。

Iterator甚至能够表示一个无限大的数据流，例如全体天然数。而使用list是永远不可能存储全体天然数的。

小结

凡是可做用于for循环的对象都是Iterable类型；

凡是可做用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过能够经过iter()函数得到一个Iterator对象。

Python的for循环本质上就是经过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

实际上彻底等价于：

# 首先得到Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 得到下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

2.装饰器

你是一家视频网站的后端开发工程师，大家网站有如下几个版块

def home():
    print("---首页----")

def america():
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

def henan():
    print("----河南专区----")

视频刚上线初期，为了吸引用户，大家采起了免费政策，全部视频免费观看，迅速吸引了一大批用户，免费一段时间后，天天巨大的带宽费用公司承受不了了，因此准备对比较受欢迎的几个版块收费，其中包括“欧美” 和 “河南”专区，你拿到这个需求后，想了想，想收费得先让其进行用户认证，认证经过后，再断定这个用户是不是VIP付费会员就能够了，是VIP就让看，不是VIP就不让看就好了呗。你以为这个需求非常简单，由于要对多个版块进行认证，那应该把认证功能提取出来单独写个模块，而后每一个版块里调用就能够了，与是你轻轻的就实现了下面的功能。

#_*_coding:utf-8_*_


user_status = False #用户登陆了就把这个改为True

def login():
    _username = "alex" #伪装这是DB里存的用户信息
    _password = "abc!23" #伪装这是DB里存的用户信息
    global user_status

    if user_status == False:
        username = input("user:")
        password = input("pasword:")

        if username == _username and password == _password:
            print("welcome login....")
            user_status = True
        else:
            print("wrong username or password!")
    else:
        print("用户已登陆，验证经过...")

def home():
    print("---首页----")

def america():
    login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

def henan():
    login() #执行前加上验证
    print("----河南专区----")



home()
america()
henan()

此时你信心满满的把这个代码提交给你的TEAM LEADER审核，没成想，没过5分钟，代码就被打回来了， TEAM LEADER给你反馈是，我如今有不少模块须要加认证模块，你的代码虽然实现了功能，可是须要更改须要加认证的各个模块的代码，这直接违反了软件开发中的一个原则“开放-封闭”原则，简单来讲，它规定已经实现的功能代码不容许被修改，但能够被扩展，即：

封闭：已实现的功能代码块
开放：对扩展开发

这个原则你仍是第一次据说，我擦，再次感觉了本身这个野生程序员与正规军的差距，BUT ANYWAY,老大要求的这个怎么实现呢？如何在不改原有功能代码的状况下加上认证功能呢？你一时想不出思路，只好带着这个问题回家继续憋，媳妇不在家，去隔壁老王家串门了，你正好落的清静，一不当心就想到了解决方案，不改源代码能够呀，

你师从沙河金角大王时，记得他教过你，高阶函数，就是把一个函数当作一个参数传给另一个函数，当时大王说，有一天，你会用到它的，没想到这时这个知识点忽然从脑子里蹦出来了，我只须要写个认证方法，每次调用须要验证的功能时，直接把这个功能的函数名当作一个参数传给个人验证模块不就好了么，哈哈，机智如我，如是你啪啪啪改写了以前的代码

#_*_coding:utf-8_*_


user_status = False #用户登陆了就把这个改为True

def login(func): #把要执行的模块从这里传进来
    _username = "alex" #伪装这是DB里存的用户信息
    _password = "abc!23" #伪装这是DB里存的用户信息
    global user_status

    if user_status == False:
        username = input("user:")
        password = input("pasword:")

        if username == _username and password == _password:
            print("welcome login....")
            user_status = True
        else:
            print("wrong username or password!")

    if user_status == True: 
        func() # 看这里看这里，只要验证经过了，就调用相应功能

def home():
    print("---首页----")

def america():
    #login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

def henan():
    #login() #执行前加上验证
    print("----河南专区----")



home()
login(america) #须要验证就调用 login，把须要验证的功能 当作一个参数传给login
# home()
# america()
login(henan)

你很开心，终于实现了老板的要求，不改变原功能代码的前提下，给功能加上了验证，此时，媳妇回来了，后面还跟着老王，你两家关系很是好，老王常常来串门，老王也是码农，你跟他分享了你写的代码，兴奋的等他看完夸奖你NB,没成想，老王看后，并无夸你，抱起你的儿子，笑笑说，你这个代码仍是改改吧，要否则会被开除的，WHAT? 会开除，明明实现了功能呀，老王讲，没错，你功能是实现了，可是你又犯了一个大忌，什么大忌？

你改变了调用方式呀，想想，如今没每一个须要认证的模块，都必须调用你的login()方法，并把本身的函数名传给你，人家以前可不是这么调用的，试想，若是有100个模块须要认证，那这100个模块都得更改调用方式，这么多模块确定不止是一我的写的，让每一个人再去修改调用方式才能加上认证，你会被骂死的。。。。

你以为老王说的对，但问题是，如何即不改变原功能代码，又不改变原有调用方式，还能加上认证呢？你苦思了一会，仍是想不出，老王在逗你的儿子玩，你说，老王呀，快给我点思路，实在想不出来，老王背对着你问，

老王：学过匿名函数没有？

你：学过学过，就是lambda嘛

老王：那lambda与正常函数的区别是什么？

你：最直接的区别是，正常函数定义时须要写名字，但lambda不须要

老王：没错，那lambda定好后，为了屡次调用，能否也给它命个名？

你：能够呀，能够写成plus = lambda x:x+1相似这样，之后再调用plus就能够了，但这样不就失去了lambda的意义了，明明人家叫匿名函数呀，你起了名字有什么用呢？

老王：我不是要跟你讨论它的意义，我想经过这个让你明白一个事实

说着，老王拿起你儿子的画板，在上面写了如下代码：

def plus(n):
    return n+1

plus2 = lambda x:x+1

老王：上面这两种写法是否是表明一样的意思？

你：是的

老王：我给lambda x:x+1 起了个名字叫plus2，是否是至关于def plus2(x) ?

你：我擦，你别说，还真是，但老王呀，你想说明什么呢？

老王：没啥，只想告诉你，给函数赋值变量名就像def func_name　是同样的效果，以下面的plus(n)函数，你调用时能够用plus名，还能够再起个其它名字，如

calc = plus

calc(n)

你明白我想传达什么意思了么？

你：。。。。。。。。。。。这。。。。。。嗯。。。。。不太。。。。明白。。

老王：。。。。这。。。。。呵呵。。。。。。好吧。。。。，那我在给你点一下，你以前写的下面这段调用认证的代码

home()
login(america) #须要验证就调用 login，把须要验证的功能 当作一个参数传给login
# home()
# america()
login(henan)

你之所改变了调用方式，是由于用户每次调用时须要执行login(henan)，相似的。其实稍一改就能够了呀

home()
america = login(america) 
henan = login(henan)

这样你，其它人调用henan时，其实至关于调用了login(henan), 经过login里的验证后，就会自动调用henan功能。

你：我擦，还真是唉。。。，老王，仍是你nb。。。不过，等等，我这样写了好，那用户调用时，应该是下面这个样子

home()
america = login(america) #你在这里至关于把america这个函数替换了
henan = login(henan)

#那用户调用时依然写
america()

但问题在于，还不等用户调用，你的america = login(america)就会先本身把america执行了呀。。。。，你应该等我用户调用的时候再执行才对呀，不信我试给你看。。。

老王：哈哈，你说的没错，这样搞会出现这个问题？但你想一想有没有解决办法呢？

你：我擦，你指的思路呀，大哥。。。我哪知道下一步怎么走。。。

老王：算了，估计你也想不出来。。。学过嵌套函数没有？

你：yes,而后呢？

老王：想实现一开始你写的america = login(america)不触发你函数的执行，只须要在这个login里面再定义一层函数，第一次调用america = login(america)只调用到外层login，这个login虽然会执行，但不会触发认证了，由于认证的全部代码被封装在login里层的新定义的函数里了，login只返回里层函数的函数名，这样下次再执行america()时，就会调用里层函数啦。。。

你：。。。。。。什么？什么个意思，我蒙逼了。。。

老王：仍是给你看代码吧。。

def login(func): #把要执行的模块从这里传进来

    def inner():#再定义一层函数
        _username = "alex" #伪装这是DB里存的用户信息
        _password = "abc!23" #伪装这是DB里存的用户信息
        global user_status

        if user_status == False:
            username = input("user:")
            password = input("pasword:")

            if username == _username and password == _password:
                print("welcome login....")
                user_status = True
            else:
                print("wrong username or password!")

        if user_status == True:
            func() # 看这里看这里，只要验证经过了，就调用相应功能

    return inner #用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数

此时你仔细着了老王写的代码　，感受老王真不是通常人呀，连这种奇淫巧技都能想出来。。。，心中默默感谢上天赐你一个大牛邻居。

你: 老王呀，你这个姿式很nb呀，你首创的？

此时你媳妇噗嗤的笑出声来，你也不知道她笑个球。。。

老王：呵呵，这不是我首创的呀固然，这是开发中一个经常使用的玩法，叫语法糖，官方名称“装饰器”，其实上面的写法，还能够更简单

能够把下面代码去掉

america = login(america) #你在这里至关于把america这个函数替换了

只在你要装饰的函数上面加上下面代码

@login
def america():
    #login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

@login
def henan():
    #login() #执行前加上验证
    print("----河南专区----")

效果是同样的。

你开心的玩着老王教你的新姿式，玩着玩着就手贱给你的“河南专区”版块加了个参数，而后，结果出错了。。。

你：老王，老王，怎么传个参数就不行了呢？

老王：那必然呀，你调用henan时，实际上是至关于调用的login，你的henan第一次调用时henan = login(henan)， login就返回了inner的内存地址，第2次用户本身调用henan("3p"),实际上至关于调用的时inner,但你的inner定义时并无设置参数，但你给他传了个参数，因此天然就报错了呀

你：可是个人版块须要传参数呀，你不让我传不行呀。。。

老王：没说不让你传，稍作改动即可。。

老王：你再试试就行了。

你：果真好使，大神就是大神呀。。。不过，若是有多个参数呢？

老王：。。。。老弟，你不要什么都让我教你吧，非固定参数你没学过么？ *args,**kwargs...

你：噢。。。还能这么搞?,nb,我再试试。

你身陷这种新玩法中没法自拔，竟没注意到老王已经离开，你媳妇告诉你说为了避免打扰你加班，今晚带孩子去跟她姐妹住，你以为媳妇真体贴，最终，你终于搞定了全部需求，彻底遵循开放-封闭原则，最终代码以下。

#_*_coding:utf-8_*_


user_status = False #用户登陆了就把这个改为True

def login(func): #把要执行的模块从这里传进来

    def inner(*args,**kwargs):#再定义一层函数
        _username = "alex" #伪装这是DB里存的用户信息
        _password = "abc!23" #伪装这是DB里存的用户信息
        global user_status

        if user_status == False:
            username = input("user:")
            password = input("pasword:")

            if username == _username and password == _password:
                print("welcome login....")
                user_status = True
            else:
                print("wrong username or password!")

        if user_status == True:
            func(*args,**kwargs) # 看这里看这里，只要验证经过了，就调用相应功能

    return inner #用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数


def home():
    print("---首页----")

@login
def america():
    #login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

# @login
def henan(style):
    '''
    :param style: 喜欢看什么类型的，就传进来
    :return:
    '''
    #login() #执行前加上验证
    print("----河南专区----")

home()
# america = login(america) #你在这里至关于把america这个函数替换了
henan = login(henan)

# #那用户调用时依然写
america()

henan("3p")

此时，你已累的不行了，洗洗就抓紧睡了，半夜，上厕所，隐隐听到隔壁老王家有微弱的女人的声音传来，你会心一笑，老王这家伙，不声不响找了女友也不带给我看看，改天必定要见下真人。。。。

第二2天早上，产品经理又提了新的需求，要容许用户选择用qq\weibo\weixin认证，此时的你，已深谙装饰器各类装逼技巧，轻松的就实现了新的需求。

#_*_coding:utf-8_*_


user_status = False #用户登陆了就把这个改为True

def login(auth_type): #把要执行的模块从这里传进来
    def auth(func):
        def inner(*args,**kwargs):#再定义一层函数
            if auth_type == "qq":
                _username = "alex" #伪装这是DB里存的用户信息
                _password = "abc!23" #伪装这是DB里存的用户信息
                global user_status

                if user_status == False:
                    username = input("user:")
                    password = input("pasword:")

                    if username == _username and password == _password:
                        print("welcome login....")
                        user_status = True
                    else:
                        print("wrong username or password!")

                if user_status == True:
                    return func(*args,**kwargs) # 看这里看这里，只要验证经过了，就调用相应功能
            else:
                print("only support qq ")
        return inner #用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数

    return auth

def home():
    print("---首页----")

@login('qq')
def america():
    #login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

@login('weibo')
def henan(style):
    '''
    :param style: 喜欢看什么类型的，就传进来
    :return:
    '''
    #login() #执行前加上验证
    print("----河南专区----")

home()
# america = login(america) #你在这里至关于把america这个函数替换了
#henan = login(henan)

# #那用户调用时依然写
america()

# henan("3p")

带参数的装饰器

3.Json & pickle 数据序列化

参考 http://www.cnblogs.com/alex3714/articles/5161349.html

4.软件目录结构规范

为何要设计好目录结构?

"设计项目目录结构"，就和"代码编码风格"同样，属于我的风格问题。对于这种风格上的规范，一直都存在两种态度:

一类同窗认为，这种我的风格问题"可有可无"。理由是能让程序work就好，风格问题根本不是问题。
另外一类同窗认为，规范化能更好的控制程序结构，让程序具备更高的可读性。

我是比较偏向于后者的，由于我是前一类同窗思想行为下的直接受害者。我曾经维护过一个很是很差读的项目，其实现的逻辑并不复杂，可是却耗费了我很是长的时间去理解它想表达的意思。今后我我的对于提升项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴，咱们设计一个层次清晰的目录结构，就是为了达到如下两点:

可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪一个，测试目录在哪儿，配置文件在哪儿等等。从而很是快速的了解这个项目。
可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪一个文件和代码应该放在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增长，项目结构不会混乱，仍然可以组织良好。

因此，我认为，保持一个层次清晰的目录结构是有必要的。更况且组织一个良好的工程目录，实际上是一件很简单的事儿。

目录组织方式

关于如何组织一个较好的Python工程目录结构，已经有一些获得了共识的目录结构。在Stackoverflow的这个问题上，能看到你们对Python目录结构的讨论。

这里面说的已经很好了，我也不打算从新造轮子列举各类不一样的方式，这里面我说一下个人理解和体会。

假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了:

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README

简要解释一下:

bin/: 存放项目的一些可执行文件，固然你能够起名script/之类的也行。
foo/: 存放项目的全部源代码。(1) 源代码中的全部模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码； (3) 程序的入口最好命名为main.py。
docs/: 存放一些文档。
setup.py: 安装、部署、打包的脚本。
requirements.txt: 存放软件依赖的外部Python包列表。
README: 项目说明文件。

除此以外，有一些方案给出了更加多的内容。好比LICENSE.txt,ChangeLog.txt文件等，我没有列在这里，由于这些东西主要是项目开源的时候须要用到。若是你想写一个开源软件，目录该如何组织，能够参考这篇文章。

下面，再简单讲一下我对这些目录的理解和我的要求吧。

关于README的内容

这个我以为是每一个项目都应该有的一个文件，目的是能简要描述该项目的信息，让读者快速了解这个项目。

它须要说明如下几个事项:

软件定位，软件的基本功能。
运行代码的方法: 安装环境、启动命令等。
简要的使用说明。
代码目录结构说明，更详细点能够说明软件的基本原理。
常见问题说明。

我以为有以上几点是比较好的一个README。在软件开发初期，因为开发过程当中以上内容可能不明确或者发生变化，并非必定要在一开始就将全部信息都补全。可是在项目完结的时候，是须要撰写这样的一个文档的。

能够参考Redis源码中Readme的写法，这里面简洁可是清晰的描述了Redis功能和源码结构。

关于requirements.txt和setup.py

setup.py

通常来讲，用setup.py来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools来管理这些事情。这种方式广泛应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题，而是说，一个项目必定要有一个安装部署工具，能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。

这个我是踩过坑的。

我刚开始接触Python写项目的时候，安装环境、部署代码、运行程序这个过程全是手动完成，遇到过如下问题:

安装环境时常常忘了最近又添加了一个新的Python包，结果一到线上运行，程序就出错了。
Python包的版本依赖问题，有时候咱们程序中使用的是一个版本的Python包，可是官方的已是最新的包了，经过手动安装就可能装错了。
若是依赖的包不少的话，一个一个安装这些依赖是很费时的事情。
新同窗开始写项目的时候，将程序跑起来很是麻烦，由于可能常常忘了要怎么安装各类依赖。

setup.py能够将这些事情自动化起来，提升效率、减小出错的几率。"复杂的东西自动化，能自动化的东西必定要自动化。"是一个很是好的习惯。

setuptools的文档比较庞大，刚接触的话，可能不太好找到切入点。学习技术的方式就是看他人是怎么用的，能够参考一下Python的一个Web框架，flask是如何写的: setup.py

固然，简单点本身写个安装脚本（deploy.sh）替代setup.py也何尝不可。

requirements.txt

这个文件存在的目的是:

方便开发者维护软件的包依赖。将开发过程当中新增的包添加进这个列表中，避免在setup.py安装依赖时漏掉软件包。
方便读者明确项目使用了哪些Python包。

这个文件的格式是每一行包含一个包依赖的说明，一般是flask>=0.10这种格式，要求是这个格式能被pip识别，这样就能够简单的经过 pip install -r requirements.txt来把全部Python包依赖都装好了。具体格式说明：点这里。

关于配置文件的使用方法

注意，在上面的目录结构中，没有将`conf.py`放在源码目录下，而是放在`docs/`目录下。

不少项目对配置文件的使用作法是:

配置文件写在一个或多个python文件中，好比此处的conf.py。
项目中哪一个模块用到这个配置文件就直接经过import conf这种形式来在代码中使用配置。

这种作法我不太赞同:

这让单元测试变得困难（由于模块内部依赖了外部配置）
另外一方面配置文件做为用户控制程序的接口，应当能够由用户自由指定该文件的路径。
程序组件可复用性太差，由于这种贯穿全部模块的代码硬编码方式，使得大部分模块都依赖conf.py这个文件。

因此，我认为配置的使用，更好的方式是，

模块的配置都是能够灵活配置的，不受外部配置文件的影响。
程序的配置也是能够灵活控制的。

可以佐证这个思想的是，用过nginx和mysql的同窗都知道，nginx、mysql这些程序均可以自由的指定用户配置。

因此，不该当在代码中直接import conf来使用配置文件。上面目录结构中的conf.py，是给出的一个配置样例，不是在写死在程序中直接引用的配置文件。能够经过给main.py启动参数指定配置路径的方式来让程序读取配置内容。固然，这里的conf.py你能够换个相似的名字，好比settings.py。或者你也能够使用其余格式的内容来编写配置文件，好比settings.yaml之类的。

5.本节做业

做业需求：

模拟实现一个ATM + 购物商城程序

额度 15000或自定义
实现购物商城，买东西加入购物车，调用信用卡接口结帐
能够提现，手续费5%
每个月22号出帐单，每个月10号为还款日，过时未还，按欠款总额万分之5 每日计息
支持多帐户登陆
支持帐户间转帐
记录每个月平常消费流水
提供还款接口
ATM记录操做日志
提供管理接口，包括添加帐户、用户额度，冻结帐户等。。。
用户认证用装饰器

示例代码 https://github.com/triaquae/py_training/tree/master/sample_code/day5-atm 　　

模块，用一砣代码实现了某个功能的代码集合。

相似于函数式编程和面向过程编程，函数式编程则完成一个功能，其余代码用来调用便可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能须要多个函数才能完成（函数又能够在不一样的.py文件中），n个 .py 文件组成的代码集合就称为模块。

如：os 是系统相关的模块；file是文件操做相关的模块

模块分为三种：

自定义模块
内置标准模块（又称标准库）
开源模块

自定义模块和开源模块的使用参考 http://www.cnblogs.com/wupeiqi/articles/4963027.html

time & datetime模块

 1 #_*_coding:utf-8_*_
 2 __author__ = 'Alex Li'
 3 
 4 import time
 5 
 6 
 7 # print(time.clock()) #返回处理器时间,3.3开始已废弃 , 改为了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来
 8 # print(time.altzone)  #返回与utc时间的时间差,以秒计算\
 9 # print(time.asctime()) #返回时间格式"Fri Aug 19 11:14:16 2016",
10 # print(time.localtime()) #返回本地时间 的struct time对象格式
11 # print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式
12 
13 # print(time.asctime(time.localtime())) #返回时间格式"Fri Aug 19 11:14:16 2016",
14 #print(time.ctime()) #返回Fri Aug 19 12:38:29 2016 格式, 同上
15 
16 
17 
18 # 日期字符串 转成  时间戳
19 # string_2_struct = time.strptime("2016/05/22","%Y/%m/%d") #将 日期字符串 转成 struct时间对象格式
20 # print(string_2_struct)
21 # #
22 # struct_2_stamp = time.mktime(string_2_struct) #将struct时间对象转成时间戳
23 # print(struct_2_stamp)
24 
25 
26 
27 #将时间戳转为字符串格式
28 # print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式
29 # print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式
30 
31 
32 
33 
34 
35 #时间加减
36 import datetime
37 
38 # print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
39 #print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19
40 # print(datetime.datetime.now() )
41 # print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
42 # print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
43 # print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
44 # print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分
45 
46 
47 #
48 # c_time  = datetime.datetime.now()
49 # print(c_time.replace(minute=3,hour=2)) #时间替换

View Code

Directive	Meaning	Notes
`%a`	Locale’s abbreviated weekday name.
`%A`	Locale’s full weekday name.
`%b`	Locale’s abbreviated month name.
`%B`	Locale’s full month name.
`%c`	Locale’s appropriate date and time representation.
`%d`	Day of the month as a decimal number [01,31].
`%H`	Hour (24-hour clock) as a decimal number [00,23].
`%I`	Hour (12-hour clock) as a decimal number [01,12].
`%j`	Day of the year as a decimal number [001,366].
`%m`	Month as a decimal number [01,12].
`%M`	Minute as a decimal number [00,59].
`%p`	Locale’s equivalent of either AM or PM.	(1)
`%S`	Second as a decimal number [00,61].	(2)
`%U`	Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.	(3)
`%w`	Weekday as a decimal number [0(Sunday),6].
`%W`	Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0.	(3)
`%x`	Locale’s appropriate date representation.
`%X`	Locale’s appropriate time representation.
`%y`	Year without century as a decimal number [00,99].
`%Y`	Year with century as a decimal number.
`%z`	Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59].
`%Z`	Time zone name (no characters if no time zone exists).
`%%`	A literal `'%'` character.

random模块

随机数

mport random
print random.random()
print random.randint(1,2)
print random.randrange(1,10)

生成随机验证码

import random
checkcode = ''
for i in range(4):
    current = random.randrange(0,4)
    if current != i:
        temp = chr(random.randint(65,90))
    else:
        temp = random.randint(0,9)
    checkcode += str(temp)
print checkcode

OS模块　　

提供对操做系统进行调用的接口

os.getcwd() 获取当前工做目录，即当前python脚本工做的目录路径
os.chdir("dirname")  改变当前脚本工做目录；至关于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；至关于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则没法删除，报错；至关于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的全部文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操做系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.environ  获取系统环境变量
os.path.abspath(path)  返回path规范化的绝对路径
os.path.split(path)  将path分割成目录和文件名二元组返回
os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  若是path存在，返回True；若是path不存在，返回False
os.path.isabs(path)  若是path是绝对路径，返回True
os.path.isfile(path)  若是path是一个存在的文件，返回True。不然返回False
os.path.isdir(path)  若是path是一个存在的目录，则返回True。不然返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径以前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

更多猛击这里

sys模块

sys.argv           命令行参数List，第一个元素是程序自己路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操做系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]

shutil 模块

直接参考 http://www.cnblogs.com/wupeiqi/articles/4963027.html

json & pickle 模块

用于序列化的两个模块

json，用于字符串和 python数据类型间进行转换
pickle，用于python特有的类型和 python的数据类型间进行转换

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load

shelve 模块

shelve模块是一个简单的k,v将内存数据经过文件持久化的模块，能够持久化任何pickle可支持的python数据格式

import shelve

d = shelve.open('shelve_test') #打开一个文件 

class Test(object):
    def __init__(self,n):
        self.n = n


t = Test(123)  
t2 = Test(123334)

name = ["alex","rain","test"] 
d["test"] = name #持久化列表
d["t1"] = t      #持久化类
d["t2"] = t2

d.close()

xml处理模块

xml是实现不一样语言或程序之间进行数据交换的协议，跟json差很少，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，你们只能选择用xml呀，至今不少传统公司如金融行业的不少系统的接口还主要是xml。

xml的格式以下，就是经过<>节点来区别数据结构的:

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml协议在各个语言里的都是支持的，在python中能够用如下模块操做xml 　　

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)

#遍历xml文档
for child in root:
    print(child.tag, child.attrib)
    for i in child:
        print(i.tag,i.text)

#只遍历year 节点
for node in root.iter('year'):
    print(node.tag,node.text)

修改和删除xml文档内容

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")
root = tree.getroot()

#修改
for node in root.iter('year'):
    new_year = int(node.text) + 1
    node.text = str(new_year)
    node.set("updated","yes")

tree.write("xmltest.xml")


#删除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)

tree.write('output.xml')

本身建立xml文档

import xml.etree.ElementTree as ET


new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'

et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)

ET.dump(new_xml) #打印生成的格式

PyYAML模块

Python也能够很容易的处理ymal文档格式，只不过须要安装一个模块，参考文档：http://pyyaml.org/wiki/PyYAMLDocumentation

ConfigParser模块

用于生成和修改常见配置文档，当前模块的名称在 python 3.x 版本中变动为 configparser。

来看一个好多软件的常见文档格式以下

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes

[bitbucket.org]
User = hg

[topsecret.server.com]
Port = 50022
ForwardX11 = no

若是想用python生成一个这样的文档怎么作呢？

import configparser

config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9'}

config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022'     # mutates the parser
topsecret['ForwardX11'] = 'no'  # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
   config.write(configfile)

写完了还能够再读出来哈。

>>> import configparser
>>> config = configparser.ConfigParser()
>>> config.sections()
[]
>>> config.read('example.ini')
['example.ini']
>>> config.sections()
['bitbucket.org', 'topsecret.server.com']
>>> 'bitbucket.org' in config
True
>>> 'bytebong.com' in config
False
>>> config['bitbucket.org']['User']
'hg'
>>> config['DEFAULT']['Compression']
'yes'
>>> topsecret = config['topsecret.server.com']
>>> topsecret['ForwardX11']
'no'
>>> topsecret['Port']
'50022'
>>> for key in config['bitbucket.org']: print(key)
...
user
compressionlevel
serveraliveinterval
compression
forwardx11
>>> config['bitbucket.org']['ForwardX11']
'yes'

configparser增删改查语法

[section1]
k1 = v1
k2:v2
 
[section2]
k1 = v1

import ConfigParser
 
config = ConfigParser.ConfigParser()
config.read('i.cfg')
 
# ########## 读 ##########
#secs = config.sections()
#print secs
#options = config.options('group2')
#print options
 
#item_list = config.items('group2')
#print item_list
 
#val = config.get('group1','key')
#val = config.getint('group1','key')
 
# ########## 改写 ##########
#sec = config.remove_section('group1')
#config.write(open('i.cfg', "w"))
 
#sec = config.has_section('wupeiqi')
#sec = config.add_section('wupeiqi')
#config.write(open('i.cfg', "w"))
 
 
#config.set('group2','k1',11111)
#config.write(open('i.cfg', "w"))
 
#config.remove_option('group2','age')
#config.write(open('i.cfg', "w"))

hashlib模块　　

用于加密相关的操做，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib

m = hashlib.md5()
m.update(b"Hello")
m.update(b"It's me")
print(m.digest())
m.update(b"It's been a long time since last time we ...")

print(m.digest()) #2进制格式hash
print(len(m.hexdigest())) #16进制格式hash
'''
def digest(self, *args, **kwargs): # real signature unknown
    """ Return the digest value as a string of binary data. """
    pass

def hexdigest(self, *args, **kwargs): # real signature unknown
    """ Return the digest value as a string of hexadecimal digits. """
    pass

'''
import hashlib

# ######## md5 ########

hash = hashlib.md5()
hash.update('admin')
print(hash.hexdigest())

# ######## sha1 ########

hash = hashlib.sha1()
hash.update('admin')
print(hash.hexdigest())

# ######## sha256 ########

hash = hashlib.sha256()
hash.update('admin')
print(hash.hexdigest())


# ######## sha384 ########

hash = hashlib.sha384()
hash.update('admin')
print(hash.hexdigest())

# ######## sha512 ########

hash = hashlib.sha512()
hash.update('admin')
print(hash.hexdigest())

还不够吊？python 还有一个 hmac 模块，它内部对咱们建立 key 和内容再进行处理而后再加密

import hmac
h = hmac.new('wueiqi')
h.update('hellowo') 
print h.hexdigest()

更多关于md5,sha1,sha256等介绍的文章看这里https://www.tbs-certificates.co.uk/FAQ/en/sha256.html

Subprocess模块

The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. This module intends to replace several older modules and functions:

os.system os.spawn*

The recommended approach to invoking subprocesses is to use the run() function for all use cases it can handle. For more advanced use cases, the underlying Popen interface can be used directly.

The run() function was added in Python 3.5; if you need to retain compatibility with older versions, see the Older high-level API section.

(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False)subprocess.run

Run the command described by args. Wait for command to complete, then return a CompletedProcess instance.

The arguments shown above are merely the most common ones, described below in Frequently Used Arguments (hence the use of keyword-only notation in the abbreviated signature). The full function signature is largely the same as that of the Popen constructor - apart from timeout, input and check, all the arguments to this function are passed through to that interface.

This does not capture stdout or stderr by default. To do so, pass PIPE for the stdout and/or stderr arguments.

The timeout argument is passed to Popen.communicate(). If the timeout expires, the child process will be killed and waited for. The TimeoutExpired exception will be re-raised after the child process has terminated.

The input argument is passed to Popen.communicate() and thus to the subprocess’s stdin. If used it must be a byte sequence, or a string if universal_newlines=True. When used, the internal Popen object is automatically created withstdin=PIPE, and the stdin argument may not be used as well.

If check is True, and the process exits with a non-zero exit code, a CalledProcessError exception will be raised. Attributes of that exception hold the arguments, the exit code, and stdout and stderr if they were captured.

经常使用subprocess方法示例

#执行命令，返回命令执行状态， 0 or 非0
>>> retcode = subprocess.call(["ls", "-l"])

#执行命令，若是命令结果为0，就正常返回，不然抛异常
>>> subprocess.check_call(["ls", "-l"])
0

#接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果
>>> subprocess.getstatusoutput('ls /bin/ls')
(0, '/bin/ls')

#接收字符串格式命令，并返回结果
>>> subprocess.getoutput('ls /bin/ls')
'/bin/ls'

#执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res
>>> res=subprocess.check_output(['ls','-l'])
>>> res
b'total 0\ndrwxr-xr-x 12 alex staff 408 Nov 2 11:05 OldBoyCRM\n'

#上面那些方法，底层都是封装的subprocess.Popen
poll()
Check if child process has terminated. Returns returncode

wait()
Wait for child process to terminate. Returns returncode attribute.

terminate() 杀掉所启动进程
communicate() 等待任务结束

stdin 标准输入

stdout 标准输出

stderr 标准错误

pid
The process ID of the child process.

#例子
>>> p = subprocess.Popen("df -h|grep disk",stdin=subprocess.PIPE,stdout=subprocess.PIPE,shell=True)
>>> p.stdout.read()
b'/dev/disk1 465Gi 64Gi 400Gi 14% 16901472 104938142 14% /\n'

>>> subprocess.run(["ls", "-l"])  # doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)

>>> subprocess.run("exit 1", shell=True, check=True)
Traceback (most recent call last):
  ...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1

>>> subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')

调用subprocess.run(...)是推荐的经常使用方法，在大多数状况下能知足需求，但若是你可能须要进行一些复杂的与系统的交互的话，你还能够用subprocess.Popen(),语法以下：

p = subprocess.Popen("find / -size +1000000 -exec ls -shl {} \;",shell=True,stdout=subprocess.PIPE)
print(p.stdout.read())

可用参数：

args：shell命令，能够是字符串或者序列类型（如：list，元组）
bufsize：指定缓冲。0 无缓冲,1 行缓冲,其余缓冲区大小,负值系统缓冲
stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行以前被调用
close_sfs：在windows平台下，若是close_fds被设置为True，则新建立的子进程将不会继承父进程的输入、输出、错误管道。
因此不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
shell：同上
cwd：用于设置子进程的当前目录
env：用于指定子进程的环境变量。若是env = None，子进程的环境变量将从父进程中继承。
universal_newlines：不一样系统的换行符不一样，True -> 赞成使用 \n
startupinfo与createionflags只在windows下有效
将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

终端输入的命令分为两种：

输入便可获得输出，如：ifconfig
输入进行某环境，依赖再输入，如：python

须要交互的命令示例

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
obj.stdin.write('print 1 \n ')
obj.stdin.write('print 2 \n ')
obj.stdin.write('print 3 \n ')
obj.stdin.write('print 4 \n ')

out_error_list = obj.communicate(timeout=10)
print out_error_list

subprocess实现sudo 自动输入密码

import subprocess

def mypass():
    mypass = '123' #or get the password from anywhere
    return mypass

echo = subprocess.Popen(['echo',mypass()],
                        stdout=subprocess.PIPE,
                        )

sudo = subprocess.Popen(['sudo','-S','iptables','-L'],
                        stdin=echo.stdout,
                        stdout=subprocess.PIPE,
                        )

end_of_pipe = sudo.stdout

print "Password ok \n Iptables Chains %s" % end_of_pipe.read()

logging模块　　

不少程序都有记录日志的需求，而且日志中包含的信息即有正常的程序访问日志，还可能有错误、警告等信息输出，python的logging模块提供了标准的日志接口，你能够经过它存储各类格式的日志，logging的日志能够分为 debug(), info(), warning(), error() and critical() 5个级别，下面咱们看一下怎么用。

最简单用法

import logging

logging.warning("user [alex] attempted wrong password more than 3 times")
logging.critical("server is down")

#输出
WARNING:root:user [alex] attempted wrong password more than 3 times
CRITICAL:root:server is down

看一下这几个日志级别分别表明什么意思

Level	When it’s used
`DEBUG`	Detailed information, typically of interest only when diagnosing problems.
`INFO`	Confirmation that things are working as expected.
`WARNING`	An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected.
`ERROR`	Due to a more serious problem, the software has not been able to perform some function.
`CRITICAL`	A serious error, indicating that the program itself may be unable to continue running.

若是想把日志写到文件里，也很简单

import logging

logging.basicConfig(filename='example.log',level=logging.INFO) 
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')

其中下面这句中的level=loggin.INFO意思是，把日志纪录级别设置为INFO，也就是说，只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里，在这个例子，第一条日志是不会被纪录的，若是但愿纪录debug的日志，那把日志级别改为DEBUG就好了。

logging.basicConfig(filename='example.log',level=logging.INFO)

感受上面的日志格式忘记加上时间啦，日志不知道时间怎么行呢，下面就来加上!

import logging
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
logging.warning('is when this event was logged.')

#输出
12/12/2010 11:46:36 AM is when this event was logged.

日志格式

%(name)s	Logger的名字
%(levelno)s	数字形式的日志级别
%(levelname)s	文本形式的日志级别
%(pathname)s	调用日志输出函数的模块的完整路径名，可能没有
%(filename)s	调用日志输出函数的模块的文件名
%(module)s	调用日志输出函数的模块名
%(funcName)s	调用日志输出函数的函数名
%(lineno)d	调用日志输出函数的语句所在的代码行
%(created)f	当前时间，用UNIX标准的表示时间的浮点数表示
%(relativeCreated)d	输出日志信息时的，自Logger建立以来的毫秒数
%(asctime)s	字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d	线程ID。可能没有
%(threadName)s	线程名。可能没有
%(process)d	进程ID。可能没有
%(message)s	用户输出的消息

若是想同时把log打印在屏幕和文件日志里，就须要了解一点复杂的知识了

Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的归纳最为合适：

logger提供了应用程序能够直接使用的接口；

handler将(logger建立的)日志记录发送到合适的目的输出；

filter提供了细度设备来决定输出哪条日志记录；

formatter决定日志记录的最终输出格式。

logger
每一个程序在输出信息以前都要得到一个Logger。Logger一般对应了程序的模块名，好比聊天工具的图形界面模块能够这样得到它的Logger：
LOG=logging.getLogger(”chat.gui”)
而核心模块能够这样：
LOG=logging.getLogger(”chat.kernel”)

Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增长或删除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：能够设置的日志级别

handler

handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler能够使用。有些Handler能够把信息输出到控制台，有些Logger能够把信息输出到文件，还有些 Handler能够把信息发送到网络上。若是以为不够用，还能够编写本身的Handler。能够经过addHandler()方法添加多个多handler
Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略
Handler.setFormatter()：给这个handler选择一个格式
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象

每一个Logger能够附加多个Handler。接下来咱们就来介绍一些经常使用的Handler：
1) logging.StreamHandler
使用这个Handler能够向相似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：
StreamHandler([strm])
其中strm参数是一个文件对象。默认是sys.stderr

2) logging.FileHandler
和StreamHandler相似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：
FileHandler(filename[,mode])
filename是文件名，必须指定一个文件名。
mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a'，即添加到文件末尾。

3) logging.handlers.RotatingFileHandler
这个Handler相似于上面的FileHandler，可是它能够管理文件大小。当文件达到必定大小以后，它会自动将当前日志文件更名，而后建立一个新的同名日志文件继续输出。好比日志文件是chat.log。当chat.log达到指定的大小以后，RotatingFileHandler自动把文件更名为chat.log.1。不过，若是chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后从新建立 chat.log，继续输出日志信息。它的构造函数是：
RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
其中filename和mode两个参数和FileHandler同样。
maxBytes用于指定日志文件的最大文件大小。若是maxBytes为0，意味着日志文件能够无限大，这时上面描述的重命名过程就不会发生。
backupCount用于指定保留的备份文件的个数。好比，若是指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被改名，而是被删除。

4) logging.handlers.TimedRotatingFileHandler
这个Handler和RotatingFileHandler相似，不过，它没有经过判断文件大小来决定什么时候从新建立日志文件，而是间隔必定时间就自动建立新的日志文件。重命名的过程与RotatingFileHandler相似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：
TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
其中filename参数和backupCount参数和RotatingFileHandler具备相同的意义。
interval是时间间隔。
when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有如下取值：
S 秒
M 分
H 小时
D 天
W 每星期（interval==0时表明星期一）
midnight 天天凌晨

import logging

#create logger
logger = logging.getLogger('TEST-LOG')
logger.setLevel(logging.DEBUG)


# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)

# create file handler and set level to warning
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# add formatter to ch and fh
ch.setFormatter(formatter)
fh.setFormatter(formatter)

# add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(fh)

# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')

文件自动截断例子

import logging

from logging import handlers

logger = logging.getLogger(__name__)

log_file = "timelog.log"
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)


formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')

fh.setFormatter(formatter)

logger.addHandler(fh)


logger.warning("test1")
logger.warning("test12")
logger.warning("test13")
logger.warning("test14")

View Code

re模块　　

经常使用正则表达式符号

'.'		默认匹配除\n以外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^'		匹配字符开头，若指定flags MULTILINE,这种也能够匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'		匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也能够
'*'		匹配*号前的字符0次或屡次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']
'+'		匹配前一个字符1次或屡次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'		匹配前一个字符1次或0次
'{m}'	匹配前一个字符m次
'{n,m}'	匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|'		匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group()	结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c


'\A'	只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'	匹配字符结尾，同$
'\d'	匹配数字0-9
'\D'	匹配非数字
'\w'	匹配[A-Za-z0-9]
'\W'	匹配非[A-Za-z0-9]
's'		匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'

'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

最经常使用的匹配语法

re.match 从头开始匹配
re.search 匹配包含
re.findall 把全部匹配到的字符放到以列表中的元素返回
re.splitall 以匹配到的字符当作列表分隔符
re.sub		匹配字符并替换

反斜杠的困扰
与大多数编程语言相同，正则表达式里使用"\"做为转义字符，这就可能形成反斜杠困扰。假如你须要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将须要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式能够使用r"\\"表示。一样，匹配一个数字的"\\d"能够写成r"\d"。有了原生字符串，你不再用担忧是否是漏写了反斜杠，写出来的表达式也更直观。

仅需轻轻知道的几个匹配模式

re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
S(DOTALL): 点任意匹配模式，改变'.'的行为

本节做业

开发一个简单的python计算器

实现加减乘除及拓号优先级解析
用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等相似公式后，必须本身解析里面的(),+,-,*,/符号和公式(不能调用eval等相似功能偷懒实现)，运算后得出结果，结果必须与真实的计算器所得出的结果一致

hint:

re.search(r'\([^()]+\)',s).group()

'(-40/5)'

Python学习基础方便查询

1、 Python介绍

Python 是一门什么样的语言？

编译和解释的区别是什么？

Python的优缺点

Python解释器

CPython

IPython

PyPy

Jython

IronPython

小结

2、Python发展史

3、Python 2 or 3?

py2与3的详细区别

4、Python安装

windows

5、Hello World程序

6、变量\字符编码

7、字符编码

注释

8、用户输入

9、模块初识

10、.pyc是个什么鬼？

11、数据类型初识

12、数据运算

十3、表达式if ... else

十4、表达式for loop

十5、while loop

十6、做业

入门知识拾遗

4、 一切皆对象

1. 列表、元组操做

元组

程序练习

2. 字符串操做

3. 字典操做

4.集合操做

5. 文件操做

6. 字符编码与转码

温故知新

1. 集合

2. 元组

3. 字典

key-value对

4. 字符编码

1.函数基本语法及特性

背景提要

函数是什么?

定义: 函数是指将一组语句的集合经过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名便可

语法定义

2.函数参数与局部变量

关键参数

局部变量

3.返回值

强行插入知识点: 嵌套函数

4. 递归

5. 匿名函数

6.函数式编程介绍

7.高阶函数

8. 内置参数

本节做业

1.列表生成式，迭代器&生成器

列表生成式

生成器

迭代器

2.装饰器

3.Json & pickle 数据序列化

4.软件目录结构规范

为何要设计好目录结构?

目录组织方式

关于README的内容

关于requirements.txt和setup.py

setup.py

requirements.txt

关于配置文件的使用方法

注意，在上面的目录结构中，没有将conf.py放在源码目录下，而是放在docs/目录下。

5.本节做业

time & datetime模块

random模块

6、变量\字符编码　　

8、用户输入　

9、模块初识　　

12、数据运算　　

十5、while loop 　　

4、一切皆对象

2. 字符串操做　　　　

2. 元组　　

2.函数参数与局部变量　　

局部变量　　

3.返回值　　

强行插入知识点: 嵌套函数　　

6.函数式编程介绍　　

8. 内置参数　　

注意，在上面的目录结构中，没有将`conf.py`放在源码目录下，而是放在`docs/`目录下。

OS模块　　

logging模块　　

re模块　　