Python中的关键字的用法

Python有哪些关键字

Python常用的关键字

and, del, from, not, while, as, elif, global, or, with, assert, else, if, pass, yield, break, except, import, print, class, exec, in, raise, contiue, finally, is, return, def, for, lambda, try

1.and , or

and , or 为逻辑关系用语，Python具有短路逻辑，False and 返回 False
不执行后面的语句， True or 直接返回True，不执行后面的语句

2.del

删除变量

if __name__=="__main__":
    a=1       # 对象 1 被 变量a引用，对象1的引用计数器为1
    b=a       # 对象1 被变量b引用，对象1的引用计数器加1
    c=a       #1对象1 被变量c引用，对象1的引用计数器加1
    del a     #删除变量a，解除a对1的引用
    del b     #删除变量b，解除b对1的引用
    #print a   #运行此句出错，name "a" is not defined，说明 del 删除变量a
    print(c)  #最终变量c仍然引用1
    print (c) 

而列表本身包含的是变量，例：

list = [1,2,3]
# 包含list[0],list[1],list[2]
# 并不包含数字1,2,3

所以

if __name__=="__main__":
    li=[1,2,3,4,5]  #列表本身不包含数据1,2,3,4,5，而是包含变量：li[0] li[1] li[2] li[3] li[4] 
    first=li[0]     #拷贝列表，也不会有数据对象的复制，而是创建新的变量引用
    del li[0]  # 列表本身包含的是变量，del 删除的是变量。

    print (li)      #输出[2, 3, 4, 5]
    print(first)   #输出 1

3.from

from引用模块时会用到，例：

from sys import argv
# 从sys中导入argv
from sys import *
# 将sys中所有东西都导入
import sys 
# 导入sys，当需要sys中内容时，需sys.argv而from sys import *
#不用每次都重复输入"sys."

4.golbal

golbal为全局变量，但当单个函数中出现同一变量名时，在单个函数中为局部变量

golbal q
q = 66
print ("q=", q) #q = 66
def function():
    q = 3
    print ("q =",q)
function() # q = 3
print ("q =",q) # q = 66

5.with

with被用来处理异常

• 不用with 处理文件异常

file = open("/tmp/foo.txt")
try:
    data = file.read()
finally:
    file.close()

• 用with

with open("/tmp/foo.txt")
 as file:
    data = file.read()

紧跟with后面的语句被求值后，返回对象的enter()方法被调用，这个方法的返回值将被赋值给as后面的变量，此处为file
当with后面的代码块全部被执行完后，将调用前面返回对象的exit()方法

#with 的工作      
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)
#1. __enter__()方法被执行
#2. __enter__()方法返回的值 - 这个例子中是"Foo"，赋值给变量"sample"
#3. 执行代码块，打印变量"sample"的值为 "Foo"
#4. __exit__()方法被调用

with真正强大之处是它可以处理异常。
可能你已经注意到Sample类的__exit__方法有三个参数- val, type 和 trace。
这些参数在异常处理中相当有用。

class Sample:
    def __enter__(self):
        return self

    def __exit__(self, type,
 value, trace):
        print ("type:", type)
        print ("value:",value)
        print ("trace:",trace)

    def do_something(self):
        bar = 1/0
        return bar + 10

with Sample() as sample:
    sample.do_something()

实际上，在with后面的代码块抛出任何异常时，exit()方法被执行。
正如例子所示，异常抛出时，与之关联的type，value和stack trace传给exit()方法，
因此抛出的ZeroDivisionError异常被打印出来了。
开发库时，清理资源，关闭文件等等操作，都可以放在exit方法当中。

6.while, for…in…

均为循环语句，使用while时要注意成立条件，防止陷入死循环
for in 遍历

7.assert

断言，声明其布尔值必须为真的判定，如果发生异常就说明表达示为假。
可以理解assert断言语句为raise-if-not，用来测试表示式，其返回值为假，就会触发异常。

assert 1==1
assert 1 == 2# 会报错  Asserterror
assert expression , "arguments"
#assert 表达式 [, 参数]用来解释断言并更好知道哪里错了

8.pass

pass是空语句，为了保证程序结构的完整性，
pass不做任何事情，一般用作 占位语句
当你编写程序部分内容还没想好，可用pass语句占位

def no_idea():
   pass

#实例
for letter in "python":
    if letter == "h":
        pass
        print (u"这是pass块")
    print (u"当前字母：", letter)
print ("bye,bye")

9.yield

yield的意思是生产，返回了一个生成器对象，每个生成器只能使用一次

def h():
    print ("To be brave")
    yield 5
h() 

看到某个函数包含了yield，这意味着这个函数已经是一个Generator
调用h()函数后,print 语句并未执行，执行yield用.next()方法

def h():
    print "Wen Chuan"
    yield 5
    print "Fighting!"

c = h()
# >>>c.next()# 在IDE 中不用print c.next()，直接c.next()。
# next()语句将恢复Generator执行，并直到下一个yield表达式处
# Wen Chuan 
# 5 
# 当再次运行c.next()时由于没有yield了报错
# >>>c.next()
#  Fighting 
#  Traceback (most recent call last):
#  File "/home/evergreen/Codes/yidld.py", line 11, in <module>
#   c.next()
# StopIteration

一个带有 yield的函数就是一个generation，他和普通函数不同，生成一个generator看起来像函数调用，但不会执行任何函数代码，直到对其调用.next()（在 for 循环中会自动调用 next()）才开始执行
虽然执行流程仍按函数的流程执行，但每执行到一个 yield 语句就会中断，并返回一个迭代值，下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。

#使用isgeneratorfunction判断一个函数是否是一个特殊的generator 函数
from inspect import isgeneratorfunction 
isgeneratorfunction(h) 
# True

send() 与next()

def h():
    print "Wen Chuan",
    m = yield 5  # Fighting!
    print m
    d = yield 12
    print "We are together!"

c = h()
m = c.next()  #m 获取了yield 5 的参数值 5
d = c.send("Fighting!")  #d 获取了yield 12 的参数值12
print "We will never forget the date", m, ".", d

send()可以传递yield表达式的值进去，而next()不能传递特定的值，只能传递None进去。
因此，我们可以看做c.next() 和 c.send(None) 作用是一样的
注意！！！第一次调用时，请使用next()语句或是send(None)，不能使用send发送一个非None的值，否则会出错的，因为没有yield语句来接收这个值

10.break 与 contiue

Python break语句用来终止循环，用在while和for循环中！！直接跳出 整个 循环
嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码

for letter in "python":# 第一个例子
    if letter == "h"
        break 
    print (u"当期字母：",letter)
#输出到"p""y""t"    

var= 10 # 第二个例子
while var > 0:
    print (u"当期字母：",var )
    var = var -1
    if var == 5
       break
#输出到6       
print ("bye")

break是跳出整个循环，continue是跳出当前循环

#例1
for letter in "pyhton":
    if letter == "h":
        continue
    print (u"当前字母：", letter)
#打印出 pyton

#例2
var = 10
while var > 0:
    var -= 1
    if var == 5:
        continue
    print (u"当前字母：", var)
#结果 98764321

11.try except finally

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了"name"异常
except <名字>，<数据>:
<语句>        #如果引发了"name"异常，获得附加的数据
else:
<语句>        #如果没有异常发生

如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

try:
    try:
        raise NameError
    except TypeError:
        print ("as")
except NameError:
    print ("e")

e，try后语句raise触发异常，except没有匹配字句，被抛到上层try匹配，print “e”

try:    
     1/0
except Exception , e:    
     print e 
#以上传统的异常处理，加入!!!traceback后会打印出详细的错误信息
import traceback
try:   
      1/0
except Exception: 
     traceback.print_exc()

try:
<语句>
finally:
<语句>    #退出try时总会执行
raise

try:
    1 / 0
except Exception as e:
    """异常的父类，可以捕获所有的异常"""
    print "0不能被除"
else:
    """保护不抛出异常的代码"""
    print "没有异常"
finally:
    print "最后总是要执行我"

12.raise

触发异常

raise [Exception[,args[,traceback]]]

语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。
该参数是可选的，如果不提供，异常的参数是”None”。
最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。

def mye( level ):
    if level < 1:
        raise Exception("Invalid level!", level)

raise 触发异常后，后面的代码就不会再执行

try:
     s = None
     if s is None:
         print ("s 是空对象")
         raise NameError     #如果引发NameError异常，后面的代码将不能执行
     print (len(s)  #这句不会执行，但是后面的except还是会走到
except TypeError:
     print ("空对象没有长度") #由于错误类型并不是TypeError,不执行print

try:
     s = None
     if s is None:
         print (u"s 是空对象")
         raise NameError("name is wrong","is")     #如果引发NameError异常，后面的代码将不能执行
     print (len(s))  #这句不会执行，但是后面的except还是会走到
except NameError,argvment:
     print (u"空对象没有长度",argvment)
"""
学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：489111204 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
"""
s = None
if s is None:
    raise NameError

 print ("is here?") #如果不使用try......except这种形式，那么直接抛出异常，不会执行到这里

def mye( level ):
    if level < 1:
        raise Exception("Invalid level!", level)
        # 触发异常后，后面的代码就不会再执行

try:
    mye(0)                # 触发异常
except "Invalid level!":
    print (1)
else:
    print (2)

die函数，打印错误信息

def die(error_massage):
    raise Exception(error_massage)

a = "wer"
if a == None:
    print ("None")
else:
    die()

13.exec–eval–execfile

exec 用来执行储存在字符串或文件中的Python语句
exec是一条语句将字符串str当成有效的python代码来执行
eval与execfile是pytho内置函数
eval(str[globals[locals]])函数将字符串str当成有效的python表达式来求值，并提供返回计算值

exec "print"hello world""
exec "a=100"
# 执行后 a = 100
print (a) #100
eval("3+5")# 8
b = eval("5+6")#eval 返回计算值
print (b + 1) #12

execfile(filename)函数可以用来执行文件

execfile(r"F:learnex1.py")
# 若你位于文件所在目录直接执行
execfile(r"ex1.py")

from os.path import exists
exists(file)将文件名字符串作为参数，如果文件存在返回True，否则返回False

14.return

return 是函数返回值

def fun():
    print ("asd")
# fun() 函数没有显示return,默认返回None

def fan(a):
    return a
#有返回值

15.lambda—filter—map—reduce—

lambda 只是一个表达式，定义了一个匿名函数，起到函数速写的作用
由于lambda只是一个表达式，它可以直接作为python 列表或python 字典的成员，比如

info = [lambda a:a**3 , lambda b:b**3]

g = lambda x:x+1
g(1) #2 等价于 lambda x:x+1(1)
g(3) #4
#其中 x 为入口参数，x+1 为函数体
#用的函数来同样表示
def g(x):
    return x+1


#lambda 也可以用在函数中
def action(x):
    return lambda y:x+y

a = action(3)# a是action函数的返回值，
a(22) # 24 ，a(22) ，调用了action返回的lambda表达式
# 上面函数也可直接写成下式
b = lambda x:lambda y:x+y
a = b(3)
a(2) # 也可直接 (b(3))(2)


# lambda 可以一个、多个参数
g = lambda x:x*2 #one
print (g(3))

m = lambda x,y,z: (x-y)*z # mutiple
print (m(3,1,2))

#lambda 并不会带来程序运行效率的提高，只会使代码更简洁。
#如果可以使用for...in...if来完成的，坚决不用lambda。
#如果使用lambda，lambda内不要包含循环，如果有，我宁愿定义函数来完成，
#使代码获得可重用性和更好的可读性。
# lambda 是为了减少单行函数的定义而存在的。


# --filter(function or None, sequence) -> list, tuple, or string
# function是一个谓词函数，接受一个参数，返回布尔值True或False。
# filter函数会对序列参数sequence中的每个元素调用function函数，
# 最后返回执行结果为True的
# 返回值的类型和参数sequence（list, tuple, string）的类型相同
foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]

print (filter(lambda x: x % 3 == 0, foo))# filter 是 过滤/筛选 函数
print([x for x in foo if x % 3==0]) #[18, 9, 24, 12, 27] 筛选foo中能被3整除的

map(function, sequence)
对sequence中的item 依次执行 function，将执行结果组成list返回
单个参数

str = ["a", "b","c", "d"] 

def fun2(s): 
    return s + ".txt"

ret = map(fun2, str)
print (ret) # ["a.txt", "b.txt", "c.txt", "d.txt"]

多个参数，要求函数接受多个参数

def add(x,y):
    return x+y

print (map(add,range(5),range(5)))
#[0,2,4,6,8]

foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
print (map(lambda x: x * 2 + 10, foo)) 
#[14, 46, 28, 54, 44, 58, 26, 34, 64]

reduce(function, sequence, starting_value)
对sequence中的item顺序迭代调用function，如果有starting_value，
还可以作为初始值调用，例如可以用来对List求和

def add1(x,y):
    return x+y

print reduce(add1,range(1,100))
# 4950 注：1+2+...+99
print reduce(add1,range(1,100),20)
# 4970 注：1+2+...+99+20，20为初始值