Python全栈工程师（面向对象）

ParisGabriel

 

 

 

         每天坚持手写  一天一篇  决定坚持几年 为了梦想为了信仰

 

　 开局一张图

　　　　　　　　　　　　　　　　　　　　　　Python人工智能从入门到精通

day16补充：

异常处理 文件操作综合练习示例

src_filename = input("请输入源文件路径名: ")
dst_filename = input('请输入目标文件路径名: ')
try:
    src = open(src_filename, 'rb')  # 打开源文件用来读数据
    try:
        try:
            dst = open(dst_filename, 'wb')  # 打开目标文件用来写
            try:
                while True:
                    b = src.read(4096)  # 4096当前Linux系统内核字节大小
                    if not b:  # 已经再也读不到数据了
                        break
                    dst.write(b)  # 写字节到文件
                print("复制成功")
            finally:
                dst.close()  # 必须关闭文件
        except OSError:
            print("打开写文件失败")
    finally:
        src.close()  # 必须关闭文件
except OSError:
    print("复制失败")

面向对象编程：
         以函数单位

面向对象编程 Ojbect-Oriented Programing
什么是对象：
　　对象是指现实中的物体或实物
　　　　对象有什么属性：
　　　　对象有很多属性（名词，形容词）
　　　　　　姓名， 年龄， 性别
　　　　对象有很多行为（动作，动词）
　　　　　　吃饭，睡觉，工作
面向对象：
　　把一切都看作对象（实例） 用各种对象之间的关系来描述事务
什么是类：
　　拥有相同属性和行为的对象分为一组， 即为一个类
　　类是用来描述对象的工具，用类可以创建此类的对象（实例）
面向对象示意：
　　车（类）----> BYD E6(京A：88888)实例（对象）
　　　　　　
　　　　　　 ----> BMW X5(京A：66666)实例（对象）
　　狗（类）----> 小京巴(户籍号：0000001)实例（对象）
　　　　　　
　　　　　　 ----> 导盲犬(户籍号：0000002)实例（对象）
　　int（类）----> 100（对象）
　　　　　　
　　　　　　 ----> 500（实例、对象）
类的创建语句：
　　class 类名（继承列表）：
　　　　‘类的文档字符串’
　　　　实例方法的定义
　　　　类变量的定义
　　　　类方法的定义（@classmethod）
　　　　静态方法的定义（@staticmethod）
　　作用：
　　　　创建一个类
　　　　类用于描述对象的行为和属性
　　　　类用于创建此类的一个或多个对象
　　说明：
　　　　类名必须是标识符
　　　　类名实质上就是变量， 它绑定一个类
示例：

# 用class语句　创建一个类

class Dog:
    '''    这是文档字符串　　描述一些小动物    '''
    pass

构造函数
　　构造函数的调用表达式
　　语法：
　　　　类名（[创建传参列表]）
　　作用：
　　　　创建这个类的实例对象，并返回此实例的引用关系

示例：

dog1 = Dog()  # 调用构造函数创建一个实例对象　再用dog1绑定
print(id(dog1))
dog2 = Dog()  # 创建另一个实例对象
print(id(dog2))


lst1 = list()  # 调用构造函数创建一个列表对象
print(id(lst1))
lst2 = list()  # 创建另一个实例对象
print(id(lst2))

实例说明：
　　1.实例有自己的作用域和空间名， 可以为该类添加实例变量（也叫属性）
　　2.实例可以调用类的方法和实例方法
　　3.实例可以访问类变量和实例变量

　　实例方法：
　　　　语法：
　　　　　　class 类名（继承列表）
　　　　　　　　def 实例方法名（self， 参数1， 参数2...）：
　　　　　　　　　　‘文档字符串’
　　　　　　　　　　语句
　　　　作用：
　　　　　　用于描述一个对象的行为， 让此类型的全部对象都拥有相同的行为
　　　　说明：
　　　　　　实例方法实质是函数， 是定义类的函数
　　　　　　实例方法至少有一个形参， 第一个形参代表调用方法的实例， 一般命名为“self”
　　实例方法语法：
　　　　实例.实例方法名（调用传参）
　　　　或
　　　　实例.实例方法名（实参， 调用传参）

示例：

# 实例方法的创建和调用


class Dog:
    '''    这是文档字符串　　描述一些小动物    '''
    def eat(self, food):
        '''此方法用来描述小狗吃的行为'''
        print("小狗正在吃", food)

    def slep(self, hour):
        '''此方法用来描述小狗睡的行为'''
        print("小狗睡了%d小时" % hour)

    def play(self, obj):
        '''此方法用来描述小狗玩的行为'''
        print("小狗正在玩", obj)


dog1 = Dog()  # 调用构造函数创建一个实例对象　再用dog1绑定
dog1.eat("单身狗粮")
dog1.slep(3)
dog1.play("球")

dog2 = Dog()
dog2.eat("提子")  # 创建另一个实例对象
dog1.slep(5)
dog1.play("MM")


======================
>>> import day17
小狗正在吃 单身狗粮
小狗睡了3小时
小狗正在玩 球
小狗正在吃 提子
小狗睡了5小时
小狗正在玩 MM
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'day17']
>>> dir(day17)
['Dog', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'dog1', 'dog2']
>>> help(day17)

>>> help(list)
======================

实例属性 atribute（也叫实例变量）
　　每个实例对象可以有自己的变量， 称为实例变量（也叫属性）
　　语法：
　　　　实例.属性名
　　赋值规则：
　　　　首次为属性赋值则创建此属性
　　　　再次为属性赋值则修改属性的绑定关系
　　作用：
　　　　记录每个对象自身数据

示例：

# 属性的方法


class Dog:
    '''    这是文档字符串　　描述一些小动物    '''
    def eat(self, food):
        '''此方法用来描述小狗吃的行为'''
        print(self.color, "的", self.kinds, "小狗正在吃", food)
        # 让调用此方法的对象添加一个last_food属性用来记住吃过的信息（方法内添加属性）
        self.last_food = food


# 方法外添加属性
dog1 = Dog()  # 调用构造函数创建一个实例对象　再用dog1绑定
dog1.kinds = "京巴"  # 为dog1对象添加kinds属性，　绑定为"京巴"
dog1.color = "白色"  # 为dog1对象添加　color　＂白色＂属性
dog1.color = "原谅色"  # 改变dog1对象　color属性
print(dog1.color, "的", dog1.kinds)  # 原谅色 的 京巴

dog2 = Dog()
# print(dog2.color, "的", dog2.kinds)  # 出错

dog2.kinds = "二哈"  # 为dog2对象添加kinds属性，　绑定为"二哈"
dog2.color = "白色"  # 为dog2对象添加　color　＂白色＂属性
dog2.color = "黄色"  # 改变dog2对象　color属性

print(dog2.color, "的", dog2.kinds)  # 黄色 的 二哈

dog1.eat("单身狗粮")  # 原谅色 的 京巴 小狗正在吃 单身狗粮
dog2.eat("爱心蛋糕")  # 黄色 的 二哈 小狗正在吃 爱心蛋糕


# 可以在方法（函数）外添加对象属性也可以在方法内添加　通常在方法内（函数）

删除属性：
del
例如：
　　class Dog:
　　　　pass
　　dog1 = Dog()
　　dog1.color = "白色"
　　del dog1.color

del 变量名 　　　　　  　 删除变量
del 列表[整数表达式]　　  删除列表元素
del 字典[键] 　　   　　     删除字典中的键
del 对象.属性 　　　　　 删除对象的属性

初始化方法：
　　作用：
　　　　对新创建的对象添加属性
　　语法：
　　　　def __init__（self[, 形参列表]）：
　　　　　　语句块
　　[ ] 代表可省略
　　说明：
　　　　1.初始化方法名必须为‘__init__’不可改变
　　　　2.初始化方法在构造函数创建实例后自动调用，且将实例自身
　　　　通过第一个参数 self 传入__init__方法
　　　　3.构造函数的实参将通过__init__方法的参数列表传入到‘__init__’方法中
　　　　4.初始化方法内如果需要return语句返回 则返回None

示例：

# 初始化方法　__init__

class Car:
    '''定义汽车类'''
    def __init__(self, c, b, m):
        self.color = c  # 颜色
        self.brand = b  # 品牌
        self.model = m  # 型号
        print('__init__方法被调用')

    def run(self, speed):
        print(self.color, "的", self.brand, self.model,
              "正才以", speed, "公里没小时行驶")


a4 = Car("红色", "奥迪", "A4")  # 调用构造函数
a4.run(1000)  # 红色 的 奥迪 A4 正才以 1000 公里没小时行驶
s3 = Car("蓝色", "TESLA", "Model S")  # 调用构造函数
s3.run(6000)  # 蓝色 的 TESLA Model S 正才以 6000 公里没小时行驶

析构方法：
　　语法：
　　　　class 类名：
　　　　　　def __del__(self):
　　　　　　...
　　说明：
　　　　析构方法在对象被销毁时会自动调用
　　　　Python建议不要在对象销毁时做任何事情， 因为销毁时间难以确定
示例：

# 析构方法


class Car:
    def __init__(self, name):
        self.name = name
        print("汽车", name, "被创建")

    def __del__(self):
        '''析构方法，对象被销毁时　次方法调用'''
        print("汽车", self.name, "被销毁")


c1 = Car("BYD E6")
input("此汽车是伪造！　　按回车继续程序...")

# 汽车 BYD E6 被创建
# 此汽车是伪造！　　按回车继续程序...
# 汽车 BYD E6 被销毁
c2 = c1
del c2
input()  # 汽车 BYD E6 被创建

预置实例属性：
　　__dict__属性
　　　　__dict__属性绑定一个储存此实例自身变量的字典
示例：

>>> class Dog:
...     pass
>>> dog1 = Dog()
>>> dog1.name = "哈哈"
>>> dog1.__dict__
{'name': '哈哈'}
>>> dog1.age = 3
>>> dog1.__dict__
{'age': 3, 'name': '哈哈'}
>>> del dog1.age
>>> dog1.__dict__
{'name': '哈哈'}
>>> 

　　__class__属性
　　　　此属性用于绑定创建一些实例的类
　　作用：
　　　　可以借助于此属性来访问创建此实例的类
示例：

>>> class Dog:
...     pass
... 
>>> dog1 = Dog()
>>> Dog
<class '__main__.Dog'>
>>> dog1.__class__
<class '__main__.Dog'>
>>> type(dog1)
<class '__main__.Dog'>
>>> type(dog1) is Dog
True
>>> dog2 = dog1.__class__()  # 等同于 dog2 = Dog()
>>> dog2.__class__
<class '__main__.Dog'>

 

面向对象的综合示例：
有两个人：
　　1.
　　　　姓名：张三
　　　　年龄：25
　　2.
　　　　姓名：李四
　　　　年龄：5
　　行为：
　　　　1.教别人学学东西 teach
　　　　2.赚钱 works
　　　　3.借钱 borrow
　　事情：
　　　　张三 教 李四 学 Python
　　　　李四 教 张三 学 跳皮筋
　　　　张三 上班赚了 1000 元钱
　　　　李四 向 张三 借了 200 元钱
　　　　打印张三的信息：25岁 的 张三 有钱 800元 他学会了跳皮筋
　　　　打印李四的信息：5岁 的 李四 有钱 200元 他学会了python

class Human:
    '''描述人的行为和属性

    teach(self, other, subject)
       　学习技能
    works(self, money)
        赚钱
    borrow(self, other, money)
        借钱
    def print_info(self)
        输出信息

    '''
    def __init__(self, name, age):
        '''初始化基本信息和属性'''
        self. name, self.age = name, age  # 名字，　年龄
        self.money = 0  # 钱数
        self.skill = []  # 技能列表

    def teach(self, other, subject):
        '''实例行参对象1　教　实例行参对象2　学　技能的实例方法

        　　　self:实例形参1（调用对象自己）
        　　　other: 实例形参2　（调用目标对象）
        　　　subject: 技能
        '''

        other.skill.append(subject)  # 行参对象2　追加新技能
        print(self.name, "教", other.name, "学", subject)

    def works(self, money):
        '''实例行参对象的　赚钱　实例方法

        　　　self:实例行参（调用对象自己）
        　　　money:赚的钱数
        '''
        self.money = money  # 实例形的钱数
        print(self.name, "上班赚了", money, "元钱")

    def borrow(self, other, money):
        '''实例行参对象1　向　实例行参对象2　借钱　的实例方法

        　　　self:实例形参1（调用对象自己）
        　　　other: 实例行参2　（调用目标对象）
        　　　monay: 接的钱数
        '''
        if other.money > money:  # 目标对象的钱小于借钱数额　借钱失败
            self.money += money  # 自己的钱
            other.money -= money  # 目标对象剩余的钱
            print(self.name, "向", other.name, "借了", self.money, "元钱")
        else:
            print(self.name, "向", other.name, "借钱失败！")

    def print_info(self):
        '''打印输出self的信息实例方法
        　　　self:实例行参（调用对象自己）
        '''
        print(self.age, "岁的", self.name,
              "有钱", self.money, "元　他学会了：", self.skill)


zhang3 = Human("张三", 25)
li4 = Human("李四", 5)
# 张三教李四Python
zhang3.teach(li4, "Python")
# 李四教张三玩游戏
li4.teach(zhang3, "玩游戏")
# 张三上班赚了　1000　元钱
zhang3.works(1000)
# 李四向张三借　200　元钱
li4.borrow(zhang3, 200)
# 打印李四信息
li4.print_info()
# 打印张三信息
zhang3.print_info()

#  第一个实例形参一般为调用者自己
# （自动传参自己　不需要填写　直接从第二个形参开始）
#  __init__()初始化信息函数内的属性为公用属性
#  初始化对象后每个对象都会调用__init__内的属性
#  其他方法（单独属性）另需调用

用于类的函数：
　　isinstance（obj, class_or_tuple）
　　返回这个对象obj是否是某个类的对象或某些类中的一个类的对象,
　　如果是则返回True,否则返回False
　　type(obj) 返回对象的类型

>>> a = 100
>>> isinstance(a, int)
True
>>> isinstance(a, bool)
False
>>> a = 100.0
>>> isinstance(a, int)
False
>>> isinstance(a, float)
True
>>> type(a)
<class 'float'>
>>> a = 100
>>> type(a)
<class 'int'>
>>> 

练习:
自己写一个'人'类: Human
class Human:
def set_info(self, name, age, address='未知'):
'''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性'''
... # << 此处自己实现
def show_info(self):
'''显示此人的全部信息'''
... # 此处自己实现
如:
h1 = Human()
h1.set_info('小张', 20, '北京市朝阳区')
h2 = Human()
h2.set_info('小李', 18)
h1.show_info() # 小张今年 20 岁,家庭住址:北京市朝阳区
h2.show_info() # 小李今年 18 岁,家庭住址:末知

答案：

class Human:
    def set_info(self, name, age, address='未知'):
        '''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性'''
        self.name = name
        self.age = age
        self.address = address

    def show_info(self):
        '''显示此人的全部信息'''
        print(self.name, '今年',
              self.age, '岁,家庭住址:',
              self.address)


h1 = Human()
h1.set_info('小张', 20, '北京市朝阳区')
h2 = Human()
h2.set_info('小李', 18)
h1.show_info()  # 小张今年 20 岁,家庭住址:北京市朝阳区
h2.show_info()  # 小李今年 18 岁,家庭住址:末知

class Human:
    def set_info(self, name, age, address='未知'):
        '''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性'''
        self.name = name
        self.age = age
        self.address = address

    def show_info(self):
        '''显示此人的全部信息'''
        print(self.name, '今年',
              self.age, '岁,家庭住址:',
              self.address)


h1 = Human()
# h1.set_info('小张', 20, '北京市朝阳区')
Human.set_info(h1, '小张', 20, '北京市朝阳区')
h1.show_info()  # 小张今年 20 岁,家庭住址:北京市朝阳区

练习:
写一个Student类
1) 为该类添加初始化方法, 实现在创建对象时自动设置
'姓名','年龄', '成绩' 属性
2) 添加set_score方法能修改成绩信息
3) 添加show_info方法打印学生对象的信息

如:
class Student:
def __init__(...):
...
...

s1 = Student('小王', 15, 59)
s1.show_info() # 小王 今年 17 岁, 成绩是: 59
s1.set_score(80)
s1.show_info() # 小王 今年 17 岁, 成绩是: 80

答案：

class Student:
    def __init__(self, n, a, s):
        self.name, self.age, self.score = n, a, s

    def show_info(self):
        print(self.name, '今年',
              self.age, '岁, 成绩是:',
              self.score)

    def set_score(self, s):
        assert 0 <= s <= 100, '参数错误'
        self.score = s


s1 = Student('小王', 15, 59)
s1.show_info()  # 小王 今年 17 岁, 成绩是: 59
s1.set_score(80)  # s1.score = 80
s1.show_info()  # 小王 今年 17 岁, 成绩是: 80

上面两个练习我写了一份很详细的  明天改 这个先凑合着...

练习:
修改原来的学生信息管理程序,将原来字典来存储学生信息,
现改为用对象来存储学生信息
# file : student.py
class Student:
def __init__(self, n, a, s):
....

L = []
# L.append({...}) 改为对象
L.append(Student('xiaozhang', 20, 100))

(要求类Student 要写在模块 student.py中)

 示例：

# 假如文件中有这么多学生信息

L = [{"name": "Tom", "age": 15, "score": 98},
     {"name": "AL", "age": 16, "score": 95},
     {"name": "Lix", "age": 16, "score": 95},
     {"name": "Li", "age": 16, "score": 95},
     {"name": "ix", "age": 16, "score": 95},
     {"name": "ix", "age": 16, "score": 95},
     {"name": "Ax", "age": 16, "score": 95},
     {"name": "i", "age": 16, "score": 95},
     {"name": "x", "age": 16, "score": 95},
     {"name": "Lx", "age": 16, "score": 95},
     {"name": "ALi", "age": 16, "score": 95},
     {"name": "Ka", "age": 16, "score": 95},
     {"name": "Kla", "age": 16, "score": 95},
     {"name": "KAl", "age": 16, "score": 95},
     {"name": "Ala", "age": 16, "score": 95},
     {"name": "Al", "age": 16, "score": 95},
     {"name": "KAla", "age": 17, "score": 100}]


class Student:
    '''创建学生类用来描述学生基本信息'''
    def __init__(self, n, a, s):
        '''初始化学生信息'''
        self.name, self.age, self.score = n, a, s

    def student_info(self):
        '''输出此学生信息'''
        print("Name:", self.name,
              "Age:", self.age,
              "score:", self.score)


def student_list(L):
    '''将文件内学生信息编号存入列表'''
    L1 = []
    for x, y in zip(L, range(1, len(L) + 1)):
        y = Student(x["name"], x["age"], x["score"])
        L1.append(y)
    return L1
# 也可以用迭代器函数
# def student_list():
#     for x in L:
#         y = Student(x["name"], x["age"], x["score"])
#         yield y
# 输出所有学生信息


def print_student(L):
    '''输出有所有学生信息'''
    for stud in L:
        stud.student_info()


print_student(student_list(L))