本教程的知识点为：计算机组成 计算机是由什么组成的？ 1. 硬件系统： 2. 软件系统： 目标 运算符的分类 1. 算数运算符 2. 赋值运算符 3. 复合赋值运算符 判断语句和循环语句 if嵌套 1. if嵌套的格式 2. if嵌套的应用 if嵌套执行流程 容器：字符串、列表、元组、字典 字符串介绍 一. 认识字符串 1.1 字符串特征 字符串输出 容器：字符串、列表、元组、字典 列表的相关操作 1添加元素("增"append, extend, insert)1 append extend 容器：字符串、列表、元组、字典 字典的常见操作1 1查看元素1 2修改元素2 3添加元素3 函数介绍 1什么是函数1 小总结: 函数定义和调用 1定义函数1 多函数程序的基本使用流程 1. 使用全局变量 2. 使用函数的返回值、参数 3. 函数嵌套调用 函数返回值(二) 函数应用：学生管理系统 递归函数 1什么是递归函数1 2递归函数的作用2 看阶乘的规律 文件操作介绍 1什么是文件1 2文件的作用2 文件的打开与关闭 1打开文件1 面向对象编程介绍 面向对象 1. 概述 2. 生活举例 类和对象 init()方法 说明： 问题： 有参数的__init__()方法 说明： 继承介绍以及单继承 1. 现实中的继承 2. 程序中的继承 单继承：子类只继承一个父类 说明： super()的使用 问题： 知识点： 私有权限 面向对象三大特性：封装、继承、多态 静态方法和类方法 1. 类方法 2. 静态方法 总结 异常 模块 1Python中的模块1 2import2 3from…import3 注意
完整笔记资料代码：https://gitee.com/yinuo112/Backend/tree/master/Python/嘿马python基础入门全体系教程/note.md
感兴趣的小伙伴可以自取哦~
全套教程部分目录：
部分文件图片：
init()方法
在Python中，xx()的函数叫做魔法方法，指的是具有特殊功能的函数。
__init__()方法的作用：初始化对象。
class Hero(object):
"""定义了一个英雄类，可以移动和"""
# Python 的类里提供的，两个下划线开始，两个下划线结束的方法，就是魔法方法，__init__()就是一个魔法方法，通常用来做属性初始化 或 赋值 操作。
# 如果类面没有写__init__方法，Python会自动创建，但是不执行任何操作，
# 如果为了能够在完成自己想要的功能，可以自己定义__init__方法，
# 所以一个类里无论自己是否编写__init__方法 一定有__init__方法。
def __init__(self):
""" 方法，用来做变量初始化 或 赋值 操作，在类实例化对象的时候，会被自动调用"""
self.name = "泰达米尔" # 姓名
self.hp = 2600 # 生命值
self.atk = 450 # 力
self.armor = 200 # 护甲值
def move(self):
"""实例方法"""
print("正在前往事发地点...")
def attack(self):
"""实例方法"""
print("发出了一招强力的普通...")
# 实例化了一个英雄对象，并自动调用__init__()方法
taidamier = Hero()
# 通过.成员选择运算符，获取对象的实例方法
taidamier.info() # 只需要调用实例方法info()，即可获取英雄的属性
taidamier.move()
taidamier.attack()
说明：
__init__()方法，在创建一个对象时默认被调用，不需要手动调用__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。
问题：
在类的方法里定义属性的固定值，则每个对象实例变量的属性值都是相同的。
一个游戏里往往有很多不同的英雄，能否让实例化的每个对象，都有不同的属性值呢？
有参数的__init__()方法
class Hero(object):
"""定义了一个英雄类，可以移动和"""
def __init__(self, name, skill, hp, atk, armor):
""" __init__() 方法，用来做变量初始化 或 赋值 操作"""
# 英雄名
self.name = name
# 技能
self.skill = skill
# 生命值：
self.hp = hp
# 力
self.atk = atk
# 护甲值
self.armor = armor
def move(self):
"""实例方法"""
print("%s 正在前往事发地点..." % self.name)
def attack(self):
"""实例方法"""
print("发出了一招强力的%s..." % self.skill)
def info(self):
print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
print("英雄 %s 的力 :%d" % (self.name, self.atk))
print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))
# 实例化英雄对象时，参数会传递到对象的__init__()方法里
taidamier = Hero("泰达米尔", "旋风斩", 2600, 450, 200)
gailun = Hero("盖伦", "大宝剑", 4200, 260, 400)
# print(gailun)
# print(taidamier)
# 不同对象的属性值的单独保存
print(id(taidamier.name))
print(id(gailun.name))
# 同一个类的不同对象，实例方法共享
print(id(taidamier.move()))
print(id(gailun.move()))
说明：
-
通过一个类，可以创建多个对象，就好比 通过一个模具创建多个实体一样
-
__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)
注意：
- 在类内部获取 属性 和 实例方法，通过self获取；
-
在类外部获取 属性 和 实例方法，通过对象名获取。
-
如果一个类有多个对象，每个对象的属性是各自保存的，都有各自独立的地址；
-
但是实例方法是所有对象共享的，只占用一份内存空间。类会通过self来判断是哪个对象调用了实例方法。
str()方法
当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了str方法，那么就会打印从在这个方法中 return 的数据。
class Hero(object):
"""定义了一个英雄类，可以移动和"""
def __init__(self, name, skill, hp, atk, armor):
""" __init__() 方法，用来做变量初始化 或 赋值 操作"""
# 英雄名
self.name = name # 实例变量
# 技能
self.skill = skill
# 生命值：
self.hp = hp # 实例变量
# 力
self.atk = atk
# 护甲值
self.armor = armor
def move(self):
"""实例方法"""
print("%s 正在前往事发地点..." % self.name)
def attack(self):
"""实例方法"""
print("发出了一招强力的%s..." % self.skill)
# def info(self):
# print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
# print("英雄 %s 的力 :%d" % (self.name, self.atk))
# print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))
def __str__(self):
"""
这个方法是一个魔法方法 (Magic Method) ，用来显示信息
该方法需要 return 一个数据，并且只有self一个参数，当在类的外部 print(对象) 则打印这个数据
"""
return "英雄 <%s> 数据： 生命值 %d, 力 %d, 护甲值 %d" % (self.name, self.hp, self.atk, self.armor)
taidamier = Hero("泰达米尔", "旋风斩", 2600, 450, 200)
gailun = Hero("盖伦", "大宝剑", 4200, 260, 400)
# 如果没有__str__ 则默认打印 对象在内存的地址。
# 当类的实例化对象 拥有 __str__ 方法后，那么打印对象则打印 __str__ 的返回值。
print(taidamier)
print(gailun)
# 查看类的文档说明，也就是类的注释
print(Hero.__doc__)
说明：
- 在python中方法名如果是
__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法 - 当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了
__str__(self)方法，那么就会打印从在这个方法中return的数据 __str__方法通常返回一个字符串，作为这个对象的描述信息
__del__()方法
创建对象后，python解释器默认调用__init__()方法；
当删除对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法
class Hero(object):
# 初始化方法
# 创建完对象后会自动被调用
def __init__(self, name):
print('__init__方法被调用')
self.name = name
# 当对象被删除时，会自动被调用
def __del__(self):
print("__del__方法被调用")
print("%s 被 GM 干掉了..." % self.name)
# 创建对象
taidamier = Hero("泰达米尔")
# 删除对象
print("%d 被删除1次" % id(taidamier))
del(taidamier)
print("--" * 10)
gailun = Hero("盖伦")
gailun1 = gailun
gailun2 = gailun
print("%d 被删除1次" % id(gailun))
del(gailun)
print("%d 被删除1次" % id(gailun1))
del(gailun1)
print("%d 被删除1次" % id(gailun2))
del(gailun2)
总结
-
当有变量保存了一个对象的引用时，此对象的引用计数就会加1；
-
当使用del() 删除变量指向的对象时，则会减少对象的引用计数。如果对象的引用计数不为1，那么会让这个对象的引用计数减1，当对象的引用计数为0的时候，则对象才会被真正删除（内存被回收）。
应用:烤地瓜
为了更好的理解面向对象编程，下面以“烤地瓜”为案例，进行分析
1.分析“烤地瓜”的属性和方法
示例属性如下:
- cookedLevel : 这是数字；0~3表示还是生的，超过3表示半生不熟，超过5表示已经烤好了，超过8表示已经烤成木炭了！我们的地瓜开始时时生的
- cookedString : 这是字符串；描述地瓜的生熟程度
- condiments : 这是地瓜的配料列表，比如番茄酱、芥末酱等
示例方法如下:
cook(): 把地瓜烤一段时间addCondiments(): 给地瓜添加配料__init__(): 设置默认的属性__str__(): 让print的结果看起来更好一些
2. 定义类，并且定义__init__()方法
#定义`地瓜`类
class SweetPotato:
"""这是烤地瓜的类"""
#定义初始化方法
def __init__(self):
self.cookedLevel = 0
self.cookedString = "生的"
self.condiments = []
3. 添加"烤地瓜"方法
#烤地瓜方法
def cook(self, time):
self.cookedLevel += time
if self.cookedLevel > 8:
self.cookedString = "烤成灰了"
elif self.cookedLevel > 5:
self.cookedString = "烤好了"
elif self.cookedLevel > 3:
self.cookedString = "半生不熟"
else:
self.cookedString = "生的"
4. 基本的功能已经有了一部分，赶紧测试一下
把上面2块代码合并为一个程序后，在代码的下面添加以下代码进行测试
mySweetPotato = SweetPotato()
print(mySweetPotato.cookedLevel)
print(mySweetPotato.cookedString)
print(mySweetPotato.condiments)
完整的代码为:
class SweetPotato:
"""这是烤地瓜的类"""
# 定义初始化方法
def __init__(self):
self.cookedLevel = 0
self.cookedString = "生的"
self.condiments = []
# 烤地瓜方法
def cook(self, time):
self.cookedLevel += time
if self.cookedLevel > 8:
self.cookedString = "烤成灰了"
elif self.cookedLevel > 5:
self.cookedString = "烤好了"
elif self.cookedLevel > 3:
self.cookedString = "半生不熟"
else:
self.cookedString = "生的"
# 用来进行测试
mySweetPotato = SweetPotato()
print(mySweetPotato.cookedLevel)
print(mySweetPotato.cookedString)
print(mySweetPotato.condiments)
5. 测试cook方法是否好用
在上面的代码最后面添加如下代码:
print("------接下来要进行烤地瓜了-----")
mySweetPotato.cook(4) #烤4分钟
print(mySweetPotato.cookedLevel)
print(mySweetPotato.cookedString)
6. 定义addCondiments()方法和__str__()方法
def __str__(self):
msg = self.cookedString + " 地瓜"
if len(self.condiments) > 0:
msg = msg + "("
for temp in self.condiments:
msg = msg + temp + ", "
msg = msg.strip(", ")
msg = msg + ")"
return msg
def addCondiments(self, condiments):
self.condiments.append(condiments)
7. 再次测试
完整的代码如下:
class SweetPotato:
"""这是烤地瓜的类"""
# 定义初始化方法
def __init__(self):
self.cookedLevel = 0
self.cookedString = "生的"
self.condiments = []
# 定制print时的显示内容
def __str__(self):
msg = self.cookedString + " 地瓜"
if len(self.condiments) > 0:
msg = msg + "("
for temp in self.condiments:
msg = msg + temp + ", "
msg = msg.strip(", ")
msg = msg + ")"
return msg
# 烤地瓜方法
def cook(self, time):
self.cookedLevel += time
if self.cookedLevel > 8:
self.cookedString = "烤成灰了"
elif self.cookedLevel > 5:
self.cookedString = "烤好了"
elif self.cookedLevel > 3:
self.cookedString = "半生不熟"
else:
self.cookedString = "生的"
# 添加配料
def addCondiments(self, condiments):
self.condiments.append(condiments)
# 用来进行测试
mySweetPotato = SweetPotato()
print("------有了一个地瓜，还没有烤-----")
print(mySweetPotato.cookedLevel)
print(mySweetPotato.cookedString)
print(mySweetPotato.condiments)
print("------接下来要进行烤地瓜了-----")
print("------地瓜经烤了4分钟-----")
mySweetPotato.cook(4) #烤4分钟
print(mySweetPotato)
print("------地瓜又经烤了3分钟-----")
mySweetPotato.cook(3) #又烤了3分钟
print(mySweetPotato)
print("------接下来要添加配料-番茄酱------")
mySweetPotato.addCondiments("番茄酱")
print(mySweetPotato)
print("------地瓜又经烤了5分钟-----")
mySweetPotato.cook(5) #又烤了5分钟
print(mySweetPotato)
print("------接下来要添加配料-芥末酱------")
mySweetPotato.addCondiments("芥末酱")
print(mySweetPotato)
应用:存放家具
代码实现
# 定义一个home类
class Home:
def __init__(self, area):
self.area = area #房间剩余的可用面积
# self.light = 'on' #灯默认是亮的
self.containsItem = []
def __str__(self):
msg = "当前房间可用面积为:" + str(self.area)
if len(self.containsItem) > 0:
msg = msg + " 容纳的物品有: "
for temp in self.containsItem:
msg = msg + temp.getName() + ", "
msg = msg.strip(", ")
return msg
# 容纳物品
def accommodateItem(self,item):
# 如果可用面积大于物品的占用面积
needArea = item.getUsedArea()
if self.area > needArea:
self.containsItem.append(item)
self.area -= needArea
print("ok:已经存放到房间中")
else:
print("err:房间可用面积为:%d,但是当前要存放的物品需要的面积为%d"%(self.area, needArea))
# 定义bed类
class Bed:
def __init__(self,area,name = '床'):
self.name = name
self.area = area
def __str__(self):
msg = '床的面积为:' + str(self.area)
return msg
# 获取床的占用面积
def getUsedArea(self):
return self.area
def getName(self):
return self.name
# 创建一个新家对象
newHome = Home(100)#100平米
print(newHome)
# 创建一个床对象
newBed = Bed(20)
print(newBed)
# 把床安放到家里
newHome.accommodateItem(newBed)
print(newHome)
# 创建一个床对象
newBed2 = Bed(30,'席梦思')
print(newBed2)
# 把床安放到家里
newHome.accommodateItem(newBed2)
print(newHome)
总结：
- 如果一个对象与另外一个对象有一定的关系，那么一个对象可用是另外一个对象的属性
思维升华：
- 添加“开、关”灯，让房间、床一起亮、灭
