面向对象基础部分及模块

class1 SQLHELPer:
    def __init__(self,a1,a2,a3):#成为构造方法，根据类创建的对象自动执行
        self.hhost = a1
        self.uusername = a2
        self.pwd = a3

    def fetch(self):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
    def create(self,sql):
        pass
    def remove(self,nid):
        pass
    def modify(self,name):
        pass
#根据类SQLHELPer创建对象
#自动执行SQLHELPer 的__init__方法
obj = SQLHELPer()
obj.hhost = "c1.salt.com"
obj.uusername = "Jason"
obj.pwd = "123"
obj1 = SQLHELPer(‘abc.com‘,‘jack‘,‘234‘)

class Foo:
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
obj1 = Foo(‘wupeiqi‘, 18)
print obj1.name    # 直接调用obj1对象的name属性
print obj1.age     # 直接调用obj1对象的age属性
 
obj2 = Foo(‘alex‘, 73)
print obj2.name    # 直接调用obj2对象的name属性
print obj2.age     # 直接调用obj2对象的age属性

class Foo:
  
    def __init__(self, name, age):
        self.name = name
        self.age = age
  
    def detail(self):
        print self.name
        print self.age
  
obj1 = Foo(‘wupeiqi‘, 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
  
obj2 = Foo(‘alex‘, 73)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

class Role(object):
    def __init__(self, name):
        self.name = name
    def get_name(self):
        return self.name
class Teacher(Role):
    def __init__(self, name, course):
        ‘‘‘
        如果父类已经有一个方法，子类也有一个同名的方法，就会覆盖掉父类的方法，专业术语叫做重写
        ‘‘‘
        super(Teacher, self).__init__(name) # 通过super这种语法可以调用父类的方法和变量，这里调用父类的构造方法，初始化name
        self.course = course # 这个变量是父类所没有的
    def say(self): # 定义父类的
        print(‘My name is %s, i am a English teather‘ %self.name)
if __name__ == ‘__main__‘:
    lisi = Teacher(‘lisi‘, ‘English‘) # 定义Teacher的实例
    print(lisi.name) # name这个变量是子类通过继承的方式获取的
    print(lisi.get_name()) # 继承自父类的方法
    lisi.say() # 子类特有的方法

class D:
    def bar(self):
        print(‘D.bar‘)

class C():
    def bar(self):
        print(‘C.bar‘)


class B(D):
    def bar2(self):
        print(‘B.bar‘)


class A(B,C):
    def bar1(self):
        print(‘A.bar‘)

a = A()
a.bar()##D.bar

# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C 如下图
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

class D（object）:
    def bar(self):
        print(‘D.bar‘)

class C(D):
    def bar(self):
        print(‘C.bar‘)


class B(D):
    def bar2(self):
        print(‘B.bar‘)


class A(B,C):
    def bar1(self):
        print(‘A.bar‘)

a = A()

# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D 如下图
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

a.bar()##C.bar

class Foo(object): # Foo为类名，括号内的表示是这个类继承自哪个类，这里的object是所有类的基类，一个类可以继承自多个类
    ‘‘‘
    类的说明文档，Python会自动将这里面内容赋值给类的变量__doc__
    ‘‘‘
    class_var1 = ‘var1‘ # 类的变量，它属于类本身，而不是类的对象，可以通过类名.变量名的方式进行调用，也可以对象.变量名调用，前提是，没有同名的实例变量
    def __init__(self, arg, arg2):
        ‘‘‘
        初始化方法，有点类似于java语言的构造方法，在创建类的对象的时候自动调用
        :param var2: 参数，初始化方法也可以
        :return:
        ‘‘‘
        self.var2 = arg # 对象的变量，属于对象不属于类，只能通过对象.变量名的方式调用
        self.__var3 = arg # 对象的变量，只能在内部调用，不能通过对象.变量名的方式调用，并且不能被继承
 
    def func1(self, arg):
        ‘‘‘
        方法
        1、方法属于类（也就是在实例化的时候不会像对象的变量一样单独开辟内存空间）
        2、self表示类的对象本身，当我们通过对象名.方法()来调用的时候，解释器会自动将对象作为第一个参数传给方法，方法名.方法(对象名)
        :return:
        ‘‘‘
        # 方法体，方法体可以通过self.关键字调用对象的变量和方法
        self.__var3 = arg # 方法可以调用私有变量和方法
 
    def __func2(self):
        ‘‘‘
        私有方法，和私有变量一样，不能被继承和外部调用
        :return:
        ‘‘‘
        pass
 
class Foo2(Foo):
    def __init__(self, arg, arg2):
        ‘‘‘
        1、这里调用了父类的初始化方法，特别注意由于“__变量名”表示的私有方法，
        2、这里尽管调用了父类的构造方法，__var3变量作为父类的私有方法，子类在没有重新定义之前依然没有这个变量，这点要特别注意
        :param arg:
        :param arg2:
        :return:
        ‘‘‘
        super(Foo2, self).__init__(arg, arg2)
        self.__var3 = arg2 # 由于__var3是父类的私有方法，尽管调用了父类的初始化方法，子类依然不会有，所以依然需要重新定义