【python】函数的定义与操作

1. 函数的定义与使用

函数概念：

函数定义的语法：函数体缩进用tab
def 函数名([参数1,参数2....]):
    函数体（实现功能）
    [return]

函数的调用语法：
函数名([参数值1，参数值2....])

# 案例1：自我介绍的函数，并调用函数
print(00000)
def introduction():
    print('''----自我介绍----
    姓名：{}
    班级：{}
    地点：{}
    '''.format('zs','211','北京'))

print(111)
print(22)
introduction()
print(3333)
print(444)

2. 函数返回值

return返回值
作用：
    1：作为函数体结束的标志
    2：函数返回值的关键点
函数是一种自带返回值，没有return,return后面没有任何值，默认返回None,
return不是必要部分，return关键字可以省略
return是函数体的结束标志，return后面的语句块不会执行，函数认为到return就结束了
return有返回值时，在调用函数时需要用一个变量来接收
return后面没有任何值，则默认返回None

# 1.return是函数体的结束标志，在return后面的代码不会被执行
def introduction():
    print('''----自我介绍----
    姓名：{}
    班级：{}
    地点：{}
    '''.format('zs','v211','北京'))
    return
    # print('1111')
    # print('222')
    # print('333')
#
introduction()
print(12345)
print('1',introduction())

# 2.return返回值，可以是变量和表达式，return后面什么都没有，则返还None
def add():
    num1 = 10
    num2 = 20
    sum = num1 + num2
    return sum

res = add()
print('2',res)

print('3',add())

# 返回多个值
def add():
    num1 = 10
    num2 = 20
    sum = num1 + num2
    return sum,num1,num2

res = add()
print(res) #有多个返回值，用一个变量接受，存储在一个元组中

res1,res2,res3 = add()
print(res1,res2,res3)

# 返回值可以是表达式：数据类型+运算符  1+1
def add():
    num1 = 10
    num2 = 20
    return num1+num2,num1+num1

res = add()  #(30, 20)
print(res)
# 依次拿到返回的数据值
# 1：元组的取值
num1 = res[0]
num2 = res[1]
print(num1,num2)
#2：for遍历
for i in res:
    print(i)
# 3：解包
print(*res)

num1,*num2 = 1,2,3,4,5
print(num1)
print(num2) #打包

res1,res2 = add()
print(res1,res2)

3. 函数的参数

函数定义的语法：函数体缩进用tab
def 函数名([参数1,参数2....]):
    函数体（实现功能）
    [return]
函数的调用语法：
函数名([参数值1，参数值2....])

形参：定义函数时，括号里面的参数就是形参，如7行中：参数1,参数2....
实参：调用函数时，括号里面的实际参数值，如12行中：参数值1，参数值2....
传参：是一个过程，将调用函数是的实际参数值传递给定义函数中的形参，如：参数值1--》参数1，参数值2--》参数2

函数的参数
位置参数：调用函数中传递的实参值，依次按照定义函数中形参值的顺序赋值
指定参数：在调用函数中的参数列表里面，写明参数名=参数值，这个顺序跟位置没有关系
缺省参数：在定义函数的时候，在参数列表中给参数赋了默认值
不定长参数：*和**可以不定长度的实参

# 1-位置参数：调用函数中传递的实参值，依次按照定义函数中形参值的顺序赋值
def introduction(name,classroom,addr):
    print('''----自我介绍----
    姓名：{}
    班级：{}
    地点：{}
    '''.format(name,classroom,addr))

introduction('zs','v211','北京')
introduction('v209','ls','上海')  # 值的位置变化了，name这个函数的输出结果也有可能变量


# 2.指定参数：在调用函数中的参数列表里面，写明参数名=参数值，这个顺序跟位置没有关系
def introduction(name,classroom,addr):
    print('''----自我介绍----
    姓名：{}
    班级：{}
    地点：{}
    '''.format(name,classroom,addr))

introduction(addr='北京',classroom='v211',name='zs')

# 3.位置+指定参数:指定参数一定要放在最后面，有多个指定参数，依次往后面放
# 一定要注意，指定参数必须放在最后面
def introduction(name,classroom,addr):
    print('''----自我介绍----
    姓名：{}
    班级：{}
    地点：{}
    '''.format(name,classroom,addr))

introduction('zs',addr='北京',classroom='v211')
introduction(name='zs','v211',addr='北京')  #SyntaxError: positional argument follows keyword argument

# 4.缺省参数：在定义函数的时候，在参数列表中给参数赋了默认值
# 缺省参数一定要放在最后，传值时可给可不给，不给用默认值，给了用给定的值

# 注意：
#  1：形参中没有给定值的参数，在调用函数的时候一定要传值
# 2：形参中有默认值的参数一定要放在最末尾
def introduction(name,classroom='v211',addr='长沙'):
    print('''----自我介绍----
    姓名：{}
    班级：{}
    地点：{}
    '''.format(name,classroom,addr))

# introduction('zs','211')
introduction('zs','209','北京')


# 5.不定长参数：*和**可以不定长度的实参
# *args,可以接受多个参数，多个参数值存在一个元组中，调用函数时只能是位置传参
#**args，可以里接受多个参数，多个参数值存在一个字典中，调用函数时只能是指定传参

num1,*num2 = 1,2,3,4,5
print(num1)
print(num2) #打包

def add(*args):
    print(args)#元组
    print(type(args))

add(1,2,3)
add(1,2,3,4)
add(1,2,3,4,5,6,7)
add(num1=1,num2=2,num3=3)  #不接受指定位置的传参


def add2(**kwargs):#keyword
    print(kwargs)  #字典{key:value}
    print(type(kwargs))
add2(a=10,b=20)
add2(a=10,a=20)  #报错的原因：字典的key要求是唯一的
add2(10,20)  #不接受位置位置的传参


# 不定长参数的计算与运用
# 1-计算传入多个数字之和
def add(*args):
    print(args)
    sum = 0
    for i in args:
        sum += i
    return sum

# res = add(10,20,30,100,200,300)
# print(res)

lst= [10,20,30]
res2 = add(*lst)
print(res2)

# 2-根据传入的数据进行自我介绍的输出
def introduction(**kwargs):
    # print(kwargs)  #kwargs={'name': 'zs', 'classroom': '211', 'addr': '长沙'}
    print('''----自我介绍----
    姓名：{}
    班级：{}
    地点：{}
    '''.format(kwargs['name'],kwargs['classroom'],kwargs['addr']))  #字典取值

introduction(name='zs',classroom='211',addr='长沙')

4. 函数的注释与嵌套

'''函数注释'''
def add(*args):
    '''
    这是一个实现多个数据相加的和的函数
    :param args: 接受多个数据，数据类型只支持数字类型，传值支持位置参数，eg:add(10,20,30)
    :return: sum:返回数据相加的结果
    '''
    print(args)
    sum = 0
    for i in args:
        sum += i
    return sum

# 查看函数的注释信息
print(add.__doc__)
print(input.__doc__)


'''函数嵌套'''
# 1.函数的嵌套调用
def fun1():
    print(1111)

def fun2():
    print(222)
    fun1()  #调用fun1()

fun2()  #调用fun2()  ???

# 2.函数的嵌套定义与调用
def fun2():
    print(222)
    def fun3():#嵌套定义函数
        print(666)
    print(444)
    fun3()  #嵌套调用函数
    print(888)

print('开始')
fun2()
print('结束')

5. 内置函数

数学函数
    abs():求绝对值
    divmod()：返还商和余数
    round():四舍五入
    pow()：幂次方
    sum():求和
    min()：最小值
    max()：最大值

res = abs(-100)
print(res)
10 / 3
print(*divmod(10,3))
print(round(3.145,2))
print(pow(10,3))

# sum() 求和
lst = [10,20,30]
print(sum(lst))  #按住ctrl+鼠标点击函数

# min()：最小值
print(min(lst))
print(min(100,200,300))

# max()：最大值
print(max(lst))
print(max(100,200,300))