python面向对象程序编程学习记录

最新推荐文章于 2023-02-17 19:48:44 发布

西安真的好热

最新推荐文章于 2023-02-17 19:48:44 发布

阅读量830

点赞数 2

分类专栏： python学习文章标签： python3 面向对象

本文链接：https://blog.csdn.net/xdzhangzhenhao/article/details/79190453

版权

python学习专栏收录该内容

2 篇文章 1 订阅

订阅专栏

1. case_1:简单的类，类方法创建

class Cat:
    
    def __init__(self, new_name):
        self.name=new_name
        print("%s 来了" % self.name)
        
    def __del__(self):
        print("%s 去了" % self.name)
        
#    def __str__(self):
#        return "我是小猫【%s】" % self.name
    
    """
    def eat(self, new_name):
        self.name=new_name
        print(" %s 爱吃鱼" %self.name)
        
    def drink(self, new_name):
        self.name=new_name
        print(" %s 爱喝水" %self.name)
    """      
        
#创建猫对象
tom=Cat("Tom")
print(tom)
print(tom)

del tom

输出：

Tom 来了
Tom 去了
<__main__.Cat object at 0x0000000005FD1588>
<__main__.Cat object at 0x0000000005FD1588>
Tom 去了

2. case_2:小明爱跑步

class Person:
    
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight
        print("我是 %s,我被创建出来了,weight: %.2f" % (self.name,self.weight))
        
    def __str__(self):
        return "我是 %s,大家好" % self.name
        
    def run(self):
        self.weight -= 0.5
        print("now weight:%.2f" % self.weight)
        
    def eat(self):
        self.weight += 1
        print("now weight:%.2f" % self.weight)
        

xiaoming=Person("小明",65)
xiaoming.run()
xiaoming.eat()
print(xiaoming)

输出：

我是 小明,我被创建出来了,weight: 65.00
now weight:64.50
now weight:65.50
我是 小明,大家好

3. case_3:添加家具

class HouseItem:
    """家具类"""
    def __init__(self, name, area):
        self.name = name
        self.area = area
        
    def __str__(self):
        return "[%s] 占地：%.2f" % (self.name, self.area)
        
    
class House:
    """房子类"""
    def __init__(self, house_type, area):
        self.house_type=house_type
        self.area=area
        
        self.free_area=area
        self.item_list=[]
        
    def __str__(self):
        return ("户型： %s\n总面积： %.2f[剩余： %.2f]\n家具： %s" 
                % (self.house_type, self.area, 
                   self.free_area, self.item_list))
        
    def add_item(self, item):
        print("要添加 %s" % item)
        #1.判断家具的面积
        if item.area > self.free_area:
            print("%s 的面积太大了，无法添加" % item.name)
            return
        
        #2.将家具的名称添加到列表中
        self.item_list.append(item.name)
        
        #3.计算剩余面积
        self.free_area -= item.area
        
        
        
#1. 创建家具
bed=HouseItem("席梦思", 400)
chest=HouseItem("衣柜", 2)
table=HouseItem("餐桌", 1.5)

print(bed)
print(chest)
print(table)

#2. 创建房子对象
my_house = House("两室一厅", 60)
my_house.add_item(bed)
my_house.add_item(chest)
my_house.add_item(table)
print(my_house)

输出：

[席梦思] 占地：400.00
[衣柜] 占地：2.00
[餐桌] 占地：1.50
要添加 [席梦思] 占地：400.00
席梦思 的面积太大了，无法添加
要添加 [衣柜] 占地：2.00
要添加 [餐桌] 占地：1.50
户型： 两室一厅
总面积： 60.00[剩余： 56.50]
家具： ['衣柜', '餐桌']

4. case_4:士兵突击（面对对象封装案列）

class Gun:
    def __init__(self, model):
        #1. 枪的型号
        self.model = model
        #2. 子弹的数量初始化为0
        self.bullet_count = 0
        
    def add_bullet(self, count):
        self.bullet_count += count
        
    def shoot(self):
        #1. 判断子弹的数量
        if self.bullet_count <= 0:
            print("[%s]没有子弹了..." % self.model)
            return

        #2. 发射子弹，-1
        self.bullet_count -=1
        
        #3. 提示发射信息
        print("[%s]突突突...[%d]" % (self.model, self.bullet_count))
        
        
class Soldier:
    def __init__(self, name):
        #1. 姓名
        self.name = name
        #2. 枪 - 默认新兵没有枪
        self.gun = None
        
    def fire(self):
        #1. 判断士兵是否有枪
        if self.gun is None:
            print("[%s] 还没有枪..." % self.name)
            return
        #2. 高喊口号
        print("冲啊...[%s]" % self.name)
        #3. 让枪填装子弹
        if self.gun.bullet_count <= 0:
            self.gun.add_bullet(50)    
        #4. 让枪发射子弹
        self.gun.shoot()
        
        
#1. 创建枪对象
ak47 = Gun("AK47")

ak47.add_bullet(100)
ak47.shoot()

#2. 创建许三多
xusanduo = Soldier("许三多")
xusanduo.gun = ak47
xusanduo.fire()
print(xusanduo.gun)

输出：

[AK47]突突突...[99]
冲啊...[许三多]
[AK47]突突突...[98]
<__main__.Gun object at 0x0000000005FC7C18>

5. 私有属性,私有方法,继承,重写,扩展

只要在属性变量的前面加两个下划线，例如：__agr

重写：当父类大方法实现满足不了子类需求时，可以对方法进行重写

case_5:

class Animal:
    def walk(self):
        print("走---")
        
    def run(self):
        print("跑---")
        
    def eat(self):
        print("吃---")
        
                
class Dog(Animal):
    def bark(self):
        print("汪汪叫")
        
        
class Cat_1(Animal):
    def catch(self):
        print("抓老鼠")
        
        
class XiaoTianQuan(Dog):
    def fly(self):
        print("我会飞")
    # 方法扩展的代码
    def bark(self):
        #1. 针对子类特有的要求，编写代码
        print("流披如我...")
        #2. 使用super(). 调用原本在父类中封装的方法
        super().bark()
        #3. 增加其他子类的代码
        print("$%^*$%^*$%^*$%^*")
        
        
    # 方法重写的代码    
#    def bark(self):
#        print("流披如我...")

        
        
# 创建一个哮天犬的对象
xtq = XiaoTianQuan()

xtq.fly()
xtq.bark()
xtq.walk()
#xtq.catch()

输出：

我会飞
流披如我...
汪汪叫
$%^*$%^*$%^*$%^*
走---

6. case_6:父类的私有属性和私有方法案列

class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200
        
    def __test(self):
        print("私有方法 %d %d" % (self.num1,self.__num2))
        
    def test(self):
        print("父类的公有方法 %d" % self.__num2)
        self.__test()
        
        
class B(A):
    def demo(self):
        #1. 在子类的对象方法中，不能访问父类的私有属性
        #print("访问父类的私有属性 %d" % self.__num2)
        #2. 在子类的对象方法中，不能调用父类的私有方法
        #self.__test()
        #3. 访问父类的公有属性
        print("子类方法 %d" % self.num1)
        #4. 调用父类的公有方法
        self.test()
        
        
# 创建一个子类对象
b = B()
print(b)

b.demo()
# 在外界访问父类的公有方法/调用公有方法
#print(b.num1)
#b.test()

# 在外界不能直接访问对象的私有属性/调用方法
#print(b.__num2)
#b.__test()

输出：

<__main__.B object at 0x0000000005323BA8>
子类方法 100
父类的公有方法 200
私有方法 100 200

7. case_7:多继承案列

class AA:
    def test(self):
        print("AA --- test 方法")
        
    def demo(self):
        print("AA --- demo 方法")
        
        
class BB:
    def test(self):
        print("BB --- test 方法")
        
    def demo(self):
        print("BB --- demo 方法")
        
        
class C(AA, BB):
    """多继承可以让子类对象，同时具有多个父类的属性和方法"""
    pass


# 创建子类对象
c = C()

c.test()
c.demo()

# 确定C类对象调用方法的顺序
print(C.__mro__)

输出：

AA --- test 方法
AA --- demo 方法
(<class '__main__.C'>, <class '__main__.AA'>, <class '__main__.BB'>, <class 'object'>)

8. case_8:多态案例

class Dog(object):
    def __init__(self, name):
        self.name = name
        
    def game(self):
        print("[%s] 普通的狗狗就普通地玩耍" % self.name)
        
        
class XiaoTianDog(Dog):
    def game(self):
        print("[%s] 不普通的狗狗就不普通地玩耍" % self.name)
        
        
class Person(object):
    def __init__(self, name):
        self.name = name
        
    def game_with_dog(self, dog):
        print("%s 和 %s 快乐的玩耍..." % (self.name, dog.name))
        # 让狗狗玩耍
        dog.game()
        
        
#1. 创建一个狗对象
#wangcai = Dog("旺财")
wangcai = XiaoTianDog("飞天旺财")
#2. 创建一个小明对象
xiaoming = Person("小明")
#3. 让小明调用和狗玩耍的方法
xiaoming.game_with_dog(wangcai)

输出：

小明 和 飞天旺财 快乐的玩耍...
[飞天旺财] 不普通的狗狗就不普通地玩耍

9. case_9:类属性和类方法案列

class Tool(object):
    # 使用赋值语句，定义类属性，记录创建工具对象的总数(不会用于记录具体对象的特征)
    count = 0
    
    @classmethod
    def show_tool_count(cls):
        print("工具对象的数量 %d" % cls.count)
    
    def __init__(self, name):
        self.name = name
        #针对类属性做一个计数+1
        Tool.count += 1
        
        
# 创建工具对象
tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("铁锹")

print(tool1.count)
print(tool2.count)
print(tool3.count)
print(Tool.count)
Tool.show_tool_count()

输出：

3
3
3
3
工具对象的数量 3

10. case_10:静态方法案列（静态方法既不需要访问实例属性或者调用实例方法也不需要访问类属性或者调用类方法）

class Dog(object):
    # 狗对象计数
    dog_count = 0
    
    @staticmethod
    def run():
        # 不需要访问实例属性也不需要访问类属性的方法
        print("狗在跑...")
        
    def __init__(self, name):
        self.name = name
        
        
# 通过类名.调用静态方法 - 不需要创建对象
Dog.run()

输出：

狗在跑...

11. case_11: 方法综合案例

class  Game(object):
    # 类属性
    top_score = 66
    
    # 类方法
    @classmethod
    def show_top_score(cls):
        print("历史最高分：%d" % cls.top_score)
        
    # 静态方法
    @staticmethod
    def show_help():
        print("游戏帮助信息")
        
    def __init__(self, name):
        self.name = name
        
    def start_game(self):
        print("%s 请您做好准备，游戏即将开始" % self.name)
        
        
#1. 查看游戏帮助
Game.show_help()
#2. 查看历史高分
Game.show_top_score()
#3. 创建游戏对象，开始游戏
game = Game("小明")
game.start_game()

输出：

游戏帮助信息
历史最高分：66
小明 请您做好准备，游戏即将开始

12. __new__方法

__new__方法是内置的静态方法，主要有两个作用：
1. 在内存空间中为对象分配空间
2. 返回对象的应用

Python的解释器获得对象的引用后，将引用作为第一个参数传递给__init__

case_12:

class MusicPlayer(object):
    """ *args多值的元组参数, **kwargs多值的字典参数"""
    def __new__(cls, *args, **kwargs):
        #1. 创建对象时，new方法会被自动调用
        print("创建对象，分配空间")
        #2. 为对象分配空间,通过调用父类的new方法
        instance = super().__new__(cls)
        #3. 返回对象的引用
        return instance
    
    def __init__(self):
        print("播放器初始化")
        
        
# 创建播放器对象
player = MusicPlayer()
print(player)

player_another = MusicPlayer()
print(player_another)

输出：

创建对象，分配空间
播放器初始化
<__main__.MusicPlayer object at 0x0000000007922F98>
创建对象，分配空间
播放器初始化
<__main__.MusicPlayer object at 0x0000000007905B38>

13. 单例设计模式

目的：让类创建的对象，在系统中只有唯一的一个实例
case_13:

class MusicPlayer(object):
    # 定义类属性记录单例对象引用
    instance = None
    # 记录是否执行过初始化方法
    init_flag = False
    
    def __new__(cls, *args, **kwargs):
        #1. 判断类属性是否已经被赋值
        if cls.instance is None:
            #2. 调用父类的方法，为第一个对象分配空间
            cls.instance = super().__new__(cls)
        #3. 返回对象引用
        return cls.instance
    
    def __init__(self):
        #1. 判断类是否执行过初始化动作
        if MusicPlayer.init_flag:
            return
        #2. 如果没有执行过，则执行初始化动作
        print("初始化播放器")
        #3. 修改类属性的标记
        MusicPlayer.init_flag = True
                  
            
# 创建多个对象
player1 = MusicPlayer()
print(player1)

player2 = MusicPlayer()
print(player2)

输出：

初始化播放器
<__main__.MusicPlayer object at 0x0000000005D0A9E8>
<__main__.MusicPlayer object at 0x0000000005D0A9E8>

14. 异常

在程序开发中，如果对某些代码的执行不能确定是否正确，可以增加try（尝试）来捕获异常

try：下方编写要尝试代码，不能确定是否能够正常执行的代码

except：如果不是，下方编写尝试失败的代码

case_14:

try:
    # 不能确定正确执行的代码
    num = int(input("请输入一个整数："))
except:
    # 错误的处理代码
    print("请输入正确的整数")
    
print("-" * 50)

输出：

请输入一个整数：d
请输入正确的整数
--------------------------------------------------

15. 错误类型捕获

case_15_1:已知错误类型进而捕获

try:
    # 提示用户输入一个整数
    num = int(input("请输入一个整数："))

    # 使用8除以用户输入的整数并且输出
    result = 8 / num

    print(result)
except(ZeroDivisionError):
    print("除0错误")
except ValueError:
    print("请输入正确的整数")

输出：

请输入一个整数：a
请输入正确的整数

case_15_2:捕获未知错误

如果希望程序无论出现任何错误，都不会因为python解释器抛出的异常而终止，可以在增加一个except

try:
    # 提示用户输入一个整数
    num = int(input("请输入一个整数："))

    # 使用8除以用户输入的整数并且输出
    result = 8 / num

    print(result)
except ValueError:
    print("请输入正确的整数")
except Exception as result:
    print("未知错误 %s" % result)

输出：

请输入一个整数：0
未知错误 division by zero

16. case_16: 完整的异常语法

try:
    # 提示用户输入一个整数
    num = int(input("请输入一个整数："))

    # 使用8除以用户输入的整数并且输出
    result = 8 / num

    print(result)
except ValueError:
    print("请输入正确的整数")
except Exception as result:
    print("未知错误 %s" % result)
else:
    print("尝试成功才会出现的代码")
finally:
    print("无论是否出现错误都会执行的代码")

输出：

请输入一个整数：10
0.8
尝试成功才会出现的代码
无论是否出现错误都会执行的代码

17. 异常的传递

当函数/方法执行出现异常，会将异常传递黑函数/方法的调用一方，如果传递到主程序，荏苒没有异常处理，程序才会被终止

case_17:

def demo1():
    return int(input("请输入整数:"))

def demo2():
    return demo1()

#print(demo2())

# 利用异常的传递性，在主程序捕获异常
try:
    print(demo2())
except Exception as result:
    print("未知错误 %s" % result)

输出：

请输入整数:j
未知错误 invalid literal for int() with base 10: 'j'

18. 主动抛出异常（根据应用程序特有的业务需求主动抛出异常）

创建一个Exception的对象
使用raise关键字抛出一场对象

case_18:

def input_password():
    #1. 提示用户输入密码
    pwd = input("请输入密码：")
    #2. 判断密码长度 >= 8，返回用户输入的密码
    if len(pwd) >= 8:
        return pwd
    #3. 如果 < 8，主动抛出异常
    print("主动抛出异常")
    # 1> 创建异常对象 - 可以使用错误信息字符串作为参数（描述信息）
    ex = Exception("密码长度不够")
    # 2> 主动抛出异常
    raise ex
    
# 提示用户输入密码
try:
    print(input_password())
except Exception as result:
    print(result)

输出：

请输入密码：123
主动抛出异常
密码长度不够

19. 模块

每一个以扩展名py结尾的python原地阿妈文件都是一个模块（全局变量，函数，类）

case_19:

import test_module_1 as DogModule
import test_module_2 as CatModule
import random

#test_module_1.say_hello()
#test_module_2.say_hello()
DogModule.say_hello()
CatModule.say_hello()

#dog = test_module_1.Dog()
##print(dog)
dog = DogModule.Dog()
print(dog)

#cat = test_module_2.Cat()
#print(cat)
cat = CatModule.Cat()
print(cat)

print(DogModule.__file__)
print(random.__file__)

输出：

我是 模块1
我是 模块2
<test_module_1.Dog object at 0x000000000538A9E8>
<test_module_2.Cat object at 0x0000000005D0AA90>
D:\pythonCode\pythonHeiMa\test_module_1.py
d:\python3.6\lib\random.py

20. 包（package）

包是一个包含多个模块的特殊目录（目录下必须包含init.py），包名的命名方式和变量名一致，小写字母+_

hm_message为制作的package

21. 文件基本操作

打开文件
读，写文件
关闭文件

操作文件的函数和方法

open 打开文件，并且返回文件操作对象
read 将文件内容读取到内存
write 将指定的内容写入文件
close 关闭文件

访问方式说明

r 以只读方式打开文件（默认模式）

w 只写方式（如果文件存在则会被覆盖，不存在则创建）

a 以追加的方式打开文件，文件指针放在文件的结尾

r+ 以读写方式打开文件（如果文件不存在，抛出异常）

w+ 以读写方式打开文件（如果文件存在则会被覆盖，不存在则创建）

a+ 以读写方式打开文件（如果文件存在，文件指针将会放在文件的结尾，不存在则创建）

readline方法：一次读取一行，方法执行后，会把文件指针移动到下一行，准备再次读取

case_21_1:

#1. 打开文件
file = open("README", "w")
#2，文件读写
file.write("hello")
#3. 文件关闭
file.close()

file = open("README")
text = file.read()
print(text)
file.close()

输出：

hello

case_21_2:

# 大文件复制
#1. 打开文件
file_read = open("README")
file_write = open("README[附件]", "w")

#2，文件读写
while True:
    # 读取一行内容
    text = file_read.readline()
    
    # 判断是否读取到内容
    if not text:
        break
        
    file_write.write(text)
    
#3. 文件关闭
file_read.close()
file_write.close()

22. 文件/目录的常用管理操作（需要导入os模块）

文件操作：

os.rename(源文件，目标文件)
os.remove(文件名)

目录操作：

os.listdir(目录名)
os.mkdir(目录名)
os.rmdir(目录名)
os.getcwd():获取当前目录
os.chdir(目录名):修改工作目录
os.path.isdir(文件路径)：判断是否是文件

23. 文本文件的编码格式

python2.x 默认使用ASCII编码 python3.x 默认使用UTF-8编码

ASCII编码：

只有256个ASCII字符
一个ASCII在内存中占用一个字节的空间

UTF-8编码格式：

计算机中使用1~6个字节来表示一个UTF-8字符，涵盖了地球上几乎所有地区的文字
大多数汉字使用3个字节表示
UTF-8是UNICODE编码的一种编码格式

python2.x中使用中文方法：

在文件第一行增加以下注释代码，解释器会以UTF-8编码来处理文件

# *-* coding:utf8 *-*

或者

# coding=utf8

case_23:

# *-* coding:utf8 *-*

# 引号前面的u告诉解释器这是一个utf8编码格式的字符串(针对python2的改动)
hello_str = u"hello世界"

print(hello_str)

for c in hello_str:
    print(c)

输出：

hello世界
h
e
l
l
o
世
界

最后感谢黑马python面向对象的优秀教学视频。

西安真的好热

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录