python函数传递内存 python调用存储过程参数传递

python函数调用的参数传递

python的函数参数传递是"引用传递(地址传递)"。

在成都做网站、成都网站建设、成都外贸网站建设过程中,需要针对客户的行业特点、产品特性、目标受众和市场情况进行定位分析,以确定网站的风格、色彩、版式、交互等方面的设计方向。成都创新互联还需要根据客户的需求进行功能模块的开发和设计,包括内容管理、前台展示、用户权限管理、数据统计和安全保护等功能。

python中赋值语句的过程(x = 1):先申请一段内存分配给一个整型对象来存储数据1,然后让变量x去指向这个对象,实际上就是指向这段内存(这里有点和C语言中的指针类似)。

在Python中,会为每个层次生成一个符号表,里层能调用外层中的变量,而外层不能调用里层中的变量,并且当外层和里层有同名变量时,外层变量会被里层变量屏蔽掉。函数  调用  会为函数局部变量生成一个新的符号表。

局部变量:作用于该函数内部,一旦函数执行完成,该变量就被回收。

全局变量:它是在函数外部定义的,作用域是整个文件。全局变量可以直接在函数里面应用,但是如果要在函数内部改变全局变量,必须使用global关键字进行声明。

注意 :默认值在函数  定义  作用域被解析

在定义函数时,就已经执行力它的局部变量

python中不可变类型是共享内存地址的:把相同的两个不可变类型数据赋给两个不同变量a,b,a,b在内存中的地址是一样的。

python怎么给函数传参

函数参数传递机制问题在本质上是调用函数(过程)和被调用函数(过程)在调用发生时进行通信的方法问题。基本的参数传递机制有两

种:值传递和引用传递。

推荐:Python教程

值传递(passl-by-value)过程中,被调函数的形式参数作为被调函数的局部变量处理,即在堆栈中开辟了内存空间以存放由主调函数放

进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函

数的实参变量的值。

引用传递(pass-by-reference)过程中,被调函数的形式参数虽然也作为局部变量在堆栈中开辟了内存空间,但是这时存放的是由主调函

数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过堆栈中存放的地址访问主调函数中的实参变量。正

因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

更多技术请关注Python视频教程。

python中函数的作用

Python 函数定义以及参数传递

1.函数定义

#形如def func(args...):

doSomething123

以关键字def 开头,后面是函数名和参数下面是函数处理过程。

举例:

def add( a, b ):

return a+b12

参数可以设定默认值,如:

def add( a, b=10 ): #注意:默认值参数只会运算一次

return a+b12

默认值参数只会运算一次是什么意思?

def func( a, b=[] ): #b的默认值指向一个空的列表,每次不带默认值都会指向这块内存

b.append(a) return b

print(func(1))#向默认的空列表里加入元素1 ,默认列表里已经是[1]print(func(2))#向默认的列表里加入元素2,默认列表里已经是[1,2]print(func(3,[]))#向b指向的空列表里加入元素1 ,默认列表里还是[1,2]print(func(4))#向默认的列表里加入元素4,默认列表里已经是[1,2,4]'''

结果:

[1]

[1, 2]

[3]

[1, 2, 4]

'''12345678910111213141516

这下明白为什么默认参数只计算一次了吧,函数参数不传递时默认值总是指向固定的内存空间,就是第一次计算的空间。

2.参数传递

def func(a, b):

print('a=%d, b=%d' % (a,b) )12

在使用函数时可以如下方式,结果都是相同的

func(10,20) #不使用参数名,需要按参数顺序传递func(a=10,b=20) #使用参数名可以不按顺序传递func(b=20,a=10)#结果:a=10, b=20a=10, b=20a=10, b=201234567

如果函数定义形式如下方式:

def func(*args): #这种定义会把传递的参数包成元组

print(args,type(args))

func(10,20)#结果:#(10, 20) class 'tuple'1234567

举一个和上述过程相反的例子:

def func(a,b):

print('a=%d, b=%d' % (a,b) )

a = (10, 20)

func(*a) #在调用函数使用`*`则会把元组解包成单个变量按顺序传入函数#结果:a=10, b=20123456

总结:*号在定义函数参数时,传入函数的参数会转换成元组,如果 *号在调用时则会把元组解包成单个元素。

另一种定义:

def func(**kw):#使用**定义参数会把传入参数包装成字典dict

print(kw, type(kw) )

func(a=10,b=20)#这种函数在使用时必须指定参数值,使用key=value这种形式#结果:{'b': 20, 'a': 10} class 'dict'12345

相反的例子:

def func(a,b):

print('a=%d, b=%d' % (a,b) )

d = {'a':10, 'b':20 }

func(**d) #在调用时使用**会把字典解包成变量传入函数。12345

def func(*args, **kw):#这种形式的定义代表可以接受任意类型的参数

print(args,kw )12

总结:**号在定义函数参数时,传入函数的参数会转换成字典,如果 **号在调用时则会把字典解包成单个元素。

lambda表达式

lambda表达式就是一种简单的函数

形如 f = lambda 参数1,参数2: 返回的计算值

例如:

add = lambda x,y: x+y

print(add(1,2))'''

结果:3

'''12345

Python 的函数是怎么传递参数的

对象vs变量

在python中,类型属于对象,变量是没有类型的,这正是python的语言特性,也是吸引着很多pythoner的一点。所有的变量都可以理解是内存中一个对象的“引用”,或者,也可以看似c中void*的感觉。所以,希望大家在看到一个python变量的时候,把变量和真正的内存对象分开。

类型是属于对象的,而不是变量。

这样,很多问题就容易思考了。

例如:

对象vs变量

12

nfoo = 1 #一个指向int数据类型的nfoo(再次提醒,nfoo没有类型)lstFoo = [1] #一个指向list类型的lstFoo,这个list中包含一个整数1

可更改(mutable)与不可更改(immutable)对象

对应于上一个概念,就必须引出另了另一概念,这就是可更改(mutable)对象与不可更改(immutable)对象。

对于python比较熟悉的人们都应该了解这个事实,在python中,strings, tuples, 和numbers是不可更改的对象,而list,dict等则是可以修改的对象。那么,这些所谓的可改变和不可改变影响着什么呢?

可更改vs不可更改

12345

nfoo = 1nfoo = 2lstFoo = [1]lstFoo[0] = 2

代码第2行中,内存中原始的1对象因为不能改变,于是被“抛弃”,另nfoo指向一个新的int对象,其值为2

代码第5行中,更改list中第一个元素的值,因为list是可改变的,所以,第一个元素变更为2。其实应该说,lstFoo指向一个包含一个对象的数组。赋值所发生的事情,是有一个新int对象被指定给lstFoo所指向的数组对象的第一个元素,但是对于lstFoo本身来说,所指向的数组对象并没有变化,只是数组对象的内容发生变化了。这个看似void*的变量所指向的对象仍旧是刚刚的那个有一个int对象的list。

如下图所示:

Python的函数参数传递:传值?引用?

对于变量(与对象相对的概念),其实,python函数参数传递可以理解为就是变量传值操作,用C++的方式理解,就是对void*赋值。如果这个变量的值不变,我们看似就是引用,如果这个变量的值改变,我们看着像是在赋值。有点晕是吧,我们仍旧据个例子。

不可变对象参数调用

12345

def ChangeInt( a ): a = 10nfoo = 2 ChangeInt(nfoo)print nfoo #结果是2

这时发生了什么,有一个int对象2,和指向它的变量nfoo,当传递给ChangeInt的时候,按照传值的方式,复制了变量nfoo的值,这样,a就是nfoo指向同一个Int对象了,函数中a=10的时候,发生什么?(还记得我上面讲到的那些概念么),int是不能更改的对象,于是,做了一个新的int对象,另a指向它(但是此时,被变量nfoo指向的对象,没有发生变化),于是在外面的感觉就是函数没有改变nfoo的值,看起来像C++中的传值方式。

可变对象参数调用

12345

def ChangeList( a ): a[0] = 10lstFoo = [2]ChangeList(lstFoo )print nfoo #结果是[10]

当传递给ChangeList的时候,变量仍旧按照“传值”的方式,复制了变量lstFoo 的值,于是a和lstFoo 指向同一个对象,但是,list是可以改变的对象,对a[0]的操作,就是对lstFoo指向的对象的内容的操作,于是,这时的a[0] = 10,就是更改了lstFoo 指向的对象的第一个元素,所以,再次输出lstFoo 时,显示[10],内容被改变了,看起来,像C++中的按引用传递。

Python对象的拷贝

Python赋值操作或函数参数传递,传递的永远是对象引用(即内存地址),而不是对象内容。在Python中一切皆对象,对象又分为可变(mutable)和不可变(immutable)两种类型。对象拷贝是指在内存中创建新的对象,产生新的内存地址。当顶层对象和它的子元素对象全都是immutable不可变对象时,不存在被拷贝,因为没有产生新对象。浅拷贝(Shallow Copy),拷贝顶层对象,但不会拷贝内部的子元素对象。深拷贝(Deep Copy),递归拷贝顶层对象,以及它内部的子元素对象。

Python中一切皆对象,对象就像一个塑料盒子, 里面装的是数据。对象有不同类型,例如布尔型和整型,类型决定了可以对它进行的操作。现实生活中的"陶器"会暗含一些信息(例如它可能很重且易碎,注意不要掉到地上)。

对象的类型还决定了它装着的数据是允许被修改的变量(可变的mutable)还是不可被修改的常量(不可变的immutable)。你可以把不可变对象想象成一个透明但封闭的盒子:你可以看到里面装的数据,但是无法改变它。类似地,可变对象就像一个开着口的盒子,你不仅可以看到里面的数据,还可以拿出来修改它,但你无法改变这个盒子本身,即你无法改变对象的类型。

对象拷贝是指在内存中创建新的对象,产生新的内存地址。

浅拷贝(Shallow Copy),拷贝顶层对象,但不会拷贝内部的子元素对象。

2.1.1. 顶层是mutable,子元素全是immutable

当顶层对象是mutable可变对象,但是它的子元素对象全都是immutable不可变对象时,如[1, 'world', 2]

① 创建列表对象并赋值给变量a

② 导入copy模块,使用copy.copy()函数浅拷贝a,并赋值给变量b

③ 修改变量a的子元素a[0] = 3,由于整数是不可变对象,所以并不是修改1变为3,而是更改a[0]指向对象3

当顶层对象是 mutable可变对象 ,但子元素也存在 mutable可变对象 时,如 [1, 2, ['hello','world']]

① 浅拷贝 copy.copy() 只拷贝了顶层对象,没有拷贝子元素对象['hello','world'],即a[2]和b[2]指向同一个列表对象

② 修改a[2][1] = 'china',则b[2][1] = 'china'

当顶层对象是immutable不可变对象,同时它的子元素对象也全都是immutable不可变对象时,如(1, 2, 3)

变量a与变量b指向的是同一个元组对象,没有拷贝

当顶层对象是immutable不可变对象时,但子元素存在mutable可变对象时,如(1, 2, ['hello','world'])

变量a与变量b指向的是相同的元组对象,并且a[2]与b[2]指向同一个列表,所以修改a[2][1]会影响b[2][1]

深拷贝(Deep Copy),递归拷贝顶层对象,以及它内部的子元素对象

当顶层对象是mutable可变对象,但是它的子元素对象全都是immutable不可变对象时,如[1, 'world', 2]

变量a与变量b指向不同的列表对象,修改a[0]只是将列表a的第一个元素重新指向新对象,不会影响b[0]

当顶层对象是mutable可变对象,但子元素也存在mutable可变对象时,如[1, 2, ['hello','world']]

深拷贝既拷贝了顶层对象,又递归拷贝了子元素对象,所以a[2]与b[2]指向了两个不同的列表对象(但是列表对象的子元素初始指定的字符串对象一样),修改a[2][1] = 'china'后,它重新指向了新的字符串对象(内存地址为140531581905808),不会影响到b[2][1]

当顶层对象是immutable不可变对象,同时它的子元素对象也全都是immutable不可变对象时,如(1, 2, 3)

变量a与变量b指向的是同一个元组对象,不存在拷贝

当顶层对象是immutable不可变对象时,但子元素存在mutable可变对象时,如(1, 2, ['hello','world'])

变量a与变量b指向的是不同的元组对象,同时a[2]与b[2]指向不同的列表对象,所以修改a[2][1]不会影响b[2][1]

使用=是赋值,即将列表对象的引用也赋值给变量b,可以将列表对象想像成一个盒子,变量a相当于这个盒子上的标签,执行b = a后,相当于再在这个盒子上贴上b标签,a和b实际上指向的是同一个对象。因此,无论我们是通过a还是通过b来修改列表的内容,其结果都会作用于双方。

b/c/d都是a的复制,它们都指向了不同的列表对象,但是没有拷贝子元素,a[2]和b[2]/c[2]/d[2]指向同一个列表, 相当于浅拷贝的效果

使用分片[:]操作,a和b其实是指向同一个元组,而且没有拷贝子元素,a[2]和b[2]也指向同一个列表,相当于浅拷贝的效果

同列表类似,可以使用字典的copy()函数或者转换函数dict()

变量a与变量b/c指向不同的字典,但是没有拷贝子元素,a['jobs']和b['jobs']/c['jobs']指定同一个列表, 相当于浅拷贝的效果

同列表类似,可以使用集合的copy()函数或者转换函数set()

变量a与变量b/c指向不同的集合,而集合的元素必须是hashable,所以修改集合a不会影响到b/c


当前文章:python函数传递内存 python调用存储过程参数传递
本文网址:http://pwwzsj.com/article/hgpoch.html