python全局符号表

❶ 程序开发中定义函数的使用方法是什么

第一：定义函数
1.1 我们可以创建一个用来生成指定边界的斐波那契数列的函数:
>>> def fib(n): # write Fibonacci series up to n
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
1.2 关键字 def 引入了一个函数 定义。在其后必须跟有函数名和包括形式参数的圆括号。函数体语句从下一行开始，必须是缩进的。
1.3 函数体的第一行语句可以是可选的字符串文本，这个字符串是函数的文档字符串，或者称为 docstring。（更多关于 docstrings 的信息请参考 文档字符串） 有些工具通过 docstrings 自动生成在线的或可打印的文档，或者让用户通过代码交互浏览；在你的代码中包含 docstrings 是一个好的实践，让它成为习惯吧。
1.4 函数 调用 会为函数局部变量生成一个新的符号表。确切的说，所有函数中的变量赋值都是将值存储在局部符号表。变量引用首先在局部符号表中查找，然后是包含函数的局部符号表，然后是全局符号表，最后是内置名字表。因此，全局变量不能在函数中直接赋值（除非用 global 语句命名），尽管他们可以被引用。
1.5 函数引用的实际参数在函数调用时引入局部符号表，因此，实参总是 传值调用 （这里的 值 总是一个对象 引用 ，而不是该对象的值）。[1] 一个函数被另一个函数调用时，一个新的局部符号表在调用过程中被创建。
1.6 一个函数定义会在当前符号表内引入函数名。函数名指代的值（即函数体）有一个被 python 解释器认定为 用户自定义函数 的类型。 这个值可以赋予其他的名字（即变量名），然后它也可以被当作函数使用。这可以作为通用的重命名机制:
>>> fib
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
1.7 如果你使用过其他语言，你可能会反对说：fib 不是一个函数，而是一个方法，因为它并不返回任何值。事实上，没有 return 语句的函数确实会返回一个值，虽然是一个相当令人厌烦的值（指 None ）。这个值被称为 None （这是一个内建名称）。如果 None 值是唯一被书写的值，那么在写的时候通常会被解释器忽略（即不输出任何内容）。如果你确实想看到这个值的输出内容，请使用 print() 函数:

❷ python 全局变量怎么用

在python中，全局变量一般有两种使用方式：
第一种：是在一个单独的模块中定义好，然后在需要使用的全局模块中将定义的全局变量模块导入。
第二种：直接在当前的模块中定义好，然后直接在本模块中通过global声明，然后使用具体的方法如下所示：
第一种：
复制代码
SOLR_URL='http://solr.org'
def tt():
global SOLR_URL
SOLR_URL=SOLR_URL+'#aa'
if __name__=='__main__':
tt()
print SOLR_URL
#输出：
http://solr.org#aa
复制代码
PS：在此种用法中，如果我们在函数tt中不使用global 声明全局变量SOLR_URL,其实也可以使用，但是此时应该是作为一个内部变量使用，由于没有初始值，因此报错Python查找变量是顺序是：先局部变量，再全局变量复制代码
SOLR_URL='http://solr.org'
def tt():
#global SOLR_URL
SOLR_URL=SOLR_URL+'#aa'
if __name__=='__main__':
tt()
print SOLR_URL
#输出：
SOLR_URL=SOLR_URL+'#aa'
UnboundLocalError: local variable 'SOLR_URL' referenced before assignment复制代码
第二种：
global_list.py
GLOBAL_A='hello'
GLOBAL_B='world'
test.py
复制代码
import global_list
def tt():
print global_list.GLOBAL_A
if __name__=='__main__':
tt()
#输出：
hello

❸ Python中定义函数的使用方法

4.6. 定义函数
我们可以创建一个用来生成指定边界的斐波那契数列的函数:
>>> def fib(n): # write Fibonacci series up to n
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
关键字 def 引入了一个函数 定义。在其后必须跟有函数名和包括形式参数的圆括号。函数体语句从下一行开始，必须是缩进的。
函数体的第一行语句可以是可选的字符串文本，这个字符串是函数的文档字符串，或者称为 docstring。（更多关于 docstrings 的信息请参考 文档字符串） 有些工具通过 docstrings 自动生成在线的或可打印的文档，或者让用户通过代码交互浏览；在你的代码中包含 docstrings 是一个好的实践，让它成为习惯吧。
函数 调用 会为函数局部变量生成一个新的符号表。确切的说，所有函数中的变量赋值都是将值存储在局部符号表。变量引用首先在局部符号表中查找，然后是包含函数的局部符号表，然后是全局符号表，最后是内置名字表。因此，全局变量不能在函数中直接赋值（除非用 global 语句命名），尽管他们可以被引用。
函数引用的实际参数在函数调用时引入局部符号表，因此，实参总是 传值调用 （这里的 值 总是一个对象 引用 ，而不是该对象的值）。[1] 一个函数被另一个函数调用时，一个新的局部符号表在调用过程中被创建。
一个函数定义会在当前符号表内引入函数名。函数名指代的值（即函数体）有一个被 Python 解释器认定为 用户自定义函数 的类型。 这个值可以赋予其他的名字（即变量名），然后它也可以被当作函数使用。这可以作为通用的重命名机制:
>>> fib
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
如果你使用过其他语言，你可能会反对说：fib 不是一个函数，而是一个方法，因为它并不返回任何值。事实上，没有 return 语句的函数确实会返回一个值，虽然是一个相当令人厌烦的值（指 None ）。这个值被称为 None （这是一个内建名称）。如果 None 值是唯一被书写的值，那么在写的时候通常会被解释器忽略（即不输出任何内容）。如果你确实想看到这个值的输出内容，请使用 print() 函数:

❹ 那些Python中的模块

Python的解释环境是很好用，但是如果我们需要编写一个大型的程序的时候，解释环境就完全不够用了。这个时候我们需要将python程序保存在一个文件里。通常这个文件是以.py结尾的。

对于大型的应用程序来说，一个文件可能是不够的，这个时候我们需要在文件中引用其他的文件，这样文件就叫做模块。

模块是一个包含Python定义和语句的文件。文件名就是模块名后跟文件后缀 .py 。在模块内部，模块名可以通过全局变量 __name__ 获得。

还是之前的斐波拉赫数列的例子，我们在fibo.py文件中存放了函数的实现：

编写完毕之后，我们可以在Python的解释环境中导入它：

然后直接使用即可：

常用的函数，我们可以将其赋值给一个变量：

或者，我们在导入的时候，直接给这个模块起个名字：

或者导入模块中的函数：

每个模块都有它自己的私有符号表，该表用作模块中定义的所有函数的全局符号表。因此，模块的作者可以在模块内使用全局变量，而不必担心与用户的全局变量发生意外冲突。

前面我们提到了可以使用import来导入一个模块，并且 __name__ 中保存的是模块的名字。

和java中的main方法一样，如果我们想要在模块中进行一些测试工作，有没有类似java中main方法的写法呢？

先看一个例子：

在模块中，我们需要进行一个判断 __name__ 是不是被赋值为 "__main__"。

我们这样来执行这个模块：

以脚本执行的情况下，模块的 __name__ 属性会被赋值为 __main__ , 这也是例子中为什么要这样写的原因。

看下执行效果：

如果是以模块导入的话，那么将不会被执行：

使用import导入模块的时候，解释器首先会去找该名字的内置模块，如果没找到的话，解释器会从 sys.path变量给出的目录列表里寻找。

sys.path的初始目录包括：

要想查看模块中定义的内容，可以使用dir函数。

上面的例子列出了当前模块中定义的内容，包括变量，模块，函数等。

我们可以给dir加上参数，来获取特定模块的内容：

java中有package的概念，用来隔离程序代码。同样的在Python中也有包。

我们看一个Python中包的例子：

上面我们定义了4个包，分别是sound,sound.formats, sound.effects, sound.filters。

__init__.py 可以是一个空文件，也可以执行包的初始化代码或设置 __all__ 变量。

当导入的时候， python就会在 sys.path 路径中搜索该包。

包的导入有很多种方式，我们可以导入单个模块：

但是这样导入之后，使用的时候必须加载全名：

如果不想加载全名，可以这样导入：

那么就可以这样使用了：

还可以直接导入模块中的方法：

然后这样使用：

如果一个包里面的子包比较多，我们可能会希望使用 * 来一次性导入：

那么如何去控制到底会导入effects的哪一个子包呢？

我们可以在 __init__.py 中定义一个名叫 __all__ 的列表，在这个列表中列出将要导出的子包名，如下所示：

这样from sound.effects import * 将导入 sound 包的三个命名子模块。

如果没有定义 __all__，from sound.effects import * 语句 不会 从包 sound.effects 中导入所有子模块到当前命名空间；它只会导入包 sound.effects。

Import 可以指定相对路径，我们使用 . 来表示当前包， 使用 .. 来表示父包。

如下所示：

❺ Python里怎么查看某个函数的本地符号表

这得看你的二进制程序是否包含这些信息。这得看 编译选项 有没有包含 -s 。-s选项会剔除不需要的符号名。 正式二进制发布的软件是可以没有这些信息的。

❻ Python怎么深入模块进行学习

6.1. 深入模块
除了包含函数定义外，模块也可以包含可执行语句。这些语句一般用来初始化模块。他们仅在 第一次 被导入的地方执行一次。[1]
每个模块都有自己私有的符号表，被模块内所有的函数定义作为全局符号表使用。因此，模块的作者可以在模块内部使用全局变量，而无需担心它与某个用户的全局变量意外冲突。从另一个方面讲，如果你确切的知道自己在做什么，你可以使用引用模块函数的表示法访问模块的全局变量，modname.itemname。
模块可以导入其他的模块。一个（好的）习惯是将所有的 import 语句放在模块的开始（或者是脚本），这并非强制。被导入的模块名会放入当前模块的全局符号表中。
import 语句的一个变体直接从被导入的模块中导入命名到本模块的语义表中。例如:
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这样不会从局域语义表中导入模块名（如上所示， fibo 没有定义）。
甚至有种方式可以导入模块中的所有定义:
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这样可以导入所有除了以下划线( _ )开头的命名。
需要注意的是在实践中往往不鼓励从一个模块或包中使用 * 导入所有，因为这样会让代码变得很难读。不过，在交互式会话中这样用很方便省力。

❼ 求助一个关于python3.4的相对包导入问题，很初级

关于 from .. import 是如下说明的：

From…import 语句

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
from modname import name1[, name2[, ... nameN]]

例如，要导入模块fib的fibonacci函数，使用如下语句：
from fib import fibonacci

这个声明不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入到执行这个声明的模块的全局符号表。

From…import* 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

所以感觉你应当是用from b import * 和 from a import * 或者直接 import a,b

❽ python中怎么定义全局变量

复制代码
count = 0
def Fuc(count):
print count
count += 1

for i in range(0, 10):
Fuc(count)
复制代码
结果是：
不是我们想要的结果。
解决之道一——全局变量：
复制代码
global a
a = 3

def Fuc():
global a
print a
a = a + 1
if __name__ == "__main__":
global a
for i in range(10):
Fuc()print 'hello'
print a
复制代码
结果：

注意要领：
哪里需要全局变量，哪里声明一下；但是函数千万不要传参数， Fuc(a)是不行的。
解决之道二——列表：
复制代码
a = [3]

def Fuc():
print a[0]
a[0] = a[0] + 1
if __name__ == "__main__":
global a
for i in range(10):
Fuc()
print 'hello'
print a[0]
复制代码
结果同上
列表可以比肩简单的实现，学习之。

❾ 求Python中全局变量的详细理解

题主你好,

拿实际例子和你说一下吧, 更好理解一些.

我们在拿到一个python脚本的时候,往往发现里面都有如下语句:

=====

希望可以帮到题主, 欢迎追问.

❿ 在python中,如果出现局部变量和全局变量同名,则服从什么原则

局部优先
所有函数中的变量赋值都是将值存储在局部符号表。变量引用首先在局部符号表中查找，然后是包含函数的局部符号表，然后是全局符号表，最后是内置名字表。