1、面向对象结构分析

如下面的图所示:面向对象整体大致分两块区域:

每个大区域又可以分为多个小部分:

  1. class A:
  2. name = 'Tom' # 静态变量(静态字段)
  3. __iphone = '138xxxxxxxx' # 私有静态变量(私有静态字段)
  4.  
  5. def __init__(self,name,age): #特殊方法
  6. self.name = name #对象属性(普通字段)
  7. self.__age = age #私有对象属性(私有普通字段)
  8.  
  9. def func1(self): #普通方法
  10. pass
  11.  
  12. def __func(self): #私有方法
  13. print(666)
  14.  
  15. @classmethod # 类方法
  16. def class_func(cls):
  17. """ 定义类方法,至少有一个cls参数 """
  18. print('类方法')
  19.  
  20. @staticmethod #静态方法
  21. def static_func():
  22. """ 定义静态方法 ,无默认参数"""
  23. print('静态方法')
  24.  
  25. @property #属性
  26. def prop(self):
  27. pass

类有这么多的成员,那么我们先从那些地方研究呢? 可以从私有与公有部分和方法的详细分类两个方向去研究。

2、面向对象的私有与公有

对于每一个类的成员而言都有两种形式:

公有成员,在任何地方都能访问
私有成员,只有在类的内部才能方法

私有成员和公有成员的访问限制不同:

2.1、静态字段(静态变量)

公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
私有静态字段:仅类内部可以访问;

1)公有静态字段

  1. class C:
  2. name = "公有静态字段"
  3. def func(self):
  4. print C.name #从类内部访问类的公有属性
  5.  
  6. class D(C):
  7. def show(self):
  8. print C.name #从派生类访问父类的公有属性
  9.  
  10. C.name # 类访问
  11.  
  12. obj = C()
  13. obj.func() # 类内部可以访问
  14.  
  15. obj_son = D()
  16. obj_son.show() # 派生类中可以访问

2)私有静态字段

  1. class C:
  2. __name = "私有静态字段"
  3. def func(self):
  4. print C.__name #可以在类内部访问私有属性
  5.  
  6. class D(C):
  7. def show(self):
  8. print C.__name #不可以在子类中访问父类的私有属性
  9.  
  10. C.__name # 不可在外部访问
  11.  
  12. obj = C()
  13. obj.__name # 不可在外部访问
  14. obj.func() # 类内部可以访问
  15.  
  16. obj_son = D()
  17. obj_son.show() #不可在派生类中可以访问

2.2、普通字段(对象属性)

公有普通字段:对象可以访问;类内部可以访问;派生类中可以访问
私有普通字段:仅类内部可以访问

1)公有普通字段

  1. class C:
  2. def __init__(self):
  3. self.foo = "公有字段"
  4. def func(self):
  5. print(self.foo)  #类内部可以访问
  6.  
  7. class D(C):
  8. def show(self):
  9. print(self.foo) #派生类中可以访问
  10.  
  11. obj = C()
  12. obj.foo # 通过对象访问
  13. obj.func() # 类内部访问
  14.  
  15. obj_son = D();
  16. obj_son.show() # 派生类中访问

2)私有普通字段

  1. class C:
  2. def __init__(self):
  3. self.__foo = "私有字段"
  4.  
  5. def func(self):
  6. print self.__foo  # 类内部可以访问
  7.  
  8. class D(C):
  9. def show(self):
  10. print self.foo # 派生类中不可以访问
  11.  
  12. obj = C()
  13. obj.__foo # 通过对象访问 ==> 错误
  14. obj.func() # 类内部访问 ==> 正确
  15.  
  16. obj_son = D();
  17. obj_son.show() # 派生类中访问 ==> 错误

2.3、方法

公有方法:对象可以访问;类内部可以访问;派生类中可以访问
私有方法:仅类内部可以访问

1)公有方法

  1. class C:
  2. def __init__(self):
  3. pass
  4. def add(self):
  5. print('in C')
  6.  
  7. class D(C):
  8. def show(self):
  9. print('in D')
  10. def func(self):
  11. self.show()
  12.  
  13. obj = D()
  14. obj.show() # 通过对象访问
  15. obj.func() # 类内部访问
  16. obj.add() # 派生类中访问

2)私有方法

  1. class C:
  2. def __init__(self):
  3. pass
  4. def __add(self):
  5. print('in C')
  6.  
  7. class D(C):
  8. def __show(self):
  9. print('in D')
  10. def func(self):
  11. self.__show()
  12.  
  13. obj = D()
  14. obj.__show() # 不能通过对象访问
  15. obj.func() # 类内部可以访问
  16. obj.__add() # 派生类中不能访问

2.4、总结

对于这些私有成员来说,他们只能在类的内部使用,不能在类的外部以及派生类中使用.
ps:非要访问私有成员的话,可以通过 对象._类__属性名obj._Classname__privateAttributeOrMethod 来访问:
,但是绝对不允许!!!
为什么可以通过._类__私有成员名访问呢?因为类在创建时,如果遇到了私有成员(包括私有静态字段,私有普通字段,私有方法),它会将其保存在内存时自动在前面加上_类名,可以在__dict__中看到。

3、面向对象的成员

3.1、字段

字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同,

普通字段属于对象
静态字段属于类

  1. class Province:
  2. # 静态字段
  3. country '中国'
  4.  
  5. def __init__(self, name):
  6. # 普通字段
  7. self.name = name
  8.  
  9. # 直接访问普通字段
  10. obj = Province('河北省')
  11. print obj.name
  12.  
  13. # 直接访问静态字段
  14. Province.country

上述代码可以看出:

普通字段需要通过对象来访问,静态字段通过类访问
在使用上可以看出普通字段和静态字段的归属是不同的

其在内存的存储方式类似如下图:

由上图可以看出:
静态字段在内存中只保存一份
普通字段在每个对象中都要保存一份

应用场景:

通过类创建对象时,如果每个对象都具有相同的字段,那么就使用静态字段

3.2、方法

方法包括:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同。

普通方法,也叫实例方法
定义:第一个参数必须是实例对象,该参数名一般约定为“self”,通过它来传递实例的属性和方法(也可以传类的属性和方法);
调用:只能由实例对象调用。

类方法
定义:使用装饰器@classmethod。第一个参数必须是当前类对象,该参数名一般约定为“cls”,通过它来传递类的属性和方法(不能传实例的属性和方法);
调用:实例对象和类对象都可以调用。

静态方法
定义:使用装饰器@staticmethod。参数随意,没有“self”和“cls”参数,但是方法体中不能使用类或实例的任何属性和方法;
调用:实例对象和类对象都可以调用。

实例方法就是第一个参数是self,类方法就是第一个参数是cls,而静态方法不需要额外的参数
类方法和静态方法都可以访问类的静态变量(类变量),但不能访问实例变量,例如不能访问self.name,而普通方法则可以

1)普通方法
简而言之,实例方法就是类的实例能够使用的方法。这里不做过多解释。

2)类方法
使用装饰器@classmethod。
原则上,类方法是将类本身作为对象进行操作的方法。假设有个方法,且这个方法在逻辑上采用类本身作为对象来调用更合理,那么这个方法就可以定义为类方法。另外,如果需要继承,也可以定义为类方法。

  1. class Student:
  2. tag = 1
  3.  
  4. @classmethod
  5. def info(cls):
  6. return cls.tag
  7.  
  8. print(Student.info())
  9. 结果:1

如下场景:
假设我有一个学生类和一个班级类,想要实现的功能为:
执行班级人数增加的操作、获得班级的总人数;
学生类继承自班级类,每实例化一个学生,班级人数都能增加;
最后,我想定义一些学生,获得班级中的总人数。

思考:这个问题用类方法做比较合适,为什么?因为我实例化的是学生,但是如果我从学生这一个实例中获得班级总人数,在逻辑上显然是不合理的。同时,如果想要获得班级总人数,如果生成一个班级的实例也是没有必要的。

  1. class ClassTest:
  2. __num = 0
  3.  
  4. @classmethod
  5. def addNum(cls):
  6. cls.__num += 1
  7.  
  8. @classmethod
  9. def getNum(cls):
  10. return cls.__num
  11.  
  12. # 这里我用到魔术函数__new__,主要是为了在创建实例的时候调用人数累加的函数。
  13. def __new__(cls, *args, **kwargs):
  14. ClassTest.addNum() #括号里不用写cls
  15. return object.__new__(cls)
  16.  
  17. class Student(ClassTest):
  18. def __init__(self,name):
  19. self.name = name
  20.  
  21. s1 = Student('小王')
  22. s2 = Student('小张')
  23. print(ClassTest.getNum())
  24. 结果:2

3)静态方法
使用装饰器@staticmethod。
静态方法是类中的函数,不需要实例。静态方法主要是用来存放逻辑性的代码,逻辑上属于类,但是和类本身没有关系,也就是说在静态方法中,不会涉及到类中的属性和方法的操作。可以理解为,静态方法是个独立的、单纯的函数,它仅仅托管于某个类的名称空间中,便于使用和维护。

譬如,我想定义一个关于时间操作的类,其中有一个获取当前时间的函数。

  1. import time
  2.  
  3. class TimeTest:
  4. def __init__(self, hour, minute, second):
  5. self.hour = hour
  6. self.minute = minute
  7. self.second = second
  8.  
  9. @staticmethod
  10. def showTime():
  11. return time.strftime("%H:%M:%S", time.localtime())
  12.  
  13. print(TimeTest.showTime())
  14. t = TimeTest(2, 10, 10)
  15. nowTime = t.showTime()
  16. print(nowTime)

如上,使用了静态方法(函数),然而方法体中并没使用(也不能使用)类或实例的属性(或方法)。若要获得当前时间的字符串时,并不一定需要实例化对象,此时对于静态方法而言,所在类更像是一种名称空间。

其实,我们也可以在类外面写一个同样的函数来做这些事,但是这样做就打乱了逻辑关系,也会导致以后代码维护困难。

3.3、属性
在Python中,property可以将方法变成一个属性来使用,借助property可以实行Python风格的getter/setter,即可以通过property获得和修改对象的某一个属性。

例一:BMI指数(bmi是计算而来的,但很明显它听起来像是一个属性而非方法,如果我们将其做成一个属性,更便于理解)
成人的BMI数值:
过轻:低于18.5
正常:18.5-23.9
过重:24-27
肥胖:28-32
非常肥胖, 高于32
  体质指数(BMI)=体重(kg)÷身高^2(m)
  EX:70kg÷(1.75×1.75)=22.86

  1. #不使用property
  2. class BMI:
  3. def __init__(self, name, weight, high):
  4. self.name = name
  5. self.high = high
  6. self.weight = weight
  7.  
  8. def bmi_show(self):
  9. rst = self.weight/self.high ** 2
  10. print('%s的BMI值为%s' %(self.name, rst))
  11.  
  12. p1 = BMI('Tom', 65, 1.7)
  13. p1.bmi_show() #需要通过调用方法()的方式显示结果
  14.  
  15. #使用property
  16. class BMI:
  17. def __init__(self, name, weight, high):
  18. self.name = name
  19. self.high = high
  20. self.weight = weight
  21. @property
  22. def bmi_show(self):
  23. rst = self.weight/self.high ** 2
  24. print('%s的BMI值为%s' %(self.name, rst))
  25.  
  26. p1 = BMI('Tom', 65, 1.7)
  27. p1.bmi_show #将方法伪装成一个属性,通过调用属性的方式显示结果

为什么要用property

将一个类的函数定义成特性以后,对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的,这种特性的使用方式遵循了统一访问的原则

@property可以将python定义的函数“当做”属性访问,从而提供更加友好访问方式。
1》只有@property表示只读。
2》同时有@property和@x.setter表示可读可写。
3》同时有@property和@x.setter和@x.deleter表示可读可写可删除。

由于新式类中具有三种访问方式,我们可以根据他们几个属性的访问特点,分别将三个方法定义为对同一个属性:获取、修改、删除

  1. class A:
  2. @property
  3. def func(self):
  4. print('get的时候运行我')
  5.  
  6. @func.setter
  7. def func(self,value):
  8. print('set的时候运行我')
  9.  
  10. @func.deleter
  11. def func(self):
  12. print('del的时候运行我')
  13.  
  14. #只有在方法func定义property后才能定义func.setter,func.deleter
  15. obj1 = A()
  16. obj1.func
  17. #get的时候运行我
  18. obj1.func = 'a'
  19. #set的时候运行我
  20. del obj1.func
  21. #del的时候运行我
  22.  
  23. 或者:
  24. class Foo:
  25. def get_func(self):
  26. print('get的时候运行我啊')
  27.  
  28. def set_func(self,value):
  29. print('set的时候运行我啊')
  30.  
  31. def delete_func(self):
  32. print('delete的时候运行我啊')
  33. func=property(get_func,set_func,delete_func) #内置property三个参数与get,set,delete一一对应
  34.  
  35. obj = Foo()
  36. obj.func
  37. #get的时候运行我啊
  38. obj.func = 'a'
  39. #set的时候运行我啊
  40. del obj.func
  41. # delete的时候运行我啊

例子:显示苹果的价格

  1. class Apple:
  2. def __init__(self, ori_price, discount):
  3. self.ori_price = ori_price
  4. self.discount = discount
  5. @property
  6. def price(self):
  7. ret = self.ori_price * self.discount
  8. print('苹果的折扣价是%s'%ret)
  9. @price.setter
  10. def price(self, new_price):
  11. self.ori_price = new_price
  12. apple1 = Apple(8, 0.8) #定义苹果的价格是8元/kg,折扣是0.8
  13. apple1.price
  14.  
  15. apple1.price = 7 #重新定义苹果的价格是7元/kg,这时苹果的价格是7*0.8
  16. apple1.price

银行账号的例子,我们要确保没人能设置金额为负,并且有个只读属性cny返回换算人名币后的金额。

  1. class Account:
  2. def __init__(self, rate):
  3. self._amount = 0
  4. self.rate = rate
  5.  
  6. @property
  7. def amount(self):
  8. """账号余额(美元)"""
  9. return self._amount
  10.  
  11. @property
  12. def cny(self):
  13. """账号余额(人名币)"""
  14. return self._amount * self.rate
  15. @amount.setter
  16. def amount(self, value):
  17. if value < 0:
  18. print('金额不能为负')
  19. else:
  20. self._amount = value
  21.  
  22. obj1 = Account(6.6)
  23. obj1.amount = 100
  24. print(obj1.cny)
  25. #660.0
  26. obj1.amount = -100
  27. #金额不能为负

day25-面向对象结构与成员的更多相关文章

  1. 标记化结构初始化语法 在结构体成员前加上小数点 如 “.open .write .close ”C99编译器 .

    今天在看串口驱动(四)的时候 有这样一个结构体初始化 我很不理解 如下: static struct s3c24xx_uart_port s3c24xx_serial_ports[NR_PORTS] ...

  2. Java基础语法(9)-面向对象之类的成员

    title: Java基础语法(9)-面向对象之类的成员 blog: CSDN data: Java学习路线及视频 1.面向对象特征--封装 为什么需要封装?封装的作用和含义? 我要用洗衣机,只需要按 ...

  3. (C语言)结构体成员的引用->(箭头)和 .(点)

    关于结构体成员的引用有这样的规律: 箭头(->):左边必须为指针: 点号(.):左边必须为实体. 那么如果一个结构体指针引用一个成员,这个成员又是一个结构体(并且是一个实体),那么如果要引用这个 ...

  4. C语言中访问结构体成员时用‘.’和‘->’的区别

    举个例子,定义了一个叫Student,别名为stu的结构类型,我们声明了一个结构体变量叫stu1,声明了一个结构体指针为stuP. typedef struct Student { char name ...

  5. C基础--结构体成员初始化方式

    之前在linux内核代码中看到结构体成员成员初始化使用类似于.owner = THIS_MODULE, 不太见过,于是搜了个博客,分享下: 转自:http://www.cnblogs.com/Anke ...

  6. 文成小盆友python-num8 面向对象中的成员,成员修饰符,特殊成员,异常处理,设计模式之单例模式

    本节主要内容: 1.面向对象中的成员 2.成员修饰符 3.特殊成员 4.异常处理 5.设计模式之单例模式 一.面向对象中的成员(类的成员) 类的成员总共可以分为3大类,每类中有不同的分支. 1.总述, ...

  7. 指针直接赋值为整型AND利用宏定义求结构体成员偏移量

    首先我们要更正一个很熟悉的概念,那就是指针不仅仅是“地址”,指针还有一个很重要的特性,那就是“类型”. 指针初始化时,“=”的右操作数; 除外,该语句表示指针为空): 所以 ; 这样的代码是不允许的. ...

  8. C/C++ 结构体成员在内存中的对齐规则(转载)

    这几天在看王艳平的<windows 程序设计>,第5章讲解了MFC框架是怎么管理窗口句柄到窗口实例之间的映射,用到了两个类CPlex和CMapPtrToPtr,用于管理内存分配的类(避免因 ...

  9. 关于C语言中结构体中的结构体成员导致的字节对齐问题

    关于结构体的字节对齐是什么,就不赘述,再此附上一篇文章,介绍字节对齐:http://www.linuxsong.org/2010/09/c-byte-alignment/ 这里的结构体字节对齐的数据类 ...

  10. C/C++ 结构体成员在内存中的对齐规则

    这几天在看王艳平的<windows 程序设计>,第5章讲解了MFC框架是怎么管理窗口句柄到窗口实例之间的映射,用到了两个类CPlex和CMapPtrToPtr,用于管理内存分配的类(避免因 ...

随机推荐

  1. 网页如何检查浏览器是否安装flash插件

    如果页面需要加载flash插件并且需要提示用户flash下载,这里有个官方很好的js文件只要引用就可以实现 //v1.7 // Flash Player Version Detection // De ...

  2. Flink安装启动

    1.下载安装包并解压 下载网址:https://flink.apache.org/ 版本选择可以根据安装的hadoop版本和Scala版本进行选择 我用的是:flink-1.3.3-bin-hadoo ...

  3. Web jsp开发学习——Session使用

    先展示效果:              导包:    在servlet的doget里创建session      在head里显示session     接下来进行注销的命令    点击注销链接到这个 ...

  4. JSON 使用

    ylbtech-JSON: JSON 使用 1. 把 JSON 文本转换为 JavaScript 对象返回顶部 JSON 最常见的用法之一,是从 web 服务器上读取 JSON 数据(作为文件或作为 ...

  5. MySQL 独立表空间恢复案例

    创建表的时候就会得到元数据.可以通过定义的方式对表的元数据进行生成 这个地方要注意的是 独立表空间当中   ibd & frm分别存储的是什么数据? 表空间:文件系统,为了更好的扩容数据库的存 ...

  6. docker启动时报错Error response from daemon: driver failed programming external connectivity on endpoint *

    公司服务器由于断电重启,部署在docker服务上的一些web服务需要重新开启容器, [root@localhost ~]# docker ps CONTAINER ID IMAGE COMMAND C ...

  7. Centos7.3安装部署Zabbix3.4.15(成功可用)

    1.Xshell 远程连接到Centos7.3.连接centos 系统后,首先关闭防火墙和SELINUX,如不关闭会各种拦截,网页访问等故障,容易造成蛋疼哦.#systemctl stop firew ...

  8. root用户以修改文件的方式,修改用户密码

    老早就听说linux的用户密码只是存储在普通的文本文件里,但一直没去了解,今天遇上了需要强行修改的情况... 给碰到个奇葩linux,居然没有passwd命令. 生成密码摘要 openssl pass ...

  9. mysql表操作与权限操作

    修改表ALTER TABLE 语法: . 修改表名 ALTER TABLE 表名 RENAME 新表名; . 增加字段 ALTER TABLE 表名 ADD 字段名 数据类型 [完整性约束条件…], ...

  10. Spark2.X集群运行模式

    rn 启动 先把这三个文件的名字改一下 配置slaves 配置spark-env.sh export JAVA_HOME=/opt/modules/jdk1..0_60 export SCALA_HO ...