威尼斯人线上娱乐

小白学习之路,内置函数

18 5月 , 2019  

python函数

  • 函数的中坚概念
  • 函数参数
  • 返回值
  • 有些变量和全局变量
  • 嵌套函数
  • 无名函数
  • 高阶函数
  • 递归

1. 背景提要

现行反革命当主令你写3个监察程序,监察和控制服务器的类别境况,当cpu\memory\disk等指标的使用量当先阀值时即发邮件报告警察方,你掏空了全数的知识量,写出了以下代码

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

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

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

上边包车型大巴代码实现了服从,但正是是邻里老王也来看了线索,老王亲切的摸了下你家儿子的脸孔,说,你这一个重复代码太多了,每便报告警方都要重写一段发邮件的代码,太low了,那样干存在二个难点:

  1. 代码重复过多,贰个劲的copy and paste不切合高等程序猿的风姿
  2. 如果之后供给修改发邮件的这段代码,例如加入群发效率,那您就必要在享有用到这段代码的地方都修改贰遍

您以为老王说的对,你也不想写重复代码,但又不知情怎么搞,老王好像看出了你的意念,此时她抱起你外孙子,笑着说,其实很简短,只须要把重复的代码提抽出来,放在2个共用的位置,起个名字,未来何人想用这段代码,就透过那一个名字调用就行了,如下:

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

while True:

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

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

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

您看着老王写的代码,气势恢宏、磅礴大气,代码里透露着一股内敛的骄气,心想,老王此人就是不一般,突然对她的背景更感兴趣了,问老王,那些花式游戏的方法你都是怎么掌握的?
老王亲了一口你孙子,捋了捋不设有的胡须,淡淡的讲,“老夫,年少时,师从京西沙河淫魔银角大王
”,
你壹听“银角大王”那多少个字,不由的娇躯1震,心想,真nb,怪不得代码写的那样陆,
那“银角大王”当年在人世上然而数得着的盛名的名字,只可惜早先时期纵欲过度,卒于公元贰零一肆年,
真是可惜了,只留下其兄长孤守当年兄弟俩一齐打下来的国家。
此时您瞧着的老王离开的人影,感到你外孙子跟她尤其像了。。。

小结运用函数的好处:

1.代码录用

二.保持一致性,易维护

三.可扩张性

 

一、函数的牵线

函数是团伙好的,可重复使用的,用来贯彻单壹,或相关联作用的代码段。

函数能增高使用的模块性,和代码的重新利用率。你早已明白Python提供了许多内建函数,比方print()。但您也足以本身创立函数,那被称功能户自定义函数

函数的好处:

  • 代码重用
  • 保持一致,易于维护
  • 可扩充性

函数的主干概念

2. 什么是函数?

函数壹词来源于数学,但编制程序中的「函数」概念,与数学中的函数是有不小不相同的。

初级中学数学函数定义:一般的,在1个浮动进度中,假设有两个变量x和y,并且对于x的每多个规定的值,y都有唯①显明的值与其对应,那么大家就把x称为自变量,把y称为因变量,y是x的函数。自变量x的取值范围叫做这些函数的定义域

例如  y=2*x

一,函数的中坚介绍

先是谈起函数,相信大家都不素不相识,不管是其他语言都会用到,大概正是叫法不平等。就自己清楚的跟python中函数类似的,在C中唯有function,在Java里头叫做method,在js中也是叫function。函数是团队好的,可重复使用的,用来兑现单一,或相关联功效的代码段。函数能加强使用的模块性,和代码的重新利用率。你早就知道Python提供了广大内建函数,例如print()。但你也足以友善成立函数,那被称成效户自定义函数。

函数有下边3点便宜:

一.力所能致减弱重复代码的运用

2.让您的次第有更加好的扩展性

3.足以令你的主次变得愈加便于保证

上边大家就来讲一下怎么定义二个函数

  • 函数代码块以 def 关键词开头,后接函数标志符名称和圆括号()
  • 任何传入参数和自变量必须放在圆括号中间。圆括号之间能够用来定义参数。
  • 函数的率先行语句能够选用性地利用文书档案字符串—用于存放函数表达。
  • 函数内容以冒号初始,并且缩进。
  • return [表达式]
    截止函数,采用性地回来3个值给调用方。不带表明式的return相当于重回None。

填补知识:return不重回值的时候有三种情势:不写return,只写四个return,可能return
None。return当有多少个重临值的时候用逗号分隔。接收的时候能够用1个变量接收(元组),也能够用七个变量接收。

二、函数的概念

函数的定义规则:

  • 函数代码块以 def 关键词开端,后接函数标志符名称和圆括号 ()
  • 别的传入参数和自变量必须放在圆括号中间,圆括号之间能够用来定义参数
  • 函数的首先行语句能够选择性地利用文书档案字符串—用于存放函数表达
  • 函数内容以冒号起首,并且缩进
  • return
    [表达式]
     甘休函数,选拔性地回去3个值给调用方。不带表明式的return也等于再次回到None

函数的语法:

  

def 函数名:
    函数体

  

函数的亲自去做:

def print_hello():
    """
    打印hello
    :return: 
    """
    print("hello")

  

引子

后天您的老董令你写二个监理程序,二四钟头全年午无休的督察你们集团网址服务器的运转情形,当cpu\memory\disk等目的的使用量超越阈值时即发送报告警察方邮件:

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

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

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

那么当你的同事见状那么些代码的时候,就意识了代码的重复性比较高,每趟报告警察方都要重写一段发邮件的代码,贰个劲的copy
and
paste根本就不吻合高档程序员的气度,其次假如未来想修改发邮件的代码,举个例子加上群发功效,那么就要求在富有代码上都要修改1次.

您也看出来了那一个标题,你也不想去写重复代码,但又不明白怎么写,此时您的同时笑着和你说,这么些很简短,壹旦把重复的代码提议出来,放在多少个共用的地方,起个名字,未来谁想用那些代码,就透过那些名字就足以调用了.,如下:

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

while True:
    if cpu利用率 > 90%:
        发送邮件('CPU报警')
    if 硬盘使用空间 > 90%:
        发送邮件('硬盘报警')
    if 内存占用 > 80%:
        发送邮件('内存报警')

2.1 python函数

函数是公司好的,可重复使用的,用来促成单一,或相关联功用的代码段。

函数能增高使用的模块性,和代码的双重利用率。你已经掌握Python提供了广大内建函数,比方print()。但您也足以友善创办函数,那被称功能户自定义函数。

python中等高校函授数定义:函数是逻辑结构化和进度化的一种编制程序方法。  
能够明白为: 函数是指将一组语句的会集通过三个名字(函数名)封装起来,要想进行那几个函数,只需调用其函数名就可以;

特性:

  1. 调整和减弱重复代码
  2. 使程序变的可扩张
  3. 使程序变得易维护

2,函数的参数

函数能够传参,也足以不传参,都以足以的哦。

威尼斯人线上娱乐 1威尼斯人线上娱乐 2

 1 #定义一个需要传参的函数
 2 def say(name):
 3     print('hello',name)
 4 say('zzq')   #调用say这个函数,并且传入参数
 5 
 6 #不需要传参的函数
 7 def take():
 8     print('I Love You')
 9 take()   #调用函数,不传任何参数
10 
11 #有返回值的函数
12 def add(x,y):
13     return x+y
14 a=add(4,5) #传入的参数必须是相同数据类型
15 print(a)   #执行结果为9

View Code

值得注意的是在扩散的参数还有三种:常见参数,不定长参数,自规范

威尼斯人线上娱乐 3威尼斯人线上娱乐 4

 1 #普通参数
 2 def say1(name):
 3     print(name)
 4 say1('gmx')
 5 
 6 #不定长参数
 7 def say2(*args):
 8     print(args)
 9 say2(1,5,'sd')
10 
11 #自典型
12 def say3(**kwargs):
13     print(kwargs)
14 say3(name='zzq',say='I Love You',to_name='gmx')#传入的参数必须是字典
15 
16 #执行结果为
17 #gmx
18 #(1, 5, 'sd')
19 #{'name': 'zzq', 'say': 'I Love You', 'to_name': 'gmx'}

View Code

视听参数大家还平日听到形参跟实参那四个词,上面作者跟我们大约讲一下相互的界别。

  • 形参变量唯有在被调用时才分配内部存款和储蓄器单元,在调用停止时,立时释放所分配的内部存款和储蓄器单元。因而,形参只在函数内部有效。函数调用结束再次回到主调用函数后则不能够再选取该形参变量
  • 实参能够是常量、变量、表明式、函数等,无论实参是何种类型的量,在拓展函数调用时,它们都必须有规定的值,以便把这么些值传送给形参。因而应事先用赋值,输入等措施使参数得到分明值

三、函数的重临值

依照示例来看下python的重回值:

def fun2():
    msg = "hello world"
    return msg


def fun3():
    return 1, 2 ,3 

aa = fun1()
bb = fun2()
cc = fun3()
print(aa)
print(bb)
print(cc)

# 输出结果:
# None
# hello world
# (1, 2, 3)

总结:

  一.函数中只要未有return语句重临,那么python函数会暗中同意重返None

  二.函数再次来到值数为0,函数默许重临None;函数再次回到值数为一是,则赶回object;再次来到值数大于一时,则赶回的是3个tuple;

 

主导概念

二.2 定义多少个函数

您能够定义二个由友好想要功效的函数,以下是简简单单的条条框框:

  • 函数代码块以 def 关键词初叶,后接函数标志符名称和圆括号()
  • 其余传入参数和自变量必须放在圆括号中间。圆括号之间能够用来定义参数。
  • 函数的第2行语句能够选取性地动用文书档案字符串—用于存放函数表明。
  • 函数内容以冒号开首,并且缩进。
  • return
    [表达式]
     停止函数,选用性地回去1个值给调用方。不带表明式的return也正是重临None。

语法定义:

def sayhi():                 # def:定义函数的关键字,函数名:sayhi,()内可以指定形参
  """The function definitions"""     # 文档描述(非必要,但是强烈建议为你的函数添加描述信息)
    print("Hello, I'm nobody!")       # 泛指代码块或程序处理逻辑
sayhi()                   # 调用函数,通过函数名()的形式

叁,全局变量跟局部变量

怎样是全局变量跟局地变量呢,依照他们的名字能够掌握,全局变量能够在全局使用,局地变量呢只可以在一些地点选拔的变量。

在函数里面定义的变量为一些变量,只可以试用于函数。

在外边定义的叫全局变量,也能够在函数内部访问。

铭记!假使全局变量有二个变量名字跟函数里面包车型客车如出一辙,函数内部在调用时,用的是函数内部的变量

威尼斯人线上娱乐 5威尼斯人线上娱乐 6

 1 name='zzq'
 2 def say():
 3     name='gmx'
 4     print(name)#调用的是函数内部的name
 5 say()
 6 print(name)#调用的全局变量的name
 7 
 8 #执行结果
 9 #gmx
10 #zzq

View Code

在函数中的局地变量也能转化为全局变量,不过这种情势是不引入应用的,也是不能够动用的。

威尼斯人线上娱乐 7威尼斯人线上娱乐 8

 1 name='zzq'
 2 def say():
 3     global name #把name设置为全局变量
 4     name='gmx'
 5     print(name)
 6 say()
 7 print(name)
 8 #执行结果
 9 #gmx
10 #gmx

小白学习之路,内置函数。View Code

肆、函数的参数

 函数参数的标准化:

  • 形参变量唯有在被调用时才分配内部存款和储蓄器单元,在调用截止时,立时释放所分配的内存单元。由此,形参只在函数内部有效。函数调用截止重临主调用函数后则不能够再使用该形参变量
  • 实参能够是常量、变量、表明式、函数等,无论实参是何体系型的量,在开展函数调用时,它们都必须有规定的值,以便把这几个值传送给形参。因而应优先用赋值,输入等方法使参数获得分明值
  • 职务参数和要紧字(标准调用:实出席形参地点壹一对应;关键字调用:地方没有供给固定)
  • 暗中认可参数
  • 参数组

函数是怎么着?

函数一词来源于数学,但编制程序中的「函数」概念,与数学中的函数是有一点都不小区别的,编制程序中的函数在英文中也可以有大多例外的叫法。在BASIC中称之为subroutine(子进度或子程序),在帕斯Carl中称之为procedure(进程)和function,在C中唯有function,在Java中间叫做method。

概念:函数是指将1组语句的集纳通过三个名字(函数名)封装起来,要想进行这一个函数,只需调用其函数名就能够

2.3 函数和进度

进程定义:进度正是轻便特殊未有重返值的函数

诸如此类看来大家在批评为什么选拔函数的的时候引进的函数,都未曾再次来到值,没有重返值正是经过,没错,可是在python中有相比美妙的专业:

def test01():
    msg = 'hello The little green frog'
    print
    msg

def test02():
    msg = 'hello WuDaLang'
    print
    msg
    return msg

t1 = test01()
t2 = test02()

print('from test01 return is [%s]' % t1)
print('from test02 return is [%s]' % t2)

总结:
当3个函数/进程并未有行使return呈现的定义重回值时,python解释器会隐式的归来None,

之所以在python中就是是经过也可以算作函数。

def test01():
    pass

def test02():
    return 0

def test03():
    return 0, 10, 'hello', ['alex', 'lb'], {'WuDaLang': 'lb'}

t1 = test01()
t2 = test02()
t3 = test03()

print('from test01 return is [%s]: ' % type(t1), t1)
print('from test02 return is [%s]: ' % type(t2), t2)
print('from test03 return is [%s]: ' % type(t3), t3)

总结:

   重回值数=0:重返None

   重临值数=1:重返object

   再次回到值数>一:再次来到tuple

四,无名氏函数

python 使用 lambda
来成立无名函数,一般多个函数用的次数比较少,为了便于就涌出了无名函数。

  • lambda只是三个表明式,函数体比def轻易诸多。
  • lambda的基点是二个表明式,而不是贰个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda函数具有和睦的命名空间,且不可能访问自有参数列表之外或全局命名空间里的参数。
  • 就算如此lambda函数看起来只可以写一行,却差异样C或C++的内联函数,后者的指标是调用小函数时不占用栈内部存款和储蓄器从而扩充运转作用。

无名函数基本语法:

1 #计算数字的平方
2 calc=lambda n:n*n  #定义一个匿名函数
3 print(calc(5))
4 
5 #当然还能这样用
6 l=map(lambda n:n*n,[1,2,3,4,5]) #map把后面可迭代对象去执行前面的函数
7 for i in l:
8     print(i)

在此间运用了map,那就简单的提一下把。因为要提到到背后的迭代对象,所以就回顾讲一下用法。

map函数的原型是map(function, iterable, …)威尼斯人线上娱乐,,它的归来结果是二个列表。

参数function传的是三个函数名,能够是python内置的,也能够是自定义的。
参数iterable传的是二个能够迭代的目的,举个例子列表,元组,字符串那样的。

批注起来有一些不佳掌握,上边一些简约的代码例子,供我们参考吧。

威尼斯人线上娱乐 9威尼斯人线上娱乐 10

 1 a=(1,2,3,4,5)
 2 b=[1,2,3,4,5]
 3 c="zhangkang"
 4 
 5 la=map(str,a)
 6 lb=map(str,b)
 7 lc=map(str,c)
 8 
 9 print(la)
10 print(lb)
11 print(lc)
12 
13 输出:
14 ['1', '2', '3', '4', '5']
15 ['1', '2', '3', '4', '5']
16 ['z', 'h', 'a', 'n', 'g', 'k', 'a', 'n', 'g']

View Code

一般说来参数

def fun1(name):   # name为形式参数
    print(name)


aa = "hello"
fun1(aa)  # aa为实参

  

函数的风味

  • 减掉重复代码
  • 使程序变得可扩展
  • 使程序变得可爱抚

贰.四 函数实例:

实例1:

以下为2个粗略的Python函数,它将贰个字符串作为传播参数,再打字与印刷到正规展现设备上。

def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return

# 调用函数
printme("我要调用用户自定义函数!");

实例2:

传递参数且有重返值的函数

a,b = 5,8
c = a**b
print(c)

#改成用函数写
def calc(x,y):
    res = x**y
    return res #返回函数执行结果

c = calc(a,b) #结果赋值给c变量
print(c)

注: 函数定义阶段只检查测试函数体的语法,并不会实践

5,嵌套函数

嵌套函数,听到名字难道是二个函数里面还是能够放函数,卧槽,居然特么还有这种操作?当然,嵌套函数就是三个函数里面还嵌套其余三个函数,上面1个简约的例证,给我们参照他事他说加以考察通晓呢。

威尼斯人线上娱乐 11威尼斯人线上娱乐 12

 1 name='zzq'
 2 def say1():
 3     name='gmx'
 4     def say2():
 5         name='other'
 6         print('最里面函数',name)
 7     say2()
 8     print('外面一层函数',name)
 9 say1()
10 print('最外面函数',name)
11 
12 #执行结果
13 #最里面函数 other
14 #外面一层函数 gmx
15 #最外面函数 zzq

View Code

默许参数

def func(name, age=18):
    print("%s:%s" % (name, age))


# 指定参数
func('wupeiqi', 19)  # 使用默认参数
func('alex')
# 注:默认参数需要放在参数列表最后

 

语法定义

def sayhi():  # sayhi函数名
    print('hello world')

sayhi()  # 调用函数

2.伍 函数的调用

def foo():
    print('from foo')

def bar(name):
    print('bar===>',name)

foo()  #调用函数foo
bar()  #调用函数bar

循途守辙有参和无参能够将函数调用分三种

foo()      # 定义时无参,调用时也无需传入参数
bar('egon') # 定义时有参,调用时也必须有参数

依照函数的调用格局和出现的岗位,分二种

foo() #调用函数的语句形式

def my_max(x,y):
    res=x if x >y else y
    return res
res=my_max(1,2)*10000000 #调用函数的表达式形式
print(res)

res=my_max(my_max(10,20),30) #把函数调用当中另外一个函数的参数
print(res)

六,递归

小编们刚刚理解了嵌套函数,知道在函数的内部能够一而再调用函数,假若在函数的个中调用本身,那么那个函数便是递归。当然递归不可小看乱用,他也许有和煦的调用天性。

递归性格:

  1. 必须有二个可想而知的扫尾条件

  2. 历次进入更加深壹层递归时,难点规模比较上次递归都应负有削减

三.
递归功效不高,递归档次过多会导致栈溢出(在计算机中,函数调用是经过栈(stack)这种数据结构落成的,每当进入两个函数调用,栈就能够加一层栈帧,每当函数重临,栈就能减壹层栈帧。由于栈的高低不是极度的,所以,递归调用的次数过多,会招致栈溢出)

威尼斯人线上娱乐 13威尼斯人线上娱乐 14

 1 #输入一个数,输出所有平方小于500的数
 2 def calc(n):
 3     if n>500:
 4         return n
 5     print(n)
 6     return calc(n*n)  #继续调用自己,形成递归
 7 calc(2)
 8 
 9 #执行结果
10 2
11 4
12 16
13 256

View Code

4.阶乘

在递归的利用中,有贰个很特出的例子,那正是测算阶乘的结果。用其余办法也足以完结,不过揣度相比较麻烦,上边是用简短的递归实现阶乘总结。

1 def test(x):
2     if x==1:
3         return x
4     else:
5         return x*test(x-1)

 

动态参数

def func1(*args):
    print(args)

# 执行方式一
func1(11, 33, 4, 4454, 5)
# 执行方式二
li = [11, 2, 2, 3, 3, 4, 54]
func1(*li)


def func2(**kwargs):
    print(kwargs)
# 执行方式一
func2(name='wupeiqi', age=18)
# 执行方式二
dict1 = {'name': 'fyh', "age": 18, 'gender': 'male'}
func2(**dict1)

 

函数参数

形参变量
除非在调用时猜分配内存单元,在调用甘休后,立时释放所分配的内部存款和储蓄器单元.因而,形参只在函数内部有效.函数调用甘休重返主调用函数后则无法再使用该形参变量

实参
能够是常量\变量\表达式\函数等,无论实参是这体系型的量,再进行函数调用时,他们都必须有规定的值,以便把这几个值传送给形参.由此应优先用赋值,输入等艺术使参数得到明显值.

def cacl(x,y):  # 此时的x,y是形参
    res = x**y
    return res

c = cacl(2,5)  # 此时的2,5是形参
print(c)

二.陆 函数的再次来到值

要想赢得函数的执行结果,就足以用return语句把结果再次来到

注意:

  1. 函数在施行进度中一旦遭受return语句,就能甘休施行并赶回结果,so
    也足以领略为 return 语句代表着函数的甘休
  2. 设若未在函数中钦点return,那这么些函数的再次回到值为None
  3. return 三个值 函数调用再次来到的结果就是那一个值
  4. return 值一,值2,值三,… 重回结果:(值一,值2,值三,…)

七,高阶函数

变量能够针对函数,函数的参数能接过变量,那么3个函数就足以接过另二个函数作为参数,这种函数就叫做高阶函数。通俗的讲正是函数的参数能够是函数,然后中间的参数能够给作为参数的函数当成传入的参数。emmm,好啊,讲得是有一点乱。。那就剖析剖判代码吧

威尼斯人线上娱乐 15威尼斯人线上娱乐 16

1 输入ascii的编码号,输出对应的值
2 def say(letter,f):
3     return f(letter)
4 ascii_name=say(65,chr)#f为一个函数
5 print(ascii_name)
6 #执行结果
7 #A

View Code

卧槽,无声无息学了那般多函数了呀,你就能想这些学了有何用嘛,放心,那几个为前面厉害的吹捧的打基础呢,那章的嵌套函数跟高阶函数为前边的装饰器打基础。万丈高楼平地起,所以依然要把基础精晓好,怎么能力越来越好的垄断(monopoly)呢,当然方法只有三个,那就是多敲,多记,多思量。

 

万能参数

# 万能参数
def func(*args, **kwargs):
    pass

 

暗许参数

看如下代码:

def stu_register(name,age,country,course):
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

stu_register('老王',22,'CHINA','PYTHON')
stu_register('小明',18,'CHINA','JAVA')
stu_register('康康',19,'CHINA','C++')

运行结果如下:

-----注册学生信息-----
姓名: 老王
年龄: 22
国家: CHINA
课程: PYTHON
-----注册学生信息-----
姓名: 小明
年龄: 18
国家: CHINA
课程: JAVA
-----注册学生信息-----
姓名: 康康
年龄: 19
国家: CHINA
课程: C++

那会儿大家发掘了3个主题素材,大家发掘country那个参数的值都以CHINA,就好像我们在注册网址的时候,像国家这种新闻,你不填写的话,那么暗中同意是CHINA,那便是经过默许参数达成的,把country形成暗许参数极其轻便.

def stu_register(name,age,course,country='CHINA'):

如此,那么些参数在调用时不钦赐,那么暗中同意便是CHINA了,如若钦点的话,就是你协和钦赐的值了.举个例证看看:

# 默认参数--如果用户指定了参数值,则使用用户指定的值,否则使用默认参数的值。
def stu_register(name,age,course,country='CHINA',):
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

stu_register('老王',22,'PYTHON')
stu_register('小明',18,'JAVA','JAPAN')  # 指定了country = JAPAN

这正是说大家看一下一周转结果:

-----注册学生信息-----
姓名: 老王
年龄: 22
国家: CHINA
课程: PYTHON
-----注册学生信息-----
姓名: 小明
年龄: 18
国家: JAPAN
课程: JAVA

那么,为何默许参数要放置在参数的末段多少个任务吗?让我们来看下:

def stu_register(name,age,country='CHINA',course):  # 如果写成这样的话,那么会立即报错,根本就不会运行,因为将实参传递给形参时,不知道CHINA是传给谁的
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

stu_register('康康',19,'CHINA','C++')

2.柒 自定义函数

概念函数的三种样式

  • 无参数函数:若是函数的机能仅仅只是推行一些操作而已,就定义成无参函数,无参函数一般都有重临值
  • 概念有参函数:函数的职能的实践依赖于表面传入的参数,有参函数一般都有重回值
  • 空函数

 

五、全局变量与部分变量

全局变量与一些变量的本色在于成效域的例外

全局变量说白了正是在漫天py文件中宣示,全局范围内都能够行使

局地变量是在有个别函数内注解的,只万幸函数内部选拔

 

举例:

def fun1():
    name = "aa"

print(name)

 

实行结果:

  威尼斯人线上娱乐 17

报错的缘由:试图访问一些变量而报的错

 

第2参数

好端端境况下,给函数字传送参数要按梯次,不想按顺序就能够用关键参数,只需点名参数名就足以了(钦命参数名的参数就叫做关键参数),注意:重中之重参数必须放在地点参数之后(以职务顺序鲜明对应涉及的参数)
比方看一下:

def stu_register(name,age,course='python',country='CHINA'):  # 设置两个默认参数
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

stu_register('王佳',course='LIUNX',age = 22)

但是不得以如此调用:

stu_register('小明',course='java ',22,country='JAPAN')
也不可以这样
stu_register('小明',22,23,country='JAPAN')  # 这句话等于将22 23传递给了age,但是不能传递两个值

三. 函数参数

形参: 变量唯有在被调用时才分配内部存款和储蓄器单元,在调用停止时,立即释放所分配的内部存款和储蓄器单元。因而,形参只在函数内部有效。函数调用截止重临主调用函数后则不可能再利用该形参变量。

实参: 能够是常量、变量、表明式、函数等,无论实参是何体系型的量,在打开函数调用时,它们都必须有规定的值,以便把那些值传送给形参。由此应先行用赋值,输入等方法使参数获得明确值。

威尼斯人线上娱乐 18

一部分变量与全局变量变量名同样

  • 全局变量与部分变量名一致,函数内部会事先利用部分变量
  • 修改部分变量不会潜移默化到全局变量

    name = “bb”

    def print_name():

    name = "aa"
    print(name)
    

    print_name()

    print(name)

    # 打字与印刷的结果为
    # aa
    # bb

 

非固定参数

若您的函数中不分明要传播多少参数,就能够利用非固定函数,举个例证来讲,小说早先的邮件报告警察方,现在本身不想只对壹位发邮件,笔者想对全部运转部的人发送报告警察方邮件,那么那个时候利用非固定参数最合适但是了:

def students(name,age,*args):  # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)  # 打印name,age,args

students('小明',22,'PYTHON','CHINA')  # 小明 22 ('PYTHON', 'CHINA')

原来,*args所承受的参数是用元组的格局保留的

那正是说今后还有3个**kwargs

def stu(name,age,*args,**kwargs):
    print(name,age,args,kwargs)

stu('肖亚飞',22)  # 肖亚飞 22 () {}
# 让我们看看args和kwargs的差别在哪?
stu('肖爸爸',23,'python','linux')  # 肖爸爸 23 ('python', 'linux') {}
stu('肖爸爸',23,'python','linux',addr = 'Henan',music = '蝴蝶')  # 肖爸爸 23 ('python', 'linux') {'addr': 'Henan', 'music': '蝴蝶'}

总结:

   1.*args必须放在**kwargs之前
   2.*args 没有key值,**kwargs有key值
   3.使用*args和**kwargs可以非常方便的定义函数,同时可以加强扩展性,以便日后的代码维护 

 

global关键字

动用global关键字:则会报告python编译器,这一个变量是全局变量而不是全局变量,那样在函数体内修改换量会潜移默化全局了

name = "bb"


def print_name():
    global name
    name = "aa"
    print(name)

print_name()
print(name)

# 打印的结果:
# aa
# aa

  

返回值

函数外部的代码想要获取函数的试行结果,就足以在函数里选择return语句把结果再次来到

def student(name,age,course='PYTHON',country='CN'):  # 设置了course和country两个默认参数
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

    if age > 20:  # 判断如果age大于20
        return False  # 返回False
    else:
        return True

result = student('张三',22)  # 函数外部的代码想要获取函数的执行结果,就需要使用一个变量来进行接受
if result:  # 如果result = True
    print('恭喜注册成功!')
else:  # 如果result = Flase
    print('年纪太大!')

看一下运营结果:

-----注册学生信息-----
姓名: 张三
年龄: 22
国家: CN
课程: PYTHON
年纪太大!   

注意

  • 函数在执行进度中,只要碰着return语句,就能甘休实践并再次来到结果,so也能够清楚为return语句代表着函数的扫尾
  • 假如未在函数中钦赐return,那么这么些函数的重临值为None

参数分类

从大的角度去看,函数的参数分两种:形参(变量名),实参(值)

详细的区分函数的参数分为四种:

  1. 岗位参数                #行业内部调用:实加入形参地方1一对应
  2. 首要字参数          #第2字调用:地方无需固定
  3. 暗中同意参数
  4. 可变长参数(*args,**kwargs)
  5. 命名重要字参数

职位参数

def foo(x,y,z):#位置形参:必须被传值的参数
    print(x,y,z)

foo(1,2,3) #位置实参数:与形参一一对应

器重字参数

def foo(x,y,z):
    print(x,y,z)

foo(z=3,x=1,y=2)      #正确 实参通过key=value的形式给形参传值
foo(1,z=3,y=2)        #正确 位置参数与关键字参数混用
foo(x=1,2,z=3)        #错误 关键字实参必须在位置实参后面
foo(1,x=1,y=2,z=3)    #错误 不能重复对一个形参数传值

注意:

  1. 重中之重字实参必须在职务实参前面
  2. 不可能重新对二个形参数传值

暗中同意参数

def register(name,age,sex='male'): #形参:默认参数
    print(name,age,sex)

register('asb',age=40)
register('a1sb',39)
register('a2sb',30)
register('a3sb',29)

注意:

  1. 暗中同意参数必须跟在非暗许参数后

    def register(sex=’male’,name,age): #在概念阶段就能报错

     print(name,age,sex) 
    
  2. 私下认可参数在概念阶段就曾经赋值了,而且只在概念阶段赋值一遍

  3. 暗许参数的值一般定义成不可变类型

非固定参数

若你的函数在概念时不明显用户想传入多少个参数,就可以使用非固定参数

第一种: *args

def foo(x,y,*args): #*会把溢出的按位置定义的实参都接收,以元组的形式赋值给args
    print(x,y)
    print(args)

第二种: **kwargs

def stu_register(name,age,*args,**kwargs): # **会把溢出的按关键字定义的实参都接收,以字典的形式赋值给kwargs
    print(name,age,args,kwargs)

stu_register("Alex",22)
#输出
#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空

stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

命名首要字参数

def foo(name,age,*,sex='male',height):  #*后定义的参数为命名关键字参数,这类参数,必须被传值,而且必须以关键字实参的形式去传值
    print(name,age)
    print(sex)
    print(height)
foo('egon',17,height='185')

知识点1:

def foo(name,age=10,*args,sex='male',height,**kwargs):
    print(name)
    print(age)
    print(args)
    print(sex)
    print(height)
    print(kwargs)

foo('alex',1,2,3,4,5,sex='female',height='150',a=1,b=2,c=3)
# 输出
alex
1       ----->age被位置参数填充
(2, 3, 4, 5)
female
150
{'a': 1, 'c': 3, 'b': 2}

知识点2:

def foo(*args):
    print(args)
foo(*(1,2,3,4)) = foo(1,2,3,4)    # 传入元组,1,2,3,4 <=====>*(1,2,3,4) 此时,*=* args=(1,2,3,4)
# 输出
(1, 2, 3, 4)
foo(*['A','B','C','D']) = foo('A','B','C','D')  # 传入列表, 此时,['A','B','C','D']相当于('A','B','C','D')
# 输出
('A', 'B', 'C', 'D')
foo(['A','B','C','D'])     #  传入列表,此时,列表作为输出的元组中的一个元素
# 输出
(['A', 'B', 'C', 'D'],)

知识点3:

def foo(**kwargs):
    print(kwargs)

foo(**{'y': 2, 'x': 1,'a':1}) #foo(a=1,y=2,x=1)   #实参传入字典,此时,{'y': 2, 'x': 1,'a':1}相当于a=1,y=2,x=1

知识点4: 接收猖狂个实参

def wrapper(*args,**kwargs):
    print(args)
    print(kwargs)

wrapper(1,2,3,a=1,b=2)

知识点5:

def foo(x,y,z):
    print('from foo',x,y,z)
def wrapper(*args,**kwargs):
    # print(args)      #args=(1,)
    # print(kwargs)     #kwargs={'y':3,'z':2}
    foo(*args,**kwargs)  #foo(*(1,),**{'y':3,'z':2}) #foo(1,z=2,y=3)

wrapper(1,z=2,y=3)
# 输出
from foo 1 3 2

  

nonlocal关键字

nonlocal关键字在python3中新辈出的最首要字,成效:用来在函数或其他作用域中使用外层(非全局)变量

nonlocal  适用于在1部分函数 中 的片段函数, 把最内层的1部分
变量设置成外层局地可用,但是还不是全局的。

注:nonlocal必要求绑定局部变量

def fun1():
    num = 1

    def fun2():
        nonlocal num    # 此处不能使用global,只能使用nonlocal
        num += 1
        return num
    return fun2

aa = fun1()

print(aa())

  

局部变量和全局变量

name = 'xiaoyafei'
def change_name(name):  # 定义一个函数,传递Name参数
    print('修改前:',name)
    name = '肖亚飞'
    print('修改后:',name)

change_name(name)
print('在外面看修改过了吗?',name)

输出结果为:

修改前: xiaoyafei  # 没修改之前的
修改后: 肖亚飞  # 在函数里修改过的
在外面看修改过了吗? xiaoyafei  

不用传name参数,在函数里面恐怕得以调用外面包车型客车变量

name = "xiaoyafei"
def change_name():
    name = '肖亚飞'
    print("修改后:",name)
change_name()
print("在外面看:",name)

运作结果为:

修改后: 肖亚飞
在外面看: xiaoyafei

那正是说,为何小编明明修改过了,为什么在外场还是没修改呢?让大家看看name变量的空间地址:

name = "xiaoyafei"
def change_name():
    name = '肖亚飞'
    print("函数内,id:",id(name))
change_name()
print("函数外,id:",id(name))

结果如下:

函数内,id: 1388194004688
函数外,id: 1388193784688

假定不加大你的眸子还确实看不清楚呢,内部存款和储蓄器空间地址不相同,所以七个name是尚未涉嫌的,那么为啥三个函数里能定义三个以致更加多1致的变量呢?

  • 在函数中定义的变量称为全局变量,在程序的一开头定义的变量称为全局变量
  • 全局变量的效率域是总体程序,局地变量的功能是概念该变量的函数
  • 当全局变量和有个别变量一样时,在概念局地变量的函数内,局地变量起效果;在其他地方全局变量起成效

肆. 局地变量与全局变量

实例:

name = "ShuKe"
def change_name(name):
    print("before change:", name)
    name = "fengfeng"
    print("after change", name)

change_name(name)
print("在外面看看name改了么?", name)

输出

before change: ShuKe
after change fengfeng
在外面看看name改了么? ShuKe

总结:

  • 在子程序中定义的变量称为局地变量,在先后的1上马定义的变量称为全局变量。
  • 全局变量功能域是总体程序,局部变量功用域是概念该变量的子程序。

当全局变量与一些变量同名时:

  • 在概念局地变量的子程序内,局地变量起效果;在另各地点全局变量起功能。

 

六、无名函数

lamba函数也叫无名函数,即函数未有实际的称呼

lambda语句中,冒号前是参数,能够有多个,用逗号隔断,冒号左侧的重回值

def calc(x):
    return x + 1

# 用lambda进行改写如下:
calc2 = lambda x: x + 1
# 进行调用
print(calc2(10))

  

作用域

功用域,程序设计概念,常常来讲,壹段代码中所用到的名字并不总是实惠/可用的,而限制那些名字的可用性的代码范围正是那些名字的效应与.

 伍. 前向引用之’函数即变量’

def action():
    print 'in the action'
    logger()
action()
报错NameError: global name 'logger' is not defined

def logger():
    print 'in the logger'
def action():
    print 'in the action'
    logger()

action()

def action():
    print 'in the action'
    logger()
def logger():
    print 'in the logger'

action()

  

7、初识高阶函数

怎么在函数里修改全局变量

name = '肖亚飞'

def change_name():
    global name  # global的作用就是在函数里声明全局变量name,意味着最上面的name = '肖亚飞'即使不写,程序最后面也可以print name
    name = 'xiaoyafei'
    print('函数里修改:',name)

change_name()  # 调用函数
print('函数外:',name )

运作结果如下:

函数里修改: xiaoyafei
函数外: xiaoyafei

 6. 嵌套函数和功用域

看上边的题指标意味是,函数还可以套函数?当然能够…

name = "Alex"

def change_name():
    name = "Alex2"

    def change_name2():
        name = "Alex3"
        print("第3层打印",name)

    change_name2() #调用内层函数
    print("第2层打印",name)


change_name()
print("最外层打印",name)

#输出
第3层打印 Alex3
第2层打印 Alex2
最外层打印 Alex

效能域在概念函数时就早已固定住了,不会随着调用地点的转移而改变

# 例一:
name='alex'

def foo():
    name='lhf'
    def bar():
        print(name)
    return bar

func=foo()
func()


# 例二:
name='alex'

def foo():
    name='lhf'
    def bar():
        name='wupeiqi'
        def tt():
            print(name)
        return tt
    return bar

func=foo()
func()

输出

lhf
wupeiqi

 

map函数

map处理序列中的每个元素,得到一个结果(迭代器),该迭代器元素个数与位置不变

list1 = [1, 2, 3, 4, 5]
list2 = map(lambda x: x+1, list1)  # map的第一个参数为函数,后面的参数为可迭代对象
print(list(list2))

# 结果:[2, 3, 4, 5, 6]

  

嵌套函数

name = 'xiaoyafei'
def change_name():
    name = 'xiaoyafei2'

    def change_name2():
        name = 'xiaoyafei3'  # 如果在当前函数拥有name变量,则使用函数内的name变量,如果没有,则会去上一级去找name,一直找到全局变量
        print('第3层打印:',name)  # 第3层打印: xiaoyafei3

    change_name2()
    print('第2层的音:',name)  # 第2层的音: xiaoyafei2

change_name()
print('第一层打印:',name)  # 第一层打印: xiaoyafei

七. 递归

在函数内部,能够调用别的函数。假如在调用二个函数的经过中央直机关接或直接调用本身本人

def calc(n):
    print(n)
    if int(n/2) ==0:
        return n
    return calc(int(n/2))

calc(10)

输出:
10
5
2
1

威尼斯人线上娱乐 19威尼斯人线上娱乐 20

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import time

person_list=['alex','wupeiqi','yuanhao','linhaifeng']
def ask_way(person_list):
    print('-'*60)
    if len(person_list) == 0:
        return '没人知道'
    person=person_list.pop(0)
    if person == 'linhaifeng':
        return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' %person
    print('hi 美男[%s],敢问路在何方' %person)
    print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' %(person,person_list))
    time.sleep(3)
    res=ask_way(person_list)
    # print('%s问的结果是: %res' %(person,res))
    return res



res=ask_way(person_list)

print(res)

递归问路

递归问路

递归天性:

  1. 总得有1个醒目标结束条件

  2. 历次进入更加深1层递归时,难点规模相比较上次递归都应具有减少

3.
递归功用不高,递归档次过多会招致栈溢出(在微型Computer中,函数调用是透过栈(stack)这种数据结构达成的,每当进入二个函数调用,栈就能够加壹层栈帧,每当函数重回,栈就能减一层栈帧。由于栈的大小不是最为的,所以,递归调用的次数过多,会促成栈溢出)

仓库扫除文盲:
http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html 

尾递归优化:

威尼斯人线上娱乐 21威尼斯人线上娱乐 22

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]


def binary_search(dataset,find_num):
    print(dataset)

    if len(dataset) >1:
        mid = int(len(dataset)/2)
        if dataset[mid] == find_num:  #find it
            print("找到数字",dataset[mid])
        elif dataset[mid] > find_num :# 找的数在mid左面
            print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:# 找的数在mid右面
            print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
            return binary_search(dataset[mid+1:],find_num)
    else:
        if dataset[0] == find_num:  #find it
            print("找到数字啦",dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)


binary_search(data,66)

二分查找

二分查找

递归默许的递归档次数是:一千

import sys
print(sys.getrecursionlimit())      # 默认递归调用层数
sys.setrecursionlimit(100000)       # 设置递归最大的调用层数
print(sys.getrecursionlimit())
'''
1000
100000
'''

 

filter函数

filter(过滤):遍历序列中的每个元素,判断每个元素得到布尔值,如果是True则留下来,组成新的迭代器

list1 = ["1111aaa", "2222aaa", "3333aaa", "4444", "5555", "6666"]
list2 = filter(lambda x: x.endswith("aaa"), list1)  # 有过滤的作用
print(list(list2))

# 运行结果:['1111aaa', '2222aaa', '3333aaa']

  

无名氏函数

无名氏函数正是无需出示的钦赐函数名

无名氏函数的扬言

res1 = lambda x,y:x+y  #声明一个匿名函数,有x和y两个参数,操作为x+y
print(res1)  # <function <lambda> at 0x0000021D32590D08>

常规函数和无名函数:

# 常规函数
def cacl(x,y):
    return x**y

res = cacl(2,3)  # 如果想要使用函数的返回值,就需要定义一个变量来接收
print(res)  # 8

# 匿名函数
res = lambda x,y:x**y
print(res(2,3))  # 8

佚名函数的优点:

  • 选拔python写一些本子时,使用lambda能够省去自定义函数的长河,让代码特别简洁
  • 对于部分虚幻的,不会被别的地点再重复使用的函数,一时候函数起个名字也是个难题,使用lambda不用思量那些主题材料
  • 动用lambda在好哪天候让代码更易于通晓

捌. 无名函数

  1. 佚名函数就是无需显式的钦赐函数,程序运维结束登时被灭绝

语法:

lambda x:y
x为接收值,y为返回值
lambda表达式中不支持if...else...简单的判断

一般将轻易的函数用lambda表明式方式取代,如下:

#这段代码
def calc(n):
    return n**n
print(calc(10))

#换成匿名函数
calc = lambda n:n**n
print(calc(10))

您或许会说,用上那一个东西没感觉有毛方便呀,
。。。。呵呵,借使是那样用,确实没毛线立异,然则无名函数首如若和别的函数搭配使用的吧,如下:

威尼斯人线上娱乐 23威尼斯人线上娱乐 24

f=lambda x,y:x+y
print(f)
print(f(1,2))

'''
#结果
<function <lambda> at 0x0000000000A4E0D0>
3
'''

示例1

  1. 无名氏函数与max,min,zip,sorted的利用方式如下:
    注:
    max,min,zip,sorted内置函数内部依次迭代传入的靶子

    # 示例所使用的剧情如下所示

    salaries={
    ‘egon’:3000,
    ‘alex’:100000000,
    ‘wupeiqi’:10000,
    ‘yuanhao’:2000
    }

威尼斯人线上娱乐 25威尼斯人线上娱乐 26

print(max(salaries))            # 默认以字典的key作为元素对比
res=zip(salaries.values(),salaries.keys())      # 使用zip函数进行转换,以values作为key,以key作为values进行max求最大值
print(res)          # 一个zip对象
# print(list(res))
print(max(res))     # 最大值根据key来判断,此时res的可以为salarise的values值

'''
yuanhao     # 错误值
<zip object at 0x0000000000A45348>
(100000000, 'alex')
'''

zip和lambda函数

威尼斯人线上娱乐 27威尼斯人线上娱乐 28

def func(k):
    return salaries[k]
print(max(salaries))        # 默认以key进行对比,输出错误
print(max(salaries,key=func))       # 以key进行对比,同时将key传给函数func,形如:func(key)-->salaries[k],此时salaries[k]对应的是字典中的values,再次进行max求最大值后,获取最大值
print(max(salaries,key=lambda k:salaries[k]))
print(min(salaries,key=lambda k:salaries[k]))
print(sorted(salaries))     # 默认的排序结果是从小到到,默认以key对比
print(sorted(salaries,key=lambda x:salaries[x])) # 根据values作为对比,从小到大排列,输出key
print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) # 设置reverse=True,从大到小

'''
yuanhao         # 错误值
alex
alex
yuanhao
['alex', 'egon', 'wupeiqi', 'yuanhao']
['yuanhao', 'egon', 'wupeiqi', 'alex']
['alex', 'wupeiqi', 'egon', 'yuanhao']
'''

max|min|sorted与lambda函数

  1. 无名函数与map,reduce,filter的利用情势如下:
  • map()函数 map()是 Python 内置的高阶函数,它接受二个函数 f 和一个list,并通过把函数 f 依次功用在 list 的各样成分上,获得叁个新的 list
    并回到。

注:map()函数不改换原有的
list,而是回到二个新的 list。

威尼斯人线上娱乐 29威尼斯人线上娱乐 30

map()函数
map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回。

例如,对于list [1, 2, 3, 4, 5, 6, 7, 8, 9]

如果希望把list的每个元素都作平方,就可以用map()函数:



因此,我们只需要传入函数f(x)=x*x,就可以利用map()函数完成这个计算:

def f(x):
    return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
输出结果:

[1, 4, 9, 10, 25, 36, 49, 64, 81]
注意:map()函数不改变原有的 list,而是返回一个新的 list。

利用map()函数,可以把一个 list 转换为另一个 list,只需要传入转换函数。

由于list包含的元素可以是任何类型,因此,map() 不仅仅可以处理只包含数值的 list,事实上它可以处理包含任意类型的 list,只要传入的函数f可以处理这种数据类型。

任务
假设用户输入的英文名字不规范,没有按照首字母大写,后续字母小写的规则,请利用map()函数,把一个list(包含若干不规范的英文名字)变成一个包含规范英文名字的list:

输入:['adam', 'LISA', 'barT']
输出:['Adam', 'Lisa', 'Bart']


def format_name(s):
    s1=s[0:1].upper()+s[1:].lower();
    return s1;

print map(format_name, ['adam', 'LISA', 'barT'])

map函数示例

威尼斯人线上娱乐 31威尼斯人线上娱乐 32

li=['alex','egon','shuke']

res=map(lambda x:x+' Love me',li)     # 它接收一个函数(lambda)和一个 list,并通过把函数 lambda(可以是任何函数对象,\只要能够处理list中的数据) 依次作用在 list 的每个元素上,得到一个新的 list 并返回
print(res)
print(list(res))

'''
<map object at 0x0000000000B64588>
['alex Love me', 'egon Love me', 'shuke Love me']
'''

map与lambda

威尼斯人线上娱乐 33威尼斯人线上娱乐 34

nums=(2,4,9,10)
res1=map(lambda x:x**2,nums)
print(list(res1))

'''
[4, 16, 81, 100]
'''

示例2

reduce()函数也是Python内置的二个高阶函数。

reduce()函数接收的参数和 map()类似,3个函数 f,3个list,但作为和
map()分化,reduce()传入的函数 f
必须接受多少个参数,reduce()对list的每种成分反复调用函数f,并再次回到最后结果值。

威尼斯人线上娱乐 35威尼斯人线上娱乐 36

# python3中reduce函数需要导入
from functools import reduce

li=[1,2,3,4,5]
print(reduce(lambda x,y:x+y,li))  # 默认的初始值为列表中的第一个元素,即x=li[0],之后会遍历li列表中的每一个元素进行求和操作,从li[1]开始
print(reduce(lambda x,y:x+y,li,100))  # 此处10为第一次传入的初始值,即x = 100,之后会遍历li列表中的每一个值进行求和操作,从li[0]开始

'''
15
115
'''

reduce和lambda

filter()函数也是Python内置的叁个高阶函数。

filter()函数包涵三个参数,分别是function和list。该函数基于function参数重回的结果是还是不是为真来过滤list参数中的项.

威尼斯人线上娱乐 37威尼斯人线上娱乐 38

# 示例1
li=['alex-old','wupeiqi-old','yuanhao','egon']
res=filter(lambda x:x.endswith('old'),li)       # x.endswith('old')值为真,则储存元素,list参数中所有为假的元素都将被删除。
print(res)
print(list(res))
'''
<filter object at 0x00000000006D4908>
['alex-old', 'wupeiqi-old']
'''
#示例2
nums=[0,1,2,3,4,5,6,7]
res = filter(None,nums)         # 如果filter参数值为None,就使用identity()函数,list参数中所有为假的元素都将被删除。
print(list(res))
'''
[1, 2, 3, 4, 5, 6, 7]
'''

fliter和lambda

 

reduce函数

reduce 处理一个序列,把序列进行合并操作

from functools import reduce

list1 = [1, 2, 3, 4, 5]
aa = reduce(lambda x, y: x+y, list1)  # 前一个参数的函数必须是两个参数
print(aa)

# 运行结果:15

  

佚名函数的其它用法

data  = list(range(10))
print(data)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 问题:用两种方法计算这些数的平方

# 常规操作
for index,i in enumerate(data):
    data[i] = i*i
print(data)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 装逼操作
res = list(map(lambda x:x*x,data))
print(res)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

那么在章程第22中学的map()函数是啥意思?

map()会依靠提供的函数对点名种类做映射

先是个参数functrion以参数系列中的每1个成分调用function函数,重临包涵每便function函数再次来到值的新列表,能够不懂,上边就能讲,

后天不是看到map()函数,作者还真不知道python二和python三中的map()有分别,让大家比方看一下map()函数的用法:

在python2中:
>>> def cacl(x):  # 求一个数的平方
...     return x**2
...
>>> map(cacl,[1,2,3,4,5])  # 在python2中返回的是列表
[1, 4, 9, 16, 25]
>>>

在python3中:
>>> def cacl(x):
...     return x**2
...
>>> map(cacl,[1,2,3,4,5])  # python3中返回的是迭代器对象,何谓迭代器?晚点会在博客中说明
<map object at 0x0000015B373533C8>
>>> res = map(cacl,[1,2,3,4,5])
>>> next(res)  # 返回迭代器中的下一个值
1
>>> next(res)
4

map()函数在python二和python3中的差距:

  • 在python第22中学回到的是列表
  • 在python3中回到的是迭代器对象

map()是python内置的高阶函数,它接受二个函数cacl和三个list,并通过函数cacl依次功效于list的各样成分上,并且得到一个新的list并赶回,由于list包罗的成分得以是各连串型的,因而,map()不仅能够拍卖只含有数值的list,事实上它也得以管理包涵自由等级次序的list,只要传入的函数cacl能够处理这种数量类型.

九. 函数式编制程序

函数是Python内建帮衬的壹种包装,大家透过把大段代码拆成函数,通过1层一层的函数调用,就足以把复杂职务分解成轻易的职分,这种解释可以称之为面向进度的次第设计。函数正是面向过程的程序设计的骨干单元。

函数式编制程序中的函数那一个术语不是指计算机中的函数(实际上是Subroutine),而是指数学中的函数,即自变量的炫目。也便是说八个函数的值仅决定于函数参数的值,不依赖别的景况。举个例子sqrt(x)函数总括x的平方根,只要x不改变,不论什么日期调用,调用四回,值都以不改变的。

Python对函数式编制程序提供部分协助。由于Python允许接纳变量,因而,Python不是纯函数式编制程序语言。

8、内置函数

威尼斯人线上娱乐 39

学学资料参谋:

高端函数

变量能够针对函数,函数的参数能经受变量,那么1个函数就足以收起另二个函数作为参数,这种函数就被称之为高阶函数.

  • 接过1个或四个函数作为输入
  • return 再次来到别的一个函数
def func2(x,y):
    return abs,x,y
res = func2(-1,10)
print(res)  # (<built-in function abs>, -1, 10)

def cacl(x,y,f):
    return f(x)+f(y)

res = cacl(-4,10,abs)
print(res)  # 14

1. 定义

差不离说,”函数式编程”是壹种”编制程序范式”(programming
paradigm),也正是如何编写程序的方法论。

待补充……

 

10. 松手函数

威尼斯人线上娱乐 40

1、数学生运动算

  abs(), round(),pow(),divmod(),max(),min(),sum()

威尼斯人线上娱乐 41威尼斯人线上娱乐 42

'''
1、数学运算
'''
# abs(-5)  # 取绝对值,也就是5
# round(2.623423, 4)  # 四舍五入取整,也就是3.0, 4为精准到四位四舍五入
# pow(2, 3)  # 相当于2**3,如果是pow(2, 3, 5),相当于2**3 % 5
# divmod(9, 2)  # 返回除法结果和余数
# max([1, 5, 2, 9])  # 求最大值
# min([9, 2, -4, 2])  # 求最小值
# sum([2, -1, 9, 12])  # 求和

数学生运动算

二、工厂函数

  int(), float(), str(), bool(), slice(), list(), tuple(), dict(),
set(), frozenset()

威尼斯人线上娱乐 43威尼斯人线上娱乐 44

# int("5")  # 转换为整数 integer
# float(2)  # 转换为浮点数 float
# str(2.3)  # 转换为字符串 string
# bool(0)  # 转换为相应的真假值,在Python中,0相当于False在Python中,下列对象都相当于False:[], (), {}, 0, None, 0.0, ''
# slice(5, 2, -1)  # 构建下标对象 slice,切片函数
# list((1, 2, 3))  # 转换为表 list
# tuple([2, 3, 4])  # 转换为定值表 tuple
# dict(a=1, b="hello", c=[1, 2, 3])  # 构建词典 dictionary
# set()          创建集合函数
# frozenset()  创建一个不可修改的集合 如:s=frozenset({1,2}) # 定义不可变集合

工厂函数

三、类型转变

  ord(), chr(), bin(), hex(), oct(), complex()

威尼斯人线上娱乐 45威尼斯人线上娱乐 46

ord("A")  # "A"字符对应的数值
chr(65)  # 数值65对应的字符
bin(56)  # 返回一个字符串,表示56的二进制数
hex(56)  # 返回一个字符串,表示56的十六进制数
oct(56)  # 返回一个字符串,表示56的八进制数
complex(3, 9)  # 返回复数 3 + 9j

类型调换

4、体系操作

  all(), any(), sorted(), reversed()

威尼斯人线上娱乐 47威尼斯人线上娱乐 48

all([True, 1, "hello!"])        # 是否所有的元素都相当于True值
any(["", 0, False, [], None])   # 是否有任意一个元素相当于True值
reversed([1,5,3])               # 返回反序的序列,也就是[3,5,1]

队列操作

五、编写翻译实施函数

  repr(), compile(), eval(), exec()

威尼斯人线上娱乐 49威尼斯人线上娱乐 50

# repr(me)                         # 返回一个对象的字符串表示。有时可以使用这个函数来访问操作。
# compile("print('Hello')",'test.py','exec')       # 编译字符串成为code对象
# eval("1 + 1")                     # 解释字符串表达式。参数也可以是compile()返回的code对象
'''
# cmd='print("你瞅啥")'
# 
# dic="{'a':1,'b':2}"
# d=eval(dic)
# print(type(d),d['a'])
# 
# with open('user.db','w',encoding='utf-8') as f:
#     user_dic={'name':'egon','password':'123'}
#     f.write(str(user_dic))
# 
# with open('user.db','r',encoding='utf-8') as f:
#     dic=f.read()
#     print(dic,type(dic))
#     dic=eval(dic)
#     print(dic['name'])
'''
# exec("print('Hello')")            #  exec()执行字符串或complie方法编译过的字符串,没有返回值

编写翻译试行函数

陆、支持函数

  dir(), help(), id(), len(), challables()

威尼斯人线上娱乐 51威尼斯人线上娱乐 52

'''
6、帮助函数
'''
# dir()  不带参数时返回当前范围内的变量,方法和定义的类型列表,带参数时返回参数的属性,方法列表
'''
l=[]
print(dir(l)) #查看一个对象下面的属性
'''
# help()  返回对象的帮助文档
'''
print(help(l))
'''
# id()  返回对象的内存地址
'''
# x=1
# y=x
# print(id(x),id(y))
#
# print(x is y) #判断的是身份
'''
# len()  返回对象长度,参数可以是序列类型(字符串,元组或列表)或映射类型(如字典)
# challable()  判断对象是否可以被调用,能被调用的对象就是一个callables对象,比如函数和带有__call__()的实例
'''
def func():
    pass
print(callable(func))
'''

接济函数

柒、成效域查看函数

  globals(), locals(), vars()

威尼斯人线上娱乐 53威尼斯人线上娱乐 54

#globals()  返回一个描述当前全局变量的字典
#locals()  打印当前可用的局部变量的字典
#vars() #等于locals()

成效域查看函数

八、迭代器函数

  iter(), next(), enumerate(), range()#python三中为浮动三个迭代器

威尼斯人线上娱乐 55威尼斯人线上娱乐 56

'''
8、迭代器函数
'''
'''
iter(o[, sentinel])
返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。
如果没有提供第二个参数,参数o必须是一个集合对象,支持遍历功能(__iter__()方法)或支持序列功能(__getitem__()方法),
参数为整数,从零开始。如果不支持这两种功能,将处罚TypeError异常。
如果提供了第二个参数,参数o必须是一个可调用对象。在这种情况下创建一个iterator对象,每次调用iterator的next()方法来无
参数的调用o,如果返回值等于参数sentinel,触发StopIteration异常,否则将返回该值。
'''
# next()  返回一个可迭代数据结构(如列表)中的下一项
# enumerate()  # 返回一个可以枚举的对象,该对象的next()方法将返回一个元组
# x=range(10)
# enumerate([1,2,3]).__next__()
# range()  根据需要生成一个指定范围的数字,可以提供你需要的控制来迭代指定的次数

迭代器相关函数

玖、别的函数

  hash(), filter(), format(), input(), open(), print(), zip(), map(),
__import__

威尼斯人线上娱乐 57威尼斯人线上娱乐 58

# hash() 哈希值用于快递比价字典的键。
# 1. 只要校验的内容一致,那hash得到结果永远一样
# 2. 不可逆
# 3. 只要采用的哈希算法一样,那无论被校验的内容有多长,hash的到的结果长度都一样
# print(hash('asdfasdfsadf'))
# print(hash('asdfasdfsadf'))

# filter()  过滤器,构造一个序列,等价于[ item for item in iterables if function(item)],在函数中设定过滤条件,逐一循环迭代器中的元素,将返回值为True时的元素留下,形成一个filter类型数据
'''
filter(function, iterable)
参数function:返回值为True或False的函数,可以为None。
参数iterable:序列或可迭代对象。
>>> def bigerthan5(x):
...     return x > 5
>>> filter(bigerthan5, [3, 4, 5, 6, 7, 8])
[6, 7, 8]
'''

# format()  #格式化输出字符串,format(value, format_spec)实质上是调用了value的__format__(format_spec)方法
'''
"I am {0}, I like {1}!".format("wang", "moon")
"I am {}, I like {}!".format("wang", "moon")
"I am {name}, I like {msg}!".format(name = "wang", msg ="moon")
'''

# input()  #获取用户输入内容
# open()  打开文件
# print()  输出函数

# zip()  拉链函数将对象逐一配对
# s='helloo'
# l=[1,2,3,4,5]
#
# z=zip(s,l)
# print(z)
# for i in z:
#     print(i)


# import time
# m=__import__('time') #以字符串的形式导入模块
# m.sleep(3000)

'''
map(function, iterable,...)
对于参数iterable中的每个元素都应用fuction函数,并将结果作为列表返回。
如果有多个iterable参数,那么fuction函数必须接收多个参数,这些iterable中相同索引处的元素将并行的作为function函数的参数。
如果一个iterable中元素的个数比其他少,那么将用None来扩展改iterable使元素个数一致。
如果有多个iterable且function为None,map()将返回由元组组成的列表,每个元组包含所有iterable中对应索引处值。
参数iterable必须是一个序列或任何可遍历对象,函数返回的往往是一个列表(list)。

li = [1,2,3]
data = map(lambda x :x*100,li)
print(type(data))
data = list(data)
print(data)

运行结果:

<class 'map'>
[100, 200, 300]
'''

其它函数

十、面向对象使用函数

  super(), isinstance(), issubclass(), classmethod(),
staticmethod(), proerty(), delatter(), hasattr(), getattr(), setattr()

威尼斯人线上娱乐 59威尼斯人线上娱乐 60

#super()  调用父类的方法

# isinstance()  检查对象是否是类的对象,返回True或False
# issubclass()  检查一个类是否是另一个类的子类。返回True或False


# classmethod()  # 用来指定一个方法为类的方法,由类直接调用执行,只有一个cls参数,执行雷的方法时,自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法
# staticmethod
# property

# delattr()  # 删除对象的属性
# hasattr
'''
hasattr(object,name)
判断对象object是否包含名为name的特性(hasattr是通过调用getattr(object,name))是否抛出异常来实现的。
参数object:对象
参数name:特性名称
>>> hasattr(list, 'append')
True
>>> hasattr(list, 'add')
False
'''
#getattr()  获取对象的属性
#setattr()  与getattr()相对应

面向对象使用函数

1一. 放权函数实例

威尼斯人线上娱乐 61威尼斯人线上娱乐 62

字典的运算:最小值,最大值,排序
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

迭代字典,取得是key,因而比较的是key的最大和最小值
>>> max(salaries)
'yuanhao'
>>> min(salaries)
'alex'

可以取values,来比较
>>> max(salaries.values())
>>> min(salaries.values())
但通常我们都是想取出,工资最高的那个人名,即比较的是salaries的值,得到的是键
>>> max(salaries,key=lambda k:salary[k])
'alex'
>>> min(salaries,key=lambda k:salary[k])
'yuanhao'


也可以通过zip的方式实现
salaries_and_names=zip(salaries.values(),salaries.keys()) 

先比较值,值相同则比较键
>>> max(salaries_and_names)
(100000000, 'alex')

salaries_and_names是迭代器,因而只能访问一次
>>> min(salaries_and_names)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: min() arg is an empty sequence


sorted(iterable,key=None,reverse=False)

多少个放置函数实例

置于参数详解: https://docs.python.org/3/library/functions.html?highlight=built\#ascii 

 


相关文章

发表评论

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

网站地图xml地图