(python)代码学习||2024.2.3||题目是codewars上的【Validate Sudoku with size `NxN`】

题目的要求是写一个Sudoku类，类中要有一个实例函数判断传给对象的二维数组是否符合数独规则

题目链接：https://www.codewars.com/kata/540afbe2dc9f615d5e000425/python

---

下面是写完题后看到的别人的解决方法

from itertools import chain

class Sudoku(object):

    def __init__(self, grid):
        self.grid = grid
        self.size = len(grid)
        self.good_zone = set(range(1, self.size + 1))
    
    def __iter__(self):
        """Iterate over each row, column and square of the sudoku"""
        rows = self.grid
        cols = zip(*rows)
        square_size = int(self.size ** 0.5)
        squares = [sum((rows[y+i][x:x+square_size]
                        for i in range(square_size)), [])
                   for y in range(0, self.size, square_size)
                   for x in range(0, self.size, square_size)]
        return chain(rows, cols, squares)
    
    def valid_data_types(self):
        """Check data types"""
        return all(type(num) == int for num in chain(*self.grid))
    
    def zone_is_valid(self, zone):
        """Check if a zone contain every numbers"""
        return set(zone) == self.good_zone
    
    def is_valid(self):
        """Is the sudoku solved"""
        if not self.valid_data_types(): return False
        return all(self.zone_is_valid(zone) for zone in self)

---

观察到的东西

• 函数__iter__返回值处的chain()函数来自于from itertools import chain，网上搜来的结果是这样的：**Python中的chain()函数可以将多个迭代器组合起来，形成一个更大的迭代器。chain()函数的语法如下：itertools.chain(*iterables)其中，*iterables是一个可变参数，代表着可以传入多个可迭代的对象，如序列、列表、生成器等。chain()函数将这些可迭代对象连接起来成为一个更大的迭代器。**大概用法应该是这样：

from itertools import chain
a=[1,2,3]
b=[4,5]
c=('*','*')
d = chain(a,b,c)
print(d)
for i in d:
    print(i,end=' ')
#1 2 3 4 5 * *
'''输出
<itertools.chain object at 0x00000210F2869E40>
1 2 3 4 5 * *
'''

迭代器没学过，不过应该是一个可以遍历的东西
chain(rows,cols,squares)中rows,cols,squares都是二级列表，所以函数返回的是一个更迭代器，其中的元素是他们三个二级列表的所有元素，即一些一级列表

---

• 函数def valid_data_types(self)最后的all(type(num) == int for num in chain(*self.grid))处的chain(*self.grid)。self.grid是个二级列表，那这里chain处理之后的结果应该是一些元素（即num）为一级列表的迭代器，但是前面判断元素类型却是type(num)==int。实际上chain(*self.grid)的作用是将列表self.grid中的一级列表们中的所有元素放到一个迭代器中。这里应该是*在起作用：

a=[[1,2],[3,4]]
print(*a)
'''输出
[1, 2] [3, 4]
'''

*将二级列表中的一级列表们取出来，变成多个一级列表，于是chain就能对它们操作了

---

• 在函数is_valid最后的for zone in self处的self实际上是__iter__的返回值chain(rows, cols, squares)，实验了一下：

from itertools import chain
class test(object):
    def __iter__(self):
        return chain([1,2,3])
aa=test()
print(aa)
print(list(aa))
for i in aa:
    print(i,end=' ')
'''
<__main__.test object at 0x0000026A1442A0C0>
[1, 2, 3]
1 2 3
'''

这里如果把def __iter__(self)中的self去掉会在print(list(aa))处报错，报错为：

TypeError: test.iter() takes 0 positional arguments but 1 was given

如果把return chain([1,2,3])该为return [1,2,3]会在print(list(aa))处报错：

TypeError: iter() returned non-iterator of type 'list'

---

网上搜出来的东西也没看懂多少，似乎__iter__正常的用法类似于这样：

class test():
    def __init__(self,end):
        self.end=end
    def __iter__(self):
        print('__iter__被调用了')
        self.a=-1
        return self
    def __next__(self):
        print('__next__被调用了')
        self.a+=1
        if self.a>self.end:
            raise StopIteration()
        return self.a

for i in test(5):
    print(i)

'''换成这样是一样的输出
a=test(5)
for i in a:
    print(i)
'''

'''输出
__iter__被调用了
__next__被调用了
0
__next__被调用了
1
__next__被调用了
2
__next__被调用了
3
__next__被调用了
4
__next__被调用了
5
__next__被调用了
'''

看起来是要遍历test类的对象时会自动调用__iter__函数，每次遍历（包括第一次遍历以及结束时的那个没有遍历出结果的遍历）都会调用__next__函数，遍历出来的东西就是__next__的返回值

---

• 函数is_valid(self)和函数valid_data_types(self)最后的返回处都出现了all()函数，以下来自菜鸟教程：

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False

元素除了是 0、空、None、False 外都算 True。

函数等价于：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

使用例子：

print(all([1,1,1]))
print(all([1,1,0]))
'''输出
True
False
'''
print(all([True,True,True]))
print(all([True,True,False]))
'''输出
True
False
'''