day25-面向对象结构与成员
1、面向对象结构分析
如下面的图所示:面向对象整体大致分两块区域:
每个大区域又可以分为多个小部分:
class A:
name = 'Tom' # 静态变量(静态字段)
__iphone = '138xxxxxxxx' # 私有静态变量(私有静态字段) def __init__(self,name,age): #特殊方法
self.name = name #对象属性(普通字段)
self.__age = age #私有对象属性(私有普通字段) def func1(self): #普通方法
pass def __func(self): #私有方法
print(666) @classmethod # 类方法
def class_func(cls):
""" 定义类方法,至少有一个cls参数 """
print('类方法') @staticmethod #静态方法
def static_func():
""" 定义静态方法 ,无默认参数"""
print('静态方法') @property #属性
def prop(self):
pass
类有这么多的成员,那么我们先从那些地方研究呢? 可以从私有与公有部分和方法的详细分类两个方向去研究。
2、面向对象的私有与公有
对于每一个类的成员而言都有两种形式:
公有成员,在任何地方都能访问
私有成员,只有在类的内部才能方法
私有成员和公有成员的访问限制不同:
2.1、静态字段(静态变量)
公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
私有静态字段:仅类内部可以访问;
1)公有静态字段
class C:
name = "公有静态字段"
def func(self):
print C.name #从类内部访问类的公有属性 class D(C):
def show(self):
print C.name #从派生类访问父类的公有属性 C.name # 类访问 obj = C()
obj.func() # 类内部可以访问 obj_son = D()
obj_son.show() # 派生类中可以访问
2)私有静态字段
class C:
__name = "私有静态字段"
def func(self):
print C.__name #可以在类内部访问私有属性 class D(C):
def show(self):
print C.__name #不可以在子类中访问父类的私有属性 C.__name # 不可在外部访问 obj = C()
obj.__name # 不可在外部访问
obj.func() # 类内部可以访问 obj_son = D()
obj_son.show() #不可在派生类中可以访问
2.2、普通字段(对象属性)
公有普通字段:对象可以访问;类内部可以访问;派生类中可以访问
私有普通字段:仅类内部可以访问
1)公有普通字段
class C:
def __init__(self):
self.foo = "公有字段"
def func(self):
print(self.foo) #类内部可以访问 class D(C):
def show(self):
print(self.foo) #派生类中可以访问 obj = C()
obj.foo # 通过对象访问
obj.func() # 类内部访问 obj_son = D();
obj_son.show() # 派生类中访问
2)私有普通字段
class C:
def __init__(self):
self.__foo = "私有字段" def func(self):
print self.__foo # 类内部可以访问 class D(C):
def show(self):
print self.foo # 派生类中不可以访问 obj = C()
obj.__foo # 通过对象访问 ==> 错误
obj.func() # 类内部访问 ==> 正确 obj_son = D();
obj_son.show() # 派生类中访问 ==> 错误
2.3、方法
公有方法:对象可以访问;类内部可以访问;派生类中可以访问
私有方法:仅类内部可以访问
1)公有方法
class C:
def __init__(self):
pass
def add(self):
print('in C') class D(C):
def show(self):
print('in D')
def func(self):
self.show() obj = D()
obj.show() # 通过对象访问
obj.func() # 类内部访问
obj.add() # 派生类中访问
2)私有方法
class C:
def __init__(self):
pass
def __add(self):
print('in C') class D(C):
def __show(self):
print('in D')
def func(self):
self.__show() obj = D()
obj.__show() # 不能通过对象访问
obj.func() # 类内部可以访问
obj.__add() # 派生类中不能访问
2.4、总结
对于这些私有成员来说,他们只能在类的内部使用,不能在类的外部以及派生类中使用.
ps:非要访问私有成员的话,可以通过 对象._类__属性名obj._Classname__privateAttributeOrMethod 来访问:
,但是绝对不允许!!!
为什么可以通过._类__私有成员名访问呢?因为类在创建时,如果遇到了私有成员(包括私有静态字段,私有普通字段,私有方法),它会将其保存在内存时自动在前面加上_类名,可以在__dict__中看到。
3、面向对象的成员
3.1、字段
字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同,
普通字段属于对象
静态字段属于类
class Province:
# 静态字段
country = '中国' def __init__(self, name):
# 普通字段
self.name = name # 直接访问普通字段
obj = Province('河北省')
print obj.name # 直接访问静态字段
Province.country
上述代码可以看出:
普通字段需要通过对象来访问,静态字段通过类访问
在使用上可以看出普通字段和静态字段的归属是不同的
其在内存的存储方式类似如下图:
由上图可以看出:
静态字段在内存中只保存一份
普通字段在每个对象中都要保存一份
应用场景:
通过类创建对象时,如果每个对象都具有相同的字段,那么就使用静态字段
3.2、方法
方法包括:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同。
普通方法,也叫实例方法
定义:第一个参数必须是实例对象,该参数名一般约定为“self”,通过它来传递实例的属性和方法(也可以传类的属性和方法);
调用:只能由实例对象调用。
类方法
定义:使用装饰器@classmethod。第一个参数必须是当前类对象,该参数名一般约定为“cls”,通过它来传递类的属性和方法(不能传实例的属性和方法);
调用:实例对象和类对象都可以调用。
静态方法
定义:使用装饰器@staticmethod。参数随意,没有“self”和“cls”参数,但是方法体中不能使用类或实例的任何属性和方法;
调用:实例对象和类对象都可以调用。
实例方法就是第一个参数是self,类方法就是第一个参数是cls,而静态方法不需要额外的参数
类方法和静态方法都可以访问类的静态变量(类变量),但不能访问实例变量,例如不能访问self.name,而普通方法则可以
1)普通方法
简而言之,实例方法就是类的实例能够使用的方法。这里不做过多解释。
2)类方法
使用装饰器@classmethod。
原则上,类方法是将类本身作为对象进行操作的方法。假设有个方法,且这个方法在逻辑上采用类本身作为对象来调用更合理,那么这个方法就可以定义为类方法。另外,如果需要继承,也可以定义为类方法。
class Student:
tag = 1 @classmethod
def info(cls):
return cls.tag print(Student.info())
结果:1
如下场景:
假设我有一个学生类和一个班级类,想要实现的功能为:
执行班级人数增加的操作、获得班级的总人数;
学生类继承自班级类,每实例化一个学生,班级人数都能增加;
最后,我想定义一些学生,获得班级中的总人数。
思考:这个问题用类方法做比较合适,为什么?因为我实例化的是学生,但是如果我从学生这一个实例中获得班级总人数,在逻辑上显然是不合理的。同时,如果想要获得班级总人数,如果生成一个班级的实例也是没有必要的。
class ClassTest:
__num = 0 @classmethod
def addNum(cls):
cls.__num += 1 @classmethod
def getNum(cls):
return cls.__num # 这里我用到魔术函数__new__,主要是为了在创建实例的时候调用人数累加的函数。
def __new__(cls, *args, **kwargs):
ClassTest.addNum() #括号里不用写cls
return object.__new__(cls) class Student(ClassTest):
def __init__(self,name):
self.name = name s1 = Student('小王')
s2 = Student('小张')
print(ClassTest.getNum())
结果:2
3)静态方法
使用装饰器@staticmethod。
静态方法是类中的函数,不需要实例。静态方法主要是用来存放逻辑性的代码,逻辑上属于类,但是和类本身没有关系,也就是说在静态方法中,不会涉及到类中的属性和方法的操作。可以理解为,静态方法是个独立的、单纯的函数,它仅仅托管于某个类的名称空间中,便于使用和维护。
譬如,我想定义一个关于时间操作的类,其中有一个获取当前时间的函数。
import time class TimeTest:
def __init__(self, hour, minute, second):
self.hour = hour
self.minute = minute
self.second = second @staticmethod
def showTime():
return time.strftime("%H:%M:%S", time.localtime()) print(TimeTest.showTime())
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
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
#不使用property
class BMI:
def __init__(self, name, weight, high):
self.name = name
self.high = high
self.weight = weight def bmi_show(self):
rst = self.weight/self.high ** 2
print('%s的BMI值为%s' %(self.name, rst)) p1 = BMI('Tom', 65, 1.7)
p1.bmi_show() #需要通过调用方法()的方式显示结果 #使用property
class BMI:
def __init__(self, name, weight, high):
self.name = name
self.high = high
self.weight = weight
@property
def bmi_show(self):
rst = self.weight/self.high ** 2
print('%s的BMI值为%s' %(self.name, rst)) p1 = BMI('Tom', 65, 1.7)
p1.bmi_show #将方法伪装成一个属性,通过调用属性的方式显示结果
为什么要用property
将一个类的函数定义成特性以后,对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的,这种特性的使用方式遵循了统一访问的原则
@property可以将python定义的函数“当做”属性访问,从而提供更加友好访问方式。
1》只有@property表示只读。
2》同时有@property和@x.setter表示可读可写。
3》同时有@property和@x.setter和@x.deleter表示可读可写可删除。
由于新式类中具有三种访问方式,我们可以根据他们几个属性的访问特点,分别将三个方法定义为对同一个属性:获取、修改、删除
class A:
@property
def func(self):
print('get的时候运行我') @func.setter
def func(self,value):
print('set的时候运行我') @func.deleter
def func(self):
print('del的时候运行我') #只有在方法func定义property后才能定义func.setter,func.deleter
obj1 = A()
obj1.func
#get的时候运行我
obj1.func = 'a'
#set的时候运行我
del obj1.func
#del的时候运行我 或者:
class Foo:
def get_func(self):
print('get的时候运行我啊') def set_func(self,value):
print('set的时候运行我啊') def delete_func(self):
print('delete的时候运行我啊')
func=property(get_func,set_func,delete_func) #内置property三个参数与get,set,delete一一对应 obj = Foo()
obj.func
#get的时候运行我啊
obj.func = 'a'
#set的时候运行我啊
del obj.func
# delete的时候运行我啊
例子:显示苹果的价格
class Apple:
def __init__(self, ori_price, discount):
self.ori_price = ori_price
self.discount = discount
@property
def price(self):
ret = self.ori_price * self.discount
print('苹果的折扣价是%s'%ret)
@price.setter
def price(self, new_price):
self.ori_price = new_price
apple1 = Apple(8, 0.8) #定义苹果的价格是8元/kg,折扣是0.8
apple1.price apple1.price = 7 #重新定义苹果的价格是7元/kg,这时苹果的价格是7*0.8
apple1.price
银行账号的例子,我们要确保没人能设置金额为负,并且有个只读属性cny返回换算人名币后的金额。
class Account:
def __init__(self, rate):
self._amount = 0
self.rate = rate @property
def amount(self):
"""账号余额(美元)"""
return self._amount @property
def cny(self):
"""账号余额(人名币)"""
return self._amount * self.rate
@amount.setter
def amount(self, value):
if value < 0:
print('金额不能为负')
else:
self._amount = value obj1 = Account(6.6)
obj1.amount = 100
print(obj1.cny)
#660.0
obj1.amount = -100
#金额不能为负
day25-面向对象结构与成员的更多相关文章
- 标记化结构初始化语法 在结构体成员前加上小数点 如 “.open .write .close ”C99编译器 .
今天在看串口驱动(四)的时候 有这样一个结构体初始化 我很不理解 如下: static struct s3c24xx_uart_port s3c24xx_serial_ports[NR_PORTS] ...
- Java基础语法(9)-面向对象之类的成员
title: Java基础语法(9)-面向对象之类的成员 blog: CSDN data: Java学习路线及视频 1.面向对象特征--封装 为什么需要封装?封装的作用和含义? 我要用洗衣机,只需要按 ...
- (C语言)结构体成员的引用->(箭头)和 .(点)
关于结构体成员的引用有这样的规律: 箭头(->):左边必须为指针: 点号(.):左边必须为实体. 那么如果一个结构体指针引用一个成员,这个成员又是一个结构体(并且是一个实体),那么如果要引用这个 ...
- C语言中访问结构体成员时用‘.’和‘->’的区别
举个例子,定义了一个叫Student,别名为stu的结构类型,我们声明了一个结构体变量叫stu1,声明了一个结构体指针为stuP. typedef struct Student { char name ...
- C基础--结构体成员初始化方式
之前在linux内核代码中看到结构体成员成员初始化使用类似于.owner = THIS_MODULE, 不太见过,于是搜了个博客,分享下: 转自:http://www.cnblogs.com/Anke ...
- 文成小盆友python-num8 面向对象中的成员,成员修饰符,特殊成员,异常处理,设计模式之单例模式
本节主要内容: 1.面向对象中的成员 2.成员修饰符 3.特殊成员 4.异常处理 5.设计模式之单例模式 一.面向对象中的成员(类的成员) 类的成员总共可以分为3大类,每类中有不同的分支. 1.总述, ...
- 指针直接赋值为整型AND利用宏定义求结构体成员偏移量
首先我们要更正一个很熟悉的概念,那就是指针不仅仅是“地址”,指针还有一个很重要的特性,那就是“类型”. 指针初始化时,“=”的右操作数; 除外,该语句表示指针为空): 所以 ; 这样的代码是不允许的. ...
- C/C++ 结构体成员在内存中的对齐规则(转载)
这几天在看王艳平的<windows 程序设计>,第5章讲解了MFC框架是怎么管理窗口句柄到窗口实例之间的映射,用到了两个类CPlex和CMapPtrToPtr,用于管理内存分配的类(避免因 ...
- 关于C语言中结构体中的结构体成员导致的字节对齐问题
关于结构体的字节对齐是什么,就不赘述,再此附上一篇文章,介绍字节对齐:http://www.linuxsong.org/2010/09/c-byte-alignment/ 这里的结构体字节对齐的数据类 ...
- C/C++ 结构体成员在内存中的对齐规则
这几天在看王艳平的<windows 程序设计>,第5章讲解了MFC框架是怎么管理窗口句柄到窗口实例之间的映射,用到了两个类CPlex和CMapPtrToPtr,用于管理内存分配的类(避免因 ...
随机推荐
- 第一篇Docker博文
Docker组件 Docker引擎 Docker是一个客户端/服务器(C/S)架构的程序.Docker客户端只需向Docker服务器或叫守护进程发出请求,服务器将完成所有工作并返回结果. Docker ...
- mysql默认8小时连接断开机制解决
转载连接:http://www.myexception.cn/database/1639209.html 本文提供了对c3p0与DBCP连接池连接MySql数据库时, 8小时内无请求自动断开连接的解决 ...
- jdbi
JDBI是一个使用方便的SQL开发库,用符合Java语言习惯的集合.Bean等方式,提供关系数据库访问接口,同时保留了JDBC类似的信息.JDBI提供了链式和SQL两种风格的API. jdbi的网址是 ...
- Navicat 12 破解方法
1.按步骤安装Navicat Premium,如果没有可以去官网下载:http://www.navicat.com.cn/download/navicat-premium 2.安装好后下载激活文件:h ...
- SCCM2012 R2实战系列之十二:解决OSD分发时间过长的问题
对于SCCM 2012 R2的初学者来说,能够成功分发操作系统可能已经是非常兴奋了.但在企业中会遇到客户提出的各种各样苛刻的需求.所以在平时实验过程中多站点客户的角度想问题,尽可能的贴近企业实际生产环 ...
- HTTP协议的简单解析
超文本传输协议(HTTP,HyperText Transfer Protocol)是用于从服务器传输超文本到本地浏览器的传输协议,是应用最为广泛的网络协议.B/S网络架构的核心是HTTP,掌握HTTP ...
- Round545div2B(1138B)
一.题目链接 https://codeforces.com/problemset/problem/1138/B 二.思路 贪心是肯定不行的. 设会$[1,0]$的人存在容器$p_1$里面,会$[0,1 ...
- 提高modem的core dump级别
zhangze@zhangze-OptiPlex-7040:~/e2_8939-E2-2104026-CTA/device/qcom/common$ git showcommit be2b5cb33a ...
- Qt Xml Dom
//Dom方式更改节点信息 bool XmlTools::SetValue(QString name,float exposure,float gain,float gamma,int brightn ...
- babel-polyfill
babel-polyfill Babel默认只转换新的JavaScript句法(syntax),而不转换新的API,比如Iterator.Generator.Set.Maps.Proxy.Reflec ...