day11笔记

最新推荐文章于 2025-07-14 20:29:18 发布

zy13955413303

最新推荐文章于 2025-07-14 20:29:18 发布

阅读量271

点赞数

本文详细介绍Python面向对象的基础概念，包括类和对象的区别、类的构成与抽象、如何定义类及其实例化对象、构造方法与析构方法的作用、私有属性的设定与访问限制等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

11.01_Python语言基础(面向对象思想)(理解)

面向对象的思想

#
“””
思考：
请用程序描述如下事件：
A同学报道等级信息
B同学报道等级信息
C同学报道等级信息
A同学做自我介绍
B同学自我介绍
c同学自我介绍

#
请用程序描述如下事件：
A同学报道等级信息
B同学报道等级信息
C同学报道等级信息
A同学做自我介绍
B同学自我介绍
c同学自我介绍
“””
stu_a = {“name”:”A”,”age”:21}
stu_b = {“name”:”B”,”age”:22}
stu_c = {“name”:”C”,”age”:23}

def stu_infor(stu):
    for key,value in stu.items():
        print("key = %s,value = %d"%(key,value))

"""

面向过程：

根据业务逻辑从上到下写代码

面向对象：

将数据与函数绑定到一起，进行封装，能够更快速的开发程序，减少代码的重写的过程

def 发送邮件(内容):
    # 连接邮箱服务器
    # 发送邮件
    # 关闭连接

11.02_Python语言基础(类和对象)(掌握)

类和对象的概述

对象和类

#
对象是面向对象思想的核心
在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义—–》类
类—》制造飞机的图纸
用它来创建的飞机就相当于对象

类

具有相似的内部状态和运动规律的实体的集合（抽象）
或者具有相同的属性和行为的统称

定义：
  类  抽象的  在使用的时候通常会找到这个类的具体的存在----》对象
  特点：
     使用这个具体的存在，一个类可以找到多个对象

对象

概述：
   某一个具体事物的存在，在现实世界中可以看得见摸得着
可以直接使用

总结：
  类和对象之间的关系：
     就像利用玩具模型来创建多种不同的玩具
     类就是创建对象的模板

区分类和对象

奔驰汽车   类
奔驰smart   类
张三的那辆奔驰smart    对象

狗    类
大黄狗   类
李四家的那只大黄狗    对象

水果    类
苹果   类
红苹果   类   红富士苹果   类
张三嘴里吃了一半的苹果   对象

11.03_Python语言基础(类的构成)(掌握)

类的构成

#
类（class）：由3部分组成
类的名称：类名
类的属性：一组数据
类的方法：允许对其操作的方法（行为）

设计一个人类

"""
事物的名称（类名）：人（Person）
属性：身高  年龄
方法（行为）：跑，吃饭

"""
"""
狗  类
类名：dog
属性：品种，毛色，性别，腿的数量
方法：叫，跑，咬人，摇尾巴
"""

11.04_Python语言基础(类的抽象)(掌握)

如何把日常生活中的事物抽象成程序中的类？

#
类：
拥有相同属性和行为的对象可以抽取出来—–》类

一般名称提炼法
例如：
 1.坦克发射了3颗炮弹炸掉了2架飞机
 坦克----》抽象成类
 炮弹---》抽象成类
 飞机----》抽象成类

 2.小明在公车上牵了一条叼着热狗的狗
 小明  -----》 人类
 公车  -----》 交通工具类
 热狗  -----》 食物类
 狗    -----》    狗类

游戏中的类和对象

#
cf
人
枪

植物大战僵尸：
向日葵   -----》类
    类名：xrk
    属性：颜色，尺寸
    行为：产生阳光

豌豆：   ------》   类
    类名：  wd
    属性：颜色，发型
    行为：发射炮弹  
僵尸：
    类名：js
    属性：颜色，
    行为：走，吃植物，啃

11.05_Python语言基础(定义类)(掌握)

定义一个类的格式：

#
class 类名:
属性1
属性2
属性3
… …

    方法1
    方法2
    方法3
    ... ...

定义类–猫

#
“””
猫：
类名：cat
属性:毛色，性别
行为：跑，吃
“””
class Cat:
#属性

    #方法
    def eat(self):
        print("猫吃鱼....")

    def drink(self):
        print("猫喝可乐....")

定义类–车

#
“””
车：
类名：Car
属性:颜色，
行为：跑
“””
class Car:
#方法列表
def getCarInfo(self):
print(“车的轮子数：%d,颜色%s”%())

    def move(self):
        print("车子在移动....")

11.06_Python语言基础(经典类和新式类)(熟练)

新式类：

* Python3.X之后对类的定义方式进行了改变
* 在类名后面(object)，Car(object)

说明：
- 定义类的时候有两种，新式类和经典类，上面定义Car为经典类
- 如class Car(object): 是新式类
- class Cat: 是经典类

注意：
定义类名时，尽量使用大驼峰命名法则

11.07_Python语言基础(创建对象)(掌握)

python中，可以根据已经定义好的类来创建一个一个的对象

创建对象的格式：对象名 = 类名()

创建一个Car类

#
#创建一个Car类
class Car(object):
def move(self):
print(“车子在移动….”)
def toot(self):
print(“车子在鸣笛….”)

#创建车子的对象，并用变量进行保存
BMW = Car()
BMW.color = "黑色"#车子的颜色
BMW.wheelNum = 4#车轮的数量
BMW.color = "白色"
BMW.move()
BMW.toot()
print(BMW.color)
print(BMW.wheelNum)

总结：

BMW = Car():这样就产生了一个Car的实例对象，
此时可以通过实例对象BMW访问属性和行为
BMW--->对象，它拥有属性和行为

为对象添加属性

下面以Cat类为例子,添加属性
#
class Cat:
def eat(self):
print(“猫在吃鱼…..”)
def drink(self):
print(“猫在和芬达….”)

创建一个Cat对象

tom = Cat()

调用tom指向的对象中的方法

tom.eat()
tom.drink()
tom.name = “汤姆”
tom.age = 3

获取对象的属性

class Cat:
    def eat(self):
        print("猫在吃鱼.....")
    def drink(self):
        print("猫在和芬达....")

#创建一个Cat对象
tom = Cat()
#调用tom指向的对象中的方法
tom.eat()
tom.drink()
tom.name = "汤姆"
tom.age = 3
print("tom的中文名：%s,年龄：%d"%(tom.name,tom.age))

11.08_Python语言基础(init方法和self的作用)(掌握)

init方法是初始化函数，用来完成一些对象默认的设置

init方法格式

#
class 类名：
#初始化函数，用来完成一些默认的设置
def init(self):
函数体语句

init（）方法调用
- 下面以汽车类Car示例init方法的调用
  #
第一种方式

class Car:
# 初始化方法
def init(self):
self.color = “黑色”
self.wheelNum = 4
```
# 普通的方法，移动
def move(self):
    print("车子在移动.....")
```
创建对象

bmw = Car()
print(“车子的颜色：%s” % bmw.color)
print(“车子的轮子数:%d” % bmw.wheelNum)
bmw1 = Car()
print(“车子的颜色：%s” % bmw1.color)
print(“车子的轮子数:%d” % bmw1.wheelNum)

总结：
当创建Car对象后，在没有调用init()函数的前提下，
bmw就默认拥有了两个属性color/wheelNum，
原因是init()函数在创建对象后，就立刻默认被调用

还有另一种方式能更灵活的使用init方法
#

第二种方式

class Car:
    #初始化方法
    def __init__(self,newWheelNum,newColor):
        self.wheelNum = newWheelNum
        self.color = newColor
    #普通的方法，移动
    def move(self):
        print("车子在移动.....")
#创建对象
bmw = Car(4,"黄色")
print("车子的颜色：%s"%bmw.color)
print("车子的轮子数:%d"%bmw.wheelNum)
bmw1 = Car(6,"绿色")
print("车子的颜色：%s"%bmw1.color)
print("车子的轮子数:%d"%bmw1.wheelNum)

总结：
init():在创建一个对象的时候默认被调用，不需要手动调用
init(self),默认一个参数名字为self,不需要开发者传递
python 解释器会自动将当前的对象的引用传递进来

11.09_Python语言基础(del()方法(析构方法))(熟练)

创建对象后，python解释器默认调用init()
当删除一个对象的时候，python解释器也会默认调用del()

分析下面案例

import sys

class Cat(object):
    def __init__(self):
        self.color = "while"
        self.weight = "8斤"

    def __del__(self):
        print("所有对象被干掉啦")

    def __str__(self):
        return ("颜色%s-体重%s" % (self.color, self.weight))


Tom01 = Cat()
print("Tom01即将被干掉,当前Tom01引用指向地址被引用数量%s" % sys.getrefcount(Tom01))
Tom02 = Tom01
Tom03 = Tom02
print(Tom01)
print(Tom02)
print(Tom03)

print("Tom01即将被干掉,当前Tom01引用指向地址被引用数量%s" % sys.getrefcount(Cat))
print(id(Cat))
del Tom01

print("Tom02即将被干掉,当前Tom02引用指向地址被引用数量%s" % sys.getrefcount(Tom02))
print("Tom02即将被干掉,当前Tom03引用指向地址被引用数量%s" % sys.getrefcount(Tom03))
print("Tom02和Tom03引用指向地址是相同的吗?", Tom02 == Tom03)
del Tom02
print("Tom02被干掉啦")

# del Tom03
# print("Tom03被干掉啦")
print("我是程序结尾的一句话")
print("-" * 30)

print(Tom03)
print(repr(Tom03))
print(eval(repr(Tom03)))

总结：
- 当有1个变量保存了对象的引用，此时对象的引用计数加1
- 当使用del()函数的时候，删除的是变量指向的对象时，
- 如果对象的引用计数不为1，比如3，那么此时只会让这个引用计数减1
- 即变为2，当再次调用del 此时会通用删除引用计数，直到变量的引用计数为0
- 此时才会将变量指向的对象真正删除
- 获取对象计数:sys.getrefcount(object))

11.10_Python语言基础(创建多个对象)(掌握)

同一个类可以创建多个对象,比如常见的猫有加菲和Tom

#
class Cat:
def eat(self):
print(“猫吃鱼….”)
def drink(self):
print(“猫喝水….”)

#创建tom 对象       
tom = Cat()
tom.eat()
tom.drink()
#给tom指向的对象添加两个属性
tom.name = "汤姆"
tom.age = 2


jiafei = Cat()
jiafei.eat()
jiafei.drink()
jiafei.name = "加菲"
jiafei.age = 3

同意个类创建的多个对象是相互独立的

11.11_Python语言基础(魔方方法)(掌握)

魔方方法：
- 魔法方法是Python中的特殊方法
- 魔方方法是指指被包含下划线的方法或者所能调用的方法的统称
- 这些统方法在特殊的情况下被调用，并且基本没有手动调用它的必要

下面我们看一下使用Cat类编写的案例

#定义类
class Car:
    def __init__(self,newWheelNum,newColor):
        self.wheelNum = newWheelNum
        self.color = newColor

    def __str__(self):
        msg = "嘿嘿....我的颜色是"+self.color+"我有"+self.wheelNum+"个轮子"
        return msg

    def move(self):

        print("车子在移动....")

#创建一个对象
bmw = Car("4","白色")
print(bmw)

总结:
在python中方法名如果是XXX那么就具有特殊的功能，—》魔方
str():
当使用print输出对象，只要定义了str()方法，
那么就会返回这个方法中return 的数据

11.12_Python语言基础(str和repr())(掌握)

str和repr()
- repr()与str()函数的功能类似
- str()用于将数值转化为人阅读的形式
- repr()转化为python解释器读取的形式

str():在调用print打印对象的时候自动调用，给用户用的，是一个描述对象的方法
repr():给机器用的，供python的解释器读取

注意：
在没有str（）函数时，有repr()，str == repr

#
import datetime

now = datetime.datetime.now()
print(str(now))
print(repr(now))
print(eval(repr(now)))

说明：
datetime python的内置模块，import 加载导入模块
now = datetime.datetime.now()系统当前的时间赋值给now变量
eval函数是把参数当做代码执行，验证repr之后的字符串可以被python识别执行

#
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)
print(repr(per))
# print(eval(repr(per)))#eval函数中的参数为一个字符串，如果不是一个字符串会报错
aa = "hello"
print(repr(aa))
print(eval(repr(aa)))

>
优点：
当一个对象的属性过多，并且还要打印，重写str()方法简化代码的书写
可读性强

注意：
repr()函数得到的字符串，通常可以用来获得该对象，obj == eval(repr(obj))这个等式是成立的
返回的是一个字符串

11.13_Python语言基础(构造方法)(掌握)

定义：
- 构造方法类似init()函数，差别在于一个对象被构建好之后会自定调用该方法
- python中创建一个构造方法（使用init())
  #
  class Cat:
  def init(self):
  初始化属性

11.14_Python语言基础(重写init()和str()方法)(掌握)

概述：
- Python中所有的类都直接或间接继承object
- object中有init()和str()方法
- object中的这两个方法大部分时间和我们使用时的需求不匹配
- 我们可以根据自己的需求对方法体进行更改,这就叫做重写
- 更多内容在明天的知识点继承中
重写方法使用总结:
- 当两个关联的类，出现了相同的函数名，在调用该函数时，先在本类中找，
- 如果有，调用
- 如果没有，在去父类找，如果有调用，
- 如果没有，去基类，找不到报错

重写对于类很重要：
尤其对于构造 init

#
class Bird():
def init(self):
self.hungry = True

    def eat(self):
        if self.hungry:
            print(".....")
            self.hungry = False
        else:
            print("no thanks")
b = Bird()
b.eat()
b.eat()

重写的定义：
在子类中定义了一个和父类同名的函数—》重写

11.15_Python语言基础(理解self)(掌握)

#
#定义一个类
class Animal:
def init(self,name):
self.name = name
def printName(self):
print(“名字为：%s”%self.name)

#定义一个函数
def myPrint(animal):
    animal.printName()

#创建对象
dog1 = Animal("西西")
myPrint(dog1)

dog2 = Animal("北北")
myPrint(dog2)

总结：

所谓self理解为自己,也就是对象自身
程序中的self是什么?哪个对象调用了init(),self就代表谁

11.16_Python语言基础(应用-烤牛排)(掌握)

"""
烤牛排:
类:
    类名:
        牛排:
    属性:
        几成熟
            0--3表示生的,4--6表示半生不熟,7--9表示熟了,10及以上表示糊了
        红酒
        胡椒
        ... ...
    行为:
        烧烤时间
        添加佐料
        __init__()
        __str__()

    """


class CookSteak:
    def __init__(self):
        self.time = 0
        self.cook_level = 0
        self.cook_string = "生的"
        self.condiments = []

    def cook(self, time):
        self.cook_level += time
        if self.cook_level > 9:
            self.cook_string = "扔了吧,都糊啦"
        elif self.cook_level > 6:
            self.cook_string = "熟了,味道应该很棒"
        elif self.cook_level > 3:
            self.cook_string = "半生不熟,快要熟了"
        elif self.cook_level > 0:
            self.cook_string = "牛排刚放进去,耐性等一会"
        else:
            print("没有这个状态")
        print("牛排已经烤了很久了,现在达到%s成熟了," % self.cook_level)

    def add_cendiments(self, cendiments):
        self.condiments.append(cendiments)

    def __str__(self):
        return "牛排已经烤了很久了,现在达到%s成熟了,添加的佐料有%s" % (self.cook_level, self.condiments)


hui_ling_dun = CookSteak()
hui_ling_dun.cook(1)
hui_ling_dun.cook(1)
hui_ling_dun.cook(1)
hui_ling_dun.cook(1)
hui_ling_dun.add_cendiments("胡椒粉")
hui_ling_dun.cook(1)
hui_ling_dun.cook(1)
hui_ling_dun.add_cendiments("红酒")
hui_ling_dun.cook(1)
print(hui_ling_dun)

11.17_Python语言基础(访问限制)(掌握)

如果有一个对象，当需要对其进行修改属性：
- 方法2种
- #直接修改对象名.属性名 = 数据
- #间接修改对象名.方法名（）
  #
  将属性定义为私有
  格式：
  __属性名

属性私有案例

#
# 定义一个类
class Person(object):
def init(self, name):
self.__name = name

    def __str__(self):
        return self.__name

    def getName(self):
        return self.__name

    def setName(self, newName):
        if len(newName) <= 5:
            self.__name = newName
        else:
            print("名字的长度需要小于等于5")


person = Person("张三")
# print(person)
# #直接修改   对象名.属性名 = 数据
# person.__name = "李四"
# print(person)

# 间接访问   对象名.属性名
# print(person.__name)  #报错


person.setName("李四")
print(person.getName())

person.setName("王五")
print(person.getName())

python没有c++或者Java中的public(公有) private（私有）区分公有和私有
python以属性的命名方式来进行区分：
- 如果在属性名前面加上两个下划线“__”，则表明该属性是私有属性
- 否则就是公有属性（方法的设置同属性设置一致）

11.18_Python语言基础(set()和get()方法)(掌握)

Python私有属性修改
- 类中的属性私有化之后,外部无法访问
- 我们可以在类中定义公共的方法提供给外部,让这个公共的方在类内部修改私有属性

set()和get()使用案例:

#
class Person(object):
def init(self,name,age,height,weight,money):
self.name = name
self.age = age
self.height = height
self.weight = weight
self.__money = money

    def ss(self):
        print(self.__money)

    #通过内部的方法，去修改私有属性
    #通过自定义的方法实现对私有属性的修改
    def getMoney(self):
        return self.__money
    def setMoney(self,money):
        #数据的过滤
        if money < 0:
            money = 0
        self.__money = money

#创建对象
person = Person("张三",12,170,55,100)
# person.age = 15
# person.setMoney(200)
# print(person.getMoney())

# print(person.__money)#外部使用  不ok
print(person.ss)#内部  ok

思考，不能通过对象访问私有属性？
在python的解释器把__money 变成_Person_money.
任然可以使用_Person_money去访问，但是不建议这么做，

"""
person._Person__money = 1
print(person.getMoney())

print(person.__age__)
"""
在python中__XXX__，属于特殊的变量，可以直接访问（公有）
"""