类和对象
- 类
-
- 类属性
- 类方法
- 静态方法
- 对象
-
- 构造函数
- 私有属性/方法
- getter/setter方法
-
- 普通方式
- 使用装饰器@property来简化
- 对象（实例）方法
- 析构函数
- 对象的call函数与可调用对象
- 方法重载
- python的动态性
-
- 动态的给类添加方法
- 动态的给类修改方法
- isinstance函数
- 面向对象的特性（封装，继承，多态）
-
- 封装
- 继承
-
- 单继承
- 多继承
- 多态
类
类属性
类属性：可以被当前类实例对象所共享的，通过类名调用
类似于类的静态变量
class Student:
# 所有类实例对象都可以操作
school='牛津大学'
print(Student.school)
类方法
类方法：类似静态方法，通过类名调用，需要加修饰器@classmethod
可以操作类属性
默认参数cls代表当前类，cls是class的缩写
class Student:
# 类属性
school='牛津大学'
# 类方法
@classmethod
def printSchool(cls):
print(cls.school)
静态方法
静态方法：和类方法相似，区别是，不能调用当前类属性，没有默认属性
cls，也是通过类名调用
需要用修饰器@staticmehtod
通常定义一些与类无关的方法
class Student:
@staticmethod
def caculate(a,b):
'''
计算参数a和参数b的和
'''
return a+b
对象
构造函数
在python中一切class的构造函数都叫
__init__，所有实例方法都有一个默认参数self，我们不用给self传参赋值，self代表当前对象，解释器自动解释
class Student:
def __init__(self,name,age):
'''
第一参数必须是self
通过self.的方式创建对象属性
下面实例给student对象创建两个对象属性name,age
'''
self.name=name
self.age=age
stu=Student('张三',18)
私有属性/方法
python对类的成员没有严格的访问控制，这与其他面向对象有区别。关于私有属性和私有方法有如下要点：
- 通常我们约定，两个下划线开头的属性是私有的，其他为公共的
- 类的外部不能直接访问私有属性或方法
- 类的内部可以直接访问私有属性或方法
- 类的外部可以通过“_类名__私有属性（方法）名”访问私有属性或方法
class Person:
def __init__(self,name,age):
self.__name=name
self.__age=age
def toString(self):
'''
在类内部访问类的私有属性
'''
print('name:{0}age:{1}'.format(self.__name,self.__age))
p=Person('张三',18)
p.toString()
'''
一定要非法访问，可以通过_类名__属性名的方式访问
'''
print(p._Person__name)
print(p._Person__age)
'''
在外部直接访问私有属性会直接报错的
'''
print(p.__name)
class Person:
def __init__(self):
print('构造方法被执行了')
self.__work()
def __work(self):
'''
私有方法
'''
print('我会努力工作')
p=Person()
p.__work()
getter/setter方法
普通方式
'''
普通方式给类属性设置get和set方法
'''
class Person:
def __init__(self,name):
'''
构造方法
'''
# 属性一定要私有化
self.__name=name
def set_name(self,name):
self.__name=name
def get_name(self):
return self.__name
p=Person('李四')
print(p.get_name())
p.set_name('张三')
print(p.get_name())
使用装饰器@property来简化
@property修饰器可以使得方法像属性一样调用
class Person:
def __init__(self,salay):
# 属性必须私有化
self.__salay=salay
@property
def salay(self):
'''
get方法
'''
return self.__salay
@salay.setter
def salay(self,salay):
'''
set方法
'''
if salay>0:
self.__salay=salay
else :
print('输入值不能低于0')
p=Person(3000)
print(p.salay)
p.salay=-2000
print(p.salay)
p.salay=8000
print(p.salay)
对象（实例）方法
所有实例方法都有一个默认参数
self，我们不用给self传参赋值，self代表当前对象，解释器自动解释
调用方式：实例名.方法名
class Student:
def __init__(self,name,age):
'''
第一参数必须是self
通过self.的方式创建对象属性
下面实例给student对象创建两个对象属性name,age
'''
self.name=name
self.age=age
def toString(self):
'''
打印name和age
'''
print('name={0},age={1}'.format(self.name,self,age))
stu=Student('张三',18)
析构函数
__del__方法在python里称为析构函数，用于实现对象被销毁时所需要的操作。
python实现了自动的垃圾回收，当对象没有被引用时（引用计数器为0时），由垃圾回收器调用对象的__del__函数
我们也可以通过关键字del删除对象，从而达到调用__del__方法
一般系统自动提供了__del__方法，一般不需要自定义析构方法
class Student:
def __init__(self):
'''
构造函数
'''
print('初始化一个student对象'+str(id(self)))
pass
def __del__(self):
'''
析构函数
'''
print('id:'+str(id(self))+'被销毁')
stu01=Student()
stu02=Student()
结果
对象的call函数与可调用对象
每个对象都有一个
call函数，通过对象名()方式调用
class Person:
def __init__(self):
'''
构造函数
'''
print('创建了一个对象：'+str(self))
def __call__(self,salary):
'''
call函数
'''
yearsSalary=salary*12
daySalary=salary//27.5
return {
'yearsSalary':yearsSalary,
'daySalary':daySalary
}
p=Person()
print(p(3000))
方法重载
在python中方法没有重载这一说，Python不支持重载
有多个重名的方法，只有最后一个方法有效，其余都无效
class Student:
def hello(self):
print('hello world')
def hello(self,message):
print(message)
stu=Student()
stu.hello()
结果
python的动态性
动态的给类添加方法
class Person:
def work(self):
print('努力工作')
# 在类的外面定义个方法
def play_games(s):
print(str(id(s))+'愉快的玩游戏')
# 将玩游戏这个方法添加给Person
Person.play_game=play_games
p=Person()
p.work()
p.play_game()
动态的给类修改方法
class Person:
def work(self):
print('努力工作')
# 在类的外部定义一个work方法
def works(s):
print(str(id(s))+'说：好好工作，努力学习')
# 将person的work赋值等于work()方法
Person.work=works
p=Person()
p.work()
isinstance函数
参数1：对象
参数2：类
作用：用来判断当前对象是否属于当前类
class Student:
def __init__(self):
pass
pass
stu=Student()
print(isinstance(stu,Student))# 结果为True
面向对象的特性（封装，继承，多态）
封装
封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
class Person:
def __init__(self,name,age):
self.__name=name
self.__age=age
@property
def name(self):
print('name的get方法')
return self.__name
@name.setter
def name(self,name):
print('name的set方法')
self.__name=name
@property
def age(self):
print('age的get方法')
return self.__age
@age.setter
def age(self,age):
print('age的set方法')
self.__age=age
p=Person('张三',18)
print(p.name)
p.name='李四'
print(p.name)
print(p.age)
p.age=20
print(p.age)
结果
继承
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。
python支持多继承
单继承
class Father:
def __init__(self,name='暂未设置',age=28):
'''
构造函数
'''
self.__name=name
self.__age=age
def toString(self):
print('name:{0}age:{1}'.format(self.__name,self.__age))
f=Father('张三',30)
f.toString()
class Children(Father):
def __init__(self,name='暂未设置',age=18):
'''
子类需要显式的调用父类的构造函数
\n不调用解释器不会去执行父类的构造函数
'''
self.__name=name
self.__age=age
Father.__init__(self)
c=Children()
c.toString()
多继承
class a:
def say(self):
print('你好，我是a类说的第一句话')
class b:
def hello(self):
print('b说的话')
class c(a,b):
pass
c=c()
c.hello()
c.say()
结果
多态
多态是同一个行为具有多个不同表现形式或形态的能力。
本文地址：https://blog.csdn.net/qq_42418169/article/details/109620887
