翻看企业的代码文书档案,在代码风格文书档案中,写着:为了巩固代码的可维护性,代码中减掉flag那类状态变量的运用。那么些难点,平日确实并未有想过,面对那种须求时,第一影响就是应用flag标识状态。那么使用什么的技巧或代码结构技术,才具代表状态变量的应用啊?我想开的点子是应用else。

python中动用else代替状态变量,pythonelse

翻看商家的代码文书档案,在代码风格文档中,写着:为了增强代码的可维护性,代码中减弱flag那类状态变量的运用。这一个主题素材,平日实在未有想过,面对那种须求时,第3反响就是运用flag标志状态。那么使用什么的本领或代码结构技术,才具代表状态变量的利用呢?笔者想开的艺术是应用else。

提起else,最常用的语法是if-elif-else,实际上else是能够与巡回和try搭配使用的,上边我写了一个else替换状态变量的事例,使用插入法对数组排序。首先采用状态变量落成,代码如下:

def insertion_sort(input_list):
    if len(input_list) <= 1:
        return input_list
    _sorted = input_list[:1]

    for i in input_list[1:]:
        inserted = False
        for j in xrange(len(_sorted)):
            if i <= _sorted[j]:
                _sorted.insert(j, i)
                inserted = True
                break
        if not inserted:
            _sorted.append(i)
    return _sorted

动用inserted来标志新成分是或不是实施了插入操作,假若未实行的话,将成分插入到最后一位。

行使else替代状态变量,python中央银行使else代替状态变量。上边给出使用else替换inserted的代码达成:

 

def insertion_sort1(input_list):
    if len(input_list) <= 1:
        return input_list
    _sorted = input_list[:1]

    for i in input_list[1:]:
        for j in xrange(len(_sorted)):
            if i <= _sorted[j]:
                _sorted.insert(j, i)
                break
        else:
            _sorted.append(i)
    return _sorted

 

当for循环实施总体,中途未有break的话,就能推行else操作,也就起到了和inserted一样的功用。

else在try…except…else…finally的流水生产线调整语法中平等适用,当程序没走进except时,就能够选拔else
中的代码,大家就无需定义状态变量来记录程序是或不是走入except,代码如下:

def divide(x, y):
    try:
        result = x / y
    except ZeroDivisionError:
        print("error: division by 0!")
    else:
        print "result = %s" % result
    finally:
        print("divide finished!")

因为每一种人的形成习于旧贯差别,那种python独有的语法并不被提倡,而且只要代码嵌套了多层循环,那么使用else替代状态变量也降低了代码的可读性。可是1旦python使用丰盛熟谙,在有个别简单易行的轮回调控语句中,我们透过else摆脱一些繁琐的状态变量,依旧亮点的。

 

翻看铺子的代码文书档案,在代码风格文档中,写着:为了巩固代码的可维护性,代码中核减flag那类状态…

Python 中的 else详解,pythonelse详解

大家都驾驭 Python 中else的主干用法是在尺度决定语句中的
if…elif…else…,不过 else
还有七个其他的用途,一是用来循环的尾声,另三个是用在错误管理的 try
中。那原本是 Python
的正式语法,但鉴于和大部分别样编制程序语言的习贯不太一致,致使人们有意或下意识地忽视了这个用法。别的,对于那个用法是还是不是顺应
0×00 The Zen of Python
的条件以及该不应该普遍利用也存在不少争执不休。比如在自己看出的两本书里(Effective
Python VS Write Idiomatic
Python),两位小编就分别对其颇具相差甚远的态势。

巡回中的 else

跟在循环前面包车型大巴 else 语句只有在当循环内没出现break,约等于健康循环完结时才会实行。首先大家来看二个计划排序法的例子:

from random import randrange
def insertion_sort(seq):
  if len(seq) 1:
    return seq
  _sorted = seq[:1]
  for i in seq[1:]:
    inserted = False
    for j in range(len(_sorted)):
      if i _sorted[j]:
        _sorted = [*_sorted[:j], i, *_sorted[j:]]
        inserted = True
        break
    if not inserted:
      _sorted.append(i)
  return _sorted

print(insertion_sort([randrange(1, 100) for i in range(10)]))

[8, 12, 12, 34, 38, 68, 72, 78, 84, 90]

在那么些例子中,对已排序的 _sorted 成分每一种与 i 实行比较,若 i
比已排序的保有因素都大,则不得不排在已排类别表的结尾。那时我们就需求一个外加的状态变量
inserted 来标识完结遍历循环照旧半路被 break,在那种场合下,大家得以用
else 来代表这1状态变量:

def insertion_sort(seq):
  if len(seq) 1:
    return seq
  _sorted = seq[:1]
  for i in seq[1:]:
    for j in range(len(_sorted)):
      if i _sorted[j]:
        _sorted = [*_sorted[:j], i, *_sorted[j:]]
        break
    else:
      _sorted.append(i)
  return _sorted
print(insertion_sort([randrange(1, 100) for i in range(10)]))

[1, 10, 27, 32, 32, 43, 50, 55, 80, 94]

自己感觉那是二个相当酷的做法!可是要小心的是,除了 break 能够触发前面包车型大巴else 语句,未有循环的时候也会:

while False:
  print("Will never print!")
else:
  print("Loop failed!")


Loop failed!

谬误捕捉中的 else

try…except…else…finally
流程序调节制语法用于捕捉大概出现的相当并实行对应的管理,个中 except 用于捕捉
try 语句中出现的不当;而 else 则用于拍卖未有出现谬误的情事;finally 肩负try 语句的”善后职业“ ,无论怎样都会实行。可以经过二个简约的例子来呈现:

def divide(x, y):
  try:
    result = x / y
  except ZeroDivisionError:
    print("division by 0!")
  else:
    print("result = {}".format(result))
  finally:
    print("divide finished!")
divide(5,2)
print("*"*20)
divide(5,0)



result = 2.5
divide finished!
********************
division by 0!
divide finished!

自然,也足以用状态变量的做法来代表 else:

def divide(x, y):
  result = None
  try:
    result = x / y
  except ZeroDivisionError:
    print("division by 0!")
  if result is not None:
    print("result = {}".format(result))
  print("divide finished!")

divide(5,2)
print("*"*20)
divide(5,0)



result = 2.5
divide finished!
********************
division by 0!
divide finished!

总结

有人感觉 else 的这个用法违反直觉可能是 implicit 而非
explicit,不值得说倡。但自身觉着那种”判决“须求看重具体的使用场景以及大家对
Python 的掌握,并非一定要对新人友好的语法才算是 explicit
的。当然也不引入在富有地点都应用这一个语法,for/while…else
最大的症结在于 else 是供给与 for/file
对齐的,若是是多层嵌套也许循环体太长的景色,就特别不合乎用
else(纪念一下游标卡尺的梗就知晓了:P)。唯有在部分简便的循环调节语句中,大家经过
else 摆脱一些累赘的状态变量,那才是最 Pythonic 的利用场景!

中的 else详解,pythonelse详解 我们都通晓Python 中else的中央用法是在标准决定语句中的 if…elif…else…,可是else 还有多个别的的用处,…

查看关键字的法子

聊起else,最常用的语法是if-elif-else,实际上else是能够与循环和try搭配使用的,下边作者写了一个else替换状态变量的例子,使用插入法对数组排序。首先使用状态变量达成,代码如下:

翻看全体的首要字:help(“keywords”)

def insertion_sort(input_list):
    if len(input_list) <= 1:
        return input_list
    _sorted = input_list[:1]

    for i in input_list[1:]:
        inserted = False
        for j in xrange(len(_sorted)):
            if i <= _sorted[j]:
                _sorted.insert(j, i)
                inserted = True
                break
        if not inserted:
            _sorted.append(i)
    return _sorted
>>> help("keywords")

Here is a list of the Python keywords.  Enter any keyword to get more help.

False               def                 if                  raise
None                del                 import              return
True                elif                in                  try
and                 else                is                  while
as                  except              lambda              with
assert              finally             nonlocal            yield
break               for                 not
class               from                or
continue            global              pass

选择inserted来标志新成分是或不是施行了插入操作,假若未推行的话,将成分插入到最后一位。

或者

上面给出使用else替换inserted的代码落成:

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

 

重大字概述

关键字 含义
and 为逻辑关系用语,Python具有短路逻辑,不执行后面的语句,False and 返回 False
as 使用标准库中的模块,如import cPickle as p
assert 断言,声明其布尔值必须为真的判定,如果发生异常就说明表达示为假。 可以理解assert断言语句为raise-if-not,用来测试表示式,其返回值为假,就会触发异常。
break 提前跳出一个块
class 定义类
continue 回到一个块的开始处
def def关键字进行函数的定义,不用指定返回值的类型。
del 删除变量
elif 和if配合使用的,if语句中的一个分支用elif表示。
else 用在条件语句中,表明当条件不成立时的分支
except 和try一起使用,用来捕获异常。
False 数据类型bool(布尔)类型的实例对象(值),假
finally 用于处理异常情况,用来声明一个基本肯定会被执行到的语句块
for 一种循环结构的引导词
from 在python用import或者from…import来导入相应的模块
global golbal为全局变量,但当单个函数中出现同一变量名时,在单个函数中为局部变量
if 条件语句的引导词
import 导入相应的库
in 迭代器
is is 和 is not 是Python下判断同一性的关键字
lambda 即匿名函数,不用想给函数起什么名字。提升了代码的简洁程度。
None 空对象,空值是Python里一个特殊的值
nonlocal 用来在函数或其他作用域中使用外层(非全局)变量
not 布尔的非
pass 空语句 do nothing,保证格式完整,保证语义完整
raise 触发异常后,后面的代码就不会再执行
return 从成员方法中返回数据
True 数据类型bool(布尔)类型的实例对象(值),真
or 为逻辑关系用语,Python具有短路逻辑,不执行后面的语句, True or 直接返回True,
try 尝试一个可能抛出异常的程序块
while 用在循环结构中
with with被用来处理异常
yield 意思是生产,返回了一个生成器对象,每个生成器只能使用一次
def insertion_sort1(input_list):
    if len(input_list) <= 1:
        return input_list
    _sorted = input_list[:1]

    for i in input_list[1:]:
        for j in xrange(len(_sorted)):
            if i <= _sorted[j]:
                _sorted.insert(j, i)
                break
        else:
            _sorted.append(i)
    return _sorted

判断、循环

金沙注册送58 ,Python的巡回及看清首要包蕴那个首要字:
if  elif  else  for  while  break  continue  and  
or  is  not  in

if 语法、while语法、for语法以及and…or语法

 

if 语法

  • if-else的使用格式

if 条件:
    满足条件时要做的事情1
    ...(省略)...
else:
    不满足条件时要做的事情1
    ...(省略)...
  • elif的功能

if 条件1:
    满足条件1时要做的事情
    ...
elif 条件2:
    不满足条件1,满足条件2时要做的事情
    ...
else:
    不满足条件1,2时要做的事情
    ...

当for循环试行总体,中途未有break的话,就能施行else操作,也就起到了和inserted一样的效益。

while语法

while 条件:
    条件满⾜时,做的事情1
    条件满⾜时,做的事情2
    条件满⾜时,做的事情3
    ...(省略)...

else在try…except…else…finally的流水生产线调整语法中一样适用,当程序没走进except时,就能选择else
中的代码,我们就没有供给定义状态变量来记录程序是还是不是走入except,代码如下:

for语法

for 临时变量 in 列表或者字符串等:
    循环满⾜条件时执⾏的代码
else:
    循环不满⾜条件时执⾏的代码

break的作⽤:⽤来结束全数循环
continue的作⽤:⽤来甘休本次巡回,紧接着执⾏下⼀次的大循环

def divide(x, y):
    try:
        result = x / y
    except ZeroDivisionError:
        print("error: division by 0!")
    else:
        print "result = %s" % result
    finally:
        print("divide finished!")

and…or语法

  
Python的and/or操作与其余语言分化的是它的再次回到值是参加剖断的三个值之1,所以我们得以通过那个特点来得以落成Python下的
a ? b : c !

  Python下大家可以那样用:“ a and b or c
”(此办法中务必保险b必须是True值),python自左向右推行此句,先推断a
and b :假若a是True值,a and b语句仍须要实践b,而此时b是True值!所以a
and b的值是b,而这时a and b or c就成为了b or c,因b是True值,所以b or
c的结果也是b;纵然a是False值,a and b语句的结果正是a,此时 a and b or
c就转向为a or c,因为此时a是 False值,所以不管c是True 依然Flase,a or
c的结果正是c

当bool and a or b相当于bool? a: b
注:但是卓殊情形是,若a为假,则不会一定于,而是重临b
化解办法:用 (bool and [a] or [b])[0]代替

因为各类人的产生习惯分裂,那种python独有的语法并不被提倡,而且只要代码嵌套了多层循环,那么使用else替代状态变量也降低了代码的可读性。可是如若python使用丰富熟稔,在某些简约的大循环调整语句中,大家透过else摆脱一些麻烦的状态变量,依然亮点的。

函数、模块、类

对此Python的函数及模块主要总结这一个重大字:
from  import  as  def  pass  lambda  return  class

 

模块

  Python的编制程序经常大量用到标准库中的模块,使用方法正是选取import
、from以及as 关键字。

比如:

import sys  # 导入sys模块
from sys import argv   # 从sys模块中导入argv ,这个在前面介绍脚本传参数时使用到
import cPickle as p     # 将cPickle模块导入并在此将它简单命名为p,此后直接可以使用p替代cPickle模块原名,这个在介绍文件输入输出时的存储器中使用到
  • from…import

如 from A import b,相当于
  import A
  b=A.b

再如:
“from t2 import var1” 相当于:
  import t2
  var1= t2.var1
在此进程中有一个包罗的赋值的进度

  • import……as

  import A as B,给予A库二个B的小名,援救纪念

函数

Python中定义函数时利用到def根本字,如果你眼下不想写入真实的函数操作,能够应用pass重视字指代不做别的操作

def

def function(params):
    block
    return expression/value
  • 在Python中动用def关键字张开函数的概念,不用钦命再次回到值的连串。

  • 函数参数params可以是零个、二个或许八个,同样的,函数参数也绝不钦定参数类型,因为在Python中变量都以弱类型的,Python会自动依照值来保险其项目。

  • return语句是可选的,它能够在函数体内其余地点出现,表示函数调用试行到此甘休;假设未有return语句,会自动回到NONE,借使有return语句,可是return前面未有接表明式只怕值的话也是回到NONE。

pass

  • 空语句 do nothing
  • 担保格式完整
  • 保证语义完整

pass语句在函数中的成效

  当您在编写3个顺序时,实践语句部分思路还不曾完成,这时你能够用pass语句来占位,也足以看作是一个符号,是要过后来实现的代码。举个例子下边那样:

def iplaypython():
    pass

  定义三个函数iplaypython,但函数体部分一时半刻还不曾完成,又无法空着不写内容,因而得以用pass来替代占个任务。

pass语句在循环中的成效

  pass也常用于为复合语句编写四个空的重头戏,比方说你想3个while语句的无比循环,每一趟迭代时无需此外操作,你能够如此写:

while True:
    pass

  以上只是举个例证,现实中最佳永不写那样的代码,因为实行代码块为pass也便是空什么也不做,那时python会进入死循环。

Lambda

  lambda的貌似情势是注重字lambda后边跟三个或四个参数,紧跟3个冒号,现在是五个表达式。lambda是1个表明式而不是1个说话。它亦可产出在Python语法不允许def现身的地点。作为表明式,lambda重返贰个值(即2个新的函数)。lambda用来编排轻巧的函数,而def用来拍卖越来越强硬的任务。

f = lambda x,y,z : x+y+z  
print f(1,2,3)  #6

g = lambda x,y=2,z=3 : x+y+z  
print g(1,z=4,y=5)  #10

异常

对于Python的非凡首要不外乎那些关键字:
try  except  finally  raise
捕捉万分能够使用try/except语句。
try/except语句用来检查评定try语句块中的错误,从而让except语句捕获相当音信并拍卖。
若果您不想在老大发生时结束你的先后,只需在try里捕获它。

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

  try的做事原理是,当初阶3个try语句后,python就在现阶段先后的上下文中作标识,那样当非凡出现时就能够回来这里,try子句先实践,接下去会发出哪些注重于实行时是或不是出现卓殊。

  • 1经当try后的口舌推行时发出卓殊,python就跳回到try并奉行第3个门户异常该尤其的except子句,非常管理完成,调节流就透过任何try语句(除非在拍卖相当时又引发新的十二分)。

  • 假使在try后的言辞里产生了极度,却并未有相配的except子句,卓殊将被递交到上层的try,大概到程序的最上层(那样将扫尾程序,并打字与印刷缺省的失误音讯)。

  • 万壹在try子句实施时从没生出尤其,python将实施else语句后的说话(借使有else的话),然后决定流通过全数try语句。

raise关键字是在早晚的状态下掀起这么些,平日结合自定义的丰裕类型应用。

其他

print  del  global  with  assert  yield  exec

del

  由于python都以援引,而python有GC机制,所以,del语句成效在变量上,而不是数量对象上。del删除的是变量,而不是数码。

global

  当你在函数定义内评释变量的时候,它们与函数外全体一样名称的其余变量没有其他关联,即变量名称对于函数来讲是
局地 的。那叫做变量的 功能域
。全部变量的成效域是它们被定义的块,从它们的称号被定义的那点发轫。

# Filename: func_local.py  

def func(x):  
    print 'x is', x  
    x = 2  
    print 'Changed local x to', x  

x = 50  
func(x)  
print 'x is still', x  

运行的结果是如此的:

[python] view plain copy
$ python func_local.py  
x is 50                     # 运行func函数时,先打印x的值,此时带的值是作为参数带入的外部定义的50,所以能正常打印 x=50   
Changed local x to 2        # 在func函数中将x赋2,并打印  
x is still 50               # 运行完func函数,打印x的值,此时x的值仍然是之前赋给的50,而不是func函数中修改过的2,因为在函数中修改的只是函数内的局部变量  

  那么为啥大家要在那关系局地变量呢?bingo,聪明的你须臾间就猜到那几个global正是用来定义全局变量的。约等于说尽管你想要为3个在函数外定义的变量赋值,那么您就得告诉Python那个变量名不是部分的,而是
全局
的。大家使用global语句达成那1功用。未有global语句,是不容许为定义在函数外的变量赋值的。
  只是函数内的有的变量

# Filename: func_global.py  

def func():  
    global x  
    print 'x is', x  
    x = 2  
    print 'Changed local x to', x  

x = 50  
func()  
print 'Value of x is', x  
只是函数内的局部变量  

 运维的结果是那样的:
 只是函数内的一些变量

$ python func_global.py  
x is 50  
Changed global x to 2  
Value of x is 2             # global语句被用来声明x是全局的——因此,当我们在函数内把值赋给x的时候,这个变化也反映在我们在主块中使用x的值的时候。  
只是函数内的局部变量  

with 关键字

  有部分职务,只怕事先需求安装,事后做清理专门的学业。对于那种光景,Python的with语句提供了壹种至极有利于的管理格局。二个很好的事例是文件管理,你要求得到一个文书句柄,从文件中读取数据,然后停业文件句柄。

  要是不用with语句,张开1个文件并读文件的代码如下:

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

  当然如此直白打开有三个难题:一是或然忘记关闭文件句柄;二是文本读取数据发生尤其,未有张开别的管理。下边是增加上越发管理的版本:

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

  固然那段代码运行优异,可是太冗余了。那时候就是with一展身手的时候了。除了有更优雅的语法,with还足以很好的拍卖上下文处境发生的老大。上面是with版本的代码:

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

  那看起来充满法力,但不光是法力,Python对with的拍卖还很驾驭。基本思量是with所求值的靶子必须有3个__enter__()方法,一个__exit__()方法。
  with语句的实行逻辑如下:紧跟with后边的语句被求值后,重回对象的__enter__()方法被调用,那一个点子的再次回到值将被赋值给as后边的变量。当with前面的代码块全体被施行完现在,将调用前边重临对象的__exit__()方法。

下边例子能够具体表达with怎么做事:

# with_example01.py  

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  

运维代码,输出如下

$python with_example01.py     
In __enter__()           # __enter__()方法被执行  
sample: Foo              # __enter__()方法返回的值 - 这个例子中是"Foo",赋值给变量'sample',执行代码块,打印变量"sample"的值为 "Foo"  
In __exit__()            # __exit__()方法被调用  

assert 关键字

  assert语句是1种插入调节和测试断点到程序的壹种便利的办法。assert语句用来声称某些条件是当真,当assert语句战败的时候,会掀起1AssertionError,所以结合try…except大家就足以管理那样的不行。

>>> mylist         # 此时mylist是有三个元素的列表
['a', 'b', 'c']
>>> assert len(mylist) is not None  # 用assert判断列表不为空,正确无返回
>>> assert len(mylist) is  None     # 用assert判断列表为空
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module>
AssertionError                      # 引发AssertionError异常

yield 关键字

作者们先看二个示范:

def fab(max):   
   n, a, b = 0, 0, 1   
   while n < max:   
       yield b   
       # print b   
       a, b = b, a + b   
       n = n + 1   

使用这么些函数:

>>> for n in fab(5):   
...     print n   
...   
1   
1   
2   
3   
5  

  轻便地讲,yield 的服从就是把3个函数形成贰个generator(生成器),带有 yield 的函数不再是三个普普通通函数,Python
解释器会将其视为叁个 generator,调用 fab(伍) 不会施行 fab
函数,而是重回五个 iterable(可迭代的)对象!在 for
循环施行时,每便循环都会实践 fab 函数内部的代码,实施到 yield b 时,fab
函数就回来三个迭代值,下次迭代时,代码从 yield b
的下一条语句继续施行,而函数的本地变量看起来和上次中断施行前是一点一滴等同的,于是函数继续实践,直到再度碰着yield。
  也足以手动调用 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 的利润是综上可得的,把1个函数改写为一个 generator
就赢得了迭代技巧,比起用类的实例保存情况来计算下四个 next()
的值,不仅代码简洁,而且推行流程非凡分明。

  注:比方看完此段你还未领会yield,没难点,因为yield是初学者的三个困难,那么您下一步供给做的正是……看壹看上边参考资料中给的有关yield的博文!

exec 关键字

  官方文书档案对于exec的解释: “This statement supports dynamic execution
of Python
code.”也正是说使用exec可以动态推行Python代码(也足以是文本)

>>> longer = "print \"Hello World ,my name is longer\""     # 比如说我们定义了一个字符串  
>>> longer  
'print "Hello World ,my name is longer"'  
>>> exec(longer)                                            # 使用exec 动态执行字符串中的代码  
Hello World ,my name is longer  
>>> exec(sayhi)                                             # 使用exec直接打开文件名(指定sayhi,sayhi.py以及"sayhi.py"都会报一定的错,但是我觉得直接带sayhi报错非常典型)  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: exec: arg 1 must be a string, file, or code object   # python IDE报错,提示exec的第一个参  
数必须是一个字符串、文件或者一个代码对象  
>>> f = file("sayhi.py")                                    # 使用file打开sayhi.py并创建f实例  
>>> exec(f)                     # 使用exec直接运行文件描述符f,运行正常!!  
Hi, this is [''] script  

  上述给的例证相比较轻便,注意例子中exec语句的用法和eval_r(),
execfile()是不雷同的.
exec是二个根本字而eval_r()和execfile()则是内建函数。

相关文章

网站地图xml地图