文章目录

错误异常处理与面向对象
- [1. 错误和异常](#1. 错误和异常)
- - [1.1 基本概念](#1.1 基本概念)
  - - [1.1.1 Python 异常](#1.1.1 Python 异常)
  - [1.2 检测（捕获）异常](#1.2 检测（捕获）异常)
  - - [1.2.1 try except 语句](#1.2.1 try except 语句)
    - [1.2.2 捕获多种异常](#1.2.2 捕获多种异常)
    - [1.2.3 捕获所有异常](#1.2.3 捕获所有异常)
  - [1.3 处理异常](#1.3 处理异常)
  - [1.4 特殊场景](#1.4 特殊场景)
  - - [1.4.1 with 语句](#1.4.1 with 语句)
  - [1.5 脚本完善](#1.5 脚本完善)
- [2. 内网主机存活检测程序](#2. 内网主机存活检测程序)
- - [2.1 scapy 模块](#2.1 scapy 模块)
  - - [2.1.1 主要功能](#2.1.1 主要功能)
    - [2.1.2 scapy 安装](#2.1.2 scapy 安装)
    - [2.1.3 进入scapy 模块](#2.1.3 进入scapy 模块)
    - [2.1.4 简单使用](#2.1.4 简单使用)
  - [2.2 主机存活检测程序](#2.2 主机存活检测程序)
- [3. 面向对象编程](#3. 面向对象编程)
- - [3.1 类](#3.1 类)
  - - [3.1.1 创建类](#3.1.1 创建类)
    - [3.1.2 \init 方法](#3.1.2 _init_ 方法)
  - [3.2 方法](#3.2 方法)
  - - [3.2.1 绑定方法](#3.2.1 绑定方法)
  - [3.3 继承](#3.3 继承)
  - - [3.3.1 子类继承](#3.3.1 子类继承)
    - [3.3.2 方法重写](#3.3.2 方法重写)
    - [3.3.3 多重继承](#3.3.3 多重继承)
    - [3.3.4 静态方法和动态方法的区别](#3.3.4 静态方法和动态方法的区别)
  - [3.4 魔法函数](#3.4 魔法函数)
  - - [3.4.1 类和实例的内建函数](#3.4.1 类和实例的内建函数)
    - [3.4.2 常用的魔法函数](#3.4.2 常用的魔法函数)
  - [3.5 私有化](#3.5 私有化)

错误异常处理与面向对象

1. 错误和异常

如果遇到了错误（异常），如何去处理？

1.1 基本概念

1.1.1 Python 异常

当程序运行时，因为遇到未知的错误而导致中止运行，便会出现Traceback 消息，打印异常。异常即是一个事件 ，该事件会在程序执行过程中发生，影响程序的正常执行。一般情况下，在Python 无法正常处理程序时就会发生一个异常。异常是Python 对象，表示一个错误。当Python 脚本发生异常时我们需要响应处理它，否则程序会终止执行。

异常	描述
SyntaxError	语法错误
NameError	未声明/初始化对象
IndexError	序列中没有此索引
KeyboardInterrupt	用户中断执行（Ctrl+C）
EOFError	没有内建输入，到达EOF 标记（Ctrl+D）不适用windows 系统
IOError	输入/输出操作失败
ValueError	当操作或函数接收到具有正确类型但值不适合的参数，并且情况不能用更精确的异常，例如 IndexError来描述时将被引发。
TypeError	字符串与整数相加时触发。

1.2 检测（捕获）异常

如果一个语句发生了错误或异常，跳过该语句的执行，执行另外的语句。

1.2.1 try except 语句

尝试执行try 语句，如果遇到异常则执行except 语句。两个语句执行执行一个。

语法规则

python 复制代码

try:
    pass                # 监控这里的异常
except Exception[, reason]:
    pass                # 异常处理代码

示例：

python 复制代码

# 01 - 异常初探.py

try:
    username = input("Please input your name: ")
    print(f"Welcome, {username}")

except:
    print("\nSomething Error!")

1.2.2 捕获多种异常

算命脚本：输入年龄，预测明年的年龄。

可以把多个except 语句连接在一起，处理一个try 块中可能发生的多种异常。

python 复制代码

# 02 - 捕获多种异常.py

banner = '''
算命脚本
1. 预测年龄
2. 预测财运
3. 预测姻缘
'''

print(banner)

choice = input("Please input the number: ")
choice = int(choice)

if choice != 1:
    print("好好学习...")
    exit()

try:
    age = input("Please input your age: ")
    print(f"The next year your name: {int(age) + 1}")

except ValueError:
    print("Please input a number!")

except KeyboardInterrupt:
    print("\nCtrl + C")

except:
    print("\nSomething Error!")

1.2.3 捕获所有异常

如果出现的异常没有出现在指定要捕获的异常列表中，程序仍然会中断。可以使用在异常继承的树结构中，BaseException 是在最顶层的，所以使用它可以捕获任意类型的异常。

python 复制代码

except BaseException:           # 捕获所有异常，相当于except
    print("\nSomething Error!")

Pyhton 异常树

sh 复制代码

BaseException                                               所有异常的基类
     |
     |
     +-- SystemExit                                         解释器请求退出
     |
     |
     +-- KeyboardInterrupt                                  用户中断执行(通常是输入^C)
     |
     |
     +-- GeneratorExit                                      生成器调用close();方法时触发的
     |
     |
     +-- Exception                          常规错误的基类，异常都是从基类Exception继承的。
          |
          +-- StopIteration                                 迭代器没有更多的值
          |
          +-- StandardError                                 所有的内建标准异常的基类
          |    +-- BufferError                              缓冲区操作不能执行
          |    +-- ArithmeticError                          所有数值计算错误的基类
          |    |    +-- FloatingPointError                  浮点计算错误
          |    |    +-- OverflowError                       数值运算超出最大限制
          |    |    +-- ZeroDivisionError                   除(或取模)零 (所有数据类型)
          |    +-- AssertionError                           断言语句失败
          |    +-- AttributeError                           访问未知对象属性
          |    +-- EnvironmentError                         操作系统错误的基类
          |    |    +-- IOError                             输入输出错误
          |    |    +-- OSError                             操作系统错误
          |    |         +-- WindowsError (Windows)         系统调用失败
          |    |         +-- VMSError (VMS)                 系统调用失败
          |    +-- EOFError                                 没有内建输入,到达EOF 标记
          |    +-- ImportError                              导入模块/对象失败
          |    +-- LookupError              无效数据查询的基类&#xff0c;键、值不存在引发的异常
          |    |    +-- IndexError                          索引超出范围
          |    |    +-- KeyError                            字典关键字不存在
          |    +-- MemoryError              内存溢出错误(对于Python 解释器不是致命的)
          |    +-- NameError                未声明/初始化对象 (没有属性)
          |    |    +-- UnboundLocalError                   访问未初始化的本地变量
          |    +-- ReferenceError           弱引用(Weak reference)试图访问已经垃圾回收了的对象
          |    +-- RuntimeError                             一般的运行时错误
          |    |    +-- NotImplementedError                 尚未实现的方法
          |    +-- SyntaxError                              语法错误
          |    |    +-- IndentationError                    缩进错误
          |    |         +-- TabError                       Tab 和空格混用
          |    +-- SystemError                              一般的解释器系统错误
          |    +-- TypeError                                对类型无效的操作
          |    +-- ValueError                               传入无效的参数
          |         +-- UnicodeError                        Unicode 相关的错误
          |              +-- UnicodeDecodeError             Unicode 解码时的错误
          |              +-- UnicodeEncodeError             Unicode 编码时错误
          |              +-- UnicodeTranslateError          Unicode 转换时错误
          |
          +-- Warning                                       警告的基类
               +-- DeprecationWarning                       关于被弃用的特征的警告
               +-- PendingDeprecationWarning                关于特性将会被废弃的警告
               +-- RuntimeWarning              可疑的运行时行为(runtime behavior)的警告
               +-- SyntaxWarning                            可疑的语法的警告
               +-- UserWarning                              用户代码生成的警告
               +-- FutureWarning                            关于构造将来语义会有改变的警告
               +-- ImportWarning               关于模块进口可能出现错误的警告的基类。
               +-- UnicodeWarning                           有关Unicode警告的基类。
               +-- BytesWarning                             有关字节警告相关的基类。

1.3 处理异常

python 复制代码

try:                                                # 尝试执行某个语句
    num = int(input("The number:"))
except BaseException:                               # 如果遇到异常，执行的语句
    print("something error!")
else:                                               # 如果没有遇到异常，执行的语句
    print(num)
finally:                                            # 不管是否遇到异常，都要执行的语句。
    print("This is finally")

else 子句：在try 范围中没有异常被检测到时，执行else 子句。在else 范围中的任何代码运行前，try 范围中的所有代码必须完全成功。
finally 子句：finally 子句是无论异常是否发生，是否捕捉都会执行的一段代码。比如获取用户的输入，写入文件，但是如果在获取数据过程中，发生了异常，就会导致整个脚本结束执行，文件也无法关闭了。为了解决这个问题，可以采用异常处理中的finally 子句，也就是说，无论语句是否正常执行，都需要关闭。

python 复制代码

# 03 - 处理异常.py

banner = '''
算命脚本
1. 预测年龄
2. 预测财运
3. 预测姻缘
'''

print(banner)

choice = input("Please input the number: ")
choice = int(choice)

if choice != 1:
    print("好好学习...")
    exit()

try:
    age = input("Please input your age: ")
    age = int(age) 

except ValueError:
    print("Please input a number!")

except KeyboardInterrupt:
    print("\nCtrl + C")

except:
    print("\nSomething Error!")

else:
    print(f"The next year your name: {age + 1}")

finally:
    print("脚本执行结束，祝你好运！")

1.4 特殊场景

1.4.1 with 语句

with 语句是用来简化代码的。比如在将打开文件的操作放在with 语句中，代码块结束后，文件将自动关闭。用来简化文件操作的打开和关闭，其中closed 属性是判断文件是否被关闭的

python 复制代码

>>> with open('foo.py') as f:

1.5 脚本完善

python 复制代码

from pyfiglet import Figlet
from termcolor import colored, cprint

f = Figlet(font='slant')
print('*' * 75)
print('-' * 75) 
print(f.renderText('WuHu Exception'))
banner = '''
算命脚本
1. 预测年龄
2. 预测财运
3. 预测姻缘
4. 退出脚本
'''
print(banner)
print('-' * 75)
print('*' * 75)

choice = input("请输入你的选项: ")
choice = int(choice)

if choice == 1:
    try:            # 尝试执行某个语句
        age = int(input("Please input your age: "))

    except ValueError:          # 遇到异常执行的语句
        cprint("\nPlease input a number!", "white", "on_red")

    except KeyboardInterrupt:   # 遇到异常执行的语句
        cprint("\nCtrl + C", "white", "on_red")

    except:         # 遇到异常执行的语句
        cprint("\nSomething Error!", "white", "on_red")

    else:           # 如果没有遇到异常，执行的语句   
        cprint(f"\nThe next year your age: {int(age) + 1}", "white", "on_green")

    finally:        # 无论是否遇到异常，都会执行的语句
        cprint("\n脚本执行完毕", "white", "on_green")
elif choice == 4:
    print("欢迎下次光临~")
    exit()
else:
    print("好好学习！")

2. 内网主机存活检测程序

2.1 scapy 模块

与scrapy 有非常大的区别。

scapy 是一个Python 的第三方模块，被称为"网络神器"。scapy 模块能够发送、捕获、分析和铸造网络数据包。

2.1.1 主要功能

2.1.2 scapy 安装

Windows 下安装scapy

sh 复制代码

python -m pip install scapy

Kali 中自带scapy 环境。

2.1.3 进入scapy 模块

python 复制代码

┌──(ajest zh-CN)-[~]
└─$ sudo scapy                     

                     aSPY//YASa       
             apyyyyCY//////////YCa       |
            sY//////YSpcs  scpCY//Pp     | Welcome to Scapy
 ayp ayyyyyyySCP//Pp           syY//C    | Version 2.4.5
 AYAsAYYYYYYYY///Ps              cY//S   |
         pCCCCY//p          cSSps y//Y   | https://github.com/secdev/scapy
         SPPPP///a          pP///AC//Y   |
              A//A            cyP////C   | Have fun!
              p///Ac            sC///a   |
              P////YCpc           A//A   | Craft packets before they craft
       scccccp///pSP///p          p//Y   | you.
      sY/////////y  caa           S//P   |                      -- Socrate
       cayCyayP//Ya              pY/Ya   |
        sY/PsY////YCc          aC//Yp 
         sc  sccaCY//PCypaapyCP//YSs  
                  spCPY//////YPSps    
                       ccaacs         
                                       using IPython 7.22.0
>>>

2.1.4 简单使用

构造数据包

python 复制代码

>>> pkt = IP()/TCP()
>>> pkt.show()
###[ IP ]### 
  version   = 4
  ihl       = None
  tos       = 0x0
  len       = None
  id        = 1
  flags     = 
  frag      = 0
  ttl       = 64
  proto     = tcp
  chksum    = None
  src       = 127.0.0.1
  dst       = 127.0.0.1
  \options   \
###[ TCP ]### 
     sport     = ftp_data
     dport     = http
     seq       = 0
     ack       = 0
     dataofs   = None
     reserved  = 0
     flags     = S
     window    = 8192
     chksum    = None
     urgptr    = 0
     options   = ''

python 复制代码

>>> pkt = IP(src = "192.168.1.11", dst = "192.168.1.1")/TCP()
>>> pkt.show()
###[ IP ]### 
  version   = 4
  ihl       = None
  tos       = 0x0
  len       = None
  id        = 1
  flags     = 
  frag      = 0
  ttl       = 64
  proto     = tcp
  chksum    = None
  src       = 192.168.1.11
  dst       = 192.168.1.1
  \options   \
###[ TCP ]### 
     sport     = ftp_data
     dport     = http
     seq       = 0
     ack       = 0
     dataofs   = None
     reserved  = 0
     flags     = S
     window    = 8192
     chksum    = None
     urgptr    = 0
     options   = ''

>>>

发送数据包

发送数据包的函数	说明
sr(pkt)	发送数据包，接收所有返回包
sr1(pkt)	发送数据包，接收一个返回包
send(pkt)	发送数据包，不等待返回包
srp(pkt)	发送2 层数据包，等待回应
sendp(pkt)	发送2 层数据包，不等待返回包

python 复制代码

>>> res = sr1(pkt)
Begin emission:
Finished sending 1 packets.
.*
Received 2 packets, got 1 answers, remaining 0 packets
>>>

解析：

Received 2 packets表示接收了2个包
got 1 answers表示响应了1个包

查看返回包

python 复制代码

>>> res.show()
###[ IP ]### 
  version   = 4
  ihl       = 5
  tos       = 0x0
  len       = 44
  id        = 13990
  flags     = 
  frag      = 0
  ttl       = 255
  proto     = tcp
  chksum    = 0x46a4
  src       = 10.9.21.1
  dst       = 10.9.21.111
  \options   \
###[ TCP ]### 
     sport     = http
     dport     = ftp_data
     seq       = 1510518667
     ack       = 1
     dataofs   = 6
     reserved  = 0
     flags     = SA
     window    = 65535
     chksum    = 0x4f9c
     urgptr    = 0
     options   = [('MSS', 1460)]
###[ Padding ]### 
        load      = '\x00\x00'

>>>

2.2 主机存活检测程序

python 复制代码

# 04 - 内网主机存活检测程序.py

from scapy.all import *
from scapy.layers.inet import *
from termcolor import colored, cprint

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)	



network = "192.168.188."

for host in range(1, 20):
    ip = f"{network}{host}"
    # print(f"[-] Trying: {ip}")
	
    # 创建数据包
    pkt = IP(src = "192.168.188.185", dst = ip)/ICMP()
    # 发送数据包
    res = sr1(pkt, timeout = 0.2, verbose = False)
    
    if res and res.type == 0:
        print(colored(f"\n{ip} is ALIVE!","green"))
    else:
        print(f"\n{ip} is NOT ALIVE!",end= "")

解析：

res = sr1(pkt, timeout = 0.2, verbose = False)：sr1() 函数将发送数据包并等待响应，然后返回第一个收到的响应数据包。如果在指定的超时时间内没有收到响应，则返回 None。并且禁用了详细输出。
- timeout = 0.2：设置的超时时间为0.2
- verbose = False：禁用了详细输出
logging：屏蔽信息模块。
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)：在scapy运行期间，只有ERROR才显示输出其他都不输出。

3. 面向对象编程

3.1 类

类是一类事物的统称，比如学生。对象就是类的实例化。

类有属性（变量），比如学生的姓名、性别、年龄、成绩等，也就是编程里面的变量。

类有方法（函数），比如学生的上课、下课等，也就是编程里面的函数。

3.1.1 创建类

类是一种数据结构，我们可以用它来定义对象，对象把数据值和行为特性融合在一起。

Python 使用 class 关键字来创建类：通常类名的第一个字母大写，推荐使用驼峰式命名法，单词首字母均大写。类有属性（变量）和方法（动作，函数）组成。

python 复制代码

class ClassName(bases):
    'class documentation string'    #'类文档字符串'
    class_suite                     # 类体

3.1.2 init 方法

__init__() 是类的实例（对象）创建后第一个被调用的方法（自动被调用） ，通常被用来进行对象中属性（变量）的初始化。设置实例的属性可以在实例创建后任意时间进行，但是通常情况下优先在__init__() 方法中实现。

定义类型
实例化对象（创建一个对象）
初始化对象（第一次给对象属性赋值）

python 复制代码

# 05 - __init__.py

class Stu():
    def __init__(self, name, sex, age, score):
        self.name = name
        self.sex = sex
        self.age = age
        self.score = score

stu1 = Stu(name = "AJEST", sex = True, age = 24, score = 59.9)

print(f"{stu1.name} 的成绩是{stu1.score}")

解析：

在 Python 类中，self 是一个约定俗成的名称也是一个特殊的参数，它表示类的实例（对象）本身。可以使用其他名称代替 self，但强烈建议仍然使用 self，这是因为 self 在Python社区中被广泛接受并被视为最佳实践。在类的方法中，使用 self 参数可以访问该对象的属性和方法。
在 __init__() 方法中，self 参数指向正在创建的对象。通过使用 self 参数，我们可以将传递给 __init__() 方法的参数的值分配给对象的属性，以便在整个类的其他方法中使用。
self.name = name 表示将传递给构造函数的 name 参数的值赋给对象的 name 属性。类似地，self.sex = sex、self.age = age 和 self.score = score 将传递的参数值分别赋给对象的 sex、age 和 score 属性。

3.2 方法

3.2.1 绑定方法

方法仅仅是类内部定义的函数，方法只有在其所属的类拥有实例时，才能被调用；任何一个方法定义中的第一个参数都是变量self，它表示调用此方法的实例对象就是自己。

类中的方法，也就是类中定义的函数，这个函数第一个参数永远是self，表示自己。

python 复制代码

# 06 - 绑定方法.py

import time

class Stu():
    def __init__(self, name, sex, age, score):
        self.name = name
        self.sex = sex
        self.age = age
        self.score = score

    def getSocre(self):
        print(f"{self.name} 的成绩是{self.score}")

    def goodGoodStudy(self):
        print("好好学习中...")
        time.sleep(10)
        self.score += 0.1


stu1 = Stu(name = "AJEST", sex = True, age = 24, score = 59.9)
stu2 = Stu(name = "HMM", sex = True, age = 24, score = 89.9)

# 调用方法
stu2.getSocre()
stu2.goodGoodStudy()
stu2.getSocre()

解析：

在 getSocre() 方法中，我们使用 self.name 来访问对象的 name 属性。这里的 self 指的就是调用 getSocre() 方法的对象本身。

3.3 继承

3.3.1 子类继承

继承描述了基类（祖先）的属性如何遗传给派生类（子孙），子类可以继承它的基类的任何属性，不管是数据属性还是方法。

python 复制代码

# 34 - 子类继承.py

import time

class Kid():
    def __init__(self, name = "", sex = "", age = ""):
        self.name = name
        self.age = age
        self.sex = sex

    def play(self):
        print("玩游戏中...")

class Stu(Kid):
    def __init__(self,name = "", sex = "", age = "", score = ""):
        Kid.__init__(self, name, sex, age)
        self.score = score

    def get_score(self):
        print(f"{self.name} 的成绩是{self.score}")

    def good_good_study(self):
        print("好好学习中...")
        time.sleep(10)
        self.score += 0.1

stu1 = Stu(name = "AJEST", sex = True, age = 24, score = 59.9)
stu2 = Stu(name = "LL", sex = True, age = 25, score = 49.9)
stu3 = Stu(name = "HMM", sex = True, age = 23, score = 99.9)
stu4 = Stu(name = "LH", sex = True, age = 24, score = 79.9)

stu1.play()

3.3.2 方法重写

如果子类中有和父类同名的方法，父类方法将被覆盖；如果需要访问父类的方法，则要调用一个未绑定的父类方法，明确给出子类的实例。

python 复制代码

# 08 - 方法重写.py

import time

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

    def play(self):
        print("玩游戏中...")

class Stu(Kid):
    def __init__(self, name, sex, age, score):
        Kid.__init__(self, name, sex, age)
        self.score = score

    def getSocre(self):
        print(f"{self.name} 的成绩是{self.score}")

    def goodGoodStudy(self):
        print("好好学习中...")
        time.sleep(10)
        self.score += 0.1

    def play(self):
        print("玩王者荣耀中...")
        time.sleep(2)
        self.score -= 10

stu1 = Stu(name = "AJEST", sex = True, age = 24, score = 59.9)
stu2 = Stu(name = "HMM", sex = True, age = 24, score = 89.9)

stu2.getSocre()
stu2.play()
stu2.getSocre()
stu2.goodGoodStudy()
stu2.goodGoodStudy()
stu2.getSocre()
stu2.play()
stu2.getSocre()

说明：

Kid.__init__(self, name, sex, age) 是在 Stu 类的构造函数中调用了 Kid 类的构造函数来初始化从 Kid 类继承的属性。
在Python中，当一个类继承自另一个类时，子类可以通过调用父类的构造函数来初始化继承的属性。在这个例子中，Stu 类继承自 Kid 类，因此在 Stu 类的构造函数中，我们需要先调用 Kid 类的构造函数来初始化继承的属性。

3.3.3 多重继承

需要注意的是，Python支持单继承和多继承。单继承指一个类只能继承自一个父类，而多继承指一个类可以同时继承自多个父类。在多继承的情况下，子类可以获得多个父类的属性和方法，但需要注意避免出现命名冲突和混淆的情况。

python 复制代码

# 09 - 多重继承.py

class A():
    def a():
        print("This is function A!")

class B():
    def b():
        print("This is function B!")

class C(A, B):
    pass

C.a()
C.b()

说明：

在Python中，pass 是一个空语句，不执行任何操作。当你在代码中遇到需要写一段代码但又暂时没有实现的情况时，可以使用 pass 来占位，使得代码结构完整而没有语法错误。

python 复制代码

# 定义食物类
class Food():
    def __init__(self,name,price):
        self.name = name
        self.price = price

# 定义蔬菜类
class Vegetable(Food):
    def __init__(self,name,price,place):
        Food.__init__(self,name,price)
        self.place = place

# 定义肥料类
class Manure():
    def __init__(self,flag):  
        self.flag = flag      

# 定义西红柿类
class Tomato(Vegetable,Manure):
    def __init__(self, name, price, place,colour,flag):
        Vegetable.__init__(self, name, price, place)
        Manure.__init__(self,flag)
        self.colour = colour
    def wuhu(self):
        print(f"{self.name}价格为{self.price},产地是{self.place},颜色是{self.colour}")
        print(f"添加肥料{self.flag}")


tomato = Tomato("西红柿🍅","23💴","北京","红色🔴","💩")
tomato.wuhu()

3.3.4 静态方法和动态方法的区别

静态方法和动态方法的区别：

静态方法 ：静态方法是属于类的方法，它与实例无关。它们不需要访问或修改类的实例属性，也没有self参数。静态方法可以被类本身直接调用，而不需要创建类的实例。静态方法通常用于执行与类关联但不依赖于实例的操作，或者在方法内部不需要访问实例属性的情况下。
动态方法 ：动态方法是属于实例的方法，它需要通过创建类的实例来调用。动态方法的第一个参数通常是self，它代表实例本身。通过这个参数，动态方法可以访问和修改实例的属性。动态方法定义在类的内部，可以通过实例访问，也可以通过类访问。

3.4 魔法函数

3.4.1 类和实例的内建函数

函数	作用
issubclass()	判断一个类是另一个类的子类或子孙类
isinstance()	判定一个对象是否是另一个给定类的实例
hasattr()	判断一个对象是否有一个特定的属性
getattr()	获得一个对象的属性值
setattr()	设置一个对象的属性
delattr()	删除一个对象的属性

3.4.2 常用的魔法函数

魔法函数是系统自带的，会在"恰当"的时候自动调用。

python 复制代码

# 10 - 魔术方法.py

class Test():
    def __init__(self):
        print("Function __init__ is called!")

    def __str__(self):
        return "Why print(self)?"

    def __call__(self):
        print("Why call me like Function?")

t = Test()

print(t)

t()

解析：

init：该函数会在创建对象的时候调用。
_str _：该函数用于返回对象的字符串表示，当尝试将对象转换为字符串时（例如通过 print() 函数或 str() 函数），Python 会调用该方法来获取对象的字符串表示。
_call _：当我们使用对象名后面加上一对小括号 () 来调用对象时，Python 会调用该方法。
_len _：长度方法，在使用 len() 函数时自动调用，返回对象的长度。
getitem：索引获取方法，在使用索引访问对象时自动调用，返回对应位置的值。
t()：使用对象名后面加上一对小括号 () 来调用对象。

3.5 私有化

Python 为类元素（属性和方法）的私有性提供初步的形式，由双下划线开始的属性在运行时被"混淆"，所以直接访问是不允许的。

通过给属性和方法名添加双下划线 __ 来将它们私有化。例如，__score 表示一个私有属性，还可以__method()表示一个私有方法。私有属性和方法只能在类定义中被引用，子类也无法访问。

python 复制代码

import time

class Stu():
    def __init__(self, name, sex, age, score):
        self.name = name
        self.sex = sex
        self.age = age
        # 定义私有属性
        self.__score = score

    def getSocre(self):
        print(f"{self.name} 的成绩是{self.__score}")

    def goodGoodStudy(self):
        print("好好学习中...")
        time.sleep(10)
        self.__score += 0.1
     
    # 定义私有方法
    def __wuhu(self):
        print("芜湖")

class R(Stu):
    def __init__(self,name,sex,age,score):
        Stu.__init__(self, name, sex, age,score)

    def play(self):
        print("玩🐍")
        print(f"{self.name}的成绩是{self.__score}")        
        
stu1 = Stu("wuhu",True,24,77)

stu1.getSocre()
stu1.goodGoodStudy()
stu1.getSocre()

r = R("haha",True,24,66)
# 调用私有方法
r.__wuhu()
# r.play()

如果Stu的子类访问的话Stu中的私有属性就会抛出一个访问未知对象属性（AttributeError）的异常。

Python灰帽编程——错误异常处理与面向对象

文章目录

错误异常处理与面向对象

1. 错误和异常

1.1 基本概念

1.1.1 Python 异常

1.2 检测（捕获）异常

1.2.1 try except 语句

1.2.2 捕获多种异常

1.2.3 捕获所有异常

1.3 处理异常

1.4 特殊场景

1.4.1 with 语句

1.5 脚本完善

2. 内网主机存活检测程序

2.1 scapy 模块

2.1.1 主要功能

2.1.2 scapy 安装

2.1.3 进入scapy 模块

2.1.4 简单使用

2.2 主机存活检测程序

3. 面向对象编程

3.1 类

3.1.1 创建类

3.1.2 init 方法

3.2 方法

3.2.1 绑定方法

3.3 继承

3.3.1 子类继承

3.3.2 方法重写

3.3.3 多重继承

3.3.4 静态方法和动态方法的区别

3.4 魔法函数

3.4.1 类和实例的内建函数

3.4.2 常用的魔法函数

3.5 私有化