Python函数

函数的定义：

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

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

使用函数的好处

1. 把经常使用的功能封装，减少代码量

2. 便于统一维护和修改

3. 具有更加良好的可扩展性

函数与过程的区别

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

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

函数

>>>def 函数名（形参）：
>>>    """      注释      """
>>>    [指令过程]
>>>    return  ##也可以不用return

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

位置参数和关键字参数

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

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

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

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

接收多个参数

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

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

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

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

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

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

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

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

>>> def test():
    print("Good morning!"    
>>> def test1():
    return test
>>> bar = test1()    ##获得函数test()的内存地址
>>> bar()            ##运行test()
Good morning!

>>> name = "YuanMing"
>>> def func1():
    name = "Hermaeus"
    def func2():
        name = "Duke_Yuan"
        def func3():
            print(name)
        return func3
    return func2
#####执行方式一
>>> test1 = func1
>>> test1 = func1()
>>> test2 = test1()
>>> test2()
Duke_Yuan   ##随着定义域不断向上级找变量
#####执行方式二
>>> func1()()()
Duke_Yuan

递归函数

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

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

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

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

>>> def calc(n):
    if n == 10:
        return n
    print(n)
    calc(n+1)    
>>> calc(0)
0
1
2
3
4
5
6
7
8
9

匿名函数

>>>lambda 形参：[表达式]
##########该匿名函数表示
>>>def 函数名()：
>>>    return 表达式

##########调用 
>>> func = lambda x,y:x*y
>>> func(1,2)
2

##########要返回多个值
>>> func = lambda x, y, z:(x+1, y+1, z+1)  ##必须要加括号
>>> func(1,2,3)
(2, 3, 4)

函数式编程

高阶函数

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

1. 函数的传入参数是一个函数名

2. 函数的返回值是一个函数名

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

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

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

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

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

>>> lis = ["ADC", "AD", "ad", "ae"]
>>> print(list(filter(lambda n:n.startswith("A"), lis)))
['ADC', 'AD']
>>> print(list(filter(lambda n:n.isupper(), lis)))
['ADC', 'AD']
>>> print(list(filter(lambda n:n.islower(), lis)))
['ad', 'ae']

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

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

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

内置函数

[官方解释链接]

 abs（x ） 

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

>>> abs(-1)
1
>>> abs(-12)
12

 all(iterable) 

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

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

 any(iterable) 

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

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

 ascii(object) 

 bin（x ） 

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

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010

 bool(x) 

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

>>> bool(0)
False
>>> bool(None)
False
>>> bool([])
False
>>> bool(12)
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方法.

>>> name = "YuanMing"
>>> callable(bool)
True
>>> callable(name)
False
>>> callable(1)
False

 chr(i) 

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

>>> chr(13)
'
'
>>> 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=' ', file=sys.stdout) 

• objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。

• sep -- 用来间隔多个对象，默认值是一个空格。

• end -- 用来设定以什么结尾。默认值是换行符 ，我们可以换成其他字符串。

• 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' …………………………………………………………