python学习笔记三 函数（基础篇）

函数

内置函数

常用的内建函数：

type()  列出指定对象的类型

help()  能够提供详细的帮助信息

dir()    将对象的所有特性列出

vars()  列出当前模块的所有变量 file，doc,name

 

__file__  列出文件位置

__doc__  文档字符串

__name__ 被执行的脚本，name == __main__

if __name__ == "__main__":
    print("hello")

 

int() 

abs()

max()

min()

pow()

bool()

divmod(x,y)  #相除，得到商和余数组成的元组,在网页分页操作中使用。

sum()

 

len()

all()   接受一个序列 判断所有值都为真，才会返回为true

any() 接受一个序列，只要有一项为真，即为真

 

chr()   返回值是当前整数对应的ascii字符。

ord()   返回值是当前ascii字符对应的整数。

hex()  16进制转换

oct()   8进制转换

bin()   2进制转换

 

range()  创建整数的迭代器

enumerate() 枚举函数

for k,v in enumerate(range(5)):
    print(k,v)

 

print()  

eval(source[,globals[,locals]])  将字符串作为表达式计算,并且返回值

 

zip(seq1,seq2,...)   创造用于并行迭代的新序列

sorted()     返回seq中排序后的列表

reversed()  产生seq中值的反向版本，用于迭代

自定义函数

def 定义函数的关键字
函数名，通过函数名调用函数

函数声明，不自动执行；调用后才执行

函数的参数 为函数提供数据；普通参数，关键字参数，默认参数，动态参数；

返回值 当函数执行完毕后，返回的数据；可以同时返回多个值，但其实就是一个tuple

创建函数：

def fib(n):    
　　result = [0,1]
　　for i in range(n-2):
　　　　result.append(result[-2]+result[-1])
　　return result

函数的返回值
1.未明确指定返回值，返回None

并非真正的函数：

def show():
    print('a')
    return
    print('b')
x = show()
print(x)

a
None
#函数会执行print('a')，然后被return终止，不会继续执行print('b')

2.返回值可以赋值给某个变量

def show(guess):
    ret =  False
    if guess == 'xixi':
        ret = True
    return ret
ret = show('xixi')

if ret:
    print("猜对了")
else:
    print("猜错了")

猜对了

普通参数:
    形式参数，形参;实际参数，实参;参数可以有n个，传入n个参数

def fun2(a1,a2):
    print(a1,a2)
fun2('hello,','wolrd')

关键字参数

    有时候参数的顺序很难记住，可以提供参数的名字；这样参数顺序不受影响，但是参数名和值一定要对应。

def hello(greet,name):
    print('%s,%s!'%(greet,name))
hello(name='csp',greet='hello')

hello,csp

默认参数

   默认参数只能放在最后，不传入参数则使用默认提供的参数。

def hello1(greet,name="koka"):
    print('%s,%s!'%(greet,name))
hello1('hello')

hello,koka!

动态参数

    定义时添加*，接受多个参数，内部构造元组

def xixi(*arg):
    print(arg,type(arg))
xixi(1,2,3,4)

(1, 2, 3，4) <class 'tuple'>

    定义时添加**，接受多个参数，内部构造字典

def haha(**args):
    print(args,type(args))
haha(name='koka',age=24)

{'name': 'koka', 'age': 24} <class 'dict'>

    调用时添加* 或**可以分隔序列和字典，避免内部构造元组或字典

def haha(*arg,**args):
    print(arg,type(arg))
    print(args,type(args))

haha(11,22,33,44,name='doubi')
(11, 22, 33, 44) <class 'tuple'>
{'name': 'doubi'} <class 'dict'>

li1= [11,22,33,44]
name = {'haha':123,'xixi':456}
haha(*li1,**name)
(11, 22, 33, 44) <class 'tuple'>
{'haha': 123, 'xixi': 456} <class 'dict'>

#星号只有在定义（允许使用不定数目的参数）或者调用（"分割"字典或者序列）的时候才有效。

#字典元素必须放在后面，否则将报错
haha(name='test',12,13,14)

  haha(name='test',12,13,14)
                    ^
SyntaxError: positional argument follows keyword argument

一些功能函数

lambda 函数

#普通函数
def func1(arg):
    return arg + 1
 
#匿名函数，执行简单语句
func2 = lambda arg: arg + 1
print(func2(12))
 
#匿名函数也可以像普通函数一样，收集多个参数
fun3 = lambda a,b,*arg,**args: print(a,b,arg,args)
 
fun3(2,3,4,5,6,name='koka')

filter 函数

过滤函数 对于序列中的元素进行筛选，最终获取符合条件的序列

#filter(function_or_None, iterable)
seq = [11,22,33,44,55]
filter(lambda a:a>33,seq) #返回迭代器,可以基于一个返回布尔值的函数对元素进行过滤

map 函数

将序列中的元素全部传递给一个函数

#map(func, *iterables)
l1 = [11,22,33]
l2 = [44,55,66]
def func1(a1,a2):
    return a1 + a2
map(func1,l1,l2)

[55,77,99]