菜鸟学python之类和对象

Acfe

　　我们把一类相同的事物叫做类，其中相同事物相同的属性可以抽象出来，而一些相同的动作行为，也可以抽象成方法。
　　比如，汽车是一个类，它包括价格、品牌等属性。那么我们需要打印某一辆车的价格和品牌，只需要使用一句代码
print "the car's type ‘ford’,price：280000"，但是当我们需要对一百个品种的车打印这句话的时候，怎么办呢？
　　这个问题我们通过以前学过的函数式编程就可以实现啦！我们只需要写一个类，然后将不同的车品牌和价格以参数的方式传到类里就好了。这样大大的提高了代码的重用性，我们就不需要把同样的print这句话写100次了。
class Car:　　
def __init__(self,type,price):
　　
self.type=type
　　
self.price=price
　　
def printInfo(self):
　　
print('the car'+self.type+'\'s price is:'+str(self.price))
　　
carOne=Car('passat',25000)
　　
carTwo=Car('ford',25000000)
　　
carOne.printInfo()
　　
carTwo.printInfo()
　　
the carpassat's price is:25000
　　
the carford's price is:25000000
　　想一想，如果没有这些做法，想要打印信息，那会多麻烦？而创建好类模版后，我们只需要根据具体情况创建不同对象（实例），然后再调用对象内的封装好的打印函数就好
　　1.self是个什么鬼
　　self是自身对象的引用，也是一个变量。创建不同对象时，self自然指向的对象也就不同；
　　所以当我们使用passat这个对象去调用printCarInfo这个方法的时候，其实是做了这样一部操作printCarInfo(passat)，把passat这个对象传给了printCarInfo方法，passat这个对象又包含了两个属性cartype、price，我们在python规定这样使用一个对象中的变量：passat.cartype、passat.price
　　在对象中，属性有点类似一个家庭中的物件，而方法相当于是要使用物件的人，人和物件都属于这个家庭，但是不给人指定具体哪个物件，人还可以使用人家的东西，万一借来的呢？所以要指定使用自己家的，就要用一个self（指向自家家庭的门牌号）
　　类的初始化过程：
carOne=Car('passat',25000)　　其实这两句话每句话都完成了三个功能：
　　第一，从car类中实例化出了一个对象——passat/ford；
　　第二：给新对象的属性赋了值
　　第三：将引用调给carOne
　　2 init 初始化函数
　　由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的 __init__ 方法，在创建实例的时候，就把 type ，price等属性绑上去：
　　注意到 __init__ 方法的第一个参数永远是 self ，表示创建的实例本身，因此，在 __init__ 方法内部，就可以把各种属性绑定到 self ，因为 self就指向创建的实例本身。有了 __init__ 方法，在创建实例的时候，就不能传入空的参数了，必须传入与 __init__ 方法匹配的参数，但 self 不需要传，Python 解释器自己会把实例变量传进去
　　3 方法
　　我们在使用printInfo函数打印数据时，不需要到外部去执行。直接封装在内部。这样，就把“数据”给封装起来了。这些封装数据的函数是和Car类本身是关联起来的，我们称之为类的方法
　　要定义一个方法，除了第一个参数是 self 外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了 self 不用传递，其他参数正常传入
def printInfo(self):　　
print('the car'+self.type+'\'s price is:'+str(self.price))
　　
carOne.printInfo()
　　这样一来，我们从外部看 Car 类，就只需要知道，创建实例需要给出 type 和 price ，而如何打印，都是在 Student 类的内部定义的，这些数据和逻辑被“封装”起来了，调用很容易，但却不用知道内部实现的细节。
　　4 访问限制
　　从前面 Student 类的定义来看，外部代码还是可以自由地修改一个实例的 price 、 type 属性：
carOne.price=250　　
the carpassat's price is:250
　　1）私有属性
　　如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__ ，在 Python 中，实例的变量名如果以 __ 开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问
class Car:　　
    def __init__(self,type,price):
　　
        self.__type=type
　　
        self.__price=price
　　
carOne=Car('wote',20)
　　
carOne.price
　　
AttributeError: 'tuple' object has no attribute 'price'
　　此时已经不能访问了，如果想访问咋办？
　　通过内部方法返回值
　　如果想改变咋办？
def get_price(self)　　
    return self.__price
　　
def get_type(self)
　　
      return self.__type
　　通过内部方法传入值，再赋值给self
  def set_price(self,price)　　
     self.__price=price
　　
  def set_type(self,type)
　　
     self.__type=type
　　思考：
　　原先那种直接通过 carOne.price = 2500 也可以修改啊，为什么要定义一个方法大费周折？
　　因为在方法中，可以对参数做检查，避免传入无效的参数：
def set_price(self,price)　　
    if 0<=price<=3000:
　　
     self.__price=price
　　
  else:
　　
        print('i cant pay')
　　双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问 __price 是因为 Python 解释器对外把 __price 变量改成了_Car__price ，所以，仍然可以通过 _Car__price 来访问 __price 变量，但最好别这样干
　　实例属性和类属性
　　由于 Python 是动态语言，根据类创建的实例可以任意绑定属性。给实例绑定属性的方法是通过实例变量，或者通过 self 变量：
class Student:　　
def __init__(self, name):
　　
self.name = name
　　
s = Student('Bob')
　　
s.score = 90

　　但是，如果 Student 类本身需要绑定一个属性呢？可以直接在>class Student:　　
name = 'Student'
　　当我们定义了一个类属性后，这个属性虽然归类所有，但类的所有实例都可以访问到。来测试一下：
>>> class Student(object):　　
... name = 'Student'
　　
...
　　
>>> s = Student() # 创建实例 s
　　
>>> print(s.name) #
　　
Student
　　
>>> print(Student.name) # 打印类的 name 属性
　　
Student
　　
>>> s.name = 'Michael' # 给实例绑定 name 属性
　　
>>> print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name 属性
　　
Michael
　　
>>> print(Student.name) # 但是类属性并未消失，用 Student.name 仍然可以访问
　　
Student
　　
>>> del s.name # 如果删除实例的 name 属性
　　
>>> print(s.name) # 再次调用 s.name，由于实例的 name 属性没有找到，类的name 属性就显示
　　
Student
　　从上面的例子可以看出，在编写程序的时候，千万不要把实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称，访问到的将是类属性。