python函数调用外部变量

python基础语法

n 换行；t 制表符;代码分隔
‘‘’ ‘’‘多行文本赋值
；多行语句写在一行（不符合PEP8规范）
关键字

python 自带的好用的函数
注：reduce() 函数在 python 2 是内置函数，从python 3 开始移到了 functools 模块

运算符

循环
迭代循环 for
条件循环 while
循环跳出：
break 终止循环
continue 跳过本次循环
pass 不执行，只是让代码看的完整
三元运算符
为真的结果 if 判定条件 else 为假的结果
标准数据类型
不可变类型
数值 number
字符串 string
元组 tuple
可变类型
列表 list
集合 set
字典 dict不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
函数必包：函数内部域能记住外部定义的参数和变量
变量搜索位置如果函数内部有先使用，如果没有则向上一层寻找。函数内的局部变量的生命周期随着函数的结束而结束。全局变量会一直存在，除非脚本运行结束或者del删除它。

# print_msg是外围函数
def print_msg():msg = "I'm closure"# printer是嵌套函数def printer():print(msg)return printer# 这里获得的就是一个闭包
closure = print_msg()
# 输出 I'm closure
closure()

偏函数
functools.partial() 固定位置参数

python函数

python 函数的参数传递：不可变类型：类似 c++ 的值传递，如整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。可变类型：类似 c++ 的引用传递，如列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

必备参数
必备参数须以正确的顺序传入函数，调用时的数量必须和声明时的一样。
关键字参数
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
默认参数
调用函数时，默认参数的值如果没有传入，则被认为是默认值。
可变参数通过*传入不定长的参数 *传递list tuple类型 **传递dict类型

l = [(1,3),(2,4)]
#通过*传入不定长的参数    *传递list tuple类型 **传递dict类型
a = zip(*l)
for i,j in a:print(i,j)

def total(a=5, *numbers, **phonebook):print('a', a)#遍历元组中的所有项目for single_item in numbers:print('single_item', single_item)#遍历字典中的所有项目for first_part, second_part in phonebook.items():print(first_part,second_part)print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))

当我们声明一个诸如 *param 的星号参数时，从此处开始直到结束的所有位置参数（Positional Arguments）都将被收集并汇集成一个称为“param”的元组（Tuple）。
类似地，当我们声明一个诸如 **param 的双星号参数时，从此处开始直至结束的所有关键字参数都将被收集并汇集成一个名为 param 的字典（Dictionary）。

装饰器

装饰器的本质是函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象，，主要用来装饰其他函数，也就是为其他函数添加附加功能

import time
def showtime(func):def wrapper():start_time = time.time()func()end_time = time.time()print('spend is {}'.format(end_time - start_time))return wrapper@showtime   这样方便 不然需要调用  #foo = showtime(foo)
def foo():print('foo..')time.sleep(3)@showtime   这样方便 不然需要调用  #doo = showtime(doo)
def doo():print('doo..')time.sleep(2)foo()
doo()#多好个函数都这么用 互相不冲突

带参数的装饰器

import time
def time_logger(flag = 0):def showtime(func):def wrapper(a, b):start_time = time.time()func(a,b)end_time = time.time()print('spend is {}'.format(end_time - start_time))if flag:print('将此操作保留至日志')return wrapperreturn showtime@time_logger(2)  #得到闭包函数showtime,add = showtime(add)
def add(a, b):print(a+b)time.sleep(1)add(3,4)

装饰器总结

def myDecorator(...):　　　　#定义装饰器，可能带参数def decorator(func):    #装饰器核心，以被装饰的函数对象为参数，返回装饰后的函数对象def wrapper(*args, **kvargs):    #装饰的过程，参数列表适应不同参数的函数...    #修改函数调用前的行为func(*args, **kvargs)    #调用函数...    #修改函数调用后的行为return wrapperreturn decorator@myDecorator(...):　　　　#给函数加上装饰器
def myFunc(...):　　　　  #自己定义的功能函数...

Python内置装饰器

在Python中有三个跟class相关的内置装饰器：staticmethod、classmethod 和property。

staticmethod 是类静态方法，其跟成员方法的区别是没有 self 参数，并且可以在类不进行实例化的情况下调用

classmethod 与成员方法的区别在于所接收的第一个参数不是 self （类实例的指针），而是cls（当前类的具体类型）

property 是属性的意思，表示可以通过通过类实例直接访问的信息

面向对象

type() #一切都可以用type()看类型，因为python一切皆对象
id()
dir()
isinstance([1,2,3],list)

其他部分代码：

from functools import reduce
reduce(lambda x,y:x*10+y,[1,2,3,4,5])#前面函数后面参数
：12345filter(lambda x: x not in numerical_columns, list(x_test.columns))def ChangeInt( a ):#函数的参数传递,不可变对象a = 10b = 2
ChangeInt(b)
print(b) # 结果是 2def changeme(mylist):#函数的参数传递,可变对象mylist.append([1,2,3,4])print("函数内取值: ", mylist)returnmylist = [10,20,30]
changeme( mylist )
print("函数外取值: ", mylist)
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]def printinfo( name, age ):#函数的参数传递,关键字参数print("Name: ", name)print("Age ", age)return#调用printinfo函数
printinfo(age=50, name="miki")def printinfo( name, age = 35 ):#函数的参数传递,默认参数"打印任何传入的字符串"print("Name: ", name)print("Age ", age)return#调用printinfo函数
printinfo(age=50, name="miki" )
printinfo(name="miki" )def printinfo( arg1, *vartuple ):#加了星号（*）的变量名会存放所有未命名的变量参数"打印任何传入的参数"print "输出: "print arg1for var in vartuple:print varreturn# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )