求知讲堂python+人工智能day4

python函数

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

1、函数基础

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

# 定义函数
def printInfo():
    '''
    这个函数封装了小张的个人信息（备注信息）
    :return: 
    '''
    print('小张的身高是：{}'.format(1.73))
    print('小张的体重是：{}'.format(160))
    print('小张的爱好是：{}'.format('唱歌'))
    print('小张的专业是：{}'.format('信息管理与信息系统'))
    pass
# 调用函数
printInfo()
printInfo()

2、函数参数

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了。

# 通过传入参数使得定义的函数不只是小张的信息，更加的灵活
# 定义函数
def printInfo(name, height, weight, hobby, pro):
    '''
    这个函数封装了个人信息
    :return:
    '''
    print('*************{}的个人信息*************'.format(name))
    print('{}的身高是：{}'.format(name, height))
    print('{}的体重是：{}'.format(name, weight))
    print('{}的爱好是：{}'.format(name, hobby))
    print('{}的专业是：{}'.format(name, pro))
    pass


# 调用带参函数
printInfo('小张', 1.73, 160, '唱歌', '信息管理与信息系统')
printInfo('小李', 1.75, 180, '搬砖', '计算机应用')

函数的参数

参数：函数为了实现某项特定的功能，进而为了得到实现功能所需要的数据。与外部数据相对应。

• 必选参数
• 默认参数（缺省参数）
• 可选参数
• 引用参数

1、必选参数：在调用的时候必须给实参的

def sum(a,b):  # a,b为形式参数（只是意义上的参数，在定义的时候是不占用内存地址）
    sum=a+b                                   
    print(sum)                                
    pass                                      
# 调用（在调用的时候，必须参数是必须要给值的）                      
sum(20,15)   # 20 和15 就是实参，实实在在的参数，实际占用内存地址  ，必选参数

2、默认参数（缺省参数）

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

# 默认参数
def sum(a=20,b=30):   #a和b存在默认值又叫缺省值
    print("默认参数使用=%d"%(a+b))
    pass
sum()   # 默认的时候就会使用缺省参数的值
sum(10)  # 只赋值一个，默认给第一个，在调用的时候未赋值就用默认值
sum(10,50)

# 默认参数
def sum(a,b=30):
    print("默认参数使用=%d"%(a+b))
    pass
# sum()   # 默认的时候就会使用缺省参数的值，但是a并没有缺省值，所以报错
sum(10)  # 只赋值一个，默认给第一个
sum(10,50)
# def sum1(a=10,b):  # 下面不管怎么调用都会报错，因为缺省值必须在尾部,也就是说a赋值了，后面的参数必须都赋值
#     print("默认参数使用=%d"%(a+b))
#     pass
def sum1(a,b,c=1,d=3):  # c赋值了，后面的参数必须都赋值
    print("默认参数使用=%d"%(a+b+c+d))
    pass
sum1(1,2)
sum1(1,2,3)
sum1(1,2,3,4)

3、可选参数（不定长参数）：参数个数不确定

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

# 可变参数（不定长参数）
def getComputer(*args):
    '''
    计算累加
    :param args: 元组，可变长的参数类型
    :return:
    '''
    print(args)
    pass
getComputer((1,2,3,4,5,6))
getComputer(1)
getComputer('hubert')

# 可变参数（不定长参数）
def getComputer(*args):
    '''
    计算累加
    :param args: 元组，可变长的参数类型
    :return:
    '''
    # print(args)
    result=0
    for i in args:
        result+=i
        pass
    print('result={}'.format(result))
    pass
getComputer(1)
getComputer(1,2)

两个**号的可变参数（关键字参数）：字典形式
而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

# 关键字参数
# 两个**来定义
# 在函数体内，参数关键字是一个字典类型，key是一个字符串
def keyFunc(**kwargs):
    print(kwargs)
    pass
# keyFunc(1,2,3)# 不可以传递
dictA={'name':'hubert','age':35}
keyFunc()
keyFunc(**dictA)  #当直接传递字典类型的参数的时候，必须前面加两个星号
keyFunc(name='pete',age=26)
keyFunc(name='pete',age=26,pro='信管')

混合使用：

def complexFunc(*args,**kwargs):
    print(args)
    print(kwargs)
    pass
complexFunc()   # 第一个是元组，第二个是字典
complexFunc(1,2) # 只符合第一个参数要求
complexFunc(1,2,'hubert',True) # 只符合第一个参数要求
complexFunc(1,2,'hubert',True,{}) # 只符合第一个参数要求
complexFunc(1,2,'hubert',True,**{}) # 最后一个是符合第二个参数的
complexFunc(name='刘德华') # 只符合第二个参数要求
# complexFunc(name='刘德华',1,2) # 可选参数必须放在关键字参数前面（无论在定义还是调用里面）

3、函数的返回值：程序中函数完成一件事情后，最后给调用者的结果

• 如果在函数内部有return，就可以返回实际的值，没有则为空
• 可以返回多种类型值，取决于return后面的类型
• 给调用方返回数据
• 在一个函数体内有多个return值，但是只能返回一个return值
• 一旦执行了return结果，意味着函数执行完毕退出，return后面的语句将不在继续执行

def Sum(a,b):
    sum=a+b
    return sum #将sum值返回到调用的地方
    pass
rs=Sum(10,30)
print(rs)

def calsum(num):
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        pass
    return result
# 调用函数
value=calsum(10)
print(type(value))
print(value)

def calsum(num):
    li=[]
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        pass
    li.append(result)
    return li
# 调用函数
value=calsum(10)
print(type(value))  #返回是什么类型就是什么类型
print(value)

4、函数的嵌套（一个函数内部可以调用另一个函数）

def Func1():
    print('我是第一个函数！')
    pass
def Func2():
    print('我是第二个函数！')
    Func1()
    print('第二个函数结束！')
    pass
Func2()

练习

1、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表

# 找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
def process_func(con):
    list_data=[]
    for i in con:
        if i%2==1:  # 判断奇数位置
            list_data.append(i)
            pass
        pass
    return list_data

print(process_func([1,2,3,4,5,6,7,8]))
rs=tuple(range(10,30))  # 元组不能修改，但是能遍历，所以函数定义按照列表
print(rs)
print(process_func(rs))

2、检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。PS:字典中的value只能是字符串或列表

def dictFunc(data):
    result={}
    for key,value in data.items():
        if len(value)>2:
            result[key]=value[:2]
        else:
            result[key]=value
            pass
        pass
    return result
    pass
dict_data={'name':'刘德华','hobby':['唱歌','跳舞','编程','运动'],'pro':'艺术传统','age':'35'}
print(dict_data)
print(dictFunc(dict_data))