python——面向对象

面向对象

类的设计:
在程序开发中,要设计一个类,通常需要以下三个要求:
1.类名 这类事物的名字,满足大驼峰命名法
2.属性 这类事物具体有什么样的特征
3.方法 这类事物具有什么样的行为

需求1:
小明今年18岁,身高1.75,每天早上要跑步,会去吃东西
小美今年17岁,身高163,小妹不跑步,小妹喜欢吃东西

Person()
name
age
height
run()
eat()

需求2:
一只黄颜色的狗叫大黄
看见生人汪汪叫
看见家人摇尾巴

Dog()
name
color
shout()
shake()

面向对象的基础语法:
定义简单的类:
定义只包含方法的类:
class 类名:
def 方法1(self,参数列表):
pass
def 方法2(self,参数列表):
pass
当一个类定义完成之后,要使用这个类来创建对象,语法格式如下:
对象变量 = 类名()

面向对象——01.py

# _*_ coding:utf-8 _*_
"""
file:面向对象——01.py
date:2018-07-23 6:40 PM
author:wwy
desc:

需求
    小猫爱吃鱼,小猫要喝水

"""


class Cat():
    def eat(self):
        print '小猫爱吃鱼'
    def drink(self):
        print '小猫要喝水'

# 创建猫对象
tom = Cat()
tom.eat()
tom.drink()

运行结果:
这里写图片描述
面向对象——02.py

# _*_ coding:utf-8 _*_
"""
file:面向对象——02.py
date:2018-07-23 6:40 PM
author:wwy
desc:

"""


class Cat():
    def eat(self):
        print '小猫爱吃鱼'
    def drink(self):
        print '小猫要喝水'

# 创建猫对象
tom = Cat()
tom.eat()
tom.drink()
print tom

运行结果:
这里写图片描述
为什么print tom会显示一段数字?
测试:

# 创建猫对象
tom = Cat()
tom.eat()
tom.drink()
print tom
addr = id(tom)
print '%x' % addr
print '%d' % addr

运行结果:
这里写图片描述
%x:16进制
%d:10进制
在python中,使用python输出对象变量
默认情况下,会输出这个变量引用的对象是由哪一个类创建的对象
以及在内存中的地址(十六进制表示)

面向对象——03.py

# _*_ coding:utf-8 _*_
"""
file:面向对象——03.py
date:2018-07-23 6:40 PM
author:wwy
desc:

"""


class Cat():
    def eat(self):
        print '小猫爱吃鱼'
        print '%s love fish' % self.name
    def drink(self):
        print '小猫要喝水'

# 创建猫对象
tom = Cat()
#tom.name = 'tom'
tom.eat()
tom.drink()
tom.name = 'tom'
print tom

运行结果:
这里写图片描述
系统报错,必须在调用前声明变量对象

# _*_ coding:utf-8 _*_
"""
file:面向对象——03.py
date:2018-07-23 6:40 PM
author:wwy
desc:

"""


class Cat():
    def eat(self):
        print '小猫爱吃鱼'
        print '%s love fish' % self.name
    def drink(self):
        print '小猫要喝水'

# 创建猫对象
tom = Cat()
tom.name = 'tom'
tom.eat()
tom.drink()
#tom.name = 'tom'
print tom


# 再创建一个猫对象
lazy_cat = Cat()
lazy_cat.name = 'miaomiao'
lazy_cat.eat()
lazy_cat.drink()
print lazy_cat

运行结果:
这里写图片描述
两个对象类名相同,地址不同

# 再创建一个猫对象
lazy_cat = Cat()
lazy_cat.name = 'miaomiao'
lazy_cat.eat()
lazy_cat.drink()
print lazy_cat

lazy_cat2 = lazy_cat
print lazy_cat2

运行结果:
这里写图片描述
lazy_cat1 与 lazy_cat2所属类名和地址完全相同

初始化方法
我们现在已经知道了使用 类名() 就可以创建一个对象
当使用类名()创建对象时,python的解释器会自动执行以下操作:
1.为对象在内存中分配空间——创建对象
2.调用初始化方法为对象的属性设置初始值——初始化方法(init)
这个初始化方法就是init方法,init是对象的内置方法
专门用来定义一个类具有哪些属性的方法

面向对象——04.py

# _*_ coding:utf-8 _*_
"""
file:面向对象——04.py
date:2018-07-23 6:41 PM
author:wwy
desc:

"""


class Cat():
    def __init__(self):
        print '这是一个初始化方法'
        #self.属性名 = 属性的初始值
        self.name  = 'Tom'

# 使用 类名() 创建对象的时候,会自动调用初始化方法__init__
tom = Cat()
print tom.name

运行结果:
这里写图片描述

# _*_ coding:utf-8 _*_
"""
file:面向对象——05.py
date:2018-07-23 6:41 PM
author:wwy
desc:

"""


class Cat():
    def __init__(self,new_name):
        #self.name = 'Tom'
        self.name = new_name
        #在类中,任何方法都可以使用self.name
    def eat(self):
        print '%s 爱吃鱼' % self.name

tom = Cat('tom')
print tom.name
tom.eat()

lazy_cat = Cat('lazy_cat')
lazy_cat.eat()

运行结果:
这里写图片描述

内置方法

__del_.py

# _*_ coding:utf-8 _*_
"""
file:__del__.py
date:2018-07-23 10:04 PM
author:wwy
desc:


__del__方法:
在python中
当使用类名()创建对象时,为对象分配完空间后,自动调用__init__方法
当一个对象被从内存中销毁前,会自动调用__del__方法

"""


class Cat():
    def __init__(self,new_name):
        self.name = new_name
        print '%s 来了' % self.name
    def __del__(self):
        print '%s 走了'% self.name

tom = Cat('tom')
print tom.name
print '_' * 50

运行结果:
这里写图片描述
更改:

tom = Cat('tom')
print tom.name
del tom

print '_' * 50

运行结果:
这里写图片描述
__str_.py

# _*_ coding:utf-8 _*_
"""
file:__str__.py
date:2018-07-23 10:19 PM
author:wwy
desc:

在python中,使用python输出对象变量
默认情况下,会输出这个变量引用的对象是由哪一个类创建的对象
以及在内存中的地址(十六进制表示)

如果在开发中,希望使用print输出对象变量时,
能够打印自定义的内容,就可以利用__str__这个内置方法了

"""


class Cat():
    def __init__(self,name):
        self.name = name

tom = Cat('tom')
print tom

运行结果:
这里写图片描述

class Cat():
    def __init__(self,name):
        self.name = name
    def __str__(self):
        # 必须返回一个字符串
        return '我是 %s' % self.name

tom = Cat('tom')
print tom

运行结果:
这里写图片描述

面向对象三大特征
1.封装:根据职责将属性和方法封装到一个抽象的类中
2.继承:实现代码的重用,相同的代码不需要重复的写
3.多态:不同的对象调用相同的方法,产生不同的结果
增加代码的灵活度

封装

封装
1.封装是面向对象编程的一大特点
2.面向对象变成编程的第一步,将属性和方法封装到一个抽象的类中
3.外界使用类创建对象,然后让对象调用方法
4.对象方法的细节都被封装在类的内部

封装——01.py

# _*_ coding:utf-8 _*_
"""
file:封装——01.py
date:2018-07-23 11:57 PM
author:wwy
desc:

xx爱跑步
1.xx体重75.0公斤
2.xx每次跑步会减肥0.5公斤
3.xx每次吃东西体重会增加1公斤

"""


class People():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def run(self):
#在对象的方法内部,可以直接访问对象的属性
        self.weight -= 0.5
    def eat(self):
        self.weight += 1
    def __str__(self):
        return '%s 的体重是%.2f' %(self.name,self.weight)

lily = People('lily',44.0)
lily.run()
lily.eat()
print lily


# 2.coco也和他一样
coco = People('coco',50.3)
#coco.run()
coco.eat()
print coco

运行结果:
这里写图片描述
摆放家具——01.py

# _*_ coding:utf-8 _*_
"""
file:摆放家具——01.py
date:2018-07-24 12:01 AM
author:wwy
desc:

需求:
1.房子有户型,总面积和家具名称列表
    新房子没有任何家具
2.家具有名字和占地面积,其中
    床:4.6平米
    衣柜:2平米
    餐桌:3平米
3.将以上三件家具添加到房子中
4.打印房子时,要求输出:户型,面积,剩余面积,家具名称列表

"""


class HouseItem():
    # 初始化方法
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return '%s的面积为%.2f' %(self.name,self.area)

# 创建家具
bed = HouseItem('bed',4.6)
print bed
chest = HouseItem('chest',2.0)
print chest
table = HouseItem('table',3.0)
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\n剩余面积:%.2f\n家具:%s'%\
               (self.house_type,self.area,self.free_area,self.item_list)
    def add_item(self, item):
        print '要添加 %s' % item

# 创建房子对象
my_home = House('两室一厅',100)

# 添加家具
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home

运行结果:
这里写图片描述
摆放家具——02.py

# _*_ coding:utf-8 _*_
"""
file:摆放家具——02.py
date:2018-07-24 12:04 AM
author:wwy
desc:

"""


class HouseItem():
    # 初始化方法
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return '%s的面积为%.2f' %(self.name,self.area)
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\n剩余面积:%.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

# 1.创建家具
bed = HouseItem('bed',4.6)
print bed
chest = HouseItem('chest',200)
print chest
table = HouseItem('table',3.0)
print table

# 创建房子对象
my_home = House('两室一厅',100)

# 添加家具
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home

运行结果:
这里写图片描述
士兵开枪.py

# _*_ coding:utf-8 _*_
"""
file:士兵开枪.py
date:2018-07-24 12:07 AM
author:wwy
desc:

"""


class Gun():
    def __init__(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 biubiubiu ~ %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()

# 创建枪对象
ak47 = Gun('AK47')

# 创建士兵
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
print ryan.gun

运行结果:
这里写图片描述

私有属性和私有方法

> 私有属性和私有方法
应用场景及定义方法
应用场景:
在实际开发中,对象的某些属性或方法可能只希望在对象的内部使用
而不希望在外部被访问到
私有属性 就是 对象不希望公开的属性
私有方法 就是 对象不希望公开的方法
定义方法:
在定义属性或方法时,在属性名或者方法名前增加两个下划线就是私有属性或方法

私有属性和私有方法——01.py

# _*_ coding:utf-8 _*_
"""
file:私有属性和私有方法——01.py
date:2018-07-24 12:14 AM
author:wwy
desc:

"""
class Women():
    def __init__(self,name):
        self.name = name
        self.__age = 18              #私有属性
    def secret(self):                #私有方法
        print '%s 的年龄是 %d'  % (self.name,self.__age)

lily = Women('lily')
print lily
lily.secret()

运行结果:
这里写图片描述

class Women():
    def __init__(self,name):
        self.name = name
        self.__age = 18              #私有属性
    def __secret(self):              #私有方法
        print '%s 的年龄是 %d'  % (self.name,self.__age)

lily = Women('lily')
print lily
lily.__secret()

运行结果:
这里写图片描述
如果是私有方法将无法调用

继承

继承——01.py

# _*_ coding:utf-8 _*_
"""
file:继承——01.py
date:2018-07-24 12:21 AM
author:wwy
desc:

单继承
1.继承的概念  语法和特点
继承的概念:子类拥有父类的所有方法和属性(子类只需封装自己特有的属性)
2.继承的语法
class 类名(父亲)
    def 子类特有的方法

"""


class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat():
    # 子类拥有父类的所有属性和方法
    def eat(self):
         print '吃'
    def drink(self):
         print '喝'
    def run(self):
         print '跑'
    def sleep(self):
         print '睡'
    def call(self):
        print '喵呜~'

fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.call()

运行结果:
这里写图片描述
继承——02.py

# _*_ coding:utf-8 _*_
"""
file:继承——02.py
date:2018-07-24 12:21 AM
author:wwy
desc:

"""


class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    def call(self):
        print '喵呜~'

fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.call()


# 子类继承自父类,可以直接享受父类中已经封装好的方法
# 子类中应该根据自己的职责,封装子类特有的属性和方法

运行结果:
这里写图片描述
继承——03.py

# _*_ coding:utf-8 _*_
"""
file:继承——03.py
date:2018-07-24 12:21 AM
author:wwy
desc:

继承的传递性:(爷爷 父亲 儿子)
1.C类从B类继承,B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父亲以及父类的父类中封装的所有属性和方法

"""


class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    def call(self):
        print '喵呜~'

class HelloKitty(Cat):
    def speak(self):
        print '我可以说日语'

# 创建一个HelloKitty对象
kt = HelloKitty()

kt.speak()
kt.eat()
kt.drink()
kt.run()
kt.sleep()
kt.call()

运行结果:
这里写图片描述
继承——04.py

# _*_ coding:utf-8 _*_
"""
file:继承——04.py
date:2018-07-24 12:22 AM
author:wwy
desc:

"""

class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    def call(self):
        print '喵呜~'

class HelloKitty(Cat):
    def speak(self):
        print '我可以说日语'

class Dog(Animal):
    def bark(self):
        print '旺旺~'

# 创建一个HelloKitty对象
kt = HelloKitty()

#继承的传递性,子类拥有父类和父类的父类的属性和方法
kt.speak()
kt.eat()
kt.drink()
kt.run()
kt.sleep()
kt.call()

dog =Dog()
dog.sleep()
dog.bark()

运行结果:
这里写图片描述
继承——05.py

# _*_ coding:utf-8 _*_
"""
file:继承——05.py
date:2018-07-24 12:22 AM
author:wwy
desc:

重写父类方法有两种情况:
1.覆盖父类的方法
2.对父类方法进行扩展

1.覆盖父类的方法
如果在开发中,父类的方法的实现和子类方法的实现完全不同
就可以使用覆盖的方法,在子类中重新编写父类的方法

具体实现方式,就相当于在子类中定义了
一个和父类同名的方法并且实现
重写之后,在运行时,只会调用子类的重写方法
而不会调用父类封装的方法

"""



class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    def call(self):
        print '喵呜~'

class HelloKitty(Cat):
    def speak(self):
        print '我可以说日语'
    def call(self):
        print 'ouhayaogaozayimasi'

kt = HelloKitty()
kt.speak()
kt.call()

运行结果:
这里写图片描述
继承——06.py

# _*_ coding:utf-8 _*_
"""
file:继承——06.py
date:2018-07-24 12:22 AM
author:wwy
desc:

对父类的方法进行扩展
如果在开发中,子类的方法实现包含有父类的方法实现
(父类原本封装的方法实现时子类方法的一部分
就可以使用扩展的方法)
1.在子类中重写父类的方法
2.在需要的位置使用 父类名.方法(self) 来调用父类方法的执行
(使用父类名称调用父类方法)
3.代码其他位置针对子类的需求,编写子类特有的代码实现

"""


class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    def call(self):
        print '喵呜~'

class HelloKitty(Cat):
    def speak(self):
        print '我可以说日语'
    def call(self):
        print 'ouhayaogaozayimasi'
        # 调用本来在父类中封装的方法
        Cat.call(self)
        print '@#$#$%$&^^*&'
kt = HelloKitty()
kt.speak()
kt.call()

运行结果:
这里写图片描述
继承——07.py

# _*_ coding:utf-8 _*_
"""
file:继承——07.py
date:2018-07-24 12:22 AM
author:wwy
desc:

"""

class Bird():
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print 'aaaaaaaaaa'
            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()

运行结果:
这里写图片描述


# bird = Bird()
# bird.eat()

littlebird = SongBird()
littlebird.eat()
littlebird.sing()

运行结果:
这里写图片描述
继承——08.py

# _*_ coding:utf-8 _*_
"""
file:继承——08.py
date:2018-07-24 12:23 AM
author:wwy
desc:
多继承
子类拥有单个父类叫做单继承
子类可以拥有多个父类,并且具有所有父类的属性和方法
例如:孩子会继承自己父亲和母亲的特性

语法:
class 子类名 (父类名1,父类名2...)
    pass

"""



class A():
    def test(self):
        print 'test 方法'
class B():
    def demo(self):
        print 'demo 方法'

class C(A,B):
    # 多继承可以让子类对象,同时具有多个父类的属性和方法
    pass

c = C()
c.test()
c.demo()

运行结果:
这里写图片描述
继承——09.py

# _*_ coding:utf-8 _*_
"""
file:继承——09.py
date:2018-07-24 1:03 AM
author:wwy
desc:

"""



class A():
    def test(self):
        print 'A----test 方法'
    def demo(self):
        print 'A----demo 方法'
class B():
    def test(self):
        print 'B----test 方法'
    def demo(self):
        print 'B----demo 方法'

class C(A,B):
    # 多继承可以让子类对象,同时具有多个父类的属性和方法
    pass

c = C()
c.test()
c.demo()

将class C(A,B):换为class C(B,A):

# class C(A,B):
class C(B,A):

运行结果:
这里写图片描述

新式类 经典类

在Python 2及以前的版本中,由任意内置类型派生出的类(只要一个内置类型位于类树的某个位置),都属于“新式类”,都会获得所有“新式类”的特性;反之,即不由任意内置类型派生出的类,则称之为“经典类”。
“新式类”和“经典类”的区分在Python 3之后就已经不存在,在Python 3.x之后的版本,因为所有的类都派生自内置类型object(即使没有显示的继承object类型),即所有的类都是“新式类”。

基类:


In [1]: class A(object):
   ...:     pass
   ...: 

In [2]: a = A()

In [3]: dir(a)
Out[3]: 
['__class__',
 '__delattr__',
 '__dict__',
 '__doc__',
 '__format__',
 '__getattribute__',
 '__hash__',
 '__init__',
 '__module__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__']

In [4]: class B():
   ...:     pass
   ...: 

In [5]: b = B()

In [6]: dir(b)
Out[6]: ['__doc__', '__module__']

私有属性和私有方法——02.py

# _*_ coding:utf-8 _*_
"""
file:私有属性和私有方法——02.py
date:2018-07-24 1:15 AM
author:wwy
desc:

父类的私有属性和私有方法
1.子类对象不能在自己的方法内部,直接访问父类的私有属性和私有方法
2.子类对象可以通过父类的共有方法间接访问到私有属性或私有方法
私有属性,私有方法是对象的隐私,不对外公开,外界以及子类都不能直接访问
私有属性,私有方法常用做一些内部的事情

"""


class A(object):
    def __init__(self):
        # 在初始化方法中定义了两个属性,一个共有属性,一个私有属性
        self.num1 = 100
        self.__num2 = 200
        # 定义私有方法
    def __test(self):
        print '私有方法 %d %d' %(self.num1,self.__num2)
    def test1(self):
        print '%d' % self.__num2
        self.__test()

class B(A):
    def demo(self):
        # 在子类的方法中,不能访问父类的私有属性
        print '访问父类的私有属性 %d' % self.__num2
        # 在子类的方法中,不能调用父类的私有方法
        self.test1()
        pass

# 创建了一个子类对象
b = B()
print b
# 在外界不能直接访问对象的私有属性/调用私有方法
# print b.__num2
# b.__test
#b.demo()
b.test1()

运行结果:
这里写图片描述

多态

多态——01.py

# _*_ coding:utf-8 _*_
"""
file:多态——01.py
date:2018-07-24 1:21 AM
author:wwy
desc:

1.封装:根据职责将属性和方法封装到一个抽象的类中
    定义类的标准
2.继承:实现代码的重用,相同的代码不需要重复的编写
    设计类的技巧
    子类针对自己特有的需求,编写特定的代码
3.多态
    不同的子类(这是之前提到的继承知识)
    对象调用相同的方法,产生不同的执行结果

"""
"""
在执行相同方法时:

继承:子类方法会覆盖父类方法
    继承时,父类game方法将会被覆盖,不会显示两只耳朵竖起来
多态:会执行不同的特点
    父类的不会被覆盖,子类也会显示自己不同的特点
"""

class Ribbit(object):
    def __init__(self,name):
        self.name = name
    def game(self):
        print  '%s 会两只耳朵竖起来' % self.name

class yutu(Ribbit):
    def game(self):
        print '%s 和嫦娥跳舞' % self.name

class Person(object):
    def __init__(self,name):
        self.name = name
    def game_with_ribbit(self,ribbit):
        print '%s 和 %s 一起跳舞' %(self.name,ribbit.name)
        ribbit.game()

# 1.创建一个兔对象
#xiaohui = Ribbit('小灰')
xiaohui = yutu('洛小依')
# 2.创建一个人对象
xiaoming = Person('小明')
# 3.让小明和兔子跳舞
xiaoming.game_with_ribbit(xiaohui)

运行结果:
这里写图片描述

类结构、类属性和类方法

类的结构
实例:
1.使用面向对象开发,第一步是设计类
2.使用 类名() 创建对象,创建对象的动作有两步
1.在内存中为对象分配空间
2.调用初始化方法init为对象初始化
3.对象创建后,内存中就有了一个对象的真实存在——实例
因此:
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例比
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法
在程序执行时:
1.对象各自拥有自己的实例属性
2.调用对象的方法,可以通过self
访问自己的属性
调用自己的方法
结论:
1.每一个对象都有自己独立的内存空间,保存各自不同的属性
2.多个对象的方法,在内存中有一份,在调用方法时
需要把对象的引用传递到方法内部

类属性——01.py

# _*_ coding:utf-8 _*_
"""
file:类属性——01.py
date:2018-07-24 1:27 AM
author:wwy
desc:
类是一个特殊的对象
python中一切皆对象
    class AAA :定义的类属性属于类对象
    obj1 =AAA :属于实例对象
在运行程序时,类同样会被加载到内存
在python中,类是一个特殊的对象--类对象

除了封装 实例 的属性和方法外,类对象还可以有自己的属性和方法

通过 类名. 的方式可以直接访问类的属性或者调用类的方法


"""


class Tool(object):
    #1.使用了赋值语句定义类属性,记录所有的工具的数量
    count = 0
    def __init__(self,name):
        self.name = name
        Tool.count += 1

# 创建工具对象(对象在创建的时候,会自动调用初始化方法)
tool1 = Tool('斧头')
tool2 = Tool('剪刀')
tool3 = Tool('榔头')

# 输出工具对象的总数
# 使用 类名.属性名 来获取
print Tool.count

运行结果:
这里写图片描述
类属性——02.py

# _*_ coding:utf-8 _*_
"""
file:类属性——02.py
date:2018-07-24 1:32 AM
author:wwy
desc:

类属性就算针对类对象定义的属性
    使用赋值语句在class关键字下方可以定义类属性
    类属性用于记录与这个类相关的特性

类方法就是针对类对象定义的方法
    在类方法内部可以直接访问类属性或者调用其他类方法


语法如下:
@classmethod
def 类方法(cls):
    pass

"""


class Toy(object):
    # 1.定义类属性
    count = 0

    @classmethod
    def show_toy_count(cls):
    # cls.count:在类方法内部,访问当前类属性
        print '玩具对象数量 %d' % cls.count
    def __init__(self,name):
        self.name = name
        Toy.count += 1

# 创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('大风车')
toy3 = Toy('tiddy beer')

# 调用类方法
Toy.show_toy_count()
# 在方法的内部,可以直接访问类属性

运行结果:
这里写图片描述
类方法——03.py

# _*_ coding:utf-8 _*_
"""
file:类方法——03.py
date:2018-07-24 1:34 AM
author:wwy
desc:
静态方法
在开发时,如果需要在类中封装一个方法,这个方法:
    即不需要访问实例属性或调用实例方法
    也不需要访问类属性或者调用类方法
这个时候可以把这个方法封装成一个静态方法

方法如下:
@staticmethod
def 静态方法():
    pass
静态方法需要修饰器@staticmethod来标识,告诉解释器这是一个静态方法
通过类名,调用静态方法

"""


class Cat(object):
    @staticmethod
    #静态方法不需要传递第一个参数:self
    def call():
        print '小猫喵喵叫~'


# 通过 类名. 调用静态方法
# 不需要创建对象可以直接使用
Cat.call()

运行结果:
这里写图片描述
综合应用.py

# _*_ coding:utf-8 _*_
"""
file:综合应用.py
date:2018-07-24 1:36 AM
author:wwy
desc:
1.设计一个Game类
2.属性
    类属性:记录游戏的历史最高分(与这个游戏类有关系,与每次游戏无关)
    实例属性:记录当前游戏玩家的玩家姓名
3.方法
    静态方法:方法show_help显示游戏帮助信息
    类方法:show_top_score显示历史最高分
    实例方法:start_game开始当前玩家的游戏
4.主程序步骤
    1.查看帮助信息
    2.查看历史最高分
    3.创建游戏对象,开始游戏

"""


class Game(object):
    #1.记录历史最高分
    top_score = 0
    def __init__(self,play_name):
        self.player_name = play_name

    @staticmethod
    def show_help():
        print '#@@$$#%^&*('

    @classmethod
    def show_top_score(cls):
        print '历史记录 %d' % cls.top_score

    def star_game(self):
        print '%s 开始游戏了' % self.player_name

# 1.查看游戏帮助信息
Game.show_help()
# 2.查看历史最高分
Game.show_top_score()
# 3.创建游戏对象 开启游戏
game = Game('小明')
game.star_game()


"""
案例小结:
1.实例方法:方法内部需要访问实例属性
2.类方法:方法内部只需要访问类属性
3.静态方法:方法内部不需要访问实例属性和类属性

提问:如果方法内部,既需要访问类属性,应该定义什么方法
"""

运行结果:
这里写图片描述

设计模式

设计模式——01.py

# _*_ coding:utf-8 _*_
"""
file:设计模式——01.py
date:2018-07-24 1:40 AM
author:wwy
desc:

"""


class Cat():
    def __init__(self,name):
        self.name = name
    def call(self):
        print '喵喵'

cat1 = Cat('fendai')
print cat1
cat1.call()
cat2 = Cat('liangpi')
print cat2
cat2.call()

运行结果:
这里写图片描述
设计模式——02.py

# _*_ coding:utf-8 _*_
"""
file:设计模式——02.py
date:2018-07-24 1:40 AM
author:wwy
desc:

使用类名()创建对象时,python的解释器首先会调用__new__
方法为对象分配空间
__new__是一个有object基类提供的内置的静态方法,主要有两个作用:
    在内存中为对象分配空间
    返回对象的引用

python的解释器获得对象的引用后,将引用作为一个参数,传递给
__init__方法
# __new__:负责给对象分配空间 __init__(初始化方法)负责给对象初始化

"""


class MusicPlayer(object):
    def __new__(cls, *args, **kwargs):
    # 第一个参数 cls:哪一个类调用,就传递哪一个类
    # 第二个参数 *args:多值参数
    # 第三个参数 **kwargs :多值的字典参数

        print '创建对象,分配空间'

    def __init__(self):
        print '播放器初始化'

player = MusicPlayer()
print player

运行结果:
这里写图片描述

def test(**kwargs):
    for key in kwargs:
        print '%s: %s' %(key,kwargs[key])

test(arg2='two',arg3=3)

运行结果:
这里写图片描述
设计模式——03.py

# _*_ coding:utf-8 _*_
"""
file:设计模式——03.py
date:2018-07-24 1:41 AM
author:wwy
desc:

"""


class MusicPlayer(object):
    #def __new__(cls, *args, **kwargs):
    # 第一个参数 cls:哪一个类调用,就传递哪一个类
    # 第二个参数 *args:多值参数
    # 第三个参数 **kwargs :多值的字典参数
    #    print '创建对象,分配空间'

    def __init__(self):
        print '播放器初始化'

player = MusicPlayer()
print player

运行结果:
这里写图片描述
设计模式——04.py

# _*_ coding:utf-8 _*_
"""
file:设计模式——04.py
date:2018-07-24 1:41 AM
author:wwy
desc:

"""


class MusicPlayer(object):
    def __new__(cls, *args, **kwargs):
    # 第一个参数 cls:哪一个类调用,就传递哪一个类
    # 第二个参数 *args:多值参数
    # 第三个参数 **kwargs :多值的字典参数
    # 创建对象的时候,new方法会被自动调用
    # 重写了父类的方法
    # 1.创建对象,new方法会被自动调用
        print '创建对象,分配空间'
    # 2.为对象分配空间
        instance = object.__new__(cls)
    # 3.返回对象的引用
        return instance

    def __init__(self):
        print '播放器初始化'

player = MusicPlayer()
print player

运行结果:
这里写图片描述
设计模式——05.py

# _*_ coding:utf-8 _*_
"""
file:设计模式——05.py
date:2018-07-24 1:41 AM
author:wwy
desc:

只执行一次初始化工作
在每次使用 类名() 创建对象时,python的解释器都会自动调用两个方法
    __new__     分配空间
    __init__    对象初始化
但在上一个小结中 __new__方法改造之后,每次都会得到第一次被创建对象的引用
但是:初始化方法还会被再次用掉

需求:让初始化方法只执行一次

"""


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

运行结果:
这里写图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值