封装
士兵开枪.py
lass Gun():
def __int__(self,model):
# 枪的型号
self.model = model
#子弹的数量
self.bullet_count = 0
def add_bullet(self,count):
self.bullet_count += count
def shoot(self):
# 1.判断子弹的数量
if self.bullet_count <=0:
print '%s 没有子弹' %self.model
return
# 2.发射子弹
self.bullet_count -= 1
# 3.提示发射信息
print '%s 凸凸图 %d' % (self.model,self.bullet_count)
class Soldier():
def __init__(self,name):
self.name = name
self.gun = None
def fire(self):
# 1.判断士兵有没有枪
if self.gun == None:
print '%s 还没有枪..' %self.name
return
# 2.高叫口号
print 'go!!! %s' %self.name
# 3.让枪装填子弹
self.gun.add_bullet(50)
# 4.让枪发射子弹
self.gun.shoot()
# 1.创建枪的对象
ak47 = Gun('AK47')
ak47.add_buller(50)
ak47.shoot()
#2. 创建士兵
nan = Soldier('nan')
nan.gun = ak47
nan.fire()
print nan.gun
__str__.py
class Pot():
def __init__(self,name):
self.name = name
def __str__(self):
return '我 %s' % self.name
rib = Pot('rib')
print rib
家具
class Home:
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return '%s 地方 %.2f' %(self.name,self.area)
# 1.建造家具
bed = Home('bed',10)
print bed
table = Home('table',40)
print table
class House():
def __init__(self,house_type,area):
self.house_type = house_type
self.area = area
#剩下面积
self.free_area = area
#家具名称列表
self.item_list = []
def __str__(self):
return '户型:%s\n总面积:%.2f[剩下:%.2f]\n家具:%s' % \
(self.house_type,self.area,self.free_area,self.item_list)
def add__item(self,item):
print '要添加 %s' % item
# 1.判断家具的面积
if item.area > self.free_area:
print '%s 的面积太大,无法添加' % item.name
# 如果不满足,下面的代码就不执行
return
# 2.将家具的名称添加到列表中
self.item_list.append(item.name)
# 3.计算剩下的面积
self.free_area -= item.area
my_home = House('两室一方',100)
my_home.add__item(bed)
my_home.add__item(table)
print my_home
封装.py
class Run():
def __init__(self,name,weight):
self.name = name
self.weight = weight
def __str__(self):
return '我的名字叫 %s 体重是 %2f' (self.name,self.weight)
def eat(self):
self.weight += 1
print '%s 爱跑步' % self.name
tom = Run('tom',75.0)
tom.eat()
print tom
多态
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print '%s 跑步' %self.name
class Xiaotianquan(Dog):
def game(self):
print '%s 飞到天上玩' % self.name
class Person(object):
def __init__(self,name):
self.name = name
def game_with_dog(self,dog):
print '%s 和 %s 快乐的玩' % (self.name,dog)
dog.game()
# 1.建造一个狗对象
wangcai = Dog('王才')
# 2.建造一个人对象
xiaoming = Person('小明')
# 让小帝和狗玩
xiaoming.game_with_dog(wangcai)
私有属性和私有方法
01 py
class Men():
def __init__(self,name):
self.name = name
self._age = 18
def secret(self):
print '%s 的年龄是 %d' % (self.name,self._age)
nan = man('nan')
print nan.age
nan.secret()
02.py
class A(object):
def __init__(self):
# 在初始化方法中定义了两个属性,一个共有属性,一个私有属性
self.nm1 = 100
self._num2 = 200
# 定义私有方法
def _test(self):
print '私有方法 %d $d' (self.nm1,self._num2)
def test(self):
print '%d' % self._num2
self._test()
class B(A):
def demo(self):
#在子类的方法中,不能调用父类的私有属性
print '访问父类的私有属性 %d' % self._num2
#在子类的方法中,不能调用父类的私有方法
self._test()
pass
# 建造了一个子类对象
b = B()
print b
print b._num2
b._test
类的属性
类属性-类方法
综合应用.py
类属class Game(object):
score_count = 0
def show_score_count(cls):
score.count += 1
def __init__(self,name):
self.name = name
# 让类属性的值+1
@classmethod
def show_help():
print '!!!!!'
@classmethod
def show_top_score(cls):
print '历史记录 %d' % cls.top_score
def star_game(self):
print
"""
案例小结:
1.案例方法:方法内部需要访问实例属性
2.类方法:方法内部只需要访问类属性
3.静态方法:方法内部不需要访问实例属性和类属性
又需要访问类属性
提问:如果方法内部,要访问实例属性,应该定义实例方法
应该定义实例方法
因为,类只有一个,在实例方法的内部可以使用
"""
综合应用2.py
class Game(object):
@classmethod
def __init__(self,name):
self.name = name
# 让类属性的值+1
def show_help(self,show_help):
print ''
02.py
class Toy(object):
count= 0
@classmethod
def show_toy_count(cls):
#cls.coun:在类方法的内部,访问当前的类属性
print '玩具对象的数量 %d' % cls.count
def _init_(self,name):
self.name = name
Toy.count +=1
#创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('玩具车')
toy3 = Toy('玩具熊')
#调用类方法
Toy.show_toy_count()
# 在方法的内部,可以直接访问类属性
对数
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print '%s 跑步' %self.name
mao = Dog('nn')
mao.game()
类的属性.py
class Tool(object):
count =0
def __init__(self,name):
self.name = name
# 让类属性的值+1
Tool.count +=1
# 建造工具对象(对象在创建的时候,会自动调用初始化方法
tool1 = Tool('斧头')
tool2 = Tool('手套')
tool3 = Tool('阶梯')
# 输出工具对象的总数
# 是由类名,属性名 来获取
print Tool.count
类的属性03.py
#语法:
class Cat(object):
@staticmethod
#静态方法不需要传递第一个参数:self
def call():
print '小猫渺渺叫'
Cat.call()
继承
class Bird():
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print 'Aaaaaaa....'
self.hungry = False
else:
print 'no Thanks!'
class SongBird(Bird):
def __init__(self):
self.sound = 'Squawk!'
Bird.__init__(self)
def sing(self):
print self.sound
#bird = Bird()
#bird.eat()
littlebird = SongBird()
littlebird.eat()
littlebird.sing()
继承-01.py
class Humen():
def game(self):
print '打游戏'
def drink(self):
print '喝水'
def sleep(self):
print '睡觉'
def run(self):
print '跑步'
class Singer(Humen):
def sing(self):
print 'rib唱歌'
def sleep(self):
print '不睡觉'
class Rin(Singer):
def sing(self):
print 'rin唱歌'
rib = Singer()
rib.sleep()
ji = Rin()
ji.sing()
继承-03.py
class A():
def demo (self):
print 'A-----demo方法'
def test (self):
print 'A-----test方法'
class B():
def demo(self):
print 'B-------demo方法'
def test(self):
print 'B-------demo方法'
class C(A,B):
pass
c=C()
c.test()
面向对型4.py
class Dog():
def __int__(self,new_name):
self.name = new_name
def eat(self):
print '%/s 爱睡觉' % self.name
tom = Dog('tom')
print tom.name
tom.eat()
面向对象1.py
#小猫爱吃鱼,小猫要喝水
class Cat():
def run(self):
print '小猫走路'
def drink(self):
print '小猫喝水'
面向对象3.py
class Cat():
def run(self):
print '% love fish' %self.name
def drink(self):
print '% love drink' %self.name
#建造狗对象
#lazy_cat = Cat()
#lazy_cat.eat()
#lazy_cat.drik()
#print lazy_cat
#lazy_cat2 = lazy_cat
#print lazy_cat2
tom = Cat()
tom.run()
tom.name = 'tom'
tom.drink()
print tom
设计模式
class student(object):
count = 0
def __init__(self):
student.count += 1
@staticmethod
def count_num():
print '现在%s名学生' % student.count
j = student()
d = student()
f = student()
student.count_num()
class Student(object):
count = 0
def __init__(self,name):
self.name = name
Student.count += 1
Studnet1 = Student ('学生1')
Studnet1 = Student ('学生2')
Studnet1 = Student ('学生3')
print Student.count
class Parent(object):
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
class People(object):
__name = "luffy"
__age = 18
p1 = People()
print(p1.__name, p1.__age)
class MusicPlayer(object):
isinstance = None
def __new__(cls, *args, **kwargs):
# 第一个参数 cls:哪一个类调用,就传递哪一个类
# 第二个参数 *args:多值参数
# 第三个参数 **kwargs: 多值的字典参数
# 创建对象的时候,new 方法会自动调用
# 重写了父类的方法
if cls.isinstance is None:
cls.isinstance = object.__new__(cls)
return cls.isinstance
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2