首页 > > 网络编程 > 其它 >

Python函数

2019-04-11 10:04:10来源：博客园阅读 ()

函数的定义：

编程中的函数是用最基础的指令来实现比较复杂的功能，在此期间可以把该过程中的众多子程序封装成另一个高一级的“指令”，我们可以给这个“指令”起一个名字，方便在以后调用.这个过程可以无限的抽象循环，创造更高一级的“指令”.

另外重要的一点，函数即变量

使用函数的好处

把经常使用的功能封装，减少代码量
便于统一维护和修改
具有更加良好的可扩展性

函数与过程的区别

过程就是没有返回值的函数，但是在Python里面如果没有返回值的话，就会自动返回None.因此严格来说，在Python里面只有函数，而没有过程.

当return值的数量为0时，返回None；数量为1时，返回object；数量大于1时，返回tuple类型

函数

 1 >>>def 函数名（形参）：
 2 >>>    """      注释      """
 3 >>>    [指令过程]
 4 >>>    return  ##也可以不用return
 5 
 6 ##########可以在函数里面添加默认的参数##########
 7 #在执行的过程中，没有传入参数覆盖默认的参数设置，就返回默认的值
 8 >>>def 函数名（形参, 形参 = 某值）：    ##默认形参必须放在参数群的最后面
 9 >>>    """      注释      """
10 >>>    [指令过程]
11 >>>    return  ##也可以不用return

位置参数和关键字参数

>>>def 函数名（形参）：
>>>    """      注释      """
>>>    [指令过程]
>>>    return res

#####调用#####
#####位置参数
>>>def 函数名(实参，实参，实参) 

#####关键字参数
>>>def 函数名(关键字 = 值，关键字 = 值)

#####位置参数与关键字参数混用
>>>def 函数名(实参，关键字 = 值，关键字 = 值)  ##实参必须在关键字参数的前面

接收多个参数

>>>def 函数名（形参,*args,**kwargs）：
>>>    """      注释      """
>>>    [指令过程]
>>>    return res

##  其中*args表示接收多余的位置参数，**kwargs表示接收多余的关键字参数，但是不能重复传值

嵌套函数和作用域，局部变量与全局变量

局部变量即指只能在局部被调用变量，即在函数内部被定义的变量，这种变量只能被该一级的函数或低级的子程序调用.

全局变量即指能在任何一级都能被调用的，这种变量基本都是函数外面被定义的.

函数的封装可以函数里面再调用函数，外面的变量也可以被里面的使用，但是里面的变量却不能被外面所调用.如果在这一级找不到所对应的变量，那么就会不断地自动到外面去找对应的变量，直到找到相关的变量为止.如果要把里面封装的变量作为全局变量，即在任何地方都能被调用的话，就可以使用如下方法：

1 >>>def func():
2 >>>   ………………
3 >>>    def func():
4 >>>    global 变量名    ##这样之后，变量就会变成全局变量
5 >>>    变量名 = 值
6 >>>    nonlocal 变量名
7 >>>    变量名 = 值      ##变量替代上一级的变量

作用域在定义函数时就已经固定住了，本身不会随着调用位置的改变而改变

 1 >>> def test():
 2     print("Good morning!"    
 3 >>> def test1():
 4     return test
 5 >>> bar = test1()    ##获得函数test()的内存地址
 6 >>> bar()            ##运行test()
 7 Good morning!
 8 
 9 >>> name = "YuanMing"
10 >>> def func1():
11     name = "Hermaeus"
12     def func2():
13         name = "Duke_Yuan"
14         def func3():
15             print(name)
16         return func3
17     return func2
18 #####执行方式一
19 >>> test1 = func1
20 >>> test1 = func1()
21 >>> test2 = test1()
22 >>> test2()
23 Duke_Yuan   ##随着定义域不断向上级找变量
24 #####执行方式二
25 >>> func1()()()
26 Duke_Yuan

递归函数

在嵌套函数中，可以对函数自身无限再调用，而构成了一个无限调用的过程，这种函数被称之为递归函数.但是递归函数必须满足以下条件：

必须有一个明确的结束条件

每次进入更深一层递归时，问题规模相比上次递归都应有所减少

递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

 1 >>> def calc(n):
 2     if n == 10:
 3         return n
 4     print(n)
 5     calc(n+1)    
 6 >>> calc(0)
 7 0
 8 1
 9 2
10 3
11 4
12 5
13 6
14 7
15 8
16 9

匿名函数

 1 >>>lambda 形参：[表达式]
 2 ##########该匿名函数表示
 3 >>>def 函数名()：
 4 >>>    return 表达式
 5 
 6 ##########调用 
 7 >>> func = lambda x,y:x*y
 8 >>> func(1,2)
 9 2
10 
11 ##########要返回多个值
12 >>> func = lambda x, y, z:(x+1, y+1, z+1)  ##必须要加括号
13 >>> func(1,2,3)
14 (2, 3, 4)

函数式编程

高阶函数

满足下面两个任意条件之一的都叫做“高阶函数”：

函数的传入参数是一个函数名
函数的返回值是一个函数名

map()函数 map(func, *iterables)

处理序列里面每一个值，返回迭代器

1 >>> test = [1, 2, 3, 4, 5, 6]
2 >>> print(list(map(lambda x:x**2, test)))
3 [1, 4, 9, 16, 25, 36]

filter()函数 filter(function or None, iterable)

判断筛序列里面的元素，如果是True就保留，返回迭代器

1 >>> lis = ["ADC", "AD", "ad", "ae"]
2 >>> print(list(filter(lambda n:n.startswith("A"), lis)))
3 ['ADC', 'AD']
4 >>> print(list(filter(lambda n:n.isupper(), lis)))
5 ['ADC', 'AD']
6 >>> print(list(filter(lambda n:n.islower(), lis)))
7 ['ad', 'ae']

reduce()函数 reduce(function, sequence[, initial])

在Python 3里已经把reduce方法放入functools工具包里面了，整体处理列表里面的值，如让所有元素相加相乘，返回值

1 >>> from functools import reduce
2 >>> lis = [1,2,3,4,5]
3 >>> print(reduce(lambda x,y:x*y, lis, 10))
4 1200

内置函数

[官方解释链接]

abs（x ）

返回数字的绝对值.参数可以是整数或浮点数。如果参数是复数，则返回其大小.

1 >>> abs(-1)
2 1
3 >>> abs(-12)
4 12

all(iterable)

返回True如果的所有元素迭代是真的（或者如果可迭代为空）,为False的有0，空，None

1 >>> print(all([0, [], 1]))
2 False
3 >>> print(all([1, 2, 3]))
4 True

any(iterable)

返回True如果iterable的任何一个元素为bool时是True。如果iterable为空，则返回False

1 >>> print(any([0, None, []]))
2 False
3 >>> print(any([1, 0, None]))
4 True

ascii(object)

bin（x ）

将整数转换为前缀为“0b”的二进制字符串

1 >>> bin(3)
2 '0b11'
3 >>> bin(-10)
4 '-0b1010

bool(x)

返回bool值，如果为0，空，None则为False

1 >>> bool(0)
2 False
3 >>> bool(None)
4 False
5 >>> bool([])
6 False
7 >>> bool(12)
8 True

bytes([source[, encoding[, errors]]])

把source编译成指定编码

>>> name = "YuanMing"
>>> print(bytes(name, encoding = "UTF-8"))
b'YuanMing'
>>> print(bytes(name, encoding = "GBK"))
b'YuanMing'

callable(object)

1、方法用来检测对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用.

2、可调用对象，在实际调用也可能调用失败；但是不可调用对象，调用肯定不成功.

3、类对象都是可被调用对象，类的实例对象是否可调用对象，取决于类是否定义了call方法.

1 >>> name = "YuanMing"
2 >>> callable(bool)
3 True
4 >>> callable(name)
5 False
6 >>> callable(1)
7 False

chr(i)

返回表示Unicode代码点为整数i的字符的字符串

>>> chr(13)
'\r'
>>> chr(374)
'?'
>>> chr(45)
'-'

complex([real[, imag]])

创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数

>>> print(complex(1,2))
(1+2j)
>>> print(complex(1))
(1+0j)
>>> print(complex("1+2j"))
(1+2j)

dict()

创建字典

dir([object])

函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'bar', 'func', 'func1', 'lis', 'name', 'reduce', 'test', 'test1', 'test2', 'x']
>>> dir(bar)
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

divmod(a, b)

返回一个包含商和余数的元组(a // b, a % b)

>>> divmod(4,3)
(1, 1)
>>> divmod(7,2)
(3, 1)

enumerate(sequence, [start=0])

把可迭代序列变为一个索引序列

>>> name = ["YuanMing", "Marsh", "Jack"]
>>> for i,k in enumerate(name,2):
    print(i,k)    
2 YuanMing
3 Marsh
4 Jack

eval(expression[, globals[, locals]])

执行一个字符串表达式，并返回表达式的值

expression -- 表达式；globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象；locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象

>>> print(eval("1+2"))
3
>>> n = 3
>>> print(eval("n+1"))
4

exec(object[, globals[, locals]])

执行储存在字符串或文件中的 Python 语句

object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。

locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。

>>> func_program = "print('You are so good')"
>>> exec(func_program)
You are so good
>>> exec("print('Good!')")  ##冒号数量不能一样
Good!

float([x])

将整数和字符串转换成浮点数

>>> float(2)
2.0
>>> float(2.13)
2.13

hash(object)

获取一个对象（字符串或者数值等）的hash值

>>> hash("YuanMing")
5942654411917565357

help([object])

查看函数或模块用途的详细说明

>>> help(help)
Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |      Call self as a function.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

hex(x)

将10进制整数转换成16进制，以字符串形式表示

>>> hex(17)
'0x11'
>>> hex(21481)
'0x53e9'

id([object])

获取对象的内存地址

>>> name = 'YuanMing'
>>> id(name)
1725836378160
>>> number = 23
>>> id(number)
1674538704

input([prompt])

接受一个标准输入数据，返回为 string 类型

int(x, base=10)

将一个字符串或数字转换为整型，base是以什么为基础处理

>>> int("3")
3
>>> int(2.41)
2

isinstance(object, classinfo)

判断一个对象是否是一个已知的类型

sinstance() 与 type() 区别：

- type() 不会认为子类是一种父类类型，不考虑继承关系。
- isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()

>>> test = "1"
>>> isinstance(test,str)
True
>>> isinstance(test,int)
False

iter(object[, sentinel])

用来生成迭代器

>>> lis = [1,2,3]
>>> for i in iter(lis):
    print(i)    
1
2
3

len(s)

测量数量

>>> name = ["Jack", "Marsh", "Ada"]
>>> len(name)
3
>>> len("akhfajfal")
9

max( x, y, z, .... )

求最大值

>>> max(15, 17, 1, 28)
28
>>> max([1,4,27,83])
83

min( x, y, z, .... )

求最小值

>>> min(15, 17, 1, 28)
1
>>> min([1,4,27,83])
1

next(iterator[, default])

返回迭代器的下一个项目

oct(x)

将一个整数转换成8进制字符串

>>> oct(14)
'0o16'
>>> oct(6472)
'0o14510

open(name[, mode[, buffering]])

打开文本

print(*objects, sep=' ', end='\n', file=sys.stdout)

objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file -- 要写入的文件对象。

>>> print("y","m",sep="-",end='%%')
y-m%%

range(start, stop[, step])

返回的是一个可迭代对象（类型是对象），而不是列表类型，所以打印的时候不会打印列表

>>> range(1,6)
range(1, 6)
>>> for i in range(1,6):
    print(i)    
1
2
3
4
5

repr(object)

将对象转化为供解释器读取的形式

>>> name = "YuanMing"
>>> repr(name)
"'YuanMing'"

reversed(seq)

返回一个反转的迭代器

>>> lis = [1,2,3,4]
>>> reversed(lis)
<list_reverseiterator object at 0x00000191D3DD6E48>
>>> for i in reversed(lis):
    print(i)    
4
3
2
1

round( x [, n] )

返回浮点数x的四舍五入值

>>> round(15.2174113,4)
15.2174

slice(start, stop[, step])

实现切片对象，主要用在切片操作函数里的参数传递

>>> myslice = slice(1,7,2)
>>> arr = range(10)
>>> arr[myslice]
range(1, 7, 2)

sorted(iterable, key=None, reverse=False)

排序

>>> lis = [3,2,9,5,4,6,7,1]
>>> print(sorted(lis, key = lambda x:x**-1, reverse=True))
[1, 2, 3, 4, 5, 6, 7, 9]

str(object='')

转换为str类型

>>> str(1)
'1'

sum(iterable[, start])

求和

>>> sum([1,2,3,4,5])
15

type(name, bases, dict)

判断数据类型

>>> type("1")
<class 'str'>
>>> type(1)
<class 'int'>
>>> type([1,2])
<class 'list'>

zip([iterable, ...])

将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)
>>> print(list(zipped))
[(1, 4), (2, 5), (3, 6)]
>>> print(list(zip(a,c)))
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b))   ## *zip为解压
>>> print(list(a1), list(a2))
[1, 2, 3] [4, 5, 6]

vars([object])

没有object时，就相当于local()；有object时，就返回当前object所有的方法

>>> def print_hello():
    msg = "Hello, World!"
    print(locals())
    print(vars())
>>> print_hello()
{'msg': 'Hello, World!'}
{'msg': 'Hello, World!'}
{'msg': 'Hello, World!'}
{'msg': 'Hello, World!'}
>>> print(vars(int))
{'__repr__': <slot wrapper '__repr__' of 'int' objects>, '__hash__': <slot wrapper '__hash__' of 'int' objects>, '__str__': <slot wrapper '__str__' of 'int' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'int' objects>, '__lt__': <slot wrapper '__lt__' of 'int' objects>, '__le__': <slot wrapper '__le__' of 'int' objects>, '__eq__': <slot wrapper '__eq__' of 'int' …………………………………………………………