python学习基础篇之函数

何为函数？

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。

Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

如何自定义函数？

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

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

如：

def fun(args):
    """
    描述信息
    """
    function_code...
    return value|expression

程序被运行的时候，函数的def段会被执行，其他的内容会被加载到内存中，不会立即执行。

那函数何时才会执行？

当函数被调用时，如要执行上面的函数：fun()，这样函数就会执行

函数可以接受参数，接受参数的形式：

　　1.普通参数：　

def send(contact,content'):
	print(contact,content)
send('xiaob','haha'）
#运行结果：
xiaob haha

　　2.默认参数：

def send1(contact,content,result='OK'):
	print(contact,content,result)
send1('xiaoa','heihei')
#运行结果：
xiaoa heihei OK

　　3.指定参数：

def send2(contact,content,result):
    print(contact,content,result)
send2('xiaoC',result='over',content='heihei')
#运行结果：
xiaoC heihei over

注意函数参数列表：

　　1.无默认值的参数，只能放在函数参数列表的左边

　　2.有默认值的参数，只能放在函数参数列表的右边

python的函数传递的是一个参数引用，而非重新赋值，即传递可变参数时，函数会改变参数的值

上面参数传递的个数是明确的，参数列表是固定的，下面介绍动态传递参数，即需要向函数传递的参数个数不确定

　　1.星号开头，表示可收集任意多的参数，作为字典列表传递给函数

def f1(*args):
    print(args)
f1(11,22,33,44)
#运行结果：
(11, 22, 33, 44)

　　2.星号星号开头，表示可收集任意多的键值对参数，作为字典传递给函数

def f2(**kwargs):
    print(kwargs）
f2(a1='aa',b1='bb')
#运行结果
{'a1': 'aa', 'b1': 'bb'}

　　3.星号，星号星号，前面接受任意多参数作为一个列表，后面是任意多的键值对参数一起传递给函数

def f3(*args,**kwargs):
    print(args)
    print(kwargs)
f3(11,22,33,k1="v1",k2="v2")
#运行结果
(11, 22, 33)
{'k1': 'v1', 'k2': 'v2'}

　　另外，在一个python程序中，当函数名相同时，后面的函数会覆盖前面的函数

def f1(a1,a2):
	returna1+a2

def f1(a1,a2):
	returna1*a2

ret=f1(8,8)
print(ret)
64

函数定义本地作用域，而模块定义全局作用域

　　1.每个模块都是一个全局作用域，因此，全局作用域的范围仅局限于单个程序文件

　　2.全部变量、所有的作用域都可读，对不可变的全局变量需要重新赋值时，需要使用global声明，为全局变量时，需全部大写

　　3.每次对函数的调用都会创建一个新的本地作用域，赋值的变量除非声明为全局变量，否则默认为本地变量

　　4.所有的变量名都可以归纳为本地、全局或内置的（__builtin__模块提供）

变量名引用分3个作用域进行：首先是本地local、之后是函数内enclosing functions、接着是全局global、最后是内置built-in，优先级由高到低。

>>> def f1():
...     age = 18
...     print(age)
...
>>> def f2():
...     print(age)
...
>>> f1()
18
>>> f2()    #age不是全局变量，f2不能直接引用
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f2
NameError: name 'age' is not defined

>>> AGE = 18
>>> def f1():
...     print(AGE)
...
>>> def f2():
...     print(AGE)
...
>>> f1()
18
>>> f2()   #AGE为全局变量时，f1，f2，都可调用
18
>>>

>>> NAME = "test"
>>> id(NAME)
35541432
>>> def f1():
...     NAME = 'f1'
...     print(id(NAME),NAME)
...
>>> def f2():
...     print(id(NAME),NAME)
...
>>> f1()
35295336 f1    #由此可见，对顶层的不可变对象不能修改，此时的NAME是一个局部变量
>>> f2()
35541432 test

>>> def f1():
...     global NAME   #把NAME设置成全局变量
...     NAME = 'f1'
...     print(id(NAME),NAME)
...
>>> def f2():
...     print(id(NAME),NAME)
...
>>> f1()   #此时可对NAME进行修改
35295336 f1
>>> f2()
35295336 f1
>>> li = [11,22]
>>> id(li)
35176008
>>> def f1():
...     li.append(33)
...     print(id(li),li)
...
>>> def f2():
...     print(id(li),li)
...
>>> f1()    #对于可变对象，如列表，字典，函数中可以对其修改
35176008 [11, 22, 33]
>>> f2()
35176008 [11, 22, 33, 33]

常见内置函数

abs()：返回数字的绝对值，参数可以是整数，浮点数

>>> abs(-10.0)
10.0

all()：对参数中的所有元素进行迭代，如果所有元素都是真，则返回True

>>> n = all([1,2,3])
>>> print(n)
True
>>> m = all([11,22,[]])
>>> print(m)
False
>>>

any()：对参数中的所有元素进行迭代，只有要一个为真，则返回True

bin()：将十进制，转换为二进制字符串，0b开头表示2进制

>>> bin(122)
'0b1111010'

oct()：将十进制，转换为八进制字符串，0o开头表示8进制

>>> oct(122)
'0o172'
>>>

hex()：将十进制，转换为十六进制字符串，0x开头表示16进制

>>> hex(122)
'0x7a'

bytes()：把字符串转成字节类型

s="潘东林"
n=bytes(s,encoding="utf-8")
print(n)
b'\xe6\xbd\x98\xe4\xb8\x9c\xe6\x9e\x97'
n1=bytes(s,encoding="gbk")
print(n1)
b'\xc5\xcb\xb6\xab\xc1\xd6'

bool(x)：对参数进行bool判断

>>> bool([1,2,3])
True
>>> bool([])
False

callable(obj)：检查对象是否能被调用，可以调用为True，否则为False

>>> def f1():
...     pass
...
>>> callable(f1)
True

dict()：创建一个字典

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

enumerate(iterable, start=0)：返回一个可枚举的对象，该对象的next()方法将返回一个tuple.start为开始的序号默认从0开始

>>> a = ['a', 'b', 'c']
>>> for i,value in enumerate(a):
...     print(i,value)
...
0 a
1 b
2 c
>>>

format：格式化输出字符串

>>> str1="iam{0},age{1}".format("xiaoA",20)
>>> print(str1)
iamxiaoA,age20
>>> dic={'name':"xiaoD",'age':33}
>>> str4="iam{name},age{age}".format(**dic)
>>> print(str4)
iamxiaoD,age33
>>>

id()：查看对象的内存地址

>>> a = 'abc'
>>> id(a)
6321520
>>> li = [1,2,3]
>>> id(li)
6501384

str()：把字节转换成字符串

new_str=str(bytes("潘东林",encoding="utf-8"),encoding="utf-8")
print(new_str)
潘东林

ord(c)：返回字符c的ascii码对应的值

>>> ord('c')
99　

chr(x)：把ascii的整数值转成字符

>>> chr(65)
'A'

compile(str, "<string>", exec)：把字符串编译成python代码，有3种模式single(单行), eval(表达式), exec(python执行文件)，"<string>"表示输入为字符，或者给一个文件名

>>> code = "1+2+3"
>>> code
'1+2+3'
>>> ret = compile(code,'','eval')
>>> print(ret)
<code object <module> at 0x000000000058BED0, file "", line 1>
>>> eval(ret)
6
>>> code = 'print("abc")'
>>> ret = compile(code,'<string>','exec')
>>> exec(ret)
abc

eval()：把字符串返回成一个表达式，去执行，有返回值

>>> ret = exec("7+8+9")
>>> print(ret)
None

exec()：接受python代码或字符串，接受的是字符串时，会先转换python代码，再执行，但是无返回值

>>> ret = eval("7+8+9")
>>> print(ret)
24

divmod(x,y)：返回x/y的商和余数，结果为元组类型

>>> r = divmod(97,10)
>>> print(r)
(9, 7)   #第1个是商，第2个是余数

isinstance(obj, class_or_tuple, /)：用于判断，对象是否是某个类的实例

>>> s = [11,22]
>>> r = isinstance(s, list)
>>> print(r)
True

filter：过滤器，调用一个布尔函数func来迭代遍历每个序列seq中的元素，返回一个使函数func返回值为True的元素序列

>>> l1=[1,2,3,42,67,16]
>>> def f1(x):
...     if x >20:
...         return True
...     else:
...         return False
ret = filter(f1,l1)
>>> print(ret)
<filter object at 0x000000000118CC18>
>>> print(list(ret))  #或者转成tuple
[42,67]
ret=filter(lambda a:a>20,li)
print(list(ret))
[42,67]

map：映射器,把函数func作用于每个序列的每个元素，并用一个列表来提供返回值，如果func为None，func表现为一个身份函数，返回一个含有由每个序列中元素组成集合的n个元组列表

 

>>> l1=[0,1,2,3,4,5,6]
>>> ret = map(lambda a: a+100, l1)
>>> print(list(ret))
[100, 101, 102, 103, 104, 105, 106]
>>> l2=['Sun','M','Tus','W','T','F','S']
>>> map(None,l1,l2)
[(0, 'Sun'), (1, 'M'), (2, 'Tus'), (3, 'W'), (4, 'T'), (5, 'F'), (6, 'S')]
>>> def f3(x,y):
    return x*2,y
>>> map(f3,l1,l2)
[(0, 'Sun'), (2, 'M'), (4, 'Tus'), (6, 'W'), (8, 'T'), (10, 'F'), (12, 'S')]

filter与map的区别：

　　filter：函数返回True，将元素添加到结果中

　　map：把函数返回值添加到结果中

globals()：显示此程序全局所有变量

locals()：显示此程序的局部所有变量

reduce(func,seq[,init])将二元函数作用于seq序列的元素，每次携带一对（先前的结果以及下一个序列元素），连续地将现有的结果和下一个值作用在获得的随后结果上，最后减少我们的序列为一个单一的返回值，如果初始值init给定，第1个比较会是init和第一个序列元素而不是序列的头两个元素

>>> def f5(x,y):
    return x+y
>>> print l1
[0, 1, 2, 3, 4, 5, 6]
>>> reduce(f5,l1)
21

max(iterable, *[, key, default])：对一个列表或元素的数据进行迭代，返回最大值

>>> li = [11,22,33]
>>> max(li)
33

min():对一个列表或元素的数据进行迭代，返回最小值

pow：数学求平方

>>> r = pow(2, 10)
>>> print(r)
1024

reversed()：翻转序列的顺序，返回的是一个翻转的对象，相当与obje.reverse()

>>> li = [12,32,11,22]
>>> ret = reversed(li)
>>> print(ret)
<list_reverseiterator object at 0x0000000000A617F0>
>>> print(list(ret))
[22, 11, 32, 12]
>>> ret = reversed(li)
>>> print(tuple(ret))
(22, 11, 32, 12)
>>> li 
[12,32,11,22]
>>> li.reverse()
>>> li
[22, 11, 32, 12]
>>> a = 'abc'
>>> reversed(a)
<reversed object at 0x0000000000A61908>
>>> print(list(reversed(a)))
['c', 'b', 'a']

round()：四舍五入

>>> round(1.6)
2
>>> round(1.2)
1

sorted(iterable[, key][, reverse])：对参数中的元素进行排序,默认从小到大排序。可以指定排序计算方法key=function,是否倒序排列reverse=True

>>> d = {1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}
>>> sorted(d, key=lambda var:d[var])    #根据字典的value，排序key
[5, 2, 3, 1, 4]

zip(*iterables)：将两个元组或列表的值进行合并成一个新的列表

>>> l1 = ['a', 1, 2]
>>> l2 = ['b', 11, 22]
>>> l3 = ['c', 111, 222]
>>> r = zip(l1, l2, l3)
>>> tmp = list(r)
>>> print(tmp)
[('a', 'b', 'c'), (1, 11, 111), (2, 22, 222)]
>>> print(tmp[0])
('a', 'b', 'c')
>>> ''.join(tmp[0])
'abc'