python的面向对象

类继承

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()

类方法

无需实例化，可以通过类直接调用的方法，但是方法的第一个参数接收的一定是类本身

• (1).在方法上面添加@classmethod
• (2).方法的参数为 cls 也可以是其他名称，但是一般默认为cls
• (3).cls 指向 类对象
• (4).应用场景：当一个方法中只涉及到静态属性的时候可以使用类方法(类方法用来修改类属性)。
• (5).使用 可以是 对象名.类方法名。或者是 类名.类方法名

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的实例方法，类方法和静态方法之间的区别和作用的简要阐述。

python中的property属性

1.基本认识

property属性可以用来给属性添加约束，比如温度属性，我们不允许低于-273度；成绩属性，我们不允许0分以下等等。而且使用property属性，将来修改约束条件的时候也很方便，可以在代码的调用方式不变的情况下改变结果。

python中使用property属性有两种方法。使用@property装饰器和使用property()函数。

2. @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