四、函数

1、定义

函数是逻辑结构化与过程化的一种编程方法。   （☆ 函数 return 返回的值需用 print 打印出来。打印函数时，没有return默认返回None）

（过程：没有返回值return的函数）

def test(x):
    '''

    :param x:整形数字
    :return:返回计算结果
    '''
    y = 2*x+1
    return y
a = test(1)
print(a)

def：定义函数的关键字
test：函数名
（）：内可定义形参
''' '''：文档描述
y = 2*x+1：泛指代码块或程序处理的逻辑
return：定义返回值

 函数的好处：

1. 代码重用
2. 保持一致性，已维护
3. 可扩展

def test1():
    msg = 'test01'
    print(msg)

def test2():
    msg = 'test02'
    print(msg)
    return {'name':'Jack'}

def test3():
    msg = 'test03'
    print(msg)
    return 1,2,'a',['b'],{'name':'Jack'},None

t1 = test1()
t2 = test2()
t3 = test3()
print(t1)
print(t2)
print(t3)

输出：
test01
test02
test03
None
{'name': 'Jack'}
(1, 2, 'a', ['b'], {'name': 'Jack'}, None)

• 返回值数 = 0：返回None
• 返回值数 = 1：返回object
• 返回指数 > 1：返回tuple

2、函数参数：

1. 形参与实参，形参不占用内存空间，被调用时才占用。使用实参时注意对应的形参位置，位置参数需在关键字参数左边。
2. 默认参数：

   例：
   def test(x,type='Jack'):
       print(x)
       print(type)
   test('Hello')
   
   输出：
   Hello
   Jack

3. 参数组：**字典，*列表  （ 可加多个参数）
   1. 　　一个 * 表示遍历列表

      例：
      def test(x,*args):
          print(x)
          print(args)
      test(1,2,3,4,5)
      test(1,*(2,3,4,5))
      test(1,*{'name':'Jcak','age':18})
      
      输出：
      1
      (2, 3, 4, 5)
      1
      (2, 3, 4, 5)
      1
      ('name', 'age')

   2. 两个 ** 表字典，输入字典

      例：
      def test(x,**kwargs):
          print(x)
          print(kwargs)
      test(1,y=1,z= 2)
      test(1,**{'name':'Jcak','age':18})
      
      输出：
      1
      {'y': 1, 'z': 2}
      1
      {'name': 'Jcak', 'age': 18}

   3. 总：使用*args,**lwargs

      例：
      def test(x,*args,**kwargs):
          print(x)
          print(args)
          print(kwargs,kwargs.get('y'))
      test(1,1,2,3,4,y=1,z=2)
      test(1,*(1,2,3,4),**{'y':1,})
      
      输出：
      1
      (1, 2, 3, 4)
      {'y': 1, 'z': 2} 1
      1
      (1, 2, 3, 4)
      {'y': 1} 1

3、全局与局部变量：

1. 全局变量不进行缩进，局部缩进。加 global 可重新赋值全局变量，有局部变量存在时，需写在局部变量前。

   例：
   name = 'Jack'    #全局
   def test():
       name = 'Alan'  #局部
       print(name)
   
   test()
   print(name)
   
   输出：
   Alan
   Jack

   例：
   name = 'Jack'
   def test():
       global name      #表示下面修改的name为全局变量
       name = 'Alan'
       print(name)
   
   test()
   print(name)
   
   输出：
   Alan
   Alan

2. 全局变量用大写，局部变量用小写。
3. 使用 nonlocal 指定上一层局部变量，不能指定全局变量

   例：
   name = 'Jack'
   def test1():
       name = 'Alan'
       def test2():
           nonlocal name    # nonlocal 指定上一层变量
           name = 'John'
       test2()
       print(name)
   print(name)
   test1()
   
   输出：
   Jack
   John

4、递归函数：

函数直接或间接调用函数本身，使用 return 终止

例：
def test(n):
    print(n)
    if int(n / 2) == 0:
        return n
    res = test(int(n / 2))
    return  res
test(10)

输出：
10
5
2
1

• 必须有一个明确的结束条件，不然会一直循环后报错
• 每次进入更胜一成递归时，问题规模相比上一次有所减少
• 递归效率不高，递归层次过多会导致栈溢出

5、函数作用域：

作用域不随调用位置的改变而改变

1. return到一个函数时，返回其内存地址

   例：
   def test1():
       print('in the test1')
   def test2():
       print('in the test2')
       return test1
   
   res = test2()
   print(res)
   
   输出：
   in the test2
   <function test1 at 0x00000065FE5CC268>
   #返回 test1 函数的内存地址

2. 加上（）运行函数时，返回函数 test1 （）运行的值，没有 return 结果的默认输出None。

   例：
   def test1():
       print('in the test1')
   def test2():
       print('in the test2')
       return test1
   
   res = test2()
   print(res())
   
   输出：
   in the test2
   in the test1
   None

   例：
   def aa():
       name = 'test1'
       def bb():
           name = 'test2'
           def cc():
               print(name)
           return cc
       return bb
   
   # bb = aa()
   # cc = bb()
   # print(cc)
   # cc()
   aa()()()
   
   输出：
   test2

6、函数式编程

函数式 = 编程语言定义的函数 + 数学意思的函数

函数式就是用编程语言去实现数学函数。这种函数内对象是永恒不变的，要么参数是函数，要么返回值是函数，没有for和while循环，所有循环由递归去实现，无变量的赋值（即不用变量去保存状态），无赋值即不改变。

面向过程：找到解决问题的入口，按照一个固定的流程去模拟解决问题的流程。

特点：

• 不可变数据
• 第一类对象
• 尾调用优化（尾递归）

不可变：不用变量保存状态，不修该变量

#非函数式
a = 1
#增加的测试函数
def incr_test1():
    global a
    a += 1
    return a

incr_test1()
print(a)

#函数式
n = 1
def incr_test2(n):
    return n+1

print(incr_test2(2))
print(n)

第一类对象：函数即变量（满足以下两个点的函数称为高阶函数）

1. 函数名可以当做参数传递给另一个函数

   例：
   def foo(n):
       print(n)
   
   def bar(name):
       print('my name is %s' %name)
   
   foo(bar('jack'))
   
   输出：
   my name is jack
   None    #默认return返回None，所以n=None

2. 返回值可以是函数名（给返回的函数赋予一个值，运行后输出。可以return函数本身）

   例：
   def foo():
       print('from foo')
   
   def bar():
       print('from bar')
       return foo
   n = bar()
   n()
   
   输出：
   from bar
   from foo

尾调用：在函数最后一步调用另一个函数（最后一行不一定是函数的最后一步）

#函数bar在foo内为尾调用

def bar(n):
    return n
def foo(x):
    return bar(x)

#函数bar1和bar2在foo内均为尾调用，二者在if判断条件不同的情况下都有可能作为函数的最后一步
def bar1(n):
    return n
def bar2(n):
    return n+1
def foo(x):
    if type(x) is str:
        return bar1(x)
    elif type(x) is int:
        return bar2(x)

非尾调用：

#函数bar在foo内为非尾调用
def bar(n):
    return n
def foo(x):
    y = bar(x)
    return y

#函数bar在foo内为非尾调用
def bar(n):
    return n
def f00(x):
    return bar(x)+1
    #res = bar(x）
    #return res+1

1. map函数：（结果为迭代器，只能处理一次，再次处理不显示）依次处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置与原来一样（传入两个参数：1、函数   2、iterable（可迭代对象））

   def map(func,array)

   #不使用map函数
   num = [1,2,3,4,5]
   #lambda x:x+1   匿名函数
   def add_test(x):
       return x+1
   
   def map_test(array):
       ret = []
       for i in num:
           ret.append(i+1)
       return ret
   ret = map_test(num)
   print(ret)
   
   输出：
   [2, 3, 4, 5, 6]

   #使用内置函数map
   num = [1,2,3,4,5]
   def map(func,array):    #func：函数  array：可迭代对象
       ret = []
       for i in array:
           res = func(i)    #func(i)相当于执行某个函数
           ret.append(res)
       return ret
   
   print(map(lambda x:x+1,num))    # print(map(add_test,num))
   
   msg = 'jack'
   res = map(lambda x:x.upper(),msg)
   print(res)
   
   输出：
   [2, 3, 4, 5, 6]
   ['J', 'A', 'C', 'K']

2. filter函数：如果布尔值为True，则返回函数运行的值。遍历列表中每个元素，判断每个元素得到的布尔值，如果是True则留下。 

   def filter(func,array)

   people = ['a_jack','a_alen','jhon']
   res = filter(lambda n:n.startswith('a'),people)
   print(list(res))
   # def filter(func,array):
   #     ret = []
   #     for n in array:
   #         if func(n):
   #             ret.append(n)
   #     return ret
   # print(filter(lambda n:n.startswith('a'),people))
   
   输出：
   ['a_jack', 'a_alen']

3. reduce函数：把一个函数作用在一个序列上，函数本身必须接收两个参数，reduce把序列前两个数先代入函数计算后，再继续与序列下一个元素进行代入计算。

   def reduce(func,array,init=None)

   from functools import reduce
   num = [1,2,3,100]
   print(reduce(lambda x,y:x*y,num,2))
   # num = [1,2,3,100]
   # def reduce(func,array,init=None):
   #     if init is None:
   #         res = array.pop(0)
   #     else:
   #         res = init
   #     for i in array:
   #         res = func(res,i)
   #     return res
   # print(reduce(lambda x,y:x*y,num,2))
   
   输出：
   1200

   from functools import reduce
   print(reduce(lambda x,y:x+y,range(100),100))
   #print(reduce(lambda x,y:x+y,range(1,101),))
   num=[1,2,3,4]
   print(reduce(lambda x,y:x+y,num,))
   
   输出：
   5050
   10

1. 返回函数:返回函数不要引用任何循环变量、或者后续会发生变化的变量。(一定要引用时需新建一个函数，在用其函数的参数来绑定循环的值）
   • 函数闭包：一个函数返回一个函数，其内部的局部变量被新函数引用，返回的函数需要调用时才执行。

     def fun():
         l = []
         def f(j):
             def g():
                 return j*j
             return g()
         for i in range(1,4):
             l.append(f(i))
         return l
     f1,f2,f3 = fun()
     print(f1)
     print(fun())
     
     输出：
     1
     [1, 4, 9]

     #函数引用循环变量后，输出的值在函数调用时才执行，没有立即返回每一个 i 的值
     def count():
         l = []
         for i in range(1, 4):
             def f():
                  return i*i
             l.append(f)
         return l
     f1, f2, f3 = count()
     print(f1(),f2(),f3())
     
     输出：
     9 9 9

2. 匿名函数：lambda（lambda 形参：处理流程），处理多个值时用括号如 lambda x,y,z:(x+1,y+1,z+1)一般不单独处理，返回值为该表达式的结果

   例：
   name = 'jack'  #name = 'jack_name'
   def change_name(x):
       return name + '_name'
   
   res = change_name(name)
   print(res)
   
   #使用lambda，输出结果一样
   a = lambda x:name+'_name'
   print(a(name))
   
   输出：
   jack_name
   jack_name

   
   
3. 装饰器（decorator）：调用一个以函数作为参数被返回的函数，用来增强某个新函数的功能又不改变这个新函数本身的定义。用 @ 进行引用。 

   #导入functools模板
   import functools
   def g(func):        #func为一个函数名
       # @functools.wraps(func)  #将warpper.__name__返回的函数名等同于func的函数名
       def warpper():
           print('输出新函数 %s():' %func.__name__)
           return func()
       return warpper
   #引用g函数
   @g
   def now():
       return '你好'
   print(now())
   
   输出：
   输出新函数 now():
   你好

   #带参数的装饰器
   import functools
   def g(text):
       def f(func):
           @functools.wraps(func)
           def wrapper():
               print('参数内容：%s，函数：%s():' %(text,func.__name__))
               return func()
           return wrapper
       return f
   #引用装饰器
   @g('你好Python')
   def now():
       return '你好'
   print(now())
   
   输出：
   参数内容：你好Python，函数：now():
   你好

4. 偏函数（Partial function）： 使用 functools.partial（）把函数的参数固定，返回一个新函数。可接受函数参数，*arg，**kw三个参数

   import functools
   int2 = functools.partial(int,base=16)   #固定base的值
   print(int2('12345'))
   arg = functools.partial(max,10) # *arg=(10,2,7,3)再进行比较
   print(arg(2,7,3))
   
   输出:
   74565
   10

7、内置函数

1. abs（）：取绝对值

   print(abs(-1))
   
   输出：
   1

2. all（）：序列中所有元素为真时返回True，单个可迭代对象为空时，也返回True；0，[ ]，None为False

   print(all(['1','2',0]))
   print(all(''))
   
   输出：
   False
   True

3. any（）：序列中有一个为真时返回True。
4. bool（）：0，‘ ’，None为False，其它为真
5. byte（）：编码与解码。用什么编码就用什么解码，默认使用 utf-8 解码。

   name = '你好'
   print(bytes(name,encoding='utf-8'))
   print(bytes(name,encoding='utf-8').decode('utf-8'))
   print(bytes(name,encoding='gbk'))
   print(bytes(name,encoding='gbk').decode('gbk'))
   # print(bytes(name,encoding='ascii'))  ascii不能编码中文
   
   输出：
   b'xe4xbdxa0xe5xa5xbd'        #utf-8：三个字节表一个中文
   你好
   b'xc4xe3xbaxc3'        #gbk：两个字节表一个中文
   你好

6. dir（）：打印某一个对象下面有哪些方法。help（）：打印某一对象下的方法该如何使用
7. divmod（）：打印商跟余数。（可用于分页功能，10表示总共有多少条记录，3表示一页有多少记录，得出结果分3页，不为0时在多分一页。）

   print(divmod(10,3))
   
   输出：
   (3, 1)

8. eval（）：提取字符串中的数据结构，也可运算字符串中的表达式。

   dic = {'name':'jack'}
   dic_str = str(dic)      #此处转换成字符串，无法再进行索引取值
   dic_str = eval(dic_str)     #使用eval转换后，可恢复字符串中的数据结构
   print(dic_str['name'])
   
   输出：
   jack

9. frozenset（）：生成新的不可变集合，不能进行索引

   a = frozenset('jack')
   b = frozenset(range(10))
   print(a)
   print(b)
   
   输出：
   frozenset({'k', 'j', 'a', 'c'})
   frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

10. hash（）：可用来判断数据有没有被改动过。如果改动，数据的哈希值会发生改变

    name = 'jack'
    print(hash(name))
    name = 'alen'
    print(hash(name))
    
    输出：
    -1093188409928294597
    7045170762214928410

11. bin（）：十转二进制；hex（）：转十六进制；oct（）：转八进制
12. isinstance（）：判断数据类型

    print(isinstance(1,int))
    print(isinstance([1,2,3],list))
    print(isinstance(1,dict))
    
    输出：
    True
    True
    False

13. zip（）：将两个序列一一对应组成元组放在列表中。

    print(list(zip(['a','b','c'],'123')))
    p = {'name':'jack','age':18}
    print(list(zip(p.keys(),p.values())))
    
    输出：
    [('a', '1'), ('b', '2'), ('c', '3')]
    [('name', 'jack'), ('age', 18)]

14. max（）：比较后取最大值　　min（）：取最小值
    1. 处理的是一个可迭代对象，相当于一个for循环取出每个元素进行比较，不同类型不能比较。结合zip使用，字典默认比较keys。

    2. 从第一位开始每个元素依次比较，有一个分出大小后面的不再进行比较。

       dic = {'age1':'10','age2':'30','age3':'20'}    #a、g、e一个个进行比较
       print(max(zip(dic)))
       print(max(zip(dic.keys(),dic.values())))
       
       输出：
       ('age3',)
       ('age3', '20')

       #比较列表中的字典
       people = [
           {'name':'jack','age':19},
           {'name':'alen','age':25},
           {'name':'jhon','age':20}
       ]
       print(max(people,key=lambda dic:dic['age']))
       # res = []
       # for item in people:
       #     res.append(item['age'])
       # print(res)
       # print(max(res))
       
       输出：
       {'name': 'alen', 'age': 25}

15. pow（）：求出平方与余数

    print(pow(3,3))     #3**3
    print(pow(3,3,2))       #3**3%2
    
    输出：
    27
    1

16. reversed（）：反转序列，但不保存
17. round（）：四舍五入
18. slice（）：切片

    slice(start,stop,step)    #开始，结束，步长

    l = 'hello'
    s1 = slice(3,5) #赋值一个切片
    s2 = slice(1,4,2)
    print(l[s1],l[s2])
    
    输出：
    lo el

19. sorted（）：从小到大进行排序，加 key 对元素进行修改，reverse=True 时为反向排序。（高阶函数）

    l1 = ['jack','Apple','zero']
    l2 = [2,4,-3,-1]
    print(sorted(l1,key=str.lower))
    print(sorted(l2,key=abs,reverse=True))
    #l2的值绝对值后进行比较排序
    
    输出：
    ['Apple', 'jack', 'zero']
    [4, -3, 2, -1]

 8、模块（Module）

一个 .py 文件称为模块。是一组Python代码的集合，可以使用其他模块，也可以被其他模块使用。

包（Package）：按目录来组织模块的方法，选择一个顶层包，下面目录为模块名（避免模块名与其他人冲突，使用 顶层包名.模块名）每一个包目录下面都必须有一个__init__.py的文件，也是一个模块，模块名就是上层目录名


好处：

1. 提高代码可维护性
2. 避免函数名与变量名冲突

• 命名时不要使用中文、特殊字符
• 模块名不要和系统模块名冲突
• 在Python交互环境执行（import 模块名），若成功则说明系统存在此模块。

【类似_xxx和__xxx这样的函数或变量为非公开的函数（private），外部不需要引用的函数定义成private，外部需要引用的函数才定义为public。可以在满足某种条件时（如if条件成立的情况下）再调用非公开函数。】

安装第三方模块：

1. 使用pip安装

   pip install Pillow    #Pillow为模块名

2. 到 Anaconda官网 下载GUI安装包

搜索模块：默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块，搜索路径存放在sys模块的path变量中（sys.path），可用sys.path.append（路径）添加搜索目录