Python学习笔记③——函数 [基础函数 + 匿名函数 + 列表推导式]一、函数——基础知识点二、函数——进阶知识点三、列表推导式（补充内容）四、参考书籍

✅ Blogger Learns Python is for learning the “Self-supervised Learning”.

Python ????

上一篇文章链接:【Python学习笔记②】——基础的数据结构【字符串、列表、元组、字典 + 增删查改】.
下一篇文章链接: ???? ???? …

一、函数——基础知识点

● (Python中)函数的作用：如果在开发程序时，需要调用某块代码多次，为了提高编写的效率以及代码的重用，就可以把具有独立功能的代码块组织为一个小模块，这就是函数。

1.1 函数的定义

● 函数的定义格式如下：

def 函数名(): 
	函数体...

1.2 函数的调用

● 通过 “函数名()” 即可完成调用。【注意：函数名() 后需要有一个:】

# 定义一个函数，能够完成打印信息的功能 
def printInfo(): 
	print('+-----------------+')
	print('Hello 我在函数体里面')
	print('+-----------------+')

# 定义完函数后，函数是不会自动执行的，需要调用它才可以 
printInfo()

● 运行结果：

◆ 注意：
  ① 每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束。
  ② 如果函数中执行到了return也会结束函数。

● 综合样例：定义一个函数，能够计算两个数字之和，并且调用这个函数让它执行。使用def定义函数 ，且在编写完函数之后，通过 “函数名()” 进行调用。

def add(a, b):
	"用来完成对 2 个数求和"		# 函数第一行写一个字符串作为函数文档
	print("%d" % (a+b))

add(12, 34)
print('------分割线------')
help(add)

● 运行结果：

1.3 函数的参数

● 在定义函数的时候让函数的接收数据，就是函数的参数。上诉综合样例中的 “a和b” 就是。

◆ 注意：
  ① 在定义函数的时候，小括号里写等待赋值的变量名。
  ② 在调用函数的时候，小括号里写真正要进行运算的数据。
  ③ 定义时小括号中的参数，用来接收参数用的，称为 “形参”。
  ④ 调用时小括号中的参数，用来传递给函数用的，称为 “实参”。

● 调用函数时参数的顺序不可以换，但以下情况是允许的：

def sub(a, b)
	print( "%d" % (a-b) )

sub(3, 1)	# 正常调用, 即实现“3-1”
sub(b=10, a=20)	# 关键字参数调用, 即实现“30-20”

● 调用函数时，缺省参数的值如果没有传入，则取默认值。样例如下：

def printInfo(name, age=35):
    print("name: %s" % name)
    print("age: %d" % age)


# 调用 printInfo() 函数
printInfo(name="XiaoWang")  # 在函数执行过程中 → age的默认值为35
printInfo(age=9, name="XiaoWang")

● 运行结果：

● 不定长参数：有时可能需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，声明时不会命 名。
■ 基本语法如下：

def 函数名([formal_args,] *args, **kwargs): 
	"""函数_文档字符串"""
	函数体...
	return [expression]

◆注意：
  ① 加了星号*的变量 args会存放所有未命名的变量参数，args为元组
  ② 而加**的变量kwargs会存放命名参数，即形如key=value的参数，kwargs为字典。

● 样例：

def fun(a, b, *args, **kwargs):
    """可变参数演示示例"""
    print("a = %d" % a)
    print("b = %d" % b)
    print("args:")
    print(args)
    print("kwargs: %s" % kwargs)


fun(1, 2, 3, 4, 5, x=6, y=7, z=8)   # 注意传递的参数对应
print('---------------分割线---------------')
c = (30, 40, 50)
d = {"xx": 66, "yy": 77, "zz": 88}
fun(1, 2, *c, **d)  # 注意元组与字典的传参方式
print('---------------分割线---------------')
fun(1, 2, c, d)     # 注意不加星号与上面的区别

● 运行结果：

1.4 函数的返回值

● 所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果。

● 使用返回值的前提需求就是函数调用者想要在函数外使用计算结果

● 带有返回值的函数：想要在函数中把结果返回给调用者，需要在函数中使用return

def add2num(a, b): 
	c = a+b 
	return c 	# return 后可以写变量名

result = add2num(18, 28)	# 调用函数，顺便保存函数的返回值

● 补充说明：一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了。

● 一个函数返回多个数据的方式：

方式一：
def testFun(a, b):
	add_res = a + b
	sub_res = a - b
	return add_res, sub_res	 # 返回值默认是元组

res_1, res_2 = testFun(10, 20)		# 直接把元组拆分为两个变量来使用
----------------------------------------------
方式二：return 后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据
def function(): 
	# return [1, 2, 3] 	# 列表
	# return (1, 2, 3) 	# 元组
	return {"num1": 1, "num2": 2, "num3": 3}	# 字典

1.5 函数的嵌套调用

● 样例：testA()函数中嵌套调用testB()函数。

def testB():
	print('+--- testB start---+')
	print('这里是testB函数执行的代码...(省略)...')
	print('+--- testB end----+')

def testA():
	print('>>> testA start <<<')
	testB()
	print('>>> testA end <<<')

testA()

● 运行结果：

二、函数——进阶知识点

2.1 局部变量和全局变量

● 局部变量：就是在函数内部定义的变量。

◆ 对于局部变量的说明：
  ① 其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的。
  ② 因为其作用范围只是在自己的函数内部，所以不同的函数可以定义相同名字的局部变量。
  ③ 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储。
  ④ 当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了。

● 全局变量：如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量。

◆ 对于局部变量的说明：
  ① 在函数外边定义的变量叫做全局变量。
  ② 全局变量能够在所有的函数中进行访问。

● 样例：

def fun1():
	a = 100
	print('>>> fun1 <<< a现在的值为%d' % a)
	a = 200
	print('>>> fun1 <<< a现在的值为%d' % a)
	print('>>> fun1 <<< c现在的值为%d' % c)

def fun2():
	a = 300
	print('>>> fun2 <<< a现在的值为%d' % a)
	print('>>> fun2 <<< c现在的值为%d' % c)


c = 188		# c 是全局变量
a = 999		# a 也是全局变量
print('a现在的值为%d' % a)
print('c现在的值为%d' % c)
fun1()
fun2()
print('>>> a现在的值为%d <<<' % a)
print('>>> c现在的值为%d <<<' % c)

● 运行结果：

◆ 说明：当函数内出现局部变量和全局变量相同名字时，此时可理解为定义了一个 “与全局变量重名的局部变量”，而不是修改全局变量的值。

● 函数中能否对全局变量进行修改呢？
● 答案是可以的，方法如下：

def fun1():
	global a, c		# 可以使用一次global对多个全局变量进行声明
	a = 100
	print('>>> fun1 <<< a现在的值为%d' % a)
	a = 200
	print('>>> fun1 <<< a现在的值为%d' % a)
	print('>>> fun1 <<< c现在的值为%d' % c)

def fun2():
	a = 300
	print('>>> fun2 <<< a现在的值为%d' % a)
	print('>>> fun2 <<< c现在的值为%d' % c)


c = 188		# c 是全局变量
a = 999		# a 也是全局变量
print('a现在的值为%d' % a)
print('c现在的值为%d' % c)
fun1()
fun2()
print('>>> a现在的值为%d <<<' % a)
print('>>> c现在的值为%d <<<' % c)

● 运行结果：

◆ 说明：如果在函数中出现 global 全局变量的名字，那么当局部变量与全局变量重名时，此时对局部变量的修改就是对该全局变量的修改。

2.2 引用的简介

● 先看一个简单的样例，观察一下b的变化：

a = 1
b = a
print("b的值为%d" % b)
a = 2
print("现在b的值为%d" % b)

print('------------分割线------------')

a = [1, 2]
b = a
print("b的值为%s" % b)
a.append(3)
print("b的值为%s" % b)

◆ 说明：可以发现，分割线上面 b 的值没有跟随 a 的变化而变化。但是分割线下面 b 的值随 a 的改变而发生了变化。

● 在 Python 中，值是靠引用来传递来的。

● 我们可以用 id() 来判断两个变量是否为同一个值的引用。 我们可以将id值 理解为那块内存的地址标示。

a = 1
b = a
print("现在 a、b 的值分别为 %d、%d。且id(a)=%d、id(b)=%d" % (a, b, id(a), id(b)))
a = 2
print("现在 a、b 的值分别为 %d、%d。且id(a)=%d、id(b)=%d" % (a, b, id(a), id(b)))

print('------------分割线------------')

a = [1, 2]
b = a
print("现在 a、b 的值分别为 %s、%s。且id(a)=%d、id(b)=%d" % (a, b, id(a), id(b)))
a.append(3)
print("现在 a、b 的值分别为 %s、%s。且id(a)=%d、id(b)=%d" % (a, b, id(a), id(b)))

● 运行结果：

◆ 说明：
① 之前为了更好的理解变量，咱们可以把 a=100 理解为变量a中存放了100，事实上变量a存储是100的引用（可理解为在内存中的一个编号）
② 对上述结果的图形化说明：

● 额外补充：【变量类型分为 “可变类型” 和 “不可变类型”】
  ① 所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变
  ② 可变类型(修改数据，内存地址不会发生变化)有： 列表、字典、集合
  ③ 不可变类型(修改数据，内存地址必定发生变化)有： 数字、字符串、元组

2.3 引用当做实参

● 可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？详见下例：

def test1(a):  # 变量 a 一定是一个局部变量，就看它指向的是谁，可变还是不可变
    a = a + a  # 也可以写出 "a += a"
    print("在函数体内, a = ", end="")
    print(a)


a = 100
test1(a)
print("在函数体外, a = ", end="")
print(a)

a = [22, 33]
test1(a)
print("在函数体外, a = ", end="")
print(a)

● 运行结果：

◆ 说明：
  ① Python 中函数参数是传递引用，也就是数据的内存地址。
  ② 对于不可变类型，修改形参，不影响实参。
  ③ 对于可变类型来说，修改形参，会影响实参。

2.4 匿名函数

● 用 lambda 关键词能创建小型匿名函数。这种函数得名于省略了用 def 声明函数的标准步骤。

■ lambda 函数的语法只包含一个语句：

lambda 参数列表: 运算表达式

● 样例：

sum = lambda arg1, arg2: arg1 + arg2

# 调用 sum() 函数
print("两数之和为: %d" % sum(10, 20))

● 运行结果：

● 注意：Lambda 函数能接收任何数量的参数但只能返回一个表达式的值。

● 应用场合：函数作为参数传递。

① 用于 “自己定义函数” ：

    print("a = " + str(a))
    print("b = " + str(b))
    print("result = %d" % opt(a, b))


fun(100, 20, lambda x, y: x - y) 

● 运行结果：

② 用于 “作为内置函数的参数” ：
想一想，下面的数据如何指定按 name 或 age 排序？

stus = [
    {"name": "Wang", "age": 18},
    {"name": "Dou", "age": 19},
    {"name": "dou", "age": 17}
]

按 name 排序：

func = lambda x: x['name']
stus.sort(key=func)

按 age 排序：

func = lambda x: x['age']
stus.sort(key=func)

● 运行结果：【注，字符串是按照 ASCII 码，从小到大排序的】

三、列表推导式（补充内容）

● 所谓的列表推导式，就是指的轻量级循环创建列表。

3.1 基本使用方式

● 样例：

a = [x for x in range(3)]
print(a)

b = [y for y in range(5,10)]
print(b)

c = [z for z in range(1, 10, 2)]    # 间距为 2
print(c)

● 运行结果：

3.2 在循环的过程中使用 if

● 样例：

a = [x for x in range(1, 10) if x % 2 == 0]
print(a)

stus = [
    {"name": "Wang", "age": 18},
    {"name": "Dou", "age": 19},
    {"name": "dou", "age": 18}
]

b = [item for item in stus if item['age'] == 18]
print(b)

● 运行结果：

3.3 两个 for 循环

a = [(x,y) for x in range(1, 5) for y in range(2)]  # 列表套元组
print(a)

b = [[x,y] for x in range(10,21,10) for y in range(2)]  # 列表套列表
print(b)

● 运行结果：

3.4 实战样例

● 请写出一段 Python 代码实现分组一个 list 里面的元素，比如 [1,2,3,…20] 变成 [[1,2,3],[4,5,6]…]。

list_a = [x for x in range(1,21)]
print(list_a)
list_b = [list_a[y:y+3] for y in range(0, len(list_a), 3) ]
print(list_b)

● 运行结果：

四、参考书籍

[1]《Python编程_从入门到实践》

[2]《Python程序设计——第3版》

上一篇文章链接:【Python学习笔记②】——基础的数据结构【字符串、列表、元组、字典 + 增删查改】.

下一篇文章链接: ???? ???? …

⭐️ ⭐️

最后

以上就是冷酷滑板为你收集整理的Python学习笔记③——函数 [基础函数 + 匿名函数 + 列表推导式]一、函数——基础知识点二、函数——进阶知识点三、列表推导式（补充内容）四、参考书籍的全部内容，希望文章能够帮你解决Python学习笔记③——函数 [基础函数 + 匿名函数 + 列表推导式]一、函数——基础知识点二、函数——进阶知识点三、列表推导式（补充内容）四、参考书籍所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。