python 初识函数

1.函数的定义：封装一个功能，便于调取的一组程序模块。

　　def 函数名（）：

　　　　函数体

　　1.函数有由来：

 

s = 'jidjsoijofjdo'
c = 0
for i in s:
    c += 1
print(c)

l1= [1,2,3,4,'fdsaf','gfda','fc','sz']
c = 0
for j in l1:
    c += 1
print(c)

已上方法就是len()的功能,在编程中，可能重复使用，在每次使用的时候就编写一次没效率也占用内存。
于是利用函数的模式，将程序封装起来，随用随取。

　　函数就是封装一个功能.以功能为导向
　　def my_len():
  　　  def   　　　　　　　　　　　　关键字 定义一个函数
   　　 my_name 　　 　　　　　　　 函数名，函数名的书写规则与变量一样
   　　 def 　　　　　　　　　　　　  与函数名之间一个空格
  　　  函数名（）：　　　　　　　　加上冒号，将函数名和函数体隔开，便于阅读
    　　内容是函数体
　　    函数执行：在不调用的情况下，封装以后在内存中开辟一个空间储存函数，叫做局部命名空间
2.函数的返回值：return

　　return在函数中一般都出现在末尾用做返回值操作，注意事项如下：
 　　　　1.在函数中遇到return 就结束函数，后面不执行
　　　　 2.将值返回给函数的调用者：

　　在使用return的过程中，可能出现一下几点问题，
   　　　　　　 1.函数里面没有return,返回None
  　　　　　　  2.return None,一般不多
    　　　　　　3.return一个值 则会返回该值。
    　　　　　　4.return多个值 则会将多个值放到一个元祖中，返回给调用者

def func(a):
    return a

print(func('wwww'))#wwww
需要注意的是在函数中最好不要使用print，输出函数时如果利用print而且函数中还有一个print则会出现None。

 

3.参数#重点

def my_lenn(l):  #这里的 l 是形式参数，形参
    count = 0
    for i in l:
        count += 1
    return count

print(my_lenn('ab'))  #函数中的参数为实际参数，实参

函数分实参和形参
    从实参角度出发定义:
        1.位置传参.按顺序，需要与实参一一对应
        2,按关键字传参数，不按顺序,也与实参是一一对应.
        3.混合传参，关键字参数永远在最后面

def fuck(a,b):  
    return a if a > b else b
print(fuck(22,33))  #位置参数，与上方形参一一对应

################################
def fuck(a,b):，
    return a if a > b else b
print(fuck(b=22,a=33))#关键参数

###################################
def func1(a,b,c,d,e):
     print(a)
     print(b)
     print(c)
     print(d)
     print(e)
func1(1,2,d=4,c=3,e=5)
func1(1,4,e=2,d=9,c=5)
#混合参数：需要注意的是在使用混合参数的时候位置参数在关键参数的前面。

 
    形参角度：
        1.位置参数，安顺序一一对应，
        2.默认参数，传参则覆盖，不传则默认,默认参数永远在位置参数的后面。
        3.动态参数，1.当有大量的参数需要填入的时候需要用到动态参数使用*args

　　　　　　　　2.当有多余关键字参数时候使用**kwarge

　　　在动态参数中的顺序是 1位置参数2*args3关键字参数4**kwargs

函数形参：
    动态参数：当需要多个参数，利用*args的方法
 def funx(*args):
     print(*args)#增加*号则会直接输出所有实参，没有则会将实参聚合为一个元祖并且输出
 funx(1,2,3,4,5,6,7,8,9)

def func(a,c,f,*args,d = 66,**wkargs):
     return a,c,f,d,
print(func(2,3,5,2,1,4,3,12,3,5,3,12,3,4325,d = 4444))

def func(a,c,f,*args,d = 66,**kwargs):
    print(args)  #*args将所有的没有定义的元素组合起来输出
    print(a)     #顺序是优先位置参数，然后*args再然后就是默认参数
    print(c)
    print(f)
    print(d)
    print(kwargs)
print(func(2,3,5,2,1,4,3,12,3,5,3,h=12,m=3,n=4325,d=4444))

       动态传参:
2.**kwargs:将关键字参数统合为字典类型输出，
def func(**kwargs):
    print(kwargs)
func(e = 3,r = 2)

def func(*args):
    print(args)
func(1,2,3,10,20,80)

* 的作用！
def func(*args):
    return args
l1 = [3,4,5,6,7,3,1,]
l2 = [2,3,4,2,1,4]
print(func(*l1,*l2))
print(func(*(l1+l2)))   #去列表

**的作用
def func(**kwargs):
    print(kwargs)
func(a=1,c=2,v=3,y=7)  #将关键字转化为字典格式

def func(**kwargs):
    return kwargs

dic1 = {'name1':'alex','age1':46}##要注意的是调用的时候一定要加上函数名
dic2 = {'name':'老男孩','age':56}

print(func(**dic1,**dic2))

def func(**kwargs):
    print(kwargs)

dic1 = {'name1':'alex','age1':46}
dic2 = {'name':'老男孩','age':56}
func(**dic1,**dic2)

 利用*时候，要注意后面是可迭代对象，并且将其打散，组成元祖模式输出
 利用**时候，要注意的是对应的为关键字参数，会将其聚合起来，组成字典类型输出