内容目录
类、对象
# 面向对象和面向过程的区别
# 面向过程（手洗）：需要实现一个功能的时候，着重的是过程，分析出一个个步骤，
# 并把一个个步骤用一个个函数实现，再依次去调用一个个函数即可（每一个步骤都需要自己亲力亲为）
# 面向对象（机洗）：需要实现一个功能的时候，着重的是谁去帮我做这件事情（偷懒，找别人帮我做）
# 类和对象
# 类就是一系列具有相同属性和行为的事物的统称，不是真实存在的事物
# 对象是类的具体实现，是类创建出来的真实存在的事物，面向对象思想的核心。
# 在开发中，先有类，再有对象
# 类的三要素
# 1.类名
# 2.属性：对象的特征描述，用来说明是什么样子的
# 3.方法：对象具有的功能（行为），用来说明能够做什么
# 定义类
# 基本格式
# class 类名：必须符合标识符规定，同时遵循大驼峰命名法，见名知义
# 代码块
# 洗衣机类
class Washer:
height = 800 # 类属性：就是类所拥有的属性
# 查看类属性：类名.属性名
print(Washer.height)
# 新增类属性：类名.属性名 = 值
Washer.width = 450
print(Washer.width)
# 创建对象
# 创建对象的过程也叫做实例化对象
# 实例化对象的基本格式：对象名 = 类名()
# 实例化一个洗衣机对象
wa = Washer()
print(wa) # 显示的是对象在内存中的地址
# 第二次实例化
wa2 = Washer()
print(wa2)
# 内存地址不一样，说明是不同的对象，可以实例化多个对象
800
450
<__main__.Washer object at 0x000001DF02823A00>
<__main__.Washer object at 0x000001DF028239D0># 实例方法和实例属性
# 实例方法
# 由对象调用，至少有一个self参数，执行实例化方法的时候，自动将调用该方法的对象赋值给self
class Washer:
height = 800 # 类属性
def wash(self): # self参数是类中实例方法必须具备的
print("我会洗衣服")
print("方法中的self:",self) # self表示当前调用该方法的对象
# 实例化对象
wa = Washer()
print("wa:",wa)
# 对象调用类中的方法
wa.wash()
wa2 = Washer()
print("wa2:",wa2)
wa2.wash()
# self代表对象本身，当对象调用实例方法时，python会自动将对象本身的引用作为参数，传递到实例方法的第一个参数self里面
wa: <__main__.Washer object at 0x000001388414BFD0>
我会洗衣服
方法中的self: <__main__.Washer object at 0x000001388414BFD0>
wa2: <__main__.Washer object at 0x000001388414BEE0>
我会洗衣服
方法中的self: <__main__.Washer object at 0x000001388414BEE0># 实例属性
# 格式：self.属性名
class Person:
name = "bingbing"
def introduce(self):
print("我是实例方法")
# self.age是实例属性
print(f"{Person.name}的年龄：{self.age}")
pe = Person()
pe.age = 18
pe.sex = '女' # 新增实例属性，是给pe对象新增的实例属性，其他对象依然是没有这个属性的
print(pe.sex) # 根据对象名访问实例属性
pe.introduce()
# 实例属性和类属性的区别
# 类属性属于类，是公共的，大家都能访问到，实例属性属于对象的，是私有的
# 只实例属性只能由对象名访问，不能由类名访问
# 访问类属性，类可以访问到，实例对象也可以访问到
print(Person.name)
print(pe.name)
# 每实例化一次就需要添加一次，效率不高
女
我是实例方法
bingbing的年龄：18
bingbing
bingbing构造函数
# 构造函数__init__()
# 作用：通常用来做属性初始化或者赋值操作
# 注意：在类实例化对象的时候，会被自动调用
class Test:
def __init__(self): # 实例方法
print("这是__int__()函数")
# 实例化对象：对象名 = 类名()
te = Test()
class Person:
def __init__(self, name, age,height):
self.name = name # 实例属性
self.age = age
self.height = height
def play(self):
print(f'{self.name}在打王者荣耀')
def introduce(self):
print(f'{self.name}的年龄是{self.age}，身高是{self.height}cm')
# 实例化对象
pe = Person('bingbing',18,183)
pe.play()
pe.introduce()
# 实例化第二个对象
pe2 = Person('ziyi',18,168)
pe2.play()
pe2.introduce()
这是__int__()函数
bingbing在打王者荣耀
bingbing的年龄是18，身高是183cm
ziyi在打王者荣耀
ziyi的年龄是18，身高是168cm析构函数
# 析构函数 __del__()
# 删除对象的时候，解释器会默认调用 __del__()方法
class Person:
def __init__(self):
print("我是__init__()")
def __del__(self):
print("被销毁了")
p = Person()
del p # 删除p这个对象
# del p语句执行的时候，内存会立即被回收，会调用对象本身的__del__()方法
print("这是最后一行代码")
# 正常运行时，不会调用__del__()，对象执行结束之后，系统会自动调用__del__()
# __del__()主要是表示该程序或者函数已经全部执行结束
我是__init__()
被销毁了
这是最后一行代码封装
# 封装
# 面向对象的三大特性：封装、继承、多态
# 封装：指的是隐藏对象中一些不希望被外部所访问到的属性或者方法
class Persen:
name = 'bingbing' # 类属性
pe = Persen()
print(pe.name)
Persen.name = 'ziyi'
print(Persen.name)
# 隐藏属性（私有权限），只允许在类的内部使用，无法通过对象访问
# 在属性名或者方法名前面加上两个下划线
class Humen:
name = 'James' # 类属性
__age = 28 # 隐藏属性
def introduce(self): # 实例方法
Humen.__age = 18
print(f"{Humen.name}的年龄是{Humen.__age}")
# 在实例方法中访问类属性和隐藏属性
pe = Humen()
print(pe.name)
# 第一种：
# 隐藏属性实际上是将名字修改为：_类名__属性名
print(pe._Humen__age)
pe._Humen__age = 18
print(pe._Humen__age)
# 第二种：在类的内部访问（推荐使用，正规手段）
pe.introduce()
bingbing
ziyi
James
28
18
James的年龄是18# 私有属性/方法
# 普通属性/方法，如果是类中定义的，则类可以在任意地方使用
# 隐藏属性/方法（双下划线开头）：如果定义在类中，无法在外部直接访问，子类不会继承，
# 要访问只能通过间接的方式，另一个py文件中通过from xxx import *导入的时候，也无法导入
# 这种命名一般是python中的魔术方法或属性，都是有特殊含义或者功能的，自己不要轻易定义
# 私有属性/方法（单下划线开头）：如果定义在类中，外部可以使用，子类也可以继承
# 但是在另一个py文件中通过from xxx import *导入时，无法导入
# 一般是为了避免与python关键字冲突而采用的命名方法
class Person:
name = "湖人"
__age = 28 # 隐藏属性
_sex = "男" # 私有属性
pe = Person()
# print(pe.sex) # 报错
print(pe._sex)
# 使用对象._类名__属性名访问隐藏属性
print(pe._Person__age)
class Man:
def __play(self): # 隐藏方法
print("玩手机")
def funa(self): # 平平无奇的实例方法
print("平平无奇的实例方法")
Man.__play(self) # 在实例方法中调用私有方法（不推荐）
self.__play() # 推荐使用，更简便
ma = Man()
ma.funa()
# ma._Man__play()
男
28
平平无奇的实例方法
玩手机
玩手机
# 私有方法
class Girl:
def _buy(self): # 私有方法
print("整天买买买")
girl = Girl()
girl._buy()
整天买买买继承
# 就是让类和类之间转变为父子关系，子类默认继承父类的属性和方法
# class 类名(父类名):
# 代码块
# 单继承
class Person:
def eat(self):
print("我会吃饭")
def sing(self):
print("我是唱歌小能手")
class Girl(Person): # Person类的子类
pass # 占位符，代码里面类下面不写任何东西，会自动跳过，不会报错
class Boy(Person):
pass
girl = Girl()
girl.eat()
girl.sing()
boy = Boy()
boy.eat()
boy.sing()
# 总结：子类可以继承父类的属性和方法，就算子类自己没有，也可以使用父类的。
我会吃饭
我是唱歌小能手
我会吃饭
我是唱歌小能手
# 继承的传递（多重继承）
# A/B/C C（子类）继承于B（父类），B类（子类）继承A类（父类），C类具有A/B类的属性和方法
# 子类拥有父类的父类的属性和方法
class Father: # 父类
def eat(self):
print("吃饭")
def sleep(self):
print("睡觉")
class Son(Father): # Father类的子类
pass
class GrandSon(Son): # Son的子类
pass
son = Son()
son.eat()
son.sleep()
grandson = GrandSon()
grandson.eat()
grandson.sleep()
# 继承的传递性就是子类拥有父类以及父类的父类中的属性和方法
吃饭
睡觉
吃饭
睡觉
# 重写指在在子类中定义与父类相同名称的方法
# 覆盖父类方法
class Person: # 父类
def money(self):
print("一百万需要被继承")
def sleep(self):
print("睡觉了")
class Man(Person): # 子类
def money(self):
Person.money(self)
super().money()
super().sleep() # 可以调用父类中的方法
super(Man, self).money()
print("自己赚一千万")
man = Man()
man.money()
# 对父类方法进行扩展：继承父类的方法，子类也可以增加自己的功能
# 1.父类名.方法名(self)
# 2.super().方法名() 推荐使用
# super在python里面是一个特殊的类，super()是使用super类创建出来的对象，可以调用父类中的方法
# 3.super(子类名,self).方法名()
一百万需要被继承
自己赚一千万
留言