Python全栈开发之路 【第四篇】：Python基础之函数

本节内容

函数def：
      1、位置参数，默认参数
      2、位置参数，关键参数
      3、如果参数中出现 *users，传递的参数就可以不再是固定的个数，
       传过来的所有元素进行打包成元组  *args,**kwargs
      4、非固定参数:
          方式① send_alert('别他么狼了','alex','xxx','xxx','ooo')
          方式② send_alert('别他么狼了',*['alex','xxx','iiii'])
      5、返回值：return语句把结果返回；碰到return函数就会结束
          返回只能返回一个值；当返回多个值的时候，是以元组的形式返回
      6、局部变量：只定义在函数里的变量，只能在局部生效，不能在外部调用
       在内部可以引用全局变量
       在局部修改全局变量：global name  （开发不建议用global）

      7、全局变量：定义在函数外部一级代码的，全局能用
          可以修改 全局变量 里的元素。---> 不可被修改的有 字符串，数字
      8、在函数里修改列表内部元素：可以被修改的有：列表，字典，元组(里包含列表，字典等)集合，对象，类
         不可被修改：字符串，数字 ---> 已是最小单元，内部元素不可被修改
      9、嵌套函数: 多级函数
          函数内部可以再定义函数，执行时需要被调用。

      10、作用域：在python中，函数就一个作用域，局部变量放置在其作用域中。
          代码定义完成之后，作用域已经生成，作用域链向上查找
      11、匿名函数：lambda  作用：节省代码量、看着高级
                例:func = lambda x,y:x*y  # 声明一个匿名函数
                   func(3,5)
             三元运算：lambda x,y:x*y if x < y else x/y
             map(lambda x:x**x,data)
      12、高阶函数：①函数接受一个函数或多个函数作为输入
                  ②return 返回另一个函数
      13、递归、递归的返回值：
          递归的特点：
               ① 必须有一个明确的结束条件
               ② 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
               ③ 递归效率不高，递归层次更多会导致栈溢出
          递归与栈的关系:
               每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。
               由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
          求阶乘(factorial): n! = n*(n-1)!
              代码如下:
                  def factorial(n):
                      if n == 1:
                      return 1
                    return n * factorial(n-1)
                  print(factorial(4))
          尾递归: 在调用下一次递归的时候，返回。

      14、深度查询：

      15、函数内置方法：abs():取绝对值、
                     dict():把一个数据转成字典、
                     help():帮助、min()取最小值、
                     max():
                     all():所有值bool都为True，只要有一个为0，就为False,空列表也为True
                     any():与all相反、
                     dir():打印当前程序所有的变量、
                     hex():转换为16进制
                     slice():先定义一个列表切片的规则(没卵用)、
                     divmod():divmod(10,3)--->(3,1)
                     sorted():排序，从小到大,可以自定义排序规则
                     ascii():（没卵用）
                     enumerate():
                     oct():8进制
                     bin():2进制
                     eval():把字符串转换为代码，去其外表，取本质，只能执行一行代码
                     exec():与eval()相同，但可以执行多行，区别：exec()--->没有返回值
                     ord():返回a在ASCII的位置
                     chr():与ord()相反
                     sum():求和
                     bytearray():原内存地址修改字符串，
                     map():
                     filter():过滤
                     reduce():在functools工具包里，functools.reduce
                     print():
                     tuple():
                     callable():判断对象是否可调用（判断变量是否是函数的时候可用）
                     len():
                     format():
                     frozenset():
                     vars():当前所有变量都会打印出来
                     locals():在函数里，打印函数当前作用域里所有的局部变量
                     globals():
                     repr():显示形式变成字符串
                     zip():整合两个列表的对应关系
                     compile():
                     reversed():默认翻转
                     complex():复数
                     round():保留几位小数
                     delattr,hasattr,getattr,setattr:
                     hash():哈希
                     set():把列表变成集合
      16、函数练习题：修改个人信息程序

      17、函数的进阶：（鸡汤：电影--->荒野生存 ；书：百年孤独；）
            命名空间(name space)：
                分三种：①locals:包括局部变量和形参
                       ②globals：全局变量
                       ③builtins:内置函数模块的名字空间
                    不同变量的作用域不同就是由这个变量所在的命名空间决定的。
                    查看作用域方法：globals(),locals()
            作用域的查找顺序：
                L:locals
                E:enclosing 相邻的 外部嵌套函数的名字空间
                G:globals 全局变量
                B:builtins
            闭包：
                关于闭包，即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。
                而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。
                当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。
                也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行时，
                它仍然必需访问其外部函数的局部变量、参数以及其他内部函数。
                这些局部变量、参数和函数声明（最初时）的值是外部函数返回时的值，
                但也会受到内部函数的影响。

            ①装饰器(语法糖)：作用：在符合开放、封闭原则下，给原有程序加新功能

            ②生成器(generator)：
                   range 底层就是一个生成器
                        python2
                            range = list
                            xrange = 生成器
                        python3
                            range = 生成器
                            xrange 没有
                   创建方式:
                        1、列表 生成 式 ()
                        2、函数

                   yield 作用: 返回数据，冻结当前的执行过程，并且把值返回给外面的next()
                        函数里有yield之后, 就会把函数名加()变成一个生成器；return 在生成器里 代表生成器的终止，直接报错
                   next 唤醒冻结的函数执行过程，继续执行，直到遇到下一个yield

                        调用next内置函数时，相当于调用了send 也发送了一个信息到生成器内部，但只能发送None
                        而 send 可以发送任意的值。

                   send 作用: 唤醒并继续执行，发送一个信息到生成器内部
                        sign = yield count
                        if sign == 'stop':
                                break
                        # next_range.send("sop")

            ③迭代器: 生成器是迭代器(Iterator)对象
                迭代就相当于 循环

                可直接作用于for循环的数据类型，有:
                    ①集合数据类型: 如 list  tuple  dict  set  str  等
                    ②generator : 包括 生成器 和 带yield的generator function.
                    这些可以直接作用于for循环的对象统称为可迭代对象: Iterable.
                    可以使用 isinstance() 判断一个对象是否是可迭代Iterable对象。

                可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator.
                可以使用isinstance()判断一个对象是否是Iterator对象.

                生成器都是Iterator对象，但列表list、字典dict、字符串str虽然是可迭代的Iterable，却不是迭代器Iterator。
                把list、dict、str等Iterable变成Iterator可以使用iter()函数.

                >>>from collections import Iterator
                >>>isinstance((x for i in range(10)),Iterator)  ---> True
                >>>isinstance([],Iterator)  ---> False
                >>>isinstance('abc',Iterator)  ---> False

                list,dict,str是Iterable,却不是Iterator。
                把list,dict,str的Iterable变成Iterator可以使用iter()函数
                >>>isinstance(iter([]),Iterator)  ---> True
                >>>isinstance(iter('abc'),Iterator)  ---> True

                isinstance()判断一个对象是否是可迭代(Iterable)对象.
                >>>from collections import Iterable
                >>>isinstance('abc',Iterable)  ---> True

      18、斐波那契数列(Figonacci): 除第一个和第二个数之外，任意一个数都可由前面两个数相加得到
            a,b = 0,1 ; a,b = b,a+b
            斐波那契数列用列表生成式写不出来，但是，用函数把它打印出来却很简单.

函数笔记

一、函数定义

什么是函数？

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

特点：① 减少重复代码；② 使程序变的可扩展；③ 是程序变得可维护。

语法定义：

def sayhi():#函数名
    print("Hello!")

sayhi() #调用函数

可以带参数

def calc(x,y):
    res = x**y
    return res #返回函数执行结果

c = calc(a,b) ＃结果赋值给c变量
print(c)

函数参数

形参变量：只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。

实参：可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。

默认参数

　　形参在定义时就已经为其赋值，可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）

参考如下代码

def stu_register(name,age,country,course):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)

stu_register("王山炮",22,"CN","python_devops")
stu_register("张叫春",21,"CN","linux")
stu_register("刘老根",25,"CN","linux")

　发现 country 这个参数 基本都 是"CN", 就像我们在网站上注册用户，像国籍这种信息，你不填写，默认就会是 中国， 这就是通过默认参数实现的，把country变成默认参数非常简单。

def stu_register(name,age,course,country="CN"):

这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。

注意的问题：1. 只在定义时赋值一次；2. 默认参数的定义应该在位置形参右面；3. 默认参数通常应该定义成不可变类型

另外，你可能注意到了，在把country变成默认参数后，我同时把它的位置移到了最后面，为什么呢？

关键参数

　　正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可(指定了参数名的参数就叫关键参数)，但记住一个要求就是，关键参数必须放在位置参数(以位置顺序确定对应关系的参数)之后。

def stu_register(name, age, course='PY' ,country='CN'):
    print("----注册学生信息------")
    print("姓名:", name)
    print("age:", age)
    print("国籍:", country)
    print("课程:", course)

　可以这样调用

stu_register("王山炮",course='PY', age=22,country='JP' )

　但不可以这样调用

stu_register("王山炮",course='PY',22,country='JP' )

 # 这样相当于给age赋值2次，会报错！
stu_register("王山炮",22,age=25,country='JP' )

非固定参数

　　若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数

def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)

stu_register("hyp",22)
#输出
#hyp 22 () #后面这个()就是args,只是因为没传值,所以为空

stu_register("Jack",32,"CN","Python")
#输出
# Jack 32 ('CN', 'Python')

　还可以有一个**kwargs

def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
    print(name,age,args,kwargs)

stu_register("hyp",22)
#输出
#hyp 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空

stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

返回值

　　函数外部的代码要想获取函数的执行结果，就可以在函数里用return语句把结果返回

def stu_register(name, age, course='PY' ,country='CN'):
    print("----注册学生信息------")
    print("姓名:", name)
    print("age:", age)
    print("国籍:", country)
    print("课程:", course)
    if age > 22:
        return False
    else:
        return True

registriation_status = stu_register("王山炮",22,course="PY全栈开发",country='JP')

if registriation_status:
    print("注册成功")
else:
    print("too old to be a student.")

　注意：

• 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束。
• 如果未在函数中指定return,那这个函数的返回值为None。

全局变量与局部变量

name = "hyp"

def change_name(name):
    print("before change:",name)
    name = "hyp是一个有女朋友的人"
    print("after change:", name)

change_name(name)

print("在外面看看name改了么?",name)

# 输出
before change: hyp
after change: hyp是一个有女朋友的人
在外面看看name改了么? hyp

　不用传name 值到函数里，也可以在函数里调用外面的变量

name = "hyp"

def change_name():
    print("now name: ", name)

change_name()

print("外部的name: ", name)

# 输出
now name: hyp
外部的name: hyp

　但就是不能改！

• 在函数中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
• 全局变量作用域是整个程序，局部变量作用域是定义该变量的函数。
• 当全局变量与局部变量同名时，在定义局部变量的函数内，局部变量起作用；在其它地方全局变量起作用。

作用域

　　作用域（scope），程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。

如何在函数里修改全局变量？

name = "hyp"

def change_name():
    global name
    name = "hyp还是一名学生"
    print("after change", name)

change_name()

print("在外面看看name改了么?", name)

　global name的作用就是要在函数里声明全局变量name ，意味着最上面的name = "hyp"即使不写，程序最后面的print也可以打印name

嵌套函数

name = "hyp"

def change_name():
    name = "hyp2"

    def change_name2():
        name = "hyp3"
        print("第3层打印", name)

    change_name2()  # 调用内层函数
    print("第2层打印", name)

change_name()
print("最外层打印", name)

# 输出
第3层打印 hyp3
第2层打印 hyp2
最外层打印 hyp

匿名函数

　　匿名函数就是不需要显式的指定函数名

#这段代码
def calc(x,y):
    return x**y

print(calc(2,5))

#换成匿名函数
calc = lambda x,y:x**y
print(calc(2,5))

　匿名函数主要是和其它函数搭配的使用，如下

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

高阶函数

　　变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

只需满足以下任意一个条件，即是高阶函数

• 接受一个或多个函数作为输入
• return 返回另外一个函数

def add(x,y,f):
    return f(x) + f(y)

res = add(3,-6,abs)
print(res)

递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def calc(n):
    print(n)
    if int(n/2) ==0:
        return n
    return calc(int(n/2))

calc(10)

# 输出
10
5
2
1

　来看实现过程，我改了下代码

def calc(n):
    v = int(n/2)
    print(v)
    if v > 0:
        calc(v)
    print(n)

calc(10)

# 输出
5
2
1
0
1
2
5
10

为什么呢？来看执行过程是这样的

递归的特性：

1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

递归有什么用呢？递归函数实际应用案例，二分查找

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]

def binary_search(dataset,find_num):
    print(dataset)

    if len(dataset) >1:
        mid = int(len(dataset)/2)
        if dataset[mid] == find_num:  #find it
            print("找到数字",dataset[mid])
        elif dataset[mid] > find_num :# 找的数在mid左面
            print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:# 找的数在mid右面
            print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
            return binary_search(dataset[mid+1:],find_num)
    else:
        if dataset[0] == find_num:  #find it
            print("找到数字啦",dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)

binary_search(data,66)

二分查找

内置函数

1.abs()【绝对值】

2.all()集合中的元素都为真的时候为真,若为空串返回为True

3.any()集合中的元素有一个为真的时候为真若为空串返回为False

4.chr()返回整数对应的ASCII字符

5.ord()返回字符对应的ASC码数字编号

6.bin(x)将整数x转换为二进制字符串

7.bool(x)返回x的布尔值

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

9.divmod()分别取商和余数.

10.enumerate()返回一个可枚举的对象,该对象的next()方法将返回一个tuple

11.eval()将字符串str当成有效的表达式来求值并返回计算结果。

12.filter(function, iterable)函数可以对序列做过滤处理

13.hex(x)将整数x转换为16进制字符串。

14.id()返回对象的内存地址

15.len()返回对象的长度

16.map遍历序列，对序列中每个元素进行操作，最终获取新的序列。

17.oct()八进制转换

18.range()产生一个序列，默认从0开始

19.reversed()反转

20.round()四舍五入

21.sorted()队集合排序

22.sum()对集合求和

23.type()返回该object的类型

24.vars()返回对象的变量，若无参数与dict()方法类似。

25.zip()zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。

26.reduce()对于序列内所有元素进行累计操作.

内置参数详解： https://docs.python.org/3/library/functions.html?highlight=built#ascii

几个刁钻古怪的内置方法用法提醒

#compile
f = open("函数递归.py")
data =compile(f.read(),'','exec')
exec(data)

#print
msg = "又回到最初的起点"
f = open("tofile","w")
print(msg,"记忆中你青涩的脸",sep="|",end="",file=f)

# #slice
# a = range(20)
# pattern = slice(3,8,2)
# for i in a[pattern]: #等于a[3:8:2]
#     print(i)
#
#

#memoryview
#usage:
#>>> memoryview(b'abcd')
#<memory at 0x104069648>
#在进行切片并赋值数据时，不需要重新copy原列表数据，可以直接映射原数据内存，
import time
for n in (100000, 200000, 300000, 400000):
    data = b'x'*n
    start = time.time()
    b = data
    while b:
        b = b[1:]
    print('bytes', n, time.time()-start)

for n in (100000, 200000, 300000, 400000):
    data = b'x'*n
    start = time.time()
    b = memoryview(data)
    while b:
        b = b[1:]
    print('memoryview', n, time.time()-start)