可迭代对象和迭代器
# 可以进行循环更新的一个实实在在值。
# 如何判断一个对象是否是可迭代对象： 利用内置函数：dir()可以查看对象内部方法
# 有__iter__方法的对象，都是可迭代对象。
# print('__iter__' in dir(str))
# 如何判断一个对象是迭代器： 可更新迭代的工具
# 在python中，内部含有'__iter__'方法并且含有'__next__'方法的对象就是迭代器。
# print('__iter__' in dir(str) and '__next__' in dir(str))
# 可迭代对象转化成迭代器：
# 利用内置函数iter()
# obj = iter(l1)
# object.__iter__()
# 迭代器可以迭代取值。利用next()进行取值（节省内存）或者转为list 元祖等等取值
# 一个next()取一个值 且会记录位置
# 迭代器一条路走到底，不走回头（记录位置）。
# 取完了再next()会报错(StopIteration) 我们可以用try处理 万能异常（Exception）while模拟for循环
s = 'gkffdsa;lfkdsk;lafkds;laldgjfd'
obj = iter(s)
while 1:
try:
print(next(obj))
except StopIteration:
break可迭代对象与迭代器的对比
- 可迭代对象是一个操作方法比较多，比较直观，存储数据相对少（几百万个对象，8G内存是可以承受的）的一个数据集。
- 当你侧重于对于数据可以灵活处理，并且内存空间足够，将数据集设置为可迭代对象是明确的选择。
- 是一个非常节省内存，可以记录取值位置，可以直接通过循环+next方法取值，但是不直观，操作方法比较单一的数据集。
- 当你的数据量过大，大到足以撑爆你的内存或者你以节省内存为首选因素时，将数据集设置为迭代器是一个不错的选择。
小练习
https://www.cnblogs.com/saoqiang/p/11402159.html
生成器
# return作用 返回值 单个或多个 终止函数
# 结束函数，给函数的执行者返回值(多个值通过元组的形式返回)。
# 将return换为yield就是生成器函数
# 只要函数中出现了yield那么他就不是函数，它是生成器函数。
# 不结束函数，对应着给 next 返回值(多个值通过元组的形式返回)。 会记录位置
def func():
yield 2,4,5
print(11)
yield 3
print(22)
print(33)
yield 4
yield 5
ret = func() # 生成器对象
# print(ret)
# print(next(ret))
# print(next(ret))
# print(next(ret))
# yield : 对应next给next返回值yield from
# yield from 将一个可迭代对象的每一个元素返回给next
# yield from 节省代码，提升效率（代替了for循环）
# def func():
# l1 = [1, 2, 3]
# yield from l1#就是下面的简写
# '''
# yield 1
# yield 2
# yield 3
# '''
# ret = func()
# print(next(ret))出错题
def eat_baozi_gen():
for i in range(1,5):
yield f'{i}号包子'
print(11)
ret1 = eat_baozi_gen()
for i in ret1:
print(i)生成器表达式，列表推导式
# 两种构建方式：
# 1.循环模式： [变量(加工后的变量) for 变量 in iterable]
# print([i**2 for i in range(1, 11)])
# 2.筛选模式： [变量(加工后的变量) for 变量 in iterable if 条件]
# print([i**2 for i in range(1, 11)])
# 列表推导式的优缺点：
# 优点：
# 1， 简单，快捷，装b。
# 缺点：
# 2. 可读性不高，不好排错。
# 慎用，不要入迷。
# 生成器表达式： 小括号
# 与列表推导式几乎一模一样。
# 循环模式，筛选模式。
# obj = (i for i in range(1, 11))
# 字典推导式，集合推导式： 两种模式： 循环模式，筛选模式
l1 = ['小潘', '怼怼哥','西门大官人', '小泽ml亚']
# {0： '小潘', 1： '怼怼哥', 2: '西门大官人'}
# dic = {}
# for index in range(len(l1)):
# dic[index] = l1[index]
# print(dic)
# print({i:l1[i] for i in range(len(l1))})匿名函数
一句话函数 一般与内战函数结合
# 匿名函数：没有名字的函数
# 匿名函数只能构建简单的函数，一句话函数。
# func2 = lambda 形参: 返回值
# func2 = lambda x,y: x + y面试题
i改变了指向
func_list = []
for i in range(10):
func_list.append(lambda x:x+i)
v1 = func_list[0](2)
v2 = func_list[5](1)
print(v1,v2)
func_list = []
for i in range(10):
func_list.append(lambda x:x+i)
for i in range(0,len(func_list)):
result = func_list[i](i)
print(result)
result = []
for i in range(10):
func = lambda : i # 注意：函数不执行，内部代码不会执行。
result.append(func)
print(i)#9
print(result)
v1 = result[0]()
v2 = result[9]()
print(v1,v2)
def func(num):
def inner():
print(num)
return inner
result = []
for i in range(10):
f = func(i)
result.append(f)
print(i)
print(result)
v1 = result[0]()
v2 = result[9]()
print(v1,v2)
如 10.3.9.12 转换规则为二进制：
10 00001010
3 00000011
9 00001001
12 00001100
再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？
# IP地址转换为int
# 思路IP按照split进行分隔成4个部分,然后每个部分都转换为二进制类型.
# 然后将这些二进制进行拼接成一个32位的大的二进制字符串.
# 最后将这个二进制数,转换成对应的int类型
def ipToInt(ip_str):
# 分隔
ip_list = ip_str.split('.')
# 拼接
bin_str = ""
# 遍历,然后求出每一个二进制数,(注意切割,舍弃0b),还要把它弄成8位.再相加
for i in ip_list:
part = bin(int(i))[2:]
# 将part前面补充0
part = part.zfill(8)
bin_str += part
# 最后将这个二进制数转换为整数
ip_int = int(bin_str, 2)
return ip_int
v = [lambda :x for x in range(10)]
print(v)
print(v[0])
print(v[0]())
v = (lambda :x for x in range(10))
print(v)
print(next(v))
print(next(v)())
def num():
return [lambda x:i*x for i in range(4)]
print([m(2)for m in num()])原文地址：https://www.cnblogs.com/saoqiang/p/12386192.html
时间： 2024-10-08 01:10:13