作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

 

这一讲的主要目的是为了大家在读Python程序的时候对循环对象有一个基本概念。

循环对象的并不是随着Python的诞生就存在的，但它的发展迅速，特别是Python 3x的时代，循环对象正在成为循环的标准形式。

 

什么是循环对象

循环对象是这样一个对象，它包含有一个next()方法(__next__()方法，在python 3x中)， 这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出StopIteration错误。

当一个循环结构（比如for）调用循环对象时，它就会每次循环的时候调用next()方法，直到StopIteration出现，for循环接收到，就知道循环已经结束，停止调用next()。

假设我们有一个test.txt的文件:

1234
abcd
efg


我们运行一下python命令行：

>>>f = open('test.txt')

>>>f.next()

>>>f.next()

...


不断输入f.next()，直到最后出现StopIteration

open()返回的实际上是一个循环对象，包含有next()方法。而该next()方法每次返回的就是新的一行的内容，到达文件结尾时举出StopIteration。这样，我们相当于手工进行了循环。

自动进行的话，就是：

for line in open('test.txt'):
    print line


在这里，for结构自动调用next()方法，将该方法的返回值赋予给line。循环知道出现StopIteration的时候结束。

 

相对于序列，用循环对象的好处在于：不用在循环还没有开始的时候，就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样，节省了空间，提高了效率，编程更灵活。

 

迭代器

从技术上来说，循环对象和for循环调用之间还有一个中间层，就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用iter()函数实现的。但从逻辑层面上，常常可以忽略这一层，所以循环对象和迭代器常常相互指代对方。

 

生成器

生成器(generator)的主要目的是构成一个用户自定义的循环对象。

生成器的编写方法和函数定义类似，只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个循环器，每次循环使用一个yield返回的值。

 

下面是一个生成器:

def gen():
    a = 100
    yield a
    a = a*8
    yield a
    yield 1000


该生成器共有三个yield， 如果用作循环器时，会进行三次循环。

for i in gen():
    print i


 

再考虑如下一个生成器:

def gen():
    for i in range(4):
        yield i


它又可以写成生成器表达式(Generator Expression):

G = (x for x in range(4))


生成器表达式是生成器的一种简便的编写方式。读者可进一步查阅。

 

表推导

表推导(list comprehension)是快速生成表的方法。它的语法简单，很有实用价值。

 

假设我们生成表L：

L = []
for x in range(10):
    L.append(x**2)


以上产生了表L，但实际上有快捷的写法，也就是表推导的方式:

L = [x**2 for x in range(10)]


这与生成器表达式类似，只不过用的是中括号。

（表推导的机制实际上是利用循环对象，有兴趣可以查阅。）

 

练习 下面的表推导会生成什么？

xl = [1,3,5]
yl = [9,12,13]
L  = [ x**2 for (x,y) in zip(xl,yl) if y > 10]


 

总结

循环对象

生成器

表推导



函数的定义


首先，我们要定义一个函数, 以说明这个函数的功能。

def square_sum(a,b):
    c = a**2 + b**2
    return c


这个函数的功能是求两个数的平方和。

首先，def，这个关键字通知python：我在定义一个函数。square_sum是函数名。

括号中的a, b是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）。

我们已经在循环和选择中见过冒号和缩进来表示的隶属关系。

c = a**2 + b**2        #
 这一句是函数内部进行的运算

return c               # 返回c的值，也就是输出的功能。Python的函数允许不返回值，也就是不用return。

return可以返回多个值，以逗号分隔。相当于返回一个tuple(定值表)。

return a,b,c          # 相当于 return (a,b,c)

 

在Python中，当程序执行到return的时候，程序将停止执行函数内余下的语句。return并不是必须的，当没有return, 或者return后面没有返回值时，函数将自动返回None。None是Python中的一个特别的数据类型，用来表示什么都没有，相当于C中的NULL。None多用于关键字参数传递的默认值。

 

函数调用和参数传递

定义过函数后，就可以在后面程序中使用这一函数

print square_sum(3,4)


Python通过位置，知道3对应的是函数定义中的第一个参数a， 4对应第二个参数b，然后把参数传递给函数square_sum。

（Python有丰富的参数传递方式，还有关键字传递、表传递、字典传递等，基础教程将只涉及位置传递）

函数经过运算，返回值25, 这个25被print打印出来。

 

我们再看下面两个例子


a = 1

def change_integer(a):
    a = a + 1
    return a

print change_integer(a)
print a

#===(Python中 "#" 后面跟的内容是注释，不执行 )

b = [1,2,3]

def change_list(b):
    b[0] = b[0] + 1
    return b

print change_list(b)
print b



第一个例子，我们将一个整数变量传递给函数，函数对它进行操作，但原整数变量a不发生变化。

第二个例子，我们将一个表传递给函数，函数进行操作，原来的表b发生变化。

对于基本数据类型的变量，变量传递给函数后，函数会在内存中复制一个新的变量，从而不影响原来的变量。（我们称此为值传递）

但是对于表来说，表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作将在原有内存中进行，从而影响原有变量。 （我们称此为指针传递）

 

总结

def function_name(a,b,c):
    statement
    return something  # return不是必须的


函数的目的： 提高程序的重复可用性。

return     None

通过位置，传递参数。

基本数据类型的参数：值传递

表作为参数：指针传递

 

练习:

写一个判断闰年的函数，参数为年、月、日。若是是闰年，返回True

package com.xjc;

/任务二：创建士兵（Soldiers）类，该类有三个属性name(名字),x（横坐标）,y（纵坐标）

在该类中定义有参构造方法，该方法有一个String类型参数name，代表士兵的姓名，

两个int类型变量x和y，分别表示士兵被实例化后所在的坐标位置，x代表横坐标，y代表纵坐标。

在主方法中使用for循环创建5个士兵对象，每个士兵对象的姓名以及x，y坐标是通过用户在控制台输入的。将5个士兵对象存入到数组中。/
import java.util.Scanner;
//创建Soldiers类

public class Soldiers {
// 定义几个属性
String name;
int x;
int y;

/*
 * 创建一个无参构造方法(当没有手动添加构造方法，系统会默认添加一个无参的构造方法。
 * 当手动添加了构造方法，默认的无参的构造方法会消失。所以我们通常都会创建一个无参构造方法,可能会用到)
 */
public Soldiers() {
}

// 创建一个有参构造方法
public Soldiers(String name, int x, int y) {
	this.name = name;
	this.x = x;
	this.y = y;
}

public static void main(String[] args) {
	Scanner input = new Scanner(System.in);

	// 定义一个Soldiers类型的数组,Soldiers是我们自己定义的一个类
	Soldiers[] soldiersShuZu = new Soldiers[5];

	// 使用for循环获取这五个士兵的信息
	for (int i = 0; i < 5; i++) {
		System.out.println("请输入第" + (i + 1) + "个小兵的名字:");
		String name = input.next();
		System.out.println("请输入第" + (i + 1) + "个小兵的x坐标:");
		int x = input.nextInt();
		System.out.println("请输入第" + (i + 1) + "个小兵的y坐标:");
		int y = input.nextInt();

		// 新建一个ShiBing对象,把上面输入的参数传给这个对象,并且输出属性
		Soldiers ShiBing = new Soldiers(name, x, y);
		System.out.println("士兵名字:" + name + "  X坐标:" + x + "  Y坐标:" + y);

		// 把ShiBing对象存入我们定义的数组
		soldiersShuZu[i] = ShiBing;
	}

	// for循环遍历数组,输出小兵信息
	for (int i = 0; i < soldiersShuZu.length; i++) {

		// 这里是定义一个soldiers类型的变量--ShiBing;可以理解为类似:int a 这种,只不过这里的数据类型是soldiers,是我们自己定义的类型
		Soldiers ShiBing = soldiersShuZu[i];
		System.out
				.println("第" + i + "个小兵的信息:\n姓名:" + ShiBing.name + "坐标:" + "(" + ShiBing.x + "," + ShiBing.y + ")");
	}
}

}

为什么我会总结这篇文章，可能新手都会遇到的一个问题

当然我也是新手，所以这是我遇到的问题吧

 

 

首先先描述一下我遇到的这个问题

有一天夜黑风高，我像往常一样蹲着路边（嘻嘻嘻），突然有个女孩急匆匆跑过来

拉着我的手问：“为什么为什么我的迭代循环只循环一次，第二次，第三次，第四次...就没有东西了,我的迭代啊.....”

我一看，就这，哼，我伸出那熟练的单手一把把她撸进怀里，错误错误，是搂是搂进怀里，结果我的被单湿透了，

一看全身都是汗啊.....

 

废话少说，开练开练

 

首先我们要弄清楚，这个可迭代的东西（也就是循环的这个东西），它这个到底是迭代器呢还是可迭代对象呢

先简单概括一下：迭代器呢，一次for循环就没有了，而可迭代对象呢，任你for一万次都会输出

【这里的for指for i in 可迭代的东西】

差不多你可能就会明白了，别着急我们再往里深入深入

 

迭代器（Iterator）和可迭代对象（Iterable）的区别和联系

 

迭代器（Iterator）：它的特点就是不知道要执行多少次，所以可以理解不知道有多少个元素，每调用一次__next__()方法，就会往下走一步，当然是用__next__()方法只能往下走，不会回退，遵循迭代器协议。

迭代器协议：含__iter__()方法，且方法返回的Iterator对象本身；含__next__()方法，每当__next__()方法被调用，返回下一个值，直到没有值可以访问，这个时候会抛出stopinteration的异常。

 

可迭代对象（Iterable）：它的特点其实就是序列的大小长度已经确定了(list,tuple,dict,string等)，遵循可迭代协议。

可迭代协议：含__iter__()方法。且可迭代对象中的__iter__()方法返回的是一个对应的迭代器。(如list对应的迭代器就是list_iterator)

 

通俗地讲就是类如果满足可迭代协议也就是有__iter__()的时候就可以成为可迭代对象，如果类有__iter__()和__next__()方法就可以称之为迭代器

 

或者更简单的说：

一个可迭代对象，不含__next__()方法，每次遍历都是将迭代对象转化为迭代器，遍历多少次就转化多少次。

而如果是迭代器呢，此时的遍历就是不断调用__next__()的过程，而这个过程是单向的，到最后一个元素时会抛出StopIteration异常终止此次遍历，迭代器用完了就没有了

 

 

到此你应该可以可能理解了吧哈哈哈哈

------------------------------------------------------------------------------

如果还有帅哥美女不理解迭代器是什么的话，请接着往下看

 


 

迭代就是循环

迭代器就是存放迭代的地方

序列和字典都可以迭代（不过是可迭代对象）

iter()  表示生成一个迭代器（记得迭代器是一次性的，如果尝试多次性可能有危险哦），可以把序列，字典啊...等弄成迭代器

next() 表示每完成一次循环输出的值

 



>> string = 'BCDEFG'
>>> c = iter(string)
>>> next(c)
'B'
>>> next(c)
'C'
>>> next(c)
'D'
>>> next(c)
'E'
>>> next(c)
'F'
>>> next(c)
'G'
>>> next(c)    ##如果循环到最后，没有值了，则抛出一个StopIteration报错
Traceback (most recent call last):
  File "<pyshell#82>", line 1, in <module>
    next(c)
StopIteration

到这里就接近尾声了....如果对各位靓仔靓妹有帮助的话记得给我个赞噢（啥都不要，就想集赞）

Java循环一个对象的所有属性，并通过反射给这些属性赋值/取值

说到循环遍历，最常见的遍历数组/列表、Map等。但是，在开发过程中，有时需要循环遍历一个对象的所有属性。遍历对象的属性该如何遍历呢？查了一下资料，需要用到一些反射的知识！



话不多说，先上代码

首先先定义一个测试对象 Test



public class Test {

    private String aa;

    private int bb;

    private String cc;

    public String dd;

    public String getAa() {
        return aa;
    }

    public void setAa(String aa) {
        this.aa = aa;
    }

    public int getBb() {
        return bb;
    }

    public void setBb(int bb) {
        this.bb = bb;
    }

    public String getCc() {
        return cc;
    }

    public void setCc(String cc) {
        this.cc = cc;
    }
}

这个对象里分别有aa bb cc 三个私有属性，dd一个公有属性，接下来通过反射来获取这个对象的四个属性值



    public static void main(String[] args) {

        /**
         *  返回Class 对象所表示的类或接口的所有可访问公共字段。
         */
        Field[] f1=Test.class.getFields();
        System.out.println("Test类里面的公共字段属性的个数为：" +f1.length+"个，分别为：");
        for(int i=0;i<f1.length;i++){
            String attributeName=f1[i].getName();
            System.out.println(attributeName);
        }


        /**
         * 返回 Class 对象所表示的类或接口所声明的所有字段，
         * 包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。
         */
        Field[] f=Test.class.getDeclaredFields();
        System.out.println("Test类里面的所有字段属性的个数为："+f.length+"个，分别为：");
        for(int i=0;i<f.length;i++){
            String attributeName=f[i].getName();
            System.out.println(attributeName);
        }

    }

运行main函数，输出如下： 


  
Test类里面的公共字段属性的个数为：1个，分别为： 

  dd 

  Test类里面的所有字段属性的个数为：4个，分别为： 

  aa 

  bb 

  cc 

  dd


getFields()方法只能获取Test类里面的所有公有属性，getDeclaredFields()方法可获取Test类所有公有/私有属性。需要注意的是，如果Test类继承了别的类，这两个方法都无法获取父类里面的属性的。

现在，已经获取到了Test类里面的所有属性名，然后通过这些属性名给这个类的实例赋值和取值操作。

先来给实例赋值，代码如下：



        Test test=new Test();
        //给test对象赋值
        for(int i=0;i<f.length;i++){
            //获取属相名
            String attributeName=f[i].getName();
            //将属性名的首字母变为大写，为执行set/get方法做准备
            String methodName=attributeName.substring(0,1).toUpperCase()+attributeName.substring(1);
            try{
                //获取Test类当前属性的setXXX方法（私有和公有方法）
                /*Method setMethod=Test.class.getDeclaredMethod("set"+methodName);*/
                //获取Test类当前属性的setXXX方法（只能获取公有方法）
                Method setMethod=Test.class.getMethod("set"+methodName,String.class);
                //执行该set方法
                setMethod.invoke(test,attributeName+"方法赋值");
            }catch (NoSuchMethodException e) {
                try {
                    Method setMethod=Test.class.getMethod("set"+methodName,int.class);
                    setMethod.invoke(test,123);
                } catch (Exception e2) {
                    f[i].set(test,attributeName+"直接赋值");
                }

            }

        }   

如上代码，之前已经获取到了Test类里面的所有属性名，在这部分代码中，就可以通过属性名来获取与之对应的set方法。需要注意的是，在上面代码中try-catch了两次，是因为在Test这个类中的属性的set方法的参数，有的是String类型，有的是int类型的，还有的属性是没有set方法的。第一次try是未了抓取所有参数类型不是String类型和不存在的set方法。第二次抓取的是参数不是int类型的和不存在的set方法。依次进行处理。除此之外，假如set方法的参数类型还有更多的类型的话，可以通过Filed类的getGenericType() 这个方法先判断类型，这个以后再做赘述。

接下来从实例中通过get方法来取值，代码如下：

        //从test对象取值
        for(int i=0;i<f.length;i++){
            //获取属相名
            String attributeName=f[i].getName();
            //将属性名的首字母变为大写，为执行set/get方法做准备
            String methodName=attributeName.substring(0,1).toUpperCase()+attributeName.substring(1);
            Object result;
            try{
                //获取Test类当前属性的setXXX方法（私有和公有方法）
                /*Method setMethod=Test.class.getDeclaredMethod("set"+methodName);*/
                //获取Test类当前属性的setXXX方法（只能获取公有方法）
                Method getMethod=Test.class.getMethod("get"+methodName);
                //执行该set方法
                result=getMethod.invoke(test);

            }catch(NoSuchMethodException e){
                result=f[i].get(test);
            }
            System.out.println("属性："+attributeName+"="+result);
        }

这里的代码也try-catch一次，get方法不存在参数类型判断的，这里的try-catch只是为了抓取公有属性不存在get方法的情况以做相应的处理。

运行测试程序，输出结果如下：


  
属性：aa=aa方法赋值 

  属性：bb=123 

  属性：cc=cc方法赋值 

  属性：dd=dd直接赋值


最后附上完整的测试程序



    public static void main(String[] args) throws Exception{

        /**
         *  返回Class 对象所表示的类或接口的所有可访问公共字段。
         */
        Field[] f1=Test.class.getFields();
        System.out.println("Test类里面的公共字段属性的个数为：" +f1.length+"个，分别为：");
        for(int i=0;i<f1.length;i++){
            String attributeName=f1[i].getName();
            System.out.println(attributeName);
        }

        /**
         * 返回 Class 对象所表示的类或接口所声明的所有字段，
         * 包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。
         */
        Field[] f=Test.class.getDeclaredFields();
        System.out.println("Test类里面的所有字段属性的个数为："+f.length+"个，分别为：");
        for(int i=0;i<f.length;i++){
            String attributeName=f[i].getName();
            System.out.println(attributeName);
        }

        Test test=new Test();
        //给test对象赋值
        for(int i=0;i<f.length;i++){
            //获取属相名
            String attributeName=f[i].getName();
            //将属性名的首字母变为大写，为执行set/get方法做准备
            String methodName=attributeName.substring(0,1).toUpperCase()+attributeName.substring(1);
            try{
                //获取Test类当前属性的setXXX方法（私有和公有方法）
                /*Method setMethod=Test.class.getDeclaredMethod("set"+methodName);*/
                //获取Test类当前属性的setXXX方法（只能获取公有方法）
                Method setMethod=Test.class.getMethod("set"+methodName,String.class);
                //执行该set方法
                setMethod.invoke(test,attributeName+"方法赋值");
            }catch (NoSuchMethodException e) {
                try {
                    Method setMethod=Test.class.getMethod("set"+methodName,int.class);
                    setMethod.invoke(test,123);
                } catch (Exception e2) {
                    f[i].set(test,attributeName+"直接赋值");
                }

            }

        }
        //从test对象取值
        for(int i=0;i<f.length;i++){
            //获取属相名
            String attributeName=f[i].getName();
            //将属性名的首字母变为大写，为执行set/get方法做准备
            String methodName=attributeName.substring(0,1).toUpperCase()+attributeName.substring(1);
            Object result;
            try{
                //获取Test类当前属性的setXXX方法（私有和公有方法）
                /*Method setMethod=Test.class.getDeclaredMethod("set"+methodName);*/
                //获取Test类当前属性的setXXX方法（只能获取公有方法）
                Method getMethod=Test.class.getMethod("get"+methodName);
                //执行该set方法
                result=getMethod.invoke(test);

            }catch(NoSuchMethodException e){
                result=f[i].get(test);
            }
            System.out.println("属性："+attributeName+"="+result);
        }

    }

第一次写博客，写的不好的地方还请大家多多谅解，请大神多多指导。