class Person(object):
    COUNTRY = '牧师' #静态属性
    __MAGE = '法师'  # 私有静态属性,只能在类的内部使用,外部无法直接操作
    def __init__(self,name,age): #self是一块内存空间,实例化后会存放属性的值
        self.name = name #属性,属于对象的值 --对象属性
        self.__age = age #对象的私有属性 ,私有属性不能被继承,只能在类的内部使用,外部无法直接操作
    def running(self): #类的方法,方法自带self参数,动态属性
        print('%s running'%self.name) #使用对象属性
        print(self.__age) #使用对象的静态属性
print(Person.COUNTRY) #查看类的静态属性 类名.静态属性名
ret = Person('wanglan',18) #ret:对象  实例化
print(ret.name) #使用对象查看对象属性
ret.running() #使用对象调用类中的方法

什么是类:具有相同属性和方法的一类事事物
什么是对象:对象是类中一个具体的例子(拥有具体的属性值和具体的方法),对象就是类的实例化,类的实例
什么是实例:实例完全和对象是一样的
什么是实例化:由类创建对象的过程
实例化的过程:1.创建一个属于对象的空间  2.将这个空间的地址和参数传递给__init__方法 3.执行init方法,4.将对象的空间返回给对象名
静态属性:所有的这个类的对象都共有的属性
什么是对象的属性:存储在实例化之后创建的空间中的所有变量都是对象的属性,每一次实例化产生的空间都是独立的,每一个对象都有自己的属性值
对象能做什么:调用对象的属性,调用类中的方法(动态属性)
什么是动态属性:定义在类中的函数,自带一个self属性
类中的代码在实例化之前执行
类的命名空间中有静态属性和动态方法

class Person(object):
    NAME = 'WL'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(self.name)
        print(self.age)
person = Person('wanglan','18')
print(Person.__dict__) #类名.__dict__,查看类中的变量,属性,不能操作,只能查看
print(person.__dict__) #对象名.__dict__会将对象属性和值以字典的方式打印出来
print(person.__dict__['name']) #取值

class Person(object):
    NAME = 'WL'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(self.name)
        print(self.age)
person = Person('wanglan','18')
#查看属性值
print(person.name)
# 修改属性的值
person.name = 'wl'
print(person.name)
#添加一个属性
person.gender = '男'
print(person.gender)
#删除属性的值
del person.gender
print(person.gender)

class Dog:
    def __init__(self,name,kind,hp,ad):
        self.name = name
        self.kind = kind
        self.hp = hp
        self.ad = ad
    def bite(self,person):
        print('%s咬人%s'%(self.name,person.name))
        person.hp -= self.ad
        if person.hp <= 0 :
            print('%s死了'%person.name)
            person.hp = 0
# 实例化一些对象
xm = Person('xiaoming','男',10,10,100)
eh = Dog('二哈','金毛',9999,998)
print(eh.hp) #查看二哈的hp
xm.attack(eh) #小明攻击了二哈,
print(eh.hp) # 再次查看二哈的hp
print(xm.hp) #查看小明的hp
eh.bite(xm) #二哈咬了小明
print(xm.hp) #再次查看小明的hp

class A:
    Country = 'China'
    def talk(self):
        print('%s is talking'%self.name)
xm = A()
xm.name = 'alex'
xm.talk()
# 在没有__init__的情况下,实例化经历了哪些步骤???
# 1.创建一个空间给对象
# 2.将这个空间的地址返回

对象和类之间有一个单向的联系,类对象指针
对象在使用某个名字的时候,如果在自己的空间中没有找到,就要到类的空间中去找

class A:
    Country = 'China' # 静态属性就是用来描述所有的对象都共享的某一个值
    def __init__(self,name):
        self.name = name
    def talk(self):
        print('%s is talking'%self.name)
xiaogao = A('xiaogao')
print(xiaogao.Country)
xiaogao.Country = '泰国'  #在xiaogao中创建,并不是去找静态属性
print(xiaogao.Country)   # '泰国'
del xiaogao.Country
print(xiaogao.Country)   # 'China'
print(A.Country)

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
c1 = Circle(10)
print(c1.area())
print(c1.perimeter())

class Ring:
    def __init__(self,outer_r,inner_r):
        self.out_c = Circle(outer_r)   # Circle(10)
        self.in_c = Circle(inner_r)   # Circle(5)

    def area(self):
        return self.out_c.area() - self.in_c.area()

    def perimeter(self):
        return self.out_c.perimeter() + self.in_c.perimeter()

r1 = Ring(10,5)
print(r1.area())
print(r1.perimeter())

class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

class Student:
    def __init__(self,name,sex,birth_day):
        self.name = name
        self.sex = sex
        self.birthday = birth_day

birth = Birthday(1996,9,13)
bobo = Student('bobo','male',birth)
# birth == bobo.birthday
# birth.year
print(bobo.birthday.year)

import pickle
class Course:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def __str__(self):
        return ('%s %s %s' %(self.name,self.age,self.gender))
xl = Course('xiaoming',18,'男')
print(xl)
with open('courses','wb') as f:
    pickle.dump(xl,f)  #写入文件
with open('courses','rb') as f:
    ret = pickle.load(f)
    print(ret)

如果load一个对象,那么这个对象所对应的类必须已经在内存中
同一个类的对象 会存储在同一个文件中

class A:pass
class B(A):pass
print(A.__bases__)  #查看父类
print(B.__bases__)

结果:
(<class 'object'>,)    #类默认继承onject
(<class '__main__.A'>,)  #B继承了A

class A:pass
class B:pass
class C(A,B):pass
print(A.__bases__)
print(B.__bases__)
print(C.__bases__)

结果:
(<class 'object'>,)
(<class 'object'>,)
(<class '__main__.A'>, <class '__main__.B'>)