python基础 day12 函数名的应用 新特性：格式化输出 f-string 迭代器

今日内容
1、global nonlocal
#默认参数的坑
"""
陷阱只针对于默认参数是可变类型的数据
"""
# def func(name,lst = []):
# lst.append(name)
# return lst
# ret1 = func("alex")
# ret2 = func("太白金星")
# print(ret1)
# print(ret2)
# # ['alex', '太白金星']
# # ['alex', '太白金星']
#
# def func(name,lst = []):
# lst.append(name)
# return lst
# ret1 = func("alex")
# print(ret1) #['alex']
# ret2 = func("太白金星")
# print(ret2) #['alex', '太白金星']

"""
global 的坑的应用
"""
# 在局部定义一个全局变量
# def func():
# global name
# name = "太白金星"
# func()
# print(name)
# 在局部修改一个全局变量值
# name = "alex"
# def func():
# global name
# name = "太白金星"
# print(name)
# func()
# print(name)

"""
nonlocal 不能操作全局变量
"""
# count = 1
# def func():
# nonlocal count
# count += 1
# func()
"""
局部作用域：内层函数对外层函数的局部变量的修改
"""
def wrapper():
count = 1
def inner():
nonlocal count
count += 1
print(count)
inner()
wrapper()
2、函数名的应用
3、新特性，格式化输出
# 格式化输出

name = "太白"
age = 18
msg = f"我叫{name},今年{age}"
print(msg)

dic = {"name" : "alex" ,"age" : 18}
msg = f'我叫{dic["name"]},今年{dic["age"]}'
print(msg)
4、迭代器
可迭代对象
获取对象的方法
判断一个对象是否是可迭代对象
""""
获取一个对象的所有方法
"""
# s1 = "sfkjhdskj"
# print(dir(s1)) 获取所有方法
# print('__iter__' in dir(s1)) 判断是不是可迭代对象
小结
优点：1、节省内存
2、惰性机制 next一下，取一个值
缺点：1、速度慢
2、不走回头路

迭代器: 文件时一个迭代器
迭代器的定义
判断一个对象是否是一个迭代器
"""
判断是否是一个迭代器
"""
with open("v",encoding="utf-8",mode="r") as f1:
if ('__iter__' in dir(f1)) and ('__next__' in dir(f1)):
print("是一个迭代器")
else:
print("不是迭代器")
迭代器的取值
"""
可迭代对象转换成迭代器,多一个next都会报错，但可以少
"""
# s1 = "fjdskaj"
# obj = iter(s1) # s1.__iter__()
# print(obj)
# print(next(obj)) #obj.__next__()
# print(next(obj))
# print(next(obj))
# print(next(obj))
# print(next(obj))
# print(next(obj))
# print(next(obj))
可迭代对象转换成迭代器
l1 = [1,2,3,4,5,6]
obj = iter(l1)
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))
————————非常重要————————
"""
将可迭代对象转换成迭代器
利用 while 循环 模拟for循环对可迭代对象取值的机制
"""
l1 = [11,22,33,44,55,66,77,88,99]
obj = iter(l1)
while 1:
try:
print(next(obj))
except StopIteration:
break

内容回顾
1、函数的参数
实参角度：位置参数，关键字参数，混合参数
形参角度：位置参数，默认参数，仅限关键字参数，万能参数
顺序：位置参数，*args，仅限关键字参数，默认参数，**kwagrs
2、*的魔性用法
函数的定义时：*代表聚合
函数的调用时：*代表打散
3、python中存在三个空间
内置名称空间：存放内置函数等等
全局名称空间：整个py文件内的所有变量和函数等（除去函数和类型中的变量）
局部名称空间：函数内部的变量与值的对应关系
4、加载顺序
内置名称空间——》全局名称空间——》局部名称空间
5、取值顺序：
就近原则 （LEGB）
局部作用域智能引用全局变量，不能修改
6、作用域
全局作用域：内置名称空间+全局名称空间
局部作用域：局部名称空间
7、函数的嵌套
8、globals() locals()
————————————作业————————————
# 请写出下列代码的执行结果： 例一：
#
# def func1():
# print('in func1' )
# def func2():
# print('in func2' )
# ret = func1
# ret() # in func1
#
# ret1 = func2
# ret1() # in func2
#
# ret2 = ret
# ret3 = ret2
# ret2() # in func1
# ret3() # in func1
# 执行结果：
# ​ 例二：
# def func1():
# print('in func1')
# def func2():
# print('in func2')
# def func3(x, y):
# x()
# print('in func3')
# y()
# print(111)
# func3(func2, func1)
# print(222)
"""结果 111
in func2
in func3
in func1
222
"""
# 执行结果：
# 111
# in func2
# in func3
# in func1
# 222
# ​ 例三（选做题）：
# def func1():
# print('in func1')
# def func2(x):
# print('in func2')
# return x
# def func3(y):
# print('in func3')
# return y
# ret = func2(func1) # in func2 返回 func1
# ret() # 执行 func1 in func1
# ret2 = func3(func2) # in func3 返回func2
# ret3 = ret2(func1) #func2(func1) in func2 返回 func1
# ret3() # in func1
# 执行结果：
# in func2
# in func1
# in func3
# in func2
# in func1
# 看代码写结果：
# def func(arg):
# return arg.replace('苍老师', '***')
# def run():
# msg = "Alex的女朋友苍老师和大家都是好朋友"
# result = func(msg)
# print(result)
# run()
# Alex的女朋友 *** 和大家都是好朋友
#
#
# def func(arg):
# return arg.replace('苍老师', '***')
# def run():
# msg = "Alex的女朋友苍老师和大家都是好朋友"
# result = func(msg)
# print(result)
# data = run()
# print(data)
# Alex的女朋友 ** * 和大家都是好朋友
# None
# 看代码写结果：
# DATA_LIST = []
# def func(arg):
# s = DATA_LIST.insert(0, arg)
# print(s)
# return s
# data = func('绕不死你')
# print(data)
# print(DATA_LIST)
"""
初识答案：#报错，局部操作不能对全局变量进行修改，只能引用
查阅资料后：虽然说局部变量不能改全局变量.
像字符串这种单独的整个的全局变量就是局部变量不能修改全局变量，但是像列表、
字典、集合、类都是可以在局部里面改全局的
"""
# None # insert方法是没有返回值的
# ['绕不死你'] # 全局变量如果是可变类型,局部作用域可以直接修改,不用global声明
# 看代码写结果：
# def func():
# print('你好呀')
# return '好你妹呀'
# func_list = [func, func, func]
# for item in func_list:
# val = item()
# print(val)
"""
你好呀
好你妹呀
你好呀
好你妹呀
你好呀
好你妹呀
"""

# 你好呀
# 好你妹呀
# 你好呀
# 好你妹呀
# 你好呀
# 好你妹呀
# 看代码写结果：
# def func():
# print('你好呀')
# return '好你妹呀'
# func_list = [func, func, func]
# for i in range(len(func_list)):
# val = func_list[i]()
# print(val)
"""
你好呀
好你妹呀
你好呀
好你妹呀
你好呀
好你妹呀
"""
# 你好呀
# 好你妹呀
# 你好呀
# 好你妹呀
# 你好呀
# 好你妹呀
# 看代码写结果：
# def func():
# return '烧饼'
# def bar():
# return '豆饼'
# def base(a1, a2):
# return a1() + a2()
# result = base(func, bar)
# print(result)
"""
烧饼豆饼
"""

# 烧饼豆饼
# 看代码写结果：
# for item in range(10):
# print(item)
# print(item)

# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 9
# 看代码写结果：
# def func():
# for item in range(10):
# pass
# print(item)
# func()
"""
9
"""
# 9
# 看代码写结果：
# item = '老男孩'
# def func():
# item = 'alex'
# def inner():
# print(item)
# for item in range(10): # for循环改变了item的值, item = 9
# pass
# inner()
# func()
"""
9
"""
# 9
# 看代码写结果：
# l1 = []
# def func(args):
# l1.append(args)
# return l1
# print(func(1))
# print(func(2))
# print(func(3))
"""
[1]
[1,2]
[1,2,3]
"""

# [1]
# [1, 2]
# [1, 2, 3]
# 看代码写结果：
# name = '太白'
# def func():
# global name # global 修改了全局变量name,所以第二次打印时,变化
# name = '男神'
# print(name) #大白
# func() # name已经变成了 '男神'
# print(name) #男神
"""
大白
男神
"""
# 太白
# 男神
# 看代码写结果：
# name = '太白'
# def func():
# print(name)
# func()
# 太白
# 看代码写结果：
# name = '太白'
# def func():
# print(name)
# name = 'alex'
# func()
"""
python解释器会认为你应该在引用之前，对变量进行申明，它不明白到底要取局部变量还是全局变量，有歧义
"""
# # 报错 : 不能改不是改了没效果,而是改了报错,不能有重新赋值的动作,语法错误
# 看代码写结果：
#
# def func():
# count = 1
# def inner():
# nonlocal count
# count += 1
# print(count)
# print(count)
# inner()
# print(count)
# func()
"""
1
2
2
"""
# 1
# 2
# 2
# 看代码写结果：
#
# def extendList(val, list=[]):
# list.append(val)
# return list
#
# list1 = extendList(10) # [10],默认列表改为[10]
# list2 = extendList(123, []) # 传入一个新的列表,存放val,默认列表不改变,还是[10] []
# list3 = extendList('a') # 还是覆盖默认列表[10] [10,'a']
#
# print('list1=%s' % list1) #[10,'a']
# print('list2=%s' % list2) #[123]
# print('list3=%s' % list3) #[10,'a']
# # list1=[10, 'a'] #指向同一列表,随之改变
# # list2=[123]
# # list3=[10, 'a']
# 看代码写结果：
# def extendList(val, list=[]):
# list.append(val)
# return list
# print('list1=%s' % extendList(10))
# print('list2=%s' % extendList(123, []))
# print('list3=%s' % extendList('a'))
# # list1=[10]
# # list2=[123]
# # list3=[10, 'a']
# 用你的理解解释一下什么是可迭代对象，什么是迭代器。
#
# 可迭代对象就是一个操作灵活, 直观, 效率高, 占用内存高的数据集
# 迭代器就是一个节省内存, 满足惰性机制, 效率低, 操作不灵活的数据集
# 如何判断该对象是否是可迭代对象或者迭代器？
# if '__iter__' in 对象
# 迭代对象就是含有__iter__方法的对象就是可迭代对象
#
# 迭代器就是在可迭代对象的基础上再含有next方法
#
# 写代码：用while循环模拟for内部的循环机制（面试题）。
#
# li = [1, 2, 3, 4, 5, 6, 7]
# # li=iter(li)
# li = li.__iter__()
# while 1:
# try:
# print(next(li))
# except StopIteration:
# break
# 写函数，传入n个数，返回字典
# {‘max’:最大值,’min’:最小值} 例如: min_max(2, 5, 7, 8, 4)
# 返回: {‘max’:8,’min’:2}(此题用到max(), min()内置函数)
# min_max = (2, 5, 7, 8, 4)
# print(max(min_max))
# print(min(min_max))
# dic = {}
# def func(*args):
# return max(args),min(args)
# max_num,min_num = func(2, 5, 7, 8, 4)
# dic['max'] = max_num
# dic['min'] = min_num
# print(dic)

# def func(*args):
# dic = {}
# dic["max"] = max(args)
# dic["min"] = min(args)
# # print(dic)
# return dic
#
#
# print(func(1, 23, 4, 5, 6, 67))
# # func(1,23,4,5,6,67)
# 写函数，传入一个参数n，返回n的阶乘 例如: cal(7)
# 计算7654321
#
#
# def func(n):
# s = 1
# for i in range(1, n + 1):
# s = s * i
# return s
#
#
# print(func(7))
# 写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组(选做题)
# 例如：[(‘红心’，2), (‘草花’，2), …(‘黑桃’，‘A’)]
# LST = []
# lst = [2,3,4,5,6,7,8,9,10,'J','Q','K','A']
# lst_1 = ["红桃","黑桃","梅花","方片"]
# for i in lst:
# for j in lst_1:
# LST.append((j,i))
# print(LST)
# num = [2,3,4,5,6,7,8,9,10,'J','Q','K','A']
# def func(*args,):
# lst = []
# for i in num:
# for j in args:
# lst.append((j,i))
# return lst
# print(func(*["红桃","黑桃","梅花","方片"]))

# def func1():
# li = []
# l1 = [2, 3, 4, 5, 6, 7, 8, 9, 10, "J", "Q", "K", "A"]
# l2 = []
# l3 = []
# for i in range(len(l1)):
# l2.append(str(l1[i]))
# l2.append(str(l1[i]))
# l2.append(str(l1[i]))
# l2.append(str(l1[i]))
# for i in range(len(l1)):
# li.insert(i, "黑桃")
# li.insert(i, "方片")
# li.insert(i, "草花")
# li.insert(i, "红心")
# li.insert(i, "") # 憨憨方法
# for i in range(len(li[13:])):
# def func(a, b):
# try:
# return (a, int(b))
# except ValueError:
# return (a, b)
#
# ret = func(li[13:][i], l2[i])
# l3.append(ret)
# print(l3)
#
#
# func1()
# 写代码完成99乘法表.(选做题，面试题)
# s = 1
# for i in range(1,10):
# for j in range(1,10):
# s = i*j
# print("{}*{}={}".format(i,j,s))
def func(num):
s = 1
for i in range(1,num):
for j in range(1,num):
s = i * j
print("{} * {} = {}".format(i,j,s))
func(10)
# 1 * 1 = 1
#
# 2 * 1 = 2
# 2 * 2 = 4
#
# 3 * 1 = 3
# 3 * 2 = 6
# 3 * 3 = 9
#
# ......
#
# 9 * 1 = 9
# 9 * 2 = 18
# 9 * 3 = 27
# 9 * 4 = 36
# 9 * 5 = 45
# 9 * 6 = 54
# 9 * 7 = 63
# 9 * 8 = 72
# 9 * 9 = 81
#
#
# def func():
# for n in range(1, 10):
# li = []
# for i in range(1, n + 1):
# li.append(str(i) + "*" + str(n) + "=" + str(i * n))
#
# def func(*args):
# print(args)
#
# func(*li)
#
#
# func()
#
# for n in range(1, 10):
# for i in range(1, n + 1):
# print(f"{i}*{n}={i * n}", end=" ") # end = " " 默认循环不换行,中间加空格,
# # 则表示没个元素后面加空格也可加其他元素
# print("")