python中标示符作用详解

python中的标示符

在python里，标识符有字母、数字、下划线组成。

在python中，所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头。

python中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用"fromxxx import *"而导入；

以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如__init__（）代表类的构造函数。

 

一、python中的保留字：

1 and

python 中的and从左到右计算表达式，若所有值均为真，则返回最后一个值，若存在假，返回第一个假值。

例子：

(1)print'a' and 'b';

输出值(返回第一个真值)：

b

(2)print ''and'b

输出值(返回第一个假值)：

为'空

2 exec

该语句用来执行储存在字符串或文件中的Python语句。例如，我们可以在运行时生成一个包含Python代码的字符串，然后使用exec语句执行这些语句。下面是一个简单的例子

exec 'print"hello world!"'

输出值（执行了该语句）：

hello world！

3 not

在python中not是逻辑判断词，用于布尔型True和False，not True为False，notFalse为True，以下是几个常用的not的用法：

(1) not与逻辑判断句if连用，代表not后面的表达式为False的时候，执行冒号后面的语句。比如：

a = False

if not a:   (这里因为a是False，所以not a就是True)

   print "hello"

这里就能够输出结果hello

(2)判断元素是否在列表或者字典中，if a not in b，a是元素，b是列表或字典，这句话的意思是如果a不在列表b中，那么就执行冒号后面的语句，比如：

a = 5

b = [1, 2, 3]

if a not in b:

   print "hello"

这里也能够输出结果hello

4 assert

（1）语句用来声明某个条件是真的。

（2）如果你非常确信某个你使用的列表中至少有一个元素，而你想要检验这一点，并且在它非真的时候引发一个错误，那么语句是应用在这种情形下的理想语句。

（3）当assert语句失败的时候，会引发例如：

buf = ['abc'];

assert len(buf)>=1

buf.pop() #之后buf为长度为0

assert len(buf) ==1#该条件为假，就会引发

输出结果：

Traceback (most recent call last):

 assert len(buf) ==1

AssertionError

5 finally

假如你在读一个文件的时候，希望在无论异常发生与否的情况下都关闭文件，该怎么做呢？这可以使用块来完成。

例如：

import time

try:

    f=file('poem.txt')

    while True: 

        line =f.readline()

        if len(line)== 0:

           break

       time.sleep(10)

        print line,

finally:

    f.close()

    print "Cleaningup...closed the file" 

执行结果：

heheheheheheheeh!!!!!!!!!! Cleaningup...closed the file

特别注意：你所读取的文件一定要有数据，否则直接break，不执行休眠10S，另外finally必须和try对齐，python中队格式要求非常严格，因为不同的格式决定该部分属于不同的分支。

6 or

从左到右计算，返回第一个为真的值。

‘’or'b'#返回值为b

7 break

Python break语句，就像在C语言中，打破了最小封闭for或while循环。

break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

break语句用在while和for循环中。

如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

8 for

在C/C++中，如果你想要写for (int i = 0; i < 5; i++)，那么用Python，你写成for i in range(0,5)

例如：

import math

i = 0
for i in range(0,10):
    print"%d"%i

注意：此处的i会自动加1，打印10次i的值0~9，格式输出在双引号外加%+变量

9 pass

空语句 do nothing；保证格式完整；保证语义完整；以if语句为例：

C语言中:

if(true)

; // do nothing

else

{} // do nothing

python中写法：

if true:

pass # do nothing

else:

print "dosomething."

10 class

#class类
class GrandPa:
    def __init__(self):
        print"'I\'m GrandPa"
        
class Father(GrandPa):
    def __init__(self):
        print"'I\'m Father!"
        
class Son(Father):
    i = 12345
    def __init__(self):
        print('这是构造函数,son')
    def sayHello(self):
        return 'hello world'
if __name__ == 'hello':
    print""
    GrandPa()
    Father()
    son = Son()
#   print"__name__:%s"%__name__
#   print"__main__:%s"%'__main__'
    # 类型帮助信息 
    print"类型帮助信息:%s"%Son.__doc__
    #类型名称
    print"类型名称:%s"%Son.__name__
    #类型所继承的基类
    print"类型所继承的基类:%s"%Son.__bases__
    #类型字典
    print"类型字典:%s"%Son.__dict__
    #类型所在模块
    print"类型所在模块:%s"%Son.__module__
    #实例类型
    print"实例类型:%s"%Son().__class__

运行输出：

'I'm GrandPa
'I'm Father!
这是构造函数,son
类型帮助信息:None
类型名称:Son
类型所继承的基类:hello.Father
类型字典:{'i': 12345, '__module__': 'hello', 'sayHello':<function sayHello at 0x0000000002ED9198>, '__doc__': None, '__init__':<function __init__ at 0x0000000002ED9128>}
类型所在模块:hello
这是构造函数,son
实例类型:hello.Son

11 form

在python用import或者from...import来导入相应的模块。模块其实就是一些函数和类的集合文件，它能实现一些相应的功能，当我们需要使用这些功能的时候，直接把相应的模块导入到我们的程序中，我们就可以使用了。这类似于C语言中的include头文件，Python中我们用import导入我们需要的模块

一般使用import，from import有时会带来conflict冲突，且不易读。

12 print

打印字符串和变量值进行输出：

输出一个字符串：

print"hello world";

输出一个值：

   直接输出值：

      a= 10

      printa

   格式输出值：

      a= 10
      print "a=%d"%a

输出一个浮点数值：

a = 10.46456
print "a=%8.3f"%a

输出值：

a=  10.465

特别说明：8.3分别指整个宽度为8，精度为3，整个宽度指从5到=右边的空格共8位，小数点自身算1位，精度3指小数点后3位

13 continue

# 第一个实例
for letter in 'Python':    
    if letter == 'h':
       continue
    print '当前字母 :', letter
# 第二个实例
var = 10                   
while var > 0:              
    var = var -1
    if var == 5:
       continue
    print '当前变量值 :', var
print "Good bye!"

14 global

global---将变量定义为全局变量。可以通过定义为全局变量，实现在函数内部改变变量值。

一个global语句可以同时定义多个变量，如 global x, y, z

globalm
m=10;
print"m=%d"%m;
def func():
    m=20;
    return m
print "func=%d"%func();

输出结果：

m=10
func=20

global声明的全局变量可以再函数内外改变其值。

15 raise

当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。

例子：

#raise
try:
    ver = True;
    if ver is True:
        print ver;
        print"raise Sucess!";
        raise NameError
        print "可执行"
    else:
        print"No raise!"
except TypeError:
    print"空对象"

执行结果：

True
raise Sucess!
NameError
ERROR: Module: hello could not be imported (file:H:\NetLeran\workspace\test\hello.py).

16 def和lambda

python lambda是在python中使用lambda来创建匿名函数，而用def创建的方法是有名称的，除了从表面上的方法名不一样外，python lambda还有哪些和def不一样呢？

1 python lambda会创建一个函数对象，但不会把这个函数对象赋给一个标识符，而def则会把函数对象赋值给一个变量。
2 python lambda它只是一个表达式，而def则是一个语句。

下面是python lambda的格式，看起来好精简阿。

1. lambda x: print x

如果你在python 列表解析里用到pythonlambda，我感觉意义不是很大，因为python lambda它会创建一个函数对象，但马上又给丢弃了，因为你没有使用它的返回值，即那个函数对象。也正是由于lambda只是一个表达式，它可以直接作为python 列表或python 字典的成员，比如：

1. info = [lamba a: a**3, lambda b: b**3]

在这个地方没有办法用def语句直接代替。因为def是语句，不是表达式不能嵌套在里面，lambda表达式在“：”后只能有一个表达式。也就是说，在def中，用return可以返回的也可以放在lambda后面，不能用return返回的也不能定义在python lambda后面。因此，像if或for或print这种语句就不能用于lambda中，lambda一般只用来定义简单的函数。

下面举几个python lambda和def的例子吧
1单个参数的：

lambda方法：
gol = lambda b:b*5
print gol(3)
结果是15

def方法：

defgol(x):
    return 7*x
print gol(3)

输出结果是：21

特别说明：网上有这样的例子

gol =lambda b*3

printgol(3)

我在执行的时候发现错误，也许是版本的问题，有高手经过希望解释？

多个参数的：

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

#def方法：
def func1(x,y,z):
    return (x-y)*z
m=func1(3,1,2)
print"m2 = %d"%m;

输出结果是：4

17、if 和else

C和C++中if和else使用

if(a==5)

{/*执行的内容*/}

else

{/*执行的内容*/}

python中if和else使用：

if a is 5:

/*执行的内容*/

else:

/*执行的内容*/

18 return

return语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回一个值。基本和C相同

19 del

del用于list列表操作，删除一个或者连续几个元素：例子

listarr = [1,2,3,4,5,6,7,8,9]
del listarr[2:4] #删除下标从2到4的元素
print "listarr:%s"%listarr
del listarr[2]      #删除下标为2的元素
print "listarr:%s"%listarr
del listarr[1:5] #删除下标为1到5的元素
print "listarr:%s"%listarr

输出结果：

listarr:[1, 2, 5, 6, 7, 8, 9]
listarr:[1, 2, 6, 7, 8, 9]
listarr:[1, 9]

20 import

在python用import或者from...import来导入相应的模块。模块其实就是一些函数和类的集合文件，它能实现一些相应的功能，当我们需要使用这些功能的时候，直接把相应的模块导入到我们的程序中，我们就可以使用了。这类似于C语言中的include头文件，Python中我们用import导入我们需要的模块。

21 try/except/else/finally语句

与其他语言相同，在python中，try/except语句主要是用于处理程序正常执行过程中出现的一些异常情况，如语法错误（python作为脚本语言没有编译的环节，在执行过程中对语法进行检测，出错后发出异常消息）、数据除零错误、从未定义的变量上取值等；而try/finally语句则主要用于在无论是否发生异常情况，都需要执行一些清理工作的场合，如在通信过程中，无论通信是否发生错误，都需要在通信完成或者发生错误时关闭网络连接。尽管try/except和try/finally的作用不同，但是在编程实践中通常可以把它们组合在一起使用try/except/else/finally的形式来实现稳定性和灵活性更好的设计。

默认情况下，在程序段的执行过程中，如果没有提供try/except的处理，脚本文件执行过程中所产生的异常消息会自动发送给程序调用端，如pythonshell，而python shell对异常消息的默认处理则是终止程序的执行并打印具体的出错信息。这也是在python shell中执行程序错误后所出现的出错打印信息的由来。

python中try/except/else/finally语句的完整格式如下所示：

try:

     Normal executionblock

except A:
     Exception A handle

except B:

     Exception B handle

except:

     Other exceptionhandle

else:
     if no exception,get here

finally:
     print("finally")   

说明：

正常执行的程序在try下面的Normal execution block执行块中执行，在执行过程中如果发生了异常，则中断当前在Normal execution block中的执行跳转到对应的异常处理块中开始执行；

python从第一个except X处开始查找，如果找到了对应的exception类型则进入其提供的exception handle中进行处理，如果没有找到则直接进入except块处进行处理。except块是可选项，如果没有提供，该exception将会被提交给python进行默认处理，处理方式则是终止应用程序并打印提示信息；

如果在Normal execution block执行块中执行过程中没有发生任何异常，则在执行完Normal execution block后会进入else执行块中（如果存在的话）执行。

无论是否发生了异常，只要提供了finally语句，以上try/except/else/finally代码块执行的最后一步总是执行finally所对应的代码块。

需要注意的是：

1.在上面所示的完整语句中try/except/else/finally所出现的顺序必须是try-->exceptX-->except-->else-->finally，即所有的except必须在else和finally之前，else（如果有的话）必须在finally之前，而except X必须在except之前。否则会出现语法错误。

2.对于上面所展示的try/except完整格式而言，else和finally都是可选的，而不是必须的，但是如果存在的话else必须在finally之前，finally（如果存在的话）必须在整个语句的最后位置。

3.在上面的完整语句中，else语句的存在必须以except X或者except语句为前提，如果在没有except语句的try block中使用else语句会引发语法错误。也就是说else不能与try/finally配合使用。

4.except的使用要非常小心，慎用。

class AError(Exception):
     """AError---exception"""
     print('AError')
 
try:
     #raise AError
    df(4)
except AError:
     print("Get AError")
except:
     print("exception")     
else:
     print("else")
finally:
     print("finally")     
print("hello wolrd")

执行结果：

AError
exception
finally
hello wolrd

在上面的代码中，Normal execution block中出现了语法错误，但是由于使用了except语句，该语法错误就被掩盖掉了。因此在使用try/except是最好还是要非常清楚的知道Normal executionblock中有可能出现的异常类型以进行针对性的处理。

如果上述函数中不定义class AError(Exception):函数处理异常，那么函数执行到try中系统将会自动报错，最后只执行finally中的内容。

22 elif

elif语句可以检查多个表达式的真值，并执行一个代码块的条件之一计算结果为true。

if...elif语句是可选的。然而不像else，对此可以有最多一个语句，if语句下边可以有任意数量elif语句。

if...elif语句的语法是：

var = 100

if var == 200:

    print "1 - Got atrue expression value"

    print var

elif var == 150:

    print "2 - Got atrue expression value"

    print var

elif var == 100:

    print "3 - Got atrue expression value"

    print var

else:

    print "4 - Got afalse expression value"

    print var

print "Good bye!

执行结果：

3 -Got a true expression value

100

Goodbye!

23 in和is

in和is用处不同
in是判断某个元素是否在集合中
is是判断二个参数对像id是否相同，可以把对象id理解为指针

例子：

#in 和is

a=[1,2,3]

b=[1,2,3]

c=d=[1,2,3]

print("a is b:%s"%(a is b))

print("a in b:%s"%(a in b))

print("c is d:%s"%(c is d))

print("c in d:%s"%(c in d))

输出结果：

a is b:False

a in b:False

c is d:True

c in d:False

从上面可以得出 ：首先a和b是分别定义的，即使它们值相同，也会在内存中创建二个对像，所以它们的对象id并不同。
其次c和d已经指明，c＝d，因而是同时创建的，所以二者是指向同个数据区的，即对象id相同
这也就是c is d 结果为ture，而a is b结果为false的原因了；而c in d含义是c是d中的一个元素为True，不是为False，很显然c是一个和d相同的元组。

24 while

循环语句

count = 0
while (count < 9):
print 'The count is:%d'%count
count = count + 1
print "Good bye!"

执行结果：

The count is:0
The count is:1
The count is:2
The count is:3
The count is:4
The count is:5
The count is:6
The count is:7
The count is:8
Good bye!

25 with

1.紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法

file = open("foo.txt")
try:
    data = file.read()
    print data
    print"fileopen:",file
finally:
    file.close()
    print"fileclose:",file
#使用with as   
with open("foo.txt") as fd:
    data = fd.read()
    print data
    print"fdopen:",fd
print"fdclose:",fd

执行结果：

open txt!
Sucess!
fileopen: <open file 'foo.txt', mode 'r' at 0x0000000002D3C1E0>
fileclose: <closed file 'foo.txt', mode 'r' at 0x0000000002D3C1E0>
open txt!
Sucess!
fdopen: <open file 'foo.txt', mode 'r' at 0x0000000002D3C030>
fdclose: <closed file 'foo.txt', mode 'r' at 0x0000000002D3C030>

从上面的例子可以看出with as打开文件处理后能够自动将文件关闭，不需要向第一种方法一样认为close文件，代码优化且稳定了许多。

2.下面是一个队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

执行结果：

In__enter__()
sample: Foo
In__exit__()

26 yield

简单地讲，yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator，调用 fab(5) 不会执行 fab 函数，而是返回一个 iterable 对象！在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。

下面例子可以看出，实质上迭代器每次将b的值付给了n

#yield
n=0
def fab(max): 
    i, a, b = 0, 0, 1 
    while i < max: 
        yield b  #每次执行到此处都会将值
        a, b = b, a + b 
        #print"b:",b 
        i = i+1
for n in fab(7):
    print "n:",n;

执行结果：

n: 1
n: 1
n: 2
n: 3
n: 5
n: 8
n: 13

也可以手动调用 fab(5) 的 next() 方法（因为 fab(5) 是一个 generator 对象，该对象具有 next() 方法），这样我们就可以更清楚地看到 fab 的执行流程：

 >>> f = fab(5) 
 >>> f.next() 
 1 
 >>> f.next() 
 1 
 >>> f.next() 
 2 
 >>> f.next() 
 3 
 >>> f.next() 
 5 
 >>> f.next() 
 Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
 StopIteration

当函数执行结束时，generator 自动抛出 StopIteration 异常，表示迭代完成。在 for 循环里，无需处理 StopIteration 异常，循环会正常结束。

我们可以得出以下结论

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

yield 的好处是显而易见的，把一个函数改写为一个 generator 就获得了迭代能力，比起用类的实例保存状态来计算下一个 next() 的值，不仅代码简洁，而且执行流程异常清晰。

如何判断一个函数是否是一个特殊的 generator 函数？可以利用 isgeneratorfunction 判断：

#迭代器
from inspect import isgeneratorfunction 
print isgeneratorfunction(fab)    

执行结果：

True

欢迎提出问题，指出不足，一起学习一起进步！