Python 学习（5）---类的相关知识整理

Python 是一门很灵活、很方便的语言。学起来很顺手，我们可以用它快捷的完成许多实际任务，下面是我学习python的过程中整理的基本知识点。

面向对象的编程是当今最主流的编程思想，类的三大特性：封装、继承、多态是面向对象编程的优势所在，下面是我整理的相关知识点。

# -*- coding:utf-8 -*-
__author__ = 'Microcosm'

print("关于self，它是定位实例化对象的量，类在实例化一个对象的时候，"
"self就会接收这个对象的地址，作为后续调用类属性和类方法的寻址标志")

print("--------------------封装---------------------")
# 将一类物体抽象成属性和方法的集合体
class Turtle:
def run(self):
print("我在努力的爬...")

def bite(self):
print("咬死你咬死你...")

def sleep(self):
print("睡觉了，晚安，Zzzzz")

turtle = Turtle()
turtle.run()
turtle.bite()
turtle.sleep()

print("================================================")

class Animal:
def __init__(self,name):
self.name = name
def eat(self):
print("%s 正在吃东西" % self.name)
def sleep(self):
print("%s 正在睡觉" % self.name)

a = Animal("小猫")
a.eat()
a.sleep()
b = Animal("小狗")
b.eat()
b.sleep()

print("=================================================")
class Dog:
name = '小泡泡'
age = 2
__legs = 4   # 以双下划线开头的属性或者方法是私有的
def printName(self):
print("我叫 %s" % self.name)
def printAge(self):
print("我今年 %d 岁" % self.age)
def getLegs(self):
return self.__legs

dog = Dog()
dog.printName()
dog.printAge()
dog.name = '狗蛋儿'  # 直接修改属性变量值
dog.printName()
# print dog.__legs   # 访问私有属性，会抛出AttriuteError的异常，但可以用下面这种方式解决
print dog._Dog__legs  # Python实际上只是给私有属性换名了，也就是说这是一种伪私有
print dog.getLegs()

print("--------------------继承---------------------")
import random as r
class Fish:
def __init__(self):
self.x = r.randint(0,10)
self.y = r.randint(0,10)
print("我的初始位置在（%d,%d)" % (self.x,self.y))
def move(self):
self.x += 1
self.y -= 1
print("向东北方向移动一步后，我现在在(%d,%d)" % (self.x, self.y))

class GoldFish(Fish):
pass

class Crop(Fish):
pass

class Salmon(Fish):
pass

class Shark(Fish):
def __init__(self):   # 这里其实改写了父类的方法，也就是覆盖了它，所以不会初始化位置，只有调用父类的方法才行
Fish.__init__(self)  # 方法一
# super().__init__()  # 方法二,更常用，对于多重继承，都会自动调用父类的构造函数,好像是Python3的语法
self.hungry = True
def eat(self):
if self.hungry:
print("我正在吃东西^_^")
self.hungry = False
else:
print("太撑了，我吃不下了！")

fish = Fish()
fish.move()
goldfish = GoldFish()
goldfish.move()
shark = Shark()
shark.move()
shark.eat()
shark.eat()
print("=================================================")
class A:
def foo(self):
print("我是小A")

class B:
def foo(self):
print("我是小B")
def foo2(self):
print("我是小小B")

class C(A,B):    # 多重继承
def foo2(self):
print("我是小C")

a = A()
a.foo()
b = B()
b.foo()
c = C()
c.foo()   # 同名的父类函数，按照继承的顺序调用
c.foo2()  # 子类的方法与父类同名时，会调动子类的方法

print("--------------------组合---------------------")
print("当几个对象之间的关系是横向而不是纵向时，则不适宜使用继承关系，应该使用组合关系")
class Fish:
def __init__(self,x):
self.x = x

class Turtle:
def __init__(self,x):
self.x = x

class Pool:
def __init__(self,x,y):     # 将其他类的对象作为该类的属性
self.turtle = Turtle(x)
self.fish = Fish(y)
print("水池里总共有 %d 只乌龟和 %d 条鱼" %(self.turtle.x, self.fish.x))

pool = Pool(1,10)

print("--------------------多态---------------------")
print("不同的类对象调用同一个函数方法，可以有各自不同的实现，这就叫做多态，"
"就像不同的动物有各自行走的方式一样")
class Turtle:
def run(self):
print("A turtle is running!")

class Dog:
def run(self):
print("A dog is running!")

class Cat:
def run(self):
print("A cat is running!")
t = Turtle()
t.run()
d = Dog()
d.run()
c = Cat()
c.run()

print("---------------------------类、类对象、实例对象------------------------------")
class C:
count = 0

a = C()
b = C()
print a.count   # 0
print b.count   # 0
c = C()
c.count += 10
print c.count   # 10
print a.count   # 0
C.count = 100      # 静态变量，直到程序退出才会清空
print a.count   # 100
print b.count   # 100
print c.count   # 10
del C      # 删除类
print a.count   # 100
#print C.count   # 抛出NameError的异常
print c.count   # 10

print("==========================================")
class A:
def x(self):
print("X-man")

a = A()
a.x()
a.x = 1  # 添加一个属性覆盖了类的方法
# a.x()  # 抛出TypeError的异常

print("============================================")
class BB:
def printBB(self):   # 这个版本的Python好像不能创建静态方法,例如： def printBB(): 就会报错
print("no zuo no die")

BB.printBB(BB())  # 这种方式也可以
BB().printBB()

print("=============================================")
class CC:
age = 1
def setXY(self,x,y):
self.x = x   # 实例属性，与实例对象绑定
self.y = y
def printXY(self):
print(self.x,self.y)

print CC.age       # 静态属性，可以用类名直接调用修改
dd = CC()
print dd.__dict__  # 查看实例对象的属性，发现dd是没有任何属性的
print CC.__dict__  # 查看类的属性
dd.setXY(4,5)
print dd.__dict__  # {'y': 5, 'x': 4} 这个属性只有dd这个实例对象有，这主要归功于类对象的绑定
print CC.__dict__
del CC  # 删除类对象
#ee = CC()   # 抛出NameError异常
dd.printXY() # 但是实例对象dd依然可以调用类的方法，
# 主要是因为类的属性和方法都是静态的，一直都在内存中，只有当程序退出时才会清空

print("=================与类相关的一些BIF===================")
# issubclass(class,classinfo) 判断class 是否是 classinfo 的子类
class A:
pass

class B(A):
pass

class C:
pass

print issubclass(B,A)
print issubclass(B,B)   # 通常一个类被认为是自己的子类
print issubclass(B,C)
print issubclass(B,object)  # 这个版本返回值是False
print issubclass(B,(A,C))   # True
print("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-")
# isinstance(object,classinfo) 判断object 是否是 classinfo 的实例
b1 = B()
print isinstance(b1,B)  # True
print isinstance(b1,A)  # True B是A的子烈
print isinstance(b1,C)  # False
print isinstance(b1,(A,B,C))  # 只有b1是后面类中某一个的实例就返回True

print("=======================================")
# hasattr(object,name)  判断实例对象有没有name属性
class C:
def __init__(self,x=0):
self.x = x

c = C()
print hasattr(c,'x')
#print hasattr(c,x) #是错误的

# getattr(object,name,default) 获取name属性的值，如果不存在，则打印default提示信息
print getattr(c,'x')
#print getattr(c,'y')  # 会抛出一个AttributeError的异常
print getattr(c,'y','你访问的属性不存在')  # 没有异常，输出提示信息，用户体验好

# setattr(object,name,value) 设置name属性，并给它赋值为value
setattr(c,'y','hello')
print getattr(c,'y','你访问的属性不存在')

# delattr(object,name) 删除name属性
delattr(c,'y')
print getattr(c,'y','你访问的属性不存在')
# delattr(c,'y')  # 已经被删除，会抛出AttributeError的异常

print("------------------property----------------------------")
# property(fget=None,fset=None,fdel=None,doc=None)
class D:
def __init__(self,size=10):
self.size = size
def getSize(self):
return self.size
def setSize(self,size):
self.size = size
def delSize(self):
del self.size
x = property(getSize,setSize,delSize)      # 好像不起作用，难道是版本的问题!!!!????

c = D()
print c.getSize()
print c.x   # 10
c.x = 18
print c.x
print c.getSize()  # 10
print c.size   # 10
c.setSize(19)
print c.getSize()
print c.size
print c.x  # 18

del c.x
print c.size
print c.x