查漏补缺--python小细节拾遗(二)

废话不多说,继续补漏:

1.python的命名空间和作用域

　　命名空间:

　　　　a.全局命名空间: pycharm创建一个py文件,此时整个文件为全局命名空间;

　　　　b.局部命名空间: 此时在py文件中创建一个函数,函数中即为局部命名空间;

　　　　c.内置命名空间: python存放内置函数和类的空间,如存放min,list函数等;

　　作用域:

　　　　a.全局作用域: 包含 全局命名空间 和 内置命名空间.

　　　　b.局部作用域: 包含 局部命名空间.

　　　　c.闭包: 如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure),不需要一定返回内层函数;

　　程序运行时命名空间加载顺序:

　　　　c ----> b ----> a

　　程序运行时取值作用域顺序:(就近原则)

a = 5
def func(a):
    a = 10
    print(a)
func(a)    # 10
print(a)    # 5

2.可迭代对象与迭代器与生成器

　　python官网术语大全: https://docs.python.org/zh-cn/3/glossary.html

　　a.可迭代对象: (Iterable, 摘用"流畅的python"中的定义)

　　　　使用iter内置函数可以获取迭代器的对象.

　　　　如果对象实现了能返回迭代器的__iter__方法,那么对象就是可迭代的.

　　　　序列都可以迭代.(标准序列实现了: __iter__方法和__getitem__方法)

　　　　实现了__getitem__方法,而且其参数是从零开始的索引,这种对象也可以迭代.

　　　　检测可迭代对象方法:

　　　　　　方法一: 调用iter(),返回一个迭代器对象,若报错,则为不可迭代对象.(python3.4以上推荐)

　　　　　　方法二: from collections import abc　　isinstance(x, abc.Iterable)　　(python3.4以上不推荐,其忽略了__getitem__方法)

　　　　python中的字符串,列表,字典,集合等均为可迭代对象,可迭代对象不能直接取值,需要转换为迭代器才能取值.

　　　　注: for循环本质上调用了可迭代对象的__iter__()方法,得到了该对象对应的迭代器对象,然后无限调用__next__()方法,

　　　　　  得到对象中的每一个元素.直到StopIteration异常,代表迭代器中已无下一个元素,for循环自动处理该异常,跳出循环.

　　　　这里可以想想怎么用while循环来模拟for循环取字符串中每个元素的值,

　　b.迭代器(Iterator): 

　　　　定义: 实现了无参数的__next__方法,返回序列中的下一个元素;如果没有元素,抛出StopIteration异常.

　　　　Python中的迭代器还实现了__iter__方法(必须return self),方便在应该使用可迭代对象的地方使用迭代器),因此迭代器也可以迭代,也是可迭代对象.

s = 'ABC'
for char in s:
    print(char)
    
# while循环模拟
iterator = iter(s)
while True:
    try:
        print(next(iterator))
    except StopIteration:
        del iterator    # 释放迭代器引用,废弃迭代器对象
        break

　　　　检查迭代器最靠谱的方法:

　　　　　　from collections import abc

　　　　　　isinstance(x, abc.Iterator)

　　c.生成器: 通常指的是生成器函数,某些情况下也可能是指 生成器迭代器

　　　　生成器函数: 含有yield表达式的函数;(reversed(seq), zip, enumarate, filter, map,另外itertools模块中一堆鬼鬼函数)

　　　　生成器迭代器: 生成器函数创建的对象.

def func():
    for i in range(10):
        yield i
g = func()　　# func为生成器函数, g为生成器迭代器
print(next(g))　　# next取值
        

 

　　d.生成器表达式: 将列表表达式的[]用()替换;

　　　　这里需要注意的是:调用生成器表达式时,内部运行从起始开始,而列表表达式内部已经运行完毕.

def func1():
    return [lambda x: i*x for i in range(4)]

def func2():
    return (lambda x: i*x for i in range(4))

print([i(2) for i in func1()])    # [6, 6, 6, 6]
print([i(2) for i in func2()])    # [0, 2, 4, 6]

　　总结与对比:

　　　　1.迭代器需要可迭代对象转换才能取值,可迭代对象是十分占内存的;

　　　　2.生成器在调用时才创建,本质上十分节省内存;

　　　　3.生成器和迭代器均可以统一用next(x)来进行元素调用;

 

3.继承相关

　　新式类和经典类

　　　　新式类: 继承自object类,python3中所有类均为新式类;(多继承时遵循广度优先,根据mro列表来进行继承关系顺序)

　　　　经典类: 不继承自object类,仅存于python2中;(多继承时遵循深度度优先,无super()方法和mro列表)　　

 

class A:
    def func(self):
        print("A")


class B(A):
    def func(self):
        super().func()
        print("B")


class C(A):
    def func(self):
        super().func()
        print("C")


class D(B, C):
    def func(self):
        super().func()
        print("D")


d = D()
print(D.mro())  # [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
d.func()        # 返回结果和上面mro列表保持一致,遵循广度优先原则

4.方法

　　只有能被对象调用的类中的方法才能成为方法.(学术装B利器)

class A:
    def func1(self): pass

    @staticmethod
    def func2():pass

a = A()
from types import MethodType, FunctionType

print(isinstance(a.func1, MethodType))      # True, 类实例对象调用才是方法
print(isinstance(a.func1, FunctionType))    # False
print(isinstance(a.func2, MethodType))      # False,类实例调用静态方法也不是方法
print(isinstance(a.func2, FunctionType))    # True, 而是函数
print(isinstance(A.func1, MethodType))      # False
print(isinstance(A.func1, FunctionType))    # True
print(isinstance(A.func2, MethodType))      # False
print(isinstance(A.func2, FunctionType))    # True, 静态方法永远都是函数

5.python中的多态

　　多态: 一种事物有多种形态.

　　多态的存在其实本身就是为了解决由于规定了传参类型而导致需要不断创建函数或类来涵盖更多传参的问题啦,因为继承,所以多态.

　　而python不同于其它语言,其传参相当自由,且python3中所有类均为object类的子类,所以其语言本身就是多态的体现.

　　注: 鸭子类型(多态具象化): 你看起来像鸭子,所以我认为你就是鸭子.

　　　  描述: 不是明确的通过继承实现的多态,而是通过一个模糊的概念来判断这个函数能不能接受这个类型的参数;

　　　  python中最典型的鸭子类型: print()函数,传入啥都能打印.

6.反射

　　定义: 通过字符串来获得属性(包括类方法,变量等),简单举例就是给个'abc'的字符串,返回abc()方法.

　　　　  相比于eval的不稳定性,反射让我们装B更有底气了.

　　以下举例说明:

　　a.反射类中的变量: 主要有: 静态属性, 类方法, 静态方法

class Foo:
    school = "QJZX"
    country = 'China'
    language = 'Chinese'
    
    def a():
        print("a")

print(getattr(Foo, 'school'))  # QJZX,获取属性值
getattr(Foo, 'a')()         # 打印a,getattr(Foo, 'a')等同于Foo.a,加括号直接调用
print(hasattr(Foo, 'a'))                # True
print(hasattr(Foo, 'country'))       # True
print(hasattr(Foo, 'language'))     # True
print(hasattr(Foo, 'b'))                # False

　　b.反射实例化对象中的变量

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def eating(self):
        print("%s is eating shit" % self.name)

sss = Foo("hxb", 3)
print(getattr(sss, 'name'))     # hxb, 获取实例对象属性
getattr(sss, 'eating')()        # hxb is eating shit, 调用类方法

　　c.反射模块中的变量

import os

os.rename("文件名1", '文件名2')                    # 改名
getattr(os, 'rename')('文件名2', '文件名1')      # 再改回来

　　d.反射本py文件中的变量

a = 1
b = 2
name = 'alex'

def merry_me():
    print("No!")

class Foo: pass

import sys

print(sys.modules)                              # 加载模块的内置内容
print(sys.modules['__main__'])                  # 本文件的命名空间
print(sys.modules['__main__'].a)                # 显示a的值为1
print(__name__, __name__ == '__main__')         # 内置变量,为字符串
print(sys.modules[__name__])                    # 反射本文件中的变量,固定的使用这个命名空间
getattr(sys.modules[__name__], 'merry_me')()    # 调用merry_me函数
print(getattr(sys.modules[__name__], 'Foo'))    # 反射类
obj = getattr(sys.modules[__name__], 'Foo')()   # 实例化类对象

 End!