python 第一类对象 闭包 迭代器

########################总结###########################

1. 函数名 -> 第一类对象
函数名就是变量名.
函数可以赋值
函数可以作为集合类的元素
函数可以作为参数传递
函数可以作为返回值返回
2. 闭包
语法: 内层函数对外层函数的局部变量的使用
def wrapper():
name = ""
def inner():
return name
return inner

如何查看一个函数是否是闭包
函数名.__closure__ 有值就是闭包. None就不是闭包

优点:
1. 保护变量不被侵害 (javascript)
2. 可以让一个变量常驻内存

3. 迭代器
在数据中包含了__iter__是一个可迭代对象.
for循环内部

it = lst.__iter__()
while 1:
try:
it.__next__()
except StopIteration:
break

特点:
1. 节省内存
2. 惰性机制
3. 只能向前, 不能反复

意义: 统一数据类型的遍历工作

官方查看xxx是迭代器, 可迭代对象
from collections import Iterable, Iterator

isinstance(对象, Iterable)#是否是迭代器
isinstance(对象, Iterator) #是否迭代的对象

from collections import Iterable, Iterator
lst = ["周润发","麻花藤","刘伟"]
print(isinstance(lst, Iterable)) # instance  实例, 对象 #True
print(isinstance(lst, Iterator)) # instance  实例, 对象#False
it = lst.__iter__()
print(isinstance(it, Iterable)) # instance  实例, 对象#True
print(isinstance(it, Iterator)) # instance  实例, 对象#True

迭代器一定可迭代 -> for循环
可迭代的不一定是迭代器

########################作业###########################

2,写函数，接收n个数字，求这些参数数字的和。（动态传参）

def number(*args):
    sum =0
    for i in args:
        sum=i+sum
    return sum
print(number(1,2,3,4,5,6))

3, 读代码，回答：代码中, 打印出来的值a, b, c分别是什么？为什么？

a = 10
b = 20
def test5(a, b):
    print(a, b)     #   a = 20   b = 10
c = test5(b, a)
print(c)            #   c = None    c是None是因为没有返回值，就是None

4.读代码，回答：代码中, 打印出来的值a, b, c分别是什么？为什么？

a=10
b=20
def test5(a,b):
    a=3
    b=5
print(a,b) #10 20  这个地方 如果推进去 就是3 5
c = test5(b,a)
print(c)  #none  没有返回值
print(a,b) #10 20

5, 写函数, 传入函数中多个实参(均为可迭代对象如字符串, 列表, 元祖, 集合等), 将每个实参的每个元素依次添加到函数的动态参数args里面.
例如
传入函数两个参数[1, 2, 3](22, 33)
最终args为(1, 2, 3, 22, 33)

def func(*args):
    return args
print(func(*[1, 2, 3],*(22, 33)))#分解的意思

6, 写函数, 传入函数中多个实参(实参均为字典), 将每个实参的键值对依次添加到函数的动态参数kwargs里面.
例如
传入函数两个参数
例如 传入函数两个参数{‘name’:’alex’} {‘age’:1000}最终kwargs为{‘name’:’alex’ ,‘age’:1000}

def func(**args):
    return args
print(func(**{'name1':'alex'},{'name2':1000}))#分解的意思

7, 下面代码成立么?如果不成立为什么报错?怎么解决?

a = 2
def wrapper():
        print(a)
wrapper() #内部变量引用外部变量


a = 2
def wrapper():
        a += 1 #内部变量不能直接更改外部变量的数据
    print(a)
wrapper()

def wrapper():
    a = 1
    def inner():
        print(a)#局部可以找到外部变量
    inner()
wrapper()

def wrapper():
    a = 1
    def inner():
        a += 1
        print(a)#局部变量不能更改外部变量的值
    inner()
wrapper()

8，写函数,接收两个数字参数,将较小的数字返回.

def number(*args):
    a=args[0]
    b=args[1]
    #先判断 如果 if 条件成立 走a 不成立走b
    c = a if a < b else b
    return c
print(number(2,3))

9，写函数, 接收一个参数(此参数类型必须是可迭代对象),
将可迭代对象的每个元素以’_’相连接, 形成新的字符串, 并返回.
例如
传入的可迭代对象为[1, '老男孩', '武sir']
返回的结果为’1_老男孩_武sir’

def pingjie(*args):
    s=''
    for i in args:
        s = s + '_' + str(i)
    return s.lstrip('_')
print(pingjie(*[1, '老男孩', '武sir']))

10, 写函数，传入n个数，返回字典
{‘max’:最大值,’min’:最小值}
例如: min_max(2, 5, 7, 8, 4)
返回: {‘max’:8,’min’:2}(此题用到max(), min()内置函数)

def func(*args):
    dic = {}
    dic['max'] = max(args)
    dic['min'] = min(args)
    return dic

print(func(1,2,3,4,5,6))

def func(*args):
    return {'max':max(args),'min':min(args)}
print(func(1,2,3,4,5,6,7,8))

11, 写函数，传入一个参数n，返回n的阶乘
例如: cal(7)
计算7 * 6 * 5 * 4 * 3 * 2 * 1

def cal(*args):
    sum=1
    for i in range(args,0,-1):
        sum=sum*i
    return sum
print(cal(7))

12
写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
例如：[(‘红心’，2), (‘草花’，2), …(‘黑桃’，‘A’)]
li = ['红心','方块','梅花','黑桃']

li = ['红心','方块','梅花','黑桃']
def func(*args):
    ls = []
    for a in args:
        for b in li:#循环li 列表
            if a == 1:
                ls.append((b,'A'))
            elif a == 11:
                ls.append((b,"J"))
            elif a == 12:
                ls.append((b,"Q"))
            elif a == 13:
                ls.append((b,"K"))
            else:
                ls.append((b,a))
    print(ls)
func(1,2,3,4,5,6,7,8,9,10,11,12,13)

13 有如下函数:
def wrapper():
    def inner():
        print(666)
wrapper()

# 你可以任意添加代码, 用两种或以上的方法, 执行inner函数.


# def wrapper():
#     def inner():
#         print(666)
#     inner()
# wrapper()

# def wrapper():
#     def inner():
#         print(666)
#     return inner
# ret = wrapper()
# ret()

# def wrapper():
#     def inner():
#         print(666)
#     ret = inner()
#     print(ret)
# wrapper()

14 相关面试题（先从纸上写好答案，然后在运行）：

1，有函数定义如下：
def calc(a,b,c,d=1,e=2):
    return (a+b)*(c-d)+e
请分别写出下列标号代码的输出结果，如果出错请写出Error。
print(calc(1,2,3,4,5))_____ 5
print(calc(1,2))____error
print(calc(e=4,c=5,a=2,b=3))___24
print(calc(1,2,3))_____8
print(calc(1,2,3,e=4))____10
print(calc(1,2,3,d=5,4))_____#顺序写错了

2，(此题有坑)下面代码打印的结果分别是_________,________,________.
def extendList(val, list=[]):   #默认值如果是可变的数据类型，每次使用都是同一个
    list.append(val)
    return list
list1 = extendList(10)
list2 = extendList(123, [])
list3 = extendList('a')
print('list1=%s' % list1)   # list1=[10, 'a']
print('list2=%s' % list2)   # list2=[123]
print('list3=%s' % list3)   # list3=[10, 'a']


默认参数会创建一块内存地址，list1和list3传的10和a都添加到了默认参数的这个列表中，
他俩就指向同一个内存地址，list2新传了一个列表，又创建了一个内存地址，
所以list2是[123]，list1和list3是[10, 'a']

3, 写代码完成99乘法表.(升级题)

for i in range(1, 10):
    for j in range(1, i + 1):
        print("%s x %s = %s" % (i, j, i * j), end=" ")
    print() # 换行