Python25 面向对象

def person(name,age,sex,job):   #这类函数相当于模板
    data = {
        'name':name,
        'age':age,
        'sex':sex,
        'job':job
    }

    return data

def dog(name,dog_type):
    data = {
        'name':name,
        'type':dog_type
    }
    return data

d1 = dog("李磊","京巴")

p1 = person("严帅",36,"F","运维")

p2 = person("林海峰",27,"F","Teacher")

def bark(d):
    print("dog %s:wang.wang..wang..."%d['name'])

def walk(p):
    print("person %s is walking..." %p['name'])

d1 = dog("李磊","京巴")
p1 = person("严帅",36,"F","运维")
p2 = person("林海峰",27,"F","Teacher")

walk(p1) bark(d1)

p1 = person("严帅",36,"F","运维")
bark(p1) #把人的对象传给了狗的方法

def person(name, age, sex, job):
    def walk(p):
        print("person %s is walking..." % p['name'])

    data = {
        'name': name,
        'age': age,
        'sex': sex,
        'job': job,
        'walk': walk
    }

    return data

def dog(name, dog_type):
    def bark(d):

        print("dog %s:wang.wang..wang..." % d['name'])

    data = {
        'name': name,
        'type': dog_type,
        'bark': bark        #将bark这个函数的内存地址retur给dog
    }

    return data

d1 = dog("李磊","京巴")
p1 = person("严帅",36,"F","运维")
p2 = person("林海峰",27,"F","Teacher")

print (d1['bark'](d1))  #(d1['bark'](d1)) == (data['bark'](data))

# d1['bark'](p1) 把人的对象传给了狗的方法

执行结果：
dog 李磊:wang.wang..wang...
None    #这里是因为bark函数没有被return，所以为空

p2['walk'](p2)

执行结果：
person 林海峰 is walking...

def db_conn():
    print("connecting db...")

def db_backup(dbname):
    print("导出数据库...",dbname)
    print("将备份文件打包，移至相应目录...")

def db_backup_test():
    print("将备份文件导入测试库，看导入是否成功")

def main(): #main是一个大块，这个大块集成了很多小块（将很多独立的函数集成到一块）
    db_conn()
    db_backup('my_db')
    db_backup_test()

if __name__ == '__main__':
    main()

写重复代码是非常不好的低级行为
你写的代码需要经常变更 

#role 1
name = 'Alex'
role = 'terrorist'
weapon = 'AK47'
life_value = 100

#rolw 2
name2 = 'Jack'
role2 = 'police'
weapon2 = 'B22'
life_value2 = 100

role 1
name = 'Alex'
role = 'terrorist'
weapon = 'AK47'
life_value = 100
money = 10000

#rolw 2
name2 = 'Jack'
role2 = 'police'
weapon2 = 'B22'
life_value2 = 100
money2 = 10000

#role 3
name3 = 'Rain'
role3 = 'terrorist'
weapon3 = 'C33'
life_value3 = 100
money3 = 10000

#rolw 4
name4 = 'Eric'
role4 = 'police'
weapon4 = 'B51'
life_value4 = 100
money4 = 10000

roles = {
    1:{'name':'Alex',
       'role':'terrorist',
       'weapon':'AK47',
       'life_value': 100,
       'money': 15000,
       },
    2:{'name':'Jack',
       'role':'police',
       'weapon':'B22',
       'life_value': 100,
        'money': 15000,
       },
    3:{'name':'Rain',
       'role':'terrorist',
       'weapon':'C33',
       'life_value': 100,
       'money': 15000,
       },
    4:{'name':'Eirc',
       'role':'police',
       'weapon':'B51',
       'life_value': 100,
       'money': 15000,
       },
}

print(roles[1]) #Alex
print(roles[2]) #Jack

被打中后就会掉血的功能
开枪功能
换×××
买枪
跑、走、跳、下蹲等动作
保护人质（仅适用于警察）
不能杀同伴
。。。

def shot(by_who):
    #开了枪后要减×××数
    pass
def got_shot(who):
    #中枪后要减血
    who[‘life_value’] -= 10
    pass
def buy_gun(who,gun_name):
    #检查钱够不够,买了枪后要扣钱
    pass

class Role(object):
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
        #以上代码是属性

    def shot(self):
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")

    def buy_gun(self,gun_name):
        print("just bought %s" %gun_name)
    #以上代码是功能

r1 = Role('Alex','police','AK47') #生成一个角色
r2 = Role('Jack','terrorist','B22')  #生成一个角色
#以上代码是角色

代码量少了近一半
角色和它所具有的功能可以一目了然看出来

class Dog(object):

    print("hello,I am a dog!")  #这里相当于一个功能

d = Dog() #实例化这个类，
#此时的d就是类Dog的实例化对象

#实例化，其实就是以Dog类为模版，在内存里开辟一块空间，存上数据，赋值成一个变量名

执行结果：
hello, i am a dog.

class Dog(object):

    def sayhi(self):

        print("hello,I am a dog" )  #功能不应该直接放在class下，应该定义在函数中

d = Dog()   #第一条狗
d2 = Dog()  #第二条狗

d.sayhi()
d2.sayhi()

执行结果:
hello,I am a dog
hello,I am a dog
#可以看到根本分不清是哪一条狗的信息

class Dog(object):

    def __init__(self,name):
        self.name = name

    def sayhi(self):
        print("hello,I am a dog , my name is" name )    #在当前函数中没有name这个参数和变量，而且也无法到__init__这个函数中去调用，name属于局部参数

d = Dog("maomao")
d2 = Dog("lele")

d.sayhi()
d2.sayhi()

执行结果：
Traceback (most recent call last):
  File "E:/Python/练习代码/003.py", line 14, in <module>
    d.sayhi()
  File "E:/Python/练习代码/003.py", line 8, in sayhi
    print("hello,I am a dog , my name is" ,name)
NameError: name 'name' is not defined   #报错name找不到

class Person:

    def setName(self,name):
        self.abc = name

    def getName(self):
        return self.abc

    def greet(self):
        print ("hello ,world! I'm %s." % self.abc)

foo = Person()  #foo是Person()的对象，foo会将自己这个对象作为第一参数传入函数中，也就是传给self；  实例化后产生的对象（foo)叫 实例，所以self就是实例本身
bar = Person()
foo.setName('Luke') #将"Luke"当做第二参数传入参数中，也就是传给name；定义self.abc(相当于foo.abc)这个新变量==name("Luke")；然后看到其他函数也都继承了self这个参数，也就是说self.abc可以被该类中的其他任何函数（方法）继承使用。
bar.setName('Amy')  #bar.setName('Amy')==Person.setName('Amy')
foo.greet() #可以看做Person.greet(foo)
bar.greet()

执行结果：
hello ,world! I'm Luke.
hello ,world! I'm Amy.

class Dog(object):

    def __init__(self,name):    #构造函数，构造方法==初始化方法，__init__是创建类时必写的内容，实例传递参数需要传给构造函数。 这样才能被其他类的方法所调用。

        self.abc = name

    def sayhi(self):    #类的方法，在创建任何一个方法时，self都会被自动创建。
        print("hello,I am a dog , my name is" ,self.abc)

d = Dog("maomao")   # 这里相当于调用了 def __init__(self,name)，将d传给self，将"maomao"传给name
d2 = Dog("lele")

d.sayhi()   #相当于Dog.sayhi()
d2.sayhi()

class Dog(object):

    def __init__(self,name,dog_type):
        self.name = name
        self.type = dog_type

    def sayhi(self):    

        print("hello,I am a dog, my name is ",self.name)    

d = Dog('LiChuang',"京巴")  #先去实例化，把Dog这个模板变成具体的对象，d就成为了实例化后的对象
d.sayhi()   #在调用这个对象中的sayhi功能

# d = Dog('LiChuang', "京巴")
# d.sayhi()

print(Dog) 

<class '__main__.Dog'>

class Dog(object):

    def __init__(self,name):
        self.abc = name

    def sayhi(self):
        print("hello,I am a dog , my name is" ,self.abc)

    def eat(self,food):
        print ("%s is eating %s" %(self.abc,food)) #这里的food在本函数中可以直接调用，只有定义了self.food=food这个变量，才可以使用self.food方式

d = Dog("maomao")  
d2 = Dog("lele")

d.sayhi()   
d2.sayhi()

d.eat('baozi')

执行结果：
hello,I am a dog , my name is maomao
hello,I am a dog , my name is lele
maomao is eating baozi

class Role(object):
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        self.name = name    #这个name相当于属性或者叫成员变量
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
        self.__heart="Normal"   #私有属性：对外是不可见的，是不能被访问的
        #以上代码是属性

    def shot(self): #定义其中一个方法，或者叫动态属性
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")
        self.__heart = "Die"    #私有属性可以被内部访问
        print (self.__heart)    #在内部访问私有属性

    def get_heart(self):    #对外部提供只读访问接口
        return self.__heart #让私有属性可以访问，但不可以修改

    def buy_gun(self,gun_name):
        print("just bought %s" %gun_name)
    #以上代码是功能

r1 = Role('Alex','police','AK47') #生成一个角色
r2 = Role('Jack','terrorist','B22')  #生成一个角色
#以上代码是角色

print (r1.name)
print (r1.__heart)
执行结果：
Alex

Traceback (most recent call last):
  File "E:/python/代码练习/002.py", line 27, in <module>
    print (r1.__heart)
AttributeError: 'Role' object has no attribute '__heart'
#私有属性无法被外部访问

print (r1.name)

r1.got_shot()

执行结果：
Alex
ah...,I got shot...
Die     #可以看到是可以被内部（got_shot）所访问的

print (r1.get_heart())
执行结果：
Normal  #此时这个私有属性可以被访问，但不能被修改

print( r1._Role__heart) #强制访问私有属性
执行结果：
Normal

访问got_shot方法中的私有属性:
r1.got_shot()   #运行了r1.got_shot方法，这里__heart就是"Die"了
print( r1._Role__heart) #在去取值__heart就是，取值的就是got_shot中的__heart了
执行结果：
ah...,I got shot...
Die
Die

class Role(object):

    nationality = "USA"     #公有属性，在class下面直接定义的变量就是公有属性

    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name    #成员属性，指定了具体参数，参数不同就表示是不同的成员
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
        self.__heart = "Normal"
        # 以上代码是属性

    def shot(self):     #这个函数也属于公有属性，不管有多少个实例化对象，都是到class下去调用这个函数（方法）
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")
        self.__heart = "Die"

    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)
        # 以上代码是功能

r1 = Role('Alex', '警察', 'AK47') #生成一个角色
r2 = Role('dashan', '警犬', 'B22')  #生成一个角色

print( r1.weapon)
执行结果：
AK47    #可以看到这个AK47武器只能被r1这个实例化后的对象访问，不能被r2访问，所以就不满足公有属性的条件；  这个AK47属于成员属性，只属r1；r2要访问r1的成员属性也可以，但必须经过r1这个对象来访问

print( r1.nationality)  
print( r2.nationality)
#r1和r2这两个对象都可以访问nationnality这个公有属性

Role.nationality = 'JP' 修改类的公有属性

print( r1.nationality)  #r1会现在当前局部去找nationality这个变量，如果找不到就会去超类（父类）中去找，这里说明r1是引用这个公有属性就是超类的nationality
print( r2.nationality)

执行结果：
JP  #可以看到r1和r2的公有属性都被修改了，在类下会修改所有对象的公有属性
JP

Role.nationality = 'JP'

print( r1.nationality)
print( r2.nationality)

r1.nationality = 'CN'   #这里是r1新创建的一个变量叫nationality，虽然和超类中的nationality同名，但是它们两个之间没有任何关系；  此时局部已经有一个叫nationality的变量了，就不会到超类中（类似不会去全局中）找nationality变量了。   这个局部的nationality不是公有属性，只有class下的nationality才是。
print( r1.nationality)
print( r2.nationality)

执行结果：
JP
JP
CN  #可以看到这里被修改了
JP

#下面这几个代码用于把公有属性的方法 传到外部
def shot2(abc):
     print (abc)
     print ('in the shot2')
    # print (self)

r1.shot = shot2   #相当于将shot2代替r1.shot了

r1.shot(r1.nationality)  #所以这里相当于直接调用shot2这个函数

shot2(r1.nationality)        #这里相当于直接

r1.shot(r1.nationality) 和shot2(r1.nationality)执行结果：
CN
in the shot2
CN
in the shot2

class Role(object): #定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写，以后再讲为什么
    def __init__(self,name,role,weapon,life_value=100,money=15000): #初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
        self.name = name #__init__中的第一个参数self,和这里的self都 是什么意思？ 看下面解释
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

r1 = Role('Alex','police','AK47’) #生成一个角色 , 会自动把参数传给Role下面的__init__(...)方法
r2 = Role('Jack','terrorist','B22’)  #生成一个角色

r1 = Role('Alex','police','AK47’) #此时self 相当于 r1 ,  Role(r1,'Alex','police','AK47’)
r2 = Role('Jack','terrorist','B22’)#此时self 相当于 r2, Role(r2,'Jack','terrorist','B22’)

def buy_gun(self,gun_name):
    print(“%s has just bought %s” %(self.name,gun_name) )

r1 = Role('Alex','police','AK47')
r1.buy_gun("B21”) #python 会自动帮你转成 Role.buy_gun(r1,”B21")

class Role(object):

    nationality = "USA"

    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
        self.__heart = "Normal"
        # 以上代码是属性

    def shot(self):
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")
        self.__heart = "Die"

    def __del__(self):  #析构函数（析构方法） 
        print ("del.....run...")
#__del__在对象(r1)销毁的时候被调用，当对象不再被使用时，__del__方法运行

r1 = Role('Alex', '警察', 'AK47')  # 生成一个角色

执行结果：
del.....run...
#代码只做了一个实例化，没有主动去调用del这个方法依然自动执行了
析构函数是用来释放内存空间的，比如一个全局变量被引用后那么除非这个程序执行完成，那么它就会一直占用内存空间；  相关的引用被执行完成后依然会占用内存空间，如果引用过多的话可能你得内存就不够用了，所以需要将接下来不会再次调用，或者使用不到的引用占用的内存空间给释放出来，所以就用到了析构函数，它就是当程序执行完成后会自动调用该虚构函数，然后将内存释放出来。

# 再次强调，析构函数只有在实例（对象）被销毁的时候才会调用！！！   这个析构函数你是否写都会被执行，因为默认有一个析构函数，只不过自己写的话相当于将析构函数给重构了。

class Person(object):
    #当不需要传参数的时候，可以不创建构造函数
    def talk(self):
        print ("person is talking...1")

class BlackPerson(Person):  #继承Person这个父类

    pass

b = BlackPerson()
b.talk()    #继承父类，会将其方法也继承

执行结果：
person is talking...1

class Person(object):

    def talk(self):
        print ("person is talking...1")

class BlackPerson(Person):
    #继承后，自己也可以额外的创建其他方法
    def walk(self):     
        print ("is walking......")

b = BlackPerson()
b.talk()
b.walk()

执行结果：
person is talking...1
is walking......

class Person(object):

    def talk(self):
        print ("person is talking...1")

class BlackPerson(Person):

    def talk(self): #自己写一个talk方法
        print ("bala..bala.bala")

    def walk(self):
        print ("is walking......")

b = BlackPerson()
b.talk()
b.walk()

执行结果：
bala..bala.bala #如果本地局部有talk这个方法，就用本地的，没有则用继承的talk方法。
is walking......

class Person(object):

    def __init__(self,name,age):    #创建构造函数
        self.name = name
        self.age = age

    def talk(self):
        print ("person is talking...1")

class BlackPerson(Person):
    #子类 没有写构造函数，但是会继承父类的构造函数
    def talk(self):
        print ("bala..bala.bala")

    def walk(self):
        print ("is walking......")

b = BlackPerson()
b.talk()
b.walk()

执行结果:
Traceback (most recent call last):
  File "E:/python/代码练习/002.py", line 21, in <module>
    b = BlackPerson()
TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'
#可以看到报错了，这是因为子类继承了父类的构造函数，继承的构造函数需要传参数

b = BlackPerson("smith",30) #修改该代码，传入参数给继承过来的构造函数中的形参

执行结果：
bala..bala.bala
is walking......
##代码中并没有打印参数，所以不会显示

class Person(object):

    def __init__(self,name,age):    #self==b,name和age等于子类(BlackPerson)的name和age
        self.name = name
        self.age = age
        self.power = "Normal"   #self.power这里并没有传入参数

    def talk(self):
        print ("person is talking...1")

class WhitePerson(Person):  #先创建一个白人函数方法备用
    pass

class BlackPerson(Person):  #继承Person父类

    #现在需要给黑人函数增加一个独有的功能“力量”，所以就需要创建构造函数；
    #但是因为需要保持继承父类的构造函数功能，这里不能直接重构构造函数，否则就将继承过来的构造函数给覆盖了（局部优先引用），这样父类的功能（name、age）就无法使用了； 所以最后需要不但能够正常继承父类的功能，自己还可以扩展；需要先继承，在重构。

    #class BlackPerson(Person)这里已经相当于继承了父类的构造函数，如果子类在创建__init__构造函数的话就是重构 构造函数

    def __init__(self,name,age,strength): #重构 构造函数（重构后默认就就不继承了）
    #当实例化BlackPerson后候会将b传给子类的self,将参数传给子类形参；
        Person.__init__(self,name,age)  #调用父类构造函数（同时继承）
        #因为重置了构造函数，所以需要调用父类的构造函数，调用了父类的构造函数后，相同名称的属性就会被父类覆盖；在子类中新建且父类构造函数中没有的，此时子类就实现了继承，而且子类同时可以建立新的属性。
        #继承构造函数，会调用Person的init方法，init方法要求有self、参数name和age。   
        print (self.name,self.age,self.power) #这里print的都是Person这个父类的变量

        self.strength = strength    #设置自己的扩展功能
        print (self.strength)

    def talk(self): #此处创建talk这个方法，就不会在继承父类的talk方法，这里相当于将talk方法也给重置了
        Person.talk(self)   #既然不能继承了，却可以调用，我们这里调用一下父类中的talk方法; 不过这样没有什么意义，一般都是重构构造函数，很少有重构方法的。
        print ("bala..bala.bala")

    def walk(self):
        print ("is walking......")

b = BlackPerson("smith",30,"strong") #实例化后的BlackPerson会继承Person
b.talk()
b.walk()

执行结果：
smith 30 Normal 
#虽然重构了构造函数，但调用了父类的构造函数，所以相同名称的属性就被覆盖了（smith和30），而self.power并没有重复，所以依然还是从父类继承过来的结果（"Normal"）
strong
person is talking...1
bala..bala.bala
is walking......

#写一个学校成员的代码，学生和老师都属于成员，每个加进学校的成员都需要注册
class SchoolMember(object): #类的命名首字母要大写，这是命名规范
    members = 0  # 初始学校人数为0，公有属性，老师和学生都可以访问
    def __init__(self ,name ,age):
        self.name = name
        self.age = age
        self.enroll()  # 成员注册，用于被子类继承

    def enroll(self):
        '''注册'''
        print ("just enrolled a new school member [%s]" % self.name)
        SchoolMember.members +=1   #调用公有属性（这里不是继承过来的）
        #这里不能使用self.member += 1，否则只会在实例中去相加了；不同的实例会在各自的实例中相加，这样打印的时候肯定就不是所有成员总数了

    def tell(self):
        '''print成员信息'''
        print ('-------info:%s--------'%self.name)
        for k,v in self.__dict__.items():
            print ('\t',k,v)

        print ('-------end:%s--------')

    def __del__(self):
        print ('开出了[%s]...' % self.name)
        SchoolMember.members -= 1

class Teacher(SchoolMember):
    '''讲师子类'''
    def __init__(self,name,age,salary,course):
        '''course教课'''
        SchoolMember.__init__(self,name,age)
        self.salary = salary
        self.course = course

    def teaching(self):
        '''讲课的功能'''
        print ('Teacher [%s] is teaching [%s]' %(self.name,self.course))
class Student(SchoolMember):
    '''学生子类'''
    def __init__(self,name,age,course,tuition):
        '''tuition学费'''
        SchoolMember.__init__(self,name,age)
        self.course = course
        self.tuition = tuition
        self.amount = 0 #amount交学费的功能，默认0元

    def pay_tuition(self,amount):
        '''交学费的功能'''
        print ("student [%s] has just paied [%s]" %(self.name,amount))
        self.amount += amount

t1 = Teacher("Wusir",28,3000,"Python")
s1 = Student("HaiTao",38,"PYS16",30000)
s2 = Student("LiChuang",12,"PYS16",11000)

print (SchoolMember.members)

del s2  #使用del函数会直接调用到s2父类中的析构函数__del__；  （del s2就会触发Student继承了SchoolMember下的def __del__(self)，然后执行SchoolMember.members -= 1）
print (SchoolMember.members)

执行结果：
just enrolled a new school member [Wusir]
just enrolled a new school member [HaiTao]
just enrolled a new school member [LiChuang]
3
开出了[LiChuang]... #del s2时会直接跳到父类中的__del__（因为Student继承了）
2
#下面两个被删除是因为在程序结束的时候会自动调用析构函数，如果使用debug一直执行的话就不会出现下面两个信息了
开出了[Wusir]...  
开出了[HaiTao]...

print (t1.__dict__)
执行结果：
{'name': 'Wusir', 'age': 28, 'salary': 3000, 'course': 'Python'}
可以看到，可以将t1的形参和实际参数通过字典的方式打印出来

t1.tell()   #直接调用t1实例中的tell()方法
s1.tell()
s2.tell()
执行结果：
-------info:Wusir--------
     name Wusir
     age 28
     salary 3000
     course Python
-------end:%s--------
-------info:HaiTao--------
     name HaiTao
     age 38
     course PYS16
     tuition 30000
     amount 0
-------end:%s--------
-------info:LiChuang--------
     name LiChuang
     age 12
     course PYS16
     tuition 11000
     amount 0
-------end:%s--------

SchoolMember.__init__(self, name, age)    #经典类写法
super(Teacher,self).__init__(name,age)  #新式类写法，也是用来继承父类的，效果一样

class SchoolMember(object): 
    members = 0
    def __init__(self ,name, age):
        self.name = name
        self.age = age
        self.enroll()

    def enroll(self):
        '''注册'''
        print("just enrolled a new school member [%s]" % self.name)
        SchoolMember.members += 1

    def tell(self):
        '''print成员信息'''
        print('-------info:%s--------' % self.name)
        for k, v in self.__dict__.items():
            print('\t', k, v)

        print('-------end:%s--------')

    def __del__(self):
        print('开出了[%s]...' % self.name)
        SchoolMember.members -= 1

class Second(object):   #新建一个父类
    '''第二个父类'''

    def test(self):
        print ('test......................')

class Teacher(SchoolMember,Second): #继承新的父类
    '''讲师子类'''

    def __init__(self, name, age, salary, course):
        '''course教课'''
        super(Teacher,self).__init__(name,age)  #使用的是新式类
        self.salary = salary
        self.course = course

    def teaching(self):
        '''讲课的功能'''
        print('Teacher [%s] is teaching [%s]' % (self.name, self.course))

class Student(SchoolMember):
    '''学生子类'''

    def __init__(self, name, age, course, tuition):
        '''tuition学费'''
        SchoolMember.__init__(self, name, age)
        self.course = course
        self.tuition = tuition
        self.amount = 0  # amount交学费的功能，默认0元

    def pay_tuition(self, amount):
        '''交学费的功能'''
        print("student [%s] has just paied [%s]" % (self.name, amount))
        self.amount += amount

t1 = Teacher("Wusir", 28, 3000, "Python")
t1.test()   #调用集成父类中的方法

s1 = Student("HaiTao", 38, "PYS16", 30000)
s2 = Student("LiChuang", 12, "PYS16", 11000)

print(SchoolMember.members)

del s2
print(SchoolMember.members)

执行结果：
just enrolled a new school member [Wusir]
test......................  #成功执行新父类中的test方法；  继承多个父类这种方式实际中用的较少。
just enrolled a new school member [HaiTao]
just enrolled a new school member [LiChuang]
3
开出了[LiChuang]...
2
开出了[Wusir]...
开出了[HaiTao]...

#### 新式类 VS 经典类

class Person(object):  #新式类；  ，
class Person:   #经典类

SchoolMember.__init__(self, name, age)    #经典类写法
super(Teacher,self).__init__(name,age)  #新式类写法，也是用来继承父类的，效果一样

class A(object):
    def __init__(self):
        self.n = 'A'
class B(A): #继承A
    def __init__(self):
        self.n = 'B'

class C(A): #继承A
    def __init__(self):
        self.n = 'C'

class D(B,C):   #继承B和C
    def __init__(self):
        self.n = 'D'

d = D()
print (d.n)

执行结果：
D   #每一个class都定义了self.n，肯定是局部的优先级最高，所以结果是D

class A(object):
    def __init__(self):
        self.n = 'A'
class B(A): #继承A
    def __init__(self):
        self.n = 'B'

class C(A): #继承A
    def __init__(self):
        self.n = 'C'

class D(B,C):   #继承B和C
    pass
    #def __init__(self):
        #self.n = 'D'

d = D()
print (d.n)

执行结果：
B   #从左到右先继承了B中的self.n，与C中的self.n冲突的话，就不会再去继承C的self.n了。

class A(object):
    def __init__(self):
        self.n = 'A'
class B(A):
    pass
    # def __init__(self):
    #     self.n = 'B'

class C(A):
    def __init__(self):
        self.n = 'C'

class D(B,C):
    pass
    # def __init__(self):
    #     self.n = 'D'

d = D()
print (d.n)

执行结果：
C   #从左到右，B去掉了，就会继承C；  如果此时还有E、F什么的，左面找不到的话，只要右边存在就会一直向右查找，这叫做广度查询

class A:    #修改为经典类，然后复现上面代码的情况
    def __init__(self):
        self.n = 'A'
class B(A):
    pass
    # def __init__(self):
    #     self.n = 'B'

class C(A):

    def __init__(self):
        self.n = 'C'

class D(B,C):
    pass
    # def __init__(self):
    #     self.n = 'D'

d = D()
print (d.n)

执行结果：
C   #可以看到执行结果依然是C，好像看似经典类和新式类没什么区别，下面我们换到Python2的环境使用这一段代码测试

#依然是上面的代码
class A:
    def __init__(self):
        self.n = 'A'
class B(A):
    pass
    # def __init__(self):
    #     self.n = 'B'

class C(A):

    def __init__(self):
        self.n = 'C'

class D(B,C):
    pass
    # def __init__(self):
    #     self.n = 'D'

d = D()
print (d.n)

class A:    
    pass
    # def __init__(self):   
    #     self.n = 'A'
class B(A):    
    pass
    # def __init__(self):
    #     self.n = 'B'

class C(A):

    def __init__(self):
        self.n = 'C'

class D(B,C):
    pass
    # def __init__(self):
    #     self.n = 'D'

d = D()
print (d.n)

    class创建方法和继承方式都用新式类；
    创建class用新式类，可以广度查找，这样查找时会更优。
    继承时使用super（新式类），可以同时继承多重父类，不像经典类，必须指定父类的名称（继承多少个父类，就要指定几个）才能继承；当多继承时要注意的是子类会从左到右的广度查找顺序来继承，左边的父类如果没有找到则向右去找（广度查找），这个广度查找只是先去找构造函数和对应的属性，否则就去找下一个父类的构造函数和属性；   当继承多个父类的时候，每个父类都有参数的话，只能继承其中一个父类的参数，假如A父类有1、2两个参数，B父类有3这一个参数，那么1、2、3这个三个参数不能同时被继承，所以在写代码的时候，最好是写只继承一个父类即可！！！！！！！！！！  

class AA(object):   #父类AA
    def __init__(self,A1,A2):
        self.A1 = A1
        self.A2 = A2
class BB(object):   #父类BB
    def __init__(self,B1,B2):
        self.B1 = B1
        self.B2 = B2

class ZiLei(AA):
    def __init__(self,A1,A2,name1,BB_obj): #先重构
        super(ZiLei,self).__init__(A1,A2) #在继承

        self.BB = BB_obj    #这里直接将BB这个类传进来即可，通过这种方式关联其他父类的内容
        print (self.BB.B1)  #在self.BB后面再通过 点 来调用相应的内容
        print (self.BB.B2)

BB_obj = BB('b111','b222')  #实例化BB这个类

zilei = ZiLei('a111','a222','name1111',BB_obj)  #将BB_obj这个实力传入

执行结果：
b111
b222

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")
        #raise是主动使其发送一个错误到执行后的屏幕身上

class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' %self.name)

class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)

c1 = Cat('小白')
d1 = Dog('小黑')

c1.talk()
d1.talk()

执行结果：
小白: 喵喵喵!
小黑: 汪！汪！汪！
#我们在执行的时候指定了c1.talk和d1.talk方法才会去执行，这里需要指定两个接口，而我们不想通过指定c1或d1才会执行两个接口；  只想通过一个接口来实现方法的执行，只是在执行的时加入不同的形态（c1就是猫叫，加入d1就是狗叫），来实现一个接口，多种形态。

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' %self.name)

class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)

def func(obj):  # 一个接口，多种形态
    obj.talk()

c1 = Cat('小白')
d1 = Dog('小黑')

func(c1)    #将c1传给obj参数，然后在执行obj.talk()，其实相当于变相执行c1.talk()，只不过可以利用这种方法实现一个借口，多种形态；   这只是一个这种的方法，并不是真正的多态实现方法。
func(d1)

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' %self.name)

class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)

def func(obj):  # 一个接口，多种形态
    obj.talk()

c1 = Cat('小白')
d1 = Dog('小黑')

Animal.talk(c1) 
Animal.talk(d1)

执行结果：
Traceback (most recent call last):
  File "E:/Python/练习代码/001.py", line 29, in <module>
    Animal.talk(c1)
  File "E:/Python/练习代码/001.py", line 7, in talk
    raise NotImplementedError("Subclass must implement abstract method")
NotImplementedError: Subclass must implement abstract method

#可以看到并没有执行成功，并报错。

这是因为当使用Animal.talk(c1)时，在子类中talk这个方法已经被重写了，重写后只能通过c1.talk()这种方式调用了

- class 类:
    def 函数1():
        pass
    def 函数2():
        pass 

obj = 类() #obj是对象，对象就是将类实例化的过程
obj.函数1() #在面向对象中只不能直接调用函数，需要通过对象来调用函数（方法）

每创建一个对象，都会存在内存中，对象越多内存开销越大；所以说从调用、使用的角度来看，直接调用函数是更方便的，而面向对象反而会更复杂。  在实际的工作当中面向对象（面向对象编程）能实现的功能，通过直接使用函数（函数式编程）都能实现。

有时候，通过函数式编程实现会比较麻烦，
而使用面向对象简单、快速的就能实现。

def upload():   #该函数只能上传文件
    连接服务器
    上传文件
    关闭

def cmd():       #该函数只能执行命令
    连接服务器
    执行命令
    关闭

def cmd():
    连接服务器  #该函数既能上传文件又能执行命令
    上传文件
    执行命令
    关闭

class SSH:
    def __init__(self,host,port,username,password):
        self.host = ...

    def connection(self):
        # 去创建连接
        self.conn = 和服务器创建的连接对象()

    def close(self):
        # 关闭
        self.conn.关闭

    def upload(self):
        self.conn  使用这个连接上传文件

    def cmd(self):
        self.conn  使用这个连接执行命令

obj = SSH(参数)  #修改这里的host(IP)和port参数就可以连接其他SSH 服务器，所以面向对象的改造型比较强
obj.connection()
obj.cmd()
obj.upload()
obj.cmd()
obj.upload()
obj.cmd()
obj.upload()
obj.close()
#我们可以使用一个连接，做多次操作，而不需要反复的许建立连接和关闭

def f1(host,port,pwd,arg):
    pass

def f2(host,port,pwd,arg1,arg2):
    pass

def f3(host,port,pwd,arg1,arg2,arg3):
    pass

f1(1,2,3,4)
f2(1,2,3,4,5)
f3(1,2,3,4,5,6)

class FOO:
    def __init__(self,host,port,pwd):
        self.host = host
        self.port = port
        self.pwd = pwd
    def f1(self,arg1):
        self.host
        self.port
        self.pwd
        pass

    def f2(self,arg1,arg2):
        self.host
        self.port
        self.pwd
        pass

    def f3(self,arg1,arg2,arg3):
        self.host
        self.port
        self.pwd
        pass

obj = FOO(1,1,1)
obj.f1(2)
obj,f2(3,4)
obj,f3(5,6,7)

class FOO:  #创建类，这个类在内存中创建一块空间
    def __init__(self,name):
        self.NAME = name    #当实例化后，相当于将对象传给了self这个形参，然后self.NAME相当于obj1.NAME，这个self.NAME属性在obj1的内存空间中体现

    def bar(self):  #类中的方法和类关联，在类的内存空间中体现
        pass

obj1 = FOO('alex')  #实例化的对象，这个对象会在内存中单独创建一块obj1空间
obj1.bar()

obj2 = FOO('eric')  #独立创建一个obj2的内存空间
obj2.bar()  

#目前为止有3个内存空间FOO、obj1、obj2

class FOO:
    def __init__(self,name,count):
        self.NAME = name    #这里可以叫普通字段或普通属性
        self.COUNT = count
        self.Country = '中国'   #这个属性会被赋予每一个对象，中国有32个省，如要针对每一个省写一个对象，那么就相当于有32个self.Country属性被保存到每一个对象中了

    def bar(self):
        print (self.NAME)
        print (self.COUNT)
        print (self.Country)

obj1 = FOO('河南',12345)
obj1.bar()

obj2 = FOO('山东',131313)
obj2.bar()

class FOO:

    country = '中国'    #公有属性在内存中属于class，不属于对象
    #在class下面创建一个变量叫做静态字段或公有属性，这个公有属性只会在class下面保存1份（32个省也是1份），class下面的每一个方法都可以调用该公有属性；
    #使用场景：当每一个方法都会用到同一个属性的时候，就可以使用这个公有属性。

    def __init__(self,name,count):
        self.NAME = name
        self.COUNT = count

    def bar(self):
        print (self.NAME)
        print (self.COUNT)

obj1 = FOO('河南',12345)
obj1.bar()

obj2 = FOO('山东',131313)
obj2.bar()

class F1:
    def __init__(self,n):
        self.N = n
        print ('F1')

class F2:
    def __init__(self,arg1):
        self.a = arg1
        print ('F2')

class F3:
    def __init__(self,arg2):
        self.b = arg2
        print ('F3')

o1 = F1('alex')
o2 = F2(o1) #o2这个对象封装了o1这个对象
o3 = F3(o2) #o3这个对象封装了o2这个对象

#o3.b=o2
#o2.a=o1
#o3.b.a=o1
#03.b.a.N=o1.N
#o3.b.a.N=alex

print (o3.b.a.N)
#o3.b相当于o2
#o3.b.a相当于o1

执行结果：
F1
F2
F3
alex

class F1:
    def __init__(self,n):
        print ('F1')

    def a1(self):
        print ('F1:a1')

class F2(F1):
    def __init__(self):
        print ('F2')

    def a1(self):
        print ('F2:a1')

class F3(F2):
    def __init__(self):
        print ('F3')

    def a1(self):
        print ('F3:a1')

obj = F3()
obj.a1()

执行结果：
F3
F3:a1
#局部优先，所以取值F3类中的a1优先，如果没有才会继承

class F1:
    def __init__(self,n):
        print ('F1')

    def a1(self):
        print ('F1:a1')

    def a2(self):
        print ('F1:a2')

class F2(F1):
    def __init__(self):
        print ('F2')

    def a1(self):
        self.a2()   
        print ('F2:a1')

    def a2(self):
        print ('F2:a2')

class F3(F2):
    def __init__(self):
        print ('F3')

    def a1(self):   
        print ('F3:a1')

    def a2(self):    #此时self是obj这个对象，对象实例化的是F3，那么a2也就是class F3中的方法a2
        print ('F3:a2')

obj = F3()
obj.a2()

静态方法：

class F1:
    @staticmethod   
    def a1():   #在类中的函数正常必须有self，但是用了@staticmethod后就可以让该类和类里面的函数当做一个正常的函数来使用
        print ('alex')

F1()    #这里无需创建对象，直接调用类即可
F1.a1()

#以上代码，其实效果和函数一模一样，没什么特别的，只是有这么一种写法而已。