# c = a if a>b else b #三元运算
def func(name,*args,name1=‘name1‘,**kwargs):
# 如果默认参数的值是一个可变数据类型，那么每一次调用函数且对其进行增删改的时候，如果不传值就公用这个数据类型的资源
return ‘s‘ # 可以元组方式返回多个值，也可以单独返回字符串列表字典等
func(name,) # ret = func()多个值之间用逗号隔开，接收的时候可以用一个变量接收（元组），也可以用等量的多个变量接收
func(*[‘a‘,[1,2],‘c‘]) # *打撒 将元素单个传参
#4.函数的参数
#形参：
# 位置参数 ： 必须传
# *args ：可以接收任意多个位置参数
# 默认参数 ： 可以不传
# **kwargs ： 可以接收多个关键字参数
#实参 调用函数的时候
# 按照位置传参数
# 按照关键字传参数
# 可以混用 位置参数必须在关键字传参之前
# 不能对一个参数重复赋值
# 作用域两种
# 全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域 ——globals()
# 局部作用域 —— 作用在局部 —— 函数（局部名字空间中的名字属于局部作用域） ——locals()
# 如果在一个局部（函数）内声明了一个 global 变量名，那么这个变量在局部的所有操作将对全局的变量有效
# globals 永远打印全局的名字
# locals 输出什么 根据locals所在的位置
# nonlocal 只能用于局部变量 找上层中离当前函数最近一层的局部变量,局部没有则报错,声明了nonlocal的内部函数的变量修改会影响到 离当前函数最近一层的局部变量,对全局无效,对局部 也只是对 最近的 一层 有影响
# func() # 函数名就是内存地址
# func2 = func # 函数名可以赋值
# l = [func,func2] # 函数名可以作为容器类型的元素
# return f # 函数名可以作为函数的返回值
# qqxing = wahaha(func) # 函数名可以作为函数的参数
# 闭包 ： 内部函数使用外部函数的变量
# 装饰器函数
# def wrapper(f): #装饰器函数，f是被装饰的函数
# def inner(*args,**kwargs):
# ‘‘‘在被装饰函数之前要做的事‘‘‘
# ret = f(*args,**kwargs) #被装饰的函数
# ‘‘‘在被装饰函数之后要做的事‘‘‘
# return ret
# return inner
# @wrapper #语法糖 @装饰器函数名
# def func(a,b): #被装饰的函数
# pass
# import time
# from functools import wraps
# FLAGE = False
# def timmer_out(flag):
# def timmer(func):
# @wraps(func) #加在最内层函数正上方
# def inner(*args,**kwargs):
# if flag:
# start = time.time()
# ret = func(*args,**kwargs)
# end = time.time()
# print(end-start)
# return ret
# else:
# ret = func(*args, **kwargs)
# return ret
# return inner
# return timmer
# @timmer_out(FLAGE)
# @ def func():
# pass
# @wrapper3
# @wrapper2
# @wrapper1
# def func():pass
l=[‘a‘,‘b‘]
p = l.__iter__()
print(next(p),p.__next__())
# 迭代器协议 —— 内部含有__next__和__iter__方法的就是迭代器
# 可以被for循环的都是可迭代的
# 可迭代的内部都有__iter__方法
# 只要是迭代器 一定可迭代
# 可迭代的.__iter__()方法就可以得到一个迭代器
# 迭代器中的__next__()方法可以一个一个的获取值
# def func():
# yield ‘a‘
# yield ‘b‘
# 只要含有yield关键字的函数都是生成器函数
# 生成器函数：执行之后会得到一个生成器作为返回值，可循环取值for i in 调用的返回值:pass，next()取值
# 迭代器的特点：很方便使用，且只能取所有的数据取一次，节省内存空间
# 生成器函数：
#含有yield关键字的函数就是生成器函数
#特点：
#调用函数的之后函数不执行，返回一个生成器
#每次调用next方法的时候会取到一个值
#直到取完最后一个，在执行next会报错
# def func():
# content = yield ‘a‘
# yield ‘b‘
# ret = g.__next__()
# ret = g.send(‘hello‘)
# send获取下一个值的效果和next基本一致，只是在获取下一个值的时候，给上一yield的位置传递一个数据
# 使用send的注意事项：第一次使用生成器的时候 是用next获取下一个值，最后一个yield不能接受外部的值
# 获取移动平均值，预激生成器的装饰器
# def init(func): #装饰器
# def inner(*args,**kwargs):
# g = func(*args,**kwargs) #g = average()
# g.__next__()
# return g
# return inner
# @init
# def average():
# sum,count,avg = 0,0,0
# while True:
# num = yield avg
# sum += num # 10
# count += 1 # 1
# avg = sum/count
# avg_g = average() #===> inner
# ret = avg_g.send(10)
# print(ret)
# ret = avg_g.send(20)
# print(ret)
# [每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型] #遍历之后挨个处理
# [满足条件的元素相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件] #筛选功能
l1 = [‘选项%s‘%i for i in range(10)]
# 把列表解析的[]换成()得到的就是生成器表达式
# 列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
# l1 = [‘选项%s‘%i for i in range(10) if i%3==0] 理解如下==>
# for i in range(10):
# if i%3==0:
# li.append(‘选项%s‘%i)
# 若还有条件则继续缩进代码取值
#
# l1 = (‘选项%s‘%i for i in range(10)) # 返回一个生成器对象
# for i in l1:print(i)
# print(li,list(li))
# l1.__next__() # next(l1)
# l1 = {‘选项%s‘%i for i in range(10)} # 生成集合
# l1 = {i:‘选项%s‘%i for i in range(10)} # 生成字典
原文地址：https://www.cnblogs.com/ming-yuan/p/9536860.html
时间： 2024-10-06 15:15:42