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,用于管理内存分配的类(避免因 ...
随机推荐
- 网页如何检查浏览器是否安装flash插件
如果页面需要加载flash插件并且需要提示用户flash下载,这里有个官方很好的js文件只要引用就可以实现 //v1.7 // Flash Player Version Detection // De ...
- Flink安装启动
1.下载安装包并解压 下载网址:https://flink.apache.org/ 版本选择可以根据安装的hadoop版本和Scala版本进行选择 我用的是:flink-1.3.3-bin-hadoo ...
- Web jsp开发学习——Session使用
先展示效果: 导包: 在servlet的doget里创建session 在head里显示session 接下来进行注销的命令 点击注销链接到这个 ...
- JSON 使用
ylbtech-JSON: JSON 使用 1. 把 JSON 文本转换为 JavaScript 对象返回顶部 JSON 最常见的用法之一,是从 web 服务器上读取 JSON 数据(作为文件或作为 ...
- MySQL 独立表空间恢复案例
创建表的时候就会得到元数据.可以通过定义的方式对表的元数据进行生成 这个地方要注意的是 独立表空间当中 ibd & frm分别存储的是什么数据? 表空间:文件系统,为了更好的扩容数据库的存 ...
- docker启动时报错Error response from daemon: driver failed programming external connectivity on endpoint *
公司服务器由于断电重启,部署在docker服务上的一些web服务需要重新开启容器, [root@localhost ~]# docker ps CONTAINER ID IMAGE COMMAND C ...
- Centos7.3安装部署Zabbix3.4.15(成功可用)
1.Xshell 远程连接到Centos7.3.连接centos 系统后,首先关闭防火墙和SELINUX,如不关闭会各种拦截,网页访问等故障,容易造成蛋疼哦.#systemctl stop firew ...
- root用户以修改文件的方式,修改用户密码
老早就听说linux的用户密码只是存储在普通的文本文件里,但一直没去了解,今天遇上了需要强行修改的情况... 给碰到个奇葩linux,居然没有passwd命令. 生成密码摘要 openssl pass ...
- mysql表操作与权限操作
修改表ALTER TABLE 语法: . 修改表名 ALTER TABLE 表名 RENAME 新表名; . 增加字段 ALTER TABLE 表名 ADD 字段名 数据类型 [完整性约束条件…], ...
- Spark2.X集群运行模式
rn 启动 先把这三个文件的名字改一下 配置slaves 配置spark-env.sh export JAVA_HOME=/opt/modules/jdk1..0_60 export SCALA_HO ...