python知识点总结02(不定时更新)

请用至少两种方式实现m与n值交换m=10,n=5

# 方式一
temp = 0
m = 10
n = 5
print(f'方式一交换前，m:{},n:{}')
temp = m
m = n
n = temp
print(f'方式一交换后，m:{},n:{}')

# 方式二
m = 10
n = 5
m, n = n, m
print(f'方式二交换前，m:{},n:{}')
print(f'方式二交换后，m:{},n:{}')

你所知道的能够实现单例模式的方式有哪些，尝试着手写几个

'''
单例模式：让所有类在实例化时，指向同一内存地址
实现单例模式的5种方式：
    1.通过关键字classmethod实现
    2.通过装饰器实现
    3.通过__new__实现
    4.通过导入模块实现
    5.通过元类实现
'''
# 通过关键字classmethod实现
class Singleton:
    def __init__(self, *args, **kwargs):
        pass

    @classmethod
    def instance(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = cls(*args, **kwargs)
        return cls._instance

# 通过装饰器实现
def singleton(cls):
    _instance = {}

    def inner(*args, **kwargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kwargs)
        return _instance[cls]
    return inner

# 通过__new__实现
class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super().__new__(cls)
        return cls._instance

# 通过导入模块实现
# a.py
class Singleton:
    def __init__(self):
        pass

    singleton_obj = Singleton()

# b.py
from a import singleton_obj
	print singleton_obj

# 通过元类实现
class SingletonMeta(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super().__call__(*args, **kwargs)

        return cls._instance

class Singleton(metaclass=SingletonMeta):
    def __init__(self):
        pass

数值进制之间的转换

# 二进制转换成十进制
v = '0b1111011'
print(int(v, 2))  # 第二个参数表示是什么进制的数字
# 十进制转换成二进制
v = 18
print(bin(v))  # bin() 将十进制转换成二进制

# 八进制转换成十进制
v = '0o11'
print(int(v, 8))  # 第二个参数表示是什么进制的数字
# 十进制转换成八进制
v = 30
print(oct(v))  # oct() 将十进制转换成二进制

# 十六进制转换成十进制
v = '0x12'
print(int(v, 16))  #第二个参数表示是什么进制的数字

# 十进制转换成十六进制
v = 87
print(hex(v))  # hex() 将十进制转换成十六进制

'''
总结：
1.其他进制转换成十进制，通过int来实现
	语法：int(其他进制数, 进制[数字表示])
2.十进制转其他进制的语法
  十进制转换成二进制：bin()
  十进制转换成八进制：oct()
  十进制转换成十六进制：hex()
'''

简述可迭代对象，迭代器对象，生成器对象及应用场景

# 参照https://www.cnblogs.com/xiaoyuanqujing/protected/articles/11640962.html
# 参照https://www.cnblogs.com/nickchen121/p/10778506.html
'''
可迭代对象：从语法来说，凡是有内置方法__iter__()的对象都是可迭代对象，比如说str(字符串)，list(列表)，tuple(元组)，dict(字典），set(集合)，file(打开文件)

迭代器：用于迭代取值的工具，每一次对过程的重复称为一次迭代，每一次迭代的结果会作为下一次迭代的初始值，每一次都更逼近所需目标或结果

迭代器对象：可迭代对象通过内置方法__iter__()得到的返回值，就是迭代器对象。
特点：
1.有__next__()内置方法，执行该方法会得到迭代器对象中的一个值
2.有__iter__()内置方法，执行该方法会得到迭代器本身
3.打开的文件本身就是一个迭代器对象
优点：
1.为序列和非序列数据类型提供了一种统一的迭代取值方式
2.惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用__next__()来计算一个值，就迭代器本身来说，同一个时刻在内存中只有一个值，因此可以存放无限大的数据流
缺点：
1.取值麻烦，只能一个一个取，并且只能往后取，值取出后就没了
2.无法使用len()方法获取长度
应用场景：
1.for循环
2.逐行遍历文本文件
3.列表推导、字典推导和集合推导

生成器对象：
生成器是构造迭代器的最简单有力的工具，本质就是一个迭代器，自定义的迭代器。使用方式跟普通函数类似，不同点在于返回一个值的时候使用yield来代替return，yield关键字会自动构建好next()和iter()
特点：也有内置方法__next__()和__iter__()
应用场景：
1.不想同一时间将所有计算出来的大量结果集分配到内存当中，特别是结果集里还包含循环。

总结：
1.迭代器：节约内存；读取数据的一种方式
2.生成器：本质就是迭代器，可理解为自定义的迭代器，用于生成数据
3.可迭代对象、迭代器和生成器之间的关系：
'''

什么是元类?元类的应用场景有哪些，能具体说说吗？

'''
在python中，万物皆对象，对象是通过类实例化的结果，那么类是怎么来的？类是元类实例化的结果，也就是创建类的类。
ps：一个类在实例化的过程中，做了以下事情
1.触发元类中（造出这个类的类）的__call__方法（通过对象+()的方式触发）
2.通过__new__产生一个空对象（在__init__触发前触发）
3.通过__init__初始化这个对象（在实例化的时候触发）
4.返回这个对象

元类的场景
1.ORM(Object Relational Mapping)，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表
2.实现单例模式
'''