17.python自定义函数,17.python函数

by admin on 2019年9月3日

Python中自定义函数的教程,python自定义函数

在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。

我们以自定义一个求绝对值的my_abs函数为例:

def my_abs(x):
  if x >= 0:
    return x
  else:
    return -x

请自行测试并调用my_abs看看返回结果是否正确。

请注意,函数体内部的语句在执行时,一旦执行到return时,函数就执行完毕,并将结果返回。因此,函数内部通过条件判断和循环可以实现非常复杂的逻辑。

如果没有return语句,函数执行完毕后也会返回结果,只是结果为None。

return None可以简写为return。
空函数

如果想定义一个什么事也不做的空函数,可以用pass语句:

def nop():
  pass

pass语句什么都不做,那有什么用?实际上pass可以用来作为占位符,比如现在还没想好怎么写函数的代码,就可以先放一个pass,让代码能运行起来。

pass还可以用在其他语句里,比如:

if age >= 18:
  pass

缺少了pass,代码运行就会有语法错误。
参数检查

调用函数时,如果参数个数不对,Python解释器会自动检查出来,并抛出TypeError:

>>> my_abs(1, 2)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: my_abs() takes exactly 1 argument (2 given)

但是如果参数类型不对,Python解释器就无法帮我们检查。试试my_abs和内置函数abs的差别:

>>> my_abs('A')
'A'
>>> abs('A')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

当传入了不恰当的参数时,内置函数abs会检查出参数错误,而我们定义的my_abs没有参数检查,所以,这个函数定义不够完善。

让我们修改一下my_abs的定义,对参数类型做检查,只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance实现:

def my_abs(x):
  if not isinstance(x, (int, float)):
    raise TypeError('bad operand type')
  if x >= 0:
    return x
  else:
    return -x

添加了参数检查后,如果传入错误的参数类型,函数就可以抛出一个错误:

>>> my_abs('A')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 File "<stdin>", line 3, in my_abs
TypeError: bad operand type

错误和异常处理将在后续讲到。
返回多个值

函数可以返回多个值吗?答案是肯定的。

比如在游戏中经常需要从一个点移动到另一个点,给出坐标、位移和角度,就可以计算出新的新的坐标:

import math

def move(x, y, step, angle=0):
  nx = x + step * math.cos(angle)
  ny = y - step * math.sin(angle)
  return nx, ny

这样我们就可以同时获得返回值:

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print x, y
151.961524227 70.0

但其实这只是一种假象,Python函数返回的仍然是单一值:

>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0)

原来返回值是一个tuple!但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。
小结

定义函数时,需要确定函数名和参数个数;

如果有必要,可以先对参数的数据类型做检查;

函数体内部可以用return随时返回函数结果;

函数执行完毕也没有return语句时,自动return None。

函数可以同时返回多个值,但其实就是一个tuple。

 

在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后…

Python3.x中自定义比较函数,python3.x函数

在Python3.x的世界里,cmp函数没有了。那么sorted,min,max等需要比较函数作为参数的函数该如何用呢?

以min函数的定义为例,有两种重载形式:

单参数(一个迭代器):

复制代码 代码如下:
min(iterable[, key=func]) -> value 

多参数(多个待比较内容):

复制代码 代码如下:
min(a, b, c, …[, key=func]) -> value 

本文主要讨论key=func参数的使用 。举例说明吧:

1.自定义对象的比较
我定义了一个类test,有两个成员变量a和b:
复制代码 代码如下:
class test: 
         def __init__(self,a,b): 
              self.a = a 
              self.b = b 

然后实例化了三个对象x,y,z:
复制代码 代码如下:
x=test(10,’x’) 
y=test(2,’y’) 
z=test(8,’z’) 

我想让它们以变量a为标准做比较,求得a最小的对象:
复制代码 代码如下:
minTest=min(x,y,z,key=lambda t:t.a) 

由于key这个参数需要传入一个函数,用lambda匿名函数很方便。本例中要实现比较函数(准确地说是比较关键字函数),故lamda的参数只要一个,随便你取什么名字(我用的是t),代表待比较的对象(即a,b,c);冒号后面是表达式,这里直接返回t的成员变量a。

于是乎,min函数(换成max,sorted等函数也是类似的)就会根据每个待比较对象的a值进行分别比较,返回a值最小的对象(的引用)赋值给minTest。

输出一下minTest.a,minTest.b就可以验证结果啦。

2.字典值value的比较
有一个字典:
复制代码 代码如下:
dic={‘b’:3,’a’:5,’c’:9,’d’:2} 

如果要根据字典的键key排序,只要:
复制代码 代码如下:
sorted(dic)

返回一个list,是排序后的键,但是值没有放入list:
复制代码 代码如下:
[‘a’, ‘b’, ‘c’, ‘d’] 

用以下方法就好了:
复制代码 代码如下:
>>> sorted(dic.items()) 
[(‘a’, 5), (‘b’, 3), (‘c’, 9), (‘d’, 2)]

如果要根据值value排序呢?那么就传入比较函数这一参数就好啦:

复制代码 代码如下:
sorted(dic.items(),key=lambda d:d[1])

我继续用lambda匿名函数。其中d表示dic.items()里的每个迭代元素,即一个元组(例如(‘a’,
5));表达式d[1]就是元组中的第二个元素(例如5),它也是字典的值value,我们需要以它为比较标准。运行结果:
复制代码 代码如下:
[(‘d’, 2), (‘b’, 3), (‘a’, 5), (‘c’, 9)]

P.S.
博主今天闯关The Python
Challenge遇到一关,需要统计文本中出现的字符个数并找出出现最少的字符。当然那一关其实不需要自己写比较函数,输出统计结果肉眼看得出。博主借助搜索引擎min函数的key=func参数时,深痛中文Python介绍文章都是旧世界Python2.x的天下,满是在新世界不能用的语法,给Python3.x的初学者带来很多误导,有害无益。故出此文。

博主也是Python初学者,如有大牛批评指正,深感荣幸。

在Python3.x的世界里,cmp函数没有了。那么sorted,min,max等需要比较函数作为参数的函数该如何用呢?…

python基础:自定义函数,python自定义函数

一、背景

在学习函数之前,一直遵循:面向过程编程,即:根据业务逻辑从上到下实现功能,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,也就是将之前实现的代码块复制到现需功能处,如下

while True:
    if cpu利用率 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

    if 内存占用 > 80%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

 腚眼一看上述代码,if条件语句下的内容可以被提取出来公用,如下:

def 发送邮件(内容)
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接

while True:

    if cpu利用率 > 90%:
        发送邮件('CPU报警')

    if 硬盘使用空间 > 90%:
        发送邮件('硬盘报警')

    if 内存占用 > 80%:

  

对于上述的两种实现方式,第二次必然比第一次的重用性和可读性要好,其实这就是函数式编程和面向过程编程的区别:

  • 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可
  • 面向对象:对函数进行分类和封装,让开发“更快更好更强…”

函数式编程最重要的是增强代码的重用性和可读性

二、 函数的定义和使用

def 函数名(参数):

    ...
    函数体
    ...

  

函数的定义主要有如下要点:

  • def:表示函数的关键字
  • 函数名:函数的名称,日后根据函数名调用函数
  • 函数体:函数中进行一系列的逻辑计算,如:发送邮件、计算出
    [11,22,38,888,2]中的最大数等…
  • 参数:为函数体提供数据
  • 返回值:当函数执行完毕后,可以给调用者返回数据。

以上要点中,比较重要有参数和返回值:

1、返回值

函数是一个功能块,该功能到底执行成功与否,需要通过返回值来告知调用者。

def 发送短信():

    发送短信的代码...

    if 发送成功:
        return True
    else:
        return False


while True:

    # 每次执行发送短信函数,都会将返回值自动赋值给result
    # 之后,可以根据result来写日志,或重发等操作

    result = 发送短信()
    if result == False:
        记录日志,短信发送失败...

  

1、返回值

函数是一个功能块,该功能到底执行成功与否,需要通过返回值来告知调用者。

def 发送短信():

    发送短信的代码...

    if 发送成功:
        return True
    else:
        return False


while True:

    # 每次执行发送短信函数,都会将返回值自动赋值给result
    # 之后,可以根据result来写日志,或重发等操作

    result = 发送短信()
    if result == False:
        记录日志,短信发送失败...

澳门威斯尼人平台登陆 ,  

2、参数

为什么要有参数?

def CPU报警邮件()
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接

def 硬盘报警邮件()
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接

def 内存报警邮件()
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接

while True:

    if cpu利用率 > 90%:
        CPU报警邮件()

    if 硬盘使用空间 > 90%:
        硬盘报警邮件()

    if 内存占用 > 80%:
        内存报警邮件()

上例,无参数实现

  

def 发送邮件(邮件内容)

    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接


while True:

    if cpu利用率 > 90%:
        发送邮件("CPU报警了。")

    if 硬盘使用空间 > 90%:
        发送邮件("硬盘报警了。")

    if 内存占用 > 80%:
        发送邮件("内存报警了。")

  

函数的有三中不同的参数:

  • 普通参数
  • 默认参数
  • 动态参数

# ######### 定义函数 ######### 

# name 叫做函数func的形式参数,简称:形参
def func(name):
    print name

# ######### 执行函数 ######### 
#  'wupeiqi' 叫做函数func的实际参数,简称:实参
func('wupeiqi')

普通参数

  

def func(name, age = 18):

    print "%s:%s" %(name,age)

# 指定参数
func('wupeiqi', 19)
# 使用默认参数
func('alex')

注:默认参数需要放在参数列表最后

默认参数

  

def func(*args):

    print args


# 执行方式一
func(11,33,4,4454,5)

# 执行方式二
li = [11,2,2,3,3,4,54]
func(*li)

动态参数一

  

def func(**kwargs):

    print args


# 执行方式一
func(name='wupeiqi',age=18)

# 执行方式二
li = {'name':'wupeiqi', age:18, 'gender':'male'}
func(**li)

动态参数二

def func(*args, **kwargs):

    print args
    print kwargs

  

python的变参

*args和**kwargs是Python的两个动态参数,两者有所不同的是*args是个tuple,**kwargs是个dict。

*args 和**kwargs并用时,*args必须放在**kwargs的前面。

例如:

def func(a,b, *c):

    pass

函数func至少有两个参数变参数放在tuple  c中

def func(*c): 或者 def  func(**dc) 参数不确定

def func(a, *c, **dc): 
可以共用*args和**kwargs,不过一定要把*args放在前

一、背景
在学习函数之前,一直遵循:面向过程编程,即:根据业务逻辑从上到下实现功能,其往…

17.python自定义函数,17.python函数

  什么是函数,函数说白了就是将一系列代码封装起来,实现代码的重用。

  什么是代码重用?

  假设我有这样的需求:

自定义函数

  知道了函数是干什么用的之后,我们就开始学习自定义函数,也就是动手来造这个神奇的机器。

  看代码示例:

def dfb(a):
    '''一系列操作'''
    return '一碗%s饭' %a

a = dfb('米')
b = dfb('米')
print a
print b

 

澳门威斯尼人平台登陆 1

  这样我们就得到了两碗饭,真是方便快捷。

  现在来解释里面都有什么:

  1. def
是python的关键字,是专门用来自定义函数的。

  2. dfb是函数名,用来以后调用的。

  3.(a)中的a为函数的参数,为函数里面的操作提供数据的。

  4.return用来返回一个对象,这个对象可以是函数的处理结果,也可以是函数的处理状态等等。


1.def

  没什么好解释的,语法规定。

 

2.函数名

  函数名就类似于变量名。

  例如我写了一个函数,但我不调用它,那会怎么样。

def dfb(a):
    '''一系列操作'''
    return '一碗%s饭' %a

 

澳门威斯尼人平台登陆 2

  什么也没有输出,那是不是意味着函数不存在呢?

  我们看看内存里有没有:

print id(dfb)

 

澳门威斯尼人平台登陆 3

  很明显,函数在内存中,能够找得到。

  所以,当我们定义一个函数的时候,python就会将函数加载到内存中,只不过不调用的时候,函数内部的代码就不执行。

澳门威斯尼人平台登陆 4

  很明显,和变量赋值原理差不多,所以要注意一个问题:如果函数名和变量名冲突了,相当于重新赋值。而python解释是从上到下的,也就是说此时谁在下面谁占用这个变量名。剩下的那个就只能在内存中等待垃圾回收了。

def dfb(a):
    '''一系列操作'''
    return '一碗%s饭' %a
dfb = 1
print dfb

 

  澳门威斯尼人平台登陆 5

print dfb()

 

  澳门威斯尼人平台登陆 6

  那么函数名的命名有什么要求吗?

  函数名的要求比变量名严格一点,除了遵守变量名的要求之外,还不能够使用数字

  所以函数名只能使用字母和下划线(_),同时还要避开python的关键字。

  另外,在pep8标准中,函数名提倡都要小写


2.函数的作用于域

  参数函数的一大重难点,很多人不明白所谓的形参和实参到底是怎么回事。

  要明白其中的区别,首先还解释函数的作用域是什么回事。

澳门威斯尼人平台登陆 7

  所谓的函数作用域,就是这样。

  python在执行函数里面的代码的时候,会将其放在一个新的环境中,而这种新的环境就像电脑安装了虚拟机一样。新环境中并没有之前所创建的对象,相当于我在虚拟机中找不到我本机的文件一样。

  而函数运行之后,python会销毁函数的运行环境,也就是完成任务后就将虚拟机删除掉,里面的数据也就删除了。但代码还是有效的,例如我在虚拟机中去某网站注册了个账号,注册完以后我将虚拟机删掉了。但是我注册的账号不会被删掉,只不过我在虚拟机中的浏览记录不见了。

  这是,我问这样的一个问题:

a = 123

def dfb(a):
    '''一系列操作'''
    return '一碗%s饭' %a

b = '米'
print dfb(b)

  函数会输出什么,a现在指向谁?

澳门威斯尼人平台登陆 8

  因为函数是有作用域的,虽然全局中有a这变量,但是函数执行的时候是在新环境执行的,也就自然没有a这个变量。而当我函数执行完毕后,执行环境就销毁了,而且本来就是相互不影响的。自然a的指向就没有被改变。

  正是因为函数里面的a执行完毕后就消失了,所以它是形式上的,对全局来说没有什么意义。所以称其为形参,仅仅只是函数内部处理时用的。而当我们调用函数时,实际给的参数,如这里的 dfb(b) 中的b这个实际的参数,就称为实参。

  而在函数内的变量就是局部变量,外部的就是全局变量所以在函数中定义的变量,也就是局部变量,只在函数内部有效。


 2.global

  如果我要强制在函数里面进行全局变量的声明怎么办?

a = 123

def dfb(a):
    '''一系列操作'''
    b = 1
    return '一碗%s饭' %a

dfb('米')
print b

 

  澳门威斯尼人平台登陆 9

  此时可以使用global关键字:

a = 123

def dfb(a):
    '''一系列操作'''
    global b  #我先声明我要创建一个全局变量b
    b = 1   #然后我再为b赋值
    return '一碗%s饭' %a

dfb('米')
print b

 

澳门威斯尼人平台登陆 10

  这样就可以在函数内创建全局变量了。

  此时有机智的同学就要问了,那我在函数内部声明的全局变量和之前的冲突,是不是会重新赋值呢?

  答案:是的。

  但要注意一个问题:

a = 123

def dfb(a):
    '''一系列操作'''
    global a    #我声明全局变量a,想要覆盖之前的赋值,而传参的时候,相对于进行了a=b的操作
    return '一碗%s饭' %a

b = '米'
print dfb(b)

 

  然而报错了:

澳门威斯尼人平台登陆 11

  说明我们不能将形式参数声明为全局的。

  那我们改一下形式参数的名称:

a = 123

def dfb(c):
    '''一系列操作'''
    global a    #我声明全局变量a,想要覆盖之前的赋值
    a = c
    return '一碗%s饭' %a

b = '米'
dfb(b)
print a

澳门威斯尼人平台登陆 12

  可以了,说明我们的思路是正确的,在函数内声明全局变量确实会覆盖已经有的变量。


 

 

3.传参

  传参是函数的又一大重点和难点。

  传参是为了能使函数适用更多的情况,我们在上面的示例中都写列带参数的函数,是不是说函数一定要参数才行呢?

def test():
    print '然而我并没有参数'

test()

 

澳门威斯尼人平台登陆 13

  可以看出没有参数也是可以的,只是没有参数的时候,无论怎么调用得到的结果都是一样的,灵活性太低,所以为了提高灵活性,就有了参数存在的必要。

  而参数又分为普通参数,默认参数,动态参数,下面逐一说明。

1.普通参数

def test(a,b,c):
    print a
    print b
    print c
test(1,2,3)

 

澳门威斯尼人平台登陆 14

  可以看出参数是按照顺序传递进去的,这种写法就叫普通函数。

  但是这里有一个问题:

def test(a,b,c):
    print a
    print b
    print c
test(1,2)

 

澳门威斯尼人平台登陆 15

  本来要传3个参数的,但是我仅传了2个,这样就报错了。但我不想这样,我希望当我不传参数的时候,参数有一个默认的值,此时就需要默认参数了。

 

2.默认参数

def test(a,b,c=3):
    print a
    print b
    print c
test(1,2)

 

澳门威斯尼人平台登陆 16

  传参就相当于为形参赋上实参的值,你给了参数,我就按顺序执行 a = 1 ,b
= 2,但此时c已经赋值为3了,所以就算不传,参数的数量也够了。

  当然也可以将参数传够, text(1,2,3)
就相当于为c重新赋值了。这样就能达到你传了参数就按照传的参数来处理,而没传就按默认的值处理

  所以我们可以为全部的参数都设置默认值。

  但是可能会出现这样的情况:

def test(a=1,b,c=3):
    print a
    print b
    print c
test(1,2)

 

澳门威斯尼人平台登陆 17

  并不允许这样的写法,因为这样没有默认值的参数很难处理,所以当默认参数和普通参数同时存在时,要将普通参数放在前面:

def test(b,a=1,c=3):
    print a
    print b
    print c
test(1,2)

 

澳门威斯尼人平台登陆 18

  之所以要规定这样写,是因为要配合传参的方法:我们可以显式地规定哪个值是传给哪个参数的:

def test(b,a=1,c=3):
    print a
    print b
    print c
test(a=1,b=2,c=3)

 

澳门威斯尼人平台登陆 19

  如果是这样的显式传参的话,传参的顺序是任意的。也就是 text(a=1,c=3,b=2)
也可以,反正最后赋值的结果是一样的。

  但是,如果是普通传参和显式传参配合使用时,就必须将默认传参放在开头: text(2,a=1,c=3,)
普通的按顺序传,显式可以不按顺序传。这也就是我们在写函数的时候要求普通的参数都放在前面,默认的参数都放在后面,就是为了和这里对应。

 

3.动态参数

  因为我们的函数最后可能并不是只有自己用,而是给用户或其他人调用,但是其他人不一定了解我这里接受多少个参数。

  传少了我们可以使用默认参数来解决,但是传多了怎么办,一旦传多了就报错用户体验就不好了,为了提高函数的适应能力,就出现了动态参数。

def test(a,*args,**kwargs):
    print a
test(1,2,c=3)

 

澳门威斯尼人平台登陆 20

  这样函数的适应性就更高了,那么这里的 *args 和 **kwargs 分别是什么意思。

  我们先来看去是什么类型:

def test(a,*args,**kwargs):
    print type(args),type(kwargs)

test(1,2,c=3)

 

澳门威斯尼人平台登陆 21

  它们是元祖和字典,这里注意前面的*号只是表示这个是什么类型的,*表示元祖,**代表字典,而真正的变量名是*后面的。这里并没有规定一定要用args命名元祖,kwargs命名字典。但是这是个规范的写法,为的是让别的程序员能一眼看出这是个什么东西。

  接下来我们看看里面存的是什么:

def test(a,*args,**kwargs):
   print args
   print kwargs

test(1,2,c=3)

 

澳门威斯尼人平台登陆 22

  它将默认传参方式多传的值放在一个元祖里,而用显式传参多传的用其参数名为键,参数值为值,组成了字典。

  你可以无视它们,也可以将处理它们,赋值操作也好,循环也好,成员判断也好,各种需要看个人。


4.return

  当函数遇到return语句时,表示函数执行完毕,此时返回一个对象,然后销毁函数的执行环境。

  但是你在上面的示例中看到也有这样的写法:

def test():
    print '我并没写return'

test()

 

澳门威斯尼人平台登陆 23

  发现没有return语句还是能执行的,在调用的时候输出了东西,执行一遍后也停止了。

  注意,在函数内没有写return语句的时候,默认return的是一个空对象。也就是就算没写,python内部也做了处理。

  此时,有部分人分不清函数的输出和返回值的区别。

  这样说吧,在函数里print之类的操作能够输出内容,是因为虽然函数的执行环境是独立的,但代码还是有效的。外部能进行的操作,函数内部也可以。但是并不是所有的函数在执行完毕后都有如此明显的输出效果,此时我们需要查看函数是否成功,或者说我放了米进去,你操作一番之后总要把饭给我拿出来吧。

  这就是函数中return的意义。返回一个对象。这个对象可以是对执行状态的说明,也可以是处理后的结果等等。

def test():
    '''一系列操作'''
    return '搞定了'

test()

 

澳门威斯尼人平台登陆 24

  但运行还是没看到东西。

  那是因为函数虽然返回了对象,但是这个对象还在内存中,你并没有把它拿出了,当然什么也看不到。

print test()

 

澳门威斯尼人平台登陆 25

  这样就看到了,当然你可以进行变量的赋值,如 a = test()
,之后调用变量a就行了。当然返回结果多用True和False代表成功和失败,然后可以和条件控制语句配合使用。

def test():
    '''一系列操作'''

print test()

澳门威斯尼人平台登陆 26

  当然不写就默认返回空对象None了。

 

def test(a,b):
    c = a + b
    return c

print test(1,2)

 

澳门威斯尼人平台登陆 27

  返回处理后的结果也是可以的,反正看个人需求。

 

  最后,虽说遇到return代表函数结束,但并意味着一个函数里面只有一个return。

def test(a,b):
    if a != 0:
        return a + b
    return 'a不能为0'

print test(1,2)
print test(0,2)

 澳门威斯尼人平台登陆 28

  可以配合条件控制语句实现不同情况返回不同的对象,这样就函数就能处理更多的情况了。

 


匿名函数:

  有些情况下,我只想用函数处理一下很简单的业务,这个时候完整地写一个函数感觉会增大代码量,此时可以使用匿名函数进行处理。

  python 使用 lambda 来创建匿名函数:

  1.lambda只是一个表达式,函数体比def简单很多。

  2.lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

  3.lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。

  4.虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。

 

语法:

lambda [arg1 [,arg2,.....argn]]:expression

 

示例:

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

 

澳门威斯尼人平台登陆 29

  虽说是匿名函数,但是还是需要将其赋给一个变量,否则无法调用。而匿名函数里面的变量也是局部变量,和完整的函数也没有什么区别。

  匿名函数建议只在处理简单功能的时候使用,太过复杂的还是使用完整的函数吧。


pass语句

  Python pass是空语句,是为了保持程序结构的完整性。pass
不做任何事情,一般用做占位语句。

def test():
    pass    #我想要用这个函数处理某些事,但我暂时没想好怎么写,就先占个坑

 

  当然,不仅函数可以使用,流程控制中也可以使用。

if a <= 10:
    pass
else:
    print 'a大于10'

 

  还是那句话,仅起占位的作用。

 


  关于自定义函数就先说到这里,如有什么错误和需要补充的后面会相应修改。

 

什么是函数,函数说白了就是将一系列代码封装起来,实现代码的重用。
什么是代码重用? 假设我有这样…

标签: python类 双下划线特殊函数


今天遇到python类内部系统以双下划线开头和结尾的情况,特去学习一部分的应用情况,顺便记录一下。python
的OOP编程中,每个类拥有一些系统特殊定义的函数,比如__init__表示初始化类,相当于构造函数,建立对象时候会先调用这个方法来初始化一些成员变量。__del__表示析构函数,就是对象不再存在于作用空间时,会调用这个函数来释放空间。今天要记录两个比较特殊双下划线的函数:__getitem____contains__:

1、__getitem__、__contains__函数###\

  • __getitem__函数表示通过索引获得数据,相当于data[key],通过在类中重写这个函数,我就可以使用该类的对象obj[key]来直接操作
  • __contains__函数在类的对象使用 in 和 not
    in时可以返回TRUE或者False。

2、代码###\

class DoubleUnderline():
    def __init__(self, d=None):
        self.data = dict()
        self.data = d

    def __getitem__(self, key):
        print 'use __getitem__'
        return self.data[key]

    def __contains__(self, item):
        print 'use __contains__'
        return item in self.data


def main():
    data = dict()
    names = []
    for i in range(1, 5):
        names.append(str(i))
    val = 'a'
    for name in names:
        data[name] = val
        val = val + val
    dbline1 = DoubleUnderline(data) #类对象
    print dbline1['2']
    str1 = '3'
    print str1 in dbline1


if __name__ == "__main__":
    main()

3、输出结果###\

use __getitem__
aa
use __contains__
True

4、使用环境###\

一般对于dict词典数的应用比较合理,data[key]和 in、not in
对于词典数来说应用比较灵活。

5、其他类内部神奇函数如下链接###\

Python
的神奇方法指南

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图