Python迭代器

Yellowpython 2020-03-06

1,函数名的运用

1,函数的内存地址

函数名的定义和变量的定义几乎是一样的,在变量的角度,函数名就是一个变量,具有变量的功能:可以赋值;但是作为函数名他也有特殊的功能就是加上()就会执行对应的函数,所以我们可以把函数名当作一个特殊的变量

def func():
    print(‘hh‘)

print(func)  #结果:<function func at 0x1101e4ea0>

通过以上的例子可以知道,函数名是指向这个函数的内存地址,与其说函数名()可以执行这个函数,不如说是函数的内存地址()才是执行这个函数的关键,比如

a = 1
b = 2
c = a + b
print(c)  #  3

a + b 并不是变量相加,而是两个变量指向的int对象的相加

2,函数名可以赋值给其它变量

def func():
    print(‘hh‘)

print(func)
a = func  # 把函数当成一个变量赋值给另外一个变量
a()  # 函数调用func()

通过变量的赋值,变量a,和变量func都指向的这个函数的内存地址,那么a()就当然可以执行这个函数

3,函数名可以当作容器类的元素

其实函数名就是一个变量,变量是可以当作容器类类型的元素:

a = 1
b = ‘alex‘
c = ‘sir‘
l1 = [a, b, c]

for i in l1:
    print(i)

# 结果:
1
alex
sir

那么函数名也可以是

def func1():
    print("in func1: aa")
def func2():
    print("in func2: bb")
def func3():
    print("in func3: cc")
def func4():
    print("in func4: dd")
lst = [func1, func2, func3, func4]
for i in lst:
    i()

4,函数名可以当作函数的参数

变量可以做的,函数名也可以做

def func1():
    print(‘in func1‘)

def func2(f):
    print(‘in func2‘)
    f()

func2(func1)

5,函数名可以当作函数的返回值

def func1():
    print(‘in func1‘)

def func2(f):
    print(‘in func2‘)
    return f

ret = func2(func1)
ret()  # ret, f, func1 都是指向的func1这个函数的内存地址

View Codex

小结:函数名是一个特殊的变量,他除了具有变量的功能,还有最主要的特点就是加上()就执行,其实还有一个学名是叫第一类对象

2,f-strings格式化输出

f-strings是python3.6的标准库的格式化输出新的写法,这个格式化比%s或者format效率高并且更加简化。

1,举个栗子

它的结构就是F(f)+str的形式,在字符串中想替换的位置用{}展位,与format类似,但是用在字符串后面写入替换的内容,二他可以直接识别

name = ‘xzc‘
age = 18
sex = ‘男‘
msg = F‘姓名:{name},性别:{age},年龄:{sex}‘  # 大写字母也可以
msg = f‘姓名:{name},性别:{age},年龄:{sex}‘  
print(msg)
‘‘‘
输出结果:
姓名:xzc,性别:18,年龄:男
‘‘‘

2,任意表达式

它可以加任意的表达式

print(f‘{3*21}‘)  # 63

name = ‘barry‘
print(f"全部大写:{name.upper()}")  # 全部大写:BARRY

# 字典也可以
teacher = {‘name‘: ‘xzc‘, ‘age‘: 18}
msg = f"The teacher is {teacher[‘name‘]}, aged {teacher[‘age‘]}"
print(msg)  # The comedian is xzc, aged 18

# 列表也行
l1 = [‘xzc‘, 18]
msg = f‘姓名:{l1[0]},年龄:{l1[1]}.‘
print(msg)  # 姓名:xzc,年龄:18.

3,插入表达式

可以用函数完成相应的功能,然后返回值返回到字符串相应的位置

def sum_a_b(a,b):
    return a + b
a = 1
b = 2
print(‘求和的结果为‘ + f‘{sum_a_b(a,b)}‘)

4,多行f

name = ‘barry‘
age = 18
ajd = ‘handsome‘

# speaker = f‘‘‘Hi {name}.
# You are {age} years old.
# You are a {ajd} guy!‘‘‘

speaker = f‘Hi {name}.‘          f‘You are {age} years old.‘          f‘You are a {ajd} guy!‘
print(speaker)

5,其他

注意细节

print(f"{{73}}")  # {73}
print(f"{{{73}}}")  # {73}
print(f"{{{{73}}}}")  # {{73}}
m = 21
# ! , : { } ;这些标点不能出现在{} 这里面。
# print(f‘{;12}‘)  # 报错
# 所以使用lambda 表达式会出现一些问题。
# 解决方式:可将lambda嵌套在圆括号里面解决此问题。
x = 5
print(f‘{(lambda x: x*2) (x)}‘)  # 10

3,迭代器

1,可迭代对象

1)可迭代对象定义

什么叫对象?在python中所有的一切都可以是对象;什么叫迭代?迭代就是一个重复的过程,但是不能单纯的重复,每一次迭代都是基于上一次的结果而来,就像游戏更新,这就叫迭代。

在python中现在学的有str  list  tuple  dic  set  range 文件句柄等都是可迭代对象,在python中但凡内部含有_iter_方法的对象,都是可迭代对象

2)查看对象内部的方法

查看对象内部的方法除了看源码意外还有通过dir()去判断一个对象具有什么样的方法

s1 = ‘alex‘
print(dir(s1))

dir()会返回一个列表,这个列表中含有该对象的以字符形式所有方法名这样就可以判断python中的一个对象是不是可迭代对象

s1 = ‘alex‘
i = 100
print(‘__iter__‘ in dir(i))  # False
print(‘__iter__‘ in dir(s1))  # True

3)小结:

从字面角度:可迭代对象是一个可以重复取值的实实在在的东西

从专业角度:但凡内部含有_iter_方法的对象,都是可迭代对象

可迭代对象可以通过判断该对象是否有‘_iter_‘方法来判断

可迭代对象的优点:

可以直观的查看里面的数据

可迭代对象的缺点:

1,占用内存

2,可迭代对象不能迭代取值(除去索引,key以外)

即使抛去索引,key以外,这些可迭代对象可以通过for循环进行取值,就是先将可迭代对象转化成迭代器,然后在进行取值

2,迭代器

1)迭代器的定义

从字面意思来说:迭代器,是一个可以迭代取值的工具

从专业角度来说:迭代器时这样的对象:实现了无参数_next_方法,返回序列中的下一个元素,如果没有元素,那么抛出Stoplteration异常,python中迭代器还实现了_iter_方法,因此迭代器也可以迭代

那么简单来说:在python中,内部含有_lter_方法并且含有_next_方法的对象就是迭代器

2)如何判断该对象是否是迭代器

例:

o1 = ‘alex‘
o2 = [1, 2, 3]
o3 = (1, 2, 3)
o4 = {‘name‘: ‘太白‘,‘age‘: 18}
o5 = {1, 2, 3}
f = open(‘file‘,encoding=‘utf-8‘, mode=‘w‘)
print(‘__iter__‘ in dir(o1))  # True
print(‘__iter__‘ in dir(o2))  # True
print(‘__iter__‘ in dir(o3))  # True
print(‘__iter__‘ in dir(o4))  # True
print(‘__iter__‘ in dir(o5))  # True
print(‘__iter__‘ in dir(f))  # True
# hsagn
print(‘__next__‘ in dir(o1))  # False
print(‘__next__‘ in dir(o2))  # False
print(‘__next__‘ in dir(o3))  # False
print(‘__next__‘ in dir(o4))  # False
print(‘__next__‘ in dir(o5))  # False
print(‘__next__‘ in dir(f))  # True
f.close()

通过以上代码可以验证,以上对象中只有文件句柄时迭代器,剩下的数据类型都是可迭代对象

3)可迭代对象如何转化成迭代器

l1 = [1, 2, 3, 4, 5, 6]
obj = l1.__iter__() 
# 或者 iter(l1)print(obj) 
# <list_iterator object at 0x000002057FE1A3C8>

4)迭代器取值

可迭代对象时不可以一直迭代取值(出去索引,切片以及key),但是转化成迭代器就可以了,迭代器是使用_next_()方法进行取值

l1 = [1, 2, 3,]
obj = l1.__iter__()  # 或者 iter(l1)
# print(obj)  # <list_iterator object at 0x000002057FE1A3C8>
ret = obj.__next__()
print(ret)
ret = obj.__next__()
print(ret)
ret = obj.__next__()
print(ret)
ret = obj.__next__()  # StopIteration
print(ret)
# 迭代器利用next取值:一个next取对应的一个值,如果迭代器里面的值取完了,还要next,
# 那么就报StopIteration的错误。

5)通过while模拟for的内部循环机制

使用for循环的循环对象一定要是可迭代对象,但是这不意味着可迭代对象就可以取值因为for循环的内部机制是:将可迭代对象转化成迭代器,然后利用_next_进行取值,最后利用异常处理Stoplteration抛出异常

l1 = [1, 2, 3, 4, 5, 6]
# 1 将可迭代对象转化成迭代器
obj = iter(l1)
# 2,利用while循环,next进行取值
while 1:
    # 3,利用异常处理终止循环
    try:
        print(next(obj))
    except StopIteration:
        break

6)小结:

从字面意思来说:迭代器是可迭代取值的工具

从专业角度来说:在python中,内部含有_iter_方法并且含有_next_方法的对象就是迭代器

迭代器的优点:

节省内存

迭代器在内存中相当于只占一个数据空间:因为每次取值都上一条数据会释放内存,加载当前的此条数据

惰性机制

next一次,取一次值,绝对不过多取值

有一个迭代器模式就i可以解释上面两条:迭代是数据处理的基石,扫描内存中放不下的数据集时,我们要找到一种惰性获取数据的方法,即按需一次取得一个数据,这就是迭代器的模式

迭代器的缺点:

不能直观的查看里面的数据

取值时不走回头路,只能一直向下取值

3,可迭代对象与迭代器的对比

可迭代对象

是一个私有方法比较多,操作比较灵活,比较直观,但是占用过多内存,而且不能直接通过循环迭代取值的一个数据集

应用

当侧重于对数据可以灵活处理,并且内存空间足够的情况下,将数据集设置为可迭代对象时明确的选择

迭代器

是一个非常节省内存,可以记录取值位置,可以通过循环+next方法取值,但是不直观,操作方法比较单一的数据集

应用

当数据量过大,大到足以撑爆内存或者以节省内存为首选因素时,将数据集设置为迭代器是一个很好的选择

相关推荐