函数之迭代器...

2019-06-03 20:53:13 阅读：150 来源： 互联网

迭代器

迭代器：迭代的工具。

迭代也可以说是重复，每一次的结果都是基于上一次的结果来的。

可迭代对象：

height=180
salary=3.2
name='nick'
hobby_list=['run','read']
bobby_tup=('run','read')
info_dict={'name':'nick','weight':140}
hobby_set={'read','run',}
文件f

总结：

只要拥有_ _ iter_ _方法的对象就是可迭代对象
python内置字符串/列表/元祖/字典/集合/文件都是可迭代对象

迭代器对象

height.__iter__
salary.__iter__
func.__iter__
name.__iter__()
hobby_list.__iter__()
hobby_set.__iter__()
hobby_tup.__iter__()
info_dict.__iter__()
f.__iter__()

总结：

迭代器对象:执行可迭代对象的__iter__方法,拿到的返回值就是迭代器对象。

内置有__next__方法
文件本身就是迭代器对象

可迭代对象: 拥有iter方法的对象就是可迭代对象,推导:可迭代对象不一定是迭代器对象
迭代器对象: 拥有iter方法和next方法的就是迭代器对象,推导: 迭代器对象一定是可迭代对象,又是迭代器对象

for循环原理

for循环称为迭代器循环，in后必须是可迭代的对象。

二、三元表达式（三目表达式）

条件成立时的返回值if条件else条件不成立时的返回值。

dog_name='xiaogou'
if dog_name=='fenggou'
    print('远离他')
else:
    print('盘')
------------------------>>
print('远离他') if dog_name=='fenggou'else  print('盘他'）

不推荐使用，写程序的易懂，变得简单

三、列表推导式

lis=[]
for i in range(100):
    lis.append(i)
print(lis)
lis = [i*2 for i in range(100)]
print(lis)
lis1 = [i * 2 if i > 50 else i for i in range(100)]
print(lis1)

四、字典生成式

dic=dict.fromkeys([1,2,3,4],2)
print(dic)
#  {1: 2, 2: 2, 3: 2, 4: 2}
dic={i:i**2 for i in range(10)}
for i in dic.items():
    print(i)
##(0, 0)
  (1, 1)
  (2, 4)
  (3, 9)
  (4, 16)
  (5, 25)
  (6, 36)
  (7, 49)
  (8, 64)
  (9, 81)

拉链函数 zip()方法，通过解压缩函数生成一个字典。

res=zip('abcd',[1,2,3,4])
dic=dict()
for k,v in res
    dic[k]=v
print(dic)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
print({k:v for k,v in zip('abcd',[1,2,3,4])})
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

五、生成器：自定义的迭代器

生成器提供了非常方便的自定义迭代器的途径。

yield关键字：接收值，但不会结束函数，而是继续运行下一个代码

def func():
    pass

def func():
    print('from 1')
    yield
    print('from 2')
    yield
#func调用之后变成一个迭代器，yield默认返回none
g=func()
print(g.__next__())
print(g.__next__())
g.__next__()
for i in g:
    print(i)

def func():
    print('from 1')
    yield 1,2
    print('from 2')
    yield['a',1,2],2
g=func()
for k,v in g:
    print(k,v)
    -------------->
    from 1
    1 2
    from 2
    ['a', 1, 2] 2
#yield：接收值，但是不会结束函数，然后继续下一行代码，直到return
#return：返回值，直到结束函数，其他的特性和yield一摸一呀

range(1,10)
print([i for i in range(10)])
---------->
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(range(10).__iter__().next__())
---------->
0

def range(end,start=0,step=1):
    end,start=start,end
    count=start
    while count<end:
        yield count
        count+=step
g=range(1,10)
def range(*args,**kwargs)
    start=0
    step=1
    if len(args)==1:
        end=args[0]
        #arg=(10,)
    elif len(args)==2:
        #arg=(1,10)
        start=arg[0]
        end=args[1]
    elif len(args)==3:
        start=args[0]
        end=args[1]
        step=args[2]
    else:
        raise('传多值了')
    count=start
    while count<end
    yield count
    count+=step
print(list(range(2,10,3)))
------------>
[2,5,8]

tup=(i for i in range(10))
print(tup.__next__())
for i in tup
    print(i)
lis=[i for i in range(10)]
print(lis)

总结：

yield:

提供一种自定义迭代器的方式
yield可以暂停住函数，并提供当前的返回值

yield和return:

相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制
不同点：return只能返回一次之；yield可以返回多次值

生成器表达式
1. 把列表推倒式的[]换成()就是生成器表达式
2. 优点：省内存，一次只产生一个值在内存中

六、递归

def f2()；
    print（'from f2')

==递归：函数调用函数自己，类似于循环，但是这个循环必须得有结束条件==

直接调用：直接在函数内部调用函数自身
间接调用：不在原函数体内调用函数，而是通过其他的方法间接调用函数自身

def guess_age(age,count)
    age-=2
    count-=1
    if count==1
        print(age)
        return
    guess_age(age,count)
    


guess_age(38,5)
def guess-age(count):
    count-=1
    if count==1:
        print(age)
        return 26
    return guess_age(count)+2
res=guess_age(5)
print(res)

r()

递归必须要有两个明确的阶段：

递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小
回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯。

递归的精髓在于通过不断地重复逼近一个最终的结果。

标签：__,...,.__,函数,迭代,iter,yield,print
来源： https://www.cnblogs.com/gongjingyun123--/p/10969901.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9