xml地图|网站地图|网站标签 [设为首页] [加入收藏]

智能家电

当前位置:美高梅游戏网站 > 智能家电 > 简学Python第三章__函数式编程、递归、内置函数,

简学Python第三章__函数式编程、递归、内置函数,

来源:http://www.gd-chuangmei.com 作者:美高梅游戏网站 时间:2019-09-02 13:41

简学Python第一章__进入PY的世界,简学python

简学Python第三章__函数式编程、递归、内置函数,简学python

Python第一章__进入Python的世界

Python第三章__函数式编程、递归、闭包

 

欢迎加入Linux_Python学习群

 图片 1 群号:478616847

 

 

目录:

  • 函数式编程

  • **传参与返回值**

  • 递归

  • 匿名函数**
    **

  • 闭包

  • 高阶函数

  • 内置函数

 

在第三章,我们引入新的概念函数,在以往的代码编写中我们都是用的过程式编程,函数式编程的特点将过程式编程变成易于管理调用的小模块,

让重复的代码可以反复的调用,大大减少代码量,懒惰即美德

 

 

欢迎加入Linux_Python学习群

 图片 2 群号:478616847

 转载文章请注明文章来源出处

 

 

一、函数式编程

  创建函数

  一个函数式由关键字 def ,与函数名与括号冒号,和括号中的参数组成,当想要执行函数的时候只需要写上函数名加括号即可

  格式:  def  function (parameter)  下面就创建一个函数

图片 3

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 #创建函数
5 def print_str():
6     print("Hello World")
7 
8 #调用函数
9 print_str()

第一个函数

  变量的作用域

  我们看一个例子,在下面代码中我们先把变量 a=“haha” 然后在函数中把 a=“heihei” 最后执行这个函数,并输出变量a的结果

  我们发现为什么a不等于 "heihei",而是我们之前赋值的 “haha” 这个现象我们马上揭秘

图片 4

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 
 5 a = "haha"
 6 
 7 #创建函数
 8 def print_str():
 9     a = "heihei"
10     print("Hello World")
11 
12 #调用函数
13 print_str()
14 print("我是变量a:",a)

变量的作用域例一

  全局变量与局部变量

  很明显变量的作用域就是变量在哪一个范围内生效,如果出了这个范围则无法使用

  全局变量:通常全局变量存活在脚本运行结束,并且所有的函数都可以访问它

  局部变量:只能局部变量所在的函数内部调用,并且除非把局部变量声明成全局变量否则,其他函数均无法调用,并且局部变量

  当所在的函数执行完成后就不存在了

图片 5

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 
 5 a = "haha"
 6 
 7 #创建函数
 8 def print_str():
 9     a = "heihei"
10     print("我是局部变量a:",a)
11 
12 
13 #调用函数
14 print_str()
15 print("我是全局变量a:",a)

全局变量与局部变量

  global

  global就是可以把局部变量变成全局变量的,如果被声明的局部变量名与全局变量名一样的话,那么局部变量会覆盖全局变量,切

  使用global声明变量需要在变量之前声明否则python会告诉你,你需要在 a 前面声明

  报错提示:SyntaxWarning: name 'a' is assigned to before global declaration global a

图片 6

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 a = "haha"
 5 
 6 #创建函数
 7 def print_str():
 8     global a
 9     a = "heihei"
10     print("我是局部变量a:",a)
11 
12 #调用函数
13 print_str()
14 print("我是全局变量a:",a)

gloable

 

目录:

  • ### 什么是Python

  • ### Python开发环境安装

  • ### 第一个程序 HelloWord!

  • ### 初识数据类型

  • ### 初识条件语句

  • ### Pass continue break

    ###  

二、传参与返回值

**  传参**

  函数用起来比较简单也容易理解,但是参数的变化就比较多了,在函数括号内就是参数,参数可以接收字符串,数字,也可以接收字典和列表

  并且在调用的时候,我们还可以指定给哪个参数赋什么值

图片 7

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 #创建函数
 5 def print_str(Name,Age,Aender):
 6     print('''
 7     Name:%s
 8     Age:%s
 9     Aender:%s
10     '''%(Name,Age,Aender))
11 
12 #用户输入
13 in_name = input("请输入你的名字:")
14 in_age = input("请输入你的年龄:")
15 in_aender = input("请输入你的性别:")
16 
17 #固定位置传参
18 print_str(in_name,in_age,in_aender)
19 print("----------------------------------")
20 
21 #不固定位置传参
22 print_str(in_name,Aender=in_aender,Age=in_age)

传参

  当我们想要传入列表或者字典时需要怎么办?

图片 8

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 def print_str(lists):
 5     if type(lists) == list:
 6         print('''
 7         Name:%s
 8         Age:%s
 9         Aender:%s
10         '''%(lists[0],lists[1],lists[2]))
11     else:
12         print('''
13         Name:%s
14         Age:%s
15         Aender:%s
16         '''%(lists["name"],lists["age"],lists["aenber"]))
17 
18 #传入列表
19 userlist = ["Ben","22","Man"]
20 print_str(userlist)
21 
22 print("----------------------------------")
23 #传入字典
24 userdict = {"name":"Ben","age":"022","aender":"Man"}
25 print_str(userlist)

传入字典或列表

  默认参数

  在函数中还可以设置默认参数,默认参数的意思是这个参数你可以传值也可以不传值,当不传值的时候这个参数就等于默认值

图片 9

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 def print_str(lists,Country="China"):
 5     if type(lists) == list:
 6         print('''
 7         Name:%s
 8         Age:%s
 9         Aender:%s
10         country:%s
11         '''%(lists[0],lists[1],lists[2],Country))
12     else:
13         print('''
14         Name:%s
15         Age:%s
16         Aender:%s
17         country:%s
18         '''%(lists["name"],lists["age"],lists["aenber"],Country))
19 
20 #传入列表
21 userlist = ["Ben","22","Man"]
22 print_str(userlist)
23 
24 print("----------------------------------")
25 #传入字典
26 userdict = {"name":"Ben","age":"022","aender":"Man"}
27 print_str(userlist,"America")

默认参数

  非固定参数

  非固定参数的意义在于可以接收任意个值,在你的函数不确定用户想传入多少个值的时候使用,当然在调用有只有非固定参数的函数的时候我们可以不传参数。

  非固定参数分一个*和两个*,*args会把传入的参数变成元祖,**kwargs把传入的参数变成字典,当然*ages可以是别的名称,但是在规范中最好使用*args,和**kwargs

图片 10

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 def print_str(*args,**kwargs):
 5     print("我是*",args)
 6     print("我是**",kwargs)
 7 
 8 #传入列表
 9 userlist = ["Ben","22","Man"]
10 print_str(userlist,"America")
11 print("----------------------------------")
12 #传入字典
13 print_str(A = "1",B = "2")

非固定传参

  既然形参可以带*和**,那么实参也是可以带*和**,那么*就是配合列表使用的,**就是配合字典的!

图片 11

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 def print_str(*args,**kwargs):
 5     print("我是*",args)
 6     print("我是**",kwargs)
 7 
 8 #传入列表
 9 userlist = ["Ben","22","Man"]
10 print_str(*userlist)
11 
12 print("----------------分隔符----------------")
13 
14 #传入字典
15 userdict = {"name":"Ben","age":"022","gender":"Man"}
16 print_str(**userdict)
17 
18 解参

解参

  实参带*就会把列表分解成   "Ben","22","Man" 一个一个单独的元素传入函数,而**会把字典分解成name="Ben",age="022",gender="Man"

  这种键值对传入函数。

  

  形参与实参

  形参:

  变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只在函数内部有效。函数调用结束返回主调用

  函数后则不能再使用该形参变量

  实参:

  可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。因此

  应预先用赋值,输入等办法使参数获得确定值

  

  注!当普通参数和默认参数和非固定参数结合使用的时候,要遵循一个顺序,普通参数在默认参数前面,默认参数在非固定参数前面

  

  返回值

  在正常使用函数的时候,函数是可以把函数内部处理的结果返回给函数调用者的,在没有返回值得函数中会保留None传给函数调用者,返回值可以返回序列等

  在函数执行的时候遇到return函数会停止执行,并返回结果

图片 12

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 #创建函数
 5 def print_str(Age):
 6     if int(Age) <= 30:
 7         return "你才%s啊!真年轻"%(Age)
 8     else:
 9         return "你都%s啦!老家伙"%(Age)
10 
11 in_age = input("请输入你的年龄:")
12 word = print_str(in_age)
13 print(word)

return

  

  嵌套函数

  在函数内部也可以写函数,这样就是外层函数套着内侧函数,这种形式称之为嵌套函数,同理因为作用域的关系嵌套函数只能内部调用

  return unction_2(stra)+"我是第二层n" 就等于先 c = unction_2(stra) 然后 return c+"我是第二层n"

图片 13

1 def unction(stra):
2     def unction_2(stra_2):
3         return stra_2+"我是第三层n"
4     return unction_2(stra)+"我是第二层n"
5 
6 r_str = unction("")
7 print(r_str+"我是第一层")

嵌套函数

 

一、什么是Python

  刚接触Python的我们第一个问题肯定就是到底什么是Python?Python能做什么?为什么Python现在这么火?

  来大家看图片 14这货就是Python,在看的观众肯定要骂了,你就给我看着个?哈哈,没错这个就是Python的代言人。

 

  其实Python有很多优秀的特点:

  (1)Python 是一门简明并强大的面向对象编程的语言、

  (2)简单易学适合快速开发各种程序

  (3)Python在WEB开发,软件开发,科学运算,大数据分析,自动化运维等方面得到了广泛的应用

  Python的创始人为 吉多·范罗苏姆 1989年的圣诞节期间,他为了打发时间,决心开发一个新的脚本解释程序作为ABC语言的一种集成,

  这门语言结合了JAVA和Shell的优势特性,并且属于解释型语言的它在可移植性、可扩展性、可嵌入性都有独特的优势。那么有人要问什么是解释型语言?

 

  解释型语言与编译型语言的区别

  编译型

  优点:编译器一般会有预编译的过程对代码进行优化,因为编译只做一次,运行时不需要编译,所以编译型语言的程序执行效率高,可以脱离语言环境独立运行。

  缺点:编译之后如果需要修改就需要整个模块重新编译,编译的时候根据对应的运行环境生成机器码,不同的操作系统之间移植就好有问题,需要根据运行的操作

  系统环境编译不同的可执行文件。

  解释型:

  优点:有良好的平台兼容性,在任何环境中都可以运行,前提是安装了解释器(虚拟机)。灵活,修改代码直接修改即可,无需再次编译,快速部署无需停机维护

  缺点:性能方面不如编译型语言

 

  Python的种类

  • Cpython
    Python的官方版本,使用C语言实现,使用最为广泛,CPython实现会将源文件(py文件)转换成字节码文件(pyc文件),然后运行在Python虚拟机上。
  • Jyhton
    Python的Java实现,Jython会将Python代码动态编译成Java字节码,然后在JVM上运行。
  • IronPython
    Python的C#实现,IronPython将Python代码编译成C#字节码,然后在CLR上运行。(与Jython类似)
  • PyPy(特殊)
    Python实现的Python,将Python的字节码字节码再编译成机器码。

  Python在热门语言中的排名:

  下面的图片就是今年Python跟各大热门语言对比的排名,我们的Python现在处于第四位,并且同JAVA/C/C++/一起成为程序员最热爱的四大语言之一。

  总而言之用一句话总结Python,就是学的快,用的多。

  

 

三、递归

  前面已经介绍了函数相关的知识,在函数中,函数可以调用其他的函数,并且函数还可以调用自身,利用这种特性我们可以完成一些特定的

  操作,这种函数调用自身的形式就是递归

  def recursion() :
    return recursion()

  在递归中不能像上面两行一样一直调用自身,这样一会程序就会崩溃,因为它永远的在调用就跟while死循环一样出不去,所以递归也需要进

  判断给它出口

  例子:阶乘

  什么是阶乘,阶乘就是给一个自然数N,然后计算N的阶乘那么 N = 1x2x3x4....N ,这个就是阶乘,我们可以把它到过来看,

  N = N x (n-1) x (n-2) x (n-3) ...... 1 一直乘到括号中的值等于1,既然知道了阶乘是什么,那么我们来写一个程序实现它

图片 15

1 def factorial(n):
2     for i in range(1,n):
3         n *= i
4     return n
5 c = factorial(4)
6 print(c)

阶乘非递归版本

  剖析:上面的例子首先把n=4传入进去,然后通过 for i in range(1,4)让i分别等于1,2,3,然后进行 n*=i,我们可以看出这个for循环是循环3次的

  第一次(n = n*i) n = 4*1 ,此时n还是等于4

  第二次(n = 4*i)  n = 4*2 此时n = 8 

  第三次(n = 8*i)  n = 8*3 此时n等于24

  此时for循环了3次所以结束了,通过return把n的结果返回,所以最终结果算出 4的阶乘等于24

  递归版本

  下面看递归版本的阶乘

图片 16

1 def factorial(n) :
2     if n == 1:
3         return 1
4     else:
5         return n * factorial(n-1)
6 c = factorial(4)
7 print(c)

阶乘递归版本

  剖析:

  首先c = factorial(4)开始执行函数,然后进行第一次判断 n == 1,显然第一层n不等于1,然后碰到return n * factorial(n-1),碰到return本来是要返回的,但是 factorial(n-1)

  有调用了factiorial这个函数,因此进入了第二层

  第二层因为上一层传入的参数是n-1,所以第二层的n是等于3的,然后判断,这一层的n也不等于1,然后又进入第三层

  第三层n等于3,然后判断这一层的n还不等于1,然后又进入第四层

  

  到第四层的时候这时的 n就等于1,所以触发了 return 1 不再调用函数了,所以就开始返回

  返回第三层 return n * factorial(n-1) , 此时factorial(n-1) 就等于第四层return上去的1,所以第三层返回时就等于return n * 1(return 2 * 1),并且第三层n是等于2的

  返回第二层factorial(n-1)就等于第三层return上去的2,并且第二层n是等于3的,return 3 * 2

  返回第一层factorial(n-1)就等于第二层return上去的6,并且第一层n是等于4的,return 4 * 6

  到此为止递归执行完毕,c就等于 4 * 6 c=24

   

   

二、Python开发环境安装

  下面我们开始安装我们的Python环境,首先我们去Python官网下载安装包,官方下载地址 选择对应的版本下载即可,安装非常傻瓜式,

  下一步下一步即可,Linux自带Python2.6,我们可以使用yum 和apt进行安装其它版本。

  (1)配置windows 命令行运行python2.7,和3.5环境

  右键计算机-选择管理-选择高级系统设置-选择高级-选择环境变量-选择系统变量中的Path-选择编辑,如下图添加python3.5和2.7的安装路径即可,记住分隔符是分号“;”

  

  进入到最后添加版本的安装目录中复制python.exe,粘贴,并更改名称3.5改成python3.exe,2.7改成python2.exe,记住更改的是在Path变量中添加到最后Pthon版本的执行文件

  

  结果

  

 

四、匿名函数

  匿名函数也叫lambda函数,函数没有具体的名称。语法:function name=  lambda  args(多个参数用逗号隔开): Expression(表达式,表达式的结果就是返回值)

  先来看一个最简单例子:

图片 17

 1 #普通函数
 2 def func(arg1,arg2):
 3     return arg1-arg2
 4 
 5 #lambda函数
 6 func_2 = lambda arg1,arg2: arg1-arg2
 7 
 8 #传参执行
 9 print(func(5,4))
10 print(func_2(5,4))

匿名函数

  有认识,这个匿名函数和普通函数没有什么区别么,其实匿名函数就像三元运算一样,并且能够用lambda函数有几大优势

  1、在一些不会再别的地方调用的函数,我们可以使用匿名函数,并且这样简化了代码,看起来更加整洁。

  2、lambda函数将会搭配一些内置函数来使用(下面会涉及到)

 

本文由美高梅游戏网站发布于智能家电,转载请注明出处:简学Python第三章__函数式编程、递归、内置函数,

关键词: