美文网首页
python学习日记3-面向对象

python学习日记3-面向对象

作者: livein80 | 来源:发表于2023-12-29 23:46 被阅读0次

面向对象

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

总结目录:

一. 属性与方法
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

相关文章

  • python面向对象学习笔记-01

    学习笔记 # 0,OOP-Python面向对象 - Python的面向对象 - 面向对象编程 - 基础 -...

  • Python精简入门学习(十四)

    Python精简入门学习之面向对象(oop) -面向对象 -类和对象

  • python学习笔记目录

    Python学习笔记目录(倒序) Python学习-异常 Python学习-面向对象 Python学习-文件系统 ...

  • Python学习-面向对象

    查看所有Python相关学习笔记 面向对象 面向对象知识点汇总: 面向对象静态属性实例属性(self)静态方法(@...

  • Python 面向对象编程

    Python 面向对象编程(一) Python 面向对象编程(一) 虽然Python是解释性语言,但是它是面向对象...

  • 22.Python编程:封装、继承、多态

    前面学习了面向过程和面向对象的概念,又学习了Python中类和对象的相关知识,其中面向对象最大的特征是:封装、继承...

  • python基础-02

    Python 面向对象 python是一门面向对象的语言 Python内置类属性 python对象销毁(垃圾回收)...

  • 王艳华Pythonday03

    Python的面向对象 Java 面向对象 继承

  • Python是一门纯粹的面向对象语言?

    我之前就在学习Python,而Python自己也说了自己是一门纯粹的面向对象语言.包括int类型都是对象.所谓面向...

  • 10.28

    看海量数据处理部分题目 学习python面向对象

网友评论

      本文标题:python学习日记3-面向对象

      本文链接:https://www.haomeiwen.com/subject/dahjndtx.html