目录
1. 对象独有的功能
1.1 代码演示
class Person:
h_type = '人类'
def __init__(self,name): # 让对象拥有独有的数据
self.name = name
# 定义在类中的函数 我们称之为方法
def eat(self): # 是多个对象公共的方法 也算多个对象独有的方法 对象来调用就会将对象当做第一个参数传入
print('%sz正在干饭'%self.name)
def others(self,a,b):
print('other哈哈哈')
# 针对对象独有的方法 我们没法真正实现
# 1. 如果在全局则不是独有的
# 2. 如果在类中则是公开的
# python解释器针对上述问题添加了一个非常牛的特性， 定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法)
p1 = Person('jason')
p1.eat() # set(p1)
p2 = Person('kevin')
p2.eat()
1.2 绑定
p3 = Person('oscar')
Person.eat(p3)
1.3 多个参数
p1 = Person('jason')
p1.others(1, 2)
Person.others(p1,1,2)
2. 动静态方法
2.1 绑定给对象的方法
直接在类体代码中编写即可，对象调用会自动将对象当做第一个参数传入，类调用则有几个形参就传几个实参
class Student:
school = '清华大学'
# 绑定给对象的方法
def run(self): # self 用于接收对象
print('绑定对象', self)
stu1 = Student
print(stu1.run) # <function Student.run at 0x000002D814B28700>
2.2 绑定给类的方法
class Student:
school = '清华大学'
# 绑定给对象的方法
def run(self): # self 用于接收对象
print('绑定对象', self)
@classmethod # 绑定给类的方法
def eat(cls): # cls用于接收类
print('绑定类', cls)
# 调用绑定类的方法
Student.eat() # 类调用会自动将类当做第一个参数传入 eat(Student)
stu1.eat() # 对象调用会自动将产生该对象的类当做第一个参数传入 eat(Student)
2.3 静态方法
class Student:
school = '清华大学'
# 绑定给对象的方法
def run(self): # self 用于接收对象
print('绑定对象', self)
@classmethod # 绑定给类的方法
def eat(cls): # cls用于接收类
print('绑定类', cls)
@staticmethod #静态方法
def sleep(a, b): # 无论谁来调用都必须按照普普通通的函数传参方式
print('静态方法')
# 调用静态方法
stu1 = Student
Student.sleep(1,2) # 静态方法
stu1.sleep(1,2) # 静态方法
3. 面向对象三大特性之继承
3.1 三大特性
- 继承
- 封装
- 多态
3.2 继承的含义
- 在现实生活中继承其实就是用来描述人与人之间资源的关系。eg:儿子继承父亲的财产(拥有了父亲所有的资源)
- 在编程世界里继承其实就是用来描述类与类之间数据的关系。eg:类A继承类B(拥有了类B里面所有的数据和功能)
3.3 继承的目的
- 现实生活中继承就是想占有别人的财产。eg:亲身父亲 干爹 干妈
- 编程世界里继承就是为了节省代码编写。eg:可以继承一个类 也可以继承多个类
3.4 继承的操作
3.4.1 语法结构
# 语法结构
class 类名(类名)：
pass
- 定义类的时候在类名后加括号
- 括号内填写你需要继承的类名
- 括号内可以填写多个父类 逗号隔开即可
- 我们将被继承的类称之为: 父类或基类或超类
- 我们将继承类的类称之为: 子类或派生类
ps:平时最常用的就是父类和子类
3.4.2 多个父类查找
从左到右查找每个父类中的属性即可
class MyClass(F1,F2,F3):
pass
3.4.3 继承的本质
- 抽象:将多个类共同的数据或功能抽取出来形成一个基类
- 继承:从上往下白嫖各个基类里面的资源
对象:数据和功能的结合体
类:多个对象相同的数据和功能的结合体
父类:多个类相同的数据和功能的结合体
ps:类和父类最主要的功能其实就是节省代码
4. 名字的查找顺序
4.1 不继承的情况下名字的查找顺序
先从对象自身查找，没有的话，再去产生该对象的类中查找（对象自身 >>> 类）
class Student:
school = '清华大学'
def choice(self):
print('选课')
stu1 = Student()
print(stu1.school) # 对象查找school 自身名称空间没有 所以查找的是类的 清华大学
stu1.school = '北京大学' # 自身的名称空间中产生了新的school
# 对象点名并写了赋值符号和数据值，那么操作的肯定是自己的名称空间
print(stu1.school) # 北京大学
print(Student.school) # 清华大学
4.2 单继承的情况下名字1的查找顺序
先从对象自身查找，然后是产生该对象的类 然后是一个个父类(对象 >>> 类 >>> 父类)
class A:
name = 'from A' # B pass 打印A name from A
class B(A):
# name = 'from B' # C pass 打印B name from B
pass
class C(B):
# name = 'from C' # 有name 打印出 from C
pass
obj = C()
# obj.name = '打印' # 打印
print(obj.name)
class A:
def func1(self):
print('from A func1')
def func2(self):
print('from A func2')
self.func1() # # obj.func1()
class B(A):
def func1(self):
print('from B func1')
obj = B()
obj.func2()
4.3 多继承的情况下名字的查找顺序
- 非菱形继承(最后不会归总到一个我们自定义类上)深度优先(每个分支都走到底 再切换)
class D:
name = 'from D'
class E:
name = 'from E'
class F:
name = 'from F'
class A(D):
name = 'from A'
class B(E):
name = 'from B'
class C(F):
name = 'from C'
class My(A, B, C):
pass
obj = My()
print(obj.name)
2. 菱形继承(最后归总到一个我们自定义类上)广度优先(前面几个分支都不会走最后一个类 最后一个分支才会走)
5. 经典类与新式类
5.1 经典类
不继承object或其子类的类(什么都不继承)
5.2 新式类
继承了object或其子类的类
5.3 python2 和 python3
- 在python3中所有的类默认都会继承object,也就意味着python3里面只有新式类
- 也就意味着python3里面只有新式类,由于经典类没有核心的功能 所以到了python3直接砍掉了
- 在定义类的时候,如果没有想要继承的父类,一般推荐以下写法,目的是为了兼容python2(码针对object无需关心 知道它的存在即可)
class MyClass(object):
pass
6. 派生方法
子类中定义类与父类一模一样的方法并且扩展了该功能>>>:派生 (super())
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):
if value == 'jason':
print('jason 不能追加')
return
super().append(value)
obj = MyClass()
obj.append(111)
obj.append(222)
obj.append('jason')
obj.append(333) # [111, 222, 333]
print(obj)
原创文章，作者：，如若转载，请注明出处：https://blog.ytso.com/277380.html