Python简介和入门

python简介：

一、什么是python

Python（英国发音：/ pa θ n/ 美国发音：/ pa θɑ n/），是一种面向对象、直译式的计算机程序语言。

每一门语言都有自己的哲学：

pythonde 设计哲学是：“优雅”、“明确”、“简单”

二、python由来

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

三、Python能做什么

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解释器内运行import this可以获得完整的列表

 

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

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

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

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

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

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

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

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

9.不要包容所有错误，除非你确定需要这样做（精准地捕获异常，不写 except:pass 风格的代码）

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

11.而是尽量找一种，最好是唯一一种明显的解决方案（如果不确定，就用穷举法）

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

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

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

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

 

PS：

简单的拿php和python做对比：

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

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

简单的拿C和python做对比：

Python慢，慢的严重，慢出风格，慢出自信！！！相同的程序Python比C慢几百倍很正常

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

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: 

1
2
3
4
5
6
7
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)!

编程风格

一、语法要求
–缩进统一
同一级别的代码必须一致！(并且建议所有级别的代码的缩进建议是相同的--必须，开发规范里建议4个空格）建议不要用table因为如果想把代码在windows上运行，linux和windows的table的定义不同！！！！
好的编辑器能提高开发代码的效率！
所有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

windows:

 

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

linux:

1
2
3
无需安装，原装Python环境
   
ps：如果自带2.6，请更新至2.7

 

 

 

 Python入门

 一、第一句python

 vim hello.py 创建一个文件

1
2
3
4
#!//usr/bin/env python
#-*- conding:utf-8 -*-
  
print "Hello World"

执行：

1
2
3
python hello.py 即可
或者增加执行权限：chmod 755 hello.py
./hello.py

解释：

1
2
1 #!//usr/bin/env python   #脚本用env启动的原因，是因为脚本解释器在linux中可能被安装于不同的目录，env可以在系统的PATH目录中查找。同时，env还规定一些系统环境变量。env就是:envirnment 环境变量）
2 # -*- coding: utf-8 -*- 指定编码类型为utf-8 (详情继续阅读)

二、编码 

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

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

显然ASCII码无法将世界上的各种文字和符号全部表示，所以，就需要新出一种可以代表所有字符和符号的编码，即：Unicode

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

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

所以，python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ascill），所以如果不指定编码类型，如果有中文就会报错。

三、Python的工作过程

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

四、执行脚本传入参数

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

五、pyc文件

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

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

六、变量

字符串的值是不能被修改的，他在内存里是连续的，如果想改的话必须在后面预留所以不支持修改！
字符串特性，一旦修改，重新创建
例子：

1
2
3
name1 = "JasonWang"
name2 = name1
这里然后把name1 = "James"

name2 变不变呢？其实是不变的结合上面的规则来：字符串特性，一旦修改，重新创建
name1 = "James" name1的值变了，他会重新开辟一块内存空间！

注：

1
2
name1 = "James"
name2 = "Jason"

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

集合又不相同：

1
2
>>> name1 = ['Jason','James','Lily'] 
>>> name2 = name1
>>> print name1

['Jason', 'James', 'Lily', 'aa']
>>> print name2
['Jason', 'James', 'Lily', 'aa']
>>>

name1 这个集合增加一个，现在name2 变不变呢？会变的集合和字符串不同他的各个元素不是连续的，所以name2=name1指向后，name1增加 一个元素不会开辟一块新的空间，name2就会跟着改变。

七、输入

1
2
3
4
5
6
#!/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

 

八. 模块初识

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

sys

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import sys
 
print(sys.argv)
 
 
#输出
$ python test.py helo world
['test.py', 'helo', 'world']  #把执行脚本时传递的参数获取到了

　　

os

1
2
3
4
5
6
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import os
 
os.system("df -h") #调用系统命令

完全结合一下　　

1
2
3
import os,sys
 
os.system(''.join(sys.argv[1:])) #把用户的输入的参数当作一条命令交给os.system来执行

自己写个模块

python tab补全模块

import sys
import readline
import rlcompleter

if sys.platform == 'darwin' and sys.version_info[0] == 2:
    readline.parse_and_bind("bind ^I rl_complete")
else:
    readline.parse_and_bind("tab: complete")  # linux and python3 on mac

for mac

 

写完保存后就可以使用了

1
2
3
4
5
localhost:$ 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环境变量列表。

　　

九、.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的一种持久化保存方式。

十、数据类型初识 

1、数字

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

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
 
2、布尔值
　　真或假
　　1 或 0
3、字符串
"hello world"
万恶的字符串拼接：
　　python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。
字符串格式化输出
1
2
3
4
name = "alex"
print "i am %s " % name
  
#输出: i am alex

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

字符串常用功能：
  • 移除空白
  • 分割
  • 长度
  • 索引
  • 切片
4、列表
创建列表：
1
2
3
name_list = ['alex', 'seven', 'eric']
或
name_list ＝ list(['alex', 'seven', 'eric'])

基本操作：

  • 索引
  • 切片
  • 追加
  • 删除
  • 长度
  • 切片
  • 循环
  • 包含
5、元组(不可变列表)
创建元组：
1
2
3
ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))
 
6、字典（无序）
创建字典：
1
2
3
person = {"name": "mr.wu", 'age': 18}
或
person = dict({"name": "mr.wu", 'age': 18})

常用操作：

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

十一、数据运算　　

算数运算：

比较运算：

赋值运算：

逻辑运算：

成员运算：

身份运算：

位运算：

运算符优先级：

更多内容：猛击这里

十二、流程控制

if...else      和   if....elif...elif..........else

需求一、用户身份认证

1
2
3
4
5
6
7
8
9
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import getpass
name = raw_input("请输入用户名：")
pwd = raw_input("请输入密码：")
if name == "tianshuai" and pwd == "123":
    print "登录成功"
else:
    print "登录失败"

测试：

1
2
3
4
5
6
7
8
9
root@localhost#: python guess.py
请输入用户名：Jason
请输入密码：
登录成功
root@localhost#:python guess.py
请输入用户名:Jason
请输入密码：
登录失败
root@localhost#:

 

 

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

需求一、猜数字游戏

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import random   #随机模块
rand_num = random.randrange(10)
  
for i in range(3):
    guess_num = int(raw_input("请猜测数字："))
    if guess_num == rand_num:
        print "太棒了你猜对了"
        break
    elif guess_num > rand_num:
        print "你猜测的有点大了，请尝试小点的数字"
    else:
        print "你猜测的有点小了，请尝试大点的数字"
else:
    print "不要灰心，这次只是运气不好，请下次尝试"
  
print "这个真正的数字是：%" % rand_num

输出结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
root@localhost# python guess1.py
请猜测数字：8
你猜测的有点大了，请尝试小点的数字
请猜测数字：7
你猜测的有点大了，请尝试小点的数字
请猜测数字：6
你猜测的有点大了，请尝试小点的数字
不要灰心，这次只是运气不好
root@localhsot# python guess1.py
请猜测数字：5
太棒了你猜对了
这个真正的数字是：5

十三、for and while循环

for loop

最简单的循环10次

1
2
3
4
5
6
#_*_coding:utf-8_*_
__author__ = 'JasonWang'
 
 
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 #不往下走了,直接进入下一次循环
    print("loop:", i )

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

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

 

while loop 　　

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

无限循环代码

1
2
3
4
5
count = 0
while True:
    print("looping...",count)
    count +=1
    

 

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

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

while 循环

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

没有一个规定次数，不设置条件永远循环下去。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import time
count = 0
while True:
    count +=1
    print "loop",count
    time.sleep(3)
#这个循环3秒钟自+1 ，后无线循环只要这个条件为”真“，就无限循环下去
那看下下面的例子
#!/usr/bin/env python
#-*- coding:utf-8 -*-
  
import time
cout = 0
  
while cout < 3:
    cout +=1
    print "runnig",cout
    time.sleep(3)
      
#这个循环每3秒循环一次，当条件cout < 3的时候为真（自己设置的条件），当cout 不小于3的时候为假(false)停止。

 

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
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#
import random
rand_num = random.randrange(10)
try_cout = 0
  
while try_cout < 3:
    guess_num = int(input("请输入猜测的数字："))
    if guess_num > 10:
        print "输入的数字超出范围了"
        continue
    if guess_num == rand_num:
        print "哇！太棒了你猜对了"
        break
    elif guess_num < rand_num:
        print "你猜的数字有点小了，请尝试大点的数字"
    else:
        print "你猜的数字有点大了，请尝试小点的数字"
  
    try_cout +=1
else:
    print "不要灰心你，这次只是运气不好，请下次尝试"
print "这个真正的数字是：%d"  % rand_num
#当执行到guess_num> 10 如果你输入的是大于10的数字那么将会执行continue,就会跳出档次循环，没有执行try_cout +=1 所以没有计数！

 

注：continue 是跳出当前循环，break是跳出整个循环！

有个需求，我想返回我的上层怎么做，用标识位！如下面的例子：

 

1
2
3
4
5
6
7
8
9
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#
while True:
    print "我是第一层"
    while True:
        print "我是第二层"
        while True:
            print "我是第三层"

这就是个死循环，当执行到第三个循环的时候就无限循环，这里有人回想，用break行不行，不行如下：

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#
while True:
    print "我是第一层"
    break
    while True:
        print "我是第二层"
        break
        while True:
            print "我是第三层"
            break

这个的输出结果：

1
2
root@localhost# python jason.py
我是第一层

就只执行了第一个循环就跳出，不我们想要的效果，那就用到“标志位”了，工作中也有很多地方用到他：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#
count = 0
while True:
    print "我是第一层"
    jump_1_flag = False
    while True:
        print "我是第二层"
        jump_2_flag = False
        while True:
            count += 1
            print "我是第三层"     
            if count > 3:
                jump_2_flag = True
                break
        if jump_2_flag:
            print "第三层跳到我这里来了，我也要跳到第一层"
            jump_1_flag = True
            break
          
    if jump_1_flag:
        print "第二层和第三层跳到第一层了，我也要跳"
        break

 

 

 

 

 

 

　

 

posted on 2016-05-10 18:39  Jason_wang_2016  阅读(355)  评论(0)  编辑  收藏  举报

导航