python函数做参数 Python中函数的参数

python函数调用的参数传递

python的函数参数传递是"引用传递（地址传递）"。

成都地区优秀IDC服务器托管提供商(成都创新互联).为客户提供专业的电信内江机房,四川各地服务器托管,电信内江机房、多线服务器托管.托管咨询专线：18980820575

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

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

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

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

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

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

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

Python的函数参数总结

import math

a = abs

print(a(-1))

n1 = 255

print(str(hex(n1)))

def my_abs(x):

# 增加了参数的检查

if not isinstance(x, (int, float)):

raise TypeError('bad operand type')

if x = 0:

return x

else:

return -x

print(my_abs(-3))

def nop():

pass

if n1 = 255:

pass

def move(x, y, step, angle=0):

nx = x + step * math.cos(angle)

ny = y - step * math.sin(angle)

return nx, ny

x, y = move(100, 100, 60, math.pi / 6)

print(x, y)

tup = move(100, 100, 60, math.pi / 6)

print(tup)

print(isinstance(tup, tuple))

def quadratic(a, b, c):

k = b * b - 4 * a * c

# print(k)

# print(math.sqrt(k))

if k 0:

print('This is no result!')

return None

elif k == 0:

x1 = -(b / 2 * a)

x2 = x1

return x1, x2

else:

x1 = (-b + math.sqrt(k)) / (2 * a)

x2 = (-b - math.sqrt(k)) / (2 * a)

return x1, x2

print(quadratic(2, 3, 1))

def power(x, n=2):

s = 1

while n 0:

n = n - 1

s = s * x

return s

print(power(2))

print(power(2, 3))

def enroll(name, gender, age=8, city='BeiJing'):

print('name:', name)

print('gender:', gender)

print('age:', age)

print('city:', city)

enroll('elder', 'F')

enroll('android', 'B', 9)

enroll('pythone', '6', city='AnShan')

def add_end(L=[]):

L.append('end')

return L

print(add_end())

def add_end_none(L=None):

if L is None:

L = []

L.append('END')

return L

print(add_end_none())

def calc(*nums):

sum = 0

for n in nums:

sum = sum + n * n

return sum

print(calc(1, 2, 3))

print(calc())

l = [1, 2, 3, 4]

print(calc(*l))

def foo(x, y):

print('x is %s' % x)

print('y is %s' % y)

foo(1, 2)

foo(y=1, x=2)

def person(name, age, **kv):

print('name:', name, 'age:', age, 'other:', kv)

person('Elder', '8')

person('Android', '9', city='BeiJing', Edu='人民大学')

extra = {'city': 'Beijing', 'job': 'Engineer'}

person('Jack', 24, **extra)

def person2(name, age, *, city, job):

print(name, age, city, job)

person2('Pthon', 8, city='BeiJing', job='Android Engineer')

def person3(name, age, *other, city='BeiJing', job='Android Engineer'):

print(name, age, other, city, job)

person3('Php', 18, 'test', 1, 2, 3)

person3('Php2', 28, 'test', 1, 2, 3, city='ShangHai', job='Pyhton Engineer')

def test2(a, b, c=0, *args, key=None, **kw):

print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'key=', key, 'kw =', kw)

test2(1, 2, 3, 'a', 'b', 'c', key='key', other='extra')

args = (1, 2, 3, 4)

kw = {'d': 99, 'x': '#'}

test2(*args, **kw)

Python:函数的参数、混搭、开包

位置参数适合参数少的情况，当参数较多时，位置容易存错。

关键词参数适合参数较多时，通过指定关键词来存。

混搭时应注意先放位置参数后放关键词参数，否则会出现语法错误。语法上允许混搭，但尽量不要采用。

d在*的前面，可以作为位置参数，不用指定关键词，*后面必须指定关键词，可以混搭。

一旦设置默认值，可以不传它；但也可以继续传入，传了多少就是多少。默认参数需要注意，现房非默认参数再放默认参数。

当参数是多个时，可以在变量前面加*，表示零到无穷多个位置参数，传入的参数会被合并为一个元组，若需要破开元组，只需要在元组前面加上*。注意要先固定参数再可变参数。

在变量前加**，表示可变参数是关键词参数，在调用时必须用键值对来调用。

顺序必须是：必选参数、默认参数、可变位置参数、命名关键字参数和可变关键字参数。

/ 前面一定为位置参数

文章知识点与官方知识档案匹配，可进一步学习相关知识！！！

在python的函数中，如何将列表list的一部分作为函数的参数？

后面paraTestList(a[2:])中，括号里面的a[2:]命令是指创建了一个包含列表a的一部分的一个副本列表。具体做法是：

def

paraTestList(L):

L[0]='z'

a=['a','b','c','d']

b=a[2:]

paraTestList(b)

print(b)

具体情况如下：

1.Python的函数定义简单但灵活度大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，也可以简化调用者的代码。

2.默认参数可以简化函数的调用，设置默认参数时要注意：一是必选参数在前，默认参数在后，否则Python的解释器会报错；二是如何设置默认参数。当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

3.默认参数降低了函数调用的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现。无论是简单调用还是复杂调用，函数只需要定义一个。

4.有多个默认参数时，调用的时候，既可以按顺序提供默认参数。

4.Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

Python的函数和参数

parameter 是函数定义的参数形式

argument 是函数调用时传入的参数实体。

对于函数调用的传参模式，一般有两种：

此外，

也是关键字传参

python的函数参数定义一般来说有五种: 位置和关键字参数混合，仅位置参数，仅关键字参数，可变位置参数，可变关键字参数。其中仅位置参数的方式仅仅是一个概念，python语法中暂时没有这样的设计。

通常我们见到的函数是位置和关键字混合的方式。

既可以用关键字又可以用位置调用

或

这种方式的定义只能使用关键字传参的模式

f(*some_list) 与 f(arg1, arg2, ...) （其中some_list = [arg1, arg2, ...]）是等价的

网络模块request的request方法的设计

多数的可选参数被设计成可变关键字参数

有多种方法能够为函数定义输出：

非常晦涩

如果使用可变对象作为函数的默认参数，会导致默认参数在所有的函数调用中被共享。

例子1：

addItem方法的data设计了一个默认参数，使用不当会造成默认参数被共享。

python里面，函数的默认参数被存在__default__属性中，这是一个元组类型

例子2：

在例子1中，默认参数是一个列表，它是mutable的数据类型，当它写进 __defauts__属性中时，函数addItem的操作并不会改变它的id，相当于 __defauts__只是保存了data的引用，对于它的内存数据并不关心，每次调用addItem，都可以修改 addItem.__defauts__中的数据，它是一个共享数据。

如果默认参数是一个imutable类型，情况将会不一样,你无法改变默认参数第一次存入的值。

例子1中，连续调用addItem('world') 的结果会是

而不是期望的

本文题目：python函数做参数 Python中函数的参数
转载来源：http://ybzwz.com/article/hpcjde.html