参考： 教学博客地址1，教学博客地址2，教学博客地址3

函数

一、函数基础

1.1、什么是函数

        函数的作用是非常重要的，函数可以说是现代编程中最小的模块单元，其本质上是子程序，就是可以独立执行一个功能的程序，函数的操作方法是将函数体压入栈中,然后传入参数,在计算完毕之后,将return的值返回到调用处,然后将函数从栈中释放出去.

        函数对于编程的一般意义来讲,是实现一个特定的功能,并且可以反复调用,减少代码量，在python里没有return语句的话会返回None,所以python里没有真正意义上的过程.所有的都是函数.

        面向对象其实是在函数上发展起来的，对象的方法其实就可以看做函数，当然函数在面向对象的语言中也是函数，可以认为面向对象语言是将函数，基础数据类型这些东西做了一个更高层次的封装.

1.2、为何要用函数之不用函数的问题

#1、 代码的组织结构不清晰，可读性差
#2、 遇到重复的功能只能重复编写实现代码，代码冗余
#3、 功能需要扩展时，需要找出所有实现该功能的地方修改之，无法统一管理且维护难度极大 

1.3、函数分类

#1、内置函数
为了方便我们的开发，针对一些简单的功能，python解释器已经为我们定义好了的函数即内置函数。对于内置函数，我们可以拿来就用而无需事先定义，参考官网：https://docs.python.org/3/library/functions.html

#2、自定义函数
在一些的场景中内置函数是可能无法满足需求的，这就可能需要根据自身或项目要求来定制自己的函数来实现，后续如果遇到相应的场景，直接设定所定义的函数即可。

1.4、自定义函数

#语法,函数名要能反映其意义
def 函数名(参数1,参数2,参数3,...):
    '''注释'''
    函数体
    return 返回的值

# 一个简单的实例
def hello():
    print("你好")
hello()  		# 直接调用就能显示函数的print结果，但是如果没有return返回过程，那么其结果一定是none

# 比如 login
def login():
    username = input("请输入用户名: ")
    password = input("请输入密码: ")

    if username == "xiong" and password == "123":
        return "登陆通过"
    return "错误"

print(login())

1.5、函数原则及定义

# 1、函数需要先定义，然后在调用， 但A函数调用B，但B函数在A函数之后，那就会报错
def a():
    print("这里是a")
    b()
a()   # 先引用了a函数，但是b函数还没有引用到内存中，就会出现 b函数没有被定义

def b():
    print("这里是b")

# 2、函数定义阶段
    # 函数在引用时啥都不会干，只会加载到内存中，但它一旦被调用就会执行函数内的过程

1.6、有参无参

def play():
    print("玩耍")

def get(num):
    print("你的号码是: {}".format(num))

play()
get(12332112222)

1.7、函数返回值

无return-> pring时会直接打印 None
return 1个值->返回1个值
return 逗号分隔多个值->元组

• 什么时候该有返回值？
  • 调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值
  • 通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果
• 什么时候不需要有返回值？
  • 调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值
  • 通常无参函数不需要有返回值

1.8、形参与实参

# 形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定

• 位置参数

按照从左到右的顺序定义的参数
	位置形参：必选参数
	位置实参：按照位置给形参传值

def test(v1,v2):		# 2、函数test(形参v1,v2)
	print(v1,v2)		# 3、当调用之后，获取实参 3 5

test(3,5)		# 1、调用 test(传递实参 3 5)

• 关键字参数

按照key=value的形式定义的实参,无需按照位置为形参传值
注意的问题：
    1. 关键字实参必须在位置实参右面
    2. 对同一个形参不能重复传值

def local(v1, status=False):			 # 2、关键字参数必须在最右边
    return v1 if status else "木有状态"	   # 3、三元表达式 获取任意一个值返回其状态
print(local("hello"))     				 # 1、当有关键字参数时，可以不用传递 默认就是false


# 失败案例， 这种是不可以的
    # non-default argument follows default argument
    def the_test(v1, status=False, v2):	
        return v1 if status else "木有状态"		

    # duplicate argument 'v1' in function definition
    def the_test(v1, v2, v1):      
        return v1 if v2 else "木有状态"

• 默认参数

# 可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
注意的问题：
    1. 只在定义时赋值一次
    2. 默认参数的定义应该在位置形参右面
    3. 默认参数通常应该定义成不可变类型

# 与关键字参数差不多

• 可变长参数

  可变长指的是实参值的个数不固定
  而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs
  
  #################################### *args ####################################
  def test(x, y, *args):
      print("x: {} ny: {} nargs: {}".format(x, y, args))
  
  
  test(1, 2, 3, 4, 5, 6, 7, 8)  # args: (3, 4, 5, 6, 7, 8)
  
  # 如果不做处理，那么传递的就是一个元组加列表的形式
  test(1, 2, [1, 2], [111, 22])  # args: ([1, 2], [111, 22])
  
  # 通过 *[] 类似于迭代直接列表做了一个for循环传递到*args当中
  test(1, 2, *[1, 2, 3, 5, 6])  # args: (1, 2, 3, 5, 6)
  
  
  #################################### **kwargs ####################################
  def test(x, **kwargs):
      print("x: {} nkwargs: {}".format(x, kwargs))
  
  
  # kwargs: {'k': '123', 'k2': '234', 'k3': '345', 'k4': '456'}
  test(1, k="123", k2="234", k3="345", k4="456")
  
  # 通过迭代的方式传递，先解开然后在传值， 如果直接传字典会报错
  test(1, **{'k': '123', 'k2': '234', 'k3': '345', 'k4': '456'})
  
  
  ############################ *args + **kwargs ####################################
  def test(*args, **kwargs):
      print("args: {}nkwargs: {}".format(args, kwargs))
  
  
  # args: (1, 2, 3) kwargs: {'k': '123', 'k2': '234'}
  test(1, 2, 3, k="123", k2="234")
  
  # args: (1, 2, 3) kwargs: {'k': '123', 'k2': '234'}
  test(*[1, 2, 3], **{'k': '123', 'k2': '234'})
  

二、对象及嵌套

2.1、函数对象

函数是第一类对象，即函数可以当作数据传递

#1 可以被引用
#2 可以当作参数传递
#3 返回值可以是函数
#3 可以当作容器类型的元素

# 示例  特性
def foo():
    print("foo")

def bar():
    print("bar")

dic = {
    "foo": foo,
    "bar": bar
}

while True:
    chiose = input(">>: ").strip()
    if chiose in dic:
        dic[chiose]()

2.2、嵌套调用

def max(x, y):
    return x if x > y else y

def check(a, b, c, d):
    res1 = max(a, b)			# check嵌套max使用
    res2 = max(c, d)			# 两两比较，在得出最大值
    return max(res1, res2)

print(check(11, 2, 3, 4))

三、名称空间与作用域

• 什么是名称空间

#名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方）

• 名称空间的加载顺序

  python test.py
  #1、python解释器先启动，因而首先加载的是：内置名称空间
  #2、执行test.py文件，然后以文件为基础，加载全局名称空间
  #3、在执行文件的过程中如果调用函数，则临时产生局部名称空间
  
  # 名字的查找顺序
      局部名称空间--->全局名称空间--->内置名称空间
      #需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例
  
  def foo():
      max_num = 111		 # 2、min_num相对于foo来说就是一个局部名称变量了
  
      def foo_two():
          min_num = 2222    # 1、max_num相对于foo_two来说也是一个全局变量
          return min_num
      foo_two()
      return max_num
  
  foo()     
  # 然后Py里直接执行 max_num 会报出 NameError: name 'max_num' is not defined
  

• 作用域

  #1、作用域即范围
      - 全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效
      - 局部范围（局部名称空间属于该范围）：临时存活，局部有效
  #2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下
  
  x=11111
  def f1():
      def f2():
          print(x)
      return f2
  
  x = 22222
  
  def f3(func):
      x = 33333
      func()
  
  f3(f1())     # 最终的结果是 22222
  # 先到 全局11111- 22222， 执行f3->f1->f2，f2此时是22222，然后进入x=33333,执行函数func 由于x=33333是局部范围，所以并没有更改x的全局变量，然后在打印 结果为22222
  

• 作用域查询

  #3、查看作用域：globals(),locals()
  
  LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
  locals 是函数内的名字空间，包括局部变量和形参
  enclosing 外部嵌套函数的名字空间（闭包中常见）
  globals 全局变量，函数定义所在模块的名字空间
  builtins 内置模块的名字空间
  

• global与nonlocal关键字

  global 将局部变量 修改为全局变量， 这个关键字并不建议使用，如果引用全局可变对象,也就是按引用传递,最好将引用复制一份,否则对全局可变对象直接操作,会修改全局可变对象
  
  max = 123
  def f1():
      # global max		# 1、如果引用了global那么它会修改全局变量
      max = 12321
      print(max)
  
  f1()
  print(max)    			# 2、这里得到的结果就是12321
  
  # nonlocal  如果想指定上一层的局部变量,用nonlocal声明
  
  min = "最小值"
  def f2():
      min = "f2里头的"
  
      def f3():
          nonlocal min      # 只修改函数内的上一级
          min = "f3里的"
          print("*" * 10, min)
          
      def f4():     
          print(min)   # f3 修改了f2的min值，此时f4得到的全局变量 f2的min就是 f3的结果了
  
      f3()
      f4()
      print(min)
  
  f2()
  print(min)
  
  ############################  结果为  ############################
      ********** f3里的
      f3里的
      最小值
  

四、闭包

4.1、什么是闭包？

# 内部函数包含对外部作用域而非全局作用域的引用
# 提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，将函数包裹起来

def t1():
    n = 0
    def t2():
        nonlocal n  # 修改上层的n值
        x = n  		# 重新赋值x
        n += 1  	# 每次执行函数+1
        return x  	# 返回修改之后的值

    return t2  # 返回x

c = t1()
print(c())  # 0
print(c())  # 1
print(c())  # 2
print(c())  # 3
print(c.__closure__[0].cell_contents)  #查看闭包的元素  下一次就是4了

4.2、闭包的意义与应用

#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
#应用领域：延迟计算（原来我们是传参，现在我们是包起来）

from urllib.request import urlopen

def index(url):
    def get():
        return urlopen(url).read()
    return get

bd=index("http://www.baidu.com")   # 得到的是一个内存对象
print(bd().decode('utf-8'))

五、装饰器

装饰器就是闭包函数的一种应用场景

为什么用装饰器

程序中的函数就是具备某一功能的工具, 装饰器就是一个函数,
定义装饰器就是定义一个函数, 只不过装饰器的功能是就是用来给其它函数添加额外的功能,
装饰器( 被装饰的对象 )本身其实是任意可调用的对象, 

软件的维护应该遵循开放封闭原则
开放封闭的原则是: 软件一旦上线运行后对修改源代码是封闭的,对扩展功能是开放的
    装饰器的实现必须遵循的两大原则
   1、不修改被装饰对象的源代码
   2、不修改被装饰对象的调用方式

装饰器语法糖 
	在被装饰的函数上加上 @装饰器 (闭包函数)  等于 函数名=装饰器(函数名)

5.1、无参装饰器

5.1、示例一

简单demo 写法一：  有一定的局限性

import time

def home():
    print("welcome home ")
    time.sleep(2)

def times(func):
    def warpper():
        start = time.time()
        func()     # 执行被装饰的函数
        end = time.time()
        print("装饰器执行的时长为: {}".format(end-start))
    return warpper    # 拿到并返回装饰函数的内存地址

home = times(home)
home()

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

demo 第二个

def index():
    print("welcome to index..")
    time.sleep(1)
    return 123

def home(tip):
    print("this price {}".format(tip))

def timmer(func):
    def warpper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()
        print("程序运行时间: {}".format(end-start))
        return res
    return warpper

index = timmer(index)
print(index())
home = timmer(home)
home(100)

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

demo 第三个    装饰器语法糖的方式
import time

timmer函数不变

@timmer         #  等于 index = timmer(index)
def index():
	.....
	
@timmer         #  等于 home=timmer(home)
def home(tip):
    print("this price {}".format(tip))


print(index())
home(100)

5.2、有参装饰器

import time

current_user = {"user": None}
def auth(eng):
    def timeer(func):
        def wrapper(*args, **kwargs):
            if current_user["user"]:
                res = func(*args, **kwargs)
                return res

            username = input("请输入用户: ").strip()    # 输入用户 去掉空格
            pwd = input("请输入密码: ").strip()         # 输入密码 去掉空格
            if eng == "file":
                if username == "xiong" and pwd == "123":
                    current_user["user"] = "xiong"
                    print("登陆成功")
                else:
                    print("登陆失败")
            elif eng == "mysql":
                print("mysql登陆")
            res = func(*args, **kwargs)
            return res
        return wrapper
    return timeer

timeer = auth(eng="file")

@timeer
def index():
    print("this's index page")
    time.sleep(1)

@auth(eng="file")
def home():
    print("this's home page")
    time.sleep(1)

index()
home()

装饰器- wraps

**@wraps**接受一个函数来进行装饰，并加入了复制函数名称、注释文档、参数列表等等的功能。这可以让我们在装饰器里面访问在装饰之前的函数的属性。

demo-1 - 不带参数的装饰器

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
from functools import wraps

check_auth = {"user": None}


def auth(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        if check_auth["user"]:
            res = func(*args, **kwargs)
            return res
        user = input("username >>>: ").strip()
        passwd = input("passwd >>>: ").strip()
        if user == "xiong" and passwd == "123":
            res = func(*args, **kwargs)
            return res
        return "登陆失败"

    return wrapper

@auth         # 相当于是 login=auth(login)
def login():
    return "登陆到了主页"


print(login())

demo-2 - 带参数的装饰器

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
from functools import wraps

check_auth = {"user": None}


def check_auth_types(auth_type="file"):
    def auth(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            if check_auth["user"]:
                res = func(*args, **kwargs)
                return res
            if auth_type == "file":
                print("文件认证")
                user = input("username >>>: ").strip()
                passwd = input("passwd >>>: ").strip()
                if user == "xiong" and passwd == "123":
                    res = func(*args, **kwargs)
                    return res
            if auth_type == "mysql":
                return func(*args, **kwargs),"数据库认证"
            return "登陆失败"

        return wrapper

    return auth


x = check_auth_types(auth_type="mysql")

@check_auth_types(auth_type="mysql")  # 也可以是 @x
def login():
    return "登陆到了主页"
#  check_auth_types 传递参数，返回给了auth, 做为有参装饰器继续往里传递执行

print(login())

多个装饰器

# 叠加多个装饰器
# 1. 加载顺序(outter函数的调用顺序):自下而上
# 2. 执行顺序(wrapper函数的执行顺序):自上而下

六、迭代器

迭代器概念

# 迭代器即迭代的工具，那什么是迭代呢？
# 迭代是一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值

while True: # 只是单纯地重复，因而不是迭代
    print('===>') 	# 一个无脑的死循环

lis=[1,2,3]
count=0
while count < len(lis): # 迭代 重复的过程，但每次迭代都是下一次的初始值
    print(lis[count])
    count+=1			# 每次加1， 如果没有+1 那就不是下一次的初始值 == 一个无脑的死循环

为何要有迭代器？什么是可迭代对象？什么是迭代器对象？

#1、为何要有迭代器？
	对于序列类型：字符串（str）、列表(list)、元组(tuple)，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

#2、什么是可迭代对象？
    可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下 
    # 也可通过 dir() 可查看内置函数方法 __iter__
    'hello'.__iter__
    (1,2,3).__iter__
    [1,2,3].__iter__
    {'a':1}.__iter__
    {'a','b'}.__iter__
    open('a.txt').__iter__

#3、什么是迭代器对象？
    可迭代对象执行obj.__iter__()得到的结果就是迭代器对象
    执行迭代器对象是__next__得到的是迭代器下一个值
    执行迭代器对象的__iter__得到的仍然是迭代器本身
    而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

文件类型是迭代器对象
open('a.txt').__iter__()
open('a.txt').__next__()

# 使用
dic = {'a': 1, 'b': 2, 'c': 3}
iter_dic = dic.__iter__() #得到迭代器对象，迭代器对象即有__iter__又有__next__，但是：迭代器.__iter__()得到的仍然是迭代器本身
print(iter_dic, type(iter_dic))
# <dict_keyiterator object at 0x0000020BAF49BB88> <class 'dict_keyiterator'>

print(iter_dic.__next__())
print(iter_dic.__next__())
print(iter_dic.__next__())
# print(iter_dic.__next__())  # StopIteration

#4、注意：
迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

for循环 - 迭代器

dic = {'a': 1, 'b': 2, 'c': 3}

for i in dic:  	   # dic.__iter__()  得到迭代器对象
    print(dic[i])  # 每次循环都是 xx.__next__() 获取值,直到StopIteration

# for循环的工作原理
# 1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic
# 2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码
# 3: 重复过程2，直到捕捉到异常StopIteration,结束循环

迭代器优缺点

#优点：
  - 提供一种统一的、不依赖于索引的迭代取值方式
  - 惰性计算，节省内存

#缺点：
  - 迭代器的取值不如按照索引的方式灵活，它只能往后取而不能往前退
  - 无法预测迭代器的个数
  - 无法获取长度（只有在next完毕才知道到底有几个值）
  - 一次性的，只能往后走，不能往前退

七、生成器-yield

# 生成器 generator
	生成器指的是生成器对象，可以由生成器表达式得到，也可以使用yield关键字得到一个生成器函数，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码
    
# 生成器函数
	函数体中包含yield语句的函数，返回生成器对象
    生成器对象，是一个可迭代对象，是一个迭代器
    生成器对象，是延迟计算、惰性求值的

示例

def yie():
    for i in range(5):
        yield i


print(type(yie))
print(type(yie()))   # <class 'generator'>
y = yie()			 # 通过生成器生成的对象都是一个内存地址 
for i in y:
    print(i)

普通的函数调用 fn()，函数会立即执行完毕，但是生成器函数可以使用next函数多次执行
生成器函数等价于生成器表达式，只不过生成器函数可以更加复杂

yield from

def yie():
    for x in range(100): yield x

# 等价于
def yie():
    yield from range(100)

yield from 是python3.3出现的新语法，  是fro item in iterable: yield item形式的语法糖

八、表达式

1.1、三元表达式

条件成立时的返回值， if 条件 else 条件不成立时时的返回值

def check(x,y):
    if x > y:
        return x
    else:
        return y

x=10
y=20

# 三元表达式   如果x 大于 y 最左边为x （true），最右边为如果不大于的结果
res = x if x > y else y   # 如上的函数可以简化为这种三元表达式
print(res)

1.2、列表生成式

# 重要： 把列表推导式的[]换成()就是生成器表达式

li=[]
for i in range(10):
    li.append(i)
print(li)

# 在列表中循环, 然后将循环的值放到左右就能直接append了
li2 = [i for i in range(10)]
print(li2)

# 列表生成式 只能 for if 不能跟else
name = ["xiong", "xiong2", "xiong3"]
li3 = [i for i in name if i not in "xiong"]
print(li3)

# 循环1到10如果小于5 那么i就加1,
li4 = [i+1 for i in range(1,10) if i<5]
print(li4)

1.3、生成器表达式

# 把列表推导式的[]换成()就是生成器表达式

x = (i for i in range(10))
print(x, type(x))
# <generator object <genexpr> at 0x00000231AB5725E8> <class 'generator'>

# 使用生成器的优点：省内存，一次只产生一个值在内存中，每次执行next只会取出一个

with open("a.txt", "r") as files:
    # 生成器刚开始造的时候 代码不会执行， 只能在.__next() 调用的时候才会运行
    nums = (len(line) for line in files)
    print(max(nums))

1.4、字典生成式

keys=["name", "age", "sex"]
values = ["xiong", "100", "male"]
# zip 拉链函数 将两个值对应成元组 如 (name, xiong)
print(list(zip(keys,values)))

res = {k:v for k,v in zip(keys, values)}
print(res)
# {'name': 'xiong', 'age': '100', 'sex': 'male'}

1.5、元组生成器

tuple(random.randint(0, 255) for i in range(3))
(241, 97, 220)

九、递归与二分法

1.1、什么是递归

# 1、什么是递归
	递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用
   	递归就是一个无何止的重复过程， 递归必须要有一个明确的结束条件

# 2、代码特点
    - 函数内部的 代码 是相同的，只是针对 参数不同，处理的结果不同
    - 当参数满足一个条件时，函数不再执行
      - 这个通常称为递归的出口，否则会出现死循环

# 3、递归阶段
    递归必须要有两个明确的阶段
    	递推： 一层一层递归调用下去，每进入下一层递归问题的规模都必须有所减少
        回溯： 递归必须要有一个明确的结束条件，在满足该条件时结束递推，开始一层一层回溯	
    递归的精髓在于通过不断地重复逼近一个最终的结果

# 4、递归层级
    print(sys.getrecursionlimit())  # 获取递归的层级， 1000层
    sys.setrecursionlimit(next())	# 设置递归的层级，但没有多大的意义，如果太多可能会导致内存崩掉

# 5、为什么使用递归
	递归本身就是一个重复的过程，while循环本身也是做一个重复的过程，递归能做的事 循环也都能满足，但比如是如下这种使用while就会显得比较麻烦，而直接使用递归就能得出想要的结果
    
l = [1, [2, [3, [4, [5, [6, [7, [8]]]]]]]]

def dl(l):
    for its in l:
        if type(its) is list:
            dl(its)
        else:
            print(its)
dl(l)

# 示例2 
def age(n):
    if n == 1: return 10     
    return age(n-1)+2      // 递推到n等于1时返回10,  然后取到10每次加2  

print(age(5)) 循环五次

1.2、递归-二分法

# 查找列表
search_list = [1, 3, 5, 7, 9, 11, 23, 33, 44, 112, 115, 125, 136, 147, 199]

def search(search_list, num):
    two_search = len(search_list) // 2  # # 每次取一半
    if two_search == 0:
        print("没有这个")
        return
    if num > search_list[two_search]:
        n = search_list[two_search:]
        search(n, num)
    elif num < search_list[two_search]:
        n = search_list[:two_search + 1]
        search(n, num)
    else:
        print("找着了")

search(search_list, 112)

十、匿名函数

# 有名函数，调用函数名可以一直重复使用
# 有名函数
def fun(x, y):
    return x + y

print(fun(1, 4))

# 匿名函数， 通常于其它函数一起使用，直接执行就的是一个内存地址， :后的x+y就相当于是return x+y
print(lambda x, y: x + y)  # <function <lambda> at 0x000002948ACD47B8>
# 与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字

示例

salaries = {
    "axiong": 10000,
    "wen": 99000,
    "hei": 19999,
    "bai": 22222
}

def fun(k):
    return salaries[k]

max工作原理：

1、 先将可迭代对象变成 迭代器对象
2、 res=next(可迭代器对象), 将res当作参数传递给max函数，然后将该函数的返回值当作判断依据

# 最大值就是w，但func却只需要一次性使用，这里就可以直接使用匿名函数了
# max(iterable, *[, default = obj, key = func]) -> value
# max(arg1, arg2, *args, *[, key = func]) -> val, key=funue
print(max(salaries, key=fun))
print(max(salaries, key=lambda k:salaries[k]))    # wen
print(min(salaries, key=lambda k:salaries[k]))    # axiong

sorted

# sorted 排序
print(sorted(names, reverse=True))  # 从大到小
print(sorted(names, reverse=False))  # 从小到大

# 与匿名函数进行配置 sorted(可迭代对象, key=匿名函数, 排序=True/False)
print(sorted(names, key=lambda x:x, reverse=True))
print(sorted(names, key=lambda x:x, reverse=False))

map工作原理

1、 先将可迭代对象变成 迭代器对象
2、 res=next(可迭代器对象), 将res当作参数传递给第一个参数指定的函数，然后将该函数的返回值当作map的结果之一
3、 映射： 将原来的值映射成新的值 

# 映射，将列表的旧值映射为新的值
m_name = map(lambda x: x + "XXS", names)  # ['heiXXS', 'baiXXS', 'hongXXS', 'nvXXS']
print(list(m_name))  # 如果不使用list 打印的话  打印的结果就是迭代器对象，需要通过 __next__

# 与如下的列表生成式相等
m_name = [name + "xxxx" for name in names]
print(m_name)

filter工作原理

1、 先将可迭代对象变成 迭代器对象
2、 res=next(可迭代器对象), 将res当作参数传递给第一个参数指定的函数，然后filter会判断函数的返回值 的真假，如果为真则留下res

names = ["xiongge", "wo", "ni", "hao"]

#  列表生成器
res = [name for name in names if name.endswith("ge")]
print(res)

# filter 过滤器  filter(匿名函数, 可迭代对象)
f_name = filter(lambda x: not x.endswith("ge"), names)
print(f_name)  # <filter object at 0x000002B9433EB240>
print(list(f_name))  # ['wo', 'ni', 'hao']

# 使用lamba过滤  filter   过滤某个条件     
语法：  lambda i: i %2, range(10)   等于是下面这个函数 
def t1(i):
    temp=[]
    for i in range(10):
        temp.append('{0}'.format(i%2))
    return temp

y=list(filter(lambda i:i %2, range(10)))
print(y)  # [1, 3, 5, 7, 9]

map() 可以批量处理数据，与filter() 相比，输入可以是多个可迭代对象
xx = map(lambda x:x, range(10))
print(list(xx))   # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

使用递归打印斐波那契数列

# 使用递归打印斐波那契数列

def fib(n):
    a, b = 0, 1
    while a < n:
        print(a, end=" ")
        a, b = b, a + b
    print(" ")


fib(20)


def flb(a, b, stop):
    if a > stop:
        return
    print(a, end="t")
    flb(b, a + b, stop)

# 一个嵌套很多层的列表，如l=［1,2,[3,[4,5,6,[7,8,[9,10,[11,12,13,[14,15]]]]]]］，用递归取出所有的值
l = [1, 2, [3, [4, 5, 6, [7, 8, [9, 10, [11, 12, 13, [14, 15]]]]]]]
def gl(l):
    if type(l) is list:
        for li in l:
            gl(li)
    else:
        print(l, end="t")

gl(l)

十一、内置函数

官方内置函数

11.1、需要了解的函数

# 列表中所有值为真，则为真，如果为空也是真
	print(all([1, 2, 3, 4, 5]))     # True

# 有一个bool值为真，则为真，  如果为空则是false
	print(any([1, 0, False]))       # True

# 十进制转二进制
	print(bin(11))                  # 0b1011
    
# oct  十进制转八进制
    print(oct(9))                   # 0o11

# hex 十进制转十六进制
	print(hex(19))                  # 0x13

# chr()  将数字转换成字符
	print(chr(103))                 # g

# ord 将字符串转成数字
	print(ord("g"))                 # 103

# dir   判断函数里的所有属性
	print(dir(True))                # ['__abs__', '__add__',....]

# pow (3,2,2)   3的2次方取余
	print(pow(5,2,2))               # 1
    
# round(3.5)  四舍五入
    print(round(3.99))              # 4
    
callable()   判断函数是否可被调用

divmod(10,3)     分页使用，  比如31 就是  3,1 总共有30页 余1页

最后

以上就是高大寒风为你收集整理的python-基础-4-函数函数的全部内容，希望文章能够帮你解决python-基础-4-函数函数所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。