Python之高级特性

###1.迭代###

1.可以通过for循环来遍历这个list或tuple，这种遍历称为迭代(lteration)

2.只要时可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代：

3.默认情况下，dict迭代的是key，如果要迭代value

for k,v in d.iteritems():

     print k, v

4.如何判断一个对象是否为可迭代对象：通过collections模块的Iterable类型判断

5.如何对list实现类似Java那样的下标循环：python内置的枚举方法enumerate，把一个list变成索引-元素对。

6.如何显示[(1,2),(2,3),(3,4)]

###2.列表生成式###

#1.接收变量k,a,b
s = '51 5000 10000'

#['51','5000','10000']
#存储整形的k,a,b
#li = [ ]
#for item in s.split():
    li.append(int(item))
k,a,b = li

#k,a,b = [int{item} for item in s.split()]
#print(k,a,b)

 

需求2：生成一个列表，列表元素分别为[1**1,2**2,3**3....]
#li =[]
#for i in range(1,8):
#    li.append(i**i)
#print(li)

print([i**i for i in range(1,8)])

总结：
    [experssion(或函数) for item1 in 序列 if 判断语句
               for item1 in 序列 if 判断语句
               for item1 in 序列 if 判断语句
    ]
        

print([i**i for i in range(1,8) if i%2 == 0])

需求：将3*3d的矩阵转换为一维数组
3*3矩阵：[
        [1,2,3],
        [4,5,6],
        [7,8,9]
    ]

一维数组：[1,2,3,4,5,6,7,8,9]

li=    [
        [1,2,3],
        [4,5,6],
        [7,8,9]
    ]

resLi = []
for item1 in li:
    for item2 in item1:
        resLi.append(item2)
print(resLi)    

print([item2 for item1 in li for item2 in item1])

# 列表生成式使用变形:

#       1). [i**2 for i in range(2,10,2) ]
#       2). [fun(i) for i in range(2,10,2)]

#       3). [i**2 for i in range(2,10,2) if i%3==0]
#       4). [fun(i) for i in range(2,10,2) if i%3==0]
#       5). [fun(i) for i in range(2,10,2) if isFun(i)]
#       6). [fun1(i) if isFun(i) else fun2(i) for i in range(2,10,2)]

###3.字典生成式###

# 需求1： 假设有20个学生，学生分数在60-100之间，筛选出成绩在90分以上的学生
import random

# stuInfo={}
# for i in range(20):
#     # name = "westos"+ str(i)
#     # score = random.randint(60,100)
#     # stuInfo[name] = score
#     stuInfo["westos"+ str(i)] = random.randint(60,100)
# print(stuInfo)

stuInfo = {"westos"+ str(i):random.randint(60,100)
            for i in range(20)}

# 筛选出score>90

# highScore = {}
# for name, score in stuInfo.items():
#     if score > 90:
#         highScore[name] = score
# print(highScore)

print({ name:score for name, score in stuInfo.items() if score > 90 })

#需求2.

将字典的key值和value值调换;
d = {'a':'apple', 'b':'bob', 'c':'come'}

print({v:k for k,v in d.items()})

#需求3.

大小写计数合并 : key值最终全部为小写.

d = {'A':10, 'b':3, 'a':5, 'B':8, 'd':1}

print({k.lower(): d.get(k.upper(),0)+d.get(k.lower(),0) for k,v in d.items()})
# print({k.lower(): d[k.upper()]+d[k.lower()] for k,v in d.items()})  # 报错    ##后面跟的数字表示，如果没有大小写，返回值为0.

###4.集合生成式###

s = {1,2,3,4,5,6,7}
# 集合生成式
print({i**2 for i in s })
# 字典生成式
print({i:i**2 for i in s })

###5.生成器###

# 1). 判断2～num之间有多少个质数?
def isPrime(num):
    for i in range(2, num):
        if num % i == 0:
            return  False
    else:
        return True
# primeLi =  [i for i in range(1,1000) if isPrime(i)]
# print(primeLi)

# 生成器最快实现的方式:通过列表生成式改写. 一边循环， 一边计算的机制.
primeLi =  (i for i in range(2,1000) if isPrime(i))
# print(next(primeLi))
# print(next(primeLi))
# print(next(primeLi))
# print(next(primeLi))

from collections import  Iterable
for i in primeLi:
    print(i)

# print(isinstance(primeLi,Iterable))  # 判断是否可以for循环

# yield: 当函数中包含yield关键字， 返回值是一个生成器, 如果要执行函数内容.需要调用next方法， 或者for循环.
#         运行过程: 当执行next方法时， 遇到yield程序停止, 直到执行下一次next方法时，
#          从上一次停止的yield处继续执行，遇到yield停止运行.
# return: 遇到return函数执行结束;

# num=1
def fib(num):
    """将来显示几个fib数列"""
    # count代表显示的已经
    # a代表第一个数， b代表第二个数， count代表已经显示的fib个数，当前为0.
    a,b,count = 0,1,0
    # 如果当前显示的个数小于需要显示的格式， 则显示b， 并且计算出下一个要显示的数。
    while count < num:
        yield  b
        a, b = b, a+b
        # 已经显示的次数加1;
        count += 1

# 生成器: 如果函数中有yield， 那么这个函数的返回值就是一个生成器;
res=fib(4)
print(next(res))
print(next(res))

# 生成器fib()执行的过程分析:
#       执行语句 f = fab(100) 时，并不会马上执行 fib() 函数的代码块，而是首先返回一个 iterable 对象(即生成器)！
#       在 for 循环语句执行时或者next()，才会执行 fib() 函数的代码块。
#       执行到语句 yield b 时，fib() 函数会返回一个迭代值，直到下次迭代前，
#       程序会回到 yield b 的下一条语句继续执行，然后再次回到 for 循环，如此迭代直到结束。
#       看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。
# 由此可以看出，生成器通过关键字 yield 不断的将迭代器返回到内存进行处理，而不会一次性的将对象全部放入内存，
# 从而节省内存空间。