--********************************************************************************************************************************
--python 版本---解析器----------------------------------------------------------------------------
--********************************************************************************************************************************
--5-----------Python 工具-------------数据专家必知必会的 7 款 Python 工具-----------------------------------------------------------------------------
如果你有志于做一个数据专家，你就应该保持一颗好奇心，总是不断探索，学习，问各种问题。在线入门教程和视频教程能帮你走出第一步，但是最好的方式就是通过熟悉各种已经在生产环境中使用的工具而为成为一个真正的数据专家做好充分准备。
我咨询了我们真正的数据专家，收集整理了他们认为所有数据专家都应该会的七款 Python 工具。The Galvanize Data Science 和 GalvanizeU 课程注重让学生们花大量的时间沉浸在这些技术里。当你找第一份工作的时候，你曾经投入的时间而获得的对工具的深入理解将会使你有更大的优势。下面就了解它们一下吧:
--Tool1------IPython
IPython 是一个在多种编程语言之间进行交互计算的命令行 shell，最开始是用 python 开发的，提供增强的内省，富媒体，扩展的 shell 语法，tab 补全，丰富的历史等功能。IPython 提供了如下特性:
? 更强的交互 shell（基于 Qt 的终端）
? 一个基于浏览器的记事本，支持代码，纯文本，数学公式，内置图表和其他富媒体
? 支持交互数据可视化和图形界面工具
? 灵活，可嵌入解释器加载到任意一个自有工程里
? 简单易用，用于并行计算的高性能工具
由数据分析总监，Galvanize 专家 Nir Kaldero 提供。
--Tool2------GraphLab Greate
GraphLab Greate 是一个 Python 库，由 C++ 引擎支持，可以快速构建大型高性能数据产品。
这有一些关于 GraphLab Greate 的特点:
? 可以在您的计算机上以交互的速度分析以 T 为计量单位的数据量。
? 在单一平台上可以分析表格数据、曲线、文字、图像。
? 最新的机器学习算法包括深度学习，进化树和 factorization machines 理论。
? 可以用 Hadoop Yarn 或者 EC2 聚类在你的笔记本或者分布系统上运行同样的代码。
? 借助于灵活的 API 函数专注于任务或者机器学习。
? 在云上用预测服务便捷地配置数据产品。
? 为探索和产品监测创建可视化的数据。
由Galvanize数据科学家Benjamin Skrainka提供。
--Tool3------Pandas
pandas 是一个开源的软件，它具有 BSD 的开源许可，为 Python 编程语言提供高性能，易用数据结构和数据分析工具。在数据改动和数据预处理方面，Python 早已名声显赫，但是在数据分析与建模方面，Python 是个短板。Pands 软件就填补了这个空白，能让你用 Python 方便地进行你所有数据的处理，而不用转而选择更主流的专业语言，例如 R 语言。
整合了劲爆的 IPyton 工具包和其他的库，它在 Python 中进行数据分析的开发环境在处理性能，速度，和兼容方面都性能卓越。Pands 不会执行重要的建模函数超出线性回归和面板回归；对于这些，参考 statsmodel 统计建模工具和 scikit-learn 库。为了把 Python 打造成顶级的统计建模分析环境，我们需要进一步努力，但是我们已经奋斗在这条路上了。
由Galvanize 专家，数据科学家Nir Kaldero提供。
--Tool4------PuLP
线性编程是一种优化，其中一个对象函数被最大程度地限制了。PuLP 是一个用 Python 编写的线性编程模型。它能产生线性文件，能调用高度优化的求解器，GLPK，COIN CLP/CBC，CPLEX，和GUROBI，来求解这些线性问题。
由Galvanize 数据科学家Isaac Laughlin提供
--Tool5------Matplotlib
matplotlib 是基于 Python 的 2D（数据）绘图库，它产生（输出）出版级质量的图表，用于各种打印纸质的原件格式和跨平台的交互式环境。matplotlib 既可以用在 python 脚本, python 和 ipython 的 shell 界面 (ala MATLAB? 或 Mathematica?)，web 应用服务器，和6类 GUI 工具箱。
matplotlib 尝试使容易事情变得更容易，使困难事情变为可能。你只需要少量几行代码，就可以生成图表，直方图，能量光谱（power spectra），柱状图，errorcharts，散点图（scatterplots）等,。
为简化数据绘图，pyplot 提供一个类 MATLAB 的接口界面，尤其是它与 IPython 共同使用时。对于高级用户，你可以完全定制包括线型，字体属性，坐标属性等，借助面向对象接口界面，或项 MATLAB 用户提供类似（MATLAB）的界面。
Galvanize 公司的首席科学官Mike Tamir供稿。
--Tool6------Scikit-Learn
Scikit-Learn 是一个简单有效地数据挖掘和数据分析工具（库）。关于最值得一提的是，它人人可用，重复用于多种语境。它基于 NumPy，SciPy 和 mathplotlib 等构建。Scikit 采用开源的 BSD 授权协议，同时也可用于商业。Scikit-Learn 具备如下特性:
? 分类（Classification） – 识别鉴定一个对象属于哪一类别
? 回归（Regression） – 预测对象关联的连续值属性
? 聚类（Clustering） – 类似对象自动分组集合
? 降维（Dimensionality Reduction） – 减少需要考虑的随机变量数量
? 模型选择（Model Selection） –比较、验证和选择参数和模型
? 预处理（Preprocessing） – 特征提取和规范化
Galvanize 公司数据科学讲师，Isaac Laughlin提供
--Tool7------Spark
Spark 由一个驱动程序构成，它运行用户的 main 函数并在聚类上执行多个并行操作。Spark 最吸引人的地方在于它提供的弹性分布数据集（RDD），那是一个按照聚类的节点进行分区的元素的集合，它可以在并行计算中使用。RDDs 可以从一个 Hadoop 文件系统中的文件（或者其他的 Hadoop 支持的文件系统的文件）来创建，或者是驱动程序中其他的已经存在的标量数据集合，把它进行变换。用户也许想要 Spark 在内存中永久保存 RDD，来通过并行操作有效地对 RDD 进行复用。最终，RDDs 无法从节点中自动复原。
Spark 中第二个吸引人的地方在并行操作中变量的共享。默认情况下，当 Spark 在并行情况下运行一个函数作为一组不同节点上的任务时，它把每一个函数中用到的变量拷贝一份送到每一任务。有时，一个变量需要被许多任务和驱动程序共享。Spark 支持两种方式的共享变量: 广播变量，它可以用来在所有的节点上缓存数据。另一种方式是累加器，这是一种只能用作执行加法的变量，例如在计数器中和加法运算中。
由Galvanize 数据科学家 Benjamin Skrainka 提供。
如果您想对数据科学进行更深入了解，请点击进入我们的项目our data science giveaway来获取关于数据研讨会的入场券: 诸如PyData Seattle和Data Science Summit，或者获得 Python 资源的优惠，像: Effective Python和Data Science from Scratch。
--35-----------Python IDE/环境搭建----------------------------------------------------------------------------------------------------------------------------
本文为大家推荐几款款不错的 Python IDE（集成开发环境），比较推荐 PyCharm，当然你可以根据自己的喜好来选择适合自己的 Python IDE。
PyCharm
PyCharm 是由 JetBrains 打造的一款 Python IDE。
PyCharm 具备一般 Python IDE 的功能，比如: 调试、语法高亮、项目管理、代码跳转、智能提示、自动完成、单元测试、版本控制等。
另外，PyCharm 还提供了一些很好的功能用于 Django 开发，同时支持 Google App Engine，更酷的是，PyCharm 支持 IronPython。
PyCharm 官方下载地址: http://www.jetbrains.com/pycharm/download/
效果图查看:
Sublime Text
Sublime Text 具有漂亮的用户界面和强大的功能，例如代码缩略图，Python 的插件，代码段等。还可自定义键绑定，菜单和工具栏。
Sublime Text 的主要功能包括: 拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。
Sublime Text 是一个跨平台的编辑器，同时支持 Windows、Linux、Mac OS X等操作系统。
使用Sublime Text 2的插件扩展功能，你可以轻松的打造一款不错的 Python IDE，以下推荐几款插件（你可以找到更多）:
CodeIntel: 自动补全+成员/方法提示（强烈推荐）
SublimeREPL: 用于运行和调试一些需要交互的程序（E.G. 使用了Input()的程序）
Bracket Highlighter: 括号匹配及高亮
SublimeLinter: 代码pep8格式检查
Eclipse+Pydev
1、安装Eclipse
Eclipse可以在它的官方网站Eclipse.org找到并下载，通常我们可以选择适合自己的Eclipse版本，比如Eclipse Classic。下载完成后解压到到你想安装的目录中即可。
当然在执行Eclipse之前，你必须确认安装了Java运行环境,即必须安装JRE或JDK，你可以到（http://www.java.com/en/download/manual.jsp）找到JRE下载并安装。
2、安装Pydev
运行Eclipse之后，选择help-->Install new Software，如下图所示。
点击Add，添加pydev的安装地址: http://pydev.org/updates/，如下图所示。
Snap2
完成后点击"ok"，接着点击PyDev的"+"，展开PyDev的节点，要等一小段时间，让它从网上获取PyDev的相关套件，当完成后会多出PyDev的相关套件在子节点里，勾选它们然后按next进行安装。如下图所示。
安装完成后，重启Eclipse即可
3、设置Pydev
安装完成后，还需要设置一下PyDev，选择Window -> Preferences来设置PyDev。设置Python的路径，从Pydev的Interpreter - Python页面选择New
会弹出一个窗口让你选择Python的安装位置，选择你安装Python的所在位置。
完成之后PyDev就设置完成，可以开始使用。
4、建立Python Project:
安装好Eclipse+PyDev以后，我们就可以开始使用它来开发项目了。首先要创建一个项目，选择File -> New ->Pydev Project
会弹出一个新窗口，填写Project Name，以及项目保存地址，然后点击next完成项目的创建。
5、创建新的Pydev Module
光有项目是无法执行的，接着必须创建新的Pydev Moudle，选择File -> New -> Pydev Module
在弹出的窗口中选择文件存放位置以及Moudle Name，注意Name不用加.py，它会自动帮助我们添加。然后点击Finish完成创建。
Snap10
输入"hello world"的代码。
6、执行程序
程序写完后，我们可以开始执行程序,在上方的工具栏上面找到执行的按钮。
之后会弹出一个让你选择执行方式的窗口，通常我们选择Python Run，开始执行程序。
Snap14
更多 Python IDE
推荐10 款最好的 Python IDE: http://www.runoob.com/w3cnote/best-python-ide-for-developers.html
当然还有非常多很棒的 Python IDE，你可以自由的选择，更多 Python IDE 请参阅: http://wiki.python.org/moin/PythonEditors
Python2.x与3??.x版本区别 Python JSON
我觉得对于像我这样的初学者用户，python官方的IDLE就是一个挺不错的选择。
当然，IDLE其实也需要适应。
其实我挺早之前就安装过官方自带的，后来每次打开都是打开到shell，觉得这样学编程简直是太折磨了，就放弃；后来觉得还是要学习python，就又下载下来，这次倒是找到了IDLE，然后觉得这个IDE也太简陋了吧，写了几句，运行出了些错误，就觉得不想学了。
直到第三次，才找到了IDLE的感觉，知道怎么通过运行后的shell中的提示去修改编辑器中的代码，也知道怎么打开debuger模式，这个时候才觉得python自带的IDLE很适合自己。
另外，觉得IDLE的有一套主题，叫IDLE Dark，很好看，配上fixedsys字体，是我现在最棒的感觉。这部分没有什么代码可以贴，不过希望我的这些感受和经历能够让更多人喜欢python和python自带的IDLE
--1-----------Python 简介--------------------------------------------------------------------------------------------------------------------------------
Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。
Python由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。
像Perl语言一样, Python 源代码同样遵循 GPL(GNU General Public License)协议。
--34-----------Python 版本----------------------------------------------------------------------------------------------------------------------------
--Python的诞生
Python的创始人吉多·范罗苏姆（Guido van Rossum），在1989年12月的圣诞节期间，为了打发时间，决定开发一种新的脚本解释程序，作为ABC语言的继承。
现在，python以其优美，清晰，简单的特性在全世界广泛流行，成为最主流的编程语言之一。
截止至2016年7月，python在TIOBE流行编程语言排行榜，已经上升到第四名。并且从趋势图中可以看出其还在呈增长趋势。
--Python被广泛应用于众多领域
数据分析: 2016/2月/11，美国科学家宣布发现引力波，分析观测30年的数据。分析引力波数据的Python包: GWPY
云计算 : 典型应用——Python开发的OpenStack
WEB开发: 众多优秀的WEB框架，Django、flask、 tornado
科学运算、人工智能: 典型库NumPy, SciPy, Matplotlib, Enthought librarys,pandas。
系统运维: 运维人员必备，slatstack（系统自动化配置和管理工具），Ansible（自动化运维工具）
图形开发: wxPython、PyQT、TKinter
并且越来越多的公司选在python作为其主要开发语言，例如:
Google - Google Groups、Gmail、Google Maps、AlphaGo等，Google App Engine支持python作为开发语言
NASA - 美国宇航局，从1994年起把python作为主要开发语言
Dropbox - 美国最大的在线云存储网站，全部用Python实现，每天网站处理10亿个文件的上传和下载
豆瓣网 - 图书、唱片、电影等文化产品的资料数据库网站
BitTorrent - bt下载软件客户端
gedit - Linux平台的文本编辑器
GIMP - Linux平台的图像处理软件(Linux下的PS)
知乎（国外的Quora） - 社交问答网站，国内最大的问答社区，通过Python开发
Autodesk Maya - 3D建模软件，支持python作为脚本语言
YouTube:世界上最大的视频网站YouTube就是用Python开发的
Facebook:大量的基础库均通过Python实现的
Redhat: 世界上最流行的Linux发行版本中的yum包管理工具就是用python开发的
除上面之外，还有搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝 、土豆、新浪、果壳等公司都在使用Python完成各种各样的任务。
--Python发展史
1989年的圣诞节，Guido开始编写Python语言的编译器。Python这个名字，来自Guido所挚爱的电视剧Monty Python’s Flying Circus。他希望这个新的叫做Python的语言，能符合他的理想: 创造一种C和shell之间，功能全面，易学易用，可拓展的语言。
1991年，第一个Python编译器诞生。它是用C语言实现的，并能够调用C语言的库文件。从一出生，Python已经具有了: 类，函数，异常处理，包含表和词典在内的核心数据类型，以及模块为基础的拓展系统。
Python 1.0 - January 1994 增加了 lambda, map, filter and reduce.
1999年 Python的web框架之祖——Zope 1发布
Python 2.0 - 2000/10/16，加入了内存回收机制，构成了现在Python语言框架的基础
Python 2.4 – 2004/11/30, 同年目前最流行的WEB框架Django 诞生
Python 2.5 - 2006/09/19
Python 2.6 - 2008/10/1
Python 2.7 - 2010/07/03
Python 3.0 - 2008/12/03
Python 3.1 - 2009/06/27
Python 3.2 - 2011/02/20
Python 3.3 - 2012/09/29
Python 3.4 - 2014/03/16
Python 3.5 - 2015/09/13
2014年11月，Python2.7将在2020年停止支持的消息被发布，并且不会在发布2.8版本，建议用户尽可能的迁移到3.4+ Python最初发布时，在设计上有一些缺陷，比如Unicode标准晚于Python出现，所以一直以来对Unicode的支持并不完全，而ASCII编码支持的字符有限。例: 对中文支持不好Python3相对Python早期的版本是一个较大的升级，Py3在设计的时候没有考虑向下兼容，所以很多早期版本的Python的程序无法再Py3上运行。为了照顾早期的版本，推出过渡版本2.6——基本使用了Python 2.x的语法和库，同时考虑了向Python 3.0的迁移，允许使用部分Python 3.0的语法与函数。2010年继续推出了兼容版本2.7，大量Python3的特性被反向迁移到了Python2.7，2.7比2.6进步非常多，同时拥有大量3中的特性和库，并且照顾了原有的Python开发人群。
Python2还是Python3？
py2.7是2.x系列的最后一个版本，已经停止开发，不再增加新功能。2020年终止支持。所有的最新的标准库的更新改进，只会在3.x的版本里出现。Guido决定清理Python2.x ，并且不再兼容旧版本。
最大的一个改变就是使用Unicode作为默认编码。Pyhton2.x中直接写中文会报错，Python3中可以直接写中文了。从开源项目看，支持py3的比例已经大大提高，知名的项目一般都支持py2.7和py3+。
py3比py2更规范统一、去掉了没必要的关键字Python3.x还在持续改进。
所以我们还是推荐大家使用Python3.x。
Python的3??.0版本，常被称为Python 3000，或简称Py3k。相对于Python的早期版本，这是一个较大的升级。
为了不带入过多的累赘，Python 3.0在设计的时候没有考虑向下相容。
许多针对早期Python版本设计的程式都无法在Python 3.0上正常执行。
为了照顾现有程式，Python 2.6作为一个过渡版本，基本使用了Python 2.x的语法和库，同时考虑了向Python 3.0的迁移，允许使用部分Python 3.0的语法与函数。
新的Python程式建议使用Python 3.0版本的语法。
除非执行环境无法安装Python 3.0或者程式本身使用了不支援Python 3.0的第三方库。目前不支援Python 3.0的第三方库有Twisted, py2exe, PIL等。
大多数第三方库都正在努力地相容Python 3.0版本。即使无法立即使用Python 3.0，也建议编写相容Python 3.0版本的程式，然后使用Python 2.6, Python 2.7来执行。
Python 3.0的变化主要在以下几个方面:
print 函数
print语句没有了，取而代之的是print()函数。 Python 2.6与Python 2.7部分地支持这种形式的print语法。在Python 2.6与Python 2.7里面，以下三种形式是等价的:
print "fish"
print ("fish") #注意print后面有个空格
print("fish") #print()不能带有任何其它参数
然而，Python 2.6实际已经支持新的print()语法:
from __future__ import print_function
print("fish", "panda", sep=', ')
Unicode
Python 2 有 ASCII str() 类型，unicode() 是单独的，不是 byte 类型。
现在， 在 Python 3，我们最终有了 Unicode (utf-8) 字符串，以及一个字节类: byte 和 bytearrays。
由于 Python3.X 源码文件默认使用utf-8编码，这就使得以下代码是合法的:
>>> 中国 = 'china'
>>>print(中国)
china
Python 2.x
>>> str = "我爱北京天安门"
>>> str
'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8'
>>> str = u"我爱北京天安门"
>>> str
u'\u6211\u7231\u5317\u4eac\u5929\u5b89\u95e8'
Python 3.x
>>> str = "我爱北京天安门"
>>> str
'我爱北京天安门'
除法运算
Python中的除法较其它语言显得非常高端，有套很复杂的规则。Python中的除法有两个运算符，/和//
首先来说/除法:
在python 2.x中/除法就跟我们熟悉的大多数语言，比如Java啊C啊差不多，整数相除的结果是一个整数，把小数部分完全忽略掉，浮点数除法会保留小数点的部分得到一个浮点数的结果。
在python 3.x中/除法不再这么做了，对于整数之间的相除，结果也会是浮点数。
Python 2.x:
>>> 1 / 2
0
>>> 1.0 / 2.0
0.5
Python 3.x:
>>> 1/2
0.5
而对于//除法，这种除法叫做floor除法，会对除法的结果自动进行一个floor操作，在python 2.x和python 3.x中是一致的。
python 2.x:
>>> -1 // 2
-1
python 3.x:
>>> -1 // 2
-1
注意的是并不是舍弃小数部分，而是执行floor操作，如果要截取小数部分，那么需要使用math模块的trunc函数
python 3.x:
>>> import math
>>> math.trunc(1 / 2)
0
>>> math.trunc(-1 / 2)
0
异常
在 Python 3 中处理异常也轻微的改变了，在 Python 3 中我们现在使用 as 作为关键词。
捕获异常的语法由 except exc, var 改为 except exc as var。
使用语法except (exc1, exc2) as var可以同时捕获多种类别的异常。 Python 2.6已经支持这两种语法。
1. 在2.x时代，所有类型的对象都是可以被直接抛出的，在3.x时代，只有继承自BaseException的对象才可以被抛出。
2. 2.x raise语句使用逗号将抛出对象类型和参数分开，3.x取消了这种奇葩的写法，直接调用构造函数抛出对象即可。
在2.x时代，异常在代码中除了表示程序错误，还经常做一些普通控制结构应该做的事情，在3.x中可以看出，设计者让异常变的更加专一，只有在错误发生的情况才能去用异常捕获语句来处理。
xrange
在 Python 2 中 xrange() 创建迭代对象的用法是非常流行的。比如: for 循环或者是列表/集合/字典推导式。
这个表现十分像生成器（比如。"惰性求值"）。但是这个 xrange-iterable 是无穷的，意味着你可以无限遍历。
由于它的惰性求值，如果你不得仅仅不遍历它一次，xrange() 函数 比 range() 更快（比如 for 循环）。尽管如此，对比迭代一次，不建议你重复迭代多次，因为生成器每次都从头开始。
在 Python 3 中，range() 是像 xrange() 那样实现以至于一个专门的 xrange() 函数都不再存在（在 Python 3 中 xrange() 会抛出命名异常）。
import timeit
n = 10000
def test_range(n):
return for i in range(n):
pass
def test_xrange(n):
for i in xrange(n):
pass
Python 2
print 'Python', python_version()
print '\ntiming range()'
%timeit test_range(n)
print '\n\ntiming xrange()'
%timeit test_xrange(n)
Python 2.7.6
timing range()
1000 loops, best of 3: 433 μs per loop
timing xrange()
1000 loops, best of 3: 350 μs per loop
Python 3
print('Python', python_version())
print('\ntiming range()')
%timeit test_range(n)
Python 3.4.1
timing range()
1000 loops, best of 3: 520 μs per loop
print(xrange(10))
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-5-5d8f9b79ea70> in <module>()
----> 1 print(xrange(10))
NameError: name 'xrange' is not defined
八进制字面量表示
八进制数必须写成0o777，原来的形式0777不能用了；二进制必须写成0b111。
新增了一个bin()函数用于将一个整数转换成二进制字串。 Python 2.6已经支持这两种语法。
在Python 3.x中，表示八进制字面量的方式只有一种，就是0o1000。
python 2.x
>>> 0o1000
512
>>> 01000
512
python 3.x
>>> 01000
File "<stdin>", line 1
01000
^
SyntaxError: invalid token
>>> 0o1000
512
不等运算符
Python 2.x中不等于有两种写法 != 和 <>
Python 3.x中去掉了<>, 只有!=一种写法，还好，我从来没有使用<>的习惯
去掉了repr表达式``
Python 2.x 中反引号``相当于repr函数的作用
Python 3.x 中去掉了``这种写法，只允许使用repr函数，这样做的目的是为了使代码看上去更清晰么？不过我感觉用repr的机会很少，一般只在debug的时候才用，多数时候还是用str函数来用字符串描述对象。
def sendMail(from_: str, to: str, title: str, body: str) -> bool:
pass
多个模块被改名（根据PEP8）
旧的名字 新的名字
_winreg winreg
ConfigParser configparser
copy_reg copyreg
Queue queue
SocketServer socketserver
repr reprlib
StringIO模块现在被合并到新的io模组内。 new, md5, gopherlib等模块被删除。 Python 2.6已经支援新的io模组。
httplib, BaseHTTPServer, CGIHTTPServer, SimpleHTTPServer, Cookie, cookielib被合并到http包内。
取消了exec语句，只剩下exec()函数。 Python 2.6已经支援exec()函数。
5.数据类型
1）Py3.X去除了long类型，现在只有一种整型——int，但它的行为就像2.X版本的long
2）新增了bytes类型，对应于2.X版本的八位串，定义一个bytes字面量的方法如下:
>>> b = b'china'
>>> type(b)
<type 'bytes'>
str对象和bytes对象可以使用.encode() (str -> bytes) or .decode() (bytes -> str)方法相互转化。
>>> s = b.decode()
>>> s
'china'
>>> b1 = s.encode()
>>> b1
b'china'
3）dict的.keys()、.items 和.values()方法返回迭代器，而之前的iterkeys()等函数都被废弃。同时去掉的还有 dict.has_key()，用 in替代它吧 。
打开文件
原:
file( ..... )
或
open(.....)
改为只能用
open(.....)
从键盘录入一个字符串
原: raw_input( "提示信息" )
改为: input( "提示信息" )
在python2.x中raw_input()和input( )，两个函数都存在，其中区别为:
raw_input()---将所有输入作为字符串看待，返回字符串类型
input()-----只能接收"数字"的输入，在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（int, float ）
在python3.x中raw_input()和input( )进行了整合，去除了raw_input()，仅保留了input()函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。
--********************************************************************************************************************************
--python执行原理----------------------------------------------------------------------------
--********************************************************************************************************************************
--Python 虚拟机
demo.py 被编译后，接下来的工作就交由 Python 虚拟机来执行字节码指令了。
Python 虚拟机会从编译得到的 PyCodeObject 对象中依次读入每一条字节码指令，并在当前的上下文环境中执行这条字节码指令。我们的程序就是通过这样循环往复的过程才得以执行。
--模块py
Python 将 .py 文件视为一个 module，这些 module 中，有一个主 module，也就是程序运行的入口。在这个例子中，主 module 是 demo.py。
--编译
执行 python demo.py 后，将会启动 Python 的解释器，然后将 demo.py 编译成一个字节码对象 PyCodeObject。
有的人可能会很好奇，编译的结果不应是 pyc 文件吗，就像 Java 的 class 文件，那为什么是一个对象呢，这里稍微解释一下。
在 Python 的世界中，一切都是对象，函数也是对象，类型也是对象，类也是对象（类属于自定义的类型，在 Python 2.2 之前，int, dict 这些内置类型与类是存在不同的，在之后才统一起来，全部继承自 object），甚至连编译出来的字节码也是对象，.pyc 文件是字节码对象（PyCodeObject）在硬盘上的表现形式。
在运行期间，编译结果也就是 PyCodeObject 对象，只会存在于内存中，而当这个模块的 Python 代码执行完后，就会将编译结果保存到了 pyc 文件中，这样下次就不用编译，直接加载到内存中。pyc 文件只是 PyCodeObject 对象在硬盘上的表现形式。
这个 PyCodeObject 对象包含了 Python 源代码中的字符串，常量值，以及通过语法解析后编译生成的字节码指令。PyCodeObject 对象还会存储这些字节码指令与原始代码行号的对应关系，这样当出现异常时，就能指明位于哪一行的代码。
--pyc 文件
Python 只会对那些以后可能继续被使用和载入的模块才会生成 pyc 文件，Python 认为使用了 import 指令的模块，属于这种类型，因此会生成 pyc 文件。而对于只是临时用一次的模块，并不会生成 pyc 文件，Python 将主模块当成了这种类型的文件。这就解释了为什么 python demo.py 执行完后，只会生成一个 foo.pyc 文件。
如果要问 pyc 文件什么时候生成，答案就是在执行了 import 指令之后，from xx import yy 同样属于 import 指令。
一个 pyc 文件包含了三部分信息: Python 的 magic number、pyc 文件创建的时间信息，以及 PyCodeObject 对象。
magic number 是 Python 定义的一个整数值。一般来说，不同版本的 Python 实现都会定义不同的 magic number，这个值是用来保证 Python 兼容性的。比如要限制由低版本编译的 pyc 文件不能让高版本的 Python 程序来执行，只需要检查 magic number 不同就可以了。由于不同版本的 Python 定义的字节码指令可能会不同，如果不做检查，执行的时候就可能出错。
下面所示的代码可以来创建 pyc 文件，使用方法
python generate_pyc.py module_name
例如
python generate_pyc.py demo
[generate_pyc.pyc] import imp import sys def generate_pyc(name): fp, pathname, description = imp.find_module(name) try: imp.load_module(name, fp, pathname, description) finally: if fp: fp.close() if __name__ == '__main__': generate_pyc(sys.argv[1])
--字节码指令
为什么 pyc 文件也称作字节码文件？因为这些文件存储的都是一些二进制的字节数据，而不是能让人直观查看的文本数据。
Python 标准库提供了用来生成代码对应字节码的工具 dis。dis 提供一个名为 dis 的方法，这个方法接收一个 code 对象，然后会输出 code 对象里的字节码指令信息。
s = open('demo.py').read() co = compile(s, 'demo.py', 'exec') import dis dis.dis(co)
执行上面这段代码可以输出 demo.py 编译后的字节码指令
1 0 LOAD_CONST 0 (-1) 3 LOAD_CONST 1 (None) 6 IMPORT_NAME 0 (foo) 9 STORE_NAME 0 (foo) 3 12 LOAD_CONST 2 (1) 15 LOAD_CONST 3 (u'python') 18 BUILD_LIST 2 21 STORE_NAME 1 (a) 4 24 LOAD_CONST 4 (u'a string') 27 STORE_NAME 1 (a) 6 30 LOAD_CONST 5 (<code object func at 00D97650, file "demo.py", line 6>) 33 MAKE_FUNCTION 0 36 STORE_NAME 2 (func) 11 39 LOAD_NAME 1 (a) 42 PRINT_ITEM 43 PRINT_NEWLINE 13 44 LOAD_NAME 3 (__name__) 47 LOAD_CONST 6 (u'__main__') 50 COMPARE_OP 2 (==) 53 POP_JUMP_IF_FALSE 82 14 56 LOAD_NAME 2 (func) 59 CALL_FUNCTION 0 62 POP_TOP 15 63 LOAD_NAME 0 (foo) 66 LOAD_ATTR 4 (add) 69 LOAD_CONST 2 (1) 72 LOAD_CONST 7 (2) 75 CALL_FUNCTION 2 78 POP_TOP 79 JUMP_FORWARD 0 (to 82) >> 82 LOAD_CONST 1 (None) 85 RETURN_VALUE
--Python的优点---任何语言都有其优缺点，python也不例外
1.Python的定位是“优雅”、“明确”、“简单”，所以Python程序看上去总是简单易懂，初学者学Python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程序。
2.开发效率非常高，Python有非常强大的第3方库，基本上想通过计算机实现任何功能，Python官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上再进行开发，大大降低开发周期，避免重复造轮子
3. 高级语言————当用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节
4.可移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。如果小心地避免使用依赖于系统的特性，那么你的所有Python程序无需修改就几乎可以在市场上所有的系统平台上运行
5. 可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。
6. 可嵌入性————你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能
--Python的缺点
1.代码不能加密 因为PYTHON是解释性语言，它的源码都是以明文形式存放的，不过我不认为这算是一个缺点，如果你的项目要求源代码必须是加密的，那你一开始就不应该用Python来去实现。
2.多线程支持不好
3.Python慢 Python相对C语言确实慢很多，但其实这里所指的速度慢在大多数时候我们是无法感知的，比如说，是用C语言程序开发了一个程序，执行需要花0.01秒，使用Python实现同样功能的程序，需要花0.1秒
的时间，虽然相差10倍，但是我们基本是感知不到的。更多的时候，程序慢是程序员实现功能方式导致的。就好像开罐头的时候，有的人用牙咬，有的人用工具，这样两个人的效率相比起来就差了很多。
我曾经听过一句话，语言本身的快慢差距并不能被我们体会出来，真正让我们体会出差距的是用语言的人。
--Python的解释器---很多--使用最广泛CPython
如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。
本教程的所有代码只确保在CPython 2.7版本下运行。请务必在本地安装CPython（也就是从Python官方网站下载的安装程序）。
此外，教程还内嵌一个IPython的Web版本，用来在浏览器内练习执行一些Python代码。要注意两者功能一样，输入的代码一样，但是提示符有所不同。另外，不是所有代码都能在Web版本的IPython中执行，出于安全原因，很多操作（比如文件操作）是受限的，所以有些代码必须在本地环境执行代码。
1.Cpython Python的官方版本，使用C语言开发实现，CPython实现会将源文件（py文件）转换成字节码文件（pyc文件），然后运行在Python虚拟机上。在命令行下运行python就是启动CPython解释器。
2.Jython Python的Java实现，Jython会将Python代码动态编译成Java字节码，然后在JVM上运行。是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。
3.IronPython Python的C#实现，与Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成C#的字节码，然后在CLR上运行。
4.PyPy Python实现的Python，将Python的字节码，再编译成机器码。可能会是Python的未来，它的目标是执行速度。能够大大加快Python程序的运行速度，
PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。
绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。
5.RubyPython
6.Brython ...
7.IPython是基于CPython之上的一个交互式解释器，也即，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。
CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。
如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。
当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。
由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以编写Python解释器来执行Python代码（当然难度很大）。事实上，确实存在多种Python解释器。
--Python解释执行原理及过程
谈到了Python语句的2种执行方式，实际上，这两种运行方式在本质 上是相同的，它们都是由解释器来解释执行我们提供的Python语句。
这里所说的解释执行是相对于编译执行而言的。我们知道，使用诸如 C或C++之类的编译性语言编写的程序可以从源文件转换成计算机使用 的机器语言， 经连接器连接后形成二进制可执行文件。当我们运行二进制可执行程 序的时候，因为已经编译好了，所以加载器软件把二进制程序从硬盘 载入内存中并运行。
与之不同，Python语言写的程序不需要编译成二进制代码，它可以直 接从源代码运行程序。当我们运行Python文件程序的时候， Python解释器把源代码转换成中间形式: 字节码，然后再由Python虚 拟机来执行这些字节码，如图5所示。 这样的话，我们就用不着担心程序的编译，库的连接加载等问题了， 所有这些工作都由Python虚拟机代劳了。 对于Python的解释语言特性，我们要一分为二的看待。一方面，每次 运行时都要进行转换成 字节码，然后再由虚拟机把字节码转换成机器语言，最后才能在硬件 上运行。较之于编译性 编程 语言，每次运行都会多出两道工序，所以它的性能会受到影响。另一 方面，由于不用关心程 序的编译以及库的连接等问题，所以开发工作会变得更轻松；同时虚 拟机距离物理机器更远 了， 所以Python程序更加易于移植，实际上无需改动就能在多种平台上运 行。
1. 在具体计算机上实现一种语言，首先要确定的是表示该语言语义解释 的虚拟计算机，一个关键的问题是程序执行时的基本表示是实际计算 机上的机器语言还是虚拟机 的机器语言。这个问题决定了语言的实现。根据这个问题的回答，可 以将程序设计语言划分为两大类: 编译型语言和解释型语言。
2. 由编译型语言编写的源程序需要经过编译、汇编和链接才能输出目标 代码，然后机器执行目标代码，得出运行结果，目标代码由机器指令 组成，一般不能独立运行， 因为源程序中可能使用了某些汇编程序不能解释引用的库函数，而库 函数代码又不在源程序中，此时还需要链接程序完成外部引用和目标 模块调用的链接任务，最后 输出可执行代码。C、C++、Fortran、Pascal、Ada都是编译实现的。
3. 解释型语言的实现中，翻译器并不产生目标机器代码，而是产生易于 执行的中间代码，这种中间代码与机器代码是不同的，中间代码的解 释是由软件支持的，不能直接 使用硬件，软件解释器通常会导致执行效率较低。用解释型语言编写 的程序是由另一个可以理解中间代码的解释程序执行的。与编译程序 不同的是，解释程序的任务 是逐一将源程序的语句解释成可执行的机器指令，不需要将源程序翻 译成目标代码后再执行。对于解释型Basic语言，需要一个专门的解 释器解释执行 Basic程序，每条语言只有在执行才被翻译。这种解释型语言每执行 一次就翻译一次，因而效率低下。
4. Java很特殊，Java程序也需要编译，但是没有直接编译称为机器语言 ，而是编译称为字节码，然后在Java虚拟机上用解释方式执行字节码 。Python 的也采用了类似Java的编译模式，先将Python程序编译成Python字节 码，然后由一个专门的Python字节码解释器负责解释执行字节码。
(Java虚拟机对字节码的执行相当于模拟一个cpu，而ruby1.8--在虚 拟机还未出现前--是通过解释成语法树执行。)
Python是一个解释型的语言。但是为了效率上的考虑，Python也提供 了编译的方法。编译之后是bytecode的形式。Python也提供了和Java 类似的VM来执行这样的bytecode。不同的是，因为Python是一个解释 型的语言，所以编译（compile）不是一个强制的操作。事实上，编 译是一个自动的过程。多数情况下，你甚至不会在意他的存在。编译 成bytecode可以节省加载模块的时间，从而提高效率
除了效率原因，bytecode也增加了反向工程的难度，在某种程度上保 护你的代码。当然，反编译仍然是可以的。所以如果真的想保护代码 ，还是用别的方法吧。 另外Python还提供了-O选项，可以编译生成“优化”的bytecode，文 件扩展名是.pyo。但实际上优化的内容有限，作用不大。 如果希望生成可执行文件，就要依赖于第三方的工具了。
1. Python是一门解释型语言？
我初学Python时，听到的关于Python的第一句话就是，Python是一门解释性语言，我就这样一直相信下去，直到发现了*.pyc文件的存在。如果是解释型语言，那么生成的*.pyc文件是什么呢？c应该是compiled的缩写才对啊！
为了防止其他学习Python的人也被这句话误解，那么我们就在文中来澄清下这个问题，并且把一些基础概念给理清。
2. 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 机器语言 即由01组成的机器硬件可以识别的语言
计算机"不能直接识别"高级语言，"只能直接识别"机器语言
##2 低级语言 即汇编语言 Assembly Languages
将由01组成的机器语言用具有简单语义的英文代码表示，以便于理解和程序员编程。
通常用于对硬件的直接操控(用于对单片机，芯片等底层的硬件编程)。是最接近于硬件的语言，不过现在几乎没多少人用了。
由于汇编语言编写的程序很小，所以通常在程序中最核心的、控制硬件的代码可以采用汇编语言编写，一方面是安全，另一方面提高运行速度。
汇编语言是一种用于编写某些程序的语言。
而编程则是程序员用某种语言编写程序的过程。 汇编较烦(不如C来得快，也没C直接)，通常一个很简单的算术表达式用C可以一句搞定，用汇编则要用几十行（比如先定义段寄存器，什么数据段，栈段，代码段），还要算什么偏移量，而且有很多都是用十六进制的。而且运行结果还不能一下子就能看出，你要仔细查看每一个寄存器的值。 汇编语言由于采用了助记符号来编写程序，比用机器语言的二进制代码编程要方便些，在一定程度上简化了编程过程。汇编语言的特点是用符号代替了机器指令代码，而且助记符与指令代码一一对应，基本保留了机器语言的灵活性。使用汇编语言能面向机器并较好地发挥机器的特性，得到质量较高的程序。
汇编语言是面向具体机型的，它离不开具体计算机的指令系统，因此，对于不同型号的计算机，有着不同的结构的汇编语言，而且，对于同一问题所编制的汇编语言程序在不同种类的计算机间是互不相通的。
汇编语言中由于使用了助记符号，用汇编语言编制的程序输入计算机，计算机不能象用机器语言编写的程序一样直接识别和执行，必须通过预先放入计算机的"汇编程序"的加工和翻译，才能变成能够被计算机识别和处理的二进制代码程序。用汇编语言等非机器语言书写好的符号程序称为源程序，运行时汇编程序要将源程序翻译成目标程序。目标程序是机器语言程序，它一经被安置在内存的预定位置上，就能被计算机的CPU处理和执行。
汇编语言像机器指令一样，是硬件操作的控制信息，因而仍然是面向机器的语言，使用起来还是比较繁琐费时，通用性也差。但是，汇编语言用来编制系统软件和过程控制软件，其目标程序占用内存空间少，运行速度快，有着高级语言不可替代的用途。
##3 中级语言 如C语言(C是位于高级与低级之间的一门语言)
既强大可以直接控制硬件，也方便，图形化的执行效率高。
##4 高级语言 如C++/JAVA/C#/VB(用这些语言设计图形界面比较合适)
高级语言包括C之类都可以转化为汇编
计算机"不能直接识别"高级语言，"只能直接识别"机器语言,所以必须要把高级语言"翻译成"机器语言，计算机才能执行高级语言编写的程序。
按照翻译的方式有2种《2种方式只是翻译的时间不同》
计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。
这个过程分成两类，第一种是编译，第二种是解释。
编译型语言 在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。
解释型语言 就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。
通过以上的例子，我们可以来总结一下解释型语言和编译型语言的优缺点，因为编译型语言在程序运行之前就已经对程序做出了“翻译”，所以在运行时就少掉了“翻译”的过程，所以效率比较高。但是我们也不能一概而论，一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化，从而在效率上超过编译型语言。
此外，随着Java等基于虚拟机的语言的兴起，我们又不能把语言纯粹地分成解释型和编译型这两种。
用Java来举例，Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。
再换成C#，C#首先是通过编译器将C#文件编译成IL文件，然后在通过CLR将IL文件编译成机器文件。所以我们说C#是一门纯编译语言，但是C#是一门需要二次编译的语言。同理也可等效运用到基于.NET平台上的其他语言。
##--1 编译型语言 COMPILING Languages
C/C++，JAVA都是编译型语言。蔡说C++很复杂，要成为高手没三五年是不行的（就凭这句话，我决定向JAVA投降），虽然如此，但真正要成为高手的都应该懂C/C++。
关于Delphi，蔡说如果想要跨Linux和Windows平台的语言，则Delphi似乎是最好的选择。
过程==>编译型语言写的程序
-->在应用源程序执行之前,就使用专门的编译过程
-->即: 需要一个专门的"编译器",针对特定平台(OS),把高级语言源代码“一次性翻译成等价的”该平台硬件执行的机器码(包括机器指令和操作数)
-->并包装成该平台所能识别的可执行性程序的格式(机器语言的文件 如.exe文件)),而后就隐退了。这个转换过程即编译Compile
-->经过链接器链接之后形成了二进制的可执行文件。
-->有些程序在编译结束后，还可能需要对其他编译好的目标代码进行链接，即组装2个以上的目标代码模块生成最终的可执行程序，通过这种方式实现低层次的代码复用。
-->编译生成的可执行程序,在以后的某时刻,要执行该程序时,就不用再重新翻译了,可以把二进制程序从硬盘载入到内存中并运行
可以脱离其语言环境,在特定的平台上独立执行，使用比较方便
-->用户启动目标程序由os执行,直接使用编译的结果就行了(exe文件) 且其目标程序
-->但应用程序一旦需要修改，必须先修改源代码，再重新编译生成新的目标文件(＊.OBJ)才能执行，只有目标文件而没有源代码，修改很不方便。
经过编译,汇编和链接才能输出目标代码，然后由机器执行目标代码。
目标代码是有机器指令组成，不能独立运行，因为源程序中可能使用了一些汇编程序不能解释引用的库函数，而库函数又不在源程序中，此时还需要链接程序完成外部引用和目标模板调用的链接任务，最后才能输出可执行代码。
性能==>程序执行效率高(因为翻译只做了1次，运行时不需要翻译)
缺陷==>依赖编译器 但因编译性语言的程序被编译成特定平台上的机器码，因此编译生成的可执行程序通常无法移植到其他平台上运行
跨平台性差些 如果需要移植，则必须将源代码复制到特定的平台上，针对特定的平台进行修改，至少也需要采用特定平台上的编译器重新编译。
代表==>C/C++/Objective-C/Fortran/Pascal/Ada/Delphi等
##--2 解释型语言 [Interpreted Languages] python和java很类似 《源码->字节码->机器码->运行》(但编译字节码不是一个强制的操作)事实上，编译是一个自动的过程，一般不会在意它的存在。
也常被称作Script语言，通常被用于和底下的操作系统沟通。
过程==>解释性语言写的程序
-->此时不需要编译,省了道工序,不需要将源程序编译成二进制目标机器代码再执行,它可以直接从源代码运行程序,
-->即: 需要一个专门的"解释器"将源程序编译成字节码(可理解为产生中间代码,该中间代码与机器代码不同),
-->但每条语句都是只在每次执行时才能被且都要翻译成字节码,且每次执行都需要进行1次编译
-->然后在运行的时候,再把字节码转换成机器语言(由虚拟机使用专门的"解释器"对源代码的语句进行“逐行解释成”特定平台的可执行的机器指令,并立即执行的语言),
-->最后才能在硬件上运行
执行方式==>应用程序源代码一边由相应语言的解释器“翻译”成目标代码(机器语言)，一边执行，因此效率比较低，而且不能生成可独立执行的可执行文件
通常不会进行整体的编译和链接处理,相当于把编译型语言中的编译和解释过程混合在一起同时完成。
在具体计算机上实现一种语言，首先要确定的是表示该语言语义解释的虚拟计算机，一个关键的问题是程序执行时的基本表示是实际计算机上的机器语言还是虚拟机的机器语言。这个问题决定了语言的实现。
优势==>跨平台比较容易，只需提供特定平台的解释器即可,每个特定平台上的解释器负责将源程序解释成特定平台的机器指令即可
可以方便的实现源程序的移植，但这是以牺牲程序执行效率为代价的，而且应用程序不能脱离其解释器独立运行。
比较灵活，可以动态地调整、修改应用程序
python代码与机器底层更远了，python程序更加易于移植，基本上无需改动就能在多平台上运行。
编译成字节码可以节省加载模块的时间，提高效率。
除了效率之外，字节码的形式也增加了反向工程的难度，可以保护源代码。这个只是一定程度上的保护，反编译还是可以的
缺陷==>源代码外露: 所以不适合用来开发软件产品，一般用于网页服务器。
中间代码的解释是由软件支持的，不能直接使用在硬件上, 该软件解释器通常会导致执行效率较低
与编译性语言相比，每次多出了编译和链接的过程，性能肯定会受到影响。这样解释性语言每执行1次就要翻译1次，因而效率比较低。
代表==>Java/C#/Ruby/Python/Perl/basic/rebol等
##------ basic,专门有一个解释器能够直接执行basic程序,比较典型
##------Java解释器,java程序很特殊,
在运行前也有一个编译过程,只是不将源程序直接编译成机器语言而已
=>java由JVM将字节码再翻译成机器语言,在Java虚拟机上用解释的方式执行字节码《类似于“同声翻译”》
##------Python解释器,
先将py源代码"编译为"字节码pyc(出于效率的考虑，提供的一种编译的方法，编译之后就得到pyc文件，存储了字节码)
再当运行python文件程序时,再由一个专门的python字节码解释器来负责执行这些字节码
这样，python就不用担心程序的编译,库的链接加载等问题了,开发的工作也就更加轻松啦。
##--3 混合型语言 Hybrid Laguages
介于解释型和编译型之间。蔡认为C#是.NET最重要的语言，值得期待其后续发展；至于JAVA，蔡叫看他的《Sleepless in Java》——我倒！
代表==>JAVA/C#
##--4 脚本语言 是一种解释性的语言
过程==>一般都有相应的脚本引擎来解释执行.他们一般需要解释器才能运行。
不需要编译，可以直接用，由解释器来负责解释。
介于HTML和C,C++,Java,C#等编程语言之间
html 通常用于格式化和链结文本
编程语言 通常用于向机器发出一系列复杂的指令
执行方式==> 一般都是以文本形式存在,类似于一种命令
性能==>
优势==>
代表==>javascript/vbscript/ActionScript/installshield script/ASP/PHP/perl/Nuva
举例,如果你建立了一个程序,叫aaa.exe,可以打开.aa为扩展名的文件.
你为.aa文件的编写指定了一套规则(语法),当别人编写了.aa文件后,你的程序用这种规则来理解编写人的意图,并作出回应.那么,这一套规则就是脚本语言
2.脚本语言与编程语言也有很多相似地方，其函数与编程语言比较相象一些,其也涉及到变量。与编程语言之间最大的区别是编程语言的语法和规则更为严格和复杂一些.
3.与程序代码的关系:脚本也是一种语言，其同样由程序代码组成。
JAVA语言
java很特殊，java程序也需要编译，但是没有直接编译称为机器语言，而是编译称为字节码，然后用解释方式执行字节码。Java既可以被编译，也可以被解释。通过编译器，可以把Java程序翻译成一种中间代码 - 称为字节码 - 可以被Java解释器解释的独立于平台的代码。通过解释器，每条Java字节指令被分析，然后在计算机上运行。只需编译一次，程序运行时解释执行。下图说明了它是如何工作的:
可以把Java字节码看作运行在Java虚拟机（Java VM）上的机器代码指令。每中Java解释器，不管是Java开发工具还是可以运行Java小应用程序的Web浏览器，都是一种Java VM的实例。JavaVM也可以由硬件实现。
Java字节码使“写一次，到处运行”成为可能。可以在任何有Java编译器的平台上把Java程序编译成字节码。这个字节码可以运行在任何Java VM上。例如，同一个Java程序可以运行在WindowsNT、Solaris和Macintosh上。
Java平台
平台是程序运行的硬件或软件环境。Java平台与大多数其它平台不同之处在于它是运行于其它基于硬件平台的纯软件平台。大多数其它平台是硬件和操作系统的结合。
Java平台由两部分组成:
?Java虚拟机（Java VM）
?Java应用程序界面（Java API）
我们已经介绍了Java VM，它是Java平台的基础，可以移植到各种基于硬件的平台上。Java API是软件组件的集合，它们提供了很多有用的功能，如图
形用户界面（GUI）。Java API被分组为相关组件的库（包）。
下图描述了一个运行在Java平台上的Java程序，如应用程序（application）或小应用程序（applet）。如图中显示的，JavaAPI和VM把Java程序从硬件依赖中分离出来。
作为一种独立于平台的环境，Java比本地代码慢一些。然而，聪明的编译器、很好地调制过的解释器和即时字节码编译器可以在不牺牲可移植性的条件下使Java的表现接近本地代码。
解释器在目标程序（其实根本就没有目标程序，只是与编译来对比）执行期间，解释器一直随之运行。这种执行过程完全由解释器控制的。从效果上看，解释器实现了一台“虚拟计算机”，其“机器语言”就是高级语言，解释器一次读入一条或多条语句，按照其自身规定的方式去执行相应的操作。一般说来，解释比编译有着很好的灵活性；编译一般有着较好的性能。
但是有些语言确是采用了两者的混合形式:
书中的原文: ”如果初始阶段的翻译器比较简单，我们就说这个语言是“解释的”。
如果翻译器很复杂，我们就说这一语言是“编译的”。
现在两者的区分变得有些模糊了，因为“简单”和“复杂”都是修饰性术语，也因为完全可能出现用一个编译器（复杂的翻译过程）生成代码，而后又由一个复杂的虚拟机（解释器）执行。对于最后这种情况，如果翻译器对程序做了彻底的分析（而不是做某种“机械的”变换），而且有关的中间语言程序与源程序并没有很强的相似性，我们还是说这个语言是编译的。
这两种特性----彻底的分析和非平凡的变换-----是刻画编译方式的标志性特征。“
--程序语言的分类 和 汇编型、编译型、解释型语言的区别
程序语言可分为5类
1、web page script languages
就是网页代码，比如Html、javascript、Css、Asp、Php、Xml都应该属于此类（照蔡的意思，Html不应该属于anguages的，可能他觉得太简单了吧，不过我觉得Html也应该算的，大家爱听谁的就听谁的好了，这个不重要）
程序语言学习顺序建议
如果完全没有程序经验，可照这个顺序: javascript——解释型语言——混合型语言——编译型语言——汇编（如果需要的话）
用业界流行一句话做结尾“真正的程序员用C++,聪明的程序员用Delphi”，那么，什么样的程序员用JAVA呢？
解释型语言在运行程序的时候才翻译，专门有一个解释器去进行翻译，每个语句都是执行的时候才翻译。效率比较低，依赖解释器，跨平台性好，如Basic。
脚本语言介于HTML和C,C++,Java,C#等编程语言之间。
HTML通常用于格式化和链结文本。而编程语言通常用于向机器发出一系列复杂的指令。
脚本语言与编程语言也有很多相似地方，其函数与编程语言比较相象一些，其也涉及到变量。与编程语言之间最大的区别是编程语言的语法和规则更为严格和复杂一些.
脚本与程序代码的关系: 脚本也是一种语言，其同样由程序代码组成。 注: 脚本语言一般都有相应的脚本引擎来解释执行。他们一般需要解释器才能运行。JAVASCRIPT、ASP、PHP、PERL都是脚本语言。C/C++编译、链接后，可形成独立执行的exe文件。
脚本语言是一种解释性的语言，例如vbscript、javascript、installshield script等等，它不象c\c++等可以编译成二进制代码，以可执行文件的形式存在。
脚本语言不需要编译，可以直接用，由解释器来负责解释。
脚本语言一般都是以文本形式存在，类似于一种命令。
看上去陷入了一个困境，Java到底是编译型语言呢，还是解释型语言呢？
一种朴素的判定方式:
如果翻译器部分较为简单，我们说这个语言是“解释的”，反之如果翻译器部分很复杂，我们就说这个语言是“编译的”。“”
事实上这两者之间的界限是模糊的，因为“简单”和“复杂”都具有主观性。“解释型”和“编译型”并不是一个清晰的描述。故强行将某种具有混合形式的语言划入两者之一是不当的。
但实践中肯定还是有进行分类的需求的，所以这里有一条启发性原则用以判断语言的类型:
如果翻译器对程序进行了彻底的分析而非某种机械的变换，而且生成的中间程序与源程序之间没有很强的相似性，我们就认为这个语言是编译的。彻底的分析和非平凡的变换，是编译方式的标志性特征。
因此，Java应当被认作一种编译型语言。
——《PLP》1.4 Compilation and Interpretation
JAVA的源代码首先被编译成字节码，然后依赖各种不同平台上的虚拟机来解释执行字节码。
我更倾向于把它归类为解释型语言，因为编译型语言的特征是编译过程与环境相关，而且编译结果机器可以直接执行；Java的编译结果不满足任何一条，只是中间码。不过确实……知道整个过程就可以了，编译和解释执行这两个过程确实都发生了
个人觉得，解释性或编译性跟语言本身是没有关系的，即，更愿意把解释或编译看作是一个语言的状态，而不是属性。
的确是这样的, 然而Java经由编译后得到的是类似汇编的一种给机器读的代码(也就是所谓的字节码), 但汇编码会直接交由CPU执行, 而Java的是会由JVM执行, 正如 @陈劭玮 所说的, 不同平台下有不同的JVM, 但是却执行同样一种字节码, 所以Java才是跨平台的.
另外呢, 有些时候编译性语言和解释性语言界线并不那么清晰. 譬如Python, Ruby(仅限1.9+)这些典型的脚本语言, 当然是解释性语言无误. 但它们也可以产生编译过的字节码, 只是把编译和执行两块合在一起而已, 理论上当然也可以写一个专门的字节码执行程序, 那么这样就很像编译性语言了.
反过来说, 如果有人写一套程序语言解释器, 语法是Java的语法, 却不经过编译这个步骤, 那样很明显它就是解释性的.
那么我的观点应该是这样的
? 程序语言本身不具备解释性或编译性这个属性, 编译程序或解释器决定这些
? 有些时候很难断定一个编译程序或解释器是是哪种性质, 那要看如何定义这两个概念
编译型，没见过直接执行.java文件的。进一步成为.class文件之后就看JVM的工作方式了。
Java应该算是编译型-解释型混合的语言，同时具有编译和解释特性，Java的编译其实是将.java文件翻译成与平台无关的字节码.class文件（类文件），类文件不是可执行的，需要被JVM翻译成本地的机器码才可以执行，这个过程是解释型的。
从jvm解释执行这一点来说，Java的确像是解释性语言，但是，其实远没有那么简单，Java的效率要比一般的解释性语言高的多。
编译型语言，而且跟解释型一点关系都没有。
解释执行class文件 不等于 他有解释型语言的特性。jvm加载class后，只要他不卸载，即使你改了class，他永远也不会加载改变后的。但是他什么时候卸载？你都没法控制！还谈什么解释型？
终于了解了编译和解释的概念及区别！
## Java 是编译型语言还是解释型语言？
有些答案对JAVA的理解还停留在上古时代或者教科书里。
其实，现在用编译型、解释型来分类编程语言已经有点力不从心了。
##Step1: JAVA的第一道工序是javac编译，当然目标文件是BYTECODE。
java的编译器先将其编译为class文件，也就是字节码
然后将字节码交由jvm(java虚拟机)解释执行
##Step2: 后续可能有三种处理方式(所以很多地方都说“java是一种半编译、半解释执行”的语言)
1. 运行时，BYTECODE由JVM逐条解释执行，
2. 运行时，部分代码可能由JIT翻译为目标机器指令（以method为翻译单位，还会保存起来，第二次执行就不用翻译了）直接执行；
3. RTSJ。继JAVAC之后执行AOT二次编译，生成静态的目标平台代码（典型的就是IBM WEBSHPERE REAL TIME）。
有的时候，可能是以上三种方式同时在使用。至少，1和2是同时使用的，3需要程序员手工指定。
所以讨论语言得更细化一点了，强类型的、弱类型的，静态的、动态的，GC-based的、手工管理内存的，有没有VM...
我是倾向于避开把编程语言描述为“编译型”或者“解释性”的。
原因之前在博客上写过，写得比较长所以不想搬过来了: http://rednaxelafx.iteye.com/blog/492667
近来(其实也不是很"近")Oracle的(以前是Sun的)HotSpot VM采用了jit compile(just in time compilation)技术，将运行频率很高的字节码直接编译为机器指令执行以提高性能, 所以当字节码被jit编译为机器码的时候，要说它是编译执行的也可以...
不过总体来讲，java的编译结果是被jvm“解释执行”的，所以这么说也能说通，而其实这个“是编译还是解释”这个概念在这里已经有点模糊了，理解它的过程就行了，不必下一个“精确”的定义;
而我自己仍然赞成“java是编译型语言”的说法，因为“编译”其本质就是“把一个相对高级的语言转换为另一个相对低级的语言”，而由java -> class文件的编译已经满足了这个特征; 而后面你要说jvm是“解释执行”的，那其实硬件对于机器码又何尝不是“解释执行”呢？
有人说Java是编译型的。因为所有的Java代码都是要编译的，.java不经过编译就无法执行。
也有人说Java是解释型的。因为java代码编译后不能直接运行，它是解释运行在JVM上的，所以它是解释型的。
对于C和C++，它们经过一次编译之后，可以由操作系统直接执行，所以它们是编译型语言。
而Java不一样，它首先由编译器编译成.class（字节码）文件，然后在通过JVM从.class文件中读一行解释执行一行，所以它是解释型的语言。
也正是由于java对于多种不同的操作系统有不同的JVM，所以实现了真正意义上的跨平台。
##Step1: 准备文件test.py
def print_str(s):
print 'result:%s' %(s)
if __name__ == '__main__':
print_str('hello world')
##Step2: 运行文件test.py
$ python test.py
##Step3: 然而我们在程序中并没有看到pyc文件，仍然是test.py孤零零地呆在那！
$ ls 只有test.py一个文件
##Step4: 准备拆1文件test.py
def print_str(s):
print 'result:%s' %(s)
##Step5: 准备拆2文件print_m.py/那么我们换一种写法，我们把print_str方法换到另外的一个python模块中
from print_m import print_str
if __name__ == '__main__':
print_str('hello world')
##Step6: 运行文件test.py 为什么这里我的运行不显示
$ python test.py
##Step7: 这个时候pyc文件出现了，其实认真思考一下不难得到原因，我们考虑一下实际的业务情况。
$ ls 可以看到多了test.pyc文件
之所以要把py文件编译成pyc文件，最大的优点在于我们在运行程序时，不需要重新对该模块进行重新的解释
所以，我们需要编译成pyc文件的应该是那些可以重用的模块，这于我们在设计软件类时是一样的目的。所以Python的解释器认为: 只有import进来的模块，才是需要被重用的模块。
这个时候也许有人会说，不对啊！你的这个问题没有被解释通啊，我的test.py不是也需要运行么，虽然不是一个模块，但是以后我每次运行也可以节省时间啊！
OK，我们从实际情况出发，思考下我们在什么时候才可能运行python xxx.py文件:
A. 执行测试时。
B. 开启一个Web进程时。
C. 执行一个程序脚本。
我们逐个来说，第一种情况我们就不用多说了，这个时候哪怕所有的文件都没有pyc文件都是无所谓的。
--https://www.cnblogs.com/mq0036/p/5014236.html python是什么样的语言
