Python开发-- Lesson 1--Python介绍和入门（2016/07/23）

 

一、python创始人介绍

python的创始人为吉多·范罗苏姆（Guido van Rossum），从2005年开始就任于Google公司。

Python是线上和线下的一种重要的编程语言。Python社区的人赋予他“仁慈大君” 的称号，这一称号直接来自英国肥皂剧《Monty Python飞行马戏团》。Guido当初之因此选中Python做为程序的名字，是由于他太喜欢这部肥皂剧了。

Guido原居荷兰，1995移居到美国，并遇到了他如今的妻子。在2003年初，Guido和他的家人，包括他2001年出生的儿子Orlijn一直居住在华盛顿洲北弗吉尼亚的郊区。随后他们搬迁到硅谷，如今Guido在为Google工做（其中有一半时间是花在Python上）。

Guido在1982年得到阿姆斯特丹大学的数学和计算机科学的硕士学位，并于同年加入一个多媒体组织CWI，作调研员。1989年，他创立了Python语言。

 

二、python介绍

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

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

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

目前Python主要应用领域：

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

Python在一些公司的应用： 

 

• 谷歌：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的设计哲学是“优雅”、“明确”、“简单”。Python开发者的哲学是“用一种方法，最好是只有一种方法来作一件事”。在设计Python语言时，若是面临多种选择，Python开发者通常会拒绝花俏的语法，而选择明确没有或者不多有歧义的语法。这些准则被称为“ Python格言”。在Python解释器内运行import this能够得到完整的列表

 1.优美胜于丑陋（Python 以编写优美的代码为目标）

2.明了胜于晦涩（优美的代码应当是明了的，命名规范，风格类似）

3.简洁胜于复杂（优美的代码应当是简洁的，不要有复杂的内部实现）

4.复杂胜于凌乱（若是复杂不可避免，那代码间也不能有难懂的关系，要保持接口简洁，多加注释！）

5.扁平胜于嵌套（优美的代码应当是扁平的，不能有太多的嵌套）

6.间隔胜于紧凑（优美的代码有适当的间隔，不要奢望一行代码解决问题，一行代码不能超过80个字符，你能够换行或起一个新的逻辑来写）

7.可读性很重要（优美的代码是可读的）

8.即使假借特例的实用性之名，也不可违背这些规则（这些规则至高无上），觉对不容许特列必须按照这个规则

9.不要包容全部错误，除非你肯定须要这样作（精准地捕获异常，不写 except:pass 风格的代码）

10.当存在多种可能，不要尝试去猜想！

11.而是尽可能找一种，最好是惟一一种明显的解决方案（若是不肯定，就用穷举法）

12.虽然这并不容易，由于你不是 Python 之父（这里的 Dutch 是指 Guido ）

13.作也许好过不作，但不假思索就动手还不如不作（动手以前要细思量）

14.若是你没法向人描述你的方案，那确定不是一个好方案；反之亦然（方案测评标准）

15.命名空间是一种绝妙的理念，咱们应当多加利用（倡导与号召）

 

四、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

五、Python的优缺点

先看优势

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

再看缺点：

1. 速度慢，Python 的运行速度相比C语言确实慢不少，跟JAVA相比也要慢一些，所以这也是不少所谓的大牛不屑于使用Python的主要缘由，但其实这里所指的运行速度慢在大多数状况下用户是没法直接感知到的，必须借助测试工具才能体现出来，好比你用C运一个程序花了0.1s,用Python是0.01s,这样C语言直接比Python快了10s,算是很是夸张了，可是你是没法直接经过肉眼感知的，由于一个正常人所能感知的时间最小单位是0.15-0.4s左右，哈哈。其实在大多数状况下Python已经彻底能够知足你对程序速度的要求，除非你要写对速度要求极高的搜索引擎等，这种状况下，固然仍是建议你用C去实现的。
2. 代码不能加密，由于PYTHON是解释性语言，它的源码都是以名文形式存放的，不过我不认为这算是一个缺点，若是你的项目要求源代码必须是加密的，那你一开始就不该该用Python来去实现。
3. 线程不能利用多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 和 php

python是综合性的语言，他不光能够作web开发。他俩的对比应该仅限于web开发方向。不见其phpweb开发别python好，php是先入为主，python的web框架在2000才有的比较晚了

django起来的比较晚，他们的web开发都是很不错了。你用php作的python均可以作。python给你的是一个完整的解决，前端和后端均可以用python。

 

Python 和 c

C语言： 代码编译获得 机器码 ，机器码在处理器上直接执行，每一条指令控制CPU工做

其余语言： 代码编译获得 字节码 ，虚拟机执行字节码并转换成机器码再后在处理器上执行

Python 和 C  Python这门语言是由C开发而来

　　对于使用：Python的类库齐全而且使用简洁，若是要实现一样的功能，Python 10行代码能够解决，C可能就须要100行甚至更多.
　　对于速度：Python的运行速度相较与C，相同的程序Python比C慢几百倍很正常

程序的快慢很大程度上程序员逻辑、SQL、算法，比起O（n）和O（n^2)的区别， 语言间的差别就显得微乎其微

 

Python 和 Java、C#等

　　对于使用：Linux原装Python，其余语言没有；以上几门语言都有很是丰富的类库支持
　　对于速度：Python在速度上可能稍显逊色

因此，Python和其余语言没有什么本质区别，其余区别在于：擅长某领域、人才丰富、先入为主。

 

六、Python的种类

• Cpython
      Python的官方版本，使用C语言实现，使用最为普遍，CPython实现会将源文件（py文件）转换成字节码文件（pyc文件），而后运行在Python虚拟机上。
• Jyhton
      Python的Java实现，Jython会将Python代码动态编译成Java字节码，而后在JVM上运行。
• IronPython
      Python的C#实现，IronPython将Python代码编译成C#字节码，而后在CLR上运行。（与Jython相似）
• PyPy（特殊）
      Python实现的Python，将Python的字节码字节码再编译成机器码。
• RubyPython、Brython ...

以上除PyPy以外，其余的Python的对应关系和执行流程以下：

 

PyPy，在Python的基础上对Python的字节码进一步处理，从而提高执行速度！

 

七、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: 

+ View Code

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

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

ALL IS UNICODE NOW

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

 

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

1 2 3 4

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

　　

某些库更名了

 

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 tri

 

八、安装Python

windows：

1 2 3 4 5 6 7

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

linux：

1 2 3

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

更新Python

windows:

1

卸载重装便可

linux:

Linux的yum依赖自带Python，为防止错误，此处更新其实就是再安装一个Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

查看默认Python版本 python  - V    1 、安装gcc，用于编译Python源码      yum install gcc 2 、下载源码包，https: / / www.python.org / ftp / python / 3 、解压并进入源码文件 4 、编译安装      . / configure      make  all      make install 5 、查看版本      / usr / local / bin / python2. 7  - V 6 、修改默认Python版本      mv  / usr / bin / python  / usr / bin / python2. 6      ln  - s  / usr / local / bin / python2. 7  / usr / bin / python 7 、防止yum执行异常，修改yum使用的Python版本      vi  / usr / bin / yum      将头部  #!/usr/bin/python 修改成 #!/usr/bin/python2.6

九、Python 入门仪式 'Hello World'

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

1	print ( "Hello World!" )

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

1 2 3

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

指定解释器

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

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

1 2 3

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

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

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

在交互器中执行　

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

1 2 3 4 5 6

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!

 

十、变量\字符编码　　

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.

声明变量

1 2 3

#_*_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']

变量的赋值

1 2 3 4 5 6 7 8

name  =  "Alex Li"   name2  =  name print (name,name2)   name  =  "Jack"   print ( "What is the value of name2 now?" )

　

字符编码

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码没法表示中文

1 2 3

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

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

1 2 3 4

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

 

1字节＝8bit   又叫8位，最先的ASCII码就是占一个字节（8位）  8位也就是二进制0000 0000，二进制8位最大表示数字位255，因为老外并不知道地球的另外一边有其余世界的存在，因此他就在0-255之间选择0-127做为英文的存放，还预留了一半的空间做为扩展。但后后来中国人发现预留的这些空间远远不够存放中国博大精深的全部汉字，可是中国人有办法，中国人在128-255中间取了一部分用于存放汉字的索引，也能够说只要查找的位置落到了这一部分就表明着要存放汉字，在1980年中国的人们本身又建立了一个表存放中国汉字就产生了GB2312其中共收录了7445个字符，包括6763个汉字和682个其它符号；可是中国实在是博大精深在1995年又诞生了GBK编码共收录21886个符号，它分为汉字区和图形符号区，汉字区包括21003个字符。2000年的 GB18030是取代GBK1.0的正式国家标准。该标准收录了27484个汉字，同时还收录了藏文、蒙文、维吾尔文等主要的少数民族文字。如今的PC平台必须支持GB18030，对嵌入式产品暂不做要求。因此手机、MP3通常只支持GB2312。

　　因为Unicode浪费了存储空间，不管存放中文仍是英文都要是用16位来存放，平时50G的数据，使用Unicode就要使用100G，这显然不合适，这样就有了UTF-8的编码，这个编码存放英文将占用1个字节，存放中文占用3个字节。

注释

　　当行注视：# 被注释内容

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

 

 

 

 

十一、Python运算符

Python算术运算符：

操做符	描述符	例子
+	加法 - 对操做符的两侧增长值	a + b = 30
-	减法 - 减去从左侧操做数右侧操做数	a - b = -10
*	乘法 - 相乘的运算符两侧的值	a * b = 200
/	除 - 由右侧操做数除以左侧操做数	b / a = 2
%	模 - 由右侧操做数和余返回除以左侧操做数	b % a = 0
**	指数- 执行对操做指数（幂）的计算	a**b = 10 的幂 20
//	地板除 - 操做数的除法，其中结果是将小数点后的位数被除去的商。	9//2 =  4 而 9.0//2.0 = 4.0

1 2 3 4 5 6 7 8

>>> a  =  21 >>> b  =  10 >>> c  =  0 >>> c  =  a  +  b ;  print  c 31 >>> c  =  a  - b ;  print  c11>>> c  =  a  *  b ;  print  c210 >>> c  =  c  /  b ;  print  c 21 >>> c  =  c  %  b ;  print  c 1

Python的比较操做符：

 

运算符	描述	示例
==	检查，两个操做数的值是否相等，若是是则条件变为真。	(a == b) 不为 true.
!=	检查两个操做数的值是否相等，若是值不相等，则条件变为真。	(a != b) 为 true.
<>	检查两个操做数的值是否相等，若是值不相等，则条件变为真。	(a <> b) 为 true。这个相似于 != 运算符
>	检查左操做数的值是否大于右操做数的值，若是是，则条件成立。	(a > b) 不为 true.
<	检查左操做数的值是否小于右操做数的值，若是是，则条件成立。	(a < b) 为 true.
>=	检查左操做数的值是否大于或等于右操做数的值，若是是，则条件成立。	(a >= b) 不为 true.
<=	检查左操做数的值是否小于或等于右操做数的值，若是是，则条件成立。	(a <= b) 为 true.

 

1 2 3 4 5 6 7 8

>>> a  =  21 >>> b  =  10 >>> c  =  0 >>> c  =  a  +  b ;  print  c 31 >>> c  =  a  - b ;  print  c11>>> c  =  a  *  b ;  print  c210 >>> c  =  c  /  b ;  print  c 21 >>> c  =  c  %  b ;  print  c 1

 Python赋值运算符：

运算符	描述	示例
=	简单的赋值运算符，赋值从右侧操做数左侧操做数	c = a + b将指定的值 a + b 到  c
+=	加法AND赋值操做符，它增长了右操做数左操做数和结果赋给左操做数	c += a 至关于 c = c + a
-=	减AND赋值操做符，它减去右边的操做数从左边操做数，并将结果赋给左操做数	c -= a 至关于 c = c - a
*=	乘法AND赋值操做符，它乘以右边的操做数与左操做数，并将结果赋给左操做数	c *= a 至关于 c = c * a
/=	除法AND赋值操做符，它把左操做数与正确的操做数，并将结果赋给左操做数	c /= a 至关于= c / a
%=	模量AND赋值操做符，它须要使用两个操做数的模量和分配结果左操做数	c %= a is equivalent to c = c % a
**=	指数AND赋值运算符，执行指数（功率）计算操做符和赋值给左操做数	c **= a 至关于 c = c ** a
//=	地板除，并分配一个值，执行地板除对操做和赋值给左操做数	c //= a 至关于 c = c // a

1 2 3 4 5 6 7 8

>>> a  =  21 >>> b  =  10 >>> c  =  0 >>> >>> c  =  a  + b >>> c  + =  a ;  print  c 52 >>> c  + =  a  is  c  =  c  +  a

Python位运算符：

 

二进制换算成10进制网络学过的东西回忆下：

128 64 32 16 8 4 2 1

二进制是8位的好比说：01001111    换成10进制的就是：1+2+4+8+64  和上面的对比取值

操做符	描述	示例
&	二进制和复制操做了一下，结果，若是它存在于两个操做数。	(a & b) = 12 即 0000 1100
|	二进制或复制操做了一个比特，若是它存在一个操做数中。	(a | b) = 61 即 0011 1101
^	二进制异或运算符的副本，若是它被设置在一个操做数而不是两个比特。	(a ^ b) =  49 即  0011 0001
~	二进制的补运算符是一元的，并有“翻转”位的效果。	(~a ) =  -61 即 1100 0011以2的补码形式因为带符号二进制数。
<<	二进位向左移位运算符。左操做数的值左移由右操做数指定的位数。	a << 2 = 240 即 1111 0000
>>	二进位向右移位运算符。左操做数的值是由右操做数指定的位数向右移动。	a >> 2 = 15 即 0000 1111

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

二进制“与”计算：（ 1 和 1 = 1   0 和任意都为 0 ） a  =  10 b  =  49 a&b   10         0     0     0     0        1     0     1     0 49         0     0     1     1        0     0     0     1 = 0         0     0     0     0        0     0     0     0     二进制“或”计算：（遇 1 得 1 ） a|b a  =  60  # 60 = 0 0 1 1    1 1 0 0 b  =  13  #13 =  0 0 0 0    1 1 0 1 =                      0  0  1  1     1  1  0  1    =  0 + 0 + 32 + 16 + 8 + 4 + 0 + 1  =  61                       二进制“异或”运算：（相同为 0 ，不一样为 1 ） a^b   a  =  60             # 60 = 0011 1100 b  =  13             # 13 = 0000 1101                                    0011  0001   =  0 + 0 + 32 + 16 + 0 + 0 + 0 + 1 = 49   二进制取反运算:( 0 置换为 1 ， 1 置换为 0 ） ~a   a  =  60             # 60 = 0011 1100 那么   - a  =  1100  0011      128  +  64  + 2  + 1  =            二进位向左、右移位运算符: a = 2  那么 往左移 1 位就是 4 以下： a<< 1  =   4         ;         a>> 1  =  1

Python逻辑运算符：

运算符	描述	示例
and	所谓逻辑与运算符。若是两个操做数都是真的，那么则条件成立。	(a and b) 为 true.
or	所谓逻辑OR运算符。若是有两个操做数都是非零而后再条件变为真。	(a or b) 为 true.
not	所谓逻辑非运算符。用于反转操做数的逻辑状态。若是一个条件为真，则逻辑非运算符将返回false。	not(a and b) 为 false.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

例子： and 运算，都为真时为真 >>>  9  >  8  and  9  <  10 True >>>  9  >  8  and  9  >  10 False   or 运算，有一个为真的时候便可为真 >>>  9  >  8  or  9  >  10 True >>>  9  <  8  or  9  >  10 False >>>   not 运算，假为真真为假 >>>  not  6.2  < =  6 True >>>  not  6.2  > =  6 False >>>

 

十二、数据类型初识 

一、数字

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（浮点型）
　　浮点数用来处理实数，即带有小数的数字。相似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）
　　复数由实数部分和虚数部分组成，通常形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

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

 

二、布尔值

　　真或假

　　1 或 0

三、字符串

"hello world"

万恶的字符串拼接：

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

字符串格式化输出

1 2 3 4

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

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

字符串经常使用功能：

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

四、列表

建立列表：

1 2 3

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

基本操做：

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

五、元组(不可变列表)

建立元组：

1 2 3

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

 

六、字典（无序）

建立字典：

1 2 3

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

经常使用操做：

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

 

1三、输入

1 2 3 4 5 6 7 8

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

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

1 2 3 4 5 6 7 8 9 10

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

1四、流程控制和缩进

需求1、用户登录验证

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#!/usr/bin/env python # -*- coding: encoding -*-    # 提示输入用户名和密码    # 验证用户名和密码 #     若是错误，则输出用户名或密码错误 #     若是成功，则输出 欢迎，XXX!     import  getpass       name  =  raw_input ( '请输入用户名：' ) pwd  =  getpass.getpass( '请输入密码：' )    if  name  = =  "alex"  and  pwd  = =  "cmd" :      print  "欢迎，alex！" else :      print  "用户名和密码错误"

需求2、根据用户输入内容输出其权限

1 2 3 4 5 6

# 根据用户输入内容打印其权限    # alex --> 超级管理员 # eric --> 普通管理员 # tony,rain --> 业务主管 # 其余 --> 普通用户

1 2 3 4 5 6 7 8 9 10 11

name  =  raw_input ( '请输入用户名：' )       if  name  = =  "alex" ：      print  "超级管理员" elif  name  = =  "eric" :      print  "普通管理员" elif  name  = =  "tony"  or  name  = =  "rain" :      print  "业务主管" else :      print  "普通用户"

1五、while循环

一、基本循环

1 2 3 4 5 6

while  条件:            # 循环体        # 若是条件为真，那么循环体则执行      # 若是条件为假，那么循环体不执行

二、break

break用于退出全部循环

1 2 3 4

while  True :      print  "123"      break      print  "456"

三、continue

continue用于退出当前循环，继续下一次循环

1 2 3 4

while  True :      print  "123"      continue      print  "456"

 

1六、表达式if ... else

场景1、用户登录验证

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# 提示输入用户名和密码    # 验证用户名和密码 #     若是错误，则输出用户名或密码错误 #     若是成功，则输出 欢迎，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、猜年龄游戏

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

+ View Code

　　

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

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

 

1七、表达式for loop

最简单的循环10次

1 2 3 4 5 6

#_*_coding:utf-8_*_ __author__  =  'Alex Li'     for  i  in  range ( 10 ):      print ( "loop:" , i )

输出：

1 2 3 4 5 6 7 8 9 10

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

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

1 2 3 4

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

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

1 2 3 4

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

 

1八、while loop 　　

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

海枯石烂代码

1 2 3 4 5

count  =  0 while  True :      print ( "海枯石烂..." ,count)      count  + = 1

 

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

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

 

1 2 3 4 5 6 7 8

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

 

 

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#!/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 ( "猜这么屡次都不对,你个笨蛋." )

　　

 

1九、万恶的“＋”号

加号的做用是用在拼接一个较长的字符串，见下面例子：

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat hello.py 
#!/usr/bin/env    python
name = input('please input your name:')
age = input('please input your age:')
job = input('please input your job:')
salary = input('please input your salary:')
msg = '''
-------------info of '''+name+'''-----------------
    Name:'''+name+'''
    Age:''' +age+'''
    Job:'''+job+'''
    Salary:'''+salary
print (msg)

sean@sean-Parallels-Virtual-Platform:~/python/s14$ python hello.py 
please input your name:Sean
please input your age:28
please input your job:it
please input your salary:2999

-------------info of Sean-----------------
    Name:Sean
    Age:28
    Job:it
    Salary:2999

 20、字符串拼接

字符串凭借有不少种方法，我目前只知道有4种上面所说的万恶的加号是第一种也是最难用的一种，下面来介绍其他的三种

使用百分号“％”

sean@sean-Parallels-Virtual-Platform:~/python/s14$ python hello.py 
please input your name:XinZhiYu
please input your age:28
please input your job:It
please input your salary:90000

------------info of XinZhiYu-----------
Name: XinZhiYu
Age: 28
Job: It
Salary: 90000

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat hello.py 
#!/usr/bin/env    python
name = input('please input your name:')
age = input('please input your age:')
job = input('please input your job:')
salary = input('please input your salary:')
msg = '''
------------info of %s-----------
Name: %s
Age: %s
Job: %s
Salary: %s
'''%(name,name,age,job,salary)
print (msg)

使用format函数

　　听说有的时候只能使用这种格式，可是目前我还不知道那种状况下必须使用这种格式的字符串拼接

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat hello.py 
#!/usr/bin/env    python
name = input('please input your name:')
age = input('please input your age:')
job = input('please input your job:')
salary = input('please input your salary:')
msg = '''
------------info of {_name}-----------
Name: {_name}
Age: {_age}
Job: {_job}
Salary: {_salary}
'''.format(_name=name,_age=age,_job=job,_salary=salary)
print (msg)
sean@sean-Parallels-Virtual-Platform:~/python/s14$ python hello.py 
please input your name:Xinsir
please input your age:28
please input your job:It
please input your salary:29090

------------info of Xinsir-----------
Name: Xinsir
Age: 28
Job: It
Salary: 29090

依然是format函数可是这里使用｛0｝｛1｝。。。，不在使用变量

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat hello.py 
#!/usr/bin/env    python
name = input('please input your name:')
age = input('please input your age:')
job = input('please input your job:')
salary = input('please input your salary:')
msg = '''
------------info of {0}-----------
Name: {0}
Age: {1}
Job: {2}
Salary: {3}
'''.format(name,age,job,salary)
print (msg)
sean@sean-Parallels-Virtual-Platform:~/python/s14$ python hello.py 
please input your name:XiaoXin
please input your age:28
please input your job:IT
please input your salary:28765

------------info of XiaoXin-----------
Name: XiaoXin
Age: 28
Job: IT
Salary: 28765 

 

2一、for循环

　　for循环就是在指定的状况下循环指定次，往下看：

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat for.py  
#!/usr/bin/env    python
for i in range(5):
    print ('loop:',i)
sean@sean-Parallels-Virtual-Platform:~/python/s14$ python for.py 
loop: 0
loop: 1
loop: 2
loop: 3
loop: 4

　　for循环能够挨个循环，也能够跳着循环，上面是每一个循环，若是我想打印1-10之间的全部基数呢？继续看：

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat for.py 
#!/usr/bin/env    python
for i in range(1,10,2):
    print ('loop:',i)
sean@sean-Parallels-Virtual-Platform:~/python/s14$ python for.py 
loop: 1
loop: 3
loop: 5
loop: 7
loop: 9

2二、for...else...循环

　　for...else...循环就是当前面的循环正常执行完，没有跳出，后面的else将被执行

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat for.py  
#!/usr/bin/env    python
for i in range(5):
    print ('loop:',i)
else:
    print ('OK!')
sean@sean-Parallels-Virtual-Platform:~/python/s14$ python for.py 
loop: 0
loop: 1
loop: 2
loop: 3
loop: 4
OK!

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat for.py  
#!/usr/bin/env    python
for i in range(5):
    if i > 3:
        break
    print ('loop:',i)
else:
    print ('OK!')
sean@sean-Parallels-Virtual-Platform:~/python/s14$ python for.py 
loop: 0
loop: 1
loop: 2
loop: 3

 

2三、while...else...循环

　　功能和for...else...循环相差很少

sean@sean-Parallels-Virtual-Platform:~/python/s14$ python while.py 
0
1
2
3
4
5
sean@sean-Parallels-Virtual-Platform:~/python/s14$ vim while.py
sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat while.py 
#!/usr/bin/env    python
i = 0
while i < 10:
    if i > 5:
        break
    print (i)
    i += 1 
else:
    print ('ok')

---

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat while.py 
#!/usr/bin/env    python
i = 0
while i < 10:
    if i > 11:
        break
    print (i)
    i += 1 
else:
    print ('ok')
sean@sean-Parallels-Virtual-Platform:~/python/s14$ python while.py 
0
1
2
3
4
5
6
7
8
9
ok
sean@sean-Parallels-Virtual-Platform:~/python/s14$

 

2四、break 与 continue 区别  

 　　在循环里面若是遇到break函数那么就跳出本次循环，若是遇到continue函数那么就跳出本次循环

循环嵌套

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat for.py 
#!/usr/bin/env    python
i = 0
while i < 3:
    print ('while:',i)
    i += 1
    for x in range(0,3):
        print ('for:',x)
sean@sean-Parallels-Virtual-Platform:~/python/s14$ python for.py 
while: 0
for: 0
for: 1
for: 2
while: 1
for: 0
for: 1
for: 2
while: 2
for: 0
for: 1
for: 2

跳出多层循环

　　break智能跳出一次循环，可是若是循环嵌套循环，想一次性跳出2曾循环，那改怎么办呢？往下看：

sean@sean-Parallels-Virtual-Platform:~/python/s14$ cat for.py 
#!/usr/bin/env    python
i = 0
#定义一个跳出指示变量，当break_key等于true的时候，就告诉父循环跳出循环
break_key = 'false'
while i < 3:
    print ('while:',i)
    i += 1
    for x in range(0,3):
                ＃当内部循环等于2的时候，把外面的跳出指示变量设置为真
        if x == 2:
            break_key = 'true'
                        ＃跳出子循环
            break
        print ('for:',x)
    if break_key == 'true':
                ＃跳出父循环
        break
sean@sean-Parallels-Virtual-Platform:~/python/s14$ python for.py 
while: 0
for: 0
for: 1                

 

2五、Python的工做过程

一、python 把代码读到内存  二、词法语法分析 三、放到编译器  ---》 生成字节码   四、执行字节码 ---》生成机器码  CPU执行

2六、执行脚本传入参数

Python有大量的模块，从而使得开发Python程序很是简洁。类库有包括三中：
    Python内部提供的模块
    业内开源的模块
    程序员本身开发的模块
Python内部提供一个 sys 的模块，其中的 sys.argv 用来捕获执行执行python脚本时传入的参数

1 2 3 4 5 6

#!/usr/bin/env python # -*- coding: utf-8 -*-      import  sys      print  sys.argv

2七、pyc文件

执行Python代码时，若是导入了其余的 .py 文件，那么，执行过程当中会自动生成一个与其同名的 .pyc 文件，该文件就是Python解释器编译以后产生的字节码。

ps：代码通过编译能够产生字节码；字节码经过反编译也能够获得代码。（任何字节码经过反编译均可以获得代码）

2八、做业

做业一：博客

 https://i.cnblogs.com/EditPosts.aspx?postid=5712122

做业二：编写登录接口

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

#!/usr/bin/env/python
import sys,os,getpass

#os.system('clear')                             #清屏
i=0
while i < 3:                                   #只要用户异常登陆不超过3次，能够不断循环
    name = input('\33[32m请输入用户名：\33[37m')

    lock_file = open('user_lock_info.txt','a+')
    #当用户输入用户名后，打开锁定文件 检查此用户是否已经lock掉了
    lock_list = lock_file.readlines()           #按行的形式打开

    for lock_line in lock_list:                 #循环lock文件
        lock_line =lock_line.strip('\n')               #去掉换行符
        if name == lock_line:                          #若是lock，直接退出
            sys.exit('用户 %s 已经被锁定,退出！' % name)
    user_file = open('user_info.txt')        #打开帐号文件
    user_list = user_file.readlines()
    for user_line in user_list:               #对帐号文件进行循环匹配
        (user,password) = user_line.strip('\n').split()     #分别获取帐号、密码
        if name == user:                                    #若是用户名正常匹配
            a = 0
            while a < 3:                            #只要用户密码异常输入不超过3次就不断循环
                passwd = input('\33[32m请输入密码：\33[37m')    #输入密码，也能够作隐藏密码
                if passwd == password:                          #密码正确匹配，提示欢迎登陆
                    print('欢迎登录管理平台,用户 %s ！' % name)
                    sys.exit(0)                              #正常退出，调用系统退出命令
                else :
                    if a != 2:                       #a=2时，是最后一次机会，不会提示0次机会了
                        print('用户 %s 密码错误，请从新输入,还有 %d 次机会' % (name,2 - a))
                a += 1                                   #密码输错后，循环增长1
            else:
                lock_file.write(name + '\n')            #密码输错三次后，将该用户写入lock文件
                sys.exit('用户 %s 达到最大登录次数将被锁定退出' % name)
    else:
        if i != 2:                                  #i=2时，是最后一次机会，再也不提示0次机会了
            print ('用户 %s 不存在，请从新输入,还有 %d 次机会' % (name,2 -i))
    i += 1                                #当用户输错时，循环增长1
else:
        print('用户 %s 不存在，退出！' % name)      #用户输入3次错误后，异常退出
lock_file.close()                               #关闭lock文件
user_file.close()                               #关闭帐号、密码文件

 流程图

 

做业三：多级菜单

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

 http://www.tuicool.com/articles/ZV3YJfM

http://www.jb51.net/article/78358.htm