python 类和方法（面向对象）

类和方法

name = "Jack"
city = "bejing"
print("my name is %S and come from %s "%(name,city))
print ("hello 51zxw")

name = "harry"
city = "shengzhen"
print("my name is %S and come from %s "%(name,city))
print ("hello 51zxw")

思考几个问题？如果班上有50个同学依次上面形式介绍怎么办？


类与对象

人类
属性：地域、肤色、国家
功能: 走路、思考、饮食、跑
具体对象：中国人、非洲人
学生

属性：姓名、学号、城市、年龄
功能：听、读、写、说
具体对象：jack同学、harry同学
三大特殊：封装、继承、多态

 定义一个学生的类
class Student(object):#括号不写默认也是object,可写可不写
　　def _init_(self,name,city): #构造函数
　　　　self.name = name #self相当于是是一个孩子，把名字绑定在这个孩子身上
　　　　self.city = city
　　　　print ("my name is %s and come from %s %(name,city)")
　　def talk(self):
　　　　print ("hello 51zxw")
生成实例对象
stu1 = Student("jack","beijing")#创建对象
stu1.talk() #对象调用方法
stu2 = Student("harry",shengzhen)
stu2.talk() 
输出结果：

name is jack and come from beijing
hello 51zxw

例二：

class A():
    def add(self,a,b):
        return a+b

count = A()
print (count.add(3,5))
输出结果：
8

例三

class A():
    def _init_(self,a,b):
        self.a = int(a)
        self.b = int(b)
    def add(self):
        return self.a+self.b
count = A(3,4)
count.add()
输出结果：
7
"""解析：当调用A类时首先执行_init_方法，所以需要对其进行传参，初始化做的事就是将输入的类型化为整型，而add()可以直接拿初始化的self.a self.b进行计算，调用add()时不需要再进行传参"""

类的继承

class A():
    def add(self,a,b):
        return a+b

class B(A):
    def sub(self,a,b):
        return a-b
print (B().add(3, 4)) #调用父类方法
输出结果：
7
print (B().sub(3, 4))#调用自己的方法
输出结果：
-1
先创建了A类，又创建了B类，B类继承了A类，所以B可以调用A类的方法

 Super的用法

"""
在类的继承中，重定义某个方法，该方法会覆盖爷类同名的方法，但有时，我们希望能用爷类的功能
，需要调用爷类的方法，用Super来实现
"""
class A(object):
    def __init__(self,name):
        self.name = name
    def greet(self):
        print "hello ,I am %s"%self.name
class B(A):#继承A的方法
    def greet(self):
        super(B,self).greet()#与A类有同名方法时，又不希望覆盖A类方法使用Super
        print "wangwang"
        
dog = B("cat")
dog.greet()

输出结果：
hello ,I am cat
wangwang

"""
super是在子类中调用父类的初始化方法
"""

class B1(object):
    def _init_(self,a,b):
        self.a = a
        self.b = b
        
class A1(B1): #继承父类
    def __init__(self,a,b,c):
        super(A1,self)._init_(a,b)#继承父类构造方法,又自己添加新方法，用supper
        self.c = c

涉及到多重继承

class Base(object):
    def __init__(self):
        print "enter Base"
        print "leave Base"

class A(Base):
    def __init__(self):
        print "enter A"
        super(A, self).__init__()
        print "leave A"

class B(Base):
    def __init__(self):
        print "enter B"
        super(B,self).__init__()
        print "leave B"
        
class C(B,A,):
    def __init__(self):
        print "enter c"
        super(C,self).__init__()
        print "leave c"
        
c1 = C()
"""
子类永远在父类的前面
如果有多个爷类，会根据它们在列表中的顺序执行

"""

输出结果：

enter c
enter B
enter A
enter Base
leave Base
leave A
leave B
leave c