Python【第一篇】基础介绍

时间：2023-03-08 15:26:37
Python【第一篇】基础介绍

一、本节主要内容

  1. Python介绍
  2. 发展史
  3. Python 2 or 3?
  4. 安装
  5. Hello World程序
  6. 变量
  7. 用户输入
  8. 模块初识
  9. .pyc文件
  10. 数据类型初识
  11. 数据运算
  12. 表达式if ...else语句
  13. 表达式for 循环
  14. break and continue
  15. 表达式while 循环
  16. 编码问题

二、具体内容

1.python介绍

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

　　Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。自从20世纪90年代初Python语言诞生至今，它逐渐被广泛应用于处理系统管理任务和Web编程。Python已经成为最受欢迎的程序设计语言之一。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。自从2004年以后，python的使用率是呈线性增长。

　　由于Python语言的简洁、易读以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python教授程序设计课程。例如麻省理工学院的计算机科学及编程导论课程就使用Python语言讲授。众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库 ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别 为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数 据、制作图表，甚至开发科学计算应用程序。

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

目前Python主要应用领域：

  • 云计算: 云计算最火的语言， 典型应用OpenStack
  • WEB开发: 众多优秀的WEB框架，众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣，知乎等；典型WEB框架有Django，flask, tornado等;
  • 科学运算、人工智能: 典型库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的优缺点：

先看优点

  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.01s,用Python是0.1s,这样C语言直接比 Python快了10倍,算是非常夸张了，但是你是无法直接通过肉眼感知的，因为一个正常人所能感知的时间最小单位是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的存在，所以禁止多线程的并行执行。关于这个问题的折衷解决方法，我们在以后线程和进程章节里再进行详细探讨。

  4. 其他缺点：

    单行语句和命令行输出问题：很多时候不能将程序连写成一行，如import sys;for i in sys.path:print i。而perl和awk就无此限制，可以较为方便的在shell下完成简单程序，不需要如Python一样，必须将程序写入一个.py文件。

    独特的语法

    这也许不应该被称为局限，但是它用缩进来区分语句关系的方式还是给很多初学者带来了困惑。即便是很有经验的Python程序员，也可能陷入陷阱当中。最常见的情况是tab和空格的混用会导致错误，而这是用肉眼无法分别的。

    无类型?

    作为一种动态语言，随时随地创建和使用变量是Python给我们带来的巨大的便利。但是它也会使得程序不严谨，某些错误只有在运行中才可能出现。所以，使用Python编程的时候，要对类型做到心里有数。这也使得Python的IDE工具无法提供便利的自动完成等功能。

    关于“无类型”的说法，是完全错误的。一看就是不了解python的人写的。python是一种“强类型”“动态绑定”。

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

中文解释（装X必备）：

　　总而言之：Python 2.x是传统的，Python 3.x是python的现在和未来。个人推荐尽量用Python3。
　　Python 3.0于2008年发布。2.x版本中的最后一版2.7发布于2010年中，其中包含了python生命周期及其扩展的支持声明。 2.x分支将没有看到新的主要版本。 3.x正在积极开发中，已经有五年以上的稳定版本，包括2012年的3.3版本，2014年的3.4和2015年的3.5版本。这意味着所有最近的标准库改进默认在Python 3.x.

　　Guido van Rossum（Python语言的原创者）决定适当地清理Python 2.x，考虑其向后兼容性，而不是在2.x范围内的出新版本。最大的改进是更好的支持Unicode（所有文本字符串默认为Unicode）以及saner字节/ Unicode分离。

　　此外，核心语言的几个方面（例如print和exec是语句，使用floor division的整数）已经被调整为让新手学习起来更容易，并且与其余的语言更一致，并且旧的cruft已经被移除（例如，所有类现在都是新式的，“range（）”返回一个内存高效的迭代，而不是如2.x中的列表）。

py2与3的详细区别

PRINT IS A FUNCTION

　　print() 是一个函数

 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.: (您还可以自定义items之间的分隔符，例如：)

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

ALL IS UNICODE NOW(字符编码统一为Unicode)

从此不再为讨厌的字符编码而烦恼，还可以这样玩： (A,*REST,B)=RANGE(5)

 <strong>>>> a,*rest,b = range(5)

 >>> a,rest,b

 (0, [1, 2, 3], 4)

 </strong>

某些库改名了

Python【第一篇】基础介绍

4.python安装

windows下：

1、下载安装包

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

5、Hello World程序

在linux 下创建一个文件叫hello.py,并输入：print("Hello Word")保存后，命令行输入python hello.py即可。

windows下用IDE打开一个新窗口如图：

Python【第一篇】基础介绍

在交互式窗口中：

Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:01:18) [MSC v.1900 32 bit (Intel)] on win32

Type "copyright", "credits" or "license()" for more information.

>>> print("hello world!")

hello world!

>>>

6 变量

6.2Python 变量类型

变量：存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

6.3变量赋值

Python 中的变量赋值不需要类型声明。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号“=”用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

 #!/usr/bin/python

 # -*- coding: UTF-8 -*-

 counter = 100 # 赋值整型变量

 miles = 1000.0 # 浮点型

 name = "John" # 字符串

 print(counter)

 print(miles)

 print(name)

以上实例中，100，1000.0和"John"分别赋值给counter，miles，name变量。

执行以上程序会输出如下结果：

100

1000.0

John

6.4多个变量赋值

Python允许你同时为多个变量赋值。例如：a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

您也可以为多个对象指定多个变量。例如：a, b, c = 1, 2, "john"

以上实例，两个整型对象1和2的分配给变量a和b，字符串对象"john"分配给变量c。

7 用户输入

>>> age = input("请输入您的年龄：")

请输入您的年龄：23

>>>  

8 模块初识

本篇从现在开始用的是python2.x版本，如果要转换成3.X版本，请在print后加上()

8.1Python 模块

模块让你能够有逻辑地组织你的Python代码段。

把相关的代码分配到一个 模块里能让你的代码更好用，更易懂。

模块也是Python对象，具有随机的名字属性用来绑定或引用。

简单地说，模块就是一个保存了Python代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的代码。

例子

一个叫做aname的模块里的Python代码一般都能在一个叫aname.py的文件中找到。下例是个简单的模块support.py。

 def print_func(par):

    print("Hello : ", par)

    return

8.2 import 语句

想使用Python源文件，只需在另一个源文件里执行import语句，语法如下：

import module1[, module2[,... moduleN]

当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块support.py，需要把命令放在脚本的顶端：

 #!/usr/bin/python

 # -*- coding: UTF-8 -*-

 # 导入模块

 import support

 # 现在可以调用模块里包含的函数了

 support.print_func("Zara")

以上实例输出结果：Hello : Zara

一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

From…import 语句

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：from modname import name1[, name2[, ... nameN]]

例如，要导入模块fib的fibonacci函数，使用如下语句：from fib import fibonacci

这个声明不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入到执行这个声明的模块的全局符号表。

From…import* 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

定位模块

当你导入一个模块，Python解析器对模块位置的搜索顺序是：

  • 当前目录
  • 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
  • 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。

模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

PYTHONPATH变量

作为环境变量，PYTHONPATH由装在一个列表里的许多目录组成。PYTHONPATH的语法和shell变量PATH的一样。

在Windows系统，典型的PYTHONPATH如下：set PYTHONPATH=c:\python20\lib;

在UNIX系统，典型的PYTHONPATH如下：set PYTHONPATH=/usr/local/lib/python

命名空间和作用域

变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。

一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。

每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。

Python会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。

因此，如果要给全局变量在一个函数里赋值，必须使用global语句。

global VarName的表达式会告诉Python， VarName是一个全局变量，这样Python就不会在局部命名空间里寻找这个变量了。

例如，我们在全局命名空间里定义一个变量money。我们再在函数内给变量money赋值，然后Python会假定money是一个局部变量。然而，我们并没有在访问前声明一个局部变量money，结果就是会出现一个UnboundLocalError的错误。取消global语句的注释就能解决这个问题。

#!/usr/bin/python

# -*- coding: UTF-8 -*-

Money = 2000

def AddMoney():

   # 想改正代码就取消以下注释:

   # global Money

   Money = Money + 1

print (Money)

AddMoney()

print (Money)

dir()函数

dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：

 #!/usr/bin/python

 # -*- coding: UTF-8 -*-

 # 导入内置math模块

 import math

 content = dir(math)

 print(content)

以上实例输出结果：

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',

'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp',

'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',

'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',

'sqrt', 'tan', 'tanh']

在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。

globals()和locals()函数

根据调用地方的不同，globals()和locals()函数可被用来返回全局和局部命名空间里的名字。

如果在函数内部调用locals()，返回的是所有能在该函数里访问的命名。

如果在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字。

两个函数的返回类型都是字典。所以名字们能用keys()函数摘取。

reload()函数

当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。

因此，如果你想重新执行模块里顶层部分的代码，可以用reload()函数。该函数会重新导入之前导入过的模块。语法如下：

reload(module_name)

在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载hello模块，如下：

reload(hello)

Python中的包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的Python的应用环境。

考虑一个在Phone目录下的pots.py文件。这个文件有如下源代码：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

def Pots():

   print ("I'm Pots Phone")

同样地，我们有另外两个保存了不同函数的文件：

  • Phone/Isdn.py 含有函数Isdn()
  • Phone/G3.py 含有函数G3()

现在，在Phone目录下创建file __init__.py：

  • Phone/__init__.py

当你导入Phone时，为了能够使用所有函数，你需要在__init__.py里使用显式的导入语句，如下：

from Pots import Pots

from Isdn import Isdn

from G3 import G3

当你把这些代码添加到__init__.py之后，导入Phone包的时候这些类就全都是可用的了。

#!/usr/bin/python

# 导入 Phone 包

import Phone

Phone.Pots()

Phone.Isdn()

Phone.G3()

以上实例输出结果：

I'm Pots Phone

I'm 3G Phone

I'm ISDN Phone

如上，为了举例，我们只在每个文件里放置了一个函数，但其实你可以放置许多函数。你也可以在这些文件里定义Python的类，然后为这些类建一个包。

9 .pyc文件

9.1 Python是一门解释型语言？

　　很多人说，Python是一门解释性语言，我就这样一直相信下去，直到发现了*.pyc文件的存在。如果是解释型语言，那么生成的*.pyc文件是什么呢？c应该是compiled（编译）的缩写才对啊！

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

 

9.2 解释型语言和编译型语言 ？

计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。

这个过程分成两类，第一种是编译，第二种是解释。

编译型语言在程序执行之前，先会通过编译系统对程序执行一个“预处理、编译、汇编、链接”的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。

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

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

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

用Java来举例，Java首先是通过编译系统编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

9.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是一门先编译后解释的语言。

9.4 简述Python的运行过程

　　在说这个问题之前，我们先来说两个概念，PyCodeObject和.pyc文件。

　　我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了，继续向下看。

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

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

　　所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。

10 数据类型初识

10.1Python Number(数字)

Python Number 数据类型用于存储数值。数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1

var2 = 10

您也可以使用del语句删除一些 Number 对象引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

您可以通过使用del语句删除单个或多个对象，例如：

del var

del var_a, var_b
Python 支持四种不同的数值类型：
  • 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
  • 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
  • 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
  • 复数( (complex numbers)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
int long float complex
10 51924361L 0.0 3.14j
100 -0x19323L 15.20 45.j
-786 0122L -21.9 9.322e-36j
080 0xDEFABCECBDAECBFBAEl 32.3+e18 .876j
-0490 535633629843L -90. -.6545+0J
-0x260 -052318172735L -32.54e100 3e+26J
0x69 -4721885298529L 70.2-E12 4.53e-7j
  • 长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。
  • Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

10.2 Python Number 类型转换

int(x [,base ])         将x转换为一个整数

long(x [,base ])        将x转换为一个长整数

float(x )               将x转换到一个浮点数

complex(real [,imag ])  创建一个复数

str(x )                 将对象 x 转换为字符串

repr(x )                将对象 x 转换为表达式字符串

eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s )               将序列 s 转换为一个元组

list(s )                将序列 s 转换为一个列表

chr(x )                 将一个整数转换为一个字符

unichr(x )              将一个整数转换为Unicode字符

ord(x )                 将一个字符转换为它的整数值

hex(x )                 将一个整数转换为一个十六进制字符串

oct(x )                 将一个整数转换为一个八进制字符串

10.3 Python数学函数

函数 返回值 ( 描述 )
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。
min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。
modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) x**y 运算后的值。
round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x) 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

10.4Python随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

函数 描述
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random() 随机生成下一个实数，它在[0,1)范围内。
seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst) 将序列的所有元素随机排序
uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

10.5 Python三角函数

Python包括以下三角函数：

函数 描述
acos(x) 返回x的反余弦弧度值。
asin(x) 返回x的反正弦弧度值。  
atan(x) 返回x的反正切弧度值。
atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
cos(x) 返回x的弧度的余弦值。
hypot(x, y) 返回欧几里德范数 sqrt(x*x + y*y)。
sin(x) 返回的x弧度的正弦值。
tan(x) 返回x弧度的正切值。
degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x) 将角度转换为弧度

10.6 Python数学常量

常量 描述
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）。

11 数据运算

11.1 Python 运算符

什么是运算符？

本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中，4 和 5 被称为操作数，"+" 称为运算符。

Python语言支持以下类型的运算符:

  • 算术运算符
    比较（关系）运算符
    赋值运算符
    逻辑运算符
    位运算符
    成员运算符
    身份运算符
    运算符优先级

接下来让我们一个个来学习Python的运算符。

Python算术运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
+ 加 - 两个对象相加 a + b 输出结果 30
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 - x除以y b / a 输出结果 2
% 取模 - 返回除法的余数 b % a 输出结果 0
** 幂 - 返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000
// 取整除 - 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

以下实例演示了Python所有算术运算符的操作：

#!/usr/bin/python

a = 21

b = 10

c = 0

c = a + b

print ("1 - c 的值为：", c)

c = a - b

print ("2 - c 的值为：", c )

c = a * b

print ("3 - c 的值为：", c) 

c = a / b

print ("4 - c 的值为：", c )

c = a % b

print ("5 - c 的值为：", c)

# 修改变量 a 、b 、c

a = 2

b = 3

c = a**b

print ("6 - c 的值为：", c)

a = 10

b = 5

c = a//b

print ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 31

2 - c 的值为： 11

3 - c 的值为： 210

4 - c 的值为： 2

5 - c 的值为： 1

6 - c 的值为： 8

7 - c 的值为： 2

Python比较运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 true.
<> 不等于 - 比较两个对象是否不相等 (a <> b) 返回 true。这个运算符类似 != 。
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 true。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 true。

以下实例演示了Python所有比较运算符的操作：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

a = 21

b = 10

c = 0

if ( a == b ):

   print ("1 - a 等于 b")

else:

   print ("1 - a 不等于 b")

if ( a != b ):

   print ("2 - a 不等于 b")

else:

   print ("2 - a 等于 b")

if ( a <> b ):

   print ("3 - a 不等于 b")

else:

   print ("3 - a 等于 b")

if ( a < b ):

   print ("4 - a 小于 b" )

else:

   print ("4 - a 大于等于 b")

if ( a > b ):

   print ("5 - a 大于 b")

else:

   print ("5 - a 小于等于 b")

# 修改变量 a 和 b 的值

a = 5;

b = 20;

if ( a <= b ):

   print ("6 - a 小于等于 b")

else:

   print "6 - a 大于  b"

if ( b >= a ):

   print ("7 - b 大于等于 b")

else:

   print ("7 - b 小于 b")

以上实例输出结果：

1 - a 不等于 b

2 - a 不等于 b

3 - a 不等于 b

4 - a 大于等于 b

5 - a 大于 b

6 - a 小于等于 b

7 - b 大于等于 b

Python赋值运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a

以下实例演示了Python所有赋值运算符的操作：

#!/usr/bin/python

a = 21

b = 10

c = 0

c = a + b

print "1 - c 的值为：", c

c += a

print "2 - c 的值为：", c 

c *= a

print "3 - c 的值为：", c 

c /= a

print "4 - c 的值为：", c 

c = 2

c %= a

print "5 - c 的值为：", c

c **= a

print "6 - c 的值为：", c

c //= a

print "7 - c 的值为：", c

以上实例输出结果：

1 - c 的值为： 31

2 - c 的值为： 52

3 - c 的值为： 1092

4 - c 的值为： 52

5 - c 的值为： 2

6 - c 的值为： 2097152

7 - c 的值为： 99864

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13。

运算符 描述 实例
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111

以下实例演示了Python所有位运算符的操作：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

a = 60            # 60 = 0011 1100

b = 13            # 13 = 0000 1101

c = 0

c = a & b;        # 12 = 0000 1100

print "1 - c 的值为：", c

c = a | b;        # 61 = 0011 1101

print "2 - c 的值为：", c

c = a ^ b;        # 49 = 0011 0001

print "3 - c 的值为：", c

c = ~a;           # -61 = 1100 0011

print "4 - c 的值为：", c

c = a << 2;       # 240 = 1111 0000

print "5 - c 的值为：", c

c = a >> 2;       # 15 = 0000 1111

print "6 - c 的值为：", c

以上实例输出结果：

1 - c 的值为： 12

2 - c 的值为： 61

3 - c 的值为： 49

4 - c 的值为： -61

5 - c 的值为： 240

6 - c 的值为： 15

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符 逻辑表达式 描述 实例
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False

以上实例输出结果：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

a = 10

b = 20

if ( a and b ):

   print "1 - 变量 a 和 b 都为 true"

else:

   print "1 - 变量 a 和 b 有一个不为 true"

if ( a or b ):

   print "2 - 变量 a 和 b 都为 true，或其中一个变量为 true"

else:

   print "2 - 变量 a 和 b 都不为 true"

# 修改变量 a 的值

a = 0

if ( a and b ):

   print "3 - 变量 a 和 b 都为 true"

else:

   print "3 - 变量 a 和 b 有一个不为 true"

if ( a or b ):

   print "4 - 变量 a 和 b 都为 true，或其中一个变量为 true"

else:

   print "4 - 变量 a 和 b 都不为 true"

if not( a and b ):

   print "5 - 变量 a 和 b 都为 false，或其中一个变量为 false"

else:

   print "5 - 变量 a 和 b 都为 true"

以上实例输出结果：

1 - 变量 a 和 b 都为 true

2 - 变量 a 和 b 都为 true，或其中一个变量为 true

3 - 变量 a 和 b 有一个不为 true

4 - 变量 a 和 b 都为 true，或其中一个变量为 true

5 - 变量 a 和 b 都为 false，或其中一个变量为 false

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

以下实例演示了Python所有成员运算符的操作：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

a = 10

b = 20

list = [1, 2, 3, 4, 5 ];

if ( a in list ):

   print "1 - 变量 a 在给定的列表中 list 中"

else:

   print "1 - 变量 a 不在给定的列表中 list 中"

if ( b not in list ):

   print "2 - 变量 b 不在给定的列表中 list 中"

else:

   print "2 - 变量 b 在给定的列表中 list 中"

# 修改变量 a 的值

a = 2

if ( a in list ):

   print "3 - 变量 a 在给定的列表中 list 中"

else:

   print "3 - 变量 a 不在给定的列表中 list 中"

以上实例输出结果：

1 - 变量 a 不在给定的列表中 list 中

2 - 变量 b 不在给定的列表中 list 中

3 - 变量 a 在给定的列表中 list 中

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述 实例
is is是判断两个标识符是不是引用自一个对象 x is y, 如果 id(x) 等于 id(y) , is 返回结果 1
is not is not是判断两个标识符是不是引用自不同对象 x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1

以下实例演示了Python所有身份运算符的操作：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

a = 20

b = 20

if ( a is b ):

   print "1 - a 和 b 有相同的标识"

else:

   print "1 - a 和 b 没有相同的标识"

if ( id(a) == id(b) ):

   print "2 - a 和 b 有相同的标识"

else:

   print "2 - a 和 b 没有相同的标识"

# 修改变量 b 的值

b = 30

if ( a is b ):

   print "3 - a 和 b 有相同的标识"

else:

   print "3 - a 和 b 没有相同的标识"

if ( a is not b ):

   print "4 - a 和 b 没有相同的标识"

else:

   print "4 - a 和 b 有相同的标识"

以上实例输出结果：

1 - a 和 b 有相同的标识

2 - a 和 b 有相同的标识

3 - a 和 b 没有相同的标识

4 - a 和 b 没有相同的标识

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符 描述
** 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法减法
>> << 右移，左移运算符
& 位 'AND'
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符

以下实例演示了Python所有运算符优先级的操作：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

a = 20

b = 10

c = 15

d = 5

e = 0

e = (a + b) * c / d       #( 30 * 15 ) / 5

print "(a + b) * c / d 运算结果为：",  e

e = ((a + b) * c) / d     # (30 * 15 ) / 5

print "((a + b) * c) / d 运算结果为：",  e

e = (a + b) * (c / d);    # (30) * (15/5)

print "(a + b) * (c / d) 运算结果为：",  e

e = a + (b * c) / d;      #  20 + (150/5)

print "a + (b * c) / d 运算结果为：",  e

以上实例输出结果：

(a + b) * c / d 运算结果为： 90

((a + b) * c) / d 运算结果为： 90

(a + b) * (c / d) 运算结果为： 90

a + (b * c) / d 运算结果为： 50

12 Python 条件语句:  if ...else语句

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

可以通过下图来简单了解条件语句的执行过程:

Python【第一篇】基础介绍

Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。

Python 编程中 if 语句用于控制程序的执行，基本形式为：

if 判断条件：

    执行语句……

else：

    执行语句……


其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。


else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句，具体例子如下：




 #!/usr/bin/python

 # -*- coding: UTF-8 -*-

 # 例1：if 基本用法

 flag = False

 name = 'luren'

 if name == 'python':         # 判断变量否为'python'

     flag = True          # 条件成立时设置标志为真

     print 'welcome boss'    # 并输出欢迎信息

 else:

     print name              # 条件不成立时输出变量名称




输出结果为：


>>> luren			# 输出结果


if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。


当判断条件为多个值时，可以使用以下形式：




if 判断条件1:

    执行语句1……

elif 判断条件2:

    执行语句2……

elif 判断条件3:

    执行语句3……

else:

    执行语句4……




实例如下：




 #!/usr/bin/python

 # -*- coding: UTF-8 -*-

 # 例2：elif用法

 num = 5

 if num == 3:            # 判断num的值

     print 'boss'

 elif num == 2:

     print 'user'

 elif num == 1:

     print 'worker'

 elif num < 0:           # 值小于零时输出

     print 'error'

 else:

     print 'roadman'     # 条件均不成立时输出




输出结果为：


>>> roadman		# 输出结果


由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。




# 例3：if语句多个条件

num = 9

if num >= 0 and num <= 10:    # 判断值是否在0~10之间

    print 'hello'

>>> hello        # 输出结果

num = 10

if num < 0 or num > 10:    # 判断值是否在小于0或大于10

    print 'hello'

else:

    print 'undefine'

>>> undefine        # 输出结果

num = 8

# 判断值是否在0~5或者10~15之间

if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):

    print 'hello'

else:

    print 'undefine'

>>> undefine        # 输出结果




当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。


简单的语句组


你也可以在同一行的位置上使用if条件判断语句，如下实例：




#!/usr/bin/python

# -*- coding: UTF-8 -*-

var = 100 

if ( var  == 100 ) : print "变量 var 的值为100" 

print "Good bye!"




以上代码执行输出结果如下：


变量 var 的值为100

Good bye!


13 表达式for 循环


Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。


语法：


for循环的语法格式如下：




for iterating_var in sequence:

   statements(s)




流程图：


Python【第一篇】基础介绍


实例：




 #!/usr/bin/python

 # -*- coding: UTF-8 -*-

 for letter in 'Python':     # 第一个实例

    print '当前字母 :', letter

 fruits = ['banana', 'apple',  'mango']

 for fruit in fruits:        # 第二个实例

    print '当前字母 :', fruit

 print "Good bye!"




以上实例输出结果:


当前字母 : P

当前字母 : y

当前字母 : t

当前字母 : h

当前字母 : o

当前字母 : n

当前字母 : banana

当前字母 : apple

当前字母 : mango

Good bye!





通过序列索引迭代


另外一种执行循环的遍历方式是通过索引，如下实例：




#!/usr/bin/python

# -*- coding: UTF-8 -*-

fruits = ['banana', 'apple',  'mango']

for index in range(len(fruits)):

   print '当前水果 :', fruits[index]

print "Good bye!"




以上实例输出结果：


当前水果 : banana

当前水果 : apple

当前水果 : mango

Good bye!



以上实例我们使用了内置函数 len() 和 range(),函数 len() 返回列表的长度，即元素的个数。 range返回一个序列的数。




循环使用 else 语句


在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。


如下实例：




#!/usr/bin/python

# -*- coding: UTF-8 -*-

for num in range(10,20):  # 迭代 10 到 20 之间的数字

   for i in range(2,num): # 根据因子迭代

      if num%i == 0:      # 确定第一个因子

         j=num/i          # 计算第二个因子

         print '%d 等于 %d * %d' % (num,i,j)

         break            # 跳出当前循环

   else:                  # 循环的 else 部分

      print num, '是一个质数'




以上实例输出结果：


10 等于 2 * 5

11 是一个质数

12 等于 2 * 6

13 是一个质数

14 等于 2 * 7

15 等于 3 * 5

16 等于 2 * 8

17 是一个质数

18 等于 2 * 9

19 是一个质数


14 break and continue


Python break 语句


Python break语句，就像在C语言中，打破了最小封闭for或while循环。


break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。


break语句用在while和for循环中。


如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。


Python语言 break 语句语法：




break




流程图：


Python【第一篇】基础介绍


实例：




 #!/usr/bin/python

 for letter in 'Python':     # First Example

    if letter == 'h':

       break

    print 'Current Letter :', letter

 var = 10                    # Second Example

 while var > 0:

    print 'Current variable value :', var

    var = var -1

    if var == 5:

       break

 print "Good bye!"




以上实例执行结果：


Current Letter : P

Current Letter : y

Current Letter : t

Current variable value : 10

Current variable value : 9

Current variable value : 8

Current variable value : 7

Current variable value : 6

Good bye!



Python continue 语句


Python continue 语句跳出本次循环，而break跳出整个循环。


continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。


continue语句用在while和for循环中。


Python 语言 continue 语句语法格式如下：




continue




流程图：


Python【第一篇】基础介绍


实例：




 #!/usr/bin/python

 # -*- coding: UTF-8 -*-

 for letter in 'Python':     # 第一个实例

    if letter == 'h':

       continue

    print '当前字母 :', letter

 var = 10                    # 第二个实例

 while var > 0:

    var = var -1

    if var == 5:

       continue

    print '当前变量值 :', var

 print "Good bye!"




以上实例执行结果：


当前字母 : P

当前字母 : y

当前字母 : t

当前字母 : o

当前字母 : n

当前变量值 : 9

当前变量值 : 8

当前变量值 : 7

当前变量值 : 6

当前变量值 : 4

当前变量值 : 3

当前变量值 : 2

当前变量值 : 1

当前变量值 : 0

Good bye!


15 表达式while 循环


Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：




while 判断条件：

    执行语句……




执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。


当判断条件假false时，循环结束。


执行流程图如下：


Python【第一篇】基础介绍


实例：




 #!/usr/bin/python

 count = 0

 while (count < 9):

    print 'The count is:', count

    count = count + 1

 print "Good bye!"




以上代码执行输出结果:


The count is: 0

The count is: 1

The count is: 2

The count is: 3

The count is: 4

The count is: 5

The count is: 6

The count is: 7

The count is: 8

Good bye!


while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环.


此外"判断条件"还可以是个常值，表示循环必定成立，具体用法如下：




 # continue 和 break 用法

 i = 1

 while i < 10:

     i += 1

     if i%2 > 0:     # 非双数时跳过输出

         continue

     print i         # 输出双数2、4、6、8、10

 i = 1

 while 1:            # 循环条件为1必定成立

     print i         # 输出1~10

     i += 1

     if i > 10:     # 当i大于10时跳出循环

         break






无限循环


如果条件判断语句永远为 true，循环将会无限的执行下去，如下实例：




 #!/usr/bin/python

 # -*- coding: UTF-8 -*-

 var = 1

 while var == 1 :  # 该条件永远为true，循环将无限执行下去

    num = raw_input("Enter a number  :")

    print "You entered: ", num

 print "Good bye!"




以上实例输出结果：


Enter a number  :20

You entered:  20

Enter a number  :29

You entered:  29

Enter a number  :3

You entered:  3

Enter a number between :Traceback (most recent call last):

  File "test.py", line 5, in <module>

    num = raw_input("Enter a number :")

KeyboardInterrupt


注意：以上的无限循环你可以使用 CTRL+C 来中断循环。




循环使用 else 语句


在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。




#!/usr/bin/python

count = 0

while count < 5:

   print count, " is  less than 5"

   count = count + 1

else:

   print count, " is not less than 5"




以上实例输出结果为：


0 is less than 5

1 is less than 5

2 is less than 5

3 is less than 5

4 is less than 5

5 is not less than 5




简单语句组


类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中， 如下所示：




#!/usr/bin/python

flag = 1

while (flag): print 'Given flag is really true!'

print "Good bye!"




注意：以上的无限循环你可以使用 CTRL+C 来中断循环。


python编码问题：


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


　　python3.X 默认编码是UTF-8


ASCII GBK UNICODE UTF-8  简介和区别：


ASCII


　　ASCII（American Standard Code for Information Interchange，美国标准信息交换代码）。


　　我们知道，计算机只认识0和1，那么我们要怎么表示我们的语言和信息呢？计算机最先由米国发明，如果要用01表示语言，那么只需要表示出26个大小写字母，0-9，还有标点符号、特殊字符等就可以储存各种英文数字等信息了吧？所以，他们就用规定二进制的八位来表示一个字符，这八个位可以表示2的8次方种情况，每一种规定表示那个字符，就OK了。这个规定就是assii码表了，如下图。


Python【第一篇】基础介绍


　　结果他们发现只用127中情况，就把所有的字母数字字符都表示了，根本没用完2**8=256中情况，剩下的咋办？（留给其他国家表示他们的语言）


　　所以，ASCII表中1个字节就可以表示所有的英文所需要的字符。127个字符完全就可以表示所有英文中能用的的内容了。


GBK


　　但是ASCII到了中国之后，常用的中文都有6000多个，完全不够用啊！
		　　怎们办？中国人非常聪明：就在原有的扩展位中，扩展出自己的gbk、gb2312、gb2318字符编码。 
		　　他是怎么扩展的呢？比如说在ASCII码中的128这个位置，这个位置又指定一张单独表，聪明吧！ 其他国家也是这样设计的！


　　为了处理汉字，程序员设计了用于简体中文的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、GB2312、GBK 到GB18030，这些编码方法是向下兼容的，即同一个字符在这些方案中总是有相同的编码，后面的标准支持更多的字符。在这些编码中，英文和中文可以统一 地处理。区分中文编码的方法是高字节的最高位不为0。按照程序员的称呼，GB2312、GBK到GB18030都属于双字节字符集 (DBCS)。


　　有的中文Windows的缺省内码还是GBK，可以通过GB18030升级包升级到GB18030。不过GB18030相对GBK增加的字符，普通人是很难用到的，通常我们还是用GBK指代中文Windows内码。


UNICODE
	　　各个国家都在扩展，扩展位够不够？假设有两个国家都同时用一个扩展位，是不是会导致乱码？　　


　　基于这个乱象国际互联网组织就说你们各个国家都别搞了，我们给你们搞一个统一的，这个统一的是什么呢Unicode“万国编码”，Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。


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


　　这里还有个问题：使用的字节增加了，那么造成的直接影响就是使用的空间就直接翻倍了！
	　　举例还说：同样是ABCD这些字符存储一篇相同的文章，使用ASCII码如果是1M的话，那么Unicode存储至少2M可能还会更多。


UTF-8


　　为了解决上述问题就出现了:UTF-8编码
	　　UTF-8编码：是对Unicode编码的压缩和优化，他不再使用至少使用2个字节，而是将所有的字符和符号进行分类：
		　　ascii码中的内容用1个字节保存；
		　　欧洲的字符用2个字节保存；
		　　东亚的字符用3个字节保存...


本篇完。。。。
相关文章