例子
#for x in [1,2,3]: #列表 # print(x) #for x in (1,2,3): #元组 # print(x)
文件本身也是个可迭代的对象：
创建一个new file：data.txt在里面写入
优品课堂学编程 好心情www.codeclassroom.comwww.youpinketang.comwww.uke.cc
再在main.py里写入
f = open('data.txt',encoding='utf8')
for line in f: #for line在刚才的f里
print(line, end=' ') #遍历出来结果的行，结尾用空格结束
1、迭代协议：_next_()
_next_()不是暴露出来给客户调用，可以获取下一个元素，就是一行一行读 next：所占内存空间不变的情况，如果想获得数据，移到下一项，移动指针用的
pyhon console里写入
f = open('data.txt',encoding='utf8')f.__next__()
'优品课堂\n'
典型支持迭代协议对象
>>> f = open('data.txt',encoding='utf8')
>>> next(f)
'优品课堂\n'
>>> next(f)
'学编程 好心情\n'
>>> next(f)
'www.codeclassroom.com\n'
>>>f = open ('data.txt',encoding='utf8')
>>> for x in f.readlines(): #返回一个列表，把所有行找到放到list里，不写ReadLines好，数据大不支持还是用for...open更好不占太多内存
... print(x)
...
优品课堂
学编程 好心情
www.codeclassroom.com
www.youpinketang.com
www.uke.cc
调用全局函数直接写next
列表：可迭代的对象
>>> urls = ['youpinketang.com','uke.cc','codeclassroom.com'] >>> for url in urls: ... print(url) ... youpinketang.com uke.cc codeclassroom.com
2、迭代工具for...推导...map...
（1）迭代对象
（2）可迭代对象
f = open('data.txt',encoding='utf8')
f.__next__()
'优品课堂\n'
for i in [1,2,3]:
print(i)
1
2
3
f = open('data.txt',encoding='utf8')
for line in f:
print(line)
优品课堂
学编程 好心情
www.codeclassroom.com
www.youpinketang.com
www.uke.cc
结果一样差别在于f本身具备next方法，但是列表没有
iter(f) is f#iter全局函数包起来f判断一下f是不是应用了迭代器功能，返回true证明使用next方法 True
>>> f = open('data.txt',encoding='utf8')
>>> iter(f) is f #iter全局函数包起来f判断一下f是不是应用了迭代器功能，返回true证明使用next方法
True
True
>>> f.__next__()
'优品课堂\n'
>>> next(f)#把f传进去本质同上
'学编程 好心情\n'
列表：不具有上面的功能，套一个进去就可以用了
>>> iter(urls) is urls #判断列表是否本身有迭代器，发现不是 False >>> i = iter(urls)#所以没有next，用for实现,或迭代器等于urls把刚才的传进去 >>> i.__next__() 'youpinketang.com'
>>> next(i)
'uke.cc'
手动迭代，返回一个列表中所有元素，要平方值
法1使用for 次啰嗦
>>> l = [1,2,3] >>> res = [] #做个空列表 >>> for x in l: ... res.append(x**2) #装列表的最加x平方项 ... >>> res [1, 4, 9]
法2手动实现不用for 最啰嗦
>>> i = iter(l) #iter全局的方法把列表加进去 >>> while True: ... try: ... ... x = res.append(next(i) ** 2) # i里取个值放入res里,追加 ... ... except StopIteration: # 捕获异常跳出循环 ... ... break >>> res [1, 4, 9, 1, 4, 9]
法3实际开发，手推导 推荐使用
result = [x**2 for x in l] result [1, 4, 9]
字典表
用for找元素
>>> emp = {'name':'Tom','age':20,'job':'dev','salary':8000.00}
>>> for k,v in emp.items():
...
... print(k,v)
...
name Tom
age 20
job dev
salary 8000.0
>>> emp.items()#看items类型,发现不是列表虽然很像
dict_items([('name', 'Tom'), ('age', 20), ('job', 'dev'), ('salary', 8000.0)])
>>> for k in emp:
...
... print(k)
...
name
age
job
salary
>>> emp.keys()#看所有键
dict_keys(['name', 'age', 'job', 'salary'])
>>> emp.values()#也不是列表
dict_values(['Tom', 20, 'dev', 8000.0])
不用for找挨个元素
>>> keys = emp.keys()#先声明一个keys,看类型 >>> keys dict_keys(['name', 'age', 'job', 'salary']) >>> iter(keys) is keys#看是keys本身吗false不包含next方法 False >>> i = iter(keys) >>> i.__next__() 'name' >>> i.__next__() 'age' >>> i.__next__() 'job' >>> i.__next__() 'salary'
可迭代都可放入推导表达式内，推导的基础：前半截是返回的结果，中间是过滤的过程，后面if是过滤的条件：res4 = [url for url in urls if url.endswith('.com')]#过滤,地址包含.com
>>> l = [1,2,3,4,5]
>>> res1 = [x for x in l]#在l遍历，每个元素放稳定变量x，取x本身放入x,[]表示返回列表
>>> type(res1)
<class 'list'>
>>> res1
[1, 2, 3, 4, 5]
>>> res2 = [x+10 for x in l] #列表找单个数把数字每个加10
>>> res2
[11, 12, 13, 14, 15]
>>> urls = ['youpinketang.com','uke.cc','codeclassroom.com']
>>> res3 = [url.upper() for url in urls]#变大写
>>> res3
['YOUPINKETANG.COM', 'UKE.CC', 'CODECLASSROOM.COM']
>>> res4 = [url for url in urls if url.endswith('.com')]#过滤,地址包含.com
>>> res4
['youpinketang.com', 'codeclassroom.com']
法2 繁琐
>>> res5 = []
>>> for x in urls:
...
... if x.endswith('.com'):
...
... res5.append(x)
...
>>> res5
['youpinketang.com', 'codeclassroom.com']
3、内置可迭代对象 range()生成序列，它不是列表虽然和列表很像
>>> range(50) range(0, 50) >>> r = range(1,20)#1-20序列 >>> type(r) <class 'range'> >>> for x in range(1,11): ... print(x) ... 1 2 3 4 5 6 7 8 9 10 >>> result = [x**2 for x in range(1,6)]#1-5平方值算出 >>> result [1, 4, 9, 16, 25]
可迭代对象 ：1自己实现next方法 2 没有
range用法：
测试
>>> r = range(1,6) >>> iter(r) is r #r生成的迭代器是它本身吗 False
不允许
>>> r = range(1,6) >>> iter(r) is r False >>> i = iter(r) #r自动生成next方法 >>> i.__next__() 1 >>> next(i)#也可用全局的方法 2
zip用法：将连个集合合成一个，本质也是可迭代对象
>>> result = zip(['x','y','z'],[1,2,3]) #xyz调用123
>>> result
<zip object at 0x000000000358C188>
>>> for x in result:#遍历
...
... print(x) #结果变成元组
...
('x', 1)
('y', 2)
('z', 3)
map用法：main.py 把一个数字乘以2
def double_number(x):
return x * 2
l = [1,2,3,4,5]
result = list(map(double_number,l) ) #把l列表的每一个元素都应用函数double nmber，map是挨个传播
print(result)
函数：
1目的：最大化代码重用dry不用重复自己
最小化代码冗余
过程分解
2定义：def函数名（参数1,...）:函数体
如计算两数相乘
def multiply(x, y): return x * y
3调用：函数名（实际参数）
def multiply(x, y):
return x * y
print(multiply(3.14,5))
试试字符串能否相乘，发现可以：字符串的特性
print(multiply('优品课堂',5))
模拟看书过程：封装执行语句形成命令
def read_book():#重复利用（）表面执行操作
print('拿到一本书')#逻辑
print('看书')
print('收起')
read_book()#调用函数
#接收参数传递信息
def learning():
print('报名')
print('学习')
print('退出')
learning()
细化信息：通过参数形式列举
#接收参数传递信息
def learning(name, course, start, end):#需要给相应的参数，形式参数
print('{}报名课程:《{}》'.format(name,course))#格式化字符串
print('从第{}节学习到第{}节.format(start, end)')
print('{}学习结束.format(name)')
learning('Tom','Python入门',1,3)#实际应用，实际参数
可以从外面向里面传递信息，也可以从里面向外面传递信息
#learning('Tom','Python入门',1,3)#实际应用
def add_number(x,y): #计算两个数据和，add添加数字
result = x + y #先声明一个result
return result #返回一个值给调用者
#print(add_number(5,3))
a = 10
result = a + add_number(5,3)
print(result)
假定两个序列找重复序列
def intersect(seq1, seq2): #两个序列以为是列表
res = []#放入空列表
for x in seq1: #找第一个序列元素放x里，声明参数是在本地定义一个变量
if x in seq2: #如果第二个也有也放进去
res.append(x) #放入空列表里
return res
s1 = 'uke.cc'
s2 = 'youpinketang.com'
l = intersect(s1, s2)#放入一个新结果
print(l)#打印看有哪些
换
s1 = 'abcdefg'
实际开发方便用推导
4变量作用域
（1）Global全局:global
（2）local本地
x = 55
def func():#定义函数，函数里定义的作用的范围是它里面的属于本地的（local）
x = 99 #赋值99
print(x)
print('全局x:',x)
print('函数内x:')#函数内x为多少
func()# func是执行逻辑
全局55 内99
如果想用全局的加个global
x = 55
def func():#定义函数
global x
x = 99 #x为外部的
print(x)
print('全局x:',x)
print('函数内x:')#函数内x为多少
func()# func是执行逻辑
print('全局x:',x)
第一次：函数没执行是55，第二次x是外部的了，把x给改了打印的是99，第三次x已经改变所以为99
（3）built-in:作用最范围广
（4）enclousure封装 ：nonlocal
函数套函数：逻辑是先定义再调用
def func():#定义函数
x = 100#第二次打印的是外侧x，外层x称之为封装
def nested():#嵌套
x = 99
print(x)
nested()#调用，第一次执行的是它
print(x)
func()#func执行，自带print
有时候也想用外侧的，可写声明nonlocal 非本地的
def func():#定义函数
x = 100#第二次打印的是外侧x，外层x称之为封装
def nested():#嵌套
nonlocal x #非本地的
x = 99
print(x)
nested()#调用，第一次执行的是它
print(x)
func()#func执行，自带print
5参数
改变数字
def change_numer(x):#默认情况下参数定义没有写类型
x += 10
x = 5 #传x为5整型不可改变
print('x={}'.format(x))#第一次打印x
change_numer(x) #执行改变操作
print('x={}'.format(x))#第二次再打x
改变列表
def change_list(l):
l[0] = 99#传递过来的列表第一个元素标记为99
l = ['uke.cc','codeclassroom.com','youpinketang.com']
print('原始列表：',l)
change_list(l)
print('操作后列表：',l)
改变字符串
def change_str(s):
s = 'uke.cc'
url = 'youpinketang.com'
print(url)
change_str(url)
print(url)
规律：参数 传递 不可变类型，传递副本给函数，函数内操作不影响原始值（int，float，str，tuple）
可变类型，传递地址引用，函数内操作可能会影响原始值（列表，字典表）
不变类型直接操作值，而列表只是个引用，改变了会影响它的值。