python基础函数一

最新推荐文章于 2021-02-22 18:37:19 发布

weixin_30878361

最新推荐文章于 2021-02-22 18:37:19 发布

阅读量72

点赞数

文章标签： python c/c++

原文链接：http://www.cnblogs.com/sniperths/p/10484136.html

版权

Python3 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

Python 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
    函数体

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

实例

让我们使用函数来输出"Hello World！"：

>>>def hello() : print("Hello World!") >>> hello() Hello World! >>>

更复杂点的应用，函数中带上参数变量:

实例(Python 3.0+)

#!/usr/bin/python3 # 计算面积函数 def area(width, height): return width * height def print_welcome(name): print("Welcome", name) print_welcome("Runoob") w = 4 h = 5 print("width =", w, " height =", h, " area =", area(w, h))

以上实例输出结果：

Welcome Runoob
width = 4 height = 5 area = 20

函数调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

如下实例调用了 printme() 函数：

实例(Python 3.0+)

#!/usr/bin/python3 # 定义函数 def printme( str ): # 打印任何传入的字符串 print (str) return # 调用函数 printme("我要调用用户自定义函数!") printme("再次调用同一函数")

以上实例输出结果：

我要调用用户自定义函数!
再次调用同一函数

参数传递

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

a=[1,2,3] a="Runoob"

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

可更改(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 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python 传不可变对象实例

实例(Python 3.0+)

#!/usr/bin/python3 def ChangeInt( a ): a = 10 b = 2 ChangeInt(b) print( b ) # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例

可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

实例(Python 3.0+)

#!/usr/bin/python3 # 可写函数说明 def changeme( mylist ): "修改传入的列表" mylist.append([1,2,3,4]) print ("函数内取值: ", mylist) return # 调用changeme函数 mylist = [10,20,30] changeme( mylist ) print ("函数外取值: ", mylist)

传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]] 函数外取值: [10, 20, 30, [1, 2, 3, 4]]

函数的参数类型

位置参数（必须参数）

在函数定义的时候直接给定形式参数的名称，调用时按照参数的位置赋予参数值

注意，如果在一个函数中定义了多个位置参数，在调用赋值的时候，必须按照定义的顺序依次赋值。

>>> def func(a,b,c):
    print('a:', a)
    print('b:', b)
    print('c:', c)

    
>>> func(1,2,3)
a: 1
b: 2
c: 3

默认参数

在函数定义的时候，给形式参数赋予一个默认值

调用函数的时候，如果没有给该参数赋新值，则使用函数定义时的默认值

如果位置参数和默认参数都存在，则必须将位置参数放在默认参数前

>>> def func(a,b,c=100):
    print('a:', a)
    print('b:', b)
    print('c:', c)

    
>>> func(1,2)
a: 1
b: 2
c: 100
>>> func(1,2,3)
a: 1
b: 2
c: 3

不定长参数（可变参数）

把没有名称，也没有位置，没有对应关系的参数放入到一个集合中（tuple）

实际传入的参数可以是任意多个，也可以没有

>>> def func(a,b,*args):
print('a:', a)
print('b:', b)
print('args:', args)


>>> func(1,2)
a: 1
b: 2
args: ()
>>> func(1,2,3,4,5,6,7)
a: 1
b: 2
args: (3, 4, 5, 6, 7)
>>> func(1,2,*(3,4,5,6,7))
a: 1
b: 2
args: (3, 4, 5, 6, 7)
>>>

关键字参数

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：

>>> def person(name, age, **kwargs):
print('name:', name)
print('age:', age)
print('kwargs:', kwargs)

>>> person('jack', 60)
name: jack
age: 60
kwargs: {}

>>> person('jack', 60, city='shanghai', gender='female')
name: jack
age: 60
kwargs: {'city': 'shanghai', 'gender': 'female'}

>>> person('jack', 60, **{'city':'shanghai', 'gender':'female'})
name: jack
age: 60
kwargs: {'city': 'shanghai', 'gender': 'female'}

关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

关键字参数是在函数调用的时候，通过参数名制定需要赋值的参数，这样做就不怕因为搞不清参数的顺序而导致函数调用出错。

而默认参数是在参数定义的过程中，为形参赋初值，当函数调用的时候，不传递实参，则默认使用形参的初始值代替。

命名关键字参数(不常用)

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

如下例子表示只接收city和gender作为关键字参数。

>>> def person(name, age, *, city, gender):
    print(name, age, city, gender)

    
>>> person('Jack', 60, city='shanhai', gender='female')
Jack 60 shanhai female
>>>