欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python进阶之对象和类

程序员文章站 2022-07-02 09:17:25
类和对象类类属性类方法静态方法对象构造函数对象(实例)方法类类属性类属性:可以被当前类实例对象所共享的,通过类名调用类似于类的静态变量class Student:# 所有类实例对象都可以操作school='牛津大学'print(Student.school)类方法类方法:类似静态方法,通过类名调用,需要加修饰器@classmethod可以操作类属性默认参数cls代表当前类,cls是class的缩写class Student:# 类属性school='牛津大学...

类属性

类属性:可以被当前类实例对象所共享的,通过类名调用
类似于类的静态变量

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)

python进阶之对象和类

class Person:

    def __init__(self):
        print('构造方法被执行了')
        self.__work()
    
    def __work(self):
        '''
        私有方法
        '''
        print('我会努力工作')
    
p=Person()
p.__work()

python进阶之对象和类

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())

python进阶之对象和类

使用装饰器@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)

python进阶之对象和类

对象(实例)方法

所有实例方法都有一个默认参数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()

结果
python进阶之对象和类

对象的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中方法没有重载这一说,Python不支持重载
有多个重名的方法,只有最后一个方法有效,其余都无效

class Student:

    def hello(self):
        print('hello world')


    def hello(self,message):
        print(message)
    
stu=Student()
stu.hello()

结果
python进阶之对象和类

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()

python进阶之对象和类

动态的给类修改方法

class Person:

    def work(self):
        print('努力工作')

# 在类的外部定义一个work方法
def works(s):
    print(str(id(s))+'说:好好工作,努力学习')

# 将person的work赋值等于work()方法
Person.work=works

p=Person()
p.work()
	

python进阶之对象和类

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)

结果
python进阶之对象和类

继承

​ 继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。当然,如果在父类中拥有私有属性(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()

结果
python进阶之对象和类

多态

​ 多态是同一个行为具有多个不同表现形式或形态的能力。

本文地址:https://blog.csdn.net/qq_42418169/article/details/109620887

相关标签: python