首页 > 编程语言 > 详细

Python——创建类和对象

时间:2018-09-14 00:33:34      阅读:77      评论:0      收藏:0      [点我收藏+]

标签:删除   elf   ron   知识   减肥   project   顺序   引用   示例   

####创建类和对象###

 

1.类的相关知识

   类有两种作用:属性应用和示例化

 

1)属性的引用(类名.属性)

   定义一个类 --> 里面定义一个属性(但是这个属性是写死在程序里的) --> 每一个引用这个属性的都是一样的内容

 

2)实例化:类名加括号就是实例化,会自动触发__init__函数的运行,可以用它来为每个实例定制自己的特有的属性

 

关于类里的方法括号中的self:

   self 在实例化时自动将对象/实例本身传给__init__的第一个参数

   self 也可以说是:哪一个对象调用这个方法,self就是哪一个对象的引用

 

在类封装的方法内部,self就表示当前调用方法的对象自己

--调用方法时,程序员不需要传递self参数(但是定义的时候,第一个参数必须是self)

--在方法内部:可以通过self.访问对象的属性

--在方法内部:可以通过self.调用其他的对象方法

 

示例:

class Cat:

    """这是class Cat的信息"""

    def eat(self):

        print ‘%s爱吃鱼‘ %self.name

    def drink(self):

        print ‘%s要喝水‘%self.name

 

# 创建猫对象

tom = Cat()

# 可以使用 .属性名 利用赋值语句就可以了

#tom.name = ‘Tom‘

tom.eat()

tom.name = ‘Tom‘

tom.drink()

print tom

 

# lazy_cat = Cat()

# lazy_cat.name = ‘miaomiao‘

# lazy_cat.eat()

# lazy_cat.drink()

 

 

2.内置方法

初始化方法:__init__是python对象的内置方法,在使用类名创建对象的时候自动被调用

__init__方法是专门用来定义一个类具有那些属性和方法的

 

##如果不用初始化方法,像一些基本属性可能在创建对象以后,还需要对象.属性,这样填写属性,还需要print手动去输出它,添加这个初始化方法,在创建方法之后会主动调用这个方法,将填写的信息添加并且输出

 

##当初始化方法没有形参变量的时候,方法内部所定义的属性,在利用该类创建对象的时候,创建的所有对象都会拥有该属性

 

##当初始化方法含有形参变量的时候,在利用该类创建对象的时候,创建的所有对象都会自动调用初始化方法,并且会要求添加相应的对象的属性,如果不添加就执行的话,编译器会报错

 

__del__方法:对象被从内存中销毁前,会自动调用

__str__方法:返回对象的描述信息 print 对象

__del__方法:在python中,当一个对象被从内存中销毁前(把这个对象从内存中删除掉),会自动调用__del__方法

 

应用场景:

__del__如果希望在对象被销毁前,再做一些事情,可以考虑一下__del__方法

 

__str__方法:在python中,使用python输出对象变量,默认情况下,会输出这个变量引用的对象是由哪>一个类创建的对象,以及在内存中的地址(十六进制表示).如果在开发中,希望使用print输出对象变量时,能够打印自定义的内容,就可以利用__str__这个内置方法了

 

示例:

1)

class Dog:

    def __init__(self,name,weight):

        self.name = ‘rourou‘

        self.weight = weight

        print ‘%s是一个%d斤的狗狗!‘%(self.name,self.weight)

    def eat(self):

        print ‘%s爱吃肉‘%self.name

    def drink(self):

        print ‘%s爱喝牛奶‘%self.name

 

rourou = Dog(‘rourou‘,10)

rourou.eat()

rourou.drink()

print rourou

 

2)

class Dog:

    def __init__(self,name,weight):

        self.name = name

        self.weight = weight

        print ‘%s是一个%d斤重的狗狗!‘%(self.name,self.weight)

    def __del__(self):

        print ‘内存信息被删除之前的调用!‘

    def __str__(self):

        return ‘我是肉肉!‘

 

dog = Dog(‘rourou‘,10)

print ‘=========‘

print dog

 

# tom是一个全局变量

# 所以当我们的代码全部执行完之后,系统才会把tom这个对象进行回收

tom = Cat(‘Tom‘)

print tom

# print tom.name

# # del关键字,可以从内存中删除一个对象,del关键字自己调用了__del__方法

# del tom

# print ‘*‘ * 50

 

 

生命周期

一个对象从调用类名()创建,声明周期开始

一个对象的__del__方法一旦被调用,生命周期就结束

在对象的生命周期内,可以访问对象的属性,调用对象的方法

 

 

3.私有属性和私有方法

 

1)私有属性和私有方法:在属性或方法前加两个下划线 ‘__‘,声明该方法是私有方法或者属性,不能在类的外部调用。在类的内部可以调用

私有属性 就是 对象 不希望公开的 属性

私有方法 就是 方法 不希望公开的 方法

2)应用场景及定义方式:

 

应用场景:

   在实际开发中,对象的某些属性或方法可能只希望在对象的内部使用,而不希望在外部被访问到

 

定义方法:

   在定义属性或方法时,在属性名或者方法名前增加两个下划线,定义的就是私有属性或方法

 

示例:

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.name

# 私有属性,外界不能直接访问

print lily.age

# 私有方法,外界不能直接调用

lily.__secret()

 

结果:

   会出现报错,显示没有这个属性,所以说,私有属性和方法,在类的外部不能被调用

 

lily

Traceback (most recent call last):

  File "/home/kiosk/PycharmProjects/王芳/day06/私有属性和私有方法.py", line 27, in <module>

    print lily.age

AttributeError: Women instance has no attribute ‘age‘

 

3)类的私有属性和私有方法

--子类对象不能在自己的方法内部,直接访问父类的私有属性和私有方法

--子类对象可以通过父类的公有方法间接访问到私有属性或私有方法

私有属性,私有方法是对象的隐私,不对外公开,外界以及子类都不能直接访问

私有属性,私有方法常用做一些内部的事情

 

示例:

 

class A:

    def __init__(self):

        # 在初始化方法中定义两个属性,一个公有属性一个私有属性

        self.num1 = 100     #公有属性

        self.__num2 = 200   #私有属性

 

    def __test(self):

        print ‘私有方法 %d %d‘ % (self.num1, self.__num2)

 

    ##如果要查看私有的属性和方法,可以在类A中定义一个公有方法,然后在公有方法中调用私有的方法和属性,再print就可以输出私有的属性和方法。再在子类直接调用这个公有方法就可以了

    def test(self):

        print ‘父类的共有方法 %d‘ % self.__num2

        self.__test()

 

class B(A):

    def demo(self):

        # # 在子类的对象方法中,不能访问父类的私有属性

        # print ‘访问父亲的私有属性 %d‘ % self.__num2

        # # 在子类对象的方法中,不能调用父类的私有方法

        # self.__test()

        #调用父类的共有方法

        self.test()

 

# 创建一个子类对象

b = B()

b.demo()

# b.test()

# 在外界不能直接访问对象有属性/调用私有方法

# print b.__num2的私

# b.__test()

 

 

4.面向对象的三大特征

(1)封装:根据职责将属性和方法封装到一个抽象的类中

(2)继承:实现代码的重用,相同的代码不需要重复的写

(3)多态

 

 

5.单继承

继承的概念:子类拥有父类的所有属性和方法

继承的语法

class 类名(父类):

    def 子类特有的方法

 

"""

Cat类是Animal类的子类,Animal类是Cat类的父类,Cat从Animal类继承

Cat类是Animal类的派生类,Animal类是Cat类的基类,Cat类从Animal类派生

"""

 

class Animal(object):

    def eat(self):

        print ‘吃‘

    def drink(self):

        print ‘喝‘

    def run(self):

        print ‘跑‘

    def sleep(self):

        print ‘睡‘

 

class Cat(Animal):

    # 子类拥有父类的所有属性和方法

    def call(self):

        print ‘喵喵‘

class Dog(Animal):

    def bark(self):

        print ‘旺旺‘

class Hellokitty(Cat):

    def speak(self):

        print ‘我可以说日语‘

 

# 创建一个猫对象

fentiao = Cat()

fentiao.eat()

fentiao.drink()

fentiao.run()

fentiao.sleep()

fentiao.call()

 

# 创建一个hellokitty对象

# kt = Hellokitty()

# kt.speak()

# kt.call()

 

# 继承的传递性,子类拥有父类的父类的属性和方法

 

"""

继承的传递性:(爷爷 父亲 儿子)

1.C类从B类继承,B类又从A类继承

2.那么C类就具有B类和A类的所有属性和方法

子类拥有父类以及父类的父类中封装的所有属性和方法

"""

 

kt.eat()

kt.drink()

kt.run()

kt.sleep()

 

# 子类继承自父类,可以直接享受父类中已经封装好的方法

# 子类中应该根据自己的职责,封装子类特有的属性和方法

 

 

6.多继承

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):

    """多继承可以让子类对象,同时具有多个父类的属性和方法"""

    """多继承(A,B)这个,如果两个父类的方法重名的话,哪个放在前面就继承哪个"""

    pass

 

# 创建子类对象

c = C()

c.test()

c.demo()

 

 

7.封装

 

(1)封装是面向对象编程的一大特点

(2)面向对象编程的第一步 将属性和方法封装到一个抽象的类中(为什么说是抽象的,因为类不能直接使用)

(3)外界使用类创建对象,然后让对象调用方法

(4)对象方法的细节都被封装在类的内部

 

示例:

 

小明爱跑步

1.小明体重75.0公斤

2.每次跑步会减肥0.5公斤

3每次吃东西体重会增加1公斤

4.小美的体重是45.0公斤

 

class Person:

    def __init__(self,name,weight):

        self.name = name

        self.weight = weight

    def __str__(self):

        return ‘我的名字叫 %s 体重是 %.2f‘ %(self.name,self.weight)

    def run(self):

        print ‘%s 爱跑步‘ %self.name

        # 在对象方法的内部,是可以直接访问对象的属性

        self.weight -= 0.5

    def eat(self):

        print ‘%s 吃东西‘ %self.name

        self.weight += 1

 

xx = Person(‘小明‘,75.0)

xx.run()

xx.eat()

print xx

 

# 同一个类创建出来的多个对象之间,属性互不干扰

xm = Person(‘小美‘,45.0)

xm.run()

xm.eat()

print xm

 

 

封装练习:

 

(1)需求

--房子有户型,总面积和家具名称列表

    新房子没有任何家具

--家具有名字和占地面积,其中

    床:占4平米

    衣柜:占2平米

    餐桌:占1.5平米

--将以上三件家具添加到房子中

--打印房子时,要求输出:户型,总面积,剩余面积,家具名称列表

 

被使用的类应该先开发

就比如:先要将家具定义出来,然后才能往房子里面加

 

# 创建家具类

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)

print bed

chest = HouseItem(‘chest‘, 2)

print chest

table = HouseItem(‘table‘, 1.5)

print table

 

 

# 创建房子类

class House:

    def __init__(self, house_type, area):

        # 下面为从外界传递进来的参数

        self.house_type = house_type

        self.area = area

        # 剩余面积不需要从外面传递,内部计算

        # 剩余面积 = 总面积 - 家具面积

        # 新房子内没有任何家具,剩余面积=总面积

        self.free = area

        self.item_list = []

 

    def __str__(self):

        return ‘户型:%s\n总面积:%.2f[剩余面积:%.2f]\n家具:%s‘ \

               % (self.house_type, self.area, self.free, self.item_list)

 

    def add_item(self, item):

        if item.area >= self.area:

            print ‘请重新订购家具‘

        else:

            print ‘添加成功‘

            self.item_list.append(item.name)

            self.free -= item.area

 

 

# 创建房子

house = House(‘两室一厅‘, 100)

house.add_item(bed)

house.add_item(chest)

house.add_item(table)

print house

 

(2)需求:

--士兵瑞恩有一把AK47

--士兵可以开火(士兵开火扣动的是扳机)

--枪 能够 发射子弹(把子弹发射出去)

--枪 能够 装填子弹  --增加子弹数量

 

class Gun:

    def __init__(self, name):

        # 自己输入枪的型号

        self.name = name

        # 假设默认的子弹数是10个

        self.count = 10

        self.free = self.count

 

    def add_zidan(self, num):

        if num + self.free > 10:

            print ‘子弹数超过10颗!装子弹失败‘

        else:

            self.free += num

            print ‘子弹添加成功!‘

 

    def shoot(self):

        if self.free <= 0:

            print ‘没有子弹了!‘

        else:

            self.free -= 1

            print ‘开火ing...‘

 

class Person:

    def __init__(self,name):

        self.name = name

        self.gun = None

 

    def fire(self):

        if self.gun == None:

            print ‘还没有枪‘

            return

        print ‘go!‘

        self.gun.shoot()

        self.gun.add_zidan(1)

 

ak47 = Gun(‘AK47‘)

ren = Person(‘ryan‘)

#人使用枪

ren.gun = ak47

ren.fire()

print ren

 

 

8.重写父类方法

 

(1).覆盖父类的方法

(2).扩展父类的方法

 

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 ‘话~~‘

        # 调用原本在父类中封装的代码

        Cat.call(self)

        # 增加其他的子类代码

        print ‘#!@$@!#!#‘

kt = Hellokitty()

# 如果子类中,重写了父类的方法

# 在运行中,只会调用在子类中重写的父类的方法而不会调用父类的方法

kt.call()

 

重写的练习:

--在写好的代码Bird类的上面,加入一个唱歌的属性(要增加到默认属性当中)

class Bird:

    def __init__(self):

        self.hungry = True

    def eat(self):

       # 如果吃过了就不饿了

        if self.hungry:

            print ‘吃东西ing。。。‘

            self.hungry = False

        else:

            print ‘No,thanks!‘

 

错误代码:

class songBird(Bird):

    def __init__(self):

        self.sound = ‘squawk!‘

    def sing(self):

        print self.sound

 

lb = songBird()

lb.eat()

lb.sing()

print lb

 

##这就相当于是songBird的初始化方法将原本的代码的初始化方法覆盖了,因此就没有了 self.hungry = True 这行代码,因此下面的判断就不能够执行下去

 

##正确的代码应该是,继承了父类,重写并且调用父类的被重写的方法,这样就相当于是在不更改源代码的同时,增加了默认的属性

 

正确代码:

class songBird(Bird):

    def __init__(self):

        self.sound = ‘squawk!‘

        Bird.__init__(self)   ##这条语句就是调用父类的方法

    def sing(self):

        print self.sound

 

lb = songBird()

lb.eat()

lb.sing()

print lb

 

 

9.新式类和旧式(经典)类

   object是Python为所有对象提供的基类,提供有一些内置的属性和方法,可以使用dir函数查看

 

   新式类:以object为基类的类,推荐使用

   经典类:不以object为基类的类,不推荐使用

   python3.X中定义的类时,如果没有指定父类,会默认使用object作为基类--python3.x中定义的类都是新式类

   python2.x中定义类时,如果没有指定父类,则不会以object作为基类

 

####推荐使用新式类#############

 

新式类和旧式类在多继承时---会影响到方法的搜索顺序

 

为保证编写的代码能够同时在python2.x和python3.x运行

今后在定义类时,如果没有父类,建议统一继承自object

 

 

10.综合练习

 

图书管理系统

    图书管理系统

        1.查询

        2.增加

        3.借阅

        4.归还

        5.退出

Python——创建类和对象

标签:删除   elf   ron   知识   减肥   project   顺序   引用   示例   

原文:https://www.cnblogs.com/wf-aiyouwei/p/9644022.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号