python基础（17）——面向对象编程 & 预置实例属性 & 用于类的函数

一、面向对象编程 Object-Oriented Programming

1、什么是对象:
对象是指现实中的物体或实体

2、什么是面向对象:
把一切看成对象(实例), 用各种对象之间的关系来描述事务

3、对象的特征
   1. 对象有很多属性(名词或形容词)——实例变量(实例属性)
     年龄，姓名，性别 ...
   2. 对象有很多行为(动作，动词) ——实例方法
     学习，吃饭，睡觉，踢球，工作...
4、什么是类:
   拥有相同属性和行为的对象分为一组，即为一个类
   类是用来描述对象的工具，用类可以创建此类的对象(实例)

5、类和对象示意
   车(类) ----->> BYD E6(京A.88888) 实例，对象
         \
          \---->> BWM X5(京B.00000)   实例,对象

狗(类) -----> 哈士奇(户籍号: 00001)
\
\-----> 导盲犬(户籍号:00002) 对象

int(类) -----> 100 (对象)
\
\ -----> 200 (对象)

1、类的创建语句 class 语句

   语法:
     class 类名(继承列表):
         '''类文档字符串'''
         实例方法定义
         类变量定义
         类方法定义(@classmethod)
         静态方法定义(@staticmethod)
   作用:
     创建一个类
     类用于描述对象的行为和属性
     类用于创建此类的一个或多个对象(实例)
   说明:
     类名必须为标识符（与变量名命名规则相同，建议首字母大写)
     类名实质上就是变量，它绑定一个类
   示例见:
     class.py

2、构造函数

构造函数调用表达式:
类名([创建传参列表])

作用:
创建这个类的实例对象，并返回此实例对象的引用关系
说明:
实例有自己的作用域和名字空间，可以为该实例添加实例变量(也叫属性)
实例诃以调用类方法和实例方法
实例可以访问类变量和实例变量

 1 class Dog:
 2     '''创建一个Dog类,此类用于描述一种
 3     小动物的行为和属性'''
 4     pass
 5 
 6 dog1 = Dog()  # 创建Dog类的一个实例
 7 print(id(dog1))
 8 
 9 dog2 = Dog()  # 创建Dog类的第二个实例
10 print(id(dog2))
11 
12 print('--------------------')
13 # 对比
14 lst1 = list()  # 创建一个空列表
15 print(id(lst1))
16 
17 lst2 = list()  # 创建另一个空列表
18 print(id(lst2))

class.py

3、实例方法(method)

   语法:
     class 类名(继承列表):
         def 实例方法名(self, 形参名1, 形参名2, ....):
             '方法文档字符串'
             语句块
   作用:
用于描述一个对象的行为，让此类型的全部对象都拥有相同的行为
   说明:
实例方法的实质是函数，是定义在类内的函数
实例方法至少有一个形参，第一个形参用来绑定调用这个方法的实例，一般命名为'self'

实例方法的调用语法:
   实例.实例方法名(调用传参)
   # 或
   类名.实例方法名(实例, 调用传参)

 1 #实例方法的定义和调用   
 2 class Dog:
 3     '''创建一个Dog类,此类用于描述一种
 4     小动物的行为和属性'''
 5     def eat(self, food):
 6         '''此方法用来描述小狗吃东西的行为'''
 7         print("id为:", id(self), '的小狗正在吃', food)
 8     def sleep(self, hour):
 9         print("小狗睡了", hour, '小时')
10     def play(self, obj):
11         print("小狗正玩", obj)
12 
13 dog1 = Dog()  # 创建一个小狗对象
14 dog1.eat('骨头')
15 dog1.sleep(1)
16 dog1.play('球')
17 
18 
19 dog2 = Dog()  # 创建另外一只狗对象
20 dog2.eat('狗粮')
21 dog2.sleep(3)
22 dog2.play('飞盘')

instance_method.py

4、实例属性 atrribute(也叫实例变量)

每个实例可以有自己的变量用来保存对象自己的数据, 称为实例变量(也叫属性)

语法:
实例.属性名

赋值规则同变量的赋值规则
     首次为属性赋值则创建此属性
     再次为属性赋值则改变属性的绑定关系
   作用:
     记录每个对象自身的数据

 1 #此示例示意为对象添加实例变量(实例属性)及访问实例变量（实例属性)  
 2 class Dog:
 3     def eat(self, food):
 4         print(self.color, '的', self.kinds,
 5               '正在吃', food)
 6         self.last_food = food
 7 
 8     def show_last_food(self):
 9         print(self.color, '的', self.kinds,
10               '上次吃的是', self.last_food)
11 
12 dog1 = Dog()
13 dog1.kinds = '京巴'  # 添加实例属性
14 dog1.color = '白色'  # 添加
15 dog1.color = '黄色'  # 修改实例属性的绑定关系
16 dog2 = Dog()  # 另一个对象
17 dog2.kinds = '藏獒'
18 dog2.color = '棕色'
19 print(dog1.color, '的', dog1.kinds)
20 print(dog2.color, '的', dog2.kinds)
21 
22 dog1.eat('骨头')
23 # dog1.last_food = '骨头'
24 dog2.eat('窝头')
25 # dog1.last_food = '窝头'
26 
27 dog1.show_last_food()
28 dog2.show_last_food()

attribute.py

练习:
   定义一个"人"(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()
     h2.show_info()

 1 class Human:
 2     def set_info(self, name, age, address='不详'):
 3         '此方法用来给人对象添加姓名，年龄，家庭住址属性'
 4         self.name = name
 5         self.age = age
 6         self.addr = address
 7 
 8     def show_info(self):
 9         '此处显示此人的信息'
10         print(self.name, '今年', self.age,
11               '家庭地址:', self.addr)
12 
13 h1 = Human()
14 h1.set_info('小张', 20, '北京市东城区')
15 h2 = Human()
16 h2.set_info('小李', 18)
17 h1.show_info()
18 h2.show_info()

练习.py

5、del语句

　　可以删除对象(实例)的属性。
语法:
del 对象.实例变量名

示例:
     class Dog:
         pass
     dog1 = Dog()
     dog1.color = '白色'
     print(dog1.color) # 白色　
     del dog1.color # 删除属性
     print(dog1.color) # AttributeError属性错误

del 语句小结:
    1) 删除变量 del name
    2) 删除列表的元素 del L[1], del L[::2]
    3) 删除字典的键 del d['name']
    4) 删除对象的属性   del dog1.color

1 #del 示例
2 class Dog:
3     pass
4 dog1 = Dog()
5 dog1.color = '白色'
6 print(dog1.color)  # 白色　
7 del dog1.color  # 删除属性
8 print(dog1.color)  # AttributeError属性错误

del.py

6、初始化方法

作用:
对新创建的对象添加属性(等同于C++构造函数)
语法格式:
     class 类名(继承列表):
         def __init__(self, [形参列表]):
             语句块
  注: [] 代表其中的内容可省略
说明:
     1. 初始化方法名必须为 '__init__'　不可改变
     2. 初始化方法会在构造函数创建实例后自动调用，且将实例自身通过第一个参数self 传入 __init__ 方法
     3. 构造函数的实参将通过 __init__方法的参数列表传入到__init__方法中
     4. 实始化方法内如果需要return 语句返回，则只能返回None

 1 #此示例示意初始化方法的定义，及用初始化方法对新建对象添加属性  
 2 class Car:
 3     '''小汽车类'''
 4     def __init__(self, c, b, m):
 5         self.color = c  # 颜色
 6         self.brand = b  # 品牌
 7         self.model = m  # 形号
 8         # print("初始化方法被调用")
 9 
10     def run(self, speed):
11         print(self.color, '的', self.brand, self.model,
12               '正在以', speed, '公里／小时的速度行驶')
13 
14 
15 a4 = Car('红色', '奥迪', 'A4')
16 a4.run(199)
17 
18 t1 = Car("蓝色", "TESLA", 'Model S')
19 t1.run(230)

init_method.py

示例:

   1. 写一个Student类,此类创建的对象有三个属性:
       姓名，年龄，成绩
     1) 用初始化方法为该类添加上述三个属性
     2) 添加set_score()　方法能为对象修改学生成绩
     3) 添加show_info()　方法,打印学生信息
     如:
       class Student:
           def __init__(.....):
               ....
           def set_score(self, score):
                ....
           def show_info(self):
               ....
       L = []
       L.append(Student('小张', 20, 100))
       L.append(Student('小李', 18, 95))
       L.append(Student('小魏', 8))
       L[2].set_score(70)
       for obj in L:
           obj.show_info() # 小张　20　岁，成绩: 100 ....

 1 class Student:
 2     def __init__(self, n, a, s=0):
 3         self.name, self.age, self.score = n, a, s
 4 
 5     def set_score(self, score):
 6         if 0 <= score <= 100:
 7             self.score = score
 8 
 9     def show_info(self):
10         print(self.name, self.age, '岁，成绩:', self.score)
11 
12 L = []
13 L.append(Student('小张', 20, 100))
14 L.append(Student('小李', 18, 95))
15 L.append(Student('小魏', 8))
16 L[2].set_score(70)
17 for obj in L:
18     obj.show_info()  # 小张　20　岁， 成绩: 100  ....

示例.py

7、析构方法:

   class 类名(继承列表):
       def __del__(self):
           语句块

析构方法在对象被销毁时被自动调用
python语言建议不要在对象销毁时做任何事情，因为销毁时间难以确定

 1 # 此示例示意析构方法的使用 
 2 class Car:
 3     def __init__(self, info):
 4         self.info = info
 5         print("汽车对象", info, '被创建')
 6 
 7     def __del__(self):
 8         print("汽车对象", self.info, '被销毁')
 9 
10 
11 c1 = Car("BYD E6")
12 # c1 = None  # 改变变量的绑定关系可以释放 BYD E6对象
13 del c1  # 删除变量，释放对象
14 L = []
15 L.append(Car("汽车1"))
16 L.append(Car("汽车2"))
17 L.append(Car("汽车3"))
18 del L  # 释放列表
19 input("请输入回车键继续执行程序: ")
20 print("程序退出")

del_method.py

二、预置实例属性

1、dict属性

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

1 # 预置实例属性__dict__属性
2 class Dog:
3     pass
4 dog1 = Dog()
5 print(dog1.__dict__)  # {}
6 dog1.color = "白色"
7 print(dog1.__dict__)  # {'color': '白色'}
8 dog1.kinds = '京巴'
9 print(dog1.__dict__)  # {'color': '白色', 'kinds':'京巴'}

示例.py

2、class属性

'__class__' 属性绑定创建此实例的类
作用:
可以借助此属性来访问创建此实例的类

1 # 预置实例属性__class__属性
2 class Dog:
3     pass
4 dog1 = Dog()
5 print(dog1.__class__)
6 dog2 = dog1.__class__()
7 print(dog2.__class__)

示例.py

三、用于类的函数:

isinstance(obj, class_or_tuple)

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

返回对象的类型

面向对象的综合示例:
   有两个人:
    属性:
       1. 姓名: 张三, 年龄 35 岁
       2. 姓名: 李四, 年龄 8 岁
     行为:
       1. 教别人学东西　teach
       2. 工作赚钱 work
       3. 借钱 borrow
   事情:
     张三　教　李四学 python
     李四　教　张三　学王者荣耀
     张三　上班赚了 1000　元钱
     李四　向张三　借了 200 元钱
     35　岁的　张三　有钱 800元，它学会的技能: 王者荣耀
     8 岁的李四有钱 200元，它学会的技能: python

 1 class Human:
 2     def __init__(self, n, a):
 3         self.name = n  # 姓名
 4         self.age = a  # 年龄
 5         self.money = 0  # 钱数为0
 6         self.skill = []  # 技能列表
 7 
 8     def teach(self, other, skill):
 9         print(self.name, '教', other.name, '学', skill)
10         other.skill.append(skill)  # 让other增加技能
11 
12     def work(self, m):
13         print(self.name, '上班赚了', m, '元钱')
14         self.money += m
15 
16     def borrow(self, other, m):
17         if other.money > m:
18             print(self.name, '向', other.name, '借', m, '元钱')
19             other.money -= m
20             self.money += m
21         else:
22             print(other.name, '没有借钱给', self.name)
23 
24     def show_info(self):
25         print(self.age, '岁的', self.name,
26               '有钱', self.money, '元，它学会的技能:',
27               '、'.join(self.skill))
28 
29 zhang3 = Human('张三', 35)
30 li4 = Human('李四', 8)
31 # 张三　教　李四 学 python
32 zhang3.teach(li4, 'Python')
33 # 李四　教　张三　学 王者荣耀
34 li4.teach(zhang3, '王者荣耀')
35 # # 张三　上班赚了 1000　元钱
36 zhang3.work(1000)
37 # 李四　向 张三　借了 200 元钱
38 li4.borrow(zhang3, 200)
39 # 35　岁的　张三　有钱 800元，它学会的技能: 王者荣耀
40 zhang3.show_info()
41 # 8 岁的 李四 有钱 200元， 它学会的技能: python
42 li4.show_info()

oop_example.py

posted on 2018-10-12 17:38 破天荒的谎言、谈敷衍阅读(407) 评论(0) 收藏举报

刷新页面返回顶部