python-基础-4-函数

参考: 教学博客地址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)

十一、内置函数

官方内置函数

Built-in Functions
abs()delattr()hash()memoryview()set()
all()dict()help()min()setattr()
any()dir()hex()next()slice()
ascii()divmod()id()object()sorted()
bin()enumerate()input()oct()staticmethod()
bool()eval()int()open()str()
breakpoint()exec()isinstance()ord()sum()
bytearray()filter()issubclass()pow()super()
bytes()float()iter()print()tuple()
callable()format()len()property()type()
chr()frozenset()list()range()vars()
classmethod()getattr()locals()repr()zip()
compile()globals()map()reversed()__import__()
complex()hasattr()max()round()

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
已标记关键词 清除标记
相关推荐
<p> <span><strong> </strong></span> </p> <p> <strong><span style="color:#337FE5;">【</span><strong><span style="color:#337FE5;">为什么学</span></strong><strong><span style="color:#337FE5;">Python?</span></strong><span style="color:#337FE5;">】</span></strong> </p> <p> Python 是当今非常热门的语言之一,2020年的 TIOBE 编程语言排行榜中 ,Python名列第一,并且其流行度依然处在上升势头。 </p> <p> 借此机会,裴老师联合CSDN推出了本课程,希望能影响更多的人走进Python,踏入编程的大门。 </p> <p> <br /> </p> <p> <strong><span style="color:#337FE5;">【</span><strong><span style="color:#337FE5;">你将收获什么?</span></strong><span style="color:#337FE5;">】</span></strong> </p> <p> · 本课程就是为开发者抓住“新基建”这个历史机遇而设置的。认真地学完了本课程,你就有了一把钥匙,所谓“时势造英雄”,Python语言就是未来成长的垫脚石。 </p> <p> · 从核心基础概念到常见第三方模块,包括数据结构、逻辑运算、常见语句、函数、类及第三方模块,丰富的案例帮助学员快速入门Python。 </p> <p> · “授人以鱼”和“授人以渔”并重是本课程的特色。通过在本课程的学习,学员能够以Python语言为载体,掌握研习高级编程语言的一般方法,为后续个人发展奠定基础。  </p> <p> <br /> </p> <p> <span style="color:#337FE5;"><strong>[知识脉络图]</strong></span> </p> <p> <span style="color:#337FE5;"><strong><img src="https://img-bss.csdnimg.cn/202007220623236011.png" alt="" /><br /> </strong></span> </p>
<p class="ql-align-justify ql-text-indent-1 ql-long-5888348" style="text-indent: 29.3333px; line-height: 1.7; margin-bottom: 0pt; margin-top: 0pt; text-align: justify; font-size: 11pt; color: #494949;" align="justify"><span class="ql-author-5888348">本课程主要介绍Python的基础知识以及展示一些企业级项目实战,并介绍如何安装Python并成功运行成功第一行Python代码。在之后将介绍Python的基础知识点(包括Python基础常识、最重要的三大语句、Python函数与模块),为之后的进阶知识做铺垫。</span></p> <p class="ql-align-justify ql-text-indent-1 ql-long-5888348" style="text-indent: 29.3333px; line-height: 1.7; margin-bottom: 0pt; margin-top: 0pt; text-align: justify; font-size: 11pt; color: #494949;" align="justify"> </p> <p class="ql-align-justify ql-text-indent-1 ql-long-5888348" style="text-indent: 29.3333px; line-height: 1.7; margin-bottom: 0pt; margin-top: 0pt; text-align: justify; font-size: 11pt; color: #494949;" align="justify"><span class="ql-author-5888348">学完Python基础知识点后,将通过5个综合案例实战来体会Python的实际应用,包括:1.商业实战之德勤笔试题;2.大数据分词与词云图绘制;3.文字识别、人脸识别实战;4.爬虫初尝试 -  百度新闻爬取;5.正则表达式提取百度新闻。通过学习这些Python基础及案例实战后,就可以进入Python编程的大门,为之后更加丰富精彩的案例实战做准备。</span></p>
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页