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

其他 2018-07-27 12:10:23 阅读次数: 0

面向对象

面向对象的三大特性：
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

这里写图片描述

猜你喜欢

转载自blog.csdn.net/wzt888_/article/details/81175590
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022