python之面向对象，类属性，设计模式，私有属性和私有方法，内置方法

最新推荐文章于 2024-08-14 15:58:26 发布

小熙同学-

最新推荐文章于 2024-08-14 15:58:26 发布

阅读量636

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/wzt888_/article/details/81175590

版权

python 专栏收录该内容

23 篇文章 2 订阅

订阅专栏

面向对象

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

# _*_ coding:utf-8 _*_
"""
file: 面向对象-01.py
date: -07-21  7:56 PM
author: ting
desc:

目标：学习面向对象的基本结构

类的设计：
1.类名 这类事物的名字，满足大驼峰命名法
2.属性 这类事物具有什么样的特征
3.方法  这类事物具有什么样的行为
需求：
小明今年18岁，身高1.75，每天早上要跑步，会去吃东西
小美今年17岁，身高1.65，不跑步，喜欢吃东西


# 类名
Person()

# 属性
name
age

# 方法
run()
eat()

一只黄颜色的狗狗叫小黄
看见陌生人旺旺叫，看见家人摇尾巴

Dog()

color
name

shout()
shake()

"""

# _*_ coding:utf-8 _*_
"""
file: 面向对象-02.py
date: -07-23  1:07 PM
author: ting
desc:
面向对象的基础语法：
1.定义简单的类
class  类名：
    def 方法1(self,参数列表):
        pass
    def 方法2(self,参数列表)：
        pass
2.创建对象
变量 = 类名


练习：
小明爱学习，小明爱吃零食
"""
class Person():
    def learn(self):
        print '%s 爱学习' % self.name
    def eat(self):
        print '%s 爱吃零食' % self.name


# 创建一个对象
xm = Person()
xm.name = ('小明')
xm.learn()
xm.eat()

"""
注意：
    在日常开发中，不推荐在类的外部给对象增加属性
    如果在运行时，没有找到属性，程序会报错
"""

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 面向对象-03.py
date: -07-23  1:22 PM
author: ting
desc:
目标：
1.了解self的意义
2.不同的引用会有不同的输出结果

练习：

通过不同的引用实现不同的输出，用三个对象来实现

"""
class Person():
    # 哪一个对象调用此方法，self就是哪一个对象的引用
    def learn(self):
        print '%s 爱学习' % self.name
    def eat(self):
        print '%s 爱吃零食' % self.name


# 创建一个对象
xm = Person()
xm.name = ('小明')
xm.learn()
xm.eat()
print xm
addr = id(xm)

# %x 打印格式为十六进制， %d 打印格式为十进制
print '%x' % addr
print '%d' % addr
print ''
print '***************这是一条分割线*****************'


# 再创建一个对象
# 这种方法的引用，可以实现不同的对象输出不同的结果
xl = Person()
xl.name = ('小李')
xl.eat()
xl.learn()
print xl
addr = id(xl)

# %x 打印格式为十六进制， %d 打印格式为十进制
print '%x' % addr
print '%d' % addr

# 创建第三个对象
# 这种方法的引用，只是换了一个记号
xh = xl
print ''
print '****************这是一条分割线*****************'
print xh

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 面向对象-04.py
date: -07-23  1:54 PM
author: ting
desc:
知识点：
通过学习我们已经知道了使用 '类名()' 就可以创建一个对象
当使用 '类名()' 创建对象时，python解释器会自动执行以下操作：
  1.为对象在内存中分配空间，并创建对象
  2.调用初始化方法为对象的属性设置初始值
初始化方法：
就是__init__方法，__init__是对象的内置方法，它是专门用来定义一个具有哪些属性的方法
__init__方法是专门用来定义一个类具有哪些属性的方法

目标：熟练掌握初始化方法

"""
class Person():
    def __init__(self):
        print '这是一个初始化方法'
        # self.属性名 = 属性的初始值
        self.name = 'tom'
# 使用 类名（） 创建对象的时候，会自动调用初始化方法 __init__(self):
xm = Person()
print xm.name

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 面向对象-05.py
date: -07-23  2:03 PM
author: ting
desc:
改进版

"""
class Person():
    def __init__(self,name):
        self.name = name
        # 在类中，任何方法都可以使用self.name
    def sport(self):
        print '%s 爱跑步' % self.name
xm = Person('小明')  # 必须给传递实际的参数不然会报错
print xm.name
xm.sport()



xh = Person('小红')
print xh.name
xh.sport()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 面向对象-06.py
date: -07-23  2:48 PM
author: ting
desc:
目标：

熟练掌握使用 self.name

"""
class Person():
    def __init__(self):
        self.name = '小明'
        # 在类中，任何方法都可以使用self.name
    def eat(self):
        print '%s 爱吃零食' % self.name
xm = Person()
print xm.name
xm.eat()
# 重新定义一个人输出还是'小明',显然不合理
xh = Person()
print xh.name
xh.eat()

这里写图片描述
###封装

# _*_ coding:utf-8 _*_
"""
file: 封装-01.py
date: -07-23  5:16 PM
author: ting
desc:
需求：
1. xx 和 xx 都爱跑步
2. xx 体重45.00kg
3. xx 体重55.00kg
4. 每次跑步都会减少 0.5 kg
5. 每次吃东西都会增加1kg

"""
class Person():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def __str__(self):
        return '我叫%s,体重是%.2fkg'%(self.name,self.weight)
    def eat(self):
        # 在对象的内部是直接可以访问对象的属性
        print '%s爱吃东西'% self.name
        self.weight += 1
    def run(self):
        print '%s爱跑步'% self.name
        self.weight -= 0.5

# 创建一个对象
xm = Person('小明',55.0)
xm.eat()
print xm

# 创建另外一个对象
xh = Person('小红',45.0)
xh.run()
print xh

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 摆放家具.py
date: -07-23  5:39 PM
author: ting
desc:
需求：
1.房子有户型，总面积和家具名称列表
    新房子没有任何家具
2.家具有名字和占地面积，其中
    床占3平米
    衣柜占10平米
    餐桌占5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出：户型，总面积，剩余面积，家具名称列表

"""
# 创建家具类
class Furniture():
    # 初始化方法
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return '%5s 占地 %.2f平方米'% (self.name,self.area)

# 创建家具
bed = Furniture('bed',3)
print bed
chest = Furniture('chest',5)
print chest
table = Furniture('table',3)
print table

# 创建房子类
class House():
    def __init__(self,house_type,area,free_area):
        self.house_type = house_type
        self.area = area
        # 剩余面积
        self.free_area = free_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.name
        # 判断家具的面积
        if item.area > self.free_area:
            print '%s的面积太大，无法添加' % item.name
            # 如果添加不进去，就直接退出
            return
        # 将家具的名称添加到列表中
        self.item_list.append(item.name)
        # 计算剩余面积
        self.free_area -= item.area

# 创建房子对象
house = House('两室一厅',150,150)
# 添加家具
house.add_item(bed)
house.add_item(chest)
house.add_item(table)
print house

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 士兵开枪.py
date: -07-23  6:24 PM
author: ting
desc:
1.士兵瑞恩有一把AK47
2.士兵可以开火
3.枪能够发射子弹（把子弹发射出去）
4.枪能够装填子弹（增加子弹数量）

"""
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):
        # 判断子弹的数量
        if self.bullet_count <= 0:
            print '%s 没有子弹'% self.model
        # 发射子弹
        self.bullet_count -= 1
        # 提示发射信息
        print '%s 发射成功 %d'% (self.model,self.bullet_count)
class Soldier():
    def __init__(self,name):
        self.name = name
        self.gun = None
    def fire(self):
        # 判断士兵有没有枪
        if self.gun == None:
            print '%s 还没有枪'% self.name
            return
        # 喊口号
        print '加油  %s'% self.name
        # 装子弹
        self.gun.add_bullet(20)
        # 发射子弹
        self.gun.shoot()

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


# 创建士兵对象
soldier = Soldier('Ryan')
soldier.gun = gun
soldier.fire()
print soldier.gun

这里写图片描述
###继承

# _*_ coding:utf-8 _*_
"""
file: -01.py
date: -07-23  7:24 PM
author: ting
desc:
单继承：
1.继承的概念语法和特点：
继承的概念：子类拥有父类的所有方法和属性
只需要封装自己特有的属性和方法
2.继承的语法：
class 类名（父类）
    def 子类特有的方法和属性

"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def play(self):
        print '玩'
    def sleep(self):
        print '睡'
class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵喵～～'
mimi = Cat()
mimi.eat()
mimi.drink()
mimi.play()
mimi.sleep()
mimi.call()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: -02.py
date: -07-23  7:35 PM
author: ting
desc:

继承的传递性：（爷爷，父亲，儿子）
1.C类从B类继承，B类从A类继承
2.那么C类具有A类和B类的所有方法和属性
"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def play(self):
        print '玩'
    def sleep(self):
        print '睡'
class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵喵～～'
class Jiafei(Cat):
    def speak(self):
        print '我可以说泰语'
    def call(self):
        print '萨瓦迪卡'

# 创建一个 Jiafei对象
jf = Jiafei()


jf.speak()
# 继承的传递性，子类拥有父类和父类的父类的属性和方法
jf.eat()
jf.drink()
jf.play()
jf.sleep()
# 子类可以继承来自父类的所有属性和方法
jf.call()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: -03.py
date: -07-23  7:41 PM
author: ting
desc:
重写父类有两种情况：
1.覆盖父类的方法
2.对父类方法进行扩展

1.覆盖父类的方法
如果在开发中，父类的方法的实现和子类的方法的实现完全不同
就可以使用覆盖的方法在子类中重写父类的方法
具体实现方式：
就相当于在子类中定义了一个和父类同名的方法
实现重写之后，在运行时，只会调用子类的重写方法,而不会调用父类的重写方法

"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def play(self):
        print '玩'
    def sleep(self):
        print '睡'
class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵喵～～'
class Jiafei(Cat):
    def speak(self):
        print '我可以说泰语'
    def call(self):
        print '萨瓦迪卡'

# 创建一个 Jiafei对象
jf = Jiafei()
# 如果子类中重写了父类的方法，在运行中，只会调用子类中重写的方法，不会调用父类的方法
jf.call()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: -04.py
date: -07-23  7:44 PM
author: ting
desc:
对父类的方法进行扩展：
如果在开发中，子类的方法实现含有父类的方法实现
（父类原本封装的方法实现是子类方法的一部分，就可以使用扩展方法）
1.在子类中重写父类的方法
2.在需要的位置使用父类名.方法(self)来调用父类方法的执行（使用父类名称调用父类方法）
3.代码其他的位置针对子类的需求，编写子类特有的属性和方法

"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def play(self):
        print '玩'
    def sleep(self):
        print '睡'
class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵喵～～'
class Jiafei(Cat):
    def speak(self):
        print '我可以说泰语'
    def call(self):
        print '萨瓦迪卡'
        # 调用原本在父类中封装的方法
        Cat.call(self)
        # 在调用的前后都可以进行扩展
        print 'lalala~~'
# 创建一个 Jiafei对象
jf = Jiafei()


jf.call()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 多继承.py
date: -07-23  8:04 PM
author: ting
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()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 多继承-01.py
date: -07-23  8:13 PM
author: ting
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()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 多继承-02.py
date: -07-23  8:19 PM
author: ting
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(B,A):
    pass


# 创建子类对象
c=C()
c.test()
c.demo()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 综合应用.py
date: -07-23  7:50 PM
author: ting
desc:


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

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

这里写图片描述
###多态

# _*_ coding:utf-8 _*_
"""
file: -01.py
date: -07-23  8:46 PM
author: ting
desc:
"""
class Dog(object):
    def __init__(self,name):
        self.name=name
    def game(self):
        print '%s 追皮球' % self.name
class Wangwang(Dog):
    def __init__(self,name):
        self.name=name
    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.name)
        dog.game()

# 创建一个狗对象
# 调用不同的对象，产生不同的结果
# huahua = Dog('花花')
huahua = Wangwang('小花')
# 创建一个人对象
xiaoming = Person('小明')
# 人和狗玩耍
xiaoming.game_with_dog(huahua)

这里写图片描述
#区分新式类与经典类
新式类 :以 object 作为基类
class A(object):

经典类 : 没有基类
class A():

<1>In [1]: class A(object):    #创建以object为基类的新式类
   ...:         pass
   ...: 

<2>In [2]: a=A()

<3>In [3]: dir(a) #object包含以下类
Out[3]: 
['__class__',
 '__delattr__',
 '__dict__',
 '__doc__',
 '__format__',
 '__getattribute__',
 '__hash__',
 '__init__',
 '__module__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__']

<4>In [4]: class
  File "<ipython-input-4-20a882c5c27d>", line 1
    class
         ^
SyntaxError: invalid syntax


<5>In [5]: class B():
   ...:     pass
   ...: 

<6>In [6]: b=B()

<7>In [7]: dir(b)  #而经典类却只有以下两个
Out[7]: ['__doc__', '__module__']

#私有属性和私有方法

私有属性和私有方法的应用场景及定义方式
  1.应用场景：
    在实际开发中，对象的某些属性或方法只希望在对象内部使用，
    而不希望在对象外部使用
    私有属性就是对象不希望公开的属性
    私有方法就是方法不希望公开的方法
  2.定义方法：
    在定义属性或方法时，在属性或方法前面加两个下划线，定义的就是
    私有属性和私有方法

# _*_ coding:utf-8 _*_
"""
file: -01.py
date: -07-23  7:13 PM
author: ting
desc:

"""
class Women():
    def __init__(self,name):
        self.name = name
        self.age = 18
    def secret(self):
        print '%s 的年龄是 %d'%(self.name,self.age)

ll = Women('lala')
# 外部通过传参可以访问到年龄，此时的age是开放的
print ll.age
ll.secret()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: -02.py
date: -07-23  7:17 PM
author: ting
desc:


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

ll = Women('lala')
# 私有属性，在外界不允许直接访问
# print ll.age    #访问不到，age已经成为私有的
ll.secret()

# 此时访问到的年龄是内部访问的，而不是外部通过传参访问到的

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: -03.py
date: -07-23  7:18 PM
author: ting
desc:


"""
class Women():
    def __init__(self,name):
        self.name = name
        # __age 表示私有化
        self.__age = 18
    def __secret(self):
        print '%s 的年龄是 %d'%(self.name,self.__age)

ll = Women('lala')
# 私有方法，在外界不允许直接访问
ll.__secret()
# 全部私有化

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 1-01.py
date: -07-23  7:21 PM
author: ting
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)
class B(A):
    pass

# 创建子类对象
b = B()
print b

# 在外界不能直接访问对象的私有属性和调用私有方法
print b.__num2
b.__test

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 2-02.py
date: -07-23  7:22 PM
author: ting
desc:


"""
class A(object):
    def __init__(self):
        # 在初始化方法中定义两个属性，一个公有属性，一个私有属性
        self.num1 = 100
        self.__num2 = 200
    # 定义私有方法
    def __test(self):
        print '私有方法 %d %d' %(self.num1,self.__num2)
class B(A):
    def demo(self):
        # 在子类的方法中，不能访问父类的私有属性
        print '访问父类的私有属性 %d' % self.__num2
        # 在子类的方法中，不能调用父类的私有方法
        self.__test()

# 创建子类对象
b = B()
b.demo()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 3-03.py
date: -07-23  7:23 PM
author: ting
desc:


"""
class A(object):
    def __init__(self):
        # 在初始化方法中定义两个属性，一个公有属性，一个私有属性
        self.num1 = 100
        self.__num2 = 200
    # 定义私有方法
    def __test(self):
        print '私有方法 %d %d' %(self.num1,self.__num2)
    def test(self):
        # 调用私有属性
        print '私有方法 %d' % self.__num2
        # 调用私有方法
        self.__test()
class B(A):
    def demo(self):
        # 在子类的方法中，不能访问父类的私有属性
        print  '访问父类的私有属性 %d' % self.__num2
        # 在子类的方法中，不能调用父类的私有方法
        self.__test()

# 创建子类对象
b = B()

b.test()

这里写图片描述
#类结构
类的结构
实例：
1.使用面向对象开发，第一步是设计类
2.使用’类名()'创建对象，创建对象的动作有两步
在内存中为对象分配空间
调用初始化方法__init__为对象初始化
3.对象创建后，内存中就有了一个对象的实实在在的存在–实例

因此
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法

在程序中执行时：
1.对象各自拥有自己的实例属性
2.调用对象的方法，可以通过self
    访问自己的属性
    调用自己的方法

结论：
1.每一个对象都有自己独立的内存空间，保存各自不同的属性
2.多个对象的方法，在内存之中有一份，在调用方法时，需要把对象的引用传递到方法内部

#类属性

# _*_ coding:utf-8 _*_
"""
file: --01.py
date: -07-23  8:54 PM
author: ting
desc:
类是一个特殊的对象
python中的所有对象
    class AAA : 定义的类属性属于类对象
    obj1 =AAA : 属于实例对象
在运行程序时，类同样会被加载到内存，在python中，类是一个特殊的对象 -- 类对象

除了封装，实例的属性和方法外，类对象还可以有自己的属性和方法
通过类名的方式可以直接访问类的属性或者调用类的方法

"""
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

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: -02.py
date: -07-23  8:56 PM
author: ting
desc:
类属性就是针对类对象定义的属性
    使用赋值语句在class关键字下方可以定义类属性
    类属性用于记录这个类相关的特性
类方法就是针对类对象定义的方法
    在类方法内部就可以直接访问类属性或者调用其他类方法
语法如下：
@classmethod
def 类方法（cls）:
    pass

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

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

# 创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('大雄')
toy3 = Toy('小猪佩琦')

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

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: -03.py
date: -07-23  8:57 PM
author: ting
desc:
静态方法：
    在开发时，如果需要在类中封装一个方法，这个方法
    1.即不需要访问实例属性或者调用实例方法
    2.也不需要访问类属性或者调用类方法
此时就可以把这个方法封装成一个静态方法

语法如下：
@staticmethod
def 静态方法()：
    pass



静态方法需要修饰器@staticmethod来标识，告诉解释器这是一个静态方法,通过类名，调用静态方法

"""
class Cat(object):
    @staticmethod
    # 静态方法不需要传递第一个参数 self
    def call():
        print '喵喵～～'
# 通过 '类名. ' 调用静态方法
# 不需要创建对象，可以直接使用
Cat.call()

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: 综合应用.py
date: -07-23  8:59 PM
author: ting
desc:
1. 设计一个Game类
2. 属性
    记录游戏的历史最高分
    记录当前游戏玩家的玩家姓名
3. 方法
    show_help 显示游戏帮助信息
    show_top_score 显示历史最高分
    start_game 开始当前玩家的游戏
4. 主程序步骤
    查看帮助信息
    查看历史最高分
    创建游戏对象，开始游戏

"""
class Game(object):

    top_score = 0

    def __init__(self,name):
        self.name = name
    # 定义实例属性：游戏开始

    def start_game(self):
        print '%s 开始游戏' % self.name
    # 定义静态方法：游戏帮助

    @staticmethod
    def show_help():
        print '游戏帮助'
    # 定义类方法：历史最高分

    @classmethod
    def show_top_score(cls):
        print '最高分为 %d' %cls.top_score

# 查看游戏帮助信息
Game.show_help()
# 查看游戏历史最高分
Game.show_top_score()
# 创建游戏对象，开始游戏
game = Game('小明')
game.start_game()

这里写图片描述
#设计模式

# _*_ coding:utf-8 _*_
"""
file: -01.py
date: -07-23  9:01 PM
author: ting
desc:
 使用类名（）创建对象时，python的解释器首先会调用__new__方法为对象分配空间
__new__是一个由object基类提供的内置的静态方法，主要有两个作用
1.在内存中为对象分配空间
2.返回对象的引用

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

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

    # 重写了父类的方法

        # 创建对象的时候，new方法会被自动调用
        print '创建对象，分配空间'
    # 创建对象时，会自动执行初始化方法
    # 实际上，再创建对象时，执行初始化之前先要给对方分配内存空间
    def __init__(self):
        print '播放器初始化'
player = MusicPlayer()
print player

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file: -02.py
date: -07-23  9:03 PM
author: ting
desc:


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

    # 重写了父类的方法

        # 创建对象的时候，new方法会被自动调用
        print '创建对象，分配空间'
        # 为对象分配空间
        instance = object.__new__(cls)
        # 返回对象的引用
        return instance
    def __init__(self):
        print '播放器初始化'
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2

这里写图片描述`

# _*_ coding:utf-8 _*_
"""
file: -03.py
date: -07-23  9:04 PM
author: ting
desc:


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

    # 重写了父类的方法
        if cls.instance is None:
            cls.instance = object.__new__(cls)
        return cls.instance


player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2

这里写图片描述`

# _*_ coding:utf-8 _*_
"""
file: -04.py
date: -07-23  9:13 PM
author: ting
desc:
只执行一次初始化工作
在每次使用 类名（） 创建对象时，python的解释器都会自动调用两个方法
    __new__ 分配空间
    __init__ 对象初始化
但在上一小节中，__new__方法改造之后，每次都会得到第一次被创建对象徳引用
但是：初始化请方法还会被再次调用


需求： 让初始化只执行一次

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

    # 重写了父类的方法
        if cls.instance is None:
            cls.instance = object.__new__(cls)
        return cls.instance
    def __init__(self):
        if MusicPlayer.init_flag:
            return
        print '初始化播放器'
        MusicPlayer.init_flag = True



player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2

这里写图片描述

区分Python中 staticmethod（静态方法）和 classmethod（类方法）
静态方法：
    在开发时，如果需要在类中封装一个方法，这个方法
    1.即不需要访问实例属性或者调用实例方法
    2.也不需要访问类属性或者调用类方法
类方法就是针对类对象定义的方法
    在类方法内部就可以直接访问类属性或者调用其他类方法

#内置方法

# _*_ coding:utf-8 _*_
"""
file:__del__.py
date: 2018-07-上午3:10
author:ting
desc:
在python中
  当使用 类名（） 创建对象时，为对象分配完空间后，自动调用__init__(self):
  当一个对象被从内存中销毁前，会自动调用__del__方法
"""
class Person():
    def __init__(self,new_name):
        self.name = new_name
        print '%s 长高了' % self.name
    def  __del__(self):
        print '%s 变瘦了' % self.name
xm = Person('小明')
print xm.name
print '-' * 55
# 这行代码运行在 __del__(self):  之前

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file:__del__ 02.py
date: 2018-07-上午3:19
author:ting
desc:

"""
class Person():
    def __init__(self,new_name):
        self.name = new_name
        print '%s 长高了' % self.name
    def  __del__(self):
        print '%s 变瘦了' % self.name
xm = Person('小明')
print xm.name
del xm
print '-' * 55
# 这行代码运行在 __del__(self):  之后

这里写图片描述

# _*_ coding:utf-8 _*_
"""
file:__str__.py
date: 2018-07-上午3:20
author:ting
desc:
在python中，使用python输出对象变量
默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象,以及在内存中的地址（十六进制表示）

如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以用__str__这个内置方法
"""
class Person():
    def __init__(self,new_name):
        self.name = new_name
        print '%s 长高了' % self.name
    def  __str__(self):
        # 必须返回一个字符串
        return '我是%s' % self.name
xm = Person('小明')
print xm

这里写图片描述