Python中oop（面向对象介绍）及练习题

一、面向过程面向对象(oop:object oriented programming)

面向过程：—侧重于怎么做？
1.把完成某一个需求的所有步骤从头到尾逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤和过程，不注重职责分工
2.如果需求复杂，代码变得非常复杂
3.开发复杂的项目的时候，没有固定的套路，开发难度很大
面向对象：----侧重于谁来做？
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责–要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路
3.需要在面向过程的基础上，再学习一些面向对象的语法

面向对象有两个核心的概念

类:是一群具有相同特征或行为的事物的一个统称(类是抽象的，不能直接使用)
对象:由类创造出来的具体存在

类和对象的关系

类是模板,对象是根据这个模板创建出来的
类只需要一个对象可以由多个
类：属性(信息)和方法(你能完成的动作)
1.类名：这类事物的名字（满足大驼峰命名法）
大驼峰命名法：
1.每个单词的首字母大写
2.单词与单词之间没有下划线
2.属性：这个类创建出来的对象有什么特征
3.方法：这个类创建出来的对象有什么行为
类名的确定
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类
属性和方法的确定
对对象的特征描述，通常可以定义成属性
对象具有的行为(动词)，通常可以定义为方法
提示：需求中没有涉及的属性或方法在设计类时，不需要考虑

class Student():
    name = ''       ##变量：数据成员
    age = 0
def print_file(self):
        print('name:' + self.name)
        print('age:' + str(self.age))

student = Student()
student.print_file()

运行结果为：
name:
age:0

#猫爱吃鱼，猫要喝水

class Cat():
    def eat(self,name):
         self.name = name
         print('%s爱吃鱼' %self.name)
    def drink(self):
         print('猫要喝水')
##创建猫对象
tom = Cat()
tom.name = 'Tom'
print(tom)

self:
哪一个对象调用的方法，self就是哪一个对象的引用
在封装的方法内部，self就表示当前调用方法的对象自己
在调用方法时，程序员不需要传递self参数(但是定义的式时候，第一个参数
必须是self)

可以使用 .属性名利用赋值语句就可以在类的外部给对象增加属性(不推荐)
将对象的属性封装在类中

构造函数

class Student():
    name = ''
    age = 0
  def __init__(self,name,age):
        #构造函数
        self.name = name
        self.age = age
        print('student')
       
  def do_homework(self):
        print('homework')

student1 = Student('老李',38)
print(student1.name)
print(student1.age)

运行结果为：
student
老李
38

str方法

class Dog():

  def __init__(self,name):
        self.name = name

  def __str__(self):
        #必须返回一个字符串
        return '这是 %s' %(self.name)

Gofei = Dog('旺财')
print(Gofei)
运行结果为：

这是 旺财

栈练习

class Stack():

    def __init__(self):
        self.stack = []

    def push(self,value):
        self.stack.append(value)
        return True

    def pop(self):
        #先判断栈是否为空
        if self.stack:
            item = self.stack.pop()
            return item
        else:
            return False

    def top(self):
        if self.stack:
            return self.stack[-1]
        else:
            return False

    def length(self):
        return len(self.stack)

    def view(self):
        return ','.join(self.stack)

s = Stack()
s.push('1')
s.push('2')
item = s.pop()
print(s.view())

二、初始化方法：

类名() 就可以创建一个对象
类名()创建对象的时候，python的解释器会自动执行以下操作
1.为对象在内存中分配空间—创建对象
2.调用初始化方法为对象的属性设置初始值 --初始化方法(init)
这个初始化方法是内置方法，是专门用来定义一个类具有哪些属性的方法

class Cat():
    def __init__(self,new_name):
        #print('这是一个初始化方法')
        self.name = new_name
   # self.name 在类中的任何方法中都可以使用
    def eat(self):
        print('%s 爱吃鱼' %(self.name))
        #print('eating~~~')
    def drink(self):
        print('%s 要喝水' %(self.name))
使用类名()创建对象的时候，会自动调用初始化方法__init__
hello_kitty = Cat('hk')
hello_kitty.eat()
hello_kitty.drink()
fentiao = Cat('fentiao')
fentiao.eat()
fentiao.drink()

如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造
1.把希望设置的属性值，定义成__init__方法的参数
2.在方法内部使用self.属性名 = 形参接收外部传递的参数
3.在创建对象的时候，使用类名(属性)调用

三、三种方法
1.__del__方法：
2.__str__方法：
3._del__方法：

在python中
当使用类名()创建对象时，为对象分配完空间后，自动调用__init__方法
当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用__del__方法
应用场景
__init__改造初始化方法，可以让创建对象更加灵活
__del__如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法

class Cat:
    def __init__(self,name):
        self.name = name
        print('%s 来了' %(self.name))
    def __del__(self):
        print('%s 走了' %(self.name))

tom = Cat('tom')
print(tom.name)
del tom
print('*' *50)
print(tom.name)

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

class Cat:
    def __init__(self,name):
        self.name = name
    # def __str__(self):
    #     #必须返回一个字符串
    #     return '我是 %s ' %(self.name)
tom = Cat('tom')
print(tom)
addr = id(tom)
print(addr)
print('%x' %(addr))
print('%d' %(addr))
#fentiao = Cat('fentiao')
#print(fentiao)

练习一
需求：
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具

2.家具有名字和占地面积，其中
床：占4平米
衣柜：占2平米
餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表

class Furniture():

   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):
        #1.判断家具的面积
        if item.area > self.free_area:
            print('%s 的面积太大，无法添加' %item.name)

   #2.添加家具
        self.item_list.append(item.name)

   #3.计算剩余面积
        self.free_area -= item.area

bed = Furniture('bed',4)
print(bed)
yigui = Furniture('yigui',200)
print(yigui)
table = Furniture('table',1.5)
print(table)

my_house = House('独门独栋',400)

my_house.add_item(bed)
my_house.add_item(yigui)
my_house.add_item(table)
print(my_house)

练习二
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪能够发射子弹(把子弹发射出去)
4.枪能够装填子弹 --增加子弹的数量
Soldier Gun

name model
gun bullet_count #子弹数量足够多才能完
成射击的动作

init(self): init(self):
fire(self): add_bullet(self,count):#装填子弹的
方法
shoot(self):

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 ... %s' %(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)

  self.gun.add_bullet(5)
  self.gun.shoot()


ak47 = Gun('ak47')
ak47.add_bullet(20)
ak47.shoot()

ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()

Python中oop（面向对象介绍）及练习题

猜你喜欢