Python中使用class()，面向对象有什么优势

首先我是辣鸡，然后这个问题的确有点意思

首先，类是一个集合，包含了数据，操作描述的一个抽象集合

你可以首先只把类当做一个容器来使用

class Cycle:
   def __init__(self,r):
       self.pi=3.14
       self.r=r
a=Cycle(4)
b=Cycle(7)

你看，我们定义了一个 Cycle 类，我们现在只是将它当做一个数据集合来用，我们利用其实例之间彼此数据隔离的特性来保证具体的实例数据彼此不污染。好了你现在想问，为什么我们要用数据集合来放数据

好了，我们来看看没有类之前我们会怎么样,假设我们现在要计算圆的面积

def square(r,pi):
   return pi * (r**2)
PI=3.14
a_r=4
a_square=square(a_r,PI)
b_r=7
b_square=square(b_r,PI)

看起来没有问题，好了，现在问题来了，假如，你现在要计算很多圆的面积，那么你是不是发现，不断的用变量命来隔离数据方式变得越来越脏了。而且你发现是不是有很多冗余的代码

好了我们这么改一改

class Cycle:
   def __init__(self,r):
       self.pi=3.14
       self.r=r

def square(value):
   if not isinstance(value,Cycle):
       raise ValueError("value muse be Cycle instace")
   value.square=value.pi * (value.r**2)

a=Cycle(4)
b=Cycle(7)

square(a)
square(b)

好了，你有没有觉得现在清晰了一点。

PS：遇到问题没人解答？需要Python学习资料？可以加点击下方链接自行获取

note.youdao.com/noteshare?id=2dce86d0c2588ae7c0a88bee34324d76

好了，现在我们现在还可以改一下

class Cycle:
   def __init__(self,r):
       self.pi=3.14
       self.r=r
   def square(self,value):
       return self.pi * (self.r**2)

好了，现在你可能迷惑了，我们为啥要把 square 函数放在类中？

好了，我现在要计算长方形，原型，梯形各种各样二维几何图形的面积，这样该怎么写？？？

你想了想我们之前说的将类作为数据容器，你想了想写了如下的代码

class Rectangle:
   def __init__(self,length,height):
       self.length=length
       self.height=height
class Cycle:
   def __init__(self,r):
       self.pi=3.14
       self.r=r
def rec_square(value):
   if not isinstance(value,Rectangle):
       raise ValueError("value muse be Rectangle instace")
   value.square=value.length * value.height
def cycle_square(value):
   if not isinstance(value,Cycle):
       raise ValueError("value muse be Cycle instace")
   value.square=value.pi * (value.r**2)

你想一想，这样是不是感觉如果计算需求越来越多，代码是不是还是会越来越脏？

如果我们将函数放在类里，并且用继承的特性，我们可以写出这样的代码

class Geometry:
   def get_square(self):
       raise NotImplementedError

class Rectangle(Geometry):
   def __init__(self,length,height):
       self.length=length
       self.height=height
   def get_square(self):
       return self.length*self.height

class Cycle(Geometry):
   def __init__(self,r):
       self.pi=3.14
       self.r=r
   def get_square(self):
       return self.pi * (self.r**2)

def square(value):
   if not isinstance(value,Geometry):
       raise ValueError("value muse be Geometry instace")
   value.square=value.get_square()

你看，我们现在只需要给用户暴露一个统一的接口，用户（用户也以是我们自己）不需要关心怎么样选择正确的函数，他只需要调用统一的 square 函数，就可以获取到具体的面积，是不是轻松很多了？？

所以，类，它是对数据，操作的一种封装，这个封装的意义在于我们可以去更好的优化代码结构。

好了再举一个例子，我们可以用类来控制访问权限

class People:
   def __init__(self,website):
       self.__favorite_website="1024.com"
   def bad_or_not(self):
       return self.__favorite_website=="1024.com"

你看，我们用 private 变量，来确保外部没法直接访问一些敏感数据（实际上 Python 里 private 并不严格，hook 一下还是可以访问的）

好，在举一个例子

class People:
   def __init__(self,website):
       self.__favorite_website="1024.com"
   def bad_or_not(self):
       return self.__favorite_website=="1024.com"
   @property
   def favorite_website(self):
       return self.__favorite_website
   @favorite_website.setter
   def favorite_website(self,value):
       if value=="1024.com":
           raise ValueError("你不能去草榴，兄弟，你营养不足")
       self.__favorite_website=value

你看，我们现在很方便的实现在设置数据值的时候，对其过滤。

撤了这么多，回到你的问题

首先A君说的没毛病，但我想知道仅仅使用函数锤子，螺丝刀来完成一个项目比使用Class工厂+函数锤子来完成一个项目的效率会更低么？

理由是什么？大神在什么时候会考虑使用Class来提高代码的“执行效率”和代码的“可读性”。回归实际情况，我很多时候都是调用同一个函数/方法去输出某个结果。

至今还想不出为什么调用Class会更方便？（PS:本人大菜鸟，写了上千行代码了，但仍然搞不懂什么情况下需要用到Class类。也曾尝试在自己的代码中强行加入Class输出结果

但感觉不灵活，而且要写的代码明显多了也不便于理解。求大神举例，碾压我的无知！）。C君说大型项目不使用Class调用对象会累死，到底这个“累死”体现在哪里？

首先一个问题，我整个答案里所写的这些代码，不用面向对象这一套能不能实现？

很明显，能。

但是实现的干净么？个人觉得不干净。

项目规格上去后，我们如果按照传统的方式进行开发，务必要多重检查，确保自己不会手抖调用了错误的东西。而 OOP 这一套思想，其实就是通过利用合适的代码结构和封装，某种程度上来讲是减少我们犯错的可能。

同时，现在开发基本都不是一个人的单打独斗，你写的代码可能会被其余人使用与维护。我们有个前提，要假设使用维护你代码的人都是傻逼。我们要适当的封装代码，优化结构，让使用者尽可能的少犯错、

所以最后，无论是各个语言的变量命名规则也好，还是 OOP 这一套范式也好。其本质是在自由度与可读性可维护性之间的一种相对较优的妥协，这种妥协根本的目的就在于通过规范化的操作与封装，减少团队开发维护的成本，优化开发体验。

另外，关于开发这一套还有个老生常谈的问题过度封装。我个人的观点是在你知道什么是 过度封装 之前，你没必要考虑这个问题，按照教科书和开源代码里的结构，去不断封装优化你的代码。

面向对象　更容易使用　，缺点就是　换一个开发人，难维护，很难理解前面人的思维，出了错不好找位置