Python语法基础
更多内容可以访问我的个人博客。
CPython、Jython、IronPython和PyPy
0. Python是解释型的还是编译型的？
这是个Python新人都会迷惑的问题。
首先需要明了的是Python只是一个接口。有一个关于Python应该做什么以及怎么做的具体说明(类似其他接口的接口说明文件)，并且对应的有很多具体的实现（CPython、Jython等）。
其次需要知道的是**“解释型”和“编译型”是具体实现的特性，而不是接口的特性。**
所以，这个问题本身就没有组织好,没意义。
1. CPython
CPython是特指C语言实现的Python，就是原汁原味的Python。当我们从Python官方网站下载并安装好比如Python 3.5后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。CPython是使用最广的Python解释器。
之所以使用CPython这个词，是因为Python解释器还有一些其它的实现，比如Java版的Jython，还有使用Python再把Python实现了一遍的PyPy。当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以用任何语言编写Python解释器来执行Python代码（当然难度很大）。
最新的语言特性都是在CPython解释器上面先实现，基本包含了所有第三方库支持，但是CPython**有几个缺陷，一是全局锁使Python在多线程效能上表现不佳，二是CPython无法支持JIT（即时编译），导致其执行速度不及Java和Javascipt等语言。**于是出现了Pypy。
2. Jython
Jython是运行在Java平台上的使用Java语言实现的Python解释器，可以直接把Python代码编译成Java字节码执行。CPython中很容易为你的Python代码写C扩展，因为最终都是由C解释器执行的。而Jython则使得和其他java程序共同工作很容易：无需其他工作，你就可导入任何Java类，在你的Jython程序中使用其他Java类。（可以把不同语言的代码混在一起，并编译成同一程序。）
下面是一个例子，一段合法的Jython代码：
[Java HotSpot(TM) 64-Bit Server VM (Apple Inc.)] on java1.6.0_51
>>> from java.util import HashSet
>>> s = HashSet(5)
>>> s.add("Foo")
>>> s.add("Bar")
>>> s
[Foo, Bar]
3. IronPython
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的使用C#实现的Python解释器，可以直接把Python代码编译成.Net的字节码。
4. PyPy
PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。 绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython仍存在一些不同，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果CPython代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。
PyPy是用Python自身实现的解释器。针对CPython的缺点进行了各方面的改良，性能得到很大的提升。最重要的一点就是Pypy集成了JIT。但是，**Pypy无法支持官方的C/Python API，导致无法使用例如Numpy，Scipy等重要的第三方库。**这也是现在Pypy没有被广泛使用的原因吧。
而PyPy与CPython的不同在于，别的一些python实现如CPython是使用解释执行的方式，这样的实现方式在性能上是很凄惨的。而PyPy使用了JIT(即时编译)技术，在性能上得到了提升。
基础数学运算
1. **
python当中^符号，区别于Matlab，在python中，^用两个**表示，如3的平方为3**2,**3表示立方，**4表示4次方，依次类推
>>> 3**2 # **2 表示2次方
9
>>> 3**3 # **3 表示3次方
27
2. %
余数符号为%，与Java相同，见代码.
>>> 8%3
2
循环语句
1. while循环
while condition:
expressions
在 Python 中除了常规比较操作
- 小于（<)
- 大于 (>)
- 不大于 (<=)
- 不小于 (>=)
- 等于 (==)
- 不等于 (!=)
会返回True和False值，其他一些变量放在条件中也会返回True和False
① 数字
整数和浮点数也能进行
Boolean数据操作, 具体规则，如果该值等于0或者0.0将会返回False其余的返回True② None
如果 while 后面接着的语句数据类型
None, 将会返回False。③ 集合
在 Python 中集合类型有
list、tuple、dict和set等，如果该集合对象作为 while 判断语句， 如果集合中的元素数量为 0，那么将会返回False, 否则返回True。
2. for循环
for item in sequence:
expressions
range()函数
在 Python 内置了工厂函数
range()，range函数将会返回一个序列.range(start, stop, step)，
step代表步长，即相隔的两个值的差值。从start开始，依次增加step的值，直至等于或者大于stop，当start为0，step为1时可省略。step为-1时表示倒序，此时start和stop也要改为由大到小。
3. 扩展
3.1 内置集合
Python 共内置了list、tuple、dict和set四种基本集合，每个 集合对象都能够迭代。
tuple 类型
tup = ('python', 2.7, 64)
for i in tup:
print(i)
程序将以此按行输出 ‘python’, 2.7 和 64。
dictionary 类型
dic = {}
dic['lan'] = 'python'
dic['version'] = 2.7
dic['platform'] = 64
for key in dic:
print(key, dic[key])
输出的结果为：platform 64，lan python, version 2.7, 字典在迭代的过程 中将key作为可迭代的对象返回。注意字典中key是乱序的，也就是说和插入 的顺序是不一致的。如果想要使用顺序一致的字典，请使用collections模块 中的OrderedDict对象。
set 类型
s = set(['python', 'python2', 'python3','python'])
for item in s:
print(item)
将会输出python, python3, python2set 集合将会去除重复项，注意输出的结果也不是按照输入的顺序。
3.2 迭代器
Python 中的for句法实际上实现了设计模式中的迭代器模式，所以我们自己也可以按照迭代器的要求自己生成迭代器对象，以便在for语句中使用。 只要类中实现了__iter__和next函数，那么对象就可以在for语句中使用。 现在创建 Fibonacci 迭代器对象,
# define a Fib class
class Fib(object):
def __init__(self, max):
self.max = max
self.n, self.a, self.b = 0, 0, 1
def __iter__(self):
return self
def __next__(self):
if self.n < self.max:
r = self.b
self.a, self.b = self.b, self.a + self.b
self.n = self.n + 1
return r
raise StopIteration()
# using Fib object
for i in Fib(5):
print(i)
将会输出前 5 个 Fibonacci 数据1，1, 2, 3, 5
3.3 生成器
除了使用迭代器以外，Python 使用yield关键字也能实现类似迭代的效果，yield语句每次 执行时，立即返回结果给上层调用者，而当前的状态仍然保留，以便迭代器下一次循环调用。这样做的好处是在于节约硬件资源，在需要的时候才会执行，并且每次只执行一次。
def fib(max):
a, b = 0, 1
while max:
r = b
a, b = b, a+b
max -= 1
yield r
# using generator
for i in fib(5):
print(i)
将会输出前 5 个 Fibonacci 数据1，1, 2, 3, 5
判断语句
Java中的&&、||在Python中直接写and、or
if a > 10 and b < 6:
#do stuff...
if a > 10 or b < 5:
#do stuff...
Java中的condition ? value1 : value2在Python中可以通过if-else的行内表达式完成类似的功能。
var = var1 if condition else var2
可以这么理解上面这段语句，如果condition的值为True, 那么将var1的值赋给var;如果为False则将var2的值赋给var。
函数定义
def function_name(parameters):
expressions
return
1. 参数
如果我们忘记了函数的参数的位置，只知道各个参数的名字，可以在 函数调用的过程中给指明特定的参数func(a=1, b=2), 这样的话，参数的位置将不受影响，所以func(b=2,a=1)是同样的效果。
1.1 默认参数
我们在定义函数时有时候有些参数在大部分情况下是相同的，只不过为了提高函数的适用性，提供了一些备选的参数， 为了方便函数调用，我们可以将这些参数设置为默认参数，那么该参数在函数调用过程中可以不需要明确给出。
def function_name(para_1,...,para_n=defau_n,..., para_m=defau_m):
expressions
函数声明只需要在需要默认参数的地方用=号给定即可, 但是要注意所有的默认参数都不能出现在非默认参数的前面。
1.2 可变参数
顾名思义，函数的可变参数是传入的参数可以变化的，1个，2个到任意个。当然可以将这些 参数封装成一个list或者tuple传入，但不够pythonic。使用可变参数可以很好解决该问题，注意可变参数在函数定义不能出现在特定参数和默认参数前面，因为可变参数会吞噬掉这些参数。
def report(name, *grades):
total_grade = 0
for grade in grades:
total_grade += grade
print(name, 'total grade is ', total_grade)
定义了一个函数，传入一个参数为name, 后面的参数*grades使用了*修饰，表明该参数是一个可变参数，这是一个可迭代的对象。该函数输入姓名和各科的成绩，输出姓名和总共成绩。所以可以这样调用函数report('Mike', 8, 9)，输出的结果为Mike total grade is 17, 也可以这样调用report('Mike', 8, 9, 10)，输出的结果为Mike total grade is 27
1.3 关键字参数
关键字参数可以传入0个或者任意个含参数名的参数，这些参数名在函数定义中并没有出现，这些参数在函数内部自动封装成一个字典(dict).
def portrait(name, **kw):
print('name is', name)
for k,v in kw.items():
print(k, v)
定义了一个函数，传入一个参数name, 和关键字参数kw，使用了**修饰。表明该参数是关键字参数，通常来讲关键字参数是放在函数参数列表的最后。如果调用方法portrait('Mike', age=24, country='China', education='bachelor')输出:
name is Mike
age 24
country China
education bachelor
通过可变参数和关键字参数，任何函数都可以用universal_func(*args, **kw)表达。
2. 全局变量
global关键字
首先我们在外部定义一个全局变量a=None, 然后再fun()中声明这个a是来自外部的a. 声明方式就是global a. 然后对这个外部的a修改后, 修改的效果会被施加到外部的a上. 所以我们将能看到运行完fun(),a的值从None变成了20.
APPLY = 100 # 全局变量
a = None
def fun():
global a # 使用之前在全局里定义的 a
a = 20 # 现在的 a 是全局变量了
return a
print(APPLE) # 100
print('a past:', a) # None
fun()
print('a now:', a) # 20
读写文件
open()打开文件
使用open能够打开一个文件,open的第一个参数为文件名和路径 ‘file.txt’, 第二个参数为将要以什么方式打开它, 比如w为可写方式. 如果计算机没有找到 ‘my file.txt’ 这个文件,w方式能够创建一个新的文件, 并命名为my file.txt。
写文件
以'w'、'a'方式打开文件，使用write()函数写文件
my_file=open('file.txt','w') #用法: open('文件名','形式'), 其中形式有'w':write;'r':read;'a':append
my_file.write(text) #该语句会写入先前定义好的 text
my_file.close() #关闭文件
append_text='\nThis is appended file.' # 为这行文字提前空行 "\n"
my_file=open('file.txt','a') # 'a'=append 以增加内容的形式打开
my_file.write(append_text)
my_file.close()
读文件
- 使用
file.read()能够读取到文本的所有内容.
file= open('file.txt','r')
content=file.read()
print(content)
- 按行读取
file.readline(),file.readline()读取的内容和你使用的次数有关, 使用第二次的时候, 读取到的是文本的第二行, 并可以以此类推:
file= open('file.txt','r')
content=file.readline() # 读取第一行
print(content)
""""
This is my first test.
""""
second_read_time=file.readline() # 读取第二行
print(second_read_time)
"""
This is the second line.
"""
- 读取所有行
file.readlines()，如果想要读取所有行, 并可以使用像for一样的迭代器迭代这些行结果, 我们可以使用file.readlines(), 将每一行的结果存储在list中, 方便以后迭代.
file= open('file.txt','r')
content=file.readlines() # python_list 形式
print(content)
""""
['This is my first test.\n', 'This is the second line.\n', 'This the third line.\n', 'This is appended file.']
""""
类的定义
class Calculator: #首字母大写，冒号不能缺
name='Good Calculator' #定义类的属性
price=18
def add(self,x,y): #定义类的方法
print(self.name)
result = x + y
print(result)
def minus(self,x,y):
result=x-y
print(result)
def times(self,x,y):
print(x*y)
def divide(self,x,y):
print(x/y)
>>> cal=Calculator() #新建一个Calculate类的对象
>>> cal.name
'Good Calculator'
>>> cal.price
18
>>> cal.add(10,20)
Good Calculator
30
>>> cal.minus(10,20)
-10
>>> cal.times(10,20)
200
>>> cal.divide(10,20)
0.5
在类中定义__init()__方法，相当于Java、C++中的构造函数;
self相当于Java中的this；
class Calculator:
name='good calculator'
price=18
def __init__(self,name,price,height,width,weight): # 注意，这里的下划线是双下划线
self.name=name
self.price=price
self.h=height
self.wi=width
self.we=weight
>>> c=Calculator('bad calculator',18,17,16,15)
>>> c.name
'bad calculator'
>>> c.price
18
>>> c.h
17
>>> c.wi
16
>>> c.we
15
>>>
异常处理
try:,except ... as ...:相当于Java中的try...catch...语句
try:
file=open('eeee.txt','r') #会报错的代码
except Exception as e: # 将报错存储在 e 中
print(e)
""""
[Errno 2] No such file or directory: 'eeee.txt'
""""