第二天，为对象定制独有的属性、属性查找、绑定方法、类即类型、继承与派生、继承的应用

其他 2018-07-27 00:09:51 阅读次数: 0

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

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

    调用类时发生两件事：

    1、创造一个空对象stu1

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

'''
# 例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 #stu1.name='耗哥'
        obj.age = y  #stu1.age=18
        obj.sex = z #stu1.sex='male'

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

#调用类时发生两件事
#1、创造一个空对象stu1
#2、自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入
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__)

2、属性查找

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

class OldboyStudent:
    school='oldboy'
    count=0

    def __init__(self, x, y, z): #会在调用类时自动触发
        self.name = x #stu1.name='耗哥'
        self.age = y  #stu1.age=18
        self.sex = z #stu1.sex='male'
        OldboyStudent.count+=1

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


# 先从对象自己的名称空间找，没有则去类中找，如果类也没有则报错
stu1=OldboyStudent('耗哥',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female')

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

3、绑定方法

类名称空间中定义的数据属性和属性都是共享给所有对象用的，对象名称空间中定义的只有数据属性，而且是对象所独有的数据属性

扫描二维码关注公众号，回复： 2395774 查看本文章

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

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

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

class OldboyStudent:
    school='oldboy'


    def __init__(self, x, y, z): #会在调用类时自动触发
        self.name = x #stu1.name='耗哥'
        self.age = y  #stu1.age=18
        self.sex = z #stu1.sex='male'

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

    def func():
        pass
# 类名称空间中定义的数据属性和函数属性都是共享给所有对象用的
# 对象名称空间中定义的只有数据属性，而且时对象所独有的数据属性

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

# print(stu1.name)
# print(stu1.school)


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

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

# print(id(stu1.school))
# print(id(stu2.school))
# print(id(stu3.school))
#
# print(id(stu1.name),id(stu2.name),id(stu3.name))


# stu1.choose_course(1)
# stu2.choose_course(2)
# stu3.choose_course(3)
stu1.func()

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

4、类即类型

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

#在python3中统一了类与类型的概念，类就是类型
class OldboyStudent:
    school='oldboy'

    def __init__(self, x, y, z): #会在调用类时自动触发
        self.name = x #stu1.name='耗哥'
        self.age = y  #stu1.age=18
        self.sex = z #stu1.sex='male'

    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)

5、小结

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

'''
# 对象是一个高度整合的产物，整合数据与专门操作该数据的方法（绑定方法）
class Foo:
    def __init__(self,host,port,db,chartset):
        self.host=host
        self.port=port
        self.db=db
        self.charset=charset

    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.charsett)
        conn.call_proc(sql)
        return xxx

class 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 exc3(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')

'''

6、继承与派生

什么是继承 

继承是一种新建类的方式，新建的类称为子类，被继承的类称为父类

继承的特性是：子类会遗传父类的属性

强调：继承是类与类之间的关系

为什么用继承

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

如何用继承

在python3 中，

    如果一个类没有继承任何类，那默认继承object类

在python2中：

    如果一类没有继承任何类，不会继承object类

新式类

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

经典类

    没有继承object的类以及该类的子类，都是经典类

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

class Parent1(object):
    pass

class Parent2(object):
    pass

class Sub1(Parent1,Parent2):
    pass

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

7、继承的应用

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

对象查找属性的顺序，对象自己=对象的类=父类=父类

在子类派生出的新功能中重用父类功能的方式有两种

指名道姓访问某一个类的函数：该方式与继承无关

#派生：子类中新定义的属性，子类在使用时始终以自己的为准
class OldboyPeople:
    school = 'oldboy'
    def __init__(self,name,age,sex):
        self.name = name #tea1.name='egon'
        self.age = age #tea1.age=18
        self.sex = sex #tea1.sex='male'



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


class OldboyTeacher(OldboyPeople):
    #            tea1,'egon',18,'male',10
    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)

#对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。
# 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
# '''

由于我自认为理解的很深刻，就这样简单写写，写作业去了，不懂可以私信我。谢谢您的观看！

猜你喜欢

转载自blog.csdn.net/weixin_42157426/article/details/80817842
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022