为对象定制自己独有的属性、属性查找、绑定方法、类即类型、小结、继承与派生、继承的应用

定义类和调用类的使用

1、先定义类

class OldboyStudent:
        school='oldboy'

        def choose_course(self):
            print('is choosing course')

强调：类定义阶段会立刻执行类体代码，会产生类的名称空间，将类体代码执行过程中产生的名字都丢进去

print(OldboyStudent.__dict__)

# 类本质就是一个名称空间/容器，从类的名称空间中增/删/改/查名字
# python为我们提供专门访问属性（名称空间中的名字）的语法，点后的都是属性 

OldboyStudent.school  # OldboyStudent.__dict__['school']
OldboyStudent.x=1 # OldboyStudent.__dict__['x']=1
OldboyStudent.school='Oldboy'  # OldboyStudent.__dict__['school']='Oldboy'
del OldboyStudent.x # del OldboyStudent.__dict__['x']

类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个

OldboyStudent.choose_course(123)

2、后调用类产生对象，调用类的过程称之为实例化，实例化的结果称为类的一个实例或者对象

stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()
# print(stu1)
# print(stu2)
# print(stu3)

# print(OldboyStudent.school)
# OldboyStudent.school='OLDBOY'
# print(stu1.school)
# print(stu2.school)

# print(stu3.school)

 

为对象定制自己独有的属性

例1：

class OldboyStudent:

    school='oldboy'
    def choose_course(self):
        print('is choosing course')

stu1=oldboyStudent()
stu2=oldboyStudent()
stu3=oldboyStudent()

对象本质也就是一个名称空间而已，对象名称空间是用存放对象自己独有的名字/属性，而类中存放的是对象们共有的属性

# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)

stu1.name='耗哥'
stu1.age=18
stu1.sex='male'
# print(stu1.name,stu1.age,stu1.sex)
# print(stu1.__dict__)

stu2.name='猪哥'
stu2.age=17
stu2.sex='male'

stu3.name='帅翔'
stu3.age=19
stu3.sex='female'

例2：

class OldboyStudent:
    school='oldboy'
    def choose_course(self):
        print('is choosing course')

stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()

def init(obj,x,y,z):
    obj.name=x
    obj.age=y

    obj.sex=z

# stu1.name='耗哥'
# stu1.age=18
# stu1.sex='male'
init(stu1,'耗哥',18,'male')


# stu2.name='猪哥'
# stu2.age=17
# stu2.sex='male'
init(stu2,'诸哥',17,'male')


# stu3.name='帅翔'
# stu3.age=19
# stu3.sex='female'
init(stu3,'帅翔',19,'female')


print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
'''

class OldboyStudent:
    school='oldboy'

    def __init__(obj,x,y,z):
        obj.name=x
        obj.age=y
        obj.sex=z
    def choose_course(self):

        print('is choosing course')

调用类时发生两件事:

1、创造一个空对象stu1
2、自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入

stu1=OldboyStudent('jammy',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female')

stu1=OldboyStudent('耗哥',18,'male') #OldboyStudent.__init__(stu1,'耗哥',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female')

print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)

 

属性查找

class OldboyStudent:
    school='oldboy'
    count=0
    def __init__(self,x,y,z):
        self.name=x
        self.age=y
        self.sex=z
    def choose_course(self):
        print('is choosing course')

# 先从对象自己的名称空间找，没有则去类中找，如果类也没有则报错

stu1=OldboyStudent('jammy',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female'

print(OldboyStudent.count)
print(stu1.count)
print(stu2.count)
print(stu3.count)

 

绑定方法

class OldboyStudent:
    school='oldboy'

    def __init__(self,x,y,z):
        self.name=x
        self.age=y
        self.sex=z

    def choose_course(self,x):

        print('%s is choosing course'%self.name)

stu1=OldboyStudent('耗哥',18,'male')
stu2=OldboyStudent('猪哥',17,'male')

stu3=OldboyStudent('帅翔',19,'female')

print(stu1.name)

print(stu1.school)

类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个

OldboyStudent.choose_course(123)

类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的，绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入

print(id(stu1.choose_course))
print(id(stu2.choose_course))
print(id(stu3.choose_course))
# 以上三种Id都指向同一个内存地址
print(id(OldboyStudent.choose_course))

类调用的类函数属性指向的内存地址与对象对应的类函数属性不同

补充：类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self

 

类即类型

在python3中统一了类与类型的概念，类就是类型

class OldboyStudent:
    school='oldboy'

    def __init__(self,x,y,z):
        self.name=x
        self.age=y
        self.sex=y

    def choose_course(self,x):
        print('%s is choosing course'%self.name)

stu1=OldboyStudent('耗哥',18,'male')
# stu1.choose_course(1) #OldboyStudent.choose_course(stu1,1)
# OldboyStudent.choose_course(stu1,1)

列表范例：

l=[1,2,3] #l=list([1,2,3])
# print(type(l))
# l.append(4) #list.append(l,4)
list.append(l,4)
print(l)

 

小结

对象是一个高度整合的产物，整合数据与专门操作该数据的方法（绑定方法）

class foo:
    def __init__(self,host,port,db,chartset):
        self.host=host
        self.port=port
        self.db=db
        self.chartset=chartset
    def exc1(self,sql)
        conn=connect(self.host, self.port, self.db, self.charset)
        conn.execute(sql)
        return xxx
    def exc2(self,proc_name)
        conn=connect(self.host, self.port, self.db, self.charset)
            conn.execute(sql)
            return xxx

def bar():
    def __init__(self,x,y,z,a,b,c)
        self.x=x
        self.y=y
        self.z=z
        self.a=a
        self.b=b
        self.c=c

    def exec3(self,xxx)
        pass
    def exc4(self,yyy)
        pass

obj1=foo('1.1.1.1',3306,'db1','utf-8') # 自定义对应参数的值

obj1.exc1('select * from t1')
obj1.exc1('select * from t2')
obj1.exc1('select * from t3')
obj1.exc1('select * from t4')

obj2=foo('1.1.1.2',3306,'db1','utf-8') # 自定义对应参数的值
obj2.exc1('select * from t4')

 

继承与派生

1.什么是继承

    继承是一种新建类的方式，新建的类称之为子类，被继承的类称为父类
    继承的特性是，子类会遗传父类的属性
    强调：继承是类与类之间的关系

2.为什么用继承

    继承的好处就是可以减少代码的冗余

3.如何用继承

    在Python中支持一个类同时继承多个父类
    在Python3中
        如果一个类没有继承任何类，那默认继承object类
    在python2中：
        如果一个类没有继承任何类，不会继承object类

    新式类
        但凡继承了object的类以及该类的子类，都是新式类
    经典类
        没有继承object的类以及该类的子类，都是经典类

    在python3中都是新式类，只有在python2（经典类）中才区别新式类与经典类

新式类vs经典类？

class parent1:
    pass

class parent2:
    pass

class sub1(parent1,parent2):
    pass

print(sub1.__bases__)
# print(Parent1.__bases__)
# print(Parent2.__bases__)

 

继承的应用

派生：子类中新定义的属性，子类在使用时始终以自己的为准

class OldboyPeople:
    school='oldboy'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

 class OldboyStudent(OldboyPeople):
    def choose_course(self)：
        print('%s is choosing course'%self.name)

class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        # self.name=name
        # self.age=age
        # self.sex=sex
        # 以下一行代替以上三行
        OldboyPeople.__init__(self.name,age,sex)
        self.level=level

    def score(self,stu_obj,num)
        print('%s is scoring'%self.name)
        stu_obj.score=num

stu1=OldboyStudent('耗哥',18,'male')
tea1=OldboyTeacher('egon',18,'male',10)stu1=OldboyStudent

#对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。
# print(stu1.school)
# print(tea1.school)
# print(stu1.__dict__)
# print(tea1.__dict__)

tea1.score(stu1,99)
print(stu1.__dict__)

在子类派生出的新功能中重用父类功能的两种方式：
1、指名道姓访问某一个类的函数：该方式与继承无关

#对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。代码量

class Foo:
    def f1(self):
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        self.f1()

class Bar(Foo):
    def f1(self):
        print('Bar.f1')

obj=Bar()
obj.f2()
# '''
# Foo.f2
# Bar.f1
# '''

2、super()

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('开动啦...')

class Subway(Vehicle): #地铁
    def __init__(self,name,speed,load,power,line):
        #super(Subway,self) 就相当于实例本身,在python3中super()等同于super(Subway,self)
        super().__init__(name,speed,load,power)
        self.line=line

    def run(self):
        print('地铁%s号线欢迎您' %self.line)
        super(Subway,self).run()

class Mobike(Vehicle):#摩拜单车
    pass

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()