Python进阶知识1

Python函数

定义一个函数

1.什么是函数：函数是可以重复执行的语句块，可以重复调用

2.作用：用于封装语句块, 提高代码的重用性。

函数是面向过程编程的最小单位

def 语句

1.作用：用来定义（ 创建）函数

2.语法

def 函数名(形式参数列表):   语句块

说明

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()
• 函数名是一个变量，不要轻易对其赋值
• 函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数内部可以访问函数外部的变量，但不能轻易对其改变
• 函数的形参列表如果不需要传入参数，形式参数列表可以为空
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

函数的调用

1.语法

函数名(实际调用传递参数)

2.说明

• 函数调用是一个表达式
• 如果函数内没有return 语句，函数执行完毕后返回 None 对象

3.例子

"""函数的创建
"""
def attack():print("第一个无参函数创建")
attack()def attack2(count):for i in range(count):print(i)print(f"第一个有参函数创建,传入的次数为：{count}")
attack2(3)

4.课后练习

写一个函数 myadd, 此函数传入两个参数， x, y 次函数的功能是打印 x + y 的和: 
def myadd(......):     .... ​ myadd(100, 200)   # 300 myadd('ABC', '123') # ABC123

参考答案

def myadd(x, y):print(x, '+', y, '=', x + y)return x+y
​
sum_all = myadd(100, 200)   # 300
myadd('ABC', '123')  # ABC123

return 语句

1.语法

return [表达式]

注: [] 代表 内部的内容可以省略

2.作用：用于函数的内部，结束当前函数的执行，返回到调用此函数的地方，同时返回一个对象的引用关系

3.说明

• return 语句后面的表达式可以省略，省略后相当于 return None
• 如果函数内部没有 return 语句, 则函数执行完毕后返回None, 相当于在最后一条语句后有一条return None

4.例子

#return
def fun01():print("hello world")print("不写return的返回值，结果为None，retrun后有返回值，函数返回设置的返回值")return 0#不写0为Noe，写0返回0
re=fun01()
# hello world
# 不写return的返回值，结果为None，retrun后有返回值，函数返回设置的返回值
# 0
print(re)

5.课后练习2

写一个函数 myadd, 实现给出两个数，返回这两个数的和 
如: def myadd(x, y): .... a = int(input("请输入第一个数: ")) 
b = int(input("请输入第二个数: ")) 
print('您输入的两个数之和是:', myadd(a, b))

参考答案

def myadd(x, y):n = x + yreturn n
a = int(input("请输入第一个数: "))
b = int(input("请输入第二个数: "))
print('您输入的两个数之和是:', myadd(a, b))

函数参数

函数的调用传参

1.位置传参：实际参数传递时，实参和形参按位置来依次对应

2.关键字传参：实际参数传递时，实参和形参 按名称依次对应

注: 位置传参要先于关键字传参

3.示例

"""函数参数实际参数(调用参数)位置参数时序参数关键字参数字典实参形式参数默认形参位置形参星号元组形参命名关键字形参双星号字典形
"""def fun01(a,b,c):print(a)print(b)print(c)
fun01("位置形参1","位置形参2","位置形参3")#输出对应内容
fun01(a="关键字形参1",b="关键字形参2",c="关键字形参3")
fun01("位置形参1",c="关键字形参3",b="关键字形参2")
fun01("位置传参需在关键词之前并与参数位置对应,否则吧报错",c="关键字形参3",b="关键字形参2")list01 = [1,2,3]
fun01(*list01)#1,2,3星号传参，拆分序列与形参位置对应#将字典拆分传入函数
dict01 = dict(a=1,b=2,c=3)
fun01(**dict01)#1,2,3拆分字典，键名对应形参位置，键值进行输出#形参
#默认参数
def fun01(a,b="NONE",c=0):print(f"形参吧不能放在默认参数之后,否则报错,此处实参传值为：{a}")print(b)print(c)
fun01(1)#星号元组形参：位置形参1合并为一个元组
#通用写法：args
def fun01(*args):print(*args)
fun01("单星号元组传参","不能用关键字传参，因为关键字传参对应着双星号字典传参",1)#双星号字典传参
#通用写法：**kwargs
def fun02(**kwargs):print(kwargs)fun02(a="双星号字典的传参",b="位置传参出现报错")#单星号元组和双星号字典传参混合使用
def fun03(*args,**kwargs):print(args)print(kwargs)
fun03("单星号元组传参,星号传参时只能先单星号传参在双星号传参",a="双星号字典传参")#命名关键字形参
def fun04(*args,a,b ,c):print(args)print(a)print(b)print(c)
fun04(1,2,3,a="单星号元组后面的形参需要使用关键字传参来区分是什么传参，否则报错",b="单星号传参后面的形参必须传参",c=2)

4.问题

写一个函数 myadd4, 实现给出四个数，返回这四个数的和 
如: def myadd4(...): .... a = int(input("请输入第一个数: ")) b = int(input("请输入第二个数: ")) c = int(input("请输入第三个数: ")) d = int(input("请输入第四个数: ")) print('您输入的四个数之和是:', myadd4(a, b, c, d))# 思考用什么方式实现:print(myadd4(1, 2)) # 3 
print(myadd4(1, 2, 3)) # 6 
print(myadd4(1, 2, 3, 4)) # 10

函数的形式参数定义方法

函数的缺省参数（默认参数）

1.语法

def 函数名(形参名1=默认实参1, 形参名2=默认实参2, ... ):语句块

2.说明：缺省参数即默认实参，必须自右向左依次存在(即,如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数)

3.示例

def myadd4(a, b, c=0, d=0):    print(a)print(b)print(c)print(d)return a + b + c + d
print(myadd4(1, 2))
print(myadd4(1, 2, 3))#默认参数的值可以被更改
print(myadd4(1, 2, 3, 4))

4.错误示例

ef myadd(a, b=0, c):   # 报错pass

形参的定义

• 位置形参

• 星号元组形参(*args)

• 命名关键字形参

• 双星号字典形参（**kwargs）

位置形参

1.语法:

def 函数名(形参名1, 形参名2, ...): pass

星号元组形参

1.语法

def 函数名(*元组形参名): pass

2.作用：收集多余的位置实参

元组形参名一般命名为args

3.示例

def myfunc2(*args):print("len(args)=", len(args))print('args=', args)myfunc2()           # args=()
myfunc2(1, 2, 3)    # args=(1, 2, 3)def myfunc3(a, b, *args):print(a, b, args)myfunc3(1, 2)        # 1-->a, 2-->b, ()--->args
myfunc3(1, 2, 3, 4)  # # 1-->a, 2-->b, (3, 4)--->args

命名关键字形参

1.语法

def 函数名(*, 命名关键字形参1, 命名关键字形参2, ...): pass # 
或者 
def 函数名(*args, 命名关键字形参1, 命名关键字形参2, ...): pass

2.作用：强制，所有的参数都必须用关键字传参

3.示例

def myfunc4(a, b,*args, c, d):print(a, b, c, d)myfunc4(1, 2, d=4, c=3)   # 正确,c,d 必须关键字传参
myfunc4(1, 2, 3, 4)   # 错误

双星号字典形参

1.语法

def 函数名(**kwargs): pass

2.作用：收集多余的关键字传参

• 字典形参名最多有一个，
• 字典形参名 一般命名为 kwargs

3.示例

def myfunc5(**kwargs):print(kwargs)# {'name': 'tarena', 'age': 18}-->kwargs
myfunc5(name='tarena', age=18) 

混合形参

1.函数的形参定义方法说明

• 位置形参，星号元组形参，命名关键字参数，双星号字典形参，缺省参数可以混合使用。
• 函数的形参定义自左至右的顺序为：位置形参，星号元组形参，命名关键字参数，双星号字典形参

2.示例:

def fn(a, b, *args, c, d, **kwargs):print(a)print(b)print(*args)print(c)print(d)print(kwargs)fn(100, 200, 300, 400, c='C',name='tarena',d='D')

6.思考:

print() # 函数是如何定义的呢: 
def myprint(*args, sep=' ', end='\n'): pass

可变不可变

可更改(mutable)与不可更改(immutable)对象

1.在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

2.python 函数的参数传递：

• 不可变类型：值传递: 如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
• 可变类型：引用传递: 如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

2.不可变类型参数有:

• 数值型(整数，浮点数)
• 布尔值bool
• None 空值
• 字符串str
• 元组tuple

3.可变类型参数有:

• 列表 list
• 字典 dict
• 集合 set

4.传参说明：

• 不可变类型的数据传参时，函数内部不会改变原数据的值。
• 可变类型的数据传参时，函数内部可以改变原数据。

传不可变对象实例

1.通过内置的 id() 函数来查看内存地址变化：

def change(a):print(id(a))
a=10
print(id(a))#1428793408
a=1
print(id(a))#1428793264#总结:可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的id。

传可变对象实例

1.可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

def changeme( mylist ):mylist.append(40)print (mylist)mylist = [10,20,30]
changeme(mylist)#[10, 20, 30, 40]
print (mylist)#[10, 20, 30, 40]
#总结:传入函数的和在末尾添加新内容的对象用的是同一个引用

返回值

1.函数可以使用return语句来返回一个或多个值。

如果没有明确的return语句，函数将默认返回None。

匿名函数

1.在Python中，匿名函数通常使用lambda关键字来创建。匿名函数也被称为lambda函数，它是一种简单的、一行的函数，常用于临时需要一个小函数的地方。匿名函数的语法如下：

2.语法

lambda [函数的参数列表]: 表达式

3.作用

• 创建一个匿名函数对象
• lambda是关键字，表示你正在定义一个匿名函数。
• 同 def 类似，但不提供函数名
• [函数的参数列表]是函数的参数，可以有零个或多个参数，参数之间用逗号分隔。
• : 表达式是函数的返回值，通常是一个表达式，匿名函数会计算这个表达式并返回结果。

4.说明：lambda 表达式 的创建函数只能包含一个表达式

5.示例

"""匿名函数
"""
myadd=lambda x,y:x+y
print(myadd(2,3))

变量作用域

什么是变量作用域

一个变量声明以后,在哪里能够被访问使用,就是这个变量"起作用"的区域:也就是这个变量的作用域

一般来说,变量的作用域,是在函数内部和外部的区域 来体现,因此常常与函数有关

局部变量和全局变量

1.局部变量

• 定义在函数内部的变量称为局部变量(函数的形参也是局部变量)
• 函数内部的变量只能在函数内部或者函数内部的函数内部访问 ，函数外部不能访问
• 局部变量在函数调用时才能够被创建，在函数调用之后会自动销毁

2.全局变量

• 定义在函数外部，模块内部的变量称为全局变量
• 全局变量, 所有的函数都可以直接访问(取值,但函数内部不能直接将其赋值改变)
• 局部变量示例

def fn(a, b):c = 100print(a, b, c)    # a, b, c三个都是局部变量
fn(1, 2)
print(a, b, c)   # 报错， 因为a,b,c 在调用后就销毁了

3.全局变量示例1

#全局变量
a = 100
def fun01():a=20def fun02():#局部作用域a=10print(f"先访问局部最内层，局部无访问变量在依次递增到访问全局，此时的a：{a}")#10fun02()#10
fun01()#10

局部作用域修改全局变量

1.问题

## 如何用一个变量来记录一个函数调用的次数
count = 0def hello(name):print('hello', name)count += 1  #  等同于 count = count + 1  # 如何让 此语句能改变全局变量而不是创建局部变量hello('小张')
hello('小李')print('您共调用hello函数', count, '次')  # 2 次
​

2.作用：告诉python 的解释执行器， global 语句声明的一个或多个变量， 这些变量是全局变量

3.语法

global 变量名1, 变量名2, ....

4.global 说明

• 全局变量如果要在函数内部被赋值，则必须经过全局声明 global
• 默认全局变量在函数内部可以使用，但只能取值，不能赋值
• 不能先声明为局部变量，再用 global 声明为全局变量，此做法不符合语法规则
• 函数的形参已经是局部变量，不能用 global 声明为全局变量

错误示例

a = 100
b = 200
def fa(a):b = 20  # SyntaxError: name 'b' is assigned to before global declarationglobal bb = 222

5.例子

#函数内部修改函数外部的变量值：global
def fun03():global aa=200print(f"修改后的全部变量为：{a}")
fun03()
print(a)

局部作用域修改外部变量

1.在函数内部 提前用nonlocal声明 函数内部的某个变量为外部的变量

前提：必须是函数嵌套

2.说明：

（1）变量的查找顺序还是遵从：LEGB顺序

• 在 Python 中，LEGB 代表四种作用域的查找顺序：Local、Enclosing、Global 和 Built-in。

（2）局部作用域中若要修改外部函数嵌套作用域中的变量需要使用：nonlocal 语句

• 格式：nonlocal 变量名
• 作用：将局部作用域中变量声明为外部函数嵌套作用域中的变量。

LEGB顺序

1.Local (L)

• 本地作用域，指当前函数内部的变量。
• 当你在函数内部定义变量并尝试访问它时，Python 首先会在函数内部查找这个变量。

def outer_function():x = 10  # Local variableprint(x)  # 查找顺序从 Local 开始

2.Enclosing (E)

• 闭包函数外的函数作用域，指嵌套函数的外部函数中定义的变量。
• 如果在当前函数内部找不到变量，Python 会查找外层（闭包）函数中的变量。

def outer_function():x = 10  # Enclosing variabledef inner_function():print(x)  # 查找顺序从 Enclosing 开始inner_function()

3.Global (G)

• 全局作用域，指模块级别定义的变量。
• 如果在本地和闭包函数中找不到变量，Python 会查找全局作用域的变量。

x = 20  # Global variable
def outer_function():print(x)  # 查找顺序从 Global 开始

4.Built-in (B)

• 内建作用域，指 Python 预定义的变量、函数等，如 len、sum 等。
• 如果在以上三个作用域中都找不到变量，Python 会查找内建作用域。

def outer_function():print(len)  # 查找顺序从 Built-in 开始

nonlocal

#修改嵌套函数的变量
def fun01():a=20def fun02():#局部作用域nonlocal aa=100print(f"不用nonlocal进行嵌套变量声明，修改外层嵌套函数变量无效，声明后，此时的a为：{a}")fun02()#嵌套函数只能在嵌套函数的同层进行调用,在超出嵌套函数的层进行调用处报错
fun01()#只调用最外层的函数，里面嵌套的函数不能被调用,想要完整的走完每个函数代码，那么每个函数都需要被调用

函数的内存分配

1、将函数的代码存储到代码区，函数体中的代码不执行。

2、调用函数时，在内存中开辟空间（栈帧），存储函数内部定义的变量。

3、函数调用后，栈帧立即被释放。

4.例子

#结论：传入的是不可变的类型，那么函数内部变量是不能直接改变的
#传入的是全局变量是可变类型，函数内部变量是可以直接修改的
def fun01(data1,data2):data1 = 10data2[0] = 100return data1,data2
a=20
b=[1,2,3]
print(fun01(a,b))
print(a)#无法改变全局变量
print(b)

函数自调用(递归)

1.函数直接或间接的调用自身

• 讲故事:

• 从前有座山,山上有座庙，庙里有个老和尚讲故事

  • 从前有座山,山上有座庙，庙里有个老和尚讲故事

    • 从前有座山,山上有座庙，庙里有个老和尚讲故事

2.示例

# 函数直接的调用自身
def f():f()  # 调用自己# 此递归达最大深度出错
# f()
print("递归完成")# 函数直接的调用自身
def fa():fb()
def fb():fa()
fa()
print("递归完成")

3.说明

• 递归一定要控制递归的层数，当符合某一条件时要终止递归调用
• 几乎所有的递归都能用while循环来代替

4.递归的实现方法

• 先假设此函数已经实现

5.递归优缺点

（1）优点：

• 递归可以把问题简单化，让思路更为清晰,代码更简洁

（2）缺点：

• 递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果

6.限制层数递归示例

• 递归函数示例 计算阶乘 factorial 迭代实现

def factorial(n):result = 1i = 1while i <= n:result *= ii+=1return resultprint("factorial: ", factorial(5))

• 递归实现示例

# file: factorial.pydef factorial(n):if n == 1:return 1s = n * factorial(n-1)return sprint("factorial: ", factorial(5))

• 练习1

写一个程序: 输入一个整数，代表树干的高度，打印如下圣诞树 
请输入: 3 
打印: * *** 
***** $ $ $ 
请输入: 4 
打印: * *** ***** 
******* $ $ $ $

参考答案

def print_tree(n):# 0. 用 n 求出 树叶部分的最大宽度max_width = 2 * n -1# 1. 打印树叶部分for line in range(1, n+1):stars = '*' * (2 * line - 1)print(stars.center(max_width))# 2. 打印树干部分dollar = ' ' * (n-1) + '$'for line in range(n):print(dollar)print_tree(3)
print_tree(4)

• 课后练习2

写一个函数 myrange 实现和 range 一样的功能， 但返回列表 
def myrange(start, stop=None, step=None):# return range(start, stop, step) 不能这样 if stop == None: # 这是一个参数 return list(range(0, start)) ... 此处自己完成 
for x in myrange(4): print(x) # 0, 1, 2, 3
for x in myrange(3, 6): print(x) # 3, 4, 5 
for x in myrange(1, 10, 2): print(x) # 1, 3, 5, 7, 9

参考答案

def myrange(start, stop=None, step=None):if stop is None:  # 如火没有给出第二个参数stop = startstart = 0if step is None:step = 1r_list = []# 向列表 r_list 内添加数据i = start   # i  代表生成的数if step > 0:while i < stop:r_list.append(i)i += stepelif step < 0:while i > stop:r_list.append(i)i += step# 返回列表return r_listfor x in myrange(4):print(x)  # 0, 1, 2, 3print('================================')for x in myrange(3, 6):print(x)  # 3, 4, 5print('================================')for x in myrange(1, 10, 2):print(x)  # 1, 3, 5, 7, 9print(myrange(5))  # [0, 1, 2, 3, 4]
print('=================================')
print(myrange(10, 0, -3))  # [10, 7, 4, 1