Python模块的执行顺序

我有一个结构正常的Python程序，其中包含导入语句、类定义、其他例程和一些调用类中方法的“main”语句（按顺序）。导入后的打印语句打印“ok”

Python 2.7.2

我在一个类方法中得到了一个nameError

print >> common, ...

NameError: 'common' is not defined

common

在同一方法的前面使用，但是前面的引用没有引起错误

common

在许多方法中使用-物理移动此方法没有效果：此方法中的错误仍然在同一行上

该错误发生在调用该方法之前，以及在执行任何“main”语句之前。将return作为方法中的第一个可执行语句没有效果。这一切显然都发生在类定义时

如果我注释掉

print>>常见的

语句，我会在相同的方法中得到一个不同的名称错误

我不知道如何在“定义时”在一个方法中得到一个NameError

有什么想法吗？方法如下：

下面的x=z**2应该生成一个名称错误：没有z。 未执行所有函数定义之后的print语句

"""code below"""
 @classmethod
    def show_role_map(cls):
        """show jobs within roles, with total days, with percents of totals"""

        return
        raise ZeroDivisionError
        return

        print >> common, "xyzzy"

        x = z ** 2

        p       = Performance("Traveler: show_role_map")
        print   "\tshow_role_map"
        roles   = cls.role_map.keys()
        roles.sort()
        header  ("Qualitative Role Map")

        role_totals = collections.defaultdict(float)
        job_totals  = collections.defaultdict(float)

        for name in Traveler.roster:
            trav = Traveler.roster[name]
            for day in trav.roles:
                frac = 1.0 / len(trav.roles[day])
                for role in trav.roles[day]:
                    role_totals[role] += frac
            for day in trav.jobs:
                frac = 1.0 / len(trav.jobs[day])
                for job in trav.jobs[day]:
                    job_totals[job] += frac

        role_total  = sum(role_totals.values())
        job_total   = sum(job_totals.values())
        assert abs(role_total - job_total) <= 1e-6

        print >> common, "Total Role days =", role_total
        print >> common, "Total Job  days =", job_total
        print >> common


        for role in roles:
            if role_totals[role] == 0: continue
            print >> common, "\t%12s %51.1f %12s %12.3f" %\
                (role, role_totals[role], \
                "", 100.0 * role_totals[role] / role_total)

            jobs = list(cls.role_map[role])
            jobs.sort (key = lambda x: (job_totals[x], x), reverse = True)

            for index, job in enumerate(jobs, 1):
                if job_totals[job] == 0: continue
                print role, job, role_totals[role], job_totals[job]
                print >> common, "\t\t%6d. %35s %12.1f % 12.3f %12.3f" % \
                    (index, job, job_totals[job], \
                100.0 * job_totals[job] / role_totals[role],
                100.0 * job_totals[job] / role_total)
            print >> common


    print >> common, "\n", "_" * 60, "\n" #--ERROR OCCURS FOR THIS LINE ****************
    print >> common, "\nRoles in Total Tripday order\n"
    roles = role_totals.keys()
    roles.sort (order = lambda x: (role_totals[x], x), reverse = True)
    for index, role, in enumerate(roles,1):
        print >> common, "%6d. %15s %12.1f %12.3f" % \
            (index, role, role_totals[role], \
            100.0 * role_totals[role]/role_total)

    print >> common, "\n", "_" * 60, "\n"
    print >> common, "\nDetailed Trip Roles in Total Tripday order"
    jobs = job_totals.keys()
    jobs.sort (key = lambda x: (job_totals[x], x), reverse = True)
    for index, job in jobs:
        print >> common, "%6d. %35s %12.1f %12.3f" % \
            (index, job, job_totals[job], 100.0 * job_totals[job] / job_total)


    p.close()

“下面的代码”
@类方法
def显示角色映射（cls）：
“”“显示角色内的作业，总天数，总百分比”“”
返回
调零误差
返回
打印>>常用“xyzzy”
x=z**2
p=性能（“旅行者：显示角色地图”）
打印“\t显示角色映射”
roles=cls.role\u map.keys（）
roles.sort（）
标题（“定性角色映射”）
角色\u总计=集合。默认dict（浮动）
作业总数=集合.defaultdict（浮动）
对于Traveler.Floster中的姓名：
trav=旅行者。花名册[姓名]
对于trav.roles中的一天：
分形=1.0/透镜（trav.角色[日]）
对于trav中的角色。角色[日期]：
角色总数[角色]+=分数
对于trav.jobs中的一天：
分形=1.0/透镜（trav.jobs[日]）
对于trav中的作业，作业[日]：
作业总数[作业]+=压裂
role_total=总和（role_totals.values（））
job_total=总和（job_totals.values（））
断言abs（角色总数-工作总数）>常见，“总角色天数=”，角色总数
打印>>常见，“总工作日=”，总工作日
打印>>通用
对于角色中的角色：
如果角色总数[角色]==0：继续
打印>>常见“\t%12s%51.1f%12s%12.3f”%\
（角色，角色总数[角色]\
“”，100.0*角色总数[角色]/角色总数）
作业=列表（cls.role\u映射[角色]）
jobs.sort（key=lambda x:（job_总计[x]，x），reverse=True）
对于索引，枚举中的作业（作业，1）：
如果作业_总计[作业]==0：继续
打印角色、作业、角色总数[角色]、作业总数[作业]
打印>>常见“\t\t%6d.%35s%12.1f%12.3f%12.3f”%\
（索引、作业、作业总数[作业]\
100.0*工作总计[工作]/角色总计[角色]，
100.0*工作总计[工作]/角色总计）
打印>>通用
打印>>常用“\n”、“”*60”\n”#--此行出错****************
打印>>常见“\n总三天订单中的孔\n”
角色=角色\u总计.keys（）
roles.sort（order=lambda x:（role_totals[x]，x），reverse=True）
对于枚举中的索引、角色（角色，1）：
打印>>常见“%6d.%15s%12.1f%12.3f”%\
（索引、角色、角色总数[角色]\
100.0*角色总数[角色]/角色总数）
打印>>常用“\n”、“\u”*60”\n
打印>>常见“\n三天总订单中的详细行程角色”
jobs=job_总计.keys（）
jobs.sort（key=lambda x:（job_总计[x]，x），reverse=True）
对于索引，作业中的作业：
打印>>常见“%6d.%35s%12.1f%12.3f”%\
（索引，作业，作业总计[作业]，100.0*作业总计[作业]/作业总计）
p、 关闭（）

所以先做第一件事。定义函数时，不执行该函数。名称空间中只记录名称。只有在调用函数（也称为已调用）时，它才会实际执行函数中的代码（假设没有语法错误，则为真）

因此，解释器处理您的导入等（在文件顶部），然后注意到您有一个函数（因此它会记录其名称），并继续执行其余代码（函数定义之后的内容）。正是在这一点上，它看到了

print>>common

。由于

common

不在内存堆栈上（以前从未定义过），解释器不知道它的值是什么，因此会引发

namererror

请注意，调用函数时仍会发生这种情况，因为在定义函数之前，函数也会使用

common

---

希望这对缩进错误有所帮助。problem语句没有在其函数中缩进，因此似乎是Python语句，在类定义时执行

---

感谢所有试图帮助我的人。

我理解这个问题。但是如果没有一些代码，很难告诉您代码与您期望的不同之处。请发布您的代码请包含您遇到问题的整个代码段（方法）。如果您不发布代码，请不要期望任何结果。另外，您可能想告诉我们您正在使用的python版本（虽然暂时不需要这样做），这是使用python调试器的一个很好的例子。只需从模块顶部开始，单步查看正在执行的内容。@Gerry我看不出在该代码示例中定义了

common

变量的位置。在此之前定义了30多个其他方法，所有打印>>common。之前有多少个方法并不重要