面向对象1

 

概述

面向过程： 根据业务逻辑从上到下的写垒代码

函数式：将某功能代码封装到函数中，日后可无需重复的编写，仅仅调用函数即可

面向对象：对函数进行分类和封装

 

面向对象编程是一种编程方式，此编程方式的落地需要使用‘类’和‘对象 ’来实现，所以，面向对象其实就是对类和对象的使用

类就是一个模版，模板里可以包含多个函数，函数里实现一些功能

对象则是根据模板的创建的实例，通过实例对象可以执行类中的函数

函数式编程和面向对象的对比：

 1 #发送一个消息提醒的功能（邮件/短信/微信）
 2 #函数：
 3 def email(em,tex):
 4     """发送邮件
 5     :return
 6     """
 7     print(em,tex)
 8 def mag(tel,tex):
 9     """发送短信
10     :return
11     """
12     print(tel,tex)
13 def wechat(num,tex):
14     """发送微信
15     :return
16     """
17     print(num,tex)
18
函数编程
 1 #函数：
 2 class Message:
 3     def email(self,em,tex):
 4         """发送邮件
 5         :return
 6         """
 7         print(em,tex)
 8     def mag(self,tel,tex):
 9         """发送短信
10         :return
11         """
12         print(tel,tex)
13     def wechat(self,num,tex):
14         """发送微信
15         :return
16         """
17         print(num,tex)
18 if 1==1:
19     obj=Message()
20     obj.email('aaaa','章子怡购买了一条裙子')
21     obj.mag('bbbb','王菲购买了一件T恤')
22     obj.wechat('cccc','汪峰购买了一块手表')
面向对象

对比：函数：定义简单/调用简单
           面向对象：定义复杂/调用复杂，好处：归类，将某些类似的函数写在一起

 

面向对象的方式格式：

1 class 类名：     #定义了一个类
2    def 函数名（self）:       #在函数中编写了一个方法
3         pass
4  obj=类名（）    #   创建了一个对象/实例化了一个对象
5 obj.函数名（）    # 通过对象调用其中一个方法
面向对象的格式
 1 #登录
 2 class Account:
 3     def login(self):
 4         user=input("请输入用户名：")
 5         pwd=input("请输入密码：")
 6         if user=="aaa" and pwd=="111":
 7             print("登录成功")
 8         else:
 9             print("登录失败")
10 obj=Account()
11 obj.login()
实例1 登录
 1 #函数版
 2 def a(name,gender,age,hobby):
 3     data='%s,性别%s,今年%s岁，喜欢%s' %(name,gender,age,hobby)
 4     print(data)
 5 
 6 def b(name,gender,age,hobby):
 7     data='%s,性别%s,今年%s岁，喜欢%s' %(name,gender,age,hobby)
 8     print(data)
 9 
10 def c(name,gender,age,hobby):
11     data='%s,性别%s,今年%s岁，喜欢%s' %(name,gender,age,hobby)
12     print(data)
13 
14 a('章子怡','女','30','喝咖啡')
15 b('汪峰','男','30','跑步')
16 c('王菲','女','30','游泳')
实例2 完成打印
 1 lass Person:
 2     def __init__(self,name,gender,age,hobby):
 3         self.name=name
 4         self.gender=gender
 5         self.age=age
 6         self.hobby=hobby
 7 
 8     def a(self):
 9         data='%s,性别%s,今年%s岁，喜欢%s' %(self.name,self.gender,self.age,self.hobby)
10         print(data)
11 
12     def b(self):
13         data='%s,性别%s,今年%s岁，喜欢%s' %(self.name,self.gender,self.age,self.hobby)
14         print(data)
15 
16     def c(self):
17         data='%s,性别%s,今年%s岁，喜欢%s' %(self.name,self.gender,self.age,self.hobby)
18         print(data)
19 
20 obj=Person('章子怡','女','30','喝咖啡')
21 obj.a()
22 obj.b()
23 obj.c()
实例2 完成打印面向对象版
 1 lass UserInfo:
 2 
 3     def __init__(self):
 4         self.name = None
 5 
 6     def info(self):
 7         print('当前用户名称:%s' %(self.name,))
 8 
 9     def account(self):
10         print('当前用户%s的账单是:....' %(self.name,))
11 
12     def shopping(self):
13         print('%s购买了一个人形抱枕' %(self.name,))
14 
15     def login(self):
16         user = input('请输入用户名:')
17         pwd = input('请输入密码:')
18         if pwd == 'sb':
19             self.name = user
20             while True:
21                 print("""
22                     1. 查看用户信息
23                     2. 查看用户账单
24                     3. 购买抱枕
25                 """)
26                 num = int(input('请输入选择的序号:'))
27                 if num == 1:
28                     self.info()     #相当于obj.info()
29                 elif num ==2:
30                     self.account()
31                 elif num == 3:
32                     self.shopping()
33                 else:
34                     print('序号不存在,请重新输入')
35         else:
36             print('登录失败')
37 
38 obj = UserInfo()
39 obj.login()
实例


面向对象的三大特性：封装，继承，多态

 1 #将相关功能封装到一个类中：
 2 class Message:       #都是提醒信息类
 3     def email(self):pass
 4     def msg(self):pass
 5     def wechat(self):pass
 6 
 7 
 8 
 9 
10 #将数据封装到一个对象中：
11 class Person:
12     def __init__(self,name,age,gender):    
13         self.name = name
14         self.age = age
15         self.gender = gender
16                         
17 obj = Person('哈哈',18,'女')
封装

 

 1 #基本写法
 2 继承
 3 class SuperBase:
 4     def f3(self):
 5         print('f3')
 6 class Base(SuperBase):    #Base是父类 也称基类
 7     def f2(self):
 8         print('f2')
 9 class Foo(Base):                 #Foo是子类，派生类
10     def f1(self):
11         print('f1')
12 obj=Foo()
13 obj.f1()
14 obj.f2()
15 obj.f3()
16 
17 
18 原则：先在自己类中找，没有才去父类找
19 结果：f1
20         f2
21         f3
继承

为何有继承：为了提高代码的重用性

 1 class Base:
 2     def f1(self):
 3         pass
 4 
 5 class Foo(Base):
 6 
 7     def f2(self):
 8         pass
 9 
10 class Bar(Base):
11 
12     def f3(self):
13         pass
代码重用性
 1 class Base1:
 2     def show(self):
 3         print('Base1.show')
 4 
 5 class Base2:
 6     def show(self):
 7         print('Base2.show')
 8 
 9 class Foo(Base1,Base2):
10     pass
11 
12 obj = Foo()
13 obj.show()
多继承
  1 # class Base:
  2 #     def f1(self):
  3 #         print('base.f1')
  4 #
  5 # class Foo(Base):
  6 #     def f2(self):
  7 #         print('foo.f2')
  8 
  9 
 10 # 1. 是否执行
 11 # obj = Foo()
 12 # obj.f2()
 13 # obj.f1()
 14 
 15 # 2. 是否执行
 16 # obj = Base()
 17 # obj.f1()
 18 # obj.f2() # 错
 19 
 20 ##### 习题2:
 21 """
 22 class Base:
 23     def f1(self):
 24         print('base.f1')
 25 
 26 class Foo(Base):
 27     def f3(self):
 28         print('foo.f3')
 29     
 30     def f2(self):
 31         print('foo.f2')
 32         self.f3() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 33         
 34 obj = Foo()
 35 obj.f2() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 36 """
 37 
 38 ##### 习题3:
 39 """
 40 class Base:
 41     def f1(self):
 42         print('base.f1')
 43 
 44     def f3(self):
 45         print('foo.f3')
 46 
 47 class Foo(Base):
 48 
 49     def f2(self):
 50         print('foo.f2')
 51         self.f3()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 52 
 53 
 54 obj = Foo()
 55 obj.f2()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 56 """
 57 ##### 习题4:
 58 """
 59 class Base:
 60     def f1(self):
 61         print('base.f1')
 62 
 63     def f3(self):
 64         self.f1() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 65         print('foo.f3')
 66 
 67 class Foo(Base):
 68 
 69     def f2(self):
 70         print('foo.f2')
 71         self.f3()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 72 
 73 
 74 obj = Foo()
 75 obj.f2()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 76 """
 77 ##### 习题5:
 78 """
 79 class Base:
 80     def f1(self):
 81         print('base.f1')
 82 
 83     def f3(self):
 84         self.f1() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 85         print('base.f3')
 86 
 87 class Foo(Base):
 88     def f1(self):
 89         print('foo.f1')
 90 
 91     def f2(self):
 92         print('foo.f2')
 93         self.f3()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 94 
 95 
 96 obj = Foo()
 97 obj.f2()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
 98 # foo.f2
 99 # foo.f1
100 # base.f3
101 
102 obj2 = Base()
103 obj2.f3()
104 # base.f1
105 # base.f3
106 """
107 # 总结: self是那个类的对象,那么就从该类开始找(自己没有就找父类)
108 
109 ##### 习题6:
110 
111 class Base1:
112     def f1(self):
113         print('base1.1')
114     def f2(self):
115         print('base1.f2')
116 
117 class Base2:
118     def f1(self):
119         print('base2.f1')
120 
121     def f2(self):
122         print('base2.f2')
123 
124     def f3(self):
125         print('base2.f3')
126         self.f1()
127 
128 class Foo(Base1,Base2):
129 
130     def f0(self):
131         print('foo.f0')
132         self.f3()
习题

多态：多种形态或多种状态（ 由于python原生支持多态,所以没有特殊性.）

 

posted @ 2018-08-27 16:38  茉莉花M  阅读(193)  评论(0)  编辑  收藏  举报