isinstance()

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()

isinstance() 与 type() 区别：

  • type() 不会认为子类是一种父类类型，不考虑继承关系。

  • isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

 用法：

isinstance(a, str)  ：变量a是否为str类型，是返回true，否返回false

raise

raise 抛出一个指定异常

  • raise：单独一个 raise。该语句引发当前上下文中捕获的异常（比如在 except 块中），或默认引发 RuntimeError 异常。
  • raise 异常类名称：raise 后带一个异常类名称，表示引发执行类型的异常。
  • raise 异常类名称(描述信息)：在引发指定类型的异常的同时，附带异常的描述信息。

用法：

常见异常类汇总：https://blog.csdn.net/frank_good/article/details/86299632

预期类型

在定义函数时，参数后面跟 ：+  type 构成的语法，例如:

class A:
    def demo(self, a: str):
        print(cs)

a 的预期类型就是字符型数据，若强行传入其他类型也不会报错，但会有警告！

预期类型也可以有多种，比如  def test(a: (str, list, dict)):

->

-> 符号在底层代码中经常出现，经常出现在python函数定义的函数名后面，其目的是为函数添加元数据, 描述函数的返回值类型，从而方便开发人员使用，例如：

def demo(self, cs: int)->int:
    return cs

Iterable

可迭代类型，通常与isinstance一起来判断一个对象是否可迭代，方法是通过collections.abc模块的Iterable类型判断：

>>> from collections.abc import Iterable
>>> isinstance('abc', Iterable)     # str 是否可迭代
True
>>> isinstance([1,2,3], Iterable)   # list 是否可迭代
True
>>> isinstance(123, Iterable)       # 整数是否可迭代
False

enumerate()

enumerate函数可以把一个可迭代对象（如list）变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

动态绑定属性和方法

在类外部给类绑定属性

class A:
    def demo(self, cs: int)->int:
        return cs
a1 = 12

a = A()
a.a1 = a1  # 绑定属性

利用 from types import MethodType 模块  给一个实例绑定方法

from types import MethodType
class A:
    def demo(self, cs: int)->int:
        return cs
def test(self):
    print("test")
a = A()
a.test = MethodType(test, a)
a.test()

但是只给一个实例绑定方法，其他实例无法使用这个方法，其他实例若要使用，则需要给类绑定方法

class A:
    def demo(self, cs: int)->int:
        return cs
def test(self):
    print("test")

A.test = test
a = A()
a.test()

__slots__

为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性：

class A:
    __slots__ = ("name", "age")
    def demo(self, cs: int)->int:
        return cs
a = A()
a.name = "linyq"
a.age = 19
# a.aaa = 12    # AttributeError报错

需要注意：__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的

序列化

简单来讲序列化就是将内存中的数据保存到磁盘中，常见库 pickle

pickle.dumps()

import pickle
class A:
    __slots__ = ("name", "age")
    def demo(self, cs: int)->int:
        return cs

if __name__ == '__main__':
    a = pickle.dumps(A)    # A 可以为list，dict等各种对象
    print(a)

>>>b'\x80\x04\x95\x12\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x01A\x94\x93\x94.'

将python对象转换成了bytes，之后可以将这个bytes写入文件或者通过网络进行传输！

pickle.dump() 直接将对象写入一个file object

import pickle
class A:
    __slots__ = ("name", "age")
    def demo(self, cs: int)->int:
        return cs

if __name__ == '__main__':
    f = open("class.txt", "wb")
    pickle.dump(A, f)
    f.close()

反序列化，简而言之就是反向操作，需要用到 pickle.loads()和 pickle.load()方法

进程和线程

线程是最小的执行单元，而进程由至少一个线程组成。如何调度进程和线程，完全由操作系统决定，程序自己不能决定什么时候执行，执行多长时间。

多进程和多线程的程序涉及到同步、数据共享的问题，编写起来更复杂。

理解参考：https://www.liaoxuefeng.com/wiki/1016959663602400/1017627212385376