推导式迭代器生成器及包

Posted 2021-01-02 nealxyz

# 一、推导式：

# 列表推导式
li = [i for i in range(1,10)]
print(li)

# 列表推导式中加判断
li1 = [i for i in range(1,10) if i % 2 == 1]
print(li1)

# 列表推导式中加三目运算符
li2 = [i*100 if i % 2 == 0 else i*10 for i in range(1,10)]
print(li2)



# 集合推导式
se = {i for i in range(1,10)}
print(se)

# 集合推导式也可以加判断和三目运算符


# 字典推导式
di = {i:j for i,j in enumerate([‘aa‘,‘bb‘,‘cc‘])}   # 利用枚举函数enumerate
print(di)

di2 = {i:j for i,j in zip([‘aa‘,‘bb‘,‘cc‘],[11,22,33])}   # 利用zip
print(di2)


# 可迭代对象：序列类型，散列类型，range keys values items等等，有内置 __iter__ 方法的：
print(dir(dict))


# 迭代器(iterator)：有 __iter__ 和 __next__ 方法
# 让可迭代对象，变为迭代器有两个方法：
# 1 iter()
it = iter([1,2,3,4])
print(dir(it))
print(it)  # <list_iterator object at 0xb720534c>  迭代器对象

# 2 __iter__()
tu = (6,7,8)
it2 = tu.__iter__()
print(dir(it2))

# 取值  方法也有两个
# 1 __next__()
while 1:
    print(it.__next__()) # 值取完后 就会返还 StopIteration 的错误

# 2 next() # 一次取一个
# while 1：
#   print(next(it))  # 没有值了就会返还  StopIteration 的错误

# 可迭代对象是“一次性”的，即对其迭代一次后，值就没了，要想再迭代，必须重新赋值
# 可迭代对象 是用来生成迭代器的



# for 原理 只能循环可迭代对象
li = [1,2,3,4,5,6,7]
my_it = iter(li)    # 首先将可迭代对象变成迭代器
while True:
    try:
        var = next(my_it)
        print(var)
    except StopIteration:
        break



# 生成器(generator)  就是 迭代器  迭代可控制、省内存
# 1 推导式

ge = (i for i in range(1,100000000000000))
print(ge)



# 2 yeild 关键字  在函数里面加上yield关键字

li = [8,7,6,5,4,3]

def my_ge():
    a = 0
    for i in li:
        yield i   # 返回这个对象、暂停这个函数、等待下次next重新激活
        a += 1
        print(‘循环次数：‘,a)
a = my_ge()
print(a)   # 打印的不是None  而是生成器
while 1:
    print(next(a))





# 三、模块
#导入：两种方法：
# 1. import first

# 2. from first import my_dir

# from first import my_dir as dd  # 取别名
# a = dd
# print(a)

import sys
sys.path.append(‘/home/pyvip/‘)  # 可以添加路径，让其导入当前路径以外的模块
print(sys.path)  # 在这个打印出的路径下可以导入

import csc  # 虽然报错，但可以导入



# 四、包

#包的概念：

#导入包下面的东西
# from pakg import pakg1

# 同级文件夹下的模块（包）可互导：
   from 同级包名1 import 同级包名2

# 不同级的包不能互相导入，如果外层要导入的内层的包，需要：
   from 外层包名.内层包名（或*） import 内层包名
# 在内层文件夹下导入外层的包：
    from 外层包名 import 里面的包
    
# 通过在上层包名前面加.来实现与上层的其他包同级

# 一般只导3层的包,即之前加两个点。