1、
私有权限
:在属性名和方法名 前面加上两个下划线 __ 类的私有属性 和 私有方法
,都不能通过对象直接访问,但是可以在本类内部访问;
2、类的
私有属性 和 私有方法
,都不会被子类继承,子类也无法访问;私有属性 和 私有方法 往往用来处理类的内部事情,不通过对象处理,起到安全作用
。
这里实例化类也无法访问
class Person(object):
def __init__(self,name,age):
self.name=name
self.__age=age
def __privateMethod(self):
print("我是私有方法")
obj=Person("yang",19)
print(obj.__age)
print(obj.__privateMethod())
这样会报错
3、私有属性,可以在类内部通过self调用,但不能通过对象访问。私有方法,可以在类内部通过self调用,但不能通过对象访问
class Person(object):
def __init__(self,name,age):
self.name=name
self.__age=age
def __privateMethod(self):
print("我是私有方法")
def method(self):
return self.____privateMethod()
def getAge(self):
return self.__age
obj=Person("yang",19)
print(obj.getAge())
print(obj.method())
这样可以访问了
4、对象不能访问私有权限的属性和方法。子类不能继承父类私有权限的属性和方法
class Person(object):
def __init__(self,name):
self.name=name
self.__age=19
def __privateMethod(self):
print("我是私有方法")
def method(self):
return self.____privateMethod()
def getAge(self):
return self.__age
class Son(Person):
pass
s=Son("yang")
s.__privateMethod()
报错,子类不能调用
5、Python中没有像C++中 public 和 private, protected 这些关键字来区别公有属性和私有属性。
Python是以属性命名方式来区分,如果在属性和方法名前面加了2个下划线’__',则表明该属性和方法是私有权限,否则为公有权限。
6、私有属性不能直接访问,所以无法通过第一种方式修改,一般的通过第二种方式修改私有属性的值:定义一个可以调用的公有方法,在这个公有方法内访问修改。
class Person(object):
def __init__(self,name,age):
self.name=name
self.__age=age
def __privateMethod(self):
print("我是私有方法")
def setAge(self,age):
self.__age=age
def getAge(self):
return self.__age
obj=Person("yang",19)
print(obj.setAge(1))
这样可以访问了
现代软件开发中,通常会定义get_xxx()方法和set_xxx()方法来获取和修改私有属性值
get_xxx()方法–>返回私有属性的值 set_xxx()方法–>接收参数,修改私有属性的值
对象不能访问私有权限的属性和方法,可以通过访问公有方法set_money()来修改私有属性的值
可以通过访问公有方法get_money()来获取私有属性的值
1、实例方法/对象方法
实例方法或者叫对象方法,指的是我们在类中定义的普通方法。只有实例化对象之后才可以使用的方法,该方法的第一个形参接收的一定是对象本身
class Person(object):
def hello(self):
print("hello")
2、静态方法
(1).格式:在方法上面添加 @staticmethod
(2).参数:静态方法可以有参数也可以无参数
(3).应用场景:一般用于和类对象以及实例对象无关的代码。
(4).使用方式: 类名.类方法名(或者对象名.类方法名)。
class Game:
@staticmethod
def menu():
print('------')
print('开始[1]')
print('暂停[2]')
print('退出[3]')
Game.menu()
类方法
无需实例化,可以通过类直接调用的方法,但是方法的第一个参数接收的一定是类本身
class Person:
type = '人类'
@classmethod
def test(cls):
print(cls.type)
Person.test()
举例:使用类方法对商品进行统一打折
class Goods:
__discount = 1
def __init__(self, name, price):
self.name = name
self.price = price
@classmethod
def change_discount(cls, new_discount):
cls.__discount = new_discount
@property
def finally_price(self):
return self.price * self.__discount
banana = Goods('香蕉', 10)
apple = Goods('苹果', 16)
Goods.change_discount(0.8)
print(banana.finally_price)
print(apple.finally_price)
Goods.change_discount(0.5)
print(banana.finally_price)
print(apple.finally_price)
输出为:
8.0
12.8
5.0
8.0
类方法和静态方法的区别
类方法
定义:使用装饰器@classmethod。第一个参数必须是当前类对象,该参数名一般约定为“cls”,通过它来传递类的属性和方法(不能传实例的属性和方法);
调用:实例对象和类对象都可以调用。
静态方法
定义:使用装饰器@staticmethod。参数随意,没有“self”和“cls”参数,但是方法体中不能使用类或实例的任何属性和方法;
调用:实例对象和类对象都可以调用。
实例方法
简而言之,实例方法就是类的实例能够使用的方法。这里不做过多解释。
类方法
使用装饰器@classmethod
原则上,类方法是将类本身作为对象进行操作的方法。假设有个方法,且这个方法在逻辑上采用类本身作为对象来调用更合理,那么这个方法就可以定义为类方法。另外,如果需要继承,也可以定义为类方法。
如下场景:
假设我有一个学生类和一个班级类,想要实现的功能为:
执行班级人数增加的操作、获得班级的总人数;
学生类继承自班级类,每实例化一个学生,班级人数都能增加;
最后,我想定义一些学生,获得班级中的总人数。
思考:这个问题用类方法做比较合适,为什么?因为我实例化的是学生,但是如果我从学生这一个实例中获得班级总人数,在逻辑上显然是不合理的。同时,如果想要获得班级总人数,如果生成一个班级的实例也是没有必要的。
class ClassTest(object):
__num = 0
@classmethod
def addNum(cls):
cls.__num += 1
@classmethod
def getNum(cls):
return cls.__num
# 这里我用到魔术函数__new__,主要是为了在创建实例的时候调用人数累加的函数。
def __new__(self):
ClassTest.addNum()
return super(ClassTest, self).__new__(self)
class Student(ClassTest):
def __init__(self):
self.name = ''
a = Student()
b = Student()
print(ClassTest.getNum())
静态方法
使用装饰器@staticmethod。
静态方法是类中的函数,不需要实例
。静态方法主要是用来存放逻辑性的代码,逻辑上属于类,但是和类本身没有关系,也就是说在静态方法中,不会涉及到类中的属性和方法的操作
。可以理解为,静态方法是个独立的、单纯的函数,它仅仅托管于某个类的名称空间中,便于使用和维护。譬如,我想定义一个关于时间操作的类,其中有一个获取当前时间的函数。
import time
class TimeTest(object):
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)
如上,使用了静态方法(函数),然而方法体中并没使用(也不能使用)类或实例的属性(或方法)。若要获得当前时间的字符串时,并不一定需要实例化对象,此时对于静态方法而言,所在类更像是一种名称空间。其实,我们也可以在类外面写一个同样的函数来做这些事,但是这样做就打乱了逻辑关系,也会导致以后代码维护困难。
以上就是我对Python的实例方法,类方法和静态方法之间的区别和作用的简要阐述。
1.基本认识
property属性可以用来给属性添加约束,比如温度属性,我们不允许低于-273度;成绩属性,我们不允许0分以下等等。而且使用property属性,将来修改约束条件的时候也很方便,可以在代码的调用方式不变的情况下改变结果。
python中使用property属性有两种方法。使用@property装饰器和使用property()函数。
- @property装饰器
@property装饰器就是负责把一个方法变成属性调用的。如下实例就可以通过s.score来获得成绩,并且对score赋值之前做出了数据检查。
class Student(object):
def __init__(self, score=0):
self._score = score
@property
def score(self):
print("getting score")
return self._score
@score.setter
def score(self, value):
print("setting score")
if not isinstance(value, int):
raise ValueError("score must be an integer!")
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
s = Student(60)
s.score
print("=====================")
s.score = 88
s.score