python基础day17笔记

2018.7.24

day16回顾：

文件

文本模式：

  把文件的字节码自动转换为字符串

  换行符会自动转化为'\n'

  F.read()

  F.readline()

  F.readlines()

  F.write

二进制模式：
  通过字节串（字节数组）进行读写

  F.read()

  F.write()

  F.tell()

  F.seek()

文件流对象是可迭代对象：

f = open('xxx.py')

for line in f:

    ....

汉字编码：

  国标：GB18030(GBK,GB2312)

day17

面向过程编程：

  函数做单位

面向对象编程 object-oriented programing

什么是对象：

  对象是指现实中的物体或实体

对象有什么特征：

  对象有很多属性（名词，形容词）

  姓名，年龄，性别

对象有很多行为（动作，动词）

  学习，吃饭，睡觉，踢球，工作，借钱

面向对象：

  把一切都看成对象（实例）用各种对象之间的关系来描述事务

 

什么是类：

  拥有相同属性和行为的对象分为一组，即为一个类

  类是用来描述对象的工具，用类可以创建此类的对象（实例）

面向对象示意：

  车(类)  ----->> BYD E6(京A.88888) 对象(实例)
         \
          \--->> BMW X5(京B.00000) 对象(实例)

  狗(类)  ----->> 小京巴(户籍号: 00001)
         \
          \--->> 导盲犬(户籍号:00002)

  int(类)  --->> 100(对象)
          \
           \-->> 200(对象,实例)

类的创建语句：

class 类名(继承列表):
    """类文档字符串"""
    实例方法(类内的函数methd) 的定义
    类变量(class variable) 定义
    类方法(@classmethod)定义
    静态方法(@staticmethod)定义

作用：

  创建一个类

  类用于描述对象的行为和属性

  类用于创建此类的一个或多个对象（实例）

说明：

  类名必须为标识符

  类名实质上就是变量，它绑定一个类

示例：

# class.py


# 此示例示意用class 语句创建一个类 Dog
class Dog:
    '''这是用来描述一种小动物的类'''
    pass

# print(Dog)

术语

类	对象	实例
class	object	instance

 

构造函数

  构造函数的调用表达式

  语法：

  类名（[创建传参列表]）

作用：

  创建这个类的实例对象，并返回此实例的引用关系

示例：

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，实例可以访问类中的类变量和实例变量

 

实例方法 method

语法：

class 类名（继续列表）：

    def 示例方法（self，参数1，参数2，...）:
        '文档字符串'

         语句

 

 

作用：

  用于描述一个对象的行为，让此类型的全部对象都拥有相同的行为

说明：

•   实例方法实质是函数，是定义在类内的函数
•   实例方法至少有一个形参有，第一个形参代表调用这个方法的实例，一般命名为‘self’

实例方法的调用语法：

  实例.实例方法名（调用传参）

  或

  类名.实例方法名(实例, 调用参数)

示例见：

# instance_method.py


# 此示例示意实例方法的创建和调用
class Dog:
    '''这是一种小动物的定义
    此类动物有吃(eat)的行为:

    '''
    def eat(self, food):
        '''此方法用来描述小狗吃的行为'''
        print("小狗正在吃:", food)

    def sleep(self, hour):
        print("小狗睡了%d小时" % hour)

    def play(self, obj):
        print("小狗正在玩:", obj)


dog1 = Dog()  # 调用构造函数创建一个实例对象 再用dog1变量绑定
dog1.eat('骨头')
dog1.sleep(1)
dog1.play('球')


dog2 = Dog()  # 创建另一个实例对象
dog2.eat('包子')
dog2.sleep(3)
dog2.play('飞盘')

  实例属性 atrtibute (也叫实例变量)

  每个实例对象可以有自己的变量，称为实例变量（也叫属性）

语法：

    实例.属性名

赋值规则：

  首次为属性赋值则创建此函数

  首次为属性赋值则修改属性的绑定关系

作用：

  记录每个对象自身的数据

 

示例1：

# attribute.py


# 此示例示意属性的用法
class Dog:
    def eat(self, food):
        # print("小狗正在吃:", food)
        print(self.color, '的', self.kinds, '正在吃', food)

dog1 = Dog()
dog1.kinds = '京巴'  # 为dog1对象添加kinds属性,绑定为'京巴'
dog1.color = '白色'  # dog1添加属性 为'白色'
dog1.color = '黄色'  # 改变dog1的color属性
print(dog1.color, "的", dog1.kinds)  # 访问dog1 的属性

dog2 = Dog()
dog2.kinds = '哈士奇'
dog2.color = '黑白相间'
print(dog2.color, '的', dog2.kinds)  # 出错

dog1.eat('骨头')
dog2.eat('窝头')

示例2：

class Dog:
    def eat(self, food):
        # print("小狗正在吃:", food)
        print(self.color, '的', self.kinds, '正在吃', food)
        # 让调用此方法的对象添加一个last_food属性用来记住吃的信息
        self.last_food = food

dog1 = Dog()
dog1.kinds = '京巴'  # 为dog1对象添加kinds属性,绑定为'京巴'
dog1.color = '白色'  # dog1添加属性 为'白色'

dog2 = Dog()
dog2.kinds = '哈士奇'
dog2.color = '黑白相间'

dog1.eat('骨头')
dog2.eat('窝头')
print("dog1上次吃的是:", dog1.last_food)
print("dog2上次吃的是:", dog2.last_food)

练习：

  自己写一个‘人’类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 岁,家庭住址:末知

 

删除属性 del 语句

  del 对象.实例变量名

例如：

class Dog:
    pass
dog1 = Dog()
dog1.color = "白色"
del dog1.color  # 删除 

del 语句

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

初始化方法：

作用：

  对新创建的对象添加属性

语法：

class 类名（继承列表）：
    def __init__(self[,形参列表])：
        语句块
[]代表中的内容可以省略

说明：

  1，实始化方法名必须为'__init__'不可改变

  2，初始化方法会在构造函数创建实例后自动调用，且将实例自身通过第一个参数self传入__init__方法

  3，构造函数的实参将通过__init__方法的参数列表传入到'__init__' 方法中

  4，初始化方法内如果需要return 语句返回，则只能返回None

示例：

# 此示例示意初始化方法的定义方法和调用过程


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

    def run(self, speed):
        print(self.color, '的', self.brand,
              self.model, '正在以', speed,
              '公里/小时的速度行驶')

    def change_color(self, c):
        self.color = c

a4 = Car('红色', '奥迪', 'A4')
a4.run(199)
a4.change_color("白色")
a4.run(280)


x5 = Car('蓝色', '宝马', 'x5')
x5.run(188)

#__init__方法被调用
#红色 的 奥迪 A4 正在以 199 公里/小时的速度行驶
#白色 的 奥迪 A4 正在以 280 公里/小时的速度行驶
#__init__方法被调用
#蓝色 的 宝马 x5 正在以 188 公里/小时的速度行驶

练习：

  写一个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

析构方法：

语法：

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')
c2 = c1
del c1  # 此时是删除c1变量,同时解除c1绑定的对象的引用

input("请按回车键结束程序的执行!")

#汽车 BYD E6 被创建
#请按回车键结束程序的执行!

#汽车 BYD E6 被销毁

 

预制实例属性

__dict__属性

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

示例：

class Dog:
    pass

dog1 = Dog()
print(dog1.__dict__)  # {}
dog1.kinds = '京巴'
print(dog1.__dict__)  # {'kinds': '京巴'}

__class__ 属性

  此属性用于绑定创建些实例的类

作用：

  可以借助于此属性来访问创建此实例的类

示例：

class Dog:
    pass
dog1 = Dog()
print(dog1.__class__)   #<class '__main__.Dog'>
dog2 = dog1.__class__()
print(dog2.__class__)   #<class '__main__.Dog'>

面向对向的综合示例：

有两个人：

  1，姓名：张三，年龄：35

  2，姓名：李四，年龄：8

  行为：

  1，教别人学东西 teach

  2，赚钱 world

  3，借钱 borrow

  事情：

  张三 教 李四 学 python

  李四 教 张三 学 跳皮筋

  张三 上班赚了 1000 元钱

  李四 向 张三 借了 200 元钱

  打印张三的信息：35岁 的 张三 有钱 800元，他学会跳皮筋

  打印李四的信息：8岁 的 李四 有钱 200元，他学会python

解析：

class Human:
    '''人类,用于描述人的行为和属性'''
    def __init__(self, n, a=1):
        self.name = n  # 姓名
        self.age = a  # 年龄
        self.money = 0  # 钱数
        self.skill = []  # 技能

    def teach(self, other, subject):
        other.skill.append(subject)
        print(self.name, '教',
              other.name, '学', subject)

    def print_info(self):
        print(self.age, '岁的',
              self.name, '有钱',
              self.money, '元,它学会了:',
              self.skill)

    def works(self, money):
        self.money += money
        print(self.name, '上班赚了', money, '元钱')

    def borrow(self, other, money):
        if other.money > money:
            other.money -= money
            self.money += money
            print(self.name, "向", other.name,
                  '成功借了', money, '元钱')
        else:
            print(self.name, '向', other.name, '错钱失败')


zhang3 = Human('张三', 35)
li4 = Human('李四', 8)
# 张三 教 李四 学 python
zhang3.teach(li4, 'Python')
# 李四 教 张三 学 跳皮筋
li4.teach(zhang3, '跳皮筋')
# 张三 上班赚了 1000 元钱
zhang3.works(1000)
# 李四 向 张三 借了 200 元钱
li4.borrow(zhang3, 200)

# 打印张三的信息: 35岁 的 张三 有钱 800元, 它学会跳皮筋
zhang3.print_info()
# 打印李四的信息: 8岁 的 李四 有钱 200元, 它学会python
li4.print_info()

用于类的函数：

  isinstance(obj,class_or_tuple) 返回这个对象obj是否是某个类的对象或某些类中的一个类的对象，如果是则返回True，否则返回False

  type(obj) 返回对象

练习：

  修改原来的学生信息管理程序，将原来字典来存储学生信息，现改为用对象存储学生信息