本篇我们介绍 Python 中的可遍历对象（iterable）与迭代器（iterator），以及它们之间的区别。

可遍历对象

在 Python 中，可遍历对象是指包含零个、一个或者多个元素的对象。

可遍历对象支持一次返回一个元素，因此我们可以使用 for 循环遍历这类对象。

实际上，range() 函数就是一个可遍历的对象，因为我们可以遍历它的结果：

for index in range(3):
    print(index)

输出结果如下：

0
1
2

同理，字符串也是一种可遍历对象，因为我们可以使用 for 循环遍历字符串：

str = 'Iterables'
for ch in str:
    print(ch)

列表和元组也都是可遍历的对象，我们可以对它们进行遍历。例如：

ranks = ['high', 'medium', 'low']

for rank in ranks:
    print(rank)

原则就是，如果某种对象可以遍历，它就是可遍历对象。

迭代器

可遍历对象可以进行迭代，迭代器（iterator）就是执行迭代操作时的代理对象。

如果想要获取可遍历对象的迭代器，可以使用 iter() 函数。例如：

colors = ['red', 'green', 'blue']
colors_iter = iter(colors)

一旦我们获得了迭代器，就可以利用 next() 函数获取可遍历对象中的下一个元素：

colors = ['red', 'green', 'blue']
colors_iter = iter(colors)

color = next(colors_iter)
print(color)

输出结果如下：

red

每次调用 next() 函数都会返回可遍历对象的下一个元素。例如：

colors = ['red', 'green', 'blue']
colors_iter = iter(colors)

color = next(colors_iter)
print(color)

color = next(colors_iter)
print(color)

color = next(colors_iter)
print(color)

输出结果如下：

red
green
blue

如果遍历完所有元素之后，再次调用 next() 函数，将会返回一个异常。

colors = ['red', 'green', 'blue']
colors_iter = iter(colors)

color = next(colors_iter)
print(color)

color = next(colors_iter)
print(color)

color = next(colors_iter)
print(color)


# 返回异常
color = next(colors_iter)
print(color)

以上示例首先会返回 colors 列表中的三个元素，然后抛出一个异常：

red
green
blue
Traceback (most recent call last):
  File "iterable.py", line 15, in <module>
    color = next(colors_iter)
StopIteration

迭代器是有状态的，意味着一旦我们使用了迭代器中的元素，它就不再存在。也就是说，一旦我们遍历完整个迭代器，它就会变成一个空的迭代器。如果我们再次遍历这个迭代器，它不会返回任何内容。

由于我们可以遍历迭代器，因此迭代器也是一种可遍历对象。这一点比较令人困惑。例如：

colors = ['red', 'green', 'blue']
iterator = iter(colors)

for color in iterator:
    print(color)

输出结果如下：

red
green
blue

如果我们使用一个迭代器作为参数调用 iter() 函数，它会返回一个相同的迭代器。

我们会在后续课程中介绍如何创建可迭代对象。

总结

• 可遍历对象（iterable）是一种可以进行遍历的对象，它可以一次返回一个元素。
• 迭代器（iterator）是执行迭代操作时的代理对象。迭代器拥有状态，它也是一种可遍历对象。
• 使用 iter() 函数获取可遍历对象的迭代器，使用 next() 函数获取可迭代对象中的下一个元素。

一、vue中v-for遍历对象

  <el-form-item label="状态：">
	   <el-select v-model="searchData.generateStatus">
          <el-option label="全部" value="null"></el-option>
             <el-option
                 v-for="(value, key) in incomeStatusEnum"
                 :key="key"
                 :label="value"
                 :value="key"
             ></el-option>
         </el-select>
     </el-form-item>
     
//data数据
incomeStatusEnum: {
     1: '未开始',
     2: '生成中',
     3: '生成完成',
     4: '生成失败',
 },

//列表中需要显示时候
<el-table-column prop="name" label="状态" min-width="100">
     <template slot-scope="{ row: { generateStatus } }">
         <span v-text="incomeStatusEnum[generateStatus]"></span>
     </template>
 </el-table-column>

二、for…in 遍历数组和对象都可以

*****************************************************对象
var obj = {
       1: '未开始',
       2: '生成中',
       3: '生成完成',
       4: '生成失败',
   }

for (let i in obj) {
     console.log(i, obj[i])  //i是键名，obj[i]是键值
 }
 ****************************************************数组
var arr = ['未开始', '生成中', '生成完成', '生成失败']

 for (let i in arr) {
     console.log(i, arr[i])  //i是index，arr[i]是item
 }

三、Object的方法

var obj = {
       1: '未开始',
       2: '生成中',
       3: '生成完成',
       4: '生成失败',
   }

for (let item of Object.keys(obj)) {
    console.log(item)
} // 遍历返回键名

for (let item of Object.values(obj)) {
    console.log(item)
} // 遍历返回键值

for (let item of Object.entries(obj)) {
    console.log(item)
}  // 返回键值对组成的数组，如：['key', 'value']

四、Object.getOwnPropertyNames(obj)

var obj = {
       1: '未开始',
       2: '生成中',
       3: '生成完成',
       4: '生成失败',
   }

Object.getOwnPropertyNames(obj).forEach(key => {
     console.log(key, obj[key])
 })

五、使用Reflect.ownKeys(obj)遍历

var obj = {
       1: '未开始',
       2: '生成中',
       3: '生成完成',
       4: '生成失败',
   }

Reflect.ownKeys(obj).forEach(key=>{
console.log(key,obj[key]);
});

链接: https://www.cnblogs.com/yuer20180726/p/11377897.html.

一、对象遍历方法

1.for…in

for...in主要用于循环对象属性。循环中的代码每执行一次，就会对对象的属性进行一次操作。语法如下：

for (let i in obj){
  执行的代码块
}

其中两个参数：

• i：必须。指定的变量可以是数组元素，也可以是对象的属性
• obj：必须。指定的迭代的对象

let obj={a:1,b:2,c:3}

for (let i in obj){

  console.log('键名：',i)
  
  console.log('键值：',obj[i])
}

⚠️：

• for...in 方法不仅会遍历当前对象的可枚举属性，还会遍历其原型链上的属性

2.Object.keys()、Object.values()、Object.entries()

这三个方法都用来遍历对象，它会返回一个由给定对象的自身可枚举属性(不含继承的和Symbol属性)组成的数组，数组元素的排列顺序和正常循环遍历该对象时返回的顺序一致，三个元素返回的值分别如下：

• Object.keys()：返回包含对象键名的数组
• Object.values()：返回包含对象键值的数组
• Object.entries()：返回包含对象键名和键值的数组

let obj={
 id:1,
 name:'hello',
 age:18
}

console.log(Object.keys(obj)) //['id','name','age']

console.log(Object.values()) //[1,'hello',18]

console.log(Object.entries()) //[['id',1],['name','hello'],['age',18]]

⚠️：

• Object.keys()方法返回的数组中的值都是字符串，也就是说不是字符串的key值会转化为字符串
• 结果数组中的属性值都是对象本身可枚举的属性，不包括继承来的属性

3.Object.getOwnPropertyNames()

Object.getOwnPropertyNames()方法与Object.keys()类似，也是接受一个对象作为参数，返回一个数组，包含了该对象自身的所有属性名。但它不能返回不可枚举的属性。

let a=['hello','word']

Object.keys(a) //['0','1']
Object.getOwnPropertyNames(a) //['0','1','length']

这两个方法都可以计算对象中属性的个数：

let a={0:'a',1:'b',2:'c'}

Object.getOwnPropertyNames(a) //['0','1','2']

Object.keys(a).length //3

Object.getOwnPropertyNames(a).length //3

4.Object.getOwnPropertySymbols()

Object.getOwnPropertySymbols()方法返回对象自身的Symbol属性组成的数组，不包括字符串属性：

let obj={a:1}

//给对象添加一个不可枚举的Symbol属性
Object.getOwnPropertySymbols(obj,{
  [Symbol('zhu')]:{
    value: 'Symbol zhu',
    enumerable: false
  }
})

//给对象添加一个可枚举的Symbol属性
obj[Symbol('yu')]='Symbol yu'

Object.getOwnPropertySymbols(obj).forEach(key=>{
  console.log(obj[key]) //Symbol zhu  Symbol yu
})

5.Reflect.ownKeys()

Reflect.ownKeys()返回一个数组，包含对象自身的属性。它和Object.keys()类似，Object.keys()返回属性key，但是不包括不可枚举的属性，而Reflect.ownKeys()会返回所有属性key：

let obj={
  a:1,
  b:2
}

Object.defineProperty(obj,'method',{
  value:function(){
     alert('non enumerable property')
  },
  enumerable:false
})

console.log(Object.keys(obj)) //['a','b']

console.log(Reflect.ownKeys(obj))  //['a','b','method']

⚠️：

• Object.keys()：相当于返回对象属性数组
• Reflect.ownKeys()：相当于Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj))

总结如下：