九、面向对象

class School:
    def __init__(self,name,addr,type):   #定义为__init__类中不用写return，自动return self，self实际就是实例本身，是一个字典
        self.name=name
        self.addr=addr
        self.type=type
    def kaoshi(self):
        print(‘kaoshi‘)
    def zhaosheng(self):
        print(‘zhaosheng‘)

school1=School(‘oldboy‘,‘沙河‘,‘私立‘)   #生成实例，类名（参数），生成实例时，会自动调用__init__函数，将school1传给self，oldboy传给name，沙河传给addr,私立传给type
print(school1.__dict__)     #打印实例的属性字典，{‘type‘:‘私立‘,‘name‘:‘oldboy‘,‘addr‘:‘沙河‘}
print(School.__dict__)　　#打印类的属性字典

　　class People:
  　　  country=‘China‘
  　　  x=1
  　　  def __init__(obj, x, y, z): #obj=obj1,x=‘egon‘,y=18,z=‘male‘
  　　      obj.name = x
   　　     obj.age = y
   　　     obj.sex = z
   　　 def run(self):
    　　    print(‘----->‘, self)

　　obj1=People(‘egon‘,18,‘male‘) #People.__init__(obj1,‘egon‘,18,‘male‘)
　　obj2=People(‘lxx‘,38,‘female‘) #People.__init__(obj2,‘lxx‘,38,‘female‘)
　　obj3=People(‘alex‘,38,‘female‘) #People.__init__(obj3,‘alex‘,38,‘female‘)

class Chinese:
    dang=‘gongchandang‘
    def aaa():
        print(‘aaa‘)
    def bbb(self):
        print(‘bbb‘)

print(Chinese.dang)     #调用类的数据属性
Chinese.aaa()           #调用类的函数属性
Chinese.bbb(‘hh‘)       #定义bbb时没有使用任何参数，所以传参可以随便传

print(dir(Chinese))     #查看类的属性列表
print(Chinese.__dict__) #查看类的属性字典

print(Chinese.__dict__[‘dang‘])   #通过属性字典调用类的属性
Chinese.__dict__[‘aaa‘]()         #通过属性字典调用类的函数属性

class Chinese:
    dang=‘gongchandang‘
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender
    def aaa():
        print(‘aaa‘)
    def bbb(self):
        print(‘bbb‘)
    def eat(self,food):
        print(‘%s吃%s‘%(self.name,food))
        
p1=Chinese(‘张‘,18,‘female‘)  #生成实例，将p1传给__init__的self，张传给name，18传给age,female传给gender
print(p1.dang)   #p1的属性字典里，只有name,age,gender没有属性dang，当调用实例没有的属性时，自动向上一级在类中查找，如果类中也没有，则报错
p1.bbb()         #实例没有函数属性，但可以调用类的函数属性
p1.aaa()         #报错，实例使用.的方式调用类的函数属性时，会自动填写self参数，写成p1.aaa(self),而定义aaa时不需要参数，所以，类中的方法，都需要有一个self参数
p1.eat(‘面‘)
Chinese.aaa()  #类调用函数属性时不会自动加self
Chinese.bbb()  #报错

#增加变量属性
Chinese.country=‘中国‘    
#增加函数属性
def play(self,ball): 
    print(‘%s play %s‘%(self.name,ball))
Chinese.play_ball=play


#删除属性
del Chinese.country


#修改变量属性
Chinese.dang=‘gongchandang123‘
#修改函数属性
def play_ball(self,ball):
    print(‘%s play %s‘%(self.name,ball))
Chinese.aaa=play_ball


#查看属性
Chinese.dang
Chinese.play_ball()

class Chinese:
    country=‘china‘
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print(‘%s play %s‘%(self.name,ball))

p1=Chinese(‘alex‘)    #生成实例
#print(p1.__dict__)    #查看实例属性字典{‘name‘:‘alex‘}


#增
#实例只能增加数据属性，没有函数属性。因为生成实例时，只是执行了__init__函数，所以只有数据属性
p1.age=18
print(p1.__dict__)  #{‘name‘:‘alex‘,‘age‘:‘18‘}


#删
del p1.name
print(p1.__dict__)  #{‘age‘:‘18‘}


#改
p1.age=19
print(p1.__dict__)  #{‘age‘:‘19‘}


#查
print(p1.age)
print(p1.play_ball(‘pingpang‘))

#例1
class Chinese:
    country=‘China‘
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print(‘%s play %s‘%(self.name,ball))
        
p1=Chinese(‘alex‘)
print(p1.country)    #China
p1.country=‘China666‘    #相当于增加实例的属性，不影响类的属性
print(Chinese.country)   #China
print(p1.country)   #China666


#例2
country=‘China‘
class Chinese:
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print(‘%s play %s‘%(self.name,ball))

p1=Chinese(‘alex‘)
print(p1.country)   #报错，实例查找属性时，先在自己的属性字典中找，找不到，在类中找，再找不到则报错


#例3
country=‘China‘
class Chinese:
    def __init__(self,name):
        self.name=name
        print(‘*****‘,country)   #此处的country只是变量名，调用类或实例的属性时，采用.的方式，如p1.country
p1=Chinese(‘alex‘)    #***** China


#例4
country=‘China‘
class Chinese:
    country=‘***China***‘
    def __init__(self,name):
        self.name=name
        print(‘---->‘,country) 
print(Chinese.country)    #***China***
p1=Chinese(‘alex‘)    #----> China
print(p1.country)    #***China***