day11 python学习 函数的建立，返回值，参数

函数的定义主要有如下要点：

• def：表示函数的关键字
• 函数名：函数的名称，日后根据函数名调用函数
• 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
• 参数：为函数体提供数据
• 返回值：当函数执行完毕后，可以给调用者返回数据。

以上要点中，比较重要有参数和返回值：

3.def  函数

写函数的时候，要尽量以功能为导向，结果最好不要直接在函数中打印

 

简单的函数
def my_len(l):#函数名的定义
    count=0
    for i in l:
        count+=1
    return count   #函数的返回值
print(my_len([1,2,2,22,4]))#函数的调用和返回值的接受

返回值:

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者

#没有返回值：

　　不写return  或和他等价的 return None

　　只写一个 return  == return None

　　return的作用，：1.返回一个值，2.终止一个循环

返回一个值：可以返回任意数据类型，返回什么  就接受什么

返回多个值：用一个变量接收返回值，接收到的是一个元祖

　　　　　　返回值有多个变量接收，那么返回值的数量和接受变量的个数完全一致。

返回值要注意的点：

 

li=[1,2,34,]
def func(*args):
    print(args)
    return args*2
print(func(li))

得到的结果：
([1, 2, 34],)  可以看到参数传到函数内部是以元祖然后把参数单独当作元祖的一个值  以元祖形式存在的
值存在的
([1, 2, 34], [1, 2, 34])    对函数进行*2的操作返回的是一个元祖 含有一个两个传入的数据

 

打散操作

li=[1,2,34,]
def func(*args):
    print(args)
    return args*2
a=func(*li)  这里是打散操作，将一个列表打散数据一一放到函数中去

l2=[5,5,6]
b,c,d,e,f,g=func(*l2)

将函数打散放到里边
#可以看到在函数内部每个数据都是以单独一个元素形式存在在元祖中的
(1, 2, 34)
#返回的值也是作为单独一个元素放到元祖中的

  print(a)   得到的值是 (1, 2, 34, 1, 2, 34)

  print(b)  得到的值是   5

 返回值的接收 
 一个变量接收多个返回值就会将数据整体放到元祖中去(1, 2, 34, 1, 2, 34)

 多个变量接收多个返回值   则以 数据的形式接收

打散在关键字参数中的应用

d1={'name':'alex','age':18}
def func(**kwargs,):
    print(kwargs)
func(**d1)  #可以看到传字典形式的关键字参数的时候需在前边加上   ** 字典打散操作
#    **打散操作   不然会被当作位置参数来接受

#打印的结果是
#{'name': 'alex', 'age': 18}    
#或者这样传位置参数
func(name='aaa')

 

参数

函数的有三中不同的参数：

• 普通参数
• 默认参数
• 动态参数

普通参数：

普通参数的传递并没有个数和数据类型的限制，可以传递字符串，数字，列表和字典。也不限定个数，需要注意的是：函数需要多少参数，调用的时候就要按照它定义时的顺序和数据类型传递过去。

形参：函数中的参数
实参：传递参数/传参，实际参数/实参 l=[1,2,2,22,4]

def my_len(l):  #参数：接收参数，形参，形式参数。
    count=0
    for i in l:
        count+=1
    return count
l=[1,2,2,22,4]#参数：传递参数/传参，实际参数/实参 l=[1,2,2,22,4]
print(my_len(l))
l2='金老板 is somebody'
print(my_len(l2))

传参可以是任意的数据类型，并且传递什么接受什么

站在传递参数的角度上看问题：一共有有两种传递参数。

　　　　　　　　第一种：按照位置穿参数（

　　　　　　　　第二种：按照关键字穿参数

def f1(arg1,arg2):#站在接受，形参的角度上：位置参数
    print(arg1)
    print(arg2)
f1('你好啊',arg2=[1,2,3,4,5])

f1(arg2='你好啊',[1,2,3,4,5])#这样会报错无法执行
f1(arg2='你好啊',arg1=[1,2,3,4,5])#这样才能正常执行

#按照关键字传参数和按照位置传参数是可以混用的
#但是首先传按位置(就是参数的索引号，前后顺序号)的，再传按关键字（arg1=  arg2=)
#按照位置传完该接受的参数只能接收一个值，不接受或者重复接受都不行

默认参数

默认参数是给参数加上一个默认的值，但我们调用函数的时候，如果传递了这个参数，那么使用我们传递过来的值；如果不传则使用默认的值，默认参数可以有多个，但是必须放在所有参数的最后。当我们有多个默认参数的时候，调用函数的时候可以使用参数名指定其中的某一个参数，以保证参数能准确的传递给被调用的函数。

#默认参数
def classmate(name,sex='男'):                     #默认参数是可以不传的参数，
            
    print("姓名%s,性别%s"%(name,sex))              #在不传参数的情况下可以使用默认的值
classmate('yakun')                                #如果传了，就会使用传的值
classmate('守业')
classmate('飞龙')
classmate('晓梅','女')

姓名yakun,性别男
姓名守业,性别男
姓名飞龙,性别男
姓名晓梅,性别女

 默认参数尽量避免可变数据类型：

def func2(args,list=[]):
    list.append(args)
    return list
aa=func2('aa')
bb=func2('bb',[])
cc=func2('cc')
print(aa)
print(bb)
print(cc)

以下是打印的情况 

['aa', 'cc']
['bb']
['aa', 'cc']

可以看到默认参数的初始值设置成了一个列表，这时候当不单传的话默认就是以当前的list去接受数据，

所以  aa  cc 的数据都是传到默认列表的内存空间里去了，所以  aa  cc 得到的值都是  [ 'aa', ' cc' ]

 函数的返回值

 

本章小结

面向过程编程的问题：代码冗余、可读性差、可扩展性差(不易修改)

定义函数的规则：

1.定义：def 关键词开头，空格之后接函数名称和圆括号()。
2.参数：圆括号用来接收参数。若传入多个参数，参数之间用逗号分割。
　　　　参数可以定义多个，也可以不定义。
　　　　参数有很多种，如果涉及到多种参数的定义，应始终遵循位置参数、*args、默认参数、**kwargs顺序定义。
　　　　如上述定义过程中某参数类型缺省，其他参数依旧遵循上述排序
3.注释：函数的第一行语句应该添加注释。
4.函数体：函数内容以冒号起始，并且缩进。
5.返回值：return [表达式] 结束函数。不带表达式的return相当于返回 None

def 函数名(参数1,参数2,*args,默认参数,**kwargs):
        """注释：函数功能和参数说明"""
        函数体
        ……
        return 返回值

调用函数的规则：

1.函数名()
    函数名后面+圆括号就是函数的调用。
2.参数：
    圆括号用来接收参数。
    若传入多个参数：
        应按先位置传值，再按关键字传值
        具体的传入顺序应按照函数定义的参数情况而定
3.返回值
    如果函数有返回值，还应该定义“变量”接收返回值
    如果返回值有多个，也可以用多个变量来接收，变量数应和返回值数目一致

无返回值的情况：
函数名()

有返回值的情况：
变量 = 函数名()

多个变量接收多返回值：
变量1，变量2，... = 函数名()