锐客网

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

python函数类语法糖 python语言函数

IT技术函数

Python 有哪些好玩的语法糖？什么是语法糖？
很多人在Python语法糖相关的问题，但是估计其中有不少同学甚至都不知道语法糖是什么概念 。
其实，它并没有那么高大上 ， 如果你跟着正常的学习链路把一门编程语言的语法学会，可能你日常开发过程中已经用到了很多语法糖 。
在正式回答问题之前，我觉得有必要先解释一下什么是语法糖 。
语法糖（Syntactic sugar） ， 由英国计算机科学家Peter J. Landin于1964年提出 ， 简单来说 ， 语法糖是指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用 。语法糖让程序更加简洁，有更高的可读性 。
引用维基百科上的一个例子：
举一个比较常见的for循环的例子：
满足同样的功能和效果，我们可以通过while来实现：
这就是一个简单的语法糖 。
由此可见，语法糖并不是什么高大上的东西，可能我们现在开发中已经用了很多Python语法糖 。
除此之外，语法糖还派生出一些词汇 。例如，语法盐（syntactic salt），指的是不容易写出坏代码的语法特性 。语法糖精（syntactic saccharine），或者说语法糖浆（syntactic syrup），指的是未能让编程更加方便的附加语法 。
花了很大功夫来解释什么是语法糖，为的就是让大家更加容易理解、循序渐进 ， 而不是上来就罗列一堆语法糖，很多基础薄弱的同学不明所以 。
讲完语法糖的概念 ， 接下来就介绍一些Python中那些好玩的语法糖 。
魔法方法（Magic methods），有时也被称为特殊方法，是一种具有预定义名称的方法，其特征是在开头和结尾处有双下划线，例如，init。
它们之所以是 "魔法" ， 是因为这些方法是间接调用的，你不需要直接调用它们，一切都在背后完成 。
例如，当你实例化一个类 x = MyClass() 时，Python 将调用new和init进行构造或者初始化 。
举一个简单的打印字符串的例子：
其实它间接的调用了背后的魔法方法，我们可以来试一下：
可以看出，repr其实就是绑定到知名的print()方法上了 。
除此之外，还有很多常用的魔法方法和我们常用的操作效果相同的：
装饰器是典型的Python语法糖，通过装饰器的使用，可以让Python语法格外简洁，而且可读性也很高 。
比如，我现在写了3个函数，并且要统计3个函数的执行时间 。
按常规的需要这样写：
这样不仅麻烦，而且有很多冗余代码 。
这时候，我们就可以实现一个计时的装饰器，并且在每个函数上通过@装饰器名来调用：
除此之外，装饰器还有很多妙用，感兴趣的同学可以看看我的另外一篇文章：
如果对装饰器的基本概念和用法不清楚，我之前也写过一篇非常受欢迎的回答，需要的也可以看一下：
开发过程中经常会用到比较运算符 ， 比如，要判断一个变量是否在一个区间内，很多语言需要这样写：
在Python中，可以这样写：
这样更符合我们日常使用习惯，也更容易理解 。
如果有一个列表或者字典 ， 该如何遍历？
很多同学估计都会这样做：
在Python中，可以用更简洁的方法实现，一行代码就够了：
假如有这么一个数字：
这是多少？
估计很多人开始逐个数零了 。
如果接触过财务或者会计的同学应该知道，有一种千位数字分割样式，这样更便于读取和理解 。
在Python中，它提供了一种语法糖可以这样表示
这种效果和上面这种一样，但是更加容易理解和读取 。
可以验证一下：
除了上面这些，Python在字符串、列表、函数等方面还有很多语法糖 。
总之，语法糖的目的就是让程序更加简洁 ， 有更高的可读性 。这和我们编程过程中一直坚持的思想是一直的，实现一项功能的方法有很多，但是，我们一直在努力让代码具有更优秀的扩展性、阅读性、简洁性 。除了语法糖，我们也可以通过养成良好的编程习惯、学习设计模式等方式来优化我们的代码 。
关于 python 的语法糖with的用法：
class A:
def __enter__(self):
print 'in enter'
def __exit__(self, e_t, e_v, t_b):
print 'in exit'
with A() as a:
print 'in with'
运行输出：
in enter
in with
in exit
也就是说在print 'in with'前自动执行了A()构造的实例的__enter__方法
with块中的程序执行完后，自动执行了A()构造的实例的__exit__方法
这里as a可以省略，因为with块中没有用到a
with app.test_request_context():
print(url_for('index'))
直接翻译的话就是
context = app.test_request_context()
context.__enter__()
print(url_for('index'))
context.__exit__(参数1,参数2,参数3)
这里可以理解为 为print(url_for('index'))创造一个环境 ， 执行完后清理环境
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变量；
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确定一个变量的类型是在你第一次给他赋值的时候；
【python函数类语法糖 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 有哪些好玩的语法糖def use_logging(func):
def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapper
def bar():
print('i am bar')
bar = use_logging(bar)
bar()
函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了 。在这个例子中，函数进入和退出时 ， 被称为一个横切面(Aspect) ， 这种编程方式被称为面向切面的编程(Aspect-Oriented Programming) 。
Python中几个有趣的语法糖当然是函数式那一套黑魔法啦，且听我细细道来 。lambda表达式也就是匿名函数 。用法：lambda 参数列表 : 返回值例：1函数 f=lambda x:x 1 max函数（条件语句的写法如下） f_max=lambda x,y:x if xy else y 上述定义的函数与用def定义的函数没有区别，而且左边的f=在某些情况下并不是必要的 。filter,map,reduce filter函数接受两个参数 ， 第一个是过滤函数 ， 第二个是可遍历的对象，用于选择出所有满足过滤条件的元素，不同版本的filter的返回值稍有区别，我用的是python3.5，filter返回的是经过过滤的可遍历对象 。例：去除小写字母 s=filter(lambda x:not str(x).islower(),"asdasfAsfBsdfC") for ch in s: print(ch) map函数接受的参数类型与filter类似，它用于把函数作用于可遍历对象的每一个元素 。类似于数学中映射的概念 。例：求y=2x 1（偷偷用了一下range函数生成定义域） s=map(lambda x:2*x 1,range(6)) for x in s: print(x) reduce函数对每个元素作累计操作，它接受的第一个参数必须是有两个参数的函数 。例：求和 from functools import reduce s=reduce(lambda x,y:x y,range(1,6)) print(s) 求乘积（第三个可选参数表示累计变量的初值） from functools import reduce s=reduce(lambda x,y:x*y,range(1,6),1) print(s) 柯里化(curry)函数如果一个函数需要2个参数 ， 而你只传入一个参数，那么你就可以得到一个柯里化的函数，这是函数式编程语言的重要特性之一，遗憾的是，python并不能在语法层面支持柯里化调用，但它在库中提供了接口 。例： *3函数 f_mul=lambda x,y:x*y from functools import partial mul3=partial(f_mul,3) print(mul3(1)) print(mul3(6)) 打包与解包有点类似于函数式中的模式匹配，略牵强 。t=(1,2,3) x,y,z=t 列表生成式这个也有点牵强 ， 不知道严格意义上讲属不属于函数式风格 。例：生成奇数序列 l=[2*x 1 for x in range(10)] for i in l: print(i) 最后来一个彩蛋（以前某答主提到的用调分函数来美颜的算法，忘了出处了，侵删） from PIL import Image from math import sqrt im = Image.open("a.jpg") ret= im.convert(mode="RGB") ret = ret.point(lambda x:sqrt(x)*sqrt(255)) ret.save("b.jpg")
如何解决 python函数，类或方法的用法已过时 的问题Python的类就是个语法糖 。一个函数写在类里面和写在类外面没有区别python函数类语法糖，唯一的区别就是参数python函数类语法糖，所谓实例方法就是第一个参数是selfpython函数类语法糖 ， 所谓类方法就是第一个参数是classpython函数类语法糖，而静态方法不需要额外的参数，所以必须区分 。
关于python函数类语法糖和python语言函数的介绍到此就结束了 ， 不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：jquery设置三秒延时，jquery timer

    下一篇：虎牙怎么看去年的直播时长，虎牙怎么看去年的直播时长多少