函数基础和函数参数

发表于 | 分类于 |
字数统计: 2.1k | 阅读时长 ≈ 9

函数基础和函数参数

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

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

函数基础

定义一个函数

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

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

演示：

我们打印几个列表

li = [1, 0, 5, 7, 9]
for i in li:
    print(i)

print('---------')

li = [1, 'A', 5, 7, 9]
for i in li:
    print(i)

print('---------')
li = [1, 3, 's', 7, 9]
for i in li:
    print(i)

输出结果：

1
0
5
7
9
---------
1
A
5
7
9
---------
1
3
s
7
9

有没有更简单的呢？

演示：

l1 = [1, 0, 5, 7, 9]
l2 = [1, 'A', 5, 7, 9]
l3 = [1, 0, 'S', 7, 9]

def demo(li):
	for i in li:
		print(i)

demo(l1)
print('---------')
demo(l2)
print('---------')
demo(l3)

输出结果

1
0
5
7
9
---------
1
A
5
7
9
---------
1
0
S
7
9

上述就是使用函数的形式来实现多个列表的打印，是不是比前面的更简单。

函数的定义

def 函数名(参数)：

pass

return 表达式

函数名命名规则： 字母、数字和下划线组成，和变量命名规则一致

return 后面可以返回任意表达式，但不能是赋值语句

注意：函数名定义和变量名的定义是一样的，只能使用字母、数字和下划线定义，不能以数字开头。

关键字

关键字是不能拿来做变量定义的。

演示：

In [3]: a
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-3-3f786850e387> in <module>()
----> 1 a

NameError: name 'a' is not defined

In [4]: def
  File "<ipython-input-4-7b18d017f89f>", line 1
    def
       ^
SyntaxError: invalid syntax

如果把关键字拿来定义，是会报语法错误的。

In [1]: import keyword

In [2]: print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

上述就是整个Python编程语言的全部关键字，在基础阶段都会提到的。

函数调用

l1 = [1, 0, 'S', 7, 9]

def demo(li):
    for i in li:
        print(i)

demo(l1)

调用方式：函数名（参数）

函数返回

l1 = [1, 0, 'S', 7, 9]

def demo(li):
    for i in li:
        print(i)
    return 'ok'

print(demo(l1))

输出：

1
0
S
7
9
ok

return：

注意 return 和 print 的区别，return是函数的返回值，返回值可以赋值给变量，而print只是打印出来

函数参数

那函数里面可以传入哪些对象呢？

def demo(x):
    print(x)

demo('demo')

输出

demo

如果我们不传值呢？

def demo(x):
    print(x)

demo()

输出

TypeError: demo() missing 1 required positional argument: 'x'

TypeError：demo()缺少一个必需的位置参数：’x’。

传入几个参数呢？

必备参数

def func(x):

pass

def demo(x):
    print(x)

demo(1, 2)

输出

TypeError: demo() takes 1 positional argument but 2 were given

一个参数对应一个数值

默认参数

def func(x, y=None):

pass

def demo(x, y=1):
    print(x, y)

demo(1, 2)
demo(3)

输出

1 2
3 1

y=1.就是默认参数，没有传入新参数的时候，就使用默认参数。

关键字参数

def demo(x, y=1):
    print(x, y)

demo(1, 2)
demo(y="q", x='s')

输出

1 2
s q

关键字参数，调用的时候带上参数名。

不定长参数

def func(args, *kwargs):

pass

注意：*+参数名

def demo(*args):
    print(args)

demo(1, 2, 3, 4)
demo(1)

输出

(1, 2, 3, 4)
(1,)

参数名前面加*号是不定长参数，输出是一个元组。

def demo(*a):
    print(*a)  # 加*：去除括号
    print(a)

demo(1, 2, 3, 4)
print('-------')
demo((1, 2, 3, 4))
print('-------')
demo(*(1, 2, 3, 4))

输出

1 2 3 4
(1, 2, 3, 4)
-------
(1, 2, 3, 4)
((1, 2, 3, 4),)
-------
1 2 3 4
(1, 2, 3, 4)

加*：去除括号

def demo(**a):
    print(a)

demo(x=1, y=2, s=2)

输出

{'x': 1, 'y': 2, 's': 2}

参数名前面加**号是不定长参数，输出是一个字典。

注意：传入的参数是键值对。

演示：

def demo(*args, **kwargs):
    print(args)
    print(kwargs)

demo(1, 2, 3, x=1, y=2, s=2)

输出

(1, 2, 3)
{'x': 1, 'y': 2, 's': 2}

传入的键值对，只能放在最后。

总结：

必备参数：在函数调用的时候，必备参数必须要传入

默认参数： 在函数调用的时候，默认参数可以不传入值，不传入值时，会使用默认参数

不定长参数：在函数调用的时候，不定长参数可以不传入，也可以传入任意长度。其中定义时，元组形式可以放到参数最前面，字典形式只能放到最后面

常见的内置函数

常见内置函数提供了一些处理的数据的方法，可以帮助我们提高开发速度

常见函数

len

求长度

li = [2,8,5]
In [6]: len(li)
Out[6]: 3
min

求最小值

li = [2,8,5]
In [6]: min(li)
Out[6]: 2
max

求最大值

li = [2,8,5]
In [8]: max(li)
Out[8]: 8
sorted

排序

li = [2,8,5]
In [9]: sorted(li)
Out[9]: [2, 5, 8]
reversed

反向

li = [2,8,5]
In [10]: reversed(li)
Out[10]: <list_reverseiterator at 0x7f68aa81af98>

In [11]: list(reversed(li))
Out[11]: [5, 8, 2]
sum

求和

li = [2,8,5]
In [12]: sum(li)
Out[12]: 15

进制转换函数

bin

二进制

In [13]: bin(12)
Out[13]: '0b1100'
oct

八进制

In [16]: oct(18)
Out[16]: '0o22
hex

十六进制

In [17]: hex(12)
Out[17]: '0xc'
ord

字符转ASCII码

In [19]: ord('a')
Out[19]: 97
chr

ASCII码转字符

In [20]: chr(97)
Out[20]: 'a'

扩展

enumerate

返回一个可以枚举的对象

In [21]: li = ['a','b','c','d']

In [22]: enumerate(li)
Out[22]: <enumerate at 0x7f68aa877d80>

In [23]: list(enumerate(li))
Out[23]: [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

In [24]: dict(enumerate(li))
Out[24]: {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
eval

取出字符串中内容

将字符串str当成有效的表达式来求值并返回计算结果

In [25]: a = "{'a':1}"

In [26]: eval(a)
Out[26]: {'a': 1}

In [27]: b = '1 + 2 + 3'

In [28]: eval(b)
Out[28]: 6
exec

执行字符串或complie方法编译过的字符串，没有返回值

In [29]: s = '''
    ...: z = 10
    ...: su = x + y + z
    ...: print(su)
    ...: print('OK')
    ...: '''

In [30]: x = 1

In [31]: y = 2

In [32]: exec(s)
13
OK

In [33]: exec(s,{'x':0,'y':0})
10
OK

In [34]: exec(s,{'x':0,'y':0},{'y':10,'z':0})  #以字符串为主,以最后的为主
20
OK

注意：eval 和 exec 是炸弹 能不能就不用，就好像你从不知道这东西一样，除非你足够的熟悉

filter

过滤器

In [38]: def test1(x):
    ...:     return x>10
    ...: l1 = [10,2,20,13,5]

In [39]: filter(test1, l1)
Out[39]: <filter at 0x7f68aa7ecb70>

In [40]: list(filter(test1, l1))
Out[40]: [20, 13]
map

对于参数iterable中的每个元素都应用fuction函数，并将结果作为列表返回

In [41]: l2 = [1,2,3]

In [42]: map(str,l2)
Out[42]: <map at 0x7f68aa7ecba8>

In [43]: list(map(str,l2))
Out[43]: ['1', '2', '3']
zip

将对象逐一配对

In [44]: l3 = [1,2,3]

In [45]: t1 = ('a','b','c')

In [46]: zip(t1,l3)
Out[46]: <zip at 0x7f68abb3ec48>

In [47]: list(zip(t1,l3))
Out[47]: [('a', 1), ('b', 2), ('c', 3)]

In [48]: dict(zip(t1,l3))
Out[48]: {'a': 1, 'b': 2, 'c': 3}
------ 本文结束 🎉🎉 谢谢观看 ------
0%