python之面向对象

三大编程范式：面向过程、函数式编程、面向对象编程
面向过程：核心是过程，过程指的是解决问题的步骤，设计一条流水线，机械式的思维方式
　　优点：复杂的问题流水化，
　　 缺点：可扩展性差
　　 应用场景：功能一旦实现，应用扩展性很少的场景

面向对象：核心是对象二字，对象是特征与技能的结合体
　　 优点：可扩展性强，
　　 缺点：编程复杂度高
　　 应用场景：用户需求经常变化，互联网应用、游戏，企业内部应用

类：是一系列对象相似的特征与技能的结合体
　　 强调：站在不同的角度，得到的分类是不一样的

　　在现实世界中：一定先有对象，后有类
　　在程序中： 一定得先定义类，后调用类来产生对象

class Student:
    school = '一中'  # 数据属性

    def learn(self):  # 函数属性
        print("is learning")

    def eat(self):
        print("is eating")

    def sleep(self):
        print("is sleeping")
    print("test")  # 类在定义阶段，代码会执行
    
    
stu1 = Student()
stu2 = Student()
stu3 = Student()
print(stu1, stu2, stu3)

# 查看类的名称空间
print(Student.__dict__)
print(Student.__dict__["school"])
print(Student.__dict__["learn"])

# 查
print(Student.school)  # 等同于 print(Student.__dict__["school"])
print(Student.learn)

# 增
Student.country = "China"
print(Student.__dict__)
print(Student.country)

# 删
del Student.country
print(Student.country)

# 改
Student.school = "二中"
print(Student.school)

     类Student加上 __init__方法，为对象自己定制自己独有的特征

# __init__ 方法，为对象自己定制自己独有的特征

class Student:
    school = '一中'

    def __init__(self, name, sex, age):
        self.Name = name
        self.Sex = sex
        self.Age = age

    def learn(self):
        print("is learning")

    def eat(self):
        print("is eating")


stu1 = Student("王二丫", "女", 18)  # stu1(当做第一个参数) 连同后面的 ("王二丫", "女", 18) 3个参数组成4个参数，传给init

# 加上__init__方法后，实例化的步骤
# 1、先产生一个空对象，stu1
# 2、Student.__init__(stu1,)
print(Student.__init__)  # 类Student函数方法 __init__ 的地址： <function Student.__init__ at 0x00000260A133D620>

# 查
print(stu1.__dict__)  # 查实例 stu1，结果{'Name': '王二丫', 'Sex': '女', 'Age': 18}
print(stu1.Name)
print(stu1.Sex)
print(stu1.Age)

# 改
stu1.Name = "李二丫"
print(stu1.__dict__)
print(stu1.Name)

# 删除
del stu1.Name
print(stu1.__dict__)

# 增
stu1.class_name = "101K"
print(stu1.__dict__)

# 增加实列stu2
stu2 = Student("李三", "男", 38)  #传值 __init__(stu2, "李三", "男", 38)
print(stu2.__dict__)
print(stu2.Name)
print(stu2.Age)
print(stu2.Sex)

 

  类Student，属性查找

class Student:
    school = '一中'

    def __init__(self, name, sex, age):
        self.Name = name
        self.Sex = sex
        self.Age = age

    def learn(self, x):
        print(" %s is learning %s" % (self.Name, x))

    def running(self):
        print(" %s is running" % self.Name)

    def eat(self):
        print("%s is eating" % self.Name)


stu1 = Student("王二丫", "女", 18)  # 实列化
stu2 = Student("李三炮", "男", 38)
stu3 = Student("王五", "男", 24)

        __dict__ 属性

      python中的__dict__属性,__dict__是一个字典，键是属性名，值为属性值。
      Python的实例有自己的__dict__，它对应的　　类也有自己的__dict__ （有些特殊的对象是没有__dict__属性的，这里不做讨论）

print(stu1.__dict__)  # {'Name': '王二丫', 'Sex': '女', 'Age': 18}
print(stu2.__dict__)  # {'Name': '李三炮', 'Sex': '男', 'Age': 38}
print(stu3.__dict__)  # {'Name': '王五', 'Sex': '男', 'Age': 24}

       类中的数据属性：是所有对象共有的，绑定到不同的对象是不同的绑定方法，对象调用绑定方法时，会把对象本身当作第一个传入，传给self　　

print(Student.school, id(Student.school)) # 4个id值相同，因为调用的都是类Student中同一个数据属性 school
print(stu1.school, id(stu1.school))
print(stu2.school, id(stu1.school))
print(stu3.school, id(stu1.school))

　 类中的函数属性：是绑定给对象，绑定到不同的是不同的绑定犯法，对象调用绑定方式时，会把对象本身当做第一个传入，传给self

print(Student.learn)
Student.learn(stu1, "room")
Student.learn(stu2, "library")
Student.learn(stu3, "subway")
# 等同于
stu1.learn("room")  # learn(stu1,"room")
stu2.learn("library")  # learn(stu1,"library")
stu3.learn("subway")  # learn(stu1,"subway")


# 这3个的函数地址不一样，因为实例对象不同
print(stu1.learn)
print(stu2.learn)
print(stu3.learn)

 

stu1.plus = "from stu1"  # 实例stu1 增加数据属性
print(stu1.__dict__)  {'Name': '王二丫', 'Sex': '女', 'Age': 18, 'plus': 'from stu1'}
print(stu1.plus)  # from stu1

　类 - 继承

什么是继承？
继承指的是类与类之间的关系，是一种什么“是”什么的关系，
继承的功能之一就是用来解决代码重用问题。继承是一种创建新类的方式，
在python中，新建的类可以继承一个或多个父类，父类又可以成为基类或超类，
新建的类称为派生类或子类

class Parentclass1:
    pass


class Parentclass2:
    pass


class SubClass1(Parentclass1):
    pass


class SubClass2(Parentclass1, Parentclass2):
    pass


print(SubClass1.__bases__)  # __bases__ 查看 类SubClass1 继承了哪些父类
print(SubClass2.__bases__)

 

class Hero:
    def __init__(self, nickname, attack_power, life_value):
        self.nickname = nickname
        self.attack_power = attack_power
        self.life_value = life_value

    def attack(self, enemy):
        enemy.life_value -= self.attack_power


class Garen(Hero):
    camp = "Demacia"


class Riven(Hero):
    camp = "Noxus"


g1 = Garen("草丛伦", 66, 78)
r1 = Riven("雷文", 80, 98)
print(g1.nickname, g1.life_value, g1.attack_power, g1.camp)

继承-属性查找小练习

      Q：b.f2() 运行显示的结果是？

      A : from Foo .f2  --- >  from Bar .f1

    

class Foo:
    def f1(self):
        print("from Foo .f1")

    def f2(self):
        print("from Foo .f2")
        self.f1()


class Bar(Foo):
    def f1(self):  # 重点 b = Bar()，顺序，对象自己、对象所在类查找、父类查找
        print("from Bar .f1")


b = Bar()
b.f2()
print(b.__dict__)