【01数据处理篇】

1.1迭代器 iter

参考：https://blog.csdn.net/qdPython/article/details/124063606

基本用法

\quad python中大多数内置容器都是可以迭代的，包括列表、元组和字符串等，称为可迭代对象（iterable）。
\quad 用法为：首先利用iter(iterable)得到迭代器，然后利用next()函数或者for循环进行遍历。也可以利用list(iterator)得到列表，利用tuple(iterator)得到元组。需要注意，利用next、for循环或list()等之后，迭代器就变了，取出的数就没办法再次取出了。
\quad 其中next(迭代器)与迭代器.__next__()等价，列表、元组和字符串对应迭代器type分别为list_str、tuple_iter和str_iter。

list_a = [1, 2, 3, 4]
tuple_a = (1, 2, 3, 4)
string_a = '1234'
# 使用iter()获取迭代器
my_iter = iter(list_a)
# 使用next()函数获取值
print(next(my_iter))
# next(迭代器)与迭代器.__next__()等价
print(my_iter.__next__())
# 利用for循环进行遍历
for item in my_iter:
    print(item)

结果为

1
2
3
4

深入理解for循环

\quad 利用for循环也可以遍历iterable，同时也可遍历迭代器，这是因为for循环内部就是利用迭代器实现的。对于迭代器而言，再用一次iter()函数仍然返回相同迭代器，则不会产生影响。

# create an iterator object from that iterable
iter_obj = iter(iterable)
  
# infinite loop
while True:
    try:
        # get the next item
        element = next(iter_obj)
        # do something with element
    except StopIteration:
        # if StopIteration is raised, break from loop
        break

创建自己的Iterator

\quad 迭代器类必须包括__iter__和__next__方法，我们实现一个用于list等的迭代器。

class iter_list:
    def __init__(self, list_n):
        self.list_n = list_n
        self.cnt = -1

    def __iter__(self):
        return self

    def __next__(self):
        if self.cnt < len(self.list_n) - 1:
            self.cnt = self.cnt + 1
            return self.list_n[self.cnt]
        else:
            raise StopIteration
# 测试代码
a = [1, 2, 3, 4]
m = iter_list(a)
iter_m = iter(m)
print(next(iter_m))
print(next(iter_m))
for i in iter_m:
    print(i)

结果为

1
2
3
4

1.2 zip

参考：https://blog.csdn.net/PaulZhn/article/details/104391756

理解

\quad 理解iteror之后，再理解zip就会好很多。在python3中，zip(a, b, c)得到的结果为[(a[0], b[0], c[0]), (a[1], b[1], c[1]),…]的迭代器，而逆变换zip(* zipped)得到的为(a, b, c)的迭代器。
\quad 当a, b, c不等长时，选取最短长度进行zip，其余的数据扔掉

a = ['1', '2', '3', '4']
b = [1, 2, 3, 4]
c = zip(a, b)
# 输出第一个元组为('1', 1)
print(next(c))
# 由于第一个元组('1', 1)已经被输出了，则此时c=(('2', 2), ('3', 3), ('4', 4))
d = zip(*c)
print(next(d))

结果为

('1', 1)
('2', '3', '4')

\quad 这里逆变换时使用zip(* zipped)而非直接用zip(zipped)是因为前者可以将最外层给解开，不然zip(zipped)等价于zip(zipped, [])

a = ['2', '3', '4']
b = [2, 3, 4]

c = zip(a, b)
d = zip(c) # 不加*时，相当于将c与空tuple做zip，则得到((('2', 2), ), (('3', 3), ), (('4', 4), ))
print(list(d))

c = zip(a, b)
e = zip(*c) # 添加*应该相当于将其最外层解开，则变成('2', 2), ('3', 3), ('4', 4)，再进行zip
print(list(e))

# 利用list测试，结论相同
f = [('2', '3', '4'), (2, 3, 4)]
g = zip(*f)
print(list(g))

输出结果为

[(('2', 2),), (('3', 3),), (('4', 4),)]
[('2', '3', '4'), (2, 3, 4)]
[('2', 2), ('3', 3), ('4', 4)]

常见用法

同时处理多个list、tuple、dict等

a = ['aa', 'bb', 'cc', 'dd']
b = [1, 2, 3, 4]
for i, j in zip(a, b):
    print(i, '->', j)

结果为

aa -> 1
bb -> 2
cc -> 3
dd -> 4

1.3 isinstance

参考：https://baijiahao.baidu.com/s?id=1704041754416854294&wfr=spider&for=pc

\quad isinstance(object，classinfo)用于判断object类型是否为classinfo，相同则返回True，反之返回False。object为实例对象，classinfo可以是直接或间接类名、基本类型或由它们组成的元组

a = 10
print(isinstance(a, int))
print(isinstance(a, (int, str))) # 是元组中的一个则返回True，元组不能替换为list

输出结果为

True
True

\quad instance与type区别为，instance认为子类是一种父类类型，考虑继承关系；type认为子类不是父类类型，不考虑继承关系

class A:
    pass

class B(A): # B继承自A
    pass

print(isinstance(A(), A)) # 利用A()得到实例对象，A则为类
print(isinstance(B(), A))
print(type(A()) == A)
print(type(B()) == A)

输出结果为

True
True
True
False

1.4 维度处理

1.4.1 广播机制

参考：https://blog.csdn.net/weixin_44319196/article/details/107871808
\quad 参与运算的两者数据维度不一致时，python会进行广播机制，广播机制是指：两个数组的后缘维度相同，或者在其中一方的维度为1。广播在缺失或者维度为1的维度上补充。注意：后缘维度是指从从后往前只要有维度就都得是匹配的，比如(3,2)和(2,)匹配，而和(3,)不匹配。

import numpy as np

a = np.ones(shape=(3,)) # shape用元组形式传入
print('shape of a: ',a.shape)
b = np.ones(shape=(2, 3))
c = np.ones(shape=(3, 2))
r1 = b - a # 后缘维度相同可广播
print('shape of b-a: ',r1.shape)
r2 = c - a # 后缘维度不同则不可广播

输出结果为

    r2 = c - a # 后缘维度不同则不可广播
ValueError: operands could not be broadcast together with shapes (3,2) (3,) 
shape of a:  (3,)
shape of b-a:  (2, 3)

\quad 只要维度数相同，对于维度大小不一致的维度，只要其中一方为1就可以进行广播

import numpy as np

a = np.ones(shape=(3, 1))
print('shape of a: ',a.shape)
b = np.ones(shape=(1, 3))
c = np.ones(shape=(3, 2))
r1 = b - a
print('shape of b-a: ',r1.shape)
r2 = c - a
print('shape of c-a: ',r2.shape)

输出结果为

shape of a:  (3, 1)
shape of b-a:  (3, 3)
shape of c-a:  (3, 2)

1.4.2 维度处理

利用None进行维度扩展
\quad 为了利用广播机制，需要对维度进行扩张，可以采用None进行扩张

import numpy as np

a = np.ones(shape=(3,))
a = a[:, None, None]
print('shape of a: ',a.shape)
b = np.ones(shape=(3, 3, 2))
r1 = b - a
print('shape of b-a: ',r1.shape)

输出结果为

shape of a:  (3, 1, 1)
shape of b-a:  (3, 3, 2)