Python基础语法05--函数

最新推荐文章于 2024-04-08 21:39:24 发布
最新推荐文章于 2024-04-08 21:39:24 发布
阅读量340 收藏
点赞数 1
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nikeylee/article/details/108984980
版权

目录

函数

1、函数的创建

2、函数的参数传递

3、函数的返回值

4、函数的参数定义

1）函数定义默认值参数

2）个数可变的位置参数

3）个数可变的关键字形参

4）传入多个个数可变的参数

5、函数的参数总结

1）将序列中的每个元素，都转换为位置实参；使用*序列对象

2）将字典中的每个键值对，都转换为关键字实参；使用**字典对象

3）举例

4）函数定义时，参数使用了*，在函数调用时，*之后的参数只能使用关键字实参传递

5）函数定义时的形参的顺序问题

6、变量的作用域

1）局部变量

2）全局变量

7、递归函数

8、斐波那契数列

9、总结

函数

  • 执行特定的任务，和完成特定功能的一段代码；

 

函数的作用：

  • 复用代码；
  • 隐藏实现细节；
  • 提高可维护性；
  • 提高可读性，便于调试；

 

1、函数的创建

1）函数的创建，语法格式：

def 函数名([输入参数]):
    函数体
    [return XXX]

 2、函数的调用，语法格式：

函数名([实际参数])

 

# 函数的创建
# 函数或类定义后，建议间隔2行
def calc(a, b):
    c = a + b
    return c


# 函数的调用
result = calc(10, 20)
print(result)

 

2、函数的参数传递

1）函数调用的参数传递

  • 位置实参，根据形参对应的位置进行实参传递；
  • 关键字实参，根据形参名称进行实参传递；
  • 在函数调用过程中，进行参数的传递：
    • 如果是不可变对象，在函数体的修改，不会影响实参的值；如整数，字符串，元组
    • 如果是可变对象，在函数体的修改，会影响实参的值；如列表，字典，集合
# 函数的创建，函数或类定义后，建议间隔2行
def calc(a, b):   # a，b为形式参数，简称形参，形参的位置是在函数的定义处 
    c = a + b
    print('a=', a)
    print('b=', b)
    print('-------------')
    return c


# 函数的调用
result1 = calc(10, 20)   # 10，20为实际参数的值，简称实参，实参的位置是函数的调用处
print('result1=', result1)
result2 = calc(b=30, a=20)   # 左侧的变量的名称称为 关键字参数，在定义处找到名字相同的参数赋值
print('result2=', result2)

输出结果：

a= 10
b= 20
-------------
result1= 30
a= 20
b= 30
-------------
result2= 50

 

函数调用的参数传递内存分析图：

def fun(arg1, arg2):
    print('arg1=', arg1)
    print('arg2=', arg2)
    arg1 = 100
    arg2.append(55)
    print('--------参数修改后-----------')
    print('arg1=', arg1)
    print('arg2=', arg2)


n1 = 11
n2 = [22, 33, 44]
print('n1=', n1)
print('n2=', n2)
print('------------------')
fun(n1, n2)  # 位置传参，arg1,arg2是函数定义处的形参，n1,n2是函数调用处的实参，即实参和形参的名称可以不一致
print('n1=', n1)
print('n2=', n2)

输出结果：

n1= 11
n2= [22, 33, 44]
------------------
arg1= 11
arg2= [22, 33, 44]
--------参数修改后-----------
arg1= 100
arg2= [22, 33, 44, 55]
n1= 11
n2= [22, 33, 44, 55]

 

3、函数的返回值

  • 如果函数没有返回值（函数执行完毕之后，不需要给调用处提供数据），return可以省略不写；
  • 函数的返回值，如果是1个，直接返回类型；
  • 函数的返回值，如果是多个，返回的结果为元组；

 

# 1）函数没有返回值,return可以省略不写
def fun1():
    print('没有返回值')

fun1()

# 2）函数的返回值，如果是1个，直接返回类型
def fun2():
    return '只有1个返回值'

result = fun2()
print(result)

# 3）函数的返回值，如果是多个，返回的结果为元组。
def fun3():
    return '第1个返回值', '第2个返回值'

result = fun3()
print(result)

输出结果:

没有返回值
只有1个返回值
('第1个返回值', '第2个返回值')

 

函数返回多个值时，结果为元组

# 函数返回多个值时，结果为元组
def fun(num):
    odd = [] # 存奇数
    even = []  # 存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd, even


lst = [1, 2, 3, 4, 5, 6]
res = fun(lst)
print('返回多个值时，结果为元组:', res)  # ([1, 3, 5], [2, 4, 6])

# 访问函数返回的多个值，元组
for i in range(len(res)):
    if i == 0:
        print('-------奇数列表：--------')
    elif i == 1:
        print('-------偶数列表：-------')
    for item in res[i]:
        print(item)

输出结果：

返回多个值时，结果为元组: ([1, 3, 5], [2, 4, 6])
-------奇数列表：--------
1
3
5
-------偶数列表：-------
2
4
6

 

4、函数的参数定义

1）函数定义默认值参数

  • 函数定义时，给形参设置默认值，只有与默认值不符的时候，才需要传递实参；
# 函数定义默认值参数
def fun(a, b=10):  # b为默认值参数
    print('a=', a, 'b=', b)

# 函数的调用
fun(100)    # 只传一个参数，b采用默认值，a= 100 b= 10
fun(20, 30)    # 30将默认值10替换，a= 20 b= 30

# print函数的end为默认值参数，end='\n'
print('hello', end='\t')
print('world')  # hello	world

 

2）个数可变的位置参数

  • 定义函数时，无法事先确定传递的位置实参的个数时，使用可变的位置参数；
  • 使用 * 定义个数可变的位置形参；
  • 结果为一个元组；
# 定义个数可变的位置参数,结果是元组
def fun(*args):
    print(args)
    print(args[0])

fun(10)  # (10,)
fun(1, 2, 3, 4)  # (1, 2, 3, 4)

输出结果：

(10,)
10
(1, 2, 3, 4)
1

 

3）个数可变的关键字形参

  • 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参；
  • 使用 ** 定义个数可变的关键字形参；
  • 结果为一个字典；
# 定义个数可变的关键字形参,结果是字典
def fun(**args):
    print(args)
    print(args['a'])  # 1

fun(a=1)  # {'a': 1}
fun(a=1, b=2, c=3)  # {'a': 1, 'b': 2, 'c': 3}

输出结果：

{'a': 1}
1
{'a': 1, 'b': 2, 'c': 3}
1

 

4）传入多个个数可变的参数

  • 1）定义多个个数可变的位置参数，报错；个数可变的位置参数，只能是1个；
  • 2）定义多个个数可变的关键字形参，报错；个数可变的关键字形参，只能是1个；
  • 3）定义一个函数，既有个数可变的位置参数，又有个数可变的关键字形参：
    • 3.1）个数可变的关键字形参在前，报错；
    • 3.2）个数可变的位置参数在前，可运行通过；
    • 即个数可变的位置参数，要在个数可变的关键字形参之前；
       
# 1）定义多个个数可变的位置参数，报错
def fun(*args, *a):  # 报错,SyntaxError: invalid syntax
    pass

# 2）定义多个个数可变的关键字形参，报错
def fun(**args, **a):  # 报错,SyntaxError: invalid syntax
    pass

# 3）定义一个个数可变的位置参数，一个个数可变的关键字形参
# 3.1）个数可变的关键字形参在前，报错
def fun(**args, *a): # 报错,SyntaxError: invalid syntax
    pass

# 3.2）个数可变的位置参数在前，可运行通过
def fun(*args, **a):
    pass

 

5、函数的参数总结

 

 

1）将序列中的每个元素，都转换为位置实参；使用*序列对象

# 将序列中的每个元素，都转换为位置实参
def fun(a, b, c):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('----------------')

# 函数的调用
fun(1, 2, 3)  # 函数调用时的参数传递，称为位置传参
lst = [4, 5, 6]
# fun(lst)  # 直接传列表，会报错，TypeError: fun() missing 2 required positional arguments: 'b' and 'c'
fun(*lst) # 在函数调用时，将列表的每个元素，都转换为位置实参传入

输出结果：

a= 1
b= 2
c= 3
----------------
a= 4
b= 5
c= 6
---------------- 

 

2）将字典中的每个键值对，都转换为关键字实参；使用**字典对象

# 将字典中的每个键值对，都转换为关键字实参
def fun(a, b, c):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('----------------')

# 函数的调用
fun(a=10, b=20, c=30)  # 关键字实参
dic = {'a': 40, 'b': 50, 'c': 60}
# fun(dic)  # 直接传入字典，会报错，TypeError: fun() missing 2 required positional arguments: 'b' and 'c'
fun(**dic)  # 在函数调用时，将字典中的键值对，都转换为关键字实参

输出结果：

a= 10
b= 20
c= 30
----------------
a= 40
b= 50
c= 60
----------------

 

3）举例

# 函数定义和调用
def fun1(a, b=3):  # 函数定义默认值参数
    print(a,b)

def fun2(*args):  # 个数可变的位置参数
    print(args)

def fun3(**args):  # 个数可变的关键字形参
    print(args)

fun1(1, 2)
fun2(10, 20, 30)
fun3(a=100, b=200, c=300, d=400)

输出结果：

1 2
(10, 20, 30)
{'a': 100, 'b': 200, 'c': 300, 'd': 400}

 

# 函数定义和调用
def fun4(a, b, c, d):
    print('a', a)
    print('b', b)
    print('c', c)
    print('d', d)
    print('--------------')

# 调用fun4()函数
fun4(1, 2, 3, 4)  # 位置实参传递
fun4(a=1, b=2, c=3, d=4)  # 关键字实参传递
fun4(1, 2, c=3, d=4)  # 前2个参数，是位置实参传递；而c,d是关键字实参传递

 

4）函数定义时，参数使用了*，在函数调用时，*之后的参数只能使用关键字实参传递

需求：c,d只能使用关键字实参传递

# 函数定义和调用
def fun4(a, b, *, c, d):  # *后面的形参，在函数调用时，c,d只能使用关键字实参传递
    print('a', a)
    print('b', b)
    print('c', c)
    print('d', d)
    print('--------------')

# 调用fun4()函数
# fun4(1, 2, 3, 4)  # 位置实参传递，会报错，TypeError: fun4() takes 2 positional arguments but 4 were given
fun4(a=1, b=2, c=3, d=4)  # 关键字实参传递，运行成功
fun4(1, 2, c=3, d=4)  # 前2个参数，是位置实参传递；而c,d是关键字实参传递，运行成功

 

5）函数定义时的形参的顺序问题

# 函数定义时的形参的顺序问题
def fun5(a, b, *, c, d, **args):
    pass

def fun6(*args1, **args2):
    pass

def fun7(a, b=10, *args1, **args2):
    pass

 

6、变量的作用域

  • 程序代码能访问该变量的区域；
  • 根据变量的有效范围，可分为局部变量，全局变量；
    • 局部变量，在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会变为全局变量；
    • 全局变量，函数体外定义的变量，可作用于函数内外；

 

1）局部变量

# 变量的作用域
# 局部变量
def fun(a, b):  # a,b为函数的形参，作用范围也是函数内部，相当于局部变量；
    c = a + b  # c是局部变量，在函数体内定义的变量；
    print(c)

# print(c)  # 报错，NameError: name 'c' is not defined
# print(a)  # 报错，NameError: name 'a' is not defined

 

2）全局变量

# 全局变量
name = '张老师'  # name是全局变量，作用范围为函数内部和外部都可以使用
print(name)

def fun():
    print(name)

fun()

输出结果：

张老师
张老师

 

函数体内的局部变量，转为全局变量，使用global

# 局部变量转为全局变量
def fun():
    global age  # 局部变量转为全局变量
    age = 10
    print(age)

fun()
print(age)  # age为全局变量，函数体外面也可以使用了

 

7、递归函数

  • 如果一个函数的函数体内调用了该函数本身，这个函数就是递归函数；
  • 递归的组成部分：递归调用，递归终止条件；
  • 递归的调用过程：
    • 每递归调用一次函数，都会在栈内存分配一个栈帧；
    • 每执行完一次函数，都会释放相应的空间；
  • 递归的优缺点：
    • 缺点：占用内存多，效率低下；
    • 优点：思路和代码简单；

 

使用递归来计算阶乘

fac(6)6! = 6x5x4x3x2x1
6*fac(5)6! = 6x5!
5*fac(4))5! = 5x4!
4*fac(3)4! = 4x3!
3*fac(2)3! = 3x2!
2*fac(1)2! = 2x1!
fac(1)1! = 1
# 使用递归来计算阶乘
def fac(n):
    if n == 1:
        return 1
    else:
        return n * fac(n-1)

res = fac(6)
print(res)  # 720

 

8、斐波那契数列

数列：0、1、1、2、3、5、8、13、21、34、……

斐波那契数列，以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 3，n ∈ N*）

# 斐波那契数列
def fib(n):
    if n == 1:
        return 0
    elif n == 2:
        return 1
    else:
        return fib(n-1) + fib(n-2)

# 输出斐波那契数列第7位上的数字
res = fib(7)
print(res)

# 输出斐波那契数列前7位上的数字
lst = []
for i in range(1, 8, 1):
    lst.append(fib(i))

print(lst)

输出结果：

8
[0, 1, 1, 2, 3, 5, 8]

 

9、总结

 

nikeylee
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
02-python 基础语法知识-04-异常与错误处理
01-20
文章目录02-python 基础语法知识-04-异常与错误处理什么是异常异常发生时会发生什么？如何处理异常如何自己主动抛出一个异常异常的分类自定义异常如何安装 第三方的包？查看第三方包 自定义的异常总结参考文档 02-...
python求定积分：quad函数
微小冷的学习笔记
07-06 6402
`quad`是`scipy.integrate`中最常用的积分函数。
python 函数教程
dudu3332的博客
12-07 738
函数 定义函数 函数function，通常接受输入参数，并有返回值。 它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。 In[1]: def add(x, y): """Add two numbers""" a = x + y return a 函数通常有一下几个特征： 使用def关键词来定义一个函数。 def后面是函数的名称，括号...
python中quad_python用quad、dblquad实现一维二维积分的实例详解
weixin_39914499的博客
12-05 313
背景：python函数库scipy的quad、dblquad实现一维二维积分的范例。需要注意dblquad的积分顺序问题。代码：import numpy as npfrom scipy import integratedef half_circle(x):"""原心：(1,0),半径为1半圆函数：(x-1)^2+y^2 = 1"""return (1-(x-1)**2)**0.5"""梯形法求积分...
python中quad_python scipy integrate.quad用法及代码示例
weixin_39830175的博客
12-05 5112
计算定积分。使用Fortran库QUADPACK中的技术将func从a集成到b(可能是无限间隔)。参数：func：{function, scipy.LowLevelCallable}集成的Python函数或方法。如果func接受许多参数，则会沿与第一个参数对应的轴进行积分。如果用户希望改善集成性能，则f可以是scipy.LowLevelCallable带有以下签名之一：double func(do...
Python--curve_fit和quad学习笔记
最新发布
DOUBISSS的博客
04-08 391
【代码】Python--curve_fit和quad学习笔记。
Python程序设计基础语法-函数的创建和调用.pptx
11-03
Python程序设计基础语法中的函数是编程中不可或缺的部分，它们提供了代码重用和模块化的能力，使得复杂的任务变得简单且易于管理。在Python中，函数的创建和调用是编程的基本操作。 首先，让我们深入理解创建函数的...
Python-Python函数-教学设计.docx
06-11
本教学设计针对Python函数这一核心概念，旨在帮助学生在已有的Python基础知识上，进一步提升编程技能。学生应已掌握了Python的基础语法和三种逻辑结构：顺序、条件分支和循环。然而，他们在逻辑思维和基础知识的扎实...
python之函数架构-搭建房子的砖
12-21
首先，定义一个函数的基本语法如下： ```python def function_name(param1, param2, ...): # 函数体 # ... return [expression] ``` 函数定义以`def`关键字开始，紧接着是函数名称，然后是圆括号内的参数列表，...
scipy/python quad()数值积分
Mr_Cat123的博客
07-26 1万+
一维积分quad()函数的用法 对(1-x**2)**0.5进行积分 def f(x): return (1-x**2)**(1/2) w, err = integrate.quad(f,-1,1) print(w,err) 1.5707963267948983 1.0002354500215915e-09 上面 (1-x**2)**(1/2) 非要定义成一个函数...
python用quad、dblquad实现一维二维积分的实例详解
01-02
背景： python函数库scipy的quad、dblquad实现一维二维积分的范例。需要注意dblquad的积分顺序问题。 代码： import numpy as np from scipy import integrate def half_circle(x): 原心：(1,0),半径为1 半圆函数：(x-1)^2+y^2 = 1 return (1-(x-1)**2)**0.5 梯形法求积分：半圆线和x轴包围的面积 N = 10000 x = np.linspace(0,2,num=N)#,endpoint=True) dh = (2
python中quad_杨桃Python基础教程第5章：Python数据类型（Quad）,的,四元组
weixin_39670849的博客
12-05 480
本人CSDN博客专栏：https://blog.csdn.net/yty_7Github地址：https://github.com/yot777/Python-Primary-Learning5.6六种数据类型之四：Tuple(元组)元组(tuple)与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里，元素之间用逗号隔开。元组中的元素类型可以不相同。# 举例1>>> a...
Python 微积分数值和符号计算（计算机代数）
跨学科知识视角展现
04-17 767
微积分是对连续变化的数学研究，就像几何学是形状的研究，代数是算术运算的推广研究一样。
python使用scipy.integrate模块进行数值积分：一维积分quad()，二维积分dblquad()
热门推荐
void_xinyue的博客
06-28 2万+
基本介绍 一般而言，使用求解微积分可以分为两大类：符号积分（即求出解析解）和数值积分（即求出数值解）。在计算机的处理当中，数值解往往更有意义。 使用python求解数值解的模块：scipy.integrate；常用的有一维积分方法quad()和二维积分quad()。本文也是主要介绍这两种方法的使用。 一维数值积分 from scipy import integrate # 基本使用格式：integ...
在Python中求解定积分scipy.integrate.quad()方法
liujingwei8610的专栏
11-11 2762
在Python中求解定积分scipy.integrate.quad()方法
Python日记（6）——数值积分
weixin_56960596的博客
03-09 1859
Python日记（6）——数值积分 每天做一个Python小练习，顺便记录一些小技巧。 在做化学实验中，一般测得的数据都是离散的，所以编写了一些程序来计算离散数据的积分。 首先，粗讲一下已知函数式的数值积分。 以下面的式子举例 这里需要用到numpy 简单地导入以下 import numpy as np 首先，表达出要积分的函数表达式 y = np.cos(2*np.pi*x)*np.exp(-x)+1.2 原始方法 就是把函数积分化成很多且宽很小的矩形，再求所有矩形的面积总和，便可以得到积分的值。这
四种使用quad积分函数的方法
wangjie36的博客
05-07 7901
示例：求y=2x^4在（1,2）的积分 方法一：fun使用inline函数 y1=inline('2*x.*x.*x.^2','x');%注意.号，及'x'关于x的函数 y=quad(y1,1,2) 方法二：fun使用sym表达式 利用syms，需要使用subs函数替换一下 syms phy; y1=2*phy*phy*phy^2; %不需要.号 y=@(x) subs(y1,phy,x...
python用quad、dblquad实现一维二维积分范例
潜水的飞鱼baby
09-25 9568
背景： python函数库scipy的quad、dblquad实现一维二维积分的范例。需要注意dblquad的积分顺序问题。 代码： import numpy as np from scipy import integrate def half_circle(x): """ 原心：(1,0),半径为1 半圆函数：(x-1)^2+y^2 = 1 """
Python基础：函数篇 - 功能复用与实战应用
在Python基础语法知识的第02部分中，我们主要探讨了函数这一核心概念。函数是编程中的一种重要工具，它使得代码组织更为模块化，提高代码的可重用性和可读性。函数可以理解为封装了一组执行特定任务的指令集合，通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值