python基础

面向对象：

　　面向对象就是将编程当成是一个事物，对外界来说，事物是直接使用的，不用去管他内部的情况。而编程就是设置事物能够做什么事。

　　类和对象的关系：用类去创建一个对象。

• 封装
  • 将属性和方法书写到类的里面的操作即为封装
  • 封装可以为属性和方法添加私有权限
• 继承
  • 子类默认继承父类的所有属性和方法
  • 子类可以重写父类属性和方法
• 多态
  • 传入不同的对象，产生不同的结果

　　魔法方法

• __init__()：初始化对象

  • 1、会在调用类时自动触发执行，用来为对象初始化自己独有的数据
  • 2、__init__内应该存放是为对象初始化属性的功能，但是是可以存放任意其他代码，想要在类调用时就立刻执行的代码都可以放到该方法内
  • 3、__init__方法必须返回None
• __str__()：默认打印对象的内存地址
  
  
• __del__()：删除对象

　　2、数据类型（可变、不可变）

　　3、多线程、协程

装饰器、生成器、迭代器

　　　  链接：https://www.jb51.net/article/234213.htm

装饰器：

　　它可以让其它函数在不作任何变动的情况下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景。比如：插入日志、性能测试、事务处理、缓存、权限校验等。有了装饰器我们就可以抽离出大量的与函数功能无关的雷同代码进行重用。

def retry(func):
    def inner(*args,**kwarys):
        ret = func(*args,**kwarys)
        max_retry = 3
        number = 0
        if not ret:
            while number < max_retry:
                number += 1
                print(number)
                ret = func(*args,**kwarys)
                if ret:
                    break
    return inner
@retry
def test():
    return False
test()

迭代器iterable：

• 可迭代对象：指该对象可被for ... in，例如：列表、集合、元租、字典、字符串、装饰器等；
  • 实现了__iter__方法，
  • 可通过isinstance(obj,Iterable)来判断是否可迭代
• 迭代器：对可迭代对象进行迭代的方式，并且需要记录当前迭代进行的位置

• 实现了__iter__和__next__方法，则是可迭代对象
• 可通过next()进行获取当前迭代的值
• 迭代对象遍历完后继续调用next()，则会抛出：StopIteration异常。　　　

from collections.abc import Iterator,Iterable

class MyIterator:
    def __init__(self,array_list):
        self.array_list = array_list
        self.index = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.index < len(self.array_list):
            val = self.array_list[self.index]
            self.index += 1
            return val
        else:
            raise StopIteration
class MySubIterator(MyIterator):
    def __init__(self):
        pass

myIterator = MyIterator([1,2,3,4])
print(isinstance(myIterator,Iterable))  #判断是否是可迭代对象
print(isinstance(myIterator,Iterator))  #判断是否是迭代器

生成器generator：一边循环一边计算的机制

• 生成器对象  带yield语句的对象
  • 普通函数运行到return语句则直接返回代码不再执行；而生成器对象会运行到yield后返回，再下次调用时从yield语句后继续执行；
    
  • yield 一次只会返回一个元素，即使返回的元素是个可迭代对象，也是一次性返回
  • yield生成器高级应用： send()方法，传递值给yield返回(会立即返回!)；如果传None，则等同于next(generator)。
  • yield from iterable 语法，基本作用为：返回一个生成器对象，提供一个“数据传输的管道”

Lambda函数（匿名函数）是什么

　　主要的作用是通过向函数传入函数或让函数返回函数最终实现代码的解耦合。 

　　 主要的用途是把一个函数传入另一个高阶函数 

#lambad匿名函数
#用一行代码实现求阶乘的函数
fac = lambda x: __import('functools').reduce(int.__mul__,range(1,x+1),1)
#用一行代码实现求最大公约数
gcd = lambda x,y:y % x and gcd(y%x,x) or x
print(fac)
print(gcd)
#实现从列表中筛选出奇数并求平方构成新列表操作
items = [12,5,7,10,8,19]
items = list(map(lambda x: x ** 2,filter(lambda x: x % 2,items)))
print(items)

#用列表的生成式来实现
items1 = [12,5,7,10,8,19]
items1 = [x ** 2 for x in items1 if x % 2]
print(items1)

实现单例模型：

　　单例模式是一个软件的设计模式，为了保证一个类，无论调用多少次产生的实例对象， 都是指向同一个内存地址，仅仅只有一个实例(对象)!

• 使用装饰器实现

def singleton(cls):
    _instance = {}

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

@singleton
class Too(object):
    pass
t1 = Too()
t2 = Too()
print(t1 is t2)
print(t2)

• 使用元类实现

class MyMeta(type):
    def __init__(self,name,base,attrs):
        self._instance = object.__new__(self)
        super().__init__(name,base,attrs)
        
    def __call__(self,*args,**kwargs):
        if args or kwargs:
            init_args = args
            init_kwargs = kwargs
            
            if init_args == args and init_kwargs == kwargs:
                return self._instance
            
            obj = object.__new__(self)
            self.__init__(obj,*args,**kwargs)
            return obj
        return self._instance
    
class Goo(metaclass=MyMeta):
    def __init__(self,x):
        self.x = x
g1 = Goo('1')
g2 = Goo('2')
print(g1,g2,g1 is g2)

• 模块实现
• __new__
• 类方法classmethod