标签：oca 作用 结构 语法 文件的操作 不用 面向对象 位置 key
解决if，else条件的简写。
v = A if 条件 else B
# 如果条件为真，就把A赋值给V，否则赋值B简单函数的简写
def func(a1,a2):
return a1+a2 #这种简单返回数值的函数形式，可以简化为：
func = lambda a1,a2:a1+a2 #这种简便写法叫做lambda表达式，和上面的形式没有区别func = lambda a1,a2: a1 if a1>0 else a2 #函数根据不同的条件输出不同的值之前简单的代码实现都是面向过程编程，实现一次就需要写一次，可读性非常差。
通过函数可以实现面向对象编程。 简单来说把一段代码取名，以后直接用名字来调用这一段代码，并且可以动态更改这段代码里面的参数。提高可读性
#定义函数
def 函数名(设定的形式参数):
#函数内容
#执行函数
函数名(输入变量的实际参数)执行完函数后，可以指定返回一些参数
def haoran(a):
a += 1
return a #返回值，不写返回None，返回数字、元组、字典等都可以
val_a = haoran(22) #执行函数后把return值赋给val_a
函数执行过程中，一旦遇到return，就不再继续执行了
打开文件，关闭文件的操作容易忘记，可以直接写
with open("/tmp/foo.txt") as file:
data = file.read()
#这样就不用f.close操作了1.位置参数： 按照顺序来传参数，那少传，多传都会报错。
def func(a1,a2):
print(a1,a2)
func(22,99)2.关键字传参数：
def func(a1,a2):
print(a1,a2)
func(a1=22,a2=99)以上两者可以混合使用，位置前，关键字参数在后
3.默认参数
def func(a1,a2=9): #a2不传就等于9， 传就按输入的来
print(a1,a2)
func(a1=22,a2=99)4.万能参数
def func(*a1): #带*， 默认会写成*args（arguments的缩写）
print(a1)
func(1,232,534534) #把所有参数传给a1，成为一个元组
func(*(1,2,3,4)) #加*就打散所有元素加进去，否则只分开最外层带*的参数只能用位置传参
带**的情况
def func(**kwargs):#**情况一般写kwargs
print(kwargs)
func(k1 = 1, k2 = 'ran')
#输出：{'k1': 1, 'k2': 'ran'} ，为字典整个代码环境从上到下执行的地方，叫做全局作用域。
函数没有执行的时候那几行代码实际是跳过的，这就叫局部作用域。 只有在你调用这个函数的时候，这几行代码才开始从上到下执行。 作用域中的数据归自己所有，别人访问不到。 只有最后会返回一个值到全局中去。
作用域中引用数据规则：优先在自己的作用域找，自己的找不到就去父级， 直到全局作用域，全局都没有就报错。
global 可以作用到全局
name = 'ran'
def func():
global name #这下就把“hao” 给赋到全局变量里面了，不然只有在函数作用域里name = hao
name = "hao"
func()nonlocal 函数以此类推，只赋到上一级变量
以后写全局变量名字必须大写，局部变量可大可小写
函数也可以和变量一样进行赋值
def func():
print(1)
v1 = func
v1() #这样也可以用函数以此内推，函数名也可以进行调用，例如嵌入到列表里
def func():
print(1)
V_list = [func,func2] #这个列表里有两个函数， 可以根据需要进行调用，调用后加括号即可执行同样，函数可以当作字典的value，但是一般不当key
为函数创建一块区域为其维护自己数据，以后执行时方便调用
def outer(x):
def inner(y):
return x + y
return inner inner(y)就是这个内部函数，对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域outer里面，但不在全局作用域里，则这个内部函数inner就是一个闭包
装饰器的作用是在原函数的基础上添加功能，但是不破坏原函数的结构。 做法是包上一层。
def wrapper(func):
def inner():
# 想在原函数基础上增加打印“登录” 这个功能
print("登录")
func() #原函数f1被当作参数传到func中了，所以此处就是运行原函数
return func() #装饰器结束，返回和原函数一样的值
return inner
@wrapper # f1 = wrapper(f1)的简写(也叫语法糖) ， 这样func=f1函数，f1又重新定义为inner函数了
#@www(9) 这种情况，先计算函数的返回值，随后必须得到的是一个函数名，然后再同理上面一步
def f1():
# 这是基本的函数，实现打印123
print(1)
f1()这样可以保证调用接口还是f1()，新增了功能。 返回值不变
如此看最外层wrapper好像多此一举，好像只需内层函数就满足了新增功能的需求。 其实外层函数的作用是让这个嵌套不执行，保持和原来一样的启动方式。
如果不加入万能参数，装饰器就不能同时应对存在不同数量参数这种情况。
def wrapper(func):
def inner(*args,**kwargs): #这样完美解决，想传啥就传啥~
print("登录")
func(*args,**kwargs)
return func()
return innerval = [i for i in "ran"] #循环ran的字符，每循环一个，就加入到val这个列表中
val = [100 for i in "ran"] #每循环一次，就添加“100”到列表中
val = [func for i in "ran"] #每循环一次，还可以添加函数到列表里，但是不会执行注意：
在列表里面生成了10个函数，但是这些函数并没有执行，所以不会给i赋值。 因此列表中的10个函数的i都是一样的。 我们从列表中取任意函数来运行，返回值i都只能读取到 for循环结束的时候i的值9
def func:
return i
v8 = [func for i in range(10)]
print(v8[0]()) #无论取哪个函数，i的值都是循环结束时的9，之前循环0-8时，函数没有执行，所以也没存储0-8
字典，集合的推导式以此类推
import time
v = time.time() #获取当前时间，从0时区的1970年开始以秒为单位
time.sleep(5) #运行至此行停顿5秒函数自己调用自己，尽量不要用递归，因为效率低，内存一直在用。 最好用while循环代替。
斐波那契数列： 从第三项开始，每一项都等于前2项之和。 1、1、2、3、5、
def func(a, b):
print(b)
func(b, a + b)
func(0, 1)相当于把装饰器再包裹一层，这样可以获得一个可以随时调用的变量、
def x(counter):
def wrapper(func):
def inner(*args,**kwargs):
print("登录")
func(*args,**kwargs)
return func()
return inner
return wrapper
@x(9)#可以传参数
def f1():
pass标签：oca 作用 结构 语法 文件的操作 不用 面向对象 位置 key
原文地址：https://www.cnblogs.com/buono/p/12500177.html
