python_day6

Posted 2020-10-31 lifeng0521

面向对象学习

编程范式的主要几种：

面向对象（世界万物皆为类、世界万物皆为对象、只要是对象，一定属于某品类）

面向过程

函数式编程

下面主要介绍面向对象编程

面向对象的核心特征：类(class)、对象(object)、封装(Encapsulation)、继承(Inheritance)、多态(Polymorphism)

1、类(class)

一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。

在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

写cs的例子说明类：

 1 #Author : Felix Li
 2  #类的基础讲解
 3 class Role(object):
 4     n=123
 5     name="我是类name"
 6     def __init__(self,name,role,weapon,life_value=100,money=15000):
 7         #构造函数
 8         #在实例化时做一些类得初始化的工作
 9         self.name=name #实例变量(静态属性)，作用域就是实例本身
10         self.role=role
11         self.weapon=weapon
12 
13         self.__life_value=life_value #私有属性 私有方法一样 都是前面佳两个下划线
14 
15         self.money=money
16     # def __del__(self):   #析构函数
17     #     print("%s彻底死了。。。"%self.name)
18     def shot(self): #类的方法，功能(动态属性)
19         print("%s shooting..."%self.name)
20 
21     def got_shot(self):
22         self.__life_value-=30
23         print("ah ...  %s got shot..."%self.name)
24 
25     def buy_gun(self,gun_name):
26         print(" %s just bought %s" %(self.name,gun_name))
27     def show_status(self):
28         print("name:%s weapon :%s life_values:%s"%(self.name,self.weapon,self.__life_value))
29 
30 r1=Role(‘felix‘,‘police‘,‘AK47‘)
31 r2=Role(‘kobe‘,‘terrorist‘,‘M1A46‘)
32 
33 r1.buy_gun(‘AK47‘)  #传值给gun_name
34 r1.shot()
35 r2.got_shot()
36 print(r1.show_status())
37 print(r2.show_status())

CS_类

2、对象(object)

一个对象即是一个类的实例化后的实例。

3、封装(Encapsulation)

在类中对数据的赋值、内部调用对外部用户是透明的，

这使类变成了一个胶囊或容器，里面包含着类的数据和方法

 

4、继承(Inheritance)

一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

 

 1 #Author : Felix Li
 2 #继承
 3 # class People:   经典类写法
 4 class People(object):  #新式类写法
 5     def __init__(self,name,age):
 6         self.Name=name
 7         self.Age=age
 8         self.friends = [] #交朋友的空列表
 9     def eat(self):
10         print("%s eating......"%self.Name)
11     def talk(self):
12         print("%s talking......"%self.Name)
13     def wc(self):
14         print("%s WCing..."%self.Name)
15     def sleep(self):
16         print("%s sleeping......"%self.Name)
17 class Relation(object):  #第二个父类，用于实现多继承
18 
19     def make_friends(self,fri):
20         print("%s is making friends with %s"%(self.Name,fri.Name))
21         self.friends.append(fri)
22 
23 class Man(Relation,People):
24     def __init__(self,name,age,money):
25 
26         #People.__init__(self,name,age)#另一种方法是super
27         super(Man,self).__init__(name,age)
28 
29         self.money=money
30         print("男 姓名：%s 年龄：%s 价值：%s"%(self.Name,self.Age,self.money))
31     def mojj(self):
32         print("%s moing jj....."%self.Name)
33     def sleep(self):
34         People.sleep(self)
35         print("%s wake up early"%self.Name)
36 
37 
38 class Woman(People,Relation):
39     def __init__(self,name,age,height):
40         super(Woman, self).__init__(name, age)
41         self.height=height
42         print("女 姓名：%s 年龄：%s 身高：%scm"%(self.Name,self.Age,self.height))
43     def get_birth(self):
44         print("%s is born a baby..."%self.Name)
45 
46 M1=Man(‘felix‘,23,‘100000$‘)
47 # M1.eat()
48 # M1.mojj()
49 # M1.sleep()
50 
51 W1=Woman(‘kobe‘,20,175)
52 # W1.get_birth()
53 
54 M1.make_friends(W1)
55 print(M1.friends[0].Name)

继承

 

继承的例子： 学校 学生 老师

 1 #Author : Felix Li
 2 
 3 #学校，学生，老师
 4 
 5 class School(object):  #学校
 6     def __init__(self,name,addr):
 7         self.name=name
 8         self.addr=addr
 9         self.students=[]
10         self.staffs=[]
11     def enroll(self,stu_obj):#注册
12         print("已为学生%s办理入学手续"%stu_obj.name)
13         self.students.append(stu_obj)
14     def hire(self,staff_obj):
15         self.staffs.append(staff_obj)
16         print("新入职员工%s"%staff_obj.name)
17 
18 class SchoolMember(object):  #学校人员
19     def __init__(self,name,sex,age):
20         self.name=name
21         self.sex=sex
22         self.age=age
23 
24 class Teacher(SchoolMember):  #老师
25     def __init__(self,name,sex,age,salary,course):
26         super(Teacher,self).__init__(name,sex,age)
27         self.salary=salary
28         self.course=course
29 
30     def tell(self):
31         print(‘‘‘
32         ---info of Teacher:%s---
33         Name:%s
34         Age:%s
35         Sex:%s
36         Salary:%s
37         Course:%s
38         ‘‘‘%(self.name,self.name,self.age,self.sex,self.salary,self.course))
39     def teach(self):
40         print("%s is teaching course [%s]"%(self.name,self.course))
41 
42 class Student(SchoolMember):#学生
43     def __init__(self,name,sex,age,stu_id,grade):
44         super(Student, self).__init__(name,sex,age)
45         self.stu_id=stu_id
46         self.grade=grade
47 
48     def tell(self):
49         print(‘‘‘
50         ---info of Student:%s---
51         Name:%s
52         Age:%s
53         Sex:%s
54         Stu_id:%s
55         Grade:%s
56         ‘‘‘%(self.name,self.name,self.age,self.sex,self.stu_id,self.grade))
57 
58     def pay_tuition(self,amount):
59         print("%s has paid tuition for $%s"%(self.name,amount))
60 
61 school=School("长春工业大学","长春")
62 t1=Teacher("kobe",‘男‘,36,20000,"basketball")
63 t2=Teacher("bryant",‘男‘,18,2000,"football")
64 
65 s1=Student("felix","男",23,‘007‘,"football")
66 s2=Student("li","男",20,‘001‘,"basketball")
67 
68 s1.tell()
69 t1.tell()
70 school.hire(t1)
71 school.enroll(s1)
72 
73 school.staffs[0].teach()
74 for stu in school.students:
75     stu.pay_tuition(5000)

继承的例子

多继承的区别：

 1 #Author : Felix Li
 2 #广度优先搜索策略来继承
 3 class A:
 4     def __init__(self):
 5         print("A")
 6 
 7 class B(A):
 8     pass
 9     # def __init__(self):
10     #     print("B")
11 
12 class C(A):
13     def __init__(self):
14         print("C")
15 
16 class D(B,C):
17     pass
18     # def __init__(self):
19     #     print("D")
20 
21 d=D()

多继承的区别

5、多态(Polymorphism)

多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

多态的例子：

 1 #Author : Felix Li
 2 
 3 class Animal(object):
 4     def __init__(self, name):  # Constructor of the class
 5         self.name = name
 6 
 7     def talk(self):  # Abstract method, defined by convention only
 8         raise NotImplementedError("Subclass must implement abstract method")
 9     @staticmethod  #是一种装饰器
10     def animal_talk(obj):
11         obj.talk()
12 
13 class Cat(Animal):
14     def talk(self):
15         print(‘%s: 喵喵喵!‘ % self.name)
16 
17 
18 class Dog(Animal):
19     def talk(self):
20         print(‘%s: 汪！汪！汪！‘ % self.name)
21 
22 
23 # def func(obj):  # 一个接口，多种形态
24 #     obj.talk()
25 
26 
27 c1 = Cat(‘小晴‘)
28 d1 = Dog(‘李磊‘)
29 
30 # func(c1)
31 # func(d1)
32 
33 Animal.animal_talk(c1)
34 Animal.animal_talk(d1)

多态的例子

6、实例变量与类变量：

1. 实例变量的作用域是实例本身。
2. 先找实例变量，再找类变量。
3. 一个实例变量改变类变量，不影响另一个实例对类变量的调用
4. 类变量是大家公用的属性，目的是节省内存空间。