| Flase |
布尔类型的值，标示假，和True相反 |
| class |
定义类的关键字 |
| finally |
在异常处理的时候添加，有了它，程序始终要执行finally里面的程序代码块。 class MyException(Exception):pass
try:
#some code here
raise MyException
except MyException:
print "MyException encoutered"
finally:
print "Arrive finally"
我们为什么要写finally，是因为防止程序抛出异常最后不能关闭文件，但是需要关闭文件有一个前提就是文件已经打开了。 一： #打开一个文件，但有可能找不到
try:
f = open('xxx')
do something
except:
do something
finally:
f.close()
二： try:
f = open('xxx')
except:
print 'fail to open'
exit(-1)
try:
do something
except:
do something
finally:
f.close()
在第一段错误代码中，如果异常发生在f=open(‘xxx’)的时候，比如文件不存在，立马就可以知道执行f.close()是没有意义的。改正后的解决方案就是第二段代码。如：
|
| is |
Python中的对象包含三要素：id、type、value 其中id用来唯一标识一个对象，type标识对象的类型，value是对象的值
is判断的是a对象是否就是b对象，是通过id来判断的
==判断的是a对象的值是否和b对象的值相等，是通过value来判断的
>>> a = 1
>>> b =1.0
>>> a is b
False
>>> a==b
True
>>> id(a)
1447508224
>>> id(b)
15390048
>>> b=1
>>> a is b
True
>>> a==b
True
>>> id(a)
1447508224
>>> id(b)
1447508224
|
| return |
return语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回一个值 |
| None |
None是一个特殊的常量。None和False不同。None不是0。None不是空字符串。None和任何其他的数据类型比较永远返回False。None有自己的数据类型NoneType。你可以将None复制给任何变量，但是你不能创建其他NoneType对象
>>> type(None)
<class 'NoneType'>
>>> None == 0
False
>>> None == ''
False
>>> None == None
True
>>> None == False
False
|
| continue |
continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。 |
| for |
for..in是另外一个循环语句，它在一序列的对象上 递归 即逐一使用队列中的每个项目 |
| lambda |
匿名函数是个很时髦的概念，提升了代码的简洁程度。如： >>>g = lambda x: x*2
>>>g(3)
6
#理解lambda
g = lambda :"lambda test."
print g()
num1 = lambda x, y=1:x + y
print num1(1) #多个变量的时候，可以不给有默认值的变量传值
print num1(10,10) #值得注意的是，如果y没有默认值而且不给它传值的话报错！
输出结果： lambda test.
2
20
|
| try |
我们可以使用try..except语句来处理异常。我们把通常的语句放在try-块中，而把我们的错误处理语句放在except-块中。 |
| True |
布尔类型的值，标示真，和False相反 |
| def |
# 定义函数
def hello():
print('hello,hongten')
# 调用函数
hello()
>>> hello,hongten
|
| from |
在python用import或者from...import来导入相应的模块 |
| nonlocal |
nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量,如；
def make_counter():
count = 0
def counter():
nonlocal count
count += 1
return count
return counter
def make_counter_test():
mc = make_counter()
print(mc())
print(mc())
print(mc())
|
| while |
while语句允许你重复执行一块语句。while语句是所谓 循环 语句的一个例子。while语句有一个可选的else从句。 |
| and |
逻辑判断和C的&&一样 |
| del |
del用于list列表操作，删除一个或者连续几个元素。如： >>>a = [-1, 3,'aa', 85] # 定义一个list
>>>del a[0] #删除第0个元素
>>>a
[3, 'aa', 85]
>>>del a[2:4] #删除从第1个元素开始，到第2个为止的元素。包括头不包括尾
>>>a
[3, 85]
|
| global |
定义全局变量，详细信息：python开发_python中的变量：全局变量和局部变量 我的理解就是：要想给全局变量重新赋值，就要global一下全局变量（相当于告诉你：哦，注意了！下面我要设定全局变量的值的），之后在重新赋值。示例如下： #定义全局变量，变量名全部大写
NAME = "xueweihan"
#得到NAME值
def get_NAME():
return NAME
#重新设定NAME值
def set_NAME(name_value):
global NAME
NAME = name_value
print u"输出全局变量NAME的值:",get_NAME()
new_name = "521xueweihan"
set_NAME(new_name)#为全局变量重新赋值
print u"输出赋值完的全局变量NMAE的值:",get_NAME()
输出结果： 输出全局变量NAME的值: xueweihan
输出赋值完的全局变量NMAE的值： 521xueweihan
|
| not |
逻辑判断和C的!一样 |
| with |
with是python2.5以后才有的，它实质是一个控制流语句，with可以用来简化try-finally语句。 as单独没有意思，是这样使用：with....as用来代替传统的try...finally语法的。 基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。 紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。示例如下：
class Sample:
def __enter__(self):
print "In __enter__()"
return "Foo"
def __exit__(self, type, value, trace):
print "In __exit__()"
def get_sample():
return Sample()
with get_sample() as sample:
print "sample:", sample
输出结果： In __enter__()
sample: Foo
In __exit__()
第一步： __enter__()方法被执行 第二步： __enter__()方法返回的值 - 这个例子中是"Foo"，赋值给变量'sample' 第三步：执行代码块，打印变量"sample"的值为 "Foo" 第四步： __exit__()方法被调用with真正强大之处是它可以处理异常。可能你已经注意到Sample类的__exit__方法有三个参数- val, type 和 trace。这些参数在异常处理中相当有用。 你也可以参考这里:http://zhoutall.com/archives/325 |
| |
结合with使用 |
| elif |
和if配合使用的，和if配合使用的，if语句中的一个分支用elif表示。 示例如下： if a > b:
print "a > b
elif a < b:
print "a < b"
else:
print "a = b"
|
| if |
if语句用来检验一个条件， 如果 条件为真，我们运行一块语句（称为 if-块 ）， 否则 我们处理另外一块语句（称为 else-块 ）。 else 从句是可选的。 |
| or |
逻辑判断和C的||一样 |
| yield |
yield是关键字， 用起来像return，yield在告诉程序，要求函数返回一个生成器， 我这样说不是很生动。你可以去看看这个关于Python中的yield（最后写的那个斐波那契，我觉得他就是大神），或者请看下面两个代码： def createGenerator() :
mylist = range(3)
for i in mylist :
yield i*i
#理解yield
def test_yield(n):
for i in range(n):
yield i*2#每次的运算结果都返回
for j in test_yield(8):
print j,":",
print u"结束理解yield"
#利用yield输出斐波那契数列
##########
#看这里，太厉害了，不是我写的。。。。
##########
def fab(max):
a,b = 0,1
while a < max:
yield a
a, b = b, a+b
print u"斐波那契数列！"
for i in fab(20):
print i,",",
，输出结果： 0 : 2 : 4 : 6 : 8 : 10 : 12 : 14 : 结束理解yield
斐波那契数列！
0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 ,
|
| assert |
断言，这个关键字用来在运行中检查程序的正确性，和很多其他语言是一样的作用。 （断言一个条件就是真的，如果断言出错则抛出异常）用于声明某个条件为真，如果该条件不是真的，则抛出异常：AssertionError 如： assert len(mylist) >= 1
|
| else |
|
| import |
在python用import或者from...import来导入相应的模块,如： from sys import *
print('path:',path)
|
| pass |
pass的意思是什么都不要做，作用是为了弥补语法和空定义上的冲突，我理解他的好处体现在代码的编写过程之中，比如你可以先写好软件的整个框架，然后再填好框架内具体函数和class的内容，如果没有pass编译器会报一堆的错误，让整个开发过程很不流畅,如： def f(arg): pass # a function that does nothing (yet)
class C: pass # a class with no methods (yet)
|
| break |
break语句是用来 终止 循环语句的，即哪怕循环条件没有称为False或序列还没有被完全递归，也停止执行循环语句。
一个重要的注释是，如果你从for或while循环中 终止，任何对应的循环else块将不执行。 |
| except |
使用try和except语句来捕获异常 try:
block
except [exception,[data…]]:
block
try:
block
except [exception,[data...]]:
block
else:
block
该种 Python异常处理语法的规则是：
◆执行try下的语句，如果引发异常，则执行过程会跳到第一个except语句。
◆如果第一个except中定义的异常与引发的异常匹配，则执行该except中的语句。
◆如果引发的异常不匹配第一个except，则会搜索第二个 except，允许编写的except数量没有限制。
◆如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。
◆ 如果没有发生异常，则执行else块代码。 第一种格式： try:
num = 5/0
except:
print u"计算出错"
第二种格式： try:
f = open("file.txt","r") #如果该文件不存在
except IOError, e: #捕获IO异常
print u"IO错误！"
print e #输出错误信息，这里e是错误信息
输出结果： 计算出错
IO错误！
[Errno 2] No such file or directory: 'file.txt'
|
| in |
for..in是另外一个循环语句，它在一序列的对象上 递归 即逐一使用队列中的每个项目。 查找列表中是否包含某个元素，或者字符串a是否包含字符串b。需要注意的是：不可以查看list1是否包含list2。代码如下： #理解in
first_list = [1, 2]
second_list = [1, 2, 3]
element = 1
red = 'red'
red_clothes = "red clothes"
print red in red_clothes #true
print first_list in second_list #false
print element in first_list #true
输出结果：
True
False
True
|
| raise |
python raise 和java throw很类似，都是抛出异常。raise可以显示地引发异常。一旦执行raise语句，后面的代码就不执行了。如：
class MyException(Exception):pass
try:
#some code here
raise MyException
except MyException:
print "MyException encoutered"
finally:
print "Arrive finally"
#理解raise
try:
raise IOError #这里可以raise一个自定义的错误类。那样就叫做自定义异常了
print u"是否执行?" #不执行
except IOError:
print "IOError test raise"
输出结果： IOError test raise
|