面向对象

++++++++++++++++++++++++++++++++++

总结目录：

一. 属性与方法
1. 类属性 @property
2. 实例属性
3. 类方法 @classmethod
4. 实例方法
5. 静态方法 @staticmethod
二. 模块 模块的引用与使用：
import xxx 引用xxx模块
import xxx as new_xxx 引用xxx模块,并以new_xxx为别名
from xxx import yyy 从xxx模块引用yyy 属性或者方法或者变量
from xxx import * 从xxx模块引用 所有的属性和方法和变量
from xxx import yyy as new_yyy 从xxx模块引用yyy 并以new_yyy为别名
三 . 列表推导式 ：[ 表达式 for 变量 in 旧列表 if 条件]
四 .生成器：
创建方式：
第一种方法：把列表推导式的[] 修改().例如：(表达式 for 变量 in 旧列表 if 条件);
第二种方法为通过函数+ yield 的方式。
读取： 通过next(生成器实例) 的方式读取数据

1. 基础

类是type类型的一个对象

class Myclass():
    
    # 方法至少需要一个参数
    def speak(self):
        print('speak')


    pass
print(id(Myclass),type(Myclass))
# 140520792804736 <class 'type'>    类型为type

mc = Myclass()
print(id(mc),type(mc))
# 输出：4482600272 <class '__main__.Myclass'>  类型为Myclass

2.self 参数

• 类内部的方法不能直接访问类内部的变量，只能通过“self.属性”的方式访问，并且self 在这里会被指代为类的具体实例。

class Myclass():
    name = '老高'
    # 方法至少需要一个参数，第一个参数指向为实力本身。
    def speak(self):
        print('%s speak'%self.name)
    pass

mc = Myclass()
mc.speak();

mc2 = Myclass()
mc2.name = '高子怡'
mc2.speak()

3. 类的特殊方法，使用开始 结束的函数，

• 在类中的特殊方法，又称为魔术方法。
• 一般是以__xx__() 形式出现的。
• 特殊方法一般都是自动调用的，不需要手动调用的

class Person:
    print('sdsd') # 现执行print('sdsd') ，后执行__init__
    def __init__(self,name):
        print('init 执行')
        self.hidden_name = name

• 其他常用的特殊方法：
  a > __repr__ 和 __str__ - 字符串表示形式
  __repr__ 用于提供给开发者查看的对象字符串表示，而 __str__ 用于提供给用户的对象字符串表示

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __repr__(self):
        return f'Point({self.x}, {self.y})'
    
    def __str__(self):
        return f'({self.x}, {self.y})'

point = Point(3, 4)
print(repr(point))  # 输出结果为 'Point(3, 4)'
print(str(point))   # 输出结果为 '(3, 4)'

b > __len__ 获取对象长度
定义对象的长度，使其支持内置函数 len()

class CustomList:
    def __init__(self, items):
        self.items = items
    
    def __len__(self):
        return len(self.items)

my_list = CustomList([1, 2, 3, 4, 5])
print(len(my_list))  # 输出结果为 5

c > __eq__ 比较相等性
定义对象之间的相等性比较

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
    
    def __eq__(self, other):
        return self.title == other.title and self.author == other.author

book1 = Book('Python', 'Guido')
book2 = Book('Python', 'Guido')
print(book1 == book2)  # 输出结果为 True

d > __iter__ 和 __next__ 迭代器
实现对象的迭代器协议，用于迭代对象。

class Countdown:
    def __init__(self, start):
        self.start = start
    
    def __iter__(self):
        self.current = self.start
        return self
    
    def __next__(self):
        if self.current <= 0:
            raise StopIteration
          # raise 手动触发异常的关键字
          #StopIteration一个内置异常类，通常与迭代器（iterator）和生成器（generator）一起使用。在迭代过程中，当没有更多的元素可供迭代时，Python 的迭代器会引发 StopIteration 异常来通知迭代结束
        else:
            result = self.current
            self.current -= 1
            return result

countdown = Countdown(5)
for num in countdown:
    print(num)  # 输出倒数 5, 4, 3, 2, 1

4. 类的封装

• 需要封装的原因：增强数据的安全性，不能使其随便的更改。
• 封装是指隐藏类中的一些不希望被外部访问的属性和方法。
• 封装的属性一般通过getter() 和setter()的方式对其进行访问和修改
• 隐藏属性真正的方式：一般是需要使用xxx 双下划线的方式，使用双下划线后，python默认会修改属性的名字，使其在外部访问不到。***修改规则为：类名_属性名***
• 但在实际应用中，我们一般使用单下划线_xx的方式定义私有属性

class Person:
    def __init__(self,name,age):
        self.__name = name
        # 在实际应用中，一般使用这种方式保持私有属性。其目的在于告知其他开发者，这是一个私有属性
        self._age = age

    def get_name(self):
        return self.__name

    def set_name(self,name):
        self.__name = name
    def sperk(self):
        print("我的名字叫: %s"%self.get_name())
  
    # 
    # age属性的getter和setter 存取器
    def get_age(self):
        return self._age

    def set_age(self, age):
        self._age = age


p = Person('laogao')
p.sperk()


print(p._Person__name)
# 输出为：laogao。也就是说在使用__xxx 双下划线的方式隐藏属性时，其实质是：python将其属性名称修改为了_类名__属性名***，即_Person__name

5. property 装饰器

@property装饰器 ： 我们可以使用@property装饰器来创建只读属性。

@property 装饰器原理：会将方法转化为相同名称的只读属性。可以与所定义的属性配合使用，这样可以有效的防止属性被修改。

class Person:
    def __init__(self,name,age):
        self._name = name
        self._age = age

    #@property 将方法转化为相同名称的只读属性
    @property
    def name(self):
        return self._name

    #这是一个setter方法，setter方法的装饰器格式为：@属性名.setter
    # 一般很少使用
    @name.setter
    def name(self,name):
        self._name = name


p = Person('laogao', 40)
p.name = '你哈'
print(p.name)

@classmethod 装饰器，可以是类中的方法直接变成为类方法，而非实例方法。
实例方法与类方法的转换：p.test() 与Person.test(p) 是一样的.

class Person():
    total = 0
    def __init__(self,name):
        # 注意类属性的时候，需要赋值给 Person.属性
        Person.total += 1
  
    # classmethod 可以是方法变为类方法，可以直接使用类名调用改方法
    @classmethod
    def getTotal(self):
        print('当前一共 %s 个人'%self.total)
        return
    # 实例方法
    def test(self):
        print('实例方法test')

p = Person('laogao')
p2 = Person('gaotui')

# 该处是 使用的类的方法 直接调用的
Person.getTotal()
#输出 当前一共 2 个人

#其实我尝试了一下，使用实例也是可以调用的
p2.getTotal()
#输出 当前一共 2 个人

# 实例方法与类方法的转换
p.test() 与Person.test(p) 是一样的。

@staticmethod 用于定义静态方法的装饰器
静态方法是类中的一个方法，与类和实例无关，它不会自动传递类或实例作为第一个参数。静态方法在逻辑上属于类，但在定义时不需要指定 self 或 cls 参数。
一般用于做一些工具类使用比较多。

class MathOperations:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

# 通过类直接调用静态方法
print(MathOperations.add(5, 3))       # 输出结果为 8
print(MathOperations.multiply(5, 3))  # 输出结果为 15

# 通过类的实例调用静态方法
math = MathOperations()
print(math.add(2, 2))       # 输出结果为 4
print(math.multiply(2, 2))  # 输出结果为 4

6. 继承与多重继承

• 使用继承的方式，提高类的复用性（基类，超类）
• super()获取当前类的父类,调用是不需要self参数
• 多重继承：是指一个子类可以继承多个父类的属性和方法。
  方式为： 在类名的()内添加多个父类,多父类中同名的方法，按照第一父类，第二父类依次向上寻找。前面的覆盖后面的

  但是 python接收多重继承。 一般很少使用，使用时会程序更加复杂化。

class A:
    def some_method(self):
        print("Method from class A")
# 继承，
class B(A):
     def __init__(self,name,age):
        # super()获取当前类的父类,调用是不需要self参数
        super().__init__(name)
        self._age = age
    def some_method(self):
        super().some_method()  # 调用 A 类的 some_method()
        print("Method from class B")

class C(A):
    def some_method(self):
        print("Method from class C")

# 多重继承
class D(B, C):
    def some_method(self):
        super(B,self).some_method()  # 调用 B 类的 some_method()
        print("Method from class D")

6. 多态 即多种形态

譬如：内置方法len()，就是多态。不管输入的是list类型还是字符串类型。都可以输出正确的长度。

lst = [1,2,3]
print(len(lst))
# 输出：2
str = 'python'
print(len(str))
# 输出：6