day3-python之函数初识(二)

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

五、总结

 

 

 

 

一、为什么要使用函数?

   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))

二、函数的定义与调用

1、函数的定义

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

2、函数的调用

返回值=函数名(参数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())

三、函数的返回值

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)

四、函数的参数

 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、实参和形参

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

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

2、传递多个参数

参数可以传递多个,多个参数之间用逗号分隔。

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)

3、位置参数

### 站在实参角度:

  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)

五、总结 

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

posted @ 2018-04-21 02:06  GaoDong  阅读(163)  评论(0编辑  收藏  举报