一、对象独有的功能
class Person:
h_type = '人类'
def __init__(self, name): # 让对象拥有独有的数据
self.name = name
# 定义在类中的函数 我们称之为方法
def eat(self): # 是多个对象公共的方法 也算多个对象独有的方法 对象来调用就会将对象当做第一个参数传入
print('%s正在干饭' % self.name)
def others(self, a, b):
print('others哈哈哈')
p1 = Person('jason')
p1.eat() # eat(p1) # jason正在干饭
p2 = Person('kevin')
p2.eat() # eat(p2) # kevin正在干饭
# 如何理解绑定二字
p3 = Person('oscar')
Person.eat(p3) # oscar正在干饭
p1 = Person('jason')
p1.others(1, 2) # others哈哈哈
Person.others(p1, 1, 2) # others哈哈哈
针对对象独有的方法 我们无法真正实现
- 如果在全局则不是独有的
- 如果在类中则是公共的
python解释器针对上述问题添加了一个非常牛的特性
定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法) 调用时需要传入一个对象
默认情况下，对象调用方法会自动将自身传入一个参数中
二、动静态方法
专门针对在类体代码中编写的函数
1.绑定给对象的方法
-
直接在类体代码中编写即可
-
对象调用会自动将对象当做第一个参数传入
-
类调用则有几个形参就传几个实参
class Student:
# 绑定给对象的方法
def run(self): # self用于接收对象
print('丧尸在跟后面，快跑！！！！', self)
stu1 = Student()
stu1.run() # 丧尸在跟后面，快跑！！！！ <__main__.Student object at 0x00000188E3B67438>
2.绑定给类的方法
class Student:
@classmethod # 绑定给类的方法
def eat(cls): # cls用于接收类
print('你可真有才', cls)
Student.eat() # 类调用会自动将类当做第一个参数传入 eat(Student) 你可真有才 <class '__main__.Student'>
stu1.eat() # 对象调用会自动将产生该对象的类当做第一个参数传入 eat(Student) 你可真有才 <class '__main__.Student'>
3.静态方法(普通的函数)
class Student:
@staticmethod # 静态方法
def sleep(a, b): # 无论谁来调用都必须按照普普通通的函数传参方式
print('快去睡觉吧')
Student.sleep(1, 2) # 快去睡觉吧
stu1.sleep(1, 2) # 快去睡觉吧
三、面向对象三大特性之继承
1.继承的简介
1.1.继承的含义
- 在现实生活中继承其实就是用来描述人与人之间资源的关系
例如：儿子继承父亲的财产(拥有了父亲所有的资源) - 在编程世界里继承其实就是用来描述类与类之间数据的关系
例如：类A继承类B(拥有了类B里面所有的数据和功能)
1.2.继承的目的
- 现实生活中继承就是想占有别人的财产
- 编程世界里继承就是为了节省代码编写
例如：:可以继承一个类，也可以继承多个类
2.继承的操作
2.1.语法结构
Class 父类类名():
pass
Class 子类类名(父类类名):
pass
Class 子类类名(父类类名1, 父类类名2, 父类类名3):
pass
被继承的类称之为: 父类或基类或超类
继承类的类称之为: 子类或派生类
- 定义类的时候在类名后加括号
- 括号内填写你需要继承的类名
- 括号内可以填写多个父类，用逗号隔开
- 平时最常用的就是父类和子类
2.2.代码示例
class Father:
money = 1000000000000000000
def run(self):
print('富婆带你飞')
class Son(Father):
pass
print(Son.money) # 1000000000000000000
Son.run(1) # 富婆带你飞
class F1:
name = 'from f1'
pass
class F2:
name = 'from f2'
pass
class F3:
name = 'from f3'
pass
class MyClass(F1, F2, F3):
name = 'jason'
print(MyClass.name) # jason
3.继承的本质
3.1.简介
| 名词 | 描述 |
|---|---|
| 抽象 | 将多个类共同的数据或功能抽取出来形成一个基类 |
| 继承 | 从上往下白嫖各个基类里面的资源 |
| 对象 | 数据和功能的结合体 |
| 类 | 多个对象相同的数据和功能的结合体 |
| 父类 | 多个类相同数据和功能的结合体 |
类和父类，最主要的功能其实就是节省代码
3.2.代码示例
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class Teacher(Person):
# def __init__(self, name, age, gender):
# self.name = name
# self.age = age
# self.gender = gender
def teach_course(self):
print('老师正在上课')
class Student(Teacher):
# def __init__(self, name, age, gender):
# self.name = name
# self.age = age
# self.gender = gender
def choice_course(self):
print('学生正在选课')
stu1 = Student('jason', 18, 'male')
print(stu1.__dict__) # {'name': 'jason', 'age': 18, 'gender': 'male'}
四、名字的查找顺序
可以使用类点mro()方法查看该类产生的对象名字的查找顺序
1.不继承的情况下名字的查找顺序
顺序：对象→类
1.1.先从对象自身查找，没有的话，再去产生该对象的类中查找
class Student:
school = '清华大学'
def choice_course(self):
print('正在选课')
stu1 = Student()
print(stu1.school) # 对象查找school 自身名称空间没有 所以查找的是类的 清华大学
stu1.school = '北京大学' # 在自身的名称空间中产生了新的school
"""对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间"""
print(stu1.school) # 北京大学
print(Student.school) # 清华大学
1.2.对象点名字并写了赋值符号和数据值，操作的是自己的名称空间
class Student:
school = '清华大学'
def choice_course(self):
print('正在选课')
"""对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间"""
stu1.school = '北京大学' # 在自身的名称空间中产生了新的school
print(stu1.school) # 北京大学
print(Student.school) # 清华大学
2.单继承的情况下的名字的查找顺序
顺序：对象→类→父类
先从对象自身查找，然后是产生该对象的类，然后是一个个父类
class A:
# name = 'from A'
pass
class B(A):
# name = 'from B'
pass
class C(B):
# name = 'from C'
pass
class MyClass(C):
name = 'from MyClass'
pass
obj = MyClass()
# obj.name = '困傻了'
print(obj.name) # from MyClass
只要涉及到对象查找名字，几乎要回到最开始的位置依次查找
class A1:
def func1(self):
print('from A1 func1')
def func2(self):
print('from A1 func2')
self.func1() # obj.func1()
class MyClass(A1):
def func1(self):
print('from MyClass func1')
obj = MyClass()
obj.func2()
3.多继承的情况下名字的查找顺序
3.1.非菱形继承：最后不会归总到一个我们自定义类上
深度优先(每个分支都走到底 再切换)
顺序：A→D→B→E→C→F
class D:
# name = 'from D'
pass
class E:
# name = 'from E'
pass
class F:
# name = 'from F'
pass
class A(D):
# name = 'from A'
pass
class B(E):
name = 'from B'
pass
class C(F):
name = 'from C'
pass
class MyClass(A, B, C):
name = 'from MyClass'
pass
obj = MyClass
print(obj.name)
print(MyClass.mro()) # [<class '__main__.MyClass'>, <class '__main__.A'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class 'object'>]
3.2.菱形继承：最后归总到一个我们自定义类上
广度优先(前面几个分支都不会走最后一个类，最后一个分支才会走)
顺序：A→D→B→E→C→F→G
class G:
name = 'from G'
pass
class D(G):
# name = 'from D'
pass
class E(G):
# name = 'from E'
pass
class F(G):
# name = 'from F'
pass
class A(D):
# name = 'from A'
pass
class B(E):
# name = 'from B'
pass
class C(F):
# name = 'from C'
pass
class MyClass(A, B, C):
# name = 'from MyClass'
pass
obj = MyClass
print(obj.name)
print(MyClass.mro()) # [<class '__main__.MyClass'>, <class '__main__.A'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class '__main__.G'>, <class 'object'>]
五、经典类与新式类
1.经典类
不继承object或其子类的类(什么都不继承)
2.新式类
继承了object或其子类的类
3.python2和python3的区别
3.1.在python3中所有的类默认都会继承object
也就意味着python3里面只有新式类
3.2.在python2中有经典类和新式类
由于经典类没有核心的功能，所以python3直接砍掉了
注意：以后在定义类的时候，如果没有想要继承的父类，一般推荐以下写法
class MyClass(object):
pass
目的是为了兼容python2
六、派生方法
子类中定义类与父类一模一样的方法并且扩展了该功能，就叫：派生
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class Teacher(Person):
def __init__(self, name, age, gender, level):
# Person.__init__(self,name,age,gender) # 先调用父类的方法
super().__init__(name, age, gender) # super专门用于子类调用父类的方法
self.level = level
class MyClass(list):
def append(self, value):
super().append(value)
obj = MyClass()
obj.append(111)
obj.append(222)
obj.append('jason')
print(obj)
posted on
