函数之迭代器...

标签：简单   进入   字典   lis   raise   ret   生成   有一个   优点   

迭代器

迭代器：迭代的工具。

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

• 可迭代对象：

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

总结：

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

• 迭代器对象

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

总结：

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

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

可迭代对象: 拥有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:

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

yield和return:

1. 相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制
2. 不同点：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()

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

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

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

函数之迭代器...

标签：简单   进入   字典   lis   raise   ret   生成   有一个   优点   

原文地址：https://www.cnblogs.com/gongjingyun123--/p/10969901.html