三元表达式 ,迭代器, 生成器,二分法

三元表达式

# x if x > y else y
##如果x大于y,值返回左边,不然则返回右边
#用一行代码表达一个函数需要做的事情,使代码更简洁

# 例1,
# res=‘x‘ if True else ‘y‘
# print(res)

迭代器

# 1. 什么是迭代器
# 什么是迭代?
# 迭代是一个重复的过程,但是每次重复都是基于上一次重复的结果而继续
#下列循环知识单纯的重复
# while True: #while循环取值,是单纯的重复。迭代取得是基于上一次取下一次的值
# print(1)
# 基于索引的迭代取值 #基于索引的方式可取值的对象不包括数字
#字符串,列表,字典
#例1,
# l=[‘a‘,‘b‘,‘c‘]
# i=0
# while i < len(l):
# print(l[i])
# i+=1

# 什么是迭代器?
# 迭代取值的工具

# 2. 为什么要用迭代器
# 优点
# 1. 提供一种不依赖索引的迭代取值方式 #比如,元组,列表都是不基于索引取值
# 2.占用内存小,迭代下一次的时候上一次的迭代的内容被回收(这也是缺点,无法索引取值)
# 缺点
# 1,不如按照索引取值的内容灵活
# 2,取值一次性的,只能往后取,且无法预测取值的格式
# 3. 如何用迭代器
# 可迭代的对象:str\list\tuple\dict\set\文件对象 (除了整形)
# 但凡内置有__iter__方法的对象都称之为可迭代对象
#例2,
# a=‘str‘ #a除了整形都可以使用__iter__内置方法
# a.__iter__()

# 迭代器对象: 文件对象
# 既内置有__iter__方法又内置有__next__方法的对象都称之为迭代器对象
# 调用可迭代对象下__iter__方法,会有一个返回值,该返回值就是内置的迭代器对象
#例3,
# a=[1,2,3,4]
# a_1=a.__iter__()
# a_1.__next__()
# 例4,
# iter(d)=d.__iter__
# next(d)=d.__next__
# len(d)=d.__len__

‘‘‘
# d={‘k1‘:111,‘k2‘:222,‘k3‘:333}
# iter_d=d.__iter__()
# # print(iter_d)
#
# try: #ry方法,可以捕捉异常(报错文件)
# print(iter_d.__next__()) #输出第一次迭代的内容
# print(iter_d.__next__()) #输出基于上一次迭代的内容
# print(iter_d.__next__())
# print(iter_d.__next__()) #如果迭代内容为空(迭代完了),再次迭代则报错
# except StopIteration: #对应try,如果报错内容为StopIteration,输出下一行代码,
#即隐藏了报错内容,使代码得已继续运行
# print(‘取值完毕‘) #报错时执行的代码

‘‘‘
‘‘‘
# for循环的底层原理
d={‘k1‘:111,‘k2‘:222,‘k3‘:333}

iter_d=d.__iter__() #赋值迭代对象
while True: #while循环迭代内容
try: #捕捉并处理报错内容的代码
v=iter_d.__next__() #产生迭代内容
print(v)
except StopIteration: #处理报错(迭代内容超过迭代对象的内容报错的情况)
break #报错时执行的内容(结束循环)
‘‘‘

# for k in d:
# print(k)
#for循环的底层原理:
# 1. 调用in后面那个值/对象的__iter__方法,拿到一个迭代器对象iter_obj
#如果对象不能迭代,则报错。比如数字类型
# 2. 调用迭代器对象iter_obj.__next__()将得到的返回值赋值变量名k,
# 循环往复直到取值完毕抛出异常StopIteration
# 3. 捕捉异常结束循环

生成器

生成器就是一种自定义的迭代器

如何得到生成器?
但凡函数内出现yield关键字,再去调用函数不会立即执行函数体代码,
会得到一个返回值,该返回值就是生成器对象,即自定义的迭代器
‘‘‘

# def func():
# print(‘first‘)
# yield 1 #yield与return的区别
# # yield运行到此处会暂停,return代表函数结束
# print(‘second‘)
# yield 2
# print(‘third‘)
# yield 3
#
#
# g=func() # g对应的就是一个生成器
# # print(g)
# #
# res1=next(g) #生成器开始运行,第一次迭代的结果就是yield 返回的内容,同时之前的代码也会运行
# print(res1)
# #
# res2=next(g) #生成器第二次迭代
# print(res2)
#
# res3=next(g) #生成器第三次迭代
# print(res3)
#
# next(g)

# 总结yield:
# 1. 提供一种自定义迭代器的解决方案
# 2. yield & return
# 相同点: 都可以返回值,返回值没有类型限制\个数限制
# 不同点: return只能返回一次值,yield却可以让函数暂停在某一个位置,可以返回多次值

# 小练习
# 实现与range一样的功能,开头结尾和步长
# def my_range(start,stop,step=1):
# while start < stop:
# yield start
# start+=step

二分法

# 二分法是算法的一种;算法是将问题简单化的一种解决方法。
#
# 二分法的应用场景很局限:当我们有一个有序的序列:从小到大或从大到小;我们需要查找一个数是否在这个序列中,就可以运用二分法去解决问题。
#
# 二分法模拟成员运算in

‘‘‘
nums = [1, 13, 15, 23, 27, 31, 33, 57, 73, 81, 93, 94, 97, 101] # 从小到大排列的数字列表
def binary_search(find_num,nums):
print(nums)
if len(nums) == 0:
print(‘False‘)
return
# 功能
mid_index = len(nums) // 2
if find_num > nums[mid_index]:
# in the right
nums=nums[mid_index+1:] #nums[x:] 删除第x列之前的内容
# 重新运行功能,传入新列表
binary_search(find_num,nums)
elif find_num < nums[mid_index]:
# in the left
nums=nums[:mid_index]
# 重新运行功能,传入新列表
binary_search(find_num,nums)
else:
print(‘True‘)
‘‘‘

原文地址:https://www.cnblogs.com/wang-kai-1994/p/10059857.html

时间: 2024-11-05 18:52:20

三元表达式 ,迭代器, 生成器,二分法的相关文章

Day 21 三元表达式、生成器函数、列表解析

知识点程序: 1 #! /usr/bin/env python 2 # -*- coding: utf-8 -*- 3 # __author__ = "DaChao" 4 # Date: 2017/6/16 5 6 l = [i for i in range(100) if i%2 > 0] 7 print(l) 8 9 ########################### 10 #生成器 generator!!! 模拟tail grep功能 11 ##############

函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数def max(x,y): if x>y: return x else: return ydef max1(a,b,c,d): res=max(a,b) res2=max(res,c) res3=ma

python学习笔记第九节(迭代器,生成器,三元表达式)

for循环相当于自动调动__iter__ for循环相当于上面这样每次__next__再打印一次 while循环的迭代方式,采用try的方式 判断是否为可迭代 判断是否为迭代器对象 加了蓝色段,可以调用原来的函数名 迭代对象 可以__iter__的迭代器 将__iter__之后的结果的迭代器对象 可以直接__next__的 生成器 迭代到yield后停止,相当于__next__函数加上yield后就是迭代器.可以每次__next__显示,每次显示到yield后停止,相当于return,但是下次_

函数---迭代器&amp;生成器&amp;列表解析&amp;三元表达式

可迭代对象:obj.__iter__ 迭代器:iter1=obj.__iter() 1iter1.__next__ 2iter2.__next__ 迭代器: 优点:不依赖索引 惰性计算,节省内存 缺点: 不如按照索引的取值方便 一次性,只能往后取,不能回退 迭代器的应用: 提供了一种不依赖索引的统一的迭代方法 惰性计算,比如取文件的每一行 判断可是否是可迭代对象和迭代器 from collections import Iterable, Iterator # 导入模块功能 isinstance(

python_day04 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式

本节课重要知识点内容如下: 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式 1.函数嵌套 函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数 def bar(): print('from nbar')def foo(): print('from foo') bar()foo()def max2(x,y): if x > y: return x else: return ydef max4(a,

python迭代器、生成器及三元表达式

(1)迭代器协议 字符串.元组.列表.字典.集合.文件对象这些都不是可迭代对象,只不过在for循环中,调用了他们内部的__iter__方法,把他们变成了可迭代对象 然后for循环调用可迭代对象的的__next__方法去取值,而且for循环会捕捉StopIateration异常,以终止迭代 x='hello'for i in x: print(i) for循环相当于: x='hello' iter_test=x.__iter__() print(iter_test) print(iter_test

迭代器|三元表达式|生成器

import numpy as np '''迭代:每次获得的结果都基于上次结果来的(更新换代)迭代器协议:对象必须提供一个next方法 ,执行该方法,要么返回迭代器的下一项,要么引起异常迭代对象(节省内存):实现迭代器协议的对象(内部:__iter__()方法) for循环的本质:循环所有对象,全部使用迭代器协议for循环可以遍历(序列[字符串.列表.元祖].非序列[字典.集合.文件对象])''''''疑问解答:(字符串.列表.元祖.字典.集合.文件对象)都不是可迭代对象,只是for循环调用了他

三元表达式、列表推导式、生成器表达式、递归、匿名函数、内置函数

一 三元表达式.列表推导式.生成器表达式 1.三元表达式 name=input('姓名>>: ') res='SB' if name == 'alex' else 'NB' print(res) 2.列表推导式 #1.示例 egg_list=[] for i in range(10): egg_list.append('鸡蛋%s' %i) egg_list=['鸡蛋%s' %i for i in range(10)] #2.语法 [expression for item1 in iterabl

三元表达式、列表解析、生成器

一.三元表达式 格式:result=值1 if x<y else 值2 满足if条件result=值1,否则result=值2 >>> 3 if 3>2 else 10 3 >>> 3 if 3>4 else 10 10 >>> 3+2 if 3>0 else 3-1 5 >>> 3+2 if 3>0 and 3>4 else 3-1 2 二.列表解析 1 s='hello' 2 res=[i.up