python-day1

时间  2019-11-21
标签 python day1 day 栏目 Python 繁體版
原文   原文链接

目录：html

  • python简介
  • python安装与执行
  • pycharm简单设置及使用
  • 注释使用及.pyc文件
  • python变量
  • python用户交互（输入输出）
  • if条件语句
  • 循环语句（while & for）
  • 运算符
  • python数据类型初识（int，bool，str，list，dict）

 

1、python简介：

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

　　

　　python的目前应用领域：数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等众多领域python

　　python的目前公司经常使用领域：自动化运维、自动化测试、大数据分析、爬虫、Web 等。linux

　　使用python的公司：Youtube、Dropbox、BT、Quora（中国知乎）、豆瓣、知乎、Google、Yahoo!、Facebook、NASA、百度、腾讯、汽车之家、美团等git

　　ps：有上可知，python正愈来愈受到程序员们的普遍承认，那python的优点在哪里呢？程序员

 

　　一、python和其余语言对比：windows

　　　　a.C 和 Python、GO、Java、C#等网络

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

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

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

　　　　　　对于使用：Python的类库齐全而且使用简洁，若是要实现一样的功能，Python 10行代码能够解决，C可能就须要100行甚至更多.

　　　　　　对于速度：Python的运行速度相较与C，绝逼是慢了

　　　　c.python和GO语言

对于使用：Go语言是将来的语言，它属于编译型（有关解释型语言和编译型语言解释，注1）语言，做为新型的语言，网络传输方面目前全部语言第一，就是语法基础等方面还有待于完善。

　　　　　　对于速度： 与C至关，很牛逼的语言，身为小白的我，坐等它的成熟。

　　　　d.Python 和 Java、C#等

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

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

 

　　二、python的种类：

　　　　a.CPython：

Python的官方版本，使用C语言实现，使用最为普遍，CPython实现会将源文件（py文件）转换成字节码文件（pyc文件），而后运行在Python虚拟机上。目前咱们建议使用3.5版本。

　　　　　　解释器：CPython。为C语言开发

　　　　　　运行方式：命令行下使用python命令直接运行。

　　　　b.pypy：

　　　　　　Python实现的Python，pypy采用JIT技术，将Python的字节码字节码再编译成机器码。其目的就是一次编译全部py变为pyc，直接调用加快程序调用速度。

　　　　　　解释器：pypy。

　　　　　　运行方式：命令行下使用pypy命令运行

　　　　c.其余Python：

    • Jyhton：

      Jython是运行在java平台上的python解释器，能够直接把python代码编译成java字节码执行。

    • IronPython：
      IronPython和Jython相似，只不过IronPython是运行在微软.net平台上的python解释器。能够直接把python代码编译成.net字节码执行。
    • RubyPython、Brython .. 　　　　

ps.因此目前python对于全部主流语言都有很好的兼容，虽然如此，若是要和java或.net等平台交互，最好的方式仍是经过网络调用交互，以此确保各各程序之间的独立性。

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

　　　　

 

2、　python安装与执行

　　前面说了这么多，下面开始正式学习python了。

　　一、安装：

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



2.linux安装

查看默认Python版本
python -V

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



　二、Hello world！程序

 　　　a.建立helloworld.py文件（pyhton程序，通常为.py结尾）

#!/usr/bin/env python
#解释器调用路径
# -*- coding:utf-8 -*-
#声明解释器编码

#程序执行
print('hello world!')

 b.执行方式

    • windows
      • "D:\Program Files\Python35\python.exe"  helloword.py   #直接文件执行（之后运行程序多为此方式）
      • "D:\Program Files\Python35\python.exe"  #进入解释器执行print('helloword!')
    • linux  
      • python helloword.py   #直接文件执行（之后运行程序多为此方式）
      • ptyhon             #进入解释器执行print('helloword!')

　　　　ps.文件头部要加#!/user/bin/evn python及chmod +x helloword.py

　　　　　　而后./helloword.py实行。

三、编码格式（做用：声明编码格式）

　可让计算机直接认识的语言，其实只有汇编语言，即0和1的代码。且计算机是美国人发明的，所以，最先只有英文加特殊字符共127位字母与0和1代码进行一一对应。而美国人以为够用了2^7 = 128不够他们扩展的，因此采用2^8 =256的内存空间(单位为‘字节’， 即256字节)，够美国人用的了。

　这就是最先的编码ASCII码。显然，256位字符不够中文用的，中国人也想用，怎么办呢？显然聪明的中国人想到了办法，经过在作一张新的表并把新表经过取ASCII码的几位映射到ASCII码中使用。这就是GBK。有21003字符，2字节一个汉字。

　全世界人民都想使用电脑，因而个个国家的编码应运而生，日本shift_JTS,韩国EUC-kr等等。中国身为共产主义多民族国家，不能只搞汉语啊，体现民族平等嘛，因而把满文，回文等等的文字也写了新的编码GB2312.有27484字，2字节一个汉字

   国际标准组织一看，世界竟然为了编码乱搞，冲突不断，乱码丛生。所以unicode诞生了，把全部语言统一到一个字符编码中，unicode也所以被称为万国码。最少用2个字节表示1个字符。

   这时，美国不干了，为何我创建的计算机，被大家乱改一通，最后我一个字符搞定的事，被大家改为了2个字符，我原本存100MB的东西，莫名其妙变成了200MB。不行，因而utf-8诞生了，utf-8是对uniccode的优化压缩。英文字符占1个字符，欧洲字符占2个字符，中文占3个字符……， 故utf-8又称可变字符编码。

　　　　ps.字符编码总结：

　　　　　　

编码名 占用字节（1中文字符） python版本（默认）
ASCII 没有中文 python2
GBK 2个字节 无
unciode 3个字节 无
utf-8 3个字节 python3

　　　　ps.二进制换算：

    • 最小计算机表示单位为bit（位）
    • 8bit = 1byte（字节，最小存储字节）
    • 1024byte = 1MB（兆）  MB--〉GB--〉TB --〉PB　　　　

3、pycharm简单设置及使用

 　　一、使用：

　　　　a、建立项目：file ---> new project

　　　　b、新建文件夹：右击要建立文件夹的项目或上级目录 ----〉new ---〉directory 

　　　　c、新建文件：右击要建立文件夹的项目或上级目录 ----〉new ---〉file

　　　　d、运行文件：要执行的.py文件内容---〉右击---〉run xx.py

　　 二、文件编码：

　　　　file ---->default settings --->editor --->file encodings

　　 三、程序文件模版：

　　　　file ---->default settings --->editor --->file and code templates 

　　 四、改变字体大小：

　　　　file ----〉settings ----〉editor ---> General ---〉mouse

4、注释使用及.pyc文件

　　一、python文件注释：

　　　 # 单行注释

　　　 ''' '''' 多行注释

     二、.pyc文件：

　　　 .pyc文件存储的是介于0101计算机语言和咱们写的文件之间的语言。是有python解释器根据咱们编写的代码自动生成的文件。具体可查看， 注1

 

5、python变量（初识）
 

　　一、变量命名规则：
 

　　　　a.字母
 

　　　　b.数字（不能开头）
 

　　　　c.下划线
 

 　　ps.硬性规定，命名必须是字母，数字，下划线，且不能以数字开头。
 

　　　　软性规则，如下划线分割
 

　　二、实例：
 

　　　　a.写法： age_of_oldboy = 60
 

　　　　b.命名潜规则：age_of_oldboy 普通变量
 

　　　　　　　　　　Age_of_oldboy  首字母大写，通常为类
 

　　　　　　　　　　AGE_OF_OLDBOY 通常为常量写法
 

6、python用户交互（输入输出）：
 

　　一、输入
 

　　　　v = input('>>>') 
 

　　　　import getpass
 

　　　　v = input（'>>>')
 

　　二、输出
 

　　　　print('input'， v)
 

　　3、实例：
 

'''
输入，输出
'''
 

#输入终端隐藏,pycharm很差使
import getpass
 

#正常输入，显示
name = input('name:')
password = getpass.getpass('password:')
age = 18
 

#正常输出
print(name, password, age)
 

7、if条件语句
 

一、if...else...结构
 

　　　　a.含义：
 

　　　　　　if 条件：
 

　　　　　　　　条件成功，执行
 

　　　　　　else：
 

　　　　　　　　条件失败，执行
 

　　　　b.实例：
 

#!/usr/bin/python
#-*- coding:utf-8 -*-
## 用户登录（三次机会重试）
user="tianyou.zhu"
password="tianyou123"
for i in range(3):
    user_input= input("请输入你的名字：")
    pass_input=input("请输入你的密码：")
    if user_input ==user  and pass_input==password:
        print ("登录成功")
        break
    else:
        print ("登录失败，请从新输入")
 

二、if ...elif ... else ...结构
 

　　　　　a.含义：
 

　　　　　　　　if 条件：
 

　　　　　　　　　　if条件成功，执行
 

　　　　　　　　elif 条件：
 

　　　　　　　　　　elif条件成功，执行
 

　　　　　　　　elif 条件：
 

　　　　　　　　　　elif条件成功，执行
 

　　　　　　　　　　....
 

　　　　　　　　else:
 

　　　　　　　　　　上述条件都失败，执行
 

　　　　　b.实例：
 

username = input('>>>')
if username == 'tianyou.zhu':
 　　print('普通管理')
elif username == 'a':
 　　print('超级管理')
elif username == 'b':
 　　print('人')
elif username == 'c':
 　　print('装逼犯')
else:
 　　print('再见...')
 

print('end')
 

8、循环语句（while & for）
 

　　一、while循环
 

　　　　a.结构
 

　　　　　　while 条件:
 

　　　　　　　　continue #当即执行下一个循环
 

　　　　　　　　break  #跳出当前while的全部循环
 

　　　　　　else: #while条件不成立执行
 

　　　　　　　　
 

　　　　b.实例1：1,2,3,4,5,6, 8, 9, 10 打印
 

#!/usr/bin/python
#-*- coding:utf-8 -*-
#一、使用while循环输入 1 2 3 4 5 6     8 9 10
#i=1
#while True:
#    if i ==7:
#        i=i+1
#        continue
#    print (i)
#    i= i +1
#    if i == 11:
#        break
for i in range(11):
    if i==7:
        continue
    print (i)

c.实例2：while 计算1到100的和
 

#!/usr/bin/python
#-*- coding:utf-8 -*-
#求1-100的全部数的和
val = 0
i=1
while i<101:
   val = val+i
   i= i +1
print (val)

a = 0
b = 1
for i in range(100):
    a =a+b
    b=b+1
print (a)

d.实例3：求1-2+3-4+5 ... 99的全部数的和
 

#!/usr/bin/python
#-*- coding:utf-8 -*-
#五、求1-2+3-4+5 ... 99的全部数的和
#value = 0
#i = 1
#while i<100:
#    if i % 2 == 1:
#        # value = value + i
#        value += i
#    else:
#        # value = value - i
#        value -= i
#    i += 1 # i = i + 1
#print(value)
e.实例4：用户登录（三次机会重试）
 

#!/usr/bin/python
#-*- coding:utf-8 -*-
## 用户登录（三次机会重试）
user="tianyou.zhu"
password="tianyou123"
for i in range(3):
    user_input= input("请输入你的名字：")
    pass_input=input("请输入你的密码：")
    if user_input ==user  and pass_input==password:
        print ("登录成功")
        break
    else:
        print ("登录失败，请从新输入")
 

9、运算符
 

 　　一、算术运算符：
 

　　　　
 

　　二、比较运算：
 

　　　　
 

　　三、赋值运算：
 

　　　　
 

　　四、逻辑运算：
 

　　　　
 

　　五、成员运算：
 

　　　　
 

　　六、身份运算：
 

　　　　
 

　　七、位运算：
 

　　　　
 

 

a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
 
c = a & b; # 12 = 0000 1100
print "Line 1 - Value of c is ", c
 
c = a | b; # 61 = 0011 1101
print "Line 2 - Value of c is ", c
 
c = a ^ b; # 49 = 0011 0001 #相同为0，不一样为1
print "Line 3 - Value of c is ", c
 
c = ~a; # -61 = 1100 0011
print "Line 4 - Value of c is ", c
 
c = a << 2; # 240 = 1111 0000
print "Line 5 - Value of c is ", c
 
c = a >> 2; # 15 = 0000 1111
print "Line 6 - Value of c is ", c
 

补充要点：
 

　　　　a. i += 1 等同于 i = i + 1。同理*= -= 等赋值运算符都为该系列。
 

　　　　b. 逻辑运算，从左往右一个一个看，先算（）内的数值。
 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 

'''
逻辑运算
'''
 

#1正确
if 1 == 1 or 1 > 2 and 1 == 4:
 　　print('正确')
else:
 　　print('错误')
 

#2错误
if 1 == 1 and 1 > 2 or 1 == 4:
 　　print('正确')
else:
 　　print('错误')
 

#3错误
if 1 == 0 and 1 > 2 or 1 == 4:
 　　print('正确')
else:
 　　print('错误')
 

#4错误
if 1 == 0 and (1 < 2 or 1 == 4):
 　　print('正确')
else:
 　　print('错误')
 

#5错误
if 1 == 0 and 1 > 2 or 1 == 4:
 　　print('正确')
else:
 　　print('错误')
 

c.成员运算
 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 

'''
成员运算符
'''
content = "Alex 前几天去泰国玩姑娘，一不当心染上了病，他的心里活动是，真该多来几个"
 

if "前几天去" in content:
 　　print('包含敏感字符')
else:
 　　print(content)
 

10、python数据类型初识（int，bool，str，list，dict）
 

　　type()查看变量类型。
 

　　一、int（整形）
 

　　　　a.建立
 

　　　　b.转换
 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 

'''
int（整形）
a.建立
b.转换
'''
 

#建立
age = 19
age1 = int(19)
print(age,age1)
 

#转换
age2 = '19'
print(type(age2))
#isdigit()判断是不是一个数字，int()只能转数字，不能转字母、中文等。会报错
if age2.isdigit(age2):
 int(age2)
print(('tpye:%s age2:%d') % (type(age2), age2))
 

 
 

　二、bool（布尔值）
 

　　　　a.建立
 

　　　　b.转换
 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 

'''
bool（布尔值）
a.建立
b.转换
'''
 

#建立
a = True
b = False
 

#转换
#数字转换，只有0是False，其余True
#字符串， 只有""是False，其余True
#其余，待续……
a1 = 0
a2 = 100
a3 = -100
a1_bool = bool(a1)
a2_bool = bool(a2)
a3_bool = bool(a3)
print('a1 %s:%s bool_type:%s'%(a1,a1_bool, type(a1_bool)))
print('a2 %s:%s bool_type:%s'%(a2,a2_bool, type(a1_bool)))
print('a3 %s:%s bool_type:%s'%(a3,a2_bool, type(a1_bool)))
 


b1 = ''
b2 = 'fafa'
b3 = 'AFSD@'
b1_bool = bool(b1)
b2_bool = bool(b2)
b3_bool = bool(b3)
print('b1 %s:%s bool_type:%s'%(b1,b1_bool, type(a1_bool)))
print('b2 %s:%s bool_type:%s'%(b2,b2_bool, type(a1_bool)))
print('b3 %s:%s bool_type:%s'%(b3,b3_bool, type(a1_bool)))
 

'''
结果：
a1 0:False bool_type:<class 'bool'>
a2 100:True bool_type:<class 'bool'>
a3 -100:True bool_type:<class 'bool'>
b1 :False bool_type:<class 'bool'>
b2 fafa:True bool_type:<class 'bool'>
b3 AFSD@:True bool_type:<class 'bool'>
'''
 

 
 

三、str（字符串）
 

　　　　a.建立
 

　　　　b.转换
 

　　　　c.拼接
 

　　　　d.格式化
 

　　　　e.是否在子序列中
 

　　　　f.移除空白.strip()
 

　　　　g.分割.split('分割符'，步长)
 

　　　　h.长度len()
 

　　　　i.索引[]
 

　　　　j.切片[开始：结束：步长]
 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 

'''
str（字符串）
a.建立 b.转换 c.拼接 d.格式化 e.是否在子序列中 f.移除空白
g.分割 h.长度 i.索引 j.切片
'''
 

#建立
name = 'tianyou.zhu'
name1 = str('tianyou.zhu')
print('name: %s tpye:%s \n name1:%s tpye:%s\n' %(name,type(name),name1,type(name1)))
 

#转换
age = 19
age_str = str(age)
print('age_str:%s tpye:%s' % (age, age_str))
 

#字符串拼接
name2 = 'alex'
gender = '女'
new_str = name2 + gender
print(new_str)
 

#字符串格式化，使用占位符%s（待续...）
name3 = '我叫李杰，性别：%s,我今年%s岁，我在说谎!'
new_str2 = name3 %('男',19,)
print(new_str2)
name4 = '我叫李杰，性别：%s,我今年%s岁，我在说谎!' %('男',19)
print(name4)
 

#判断子序列是否在其中
content = "Alex 前几天去泰国玩姑娘，一不当心染上了病，他的心里活动是，真该多来几个"
if "前几天去" in content:
 print('包含敏感字符')
else:
 print(content)
 

#移除空白
val = " alex "
print(val)
new_val = val.strip() # 左右去
# new_val = val.lstrip()# 左边去
# new_val = val.rstrip() # 右边去
print(new_val)
 

#分割.split('分隔符',步长)
user_info = "alex|sb123|9"
v = user_info.split('|')
# v = user_info.split('|',1)
# v = user_info.rsplit('|',1) #右分割
# v = user_info.lsplit('|',1) #左分割
print(v)
 

#长度（字符）python2，中文按2字节算,python按，中文按1字符算
val = "李杰nb"
v = len(val)
print(v)
 

'''
结果：
4
'''
 

#索引
val = "李杰mb"
v = val[0]
print(v)
 

val = input('>>>')
i = 0
while i < len(val):
 print(val[i])
 i += 1
 

'''
输入：dd
结果：
d
d
'''
#切片
name = '我叫李杰，性别我今年岁，我在说谎!'
print(name[0])
print(name[0:2])
print(name[3:9])
print(name[7:])
print(name[4:-2])
print(name[-2:])
 

'''
结果：
我
我叫
杰，性别我今
我今年岁，我在说谎!
，性别我今年岁，我在说
谎!
'''
 

四、list（列表）
 

　　　　a.建立
 

　　　　b.in判断
 

　　　　c.索引[]
 

　　　　d.追加.append()
 

　　　　e.插入.insert()
 

　　　　f.删除del .remove()
 

　　　　g.更新
 

　　　　h.输出
 

　　　　i.长度len()
 

　　　　j.切片[开始：结束：步长]
 

建立：
 a = ['alex','狗','eric',123]
 a = list(['alex','狗','eric',123])
 
 in判断：
 
 if 'al' in a:
 pass
 
 if 'al' in a[0]:
 pass
 
 索引：
 val = a[0]
 
 长度：
 val = len(a)
 
 切片：
 a = ['alex','狗','eric',123]
 v = a[0::2]
 print(v)
 
 追加：
 a = ['alex','狗','eric',123]
 a.append('xxoo')
 print(a)
 插入：
 a = ['alex','狗','eric',123]
 a.insert(0,'牛')
 print(a)
 删除：
 a = ['alex','eric','狗','eric',123]
 # a.remove('eric')
 del a[0]
 print(a)
 
 更新：
 a = ['alex','eric','狗','eric',123]
 a[1] = '阿斯顿发送到'
 print(a)
 
 For循环：
 a = ['alex','eric','狗','eric',123]
 for item in a:
 print(item)
 # break
 # continue
 
 

五、dict（字典）
 

　　　　a.建立
 

　　　　b.索引
 

　　　　c.增长&更新
 

　　　　d.删除
 

　　　　e.输出
 

- 建立
 
 v = {
 'name': 'alex',
 'password': '123123'
 }
 
 # 经常使用操做
 

 # 索引获取值
 # n = v['name']
 # print(n)
 
 # 增长，无，增长；有，修改
 # v['age'] = 19
 # print(v)
 
 # 删除
 # del v['name']
 # print(v)
 
 # 循环
 # for item in v.keys():
 # print(item)
 # for item in v.values():
 # print(item)
 # for key,val in v.items():
 # print(key,val)
 
 
 print(len(user_dict))
 
 PS: 相互嵌套
 user_dict = {
 'k1': 'v1',
 'k2': {'kk1':'vv1','kk2':'vv2'},
 'k3': 123,
 'k4': ['alex','eric',['a','b','c'],'李杰',{'k11':'vv1'}],
 }
 user_dict['k4'][2].append('123')
 user_dict['k4'][4]['n'] = '过啥龙'
 
 
 应用：
 
 user_list = [
 {'name':'alex','pwd':'123123','times':1},
 {'name':'eric','pwd':'123123','times':1},
 {'name':'tony','pwd':'123123','times':1},
 ]
 user = input('用户名：')
 pwd = input('密码：')
 for item in user_list:
 　　if user == item['name'] and pwd == item['pwd']:
 　　　　print('登陆成功')
 　　　　break
 

list & dict嵌套
 

　　　a.实例1：相互嵌套
 

#!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 
 5 '''
 6 dict&list相互嵌套实例1
 7 '''
 8 
 9 user_dict = {
10     'k1': 'v1',
11     'k2':{'kk1':'vv1', 'kk2':'vv2'},
12     'k3':123,
13     'k4':[ 'jack', ['a', 'b', 'c'], '李杰',{'k1':'v1'}]
14 }
15 print('dict: %s' % user_dict)
16 
17 #添加dict --〉 list的元素
18 user_dict['k4'][2].append('123')
19 print('add_dict_list: %s' % user_dict)
20 
21 #添加dict ---〉 dict的元素
22 user_dict['k4'][4]['k2'] = 'v1'
23 print('add_dict_dict: %s' % user_dict)
b.实例2：多用户密码登录
 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 

'''
dict_list多用户登录
'''
 

user_list = [
 {'name':'alex','pwd':'123123','times':1},
 {'name':'eric','pwd':'123123','times':1},
]
user = input('用户名：')
pwd = input('密码：')
 

for item in user_list:
 　　if user == item['name'] and pwd == item['pwd']:
 　　　　print('登陆成功')
 

一、注解1：
 

　　　　a. 解释型语言和编译型语言　　
 

　  计算机是不可以识别高级语言的，因此当咱们运行一个高级语言程序的时候，就须要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分红两类，第一种是编译，第二种是解释。
 

　　编译型语言在程序执行以前，先会经过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不须要翻译，而直接执行就能够了。最典型的例子就是C语言。
 

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

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

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

　　　　　　用Java来举例，Java首先是经过编译器编译成字节码文件，而后在运行时经过解释器给解释成机器文件。因此咱们说Java是一种先编译后解释的语言。
 

　　　　b.图例：
 

　　　　　　
 

　　　　　
 

　　　　c.编译型vs解释型
 

编译型
优势：编译器通常会有预编译的过程对代码进行优化。由于编译只作一次，运行时不须要编译，因此编译型语言的程序执行效率高。能够脱离语言环境独立运行。
缺点：编译以后若是须要修改就须要整个模块从新编译。编译的时候根据对应的运行环境生成机器码，不一样的操做系统之间移植就会有问题，须要根据运行的操做系统环境编译不一样的可执行文件。
 

解释型
优势：有良好的平台兼容性，在任何环境中均可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就能够，能够快速部署，不用停机维护。
 

缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。
 

 
 

 　　　　d.更多解释详见
 

　　　　　　http://www.cnblogs.com/alex3714/articles/5465198.html
 

　　　　　　http://www.cnblogs.com/wupeiqi/articles


        

            

        	





    

		

            
相关文章

            

                

                

                    

                

            


            
相关标签/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公众号
    

    

           欢迎关注本站公众号,获取更多信息

        
    





    




	


	







    

        联系我们
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程