本文深入解析Python中的类与对象概念，包括类的设计原则、属性、方法、构造函数、析构函数以及重写__str__与__repr__方法。同时，介绍了如何使用类实例化对象，访问对象的属性与方法，以及Python中的访问限制如私有属性的实现。
第一个Python类（创建类）
设计类
类名：
见名之意，首字母大写，其他遵循驼峰原则
属性：
见名之意，其他遵循驼峰原则
行为（方法\功能）：
见名之意，其他遵循驼峰原则
创建类
类：
一种数据类型，本身并不占内存空间，根据所学的number,string,boolean等类似，用类创建实例化对象（变量），对象占内存空间
格式：
class 类名(父类列表)：
属性
行为
object：
基类、超类，所有类的父类，一般没有合适的父类就写object
class Person(object):
# 定义属性
name = ""
age = 0
height = 0
weight = 0
# 定义方法(定义函数)
# 注意：方法的参数必须以self当第一个参数
# self代表类的实例（某个对象）
def run(self):
print("run")
def eat(self, food):
print("eat" + food)
使用类实例化对象.py
class Person(object):
name = ""
age = 0
height = 0
weight = 0
def run(self):
print("run")
def eat(self, food):
print("eat" + food)
def openDoor(self):
print("我已经打开了冰箱门")
def fillEle(self):
print("我已经把大象装进冰箱了")
def closeDoor():
print("我已经关闭了冰箱门")
实例化对象
格式：
对象名=类名（参数列表）
注意：
没有参数，小括号也不能省略
# 实例化一个对象
per1 = Person()
print(per1)
print(type(per1))
print(id(per1))
per2 = Person()
print(per2)
print(type(per2))
print(id(per2))
访问对象的属性与方法.py
class Person(object):
name = "stu"
age = 10
height = 160
weight = 90
def run(self):
print("run")
def eat(self, food):
print("eat" + food)
def openDoor(self):
print("我已经打开了冰箱门")
def fillEle(self):
print("我已经把大象装进冰箱了")
def closeDoor(self):
print("我已经关闭了冰箱门")
per = Person()
访问属性
格式：
对象名，属性名
赋值：
对象名.属性名 = 新值
per.name = "tom"
per.age = 18
per.height = 160
per.weight = 80
print(per.name, per.age, per.height, per.weight)
访问方法
格式：
对象名.方法名(参数列表)
注意：
没有参数，小括号也不能省略
per.openDoor()
per.fillEle()
per.closeDoor()
per.eat("apple")
# 问题：目前看来Person创建的所有对象属性都是一样的
per2 = Person()
print(per2.age)
per3 = Person()
print(per3.age)
对象的初始状态（构造函数）.py
self代表类的实例，而非类
哪个对象调用方法，那么该方法中的self就代表哪个对象
self.class 代表类名
class Person(object):
def run(self):
print("run")
print(self.__class__)
p = self.__class__("tt", 30, 10, 30)
def eat(self, food):
print("eat" + food)
def say(self):
print("Hello! my name is %s, I am %d years old" % (self.name, self.age))
# self不是关键字，换成其他的标识符也是可以的，但是帅的都是用self
def play(a):
print("play" + a.name)
def __init__(self, name, age, height, weight):
self.name = name
self.age = age
self.height = height
self.weight = weight
per1 = Person("tom", 20, 160, 80)
per1.say()
per2 = Person("lilei", 21, 160, 80)
per2.say()
per1.play()
per1.run()
析构函数.py
析构函数：del() 释放对象
class Person(object):
def run(self):
print("run")
def eat(self, food):
print("eat" + food)
def __init__(self, name, age, height, weight):
self.name = name
self.age = age
self.height = height
self.weight = weight
def __del__(self):
print("这里是析构函数")
per = Person("hanmeimei", 20, 170, 55)
# 释放对象
del per
# 对象释放之后就不能再访问了
# print(per.age)
# 在函数里定义的对象会在函数结束时，这样可以用来减少内存空间的浪费
def func():
per2 = Person("aa", 1, 1, 1)
func()
while 1:
pass
重写__repr__与__str__函数.py
重写：将函数重新定义写一遍
str()
在调用print打印对象时自动调用，是给用户用的，是一个描述对象的方法
repr()
给机器用的，在python解释器里面直接敲对象名在回车后调用的方法
注意：
在没有str时，且有repr，str = repr
class Person(object):
def __init__(self, name, age, height, weight):
self.name = name
self.age = age
self.height = height
self.weight = weight
def __str__(self):
return "%s-%d-%d-%d" % (self.name, self.age, self.height, self.weight)
per = Person("hanmeimei", 20, 170, 55)
print(per.name, per.age, per.height, per.weight)
print(per)
# 优点：
# 当一个对象属性值很多，并且都需要打印，重写了__str__方法后，简化了代码
访问限制
class Person(object):
def run(self):
print(self.__money)
print("run")
def eat(self, food):
print("eat" + food)
def __init__(self, name, age, height, weight, money):
self.name = name
self.__age__ = age
self._height = height
self.weight = weight
self.__money = money
# 通过内部的方法来伪装，去修改私有属性
# 通过自定义的方法实现对私有属性的赋值与取值
def setMoney(self, money):
# 数据的过滤
self.__money = money
if money < 0:
money = 0
self.__money = money
def getMoney(self):
return self.__money # _Person__money
per = Person("hanmeimei", 20, 170, 55, 10000000)
# per.age = 10
# print(per.age)
# 如果要让内部的属性不被外部直接访问，在属性前加两个下划线(__),
# 在Python中如果在变量前加两个下划线，那么这个属性就变成了私有属性
# print(per.__money) # 外部使用
# per.run() # 内部可以使用
per.setMoney(10)
print(per.getMoney())
# 不能直接访问 per.__money是因为Python解释器把__money变成了_Person_money,
# 仍然可以_Person__money去访问， 但是强烈建议不要这么干（帅的人都不这么干），
# 不同的解释器可能存在解释的变量名不一致
per.__Person__money = 1
print(per.getMoney())
# 在Python中 __XXX__ 属于特殊变量，可以直接访问
print(per.__age__)
# 在Python中 _XXX 变量，这样的实例变量外部是可以访问的，但是，
# 按照约定的规则，当我们看到这样变量时，意思是“虽然我可以被访问，但是
# 请把我视为私有属性，不要直接访问我”
print(per._height)
晚间作业
人开枪射击子弹
自己创作仅供参考
import time
# ak类枪支
class ak(object):
# 啪 p 表示开枪函数
def p(self):
number1 = self.number
if number1 == 0:
print("弹夹空了，请更换弹夹")
else:
number1 = number1 - 1
print("还剩%d发子弹" % (number1))
# 换弹 hd 表示换弹夹函数
def hd(self):
number1 = self.number
print("换弹中")
time.sleep(1)
print("弹夹换好了")
def __init__(self, number):
self.number = number
#一个弹夹 子弹数
# 实例化一个对象
dj = ak(4)
dj.p()
dj.p()
dj.p()
dj.p()
dj.p()
dj.hd()
dj.p()
千峰老师标准答案
Bulletbox.py
# 弹夹的类
#
class BulletBox(object):
def __init__(self, count):
self.bulletCount = count
gun.py
# 枪的类
class Gun(object):
def __init__(self, bulletBox):
self.bulletBox = bulletBox
def shoot(self):
if self.bulletBox.bulletCount == 0:
print("没有子弹了")
else:
self.bulletBox.bulletCount -= 1
print("剩余子弹：%d发" % (self.bulletBox.bulletCount))
Person.py
# 人
class Person(object):
def __init__(self, gun):
self.gun = gun
def fire(self):
self.gun.shoot()
def fillBullet(self, count):
self.gun.bulletBox.bulletCount = count
人开枪射击子弹.py
人
类名：Person
属性：gun
行为：fire
枪
类名：Gun
属性：bulletBox
行为：shoot
弹夹
类名：BulletBox
属性：BulletCount
行为：
# 此处与老师不同，我把三个类封装到了一个文件里
from Person import Person
from Person import Gun
from Person import BulletBox
# from Person import Person
# from gun import Gun
# from bulletbox import Bulletbox
# 弹夹
bulletBox = BulletBox(5)
# 枪
gun = Gun(bulletBox)
# 人
per = Person(gun)
per.fire()
per.fire()
per.fire()
per.fire()
per.fire()
per.fire()
per.fire()
per.fillBullet(2)
per.fire()
per.fire()
per.fire()
per.fire()
继承
单继承的实现.py
from person import Person
from student import Student
from worker import Worker
per = Person("aa", 1, 2)
stu = Student("tom", 18, 12345, 110)
print(stu.name, stu.age)
stu.run()
print(stu.stuId)
# print(stu.__money) 私有属性
# stu.stuFunc()
print(stu.getMoney()) # 通过继承过来的共有方法访问私有属性
wor = Worker("lilei", 20, 111)
print(wor.name, wor.age)
wor.eat("apple")
print(per.getMoney())
person.py
class Person(object):
def __init__(self, name, age, money):
self.name = name
self.age = age
self.__money = money
def setMoney(self, money):
self.__money = money
def getMoney(self):
return self.__money
def run(self):
print("run")
def eat(self, food):
print("eat"+ food)
student.py
from person import Person
class Student(Person):
def __init__(self, name, age, money, stuId):
# 调用父类中的__init__
super(Student, self).__init__(name, age, money)
# 子类可以有一些自己独有的属性
self.stuId = stuId
def stuFunc(self):
print(self.__money)
worker.py
from person import Person
class Worker(Person):
def __init__(self, name, age, money):
# 调用父类中的__init__
super(Worker, self).__init__(name, age, money)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
