面向对象(一)

• 封装思想:将同一类的函数函数封装到同一个py文件中,方便调用

• 面向对象也有封装的作用,将同一类的函数封装到一个类中

• 多态(鸭子模型):多种类型/多种形态

  #面试题,什么事鸭子模型
  对于一个函数,python对于参数的类型不会限制,传入参数时就可以是各种类型,但是在函数中如果有类似于索引等特有方法,就会对传入的参数类型有一个限制(类似于字符串的.append.send方法)
  类似于上述的函数我们认为只要能呱呱叫的就是鸭子（只要有.send方法，就是我们要想的类型）
  # Python
  def func(arg):
      v = arg[-1] # arg.append(9)
      print(v)
  
  # java
  def func(str arg):
      v = arg[-1]
      print(v)
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  

# 1.面向对象基本用法

# 1.1基本格式

class 类名:
    def __init__(self,x):
        self.x = x
    def 方法名字 (self):   #函数在类里称为方法,self就是固定参数,必须写self
        print('方法')
        return 
    def 方法名字 (self):   
        print('方法')
        return 
#实例化一个类的对象
v1 = 类(可以传参)
v2.方法()

# 1.2调用方法

1. 创建类的对象(实例化对象)

   obj=类名() #创建了一个Account类的对象

2. 使用对象调用类的方法

   obj.函数名字()调用时方法是有返回值的,与函数类似

• 应用场景:

 - 函数（业务功能）比较多，可以使用面向对象来进行归类。
 - 想要做数据封装（创建字典存储数据时，面向对象）。
 - 游戏示例：创建一些角色并且根据角色需要再创建人物。

# 1.3对象的作用

• 存储一些值,方便自己使用

  class file:
      def read(self):
          with open(self.xxx, mode='mode='r', encoding='utf-8') as f:
              data = f.read()
          return data
  
      def write(self,content):
          with open(self.xxx, mode='mode='a', encoding='utf-8') as f:
              f.write(content)
  
  # 实例化一个file的对象
  v1 = file()
  # 在对象中写了一个xxx='test.log'
  v1.xxx = 'test.log'
  # 通过对象调用类中的read方法，read方法中的self就v1:
  #v1.read()
  obj1.write('alex')
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  

# 1.4类的初始化方法

• 类() 实例化对象，自动执行此类中的 __ init __方法。

• __ init __ 初始化方法(构造方法),为对象内部做初始化

• 如果有一个反复使用的公共值,课可以放到对象中

class Person:
    def __init__ (self,n,a,g):
        self.name=n
        self.age =a
        self.gender= g
    def show(self):
        temp= '我是%s,今年%s,性别%s'%(self.name,self.age,self.gender)
        print(temp)
# 类() 实例化对象，自动执行此类中的 __init__方法。
p1 = Person('bigox',20,'男')
p1 = show()

# 2.面向对象的三大特性

# 2.1封装

class File:
    def read(self):
        pass
    def write(self):
        pass

class Person:
    def __init__(sef,name,age):
        self.name = name
        self.age = age
p = Person('alex',19)

# 2.2继承

#基本格式
class Base:
    pass
class Foo(Base):
    pass

• 在多个类中如果有公共的方法,可以使用继承,增加代码的重用性.

• 继承关系中查找方法的顺序

  • self是谁?
  • self是哪个类创建的,就从此类开始找,自己没有就找父类

• 多继承就从左往右

  # 父类(基类)
  class Base:
      def f1(self):
          pass
  # 子类（派生类）
  class Foo(Base):
      def f2(self):
          pass
  
  # 创建了一个字类的对象
  obj = Foo()
  # 执行对象.方法时，优先在自己的类中找，如果没有就是父类中找。
  obj.f2()
  obj.f1()
  
  # 创建了一个父类的对象
  obj = Base()
  obj.f1()
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  

# 2.3多态

对于一个函数,python对于参数的类型不会限制,传入参数时就可以是各种类型,但是在函数中如果有类似于索引等特有方法,就会对传入的参数类型有一个限制(类似于字符串的.append.send方法)
类似于上述的函数我们认为只要能呱呱叫的就是鸭子（只要有.send方法，就是我们要想的类型）
# Python
def func(arg):
    v = arg[-1] # arg.append(9)
    print(v)

# java
def func(str arg):
    v = arg[-1]
    print(v)