蟒蛇面向对象
作者：互联网
1. 面向对象基础语法
# -*- coding: utf-8 -*-
# @Time : 2019/12/9 14:33
# @Author : 我就是任性-Amo
# @FileName: 1.面向对象基础语法.py
# @Software: PyCharm
# @Blog ：https://blog.csdn.net/xw1680
"""
1.类: 类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
特征被称为属性
行为被称为方法
类就相当于制造飞机时的图纸，是一个模板，是复制创建对象的
2.对象: 对象是由类创建出来的一个具体存在，可以直接使用
由哪一个类创建出来的对象，就拥有在哪一个类中定义的: 属性和方法
对象就相当于用图纸制造的飞机
在程序开发中，应该先有类，再有对象
3.类和对象的关系
类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
类只有一个，而对象可以有很多个
不同的对象之间属性 可能会各不相同
类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少
4.类的设计
在程序开发中，要设计一个类，通常需要满足一下三个要素：
类名: 这类事物的名字，满足大驼峰命名法(每一个单词的首字母大写并且单词与单词之间没有下划线)
属性: 这类事物具有什么样的特征
方法: 这类事物具有什么样的行为
4.1 类名的确定
名词提炼法 分析整个业务流程，出现的名词，通常就是找到的类
4.2 属性和方法的确定
对对象的特征描述，通常可以定义成属性
对象具有的行为（动词），通常可以定义成方法
提示: 需求中没有涉及的属性或者方法在设计类时，不需要考虑
"""
# 第一个面向对象程序: 小猫爱吃鱼 小猫要喝水
# 这里的话按照需求首先是不需要定义属性的
class Cat:
"""这是一个猫类"""
def eat(self):
# self: 由哪一个对象调用的方法，方法内的self就是哪一个对象的引用
# 1.在类封装的方法内部，self就表示当前调用方法的对象自己
# 2.调用方法时，我们是不需要传递self参数的 解释器会自动帮我们传入
# 3.在方法内部 可以通过self.访问对象的属性 也可以通过self.调用其他的对象方法
print("%s 爱吃鱼" % self.name)
def drink(self):
print("小猫在喝水")
# 外汇返佣
tom = Cat()
# tom.eat() # 在设置属性之前 调用方法报错
tom.drink()
# 在类的外部是可以直接通过.的方式去给对象添加属性的，但是不推荐
# 因为对象属性的封装应该封装在类的内部
tom.name = "Tom"
# print(tom.name)
tom.eat() # tom.eat(tom)
# print(tom.__dict__) # 可以查看对象绑定了哪些属性
# print(Cat.__dict__) # 可以查看类绑定了哪些命名空间
lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat()
# 在类的外部通过变量名.访问对象的属性和方法
# 在类的封装方法中，通过self.访问对象的属性和方法
2. 初始化方法__init__
# -*- coding: utf-8 -*-
# @Time : 2019/12/9 14:40
# @Author : 我就是任性-Amo
# @FileName: 2.初始化方法.py
# @Software: PyCharm
# @Blog ：https://blog.csdn.net/xw1680
"""
初始化方法:
1.当使用类名()创建对象时，会自动执行以下操作:
为对象在内存中分配空间--创建对象
为对象的属性设置初始值--初始化方法(init)
2.__init__方法是专门用来定义一个类具有哪些属性的方法
"""
# 在Cat中增加__init__方法，验证该方法在创建对象时会被调用
class Cat:
"""这是一个猫类"""
# def __init__(self):
# print("这是一个初始化方法")
# # 定义用Cat类创建的猫对象都有一个name的属性
# self.name = "Tom"
# 在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对_init__方法进行改造
# 把希望设置的属性值，定义成__init__方法的参数，在方法内部使用
# self.属性 = 形参 接收外部传递的参数
# 在创建对象时，使用类名(属性1, 属性2...)
def __init__(self, name):
self.name = name
def eat(self):
print("%s 爱吃鱼" % self.name)
# 如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了
def __str__(self):
return "我是小猫: %s" % self.name
# def __del__(self):
# __del__:如果希望在对象被销毁前，再做一些事情，可以考虑此方法
def __del__(self):
print("准备删除~~~")
tom = Cat("Tom") # 创建对象时 会自动调用初始化__init__方法
tom.eat()
lazy_cat = Cat("大懒猫")
lazy_cat.eat()
# 在Python中，使用print输出对象变量，默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象，
# 以及在内存中的地址（十六进制表示）
print(tom) # <__main__.Cat object at 0x103959bd0>
del lazy_cat
print("-" * 50)
3. 属性查找与绑定方法
# -*- coding: utf-8 -*-
# @Time : 2019/12/9 15:00
# @Author : 我就是任性-Amo
# @FileName: 3.属性查找与绑定方法.py
# @Software: PyCharm
# @Blog ：https://blog.csdn.net/xw1680
# 属性查找与绑定方法
class Person:
"""这是一个猫类"""
# nationality = "中国"
# def __init__(self, name, age, address, nationality):
# self.name = name
# self.age = age
# self.address = address
# self.nationality = nationality 给对象绑定国籍属性
def __init__(self, name, age, address):
self.name = name
self.age = age
self.address = address
def eat(self):
print(f"{self.name}正在吃饭~~~")
# 1.分别创建amo对象和paul对象
# amo = Person("amo", 18, "重庆市沙坪坝区", "美国")
# paul = Person("paul", 22, "重庆市沙坪坝区", "中国")
# 属性: 首先会从对象本身先去查找，如果对象本身没有绑定该属性，则会从类中去找
# print(id(amo.nationality)) # 4406863312
# print(id(paul.nationality)) # 4406863504
amo = Person("amo", 18, "重庆市沙坪坝区")
paul = Person("paul", 22, "重庆市沙坪坝区")
# 如果对象身上没有绑定该属性 则去在类中查找 类属性是被所有对象共用的 所以返回的地址值是一致的.
# print(id(amo.nationality)) # 4461503952
# print(id(paul.nationality)) # 4461503952
# 如果在类中查找该属性 还是没有 程序就会报错
# print(id(paul.nationality)) # AttributeError: 'Person' object has no attribute 'nationality'
# 函数属性:是绑定给对象使用的，绑定到不同的对象是不同的绑定方法，对象调用绑定方法时，会把对象本身作为一个参数进行传入，传给self
print(amo.eat) # <bound method Person.eat of <__main__.Person object at 0x10e9c7350>>
print(paul.eat) # <bound method Person.eat of <__main__.Person object at 0x10e9c73d0>>
# 可以看到 两个的绑定方法的内存地址值是不一致的
print(Person.__dict__)
print(id(Person.eat(amo))) # 4393136216
print(id(Person.eat(paul))) # 4393136216
4. 案例
4.1 跑步案例
# -*- coding: utf-8 -*-
# @Time : 2019/12/10 16:28
# @Author : 我就是任性-Amo
# @FileName: 4.练习1.py
# @Software: PyCharm
# @Blog ：https://blog.csdn.net/xw1680
# 封装是面向对象编程的一大特点
# 面向对象编程的第一步:将属性和方法封装到一个抽象的类中
# 外界使用类创建对象，然后让对象调用方法
# 对象方法的细节都被封装在类的内部
"""
需求:amo和jerry都爱跑步
amo体重75.0公斤
jerry体重45.0 公斤
每次跑步都会减少0.5公斤
每次吃东西都会增加1公斤
"""
class Person:
def __init__(self, name, weight):
self.name = name
self.weight = weight
def run(self):
self.weight -= 0.5
print("%s 爱锻炼，跑步锻炼身体" % self.name)
def eat(self):
self.weight += 1
# 注意: 在对象的方法内部，是可以直接访问对象的属性的
print("%s 是吃货，吃完这顿在减肥" % self.name)
def __str__(self):
return "我的名字是%s,体重%.2f公斤" % (self.name, self.weight)
amo = Person("amo", 75.0)
amo.run()
amo.eat()
amo.eat()
print(amo)
print("-" * 50)
jerry = Person("jerry", 45.0) # 同一个类创建的多个对象之间，属性互不干扰
jerry.run()
jerry.eat()
jerry.eat()
print(jerry)
4.2 家具案例
# -*- coding: utf-8 -*-
# @Time : 2019/12/20 09:26
# @Author : 我就是任性-Amo
# @FileName: 5.家具案例.py
# @Software: PyCharm
# @Blog ：https://blog.csdn.net/xw1680
"""
需求:
1.房子(House)有户型、总面积和家具名称列表
新房子没有任何的家具
2.家具(HouseItem)有名字和占地面积，其中
席梦思(bed)占地4平米
衣柜(chest)占地2平米
餐桌(table)占地1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型、总面积、剩余面积、家具名称列表
"""
# 分析: 要去添加家具 首先肯定要有一个家具类 被使用的类 通常应该先被开发
class HouseItem:
def __init__(self, name, area):
self.name = name # 家具名称
self.area = area # 占地面积
def __str__(self):
return "[%s] 占地面积 %.2f" % (self.name, self.area)
bed = HouseItem("bed", 4) # 席梦思
chest = HouseItem("chest", 2) # 衣柜
table = HouseItem("table", 1.5) # 餐桌
print(bed)
print(chest)
print(table)
class House:
def __init__(self, apartment, area):
self.apartment = apartment # 户型
self.total_area = area # 总面积
self.free_area = area # 剩余面积开始的时候和总面积是一样的
self.furniture_list = [] # 家具名称列表 默认是没有放置任何家具的
def add_item(self, furniture):
"""添加家具"""
print(f"添加:{furniture.name}")
# 判断家具的面积是否超过剩余面积，如果超过，提示不能添加这件家具
if furniture.area > self.free_area:
print("房间剩余面积不够，不能添置这件家具...")
return
self.furniture_list.append(furniture.name) # 将家具名称追加到家具名称列表中
self.free_area -= furniture.area # 用房子的剩余面积-家具面积
def __str__(self):
return f"房子户型为:{self.apartment},总面积为:{self.total_area}," \
f"剩余面积为{self.free_area},家具列表为:{self.furniture_list}"
if __name__ == "__main__":
my_house1 = House("两室一厅", 60)
my_house1.add_item(bed)
my_house1.add_item(chest)
my_house1.add_item(table)
print(my_house1)
my_house2 = House("一室一厅", 10)
my_house2.add_item(bed)
my_house2.add_item(chest)
my_house2.add_item(table)
my_house2.add_item(bed)
print(my_house2)
6. 私有属性
# -*- coding: utf-8 -*-
# @Time : 2019/12/20 10:08
# @Author : 我就是任性-Amo
# @FileName: 6.私有属性.py
# @Software: PyCharm
# @Blog ：https://blog.csdn.net/xw1680
"""
应用场景:
在实际开发中，对象的某些属性或方法可能只希望在对象的内部被使用，而不希望在外部被访问到
私有属性就是对象不希望公开的属性
私有方法就是对象不希望公开的方法
定义的方式: 在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法
在java中的话是使用private关键字
"""
class Women:
def __init__(self, name):
self.name = name
self.__age = 18
def __secret(self):
print("我的年龄是 %d" % self.__age)
xiao_fang = Women("小芳")
# 私有属性外界不能直接访问
# print(xiao_fang.__age) 报错:AttributeError: 'Women' object has no attribute '__age'
# 私有方法，外部不嫩直接调用
# xiao_fang.__secret()
# 在日常开发中，不要使用这种方式，访问对象的私有属性或私有方法
# 在Python中，并没有真正意义的私有
# 在给属性、方法 命名时，实际是对名称做了一些特殊处理，使得外界无法访问到
# 处理方式:在名称前面加上 _类名 => _类名__名称
print(xiao_fang.__dict__) # 查看名称空间
print(xiao_fang._Women__age)
# print(Women.__dict__)
xiao_fang._Women__secret()
程序运行结果如下：
7. 继承
7.1 面向对象的三大特性
封装: 根据职责将属性和方法封装到一个抽象的类中
继承: 实现代码的重用，相同的代码不需要重复的编写
多态: 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度
7.2 单继承
7.2.1 继承的概念
继承的概念: 子类拥有父类的所有方法和属性
# ---------不使用继承开发动物和狗---------------
class Animal:
def eat(self):
print("吃")
def drink(self):
print("喝")
def run(self):
print("跑")
def sleep(self):
print("睡")
class Dog:
def eat(self): # 不使用继承重复书写的代码太多
print("吃")
def drink(self):
print("喝")
def run(self):
print("跑")
def sleep(self):
print("睡")
def bark(self):
print("汪汪叫")
# 创建一个狗对象
wang_cai = Dog()
wang_cai.eat()
wang_cai.drink()
wang_cai.run()
wang_cai.sleep()
wang_cai.bark()
# # ---------使用继承开发动物和狗---------------
class Animal:
def eat(self):
print("吃---")
def drink(self):
print("喝---")
def run(self):
print("跑---")
def sleep(self):
print("睡---")
class Dog(Animal):
def bark(self):
print("汪汪叫---")
# 创建一个狗对象
wang_cai = Dog()
wang_cai.eat()
wang_cai.drink()
wang_cai.run()
wang_cai.sleep()
wang_cai.bark() # 直接享受父类中已经封装好的方法 不需要再次开发
7.2.2 继承的语法
class 类名(父类名):
pass
类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
子类中应该根据职责，封装子类特有的属性和方法
专业术语
Dog类是Animal类的子类，Animal类是Dog类的父类，Dog类从Animal类继承
Dog类是Animal类的派生类，Animal类是Dog类的基类，Dog类从Animal类派生
继承的传递性
C类从B类继承，B类又从A类继承，那么C类就具有B类和A类的所有属性和方法
# -*- coding: utf-8 -*-
# @Time : 2019/12/21 10:52
# @Author : 我就是任性-Amo
# @FileName: 9.继承的传递性.py
# @Software: PyCharm
# @Blog ：https://blog.csdn.net/xw1680
class Animal:
def eat(self):
print("吃---")
def drink(self):
print("喝---")
def run(self):
print("跑---")
def sleep(self):
print("睡---")
class Dog(Animal):
def bark(self):
print("汪汪叫")
class XiaoTianQuan(Dog):
def fly(self):
print("我会飞")
# 创建一个哮天犬的对象
xtq = XiaoTianQuan()
xtq.fly()
xtq.bark()
xtq.eat()
原文链接：https://blog.csdn.net/xw1680/article/details/103641726
标签：__,name,self,面向对象,蟒蛇,print,def,属性 来源： https://www.cnblogs.com/benming/p/12096295.html