Python面向对象1：基础介绍+封装特征

目前有三种编程方式：

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

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

• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

java只支持面向对象编程；python支持函数式编程、面向对象编程

1、面向对象其实就是对类和对象的使用

案例1：函数式编程和面向对象编程初步比较

#函数式编程执行方法：【执行函数】

def mail(email,messge):
    print("可以发送邮件了")
    return True
mail("[e-mail]","Hello")#通过执行函数执行

#面向对象编程：【创建对象】【通过对象执行方法】

class Foo:#创建类
    # 定义方法
    def mail(self,email,messge):#函数写在类里，叫方法，且必须含有self参数
        print("可以发邮件了")
        return True
#调用方法：
obj=Foo()#先创建对象：类名（）
#再通过对象去执行对象中的方法
obj.mail("[e-mail]","Hello")

创建对象及使用的步骤：

a创建类

      class类名():

   def 方法名（self，xxx）：#xxx是我们需要传的参数，self是必须的参数

               pass

b.创建对象

    对象=类名（）

c.通过对象执行方法    

    对象.方法名（123）#123为传入的参数

总结：

• 面向对象含有两个特殊的东西：类、对象；

• 面向对象编程其实就是对 “类” 和 “对象” 的使用。

• 类就是一个模板，模板里可以包含多个函数（也即方法），函数是用来实现各种功能的

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

  
  

    类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是self。

2、面向对象的三大特性是指：封装、继承和多态。

2-1 封装：

    使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容

• 将内容封装到某处

• 从某处调用被封装的内容

案例2-1：封装方法1：将参数值在对象中一个个封装，通过对象直接调用，这是初级的笨方法。

self是python自动会给传值的参数，哪个对象执行方法，self就是谁；比如obj1执行时，self就代指obj1，取各种赋值的参数

class SQLHelper():
    def fetch(self, sql):
        print(self.name)
        print(sql)
    def create(self, ad):
        print(ad)
    def remove(self, nig):
        print(nig)
#执行对象1
obj1 = SQLHelper()  # 创建对象1，self就是指obj1
obj1.hhost = "c1.hhh.com"  # 赋值
obj1.name = '对象1'
obj1.pwd = 123
obj1.fetch("select * from A")  # 调用对象的fetch方法
#执行对象2
obj2 = SQLHelper()  # 创建对象2，self就是指obj2
obj2.hhost = "c1.ddd.com"
obj2.name = '对象2'
obj2.pwd = 4333
obj2.fetch("select * from B")  # 调用对象的fetch方法

执行结果：

案例2-2：封装方法二：将参数值一次性封装进对象，调用时，通过对象直接调用被封装的内容

class SQLhelper:#创建对象
    # 封装参数，相同的值/参数直接放到一个地方，即init方法
    def __init__(self,a1,a2,a3):
        print('对象后面加括号，自动执行init方法')
        self.hhost=a1
        self.name=a2
        self.pwd=a3
#调用对象1：
obj1=SQLhelper('c1.hhh.com','对象1',123) #执行init方法
print(obj1.name)# 直接调用obj1对象的name属性
print(obj1.pwd)# 直接调用obj1对象的pwd属性
#调用对象2
obj2=SQLhelper('c1.dddd.com','对象2',4333) #执行init方法
print(obj2.name)# 直接调用obj2对象的name属性
print(obj2.pwd)# 直接调用obj2对象的pwd属性

执行结果：

案例2-3：调用方法：执行类中的方法时，需要通过self间接调用被封装的内容

class SQLhelper:#定义对象
    def __init__(self,a1,a2,a3):#封装参数，相同的值/参数直接放到一个地方，即init方法
        print('对象后面加括号，自动执行init方法')
        self.hhost=a1
        self.name=a2
        self.pwd=a3
    def detail(self):#通过封装方法调用参数
        print(self.hhost)
        print(self.name)
#调用
obj1=SQLhelper('c1.hhh.com','对象1',123) #执行init方法
obj1.detail()
obj2=SQLhelper('c1.dddd.com','对象2',4333) #执行init方法
obj2.detail()

执行结果：

案例3：封装与调用三种方法比较的案例，通过嵌套调用封装的参数

class c1:
    def __init__(self,name,obj):
        self.name=name
        self.obj=obj

class c2:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        print(self.name)
class c3:
    def __init__(self,a1):
        self.money=333 #如果money不需要传参数，就不需要放在init方法中了
      self.aaa=a1 #a1是参数，aaa是c3的参数

c2_object=c2("c2name",11)#实例化c2对象
#c2_object是c2类型
#name="c2name"
#age=11
#包含show方法
c1_object=c1("c1name",c2_object)#实例化c1对象
##c1_object是c1类型,嵌套c2_object
#name="c1name"
#obj=c2_object，包含c2_object的全部参数（name="c2name",age=11，show方法）

c3_object=c3(c1_object)#实例化c3对象
#c3_object是c3类型，嵌套c1_object
#money=333,是固定参数
#aaa=c1_object,即包含c1_object的全部参数(name="c1name"、obj=c2_object)

#调用方法：
c2_object.show()#方法1，通过c2_object
c1_object.obj.show()#方法2：通过c1_object的obj属性调用
c3_object.aaa.obj.show()#方法3：通过c3_object的aaa属性调用

执行结果：三种方法的效果是一致的

案例4：案例比较函数和面向对象编程：

• 如果使用函数式编程，需要在每次执行函数时传入相同的参数，如果参数多的话，又需要粘贴复制了...  ；

• 而对于面向对象编程只需要在创建对象时，将所有需要的参数全部封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。

题目：

• 小明，10岁，男，上山去砍柴

• 小明，10岁，男，开车去东北

• 小明，10岁，男，最爱打地主

• 
  

• 老李，90岁，男，上山去砍柴

• 老李，90岁，男，开车去东北

• 老李，90岁，男，最爱打地主

• ....

• 老张...

#函数式编程实现方法：

class Foo():
    def __init__(self,name,age,gender):
        self.name=name
        self.age = age
        self.gender = gender
    def shangshan(self):
        print("姓名{},{}岁,{},上山去砍柴".format(self.name,self.age,self.gender))
    def kaiche(self):
        print("姓名{},{}岁,{},开车去东北".format(self.name,self.age,self.gender))
    def love(self):
        print("姓名{},{}岁,{},喜欢打地主".format(self.name,self.age,self.gender))
#调用对象1，小明
xiaoming=Foo("小明","10","男")
xiaoming.shangshan()
xiaoming.kaiche()
xiaoming.love()
#调用对象2，小刘
liu=Foo("小刘","20","女")
liu.shangshan()
liu.kaiche()

执行结果：

课程参考:老男孩python课程

案例链接：https://pan.baidu.com/s/1i5d9ihn 密码：mgv6