python基础四 面向对象编程
2024-05-22 05:34:24
面向对象编程
面向对象的基本思想
面向对象变成实际上是在创建类，之后再由类创建对象的一个过程，类实际上是一张图纸，用于规定对象的总体概括
而对象实际上是从图纸创建的出来的实体，实体可以涵盖图纸规定的内容，但是又有一些实际过程中的修改和加工
#设计车类
# class 表示创建类
# Car 表示类名
class Car:pass
c=Car() # 把类的概念进行是例化，实列化的过程就是通过类来创建对象的过程
print(c) # <__main__.Car object at 0x000002710CBB8C0 # 可以看出c实际上是由Car来创建的对象# 给车加东西
class Car:pass
c=Car() # 把类的概念进行是例化，实列化的过程就是通过类来创建对象的过程# 对象=类（） 这个方式是创建对象的过程
c.lunzi="园的" # . 翻译成 “的” 表示 这辆车的轮子是园的
c.color="骚红的"
c.paizhao="京A6666"
c.pailiang="6.3T" # 轮子，颜色 拍照 排量 称为类的属性
print(c.pailiang) # 查看车的属性
print(c.price)# 'Car' object has no attribute 'price' 车对象没有price这个属性"""
每创建一个对象 就开辟一个地址 该对象的所有属性 存在该地址
再次创建对象 就又开辟一个地址 这个地址没有上一个对象的属性 需要重新添加
"""
# 自己的类名 首字母大写 括号可加可不加 没有继承的时候可以不加class Computer:pass
c1=Computer() # 创建第一个对象 开辟地址 以下属性存在该地址
c1.pinpai="神州"
c1.price=100
c1.cpu="i7"
c1.neicun="1G"c2=Computer() # 创建第二个 又开辟新地址 属性存在该地址
c2.pinpai="小米"
c2.price=1000
c2.cpu="i5"
c2.neicun="1T"
print(c1.pinpai)# 神州
print(c2.pinpai)# 小米class Computer:def __init__(self): # 构造方法 创建对象的时候系统自动访问 创建对象之后这个方法就调用了# self 类的对象 当前创建的对象print("调用")
c=Computer() # 调用 # 此时就执行了 __init__()
继承
# 继承 ：子类自动拥有父类中除了私有内容外的所有其他内容 包括属性 方法 私有化下面回讲到# 子类在父类的基础上 扩展了功能 父类里面的功能 称为 基类 子类自己的功能称为 派生功能
class Niu:def da(self):print("牛魔王大家很厉害")def pao(self):print("你上来啊")
class Honghaier(Niu): # 继承Niu类def pao(self):print("你好")
H=Honghaier()
H.da() #牛魔王大家很厉害 # 调用方法的时候 先找自己 再找父类 自己有的就不找父类了
H.pao() # 你好 # 自己又pao这个方法 就不用去调用父类的方法了
方法中传入类
# 修改程序
# 创建孙悟空类
class Sunwukong:def da(self,yaoguai):yaoguai.teng()
# 创建妖怪对象
class Zhizhujing:def teng(self):print("蜘蛛精很疼")
class Heixiongjing:def teng(self):print("黑熊精很疼")
class Baigujing:def teng(self):print("白骨精很疼")
# 实例化一个孙悟空和一个妖怪
swk=Sunwukong()
hxj=Heixiongjing()
# 孙悟空打妖怪
swk.da(hxj) # 黑熊精很疼面向对象编程 成员
成员包括： 变量 方法 属性@property 私有
变量
1 实例变量 ： 对象.XXXX=XXXX 又叫字段 或者 属性 给对象用的 实列变量通过对象调出
在__init__里面的属性可以叫做实列变量
对象自己添加的属性也叫实列变量
2 类变量： 可以直接使用类名进行访问的 也可以使用对象进行访问
当有类变量的时候 类变量单独存放在一个地址 （类变量是这个类共有的属性）
在创建对象后 开辟一个新的地址 存储创建对象的各种属性（实列变量）
当对象想调用各种属性的时候 先从自身寻找 找不到再去 访问类变量存储的地址寻找属性
如果这个对象自己创建了一个和类变量一样的属性 那么这个属性存储在这个对象自己的地址里面
并不会对对象地址的属性修改 下次访问的时候 就从自己的地址里面拿
# 实列变量
class Person:def __init__(self,name,height,weight):self.name=nameself.height=heightself.weight=weight # 这些属性就是实列变量
mahuateng=Person("马化腾","180","160")
print(mahuateng.height)# 实例变量
mahuateng.company="腾讯" # 也是实列变量# 类变量
class Person:country="中国" # 类变量 可以通过类来调用 也可以通过对象来调用def __init__(self,name,age):self.name=nameself.age=age
print(Person.country) # 类调用
p1=Person("Tom","18")
p2=Person("徐速","17")
print(p1.name,p2.name) # Tom 徐速 # 找属性的时候 先从自己的地址寻找 找不到在取类的地址寻找
print(p1.country,p2.country) # 中国 中国 # 对象自己没有这个country的属性 自己的地址找不到，就从类中去调用
p1.country="大清" # 对 p1 对象指定新的属性 这个时候就会在自己的地址存储一个新的属性 下次找的时候先从自己的地址找
print(p1.country) # 大清 #从自己的地址找到了
print(p2.country) # 中国 #自己的地址没有从类里面去找
Person.country="美国" # 对类属性进行修改 类属性只能由类修改
print(p1.country,p2.country) # 美国 美国
方法
方法： 1.实例方法： 对象.方法() 通过对象来调用
2.类方法： 类.方法() （也可以用对象调用，但不推荐）
3.静态方法： 类.方法（）（也可以用对象调用，但不推荐）
# 类方法
class Person:def chi(self): # 实例方法 必须由self 表示把对象传入 通过对象来调用print("人在吃")@classmethod # 申明为类方法def he(cls): # 必须要由 cls 把类传入 所以用类来调用print(cls)print("我是和")@staticmethod # 声明为静态方法def shui(height): # 不用传递cls 和 self 相当于类中定义的一个普通函数print("身高是 %s" %height)print(Person)
Person.he()
'''
<class '__main__.Person'>
<class '__main__.Person'>
我是和
'''
# 两个地址是一样的 说明是一个东西
Person.shui(15) #身高是 15 # 用类来调用 这个静态方法
属性
属性@property: 一般设计到要计算才能算出来的属性 就用这个
特点： 1.函数只能用一个self参数
2.需要有返回值
3.不能赋值 比如下面的 u.age 不能直接用 u.age=18 来重新设置
class User:def __init__(self,name,birthday,qq,email): # 年龄要通过出生计算self.name=nameself.birthday=birthdayself.qq=qqself.email=emaildef getAge(self): # 现在是一个方法 通过方法来获取年龄 但年龄实际上应该是属性return 2018-self.birthday@property # 声明以下方法为属性 可以把方法变为属性 属性是不能传参的 除了selfdef age(self):return 2020-self.birthdayu=User("王明",1993,111111,"1111@qq.com")
print(u.getAge())# 25 # 通过方法来访问 但是年龄应该为属性
print(u.age) # 27 # 之间用属性调用
私有
#带有__前缀的都为私有 私有一般不能修改和直接调用
class Person:def __chi(self): # 这属于私有方法 对象无法访问print("我要吃，疯狂的吃")
p=Person()
p.__chi() # 'Person' object has no attribute '__chi' 无法访问
# 私有属性私有方法 不能通过对象直接调用# 通过内部才能调用私有方法
class Person:def __chi(self): # 这属于私有方法 对象无法访问print("我要吃，疯狂的吃")def he(self):self.__chi() # 内部调用 即在类里面可以调用print("我是喝")
p=Person()# 我要吃，疯狂的吃
p.he() # 我是喝# 对私有属性进行取值和修改class Person:def __init__(self,name,age):self.name=nameself.__age=age# 通过内部调用方法 来对私有属性进行修改def SetAge(self,age):return self.__age=age#通过内部方法来查看私有属性def GetAge(self):return self.__age
类与类之间的关系
依赖关系
# 紧密程度最低的是一个 依赖关系 实质上是类套对象 通过传参调用其他类
class Elephant:def open(self,bx): # 这里是依赖关系 ，想执行这个动作必须传递一个 bxprint("大象来到了冰箱们")bx.kai()print("大象成功的开门")def zhuangziji(self):print("大象自己走")def close(self,bx):print("大象要关冰箱")bx.guan()
class Bingxiang:def kai(self):print("我是冰箱，我会开门")def guan(self):print("我是冰箱，我会关门")
bx=Bingxiang() # 创建冰箱对象
dx=Elephant() # 创建大象对象
dx.open(bx) # 开冰箱
dx.zhuangziji() # 装大象
dx.close(bx) # 关冰箱
# 如果多创建一个冰箱 或者 电饭锅（能开能关的东西） 则新创建的冰箱和电饭锅都是可以被大象调用的 关系不紧密
关联关系
#关联关系 两种食物必须是互相关联大得到 ，但是在某些特殊情况¶
#下是可以更改和更换的 （一个类中有另一个类，不是传参来调用）# 一对一的关系 比如省份证 男女朋友 一对一
class Boy:def __init__(self,name,girlFriend=None):self.name=nameself.girlFriend=girlFrienddef chi(self):if self.girlFriend:print("%s 和 %s 在吃饭" % (self.name,self.girlFriend.name))self.girlFriend.happy()else:print("没有女朋友 吃屎啊")
class Girl:def __init__(self,name):self.name=namedef happy(self):print("%s 很开心" % self.name)
b=Boy("王明")
g=Girl("肉丝")
b.girlFriend=g # 找到女朋友
b.chi() # 王明 和 肉丝 在吃饭 肉丝 很开心b.girlFriend=None # 分手了
b.chi()# 没有女朋友 吃屎啊# 老师和学生的关系 一对多
class Teacher:def __init__(self,name,lst=None):self.name=nameif lst==None:self.lst=[]else:self.lst=lstdef tianjia(self,student):self.lst.append(student)def display(self): # 查看学生的方法for i in self.lst:print(i.name) # 如果是 print(i) 拿打印出来的是地址
class Student:def __init__(self,num,name,teacher=None):self.name=nameself.num=numself.teacher=teacher
# 现在有个叫大张伟的老师
t=Teacher("大张伟")#有一下四个学生
s1=Student(1,"郭德纲")
s2=Student(2,"岳云鹏")
s3=Student(3,"袁弘")
s4=Student(4,"吴彦祖")
# 大张伟老师 招了两个学生
t.tianjia(s1)
t.tianjia(s2)
print(t.lst) # <__main__.Student object at 0x000001A94EF80BC8># <__main__.Student object at 0x000001A94EF79988>
# 可以看出传进去的是两个对象
t.display() # 查看学生
'''
郭德纲
岳云鹏
'''
# 现在有招了两个学生
t.tianjia(s3)
t.tianjia(s4)
t.display()# 郭德纲 岳云鹏 袁弘 吴彦祖
聚合
# 组合 帖子和评论 多对1 反过来不符合逻辑 一个帖子可以有多个评论 但是一条评论只能属于一张帖子
class Tie: # 帖子类def __init__(self,title,content,author,time,pinglun_lst=None):self.title=titleself.content=contentself.author=authorself.time=timeif pinglun_lst==None:self.pinglun_lst=[]else:self.pinglun_lst=pinglun_lstclass Pinglun: # 创建评论类def __init__(self,name,time,content,fav):self.name=nameself.time=timeself.content=contentself.fav=fav# 现在已经评论了
# 显示帖子的内容和评论的内容
tie=Tie("ig夺冠","Ig上单一打五","2010年10月","王明")
print(tie.content)
print(tie.pinglun_lst) # 打印出的是空列表 还没人评论
# 加评论
p11=Pinglun("UZI","昨天","UZI发发祝福",188888)
p12=Pinglun("若风","前天","若风发发祝福",109999)
p13=Pinglun("厂长","大前天","厂长发发祝福",100888)
p14=Pinglun("汪洋","大大昨天","汪洋发发祝福",8888)
p15=Pinglun("UZI全体","大大大昨天","uzi全体发发祝福",678888)lst=[]
lst.append(p11)
lst.append(p12)
lst.append(p13)
lst.append(p14)
lst.append(p15)tie.pinglun_lst=lst # 装评论
for i in tie.pinglun_lst:print(i.content)'''
UZI发发祝福
若风发发祝福
厂长发发祝福
汪洋发发祝福
uzi全体发发祝'''
继承
# 单继承：x是一种y的时候 可以使用继承 比如毛是一种动物。这种 叫 is a
class Shenxian:def fly(self):print("大神会飞")
class Hou:def chi(self):print("猴子吃桃子")
class Sunwukong(Shenxian,Hou): # 一个类可以继承多个无关的类pass
swk=Sunwukong()
swk.fly()
swk.chi()# python中的两种类 经典类 新式类
#python2.2 之前用的经典类，2.2-2.4。用的是经典类和新式类，2.4之后都是新式类#经典类 mro 采用的是树型结构的深度递归表遍历（一条道跑到黑）
#再新式类中 所有类的根都是object 用的c3算法（merge）#经典类：从左到右 深度优先
# 新式子类：从左到右 广度优先
super 函数
单继承
# 单继承中 我们可以认为super 是对父类中的属性或方法的引入
class Animal:def dong(self):print("我是动物")
class Cat(Animal):def dong(self):print("我是猫") # 子类中出现和父类重名的内容，表示对父类方法的覆盖
c=Cat()
c.dong() # 我是猫 # 调用的是自己的dong 方法# 如果想调用父类的dong方法 加super
class Animal:def dong(self):print("我是动物")
class Cat(Animal):def dong(self):super(Cat,self).dong() # 这是python2 的写法 可以访问到父类的方法 # 里面的参数self 是对象 cat是指 找cat的父类# 如果不写参数 super()默认找上一级
c=Cat()
c.dong() # 我是动物class Animal:def dong(self):print("我是动物")
class Cat(Animal):def dong(self): # 加了super 就叫半盖super().dong() # 这是python3 的写法 可以之间访问到父类的方法
c=Cat()
c.dong()# 我是动物class Shengwu:def dong(self):print("我是生物")
class Animal(Shengwu):def dong(self):print("我是动物")
class Cat(Animal):def dong(self): super().dong() c=Cat()
c.dong()# 我是动物class Shengwu:def dong(self):print("我是生物")
class Animal(Shengwu):def dong(self):super().dong()# 这样继续调用Animal 父类中的 dong
class Cat(Animal):def dong(self): # 加了super 就叫半盖super().dong() # 这是python3 的写法 可以访问到父类的方法
c=Cat()
c.dong() # 我是生物
多继承
super在多继承中 是广度优先 不是找父类是找同级别的类 同级别的类没有才往上找
class Init(object):def __init__(self, v):print("init")self.val = v
class Add2(Init):def __init__(self, val):print("Add2")super(Add2, self).__init__(val)print(self.val)self.val += 2
class Mult(Init):def __init__(self, val):print("Mult")super(Mult, self).__init__(val)self.val *= 5
class HaHa(Init):def __init__(self, val):print("哈哈")super(HaHa, self).__init__(val)self.val /= 5
class Pro(Add2,Mult,HaHa): #pass
class Incr(Pro):def __init__(self, val):super(Incr, self).__init__(val)self.val+= 1
# Incr Pro Add2 Mult HaHa Init
p = Incr(5)
print(p.val)
c = Add2(2)
print(c.val)
'''
输出结果
Add2
Mult
哈哈
init
5.0
8.0
Add2
init
2
4
'''class Creature:def dong(self):print("我是祖宗")class Shengwu1(Creature):def dong(self):print("我是生物1")
class Shengwu2(Creature):def dong(self):print("我是生物2")
class Shengwu3(Creature):def dong(self):print("我是生物3")
class Animal(Shengwu1,Shengwu2,Shengwu3):pass
class Cat(Animal):def dong(self): # 加了super 就叫半盖super(Cat,self).dong() # Animal 表示访问Animal的父类 之间跳过了Animalprint("我是猫")
c=Cat()
c.dong()
'''
我是生物1
我是猫
'''
class Creature:def dong(self):print("我是祖宗")class Shengwu1(Creature):def dong(self):print("我是生物1")super(Shengwu1,self).dong()
class Shengwu2(Creature):def dong(self):print("我是生物2")
class Shengwu3(Creature):def dong(self):print("我是生物3")class Animal(Shengwu1,Shengwu2,Shengwu3):pass
class Cat(Animal):def dong(self): # 加了super 就叫半盖super(Cat,self).dong() # Animal 表示访问Animal的父类 之间跳过了Animalprint("我是猫")
c=Cat()
c.dong()
'''
我是生物1
我是生物2
我是猫
'''class A:pass
class B(A):pass
class C(A):pass
class E(A):pass
class D(B,C):pass
class F(E,D):pass
class G(E):pass
class H(G,F):pass
import inspect
inspect.getmro(H) # 用inspec看调用顺序
'''
(__main__.H,__main__.G,__main__.F,__main__.E,__main__.D,__main__.B,__main__.C,__main__.A,object)'''
反射 hasattr ,getattr,setattr,delattr 函数
'''
master模块的内容
def chi():print("大牛很能吃")
def he():print("大牛很能喝")
def la():print("大牛很能啦")
def shui():print("大牛不睡觉")
'''
import master # py 文件才可以当作模块导入
'''
import 的时候 自己产生一个空间 空间的名称叫master 将master文件里面的代码存进来供调用 不是直接从master这个文件里面拿
'''# 我们想直接通过输入就可以测试功能
count=0
while True:s=input("请输入你要测试的功能")if hasattr(master ,s): # 先判断 master 是否有s 这个功能fn=getattr(master,s)# 表示从master这个对象中找到 s 找到的用fn接受 fn 相当于变成了一个函数fn() # 调用函数else:print("没有此功能")count+=1if count==3:break
# hasattr（a,b) 是判断a 中是否由 b这个功能
# getattr（a,b) 是从a中取到b这个功能# 觉得原来模块的内容不好用 想要修改 这个修改并不会对原来模块进行修改 只是在你导入模块存储的地址里面进行修改
def new_chi():print("大牛说的不对，应该慢慢吃")
setattr(master,"chi",new_chi) # 吧master 空间里面的 "chi" 设置成我的 new_chi # 但是只是该了 chi 的作用 没有该chi 这个函数名 即chi 还是叫 chi 但是和以前的作用不一样了def clamb():print("爬山")
setattr(master,"haha",clamb) # master 空间里面没有 haha函数 这样设置相当于增加了 haha函数 作用和clamb函数一样 所以最好命名一样
# 有点像字典 由对于的键 则把值改成现在的 没有则增加键值对
# 然后把新定义的函数 放到master空间中# master模块中有些函数很low 想直接删除
delattr(master,"la") # 表示从master空间中删除la这个函数# hasattr ,getattr,setattr,delattr不仅仅用于导入的模块 同时也可用于类，对类中的方法和属性就行修改添加和删除
python基础四 面向对象编程相关推荐
- python基础之面向对象编程
python基础之面向对象编程 面向对象编程思想 面向对象是一门编程思想,编程思想仅仅是一门思想,与任何技术无关 核心是对象两字,对象可以理解为特征与技能的结合体 基于该编程思想编写程序,就好比创造世 ...
- 带你学python基础：面向对象编程
面向对象编程是个啥呢,其实,在传统的语言中,比如 C 语言,是不存在面向对象编程这个概念的,那时候的语言只有面向过程编程,也就是我们写代码从头写到底,最多也就是有函数.所以,这样的代码风格是比较难维护 ...
- Python基础课程-面向对象编程
Python面向对象编程 在本文中,您将学习Python中的OOP的以下基本概念: Python类 对象实例 定义和使用方法 OOP继承 什么是面向对象编程(OOP)? 面向对象编程(Object-o ...
- Day7 - Python基础7 面向对象编程进阶 --转自金角大王
本节内容: 面向对象高级语法部分 经典类vs新式类 静态方法.类方法.属性方法 类的特殊方法 反射 异常处理 Socket开发基础 作业:开发一个支持多用户在线的FTP程序 面向对象高级语法部分 经典 ...
- python面向对象编程的优点-Python 基础知识----面向对象编程
一.面向对象编程介绍 面向过程编程: 核心是过程二字,过程指的是解决问题的步骤,即先做什么再干什么然后干什么. 基于该思想编写程序好比在设计一条流水线,是一种机械式的思维方式. 优点:复杂的问题流程化 ...
- Python基础学习——面向对象编程（第一讲：面向对象概述、面向对象三个基本特征（封装性、继承性、多态性）、类和对象（定义类、创建和使用对象、实例变量、类变量、构造方法、实例方法、类方法、静态方法））
面向对象是Python最重要的特性,在Python中一切数据类型都是面向对象的. 1.面向对象概述 面向对象的编程思想是,按照真实世界客观事物的自然规律进行分析,客观世界中存在什么样的实体,构建软件系 ...
- Day6 - Python基础6 面向对象编程 --转自金角大王
本节内容: 面向对象编程介绍 为什么要用面向对象进行开发? 面向对象的特性:封装.继承.多态 类.方法. 引子 你现在是一家游戏公司的开发人员,现在需要你开发一款叫做<人狗大战>的游戏,你 ...
- Python基础——6面向对象编程
类和实例 类是抽象的模版,例如汽车:而实例则是拥有相同方法的类的实现,例如汽车里面有大众.宝马.奔驰等等,这些车都能在地面上跑,但是它们的具体数据可以不一样. calss Student(object ...
- Python基础：面向对象编程实战——简易图书管理系统
简易图书管理系统主要有以下功能:1.查询所有书籍2.添加书籍3.借阅书籍4.归还书籍5.退出系统.代码实现主要为: class Book:def __init__(self, name, author ...
- python基础四_01_面向对象
python基础四_01_面向对象编程 导读: 本文主要从what?why?how?三个方向理解面向对象编程的思想:仅供自己梳理. 一.什么是面向对象编程? 面向对象编程与面向过程编程是两种常见的编程 ...
最新文章
- 5m 云服务器2核4g_小鸟云的云服务器,2核4g,带宽5M，大概可支持多少人同时在线？...
- 脑电信号滤波方式汇总
- oracle 触发器 merge,如何从触发器中解决Oracle变异错误
- python-自定义@修饰符
- ASP.NET 4 和 Visual Studio 2010 Web 开发概述
- 解决mxnet错误:OSError: libcudart.so.10.0: cannot open shared object file: No such file or directory
- pygame碰撞检测
- python字典的内置函数_python – 用于字典转换的特殊方法名称的内置函数
- 把斯坦福大学土地租出去？特曼坦言：目的就是赚钱
- dvd清洗碟效果好吗_【你用对了吗？】清洗果蔬哪个好？盐水？淘米水？清洗液......
- sift算法c语言实现
- Openg图像缓存及显存布局
- Vue前端验证一个text只能输入手机号或邮箱
- 超越白皮书8：穿云而过的闪电网络
- 酒水商城|基于Springboot实现酒水商城系统
- 解决单行文本省略号显示问题
- win11 更新后打不开 pycharm 解决方案
- VUE+js高德地图2.0API两幅地图联动同步缩放
- linux 输入8个字母进行排序,Linux下使用sort进行排序
- Python爬虫基础：初探selenium——动态网页静态网页