函数的应用

1：函数的定义和调用

import  random
def sum_random():   ##定义一个函数
    s=[]
    for i in range(10):
        num = random.randint(1,20)
        s.append(num)
    print(s)
sum_random()  ##进行函数的调用

[10, 2, 13, 11, 7, 18, 17, 9, 5, 20]

2：带参数的函数调用

import random
s=[]
def sum_random(number):   ###此处的number为形参
    for i in range(number):
        ran = random.randint(1,10)
        s.append(ran)
    print(s)
sum_random(10)   ###在调用函数的时候传入的参数为实参

[1, 8, 6, 3, 5, 10, 10, 3, 3, 9]

 

3：利用函数的调用求两个数值的和:

def add_sum(a,b):
    sum = a+b
    print(sum)
add_sum(2,4)

6

4：函数中参数的应用

def user(users,paword):  ###形参
    username = 'yz'
    password = '123'
    if username == users and password == paword:
        print("登录成功")
    else:
        print("登录失败")
users = input("请输入用户名")
pasword = input("请输入密码")
user(users,pasword)  ##传输的实参

5：判断某个列表或者元组中的数字的最大值

def max_num(num):
    max_num1=num[0]
    for i in num:
        if i > max_num1:
            max_num1 = i
    print(max_num1)
list1 = [1,3,4,5]
max_num(list1)
tuple1 = (2,4,6,7,9)
max_num(tuple1)

5
9

6：isinstance()函数应用

isinstance() 函数用来判断，你传入的数据类型是什么类型的，返回值是布尔类型的。

type() 函数只能用来查看某个数据是什么类型的。

print(isinstance(2,int))            ###该函数可以传递两个参数，第一个参数为你想判断的数据，第二个参数为你觉得该数据的类型，返回值为布尔类型
print(isinstance([1,2,3],list))
print(isinstance('sac',list))
print(isinstance('sac',str))

True
True
False
True

7：给你传入的数据使用reverse方法进行排序

注意：reverse方法只能给列表类型的数据进行排序，所以次数要进行一个列表类型的判断（使用的就是isinstance()函数 ）

def fun(type):
    if isinstance(type,list):
        type.reverse()
        print(type)
    else:
        print("传入的数据类型有误，不是列表类型的")
list1 = [1,3,5,2,7,6,4]
list2 = (1,3,5,6,7,3)
fun(list1)
fun(list2)

[4, 6, 7, 2, 5, 3, 1]
传入的数据类型有误，不是列表类型的

8：可变参数

*args   可以实现在后面传递实参的时候传递多个参数

def fun(*args):
    print(args)
fun()
fun(1,2,4)
fun(2,4,5,6)

()
(1, 2, 4)
(2, 4, 5, 6)

注意：当传递多个参数的时候，一定要注意将可变参数放在最开始，剩下的发在后面

def fun(name,*args):  ##可变参数一定要放在后面.
    print(name)
    print(args)
    sum =0
    for i in args:
        sum += i
    print('学生%s计算的结果为%d' %(name,sum))

fun('飞飞',1,3,4,5,6)  ##在进行传递参数的时候，也要讲‘飞飞’这个不可变类型放在前面

=================================================

def fun(name,age,*args):  
    print(name)
    print(age)
    print(args)
    sum =0
    for i in args:
        sum += i
    print('学生%s计算的结果为%d' %(name,sum))

fun('飞飞',1,3,4,5,6)  ##第一个值给name，第二个值给age，剩下的给值都给args


飞飞
1
(3, 4, 5, 6)
学生飞飞计算的结果为18
===============================================
def fun(name,age,*args):
    print(name)
    print(age)
    print(args)
    sum =0
    for i in args:
        sum += i
    print('学生%s计算的结果为%d' %(name,sum))

fun('飞飞')   ###此处需要注意，因为我前面的实参中有两个参数不是不可变参数是一定要进行传值的，可变参数*args可以不传值。

TypeError: fun() missing 1 required positional argument: 'age'





===============================================

这个其实和之前说的给参数赋值是一样的
a,*b = 1,2,3,4,5  ##将1赋值给a，其余的赋值给b

a,*b = 1,2,3,4,5,6
print(a)
print(b)

1
[2, 3, 4, 5, 6]

a,*b = (1,2,3),2,3,4,5,6
print(a)
print(b)

(1, 2, 3)
[2, 3, 4, 5, 6]

**kwargs的使用（只能接受key=value型的关键字参数）

def fun(**kwargs):  ###  **kwargs使用说明，只要外面给函数传值，必须是key=value的形式
    print(kwargs)
fun(a=1,b=2,c=3)


{'a': 1, 'b': 2, 'c': 3}   ###返回值则是字典的形式

def fun(**kwargs):
    print(kwargs)
fun()   ##如果没有传值则返回一个空字典

{}


dict1 = {'001':('蔡徐坤',20),'002':('杨幂',30),'003':('王源',20),'004':('小胡',23)}
def fun(**kwargs):
    print(kwargs)
fun(**dict1)   ###dict1必须是一个字典的形式。

 

9：关键字参数

关键字参数 key=value 的形式，作用是指定形参中某个参数的默认值

def fun(a,b=10):
    sum = a+b
    print(sum)

fun(3)  ###此时我只需要传递一个参数，a=3,b默认为10


13

如果我已经指定了一个关键字参数，但是我在传参的时候依旧给他传了值，此时我传进去的实参就会将我关键字参数里面的默认值覆盖掉。

def fun(a,b=10):
    sum = a+b
    print(sum)
fun(3,4)

7

def fun(a,b=10,c=5):
    print(a,b,c)
    sum = a+b
    print(sum)
fun(3,4)   ###此时默认的就是将第二个关键字参数b给覆盖掉，因为实参在传递参数的时候，默认和形参都是一一对应的关系。


3 4 5
7

问题？如果我在传递参数的时候就是其实第二个实参是想传递为c的，让b保持默认值，此时我应该怎么做呢？
此时我们就需要在传递实参的时候就指定我的c=4

def fun(a,b=10,c=5):
    print(a,b,c)
    sum = a+b
    print(sum)
fun(3,c=4)   ##此时就可以了，指定将c变成4，b=10保持不变


3 10 4
13

10：传递的参数为字典（顺便复习一下前面字典的用法）

dict1 = {'001':('蔡徐坤',20),'002':('杨幂',30),'003':('王源',20),'004':('小胡',23)}
def fun(person):
    if isinstance(person,dict):  ###判断传入的数据类型是否为字典类型
        value=dict1.values()     ###去除字典的value值并赋值给value，应该是以列表类型的，列表里面是元组
        for name,age in value:   ###遍历列表中的每个元组
            print('{}的年龄是{}岁'.format(name,age))
fun(dict1)

此时如果我也想在传递参数的时候传递多个参数怎么弄呢

dict1 = {'001':('蔡徐坤',20),'002':('杨幂',30),'003':('王源',20),'004':('小胡',23)}
def fun(name,**kwargs):
    print("{}喜欢的明星有".format(name))
    if isinstance(kwargs,dict):
        value=dict1.values()
        for name,age in value:
            print('{}的年龄是{}岁'.format(name,age))
fun('小红',**dict1)  ###注意dict1必须是字典类型
 
小红喜欢的明星有
蔡徐坤的年龄是20岁
杨幂的年龄是30岁
王源的年龄是20岁
小胡的年龄是23岁

**kwargs *args 接受参数的说明

def fun(a,b,*args,**kwargs):
    print(a,b,args,kwargs)

fun(1,2)    ###应参中的a,b必须接受到参数，否则会报错
fun(1,2,3,4,5)   ##1赋值给a 2赋值为b 剩下的赋值给*args
fun(1,2,3,4,x=100)  ##  **kwargs只能接受关键字参数 key=value型的


1 2 () {}   
1 2 (3, 4, 5) {}  
1 2 (3, 4) {'x': 100}