一入python深似海，从此妹纸是路人

Posted 2023-03-15

一、递归

如果一个函数在内部不调用其它函数，而是自己，这个函数就是递归函数；

优点：定义简单，逻辑清晰

特性：

1）必须有一个明确的结束条件;

2）超出一定调用次数，会导致栈溢出;

递推

回溯

1、累计求和

def funa(n):
    sum1 = 0
    for i in range(1, n + 1):
        sum1 += i  # sum1 = sum1 + i
    print(sum1)
funa(3)
输出：6

2、递归函数

lan_zi(第二天） = lan_zi(第一天) + dan（2)个
lan_zi(第三天） = lan_zi(第二天) + dan（3)个
funb(n)    =       funb(n-1)    +    n

def f(n):
    if n > 0:
        return n + f(n-1)
    else:   # n <= 0
        return 0
print(f(3))
输出：6

解析： f(3) = f(2) + 3 = f(1) + 2 + 3 = f(0) + 1 + 2 + 3 = 0 + 1 + 2 +3

3、斐波那契函数： 1,1,2,3,5,8... 项

假设我定义这个序列的第n项为函数f(n)

f(n) = f(n-1) + f(n-2)
def f(n):
    if n <= 1:
        return n
    else:
        return f(n-1) + f(n-2)
print(f(3))
输出：2

解析： f(3) = f(1) + f(2) = 1 + f(0)+f(1) = 1+ 1 +1 = 3 ---- f(0) 必须是0 f(1) 必须是1

4、斐波那契序列 写出前面10项的序列

def f(n):
    if n <= 1:
        return n
    else:
        return f(n-1) + f(n-2)
lst = []
for i in range(1,11):
    lst.append(f(i))
print(lst)
输出：[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

二、类和对象

1、为啥要使用类和对象？

• 1）方便复用;
• 2) 方便扩展;
• 3) 方便维护；

def make_yazui():
    print(鸭嘴制作完成)
def make_erduo():
    print(鸭耳制作完成)
make_yazui()
make_erduo()
输出：鸭嘴制作完成
      鸭耳制作完成

def make_zhuzui():
    print(猪嘴制作完成)
def make_zhuer():
    print(猪耳朵制作完成)
make_zhuzui()
make_zhuer()
输出：猪嘴制作完成
     猪耳朵制作完成

面向过程 ---- 过程

面向对象 ---- 对象 谁来帮我完成这件事

面向对象的三大特征：封装 继承 多态

类：总称 ---抽象的概念

对象：实实在在具体的

举例： 水果​---- 类 车厘子 橘子 苹果 草莓 香蕉---对象

object是python里所有类的最顶级的父类

类名习惯上首字母大写

类的定义：

class 类名(): # 类名 或 类名(object)

pass

例： class Hero(): # 还可以写成Hero或Hero(object) pass

创建对象： 类名()

创建对象/实例化对象 --- 一个类可以创建很多个对象

class Hero():
    pass
hero1 = Hero()
hero2 = Hero()
hero3 = Hero()
print(id(hero1))
print(id(hero2))
print(id(hero3))

class Hero():
    pass
hero = Hero()
hero.name = wang     # 对象名.属性 = 值
hero.age = 30
# # 获取属性
print(f名字是hero.name,年龄是hero.age岁)
输出：名字是wang,年龄是30岁

2、方法

class Hero(object):
    def move(self):    # 方法
        print(正在前往事发地点……)
hero1 = Hero()
# 获取方法   对象名.方法名()
hero1.move()
hero2 = Hero()
hero2.move()
输出：正在前往事发地点……
     正在前往事发地点……

三、构造方法

__init__():初始化 系统自带的--手机一开机我就有的功能

在创建对象（实例化对象）会自动调用该方法----即拥有这个方法的所有东西

类属性：在类的内部，在方法之外

实例属性：在方法内部 "self.变量名= 值",实例属性一般在__init__()

方法里self参数一定是第一个参数，对象自动传参给self

class A:
    def __init__(self):
        print(哈哈)
a = A()
输出：哈哈

class Hero():
    # money = 10000             # 类属性
    def __init__(self):
        self.name = 奥特曼   # 实例属性
        self.hp = 200         # 生命值
        self.at = 450         # 战斗力

    def move(self):
        print(fself.name正在移动中...)

    def attack(self):
        print(fself.name的生命值是self.hp,发出了一招战斗，战斗力为self.at)
hero1 = Hero()
hero1.move()
hero1.attack()     # 对象可以访问实例属性
输出：奥特曼正在移动中...
      奥特曼的生命值是200,发出了一招战斗，战斗力为450
      
hero2 = Hero()
hero2.move()
hero2.attack()
输出：奥特曼正在移动中...
      奥特曼的生命值是200,发出了一招战斗，战斗力为450

类的封装 ---- 用统一模板，实现千人千面 -----框架一样，数值（血肉）不一样

class Hero():
    def __init__(self, name, hp, at):
        self.name = name       # 实例属性
        self.hp = hp        # 生命值
        self.at = at       # 战斗力

    def move(self):
        print(fself.name正在移动中...)

    def attack(self):
        print(fself.name的生命值是self.hp,发出了一招战斗，战斗力为self.at)
hero1 = Hero(1号,800,300)
hero1.move()
hero1.attack()     # 对象可以访问实例属性
输出：1号正在移动中...
      1号的生命值是800,发出了一招战斗，战斗力为300
      
hero2 = Hero(2号,500,200)
hero2.move()
hero2.attack()
输出：2号正在移动中...
     2号的生命值是500,发出了一招战斗，战斗力为200

三、析构方法

__del__()

作用：主要是销毁/删除临时的变量

class Person:
    def __init__(self):
        print(这是构造方法)
    def __del__(self):
        print(被销毁了)  # 析构方法
p = Person()
print(哈哈)
print(哈哈)
print(哈哈)
输出：这是构造方法
     哈哈
     哈哈
     哈哈
     被销毁了

class Person:
    def __init__(self):
        print(这是构造方法)
    def __del__(self):
        print(被销毁了)  # 析构方法
p = Person()
del p     # 删除对象时，触发__del__()调用
print(哈哈)
print(哈哈)
print(哈哈)
输出：这是构造方法
     被销毁了
     哈哈
     哈哈
     哈哈

str(): 把其它类型转换为字符串类型

__str__() 打印对象时,设置输出该方法的返回值

class A:
    def __str__(self):
        return 哈哈
a = A()
print(a)
输出：哈哈