Python基础学习—函数的调用

最新推荐文章于 2022-12-07 23:55:13 发布

安全攻防渗透

最新推荐文章于 2022-12-07 23:55:13 发布

阅读量863

点赞数

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/xingyu860990/article/details/115059753

版权

python 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Python函数基础

Python函数:

基本上所有的高级语言都支持函数，Python也不例外。Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。
函数就是最基本的一种代码抽象的方式。

函数基础

概念:

在编写程序的过程中，有某一功能代码块出现多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数。

想一想，下面这段代码打印一个美女。如果在程序中不同地方打印美女呢？那是不是没一个地方都要写一段？要解决这种代码重复的问题，函数上场了！

函数定义：

def + 关键字 + 小括号 + 冒号+ 换行缩进 + 代码块定义一个函数:

def 函数名():
    代码块

函数调用：
函数名加()即可调用该函数

函数说明文档：
函数内容的第一行可以用字符串进行函数说明

# print('小张的身高是%f'%1.73)
# print('小张的体重是%f'%160)
# print('小张的爱好是%s'%'唱歌')
# print('小张的身高是%s'%'计算机信息管理')
#处理其他的逻辑信息
# 多次去打印出小张的信息
print('---------------多次输出相同的信息---------------------')
# print('小张的身高是%f'%1.73)
# print('小张的体重是%f'%160)
# print('小张的爱好是%s'%'唱歌')
# print('小张的专业是%s'%'计算机信息管理')
# 针对上面的场景 就需要进一步的去优化代码【方案：封装函数】
# 函数的定义
# def 函数名(参数列表):0-n 个
#     代码块

def printInfo():
    '''
    这个函数是用来打印个人信息的 是对小张信息显示的组合
    :return:
    '''
    # 函数代码块
    print('小张的身高是%f' % 1.73)
    print('小张的体重是%f' % 160)
    print('小张的爱好是%s' % '唱歌')
    print('小张的专业是%s' % '计算机信息管理')
    pass
#函数的调用
# printInfo() #函数的调用
# printInfo() #多次调用
# printInfo()
# printInfo()
# printInfo()
# print('我是其他的代码块...')
# 进一步的去完善这样的需求【输出不同人的信息】 方案：通过传入参数来解决
def printInfo(name,height,weight,hobby,pro): #形式参数
    # 函数代码块
    print('%s的身高是%f' %(name,height))
    print('%s的体重是%f' %(name,weight))
    print('%s的爱好是%s' %(name,hobby))
    print('%s的专业是%s' %(name,pro))
    pass

# 调用带参数的信息
printInfo('小李',189,200,'打游戏','咨询师') #实参
print('------------------带参数的调用---------------------------')
printInfo('peter',175,160,'码代码','计算机应用')

函数参数

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了
Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码

缺省参数

缺省参数，在调用函数时如果没有传参数，那么会使用定义函数时给的缺省值。
缺省参数必须在参数列表的最后面，否则会报错。

不定长参数

一个函数有时候会处理比当初声明的参数要多，这就是不定长参数，定义函数时不用声明参数名。加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

引用参数

Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

# 参数的分类：
# 必选参数、默认参数[缺省参数]、可选参数、关键字参数
# 参数:其实就是函数为了实现某项特定的功能,进而为了得到实现功能所需要的数据
# 为了得到外部数据的
# 1 必选参数
def sum(a,b): #形式参数：只是意义上的一种参数，在定义的时候是不占内存地址的
    sum=a+b
    print(sum)
    pass
# 函数调用  在调用的时候必选参数 是必须要赋值的
# sum(20,15) #20 15 实际参数：实参，实实在在的参数，是实际占用内存地址的
# sum(15) #不能这样写的,
# 2:默认参数【缺省参数】 始终存在于参数列表中的尾部
# def sum1(a,b=40,c=90):
#     print('默认参数使用=%d'%(a+b))
#     pass
# # 默认参数调用
# sum1(10) #在调用的时候如果未赋值，就会用定义函数时给定的默认值
# sum1(2,56)
#可变参数(当参数的个数不确定时使用，比较灵活
# def getComputer(*args): #可变长的参数
# #     '''
# #     计算累加和
# #     :param args: 可变长的参数类型
# #     :return:
# #     '''
# #     # print(args)
# #     result=0
# #     for item in args:
# #         result+=item
# #         pass
# #     print('result=%d'%result)
# #     pass
# #
# # getComputer(1)
# # getComputer(1,2)
# # getComputer(1,2,3)
# # getComputer(1,2,3,4,5,6,7,8)

# 关键字可变参数  0-n
# ** 来定义
# 在函数体内 参数关键字是一个字典类型 key是一个字符串
def keyFunc(**kwargs):
    print(kwargs)
    pass
# 调用
# keyFunc(1,2,3) 不可以传递的
dictA={"name":'Leo',"age":35}
# keyFunc(**dictA)
# keyFunc(name='peter',age=26,)
# keyFunc()
# 组合的使用
# def complexFunc(*args,**kwargs):
#     print(args)
#     print(kwargs)
#     pass
# # complexFunc(1,2,3,4,name='刘德华')
# complexFunc(age=36)

# def TestMup(**kwargs,*args): #不符合要求的
#     '''
#     可选参数必须放到关键字可选参数之前
#     可选参数：接受的数据是一个元组类型
#     关键字可选参数：接受的数据是一个字段类型
#     :param kwargs:
#     :param args:
#     :return:
#     '''
#     pass

函数返回值

所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果
举个生活中例子：
我给小明10块钱，让他给我买包烟。这个例子中，10块钱是我给小明的，就相当于调用函数时传递到参数，让小明买烟这个事情最终的目标是，让他把烟带回来然后给w我，，，此时烟就是返回值
你想要组装一台电脑，你将你的电脑配置参数传给电脑店老板，电脑店老板最后得返回一台组装好的电脑给你。你调用电脑店老板这个方法去帮你组装电脑，他总得给你返回一台组装好的电脑吧，这台电脑就是返回值。
程序中也需要返回值，比如用调用函数去计算两个数的和，最后得返回两个数相加的结果给调用者。

如果函数需要返回多个结果呢？
将要返回的值用逗号隔开。最终会返回一个包含所有返回值的元组。

# 函数返回值
# 概念：函数执行完以后会返回一个对象，如果在函数的内部有return 就可以返回实际的值,否则返回None
# 类型：可以返回任意类型，返回值类型应该取决于return后面的类型
# 用途：给调用方返回数据
# 在一个函数体内可以出现多个return值：但是肯定只能返回一个return
# 如果在一个函数体内 执行了return,意味着函数就执行完成退出了，return后面的代码语句将不会执行
def Sum(a,b):
    sum=a+b
    return sum#将计算的结果返回
    pass

# rs=Sum(10,30) #将返回值赋给其他的变量
# print(rs) #函数的返回值返回到调用的地方
def calComputer(num):
    li=[]
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        pass
    li.append(result)
    return li
    pass

# 调用函数
# value=calComputer(10)
# print(type(value)) #value 类型
# print(value)
def returnTuple():
    '''
    返回元组类型的数据
    :return:
    '''
    # return 1,2,3
    return {"name":"测试"}
    pass

A=returnTuple()
print(type(A))

函数嵌套调用

函数可以嵌套调用，即在一个函数内部调用另外一个函数。
内层函数可以访问外层函数中定义的变量，但不能重新赋值（rebind）

# 函数嵌套
def fun1():
    print("--------------fun1 start-------------------")
    print("--------------执行代码省略-------------------")
    print("--------------fun1 end-------------------")
    pass

def fun2():
    print("--------------fun2 start-------------------")
    # 调用第一个函数
    fun1()
    print("--------------fun2 end-------------------")
    pass

fun2() #调用函数2

# 函数的分类：根据函数的返回值和函数的参数
# 有参数无返回值的
# 有参数又返回值的
# 无参数又返回值的
# 无参数无返回值的