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. 《Kubernetes权威指南》笔记-Pod、容器与Node的关系

  2. Ansible基础入门

    1.1 Ansible是什么        随着移动互联.物联网.互联网+.大数据.云计算等大规模应用的催生推动,以及人们日常生活的互联网化,互联网的蓬勃发展不仅冲击影响着整个经济体,更对人们的生活理 ...

  3. centos6.8下pptp客户端的安装配置

    原文: https://blog.csdn.net/zhang11321132/article/details/20612473 yum -y install ppp pptp pptp-setup ...

  4. [UE4]AWP狙击枪开镜

    一.使用一张PNG图片,中间是透明的,其他部分是纯黑色.创建一个UserWidget.作为AWP的开镜后的准心.AWP默认状态下是没有准心的. 二.右键开镜.把第一步创建的UserWidget创建出来 ...

  5. [UE4]Overlay容器:图片随着其他容器(比如Vertical Box)大小而同步改变

  6. Centos 7: 改变docker的image存放目录

    1.创建新的数据目录 mkdir /data/docker 2.关闭docker进程 systemctl stop docker 3.修改配置文件/usr/lib/systemd/system/doc ...

  7. hue中使用oozie的workflow执行mr

    workflow创建任务 进入hue–Workflows–编辑器–workflow–创建 拖一个mapreduce作业(在页面靠近顶端有一排选项图标)到页面中间虚线框中 Jar路径必须是hdfs中ja ...

  8. Delphi 解决Utf8ToAnsi和Utf8DeCode转换编码为空的问题

    //delphi DecodeUtf8Str解决系统自带UTF8解码缺陷 function DecodeUtf8Str(const S: UTF8String): WideString; var le ...

  9. Java捕获异常的问题

    ---恢复内容开始--- 在Java编译过程中,有时候会出现输入未按照规定输入的情况,此时需要警告用户输入错误,这就会是程序运行过程中出现异常.异常就是可预测但是又没办法消除的一种错误.所以在编写过程 ...

  10. Linux服务器安装Nginx

    Nginx 安装 一.安装编译工具及库文件 yum -y install make zlib zlib-devel gcc-c++ libtool openssl openssl-devel 二.首先 ...