python——面向对象

最新推荐文章于 2022-06-05 20:08:29 发布
最新推荐文章于 2022-06-05 20:08:29 发布
阅读量277 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwy0324/article/details/81177473
版权

面向对象

类的设计：
在程序开发中，要设计一个类，通常需要以下三个要求：
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

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

加油，你可以的！
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用python画四叶风车
chatgpt002的博客
08-17 530
大家好，小编来为大家解答以下问题，一个有趣的事情，一个有趣的事情，今天让我们一起来看看吧！
草莓熊python turtle绘图（风车版）附源代码
热门推荐
逆境清醒的博客
10-01 5万+
草莓熊python turtle绘图源代码
用turtle库画大风车（零基础python教程适合亲子教学互动）
lgk1996的博客
11-06 4543
大风车是少儿节目，它的图标可谓深入人心，用turtle库来画几乎可以不用掌握任何编程基础，适合亲子互动教学演示。 首先，安装turtle库。 Python2： 直接在cmd里输入pip install turtle，不用下载 python3：直接在cmd里输入 pip install turtle，不用下载 代码如下。小学水平立马掌握。 import turtle turtle.left(-30) turtle.fillcolor("blue") turtle.begin_fill() tu
python 画几何图形
bianfu2008zhi的专栏
11-23 6601
# 多边形的画法 def ployon(num, distance): #     bob.color('blue', 'red')     bob.color("red", "yellow")      for i in range(num):         bob.fd(distance)         bob.lt(360 / num)         time.sleep
大风车旋转
10-21
旋转风车 钟表 锚点 可以实现旋转速度控制
从零开始python——面向对象开发2
12-22
从零开始python——面向对象开发2 太原理工大学机器人团队20日打卡day10 1、内置方法和属性 2、私有属性和私有方法 3、继承 ​ 昨天晚上躺在床上时候还在想有没有用于arduino的python编译器，好像是没有的，不过...
Python——面向对象思想编程（一）
12-22
我的第一个类 设计类 类名：见名知意，首字母大写，其他遵循驼峰原则 属性：见名知意，其他遵循...用类创建实例化对象（变量），对象占内存空间 格式： class 类名(父类列表)： 属性 行为 示例： # object：基类，
从零开始学python——面向对象开发4
12-22
从零开始学python——面向对象开发4 太原理工大学机器人团队20日打卡day12 本文全部基于Linux系统 1、模块和包 1.1模块 模块是Python程序架构的一个核心概念 每一个以扩展名 py 结尾的 Python 源代码文件都是一个 ...
python3基础篇（八）——面向对象
01-20
python3基础篇（八）——面向对象 前言 1 阅读这篇文章我能学到什么？   这篇文章将为你详细介绍python3中的面向对象程序设计，你将学会如何定义一个类和使用一个对象。 ——如果你觉得这是一篇不错的文章，希望你...
Python基础学习——面向对象的基本编程
01-21
Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。 一、面向对象技术简介 类(Class) : 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有...
1.23-----python ----面向对象
qq_41627390的博客
02-03 251
一、面向对象两个核心概念： 1.类：是一群具有相同特征或形为的事物的一个统称，类是抽象的，不能直接使用 2.对象：由类创造出来的具体存在 在开发中，应该先有类，再有对象 二、类和对象的关系 类是模板，对象是根据这个模板创建出来的 类只需要有一个，对象可以有多个（一张图纸可以造多个飞机） 类：属性（信息）和方法（你能完成的事）     #1.类名     #2.属性     #3.方法 #...
编写一个多态性java程序_day6-Java遗传和多态性
weixin_26749843的博客
02-26 70
遗传性和多态性遗传性遗传性允许 Java 复用&扩展 现有代码。！注意，这里StyledString只是一个理论上的例子，因为String类是最终类，实践中无法被延展和添加特性。延伸基础的String类，就是要充分利用现有的方法，同时增加一些我们自己的特性。例1，String类原本只能做单纯的文本，扩展：增加文本样式，如粗体、斜体、下划线等。class StyledString exten...
python风车代码_css实现动态风车
weixin_39893893的博客
12-21 1323
html>.main{position:relative;}.main:hover{}@-webkit-keyframesdh{0%{transform:rotate(0deg);}100%{transform:rotate(360deg);}}@-webkit-keyframesdh1{0%{transform:rotate(180deg);}50%{transform:ro...
python图形编程大风车_Python图形编程
weixin_39940253的博客
12-04 562
"""定义控件"""#保存数据源def saveMsg(txt):file = open('original.txt', 'w+')file.write(txt + '\n')file.close()#保存格式化命令def saveCli(txt):file = open('Cli.txt', 'w+')file.write(txt + '\n')file.close()#格式化方法def for...
Python之面向对象（基础）
lilygg的博客
02-10 577
1.类与对象 （1）.面向对象两个核心概念 1.类：是一群具有相同特征或形为的事物的一个统称，类是抽象的，不能直接使用 2.对象：由类创造出来的具体存在 在开发中，应该先有类，再有对象 （2）.类和对象的关系 类是模板，对象是根据这个模板创建出来的 类只需要有一个，对象可以有多个（一张图纸可以造多个飞机） 类：属性（信息）和方法（你能完成的事(动作)） （3）类的三要素 1.类名 ：这类事...
python下的面向对象及其三大特点
dreamer_hahaha
07-23 438
面向对象的基础语法 定义简单的类： 定义只包含方法的类： class 类名： def 方法1(self,参数列表)： pass def 方法2(self,参数列表)： pass 当一个类定义完成之后，要使用这个类来创建对象，语法格式如下： 对象变量 = 类名() 类的设计 在程序开发中，要设计一个类，通常需要满足以下三个要求...
太厉害了！用Python做一个大风车， 继续吱呦呦地转！
cainiao_python的博客
06-05 1841
大风车，吱呀吱呦呦地转，这里的风景呀真好看！天好看，地好看……一首熟悉的歌曲，是否已经把你拉回了童年？这首歌，估计是每个80后、90后的童年记忆！小时候守着家里的电视，只要听到这个主题曲，就代表马上会有各种好看的动画片播出。又是一年6·1儿童节，作为一个Python号，当然又要想想能用python做点什么啦——Turtle绘制大风车第一步，先观察风车的重要组成部分，四个扇...
HTML5中利用animation属性实现风车动画案例
大数据-攻城狮
12-07 3368
Document
python制作学生管理系统_Python——面向对象，简易学生信息管理系统
最新发布
06-06
这个系统将使用面向对象编程的方式实现，可以方便地添加、删除和修改学生信息。 首先，我们需要定义一个 `Student` 类，用来表示学生信息。每个学生都有姓名、学号、年龄等基本信息，可以使用类的属性来表示： ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值