2023-02-22Python40

本文整理自下面这个视频：

Object Oriented Programming (OOP) In Python - Beginner Crash Course author:Python Engineer (Youtube)

谈到OOP，就不得不谈继承、多态和封装。继承实现了代码重用，并且是多态的基础；多态提高了代码的灵活性、扩展性；封装隐藏内部细节，更好地保护数据。抽象是OOP的基础，有好的抽象能力才能设计出好的基类，好的函数层级...... （by 一只大鸽子）

WHY?

为什么我们需要Class？如果你的需求很简单，基本数据类型就可以满足，那么不需要Class。但是随着需求变得复杂，你会发现有非常多的数据和函数需要管理。这个时候就需要用Class了。举例：你要写一个管理雇员信息的程序，现在正在写管理"软件工程师"人员的代码。一个软件工程师有这些信息：职位、姓名、年龄、等级、工资。你可以用列表来存储，或者用 namedtuple来存储信息。没问题，代码可以跑通。但是后面进行操作的时候，就会比较混乱。

因此，我们用类实现"软件工程师"：在 __init__中初始化他的信息（属性）。


class SoftwareEngineer:

    def __init__(self, name, age, level, salary):
        self.name = name
        self.age = age
        self.level = level
        self.salary = salary

if __name__ == '__main__':
    se1 = SoftwareEngineer('DD',20,'Senior', 7000)

class attributes & instance attributes

刚刚在 __init__中的属性是 instance attributes，和每一个具体的软件工程师相关（如名字，每个软件工程师都有自己的名字），而 class attributes是和类相关，不依赖具体的人（如他们的中文名称都是"软件工程师"）。一般在class 中定义（而不在 __init__函数内）。

class SoftwareEngineer:
    # class attributes
    alias = "Keyboard Magician"  # 别名
    cn_name = "软件工程师"

    # instance attributes
    def __init__(self, name, age, level, salary):
        self.name = name
        self.age = age
        self.level = level
        self.salary = salary

if __name__ == '__main__':
    se1 = SoftwareEngineer('DD', 20, 'Senior', 7000)
    print(se1.cn_name)
    print(SoftwareEngineer.cn_name)

现在我们要让软件工程师写代码了。我们定义一个函数 code()，让某个工程师写代码：

    def code(self):
        print(f"{self.name} is writing code...")

如果想让他用某个语言写代码，可以给函数加一个 language参数：

    def code_in_language(self,language):
        print(f"{self.name} is writing code...in {language}")

dunder method

带有双下划线的方法，是Python中的一种特殊方法，也称为魔法方法，会被隐式地自动调用。例如 __init__方法，我们不用手动调用，而是创建对象时自动调用。 se1 = SoftwareEngineer('DD', 20, 'Senior', 7000)

类中常用的一个dunder method 是 __str__，用来返回实例信息。

    # dunder method
    def __str__(self):
        information = f"name = {self.name}, age={self.age}, level={self.level}"
        return information

__str__方法返回一个包含实例信息的字符串，在print(实例)时会自动调用。 print(se1)

__eq__(self, other) ：比较两个对象相等时自动调用，该函数应该返回一个布尔类型值

类中的静态方法

使用 @staticmethod修饰。属于类但不属于某个具体的实例（没有self参数）。

    @staticmethod
    def entry_salary(age):
        if age > 25 :
            return 7000
        else:
            return 5000

继承（inherits）、扩展(extend)、重写(override)

继承（inherits）

ChildClass(BaseClass) 继承一个类，意味着继承类的属性和方法。

class Employee:
    def __init__(self, name, age, salary):
        self.name = name
        self.age = age
        self.salary = salary

    def work(self):
        print(f"f{self.name} is working...")

class SoftwareEngineer(Employee):
    pass

class Desiner(Employee):
    pass

if __name__ == '__main__':
    se = SoftwareEngineer("DD",25,5000, "Junior")
    print(se.name)

扩展(extend)

新增方法。例如可以在SoftwareEngineer中新增debug方法。

class SoftwareEngineer(Employee):
    #override
    def __init__(self,name, age, salary, level):
        super().__init__(name,age,salary)
        self.level = level
    # extend
    def debug(self):
        print(f"{self.name} is debugging...")

重写(override)

和父类方法同名时会覆盖掉父类方法，注意：初始化方法 __init__重写时必须调用父类的初始化方法 super().__init__。否则会出现意想不到的错误（找不到属性等问题）。


class Employee:
    def __init__(self, name, age, salary):
        self.name = name
        self.age = age
        self.salary = salary

    def work(self):
        print(f"{self.name} is working...")

class SoftwareEngineer(Employee):
    #override
    def __init__(self,name, age, salary, level):
        super().__init__(name,age,salary)
        self.level = level
    # extend
    def debug(self):
        print(f"{self.name} is debugging...")
    # override
    def work(self):
        print(f"{self.name} is coding...")

class Desiner(Employee):
    # override
    def work(self):
        print(f"{self.name} is designing...")

多态（Polymorphism）

调用同一方法，根据具体的类表现出不同的行为。

    se = SoftwareEngineer("DD",25,5000, "Junior")
    de = Desiner("xd",25,5000)

    employes = [se,de]
    for employe in employes:
        employe.work()

_salary 以单下划线开头的变量或函数（习惯上地、并非语法规定地） 约定为私有变量，不该在外部直接访问或修改。而应该通过getter和setter方法进行访问和修改。 __xx以双下划线开头的变量会被重命名为 _ClassName__xx，避免意外访问。虽然有这些约定，但是实际上Python没有实现真的私有变量。外部还是可以访问所有变量。

@property 修饰getter方法, 并且可以通过该函数名x获取属性x。函数名和属性名是一样的。 @x.setter 修饰setter方法，并且修改属性x时会自动调用该方法。 @x.deleter 修饰del 方法，删除属性x时会自动调用，用的很少。

class SoftwareEngineer():
    #override
    def __init__(self,name, age, salary,level):
        self.name = name
        self.age = age
        self._salary = salary
        self.level = level
    @property
    def salary(self):
        return self._salary
    @salary.setter
    def salary(self, value):
        self._salary = value
    @salary.deleter
    def salary(self):
        del self._salary

if __name__ == '__main__':
    se1 = SoftwareEngineer('DD',25,5000,'Junior')
    print(se1.salary)
    se1.salary = 7000
    print(se1.salary)

Original: https://blog.51cto.com/pigeon/5484082
Author: 一只大鸽子
Title: Python-OOP 快速入门

相关阅读1

Title: 如何使用PyQt5一步步实现用户登录GUI界面、登录后跳转？

PyQt5是强大的GUI工具之一，通过其可以实现优秀的桌面应用程序。希望通过一个简单的登录页面可以让大家顺利入坑，如有不妥之处还请大佬指点改正！

Python-OOP 快速入门

【阅读全文】

导入业务需要的所有的扩展包。

import sys  # 系统参数操作
from PyQt5.QtWidgets import *  # 模块包含创造经典桌面风格的用户界面提供了一套UI元素的类
from PyQt5.QtCore import *  # 此模块用于处理时间、文件和目录、各种数据类型、流、URL、MIME类型、线程或进程
from PyQt5.QtGui import *  # 含类窗口系统集成、事件处理、二维图形、基本成像、字体和文本

创建主界面窗口。

class MainWindow(QMainWindow):
    def __init__(self, *args, **kwargs):
        '''
        构造函数，初始化参数属性
        :param args:
        :param kwargs:
        '''
        super().__init__(*args, **kwargs)
        self.setWindowTitle('主功能页面')
        self.setFixedWidth(600)
        self.setFixedHeight(600)

创建登录对话框。

class LoginDialog(QDialog):
    def __init__(self, *args, **kwargs):
        '''
        构造函数，初始化登录对话框的内容
        :param args:
        :param kwargs:
        '''
        super().__init__(*args, **kwargs)
        self.setWindowTitle('欢迎登录')  # 设置标题
        self.resize(200, 200)  # 设置宽、高
        self.setFixedSize(self.width(), self.height())
        self.setWindowFlags(Qt.WindowCloseButtonHint)  # 设置隐藏关闭X的按钮

        '''
        定义界面控件设置
        '''
        self.frame = QFrame(self)  # 初始化 Frame对象
        self.verticalLayout = QVBoxLayout(self.frame)  # 设置横向布局
        self.verticalLayout

        self.login_id = QLineEdit()  # 定义用户名输入框
        self.login_id.setPlaceholderText("请输入登录账号")  # 设置默认显示的提示语
        self.verticalLayout.addWidget(self.login_id)  # 将该登录账户设置添加到页面控件

        self.passwd = QLineEdit()  # 定义密码输入框
        self.passwd.setPlaceholderText("请输入登录密码")  # 设置默认显示的提示语
        self.verticalLayout.addWidget(self.passwd)  # 将该登录密码设置添加到页面控件

        self.button_enter = QPushButton()  # 定义登录按钮
        self.button_enter.setText("登录")  # 按钮显示值为登录
        self.verticalLayout.addWidget(self.button_enter)  # 将按钮添加到页面控件

        self.button_quit = QPushButton()  # 定义返回按钮
        self.button_quit.setText("返回")  # 按钮显示值为返回
        self.verticalLayout.addWidget(self.button_quit)  # 将按钮添加到页面控件

        # 绑定按钮事件
        self.button_enter.clicked.connect(self.button_enter_verify)
        self.button_quit.clicked.connect(
            QCoreApplication.instance().quit)  # 返回按钮绑定到退出

    def button_enter_verify(self):
        # 校验账号是否正确
        if self.login_id.text() != "admin":
            print("test1")
            return
        # 校验密码是否正确
        if self.passwd.text() != "admin@1234":
            print("test2")
            return
        # 验证通过，设置QDialog对象状态为允许
        self.accept()

最后通过mian入口函数启动应用。

if __name__ == "__main__":
    # 创建应用
    window_application = QApplication(sys.argv)
    # 设置登录窗口
    login_ui = LoginDialog()
    # 校验是否验证通过
    if login_ui.exec_() == QDialog.Accepted:
        # 初始化主功能窗口
        main_window = MainWindow()
        # 展示窗口
        main_window.show()
        # 设置应用退出
        sys.exit(window_application.exec_())

Python-OOP 快速入门

【往期精彩】

● 办公自动化：几行代码将PDF文档转换为WORD文档（代码实战）！

● 办公自动化：轻松提取PDF页面数据，并生成Excel文件（代码实战）！

● sched 模块中巨好用的轻量级定时任务神器scheduler！

● 不用再使用命令行打包成exe，有人写出了UI应用，可视化UI界面对python程序进行打包的方法！

● 发现一个秘密：既python3.6之后字典竟然变成了有序集合，我再次验证了一下！

● 这么多的内置函数能记住吗？对python的68个内置函数分类总结！

● 当大厂码农，遇到多年未见的公务员老同学，故事的结尾炸了...

● 必须要会的文件操作对象File，python文件读写操作利器！

● 你不知道的CS模式的进程管理工具，状态监测、项目启停一目了然！

● 如何将一个python应用以docker镜像的方式来运行？

● python-celery专注于实现分布式异步任务处理、任务调度的插件！

● python远程服务操作工具：fabric，远程命令、本地命令、服务器操作利器！

● python超赞插件you-get，执行一行命令即可下载、命令行下载工具推荐！

● 办公自动化：Python-win32com自动将word文档转换成pdf格式！

Original: https://www.cnblogs.com/lwsbc/p/15525984.html
Author: Python集中营
Title: 如何使用PyQt5一步步实现用户登录GUI界面、登录后跳转？

Title: 女朋友让我深夜十二点催她睡觉，我有Python我就不干

事情是这样的：今天晚上，女朋友让我十二点催她睡觉。
Python-OOP 快速入门
不过，可是我实在太困了，熬不下去...... 是吧？女朋友哪有睡觉重要？

但，女朋友的命令，我是不敢违抗的......

Python-OOP 快速入门
但是睡觉也不能缺！

这时候我们该怎么办呢？是时候让Python登场了！

Python登场

这次我们来做一个自动发送微信的程序，在深夜十二点的时候给女朋友发去消息，也算是尽了一个男朋友的义务了。

安装和导入

我们需要两个模块： apscheduler， pyautogui

快捷键 Windows+r 打开运行控制框，输入 cmd，进入命令行，输入：

pip install apscheduler
pip install pyautogui

导入：

import pyautogui
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler # 阻塞当前进程的调度器
# blocking类型调度器会阻塞当前进程，若你想要后台运行的调度器，可以使用以下代码：
# from apscheduler.schedulers.background import BackgroundScheduler

pyautogui

首先我们来实现自动发送消息

pyautogui 是一个非常强大的库，可以操作鼠标和键盘。我们将用它来完成自动操作电脑。

先来做一些基本设置：

pyautogui.PAUSE = 1 # 设置每一步操作的间隔（秒），可防止操作太快

然后我们登录微信，最小化。

接下来我们把鼠标放到微信的任务栏图标上，运行以下语句，获取此时光标的坐标，返回一个Point对象：

print(pyautogui.position()) # 打印坐标，Point(x=148, y=879)
icon_position = pyautogui.position() # Point(x=148, y=879)

打开微信，选择女朋友的回话窗口，将鼠标放在输入框上，同样获取光标坐标，为了将焦点锁定到输入框以方便待会的输入。
Python-OOP 快速入门

print(pyautogui.position()) # 打印坐标，Point(x=174, y=751)
entry_position = pyautogui.position() # Point(x=174, y=751)

接下来，控制程序依次点击这两个点：

pyautogui.click(icon_position) # 默认左键单击
# pyautogui.click(148, 879)
pyautogui.click(entry_position)
# pyautogui.click(174, 751)

打开微信并锁定焦点后，我们开始输入文本。

输入文本可以有两种方式：

pyautogui.typewrite(['o', 'n', 'e', 'enter']) 在方法中传入一个列表，里面每一元素都是单个字母或特殊按键
pyautogui.typewrite('You can type multiple letters in this way') 传入字符串，但不能同时打印字母和特殊按键。

这两种方式都不能直接输入中文，所以只能依靠你的输入法来输入中文了。

pyautogui.typewrite([*list('zhengzai '), *list('jinxing '), 'shift', *list('pyautogui'), 'shift', *list('shiyan '), 'enter'], 0.1) # 第一个参数是输入文本，第二个是输入每个字符的间隔时间

为了使我们的操作更加人模狗样像人的操作，我么来加上移动鼠标的代码：

pyautogui.moveTo(icon_position, duration=2) # duration为执行时长，可选
pyautogui.click(icon_position)
pyautogui.moveTo(entry_position, duration=2)
pyautogui.click(entry_position)
pyautogui.typewrite([*list('zhengzai '), *list('jinxing '), 'shift', *list('pyautogui'), 'shift', *list('shiyan '), 'enter'], 0.1) # 第二个参数为按下每一个字母的间隔，可选

看看效果：
Python-OOP 快速入门
当然，若是你要输入的内容实在很多，又嫌麻烦，可以通过复制粘贴来实现：

import pyperclip

pyperclip.copy('正在进行发中文试验，看到请忽略，更不要骂傻逼') # 复制
pyautogui.hotkey('ctrl', 'v') # 按下组合键的方法，ctrl+v粘贴
pyautogui.press('enter') # 按下按键

Python-OOP 快速入门
这样，我们便完成了自动发送微信消息的功能了。

apscheduler

APScheduler 是一个Python库，可实现延迟调度要执行Python代码的功能，可以只执行一次，也可以定期执行。可以随时添加新任务或删除旧任务。能够十分方便地进行定时任务。

scheduler = BlockingScheduler() # 实例化一个调度器
scheduler.add_job(main, 'date', run_date=datetime(2021, 8, 18, 24, 00, 00)) # 添加任务
scheduler.start()

add_job 方法在这里传了 3 个参数，第一个为到时间后要执行的函数，第二个为触发器的类型。这里选用的是 date 触发器，特定的时间点触发，作业任务只会执行一次。第三个参数 run_date 就是执行的时间。在这前我已经把自动发送消息的代码封装为了 main 函数，只需到时后调用即可。

完整代码

import pyautogui
import pyperclip
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler

def main():
    pyautogui.PAUSE = 0

    icon_position = pyautogui.Point(x=148, y=879) # 任务栏图标位置
    entry_position = pyautogui.Point(x=174, y=751) # 输入框位置

    pyautogui.moveTo(icon_position, duration=1) # duration为执行时长，可选
    pyautogui.click(icon_position)
    pyautogui.moveTo(entry_position, duration=0.7)
    pyautogui.click(entry_position)
    pyperclip.copy('快去睡觉')
    pyautogui.hotkey('ctrl', 'v')
    pyautogui.press('enter')
    pyperclip.copy('笨猪')
    pyautogui.hotkey('ctrl', 'v')
    pyautogui.press('enter')

scheduler = BlockingScheduler() # 实例化
scheduler.add_job(main, 'date', run_date=datetime(2021, 8, 18, 24, 00, 00)) # 添加任务
scheduler.start()

完成啦！现在可以去睡觉了。

结果

第二天早上起床，我被我妈妈骂了一顿，问我为什么午夜12点的时候电脑还亮着，而且还在自己发微信！

不过，好在女朋友没丢，我成功完成了女朋友的任务！
Python-OOP 快速入门

-- the End --

好啦，这篇文章就到这里了。以上就是我分享的全部内容，感谢阅读！

打个小广告：作者CSDN博客主页：
https://blog.csdn.net/weixin_52132159

Original: https://www.cnblogs.com/hi-zzh/p/15885766.html
Author: 你豪哥哥
Title: 女朋友让我深夜十二点催她睡觉，我有Python我就不干

Title: python中的定义类方法有三种形式

普通方法
类方法(@classmethod)
静态方法(@staticmethod)

创建普通的方法的方式有两种(class A() & class B()).

class A():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def get_name(self):
        print('my name is', self.name)

    def get_age(self):
        print(f'i am {self.age} years old')

class B():
    def get_name(self, name):
        print('my name is', name)

    def get_age(self, age):
        print(f'i am {age} years old')

if __name__ == '__main__':
    a = A('tom',19)
    a.get_name()  # my name is tom
    a.get_age() # i am 19 years old

    b = B()
    b.get_name('tom')  # my name is tom
    b.get_age(19) # i am 19 years old

每次调用方法之前需要对类进行实例化

@classmethod不需要self来表示自身了，而是用了cls来代替。

此时不用再进行实例化了。直接类名.函数名进行调用。

#Python学习交流群：725638078
class C():
    @classmethod
    def get_name(cls, name):
        print(cls)  #
        print('my name is %s' % name)

    @classmethod
    def get_age(cls, age):
        print(f'i am %s years old' % age)

if __name__ == '__main__':
    C.get_name('tom')  # my name is tom
    C.get_age(19) # i am 19 years old

@staticmethod也是通过类名.函数名的方式进行调用

静态方法不需要表示自身对象的self或者cls作为参数，跟直接使用函数是一样的。

class D():
    @staticmethod
    def get_name(name):
        print('my name is %s' % name)

    @staticmethod
    def get_age(age):
        print(f'i am %s years old' % age)

if __name__ == '__main__':
    D.get_name('tom')  # my name is tom
    D.get_age(19) # i am 19 years old

@staticmethod 与 @classmethod在Python中称为装饰器，

用来修饰函数，相当于添加一个额外的功能，比如不再像普通函数那样进行实例化。

通过使用装饰器可以让代码更加整洁，易读。用了修饰器之后，也可以进行实例化之后再调用，但是就显得多此一举了。

Original: https://www.cnblogs.com/python1111/p/15593643.html
Author: 小小程序员ol
Title: python中的定义类方法有三种形式

2024 年 4 月
一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30