面对对象、网络和并行编程（4）

面向对象&网络&并发编程

1.面向对象

• 面向对象，Python中支持两种编程方式来写代码，分别是：函数式编程、面向对象式编程

  • 函数式

    # 函数式
    # # 定义函数，在函数中实现功能
    
    
    def func():
        print("面向对象")
    
    
    # 执行函数
    func()
    

  • 面向对象

    # 面向对象
    # # 定义类
    
    class Foo(object):
        # 在类中定义方法
        def func(self):
            print("面向对象")
    
    
    # 实例化类的对象
    obj = Foo()
    
    # 执行类中的方法
    obj.func()
    

1.面向对象基础

1.初始面向对象

• 定义类，在类中定义方法，在方法中去实现具体的功能

• 实例化类并创建一个对象，通过对象去调用并执行方法

  class Message:
      '''
      注意:
          1.类名称首字母大写 & 驼峰式命名
          2.py3之后默认类都继承object
          3.在类中编写的函数称为方法
          4.每个方法的第一参数是self
      '''
      def send_email(self, email, content):
          data = "给{}发邮件，内容是: {}".format(email, content)
          print(data)
  
  
  msg_object = Message()
  msg_object.send_email("29***651@qq.com", "注册成功")
  

• 类中可以定义多个方法

  class Message:
  
      def send_email(self, email, content):
          data = "给{}发邮件，内容是: {}".format(email, content)
          print(data)
  
      def send_wechat(self, vid, content):
          data = "给{}发微信，内容是: {}".format(vid, content)
          print(data)
  
  
  msg_object = Message()
  msg_object.send_email("29***651@qq.com", "注册成功")
  msg_object.send_wechat("Ailke", "注册成功")
  

1.对象和self

• 在每个类都可以定义个特殊的: **___init_**初始化方法，在实例化类创建对象时自动执行，即: 对象=类()

  class Message:
      
      '''
      对象 = 类名()   自动执行类中的__init__方法
      
      1.根据类型创建一个对象，内存的一块 区域
      2.执行__init__方法，模块会创建的那块区域的内存地址当self参数传递进去      往区域中(data = "注册成功" )
      '''
  
      def __init__(self, content):
          self.content = content
  
      def send_email(self, email):
          data = "给{}发邮件，内容是: {}".format(email, self.content)
          print(data)
  
      def send_wechat(self, vid):
          data = "给{}发微信，内容是: {}".format(vid, self.content)
          print(data)
  
  
  msg_object = Message("注册成功")
  msg_object.send_email("29***651@qq.com")  # 给29***651@qq.com发邮件，内容是：注册成功
  msg_object.send_wechat("Ailke")  # 给Ailke发微信，内容是：注册成功
  

  • 对象，可以在它的内部先封装一部分数据，以后想要使用时，再去里面获取
  • self， 类中的方法需要要由这个类的对象来触发并执行(对象.方法名)，且再执行时会自动将对象当作参数传递给self，以供方法中获取已封装的值
  • 注:除了self默认参数以外，方法中的参数的定义和执行与函数是相同

• 根据类创建多个对象并执行其中的方法

  class Message:
  
      '''
      对象 = 类名()   自动执行类中的__init__方法
  
      1.根据类型创建一个对象，内存的一块 区域
      2.执行__init__方法，模块会创建的那块区域的内存地址当self参数传递进去      往区域中(data = "注册成功" )
      '''
  
      def __init__(self, content):
          self.content = content
  
      def send_email(self, email):
          data = "给{}发邮件，内容是: {}".format(email, self.content)
          print(data)
  
      def send_wechat(self, vid):
          data = "给{}发微信，内容是: {}".format(vid, self.content)
          print(data)
  
  
  msg_object = Message("注册成功")
  msg_object.send_email("29***651@qq.com")
  msg_object.send_wechat("Ailke")
  
  login_object = Message("登录成功")
  login_object.send_email("29***651@qq.com")
  login_object.send_wechat("Ailke")
  

  • 面对对象的思想
    • 将一些数据封装到对象中，在执行方法时，再去对象中获取
  • 函数式的思想
    • 函数内部需要的数据均通过参数的形式传递

2.常见成员

• 实例变量，属于对象，只能通过对象调用

• 绑定方法，属于类，通过 对象调用 或 通过类调用

  class Person:
  
      country = "中国"
      
      def __init__(self, name, age):
          self.name = name
          self.age = age
  
      # 绑定方法
      def show(self):
          print("{}的年龄是{}".format(self.name, self.age))
  
      def all_message(self):
          print("我是{}人，我叫{}，我的年龄是{}".format(Person.country, self.name, self.age))
  
      def total_message(self):
          msg = "我是{}人，我叫{}，我的年龄是{}".format(self.country, self.name, self.age)
          print(msg)
  
  
  # 执行绑定方法
  p1 = Person("Ailke", 20)
  p1.show()
  # 都是调用show函数，效果类似
  p2 = Person("Ailke", 25)
  Person.show(p2)
  

2.三大特性

1.封装

• 将同一类方法封装到一个类中
• 将数据封装到对象中，再实例化一个对象是，可以通过**__init__**初始化方法在对象中封装一些数据，以便以后使用

2.继承

• 子类可以继承父类的方法和类变量(注意不是拷贝)

• Python支持多继承，先继承左边，再继承右边

• 执行对象.方法时，优先去当前对象所关联的类中找，没有再去它的父类中查找

• self到底是谁，去self对应的类中去获取成员，没有就按照继承关系向上查找

  class TCPSever:
      def fun(self):
          print("TCPSever")
  
  
  class ThreadingMixIn:
      def fun(self):
          print("ThreadingMixIn")
  
  
  class ThreadingTCPServer(ThreadingMixIn, TCPSever):
      def run(self):
          print("before")
          self.fun()
          print("after")
  
  
  '''
  before
  ThreadingMixIn
  after
  '''
  obj = ThreadingTCPServer()
  obj.fun()
  

3.多态

• 其他语言多态

  • 接口或抽象类或抽象方法来实现，让数据可以以多种形态存在(JAVA语言)

  abstract class Animal {  
      abstract void eat();  
  }  
  
  class Cat extends Animal {  
      public void eat() {  
          System.out.println("吃鱼");  
      }  
  }
  
  class Dog extends Animal {  
      public void eat() {  
          System.out.println("吃骨头");  
      }  
      public void work() {  
          System.out.println("看家");  
      }  
  }
  
  
  public class Test {
     public static void main(String[] args) {
         obj1 = Cat()
         show(obj1)
             
  	   obj2 = Dog()
  	   show(obj2)
     }  
      
      public static void show(Animal a)  {
        a.eat()
      }  
  } 
  

• Python中多态

  • Python中则不一样，由于Python对数据类型没有任何限制，所以天生支持多态

    
    class Email(object):
        def send(self):
            print("发送邮件")
    
    
    class Message(object):
        def send(self):
            print("发送短信")
    
    
    def func(arg):
        v1 = arg.send()
        print(v1)
    
    
    v1 = Email()
    func(v1)
    
    
    v2 = Message()
    func(v2)
    

2.面向对象进阶

1.成员

1.变量

• 实例变量

  • 属于对象，每个对象中各自维护自己的数据

• 类变量

  • 属于类，可以被所有对象共享，一般用于给对象提供公共数据(类似于全局变量)

    class Person(object):
        country = "中国"
    
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def show(self):
            message = "{}~{}~{}".format(self.country, self.name, self.age)
            print(message)
    
    
    print(Person.country)  # 中国
    
    
    p1 = Person("Ailke", 20)
    print(p1.name)  # Ailke
    print(p1.country)  # 中国
    p1.show()  # 中国~Ailke~20
    
    p2 = Person("Tom", 25)
    p2.country = "美国"
    p2.show()  # 美国~Tom~25
    
    Person.country = "USA"
    p1.show()  # USA~Ailke~20
    
    p2.show()  # 美国~Tom~25
    

2.方法

• 绑定方法，默认有一个self参数，由对象进行调用

• 类方法，默认有一个cls参数，用类或对象可以调用

• 静态方法，无默认参数，用类或对象都可以调用

  class Foo(object):
      def __init__(self, name, age):
          self.name = name
          self.age = age
  
      def show(self):
          print("{}~{}".format(self.name, self.age))
  
      @classmethod
      def func(cls):
          print("类方法", cls)
  
      @staticmethod
      def static_func():
          print("静态方法")
  
  # 绑定对象(方法)
  obj = Foo("Ailke", 20)
  obj.show()  # Ailke~20
  Foo.show(obj)  # # Ailke~20
  
  # 类方法
  Foo.func()  # 类方法 <class '__main__.Foo'>
  obj.func()  # 类方法 <class '__main__.Foo'>
  
  # 静态方法
  Foo.static_func()  # 静态方法
  obj.static_func()  # 静态方法
  

  • 注:
    • Python，方法可以通过对象或类进行调用
    • JAVA、c#等语言中，绑定方法只能由对象调用；类方法或静态方法只能由类调用

3.属性

• 属性其实是由绑定方法 + 特殊装饰器 组合创造出来的，以后调用方法时可以不加括号

  # 属性
  class Foo(object):
      def __init__(self, name, age):
          self.name = name
          self.age = age
  
      def func1(self):
          return 123
  
      @property
      def func2(self):
          return self.name
  
  
  obj = Foo("Ailke", 20)
  print(obj.func1())  # 123
  print(obj.func2)  # Ailke
  

• 属性的编写有两种方式

  • 基于装饰器

    • @property，@<property_name>.setter, @<property_name>.deleter是装饰器，被用于定义一个类的属性获取(get)、设置（set)和删除(delete)方法
    • @property装饰器用于将方法转换为只读属性

    class C(object):
    
        @property
        def func1(self):
            pass
    
        @func1.setter
        def func1(self, value):
            pass
    
        @func1.deleter
        def func1(self):
            pass
    
    
    obj = C()
    obj.func1
    obj.func1 = 123
    del obj.func1
    

  • 基于定义变量

    class C(object):
    
        def getx(self):
            pass
    
        def setx(self, value):
            pass
    
        def delx(self):
            pass
    
        x = property(getx, setx, delx, "I'm the 'x' property.")
    
    
    obj = C()
    
    obj.x
    obj.x = 123
    del obj.x
    

2.成员修饰符

• Python中成员的修饰符是指的是: 公有、私有

  • 公有，在任何地方都可以调用的这个成员

  • 私有，只有在类的内部才可以调用该成员(成员是以两个下划线开头，则表示该成员为私有)

    class Member_modifier(object):
    
        def __init__(self, name, age):
            self.__name = name
            self.age = age
    
        def get_data(self):
            return self.__name
    
        def get_age(self):
            return self.age
    
    # 公有成员
    obj = Member_modifier("Ailke", 20)
    print(obj.age)
    v1 = obj.get_age()
    print(v1)
    
    # 私有成员
    # print(obj.__name)  # error，由于是私有成员，只能在类中进行使用
    v2 = obj.get_data()
    print(v2)  # Ailke
    
    

    注: 父类中的私有成员，子类无法继承

3.对象嵌套

• 在基于面向对象进行编程时，对象之间可以存在各种各样的关系

  # 对象嵌套
  
  # 学生
  class Student(object):
      def __init__(self, name, age):
          self.name = name
          self.age = age
  
      def message(self):
          data = "我是一名学生，我的名字叫{},我今年{}岁了".format(self.name, self.age)
          print(data)
  
  
  stu1 = Student("张三", 18)
  stu2 = Student("李四", 19)
  stu3 = Student("王五", 20)
  
  
  # 班级
  class Classes(object):
  
      def __init__(self, title):
          self.title = title
          self.students = []
  
      def add_student(self, student):
          self.students.append(student)
  
      def add_students(self, students):
          for stu in students:
              self.add_student(stu)
  
      def show_members(self):
          for item in self.students:
              item.message()
  
  cla = Classes("高三二班")
  cla.add_student(stu1)
  cla.add_students([stu2, stu3])
  
  print(cla.title)
  cla.show_members()
  

4.特殊成员

• 在Python的类中存在一些特殊的方法，这些方法都是**__方法__**格式,这种方法在内部均有特殊的含义

  • __init__,初始化方法

  • __new__，构造方法

  • __call__

    class CallableClass:
        def __init__(self, value):
            self.value = value
    
        def __call__(self, *args, **kwargs):
            print(f"CallableClass called with {args} and {kwargs}")
            return self.value
    
    # 实例化
    c = CallableClass(10)
    # 调用__call__函数，可以直接调用
    result = c()  # CallableClass called with () and {}
    print(result)
    # 也可以给c()传递参数
    

  • __str__

    class Person:  
        def __init__(self, name, age):  
            self.name = name  
            self.age = age  
      
        def __str__(self):  
            return f"Person(name={self.name}, age={self.age})"  
      
    # 创建一个Person对象  
    person = Person("Alice", 30)  
      
    # 打印对象，这会调用__str__方法  
    print(person)  # 输出: Person(name=Alice, age=30)  
      
    # 将对象转换为字符串并与另一个字符串拼接  
    description = str(person) + " is a nice person."  
    print(description)  # 输出: Person(name=Alice, age=30) is a nice person.
    

  • __dict__

    • 注意点，__dict__不推荐用来修改对象的属性，它可能绕开属性访问控制

    class MyClass:  
        def __init__(self, name, age):  
            self.name = name  
            self.age = age  
      
    # 创建一个MyClass的实例  
    obj = MyClass("Alice", 30)  
      
    # 访问对象的__dict__属性  
    print(obj.__dict__)  # 输出: {'name': 'Alice', 'age': 30}  
      
    # 通过__dict__修改对象的属性  
    obj.__dict__['age'] = 31  
    print(obj.age)  # 输出: 31  
      
    # 也可以向__dict__添加新的属性  
    obj.__dict__['city'] = 'New York'  
    print(obj.city)  # 输出: New York
    

  • __getitem__、__setitem__ 、__delitem__

    class MySequence:  
        def __init__(self, data):  
            self.data = data  
      
        def __getitem__(self, index):  
            return self.data[index]  
      
        def __setitem__(self, index, value):  
            self.data[index] = value  
      
        def __delitem__(self, index):  
            del self.data[index]  
      
    seq = MySequence([1, 2, 3, 4, 5])  
    del seq[2]  
    print(seq[2])  # 输出: 4
    

  • __enter__ 、__exit__

    class MyContextManager:  
        def __enter__(self):  
            print("Entering the context")  
            return self  
      
        def __exit__(self, exc_type, exc_val, exc_tb):  
            print("Exiting the context")  
            if exc_type is not None:  
                print(f"Caught an exception