为了复习方便 下面内容摘自PYTHON入门期末复习汇总_锴笑口常开的博客-CSDN博客_python复习
PYTHON期末复习之语法
将用一张思维导图的形式来展示python的基础语法.
PYTHON期末复习之运算符
Python语言支持以下类型的运算符:
算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级
PYTHON期末复习之组合数据类型
1.列表类型（灵活可变）
列表是用中括号（[]）表示
直接使用list()可以生成一个空列表
list()还可以将元组和字符串转化为列表。
2.集合类型（元素类型不可重复，且是固定一种数据类型，例如整型，字符型）
集合是用大括号（{}）表示
set()函数可以生成集合.
3.字典类型（键值对，键（一个属性），值（属性的内容））
字典是通过大括号来表示（{}）以冒号连接，不同键值对通过逗号连接
大括号也可以创建一个空的字典，可以通过中括号向其增加内容.
4.元组类型（不可变序列，不能删除，不能修改）
元组用逗号和圆括号表示
使用小括号 () 或 tuple() 或直接创建，元素间用逗号分隔.
和列表类型差不多.
PYTHON期末复习之字符串类型
错题总结：
1.zip(a,b)表示[(10,93),(11,30),(12,71),(13,68)]
a = (10, 11, 12, 13)
b = (93, 30, 71, 68)
d = dict( zip(a,b) ) #打包为元组的列表,并且元素个数与最短的列表一致.zip(a,b)表示[(10,93),(11,30),(12,71),(13,68)],dict()将其转换为字典{10:93,11:30,12:71,13:68}
print( tuple(d.keys()) )#keys返回一个列表,并且提取出d中键的值放入列表中,就是(10,11,12,13),tuple将列表转换为元组.
2.排序sorted
reverse默认为false 从小到大
True为从大到小
d= {'a':24,'g':52,'i':12,'k':33}
# 以列表形式输出字典d的key
# d.items()为字典d的键值对
b1=[key for key,value in d.items()]
print(b1)
# 以列表的形式输出字典d的value
b2={value for key,value in d.items()}
print(b2)
# 颠倒字典d的key:value位置
b3={value : key for key,value in d.items()}
print(b3)
# 将字典d按value的值进行排序
b4=sorted(d.items(), key=lambda x: x[1])
print(b4)
sorted(d.items(), key=lambda x: x[1]) 中 d.items() 为待排序的对象；key=lambda x: x[1] 为对前面的对象中的第二维数据（即value）的值进行排序。 key=lambda 变量：变量[维数] 。维数可以按照自己的需要进行设置。
维数以字符串来表示
Lambda表达在Python中是作为一个匿名函数的构造器而存在。
最简单的一个Lambda表达式例子和对应的非匿名函数：
f = lambda x: x + 1
print ( f(1) )
def h (x):
return x + 1
print ( h(1) )
带有一个参数的Lambda表达式和对应的非匿名函数：
def f(n):
return lambda x: x / n
print ( f(1)(2) ) # n=1; x=2
def g(n):
return lambda x: x / n
k = g(1) # n=1
print ( (k(2)) ) # x=2
def h(x,n):
return x / n
print ( h(2,1) ) #x=2; n=1
Lambda匿名函数经常被用到filter(), map(), reduce(), sorted()函数中，这些函数的共同点是均需要函数型的参数，Lambda表达式正好适用。以sorted函数为例，其key参数指定了一个负责从带排序的list中抽取comparison key的函数。
club_ranking = [
('Arsenal', 3),
('Chelsea', 1),
('Manchester City', 2),
('Manchester United', 4),
]
club_sorted = sorted(club_ranking, key = lambda x: x[1]) # sort by ranking
print (club_sorted)
#这里的lambda x: x[1] 1指的是元组中的第二个值进行排序
'''
在Python3.4中需要使用functools将cmp函数转化为key函数
'''
import functools
club_ranking = [
('Arsenal', 3),
('Chelsea', 1),
('Manchester City', 2),
('Manchester United', 4),
]
def get_ranking( x, y ): #define cmp function
return x[1] - y[1]
club_sorted = sorted(club_ranking, key = functools.cmp_to_key(get_ranking)) # sort by ranking
print (club_sorted)
3.reversed（）函数
print(sorted([1,2,3],reverse=True)==reversed([1,2,3]))
a=[1,2,3]
print(reversed([1,2,3]))
print(reversed(a))
print(sorted(a))
def print_iter(it):
for i in it:
print(i,end=' ')
print('\n')
print_iter(a)
<list_reverseiterator object at 0x7fe578127190>
<list_reverseiterator object at 0x7fe578127190>
[1, 2, 3]
1 2 3 reversed（）函数从指定的sequence参数返回反向迭代器。
带序列的reversed（） (reversed() with sequence)
Let’s look at reversed() function examples with standard sequence objects such as string, bytes, tuple, list etc.
让我们看一下带有标准序列对象（例如字符串， 字节 ，元组，列表等）的reversed（）函数示例。
def print_iterator(it):
for x in it:
print(x, end=' ')
print('\n')
# reversed string
r = reversed('abc')
print(type(r))
print(r)
print_iterator(r)
# reversed list
r = reversed([1, 2, 3])
print_iterator(r)
# reversed tuple
r = reversed((1, 2, 3))
print_iterator(r)
# reversed bytes
r = reversed(bytes('abc', 'utf-8'))
print_iterator(r)
# reversed bytearray
r = reversed(bytearray('abc', 'utf-8'))
print_iterator(r)
<class 'reversed'>
<reversed object at 0x109d1f208>
c b a
3 2 1
3 2 1
99 98 97
99 98 97
4.enumerate（）的用法
enumerate()说明
enumerate()是python的内置函数
enumerate在字典上是枚举、列举的意思
对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
enumerate多用于在for循环中得到计数
例如对于一个seq，得到：
(0, seq[0]), (1, seq[1]), (2, seq[2])
1
enumerate()返回的是一个enumerate对象，例如：
enumerate()使用
如果对一个列表，既要遍历索引又要遍历元素时，首先可以这样写：
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
print index, item
>>>
0 这
1 是
2 一个
3 测试enumerate还可以接收第二个参数，用于指定索引起始值，如
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1, 1):
print index, item
>>>
1 这
2 是
3 一个
4 测试a=[4,3,2,1]
print(list(enumerate(a)))
for i,j in enumerate(a):
print(i,j)
//[(0, 4), (1, 3), (2, 2), (3, 1)]
0 4
1 3
2 2
3 15.map函数
map(func, seq1[, seq2,…])
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。
Python函数编程中的map()函数是将func作用于seq中的每一个元素，并将所有的调用的结果作为一个list返回。如果func为None，作用同zip()。
1、当seq只有一个时，将函数func作用于这个seq的每个元素上，并得到一个新的seq。
让我们来看一下只有一个seq的时候，map()函数是如何工作的。
从上图可以看出，函数func函数会作用于seq中的每个元素，得到func(seq[n])组成的列表。下面举得例子来帮助我们更好的理解这个工作过程。
#使用lambda
>>> print map(lambda x: x % 2, range(7))
[0, 1, 0, 1, 0, 1, 0]
#使用列表解析
>>> print [x % 2 for x in range(7)]
[0, 1, 0, 1, 0, 1, 0]
一个seq时，可以使用filter()函数代替，那什么情况不能代替呢？
2、当seq多于一个时，map可以并行（注意是并行）地对每个seq执行如下图所示的过程：
从图可以看出，每个seq的同一位置的元素同时传入一个多元的func函数之后，得到一个返回值，并将这个返回值存放在一个列表中。下面我们看一个有多个seq的例子：
>>> print map(lambda x , y : x ** y, [2,4,6],[3,2,1])
[8, 16, 6]
如果上面我们不使用map函数，就只能使用for循环，依次对每个位置的元素调用该函数去执行。还可以使返回值是一个元组。如：
>>> print map(lambda x , y : (x ** y, x + y), [2,4,6],[3,2,1])
[(8, 5), (16, 6), (6, 7)]
当func函数时None时，这就同zip()函数了，并且zip()开始取代这个了，目的是将多个列表相同位置的元素归并到一个元组。如：
需要注意的是：
map无法处理seq长度不一致、对应位置操作数类型不一致的情况，这两种情况都会报类型错误。如下图：
3、使用map()函数可以实现将其他类型的数转换成list，但是这种转换也是有类型限制的，具体什么类型限制，在以后的学习中慢慢摸索吧。这里给出几个能转换的例子：
***将元组转换成list***
>>> map(int, (1,2,3))
[1, 2, 3]
***将字符串转换成list***
>>> map(int, '1234')
[1, 2, 3, 4]
***提取字典的key，并将结果存放在一个list中***
>>> map(int, {1:2,2:3,3:4})
[1, 2, 3]
***字符串转换成元组，并将结果以列表的形式返回***
>>> map(tuple, 'agdf')
[('a',), ('g',), ('d',), ('f',)]
#将小写转成大写
def u_to_l (s):
return s.upper()
print map(u_to_l,'asdfd')
a=[1,2,3]
b=['a','b','c']
print(list(zip(a,b)))
print(map(str,a))
print(list(map(int,a)))
print(list(map(str,a)))
print(list(map(lambda x:x%2,range(7))))
print(list(map(lambda x:x+1,range(7))))
print(list(x%2 for x in range(7)))
print(list(map(lambda x,y:x**y,[2,2],[2,3])))
# [(1, 'a'), (2, 'b'), (3, 'c')]
# <map object at 0x7ffcd024c4f0>
# [1, 2, 3]
# ['1', '2', '3']
# [0, 1, 0, 1, 0, 1, 0]
# [1, 2, 3, 4, 5, 6, 7]
# [0, 1, 0, 1, 0, 1, 0]
# [4, 8]6.filter
filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个序列，函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新的序列Iterator。
例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：
a=[1,2,3,4,5,6,7]
def check(x):
if(x%2==0):
return 1
else :
return 0
print(filter(check,a))
print(list(filter(check,a)))
# <filter object at 0x7f895824c4f0>
# [2, 4, 6]
import math
def is_sqr(x):
r = int(math.sqrt(x))
return r * r == x
t = filter(is_sqr, range(1, 101))
print(list(t))
#输出结果
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
7..join()函数的运用
这个函数展开来写应该是str.join(item)，join函数是一个字符串操作函数
str表示字符串（字符），item表示一个成员，注意括号里必须只能有一个成员，比如','.join('a','b')这种写法是行不通的
举个例子：
','.join('abc')
join()函数
语法： ‘sep’.join(seq)
参数说明：
sep：分隔符，可以为空。
seq：要连接的元素序列、字符串、元组、字典。
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串。
返回值：返回一个以分隔符sep连接各个元素后生成的字符串。
#对序列进行操作（分别使用' '与':'作为分隔符）
>>> seq1 = ['hello','good','boy','doiido']
>>> print ' '.join(seq1)
hello good boy doiido
>>> print ':'.join(seq1)
hello:good:boy:doiido
#对字符串进行操作
>>> seq2 = "hello good boy doiido"
>>> print ':'.join(seq2)
h:e:l:l:o: :g:o:o:d: :b:o:y: :d:o:i:i:d:o
#对元组进行操作
>>> seq3 = ('hello','good','boy','doiido')
>>> print ':'.join(seq3)
hello:good:boy:doiido
#对字典进行操作
>>> seq4 = {'hello':1,'good':2,'boy':3,'doiido':4}
>>> print ':'.join(seq4)
boy:good:doiido:hello
#合并目录
>>> import os
>>> os.path.join('/hello/','good/boy/','doiido')
'/hello/good/boy/doiido'注意：里面的元素必须是str类型
8.eval函数
eval(str)函数很强大，官方解释为：将字符串str当成有效的表达式来求值并返回计算结果。所以，结合math当成一个计算器很好用。
eval()函数常见作用有：
1、计算字符串中有效的表达式，并返回结果
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> eval("n + 4")
85
2、将字符串转成相应的对象（如list、tuple、dict和string之间的转换）
>>> a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
>>> b = eval(a)
>>> b
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
>>> a = "{1:'xx',2:'yy'}"
>>> c = eval(a)
>>> c
{1: 'xx', 2: 'yy'}
>>> a = "(1,2,3,4)"
>>> d = eval(a)
>>> d
(1, 2, 3, 4)
10.set
首先我们需要知道什么可以作为集合的元素。集合对象是一组无序排列***可哈希***的值，集合成员可以做字典中的键。那么可哈希与不可哈希是什么意思呢？
简要的说可哈希的数据类型，即不可变的数据结构(字符串str、元组tuple、对象集objects)；同理，不可哈希的数据类型，即可变的数据结构 (集合set，列表list，字典dict)
Python面向对象静态方法，类方法，属性方法
属性：
公有属性 （属于类，每个类一份）
普通属性 （属于对象，每个对象一份）
私有属性 （属于对象，跟普通属性相似，只是不能通过对象直接访问）
方法：（按作用）
构造方法
析构函数
方法：（按类型）
普通方法
私有方法（方法前面加两个下划线）
静态方法
类方法
属性方法
静态方法
@staticmethod
静态方法，通过类直接调用，不需要创建对象，不会隐式传递self
class Dog(object):
@staticmethod
def run():
# 不需要访问类属性和实例属性的方法，就可以定义一个静态方法
print("跳着跑")
def __init__(self, name):
self.name = name
def bark(self):
pass
# 通过 类名. 调用静态方法，不需要创建对象
Dog.run()
类方法
@classmethod
类方法，方法中的self是类本身，调用方法时传的值也必须是类的公有属性，
就是说类方法只能操作类本身的公有字段
class Plant(object):
# 使用赋值语句定义类属性，记录所有植物对象的数量
count = 0
# 定义一个类方法
@classmethod
def show_count(cls):
print("目前已养植物种类数量：", Plant.count)
def __init__(self, name):
self.name = name
Plant.count += 1
duorou = Plant("多肉")
luhui = Plant("芦荟")
# 调用类方法
Plant.show_count() # 目前已养植物种类数量： 2
10 yield 和 return 对比分析
相同点：都是返回函数执行的结果
不同点：return 在返回结果后结束函数的运行，而yield 则是让函数变成一个生成器，生成器每次产生一个值（yield语句），函数被冻结，被唤醒后再产生一个值
例子：求一组数的平方值
return 实现：
def squre(n):
ls = [i*i for i in range(n)]
return ls
for i in squre(5):
print(i, end=' ')
0 1 4 9 16
yield 实现：
def squre(n):
for i in range(n):
yield i*i
for i in squre(5):
print(i, end=' ')
yield 生成器相比 return一次返回所有结果的优势：
（1）反应更迅速
（2）更节省空间
（3）使用更灵活
11.__iter__ 和 __next__
__iter__和__next__
iter()函数主要映射类中__iter__函数
next()函数主要映射类中__next__函数
class MyRange(object):
def __init__(self, end):
self.start = 0
self.end = end
def __iter__(self):
return self
def __next__(self):
if self.start < self.end:
ret = self.start
self.start += 1
return ret
else:
raise StopIteration
m = MyRange(5)
modify(m) # Iterable, Iterator
# 利用for语句迭代元素，会捕获StopIteration异常并自动结束for
for i in m:
print(i)
# 利用next()函数迭代元素
print(next(a))
print(next(a))
print(next(a))
print(next(a))
print(next(a))
print(next(a)) # 其实到这里已经完成了，我们在运行一次查看异常
12.and or
print(2 and 3)
print(2 or 3)
print(2 and 3 or 4)
print(2 and 3 and 4)
print(2 or 3 or 4)
# 3
# 2
# 3
# 4
# 213.
1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict 都是可以通过 for--in--进行遍历的
14.
1 字符串统一大小写方法
title方法，将字符串中相分割的单词首字母大写，其余小写。
upper方法
upper方法，将字符串中所有字母大写。
lowe方法
lowe方法，将字符串中所有字母小写。
2 字符串替换方法
replace方法
replace方法，替换字符串中内容，并返回新的一个字符串对象。
再Python中字符串属于不可变对象，不能在原位修改，所以replace方法，相当于先替换原字符串部分内容，然后返回替换后的一个新的字符串对象。
语法：r_str = string.replace(__old=str,__new=str,__count= int) 参数含义：old：被替换的内容，new：替换内容，count：替换次数，默认全部替换。
你可以试着自己写一个函数来实现字符串替换的功能？
split与join方法，字符串的分割与组合。
split,将字符串按特定字符进行切割返回一个列表对象，如下，按空格切割字符串：
join方法
join方法，用特定字符串来连接列表中的字符串
注意：列表中的对象需全部为字符串类型
split ，join方法的组合使用
利用join，split方法来实现特定格式字符串的传输。如网络通讯时只能传输字符串，不支持列表等形式内容，但又要保持数据的特定结构，就可以用以下方式来对信息进行处理。
如：有一个如下列表信息，需要将其转化为具有特定结构字符串：
先用对内层列表内容进行字符串转化，用‘?’连接
4 清除字符串空格方法
当读取文本字符串内容，或者从gui页面获取字符串数据时，字符串首尾可能会出现空格。而这些空格对后期数据处理可能会造成一些麻烦，此时就可以用rstrip，lstrip，strip方法来去除。
rstrip 去除右侧空格（末尾空格）。
lstrip方法
lstrip 去除左侧空格（前端空格）。
strip方法
strip 去除两侧空格（首位空格）
str_a = 'abC deF'
print(str_a.title())
# ------运行结果------
# Abc Def
# ------运行结果------
print(str_a.upper())
# ------运行结果------
# ABC DEF
# ------运行结果------
print(str_a.lower())
# ------运行结果------
# abc def
# ------运行结果------
str_b = '杰伦最帅，杰伦新歌什么时候出来？'
replace_all = str_b.replace('杰伦','周杰伦')
print(replace_all)
# ------运行结果------
# 周杰伦最帅，周杰伦新歌什么时候出来？
# ------运行结果------
replace_one = str_b.replace('杰伦','周杰伦',1)
print(replace_one)
# ------运行结果------
# 周杰伦最帅，杰伦新歌什么时候出来？
# ------运行结果------
str_c = '我 是 一 个 字 符 串'
list_a = str_c.split(' ')
print(list_a)
# ------运行结果------
# ['我', '是', '一', '个', '字', '符', '串']
# ------运行结果------
str_d = ' '.join(list_a)
print(str_d)
# ------运行结果------
# 我 是 一 个 字 符 串
# ------运行结果------
list_c = [['大明', '22', '编程'], ['大李', '23', '吃饭']]
# 列表转为字符串
message_c = '#'.join(['?'.join(t) for t in list_c])
print(message_c)
# ------运行结果------
# 大明?22?编程#大李?23?吃饭
# ------运行结果------
# 字符串转化为列表
message_list_c = [m.split('?') for m in message_c.split('#')]
print(message_list_c)
# ------运行结果------
# [['大明', '22', '编程'], ['大李', '23', '吃饭']]
# ------运行结果------
str_e = ' abc def '
str_e.rstrip()
str_e.lstrip()
str_e.strip()
16.
python 短路求值或惰性求值
总体解释
首先，‘and’、‘or’和‘not’的优先级是not>and>or。
其次，逻辑操作符and 和or 也称作短路操作符(short-circuitlogic)或者惰性求值(lazy evaluation)：它们的参数从左向右解析，一旦结果可以确定就停止。例如，如果A 和C 为真而B 为假， A and B and C 不会解析C 。作用于一个普通的非逻辑值时，短路操作符的返回值通常是最后一个变量。因此，逻辑运算符的理解也与C语言中不同。举个例子：
输出内容：
在以上例子中，按照C语言对的思维，3 and 4即3与4为3，但是由于是短路操作符，结果为4，是因为and运算符必须所有的运算数都是true才会把所有的运算数都解析，并且返回最后一个变量，即为4；改变一下顺序4 and 3 ，结果也不一样，即为3
而或逻辑(or)，即只要有一个是true，即停止解析运算数，返回最近为true的变量，即 3 or 4，值为3；改变顺序4 or 3 即为4
个人理解
赋值变量为非布尔型时，进行判断永远返回真，所以and时，由于两个值都是true，则返回末尾的值，or 时，由于第一个已经是true了，所以第二个将不再继续判断。
17/Python导入模块的3种方式
导入模块方式一：临时添加模块完整路径
模块文件的存储位置，可以临时添加到 sys.path 变量中，即向 sys.path 中添加 D:\python_module（hello.py 所在目录），在 say.py 中的开头位置添加如下代码：
import sys
sys.path.append('D:\\python_module')
导入模块方式二：将模块保存到指定位置
如果要安装某些通用性模块，比如复数功能支持的模块、矩阵计算支持的模块、图形界面支持的模块等，这些都属于对 Python 本身进行扩展的模块，这种模块应该直接安装在 Python 内部，以便被所有程序共享，此时就可借助于 Python 默认的模块加载路径。
[
'C:\\Users\\shaobing\\Desktop',
'D:\\python3.6\\Lib\\idlelib',
'D:\\python3.6\\python36.zip',
'D:\\python3.6\\DLLs',
'D:\\python3.6\\lib',
'D:\\python3.6', 'C:\\Users\\shaobing\\AppData\\Roaming\\Python\\Python36\\site-packages',
'D:\\python3.6\\lib\\site-packages',
'D:\\python3.6\\lib\\site-packages\\win32',
'D:\\python3.6\\lib\\site-packages\\win32\\lib',
'D:\\python3.6\\lib\\site-packages\\Pythonwin'
]
上面的运行结果中，列出的所有路径都是 Python 默认的模块加载路径，但通常来说，我们默认将 Python 的扩展模块添加在 lib\site-packages 路径下，它专门用于存放 Python 的扩展模块和包。
所以，我们可以直接将我们已编写好的 hello.py 文件添加到 lib\site-packages 路径下，就相当于为 Python 扩展了一个 hello 模块，这样任何 Python 程序都可使用该模块。
移动工作完成之后，再次运行 say.py 文件，可以看到成功运行的结果：
Hello,World!
导入模块方式三：设置环境变量
PYTHONPATH 环境变量（简称 path 变量）的值是很多路径组成的集合，Python 解释器会按照 path 包含的路径进行一次搜索，直到找到指定要加载的模块。当然，如果最终依旧没有找到，则 Python 就报 ModuleNotFoundError 异常。
由于不同平台，设置 path 环境变量的设置流程不尽相同，因此接下来就使用最多的 Windows、Linux、Mac OS X 这 3 个平台，给读者介绍如何设置 path 环境变量。
19.列表推导式和生成器表达式
列表推导式
- 例一：30以内所有能被3整除的数
print([i for i in range(0,31) if i%3 == 0])- 例二：30以内所有能被3整除的数的平方
print([i*i for i in range(30) if i % 3 == 0])-
例三：找到嵌套列表中名字含有两个‘e’的所有名字
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
print([name for lst in names for name in lst if name.count('e') >= 2])
练习题
例1: 过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母
例2: 求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表
例3: 求M中3,6,9组成的列表M = [[1,2,3],[4,5,6],[7,8,9]]
1.[name.upper() for name in names if len(name)>3] 2.[(x,y) for x in range(5) if x%2==0 for y in range(5) if y %2==1] 3. [row[2] for row in M]
生成器表达式
1.把列表推导式中的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数也是使用迭代器协议访问对象的。
例如：sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和。
sum(x ** 2 for x in range(4))
1 可迭代对象
Python中，列表、元组、字典、集合、字符串等类型的数据可以使用for ..in...的语法从其中依次取到数据来使用，这样的过程称为遍历，也叫迭代。
可迭代对象：可以通过for ..in...这类语句迭代读取一条数据给用户使用的对象。
下面是一段列表的迭代示例代码：
>>> list1 = [1, 2, 3]
>>> for n in list1:
... print(n)
...
1
2
3
>>> dict1 = {'one':1, 'two':2, 'three':3}
>>> for key in dict1.keys():
... print(key)
...
one
two
three
2 判断对象是否为可迭代的
使用isinstance判断一个对象是否为可迭代对象（Iterable）
示例代码如下：
from collections import Iterable
>>> isinstance([1,2,3], Iterable) # 列表为可迭代对象
True
>>> isinstance({1,2,3}, Iterable) # 集合为可迭代对象
True
>>> isinstance(100, Iterable)
False
3 可迭代对象的本质
分析迭代的过程，可发现：每迭代一次（即在for…in…中每循环一次），都会返回对象中的下一条数据，一直向后读取，直到迭代完全部数据才结束。
在迭代过程中，应该有一个“记录员”去记录每次访问到第几条数据，以便每次迭代都可以返回下一条数据。Python将这个“记录员”称为迭代器。可迭代对象的本质是：这个对象提供给用户一个迭代器，来帮助用户在遍历对象时使用。
可迭代对象通过__iter__方法通过给我们一个迭代器。当用户在迭代一个可迭代对象时，实际上就是先获取该对象提供的迭代器，然后通过这个迭代器来一次获取对象中的每一个数据。
具备__iter__方法的对象，就是一个可迭代对象。
4 iter()与next()
对于可迭代对象，可以使用iter()函数得到这些可迭代对象的迭代器，然后对迭代器使用next()函数来获取下一条数据。（iter()函数调用了可迭代对象的__iter__方法）
在使用next()迭代完最后一个元素后，再次调用next就会抛出StopIteration异常，以此来告诉我们所有元素均迭代完成。
2131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
