码迷,mamicode.com
首页 > 编程语言 > 详细

Python教程6

时间:2018-11-10 15:20:59      阅读:229      评论:0      收藏:0      [点我收藏+]

标签:特征   教程   比较   必须   自定义   引用   不能   参数设置   设置   

Python教程6

  1.面向对象

# -*-coding:utf-8-*-
""""
面向对象:相比较函数,面向对象是更大的封装,根据职责在一个对象中封装多个方法
1.在完成某一个需求前,首先确定不过职责---要做的事情(方法)
2.根据职责确定不同的对象,在对象内部封装不同的方法
特点:
注重对象和职责,不同的对象承担不同的职责
更加适合对复杂的需求变化,是专门对应复炸项目的开发,提供固定的套路
需要在面向对象的基础上,再学习一些面向对象的语法
两个核心概念:
类:是对一群具有相同特征或者行为的事务一个统称,是抽象的,不能直接使用(类包括属性和方法)
对象:是类创建的一个具体的存在
类是模板,对象根据模板创建出来的
类只有一个,而对象可以用很多个,不同的对象之间属性可能会各不相同
类中定义的属性和方法,对象中就有什么属性和方法,不能多,野不能少

再开发程序中,设计类需要满足三个要素:
类名,属性,方法
"""

""""
dir 内置函数(知道)
在python中对象是无所不在的,变量,数据,函数都是对象
验证方法:
1.在标识符/数据 后面输入一个.,然后按TAB键会显示对象能调用的方法列表
2.使用内置函数dir传入标识符/数据 ,可以查看对象内所有的属性和方法的一个列表
"""


def demo():
    """"这是个测试函数"""
    print("hello python")


demo()
print(dir(demo))  # dir()内置函数的使用
print(demo.__doc__)  # 内置函数__doc__的使用

# 定义简单的类(只包含方法),创建对象
"""
class 类名:
    def 方法1(self,参数列表)
        pass
    def 方法2(self,参数列表)
        pass
创建对象:
对象变量 = 类名()
"""


# 第一个面向对象的程序:小猫爱吃鱼,小猫要喝水
class Cat:
    def eat(self):  # 哪一个对象调用的方法,self就是哪一个对象的引用
        print("%s猫爱吃鱼" % self.name)

    def drink(self):
        print("小猫要喝水")


# 创建猫对象
tom = Cat()
tom.name = "Tom"  #如果这行增加的属性在猫的方法tom.eat()和tom.drink()后,则会报错
tom.eat()
tom.drink()
# 对象同样使用引用
print(tom)
addr = id(tom)
print("%d" % addr)  # %d 十进制打印输出
print("%x" % addr)  # %x 十六进制打印输出

# 再创建一个猫对象
lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat()
lazy_cat.drink()
print(lazy_cat)  # 两只猫tom和lazy_cat的内存地址不一样,
lazy_cat2 = lazy_cat  # 这两只猫内存一样

# 给某个对象增加属性,不推荐使用

  2.初始化方法

# -*-coding:utf-8-*-
""""
初始化方法:
当使用类名()创建对象时,会执行以下操作:
1.为对象在内存中分配空间--创建对象
2.为对象的属性设置初始值--初始化方法(__init__)
"""


class Cat:
    def __init__(self):
        print("这是初始化方法")


tom = Cat()  # 使用类名()创建对象时,会自动调用初始化方法
"""__init__(self)方法时专门用来定义一个类具有那些属性方法!"""


# 在初始方法内部定义属性
class Cat1:
    def __init__(self):
        print("这是Cat1类初始化方法")
        self.name = "Tom"


tom = Cat1()
print(tom.name)


# 使用参数设置属性的初始值
class Cat2():
    def __init__(self, new_name):
        self.name = new_name

    def eat(self):
        print("%s 爱吃鱼" % self.name)


ton = Cat2("黄小鱼")
print(ton.name)
ton.eat()

# __del__方法,如果希望对象在被销毁前,在做些事情
print("__del__对象销毁方法")


class Cat3():
    def __init__(self, new_name):
        self.name = new_name
        print("这是初始化方法,%s 我来了" % self.name)

    def __del__(self):
        print("这是对象销毁方法,%s 我去了" % self.name)


ton1 = Cat3("TON")
print("-" * 50)  # 注意销毁方法,是在程序结束时,即此行后打印。
del ton1  # del ton1可以提前销毁对象
print("*" * 50)

# __str__方法,使用print输出对象变量,默认情况下,会输出这个变量的引用对象,
# 是由哪一个类创建的对象,以及在内存中的地址(十六进制表示),__str__这个内置的方
# 法可以自定义内容,注意:__str__这个方法必须返回一个字符串
print("__str__方法")  # 常用来打印变量


class Cat4():
    def __init__(self, new_name):
        self.name = new_name
        print("这是初始化方法,%s 我来了" % self.name)

    def __del__(self):
        print("这是对象销毁方法,%s 我去了" % self.name)

    def __str__(self):
        print("这是__str__方法")
        return "我是小猫%s" % self.name


tomm = Cat4("tomm")
print(tomm)

  3.封装

# -*-coding:utf-8-*-
""""
封装:
1.封装是面向对象的一个特点
2.面向对象的第一步,将属性和方法封装到一个抽象的类中
3.外界使用类创建对象,然后让对象调用方法
4.对象方法的细节都被封装在类的内部
"""
"""封装实例,小明爱跑步,需求:小明体重75.0公斤,每次跑步减肥0.5公斤,每次吃东西体重增加1公斤"""


class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def __str__(self):
        return "我的名字是 %s,我的体重是%.2f 公斤" % (self.name, self.weight)
        pass

    def run(self):
        print("%s 爱跑步,锻炼身体" % self.name)
        self.weight -= 0.5

    def eat(self):
        print("%s 爱吃东西,是个美食家" % self.name)
        self.weight += 1.0


xm = Person("小明", 75.0)
xm.run()
xm.eat()
print(xm)
""""在对象方法内部,是可以直接访问对象的属性的,同一个类中,多个对象之间属性不干扰"""
# 小美对象
xiaomei = Person("小美", 45)
xiaomei.eat()
xiaomei.run()
print(xiaomei)
print(xm)  # 小明的体重不会增加

  4.摆放家具实例

#-*-coding:utf-8-*-
# 案列2,摆放家具
""""
1.房子有户型,总面积和家具名称列表
新房子没有任何家具
2.家具有名字和占地面加,其中:
席梦思占地4平米
衣柜占地2平米
餐桌占地1.5平米
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)


class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具列表
        self.item_list = []

    def __str__(self):
        return ("【户型】: %s \n【总面积】:%.2f[剩余面积:%.2f] \n【家具】:"                 "%s" % (self.house_type, self.area, self.free_area,
                        self.item_list))

    def add_item(self, item):
        print("要添加%s" % item)
        #1.判断家具的面积
        if item.area > self.free_area:
            print("!!!%s 面积太大,无法添加!!!" % item.name)
            return
        #2.将家具的名称添加到列表
        self.item_list.append(item.name)
        #3.计数剩余面积
        self.free_area -= item.area

# 创建家具
bed = HouseItem("席梦思", 40)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 20)
print(bed)
print(chest)
print(table)
# 创建房子对象
my_home = House("两室一厅", 60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

  5.士兵突击实例

# -*-coding:utf-8-*-
""""
一个对象的属性可以时另外一个类创建的对象
实例,士兵突击:
1.士兵许三多有一把AK47
2.士兵可以开火
3.枪能发射子弹
4.抢能装填子弹--增加子弹的数量
"""
print("!!!!士兵突击开始!!!!")


class Gun:
    def __init__(self, model):
        self.model = model
        # 抢子弹初始值为0
        self.bullet_count = 0

    def add_bullet(self, count):
        self.bullet_count += count
        print("增加子弹数[%d]" % count)

    def shoot(self):
        # 判断子弹数量
        if self.bullet_count <= 0:
            print("!!!没有子弹,赶紧补充")
            return
        # 发射子弹
        self.bullet_count -= 3
        # 提示发射信息
        print("[%s] 突 突 突 . . .!剩余子弹[%d]" % (self.model, self.bullet_count))


# 士兵类
class Soldier:
    def __init__(self, name):
        self.name = name
        # 不知道初始值可以设置为None
        self.gun = None

    def fire(self):
        # 判断是否有枪
        """身份运算符,比较两个对象内存地址是否一致。==是变量值比较
        is /is not: x is y或者x is not y
        if self.gun is None:(建议使用)
        """
        if self.gun == None:
            print("[%s]还没有枪!" % self.name)
            return
        # 高喊口号
        print("冲啊。。。。。[%s]" % self.name)
        # 装填子弹
        self.gun.add_bullet(50)
        # 发射子弹
        self.gun.shoot()


ak47 = Gun("AK47")
xsd = Soldier("许三多")  # 定义许三多对象
xsd.gun = ak47
xsd.fire()
print(xsd.gun)

  6.私有属性和私有方法

# -*-coding:utf-8-*-
"""
在实际开发中,对象的某些属性或方法,可能只希望在对象的内部使用,而不
希望在外部被访问到:
1.私有属性就是对象不希望公开的属性
2.私有方法就是对象不希望公开的方法
3.在定义私有属性或方法时,在属性名或者方法名前,增加两个下划线,定义的就是
  私有属性或者私有方法
"""


class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 18

    def secret(self):
        print("%s的年龄时 %d" % (self.name, self.__age))


xiaofang = Women("小芳")
#  print(xiaofang.__age)  # 报错,私有属性在外界不能访问
print(xiaofang._Women__age)  # 科普,python中没有完全的私有的属性,用这种方式同样可以访问
xiaofang.secret()  # 同样,私有方法类似

 

Python教程6

标签:特征   教程   比较   必须   自定义   引用   不能   参数设置   设置   

原文地址:https://www.cnblogs.com/jun1/p/9938690.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!