本文介绍了Python的面向对象编程基础，包括面向对象的思想，类和对象的概念、定义与区分，以及初始化方法`__init__()`的使用。讲解了如何创建对象、添加属性，还探讨了`__del__()`方法、特殊方法（魔方方法）以及方法的重写。通过实例展示了类的应用，如喂鸟和烤地瓜，同时也提到了单继承的基本概念。
一、面向对象基础
1.面向对象的思想
思考题目
比如我们班级里面每来一个学生,首先到前台报到登记,然后到班里做自我介绍?
如何用程序描述这个过程?
例如:
A同学到前台登记个人信息
A同学到班里做自我介绍
B同学到前台登记个人信息
B同学到班里做自我介绍
C同学到前台登记个人信息
C同学到班里做自我介绍
这时候我们进行的编程是利用字典遍历来进行实现
stu_info = {'name': '张三', 'age': '18'}
stu_info2 = {'name': '李四', 'age': '19'}
stu_info3 = {'name': '王五', 'age': '17'}
#定义一个函数获取学生的信息
def get_stu_info(stu):
#遍历字典获取学生具体信息
for key,value in stu.items():
#注意我们需要key和value的类型
print('key=%s,value=%s'%(key,value))
#调用函数
get_stu_info(stu_info)
打印结果
二、类和对象
2.1类和对象的定义
类
定义：
类--》抽象的概念 在使用的时候通常会找到这个类的具体的存在----》对象
特点：
一个类可以找到多个对象
对象
概述：
某一个具体事物的存在，在现实世界中可以看得见摸得着
例如:
一台电脑,一个水杯,一张桌子
总结（就像是：类是对象在某一方面具有共同特征的集合）
类和对象之间的关系：
就像利用玩具模型来创建多种不同的玩具
类就是创建对象的模板
2.2类和对象的区分示例
奔驰汽车 类
奔驰smart 类
张三开的那辆奔驰smart 对象
水果 类
香蕉 类
李四吃了一半的那个苹果 对象
狗 类
大黄狗 类
王五正在牵着的那只大黄狗 对象
2.3类的构成
类（class）：由3部分组成
类的名称：类名
类的属性：一组数据
类的方法：允许对其操作的方法（行为）
#设计一个人类
类名: People
属性: 身高 体重 年龄 性别
行为(方法):吃饭 睡觉
#设计一个狗类
类名:Dog
属性:身高 体重 毛色 品种 腿的数量
方法:跑 叫 啃骨头 摇尾巴
#设计一个猫类
类名:Cat
属性:身高 体重 毛色 品种 腿的数量
方法:跑 叫 吃鱼 猫抓人
2.4类的抽象
一般名词提炼法
例如：
1.坦克发射了3颗炮弹炸掉了2架飞机
坦克---->抽象成类
炮弹---->抽象成类
飞机---->抽象成类
2.小明在公车上牵了一条叼着热狗的狗
小明----->抽象出人类
公交车---->交通工具类
热狗------>食物类
狗-------->狗类
3.植物大战僵尸
豌豆------>抽象成类
类名:Wandou
属性:发型,颜色
行为:发射炮弹
向日葵---->抽象成类
类名:Xrk
属性:颜色,大小
行为:产生阳光
僵尸----->抽象成类
类名:Js
属性:颜色
行为:走 啃植物 跑
2.5定义类
class Cat: #class Cat（object）：
#属性:品种,毛色,腿的数量
#方法:吃老鼠 叫 抓人
def eat(self):
print('猫吃老鼠')
def drink(self):
print('猫喝芬达...')
class Car(object):
#属性:颜色,四个轮子
#行为:跑,鸣笛
def move(self):
print('车子在移动')
def whistle(self):
print('车子在鸣笛')
2.6创建对象
先定义完类之后，用一个字母来代指类中的具体对象
python中，可以根据已经定义好的类来创建对象
创建对象的格式：
对象名 = 类名()
#创建一个汽车类
class Car(object):
#属性:颜色,四个轮子
#方法:跑 鸣笛
#定义一个普通(实例)方法
def move(self):
print('车子正在移动...')
#定义一个普通(实例)方法
def whistle(self):
print('车子正在鸣笛')
#创建一个Car的实例对象c 赋给一个变量
c = Car()
#调用对象指向的方法
#调用格式:对象名.方法
c.move()
c.whistle()
"""
总结:
通过c = Car()就产生了一个实例对象
当创建对象的时候,对象自动拥有方法,对象就可以直接调用方法(属性也一样)
"""
2.7 给对象添加属性和获取属性
#定义一个人类
class Person(object):
#属性:身高,体重,年龄
#行为:吃饭 睡觉 喝水
#定义一个普通方法
def eat(self):
print('人都要吃饭')
#定义一个普通方法
def sleep(self):
print('人都要休息')
#通过Person创建一个实例对象p
p = Person()
#添加属性
#语法格式:对象名.属性名 = 新的值
p.name = '张三'
p.age = 20
#获取属性
print(p.name)
print(p.age)
#对象调用方法
p.eat()
p.sleep()
#通过Person创建一个对象p2
p2 = Person()
#添加属性
p2.name = '李四'
p2.age = 30
p2.sex = '男'
#获取属性
print(p2.name,p2.age,p2.sex)
三、init（）方法（初始化方法）
init()方法：
3.1使用方法
class 类名：
#初始化方法，用来完成一些默认的设置
def __init__(self):
函数体语句
3.2init方法调用
我们想修改属性的时候，可以直接修改 对象名.属性名 = 新值
例如
www = Car('蓝色',6)
www.color = '灰色'
www.wheelNum = 4
print('车子的颜色是:%s,车子有%d个轮子'%(www.color,www.wheelNum))
打印结果
#定义一个汽车类
class Car(object):
#定义初始化方法,当创建对象时候自动调用
def __init__(self,color,wheelNum):
# self.color = '黑色'
# self.wheelNum = 4
self.color = color
self.wheelNum = wheelNum
#定义一个普通方法
def move(self):
print('车子在移动')
#定义一个普通方法
def whistle(self):
print('车子在鸣笛')
#创建一个对象bmw
bmw = Car('红色',4)
#调用类里面普通方法
# bmw.move()
# bmw.whistle()
#1.直接修改 对象名.属性名 = 新值
print('车子的颜色是:%s,车子有%d个轮子'%(bmw.color,bmw.wheelNum))
#创建一个对象www
www = Car('蓝色',6)
# www.color = '灰色'
# www.wheelNum = 4
print('车子的颜色是:%s,车子有%d个轮子'%(www.color,www.wheelNum))
#创建对象aodi
audo = Car('绿色',4)
print('车子的颜色是:%s,车子有%d个轮子'%(audo.color,audo.wheelNum))
总结
当实例化类得到具体对象的时候,会自动调用__init__()方法,对类的属性进行初始化赋值
创建对象的时候,自动拥有类里面属性
3.3del（）方法（析构方法）
创建对象后，python解释器默认调用__init__()
当删除一个对象的时候，python解释器也会默认调用__del__()
创建对象后，python解释器默认调用__init__()
当删除一个对象的时候，python解释器也会默认调用__del__()
#定义一个动物类
import time
#定义一个动物类
class Animal(object):
#定义初始化方法 创建对象时候自动调用
def __init__(self,name):
# print('__init__方法被调用')
self.name = name
#定义普通方法
def walk(self):
print('动物会跑')
#定义一个析构方法 删除对象的时候自动调用
def __del__(self):
# print('__del__方法被调用')
print('%s对象被干掉'%(self.name))
#创建一个dog对象
dog = Animal('哈皮狗')
dog.walk()
# del dog
print(dog.walk())
#创建一个cat对象
cat = Animal('波斯猫')
cat2 = cat
cat3 = cat
print('删除对象1')
del cat
print('删除对象2')
del cat2
print('删除对象3')
del cat3
time.sleep(2)
print('cat对象被删除')
输出结果
3.4魔方方法（基本用不到）
定义： 魔方方法：
特殊方法：是指被包含下划线的方法或者所能调用到的方法的统称，这些通常会在特殊的情况下调用，并且基本没有手动调用他们的必要。
3.5重写一般方法和重写特殊的构造方法
3.5.1
#声明一个父类
class A(object):
#声明一个普通方法
def sayHello(self):
print('我是A')
#声明一个子类B
class B(A): #B类后面圆括号里面继承的父类名字
#声明一个普通方法
# def sayHello(self):
# print('我是B')
pass
#实例化A类创建对象a
a = A()
a.sayHello()
#实例化B类创建对象b
b = B()
b.sayHello()
打印结果
**总结：**意思大概就是如果声明的子类中如果没用声明一个普通方法，则会去执行父类中的普通方法。
3.5.2 喂鸟
class Bird(object):
#定义一个初始化方法
def __init__(self):
self.hungry = True #默认鸟饿了
#定义一个普通方法
def eat(self):
if self.hungry:
print('该喂食了')
self.hungry = False
else:
print('已经吃饱了,不能再吃了')
#实例化一个对象b
b = Bird()
b.eat()
b.eat()
打印结果
**总结：**首先创建一个鸟类，然后初始化让鸟是饿的。接着定义喂鸟的方法，如果饿了，就喂食并且给饿了一个否定。如果继续打印，再在else中返回吃饱了的字样。
3.6 self
class Animal(object):
#定义一个初始化方法
def __init__(self,name):
self.name = name
#定义一个普通方法
def printName(self):
print('动物的名字是:%s'%self.name)#self=dog
dog=Animal('dog')
dog.printName()
3.7应用-烤地瓜
class SweetPotato(object):
#定义初始化方法 创建对象对属性初始化赋值
def __init__(self):
self.cookLevel = 0 #生的
self.cookString = '生的'
self.condiments = []
#定义一个烤地瓜方法
def cook(self,time):
self.cookLevel += time
if 0 < self.cookLevel <= 3:
self.cookString = '生的'
elif 3< self.cookLevel <= 5:
self.cookString = '半生不熟'
elif 5< self.cookLevel <= 8:
self.cookString = '烤熟了'
elif self.cookLevel > 8:
self.cookString = '烤糊了'
else:
self.cookString = '生的'
#定义一个添加佐料的方法
def addCondiment(self,condiment):
self.condiments.append(condiment)
#创建一个对象s
s = SweetPotato()
# print(s.cookLevel)
# print(s.cookString)
# print(s.condiments)
#调用烤地瓜方法
print('开始测试烤地瓜')
s.cook(4)
print(s.cookLevel)
print(s.cookString)
print(s.condiments)
s.cook(4)
print(s.cookLevel)
print(s.cookString)
print(s.condiments)
#添加佐料
s.addCondiment('芥末')
s.addCondiment('蜂蜜')
print(s.cookLevel)
print(s.cookString)
print(s.condiments)
打印结果
**总结：**首先我们要先确定我们应用中有几个需要表示出来的东西。比如烤的时间、生熟度，生熟度我们又要继续往下根据烤的时间细分。然后还要考虑添加作料，这时候就需要定义一个列表把它放进去
3.8访问限制（很深奥，以后在系统学）
#定义一个人类
class Person(object):
#定义一个初始化方法
def __init__(self,name,money):
self.__name = name
self._money = money
#定义普通方法对属性设置
def setName(self,value):
#数据过滤
if len(value) <= 4:
self.__name = value
else:
print('名称的长度不能大于4个字符')
#定义普通方法获取属性值
def getName(self):
return self.__name
#定义私有方法
def __sayHello(self):
print('我的名字是:%s,我有%s存款'%(self.__name,self._money))
#定义公有方法获取私有属性
def test(self):
self.__sayHello()
#创建一个对象p
p = Person('张三','99999999')
#对象访问属性
#语法格式:对象名.属性名
# print(p.name) #完全公开 公有属性 可以在任何地方访问
#直接修改:对象名.属性名
# p.__name = '刘德华' #私有属性不能通过对象直接修改
# print(p.getName())
# print(p.__name) #私有属性不能通过对象访问,只能在类的方法里面使用
#print(p._money) #半公开 受保护的可以通过对象访问 但是不建议这样使用
#调用公有的方法 获取私有受保护属性值
# p.__sayHello() #不能通过对象访问私有的方法
# p.test()
#调用方法修改属性 间接修改 对象名.方法名
# p.setName('张飞')
# print(p.getName())
"""
如何区分:私有,受保护,公有属性
__双下划线后面跟属性名--->私有属性 只能在当前类里面使用
_单下划线后面跟属性名--->半公开 受保护属性 可以在当前类和子类里面使用
直接属性名 ---->完全公开 公有属性 在当前类里面 子类 实例化类对象都能访问
方法的设置和属性一样
"""
"""
私有属性为什么不能在类外访问?
__name python解释器将它转换成_Person__name
可以通过_Person__name访问,但是不建议这样做
"""
# p._Person__name = '李淑芬'
# print(p.getName())
#特殊属性__xxx__ 可以直接访问 相当于公有属性
#相当于添加一个特殊的属性
# p.__name__ = '李香兰'
# print(p.__name__)
3.9单继承
#定义一个猫类，设置姓名和颜色属性
class Cat(object):
#定义初始化方法
def __init__(self,name,color):
self.name = name
self.color = color
#定义一个普通方法
def eat(self):
print('猫喜欢吃老鼠')
#定义子类Bosi继承父类Cat
class Bosi(Cat):
#定义初始化方法
def __init__(self,type,num):
self.type = type
self.num = num
#子类重写父类同名的方法
def eat(self):
print('猫喜欢吃鱼')
#创建一个对象bo
# bo = Bosi('波斯猫',4)
# bo.eat()
打印结果
猫喜欢吃鱼
**总结：**如果在子类中定义与分类重名的方法，会执行子类的方法
扫一扫
1535
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
