python进阶之对象和类

类和对象

• 类
• 对象
• • 构造函数
  • 私有属性/方法
  • getter/setter方法
  • 对象（实例）方法
  • 析构函数
  • 对象的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对类的成员没有严格的访问控制，这与其他面向对象有区别。关于私有属性和私有方法有如下要点：

1. 通常我们约定，两个下划线开头的属性是私有的，其他为公共的
2. 类的外部不能直接访问私有属性或方法
3. 类的内部可以直接访问私有属性或方法
4. 类的外部可以通过“_类名__私有属性（方法）名”访问私有属性或方法

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