第三天学习python

关于构造函数
构造函数需要使用关键字 def
下面用测试代码进行思考

def x(y):
    if y==8:
        print("对了")
print(x(8))

以上会打印出什么呢？

对了
None

为什么会出现None呢？如果我们的代码是这样的

def x(y):
    if y==8:
        return("对了")
print(x(8))

输出如下

对了

为什么改了一个关键字就差别这么大？
答：代码是从上而下，他先进入x函数，输出出x函数的内容，然后再输出，此时x（8）的值为None，所以输出为为上述。

构造函数的参数问题

def x(name):
    ....
x(5)

此时name为形参 5为实参

def x(name=5，name2=6):
    ....
x()

此时x有两个默认参数，即name=5，name2=6
输出为5，6的值

def x(name=5，name2=6):
    ....
x(7，8)

此时有默认参数，但是实参为7，8所以输出7，8的值

下面介绍收集参数：

def x(*name):
    print(len(name))
    print(name[1])
x(1,5.6,8,9.8,5)

输出为：
5
5.6
全局变量和局部变量以下以代码示例

def x(price,rate):
    final_price=price*rate
    print("")
    return final_price
price=float(input("请输入价格\n"))
rate=float(input("请输入折扣率\n"))
print("原价为",x(price,rate))

上述代码final_price为局部变量,price和rate为全局变量，所以这两种变量很好理解，局部变量只能在构造函数使用，如果出了构造函数，这个变量将无法使用，而全局变量则是整个代码块都可以使用，包括构造的函数里面也可以使用！

下面介绍内嵌函数
同样以代码示例

def My(x):
    def My1(y):
        def My2(z):
            return x*y*z
        return My2
    return My1
print(My(2)(2)(2))
输出为
8

同理

def My():
    x=5
    def My1():
        def My2():
            nonlocal x
            x*=x
            return x
        return My2()
    return My1()
print(My())

输出为
25

nonlocal强制声明转换不是局部变量，所以可以直接引用了！

同时有一个特别简单的函数方法
lambda他只需要直接声明就可以输出了，相较于def更加简单

x1=lambda x,y:x*2+1+y
print(x1(2,3))
输出为
8

以下介绍filter
他只会输出1 或者true的值，false或者0的值不会返回

def x(x):
    return x%2
t=range(10)
s=filter(x,t)
print(list(s))
输出为
1 3 5 7 9

同理

print(list(filter(lambda u:u%2!=0,range(10)))
输出为
1 3 5 7 9

同时也有个关键字 map
他可以返回所以值如下

print(list(map(lambda u:u*2,range(10)))
输出为
0, 2, 4, 6, 8, 10, 12, 14, 16, 18

下面介绍一个简便函数：递归函数
以代码示例
代码一：

def xun(n):
    s=n
    for i in range(1,n):
        s=s*i
        continue
    return s

kk=int(input("输入一个数"))
print("阶乘为",xun(kk))

代码二

def factorial(n):
    if n==1:
        return 1
    else:
        return n*factorial(n-1)

pp=int(input("请输入数字"))
print("阶乘为：",factorial(pp))

上述函数都可以输出1*2*3*4*……*n的值
可以看出代码二更加简单明了，递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试计算 1000000

迭代和递归的实际使用：

**递归：**
def x(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    elif n>2:
        return x(n-2)+x(n-1)
dd=int(input("请输入数字"))
print(x(dd))

**迭代**
def oo(n):
    n1=1
    n2=1
    n3=1
    while(n-2)>0:
        n3=n1+n2
        n1=n2
        n2=n3
        n=n-1
    return n3
dd=int(input("请输入数字"))
print(oo(dd))

上述输出都可行。
不过如果输出量大的话推荐迭代，递归输出的时间需要大量，而迭代输出相较于其快

猜你喜欢