#python的基本语法网上已经有很多详细的解释了，写在这里方便自己记忆一些

　　BIF是python内置的函数，任何一门语言都能用来创造函数，python也不例外

　　1、创建一个函数

def func():
    print("this is my first function")

func()

this is my first function

python的参数数量实际上是无限的，但是定义的参数尽量不要太多，便于维护

　　　  参数分为“形参”（parameter,函数创建和定义过程中小括号里面的参数）和“实参”（argument,函数在被调用的过程中传递进来的参数）

#单个参数情况下
def func(str):
    print(str+"this is my first function")

func(str='Hello Python,')

Hello Python,this is my first function
def func(str1,str2):
    print(str1+str2+"this is my first function")

func(str2='Python,',str1='Hello')

HelloPythonthis is my first function
#这里使用了两个参数，str1与str2,它们被称作关键字参数，相比于位置参数（字符串的格式化也用到了关键字和位置参数）更便于编码。

　　3、收集参数（可变参数）

def func(*str):
    print('str的长度是%d'%len(str))
    print('str的第1个参数是',str[1])

func('Hello','Python','!')

#str的长度是3
#str的第1个参数是 Python

#如果收集参数后面还有参数的话，需要用位置参数

def func(*param,extra):
    print(param)
    print(extra)
func('what the fuck',1,2,extra=3)

('what the fuck',1,2)　　#如果有逗号的话返回的形式为元组
3　　　　　　　　　　　　　　#位置参数指定了，收集参数则不会包括位置参数

 　　4、内嵌函数与闭包

那么python就会在函数内部自动创建一个名字一模一样的变量，并且这个“复制”变量作用域只在函数内部

#变量的作用域
count = 5
def func():
    count = 10
    return  print(count)
func()
print(count)

10
5
----------------------------------------------------------------------------------
#内嵌函数的调用
def func():
    print('func正在被调用')
    def func2():
        print('func2正在被调用')
    func2()

func()

func正在被调用
func2正在被调用

------------------------------------------------------------------------------------

#闭包是函数式编程的重要语法结构

#闭包的简单定义：如果在一个内部函数里对外部作用域的变量进行引用，那么内部函数就被认为是闭包

def funA():　　　　　　　　　　　　　
    x = [5]　　　　　　　　　　　　　　　　
    def funB():
        x[0] *= x[0]
　　　　　print(x[0])
    return funB()　　　　#注意这里的写法，如果闭包中对内部函数的调用加上了括号，那么调用外层函数只需要一个括号，否则调用外层函数需要两个函数
funA()　　　　　　

25
-----
def funA():
    x = [5]
    def funB():
        x[0] *= x[0]
        print(x[0])
    return funB
funA()()

25

　　5、lambda，实用的匿名函数

#lambda关键字用来创建匿名函数，当一个函数语句较为简短时，或者使用脚本时，使用lambda即可避免函数的定义过程
f = lambda a,b:a*b
print(f(4,6))

24

　　6、filter()和map()

　　　（1）filter(function/None,iterable)，filter是一个过滤器，第一个参数是一个函数或者None,第二个参数是一个可迭代对象，如果第一个参数是一个函数，将可迭代

　　对象代入函数把返回值为True的参数筛选出来，如果是None，将可迭代对象中值为True的参数筛选出来

print(list(filter(lambda x:x%2==1,[1,2,3])))　　　　#一个返回基数的过滤器
print(list(filter(lambda x:x%2==0,[1,2,3])))　　　　#一个返回偶数的过滤器

　[1, 3]
　[2]

　　　（2）map(function,iterable),map()是一个映射函数，同时也有两个参数，第一个是一个函数，第二个是可迭代对象，返回一个可迭代对象代入函数后返回的映射

tpl1 = 1,2,
lt1 = ['a','b']
# print(type(tpl1))
for item in enumerate(tpl1):
    print(item)