day14 面向对象基础3
2018-08-02 本文已影响0人
跟我念一遍
01重写
继承后，子类可以拥有除父类继承的内容以外的其他的内容
1.关于方法
1）.在子类中可以直接添加其他的方法
2）.重写：a.完全重写
重新实现从父类继承下来的方法，重写后，子类再调用这个方法的时候，就调用子类的
b.保留父类实现在的功能，再添加新功能
对对象和类的调用方法的过程：
- 先看当前类是否存在这个方法，没有才看父类有没有这个方法
- 如果父类没有就看父类的父类有没有，直到找到基类（object）为止
class Animal(object):
def __init__(self):
self.age = 0
self.color = ''
def eat(self):
print('吃东西')
def shout(self):
print('叫唤')
def get_numbe(self):
return 100
class Dog(Animal):
def look_dog(self):
print('看家')
# 重写父类的shout
def shout(self):
print('汪汪汪')
# 重写父类的eat方法
def eat(self):
# 保留父类的eat的功能
super().eat()
print('吃骨头')
# 保留父类的类方法的功能的时候，还有super（）的功能
@classmethod
def get_number(cls):
print(super().get_number())
if __name__ == '__main__':
dog = Dog()
dog.age = 3
dog.color = 'blue'
print(dog.color)
dog.shout()
dog.look_dog()
an = Animal
# 继承后，父类不能使用子类中添加的属性和方法
02 添加属性
对象属性的继承：是通过继承init方法来继承的对象属性
给当前类添加对象属性: 重写init方法。
注意：如果要保留父类的对象属性，需要使用super()去调用父类的init方法
多态：同一个事物有多种形态。
方法的多态：子类继承父类的方法，可以对方法进行重写，一个方法就有多种形态（多态的表现）
类的多态：继承产生多态
class Person(object):
"""人类"""
def __init__(self, name, age=0, sex=''):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print('人在吃饭')
class Staff(Person):
# init方法的参数：保证在创建对象的时候就可以给某些属性赋值
def __init__(self, name='', age=0, salary=0):
super().__init__(name, age)
self.salary = salary
def eat(self):
print('员工在吃饭')
class Scientist(Person):
def eat(self):
print('科学家在吃饭')
if __name__ == '__main__':
p1 = Person('李四',sex='女')
p1.eat()
s1 = Staff(age=18)
s1.sex = '男'
print(s1.name)
s1.salary = 10000
print(s1.salary)
s1.eat()
练习：
- 声明人类，有属性，名字、年龄、性别、身高
- 要求创建人的对象的时候可以给名字、性别、年龄赋初值
- 再创建学生类继承自人类，拥有人类的所有的属性，再添加学号、成绩、电话属性
- 要求创建学生对象的时候可以给名字、年龄和电话赋初值
class Person2:
"""人类"""
a = 10
def __init__(self, name, sex, age):
self.name = name
self.age = age
self.sex = sex
self.height = 0
class Student(Person2):
"""学生类"""
b = 100
def __init__(self, name='', age=0, tel='00'):
super().__init__(name, age=age, sex='女')
self.study_id = '00'
self.score = 0
self.tel = tel
stu = Student('李四')
stu.sex = '男'
print(stu.age)
p1 = Person2('张三', '男', 18)
03 运算符的重载
重载：一个类中可以有多个名字相同的方法，但是参数不一样，就叫重载。python中不支持
class Student:
#python不支持方法的重载
# def run(self):
# print('人在跑')
def run(self, name):
print('%s在跑' % name)
"""
2.运算符重载(重新定义运算符运算的过程)
>,<
大于和小于符号只需要重载其中的一个，另外一个的结果，直接是重载的结果取反
+,-
"""
class Student2():
def __init__(self,name='',age=0,height=0):
self.name = name
self.age = age
self.height = height
# 重载：>
"""
self > other
"""
def __gt__(self, other):
# 比较对象1>对象2的时候是比较的他们的height属性
return self.height > other.height
# 重载：<
"""
self > other
"""
def __lt__(self, other):
return self.age < other.age
# 重载：+
def __add__(self, other):
return self.age + other.age
# 重载：-
def __sub__(self, other):
return self.height - other.height
if __name__ == '__main__':
stu = Student()
stu.run('胡晨宇')
stu1 = Student2('aa', 18, 170)
stu2 = Student2('bb', 20, 140)
if stu1 > stu2:
print('学生1大于学生2')
if stu1 < stu2:
print('学生1小于学生2')
print(stu1 + stu2)
print(stu1 - stu2)
04 python中内存的管理
python内存管理原理
内存中有两个特殊的区域：栈，堆
- 栈：栈中的内存是系统自动管理的（内存的开辟和释放）---》作用域结束，内存就释放
- 堆：堆中的内存都是需要写程序去开辟和释放的（python中这个过程也已经自动化）
原理：堆中的数据到底是什么时候释放的
看一个值有几个引用，当一个值没有引用的时候，值对应的内存空间就会被释放
(引用计数机制)
引用：存储对象地址的变量
class Person:
def __init__(self, name):
self.name = name
def run(self):
print(self.name,'人在跑')
if __name__ == '__main__':
# 声明了一个Person对象，存到p中的
p = Person('p')
p.run()
# 删除对象的唯一的引用，对象就会被销毁
del p
# p.run()
# Person对象(0)，name='p1' 0+1+1-1-1
p1 = Person('p1')
p2 = p1
del p2
p1.run()
p1 = 'a'
# 注意：将对象添加到容器中，对象的引用会加1
p3 = Person('p3')
lists = [p3, 100]
del p3
lists[0].run()
# del lists[0]
# del lists
lists[0] = None
05 包的使用
封装：
- 对一个功能的封装 --> 用函数
- 对多个功能的封装 --> 模块和类
- 对多个数据进行封装 --> 类、字典
- 对多个类进行封装 ---> 模块
- 对多个模块进行封装 ---> 包(文件夹)
# 导入某个包中的某个模块
from package1 import my_math
# 导入某个包的某个模块中的某个函数和类
from package1.my_math import sum,Math
if __name__ == '__main__':
# sum()
# Math.sum()
#
# my_math.sum()
# print(my_math.Math.pi)
pass
