day18私有化、关联、继承

私有化

#私有化
#封装：1.私有化属性
#     2.定义公有的set和get方法
#     3.只能在类内访问
#好处：1.隐藏属性不被外界随意修改
#     2.类内通过提供公有方法来修改
#     3.在方法内可做逻辑处理
class Student:#__age=18  #类属性def __init__(self,name,age):#每创建一个对象都会调用这个方法，在该方法内初始化对象属性，使得每个对象有该属性#对象属性self.name=nameself.age=ageself.__score=59#私有属性只能在类内部访问，一般需要在类内提供公有方法来给外界访问或修改def setScore(self,score):if score>=0 and score<=100:self.__score=scoreelse:print('分数不在规定范围内')def getScore(self):return self.__scoredef __str__(self):#self表示当前对象return '姓名：{}，年龄{}，考试分数{}'.format(self.name,self.age,self.__score)yupeng=Student('宇鹏',18)
print(yupeng)
#姓名：宇鹏，年龄18，考试分数59
yupeng.age=21
yupeng.__score=90  #私有属性改变不了，不报错但也不生效
print(yupeng)
#姓名：宇鹏，年龄21，考试分数59print(yupeng.getScore())
yupeng.setScore(99)
print(yupeng.getScore())
print(yupeng)
'''
59
99
姓名：宇鹏，年龄21，考试分数99
'''


class Student:__score=99  #类属性def __init__(self,name,age):#每创建一个对象都会调用这个方法，在该方法内初始化对象属性，使得每个对象有该属性#对象属性self.__name=nameself.__age=agedef setName(self,name):if len(name)==6:self.__name=nameelse:print('名字必须6位')def getName(self):return self.__namedef __str__(self):#self表示当前对象return '姓名：{}，年龄{}'.format(self.__name,self.__age)s=Student('宇鹏',18)
print(s)
print(dir(Student))
print(dir(s))#多了一些对象属性出来
#dir可以看到的东西是我可以调用的

私有化装饰器@property

#在开发中看到一些私有化处理：装饰器
class Student:__score=99  #类属性def __init__(self,name,age):#每创建一个对象都会调用这个方法，在该方法内初始化对象属性，使得每个对象有该属性#对象属性self.name=nameself.__age=age@propertydef age(self):return self.__age@age.setter#age是上边定义的函数，因此必须先有get，再有setdef age(self,age):if age > 0 and age < 100:self.__age=ageelse:print('不在规定范围内')# def setAge(self,age):#     if age>0 and age<100:#         self.__age=age#     else:#         print('不在规定范围内')# def getAge(self):#     return self.__agedef __str__(self):#self表示当前对象return '姓名：{}，年龄{}'.format(self.name,self.__age)s=Student('peng',20)
s.name='xiaopeng'
print(s.name)#用装饰器前
# s.setAge(30)
# print(s.getAge())
#用装饰器后
print(s.age)#找age函数，但又不需要加括号
s.age=30
print(s.age)

类之间的关系

#类与类之间的关系  is a,has a（包含）
'''
公路(Road)：属性:公路名称，公路长度
车(Car):属性:车名，时速方法:1.求车名在哪条公路上以多少的时速行驶了多长，get_time(self,road)2.初始化车属性信息__init__方法3.打印对象显示车的属性信息'''
import randomclass Road:def __init__(self,name,len):self.name=nameself.len=lenclass Car:def __init__(self,brand,speed):self.brand=brandself.speed=speeddef get_time(self,road):ran_time=random.randint(1,10)msg='{}品牌的车在{}上以{}速度行驶{}小时'.format(self.brand,road.name,self.speed,ran_time)print(msg)def __str__(self):return '{}品牌的，速度：{}'.format(self.brand,self.speed)road=Road('京藏高速',12000)
car=Car('奥迪',120)
car.get_time(road)
print(car)

关联

#has a
#student book computer
'''
知识点:
1.has a一个类中使用了另外一种自定义的类型student中使用了computer book
2.类型：系统类型：str int floatlist dict tuple set自定义类型：student book computer'''
class Computer:def __init__(self,brand,color):self.brand=brandself.color=colordef online(self):print('正在使用电脑上网...')def __str__(self):return self.brand+"--"+self.color
class Book:def __init__(self,bname,author,num):self.bname=bnameself.author=authorself.num=numdef __str__(self):return self.bname+"--"+self.author+"--"+str(self.num)class Student:def __init__(self,name,computer,book):self.name=nameself.computer=computerself.books=[]#已借的书self.books.append(book)def borrow_book(self, book):for book1 in self.books:if book1.bname==book.bname:print('已经借过此书！')breakelse:self.books.append(book)print('借阅成功')def show_book(self):for book in self.books:print(book.bname)def __str__(self):return self.name+"--"+str(self.computer)+"--"+str(self.books)computer=Computer('mac','白色')
book=Book('恶意','东野圭吾',12)
student=Student('小王',computer,book)
print(student)
#小王--mac--白色--[<__main__.Book object at 0x0000013C926F8828>]
student.show_book()
book1=Book('盗墓笔记','南派三叔',12)
print('开始借书----------------')
student.borrow_book(book1)
print('----------------')
student.show_book()
'''
恶意
开始借书----------------
借阅成功
----------------
恶意
盗墓笔记
'''

继承

#is a
#如果A是B，那么就称B是A的基类
'''
继承：Student,Doctor-->都属于人，都有相同的属性和行为'''
class Person:def __init__(self,name,age):self.name=nameself.age=agedef eat(self):print(self.name+'正在吃饭...')def run(self):print(self.name+'正在跑步...')class Student(Person):#继承父类Person的所有的方法passclass Doctor(Person):def __init__(self,name,age):print('----doctor自己的init')super().__init__(name,age)class Employee(Person):def __init__(self,name,age,department,salary):super().__init__(name,age)self.department=department#自己独有的属性self.salary=salary#继承下来的东西也可以用self调用，也是该对象的一部分，但实质上他只是引用了父类的东西def doWork(self):print('员工{}正在做工作，它的薪资为{}'.format(self.name,self.salary))stu=Student('大王',48)
stu.run()
stu=Student('小王',18)
stu.run()
'''
大王正在跑步...
小王正在跑步...
'''
doct=Doctor('小惠',18)
doct.eat()
'''
----doctor自己的init
小惠正在吃饭...
'''emplo=Employee('关欣',25,'技术部',9000)
emplo.run()
emplo.doWork()
'''
关欣正在跑步...
员工关欣正在做工作，它的薪资为9000
'''

继承总结

1、如果我的类有一个eat方法是有参的，而父类的eat无参，—重写。会默认先找当前类再去找父类，但此时他与java不一样，即使参数个数不一样，他也不会往父亲找了，因此此时你调用这个类的eat方法，必须有参。
2、优先找子类，再找父类，如果子类没有__init__,则去调用父类的
3、如果类继承了父类也自己定义了__init__，就需要在当前类的init中调用父类的__init__。
super().init(参数)
super(类名，对象).init(参数)
4、子类调用父类方法
super().eat()

练习

class Person:def __init__(self,name,age):self.name=nameself.age=agedef eat(self):print(self.name+'正在吃饭...')def run(self):print(self.name+'正在跑步...')
class Student(Person):def __init__(self,name,age):super().__init__(name,age)def eat(self,food):super().eat()print('{}太好吃了'.format(food))def study(self,course):print('{}正在学习{}课程'.format(self.name,course))s=Student('xiao',12)
s.eat('鸡腿')
'''
xiao正在吃饭...
鸡腿太好吃了
'''

python没有重载

class Person:def __init__(self,name):self.name=namedef eat(self):print('--->eat1')def eat(self,food):print('---->eat:',food)#python不存在重载，后面出现同名的函数会覆盖前面的#因此这里的无参函数是调用不了的
p=Person('jack')
p.eat('番茄')

python可以多继承

#多继承，pyhton可以，java不可class A:def test(self):print('---->AAAAAAa')class B:def test1(self):print('----->BBBBBBBBBB')def same(self):print('----->B-same')class C(A,B):def test2(self):print('-------->CCCCCCC')def same(self):print('----->c-same')
c=C()
c.test()
c.test1()
c.test2()
c.same()
'''
---->AAAAAAa
----->BBBBBBBBBB
-------->CCCCCCC
print('----->c-same')
'''

#多继承，pyhton可以，java不可
class Base:def same(self):print('---Base-----')
class A(Base):def test(self):print('---->AAAAAAa')class B(Base):def test1(self):print('----->BBBBBBBBBB')def same(self):print('----->B-same')class C(Base):def test2(self):print('-------->CCCCCCC')def same(self):print('----->c-same')
class D(A,B,C):passd=D()
d.same()
import inspectprint(inspect.getmro(D))
#查看这个类的查找顺序----广度优先，一旦在这些类中找到要的方法就停止
'''
----->B-same
(<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.Base'>, <class 'object'>)'''
'''
如果父类中有相同名称的方法，搜索顺序是
'''

day18私有化、关联、继承相关推荐

Python学习5（生成器、类、属性、方法、私有化、继承、多态）
生成器通过列表推导式得到生成器要创建一个生成器,有很多种方法.第一种方法很简单,只要把一个列表生成式的 [ ] 改成 ( ) In [15]: L = [ x*2 for x in range(5 ...
继承_月隐学python第16课
目录 1.封装 1.1 属性私有化 1.2 属性装饰器 1.3 成员⽅法私有化 2.继承 2.1 单继承 2.2 多继承(理解.了解) 3.类成员作业初级中级⾯向对象三⼤特征:封装.继承.多态 ...
JavaScript实现继承的方式，不正确的是：
JavaScript实现继承的方式,不正确的是:DA.原型链继承 B.构造函数继承 C.组合继承 D.关联继承解析 javaScript实现继承共6种方式: 原型链继承.借用构造函数继承.组合继承. ...
php开发面试题---php面向对象详解（对象的主要三个特性）
php开发面试题---php面向对象详解(对象的主要三个特性) 一.总结一句话总结: 对象的行为:可以对对象施加那些操作,开灯,关灯就是行为. 对象的形态:当施加那些方法是对象如何响应,颜色,尺寸 ...
面试知识总结（八股、网络、LINUX)
问题变量的声明和定义 C++中extern "C" 的作用了解C++中编译时的优化 C++的特点是什么 C++的异常处理机制 C和C++,java的区别 C++ 11 null ...
python 100days github_GitHub - songhp/Python-100-Days: Python - 100天从新手到大师
Python教学大纲 Python应用领域和就业形势分析简单的说,Python是一个"优雅"."明确"."简单"的编程语言. 学习曲线低, ...
技术图文：03 结构型设计模式（上）
结构型设计模式(上) 本教程主要介绍一系列用于如何将现有类或对象组合在一起形成更加强大结构的经验总结. 知识结构: 享元模式 – 实现对象的复用 Sunny 软件公司欲开发一个围棋软件,其界面效果如下 ...
Python九十天学习框架，从1到90，从0基础到IQ100
每个人的基础以及学习进度都不一样,不管最后是90天学会,还是三个月,或是更久,自学按照这个来也能相对系统的学习知识,而不是零散细碎的知识最后无法整合,所以不管怎么样,学习得有个自己的框架,下面一起来看 ...
面向对象数据库NDatabase_初识
面向对象数据库介绍先拿ORM来说吧. ORM是什么, 为什么用ORM 一般来说程序是面向对象的(或者主流是面向对象的), 也就是O(Object), 那就会有对象, 关联, 继承, 聚合等一般来说 ...
python大神-国内某Python大神自创完整版，系统性学习Python
很多小伙伴纠结于这个一百天的时间,我觉得完全没有必要,也违背了我最初放这个大纲上来的初衷,我是觉得这个学习大纲还不错,自学按照这个来也能相对系统的学习知识,而不是零散细碎的知识最后无法整合,每个人的基 ...