day3-python之函数初识(二)

　　　　目录
1、为何要使用函数？
2、函数的定义与调用
　　一、函数的定义
　　二、函数的调用
3、函数的返回值
4、函数的参数
　　一、实参和形参
　　二、传递多个参数
　　三、位置参数

5、总结

 

 

 

 

1、为何要使用函数？

　　　1.避免代码重用

　　　2.提升代码的可读性

例1：统计字符串长度

步骤1：

1 li = [1, 2, 3, 43, 'fdsa', 'alex'] 2 count = 0
3 for i in li: 4     count += 1
5 print(count)

步骤2：

1 s1 = 'fdsgdfkjlgdfgrewioj'
2 
3 count = 0
4 for i in s1: 5     count += 1
6 print(count)

步骤3：

1 s1 = 'fdsgdfkjlgdfgrewioj'
2 def my_len(): 3     count = 0
4     for i in s1: 5         count += 1
6  # print(count) 7 
8 my_len()

 步骤4：

1 def my_len(): 2     count = 0
3     for i in s1: 4         count += 1
5  return count 6 print(my_len()) 7 print(len(s1))

  步骤5：

 1 #函数的传参  2 li = [1, 2, 3, 43, 'fdsa', 'alex']  3 s1 = 'fdsgdfkjlgdfgrewioj'
 4 
 5 def my_len(a): # 函数的定义（）放的是形式参数，形参  6     count = 0
 7     for i in a:  8         count += 1
 9  return count 10 ret = my_len(li) # 函数的执行（） 实际参数，实参 11 print(ret) 12 print(len(s1))

2、函数的定义与调用

一、函数的定义

def 函数名（参数1，参数2）
　　''' 函数注释'''
　　print（'函数体'）
　　return 返回值
定义：def关键字开头，空格以后接函数名和圆括号，最后还要加一个冒号。
def是固定的，不能变。
函数名：函数名是包含字母，数字，下划线的任意组合，可是不能以数字开头。虽然函数名能够随便取名，可是通常尽可能定义成能够表示函数功能的。

二、函数的调用

返回值=函数名（参数1，参数2）#记得函数名后面加括号

例2：计算字符串的长度

 1 # 1.给定一个字符串，调用函数，当他没有返回值的时候返回Null  2 def length():  3         s='hello world'
 4         length=0
 5         for i in s:  6                 length+=1
 7  print(length)  8 print(length())  9 
10 
11 # 2.return 必须放在函数里，当函数有返回值的时候，必须用变量接收才会有效果 12 def length(): 13         s='hello world'
14         length=0
15         for i in s: 16                 length+=1
17  return length 18 print(length())

3、函数的返回值

1.return的做用:结束一个函数的执行
2.首先返回值能够是任意的数据类型。
3.函数能够有返回值：若是有返回值，必需要用变量接收才有效果
也能够没有返回值：
　　没有返回值的时候分三种状况：
　　　　1)当不写return的时候，函数的返回值为None
　　　　2)当只写一个return的时候，函数的返回值为None
　　　　3)return None的时候，函数的返回值为None（几乎不用）
4.return返回一个值（一个变量）
5.return返回多个值（多个变量）：多个值之间用逗号隔开，以元组的形式返回。
　　　　　　　　　　　　　　　 接收：能够用一个变量接收，也能够用多个变量接收，返回几个就用几个变量去接收

 1 ## 函数有一个或多个返回值  2 def func():  3         a=111
 4         b=[1,2,3]  5         c={'a':15,'b':6}  6  #return a#返回一个值  7  #return a,b,c#返回多个值，变量之间按逗号隔开，以元组的形式返回  8 print(func())  9 
10 ## 函数没有返回值的函数 11 # 1.不写return时返回None 12 def func(): 13     a=111
14     b=[1,2,3] 15 
16 ret=func() 17 print(ret) 18 
19 
20 # 2.只写一个return时返回None 21 def func(): 22     a=111
23     b=[1,2,3] 24  return 25 ret=func() 26 print(ret) 27 
28 # 3.return None的时候返回None 29 def func(): 30     a=111
31     b=[1,2,3] 32  return None 33 ret=func() 34 print(ret) 35 
36 ## return的做用 37 def func4(): 38     print (1111111) 39  return#结束一个函数的执行 40     print (1242451) 41 func4() 42 
43 ## 定义一个列表，返回列表的最后一个值 44 方法一 45 def func(): 46     list=['hello','egon',11,22] 47     return list[-1] 48 
49 print(func()) 50 
51 方法二 52 def func(): 53     list=['hello','egon',11,22] 54  return list 55 
56 m,n,k,g=func()# 57 print(g)

4、函数的参数

 1 # 函数定义  2 def fun(s):#参数接受：形式参数，简称形参  3     '''  4         计算字符串长度的函数---------函数的功能  5         参数s：接受要计算的字符串--------参数的信息  6         return：要计算字符串长度 ---------返回值得信息  7     '''  8     length=0
 9     for i in s: 10         length+=1
11  return length 12 
13 # 函数调用 14 ret=fun('helloword')#参数传入：实际参数，简称实参 15 print(ret)

一、实参和形参

形参：是函数定义时候定义的参数

实参：是函数调用的时候传进来的参数

二、传递多个参数

参数能够传递多个，多个参数之间用逗号分隔。

1 def mymax(x,y): 2     the_max = x if x > y else y 3  return the_max 4 
5 ma = mymax(10,20) 6 print(ma)

三、位置参数

### 站在实参角度：

　　1）按照位置传值，必须一一对应，按顺序

1 # 按照位置传参 2 def mymax(x,y): 3     #此时x=10,y=20
4     the_max = x if x > y else y 5  return the_max 6 
7 ma = mymax(10,20) 8 print(ma)

　　2）按照关键字传值必须一一对应，不分顺序

1 # 按照关键字传参 2 def mymax(x,y): 3     #此时x = 20,y = 10
4  print(x,y) 5     the_max = x if x > y else y 6  return the_max 7 
8 ma = mymax(y = 10,x = 20) 9 print(ma)

　　3）位置、关键字形式混着用，一一对应，且关键字参数必须在位置参数后面

1 # 混合传参 2 def mymax(x,y): 3     #此时x = 10,y = 20
4  print(x,y) 5     the_max = x if x > y else y # 若是x大于y，the_max等于x，不然the_max等于y。 6  return the_max 7 
8 ma = mymax(10,y = 20) 9 print(ma)

 　　正确用法：

　　　　　　位置参数必须在关键字参数的前面

　　　　　　对于一个形参只能赋值一次

 1 # 传递多个参数，实现比大小的功能  2 def my_max(a,b):#位置参数：按顺序定义参数  3     if a>b:  4  return a  5     else:  6  return b  7 # 站在实参的角度上  8 print(my_max(20,30))  9 print(my_max(10,20))# 1.按照位置传参 10 print(my_max(b=50,a=30))# 2.按照关键字传参 11 print(my_max(10,b=30))#3.位置和关键字传参混搭

  ### 站在形参角度

　　1）按照位置传值，必须一一对应，按顺序

1 def func1(x,y): 2  print(x,y) 3 func1(1,2)

　　2）默认参数，必须在位置参数后面

用法：为何要用默认参数？将变化比较小的值设置成默认参数（好比一个班的男生多，女生就几个，就能够设置个默认值参数）
定义：默认参数能够不传，不传的时候用的就是默认值，若是传会覆盖默认值。
　　　默认的值是在定义函数的时候就已经肯定了的

1 # 默认参数 2 def stu_info(name,sex = "male"): 3     """打印学生信息函数，因为班中大部分学生都是男生，
4         因此设置默认参数sex的默认值为'male'
5     """ 6  print(name,sex) 7 stu_info('alex') 8 stu_info('gaodong','female')

 

 1 def register(name,sex='男'):  2     with open('register',encoding='utf-8',mode='a') as f1:  3         f1.write('{} {}\n'.format(name,sex))  4 
 5 while True:  6     username = input('请输入姓名：/q 或者 Q 退出')  7     if username.upper() == 'Q':break  8     if 'a' in username:  9         sex = input('请输入性别：') 10  register(username,sex) 11     else: 12         register(username)

 默认参数缺陷：默认参数是一个可变数据类型

1 def  default_param(a,l=[]): 2  l.append(a) 3  print(l) 4 
5 default_param('alex') 6 default_param('rgon') 7 
8 输出：['alex'] 9         ['alex', 'egon']

　　3）动态参数

按位置传值多余的参数都由args统一接收，保存成一个元组的形式
按关键字传值接受多个关键字参数，由kwargs接收，保存成一个字典的形式

 1 # 接收全部位置参数，保存成一个元组的形式  2 def fun(a,b,*args):  3     sum=a+b  4     for i in args:  5            sum+=i  6     return sum
 7 print(fun(1,5,6,4))#输出1+5+6+4的和  8 
 9 
10 # 接收全部关键字参数，保存成一个字典的形式 11 def fun(a,b,**kwargs): 12  print(a,b,kwargs) 13 
14 fun(a = 10,b = 20,cccc= 30,dddd = 50) 15 # 输出：10 20 {'cccc': 30, 'dddd': 50} 16 
17 
18 # 位置参数, *args, 默认参数, **kwargs 19 def f(a,b,*args,defult=6,**kwargs): 20     #位置参数，*args, 默认参数，**kwargs 21  # print(a,b,args,defult,kwargs) 22  return a,b,args,defult,kwargs 23 
24 #传参数的时候：必须先按照位置传参数，再按照关键字传参数 25 print(f(1,2,7,8,ccc=10,der=5))

 动态参数，也叫不定长传参，就是你须要传给函数的参数不少，不定个数，那这种状况下，你就用*args，**kwargs接收，args是元祖形式，接收除去键值对之外的全部参数，kwargs接收的只是键值对的参数，并保存在字典中。

 1 def func1(*args,**kwargs):  #　函数的定义 * 聚合。  2  print(args)  3  print(kwargs)  4 l1 = [1,2,3,4]  5 l11 = (1,2,3,4)  6 l2 = ['alex','wusir',4]  7 func1(*l1,*l2,*l11)  # 函数的执行：* 打散功能。  8 # func1(1,2,3,4,'alex','wusir',4,1,2,3,4)  # 函数的执行：* 打散功能。  9 
10 def func1(*args,**kwargs):  #　函数的定义 * 聚合。 11  print(args) 12  print(kwargs) 13 dic1 = {'name1':'alex'} 14 dic2 = {'name2':'laonanhai'} 15 func1(**dic1,**dic2)

5、总结 

# 函数
    # 定义
        # 关键字 def 函数名(形参):
        # 参数 ：
            # 位置参数
            # *args  动态传参 ：接收在调用的时候传过来的多余的全部按位置传的参数
            # 关键字参数 默认参数，若是不传会有一个默认的值，若是传了会覆盖默认的值
            # **kwargs  动态传参 ：接收在调用的时候传过来的多余的全部按关键字传的参数
        # 返回值
            # return 中止一个程序的运行，返回参数
                # 没有返回值 默认返回None
                # 有一个返回值
                # 返回多个值
    # 调用
        # 调用的关键字 函数名(实参)
        # 传参数 ：
            # 按照位置传
            # 按照关键字传
        # 接收返回值
            # 没有返回值 不接受
            # 有一个返回值 用一个变量接收
            # 有多个返回值
                # 用一个变量接收 所用返回值都会被组织成一个元组
                # 用多个变量接收 有多少个返回值 就必须用多少个变量接收
# 函数是第一类对象的概念
    # 函数名 --> 函数的内存地址
    # 函数名能够做为 容器类型的元素 函数的参数、返回值 还能进行赋值  --> 变量