Python基础（面向对象编程）

AI课程笔记Python基础（面向对象编程）

1面向对象编程

1.1形象化理解

​ ①面向过程编程相当于自己去买手机，需要分成查参数，对比，取钱，去商店的过程

​ ②面向对象编程相当于让秘书去买手机

1.2类的封装

1.2.1创建一个类

#创建一个列表，其中装载0~99共100个数字
class Dog():
    def info(self):
        print(self) #打印的是实例化对象的地址
        print("狗祖宗")
jingmao = Dog()
jingmao.info()
#输出：
#<__main__.Dog object at 0x000002537E7A41C0>
#狗祖宗

jingmao.name = "乐乐" #可以向实例再添加一些属性(该实例特有的属性)
jingmao.hp = 2000
jingmao.attack = 150
print("%s的生命值为:%d" % (jingmao.name,jingmao.hp)) #print格式化输出
print("%s的攻击力为:%d" % (jingmao.name,jingmao.attack))
#输出：
#乐乐的生命值为:2000
#乐乐的攻击力为:150

注：self是实例化对象，用于接收实例化的对象

(希望能在类内访问实例的属性值↓)

class Dog():
    def info(self): #将实例self传入作为参数
    	print("%s的生命值为:%d" % (self.name,self.hp))
        print("%s的攻击力为:%d" % (self.name,self.attack))
jingmao = Dog()
Hashiqi = Dog()

jingmao.name = "乐乐" #可以向实例再添加一些属性(该实例特有的属性)
jingmao.hp = 2000
jingmao.attack = 150

Hashiqi.name = "兵兵"
Hashiqi.hp = 1300
Hashiqi.attack = 100

jingmao.info()
Hashiqi.info()
#输出：
#乐乐的生命值为:2000
#乐乐的攻击力为:150
#兵兵的生命值为:1300
#兵兵的攻击力为:100

1.2.2魔法方法__init__()（前后都有短斜杠）

# 用__init__()实现属性的初始化
class Dog():
    def __init__(self): #在实现类的时候，自动调用init的代码块
        self.name = '菜狗'
        self.hp = 2000
        self.atk = 300
        self.armor = 200
	def info(self):
        print("%s的生命值为:%d" % (self.name,self.hp))
        print("%s的攻击力为:%d" % (self.name,self.atk))
        print("%s的防御力为:%d" % (self.name,self.armor))
caigou = Dog()
caigou.info()
#输出：
#菜狗的生命值为:2000
#菜狗的攻击力为:300
#菜狗的防御力为:200

注：仍然有问题：不同的实例，却被赋予了一模一样的属性

1.2.3__init__()（改进版）

class Dog():
    def __init__(self,name,hp,atk,armor): #在实现类的时候，自动调用init的代码块
        self.name = name
        self.hp = hp
        self.atk = atk
        self.armor = armor
	def info(self):
        print("%s的生命值为:%d" % (self.name,self.hp))
        print("%s的攻击力为:%d" % (self.name,self.atk))
        print("%s的防御力为:%d" % (self.name,self.armor))

xiaocaigou = Dog("小菜狗",3000,136,68)
xiaocaigou.info()
jingmao = Dog("金毛",1000,155,87)
jingmao.info()
#输出：
#小菜狗的生命值为:3000
#小菜狗的攻击力为:136
#小菜狗的防御力为:68
#金毛的生命值为:1000
#金毛的攻击力为:155
#金毛的防御力为:87
#完美解决问题！！！！

1.2.4对象的打印（打印的是对象的地址）

#创建两个类，将其打印
class Dog():
    def __init__(self): #在实现类的时候，自动调用init的代码块
        self.name = '菜狗'
        self.hp = 2000
        self.atk = 300
        self.armor = 200

chaiquan = Dog()
hashiqi = Dog()
print(chaiquan)
print(hashiqi)
#输出：
#<__main__.Dog object at 0x000002537E7A49A0>
#<__main__.Dog object at 0x000002537E7A4CA0>

1.2.5魔法方法__str__()

class Dog():
    def __init__(self): #在实现类的时候，自动调用init的代码块
        self.name = '菜狗'
        self.hp = 2000
        self.atk = 300
        self.armor = 200
    def __str__(self): # 定义了打印实例化对象的时候需要输出的信息
        return "成功定义了一个Dog类"

puddle = Dog()
print(puddle) #输出：成功定义了一个Dog类
#(如果不定义，默认输出地址)

1.3类的继承

1.3.1创建一个父类

#创建一个父类
class Dog():  #所有定义的类都默认继承于父类Object
    def __init__(self):
        self.name = "dog dad"
    def skill(self):
        print('attack people')


#创建一个子类
class Son(Dog):  #括号内表示继承于父类Dog
    pass

jingmao = Son()
print(jingmao.name)
jingmao.skill()
#输出：
#dog dad
#attack people

1.3.2继承多个类

class Dog1():  #所有定义的类都默认继承于父类Object
    def __init__(self):
        self.name = "dog dad"
    def skill1(self):
        print('attack people')

class Dog2():
    def __init__(self):
        self.name = 'dog mom'
    def skill1(self):
        print("attack dog")
    def skill2(self):
        print("shake tail")
        
class Son1(Dog1,Dog2):
    pass

class Son2(Dog2,Dog1):
    pass

hashiqi = Son1()
hashiqi.skill1()
print(hashiqi.name)

#输出:
#attack dog
#dog dad

labuladuo = Son2()
labuladuo.skill1()
print(labuladuo.name)

#输出：
#attack dog
#dog mom

注：在子类的属性或方法存在冲突时，优先继承前面的属性（方法）

1.3.3重写子类的属性

class Dog1():  #所有定义的类都默认继承于父类Object
    def __init__(self):
        self.name = "dog dad"
    def skill1(self):
        print('attack people')

class Dog2():
    def __init__(self):
        self.name = 'dog mom'
    def skill1(self):
        print("attack dog")
    def skill2(self):
        print("shake tail")
        
class Son(Dog1,Dog2):
    def __init__(self):
        self.name = 'dog son'
    def skill1(self):
        print("sleep")
        
guibin = Son()
guibin.skill1()
print(guibin.name)
#输出：
#sleep
#dog son

1.3.4对子类属性修改后，仍希望访问父类的属性和方法(基础方法)

class Dog1():  #所有定义的类都默认继承于父类Object
    def __init__(self):
        self.name = "dog dad"
    def skill1(self):
        print('attack people')

class Dog2():
    def __init__(self):
        self.name = 'dog mom'
    def skill1(self):
        print("attack dog")
    def skill2(self):
        print("shake tail")
        
class Son(Dog1,Dog2):
    def __init__(self):
        self.name = 'dog son'
    def skill1(self):
        print("sleep")
    def dad_skill(self):
        Dog1.__init__(self)
        Dog1.skill1(self)
    def mom_skill(self):
        Dog2.__init__(self)
        Dog2.skill1(self)
guibin = Son()
guibin.skill1()
guibin.dad_skill()
guibin.mom_skill()
print(guibin.name)

#输出：
#sleep
#attack people
#attack dog
#dog mom
#(调用父类的__inir__()方法可以改变子类的属性)

注：以上方法有巨大的问题，如果一个类的名字突然改变，修改量是巨大的

1.3.4对子类属性修改后，仍希望访问父类的属性和方法(进阶super()方法)

class Dog1():  #所有定义的类都默认继承于父类Object
    def __init__(self):
        self.name = "dog dad"
    def skill1(self):
        print('attack people')

class Dog2():
    def __init__(self):
        self.name = 'dog mom'
    def skill1(self):
        print("attack dog")
    def skill2(self):
        print("shake tail")
        
class Son(Dog1,Dog2):
    def __init__(self):
        self.name = 'dog son'
    def skill1(self):
        print("sleep")
    def dad_skill(self):
        super().__init__() #不需要加上self
        super().skill1()
guibin = Son()
guibin.skill1()
guibin.dad_skill()
print(guibin.name)

#输出：
#sleep
#attack people
#dog dad

1.4类的多态

1.4.1多态的实例理解

class Dog():
    def __init__(self):
        self.name = 'dog dad'
    def skill(self):
        print("attack people")
        
class Dog1(Dog):
    def skill(self):
        print("attack man")
        
class Dog2(Dog):
    def skill(self):
        print("attack woman")
        
class Dog3(Dog):
    def skill(self):
        print("attack kid")
     
Son1 = Dog1()
Son2 = Dog2()
Son3 = Dog3()

Son1.skill() #调用的都是父类的方法，但是输出的形式不一样，这是多态的体现
Son2.skill()
Son3.skill()

#输出:
#attack man
#attack woman
#attack kid