Python 函数

函数是组织好的，可重复使用的，用来实现繁多，或相关联性能的代码段。函数能进步利用的模块性，和代码的反复利用率。Python提供了许多内建函数，比方print()。但也能够本人创立函数，这被叫做用户自定义函数。

1.函数的定义：

你能够定义一个由本人想要性能的函数，以下是简略的规定：

函数代码块以 def 关键词结尾，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号两头。圆括号之间能够用于定义参数。
函数的第一行语句能够选择性地应用文档字符串—用于寄存函数阐明。
函数内容以冒号起始，并且缩进。
pass 关键字，代表什么都不干
exit(num) 强行退出(num:是一个数字，显示为退出码)
return [表达式] 完结函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

def functionname\( parameters \):     function\_suite     return \[expression\]

默认状况下，参数值和参数名称是按函数申明中定义的的程序匹配起来的。

举例1：

def add\(x, y\):  print\(“x = \{0\}”.format\(x\)\)  print\(“x = \{0\}”.format\(x\)\)  print\(“x  + y  = \{0\}”.format\(x+y\)\)  return x+y

举例2：

#\!/usr/bin/env python  # -\*- coding: utf-8 -\*-  # \@Time    : 2018/4/14 20:31  # \@Author  : Feng Xiaoqing  # \@File    : demo1.py  # \@Function: -----------      def f\(x,l=\[\]\):      for i in range\(x\):          l.append\(i\*i\)      print\(l\)    # f\(2\) = f\(2, l=\[\]\)    f\(2\)  # 后果：\[0, 1\]    f\(3,\[3,2,1\]\)  # 后果： \[3, 2, 1, 0, 1, 4\]    f\(x=3, l=\[\]\)  # 后果: \[0, 1, 4\]

运行后果：

\[0, 1\]  \[3, 2, 1, 0, 1, 4\]  \[0, 1, 4\]

2.函数的调用

定义一个函数只给了函数一个名称，指定了函数里蕴含的参数，和代码块构造。这个函数的根本构造实现当前，你能够通过另一个函数调用执行，也能够间接从Python提示符执行。

如下实例调用了add（）函数：

#\!/usr/bin/env python  \# -\*- coding: utf-8 -\*-  \# \@Time    : 2018/4/15 21:01  \# \@Author  : Feng Xiaoqing  \# \@File    : demo2.py  \# \@Function: -----------    \# 自定义加法函数add\(\)  def add\(x,y\):      print\("\{0\} + \{1\} = \{2\}".format\(x,y,x+y\)\)      return      print\("finished"\)   #在return后不会执行这条语句      \# 调用函数,计算2+3的得数  add\(2,3\)

运行后果：

2 + 3 = 5

3.函数的参数

形式参数和理论参数

在定义函数时，函数名前面，括号中的变量名称叫做形式参数，或者称为"形参"

在调用函数时，函数名前面，括号中的变量名称叫做理论参数，或者称为"实参"

def fun\(x,y\):  //形参      print（x + y）      fun\(1,2\)     //实参      3      fun\('a','b'\)      ab

函数默认参数:

缺省参数（默认参数）

def fun\(x,y=100\)        print x,y    #调用：  fun\(1,2\)  fun\(1\)

定义：

#\!/usr/bin/env python  \# -\*- coding: utf-8 -\*-    def fun\(x=2,y=3\):    print x+y

调用：

fun\(\)  #后果：  5    fun\(23\)  #后果  26    fun\(11,22\)  #后果：  33

咱们常常在看他人的代码中，经常出现def(*args, **kwargs)这样的表现形式：

\*args             指的是：tuple  \(1, \)  \*\*kwargs       指的是：dict   \{“k”: “v”\}    fun\(\*args, \*\*keargs\)  fun\(1, 2, 3, 4, 5, a=10, b=40\)

4.函数的返回值

函数返回值：

函数被调用后会返回一个指定的值

函数调用后默认返回None

return返回值

返回值能够是任意类型

return执行后，函数终止

return与print区别

#\!/usr/bin/env python  \# -\*- coding:utf-8 -\*-  def fun\(\):    print 'hello world'    return 'ok'    print 123    fun\(\)    #后果  hello world  123  None

5.函数的变量

局部变量和全局变量：

Python中的任何变量都有特定的作用域

在函数中定义的变量个别只能在该函数外部应用，这些只能在程序的特定局部应用的变量咱们称之为局部变量

在一个文件顶部定义的变量能够供文件中的任何函数调用，这些能够为整个程序所应用的变量称为全局变量。

def fun\(\):     x=100     print x    fun\(\)  x = 100    def fun\(\):     global x   //申明     x +=1     print x    fun\(\)  print x

内部变量被改（x由100改为101）：

x = 100    def fun\(\):    global x    x += 1    print \(x\)    fun\(\)  print \(x\)    #后果  101  101

外部变量内部也可用：

#\!/usr/bin/env python  \# -\*- coding: utf-8 -\*-  \# \@Time    : 2018/4/15 21:33  \# \@Author  : Feng Xiaoqing  \# \@File    : demo2.py  \# \@Function: -----------    x = 100    def fun\(\):      global x      x +=1      global y      y = 1      print\(x\)    fun\(\)  print\(x\)  print\(y\)    #后果：  101  101  1

统计程序中的变量，返回的是个字典

#\!/usr/bin/env python  \# -\*- coding:utf-8 -\*-    x = 100  def fun\(\):      x = 1      y = 1      print\(locals\(\)\)    fun\(\)  print \(locals\(\)\)

后果：

\{'y': 1, 'x': 1\}  \{'\_\_name\_\_': '\_\_main\_\_', '\_\_doc\_\_': None, '\_\_package\_\_': None, '\_\_loader\_\_': \<\_frozen\_importlib\_external.SourceFileLoader object at 0x02FF6390\>, '\_\_spec\_\_': None, '\_\_annotations\_\_': \{\}, '\_\_builtins\_\_': \<module 'builtins' \(built-in\)>, '\_\_file\_\_': 'D:/PycharmProjects/PythonLive/untitled/day07/demo2.py', '\_\_cached\_\_': None, 'x': 100, 'fun': \<function fun at 0x052D2390\>\}

6.匿名函数

顾名思义就是没有名字的函数，那为什么要设立匿名函数，他有什么作用呢？

lambda 函数是一种疾速定义单行的最小函数，能够用在任何须要函数的中央

python 应用 lambda 来创立匿名函数。

lambda只是一个表达式，函数体比def简略很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装无限的逻辑进去。
lambda函数领有本人的命名空间，且不能拜访自有参数列表之外或全局命名空间里的参数。
尽管lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目标是调用小函数时不占用栈内存从而减少运行效率。

语法

lambda函数的语法只蕴含一个语句，如下：

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

举例：求两数的乘积：惯例写法：

def fun\(x,y\)    return x\*y

lambda版本写法：

r = lambda x,y:x\*y

7.高阶函数

（1）map(f, list)

返回每个元素通过f计算完的value的list

map()函数接管两个参数，一个是函数，一个是序列，map将传入的函数顺次作用到序列的每个元素，并把后果作为新的list返回。

举例：计算列表里值的平方

#\!/usr/bin/env python  \# -\*- coding:utf-8 -\*-    def f\(x\):      return x\*x    for i in map\(f,\[1,2,3,4,5,6,7\]\):      print\(i\)

后果：

1  4  9  16  25  36  49

（2）reduce(f,list)函数（求list中数的和）

reduce把一个函数作用在一个序列[x1, x2, x3...]上，这个函数必须接管两个参数，reduce把后果持续和序列的下一个元素做累积计算，其成果就是：

举例：计算列表中所有数的和

#\!/usr/bin/env python  \# -\*- coding:utf-8 -\*-    from functools import reduce  #导入reduce函数    def f\(x,y\):      return x+y  print\(reduce\(f,\[1,2,3,4,5,6,7,8,9,10\]\)\)  print\(reduce\(f,range\(1,101\)\)\)   #后果：  55  5050

（3）filter()函数（过滤）

filter函数接管一个函数f和一个list，函数f的作用是对每个元素进行判断，返回True或者False，filter()依据判断后果主动过滤掉不符合条件的元素，返回符合要求的元素组成的listfilter(lamdba x: x%2 ==1, [1, 2, 3, 4, 5])

举例：计算list中小于7的数

#\!/usr/bin/env python  \# -\*- coding:utf-8 -\*-    for i in filter\(lambda x:x\<7, \[1, 2, 3, 4, 5,40,8\]\):      print\(i\)      #后果：  1  2  3  4  5

（4）sorted()函数（排序）

sorted(...)
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

# sorted\(iterable, key, reverse\)  # iterable  一个可迭代的对象  # key 对什么进行排序  # reverse  bool类型，如果为true为反序， 默认为false  # 返回值是一个list

举例：

#\!/usr/bin/env python  \# -\*- coding: utf-8 -\*-  \# \@Time    : 2018/4/15 22:47  \# \@Author  : Feng Xiaoqing  \# \@File    : demo3.py  \# \@Function: -----------      m = dict\(a=1, c=10, b=20, d=15\)  print\(sorted\(m.items\(\), key = lambda d:d\[1\],reverse = True\)\) #按value值倒序排列      #后果：  \[\('b', 20\), \('d', 15\), \('c', 10\), \('a', 1\)\]

有段时间没跟大家分享资源福利了，看了下本人的资料夹，整顿了一些我认为比拟好的Python学习材料了。置信这套材料能够对你进阶高级工程师有帮忙！

学习工具

大厂实战手册

自学视频（局部）

【材料收费支付形式】

点这里：2020Python高薪实战学习大合集