python中的参数与变量_python知识汇总(变量与参数)

变量的作用域？

1.在函数和类之外定义的变量，作用域为整个模块，从定义开始直到模块结束。

2.全局变量降低了函数的通用性和可读性，应该尽量避免使用

3.全局变量一般作为常量使用

4.函数内要改变全局变量的值，使用global声明一下

a = 10

def func():

global a

a = 100

print(locals()) #打印局部变量

print(global()) #打印全局变量

print(a) #a已被修改为100

nonlocal关键字：用于声明外层的局部变量

def f1():

b = 10

def f2():

nonlocal b

b = 20

f2()

print(b)

f1() #输出20

局部变量：

1. 函数体内声明的变量

2. 如果局部变量和全部变量同名，组内隐藏全局变量，只使用同名的局部变量

LEGB规则：

python查找“名称”时，按照LocalàEnclosed->Global->Built in->name error

Local:函数或类的方法内部

Enclosed:闭包(嵌套函数)

Global:全局变量

Built in:系统定义变量

编程建议：

局部变量的查询和访问速度比全局变量快，优先考虑使用。

遇到频繁使用变量的时，可以将全局变量转化为局部变量提高效率。

例

import time

import math

def func():

'''used global'''

start = time.time()

for i in range(10000000):

math.sqrt(30)

print('time is {0}'.format(time.time() - start))

def func_fast():

'''used local'''

b = math.sqrt

start = time.time()

for i in range(10000000):

b(30)

print('time is {0}'.format(time.time() - start))

func()

func_fast()

time is 2.0604796409606934

time is 1.2875733375549316

参数的传递

python一切都是引用，参数的传递都是引用传递。参数的传递本质上就是：从实参到形参的赋值操作。

通过引用修改可变对象，能够影响原值(字典、列表、集合、自定义对象)

通过引用修改不可变对象，系统会重新创建空间，放入修改后的值，不影响原对象(数字、字符串、元组、函数等)

a = [2,3]

def func(x):

ori = id(x)

x += [4]

print(ori == id(x)) #True

func(a)

print(a) #[2,3,4]

a = (2,3)

def func(x):

ori = id(x)

x += (4,)

print(ori == id(x)) #false

func(a)

print(a) #(2,3)

深拷贝和浅拷贝

浅拷贝：只拷贝对象本身

深拷贝：拷贝对象及其指向的所有对象(完全断开与源对象的关系)

import copy

#浅拷贝

a = [2,[3,4]]

b = copy.copy(a) #等价于b = a.copy()

print(id(a) == id(b)) #False

print(id(a[1]) == id(b[1])) #True

c = copy.deepcopy(a)

print(id(a) == id(c)) #False

print(id(a[1]) == id(c[1])) #False

传递含有可变对象的不可变对象(int、float、字符串、元组、布尔值等)是浅拷贝，但写入时会生成新的对象。

a = (2,[3,4])

def fun(x):

x[1][1] = 999

fun(a)

print(a) #(2, [3, 999])

参数的类型

位置参数：实参按位置顺序传递，需要个数和形参匹配。

默认值参数：为参数设置默认值，则此参数是可选的。

def fun(a,b,c = 10, d = 20):

print(a,b,c,d)

fun(8,9)

命名参数：按照形参的名称传递参数。

def fun(a, b, c):

print(a,b,c)

fun(8,9,10) #位置参数

fun(c=10, a=20, b=30) #命名参数

可变参数：指的是可变数量的参数，形式有两种

1.*param：将多个参数收集到一个元组对象中

2.**param：将多个参数收集到一个字典中

例：

def fun(x,*y):

print(x)

print(y)

fun(1,2,3,4)

out::1

out::(2, 3, 4)

例：

def fun(x,**y):

print(x)

print(y)

fun(1,name=5,age=8)

out::1

out::{'name': 5, 'age': 8}

强制命名参数：带星号的“可变参数”后面增加新的参数，必须是强制命名参数

def fun(*x,y):

print(x)

print(y)

fun(1,5) #错误

fun(1,y = 5) #正确

lambda表达式和匿名函数

lambda表达式生成一个函数对象，它的存在能够很方便的表示函数，避免了定义函数的繁琐，其语法如下

lambda arg1,arg2,arg3 : 表达式

例

y = lambda x1,x2: x1*x1 + x2 +1

print(y(3, 2))

eval()函数:实现通过字符串传递代码并执行

eval(“print(‘abcd’)”)

语法：eval(source[, globals[, locals]]) -> value

参数:

source:一个Python表达式或函数compile()返回的代码对象

globals:可选。必须是dictionary。

locals:可选。任意映射对象。