Python Third Day-函数

'''
1 为什么要有函数？没有函数带来的困扰？
    组织结构不清晰，可读性差
    代码冗余
    可扩展性差

2 什么是函数
    具备某一个功能的工具---》函数

    事先准备工具-》函数的定义
    拿来就用、重复使用-》函数的调用
    ps：先定义后调用

3 函数的分类：
    内置函数：len，max(10,11)，help(函数名)
    自定义函数：def
        语法：
            def 函数名(参数1，参数2，...):
                """注释"""
                函数体
                return 返回值
　　　　　　　函数名（）#就可以调用
'''

  1 #'函数即是变量'
  2 # def print_tag():
  3 #     print('*'*20)
  4 #
  5 # def print_msg(): #print_msg=<function print_msg at 0x00000000027EA8C8>
  6 #     print('hello world')
  7 #
  8 #
  9 # # print(print_msg)
 10 # # print(print_tag)
 11 #
 12 # print_tag()
 13 # print_msg()
 14 # print_tag()
 15 
 16 
 17 
 18 #2、定义函数阶段都发生了什么事：只检测语法，不执行代码
 19 #定义阶段
 20 # sex='male'
 21 # def auth():
 22 #     sex#引用变量名
 23 #
 24 #     name=input('name>>: ').strip()
 25 #     password=input('password>>: ').strip()
 26 #     if name =='egon' and password == '123':
 27 #         print('login successfull')
 28 #     else:
 29 #         print('user or password err')
 30 #
 31 # #调用阶段
 32 # auth()
 33 
 34 
 35 #3、函数的使用：先定义后调用
 36 
 37 # def bar():
 38 #     print('from bar')
 39 #
 40 # def foo():
 41 #     print('from foo')
 42 #     bar()
 43 #
 44 # foo()
 45 
 46 # #定义阶段
 47 # def foo():
 48 #     print('from foo')
 49 #     bar()
 50 #
 51 # def bar():
 52 #     print('from bar')
 53 #
 54 # #调用阶段
 55 # foo()
 56 
 57 
 58 # # 定义阶段#这个地方就不行，定义阶段没有bar()
 59 # def foo():
 60 #     print('from foo')
 61 #     bar()
 62 #
 63 # # 调用
 64 # foo()
 65 #
 66 # def bar():
 67 #     print('from bar')
 68 #
 69 
 70 
 71 
 72 
 73 
 74 
 75 #4 定义函数的三种形式
 76 #第一种：无参函数
 77 #第二种：有参函数#函数体依赖外界传入的值
 78 #第三种：空函数
 79 
 80 # def auth():
 81 #     name=input('name>>: ').strip()
 82 #     password=input('password>>: ').strip()
 83 #     if name =='egon' and password == '123':
 84 #         print('login successfull')
 85 #     else:
 86 #         print('user or password err')
 87 #
 88 
 89 # def my_max(x,y):#有参函数
 90 #     if x >= y:
 91 #         print(x)
 92 #     else:
 93 #         print(y)
 94 #
 95 # my_max(1,2)
 96 
 97 
 98 
 99 # def auth(name,password):
100 #     if name =='egon' and password == '123':
101 #         print('login successfull')
102 #     else:
103 #         print('user or password err')
104 #
105 # def interactive():
106 #     name=input('name>>: ').strip()
107 #     password=input('password>>: ').strip()
108 #     auth(name,password)
109 #
110 # interactive()
111 
112 
113 #定义空函数
114 def auth():
115     pass
116 
117 def put():
118     pass
119 
120 def get():
121     pass
122 
123 def ls():
124     pass

函数返回值

 1 #return的特点：
 2 #1、 函数内可以有多个return，但是只能执行一次return
 3 #2、 执行return函数就立刻结束，并且return的后值当做本次调用的结果返回
 4 # def foo(x,y):
 5 #     return x+y
 6 #
 7 # res=foo(1,2)
 8 例：返回值
 9 #res=print('hello')
10 #print(res)#这个地方输出的是hello和none，print('hello')没有返回值所以是none
11 #
12 例：返回值2
13 # def foo(x,y):
14 #     pass#没有return定义返回值，如果return写上x+y，返回值就是3了
15 #
16 # res=foo(1,2)
17 #print(res)#上面没有定义返回值所以就是none
18 
19 # def my_max(x,y):
20 #     if x >= y:
21 #         return x
22 #     else:
23 #         return y
24 #
25 # res=my_max(1,2)
26 # print(res)
27 
28 # def foo():#有多个return，只执行第一个
29 #     print('first')
30 #     return 1
31 #     print('second')
32 #     return 2
33 #     print('third')
34 #     return 3
35 #
36 # res=foo()
37 # print(res)
38 
39 
40 
41 
42 #1、返回的值没有类型限制
43 # def bar():
44 #     print('from bar')
45 #
46 # def foo():
47 #     return bar
48 # print(foo() is bar)
49 
50 #2:return返回值的个数
51 #2.1: 没有return:默认返回None
52 #2.2：return 值：值本身
53 #3.3： return 多个值:返回一个元组
54 
55 # def foo():
56 #     pass
57 #     return 1,'a',[1,2]
58 # print(foo())
59 
60 
61 #函数调用的三种形式
62 def my_max(x,y):
63     if x >= y:
64         return x
65     else:
66         return y
67 
68 # res1=my_max(1,2)
69 
70 # res2=my_max(1,2)*10
71 
72 # res3=my_max(my_max(1,2),3)
73 # print(res3)
74 
75 range(len([1,2,3]))

函数的参数

  1 #函数的参数分类两种：
  2 #形参：在定义阶段括号内指定的参数，相当于变量名
  3 #实参：在调用阶段括号内传入的值称之为实参，相当于值
  4 #在调用阶段，实参的值会绑定给形参，在调用结束后解除绑定
  5 # def foo(x,y): #x=1,y=2
  6 #     print(x,y)
  7 #
  8 # foo(1,2)
  9 
 10 #在python中参数的分类：
 11 #1、位置参数：按照从左到右的顺序依次定义的参数
 12 #位置形参：必须被传值，多一个少一个都不行
 13 #位置实参：与形参一一对应传值
 14 # def foo(x,y):
 15 #     print(x,y)
 16 #
 17 # foo(2,1)
 18 
 19 #2、关键字参数：在函数调用时，按照key=value的形式定义的实参
 20 #特点：指名道姓地给形参传值，不再依赖与位置
 21 def foo(name,age,sex):
 22     print(name,age,sex)
 23 
 24 # foo('egon',18,'male')
 25 # foo(sex='male',age=18,name='egon',)
 26 #注意：
 27 #1、 关键字实参必须在位置实参的后面
 28 #2、 不能为同一个参数赋值多次
 29 
 30 # foo('egon',sex='male',age=18,name='egon')
 31 
 32 
 33 #3、默认参数：在函数定义阶段，就已经为形参赋值了
 34 #特点：定义阶段已经有值意味着调用阶段可以不用传值
 35 #位置参数通常用于经常变化的参数，而默认参数指的是大多数情况下都一样的
 36 # def foo(x,y=1):
 37 #     print(x,y)
 38 
 39 # foo(1,2)
 40 # foo(y=3,x=1)
 41 # foo(111)
 42 # foo(x=1111)
 43 
 44 
 45 # def register(name,age,sex='male'):
 46 #     print(name,age,sex)
 47 #
 48 # register('egon1',18)
 49 # register('egon2',18)
 50 # register('egon3',18)
 51 # register('alex',38,'female')
 52 
 53 #注意：
 54 #1、默认参数必须放到位置形参的后面
 55 # def register(name,sex='male',age,):
 56 #     print(name,age,sex)
 57 #2、默认参数的值只在定义时被赋值一次
 58 #3、默认的参数的值通常应该是不可变类型
 59 # res=1
 60 # def foo(x,y=res):
 61 #     print(x,y)
 62 #
 63 # res=10
 64 # foo('aaaaaaaa')
 65 
 66 
 67 #4 可变长参数：在调用函数时，实参值的个数不固定
 68 #实参的形式有：位置实参和关键字实参，
 69 #形参的解决方案：*，**
 70 
 71 #*args的用法
 72 # def foo(x,y,*z): #z=(3,4,5,6)   *z相当于*args
 73 #     print(x,y)
 74 #     print(args)
 75 #
 76 # # foo(1,2,3,4,5,6)
 77 #
 78 # foo(1,2,*[3,4,5,6]) #foo(1,2,3,4,5,6)
 79 # foo(*[1,2,3,4,5,6]) #foo(1,2,3,4,5,6)#实参有*就想成这种格式
 80 
 81 # def foo(x,y):
 82 #     print(x,y)
 83 #
 84 # foo(*(1,2)) #foo(1,2)
 85 
 86 #**kwargs
 87 # def foo(x,y,**kwargs): #kwargs={'c':5,'a':3,'b':4}
 88 #     print(x,y)
 89 #     print(kwargs)
 90 #
 91 # # foo(y=2,x=1,a=3,b=4,c=5)
 92 #
 93 # foo(y=2,**{'c':5,'x':1,'b':4,'a':3}) #foo(y=2,a=3,c=5,b=4)
 94 
 95 
 96 # def foo(name,age):
 97 #     print(name,age)
 98 
 99 # foo(**{'name':'egon','age':18})
100 # foo({'name':'egon','age':18})
101 
102 
103 
104 # def bar(x,y,z):
105 #     print(x,y,z)
106 #
107 # def wrapper(*args,**kwargs): #args=(1,),kwargs={'z':2,'y':3}
108 #     # print(args,kwargs)
109 #     bar(*args,**kwargs) #bar(*(1,),**{'z':2,'y':3}) #bar(1,z=2,y=3,)
110 #
111 # wrapper(1,z=2,y=3)
112 
113 
114 
115 #命名关键字参数：指的是定义在*后的参数，该参数必须被传值（除非有它有默认值），而且必须按照key=value的形式传值
116 # def foo(x,y,*args,m=100000,n):
117 #     print(x,y)
118 #     print(args)
119 #     print(m,n)
120 #
121 # foo(1,2,3,n=4,)
122 #