def dog(name,gender,type):
     def jiao():
         print('狗%s叫'%dog['name'])
     def cs():
         print('狗%scs'%dog['type'])
     def init(name,gender,type):
         dog1 = {
             'name' : name,
             'gender' :gender,
             'type':type,
             'jiao':jiao,
             'cs':cs,

         }
         return dog1
     return init(name,gender,type)

# 定义类，实例化及数据属性、函数属性的增删改查
class Chinese:
    '''中国人'''
    dang = '共产_党'
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def chi_shuijiao(self):
        print('中国人吃水饺')

    def he_cha(self):
        print('中国人%s喝茶'%self.name)

p1 = Chinese('ocean',18,'male')
print(p1.dang) #共产_党
print(p1.name) #ocean

p1.chi_shuijiao() #中国人吃水饺
p1.he_cha()# 中国人ocean喝茶
#---------------增删改查----------------
#----数据属性
Chinese.dang = '国民_党'  #改
print(p1.dang) #国民_党

Chinese.ren ='中国人' #增
print(p1.ren)   #中国人

print(Chinese.__dict__)#删
del Chinese.dang
print(Chinese.__dict__)

print(Chinese.ren)   #查
#----------函数属性
def eat_food(self,food):
    print('%s正在吃%s'%(self.name,food))

Chinese.eat = eat_food   #增
p1.eat('满汉全席')  #ocean正在吃满汉全席

def test(self):     #改
    print('test')

Chinese.he_cha=test
p1.he_cha() #test

一门面向对象的语言不一定会强制你写 OO 方面的程序。例如 C++可以被认为“更好 的 C”;而 Java,则要求万物皆类,此外还规定,一个源文件对应一个类定义。

然而,在 Python 中, 类和 OOP 都不是日常编程所必需的。尽管它从一开始设计就是面向对象的,并且结构上支持 OOP,但 Python 没有限定或要求你在你的应用中写 OO 的代码 

用面向对象语言写程序，和一个程序的设计是面向对象的，两者是八杆子打不着的两码事。

纯C写的linux kernel事实上比c++/java之类语言搞出来的大多数项目更加面向对象——只是绝大部分人都自以为自己到处瞎写class的面条代码才是面向对象的正统、而死脑筋的linus搞的泛文件抽象不过是过程式思维搞出来的老古董。

 class Animal:

     def eat(self):
         print("%s 吃 " %self.name)

     def drink(self):
         print ("%s 喝 " %self.name)

     def shit(self):
         print ("%s 拉 " %self.name)

     def pee(self):
         print ("%s 撒 " %self.name)

 class Cat(Animal):

     def __init__(self, name):
         self.name = name
         self.breed = '猫'

     def cry(self):
         print('喵喵叫')

 class Dog(Animal):

     def __init__(self, name):
         self.name = name
         self.breed='狗'

     def cry(self):
         print('汪汪叫')

 # ######### 执行 #########

 c1 = Cat('小白家的小黑猫')
 c1.eat()

 c2 = Cat('小黑的小白猫')
 c2.drink()

 d1 = Dog('胖子家的小瘦狗')
 d1.eat()

class Dad:
    money = 10000
    def __init__(self,name):
        self.name = name

    def hit_son(self):
        print('%s正在打儿子'%self.name)

class Son(Dad):
    money = 2000000000
    pass

print(Son.money)
print(Dad.money)
s1 = Son('jack')
s1.hit_son()
# 结果：
#
#
# jack正在打儿子

#_*_coding:utf-8_*_

#一切皆文件

import abc
class All_file(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        '子类必须实现读功能'
        pass

    @abc.abstractmethod
    def write(self):
        '子类必须实现写功能'
        pass

class Txt(All_file):
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的写入方法')

class Sata(All_file):
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的写入方法')

class Process(All_file):
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的写入方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#归一化,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

 class A:
     def test(self):
         print('A')

 class B(A):
     def test(self):
         print('B')

 class C(A):
     def test(self):
         print('C')

 class D(B):
     def test(self):
         print('D')

 class E(C):
     def test(self):
         print('E')

 class F(D,E):
     def test(self):
         print('F')

 f1 = F()
 f1.test()
 print(F.__mro__) #新式继承顺序：F-->D-->B-->E-->C-->A

 #_*_coding:utf-8_*_
 # 每个类中都继承了且重写了父类的方法
 class A:
     def __init__(self):
         print('A的构造方法')
 class B(A):
     def __init__(self):
         print('B的构造方法')
         A.__init__(self)

 class C(A):
     def __init__(self):
         print('C的构造方法')
         A.__init__(self)

 class D(B,C):
     def __init__(self):
         print('D的构造方法')
         B.__init__(self)
         C.__init__(self)

     pass
 f1=D()

 print(D.__mro__) #python2中没有这个属性
 #运行结果：
 # D的构造方法
 # B的构造方法
 # A的构造方法
 # C的构造方法
 # A的构造方法
 # (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
 ################################################################################
 #每个类中都继承了且重写了父类的方法
 class A:
     def __init__(self):
         print('A的构造方法')
 class B(A):
     def __init__(self):
         print('B的构造方法')
         super(B,self).__init__()

 class C(A):
     def __init__(self):
         print('C的构造方法')
         super(C,self).__init__()

 class D(B,C):
     def __init__(self):
         print('D的构造方法')
         super(D,self).__init__()

 f1=D()

 print(D.__mro__) #python2中没有这个属性
 # 运行结果：
 # D的构造方法
 # B的构造方法
 # C的构造方法
 # A的构造方法
 # (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)