Python函数

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

新老客户大回馈,云服务器低至5折

函数的定义:

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

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

使用函数的好处

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

  2. 便于统一维护和修改

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

函数与过程的区别

过程就是没有返回值的函数,但是在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)

函数式编程

高阶函数

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

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

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

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

 


原文链接:https://www.cnblogs.com/MingleYuan/p/10589197.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:python网络编程-socket编程

下一篇:30行Python代码实现人脸检测