python学习日记3-面向对象

2023-12-29  本文已影响0人  livein80

面向对象

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

总结目录:

一. 属性与方法
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 参数
class Myclass():
    name = '老高'
    # 方法至少需要一个参数,第一个参数指向为实力本身。
    def speak(self):
        print('%s speak'%self.name)
    pass

mc = Myclass()
mc.speak();

mc2 = Myclass()
mc2.name = '高子怡'
mc2.speak()
3. 类的特殊方法,使用开始 结束的函数,
class Person:
    print('sdsd') # 现执行print('sdsd') ,后执行__init__
    def __init__(self,name):
        print('init 执行')
        self.hidden_name = name
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. 类的封装
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. 继承与多重继承
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
上一篇下一篇

猜你喜欢

热点阅读