环境小硕的转行之路-15-小作业、闭包、迭代器

前言

原来视频的老师都是布置大作业,没有布置小作业。新视频的老师有布置小作业，感觉这种小作业对于巩固基础知识有很大的作用，所以顺手做了。

小作业

1.传入多个数字,求和。
2. 判断两个数字较小的一个。
3. 函数:输入1个可迭代对象,将里面的元素以_相连拼接成字符串。
4. 写函数,传入n个值,返回字典{max='',min=''}。
5. 写函数,输入n,返回n的阶乘。
6. 写函数返回一个扑克牌列表,每一项都是一个元组,需要用到笛卡尔积。
7. 打印9*9乘法表。（这个曾经自己在小学的时候用vb写出来过，但是当时没意识到自己有这个天赋。。。。）

代码

#1.传入多个数字,求和
#法1
def sum_func(*args):
    sum = 0
    for i in args:
        sum += i
    return sum
print(1,sum_func(1,2,3,4,5,6,7,8,9,10))
#法2
def sum1_func(*args):
    return sum(args)#法二2,3,4,5,6,7,8,9,10))
#2.判断两个数字较小的一个
def judge(a,b):
    return a if a<b else b
print(2,judge(1,2))

#3. 函数:输入1个可迭代对象,将里面的元素以_相连拼接成字符串
def join1(lst):
    s = ''
    for element in lst:
        s = s + str(element) + '_'

    return s.strip('_')

lst = [1,'negu','无敌','python']
print(3,join1(lst))
#4.写函数,传入n个值,返回字典{max='',min=''}
def judge_2(*args):
    max_value = max(args)
    min_value = min(args)
    dic = {'max':max_value,'min':min_value}
    return dic
print(4,judge_2(*[1,2,3,4,5]))
#5. 写函数,输入n,返回n的阶乘.
def factorial(n):
    sum = 1
    while True:#直接写n>=1即可
        if n>0:
            sum *= n
            n -=1
        elif n == 0:
            break
        else:
            print('minus is not allowed')
            return 'error'
    return sum
print(5,factorial(5))
#6. 写函数返回一个扑克牌列表,每一项都是一个元组,需要用到笛卡尔积.
def pocker():
    pocker_1 = []
    huase = ['黑桃','红心','方块','草花']
    dianshu = [2,3,4,5,6,7,8,9,10,'j','q','k','a','2']
    for i in huase:
        for e in dianshu:
            pocker_1.append((i,e))
    return  pocker_1
print(6,pocker())

def extendlist(val,list=[]):#若默认参数可变的数据类型,函数加载的时候就被定义了,那么每次执行都不会给它分配新的存储空间.只有变量每次运行完函数会消亡.
    list.append(val)
    return list
list1=extendlist(10)
list2 = extendlist(10,[])
list3 = extendlist('c')#list1和3指向同一个列表(list默认值被修改),而list不使用默认值新创建了一个列表.
print('list1=%s'%list1)
print('list2=%s'%list2)
print('list3=%s'%list3)


#7.打印9*9乘法表
def multiplication():
    for i in range(10):
        for t in range(1,i+1):
            print('%s*%s='%(i,t),i*t,end=' ')
        print('')
multiplication()

 

闭包

闭包:在内层函数中访问外层函数的变量
闭包的作用:
1.可以保护你的变量不受侵害
2.让一个变量常驻内存

例子

 a = 10#此时变量不安全,容易被函数的global改变.
 def outer():
     a = 10#此时变量安全,无法在另一个函数中改。对外界是不开放的。
     def inner():
         nonlocal  a
         a = 20
         print(a)
     return inner#保证a常驻内存
 outer()()#inner什么时候调用不确定,必须保证a常驻内存,为了inner执行的时候a有值.

 

闭包应用例子-超简易爬虫

from urllib.request import urlopen
def outter():
    s =  urlopen('http://www.baidu.com/').read()#常驻内存,第一次拿很慢,后面拿就快了。
    def getcontent():#闭包
        return s#读出一堆数据
    return getcontent#保证s常驻内存
#pa = outter()#如果网站更新得重新跑一次这个
pa()

 

查看是否闭包

#查看爬虫是否闭包
def outter():
    a = 10
    def inner():
        print('我是inner')
        #print(a)
    print(inner.__closure__)#查看是否闭包的函数
outter()#输出none,说明inner不是闭包

 

迭代器拾遗

迭代器一些概念

• 所有带iter是可以使用for循环的.称之为可迭代对象。

• 所有可迭代对象可通过iter获取迭代器。

• 迭代器里面的可执行语句里有next,iter。

展示

diedaiqi = 'dadadada'.__iter__()
print(1,dir(diedaiqi))#有__iter__和__next__

 

迭代器的基本特质

1.只能向前不能向后
2.几乎不占用内存,节省内存(和生成器处知识链接)
3.可用for循环提取数据
4.惰性机制(面试题,难度系数较高)

迭代器模拟for循环

#迭代器模拟for循环
    lst = ['a','b','c','d']
    for el in lst:#底层用的是迭代器
        print(el)
    相当于
    it = lst.__iter__()

    while 1:
        try:
            el = it.__next__()
            print(el)
        except StopIteration:
            break

 

迭代器的判断

#法1

#可以通过dir来判断数据是否可迭代的,以及数据是否是迭代器(__next__ in dir(xx))野路子
#法2
#判断迭代器和迭代对象,官方方案.
from collections import Iterator
from collections import Iterable
print(3,isinstance(it,Iterable))#判断某个对象是不是某个实例。(华为t30为手机的一个实例).
list(参数)会把参数进行循环迭代
s = list(diedaiqi)#相当于将迭代器转化成列表,在list函数中一定存在for循环->一定存在__next__
print(s)#['d','a','d','a','d','a'.....]

 

转载于:https://www.cnblogs.com/negu/p/11510395.html