python3基础——函数（2）

函数的参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]

a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），能够是 List 类型对象，也能够指向 String 类型对象。

变量从新赋值会生成一个新的数据，以前的会被覆盖更新，指针指向的内存没有变化。

>>> a=10
>>> a
10
>>> a=5
>>> a
5
>>>

2.

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

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是能够修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，至关于新生成了a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，自己la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：相似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象自己。好比在 fun（a）内部修改 a 的值，只是修改另外一个复制的对象，不会影响 a 自己。

• 可变类型：相似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义咱们不能说值传递仍是引用传递，咱们应该说传不可变对象和传可变对象。

>>> def changint(a):
...     a=10
...     if a>0:
...             print(a*4)
...
>>> b=2
>>> changint(b)
40
>>> print(b)
2

>>> def  changel(list):
...     list=[1,2,34,32]
...     list.append(['apple','bule','green'])
...     print(list)
...
>>> b=['12','banana']
>>> changel(b)
[1, 2, 34, 32, ['apple', 'bule', 'green']]

>>> def changeint(a):
...     a=10
...     print(a*4)
...
>>> def changeint(a):
...     a=10
...     print(a*10)
...     return
...
>>> a=15
>>> changeint(a)
100
>>> print(a)
15

参数（与所调用的函数有关系）

• 必填的参数
• 不定长参数
• 关键字参数
• 默认参数

必填函数——必须填写一个实参，而不是虚参

>>> def printme(str):
...     print(str)
...     return
...
>>> printme()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: printme() missing 1 required positional argument: 'str'
>>>

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来肯定传入的参数值。

使用关键字参数容许函数调用时参数的顺序与声明时不一致，由于 Python 解释器可以用参数名匹配参数值。

如下实例在函数 printme() 调用时使用参数名：

>>> def printme(age,name):
...     print("请输入你的年龄：",age)
...     print("请输入你的名字:",name)
...     return
...
>>> printme(age=60,name='jack')
请输入你的年龄： 60
请输入你的名字: jack
>>> def mode(name,age):
...     print('请输入你的名字:',name)
...     print('请说出你的年龄:',age)
...     return
...
>>>
>>> mode(age=12,name='dava')
请输入你的名字: dava
请说出你的年龄: 12
>>>

默认参数：

python 使用 lambda 来建立匿名函数。

所谓匿名，意即再也不使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单不少。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有本身的命名空间，且不能访问本身参数列表以外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增长运行效率。

函数格式——lambda [arg1 [,arg2,.....argn]]:expression

>>> sum=lambda arg1,arg2:arg1+arg2

>>> print('相加后为:',sum(10,20))
相加后为: 30
>>> print('相加后值为:',sum(90,21))
相加后值为: 111
>>>

return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。以前的例子都没有示范如何返回数值，如下实例演示了 return 语句的用法：

>>> def coding(arg1,arg2):
...     y=arg1+arg2
...     print(y)
...     return y
...
>>> coding(23,45)
68
68
>>>

 

 

 

 

 

 

lambda [arg1 [,arg2,.....argn]]:expression