python面向对象

类和对象

用类创造对象
类：对应的就是类别，相同事物，相同统称就是属于类
对象：通过类创造出来的具有相同特征和行为的事物的统称想，帮助我们在编程中完成的事物
特征就是属性
行为即为方法
先有类再有对象，再有函数，

面向对象调用

调用对象：可以通过self来访问调用，自己的属性和方法

1. 类名。类属性调用
2. 类名。类方法调用
3. 对象名 = 类名（“可以传入要用的工具”）
4. 对象名。方法名（“可以传入想要的变量”）
5. 对象名。属性名
6. self。对应的变量
7. 对象2。方法名（对象1）：里面的变量参数可以传进去
8. 父类。实例方法（self）
   类属性能如果数据保持不变的话就定义类属性，能减少内存空间
   类属性用类。属性名进行修改，下面的调用这个数据都是修改后的数据
   静态方法不会传递self和cls形参需要对象，不需要占多大内存空间，可以比如成一个·函数

#定义一个洗衣机类
class washer():
    def wash(self):
        print("能洗衣服")
    def wesh(self):
        print("能甩干")
    def suaig(self):
        print("能放水")

class mashe():


#创建对象
washer = washer()
washer.wash()
washer.wesh()
washer.suaig()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

创建添加获取属性：

class Hero(object):
    def move(self):
        print("前往往事出发点")
    def attack(self):
        print("发出了一个攻击")
taidamier = Hero()
#添加一些属性，等号后面附上的值
taidamier.name = "小李"
taidamier.hp = 2000
taidamier.atk = 200
taidamier.armor  = 300
print("英雄 %s 的生命值：%d" % (taidamier.name,taidamier.hp))
print("英雄 %s 的攻击里 %d" % (taidamier.name,taidamier.atk))
print("英雄 %s 的防御里 %d"% (taidamier.name,taidamier.armor))
taidamier.move()
taidamier.attack()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class xrk():
    def xiangri(self):
        print("放阳光")
class wd():
    def wandou(self):
        print("放炮，摇头")
class jg():
    def jianguo(self):
        print("阻挡")
class js():
    def jiangs(self):
        print("走，跑跳，吃，死")
xiang = xrk()
xiang.xiangri()
wan = wd()
wan.yan = "红色"
wan.fang = "直发"
wan.yao = "摇头"
print("豌豆的头发颜色：%s 发型： %s  行为：%s" % (wan.yan,wan.fang,wan.yao))
wan.wandou()
jian = jg()
jian.xiex ="200"
jian.lei = "护甲高"

jian.jianguo()
print(f"坚果的血量:{jian.xiex},他的技能:{jian.lei}")
jiang = js()
jiang.yans = "蓝色"
jiang.jiangs()
print(f"僵尸的颜色为：{jiang.yans}")

class Dog():
    def eat(self):
        print(f"一只颜色为：{wang.color}狗狗在打闹")
wang = Dog()

wang.color ="红色"
wang.eat()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

魔法方法

魔法方法_init__()方法的作用：初始化对象。
魔法方法_init__()方法，在创建一个对象时默认被调用，不需要手动调用
魔法方法__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。

class Hero(object):
    def __init__(self,name,skill,hp,atk,armor):
        self.name = name
        self.skill = skill
        self.hp = hp
        self.ark = atk
        self.armor = armor
    def move(self):
        print("%s 正在前往支援"% self.name)
    def attack(self):
        print("发出来一个技能 %s" % self.skill)
    def info(self):
        print(f"{self.name}的攻击力为{self.ark}，防御力{self.armor},生命力为{self.hp}")
taidamier = Hero("小李","小龙问路",500,300,400)
luban = Hero("鲁班","导弹来袭",300,400,100)

taidamier.move()
taidamier.attack()
taidamier.info()
luban.move()
luban.attack()
luban.info()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

魔法方法：

__str__()方法：返回出来的是str字符串
如果类定义了str方法，那么就会打印从在这个方法中 return 的数据。
print（）：打印出来的可以成为文档说明，而不在是内存地址



class Hero(object):
    def __init__(self,name,skill,hp,atk,armor):
        self.name = name
        self.skill = skill
        self.hp = hp
        self.ark = atk
        self.armor = armor
    def move(self):
        print("%s 正在前往支援"% self.name)
    def attack(self):
        print("发出来一个技能 %s" % self.skill)
    def __str__(self):
        return f"{self.name}的攻击力为{self.ark}，防御力{self.armor},生命力为{self.hp}"
taidamier = Hero("小李","小龙问路",500,300,400)
luban = Hero("鲁班","导弹来袭",300,400,100)

print(taidamier)
print(luban)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

扩展：

__return__：在交互式环境中包含对象时显示对象描述信息
可以将方法列入到列表中
1
2

__del__()方法：当删除对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法

 1. 当有变量保存了一个对象的引用时，此对象的引用计数就会加1；
 2. 当使用del() 删除变量指向的对象时，则会减少对象的引用计数。
 3.如果对象的引用计数不为1，那么会让这个对象的引用计数减1，
 当对象的引用计数为0的时候，则对象才会被真正删除（内存被回收）当生命周期结束时进行回收


1
2
3
4
5
6
7
8

例子

搬家具

class Furniture(object):
    def __init__(self,name,area):
        self.name = name
        self.area = area

class Home(object):
    def __init__(self,address,area):
        self.address = address
        self.area = area
        self.free_area = area
        self.furniture = []
    def __str__(self):
        return f"房屋地理位置{self.address},房屋面积{self.area}，家具剩余面积{self.free_area}，已经搬进去的家具{self.furniture}"
    def add_furniture(self,item):
        if item.area < self.free_area:
            self.furniture.append(item.name)
            self.free_area -= item.area
        else:
            print("家具太大")
bed = Furniture("床",100)
sofa = Furniture("操场",1000)
diz = Home("北京",1000)
diz.add_furniture(bed)
print(diz)
#第一点为：创建要搬进去的名字可面积生成一个类别，让第二个类的方法调用第一个类的对象
#第二点：初始化方法可以生成列表与其他，属性可以相等同一个属性值
#第三点：不同类中的方法中的形参可以在不同初始类中调用__init__属性值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

面向对象继承
类A就是基类，也叫做父类；类B就是派生类，也叫做子类。
子类继承父类，就可以继承父类的属性，和方法，

#继承
class A(object):
    def __init__(self):
        self.name = 10
    def print(self):
        print(self.name + 10)
class B(A):
    pass
C = B()
print(C.name)#继承了属性
C.print()#继承了方法
#子类继承父类，就可以继承父类的属性，和方法，

1
2
3
4
5
6
7
8
9
10
11
12
13

继承顺序： 一个子类继承了多个父类，如果多个父类有同名的属性和方法，我们会优先继承第一个顺位的。
重写： 当自己的属性和方法与继承的父类的属性和方法重名时会被重写成自己的属性和方法

查看继承关系：print(类名.mro)
子类调用父类的同名方法
调用父类的同名方法和属性，需要加入__init__来初始化一下，调用方法或者属性时，要用self来

扩展

__new__魔法方法：在创建对象时，这个对象实际上是通过这个方法魔法方法创建，只不过我们之前如果没有定义这个魔法方法，那么它使用的是父类的这个方法
创建对象的过程分两部
1：创建一个对象
2：给创建好的对象初始化属性。

class Master(object):
    def __init__(self):
        self.kongfa = "古法煎饼果子"
    def make_cake(self):
        print(f"这个是一个{self.kongfa}")
class School(object):
    def __init__(self):
        self.kongfa = "现代煎饼果子"
    def make_cake(self):
        print(f"这是一个{self.kongfa}")
class prentice(School,Master):
    def __init__(self):
        self.kongfa = "自创的煎饼果子"
    def make_cake(self):
        self.__init__()#子类也用了__init__的初始化
        print(f"这是一个{self.kongfa}")
    def mast_old_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
        School.__init__(self)
        School.make_cake(self)
      

# mast = Master
# school = School
damao = prentice()
damao.make_cake()
damao.mast_old_cake()
#父类.__init__（self）
#父类.方法（self）父类调用同名方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

super（）：
调用父类的函数方法，自动查找上一层父类同名方法
super（）.init
super（）.方法名

class Master(object):
    def __init__(self):
        self.kongfu = "古老的配方"
    def meka(self):
        print(f"这个是{self.kongfu}")
class School(Master):
    def __init__(self):
        self.kongfu = "现在的配方"
    def meka(self):
     
        print(f"这个是{self.kongfu}")
        super().__init__()
        super().meka()

class Prenyice(School):
    def __init__(self):
        self.kongfu = "测试版的配方"
    def meka(self):
        # self.__init__(self)
        print(f"这个是{self.kongfu}")
        super().__init__()
        super().meka()

    # def gulao_mast(self):
    #     Master.__init__(self)
    #     Master.meka(self)
    # def xianzao_sch(self):
    #     School.__init__(self)
    #     School.meka(self)
mow = Prenyice()
mow.meka()
# mow.gulao_mast()
# mow.xianzao_sch()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

私有属性和私有方法

设置私有的属性和方法前面加上两道下划线，子类无法继承其私有属性和方法，但只能在本类中能使用

伪私有属性和方法用：对象.__类名.__属性名可以调用

# 第八题
class Animal(object):
    def run(self):
        print("这个是动物")
    def eat(self):
        print("这个在吃饭")
class Cat(Animal):
    def __init__(self):
        self.__name = "波斯猫"
    def run(self):
        print(f"这个是猫类{self.__name}")
    def eat(self):
        print(f"这个{self.__name}在吃饭")
class Dog(Animal):
    def __init__(self):
        self.__name = "京巴狗"
    def run(self):
        print(f"这只{self.__name}在玩")
    def eat(self):
        print(f"{self.__name}在吃饭")
def lerun(lase):#创建一个函数方法，用方法中的参数连接对应的想要调用的方法，如方法名相同，
    #用类定义对象，函数（对象名）==就直接调用上面的链接的方法
    lase.run()
lase = Animal()
lerun(lase)

cat = Cat()
cat.run()
cat.eat()
lerun(cat)

dog = Dog()
dog.run()
dog.eat()
lerun(dog)
lerun(dog)

 	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40