锐客网

  1. 首页 > 生活百科 > it技术 > >

python函数运行机制 python语言中函数的作用

函数IT技术

Python中的10条冷门知识下面时Python中一些不常见的冷门知识 ， 感兴趣的小伙伴不妨来学习一下 。
1、省略号也是对象
… 这是省略号，在Python中 ， 一切皆对象 。它也不例外 。在 Python 中，它叫做 Ellipsis。在 Python 3 中你可以直接写…来得到这玩意 。
...
Ellipsis
type(...)
class 'ellipsis'
而在 Python2 中没有…这个语法，只能直接写Ellipsis来获取 。
Ellipsis
Ellipsis
type(Ellipsis)
type 'ellipsis'
它转为布尔值时为真
bool(...)
True
最后 ， 这东西是一个单例 。
id(...)
4362672336
id(...)
4362672336
这东西有啥用呢？据说它是Numpy的语法糖，不玩 Numpy 的人，可以说是没啥用的 。
在网上只看到这个 用 … 代替 pass，稍微有点用，但又不是必须使用的 。
try:
1/0
except ZeroDivisionError:
...
2、增量赋值的性能更好
诸如= 和 *= 这些运算符，叫做 增量赋值运算符 。这里使用用= 举例，以下两种写法，在效果上是等价的 。
# 第一种
a = 1 ; a= 1
# 第二种
a = 1; a = a1
= 其背后使用的魔法方法是 iadd，如果没有实现这个方法则会退而求其次，使用 add。
这两种写法有什么区别呢？
用列表举例 a= b，使用 add 的话就像是使用了a.extend(b),如果使用 add 的话，则是 a = a b,前者是直接在原列表上进行扩展 ， 而后者是先从原列表中取出值，在一个新的列表中进行扩展，然后再将新的列表对象返回给变量，显然后者的消耗要大些 。
所以在能使用增量赋值的时候尽量使用它 。
3、and 和or 的取值顺序
and 和 or 是我们再熟悉不过的两个逻辑运算符 。而我们通常只用它来做判断，很少用它来取值 。
如果一个or表达式中所有值都为真 ， Python会选择第一个值，而and表达式则会选择第二个 。
(2 or 3) * (5 and 7)
14# 2*7
4、修改解释器提示符
import sys
sys.ps1
' '
sys.ps2
'... '
sys.ps2 = '---------------- '
sys.ps1 = 'Python编程时光'
Python编程时光for i in range(2):
----------------print (i)
----------------
5、默认参数最好不为可变对象
函数的参数分三种
可变参数
默认参数
关键字参数
今天要说的是，传递默认参数时，新手很容易踩雷的一个坑 。
先来看一个示例：
def func(item, item_list=[]):
item_list.append(item)
print(item_list)
func('iphone')
func('xiaomi', item_list=['oppo','vivo'])
func('huawei')
在这里，你可以暂停一下，思考一下会输出什么？
思考过后，你的答案是否和下面的一致呢
['iphone']
['oppo', 'vivo', 'xiaomi']
['iphone', 'huawei']
如果是，那你可以跳过这部分内容，如果不是，请接着往下看，这里来分析一下 。
Python 中的 def 语句在每次执行的时候都初始化一个函数对象，这个函数对象就是我们要调用的函数，可以把它当成一个一般的对象，只不过这个对象拥有一个可执行的方法和部分属性 。
对于参数中提供了初始值的参数，由于 Python 中的函数参数传递的是对象，也可以认为是传地址，在第一次初始化 def 的时候，会先生成这个可变对象的内存地址，然后将这个默认参数 item_list 会与这个内存地址绑定 。在后面的函数调用中 ， 如果调用方指定了新的默认值，就会将原来的默认值覆盖 。如果调用方没有指定新的默认值，那就会使用原来的默认值 。
在这里插入图片描述
6、访问类中的私有方法
大家都知道 ， 类中可供直接调用的方法，只有公有方法（protected类型的方法也可以，但是不建议） 。也就是说 ， 类的私有方法是无法直接调用的 。
这里先看一下例子
class Kls():
def public(self):
print('Hello public world!')
def __private(self):
print('Hello private world!')
def call_private(self):
self.__private()
ins = Kls()
# 调用公有方法 ， 没问题
ins.public()
# 直接调用私有方法，不行
ins.__private()
# 但你可以通过内部公有方法，进行代理
ins.call_private()
既然都是方法，那我们真的没有方法可以直接调用吗？
当然有啦 ， 只是建议你千万不要这样弄，这里只是普及，让你了解一下 。
# 调用私有方法，以下两种等价
ins._Kls__private()
ins.call_private()
7、时有时无的切片异常
这是个简单例子
my_list = [1, 2, 3, 4, 5]
print(my_list[5])
Traceback (most recent call last):
File "F:/Python Script/test.py", line 2, in module
print(my_list[5])
IndexError: list index out of range
来看看 ， 如下这种写法就不会报索引异常，执行my_list[5:]，会返回一个新list：[] 。
my_list = [1, 2, 3]
print(my_list[5:])
8、for 死循环
for 循环可以说是 基础得不能再基础的知识点了 。但是如果让你用 for 写一个死循环 ， 你会写吗？（问题来自群友 陈**）
这是个开放性的问题 ， 在往下看之前，建议你先尝试自己思考，你会如何解答 。
好了，如果你还没有思路，那就来看一下 一个海外 MIT 群友的回答:
for i in iter(int, 1):pass
是不是懵逼了 。iter 还有这种用法？这为啥是个死循环？
这真的是个冷知识，关于这个知识点，你如果看中文网站，可能找不到相关资料 。
还好你可以通过 IDE 看py源码里的注释内容，介绍了很详细的使用方法 。
原来iter有两种使用方法，通常我们的认知是第一种，将一个列表转化为一个迭代器 。
而第二种方法，他接收一个 callable对象，和一个sentinel 参数 。第一个对象会一直运行，直到它返回 sentinel 值才结束 。
在这里插入图片描述
那int 呢，这又是一个知识点，int 是一个内建方法 。通过看注释，可以看出它是有默认值0的 。你可以在终端上输入 int() 看看是不是返回0 。
在这里插入图片描述
由于int() 永远返回0，永远返回不了1，所以这个 for 循环会没有终点 。一直运行下去 。
9、奇怪的字符串
字符串类型作为 Python 中最常用的数据类型之一，Python解释器为了提高字符串使用的效率和使用性能 ， 做了很多优化 。
例如：Python 解释器中使用了 intern（字符串驻留）的技术来提高字符串效率 。
什么是 intern 机制？就是同样的字符串对象仅仅会保存一份，放在一个字符串储蓄池中，是共用的，当然，肯定不能改变，这也决定了字符串必须是不可变对象 。
示例一
# Python2.7
a = "Hello_Python"
id(a)
32045616
id("Hello""_""Python")
32045616
# Python3.7
a = "Hello_Python"
id(a)
38764272
id("Hello""_""Python")
32045616
示例二
a = "MING"
b = "MING"
a is b
True
# Python2.7
a, b = "MING!", "MING!"
a is b
True
# Python3.7
a, b = "MING!", "MING!"
a is b
False
示例三
# Python2.7
'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
False
# Python3.7
'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
True
示例四
s1="hello"
s2="hello"
s1 is s2
True
# 如果有空格，默认不启用intern机制
s1="hell o"
s2="hell o"
s1 is s2
False
# 如果一个字符串长度超过20个字符，不启动intern机制
s1 = "a" * 20
s2 = "a" * 20
s1 is s2
True
s1 = "a" * 21
s2 = "a" * 21
s1 is s2
False
s1 = "ab" * 10
s2 = "ab" * 10
s1 is s2
True
s1 = "ab" * 11
s2 = "ab" * 11
s1 is s2
False
10、两次return
我们都知道，try…finally… 语句的用法，不管 try 里面是正常执行还是报异常，最终都能保证finally能够执行 。
同时 ， 我们又知道 ， 一个函数里只要遇到 return 函数就会立马结束 。
基于以上这两点 ， 我们来看看这个例子，到底运行过程是怎么样的？
def func():
...try:
...return 'try'
...finally:
...return 'finally'
...
func()
'finally'
惊奇的发现 ， 在try里的return居然不起作用 。
原因是，在try…finally…语句中，try中的return会被直接忽视 ， 因为要保证finally能够执行 。
python的内存管理机制论坛
活动
招聘
专题
打开CSDN APP
Copyright ? 1999-2020, CSDN.NET, All Rights Reserved
登录
XCCS_澍
关注
Python 的内存管理机制及调优手段python函数运行机制？ 原创
2018-08-05 06:50:53
XCCS_澍
码龄7年
关注
内存管理机制python函数运行机制：引用计数、垃圾回收、内存池 。
一、引用计数：
引用计数是一种非常高效的内存管理手段python函数运行机制，当一个 Python 对象被引用时其引用计数增加 1，当其不再被一个变量引用时则计数减 1. 当引用计数等于 0 时对象被删除 。
二、垃圾回收 ：
1. 引用计数
引用计数也是一种垃圾收集机制，而且也是一种最直观，最简单的垃圾收集技术 。当 Python 的某个对象的引用计数降为 0 时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了 。比如某个新建对象 ， 它被分配给某个引用 ， 对象的引用计数变为 1 。如果引用被删除 ， 对象的引用计数为 0，那么该对象就可以被垃圾回收 。不过如果出现循环引用的话，引用计数机制就不再起有效的作用了
2. 标记清除
如果两个对象的引用计数都为 1 ， 但是仅仅存在他们之间的循环引用，那么这两个对象都是需要被回收的，也就是说，它们的引用计数虽然表现为非 0，但实际上有效的引用计数为 0 。所以先将循环引用摘掉，就会得出这两个对象的有效计数 。
3. 分代回收
从前面“标记-清除”这样的垃圾收集机制来看，这种垃圾收集机制所带来的额外操作实际上与系统中总的内存块的数量是相关的，当需要回收的内存块越多时，垃圾检测带来的额外操作就越多，而垃圾回收带来的额外操作就越少python函数运行机制；反之，当需回收的内存块越少时，垃圾检测就将比垃圾回收带来更少的额外操作 。
python的运行机制和调试机制的区别1. 使用Python自带的IDLE 在开始--程序--Python2.5(视你安装的版本而不同)中找到IDLE(Python GUI)，
点击后弹出如下窗体：
在提示符后输入代码，回车，就可以执行此代码 。
IDLE支持语法高亮，支持自动缩进，支持方法提示 ， 不过提示的很慢 。
2. 在命令行窗口上运行 这种方法的前提是：你在系统的PATH变量中配置了Python的安装路径 。
右键我的电脑--属性--高级--环境变量，在系统变量列表中找到Path项 ， 点击编辑按钮，在其中追加“C:\Python25;”(路径及版本视你安装而定)，保存退出 。
开始--运行--输入cmd，回车，开启一个CMD窗口 。
在DOS提示符后 ， 输入python ， 回车，进入Python环境 。
它的运行和IDLE基本一致，但是没有了语法高亮、自动缩进、方法提示，唯一的好处就是运行速度比IDLE快了些(如果你告诉我可以加参数运行python，那你就不算新手了，也不用看这篇文章了) ， 所以用处不大 。
退出此python环境使用CtrlZ，然后回车 。
3. 以脚本方式运行 以上两种运行方式虽然简便，但是不适合大量代码的开发 ， 只适合查看单句或少量几句代码的运行结果，或者验证某函数的调用方法 ， 而这恰恰是我们平时调试、验证程序的常用方式 。如果是正式的开发，则应该使用独立脚本的方式运行 。
打开你的文本编辑器(我是用EmEditor，当然你使用记事本、写字板也都可以) ， 输入python代码，保存成*.py文件，然后双击运行它就可以执行了，当然前提也是必须配置系统PATH变量 。
l 在其所在目录下开启一个CMD窗口 ， 输入python *.py运行
l 在代码的最后增加如下语句：
raw_input()
然后你再双击运行，结果就会停留在那里，直到你敲击回车键才消失 。
Linux下运行Python程序，一般说来有以下两种形式，其实和Windows下基本一样 。
一、在IDLE中运行
在终端窗口输入$ python进入交互式运行环境，然后就可以边输入边执行代码了：
print 'Hello Python'
Hello Python退出使用Ctrl-D 。
二、以脚本方式运行
在py脚本所在目录下输入
Python 里为什么函数可以返回一个函数内部定义的函数“在Python中，函数本身也是对象”
这一本质 。那不妨慢慢来，从最基本的概念开始 ， 讨论一下这个问题：
1. Python中一切皆对象
这恐怕是学习Python最有用的一句话 。想必你已经知道Python中的list, tuple, dict等内置数据结构 ， 当你执行：
alist = [1, 2, 3]
时，你就创建了一个列表对象 ， 并且用alist这个变量引用它：
当然你也可以自己定义一个类:
class House(object):
def __init__(self, area, city):
self.area = area
self.city = city
def sell(self, price):
[...]#other code
return price
然后创建一个类的对象：
house = House(200, 'Shanghai')
OK，你立马就在上海有了一套200平米的房子，它有一些属性(area, city)，和一些方法(__init__, self)：
2. 函数是第一类对象
和list, tuple, dict以及用House创建的对象一样，当你定义一个函数时，函数也是对象：
def func(a, b):
return a b
在全局域，函数对象被函数名引用着，它接收两个参数a和b，计算这两个参数的和作为返回值 。
所谓第一类对象，意思是可以用标识符给对象命名，并且对象可以被当作数据处理，例如赋值、作为参数传递给函数，或者作为返回值return 等
因此，你完全可以用其他变量名引用这个函数对象：
add = func
这样，你就可以像调用func(1, 2)一样，通过新的引用调用函数了：
print func(1, 2)
print add(1, 2)#the same as func(1, 2)
或者将函数对象作为参数，传递给另一个函数：
def caller_func(f):
return f(1, 2)
if __name__ == "__main__":
print caller_func(func)
可以看到，
函数对象func作为参数传递给caller_func函数 ， 传参过程类似于一个赋值操作f=func；
于是func函数对象 ， 被caller_func函数作用域中的局部变量f引用，f实际指向了函数func；cc
当执行return f(1, 2)的时候，相当于执行了return func(1, 2)；
因此输出结果为3 。
3. 函数对象 vs 函数调用
无论是把函数赋值给新的标识符，还是作为参数传递给新的函数，针对的都是函数对象本身 ， 而不是函数的调用 。
用一个更加简单，但从外观上看 ， 更容易产生混淆的例子来说明这个问题 。例如定义了下面这个函数：
def func():
return "hello,world"
然后分别执行两次赋值：
ref1 = func#将函数对象赋值给ref1
ref2 = func()#调用函数 ， 将函数的返回值("hello,world"字符串)赋值给ref2
很多初学者会混淆这两种赋值，通过Python内建的type函数，可以查看一下这两次赋值的结果：
In [4]: type(ref1)
Out[4]: function
In [5]: type(ref2)
Out[5]: str
可以看到，ref1引用了函数对象本身，而ref2则引用了函数的返回值 。通过内建的callable函数，可以进一步验证ref1是可调用的 ， 而ref2是不可调用的：
In [9]: callable(ref1)
Out[9]: True
In [10]: callable(ref2)
Out[10]: False
传参的效果与之类似 。
4. 闭包LEGB法则
所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时 ， 得到的对象
听上去的确有些复杂，还是用一个栗子来帮助理解一下 。假设我们在foo.py模块中做了如下定义：
#foo.py
filename = "foo.py"
def call_func(f):
return f()#如前面介绍的 ， f引用一个函数对象，然后调用它
在另一个func.py模块中，写下了这样的代码：
#func.py
import foo#导入foo.py
filename = "func.py"
def show_filename():
return "filename: %s" % filename
if __name__ == "__main__":
print foo.call_func(show_filename)#注意：实际发生调用的位置，是在foo.call_func函数中
当我们用python func.py命令执行func.py时输出结果为：
chiyu@chiyu-PC:~$ python func.py
filename:func.py
很显然show_filename()函数使用的filename变量的值，是在与它相同环境(func.py模块)中定义的那个 。尽管foo.py模块中也定义了同名的filename变量，而且实际调用show_filename的位置也是在foo.py的call_func内部 。
而对于嵌套函数，这一机制则会表现的更加明显：闭包将会捕捉内层函数执行所需的整个环境：
#enclosed.py
import foo
def wrapper():
filename = "enclosed.py"
def show_filename():
return "filename: %s" % filename
print foo.call_func(show_filename)#输出：filename: enclosed.py
实际上，每一个函数对象，都有一个指向了该函数定义时所在全局名称空间的__globals__属性：
#show_filename inside wrapper
#show_filename.__globals__
{
'__builtins__': module '__builtin__' (built-in),#内建作用域环境
'__file__': 'enclosed.py',
'wrapper': function wrapper at 0x7f84768b6578,#直接外围环境
'__package__': None,
'__name__': '__main__',
'foo': module 'foo' from '/home/chiyu/foo.pyc',#全局环境
'__doc__': None
}
当代码执行到show_filename中的return "filename: %s" % filename语句时，解析器按照下面的顺序查找filename变量：
Local - 本地函数(show_filename)内部，通过任何方式赋值的，而且没有被global关键字声明为全局变量的filename变量；
Enclosing - 直接外围空间(上层函数wrapper)的本地作用域，查找filename变量(如果有多层嵌套 ， 则由内而外逐层查找，直至最外层的函数)；
Global - 全局空间(模块enclosed.py)，在模块顶层赋值的filename变量；
【python函数运行机制 python语言中函数的作用】Builtin - 内置模块(__builtin__)中预定义的变量名中查找filename变量；
在任何一层先找到了符合要求的filename变量，则不再向更外层查找 。如果直到Builtin层仍然没有找到符合要求的变量，则抛出NameError异常 。这就是变量名解析的：LEGB法则 。
总结：
闭包最重要的使用价值在于：封存函数执行的上下文环境；
闭包在其捕捉的执行环境(def语句块所在上下文)中，也遵循LEGB规则逐层查找，直至找到符合要求的变量 ， 或者抛出异常 。
5. 装饰器语法糖(syntax sugar)
那么闭包和装饰器又有什么关系呢？
上文提到闭包的重要特性：封存上下文，这一特性可以巧妙的被用于现有函数的包装，从而为现有函数更加功能 。而这就是装饰器 。
还是举个例子，代码如下：
#alist = [1, 2, 3, ..., 100]-- 1 2 3 ... 100 = 5050
def lazy_sum():
return reduce(lambda x, y: x y, alist)
我们定义了一个函数lazy_sum，作用是对alist中的所有元素求和后返回 。alist假设为1到100的整数列表：
alist = range(1, 101)
但是出于某种原因 ， 我并不想马上返回计算结果，而是在之后的某个地方，通过显示的调用输出结果 。于是我用一个wrapper函数对其进行包装：
def wrapper():
alist = range(1, 101)
def lazy_sum():
return reduce(lambda x, y: x y, alist)
return lazy_sum
lazy_sum = wrapper()#wrapper() 返回的是lazy_sum函数对象
if __name__== "__main__":
lazy_sum()#5050
这是一个典型的Lazy Evaluation的例子 。我们知道，一般情况下，局部变量在函数返回时 ， 就会被垃圾回收器回收，而不能再被使用 。但是这里的alist却没有，它随着lazy_sum函数对象的返回被一并返回了(这个说法不准确，实际是包含在了lazy_sum的执行环境中 ， 通过__globals__)，从而延长了生命周期 。
当在if语句块中调用lazy_sum()的时候，解析器会从上下文中(这里是Enclosing层的wrapper函数的局部作用域中)找到alist列表，计算结果，返回5050 。
当你需要动态的给已定义的函数增加功能时，比如：参数检查 ， 类似的原理就变得很有用：
def add(a, b):
return a b
这是很简单的一个函数：计算a b的和返回 ， 但我们知道Python是 动态类型 强类型 的语言，你并不能保证用户传入的参数a和b一定是两个整型，他有可能传入了一个整型和一个字符串类型的值：
In [2]: add(1, 2)
Out[2]: 3
In [3]: add(1.2, 3.45)
Out[3]: 4.65
In [4]: add(5, 'hello')
---------------------------------------------------------------------------
TypeErrorTraceback (most recent call last)
/home/chiyu/ipython-input-4-f2f9e8aa5eae in module()
---- 1 add(5, 'hello')
/home/chiyu/ipython-input-1-02b3d3d6caec in add(a, b)
1 def add(a, b):
---- 2return a b
TypeError: unsupported operand type(s) for: 'int' and 'str'
于是，解析器无情的抛出了一个TypeError异常 。
动态类型：在运行期间确定变量的类型，python确定一个变量的类型是在你第一次给他赋值的时候；
强类型：有强制的类型定义 ， 你有一个整数，除非显示的类型转换，否则绝不能将它当作一个字符串(例如直接尝试将一个整型和一个字符串做 运算)；
因此，为了更加优雅的使用add函数，我们需要在执行 运算前，对a和b进行参数检查 。这时候装饰器就显得非常有用：
import logging
logging.basicConfig(level = logging.INFO)
def add(a, b):
return ab
def checkParams(fn):
def wrapper(a, b):
if isinstance(a, (int, float)) and isinstance(b, (int, float)):#检查参数a和b是否都为整型或浮点型
return fn(a, b)#是则调用fn(a, b)返回计算结果
#否则通过logging记录错误信息，并友好退出
logging.warning("variable 'a' and 'b' cannot be added")
return
return wrapper#fn引用add ， 被封存在闭包的执行环境中返回
if __name__ == "__main__":
#将add函数对象传入，fn指向add
#等号左侧的add，指向checkParams的返回值wrapper
add = checkParams(add)
add(3, 'hello')#经过类型检查，不会计算结果，而是记录日志并退出
注意checkParams函数：
首先看参数fn，当我们调用checkParams(add)的时候，它将成为函数对象add的一个本地(Local)引用；
在checkParams内部，我们定义了一个wrapper函数，添加了参数类型检查的功能，然后调用了fn(a, b)，根据LEGB法则，解释器将搜索几个作用域，并最终在(Enclosing层)checkParams函数的本地作用域中找到fn；
注意最后的return wrapper，这将创建一个闭包，fn变量(add函数对象的一个引用)将会封存在闭包的执行环境中，不会随着checkParams的返回而被回收；
当调用add = checkParams(add)时，add指向了新的wrapper对象，它添加了参数检查和记录日志的功能，同时又能够通过封存的fn ， 继续调用原始的add进行 运算 。
因此调用add(3, 'hello')将不会返回计算结果 ， 而是打印出日志：
chiyu@chiyu-PC:~$ python func.py
WARNING:root:variable 'a' and 'b' cannot be added
有人觉得add = checkParams(add)这样的写法未免太过麻烦，于是python提供了一种更优雅的写法，被称为语法糖：
@checkParams
def add(a, b):
return ab
这只是一种写法上的优化 ， 解释器仍然会将它转化为add = checkParams(add)来执行 。
6. 回归问题
def addspam(fn):
def new(*args):
print "spam,spam,spam"
return fn(*args)
return new
@addspam
def useful(a,b):
print a**2 b**2
首先看第二段代码：
@addspam装饰器，相当于执行了useful = addspam(useful) 。在这里题主有一个理解误区：传递给addspam的参数，是useful这个函数对象本身，而不是它的一个调用结果；
再回到addspam函数体：
return new 返回一个闭包，fn被封存在闭包的执行环境中，不会随着addspam函数的返回被回收；
而fn此时是useful的一个引用 ， 当执行return fn(*args)时，实际相当于执行了return useful(*args)；
最后附上一张代码执行过程中的引用关系图，希望能帮助你理解：
python程序打包后源程序的运行机制？如果有main就是从main入口进入执行
没有的话 ， 我猜想是顺序执行
因为exe其实也就是把你的py文件需要用的包和环境打包，然后再其他设备上，即使没有安装python的也可以正常运行，其运行效果和你在本地调试运行应没有分别
python提供了什么机制来专门处理程序运行时错误python处理错误的机制是try和except语句 ， 有时还会跟else和finally语句 。
关于python函数运行机制和python语言中函数的作用的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：java增删改查代码步骤，java增删改查代码详细讲解

    下一篇：如何修改竞时通服务器设置？ 竞时通怎么修改服务器