一. 学习路线概述

学习地址：Python入门(下) - AI开发者体验中心​developer.aliyun.com

总学习路线：函数

Lambda 表达式

类与对象

魔法方法

本章学习第3小节。

二. 具体学习内容

类与对象

我们在之前的学习中已经知道，在Python中万物皆对象。而既然是对象，就会有对应的属性与方法。对象 = 属性 + 方法

这一小节我们主讲“类”，自然也免不了提到类的属性与方法。Python 与 C 不同，是面向对象的程序设计语言，对于第一次接触的人来讲是会比较困难的，还请耐心地看下去。

对象是类的实例。换句话说，类主要定义对象的结构，然后我们以类为模板创建对象。类不但包含方法定义，而且还包含所有实例共享的数据。

(可以这么理解：如果说“类”代表了整体人类共有的能力(包括方法、属性)，那么每一个个体的人就是“人类”这个“类”的实例。换言之，“类”是广义的，而‘实例’是狭义的)封装：信息隐蔽技术

我们可以使用关键字 class 定义 Python 类，关键字后面紧跟类的名称、分号和类的实现。

class Turtle: # Python中的类名约定以大写字母开头

"""关于类的一个简单例子"""

# 属性(注意，这里是类属性而非实例属性，区别稍后再谈)

color = 'green'

weight = 10

legs = 4

shell = True

mouth = '大嘴'

# 方法

def climb(self):

print('我正在很努力的向前爬...')

def run(self):

print('我正在飞快的向前跑...')

def bite(self):

print('咬死你咬死你!!')

def eat(self):

print('有得吃，真满足...')

def sleep(self):

print('困了，睡了，晚安，zzz')

tt = Turtle()

print(tt)

# <__main__.turtle object at>

print(type(tt))

#

print(tt.__class__)

#

print(tt.__class__.__name__)

# Turtle

tt.climb() # 使用类的方法

# 我正在很努力的向前爬...

tt.run()

# 我正在飞快的向前跑...

tt.bite()

# 咬死你咬死你!!

# Python类也是对象。它们是type的实例

print(type(Turtle))

#

类是可以继承的。试想一下游戏中的NPC，如果想把所有NPC归于一类来调用，这当然是可以的。但是由于NPC种类繁多，只用一个类的话共有属性、方法就会比较少，每个NPC需要添加的特有属性、方法就会非常多，这显然不是很方便。所以我们会另外设定子类，就像是在NPC的父类基础上(这个基础指继承父类方法与属性)另外作出细化，比如设定“野兽类NPC”、“人类NPC”、“可对话NPC”等等。继承：子类自动共享父类之间数据和方法的机制

套娃是大家喜闻乐见的事情，在类的继承中也依然有大家喜爱的套娃环节：继承父类的子类也可以有自己的“子类”(你可以叫它“孙类”呵呵~)这样就可以将类从基类不断细化，分类。(简直太方便了有木有啊，我作为主学 C 语言的人第一次学这个真的觉得开了眼界哈哈)

当然了，即便是可以不断细化类来达到我们的目的，但是每一个类对应一个实例未免还是太麻烦了。就像是有一个NPC有一个“必杀技”，你游只有它会这招，我们为了给这位NPC加上技能，难道又要给它继承一次。虽说不是不可以，但是说实话，这也太给它脸了，它配吗？

其实我们只需要在父类的基础上加上它特有的属性、方法就好了。即动态添加属性与方法：

# 动态添加属性

class Student(object):

def __init__(self, name, age):

self.name = name

self.age = age

pass

def __str__(self):

return '{}今年{}岁了'.format(self.name, self.age)

pass

zyh = Student('张艳华', 20)

zyh.weight = 80 # 动态添加(在有需求的时候，可以简单地动态添加)

print(zyh)

print(zyh.weight)

print('-------------------创建另外一个实例对象----------------------')

zm = Student('张明', 20)

zm.weight = 70

print(zm.weight)

# 张艳华今年20岁了

# 80

# -------------------创建另外一个实例对象----------------------

# 70

# 添加动态方法

import types # 添加方法的库

print('----------------动态添加实例方法------------------')

# 先定义要添加的方法

def dymicMethod(self):

print('{}的体重是{}kg，在{}读大学'.format(self.name, self.weight, self.school))

pass

zyh.printInfo = types.MethodType(dymicMethod, zyh) # 方法的绑定

zyh.printInfo() # 调用动态绑定的方法

# 绑定类方法和静态方法

print('---------------------类方法的绑定-----------------------')

@classmethod

def classTest(cls):

print('这是一个类方法')

pass

Student.xyz = classTest

Student.xyz()

# 静态方法的绑定

print('---------------静态方法------------------')

@staticmethod

def Test():

print('静态方法绑定--------Test')

pass

Student.lsh = Test

Student.lsh()

多态：不同对象对同一方法响应不同的行动多态：顾名思义就是多种状态、形态，就是同一种行为 对于不同的子类【对象】有不同的行为表现

要想实现多态 必须的有两个前提需要遵守：

1、继承：多态必须发生在父类和子类之间

2、重写: 子类重写父类的方法

多态有什么用:

增加程序的灵活性

增加程序的拓展性

# 多态实例：

class Animal:

def run(self):

raise AttributeError('子类必须实现这个方法')

class People(Animal):

def run(self):

print('人正在走')

class Pig(Animal):

def run(self):

print('pig is walking')

class Dog(Animal):

def run(self):

print('dog is running')

def func(animal):

animal.run()

func(Pig())

# pig is walking

self 是什么？

Python 的 self 相当于 C++ 的 this 指针。

class Test:

def prt(self):

print(self)

print(self.__class__)

t = Test()

t.prt()

# <__main__.test object at>

#

类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称(对应于该实例，即该对象本身)，按照惯例它的名称是self。在调用方法时，我们无需明确提供与参数self相对应的参数。

Python 的魔法方法

据说，Python 的对象天生拥有一些神奇的方法，它们是面向对象的 Python 的一切...

它们是可以给你的类增加魔力的特殊方法...

如果你的对象实现了这些方法中的某一个，那么这个方法就会在特殊的情况下被 Python 所调用，而这一切都是自动发生的...

类有一个名为__init__(self[, param1, param2...])的魔法方法，该方法在类实例化时会自动调用。

# 魔法方法__init__

class Ball:

def __init__(self, name):

self.name = name

def kick(self):

print("我叫%s,该死的，谁踢我..." % self.name)

a = Ball("球A")

b = Ball("球B")

c = Ball("球C")

a.kick()

# 我叫球A,该死的，谁踢我...

b.kick()

# 我叫球B,该死的，谁踢我...

类有很多非常实用的魔法方法，记住几个比较实用的，一定能事半功倍。

公有和私有

在 Python 中定义私有变量只需要在变量名或函数名前加上“__”两个下划线，那么这个函数或变量就会为私有的了。

class JustCounter:

__secretCount = 0 # 私有变量

publicCount = 0 # 公开变量

def count(self):

self.__secretCount += 1

self.publicCount += 1

print(self.__secretCount)

counter = JustCounter()

counter.count() # 1

counter.count() # 2

print(counter.publicCount) # 2

# Python的私有为伪私有

print(counter._JustCounter__secretCount) # 2

print(counter.__secretCount)

# AttributeError: 'JustCounter' object has no attribute '__secretCount'

组合

class Turtle:

def __init__(self, x):

self.num = x

class Fish:

def __init__(self, x):

self.num = x

class Pool:

def __init__(self, x, y):

self.turtle = Turtle(x)

self.fish = Fish(y)

def print_num(self):

print("水池里面有乌龟%s只，小鱼%s条" % (self.turtle.num, self.fish.num))

p = Pool(2, 3)

p.print_num()

# 水池里面有乌龟2只，小鱼3条

类、类对象和实例对象

类对象：创建一个类，其实也是一个对象也在内存开辟了一块空间，称为类对象，类对象只有一个。class A(object):

pass实例对象：就是通过实例化类创建的对象，称为实例对象，实例对象可以有多个。

类属性：类里面方法外面定义的变量称为类属性。类属性所属于类对象并且多个实例对象之间共享同一个类属性，说白了就是类属性所有的通过该类实例化的对象都能共享。

实例属性：实例属性和具体的某个实例对象有关系，并且一个实例对象和另外一个实例对象是不共享属性的，说白了实例属性只能在自己的对象里面使用，其他的对象不能直接使用，因为self是谁调用，它的值就属于该对象。

注意：属性与方法名相同，属性会覆盖方法。

什么是绑定？

Python 严格要求方法需要有实例才能被调用，这种限制其实就是 Python 所谓的绑定概念。

Python 对象的数据属性通常存储在名为.__ dict__的字典中，我们可以直接访问__dict__，或利用 Python 的内置函数vars()获取.__ dict__。

class CC:

def setXY(self, x, y):

self.x = x

self.y = y

def printXY(self):

print(self.x, self.y)

dd = CC()

print(dd.__dict__)

# {}

print(vars(dd))

# {}

print(CC.__dict__)

# {'__module__': '__main__', 'setXY': , 'printXY': , '__dict__': , '__weakref__': , '__doc__': None}

dd.setXY(4, 5)

print(dd.__dict__)

# {'x': 4, 'y': 5}

print(vars(CC))

# {'__module__': '__main__', 'setXY': , 'printXY': , '__dict__': , '__weakref__': , '__doc__': None}

print(CC.__dict__)

# {'__module__': '__main__', 'setXY': , 'printXY': , '__dict__': , '__weakref__': , '__doc__': None}

一些相关的内置函数(BIF)issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

一个类被认为是其自身的子类。

classinfo可以是类对象的元组，只要class是其中任何一个候选类的子类，则返回True。

isinstance(object, classinfo) 方法用于判断一个对象是否是一个已知的类型，类似type()。

type()不会认为子类是一种父类类型，不考虑继承关系。

isinstance()会认为子类是一种父类类型，考虑继承关系。

如果第一个参数不是对象，则永远返回False。

如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常。

hasattr(object, name)用于判断对象是否包含对应的属性。

getattr(object, name[, default])用于返回一个对象属性值。

setattr(object, name, value)对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

delattr(object, name)用于删除属性。

class property([fget[, fset[, fdel[, doc]]]])用于在新式类中返回属性值。fget -- 获取属性值的函数

fset -- 设置属性值的函数

fdel -- 删除属性值函数

doc -- 属性描述信息