Python之路3【第一篇】Python简介入门

Python介绍

一、Python的由来

1989年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。之所以选中Python作为程序的名字，是因为他是BBC电视剧——蒙提·派森的飞行马戏团（Monty Python‘s Flying Circus）的爱好者。

PS:ABC是由Guido参加设计的一种教学语言。就Guido本人看来，ABC 这种语言非常优美和强大，是专门为非专业程序员设计的。但是ABC语言并没有成功，究其原因，Guido 认为是非开放造成的。Guido 决心在Python 中避免这一错误。同时，他还想实现在ABC 中闪现过但未曾实现的东西。Python就这样诞生了！

二、什么是Python

Python（英国发音：/ pa θ n/ 美国发音：/ pa θɑ n/），是一种面向对象、直译式的计算机程序语言。和其他语言一样每一门语言都有自己的哲学思想。

Python的哲学思想就是：“优雅”、“明确”、“简单”

三、Python能做什么

相对于其他语言来说Python拥有：非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容等。许多功能不必从零编写，直接使用现成的即可。当然我们也可以写一些完善的程序插件供其他人使用！

Web程序

Python经常被用于Web开发。比如，通过mod_wsgi模块，Apache可以运行用Python编写的Web程序。使用Python语言编写的Gunicorn作为Web服务器，也能够运行Python语言编写的Web程序。Python定义了WSGI(Web Server Gateway Interface)标准应用接口来协调Http服务器与基于Python的Web程序之间的沟通。一些Web框架，如Django、Pyramid、TurboGears、Tornado、web2py、Zope、Flask等，可以让程序员轻松地开发和管理复杂的Web程序。

Python对于各种网络协议的支持很完善，因此经常被用于编写服务器软件、网络蠕虫。第三方库Twisted支持异步在线编写程序和多数标准的网络协议（包含客户端和服务器），并且提供了多种工具，被广泛用于编写高性能的服务器软件。另有gevent这个流行的第三方库，同样能够支持高性能高并发的网络开发。

GUI开发

Python本身包含的Tkinter库能够支持简单的GUI(Graphical User Interface)开发。但是越来越多的Python程序员选择wxPython或者PyQt等GUI包来开发跨平台的桌面软件。使用它们开发的桌面软件运行速度快，与用户的桌面环境相契合。通过PyInstaller还能将程序发布为独立的安装程序包。

操作系统

在很多操作系统里，Python是标准的系统组件。大多数Linux发布版以及NetBSD、OpenBSD和Mac OS X都集成了Python，可以在终端机下直接运行Python。有一些Linux发布版的安装器使用Python语言编写，比如Ubuntu的Ubiquity安装器、Red Hat Linux和Fedora的Anaconda安装器。Gentoo Linux使用Python来编写它的Portage包管理系统。Python标准库包含了多个调用作业系统功能的库。通过pywin32这个第三方软件包，Python能够访问Windows的COM服务及其它Windows API。使用IronPython，Python程序能够直接调用.Net Framework。

其他

NumPy、SciPy、Matplotlib可以让Python程序员编写科学计算程序。有些公司会使用Scons代替make构建C++程序。

很多游戏使用C++编写图形显示等高性能模块，而使用Python或者Lua编写游戏的逻辑、服务器。相较于Python，Lua的功能更简单、体积更小；而Python则支持更多的特性和数据类型。很多游戏，如EVE Online使用Python来处理游戏中繁多的逻辑。

YouTube、Google、Yahoo!、NASA都在内部大量地使用Python。OLPC的作业系统Sugar项目的大多数软件都是使用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是一门什么语言？

编程语言主要从以下几个角度进行分类：

编译型语言 & 解释型语言

静态语言 & 动态语言

强类型语言 & 弱类型语言

一、编译型语言 & 解释型语言

编译型语言：其实他和汇编语言是一样的，也是有一个负责翻译的程序来对我们的源代码进行转换，生成相对应的可执行代码。因为默认由程序员编写语言机器是不识别的需要一个编译的过程，这个编译的过程就是把程序员编写的程序编译成为机器可以识别的机器码！

解释型语言：上面解释了什么叫做编译型语言，通过字面意思可以看出解释和编译都有翻译的意思，那么它们两者的区别可以简单的理解为，翻译的时机不同！

举例来说：

拿一本外语书来说：
编译型语言就类似找一位专业的翻译人员来花时间把这本书完整的翻译一遍然后给你来读。

解释性语言就类似找一位专业的翻译人员来翻译一句给你讲一句。

在不考虑翻译的时间来说，就阅读效率上来说肯定是翻译完一整本之后看的比较快！

前者就相当于我们刚才说的编译型：一次把所有的代码转换成机器语言，然后写成可执行文件。

而后者就相当于我们要的节诶实行：在程序运行的前一刻， 还只有源程序而没有可执行程序；而程每执行到资源程序的某一条执行，则会有一个称之为解释程序的外壳程序，讲源代码转换成二进制代码以供执行，总而言之就 是不断的解释、执行、解释、执行。。。所以解释型语言是离不开解释程序的。

二、静态语言&动态语言

静态类型语言：静态类型语言，他的数据类型是在编译期间检查的，也就是说在写程序的时候要声明所有变量的数据类型，C/C++是静态类型的典型代表，其他的静态类型语言还有C#、JAVA等对于动态语言与静态语言的区分，套用一句比较流行的话是：Static typing when possible,dynamic typing when needed

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

三、强类型定义语言 & 弱类型定义语言

强类型定义语言：强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么他就永远是这个数据类型了。举个例子：如果你定义了一个整形变量a，那么程序根本不可能讲a当作字符串类型处理。强类型定义语言是类型安全的语言。

弱类型定义语言：数据类型可以被忽略的语言。他与强类型定义语言相反，一个变量可以赋予不同数据类型。

PS:

强类型定义语言在速度上可能略逊色与弱类型定义语言，但是他是强类型定义语言带来的严谨性能够有效便面许多错误，另外，“这么语言是不是动态语言”与“这么语言是否类型安全”之间是完全没有联系的。

例如：Python是动态语言，也是强类型定义语言（类型安全的语言）；VBScript是动态语言是弱类型定义语言（类型不安全的语言）；

JAVA是静态语言，是强类型定义语言（类型安全的语言）

Python种类

CPython

Python的官方版本，使用C语言实现，使用最为广泛，CPython实现会将源文件（py文件）转换成字节码文件（pyc文件），然后运行在Python虚拟机上

Jython

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

IronPython

Python的C#实现，IronPython将Python代码编译成C#字节码，然后在CLR上运行。（与Jython类似）

PyPy

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

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

Python环境配置

Windows

相对于之前的版本来说3.5在安装的时候直接选择：第一步add python to Path 选项就可以了。如果不可以参考2.7安装方法

2.7安装方法

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

MAC

相对来说简单双版本可以共存，直接去官网下载安装MAC版本的3.5即可。运行的时候直接运行python3 安装相关模块的时候直接pip3 模块名称

Python2 OR Python3

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

这里要说明下可以从上面看出来在2008年的时候同时发布了Python2.6 & Python2.7这是什么原因导致的呢?

在2008年的时候Python官方做了一个非常果断的决定发布Python3.0，让人们使用新的版本的Python来进行开发！里面有很多修改！并且不向下兼容，这就导致了一个问题。

比如我们家的网站是2.x编写的，但是如果想使用3.0那么之前的代码就完全不能用了需要重新开发，那耗费的人员和成本就非常庞大了，就有可能导致Python的使用人数下降和流失。

所以官方推出了一个过渡版本2.6 & 2.7 这里面包含了一些3.0的特性，给人们足够的时间进行升级至3.0

2、是选择Python2还是Python3

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

从上面可以看出结合他的发展史：Python2.7会被支持到2020年，并且官方还明确规定没有2.8版本！所以他是一个大趋势：3现在和为来的语言版本！

Python3并且做到化繁为简把重复的库和功能优化，使其更加的简洁

并且根据上面的说明终于不需要再为编码担心了默认他就是Unicode编码~ 并且移除了和新增了一些好用的东西~~

编程风格

一、语法要求
缩进统一：
同一级别的代码必须一致！(并且建议所有级别的代码的缩进建议是相同的--必须，开发规范里建议4个空格）建议不要用table因为如果想把代码在windows上运行，linux和windows的table的定义不同！！！！
好的编辑器能提高开发代码的效率！使用Pycharm会帮助你加快代码的编写。
所有python，第一行一定要顶到行头！ 同一级别的新的都要顶到行头。

二、变量
标识符的第一个字符必须是字母表中的字母（大写或小写）或者一个下划线（‘ _ ’）
标识符名称的其他部分可以由字母（大写或小写）、下划线（‘ _ ’）或数字（0-9）组成。
有效 标识符名称的例子有i、__my_name、name_23和a1b2_c3。
无效 标识符名称的例子有2things、this is spaced out和my-name。
标识符名称是对大小写敏感的。例如，myname和myName不是一个标识符。注意前者中的小写n和后者中的大写N。

常量：数值不变的
变量：数值会变动的量

在python中没有常量的，所有的数值都可以改变，但是他依然有个常量的概念，但是是人为的你不去改变他，定义一个常量应该用大写的形式。

AGE = 10 这个就是常量，他是大写的！是约定俗成的。但是他是可以改的！
name = 'Tim Luo' 这个是变量

##这里需要注意下，设置变量的时候不能设置python自带的内置方法比如type
以下关键字不能声明为变量名

1 ['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']

变量的起名的方式就是标识符名称，通过标识符去调用内存中的数据。

Python入门

一、第一句Python

1、我们前期写代码可以自进入Python的交互式模式下，在windows或者Linux下运行python就会进入到“交互式模式下”

>>> print('Hello World')
Hello World
>>>

2、还有以文件的形式来查看

vim hello.py 创建一个文件[linux下]

#!//usr/bin/env python

print "Hello World"

执行

python hello.py 即可

或者增加执行权限：chmod 755 hello.py
./hello.py

解释：

#!//usr/bin/env python   #脚本用env启动的原因，是因为脚本解释器在linux中可能被安装于不同的目录，env可以在系统的PATH目录中查找。同时，env还规定一些系统环境变量。env就是:envirnment 环境变量）

我们不需要指定编码类型了，因为在Python3中默认编码就是Unicode编码

二、Python的执行过程

把代码加载到内存中

词法分析

语法分析

编译生成字节码

执行字节码生成机器码为CPU可识别并执行

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

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

三、Python变量

1、字符串

字符串特性，一旦修改，重新创建！

字符串的值是不能被修改的，他在内存里是连续的，如果想改的话必须在后面预留所以不支持修改！

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'

name = 'luotianshuai'
print('The first variable==>:',id(name))

name = 'Tim'
print('The second variable==>:',id(name))

结果：

The first variable==>: 4323819824
The second variable==>: 4323772208

在看字符串的下个例子：

name1 = 'luotianshuai'
print(id(name1))

name2 = 'luotianshuai'
print(id(name2))

结果：

4323819824
4323819824

上面不是说：字符串特性，一旦修改，重新创建！为什么他的内存地址是相同的呢？

这里虽然他们的内存地址是相同的但是：他们的原理是各自在内存里开辟了一块内存空间，python给他进行了优化而已。有个池的概念（把你最常用的值做一个指向）！

2、列表、字典

看下面的例子：name1为1个列表，让name等于name1现在修改name1的值会影响name2吗？

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'

#给name1设置值为列表
name1 = ['tianshuai',18,]
#输出name1的内存地址
print('Thes name1 memory address:',id(name1))
#给name2复制为name1
name2 = name1
#输出name2的内存地址
print('Thes name2 memory address:',id(name2))

#修改name1的值看下name2的值是否改变
name1[0] = 'shuaige'

print(name1,'|',id(name1))
print(name2,'|',id(name2))

name2.append('dashuaige')

print(name1,'|',id(name1))
print(name2,'|',id(name2))

结果：

'''
Thes name1 memory address: 4314356360
Thes name2 memory address: 4314356360
['shuaige', 18] | 4314356360
['shuaige', 18] | 4314356360
['shuaige', 18, 'dashuaige'] | 4314356360
['shuaige', 18, 'dashuaige'] | 4314356360
'''

总结：集合中的元素不是连续的，当你修改、添加、删除里面的元素的时候内存地址是不变的！所以当我们删除添加name1里的元素的时候name2也会跟着变。

四、获取用户输入

Python 2有两个全局函数，用来在命令行请求用户输入。第一个叫做input()，它等待用户输入一个Python表达式(然后返回结果)。第二个叫做raw_input()用户输入什么它就返回什么。这让初学者非常困惑，并且这被广泛地看作是Python语言的一个“肉赘”(wart)。Python 3通过重命名raw_input()为input()，从而切掉了这个肉赘，所以现在的input()就像每个人最初期待的那样工作。

1、获取用户输入的内容

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'

name = input('Please input you name:')

print(name,'The value type',type(name))

并且这里需要注意这个input获取用户输入之后默认是字符串类型的如下：

Please input you name:123
123 The value type <class 'str'>

2、脚本传入参数

我们经常看到类似这样的命令:/etc/init.d/httpd start httpd脚本是怎么获取这个start参数呢？【这个httpd是shell写的主要这么写是方便回忆】Python中是怎么实现的呢？

通过Python自带的sys模块如下：

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'

import sys

print(sys.argv)
print(type(sys.argv))

结果：

LuoTimdeMacBook-Pro-2:Level_3_menu luotim$ python test.py 1 2 3 4 5 6 7 8 9
['test.py', '1', '2', '3', '4', '5', '6', '7', '8', '9']
<type 'list'>

五、流程控制

1、if...else 和 if....elif...elif..........else

需求一、身份验证

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'

import getpass

name = input('Please input your name:')
pwd = input('Please input your pwd:')

if name == 'tianshuai' and pwd == 'shuaige':
print('hello Shuaige')
else:
print('You cant login system')

测试：

'''
python3 test.py
Please input your name:tianshuai
Please input your pwd:shuaige
hello Shuaige
'''

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

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'
'''
alex 超级用户
wusir 管理用户
laoyao 普通用户
'''

name = input('Please input you name:')

if name == 'alex':
print('超级用户')
elif name == 'wusir':
print('管理用户')
elif name == 'laoyao':
print('普通用户')
else:
print('无效用户')

测试

LuoTimdeMacBook-Pro-2:Level_3_menu luotim$ python3 test.py
Please input you name:alex
超级用户
LuoTimdeMacBook-Pro-2:Level_3_menu luotim$ python3 test.py
Please input you name:wusir
管理用户
LuoTimdeMacBook-Pro-2:Level_3_menu luotim$ python3 test.py
Please input you name:laoyao
普通用户
LuoTimdeMacBook-Pro-2:Level_3_menu luotim$ python3 test.py
Please input you name:lskdjf
无效用户

2、for i in range(100) and for i in xrange(1,100)

需求：有3次机会，如果3次中没有猜中给予提示，3次都没有猜中，鼓励！

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'

import random
rand_num = random.randrange(10)

for i in range(3):
guess_num = int(input("请猜测数字(1~10)："))
if guess_num == rand_num:
print("太棒了你猜对了")
break
elif guess_num > rand_num:
print("你猜测的有点大了，请尝试小点的数字")
else:
print("你猜测的有点小了，请尝试大点的数字")
else:
print("不要灰心，这次只是运气不好，请下次尝试")

print("这个真正的数字是：%d" % rand_num)

测试结果1：

请猜测数字(1~10)：5
你猜测的有点大了，请尝试小点的数字
请猜测数字(1~10)：3
你猜测的有点大了，请尝试小点的数字
请猜测数字(1~10)：1
太棒了你猜对了
这个真正的数字是：1

测试结果2：

请猜测数字(1~10)：1
你猜测的有点小了，请尝试大点的数字
请猜测数字(1~10)：1
你猜测的有点小了，请尝试大点的数字
请猜测数字(1~10)：1
你猜测的有点小了，请尝试大点的数字
不要灰心，这次只是运气不好，请下次尝试
这个真正的数字是：2

3、while循环

他的原理是：当条件为真的时候运行，当条件为假的时候停止！

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'

import time

count = 0
#指定循环为True
while True:
#每次循环自加1
count += 1
#输出结果
print(count)
#休息两秒
time.sleep(2)
#这个循环就是死循环~

###############################
看看这个例子在
count = 0
#指定循环为True
while count < 10:
count += 1
print(count)
'''
每次循环加1，当count为11的时候那么这个条件：count < 10 就不成立了这个循环也就结束了！
'''

while版本的猜数字游戏

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'

import random

rand_num = random.randrange(10)
count = 0

while count < 3:
guess_num = int(input('请输入您猜测的数字(1~10):'))
if guess_num > 10:
print('您输入的数字超出范围了:1~10')
elif guess_num == rand_num:
print('哇~,太棒了你猜对了~')
break
elif guess_num < rand_num:
print('您猜的数字有点小了,请尝试大点的数字')
else:
print("你猜的数字有点大了，请尝试小点的数字")
count += 1
else:
print("不要灰心你，这次只是运气不好，请下次尝试")

print("这个真正的数字是：%d" % rand_num)

4、continue 是跳出本次循环，break是跳出整个循环(当前的while or for循环)！

for i in range(3):
count = 0
while True:
count += 1
if count == 10:
print('循环ID:%d' % count)
continue
if count == 11:
print('11次循环退出:')
break
print('这是第%d次循环' % count)
print(i)

上面的例子：

for循环中的while循环里如果为10的时候continue，那么print('这是第%d次循环' % count)就无法执行了，所以他停止了当前循环，当为11的时候print('这是第%d次循环' % count)也无法执行了并且跳出了整个大的while循环！

看下面的例子：

while True:
print("我是第一层")
while True:
print("我是第二层")
while True:
print("我是第三层")

现在我要停止他怎么办？这么写？

while True:
print("我是第一层")
break
while True:
print("我是第二层")
break
while True:
print("我是第三层")
break

NO，这个是不行的，这时候就用到标志位了！

需求：当count = 3 的时候所有循环依次退出

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luotianshuai'

count = 0

while True:
print('第一层')
level_1_falg = False
while True:
print('第二层')
level_2_flag = False
while True:
print('第三层')
count += 1
if count <= 3:
level_2_flag = True
print('这是第三层:循环3次了我要跳到第二层')
break
#当第三层退出到第二层后并且标志位被设置为True后下面的条件出发然后把level_1_falg设置为True
if level_2_flag:
level_1_falg = True
print('这是第二层:第三层跳出了,我也要跳到第一层')
break
#当第二层退出到第一层后并且标志位被设置为True后,下面的条件激活退出!
if level_1_falg:
print('这是第一层,第二层和第三层都跳出了我也要跳出,整个程序结束')
break

测试结果：

第一层
第二层
第三层
这是第三层:循环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

注：在Python2中默认是地板除，现在改为保留小数了，如果想使用地板除需要使用//

Python的比较操作符：

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

注：Python3中<>已经取消了这个所有不等于都使用!=

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

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

例子：
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
>>>