一、迭代器Iterators
迭代器仅是一容器对象，它实现了迭代器协议。它有两个基本方法：
1)next方法
返回容器的下一个元素
2)__iter__方法
返回迭代器自身
迭代器可使用内建的iter方法创建，见例子： 代码如下:
>>> i = iter('abc')
>>> i.next()
'a'
>>> i.next()
'b'
>>> i.next()
'c'
>>> i.next()
Traceback (most recent call last):
File "", line 1, in 
StopIteration:
class MyIterator(object):
def __init__(self, step):
self.step = step
def next(self):
"""Returns the next element."""
if self.step==0:
raise StopIteration
self.step-=1
return self.step
def __iter__(self):
"""Returns the iterator itself."""
return self
for el in MyIterator(4):
print el
--------------------
结果：
代码如下:
3
2
1
0
二、生成器Generators
从Python2.2起，生成器提供了一种简洁的方式帮助返回列表元素的函数来完成简单和有效的代码。
它基于yield指令，允许停止函数并立即返回结果。
此函数保存其执行上下文，如果需要，可立即继续执行。
例如Fibonacci函数：复制代码 代码如下:
def fibonacci():
a,b=0,1
while True:
yield b
a,b = b, a+b
fib=fibonacci()
print fib.next()
print fib.next()
print fib.next()
print [fib.next() for i in range(10)]
--------------------
结果：
复制代码 代码如下:
1
1
2
[3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
PEP Python Enhancement Proposal Python增强建议
tokenize模块复制代码 代码如下:
>>> import tokenize
>>> reader = open('c:/temp/py1.py').next
>>> tokens=tokenize.generate_tokens(reader)
>>> tokens.next()
(1, 'class', (1, 0), (1, 5), 'class MyIterator(object):/n')
>>> tokens.next()
(1, 'MyIterator', (1, 6), (1, 16), 'class MyIterator(object):/n')
>>> tokens.next()
(51, '(', (1, 16), (1, 17), 'class MyIterator(object):/n')
例子：
复制代码 代码如下:
def power(values):
for value in values:
print 'powering %s' %value
yield value
def adder(values):
for value in values:
print 'adding to %s' %value
if value%2==0:
yield value+3
else:
yield value+2
elements = [1,4,7,9,12,19]
res = adder(power(elements))
print res.next()
print res.next()
--------------------
结果：
复制代码 代码如下:
powering 1
adding to 1
3
powering 4
adding to 4
7
保持代码简单，而不是数据。
注意：宁可有大量简单的可迭代函数，也不要一个复杂的一次只计算出一个值的函数。
例子：复制代码 代码如下:
def psychologist():
print 'Please tell me your problems'
while True:
answer = (yield)
if answer is not None:
if answer.endswith('?'):
print ("Don't ask yourself too much questions")
elif 'good' in answer:
print "A that's good, go on"
elif 'bad' in answer:
print "Don't be so negative"
free = psychologist()
print free.next()
print free.send('I feel bad')
print free.send("Why I shouldn't ?")
print free.send("ok then i should find what is good for me")
--------------------
结果：
复制代码 代码如下:
Please tell me your problems
None
Don't be so negative
None
Don't ask yourself too much questions
None
A that's good, go on
None
认为此文章对《Python的迭代器和生成器使用实例》说的很在理，www.002pc.com为你提供最佳的编程技术，帝国cms模板制作。
更多:python对角矩阵定义Python的迭代器和生成器使用实例
https://www.002pc.comhttps://www.002pc.com/python/573.html
你可能感兴趣的生成器,Python,迭代,实例,使用
No alive nodes found in your cluster
0踩
赏
0 赞

在网上查了好久，自己写一个吧。
课本上说协方差阵对角线上是各个变量的方差，然而在numpy中通过np.cov(X)得到的协方差矩阵，其对角线线上的值不是np.var()计算出来的值。根本原因在于，np.cov(X)是在数理统计背景下计算的，得到的方差是样本方差，而不是平常意义下的方差。
嗯，不准确的讲，均值、方差、协方差。在数理统计中，除了均值的计算方式不变之外，其余的两个都是除以 
 ,而不是 
 。这样就可以解释出现上面问题的原因了。
两个随机变量 
 ,现在有两个观测数据 
 。每个随机变量可以看作一个特征，因此有 
 ，数据矩阵如下
样本均值的定义及python实现
数学定义：
 ,    
 是随机变量 
 的 
 个观测值
python代码：用np.mean()函数来实现。
笔算结果：
 的样本均值为 
 ， 
 的样本均值为 
python代码实现结果
#python代码
x1=np.array([1,3])
x2=np.array([2,4])
np.mean(x1)
#Out[62]: 2.0
np.mean(x2)
#Out[63]: 3.0
样本方差的定义及python实现
数学定义： 
， 
 是样本均值。
 是随机变量 
 的 
 个观测值。
python代码：用np.cov()函数来实现。
笔算结果：
 的样本方差为 
 的样本方差为 
python代码实现结果
np.cov(x1)
#Out[64]: array(2.)

#np.cov(x2)
Out[65]: array(2.)
方差的定义及python实现
数学定义： 
， 
 是平均值。
  是
 个数。
python代码：用np.var()函数来实现。
笔算结果：
 的方差为 
 的方差为 
python代码实现结果
np.var(x1)
#Out[67]: 1.0

np.var(x2)
#Out[68]: 1.0

 小结：其实给出一组数 
 .在学习数理统计这门课之前，一直都是采用 
 和 
 来计算平均值和方差的。我这里用的平均值可能会不太规范，反正我学数理统计之前都是这么理解的。
在接触到样本与总体的概念之后，才发现平均值有了另外一个定义，叫做样本均值，从其蕴含的统计学意义上来讲是不一样的，但是它们俩形式上一样，计算公式也一样，可以认为 
 .等号左边代表这组数 
 .的
平均值，等号右边代表
 .这 
 个
样本观测点的样本均值。
从而在开发代码语言时也就不用开发两个函数了（个人理解，查了好久，都是用的np.mean()计算的均值，当然list也有自己的函数，不过结果都是一样，如果实在理解不了，就把numpy的这个函数阿看作为统计学上的样本均值开发的函数吧，把list的函数看作日常理解的那个平均值）。
之后由于无偏估计和有偏估计的概念，才有了样本方差这个定义的出现，大致原因是：采用日常理解的方差形式 
 所定义样本方差是总体方差的有偏估计，不太好。但是人们发现如果把系数换为 
 ,这样定义的样本方差就是总体方差的无偏估计了。(但愿这样写不会被老师看见，非得被打死)。
之所以写这么多是为了铺垫协方差矩阵的问题。
 是用来计算样本各变量之间的协方差矩阵的。
这个函数必须输入一个参数，其余的都有默认值。嗯，用python还是得看源码啊。
np.cov(x)#x是一个向量是输出样本方差
a = np.array([[1, 2], [3, 4]])
#转置是因为函数把矩阵的行看作我们所熟悉的随机变量，也就是特征，把列看作观测得到的值
#会输出一个协方差矩阵
np.cov(a.T)
源码如下：
def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None,
        aweights=None):
"""
    Estimate a covariance matrix, given data and weights.

    Covariance indicates the level to which two variables vary together.
    If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
    then the covariance matrix element :math:`C_{ij}` is the covariance of
    :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
    of :math:`x_i`.

    See the notes for an outline of the algorithm.

    Parameters
    ----------
    m : array_like
        A 1-D or 2-D array containing multiple variables and observations.
        Each row of `m` represents a variable, and each column a single
        observation of all those variables. Also see `rowvar` below.
样本数据的协方差矩阵是下面这个图
上面的矩阵每一个元素的定义如下

在网上查了好久，自己写一个吧。
课本上说协方差阵对角线上是各个变量的方差，然而在numpy中通过np.cov(X)得到的协方差矩阵，其对角线线上的值不是np.var()计算出来的值。根本原因在于，np.cov(X)是在数理统计背景下计算的，得到的方差是样本方差，而不是平常意义下的方差。
嗯，不准确的讲，均值、方差、协方差。在数理统计中，除了均值的计算方式不变之外，其余的两个都是除以
 ,而不是 
 。这样就可以解释出现上面问题的原因了。
两个随机变量
 ,现在有两个观测数据 
 。每个随机变量可以看作一个特征，因此有 
 ，数据矩阵如下
样本均值的定义及python实现
数学定义：
 ,    
 是随机变量 
 的 
 个观测值
python代码：用np.mean()函数来实现。
笔算结果：
 的样本均值为 
 ， 
 的样本均值为 
python代码实现结果
#python代码
x1=np.array([1,3])
x2=np.array([2,4])
np.mean(x1)
#Out[62]: 2.0
np.mean(x2)
#Out[63]: 3.0
样本方差的定义及python实现
数学定义：
， 
 是样本均值。
 是随机变量 
 的 
 个观测值。
python代码：用np.cov()函数来实现。
笔算结果：
 的样本方差为 
 的样本方差为 
python代码实现结果
np.cov(x1)
#Out[64]: array(2.)
#np.cov(x2)
Out[65]: array(2.)
方差的定义及python实现
数学定义：
， 
 是平均值。
  是
 个数。
python代码：用np.var()函数来实现。
笔算结果：
 的方差为 
 的方差为 
python代码实现结果
np.var(x1)
#Out[67]: 1.0
np.var(x2)
#Out[68]: 1.0
小结：其实给出一组数
 .在学习数理统计这门课之前，一直都是采用
 和 
 来计算平均值和方差的。我这里用的平均值可能会不太规范，反正我学数理统计之前都是这么理解的。
在接触到样本与总体的概念之后，才发现平均值有了另外一个定义，叫做样本均值，从其蕴含的统计学意义上来讲是不一样的，但是它们俩形式上一样，计算公式也一样，可以认为
 .等号左边代表这组数 
 .的平均值，等号右边代表
 .这 
 个样本观测点的样本均值。
从而在开发代码语言时也就不用开发两个函数了（个人理解，查了好久，都是用的np.mean()计算的均值，当然list也有自己的函数，不过结果都是一样，如果实在理解不了，就把numpy的这个函数阿看作为统计学上的样本均值开发的函数吧，把list的函数看作日常理解的那个平均值）。
之后由于无偏估计和有偏估计的概念，才有了样本方差这个定义的出现，大致原因是：采用日常理解的方差形式
 所定义样本方差是总体方差的有偏估计，不太好。但是人们发现如果把系数换为 
 ,这样定义的样本方差就是总体方差的无偏估计了。(但愿这样写不会被老师看见，非得被打死)。
之所以写这么多是为了铺垫协方差矩阵的问题。
 是用来计算样本各变量之间的协方差矩阵的。
这个函数必须输入一个参数，其余的都有默认值。嗯，用python还是得看源码啊。
np.cov(x)#x是一个向量是输出样本方差
a = np.array([[1, 2], [3, 4]])
#转置是因为函数把矩阵的行看作我们所熟悉的随机变量，也就是特征，把列看作观测得到的值
#会输出一个协方差矩阵
np.cov(a.T)
源码如下：
def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None,
aweights=None):
"""
Estimate a covariance matrix, given data and weights.
Covariance indicates the level to which two variables vary together.
If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
then the covariance matrix element :math:`C_{ij}` is the covariance of
:math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
of :math:`x_i`.
See the notes for an outline of the algorithm.
Parameters
----------
m : array_like
A 1-D or 2-D array containing multiple variables and observations.
Each row of `m` represents a variable, and each column a single
observation of all those variables. Also see `rowvar` below.
样本数据的协方差矩阵是下面这个图
上面的矩阵每一个元素的定义如下

三角形的定义
1. 先创建一个Point类，然后定义Trianglele类。在Trianglele类中定义三个Point的实体来表示一个三角形的三个点，再定义构造方法对这三个点进行初始化，然后定义两个方法求三角形的周长、面积。定义一个测试类，在main()中创建一个对象，求给定三点的三角形的周长、面积。  public class Point {  int x;          int y; Point(){  } Point(int a,int b){   x=a; y=b;  }  public static double getInstance(Point p1, Point p2) {     return ((p1.x - p2.x, 2) + (p1.y - p2.y, 2));    } }    public class Triangle {  Point n1,n2,n3;                    boolean isTriangle; public Triangle(Point n1,Point n2,Point n3){             this.n1=n1; this.n2=n2; this.n3=n3; double sideA=tance(n1,n2); double sideB=tance(n2,n3); double sideC=tance(n1,n3); if(sideA+sideB>sideC&&sideB+sideC>sideA){  isTriangle=true; } else{  isTriangle=false; } } public void getPerimeter(){    if(isTriangle){  double sideA=tance(n1,n2);  double sideB=tance(n2,n3);
double sideC=tance(n1,n3);  n("三角形的周长为"+(sideA+sideB+sideC)); } else{  n("不能构成三角形。。。
");  } } public void getArea(){  if(isTriangle){           double sideA=tance(n1,n2); double sideB=tance(n2,n3); double sideC=tance(n1,n3); double p=(sideA+sideB+sideC)/2.0; n("三角形的面积为"+ (p*(p-sideA)*(p-sideB)*(p-sideC)));   }       else{  n("不能构成三角形。。
。"); }  } }   public class Test {  public static void main(String[] args) {        }  2. 编程求解矩形和圆面积。要求：为了让程序具有较好的扩展性，编写形状接口(J_sharp)，并且让矩形类(J_Rectangle)和圆类(J_Circle)均实现其接口。然后定义一个测试类(J_Area)进行测试。
J_sharp接口 public interface J_sharp {  public double Area(); }  J_        Point n1=new Point(3,0); Point n2 =new Point(0,4); Point n3=new Point(0,0); Triangle sanjiao=new Triangle(n1,n2,n3); imeter(); a(); }
public class J_Rectangle implements J_sharp {            double length; double width; double area; J_Rectangle(double width,double length){   =width; =length; } public double Area(){   } area=width*length; return area; }  J_ public class J_Circle implements J_sharp{      double r; public J_Circle(double r){  this.r=r; } public double Area(){   return r*r*3.1415;  }  } J_ public class J_Area {             } public static void main(String[] args) {  double r=10.0;   double width=12.0;          double length=4.0; J_Rectangle rectangle=new J_Rectangle(width,length); J_Circle circle =new J_Circle(r);  double result=(); n("矩形的面积为"+result); result=(); n("圆的面积为"+result); }
三角形的定义。