【python学习：推导式、解释器生成器、函数、数据结构】

推导式

列表推导式

>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

字典推导式

>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

集合推导式

>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}

元组推导式

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

迭代器和生成器

迭代器

迭代器有两个基本的方法：iter() 和 next()。

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。
iter() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
next() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))


执行结果：
1
2
3
4
5

生成器

调用一个生成器函数，返回的是一个迭代器对象。
在 Python 中，使用了 yield 的函数被称为生成器（generator）。yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。

函数

不定长参数

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
加了两个星号 ** 的参数会以字典的形式导入。
声明函数时，参数中星号 * 可以单独出现，例如:

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )


输出：
输出:
10
输出:
70
60
50

加了两个星号 ** 的参数会以字典的形式导入。
#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)


输出：
输出: 
1
{'a': 2, 'b': 3}

如果单独出现星号 *，则星号 * 后的参数必须用关键字传入：
>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

数据结构

把列表当堆栈

堆栈的特点是后进先出，append()进，pop()出

把列表当队列

队列的特点是后进后出，append()进，popleft()出

from collections import deque
list=deque([1,2,3,4,5,6,7])
print('原列表',list)
list.append(8)
print('加入append列表',list)
list.pop()
print('堆栈  pop后的列表',list)
list.append(8)
print('恢复列表',list)
list.popleft()
print('队列  popleft',list)

输出：
原列表 deque([1, 2, 3, 4, 5, 6, 7])
加入append列表 deque([1, 2, 3, 4, 5, 6, 7, 8])
堆栈  pop后的列表 deque([1, 2, 3, 4, 5, 6, 7])
恢复列表 deque([1, 2, 3, 4, 5, 6, 7, 8])
队列  popleft deque([2, 3, 4, 5, 6, 7, 8])