python 中的类

wojiaodabai

学习python必须面对的一个问题就是面向对象编程，面向对象编程必须学会定义类。什么是类呢？

1.让我们来定义一个餐厅类。
class Restrant():
    """
   this is a restrant
    """
    def __init__(self,name,d_type):
        self.name=name
        self.d_type=d_type
    def describe_restrant(self):
        print(self.name,self.d_type)
    def open_restrant(self):
        print(self.name,'is running')
这样一个类就被创建了，类中定义的函数称为方法。这个类有两个方法:餐厅的基本描述（名字和类型）和餐厅正在营业。
2.访问属性。

创建实例对象。比如：我们的餐厅叫小明，是中餐餐厅
r=Restrant('xiaoming','chinese')
r.name
r.d_type
结果：
'xiaoming'
'chinese'
3.调用方法。

r=Restrant('xiaoming','chinese')
#可以用变量去接收类的对象。
r.describe_restrant()
r.open_restrant()
结果：
xiaoming chinese
xiaoming is running

4.python 的内置类属性。
__name__ 类的名字
__doc__   类的doc文档
__module__类所在的模块
__dict__ 类的信息，以字典的方式展示
__base__ 类的所有父类构成的元素。
print（Restrant.__name__)
print(Restrant.__doc__)
print(Restrant.__module__)
print(Restrant.__dict__)
print(Restrant.__base__)
结果：
Restrant

   this is a restrant
   
__main__
{'__module__': '__main__', '__doc__': '\n   this is a restrant\n    ', '__init__': <function Restrant.__init__ at 0x000000000AFBAD08>, 'describe_restrant': <function Restrant.describe_restrant at 0x000000000AFBAD90>, 'open_restrant': <function Restrant.open_restrant at 0x000000000AFBAE18>, '__dict__': <attribute '__dict__' of 'Restrant' objects>, '__weakref__': <attribute '__weakref__' of 'Restrant' objects>}
<class 'object'>

5.修改属性的值。
我们可以通过三种方法修改：直接通过实例进行修改；通过方法进行设置；通过方法进行递增（增加特定的值）
定义一个汽车类，并添加默认属性。
class Car():
    """"""
    def __init__(self,make,model,year):
        self.make=make
        self.model=model
        self.year=year
        self.odometer_reading = 0
    def g_d_name(self):
        long_name=str(self.year)+' '+self.model+' '+self.make
        return long_name.title()

my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.g_d_name())
my_new_car.read_odometer(）

2016 A4 Audi
This car has 0 miles on it.
   
5.1 直接通过实例进行修改。
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

This car has 23 miles on it.

5.2通过方法修改属性的值。

class Car():
    """"""
......
def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        self.odometer_reading = mileage

my_new_car.update_odometer(23)
my_new_car.read_odometer()
This car has 23 miles on it.

5.3通过方法对属性的值进行递增

class Car():
    """"""
......
    def increment_odometer(self, miles):
           """将里程表读数增加指定的量"""
           self.odometer_reading += miles

my_used_car = Car('subaru', 'outback', 2013)
print(my_used_car.g_d_name())
my_used_car.update_odometer(23500)
my_used_car.read_odometer()
my_used_car.increment_odometer(100)
my_used_car.read_odometer()

2013 Outback Subaru
This car has 23500 miles on it.
This car has 23600 miles on it.   
   
6.类的继承。

class Car():
    """"""
    def __init__(self,make,model,year):
        self.make=make
        self.model=model
        self.year=year
    def g_d_name(self):
        long_name=str(self.year)+' '+self.model+' '+self.make
        return long_name.title()
   
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):  #方法__init__() 接受创建Car 实例所需的信息
        """初始化父类的属性"""
        super().__init__(make, model, year)
               
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.g_d_name())
2016 Model S Tesla

现在让我们看的更清楚一些：
class Parents():
    def __init__(self):
        print('调用父类的构造函数')
    def parensMthods(self):
        print('调用父类的方法')
class Child(Parents):
    def __init__(self):
        print('调用子类的构造函数')
    def chileMthods(self):
        print('调子父类的方法')

p2=Child()
p2.parensMthods()
调用父类的方法
由此可见，子类可以调用父类的构造方法。但是python不会自己去调用。可以加上 super().__init__()就会自动调用父类的方法。
class Parents():
    def __init__(self):
        print('调用父类的构造函数')
    def parensMthods(self):
        print('调用父类的方法')
class Child(Parents):
    def __init__(self):
        super().__init__()
        print('调用子类的构造函数')
    def childMthods(self):
        print('调子父类的方法')

p2=Child()
调用父类的构造函数
调用子类的构造函数

7.子类的重写。

class Parents():
    def __init__(self):
        print('调用父类的构造函数')
    def parensMthods(self):
        print('调用父类的方法')
    def say(self):
        print('hello world')
class Child(Parents):
    def __init__(self):
        super().__init__()
        print('调用子类的构造函数')
    def childMthods(self):
        print('调子父类的方法')
    def say(self):
        print('hello 小甲鱼')

p2=Child()
p2.say()
结果：hello 小甲鱼
再看这个：
p1=Parents()
p1.say()
结果：hello world
我们看到父类和子类中都有say()这个函数，在子类中运行的是自己定义的函数，不同于父类。

8.类的私有属性。
_private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。
在类内部的方法中使用时  self.__private_attrs。
class Parents():
    __name='小甲鱼'
    def __init__(self):
        print('调用父类的构造函数')
    def parensMthods(self):
        print('调用父类的方法')

我们没有办法调用到__name ，因为这是类私有的，要想调用，可以加一个方法。比如：
class Parents():
    __name='小甲鱼'
    def __init__(self):
        print('调用父类的构造函数')
    def parensMthods(self):
        print('调用父类的方法')
    def showName(self):
        print(self.__name)

p=Parents()
p.showName()
结果：小甲鱼
我们加了一个showName方法，那就可以调用了。
如果你觉得定义函数太麻烦，还有一种简单的访问私有变量的方法：
p._Parents__name
结果：小甲鱼

好了，以上就是我学习类的笔记。