Hi，大家好，我是编程小6，很荣幸遇见你，我把这些年在开发过程中遇到的问题或想法写出来，今天说一说python教程从基础到精通，第11课—函数,希望能够帮助你!!!。

Hello，小伙伴们，五.一快乐！

前面咱们学习了python的变量、输入输出、七大数据类型与流程控制语句等，接下来是新的篇章：函数。

python的函数是其最大的特色，是“开疆拓土”的利器，是python学习的核心。

本章先讲自定义函数，再讲常用内置函数的用法，下面开始吧。

1、函数的定义

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

你可以定义一个由自己想要功能的函数，以下是简单的规则：

1) 函数代码可以 def 关键词开头，后接函数标识符名称和圆括号()。

2) 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

3) 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

4) 函数内容以冒号起始，并且缩进。

5) return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

1.1、函数定义的语法：

def functionname( parameters ):

"子函数代码块"

return [expression]

直接上代码吧，更容易理解函数的基础结构：

最简单的自定义函数：

def fun1():
print('这是子程序')
#调用子程序
fun1() #这是子程序

带返回值的子函数：

def fun1():
print('这是子程序')
return 30
#调用子程序
print(fun1()) #这是子程序 \n 30

带参数的子函数：

def fun1(a,b ):
print('这是子程序:', a+b)
return a+b
#调用子程序
print(fun1(2,3)) #这是子程序: 5 \n 5

1.2、参数、形参、实参

定义函数时预设的临时变量，有个专门的名称：参数。上个例子中，定义过程所用的样板 a,b，叫作 形式参数，简称 形参，只起示范作用；而实际调用函数有的2,3，叫作 实际参数，简称 实参。

万能的形参，这是python最具特色的地方，拿来就用，没有太多的束缚。以往的编程语言基本上都是必须要定义形参类型的，否则无法使用。这点python自由得多，不用定义，只你需要占位就行，请看下面代码：

def fun1(x):
print('这是子程序:', x)
# 调用子程序
a = "python"
b = [1, 2, 3]
c = ('a', 'b', 'c')
d = {1, 2, 3}
e = {1: 'I', 2: 'love', 3: 'python'}
print(a) #python
print(b) #[1, 2, 3]
print(c) #('a', 'b', 'c')
print(d) #{1, 2, 3}
print(e) #{1: 'I', 2: 'love', 3: 'python'}

1.3、函数的命名

仍需要遵行变量的命名规则，由数字、字母、下划线组成，并且不可以用数字作为名称的开头。另外，名称本身要表达自己的功能，要简单易读，并且中间不能有空格。

1.4、return语句特点

return 语句有一个特别要注意的点，return 语句是函数执行结束的标记，运行完 return 语句，就会退出函数的执行，不管后面还有没有其它代码。所以我们一般都要把 return 语句放在最后。

1.5、局部变量与全局变量

局部变量是指它只适用于某段程序块内的变量，例如函数内部的变量，外部是不可见的，只在内部有效。

而全局变量是定义在所有程序块之外的变量，它在全局可见与有效，可以被使用或修改。

可以参考下面的代码：

pi = 3.14
def circle_area(r):
return (pi * r * r)
# 调用子程序
a = circle_area(2.5)
print(a) # 19.625
pi=3.142
a = circle_area(2.5)
print(a) # 19.6375

2、Lambda匿名函数

2.1、定义

python 使用 lambda 来创建匿名函数，lambda函数的主体是一个表达式，结构上比def函数简单很多。

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

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

示例代码：

x = lambda a: a + 10
print(x(5)) #15
x = lambda a, b: a * b
print(x(5, 6)) #30

2.2、Lambda函数+map函数

语法：map(function, iterable, ...)

function：函数。iterable：一个或多个序列，可以是列表、元组、集合、甚至字符串。

Python中的map()函数是一个将给定的序列的值依次在所定义的函数关系中迭代并返回一个新列表。例如：

tt = [1, 2, 3]
print(map(lambda x: x*2, tt)) #<map object at 0x000001D3E4E72650>
print(list(map(lambda x: x*2, tt))) #[2, 4, 6]
print(tuple(map(lambda x: x*2, tt))) #(2, 4, 6)

#===============================

tt = {'a', 'b', 'c'}
print(map(lambda x: x+'e', tt)) #<map object at 0x000001D3E4E72650>
print(list(map(lambda x: x+'e', tt))) #[2, 4, 6]
print(tuple(map(lambda x: x+'e', tt))) #(2, 4, 6)

#===============================

tt = "python"
print(map(lambda x: x+'e', tt)) #<map object at 0x000001900F84F250>
print(list(map(lambda x: x+'e', tt))) #['pe', 'ye', 'te', 'he', 'oe', 'ne']
print(tuple(map(lambda x: x+'e', tt))) #('pe', 'ye', 'te', 'he', 'oe', 'ne')

2.3、Lambda函数+filter函数

语法：filter(function, iterable)

function：过滤函数。iterable：一个或多个序列，可以是列表、元组、集合、甚至字符串。

tt = [1,11,2,45,7,6,13]
fil = filter(lambda x: x > 10, tt) #找出大于10的元素
print(fil) #<filter object at 0x0000020E3DF4D1E0>
print(tuple(fil)) #(11, 45, 13)

2.4、Lambda函数+sort/sorted函数

（1）sort的用法

引用方法：list1.sort(key=None, reverse=False)

按key方法，reverse=False顺序还是reverse=True逆序排序。

（2）sorted的用法

引用方法：sorted(iterable, /, *, key=None, reverse=False)

按key方法，reverse=False顺序还是reverse=True逆序排序。

（3）sort 与 sorted 区别：

² sorted是python的内置函数，可以对列表（list），元祖（tuple），字典（dict）和字符串（str）进行排序,排序对象作为sorted函数的参数。

² sort() 是列表类的方法，只能对列表排序。

² sorted()对列表排序时，有返回值；sorte()对列表排序时，无法返回值（直接在原列表中操作）。

² sort 和 sorted 都有两个可选仅限关键字参数 key 和 reverse，都是默认升序排序。

示例代码：

tup1 = (1,3,2,4)
lst1 = list(tup1)
lst1.sort() #sort对象只能是列表，无返回值
print(lst1) #[1, 2, 3, 4]，重新排序
print(sorted(tup1)) #[1, 2, 3, 4]，重新排序
tt = sorted(range(10, 0, -1)) # 对生成器排序
print(tt) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
tt = sorted(range(10, 0, -1), reverse=True) # 按逆序
print(tt) #[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
list_a = ['This', 'is', 'a', 'test', 'string', 'from', 'Andrew']
tt = sorted(list_a, key=str.lower) #都转为小写，然后再进行比较排序。
print(tt) #['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
#==================================================================
words =["apple","pear","banana","orange"]
sorted_words=sorted(words,key=lambda x: len(x)) #按字符串长度排序
print(sorted_words) #['pear', 'apple', 'banana', 'orange']

再来看一个高级的例子：

class Student:
def __init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
def __repr__(self):
return repr((self.name, self.grade, self.age))
student_objects = [
Student('john', 'A', 15),
Student('jane', 'B', 12),
Student('dave', 'B', 10),
]
tt = sorted(student_objects, key=lambda student: student.age)
print(tt) #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

2.5、Lambda函数+reduce函数

语法：reduce(function,sequence[,initial]=>value)

function：函数。iterable：可迭代的一个或多个序列。

把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。

示例代码：

from functools import reduce
nums = [6,9,2,6]
print(sum(nums)) #23,利用函数求和
print(reduce(lambda x,y: x+y,nums)) #23，从第1个元素开始一个加一个，求和
print(reduce(lambda x,y: x-y,nums)) #-11，从第1个元素开始一个减一个，求差
print(reduce(lambda x,y: x*y,nums)) #648，从第1个元素开始一个乘一个，求积

3、常用内嵌函数

这里列出了69个python内嵌函数，有些前面都已经介绍或用过了，本章不再一一介绍了，不熟悉的小伙伴可以自己去百度。

愉快学习的时光总是过得很快，一不小心又到结尾啦。

先来给自己一个奖励，双手举起，yeah!

有什么问题可以关注我/私信我/加好友，让我们一起成长吧。

今天的分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。