c++builder传递参数_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:可选。任意映射对象。