python3自动化学习06

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 """
 4 编程范式：
 5     编程是 程序员 用特定的语法+数据结构+算法 组成的代码来告诉计算机如何执行任务的过程 ，
 6     一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，
 7     实现一个任务的方式有很多种不同的方式，对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。
 8     不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，
 9     大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。
10     两种最重要的编程范式分别是 面向过程编程 和 面向对象编程。
11 
12 面向过程编程：
13     面向过程编程依赖过程，一个过程包含一组要被进行计算的步骤，面向过程又被称为top-down languages，
14     就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题 。
15     基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，
16     这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。
17     缺点：
18         如果要对程序进行修改，对修改的那部分有依赖的各个部分你都也要跟着修改。
19         举个例子，如果程序开头你设置了一个变量值为1 ，但如果其它子过程依赖这个值为1的变量才能正常运行，
20         那如果你改了这个变量，那这个子过程你也要修改，假如又有一个其它子程序依赖这个子过程，那就会发生一连串的影响，
21         随着程序越来越大，这种编程方式的维护难度会越来越高。
22     总结：
23         所以我们一般认为，如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的。
24         但如果你要处理的任务是复杂的，且需要不断迭代和维护的，那还是用面向对象最方便了。
25 
26 面向对象编程：
27     OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，
28     使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，
29     另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。
30     核心特性：
31         class 类
32             一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性、共同的方法。
33         object 对象
34             一个对象即是一个类的实例化后的实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，
35             每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之间有共性，亦有不同。
36         封装
37             在类中对数据的赋值、内部调用对外部用户是透明的（这里透明的意思是类的外部不能调用这些数据，但是类的内部可以调用），
38             这使类变成了一个胶囊或容器，里面包含着类的数据和方法
39         继承
40             一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
41         多态
42             多态是面向对象的重要特性,简单点说:“一个接口，多种实现”。
43             指一个基类(父类)中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
44             多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。
45             这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定。
46 
47 为什么要使用面向对象编程：
48     无论用什么形式来编程，我们都要明确记住以下原则：
49         1.写重复代码是非常不好的低级行为
50         2.你写的代码需要经常变更
51     代码需要：可读性好、易扩展。"""
52 
53 
54 ‘‘‘
55 #面向过程编程范例
56 def db_conn():
57     print("connecting db...")
58 
59 def db_backup(dbname):
60     print("导出数据库",dbname)
61 
62 def db_backup_test():
63     print("将备份文件导入测试库，看导入是否成功")
64 
65 def main():
66     db_conn()
67     db_backup(‘mysql‘)
68     db_backup_test()
69 
70 if __name__ == ‘__main__‘:
71     main()‘‘‘

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 class Dog(object):              #Dog是类的名称，object是所有类的父类，被称为基类
 5     """狗类"""
 6 
 7     def __init__(self,name):    #构造函数，初始化数据，接收参数
 8         self.name = name
 9 
10     def bulk(self):             #方法
11         """叫的方法"""
12         print("%s:wang wang wang!"%self.name)
13 
14 d1 = Dog("tom")                 #d1 是实例（又叫对象） ，d1 = Dog("tom") 这个是实例化过程 。实例化（初始化一个类，相当于造了一个对象）
15 d2 = Dog("jack")
16 d3 = Dog("tim")
17 
18 d1.bulk()                       #调用d1这个实例的 bulk() 方法
19 d2.bulk()
20 d3.bulk()

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 class Role(object):
 5     n = 123     #类变量（赋给了类）  类变量的用途：大家公用的属性
 6     name = ‘我是类变量‘
 7     n_list = []
 8     n_tuple = (‘类元组‘,)
 9     def __init__(self, name, role, weapon, life_value=100, money=15000):
10         """
11         构造函数
12         作用：在实例化时做一些类的初始化的工作
13         此处的self，相当于实例化中的变量，如r1，r2 。
14         """
15         self.name = name                #实例变量（赋给了实例，又叫属性或者静态属性）作用域就是实例本身
16         self.role = role                #实例变量（赋给了实例）
17         self.weapon = weapon            #实例变量（赋给了实例）
18         self.__life_value = life_value  #实例变量（赋给了实例）      #__ 表示私有属性，类的外部不能访问，但是类的内部可以访问
19         self.money = money              #实例变量（赋给了实例）
20 
21     #def __del__(self):
22         """析构函数，在实例释放，销毁的时候自动执行的，通常用于做一些收尾工作，如关闭一些数据库链接，打开的临时文件"""
23         #print("%s 彻底撕了"%self.name)
24 
25     def shot(self):     #类的方法、此处的self，相当于实例化中的变量，如r1，r2 。（动态属性）
26         ‘‘‘开枪方法‘‘‘
27         print("shooting...")
28 
29     def got_shot(self):#此处的self，相当于实例化中的变量，如r1，r2 。
30         ‘‘‘死亡方法‘‘‘
31         print("ah...,I got shot...")
32 
33     def buy_gun(self, gun_name):#此处的self，相当于实例化中的变量，如r1，r2 。
34         ‘‘‘买枪方法‘‘‘
35         print("%s just bought %s" %(self.name,gun_name))
36 
37     def show_status(self):
38         print("name:%s life_val:%s "%(self.name,self.__life_value))
39 
40     def __siyoufangfa(self):
41         ‘‘‘私有方法‘‘‘
42         print(‘私有方法‘)
43     def show_siyou(self):
44         self.__siyoufangfa()
45 ‘‘‘
46 #如果不赋值变量也可以，但是调用完就在内存中消失了。
47 Role(‘alnk‘, ‘police‘, ‘AK47‘).got_shot()
48 Role(‘alnk‘, ‘police‘, ‘AK47‘).got_shot()
49 注意：上面是两个对象，不是同一个对象，在内存中的地址是不一样的。如果想要常驻在内存中，需要赋值给一个变量，如下面的演示。‘‘‘
50 
51 ‘‘‘
52 r1 = Role(‘alnk‘, ‘police‘, ‘AK47‘) #把一个类变成一个具体对象的过程叫实例化（初始化一个类，相当于造了一个对象）
53 r2 = Role(‘Jack‘, ‘terrorist‘, ‘B22‘)  #生成一个角色
54 r1.buy_gun(‘ak47‘)      #等价于 Role.buy_gun(r1,‘ak47‘) 。类中的方法是存在类的内存中的，类是存在系统的内存中的‘‘‘
55 
56 ‘‘‘
57 #类变量和实例变量的区别
58 print(Role.n)                           #类变量存在类的内存里
59 r1 = Role(‘alnk‘, ‘police‘, ‘AK47‘)     #实例化时，先找实例变量，再找类变量
60 r1.name = "chen"                        #修改实例化的变量
61 r1.bullet_prove = True                  #给r1实例增加新的属性
62 print(r1.n,r1.name,r1.bullet_prove)
63 print(r1.weapon)
64 #del r1.weapon           #删除实例变量
65 #print(r1.weapon)
66 #改变类变量
67 #Role.n = ‘从类中改变n变量‘
68 r1.n = ‘改变类变量‘      #其实是在r1的内存中中生成了 r1.n = ‘改变类变量‘的变量，并没有真正的去改变类变量
69 print(‘r1:‘,r1.n)
70 r2 = Role(‘jack‘,‘police‘,‘m4a1‘)
71 print(‘r2:‘,r2.n)       #发现r2.n的类变量并有改变。
72 #对于列表来说。都是指向了同一个内存地址。所以类变量n_list会发生改变
73 r1.n_list.append("from r1")
74 r2.n_list.append(‘from r2‘)
75 print(r1.n_list)
76 print(r2.n_list)
77 print(Role.n_list)
78 #对于元组来说，元祖是不可变的，所以不会改变，n=123的变量一样。
79 r1.n_tuple = (‘r1‘,)
80 print(‘r1-tuple‘,r1.n_tuple)
81 print(‘Role-tuple‘,Role.n_tuple)
82 print(‘r2-tuple‘,r2.n_tuple)‘‘‘
83 
84 ‘‘‘
85 #析构函数：在实例释放，销毁的时候自动执行的，通常用于做一些收尾工作，如关闭一些数据库链接，打开的临时文件
86 r1 = Role(‘tom‘, ‘police‘, ‘AK47‘)
87 r1.got_shot()
88 #del r1
89 r2 = Role(‘jack‘,‘a‘,‘b51‘)
90 r2.got_shot()‘‘‘
91 
92 ‘‘‘
93 #私有方法、私有属性：类的外部不能访问，但是类的内部可以访问
94 r1 = Role(‘tom‘, ‘police‘, ‘AK47‘)
95 #print(r1.__life_value)
96 #r1.__siyoufangfa()
97 r1.show_status()    #私有属性
98 r1.show_siyou()     #私有方法‘‘‘

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 #继承的主要作用：就是节省代码
 4 class Peopel(object):       #加了 object 为新式类
 5     def __init__(self,name,age):
 6         self.name = name
 7         self.age = age
 8         self.freind = []
 9     def eat(self):
10         print("%s is eating"%self.name)
11     def sleep(self):
12         print("%s is sleeping..."%self.name)
13     def talk(self):
14         print(‘%s is taking...‘%self.name)
15 
16 class Relation(object):
17     ‘‘‘交朋友类‘‘‘
18     def make_friends(self,obj): #obj是w1
19         print(‘%s is making friends with %s‘ %(self.name,obj.name))
20         self.freind.append(obj)
21 
22 class Man(Peopel,Relation):
23     def __init__(self,name,age,money):
24         ‘‘‘重构父类构造函数‘‘‘
25         #Peopel.__init__(self,name,age)
26         super(Man,self).__init__(name,age)      #新式类写法
27         self.money = money
28         #print(‘%s 一出生就有：%s‘%(self.name,self.money))
29     def piao(self):
30         print(‘%s is piaoing...‘%self.name)
31     def sleep(self):
32         ‘‘‘重构父类的方法‘‘‘
33         Peopel.sleep(self)
34         print(‘man is sleeping‘)
35 
36 class Woman(Peopel,Relation):       #多继承
37     def get_birth(self):
38         print(‘%s is born a baby ..‘%self.name)
39 
40 m1 = Man(‘tom‘,18,10)
41 w1 = Woman(‘jack‘,19)
42 # w1.get_birth()
43 # m1.eat()
44 # m1.piao()
45 # m1.sleep()
46 m1.make_friends(w1)
47 print(m1.freind[0].name)

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 #python2  经典类是按深度优先来继承的，新式类是按广度优先来继承的
 5 #python3  经典类和新式类中继承都是广度优先      D -->B OR C -->A
 6 
 7 class A:
 8     #pass
 9     def __init__(self):
10        print("A")
11 class B(A):
12      pass
13      # def __init__(self):
14      #     print("B")
15 class C(A):
16     #pass
17     def __init__(self):
18         print("C")
19 class D(B,C):
20     pass
21     # def __init__(self):
22     #     print("D")
23 
24 obj = D()

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 class School(object):
 5     ‘‘‘学校类‘‘‘
 6     def __init__(self,name,addr):
 7         self.name = name
 8         self.addr = addr
 9         self.students = []
10         self.staffs = []
11 
12     def enroll(self,stu_obj):
13         ‘‘‘注册‘‘‘
14         print(‘为学员%s 办理注册手续‘%stu_obj.name)
15         self.students.append(stu_obj)
16 
17     def hire(self,staff_obj):
18         ‘‘‘雇用‘‘‘
19         self.staffs.append(staff_obj)
20         print(‘雇佣新员工%s‘ % staff_obj.name)
21 
22 class SchoolMember(object):
23     ‘‘‘老师和学生类‘‘‘
24     def  __init__(self,name,age,sex):
25         self.name = name
26         self.age =age
27         self.sex = sex
28 
29     def tell(self):
30         ‘‘‘打印自己的个人信息‘‘‘
31         pass
32 
33 class Teacher(SchoolMember):
34     ‘‘‘教师类‘‘‘
35     def __init__(self,name,age,sex,salary,course):
36         super(Teacher,self).__init__(name,age,sex)
37         self.salary = salary
38         self.course = course
39 
40     def tell(self):
41         print(‘‘‘
42         --- info of Teacher: %s ---
43         name:%s
44         age:%s
45         sex:%s
46         salary:%s
47         course:%s
48         ‘‘‘ %(self.name,self.name,self.age,self.sex,self.salary,self.course))
49 
50     def teach(self):
51         print(‘%s is teaching course [%s]‘ %(self.name,self.course))
52 
53 class Student(SchoolMember):
54     ‘‘‘学生类‘‘‘
55     def __init__(self,name,age,sex,stu_id,grade):
56         super(Student,self).__init__(name,age,sex)
57         self.stu_id = stu_id
58         self.grade = grade
59 
60     def tell(self):
61         print(‘‘‘
62         --- info of Student: %s ---
63         name:%s
64         age:%s
65         sex:%s
66         stu_id:%s
67         grade:%s
68         ‘‘‘ %(self.name,self.name,self.age,self.sex,self.stu_id,self.grade))
69 
70     def pay_tuition(self,amount):
71         ‘‘‘交学费‘‘‘
72         print(‘%s has paid tuition for $[%s]‘%(self.name,amount))
73 
74 school = School("老男孩IT",‘沙河‘)                   #实例化一所学校
75 
76 t1 = Teacher(‘oldboy‘,56,‘mf‘,20000000,‘linux‘)     #实例化一个老师
77 t2 = Teacher(‘alex‘,32,‘m‘,3000,‘pythondevops‘)     #实例化一个老师
78 
79 s1 = Student(‘tom‘,22,‘mf‘,1001,‘pythondevops‘)     #实例化一个学生
80 s2 = Student(‘xu‘,19,‘mf‘,1002,‘linux‘)             #实例化一个学生
81 
82 t1.tell()                                           #调用Teacher类tell方法
83 s1.tell()                                           #调用Student类tell方法
84 
85 school.hire(t1)                                     #调用School类hire方法
86 school.enroll(s1)
87 school.enroll(s2)
88 
89 print(school.staffs)                                #查看雇佣了多少老师，这是一个内存地址
90 print(school.students)                              #查看注册了多少学生，这是一个内存地址
91 print(‘被雇佣的老师名称：‘,school.staffs[0].name)
92 print(‘注册学生的名称：‘,school.students[0].name,school.students[1].name)
93 
94 school.staffs[0].teach() #让老师开始上课 school.staffs[0] = t1 因为school.hire(t1)中append到了self.students = []
95 t1.teach()
96 
97 for stu in school.students:#school.students = [s1,s2]
98     stu.pay_tuition(5000)
99 print(type(school.students))

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 #多态：一种接口，多种实现
 4 #封装可以隐藏实现细节，使得代码模块化；
 5 #继承可以扩展已存在的代码模块（类）；
 6 #它们的目的都是为了——代码重用。
 7 #而多态则是为了实现另一个目的——接口重用
 8 
 9 class Animal(object):
10     def __init__(self, name):  # Constructor of the class
11         self.name = name
12 
13     def talk(self):  # Abstract method, defined by convention only
14         #raise NotImplementedError("Subclass must implement abstract method")
15         pass
16 
17     @staticmethod
18     def animal_talk(obj):  # 相当于独立的接口，一种接口，多种实现
19         obj.talk()
20 
21 class Cat(Animal):
22     def talk(self):
23         print(‘%s: 喵喵喵!‘ % self.name)
24 
25 class Dog(Animal):
26     def talk(self):
27         print(‘%s: 汪！汪！汪！‘ % self.name)
28 
29 # def animal_talk(obj):       #相当于独立的接口，一种接口，多种实现
30 #     obj.talk()
31 
32 d = Dog(‘tom‘)
33 #d.talk()
34 c =Cat(‘mao‘)
35 #c.talk()
36 
37 # animal_talk(d)
38 # animal_talk(c)
39 Animal.animal_talk(d)       #相当于了一种接口，多种实现了需求
40 Animal.animal_talk(c)