高阶函数:

  

def f(n):
return n*n
def foo(a,b,func):
func(a)+func(b)
ret=func(a)+func(b)
return ret
foo(1,2,f) #f是函数foo的实参,func是函数foo的形参,因为f为函数名,所以就是变量,将地址传给了func
print(foo(1,2,f)) #输出的是函数的返回值5

2

+2

2

=5

注意函数加括号才是调用,不加括号的时候只是一个函数名。

函数本身是一个对象,函数名是变量

所以:1、函数名可以进行赋值

   2、函数名可以作为函数参数,还可以作为函数的返回值

高阶函数的条件:

  1、函数名可以作为参数输入

  2、函数名可以作为返回值

递归函数

通过递归函数可实现阶乘

def fact(n):
if n==1:
return 1
return n*fact(n-1)
print(fact(5))
递归的特性:
  1、调用自身函数
  2、有一个结束条件
  3、效率低
因为存在效率低,而且只要可以使用递归可以解决的,用循环都可以,所以一般都用循环做。

内置函数

重要的内置函数:

  filter    过滤

  str=["a","b","c","d"]

  def fun1(s):

    if s!="a":

      return s                    #filter的作用就是将字符串封装好,一个个送到fun1这个函数里面去

  ret=filter(fun1,str)                 #过滤完的就是一个迭代器了    迭代器就像哆啦A梦的口袋,用多少,拿多少,不占内存

  print(list(ret))                       #转成列表

>>>>>>["b","c","d"]

  map         在元素后面添加字符串

  str=["d","a","b"]

  def fun2(s):

    return s+"alvin"

  ret=map(fun2,str)                #map左边括号左边的是函数名

  print(ret)                               #输出的依旧是一个元组

  print(list(ret))

>>>>>>["dalvin","aalvin","balvin"]

  reduce

  from functools import reduce

  def add1(x,y):

    return x+y

  print(reduce(add1,range(1,10)))

>>>>>>45

因为reduce函数调用完成的只是一个值,所以不要迭代器,而map和filter则是一个序列,所以需要迭代器。

  lambda

  from functools import reduce

  print(reduce(lambda x,y:x*y,range(1,6)))     #实现的是阶乘,x+y也可以,所以代码比较少和方便

  >>>>>>120

装饰器(函数)

  1、作用域:L-E-G-B

  2、高阶函数

  3、闭包

  

def outer():                                      #
x=10 #
def inner(): #inner就是内部函数 #3
print(x) #外部环境的变量 #4
return inner #内部函数inner就是一个闭包 #5
#inner() #局部变量,全局无法调用
f=outer() #
f() #
#代码执行的顺序是1-->6-->2-->3-->5-->7-->4 最后输出的是10
#也许大家都会有这么一个疑问,就是在第6步执行完了之后就是到了return inner
#之后再执行第7步的时候,其实外层的函数在到return inner的时候已经执行完了
#第7步只是在执行print(x),那疑问就是为什么还能输出外层的x呢?
# (外层的代码在6235时执行完了)。这种现象就叫闭包

所以闭包的定义:如果在一个内部函数里,对外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包。

关于闭包:闭包=内部函数+引用外部环境的变量

装饰器:

  

import time
def bar():
print("bar...")
time.sleep(3)
def foo():
print("foo...")
time.sleep(2)
def showtime(f):#在括号里面加入函数名,就是变量
start=time.time()
f()
end=time.time()
print("spend:%s"%(end-start))
showtime(foo)

再看一个代码:

import time
def bar():
print("bar...")
time.sleep(3)
def foo():
print("foo...")
time.sleep(2)
def showtime(f):#在括号里面加入函数名,就是变量
def inner():
start=time.time()
f() #闭包
end=time.time()
print("spend:%s"%(end-start))
return inner
foo=showtime(foo) #showtime(foo)拿到的是inner的内存地址
foo() #执行inner函数
#其中foo=showtime(foo)等价于@showtime
#代码还可以写成:
import time
def showtime(f):#在括号里面加入函数名,就是变量
def inner():
start=time.time()
f() #闭包
end=time.time()
print("spend:%s"%(end-start))
return inner
@showtime
def bar():
print("bar...")
time.sleep(3)
@showtime
def foo():
print("foo...")
time.sleep(2) foo()

对于不定长的参数:功能函数加参数

import time
def showtime(f):#在括号里面加入函数名,就是变量
def inner(*x,**y):
start=time.time()
f(*x,**y) #闭包
end=time.time()
print("spend:%s"%(end-start))
return inner
@showtime #@showtime之后然后代码往下找,是add函数需要showtime所以add函数的形参
#也要赋给inner函数同理f函数也要调用,因为就是引用add函数的。
def add(*x,**y): #@showtime就相当于把变量定位到了inner
sum=0
for i in x:
sum+=i
print(sum)
@showtime
def foo():
print("foo...")
time.sleep(2)

图的意思:foo()函数原本执行的时候是粉色的框框,但是有@showtime是,就要执行装饰器里面的内容

就是蓝色的框框,其中粉色框的函数也包含在蓝色的框里面了,所以图中执行的顺序就是上述这个样子。

考虑在装饰器上加参数:在套一层函数引入参数flag

import time
def logger(flag):
def showtime(f):#在括号里面加入函数名,就是变量
def inner(*x,**y):
start=time.time()
f(*x,**y) #闭包
end=time.time()
print("spend:%s"%(end-start))
if flag=="true":
print("日志记录")
return inner
return showtime
@logger("true") #这行代码其实分为两部分,@是一部分,logger("true")是一部分。先执行的是logger(true)
#@是看logger(true)返回回来的值,他返回回来的是showtime,所以原来的代码就相当于
#@showtime 其实加logger()这个函数目的就是为了引用flag这个参数
def add(*x,**y):
sum=0
for i in x:
sum+=i
print(sum)
@logger("")
def foo():
print("foo...")
time.sleep(2) add(1,2,5,7)

装饰器的登录应用

login_status=False
def logger(flag):
def login(f):
def inner():
global login_status
if login_status == False:
nameuser = input("input your name:> ")
print (nameuser)
passwd = input ("input your password: > ")
print (passwd)
if flag == "jingdong":
# 打开文件
with open("jingdong","r",encoding="utf8") as file_read:
menu_dict=eval(file_read.read().strip())
for i in menu_dict: if nameuser ==i and passwd == menu_dict[i]:
print ("welcome jingdong")
login_status = True
else:
print("输入有误")
break
elif flag == "weixin":
with open("weixin", "r", encoding="utf8") as file_read:
menu_dict = eval(file_read.read().strip())
for i in menu_dict: if nameuser == i and passwd == menu_dict[i]:
print("welcome jingdong")
login_status = True f()
return inner
return login
@logger("jingdong")
def home():
print("welcome to homepage")
@logger("weixin")
def finance():
print("welcome to finance")
@logger("jingdong")
def book():
print("welcome to bookpage")
with open("home_menu","r",encoding="utf8") as page_read:
menu_dict=eval(page_read.read().strip())
menu_dict_super=[]
good_list=[]
while True:
for i,v in enumerate(menu_dict,1):
print(i,">>>",v)
user_choice = input('请输入选择:返回上一级[q]').strip()
if user_choice in menu_dict:
menu_dict_super.append(menu_dict)
if user_choice=="home":
home()
elif user_choice=="finance":
finance()
elif user_choice=="book":
book() if type(menu_dict)==list:
print("您选择的商品是:",user_choice)
else:
menu_dict=menu_dict[user_choice]
good_list.append(user_choice)
elif user_choice=="q":
if menu_dict_super:
menu_dict=menu_dict_super.pop()
else:
print("请输入正确的商品")

其中文档,比如jingdong中的就是{“mengheng”:“456”}

python语法之函数2的更多相关文章

  1. python语法之函数

    函数: 将特定功能代码编写在一个函数里 便于阅读和复用 对一组表达特定功能表达式的封装 使程序模块化 python内置函数: input(),print(),eval()... 函数定义 函数语法格式 ...

  2. python语法join函数

    Python语法中join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串. vid = )

  3. python语法基础-函数-内置函数和匿名函数-长期维护

    ##################     内置函数        #######################  """ 一共是 68个内置函数: 反射相关的内置函 ...

  4. python语法------时间函数

    1.导入函数库: import time 获取格式化的时间 你可以根据需求选取各种格式,但是最简单的获取可读的时间模式的函数是asctime(): #!/usr/bin/python # -*- co ...

  5. python语法_函数

    ---恢复内容开始--- 函数: 1 减少重复代码 2 定义一个功能,需要直接调用 3 保持代码一致性 def  funcation_name(参数s): 功能代码块0 参数可以为多个,传入时按照前后 ...

  6. python语法之函数1

    函数 计算机中的函数和数学中的函数不是一回事,而是一个subroutine .子程序.procedures.过程. 作用: 1.减少重复代码: 2.方便修改,更易扩展: 3.保持代码的一致性. 最简单 ...

  7. Python语法基础-函数,类以及调试处理

    [TOC] 1. 函数的定义 python中函数有两种: python自带的函数 用户定义函数 返回多个值 原来返回值是一个tuple!但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同 ...

  8. python语法基础-函数-装饰器-长期维护

    ######################################################### # 装饰器 # 装饰器非常重要,面试Python的公司必问, # 原则:开放封闭原则 ...

  9. python语法基础-函数-进阶-长期维护

    ###############    函数的命名空间和作用域    ############## """ # 函数进阶 命名空间和作用域 命名空间 全局命名空间——我们自 ...

  10. Python语法之函数、引用和装饰器

    所谓函数,就是把具有独立功能的代码块组织成为一个小模块,在需要的时候调用 函数是带名字的代码块,用于完成具体的工作 需要在程序中多次执行同一项任务时,你无需反复编写完成该任务的代码,而只需调用该 任务 ...

随机推荐

  1. sys.exit(main(sys.argv[1:]))

    sys.argv sys.argv[]说白了就是一个从程序外部获取参数的桥梁. 首先我们需要import sys,sys是python3的一个标准库,也就是一个官方的模块.封装了一些系统的信息和接口, ...

  2. leetcode数据库题目及答案汇总

    1. 第二高的薪水 select ifnull((select distinct Salary from Employee order by Salary desc limit 1,1),null) ...

  3. Linux命令:help

    语法 help: help [-dms] [模式 ...] 显示内建命令的相关信息. 显示内建命令的简略信息.如果指定了 PATTERN 模式,给出所有匹配 PATTERN 模式的命令的详细帮助,否则 ...

  4. UE4 Virtual Reality Input输入配置表导入

    [/Script/Engine.InputSettings] AxisConfig=(AxisKeyName="OculusTouch_Right_FaceButton2",Axi ...

  5. linux 之分区和文件系统

    分区类型 主分区:总共最多只能分4个 扩展分区:只能有一个,也算作主分区的一种,也就是说主分区加扩展分区最多4个,但是扩展分区不能存储数据和格式化,必须再划分成逻辑分区才能使用. 逻辑分区:逻辑分区是 ...

  6. 其它 搭建https服务器

    原因是这样的,做了个淘宝的数据管理系统(仅供自己使用),然后需要淘宝卖家的生意参谋里面的一些数据,比如实时访客,里面有每个用户搜索什么关键字进来的,这些信息. 自己基于CefSharp开发了一个win ...

  7. python day03笔记总结

    2019.3.29 S21 day03笔记总结 昨日回顾及补充 1.运算符补充 in not in 2.优先级 运算符与运算符之间也有优先级之分 今日内容 一.整型(int) py2 与 py3 的区 ...

  8. vue 自定义组件使用v-model(组件通信方式1)

    父组件通过v-model传递值给子组件时,会自动传递一个value的prop属性,在子组件中通过this.$emit(‘input’,val)自动修改父组件v-model绑定的值 child: < ...

  9. SpringCloud-day08-Hystrix断路器

    8.Hystrix断路器 8.1.Hystrix简介 在分布式环境中,许多服务依赖项中的一些必然会失败.Hystrix是一个库,通过添加延迟容忍和容错逻辑,帮助你控制这些分布式服务之间的交互. Hys ...

  10. 云笔记项目-Spring事务学习-传播SUPPORTS

    接下来测试事务传播属性SUPPORTS Service层 Service层将方法的事务传播属性设置为SUPPORTS LayerT层代码 package LayerT; import javax.an ...