# Basic ### Concepction | 概念 | 解释 | | ------------ | --------------------------------------------------------------------------------------------------------------------------------------- | | **类(Class)** | 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例 | | **类变量** | 类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用 | | **数据成员** | 类变量或者实例变量, 用于处理类及其实例对象的相关的数据 | | **方法重写** | 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写 | | **局部变量** | 定义在方法中的变量，只作用于当前实例的类 | | **实例变量** | 在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的 | | **继承** | 即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal） | | **实例化** | 创建一个类的实例，类的具体对象 | | **方法** | 类中定义的函数 | | **对象** | 通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法 | #### 定义一个类 ```python class Car: def __init__(self, color, model, year): self.color = color self.model = model self.year = year ``` ### Create object ``` my_car = Car("yellow", "beetle", 1967) ``` 查看一下my\_car的属性 ```python print(f" My {my_car.color} car {my_car.model} is made in {my_car.year}") # My yellow car beetle is made in 1967 ``` ### Add attribute ```python my_car.wheels = 5 print(f"Wheels: {my_car.wheels}") # Wheels: 5 ``` ```python dir(my_car) Out: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'color', 'model', 'wheels', <====已经添加成功啦 'year'] ``` ### Class variable 在Python中，我们在类外声明一个类变量，下面让我们修改一下Car类： ```python class Car: wheels = 0 def __init__(self, color, model, year): self.color = color self.model = model self.year = year ``` 这样的话，我们在调用wheels这个变量时，可以通过实例，或者直接调用Car.wheels： ```python my_car = Car("yellow", "beetle", 1967) print(f"My car is {my_car.color}") print(f"It has {Car.wheels} wheels") print(f"It has {my_car.wheels} wheels") Out: My car is yellow It has 0 wheels It has 0 wheels ``` 这里需要注意一下，如果想要通过my\_car.wheels =xxx来修改wheels的值，不会真正修改类变量wheels的值，我们来看一个具体的例子： ```python my_car = Car("yellow", "Beetle", "1966") my_other_car = Car("red", "corvette", "1999") print(f"My car is {my_car.color}") print(f"It has {my_car.wheels} wheels") print(f"My other car is {my_other_car.color}") print(f"It has {my_other_car.wheels} wheels") Out： My car is yellow It has 0 wheels My other car is red It has 0 wheels ``` 我们首先创建两个实例my\_car 和my\_other\_car ，默认的wheels=0，下面我们首先直接通过Car这个类来修改类变量的值： ```python # Change the class variable value Car.wheels = 4 print(f"My car has {my_car.wheels} wheels") print(f"My other car has {my_other_car.wheels} wheels") Out： My car has 4 wheels My other car has 4 wheels ``` 可以看到这样修改的话，Car类拥有的所有实例中的wheels值会被全部修改，如果我们通过my\_other\_car 来修改呢？ ```python # Change the instance variable value for my_car my_car.wheels = 5 print(f"My car has {my_car.wheels} wheels") print(f"My other car has {my_other_car.wheels} wheels") Out: My car has 5 wheels My other car has 4 wheels ``` 现在大家可以发现区别了，仅仅是修改了my\_car中wheels的值，对类本身不会造成影响在Python中的所有属性都是public，可能有c++和java的同学觉得神奇，其实python最初规定了一种特殊的命名方式来区分public还是private，那就是下划线\_ ### Private & Public attribute ```python class Car: wheels = 0 def __init__(self, color, model, year): self.color = color self.model = model self.year = year self._cupholders = 6 my_car = Car("yellow", "Beetle", "1969") print(f"It was built in {my_car.year}") Out： It was built in 1969 ``` 这里Car类中的杯托 \_cupholders就是“私有“属性，为什么我这里加上了引号，是因为Python只是名义上规定这种写法，但是在实际访问上没啥卵用，依然可以直接用.\_cupholders来访问： ```python my_car.year = 1966 print(f"It was built in {my_car.year}") print(f"It has {my_car._cupholders} cupholders.") Out: It was built in 1966 It has 6 cupholders. ``` 后来Python决定使用双下划线\_\_来替换单下划线，这样可以最大程度避免“意外访问“，然而还是没有卵用，再来展示一下新方案： ```python class Car: wheels = 0 def __init__(self, color, model, year): self.color = color self.model = model self.year = year self.__cupholders = 6 ``` 其实某种程度上，这回效果还是很明显的，如果我们还像刚才一样尝试调用my\_car.cupholders 会报错： ```python my_car = Car("yellow", "Beetle", "1969") print(f"It was built in {my_car.year}") print(f"It has {my_car.__cupholders} cupholders.") Out: It was built in 1969 --------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 1 my_car = Car("yellow", "Beetle", "1969") 2 print(f"It was built in {my_car.year}") ----> 3 print(f"It has {my_car.__cupholders} cupholders.") AttributeError: 'Car' object has no attribute '__cupholders' ``` 这个错误很有意思，为什么会说cupholders这个变量不存在呢 ? 因为当Python看到\_\_ 时，会自动在cupholders前面补上一个下划线\_和所属类名，也就是说，这里我们尝试用my\_car.\_\_cupholders 来调用时，Python默认的正确写法是 my\_car.\_Car\_\_cupholders，现在再试一下： ``` print(f"It has {my_car._Car__cupholders} cupholders") Out: It has 6 cupholders ``` 依然没拦住。。。。 不过我个人认为这种规定公有私有变量的方式也是好处多多，这里就仁者见仁，智者见智了\~ ## Manage access 就像刚刚提到的，Python所有的东西都是公有的，我们可以随意的新增，修改，甚至删除变量： ```python my_car = Car("yellow", "beetle", 1969) print(f"My car was built in {my_car.year}") my_car.year = 2003 print(f"It was built in {my_car.year}") del my_car.year print(f"It was built in {my_car.year}") Out： My car was built in 1969 It was built in 2003 --------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 6 7 del my_car.year ----> 8 print(f"It was built in {my_car.year}") AttributeError: 'Car' object has no attribute 'year' ``` 那我们如何才能控制属性的访问权限呢？Python给出的答案是装饰器 @property，这个类似于Java中的setter和getter，现在我们试试： ```python class Car: def __init__(self, color, model, year): self.color = color self.model = model self.year = year self._voltage = 12 @property def voltage(self): return self._voltage @voltage.setter def voltage(self, volts): print("Warning: this can cause problems!") self._voltage = volts @voltage.deleter def voltage(self): print("Warning: the radio will stop working!") del self._voltage ``` 我们新增了voltage（电压）这个属性，并用property来控制外部的访问权限，这里我们定义了三个方法，利用setter方法可以改变voltage的值，利用getter方法来访问，利用deleter方法实现删除，接下来让我们新建实例来看看propert是如何工作的： ```python my_car = Car("yellow", "beetle", 1969) print(f"My car uses {my_car.voltage} volts") my_car.voltage = 6 print(f"My car now uses {my_car.voltage} volts") del my_car.voltage Out: My car uses 12 volts Warning: this can cause problems! My car now uses 6 volts Warning: the radio will stop working! ``` 可以发现，我们这里直接使用.voltage 而不是.\_voltage，这样就告诉python去使用property装饰的方法，我们可以通过使用@.setter and @.deleter 使属性变为read-only（只读），从而保护voltage不会被随意修改和删除 ### \_\_slots\_\_ ```python class Celebrity: # 限定 Celebrity对象只能绑定name, age,domain属性,加速 __slots__ = ['name','age',"domain"] # Class Attribute species = 'human' # Initializer / Instance Attributes def __init__(self, name, age, domain): self.name = name self.age = age self.domain = domain ``` 这里注意我们用slots绑定了三个属性给Celebrity，这就是slots的作用： * 如果我们需要限定自定义类型的对象只能绑定某些属性，可以通过在类中定义\_\_slots\_\_变量来进行限定。需要注意的是\_\_slots\_\_的限定只对当前类的对象生效，对子类并不起任何作用。 * 加速 现在可以做个实验，首先我们把slots绑定的domian属性去掉： ```python class Celebrity: # Class Attribute species = 'human' __slots__ = ['name', 'age'] # Initializer / Instance Attributes def __init__(self, name, age,domain): self.name = name self.age = age self.domain = domain female_leader = Celebrity("Miss Dong",65,"electrical appliance") # Access the instance attributes print("{} is {}.".format( female_leader.name, female_leader.age)) Out:AttributeError: 'Celebrity' object has no attribute 'domain' ``` 会发现报错了，即便我们在init方法中有domain属性，但是由于slots中没有，所以Celebrity类下创建的对象都不能有domain,接下来让我们简单回顾一下如何调用类变量： ```python female_leader = Celebrity("Miss Dong", 65,"electrical appliance") male_leader = Celebrity("Jack Ma", 55,"internet") # Access the instance attributes print("{} is {} and {} is {}.".format( female_leader.name, female_leader.age, male_leader.name, male_leader.age)) # Is male_leader a human? if male_leader.species == "human": print("{0} is a {1}!".format(male_leader.name, male_leader.species)) Out: Miss Dong is 65 and Jack Ma is 55. Jack Ma is a human! ``` ### \*args 其实*args应该和*kargs一起来说，但是今天先重点看一下它在对象中的应用，我们现在给Celebrity类新建3个对象，并且我们想知道年龄最大的是谁 ？ 这种情况下\*args很好用： ```python a = Celebrity("Miss Dong",65,"electrical appliance") b = Celebrity("Jack Ma", 55,"internet") c = Celebrity("Lei Jun", 50,"mobile") def get_oldest(*args): return max(args) print("The big brother is {} years old.".format(get_oldest(a.age, b.age, c.age))) Out: The big brother is 65 years old. ``` ### Inheritance 首先，我们在Celebrity类中新增两个方法: * description:对生成的大佬简单描述 * speak: 大佬发言 完成后的结果如下： ```python class Celebrity: __slots__ = ['name', 'age',"domain"] species = 'human' def __init__(self, name, age, domain): self.name = name self.age = age self.domain = domain # instance method def description(self): return "{} is {} years old, working in the {} industry".format(self.name, self.age,self.domain) # instance method def speak(self, sound): return "{} says {}".format(self.name, sound) ``` 现在新建两个类InternetBoss，MobileBoss，全部继承于 Celebrity类： ```python # Child class (inherits from Dog() class) class InternetBoss(Celebrity): pass # Child class (inherits from Dog() class) class MobileBoss(Celebrity): pass ``` 如果我们什么都不做，会自动继承父类的 description和speak方法，我们做个实验，新建li作为InternetBoss的对象： ```python li = InternetBoss("Robbin",50,"advertisement") ``` 调用description和speak方法： ```python li.description() li.speak("What's your problem ?") Out: Robbin is 50 years old, working in the advertisement industry Robbin says: What's your problem ? lei = MobileBoss("leijun", 50,"mobile") lei.speak("Are you ok ?") Out: leijun says: Are you ok ? ``` ### Polymorphisn & Override ```python class InternetBoss(Celebrity): def description(self): print("I'm Internet Boss !") class MobileBoss(Celebrity): def description(self): print("I'm Mobile phone Boss !") li = InternetBoss("Robbin",50,"advertisement") lei = MobileBoss("leijun", 50,"mobile") li.description() lei.description() Out: I'm Internet Boss ! I'm Mobile phone Boss ! ``` #### isinstance() & issubclass() Python 有两个判断继承的函数： * isinstance() 用于检查实例类型 * issubclass() 用于检查类继承 ```python class Celebrity: __slots__ = ['name', 'age',"domain"] species = 'human' def __init__(self, name, age, domain): self.name = name self.age = age self.domain = domain def description(self): print( "{} is {} years old, working in the {} industry".format(self.name, self.age,self.domain)) def speak(self, sound): print("{} says: {}".format(self.name, sound)) class InternetBoss(Celebrity): def description(self): print("I'm Internet Boss !") class MobileBoss(Celebrity): def description(self): print("I'm Mobile phone Boss !") mingzhu = Celebrity("Miss Dong",65,"electrical appliance") ma= InternetBoss("Pony", 48,"internet") lei = MobileBoss("leijun", 50,"mobile") # 现在使用issubclass（）判断InternetBoss和MobileBoss是否继承自Celebrity： issubclass(InternetBoss,Celebrity) # True issubclass(MobileBoss,Celebrity) # True #使用isinstance（）查看mingzhu到底是谁的实例： isinstance(mingzhu,Celebrity) # True isinstance(mingzhu,InternetBoss) # False isinstance(mingzhu,MobileBoss) # False #同理查看ma到底是哪个类的实例： isinstance(ma,Celebrity) # True isinstance(ma,InternetBoss) # True isinstance(ma,MobileBoss) # False ``` ### Sub class overwrite \_\_init\_\_ 刚才提到了，如果子类没有写构造函数init（），会自动继承父类的init，但我们通常需要子类有不同的初始函数，这样我们就需要自己复写一下，这里以InternetBoss为例： ```python class InternetBoss(Celebrity): def __init__(self,name, age, domain,hometown): super().__init__(name, age, domain) self.hometown = hometown def description(self): print("I'm Internet Boss !") def __repr__(self): return f"This is {self.name} speaking !" ``` ### Example ```python import random class BingoCage: __slots__ = ("_items") def __init__(self, items): self._items = list(items) random.shuffle(self._items) def pick(self): try: return self._items.pop() except IndexError: raise LookupError('pick from empty BingoCage') def __call__(self): return self.pick() bingo= BingoCage(range(20)) bingo() # 10 ```