python学习笔记(6)--面向对象学习

 1 def person(name,age,sex,job):
 2     data = {
 3         ‘name‘:name,
 4         ‘age‘:age,
 5         ‘sex‘:sex,
 6         ‘job‘:job
 7     }
 8  
 9     return data
10  
11 def dog(name,dog_type):
12     data = {
13         ‘name‘:name,
14         ‘type‘:dog_type
15     }
16     return data

1 d1 = dog("李磊","京巴")
2  
3 p1 = person("严帅",36,"F","运维")
4  
5 p2 = person("林海峰",27,"F","Teacher")

1 def bark(d):
2     print("dog %s:wang.wang..wang..."%d[‘name‘])
3  
4  
5 def walk(p):
6     print("person %s is walking..." %p[‘name‘])<br><br>

1 d1 = dog("李磊","京巴")
2 p1 = person("严帅",36,"F","运维")
3 p2 = person("林海峰",27,"F","Teacher")

1 walk(p1) bark(d1)

1 p1 = person("严帅",36,"F","运维")
2 bark(p1) #把人的对象传给了狗的方法

 1 def person(name,age,sex,job):
 2     def walk(p):
 3         print("person %s is walking..." % p[‘name‘])
 4  
 5     data = {
 6         ‘name‘:name,
 7         ‘age‘:age,
 8         ‘sex‘:sex,
 9         ‘job‘:job,
10         ‘walk‘:walk
11     }
12  
13     return data
14  
15 def dog(name,dog_type):
16  
17  
18     def bark(d):
19         print("dog %s:wang.wang..wang..."%d[‘name‘])
20     data = {
21         ‘name‘:name,
22         ‘type‘:dog_type,
23         ‘bark‘:bark
24     }
25  
26     return data

1 d1 = dog("李磊","京巴")
2 p1 = person("严帅",36,"F","运维")
3 p2 = person("林海峰",27,"F","Teacher")<br><br>

1 d1[‘bark‘](p1) #把人的对象传给了狗的方法

 1 def db_conn():
 2     print("connecting db...")
 3  
 4  
 5 def db_backup(dbname):
 6     print("导出数据库...",dbname)
 7     print("将备份文件打包，移至相应目录...")
 8  
 9 def db_backup_test():
10     print("将备份文件导入测试库，看导入是否成功")
11  
12  
13 def main():
14     db_conn()
15     db_backup(‘my_db‘)
16     db_backup_test()
17  
18  
19  
20 if __name__ == ‘__main__‘:
21     main()

面向对象编程(Object-Oriented Programming )介绍

对于编程语言的初学者来讲，OOP不是一个很容易理解的编程方式，大家虽然都按老师讲的都知道OOP的三大特性是继承、封装、多态，并且大家也都知道了如何定义类、方法等面向对象的常用语法，但是一到真正写程序的时候，还是很多人喜欢用函数式编程来写代码，特别是初学者，很容易陷入一个窘境就是“我知道面向对象，我也会写类，但我依然没发现在使用了面向对象后，对我们的程序开发效率或其它方面带来什么好处，因为我使用函数编程就可以减少重复代码并做到程序可扩展了，为啥子还用面向对象？”。 对于此，我个人觉得原因应该还是因为你没有充分了解到面向对象能带来的好处，今天我就写一篇关于面向对象的入门文章，希望能帮大家更好的理解和使用面向对象编程。 

1. 写重复代码是非常不好的低级行为
2. 你写的代码需要经常变更 

开发正规的程序跟那种写个运行一次就扔了的小脚本一个很大不同就是，你的代码总是需要不断的更改，不是修改bug就是添加新功能等，所以为了日后方便程序的修改及扩展，你写的代码一定要遵循易读、易改的原则（专业数据叫可读性好、易扩展）。

1 # d = Dog(‘LiChuang‘, "京巴")
2 # d.sayhi()
3  
4 print(Dog)

1 <class ‘__main__.Dog‘>

1 class Dog(object):
2     ...
3     def sayhi(self):
4  
5         print("hello,I am a dog, my name is ",self.name)

1 class Role(object): #定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写，以后再讲为什么
2     def __init__(self,name,role,weapon,life_value=100,money=15000): #初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
3         self.name = name #__init__中的第一个参数self,和这里的self都 是什么意思？ 看下面解释
4         self.role = role
5         self.weapon = weapon
6         self.life_value = life_value
7         self.money = money

1 r1 = Role(‘Alex‘,‘police‘,‘AK47’) #生成一个角色 , 会自动把参数传给Role下面的__init__(...)方法
2 r2 = Role(‘Jack‘,‘terrorist‘,‘B22’)  #生成一个角色

我们看到，上面的创建角色时，我们并没有给__init__传值，程序也没未报错，是因为，类在调用它自己的__init__(…)时自己帮你给self参数赋值了， 

1 r1 = Role(‘Alex‘,‘police‘,‘AK47’) #此时self 相当于 r1 ,  Role(r1,‘Alex‘,‘police‘,‘AK47’)
2 r2 = Role(‘Jack‘,‘terrorist‘,‘B22’)#此时self 相当于 r2, Role(r2,‘Jack‘,‘terrorist‘,‘B22’)

1. 在内存中开辟一块空间指向r1这个变量名
2. 调用Role这个类并执行其中的__init__(…)方法，相当于Role.__init__(r1,‘Alex‘,‘police‘,’AK47’),这么做是为什么呢？ 是为了把‘Alex‘,‘police‘,’AK47’这3个值跟刚开辟的r1关联起来，是为了把‘Alex‘,‘police‘,’AK47’这3个值跟刚开辟的r1关联起来，是为了把‘Alex‘,‘police‘,’AK47’这3个值跟刚开辟的r1关联起来，重要的事情说3次， 因为关联起来后，你就可以直接r1.name, r1.weapon 这样来调用啦。所以，为实现这种关联，在调用__init__方法时，就必须把r1这个变量也传进去，否则__init__不知道要把那3个参数跟谁关联呀。
3. 明白了么哥？所以这个__init__(…)方法里的，self.name = name , self.role = role 等等的意思就是要把这几个值 存到r1的内存空间里。

1 def buy_gun(self,gun_name):
2     print(“%s has just bought %s” %(self.name,gun_name) )

1 r1 = Role(‘Alex‘,‘police‘,‘AK47‘)
2 r1.buy_gun("B21”) #python 会自动帮你转成 Role.buy_gun(r1,”B21")

 1 class School(object):
 2     def __init__(self,name,addr):
 3         self.name = name
 4         self.addr = addr
 5         self.students = []
 6         self.teachers = []
 7 
 8     def enroll(self,stu_obj):
 9         print("为%s 学员办理入学手续"%stu_obj.name)
10         self.students.append(stu_obj)
11 
12     def hire(self,staff_obj):
13         print("为%s 顾用员工" % staff_obj.name)
14         self.teachers.append(staff_obj)
15 
16 
17 class SchoolMember(object):
18     def __init__(self,name,age,sex):
19         self.name = name
20         self.age = age
21         self.sex = sex
22 
23 
24     def tell(self):
25         pass
26 
27 class Teacher(SchoolMember):
28     
29     def __init__(self, name, age, sex,salary,course ):
30         super(Teacher,self).__init__(name, age,sex)
31         self.salary = salary
32         self.course = course
33         
34     def tell(self):
35         print(‘‘‘
36         ------info teacher-------
37         name = %s
38          age = %s,
39          sex = %s,
40          salary = %s,
41          course = %s
42         ‘‘‘%(self.name, self.age, self.sex,self.salary,self.course))
43 
44     def teach(self):
45         print("%s teacher is teach [%s]"%(self.name,self.course))
46 
47 class Student(SchoolMember):
48     def __init__(self,name, age, sex , stu_id , grade):
49         super(Student,self).__init__(name, age, sex )
50         self.stu_id = stu_id
51         self.grade = grade
52 
53     def tell(self):
54         print(‘‘‘
55         ------info stu-------
56         name = %s
57          age = %s,
58          sex = %s,
59          stu_id = %s,
60          grade = %s
61         ‘‘‘%(self.name, self.age, self.sex,self.stu_id,self.grade))
62 
63     def pay_tuition(self,amount):
64         print("%s has paid $%s"%(self.name,amount))
65 
66 
67 sch = School(‘安师大‘,‘芜湖市‘)
68 t1 = Teacher(‘王凌江1‘,23,‘男‘,2000,"语文")
69 t2 = Teacher(‘王凌江2‘,23,‘男‘,3000,"python")
70 s1 = Student(‘康利影1‘,24,‘女‘,1001,"python")
71 s2 = Student(‘康利影2‘,24,‘女‘,1002,"语文")
72 
73 t1.tell()
74 s1.tell()
75 sch.enroll(s1)
76 sch.hire(t1)
77 print(sch.students[0].name)
78 sch.teachers[0].teach(  )

 1 class Animal(object):
 2     ‘‘‘描述动物‘‘‘
 3     def __init__(self, name):  # Constructor of the class
 4         self.name = name
 5 
 6     def talk(self):  # Abstract method, defined by convention only
 7         pass #raise NotImplementedError("Subclass must implement abstract method")
 8 
 9     @staticmethod
10     def animal_talk(obj):
11         obj.talk()
12 
13 
14 class Cat(Animal):
15     def talk(self):
16         print(‘Meow!‘)
17 
18 
19 class Dog(Animal):
20 
21     def talk(self):
22         print(‘Woof! Woof!‘)
23 
24 
25 
26 
27 d = Dog("王王")
28 #d.talk()
29 
30 c = Cat("康康")
31 #c.talk()
32 #
33 # def animal_talk(obj):
34 #     obj.talk()
35 
36 Animal.animal_talk(c)
37 Animal.animal_talk(d)
38 print(Animal.__doc__)
39 print(Animal.__module__)
40 print(d)