面向对象(二)【类的成员及修饰符】

本篇主要介绍类的成员、成员修饰符。

1 类的成员概述

类的成员可以分为三个大类:字段方法属性。关系主要如下图:

在上述类的成员中,普通字段是存储在对象之中的;其他成员均是存储在类中,也就是说无论创建了多少个对象,对象本身只保留成员中的普通字段,其他成员均存储在类中

2 字段

字段分为普通字段和静态字段,普通字段属于对象,静态字段属于类;因此,它们在内存中的位置也不一样。下面看一下它们怎么定义和访问:

class Subject(object):

    # 静态字段
    subject = "数学科"

    def __init__(self, name):
        # 普通字段
        self.name = name

# 普通字段通过对象访问
obj = Subject("高等数学")    
print(obj.name)             # 高等数学

# 静态字段通过类访问
print(Subject.subject)      # 数学科

# 通过对象去访问静态字段(不推荐)
print(obj.subject)          # 数学科

实际上每个对象内部,都存储有其类的指针,指向类。对象通过该指针,可找到创建其本身的类。我们在写代码时,可以将对象中共有的字段写成静态字段。

3 方法

方法包括普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同、定义方法时传入的参数不同。

class Person(object):

    def __init__(self, name):
        self.name = name

    # 普通方法 无装饰器  参数:self
    def talk(self):
        print("my name is %s" % self.name)

    # 类方法 装饰器:@classmethod 参数:cls(代表类本身)
    @classmethod
    def class_talk(cls):
        print("class Person")

    # 静态方法  装饰器:@staticmethod  参数:无
    @staticmethod
    def static_talk():
        print("static function")

# 通过对象调用普通方法
obj = Person("Jeo Chen")
obj.talk()               # my name is Jeo Chen

# 通过类调用类方法
Person.class_talk()      # class Person

# 通过类调用静态方法
Person.static_talk()     # static function

在Python中,是可以通过对象调用类方法和静态方法的,只是不推荐:

# 通过对象调用类方法 (不推荐)
obj.class_talk()         # class Person
# 通过对象调用静态方法 (不推荐)
obj.static_talk()        # static function

普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self; 类方法:由调用; 至少一个cls参数;执行类方法时,自动将调用该方法的类赋值给cls; 静态方法:由调用;无默认参数;

4 属性

掌握普通方法后,属性很简单。只需要在普通方法上加一个装饰器@property,即可将普通方法转变为属性。

class Person(object):

    def __init__(self, name):
        self.name = name

    # 属性 与普通方法的区别就是加一个装饰器 @property
    @property
    def talk(self):
        return "my name is %s" % self.name

# 通过对象访问属性
obj = Person("Liu You Yuan")
print(obj.talk)     # my name is Liu You Yuan

从上面看,访问属性和访问普通方法是不同的: 访问属性 对象.func 访问方法对象.func()

属性提供了一种像访问普通字段一样访问普通方法的途径。

如果想修改属性的值,或者删除属性,应该在类中有三个同名函数,且在函数上的装饰器分别为:@property,@方法名.setter, @方法名.deleter。

class Salary(object):
    def __init__(self, money):
        # 基本工资
        self.basic_salary = money
        # 提成
        self.rate = 1.2

    @property
    def salary(self):
        return self.basic_salary * self.rate

    # 修改属性
    @salary.setter
    def salary(self, value):
        self.basic_salary = value

    # 删除属性
    @salary.deleter
    def salary(self):
        del self.basic_salary

obj = Salary(20000)
print(obj.salary)    # 24000.0  触发@property装饰的salary方法

obj.salary = 30000
print(obj.salary)    # 36000.0  触发@salary.setter装饰的salary方法

del obj.salary       # 触发@salary.deleter装饰的salary方法

上述都是通过装饰的形式创建属性。Python中还有一种比较特殊的创建属性的方法如下:

class Person(object):

    def __init__(self, name):
        self.name = name

    def get_firstname(self):
        return self.name[:3]

    fistname = property(get_firstname)  # 自动返回get_firstname()的返回值

obj = Person("Liu You Yuan")
print(obj.fistname)      # Liu 

那这种方式怎么实现修改和删除属性呢?

class Salary(object):
    def __init__(self, money):
        # 基本工资
        self.basic_salary = money
        # 提成指数
        self.rate = 1.2

    def get_salary(self):
        return self.basic_salary * self.rate

    def set_salary(self, value):
        self.basic_salary = value

    def del_salary(self):
        del self.basic_salary

    salary = property(get_salary, set_salary, del_salary, "描述")

obj = Salary(20000.0)
print(obj.salary)

obj.salary = 30000.0
print(obj.salary)

del obj.salary

5 类成员的修饰符

在类中成员包括两类,公有成员和私有成员。 公有成员,在任何地方都能访问。 私有成员,只有在类的内部才能方法。在普通成员的名字前加上两个下划线。如是有静态字段:__name = "数学科" PS:可以通过【对象._类名__私有成员】去强制访问私有成员但不推荐。

class Person:

    Country = "China"
    __P = "SC"

    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def __hello(self):
        print("[{}] age is [{}]".format(self.name, self.__age))

    def hi(self):
        self.__hello()

obj = Person("Liu You Yuan", 23)
print(obj.name)      # 访问公有成员

# print(Person.__P)  # 报错,外部不能访问
# print(obj.__age)   # 报错,外部不能访问

# 强制访问可以
print(obj._Person__age)    # 23

obj.hi()    # [Liu You Yuan] age is [23]

以上就是本篇全部内容,余不一一。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏于晓飞的专栏

Java 泛型进阶

在 List<String> 中添加 Integer 将不会通过编译,但是List<Sring>与List<Integer>在运行时的确是同一种类型。

22430
来自专栏开发与安全

从零开始学C++之从C到C++(一):const与#define、结构体对齐、函数重载name mangling、new/delete 等

一、bool 类型 逻辑型也称布尔型,其取值为true(逻辑真)和false(逻辑假),存储字节数在不同编译系统中可能有所不同,VC++中为1个字节。 声明方式...

20100
来自专栏应兆康的专栏

12步轻松搞定Python装饰器

Python里面的装饰器比较复杂,下面12步可以帮你你较好的理解Python中的装饰器 1. 函数 在python中,函数通过 def关键字、函数名和可选的参数...

349100
来自专栏coder修行路

装饰器、生成器,迭代器、Json & pickle 数据序列化

1、 列表生成器:代码例子 1 a=[i*2 for i in range(10)] 2 print(a) 3 4 运行效果如下: 5 D:\python35...

20950
来自专栏Micro_awake web

es6(二):解构赋值

ES中允许按照一定格式从数组,对象值提取值,对变量进行赋值,这就是解构(Destructuring) 1 let [a,b,c]=[1,10,100] 2 ...

20850
来自专栏每日一篇技术文章

Foundation-String

最近写完了Swift 3.0教程 ,在接下来这段时间,继续写Foundation 的教程,帮助大家更加深入,系统的学习Foundation 框架,可能会持续一段...

11010
来自专栏微信公众号:Java团长

Java动态代理机制详解

在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来...

13810
来自专栏数据结构与算法

1470 数列处理

个人博客:doubleq.win 1470 数列处理  时间限制: 1 s  空间限制: 1000 KB  题目等级 : 青铜 Bronze 题解 题目描述 D...

27550
来自专栏彭湖湾的编程世界

【算法】实现栈和队列

栈(stack) 栈(stack)是一种后进先出(LIFO)的集合类型, 即后来添加的数据会先被删除 ? 可以将其类比于下面文件的取放操作:新到的文件会被先取走...

34960
来自专栏chenjx85的技术专栏

leetcode-686-Repeated String Match(重复多少次A能够找到B)

14930

扫码关注云+社区

领取腾讯云代金券