1.面向对象
类的设计：
1.类名 这类事物的名字，满足大驼峰命名法
2.属性 这类事物具有什么样的特征
3.方法 这类十五具有什么样的行为
class GoodFish():
def drink(self):
print '小鱼爱吃鱼'
def eat(self):
print '小鱼要喝水'
tonny = GoodFish()
tonny.drink()
tonny.eat()class GoodFish():
def __init__(self,Name):
self.name = Name
#在类中任何方法都可以使用self.name
print '%s爱吃鱼' %self.name
def drink(self):
print '%s要喝水'%self.name
tom = GoodFish('tom')
#使用类名创建对象的时候会自动调用__init__初始化方法
tom.drink()
内置方法
class Cat():
def __init__(self,name):
self.name = name
print '%s 来了'%self.name
def __del__(self):
print '%s 走了'%self.name
tom = Cat('tom')
#del tom
print '^' * 50
#__del__在内存中被销毁之前会执行该方法class Cat():
def __init__(self,name):
self.name = name
print '%s 来了'%self.name
def __str__(self):
return 'i am %s'%self.name
tom = Cat('tom')
print tom
#希望python能够输出对象变量而非内存地址，便可以使用__str__ 要注意的是必须返回一个字符串
面向对象的三大特性
封装：根据职责将属性和方法封装到一个抽象的类中，定义类的准则
class Furniture():
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return '%s 占地 %.2f'%(self.name,self.area)
bed = Furniture('bed',100)
print bed
table = Furniture('table',10)
print table
class House():
def __init__(self,house_type,area):
self.house_type = house_type
self.area = area
self.free_area = area
self.furniture = []
def add_furniture(self,furniture):
if furniture.area < self.free_area:
self.furniture.append(furniture.name)
self.free_area -= furniture.area
else:
print '%s 的面积太大 无法进行添加'%furniture.name
def __str__(self):
return '该房子的户型为%s,\n面积为%.2f,\n家具%s,\n剩余面积为%.2f'%(self.house_type,self.area,self.furniture,self.free_area)
home = House('两室一厅',200)
home.add_furniture(table)
desk = Furniture('desk',200)
home.add_furniture(desk)
home.add_furniture(bed)
print home继承：实现代码的重复使用，相同代码不需要重复编写，子类可以根据自己的所需进行重写
class Chicken():
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print 'Aaaa~~~~~~~~~~~'
self.hungry = False
else:
print 'no,thanks'
class SongChicken(Chicken):
def __init__(self):
self.song = 'Sqwrqes'
Chicken.__init__(self)
def Song(self):
print self.song
aaa = SongChicken()
aaa.eat()
aaa.Song()多继承
class A():
def test(self):
print 'test ++++++++ A'
def demo(self):
print 'demo ++++++++++A'
class B():
def test(self):
print 'test +++++B'
def demo(self):
print 'demo ________b'
class C(A,B):
#方法名相同时，哪个在前显示哪个
pass
C = C()
C.demo()
C.test()多肽：不同的子类，对象调用相同的方法产生不同的效果
# 不同的子类对象调用相同的方法产生不同的结果
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print '%s gou' %self.name
class BigDog(Dog):
def game(self):
print '%s run' %self.name
class Person(object):
def __init__(self,name):
self.name = name
def game(self,dog):
print '%s play with %s '%(self.name,dog.name)
dog.game()
c = Dog('wor')
q = Person('xiaoming')
q.game(c)
cc = BigDog('DENNY')
Q = Person('xiaoming')
Q.game(cc)
私有属性以及私有方法
class A(object):
def __init__(self):
self.num1 = 1
self.__num2 = 2
def __demo(self):
print '%d,%d'%(self.num1,self.__num2)
def aaa(self):
print self.__num2
self.__demo()
class B(A):
pass
c = B()
c.aaa()
classmethod（类方法）:方法内部只需要访问类属性
staticmethod（静态方法）：方法内部不需要访问类属性和实例属性
类方法
class Toy():
count = 0
@classmethod
def toy_number(cls):
print '玩具的数目为%d'%cls.count
def __init__(self,name):
self.name = name
Toy.count += 1
toy1 = Toy('的瓦')
toy2 = '大大'
toy3 = '大卫'
Toy.toy_number()
静态方法
静态方法
在开发时,如果需要在类的封装一个方法，这个方法：
即不需要访问实例属性或者调用实例方法
也不需要访问类属性或者调用类方法
"""
class Cat(object):
@staticmethod
#静态方法不需要传递第一个参数：self
def call():
print 'dada~'
Cat.call()设计模式：
class MusicPlayer(object):
instance = None
def __new__(cls, *args, **kwargs):
#第一个参数cls：哪一个调用，就传递哪一个类
#第二个参数#args：多值参数
#第三个参数**kwargs：多值的字典参数
#创建对象的时候，new方法会被自动调用
# 重写父类的方法
if cls.instance is None:
cls.instance = object.__new__(cls)
return cls.instance
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2