初识面向对象

class Dog:          #定义了Dog类
    a = 100         #静态变量
    def __init__(self,name,boold,ad,type):
        self.name = name        #相当于self.__dict__['name'] = name        实例变量
        self.boold = boold      #相当于self.__dict__['boold'] = boold
        self.ad = ad            #相当于self.__dict__['ad'] = ad
        self.type = type        #相当于self.__dict__['type'] = type

    def bite(self,person):          #动态变量 方法
        person.boold -=self.ad
        print(f"{self.name}攻击力{person.name},{person.name}掉了{self.ad}点血")

class Person:       #定义了Person类
    def __init__(self,name,boold,ad,type):
        self.name = name
        self.boold = boold
        self.ad = ad
        self.type = type
    def fight(self,dog):
        dog.boold -=self.ad
        print(f'{self.name}攻击了{dog.name},{dog.name}掉了{self.ad}点血')
        
        
langgou = Dog('langgou',100,10,'哈士奇')       #实例化对象
taibai = Person('taibai',200,5,'man')


print(Dog.a)            #静态变量一般使用类名查看            
langgou.bite(taibai)    #调用类方法
taibai.fight(langgou)

 

 一. 初识类:

 

　　类 ：具有相同方法和属性的一类事物,在python中一切皆对象　

　　对象 ：具有具体的属性值的实际存在的例子,也是实例

　　数据类型 也是类

 　　对象 就是具体的数字
　　 所以有的列表都能够使用list的方法
 　　所以有的数字都能够使用int的方法

 

　　实例化的过程 ：
     　　1.开辟了一块空间，创造了一个self变量来指向这块空间
     　　2.调用init,自动传self参数，其他的参数都是按照顺序传进来的
     　　3.执行init
     　　4.将self自动返回给调用者

　　　　1.类名可以调用所有定义在类中的名字
     　　变量
     　　函数名
　　　　2.对象名 可以调用所有定义在对象中的属性
     　　在init函数中和self相关的
     　　调用类方法的时候，会把当前的对象当做第一个参数传递给self

　　类的加载顺序:

　　　　1.类内部一个缩进的所有代码都是在py文件从上到下解释的时候就已经被执行了(先开辟一块内存加载类内部的代码)
　　　2.类中的代码永远是从上到下依次执行的

　　class Person:
    　　print(111)
    　　def __init__(self,name,age,sex):
        　　print(1)
        　　self.name = name
        　　self.name = name
        　　self.name = name
    　　print(222)
　　　　'''
　　　　没有调用类但是会将类中的代码由上到下加载一遍然后返回给Person
　　　　111
　　　　222
　　　　'''

二. 类和对象的命名空间

 

 

 

 

class Student:
    def __init__(self,name,age,sex):　　　　　　　　　　　　　　　　实例化的过程:
        self.name = name　　　　　　　　　　　　　　　　　　　　　　　　 1. 开辟一块空间,创造了一个self变量指向这块空间
        self.age = age　　　　　　　　　　　　　　　　　　　　　　　　　 2. 调用init,自动传self参数
        self.sex = sex　　　　　　　　　　　　　　　　　　　　　　　　　 3. 执行init　　
    a = 1　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 4. 将 self返回给调用者
    b = 2　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
    def func(self):
        pass

yang = Student('yang',20,'male')

 

类和对象的命名空间
     类的命名空间 是在定义类的阶段被加载进来的：
         静态变量、类变量 —— 直接定义在类中的变量
         动态变量、方法 —— 定义在类中的函数
         魔术方法、双下方法
             内置的方法 ：__init__
             内置的变量 : __dict__

     对象的命名空间  实例化的时候创建出来的
         类指针、类对象指针 执行init之前就已经在了
         对象的属性   是在执行init以及之后被添加的

 

　　　　1. 只要是对一个对象.名字直接赋值，那么就是在这个对象的空间内创建了新的属性
　　　　2. 只要是对一个可变的数据类型内部的变化，那么仍然是所有的对象和类共享这个改变的成果

　　　　3. 所有的静态变量都是用类名来操作，这样修改就能被所有的对象感知到
　　　　4. 如果是对于可变数据类型的静态变量 操作的是这个数据内部的内容，也可以使用对象来调用

　组合

　　　　软件重用的重要方式除了继承之外还有另外一种方式，即：组合

　　　　组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合

　　　　str int等都是类,在使用自定义类的时候调用str int属性也是类的组合

　　　　

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

    def area(self):                 #圆的面积计算方法
        return pi*self.r**2         

    def perimeter(self):            #圆的周长计算方法
        return 2*pi*self.r

# 圆环类


class Ring:
    def __init__(self,r1,r2):
        c1 = Circle(r1)
        c2 = Circle(r2)
        if r1>=r2:                 #保证outer的半径大于inner
            self.outer = c1       # 组合
            self.inner = c2       # 组合
        else:
            self.inner = c1       # 组合
            self.outer = c2       # 组合

    def area(self):                 
        return self.outer.area() -self.inner.area()        #直接可以调用Circle的方法进行计算圆环的面积
    
    def perimeter(self):
        return self.outer.perimeter() + self.inner.perimeter()