面向对象基础

Posted 2020-11-15 ghylpb

目录

• 面向对象基础
  • 面向过程与面向对象编程
  • 类

面向对象基础

静待一树花开，盼你叶落归来

面向过程与面向对象编程

面向过程编程的核心是‘’过程‘’，过程指的是做事情的步骤，也就是先做什么后做什么，基于该编程思想编写程序，如同工厂的流水线。

优点：逻辑清晰，复杂的问题流程化，进而简单化

缺点：可扩展性差

什么是面向对象？

向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现。

面向对象编程：

核心是‘’对象‘’，对象指的是特征与技能的结合体。面向对象编程如同在创在世界，要有一种上帝的思维方式。

优点：可扩展性高

缺点：编写程序的复杂程度远远高于面向过程编程思想

优先使用那种思想？

面向过程结合面向对象

类

创造对象需要先学习类，类：类别、类型、分类

类：先定义类，后调用类产生对象
现实世界中：对象是一个个具体存在的事物，类是人总结出来的，所以先有对象后有类；而在程序中遵循先有类后有对象。

类有两种作用：属性引用和实例化

属性引用（类名.属性）

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

实例化对象：调用类即可产生对象，调用类的过程，又称为类的实例化，实例化的结果称为类的对象/实例，实例化会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征，语法：对象名 = 类名（参数）

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;
        
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk())  #调用方法
p1 = Person(xiaozhang)#实例化出一个对象，实例化的过程就是产生对象的过程

如何定义类：

1. 先从现实世界中抽象出类。
2. 定义类。
   对象：特征与技能的结合体，
   类：一系列对象相同的特征与技能的结合体
   定义类的语法：

  class 类名：
        对象相同的特征
        对象相同的技能
  #class：用来定义类的，后面跟类名。

注意：类名必须要用驼峰体命名,python在定义变量与函数时不推荐使用驼峰体,相同的特征指类内部的变量，相同的技能指类内部的函数。

  选课系统项目:
      - 在现实世界中:
          学生对象1:
              特征:
                  school = '×××'  学校
                  name = '高峰峰'    姓名
                  age = 93           年龄
                  sex = 'female'     性别
              技能
                  learn  学习
                  choose_course  选课
          学生对象2:
              特征:
                  school = '×××'
                  name = '小丁丁'
                  age = 84
                  sex = 'female'
              技能
                  learn
                  choose_course
          学生对象3:
              特征:
                  school = '×××'
                  name = '大丁丁'
                  age = 18
                  sex = 'male'
              技能
                  learn
                  choose_course
      类:
          相同的特征:
              school = '×××'
          相同的技能:
              learn
              choose_course

定义类发生的事情：

1.在定义类时会产生一个空的名称空间，

2.把类内的名字放在名称空间里

类在定义阶段就已经产生好了名称空间执行类内的代码

调用类名时会指向类的名称空间

类.__dict__#查看类的名称空间中所有的名字

 #__dict__只在读的时候以字典的形式去展示

类.   #指向类的名称空间
类.特征或技能   #对类内部的名字进行修改，
# . 会指向类内部的名称空间从而获取名字

特征也称之为属性

class Dog:
    def __init__(self,name,aggr,life_value):
        self.name = name
        self.aggr = aggr
        self.life_value = life_value

通过类名调用类内部的函数，这个函数就只是一个普通函数
对象的产生：
语法：
类名（）调用类产生对象，然后赋值给一个变量

当实例化出对象后，会在内存中开辟一个存储对象独有特征的名称空间。

__init__:（翻译：为对象初始化某些属性）会在调用类时，自动触发该函数__init__(self)

调用类时发生的事情：
1.首先会产生一个空对象，就是产生的“对象名称空间”
2.自动触发__init__
3.会把对象本身及括号内的参数一并传给__init__函数

给对象添加属性的方式一：类中有的属性，我们可以一个一个给它们赋值，类中没有的我们也可以通过这种方式添加，添加的内容会存储在对象的名称空间里

stu1.name = 'tank'
stu1.age = 18
stu1.gender = 'male'

print(stu1.name, stu1.age, stu1.gender)

给对象添加属性的方式二：

class Person:
    def __init__(self,name,money,aggr,life_value):
        self.name = name
        self.money = money
        self.aggr = aggr
        self.life_value = life_value
person1 = Person('nick',10000,300,1000)#方式二，当添加类中没有的属性时还是要用方式一
print(person1.__dict__)#对象名.__dict__查看对象的名称空间

{‘name‘: ‘nick‘, ‘money‘: 10000, ‘aggr‘: 300, ‘life_value‘: 1000}

对象与类的查找顺序

对象.属性，若对象本身有则先用自己的，若对象本身没有则用类的，若类也没有，则报错。

对象绑定方法的特殊之处

（对象.方法 就是对象的绑定方法）

1.由类调用类内部的函数，则这个函数需要传（self）这个参数；
2.由对象调用对象的绑定方法，会将自己作为self传入绑定方法中
对象的绑定方法__特殊之处就是把对象当做第一个参数传入绑定方法中,由不同的对象调用，就把不同的对象传给不同的绑定方法。__

对象之间与类的方法功能一样，内存地址不同

python 中一切皆对象

小练习

1. 人狗大作战

class Person:
    def __init__(self,name,money,aggr,life_value):
        self.name = name
        self.money = money
        self.aggr = aggr
        self.life_value = life_value

    def attack(self,dog):
        '''攻击方法'''
        if self.life_value  > 0:
            dog.life_value -= self.aggr
            print(f'''
            {self.name}攻击{dog.name}成功
            {self.name}生命力{self.life_value}
            {dog.name}生命力{dog.life_value}
                        ''')
            return True

class Weapon:
    '''定义武器类'''
    def __init__(self,money,aggr,life_value):
        self.money = money
        self.aggr = aggr
        self.life_value = life_value

    def update(self,obj):
        obj.money -= self.money
        obj.life_value += self.life_value
        obj.aggr += self.aggr

    def pick(self,obj):
        obj.life_value -= 500
        print(f'{obj.name}的生命力还有{obj.life_value}')



person1 = Person('nick',10000,300,1000)
dog1 = Dog('hashiqi',500,5000)
weap1 = Weapon(5000,300,2500)


if person1.money > weap1.money:
    weap1.update(person1)
    person1.weapon = weap1#将weapon放入person的个人属性里面，这样就可以调用person了
    person1.attack(dog1)
    person1.weapon.pick(dog1)

1. 定义了一个圆形类；提供计算面积(area)和周长(perimeter)的方法

   from math import pi
   class Circle:
       def __init__(self,radius):
           self.radius = radius
   
       def area(self):
           aer = pi*(self.radius**2)
           return aer
   
       def perimeter(self):
           per = 2*pi*self.radius
           return per
   
   cir1 = Circle(6)
   print(cir1.area())
   print(cir1.perimeter())

2. 圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用

from math import pi
class Circle:
    def __init__(self,radius):
        self.radius = radius

    def area(self):
        aer = pi*(self.radius**2)
        return aer

    def perimeter(self):
        per = 2*pi*self.radius
        return per

class Ring:
    def __init__(self,out_round,in_round):
        self.out_round = Circle(out_round)
        self.in_round = Circle(in_round)

    def area(self):
        are = self.out_round.area() - self.in_round.area()
        return are

    def perimeter(self):
        per = self.out_round.perimeter() + self.in_round.perimeter()
        return per
ring1 = Ring(10,5)
print(ring1.perimeter())
print(ring1.area())