精华内容
下载资源
问答
  • 《Oracle编程自学与面试指南》13-07:函数嵌套

    千次阅读 多人点赞 2020-03-12 16:14:10
    当一个函数的返回值又作为另一个函数的参数时,便形成了函数嵌套。单行函数可以嵌套到任意深度。嵌套函数的计算顺序是从最内层到最外层。

    课程封面-Oracle Database-AT阿宝哥

    1、定义

    当一个函数的返回值又作为另一个函数的参数时,便形成了函数嵌套。

    格式如下:

    
    functionA(  functionB(参数1 ,  参数2 ...  参数n )  )
    
    或者
    
    functionA(  functionB()  
    展开全文
  • python函数嵌套

    2016-02-27 00:56:35
    尽管c语言可以进行递归调用函数,也可以嵌套调用,但是不允许嵌套定义,即在函数定义中继续定义一个函数。而python可以,举例如下: def foo():  def bar():  print('hello world')  bar() 再举一例: spam = 99 ...

    尽管c语言可以进行递归调用函数,也可以嵌套调用,但是不允许嵌套定义,即在函数定义中继续定义一个函数。而python可以,举例如下:

    def foo():

           def bar():

                  print('hello world')

           bar()

    再举一例:

    spam = 99

    def tester():

        def nested():

            global spam

            print('current=',spam)

            spam += 1

        return nested

    #注意:打印 print 那行的代码调用是tester()()

    #而不是tester().nested()

    #为了说明这一点,我们再举一个例子

    def multiplier(factor):

           def multiplybyfactot(number):

                  return number*factor

           return multibyfactor

    观察以上两个例子,我们发现在外层函数中,外层函数的值被内层函数使用,同时内层函数或者内层函数的值被返回,最为外层函数的值。

    >>>double=multiplier(2)

    >>>double(5)

    #相当于multiplier(2)(5)

    再说递归


    def search(sequence,number,lower,upper):
    if lower==upper:
      assert number==sequence[upper]
      return upper
    else:
        middle=(lower+upper)//2
        if number>sequence[middle]:
        return search(sequence,number,middle+1,upper)
        else:
        return search(sequence,number,lower,middle)

    这个程序实现对从小到大排列的序列进行二分查找,其中assert的引入,即断言,是为了让程序在断言那里出错时报错,如果用if,是不会报错的。//表示整除

    展开全文
  • 函数 1. return 返回值 作用: ​ 自定义函数的返回值,return 可以把值返回到函数的调用处 ​ return + 六大标准数据类型 , 还有类和对象,函数 ​ 如果不定义return , 默认返回的是None ​ 在执行完return之后,...

    函数

    1. return 返回值

    作用:

    ​ 自定义函数的返回值,return 可以把值返回到函数的调用处

    ​ return + 六大标准数据类型 , 还有类和对象,函数

    ​ 如果不定义return , 默认返回的是None

    ​ 在执行完return之后,立刻终止函数,后面的代码不执行

    1. return的返回类型

      def func():
      	return 1
      	return 3.14
      	return "abc"
      	return []
      	return ()
      	return {"a":1}
      	pass
      res = func()
      # 如果不定义return,默认返回的是None
      print(res) # None
      
    2. 在执行完return之后,立刻终止函数,后面的代码不执行

      def func():
      	print(1)
      	print(2)
      	return 3
      	print(4)
      	print(5)
      res = func()
      print(res)
      
      def func():
      	for i in range(3):
      		if i == 2:
      			return 1
      		print(i)
      res = func()
      print(res)
      
    3. 模拟简单的计算器 + - * /

      def func(sign,num1,num2):
      	if sign == "+":
      		res = num1 + num2
      	elif sign == "-":
      		res = num1 - num2
      	elif sign == "*":
      		res = num1 * num2
      	elif sign == "/":
      		if num2 == 0:
      			return "除数不能为0,老弟!"
      		res = num1 / num2
      	else:
      		return "这个本计算器真算不了"
      	return res
      
      res = func("+",3,6)
      res = func("-",6,2)
      res = func("*",5,2)
      res = func("/",8,4)
      res = func("/",8,0)
      res = func("&",4,0)
      print(res)
      

    2. 全局变量和局部变量

    局部变量: 在函数内部定义的变量(局部命名空间)

    全局变量: 在函数外部定义的或者使用global在函数内部定义的变量(全局命名空间)

    作用域: 作用的范围

    局部变量的作用域: 在函数的内部

    全局变量的作用域: 横跨整个文件

    生命周期:

    ​ 内置变量 > 全局变量 > 局部变量

    1. 局部变量

      def func():
      	# 定义局部变量
          a = 5
          # 获取局部变量
          print(a)
          # 修改局部变量
          a = 10
          print(a)
      func()
      # print(a) error 不能在全局调用局部变量
      
    2. 全局变量

      # 定义全局变量
      b = 10
      # 获取全局变量
      print(b)
      # 修改全局变量
      b = 20
      
      def func():
          # 可以在函数内部获取全局变量
          print(b)
      func()    
      
    3. 使用global在函数内部创建全局变量

      def func():
          global c
          c = 100
      func()
      print(c)
      
    4. 使用global在函数内部修改全局变量

      d = 200
      def func():
          global d
          d = 300
      func()
      print(d)
      
    5. 总结

      ​ 可以使用 global 关键字 在函数内部定义一个全局变量

      ​ 也可以使用 global 关键字 在函数内部修改一个全局变量

    3. 函数名的使用

    1. 函数名是个特殊的变量,可以当做变量赋值

      def func():
          print("我是func函数")
          return 1111
      a = "你好"
      print(a)
      a = func
      a()
      
      # 函数可以像变量一样销毁
      del a
      a()
      
    2. 函数名可以作为容器类型数据的元素

      def func1():
          print("我是func1函数")
      
      def func2():
          print("我是func3函数")
      
      def func3():
          print("我是func3函数")    
          
      lst = [func1,func2,func3]
      for i in lst:
          print(i)
          i() # func1() func2() func3()
      
    3. 函数名可以作为函数的参数

      def func():
          print("我是func函数")
      
      def func4(f):
          f()
      func4(func)    
      
    4. 函数名可以作为函数的返回值

      def func1():
          print("我是func1函数")
      
      def func(f):
          return f
      res = func(func1) # f <=> func1 => res = func1()
      res()
      
    5. doc 或者 help 查看文档

      def eat_bigchang(something):
          """
          功能: 大肠刺身
          参数: 肠子名字
          返回值: 吃的状态
          """
      	print("先把{}洗一洗".format(something))
      	print("找出肠子头放嘴里")
      	print("嘬!!")
      	return "吃完了,满意的放下肠子,擦擦嘴"
      
      res = eat_bigchang("猪肠子")
      print(res)
      help(eat_bigchang)
      res = eat_bigchang.__doc__
      print(res)
      

    4. 函数的嵌套

    函数之间可以互相嵌套

    ​ 外层的叫做外函数

    ​ 内层的叫做内涵数

    def outer():
        
        def inner():
            print("我是inner函数")
        inner()
        
    outer()    
    

    inner()

    1. 内部函数不可以直接在函数外部调用
    2. 调用外部函数后,内部函数也不可以在函数外部调用
    3. 内部函数可以在函数内部调用
    4. 内部函数在函数内部调用时,有先后顺序,必须先定义再调用
    

    外层是outer , 内层是inner , 最里层是smaller , 调用smaller里面的所有代码

    def outer():
        def inner():
            def smaller():
                print("我是smaller函数",id)
            smaller()
        inner()
    outer()    
    

    LEGB 原则 (就近找变量原则)

    ​ 找寻变量的调用顺序采用LEGB原则(即就近原则)

    ​ B —— Builtin(Python);Python内置模块的命名空间 (内建作用域)

    ​ G —— Global(module); 函数外部所在的命名空间 (全局作用域)

    ​ E —— Enclosing function locals;外部嵌套函数的作用域 (嵌套作用域)

    ​ L —— Local(function);当前函数内的作用域 (局部作用域)

    ​ 依据就近原则,从下往上 从里向外 依次寻找

    5. nonlocal 修改局部变量

    nonlocal 遵循LEGB就近找变量原则

    1. 找当前空间上一层的局部变量进行修改

      1. 如果找不到,会继续向上寻找

      2. 最后什么也没有,直接报错

      """找当前空间上一层的局部变量进行修改"""
      def outer():
          a = 100
          def inner():
              nonlocal a
              a = 200
              print(a)
      	inner()
          print(a)
      outer()  
      
      """如果找不到会继续向上寻找"""
      def outer():
      	a = 100
      	def inner():
      		def smaller():
      			nonlocal a
      			a = 400
      			print(a)
      		smaller()
      		print(a)
      	inner()
      	print(a)
      outer()    
       
      """注意点: nonlocal只能修改局部变量 (最后什么也没有,直接报错) """    
      a = 100
      def outer():
      	def inner():
      		def smaller():
      			nonlocal a
      			a = 400
      			print(a)
      		smaller()
               print(a)   
      	inner()
      	print(a)
      outer()    
      
      """不使用 nonlocal 修改局部变量"""
      def func():
      	lst = [1,2,3,4]
      	def inner():
      		lst[-1] = 10
      	inner()
      	print(lst)
      func()    
      

    6. locals 和 globals

    1. locals 获取当前作用域中所有的变量

      locals 如果在全局中,调用locals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域

      locals 如果在局部中,调用locals之后,获取的是调用之前的所有变量,返回字典,局部空间作用域

      # 例子一
      def func():
      	ff = 123
      a = 1
      b = 2
      res = locals()
      c = 3
      print(res)
      d = 4
      
      # 例子二
      a1 = 10
      def func():
      	a = 1
      	b = 2
      	res = locals()
      	c = 3
      	print(res)
      	d = 4
      a2 = 20
      func()
      a3 = 30
      
    2. globals 只获取全局空间中所有的变量

      globals 如果在全局,调用globals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域

      globals 如果在局部,调用globals之后,获取的是调用之前的所有变量,返回字典,全局空间作用域

      # 例子一
      def func():
      	ff = 123
      a = 1
      b = 2
      res = globals()
      c = 3
      print(res)
      d = 4
      
      # 例子二
      a1 = 10
      def func():
      	a = 1 
      	b = 2
      	res = globals()
      	c = 3
      	print(res)
      	d = 4
      a2 = 20
      func()  # globals
      a3 = 30
      
    3. globals 动态批量创建全局变量

      1. 用字符串定义全局变量

        dic = globals()
        print(dic) # 返回的是系统的字典
        """
        在全局的字典当中,通过添加键值对,自动创建全局变量
        对应的键是变量名,对应的值是变量指向的值
        """
        dic["name"] = "小明"
        print(name)
        
      2. 批量定义全局变量

        def func():
        	dic = globals()
        	# 通过在全局系统字典当中,添加键值对,批量创建变量
        	for i in range(1,6):
        		# "a%d" % (1) => "a1" "a%d" % (2) => "a2"
        		dic["a%d" % (i)] = i # 1~5
        func()
        """
        "a%d" % (1) => a1
        "a%d" % (2) => a2
        "a%d" % (3) => a3
        "a%d" % (4) => a4
        "a%d" % (5) => a5
        """
        

    练习

    练习1

    注册:

    1. 检测两次密码如果相同,确认注册成功
    2. 检测两次密码如果不同,提示两次密码不一致
    3. 用户名不能重复
    # accountlst 存放所有账号
    accountlst = []
    sign = True
    with open("user.txt",mode="a+",encoding="utf-8") as fp:
    	while sign:
    		# 输入用户名
    		username = input("请输入要注册的用户名:")
    		if username == "" or " " in username:
    			print("对不起,该名字含有非法字符")
    		else:
    			#  把数据从文件当中获取
    			fp.seek(0)
    			lst = fp.readlines()
    			for i in lst:
    				account = i.strip().split(":")[0]
    				accountlst.append(account)
    			print(accountlst)
    			# 判断改名字是否已经存在
    			if username in accountlst:
    				print("抱歉,该名字已经被注册")
    			else:
    				# 检测密码
    				pwd = input("请输入您的密码:")
    				while True:
    					pwd2 = input("请确认您的密码,按q退出~")
    					# 如果密码相同
    					if pwd == pwd2:
    						# 拼接字符串
    						strvar = username + ":" + pwd + "\n"
    						# 把注册的用户名和密码写入文件
    						fp.write(strvar)
    						# 终止循环
    						sign = False
    						# 打印信息
    						print("注册成功~")
    						break
    					elif pwd2.upper() == "Q":
    						break
    					else:
    						print("对不起.两次输入的密码不一致~")
    

    练习2

    登录:

    1. 账户密码会预先记录在文件中
    2. 输入账号密码:如果都正确,登录成功
    3. 如果用户登录时进行三次校验,都不对,记录黑名单文件中
    4. 如果是黑名单的用户,禁止下次再次登录
    # 存账户
    accountlst = []
    # 存密码
    pwdlst = []
    # 存黑名单
    blacklst = []
    
    sign = True
    while sign:
    	username = input("请输入您的用户名:")
    	# 获取文件当中的账号和密码
    	with open("user.txt",mode="a+",encoding="utf-8") as fp:
    		fp.seek(0)
    		lst = fp.readlines()
    		for i in lst:
    			user,pwd = i.strip().split(":")
    			# print(user,pwd)
    			accountlst.append(user)
    			pwdlst.append(pwd)
    		# print(accountlst)
    		# print(pwdlst)
    		# 判断该用户是否存在
    		if username in accountlst:
    			# 判断当前用户是否是黑名单中的用户
    			with open("black.txt",mode="a+",encoding="utf-8") as fp:
    				fp.seek(0)
    				lst = fp.readlines()
    				for i in lst:
    					blacklst.append(i.strip())
    				# print(blacklst)
    				if username in blacklst:
    					print("抱歉,该用户已经被冻结了")
    				else:
    					# 找到该用户对应的密码
    					num = accountlst.index(username)
    					pwd = pwdlst[num]
    					# print(num,pwd)
    					# 判断用户输入的密码是否正确
    					times = 1
    					while times <= 3:
    						pwd2 = input("请输入您的密码:")
    						# 输入成功的情况下,终止循环,程序结束
    						if pwd == pwd2:
    							print("登陆成功~")
    							sign = False
    							break
    						else:
    							# 剩余次数 = 总次数 - 已用次数
    							print("您还剩余%s次机会" % (3-times))
    							# 如果用掉了所有的次数,直接加入黑名单,防止下次登录  
    							if times == 3:
    								with open("black.txt",mode="a+",encoding="utf-8") as fp:
    									strvar = username + "\n"
    									fp.write(strvar)
    								print("抱歉,您的账户已经被冻结~")
    						times+=1  
    		else:
    			print("该用户不存在~")
    
    展开全文
  • python函数嵌套调用_登录验证码校验 import random def generate_checkcode(n): code = '' str = 'abcdefghijklnmopqrstuvwxyzABCDEFGHIJKLNMOPQRSTUVWXYZ0123456789' for i in range(n): ran = random.randint...

    python函数嵌套调用_登录验证码校验

    import random
    def generate_checkcode(n):
        code = ''
        str = 'abcdefghijklnmopqrstuvwxyzABCDEFGHIJKLNMOPQRSTUVWXYZ0123456789'
        for i in range(n):
            ran = random.randint(0, len(str) - 1)
            code += str[ran]
        return code
    
    
    def login():
        while True:
            username = input('请输入用户名:')
            password = input('请输入密码:')
            code = generate_checkcode(4)
            print(f'验证码是:{code}')
            code1 = input('请输入接收到的验证码:')
            if code.upper() == code1.upper():
                if username == 'admin' and password == '123456':
                    print('登录成功')
                    break
                elif username != 'admin':
                    print('用户名不存在!')
                else:
                    print('密码错误')
            else:
                print('验证码错误')
    login()
    
    展开全文
  • 1、函数嵌套 Python中以函数为作用域,在作用域中定义的相关数据只能被当前作用域或子作用域使用。 NAME = "华青水上" print(NAME) def func(): print(NAME) func() 1.1函数在作用域中 其实,函数也是定义在...
  • ruby 嵌套函数 嵌套循环 (Nested for loop) Nesting of for loop means one for loop is available inside another for loop. It means that there are two loops, then the first one is an outer loop and the ...
  • void main() //主函数名,void 表示函数没有返回值 { //函数体标志 cout!\n"; //输出字符串Hello!到标准输出设备(显示器)上。 cout!\n"; //输出字符串Welcome to c++! } 在屏幕输出如下: Hello! Welcome to c++...
  • 函数嵌套函数中声明函数 在内部函数中使用变量的时候, 查找顺序: 先找自己 -> 上一层 -> 上一层..全局 -> 内置 4. nonlocal和global关键字(重点) global: 在局部引入全局变量 (局部对该变量进行赋值,...
  • update uadpt_tac_act_data set TERMINAL=UPPER(TERMINAL) update uadpt_tac_act_data set brand=substr(brand,1,50) where length(brand) > 50 update uadpt_tac_act_data set soft_lock=decode(soft_lock
  • hive的内嵌函数

    2019-05-08 10:49:43
    注:以下是本人个人总结的,常用的一些hive的内嵌函数,可能有不足的,欢迎补充。 1.聚集函数 sum() --取字段数值的汇总 max() --取字段的最大值 min() --取字段的最小值 avg() --取字段数值的所有平均值 ...
  • 单行函数嵌套函数及条件表达式 单行函数 单行函数: ...大小写控制函数(用到的关键字,lower,upper,initcap) --将字符串转换为小写 select LOWER('ORACLE SQL') from dual; --将字符串转换为大写 ...
  • 用turtle实现用正方形画圆

    千次阅读 多人点赞 2018-11-19 13:34:54
    add – True or False – if True, a new binding will be added, otherwise it will replace a former binding 添加新的绑定函数,否则替代之前函数 例子:def turn(x, y): 。。。 left(180) onclick(turn) on...
  • Django框架基础教程(一):简单介绍Python Django框架

    万次阅读 多人点赞 2019-05-22 17:11:28
    {{ name|first|upper }}将第一个元素转化为大写。 有些过滤器有参数,过滤器的参数跟随冒号之后并总是以双引号包含: {{ name|truncatewords:"3" }}显示变量的前3个词。 addslashes:添加反斜杠到任何反...
  • Oracle DB 嵌套函数

    千次阅读 2013-10-18 23:57:31
    嵌套函数 • 单行函数可以嵌套到任意层。 • 嵌套函数的计算顺序是从最内层到最外层。 单行函数可以嵌套到任意深度。嵌套函数的计算顺序是从最内层到最外层。下面的一些示例显示这类函数的灵活性。 嵌套...
  • ruby 嵌套函数 嵌套while循环 (Nested while loop) When one while loop is living inside another while loop, it is known as nesting of while loop. It means that there are two while loops, the first one is...
  • Python实验实例

    万次阅读 多人点赞 2019-06-27 19:28:05
    Python 运算符、内置函数 实验目的:  1、熟练运用 Python 运算符。  2、熟练运用 Python 内置函数。实验内容:  1、编写程序,输入任意大的自然数,输出各位数字之和。  2、编写程序,输入两个集合 setA 和 ...
  • for循环和可迭代对象遍历 for循环语法格式: for 变量 in 可迭代对象(序列,元组,列表…) 循环体语句 range对象 range(start,end,[step]) 注:从start到end,不包括end ...嵌套循环 for x in range(5):...
  • ruby 嵌套函数 嵌套do ... while循环 (Nested do...while loop) When two post-test loops i.e. do..while loops are working together for the fulfillment of a task, it is known as the nesting of the do......
  • ruby 嵌套函数 嵌套直到循环 (Nested until loop) Alike for, while, and do...while, until loop can also be nested for meeting the specific purpose. In this type of nesting, two until loops work in the ...
  • 《数据库系统概论》复习

    千次阅读 多人点赞 2019-05-27 12:13:27
    《数据库系统概论》复习 第一章 绪论 1.1 数据库系统概述 1、数据库系统的四个基本概念 数据(Data):描述事物的符号记录称为数据,数据是数据库存储的基本对象。 ...数据库(DB):长期存储在计算机内、有组织的...
  • Perl语言入门 (08 自定义函数)

    千次阅读 2016-09-08 11:23:57
    由于公司需要,本人最近在学习Perl这种脚本语言,本文是我在学习Perl的过程中总结出来的一些心得和...Pe r l中,用户定义的函数称为子例程.子例程可以在任何位置被调用,包括在其他子例程中调用. 创建函数: sub 函数
  • 第三章 Sql查询与函数 一、 SQL概述 SQL(Structured Query Language)结构化查询语言,是一种数据库查询和程序设计语言,用于存取数据以及查询、更新和管理关系数据库系统。同时也是数据库脚本文件的扩展名。  SQL...
  • --1.返回字符串,并将所有的字符小写  [sql] view plain copy select lower('AaBbCcDd')AaBbCcDd from dual;...--2....select upper('AaBbCcDd') upper from dual;    --3.返
  • Excel函数教程

    千次阅读 2018-10-10 18:57:27
    一、Excel函数应用之函数简介 Excel的数据处理功能在现有的文字处理软件中可以说是独占鳌头,几乎没有什么软件能够与它匹敌。在您学会了Excel的基本操作后,是不是觉得自己一直局限在Excel的操作界面中,而对于Excel...
  • =mx,一开始我想现将序列从小到大排序,然后用n*n的嵌套循环来做,思路没错,就是时间超限了,后来参考了网上的做法,发现可以直接在序列中找大于mi*p的值,用二分法就行了,(看来要序列超时就想想二分)。...
  • Hive内置函数

    千次阅读 2019-06-25 18:02:17
    数学函数 下面表格中的函数为Hive的内置数学函数,大部分当参数为NULL时返回NULL。 返回类型 函数名 描述 bigint round(double a) 返回a经过四舍五入...
  • list: 列表的嵌套 # li = ['taibai','你好啊','hehe',['test','age',11],11,'12'] #列表的嵌套 # li[0] = li[0].capitalize() # print(li) # li1 = li.index('hehe') # li[li1] = '昊日天' # print(li) # li[3][0]...
  • 以下介绍Python中一些常用的已经嵌套的字符串函数,利用这些函数可以使我们在打代码的时候不用自己苦逼地自己写相应的函数,可以让我们事半功倍,用起来很方便,不过在用之前一定可以要清楚函数相应的参数的意义,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,072
精华内容 7,628
关键字:

upper函数嵌套