Python笔记（19）面向对象编程

最新推荐文章于 2024-11-08 13:43:44 发布
最新推荐文章于 2024-11-08 13:43:44 发布
阅读量27 收藏
点赞数
文章标签： python 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ToryCode/article/details/135524566
版权

定义一个类

类的格式：

class 类名(父类):

　　类的内容

#类名后面有括号的类，称为新式类

#括号里面的内容是父类的名称；程序中，所有类的父类都是object

class Animals(object):
　　pass
print Animals

执行结果：

类的数据属性

# coding:utf-8
class Animals(object):
#类的数据属性
    name = 'Tom'
    age = 8

#访问类的数据属性
print Animals.name
print Animals.age

执行结果：

类的方法

# coding:utf-8
class Animals(object):
    name = "Tom"
    age = 8
    weight = 10
#类的方法=函数
#在类中定义的函数叫做方法
#类的方法中,python解释器要求第一个形参必须是self;与java中的this类似
# self实质上是类实例化后的对象本身
    def eat(self):
        print "eating......"

#类的实例化产生的就是对象; 把抽象的类创造出实际存在的事物
#p1就是实例化产生的对象
p1 = Animals()

#调用类的属性
print p1.name
# 调用类的方法
p1.eat()

执行结果：

面对对象的三大特征：封装、继承、多态

封装：

封装实际上是把数据封装到某个地方，以后再去调用被封装在某处的内容或者数据：

　　封装数据

　　调用封装数据

　　　　通过对象直接调用

　　　　通过self间接调用

# coding:utf-8
class Animals(object):
# __init__ 构造方法，确切的说应该是初始化；
# 当类实例化时会自动调用__init__构造方法;
# name, age, weight在这里是必选参数,当实例化时必须要传参,否则报错;
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.weight = weight
# eat方法
    def eat(self):
        print "%s eating......" %(self.name)
        self.weight += 2
# drink方法
    def drink(self):
        print "%s is drinking....." %(self.name)
        self.weight += 1

# 对象可以实例化多个;
Tom = Animals("Tom", 8, 10)  #实例化实际执行了2个操作：实例化和初始化。实例化是将Animals类具象化为对象Tom，初始化指的是执行类里面的__init__构造方法(初始化方法)
Jack = Animals("Jack", 5, 3)

# 在Animals内部，self实质上就是类的实例化对象Tom和Jack
print '名字：%s 年龄：%d 体重：%d' %(Tom.name,Tom.age,Tom.weight)
Tom.eat()
print '目前体重：%d' %(Tom.weight)
Tom.drink()
print '目前体重：%d' %(Tom.weight)

执行结果：

练习1：

创建一个类(People)，拥有的方法为砍柴、娶媳妇、回家。实例化对象，执行相应的方法

# coding:utf-8
class People(object):
    def __init__(self,name):
        self.name = name
#砍柴
    def cut(self):
        return "%s砍柴" %(self.name)
#娶媳妇
    def marry(self):
        return "%s娶媳妇" %(self.name)
#回家
    def home(self):
        return "%s回家" %(self.name)

p1 = People('p1')
p2 = People('p2')
p3 = People('p3')

print p1.cut()
print p2.marry()
print p3.home()

执行结果：

练习2：栈的数据结构

#栈遵循先进后出，后进先出的原则

栈的方法：
入栈(push)，出栈(pop)，栈顶元素(top)，栈的长度(lenght)，显示栈元素(view)，判断栈是否为空(isempty)
操作结果：
栈类的实例化，入栈2次，出栈1次，显示最终栈元素

# coding:utf-8
class Stack(object):
    def __init__(self):
        self.table = []
    def push(self,value):
        print '%s 入栈' %value
        self.table.append(value)
    def pop(self):
        if not self.isempty():
            print '%s 出栈' %self.table[-1]
            self.table.pop()
    def top(self):
        if not self.isempty():
            print '栈顶元素：%s' %self.table[-1]
    def lenght(self):
        print '栈的长度；%d' %len(self.table)
    def view(self):
        print '显示栈元素：',
        for i in self.table:
            print i,
        print
    def isempty(self):  #self.table为[]则返回True,否则返回False
        return self.table == []

s1 = Stack()

s1.push(1)
s1.push(2)
s1.pop()
s1.view()

执行结果：

练习3：队列的数据结构

#队列遵循先进先出，后进后出原则

队列的方法：
入队(enqueue)，出队(dequeue)， 队头元素(head)， 队尾元素(tail)，队列的长度(lenght)， 显示队列元素(view)，判断队列是否为空(isempty)
操作结果：
队列类的实例化，入队5次，出队1次，显示最终队列元素

# coding:utf-8
class Queue(object):
    def __init__(self):
        self.table = []
    def enqueue(self,value):
        print '%s 入队' %value
        self.table.append(value)
    def dequeue(self):
        if not self.isempty():
            print '%s 出队' %self.table[0]
            self.table.pop(0)
    def head(self):
        if not self.isempty():
            print '队头元素：%s' %self.table[0]
    def tail(self):
        if not self.isempty():
            print '队尾元素：%s' %self.table[-1]
    def lenght(self):
        print '队列的长度；%d' %len(self.table)
    def view(self):
        print '显示队列元素：',
        for i in self.table:
            print i,
        print
    def isempty(self):  #self.table为[]则返回True,否则返回False
        return self.table == []

s1 = Queue()

s1.enqueue(1)
s1.enqueue(2)
s1.enqueue(3)
s1.enqueue(4)
s1.enqueue(5)
s1.dequeue()
s1.view()

执行结果：

继承：

父类(基类)和子类(派生类)

注意：类的属性名和方法名不能相同，因为相同的话，实例化时会优先调用方法，导致属性无法调用

# coding:utf-8
# Animals是父类/基类;
class Animals(object):
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.weight = weight
    def eat(self):
        print "%s is eating...,体重+2" % (self.name)
        self.weight += 2
    def drink(self):
        print "%s is drinking..." % (self.name)
        self.weight += 1
    def get_weight(self):
        print '%s is %d kg' %(self.name,self.weight)
# Dog是Animal的子类/派生类;
class Dog(Animals):
# 类里面的方法第一个参数必须是self
    def call(self):
        print "%s:汪、汪、汪..." % (self.name)
# Cat是Animal的子类/派生类;
class Cat(Animals):
    def call(self):
        print "%s:喵、喵、喵..." % (self.name)

Tom = Cat("Tom",12,10)
Tom.eat()
Tom.get_weight()
Tom.call()

执行结果：

重写父类的构造函数：

父类名.__init__(self,形参)super(自己类的名称, self).__init__(形参)
#不需要明确告诉父类的名称
#如果父类改变，只需修改class语句后面的继承关系即可

# coding:utf-8
# Animals是父类/基类;
class Animals(object):
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.weight = weight
    def eat(self):
        print "%s eating......" % (self.name)
        self.weight += 2

# Dog是Animal的子类/派生类;
class Dog(Animals):
# name, age, weight, dogid
    def __init__(self, name, age, weight, dogid):
# 重写父类构造函数;
        self.name = name
        self.age = age
        self.weight = weight
        self.dogid = dogid

# Cat是Animal的子类/派生类;
class Cat(Animals):
# name, age, weight, food
    def __init__(self, name, age, weight, food):
        self.name = name
        self.age = age
        self.weight = weight
        self.food = food


Spike = Dog("Spike", 3, 10, '001')
print Spike.name
print Spike.dogid

Tom = Cat("Tom", 2, 5, "fish")
print Tom.food

执行结果：

多态：

当父类和子类有相同的方法时, 调用优先执行子类的方法

# coding:utf-8
# Animals是父类/基类;
class Animals(object):
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.weight = weight
    def eat(self):
        print "%s eating......" % (self.name)
        self.weight += 2

class Cat(Animals):
    def eat(self):
        print "%s eating......" % (self.name)
        self.weight += 1

class Dog(Animals):
    def eat(self):
        print "%s eating......" % (self.name)
        self.weight += 3

Spike = Dog("Spike", 12, 12)
Spike.eat()
print Spike.weight

执行结果：可以看到执行完eat方法之后weight增加了3，说明调用的是子类的eat方法

特殊的类属性：

# coding:utf-8
class Base(object):
    pass

class Animals(object):
    '''
父类Animals:
Attritube:
'''
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.weight = weight
    def eat(self):
        print "%s eating......" % (self.name)
        self.weight += 2

class Cat(Animals):
    def eat(self):
        print "%s eating......" % (self.name)
        self.weight += 1

class Dog(Animals, Base):
    def eat(self):
        print "%s eating......" % (self.name)
        self.weight += 3

print Animals.__name__  #打印类名称
print Animals.__doc__  #打印类的说明，__doc__属性不能继承给子类
print Animals.__bases__  #打印类的所有父类,以元组类型返回
print Dog.__bases__  #打印类的所有父类,以元组类型返回
print Animals.__dict__  #以字典的方式返回类的方法和属性
print Animals.__module__  #如果类不是被导入的, 显示为__main__，如果类是被import导入的, 则显示类所在的模块名

执行结果：

ToryCode
关注
Python 实验八 面向对象编程
CWPIN21的博客
07-12 1374
实验八 面向对象编程
【Python】面向对象编程
illuosion7的博客
06-17 517
在对象的增删改查中，只有查询的权限是最高的，能够查到class。定义、通过类创建出一个对象、属性相关、方法相关、补充。类：对某一具体对象特征的抽象。作用：根据抽象的类，生产具体的对象。面向对象要做的就是：把行为划分到对象里面去。万物皆是对象，对象是具体物体。只能从class去改，而不能从对象上改class的属性。面向对象：对过程进行封装，调用对象的过程就好了。属性：只能通过对象来索引（访问）。类由名称，属性、行为来构成。对象可以抽象成类，类可以实例化为对象。变量：是可修改的变量，无宿主。
Python学习笔记-面向对象程序设计
向往的是：佛祖堂前的鱼，静静听禅。
12-12 842
记述python中关于面向对象程序设计的使用。
Python中面向对象（学习笔记）
热门推荐
南枝向暖北枝寒
06-15 2万+
文章目录一、面向过程与面向对象简述面向过程编程面向对象编程二、类和对象类对象（实例）类和对象的关系三、类的定义四、类中的成员类属性实例函数（对象函数，成员函数）实例函数和普通函数的区别关于self创建对象（实例化对象）调用类中的实例函数动态绑定属性和限制绑定动态绑定属性限定绑定内存中的对象构造函数工作原理给 `__init__()` 设置参数析构函数1. 将对象定义为全局变量，程序执行完毕，对象自动被销毁2. 将对象定义为局部变量,当指定的函数执行完毕，则对象随着会被自动销毁3. 强制销毁对象，什么时候de
python学习笔记——面向对象编程
qq_42489308的博客
04-20 341
上篇：https://blog.csdn.net/qq_42489308/article/details/89423181 面向对象编程 面向对象编程：Object Oriented Programming，简称OOP，是一种程序设计方法。 面向对象面向过程区别 完成自我介绍功能，面向过程完成功能 stu_a = { "name":"A" "age":18, "h...
面向对象编程：Python编程中类的使用
白帽阿叁的博客
11-23 1034
所谓面向对象编程，指的是把现实世界中的事物或者情景抽象成具有相同行为的对象，给这些对象设置一些属性和行为模式，然后去调用对象的某些属性和行为。 除了面向对象编程，还有一种是面向过程编程。面向过程编程是把事物按照顺序分成不同的步骤，对每个步骤进行编程。举个简单的例子，把大象放冰箱需要几步？按照面向过程编程，需要三步，把冰箱门打开，把大象塞进去，把冰箱门关上。按照面向对象编程，则需要定义冰箱的属性和行为，冰箱可以被打开，也可以被关上。还需要定义人的属性和行为，人可以移动某个东西。定义好之后我们调用人和冰箱的行为
Python面向对象编程——学习笔记
薛倩的专栏
04-21 666
1.  非公开的（private）的函数或变量，不应该被直接引用，比如_abc，__abc等； 正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等； __xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量 有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变
Day4 Python3mi面向对象编程学习笔记4
MoreDeepStudy的博客
03-20 222
关于属性在内存中的存储：不管是对象还是类，他们的属性都存储在他们自带的属性__dict__中，以字典的形式保留下来。对于类的__dict__是只读模式，不可进行修改，而对于对象的__dict__,是可以进行修改的。 对象： class Money: pass one.Money() one.age=19 one.height=180 print(one.__dict__)#将会把对象属...
初学者python笔记（面向对象编程、类与对象）
Viewinfinitely的博客
03-13 387
文章目录面向对象设计类与对象的概念1、类与对象的本质2、面向对象设计 到 面向对象编程3、类实例化4、例如一个学校类面向对象编程1、案例2、面向对象语言和面向对象编程之间的关系3、类的属性4、类的其他一些属性5、类中的作用域6、实例化相关（查、增、改、删） Python是一门面向对象设计的编程语言，所以Python里面提供了非常专业的面向对象用法。本篇就来总结一下面向对象相关的知识，从面向对象设计...
19_python笔记-面向对象1
cPen_web的博客
11-18 1184
文章目录练习1 用代码定义一个人示例知识点2 什么是面向对象示例知识点3 类的定义和使用示例：类的定义练习4 定义一个类示例知识点5 __init__ __new__示例1：__init__方法示例2：__new__示例3：__new__示例4：单例模式练习6 创建一个学生类示例练习7 定义一个Person类示例 博客cpen_web 练习1 用代码定义一个人 #注：OOP - 面向对象编程 #注：shell不支持面向对象的编程 用代码定义一个人，有以下信息： 姓名、年龄、性别 上网（年龄大于6岁可以上网
Python3学习笔记之面向对象编程
chenf1999的博客
08-10 3005
面向对象编程 参考链接：廖雪峰的官方网站 面向对象编程 类和实例 访问限制 类和实例 代码示例： class Student(object): def __init__(self, name, score): self.name = name self.score = score def print_sc...
Python学习笔记：17 面向对象编程进阶
qq_44733409的博客
08-07 276
动态属性 在Python中，我们可以动态为对象添加属性，这是Python作为动态类型语言的一项特权，代码如下所示。 注意：对象的方法其实本质上也是对象的属性，如果给对象发送一个无法接收的消息，引发的异常仍然是AttributeError。 class Student: def __init__(self, name, age): self.name = name self.age = age stu = Student('王其', 20) # 为Studen
（XWZ）的Python学习笔记Ⅲ——面向对象高级编程
a2011607的博客
08-07 397
声明：文章基于廖雪峰Python教程 面向对象高级编程
Python随堂笔记 面向对象程序设计
张时贰的博客
04-27 1322
🌴 2022.04.20 下午 文章目录6 面向对象程序设计6.1 概述6.2 类与对象6.2.1 类的定义6.2.2 对象创建和使用6.3 类的成员6.3.1 成员类型6.3.2 内置成员6.4 类的方法6.4.1 方法类型6.4.2 属性6.4.3 特殊方法6.5 类的继承与多态6.5.1 类的继承6.5.2 类的多态6.6 抽象类和抽象方法 6 面向对象程序设计 6.1 概述 🚀 程序设计方法 计算机程序设计的语言有很多种，如C/C++、C#、Java和Python等 程序设计语言描述计算机系统的
Java面向对象笔记整理
m0_48895748的博客
07-23 830
Java面向对象笔记整理
【anaconda】使用记录
zhuyan108的博客
11-05 324
window11 下安装anaconda。
【python GUI编码入门-21】如何用Tkinter创建一个记事本应用
最新发布
木头大左的博客
11-08 18
在现代编程环境中，图形用户界面（GUI）应用程序的开发变得越来越重要。Python的Tkinter库是一个功能强大且易于使用的GUI工具包，非常适合初学者和有经验的开发者使用。本文将详细介绍如何使用Tkinter创建一个简易的记事本应用，涵盖从安装到实现各项功能的全过程。Tkinter是Python的标准GUI库，它提供了丰富的接口来创建窗口、对话框、按钮等常见的GUI组件。Tkinter具有良好的跨平台性，可以在Windows、Mac OS和Linux上运行。
智能化运维的未来：AI和机器学习在运维中的应用
Echo_Wish的博客
11-05 354
AI和机器学习在运维中的应用，不仅提高了运维效率和质量，还为企业的数字化转型提供了强有力的技术支持。通过预测性维护、自动化运维、异常检测和智能告警等应用，企业可以更好地管理和优化其IT基础设施，确保系统的高效、稳定运行。希望本文能为读者提供有价值的参考，帮助你在运维实践中更好地应用AI和机器学习技术。如果有任何问题或需要进一步讨论，欢迎交流探讨。让我们共同推动智能运维的发展，实现更高效、更智能的运维管理。
一次薅国家超算平台的记录
weixin_55179972的博客
11-07 305
参与 谁是下一个“AI”跃人 -AI体验推介活动，赢取千元算力券！（https://www.scnet.cn/home/subject/modular/index270.html）2. Clone开源的Llama3 Chinese （https://github.com/LlamaFamily/Llama-Chinese）活动名称主题：国家超算互联网「AI跃升季」：谁是下一个“AI”跃人 - AI算力体验活动。其中位置1，2替换为商品基模型和训练出来的微调模型。模型改为商城下载的模型。2、运行的过程记录。
Python面向对象编程：深入理解类与对象
"这篇文档介绍了Python中的面向对象编程概念，特别是类和对象的使用。文章首先从生活中的实例出发，解释对象的概念，然后阐述对象由属性和方法组成，并通过一个 Turtle 类的例子展示了如何定义和使用属性及方法。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值