精华内容
下载资源
问答
  • /**************** 以下所有子函数的声明 *********************/ void clockplus(void); /* 时间加 1S 的子程序 */ void update_clockstr(void); /* 更新时间显示编码 */ void update_alartstr...
  • 闭包函数

    2019-07-12 23:04:00
    函数我们知道是什么了,那么什么是闭包函数呢? 我们从字面的意思就是包起来的函数,那么实际上的呢? :定义再函数内部的函数 包:就是内部函数引用了外部函数作用域的的名字 总体就是函数内部的函数引用了外部函数...

    闭包函数

    函数我们知道是什么了,那么什么是闭包函数呢?

     我们从字面的意思就是包起来的函数,那么实际上的呢?

    闭:定义再函数内部的函数

    包:就是内部函数引用了外部函数作用域的的名字

    总体就是函数内部的函数引用了外部函数作用域的名字,只要满足这两点就是闭包函数

    示例:

    sh = 123
    def outer():
        y = 234
        def inner():   #函数inner是在函数outer里面的函数,已经满足函数内部的函数这一项
            print(sh,y) # 内部函数引用外部函数 y的作用域名字也满足了一项,sh是全局空间空的但是 y 已经满足了
        return inner 
    res = outer()
    print(res())
    该示例重点强调只要满足两点就是闭包函数

    需要注意的是名字查找顺序:函数定义阶段名字的查找顺序就已经固定死了,是不会因为函数调用位置的变化而从而变化的.

    就好比汽车在出厂后已经把上车到启动的顺序已经设定好了,不会因为开车的人不同而改变上车的顺序,你总不能没有上车就让车自己去目的地把(目前的可以科技应该还不能够吧)

    给函数传参的两种方式:

    1.就是直接传参(默认值参数,位置参数,和可变长参数)

    def uname(name):
        print('uname)
    uname('钢铁侠')
    

     2.就是闭包传参

    def outter(name):
        def index():
            print('name)
        return index
    outter('黑寡妇')

    小爬虫

    爬虫的本质就是抓取网页的html代码

    从代码里面获取想要得到信息的链接(url链接地址)

    然后在顺着这个链接将所有的页面资源全部爬取下来

    装饰器

    装饰器就是闭包函数的一个应用的分支或者说升级或者一种方法

    那么装饰器就是一个特定功能的工具,可以给需要装饰的对象添加新的功能

    装饰器的原则:

      开放封闭原则:

        开放:开放就是对扩展的开放

        封闭:就是对修改的封闭

      装饰器对可调用的对象必须遵循两个原则:

        1.不可改变被装饰对象的源代码

        2.不可改变调用对象的调用方法,

      注:意思就是,他是大爷,他既然想舒服,但是他又不可以动

    用法示例:

    """
    统计函数lala的运行时间
    
    
    """
    import time

    def outter(fnuc): #func = 最原始的lala函数内存地址
    def get_time(*args,**kwargs):  
    start = time.time()
    res = fnuc(*args,**kwargs) # func()就可以直接调用lala函数
    end = time.time()
    print('lala 运行时间:%s'%(start-end))
    return res # func()的返回值
    return get_time
    #lala = outter(lala) #outter的最原始的lala函数的内存地址 lala就是outter的返回值get_time
    #lala()

    @outter # 等于 lala = outter(lala) lala('jason') 调用方式没有改变
    def lala(name):
    print('您点的28号技师,已接到通知五秒后到达您的房间')
    time.sleep(5)
    print('%s先生您好,我是28号技师的姐姐,保证服务到位'%(name))
    lala('jason')
    #也没有改变原来的代码,功能也扩展了计算lala函数的执行时间

     装饰器的语法糖:会将紧挨着他的可调用对象的名字当做参数自动传入调用otture

    示例:

    @outter # 等于 lala = outter(lala)  lala('jason') 调用方式没有改变  
    def lala(name):
        print('您点的28号技师,已接到通知五秒后到达您的房间')
        time.sleep(5)
        print('%s先生您好,我是28号技师的姐姐,保证服务到位'%(name))
    lala('jason')
    #也没有改变原来的代码,功能也扩展了计算lala函数的执行时间

    装饰器模板:

    无参装饰器

    def outter(func):
        def inner(*args,**kwargs):
            print('执行被装饰函数之前可以进行的操作')
            res = func(*args,**kwargs)
            print('执行完毕被装饰函数后的操作')
            return res
        return outter
    

     有参装饰器

    def lalalala(data):
        def outter(func):
            def inner(*args,**kwargs):
                if data =='file':
                    print('执行被装饰函数之前可以进行的操作')
                    res = func(*args,**kwargs)
                    print('执行被修饰代码之后可以进行操作的')
                  return res # func()的函数返回值
              return inner #outter()的函数返回值
          return outter  #lalalala()的函数返回值

     函数的递归

    函数在调用阶段直接或者间接的调用自身函数

    递归分两个阶段:

      1.回溯:就是一次次重复的过程,这个重复的过程必须建立在每一次重复问题的复杂度都应该下降,也就是一层层的扒开

      2,递推:一次次往回推导的过程,也就是追溯.从结果一步步推到回去.

      递归函数不要考虑循环的次数 只需要把握结束的条件即可

    """
    age(5) = age(4) + 2
    age(4) = age(3) + 2
    age(3) = age(2) + 2
    age(2) = age(1) + 2
    age(1) = 18
    
    import sys
    print(sys.getrecursionlimit()) # 查看python中的递归深度
    
    
    age(n) = age(n-1) + 2  # n > 1
    age(1) = 18  # n = 1
    """
    def age(n):         # 创建一个函数
        if n == 1:         #判断是否等于1,显然n != 1 但是n 等于1的返回值是18
            return 18       # n 等于1 是返回值等于18
        return age(n-1) + 2 #   n= 2 时 18+2 返回值是20 当n=3 返回值22 当n=4 返回值22+2 当输入n= 5时 返回值 24+2  依次类推
    res = age(3)    # 遇见age() 首先执行age函数 age函数等于6
    # 当等于指定的实参运行结束然后把返回结果给了res 那么输出res就得到了age(n)结果
    

      示例二:

    """
    l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,]]]]]]]]]]]]]
    将列表中的数字依次打印出来
    
    """
    
    
    def lolo(l):
        for i in l:
            if type(i) is int:   # 如果i是整数就打印出来
                print(i)
            else:
                lolo(i)  # 如果不是整数,就是列表那么就把列表再for循环 吧里面的整数拿出来直到没有数据可以进行循环
    lolo(l)
     

    初识算法

     算法是什么:算法就是解决问题的高效率的方法

    二分法:

    在之前如需要在一纯数字的列表里面需要找到列表中的一个数字,那么我们只能一个一个的循环查找,这样的效率太慢了,如果是五六个还好,如果是成千上万条呢,那不是要找到猴年马月了,所以有人就写出了更快查找的方法就是二分法,二分法是拿需要查找的这个数字对列表中间的一个数字作比较,这样就行分段查找,提高了查找的速度.

    运行条件:容器类型里面的数字必须是有大小顺序,因为需要作比较.

    演示示例:
    
    l = [1,3,4,5,7,9,64,,78,89,90,92,94,98,11,444,5555]
    
    target_na = 92
    def get_num(l,target_na):
        if not l:
            print('怕是找不到了')
            return
        print(l)
        midle_index = len(l) // 2 # 把中间那个参数索引取出来
        if target_na > l[midle_index]: # 判断要比对的数字是否小于中间的那个数字
            num_right = l[midle_indxe + 1:] #加1是因为顾头不顾尾
            get_num(num_right,target_na)
        elif target_na < l[midle_indxe]:
            num_left = l[0:midle_indxe]
            get_num(num_left, targer_num)
        else:
            print('find it ',target_na)
    get_num(1,target_na)
    

     三元表达式:

      三元表达式就是if 的一个用法,它的使用场景推荐使用使用的只有两种,那就是对了怎么操作错了怎么操作

    三元表达式固定表达式方法:

      

    值 a if 条件  else 值b
           条件表达式成立则 值a
            表达式不成立则   值b
    

     

    演示:
    
    lald = input('请放假回家不(y/n)>>>:').strip()
    lald = '回家' if lald == 'y' else '不回家'
    print(lald)
      

     列表生成式:
    平常我们要生成个列表需要循环,太麻烦了,而且效率低代码多,使用列表生成式只有一行代码

    l = ['白龙马', '悟空', '沙悟净', '八戒', '三藏', '白骨精'] new_l = [] for name in l: new_l.append('%s都不是人'%name) print(new_l) 这两个例子的功能是相同的 l2 = ['白龙马', '悟空都', '沙悟净', '八戒', '牛魔王', '白骨'] res = ['%s都是妖怪'%name for name in l2] print(res)

      

    字典生成器

    for循环和使用枚举的方式快速的生产字典

    l1 = ['jason','123','read']
    d = {i:j for i,j in enumerate(l1) if j != '123'}
    print(d)
    

     匿名函数

    见名知意就是没有名字的函数,匿名函数的特点就是临时存在用完就没了,就是吃干抹净不认人了

    func = lambda x,y:x+y
    print(func(1,2))

    :左边的相当于函数的形参
    :右边的相当于函数的返回值
    匿名函数通常不会单独使用,是配合内置函数一起使用

     

     

    转载于:https://www.cnblogs.com/ioipchina/p/11177973.html

    展开全文
  • 什么是闭包

    2021-04-01 16:13:57
    闭包不是私有,意思不是封闭内部状态,二十封闭外部状态,当外部状态的作用域失效的时候,还有一份留在函数内部状态里 function a(x, y){ console.log(x, y) //在这里,x和y都不是自由变量 function b(){ ...

    一句话解释就是:存在自由变量的函数就是闭包。闭包不是私有,闭的意思不是封闭内部状态,二十封闭外部状态,当外部状态的作用域失效的时候,还有一份留在函数内部状态里

    function a(x, y){
        console.log(x, y) //在这里,x和y都不是自由变量
        function b(){
            console.log(x, y) //但在这个内部函数b中,x和y相对于b都是自由变量,而函数a的作用域则是环境。
        }
        //无论b最终是否会作为返回值被函数a返回,b本身都已经形成了闭包。
    }

    JavaScript 闭包的本质源自两点,词法作用域和函数当作值传递。

    词法作用域,就是,按照代码书写时的样子,内部函数可以访问函数外面的变量。引擎通过数据结构和算法表示一个函数,使得在代码解释执行时按照词法作用域的规则,可以访问外围的变量,这些变量就登记在相应的数据结构中。

    函数当作值传递,即所谓的first class对象。就是可以把函数当作一个值来赋值,当作参数传给别的函数,也可以把函数当作一个值 return。一个函数被当作值返回时,也就相当于返回了一个通道,这个通道可以访问这个函数词法作用域中的变量,即函数所需要的数据结构保存了下来,数据结构中的值在外层函数执行时创建,外层函数执行完毕时理因销毁,但由于内部函数作为值返回出去,这些值得以保存下来。而且无法直接访问,必须通过返回的函数。这也就是私有性。

    展开全文
  • 什么意思呢? 下面看一个具体的案例 有一个计算器类,其目前的功能有加、减、乘、除。 //计算器类 class Calculator { public: //构造函数 Calculator(int a, int b, string m_operator) :m_A(a), m_B(b), m_...

    开闭原则是对扩展开放,对修改关闭。增加功能是通过增加代码来实现的,而不是去修改源代码。

    什么意思呢?

    下面看一个具体的案例

    有一个计算器类,其目前的功能有加、减、乘、除。

    //计算器类
    class Calculator
    {
    public:
    	//构造函数
    	Calculator(int a, int b, string m_operator) :m_A(a), m_B(b), m_Operator(m_operator)
    	{
    
    	}
    
    	int getResult()
    	{
    		if (m_Operator.compare("+") == 0)
    		{
    			return m_A + m_B;
    		}
    		else if (m_Operator.compare("-") == 0)
    		{
    			return m_A - m_B;
    		}
    		else if (m_Operator.compare("*") == 0)
    		{
    			return m_A * m_B;
    		}
    		else if (m_Operator.compare("/") == 0)
    		{
    			return m_A / m_B;
    		}
    	}
    
    	//数据
    private:
    	int m_A;
    	int m_B;
    	string m_Operator;
    	int m_Ret;
    };
    
    void test01()
    {
    	Calculator* cal = new Calculator(10, 20, "*");
    	cout<< cal->getResult()<<endl;
    }

    假如我们此时又要增加新的功能,比如说增加取余操作。

    那么对于这样的类,我们需要在getResult中,再增加一个else if来判断取余,这就修改了代码,就有可能导致整体出错,

    我们应该在增加新功能的时候,不影响其它已经完成的功能。这就是开闭原则。

     

    下面使用开闭原则来完成功能的增加

    //写一个抽象类
    class AbstractCalculator
    {
    public:
    	//纯虚函数
    	virtual int getResult() = 0;
    	virtual void setOperatorNum(int a, int b) = 0;
    };
    
    //加法计算器  继承 抽象类   重写抽象类的纯虚函数
    class PlusCalculator :public AbstractCalculator
    {
    public:
    	//set方法
    	virtual void setOperatorNum(int a,int b)
    	{
    		this->mA = a;
    		this->mB = b;
    	}
    
    	virtual int getResult()
    	{
    		return mA + mB;
    	}
    private:
    	int mA;
    	int mB;
    };
    
    
    //减法计算器
    class SubCalculator :public AbstractCalculator
    {
    public:
    	//set方法
    	virtual void setOperatorNum(int a, int b)
    	{
    		this->mA = a;
    		this->mB = b;
    	}
    
    	virtual int getResult()
    	{
    		return mA - mB;
    	}
    private:
    	int mA;
    	int mB;
    };
    
    
    //乘法计算器
    class MultibCalculator :public AbstractCalculator
    {
    public:
    	//set方法
    	virtual void setOperatorNum(int a, int b)
    	{
    		this->mA = a;
    		this->mB = b;
    	}
    
    	virtual int getResult()
    	{
    		return mA * mB;
    	}
    private:
    	int mA;
    	int mB;
    };
    
    
    //如果增加取莫运算  通过增加代码来实现的,不需要修改前面的代码
    class ModeCalculator :public AbstractCalculator
    {
    public:
    	//set方法
    	virtual void setOperatorNum(int a, int b)
    	{
    		this->mA = a;
    		this->mB = b;
    	}
    
    	virtual int getResult()
    	{
    		return mA % mB;
    	}
    private:
    	int mA;
    	int mB;
    };
    
    void test02()
    {
    	AbstractCalculator* cal = new PlusCalculator;
    	cal->setOperatorNum(10, 20);
    	cout << cal->getResult() << endl;
    	delete cal;                                    //释放指针
    
    	cal = new SubCalculator;
    	cal->setOperatorNum(10, 20);
    	cout << cal->getResult() << endl;
    	delete cal;                                    //释放指针
    
    }

    写一个抽象的计算器类,即接口,定义相应的方法,将方法定义成纯虚函数,以便子类继承时实现。

    当我们需要加法时,定义加法类继承抽象的计算器类,再实现接口里面的方法。当加入其他功能时,再写个类继承抽象类即可,以此类推。

    这就满足了 增加功能是增加代码实现的,而不是修改代码。

    当然,在这个案例中,使用开闭原则让代码更加复杂了,在比较大的项目中,开闭原则的优势就凸显出来了。当某个功能无法实现时,只需找对应的类即可。

    展开全文
  • 首先得设置gluPerspective,来看看它的参数都表示什么意思 fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果设置为0,相当你上眼睛了,所以什么也看不到,如果为180,那么可以认为你的视界很广阔, as
    gluPerspective(GLdouble
     fovy,GLdouble aspect,GLdouble zNear,GLdouble zFar)

    首先得设置gluPerspective,来看看它的参数都表示什么意思
    fovy,这个最难理解,我的理解是,眼睛睁开的角度,即,视角的大小,如果设置为0,相当你闭上眼睛了,所以什么也看不到,如果为180,那么可以认为你的视界很广阔,
    aspect,这个好理解,就是实际窗口的纵横比,即x/y
    zNear,这个呢,表示你近处,的裁面,
    zFar表示远处的裁面,

    如果还没有理解就继续看,
    我们知道,远处的东西看起来要小一些,近处的东西看起来会大一些,这就是透视原理
    如下图所示






    假设那两条线表示公路,理论上讲,它们的两条边是平行的,
    但现实情况中,它们在远方(可以无限远)总要相交于一点,
    实际线段AB的长度=CD的长度,只是在此例中使用了透视角,故会有如上的效果,是不是很接近现实的情况?

    结合我们刚才这两个函数
    zNear,眼睛距离近处的距离,假设为10米远,请不要设置为负值,OpenGl就傻了,不知道怎么算了,
    zFar表示远处的裁面,假设为1000米远,
    就是这两个参数的意义了,

    再解释下那个"眼睛睁开的角度"是什么意思,
    首先假设我们现在距离物体有50个单位距离远的位置,
    在眼睛睁开角度设置为45时,请看大屏幕:




    我们可以看到,在远处一个球,,很好玩哈,
    现在我们将眼睛再张开点看,将"眼睛睁开的角度"设置为178
    (180度表示平角,那时候我们将什么也看不到,眼睛睁太大了,眼大无神)



    我们只看到一个点,,,,,,,,,,,,,,,,,,,,,,,,,,,
    因为我们看的范围太大了,这个球本身大小没有改变,但是它在我们的"视界"内太小了,


    反之,我们将眼睛闭小些,改为1度看看会出现什么情况呢?



    在我们距离该物体3000距离远,"眼睛睁开的角度"为1时,我们似乎走进了这个球内,这个是不是类似于相机的焦距?

    当我们将"透视角"设置为0时,我们相当于闭上双眼,这个世界清静了,

    我们什么也看不到,,,,,,,,,

    原文地址:http://www.cppblog.com/COOOOOOOOL/archive/2009/12/28/104255.html

    展开全文
  • 函数原型void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)首先得设置gluPerspective,来看看它的参数都表示什么意思fovy, 这个最难理解,我的理解,眼睛睁开的角度,即,视角的...
  • 原则属于六大设计原则之一,百度百科上面介绍开原则:开原则规定“软件中的对象(类,模块,函数等等)应该对于扩展开放的,但是对于修改封闭的”,这意味着一个实体允许在不改变它的源代码的前提下...
  • OpenGL中的函数gluPerspective简单理解

    千次阅读 2013-06-29 18:37:44
    首先得设置gluPerspective,来看看它的参数都表示什么意思 fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果设置为0,相当你上眼睛了,所以什么也看不到,如果为180,那么可以认为你的视界很广阔, as
  • 什么意思呢? 就是你写的这个类,或者接口、函数,当因需求发生变化而要进行修改的时候,不应该去修改原代码,而是对原代码进行扩展。   举个书店售书的栗子:     interface IBook { // 获得书名
  • 函数原型gluPerspective(GLdouble fovy,GLdouble aspect,GLdouble zNear,GLdouble zFar)首先得设置gluPerspective,来看看它的参数都表示什么意思fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果...
  • 闭包不是私有啊,意思不是“封闭内部状态”,而是“封闭外部状态”啊。一个函数如何能封闭外部状态呢,当外部状态的scope失效的时候,还有一份留在内部状态里面…… 闭包例子:function foo() {  let a = '...
  • 设计模式中有一条叫做开原则,意思是:程序应该,对扩展开放,而对修改关闭。 而对拓展完全开放原则却不一样,对拓展完全开放原则坚持,一切都可以被修改,包括原有的函数实现,原有的变量。 这与设计模式中的开...
  • C++ lambda表达式入门

    万次阅读 多人点赞 2018-11-04 12:17:01
    lambda表达式 一个函数,一个匿名函数,也就是没有函数名的函数,为什么不需要函数名呢,因为我们直接(一次性的)用它,嵌入式用的它,不需要其他地方用它。 也叫闭包,就是封闭的意思,就是其他地方都不用他...
  • 也叫闭包,就是封闭的意思,就是其他地方都不用他,包就是函数。 lambda表达式 其实就是一个函数对象,他内部创建了一个重载()操作符的类。 2.最简单的一个lambda表达式。 int main(){ [] {}();//[]代表...
  • gluPerspective(解释得很好) ...首先得设置gluPerspective,来看看它的参数都表示什么意思 fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果设置为0,相当你上眼睛了,所以什么也
  • 函数原型 gluPerspective(GLdouble fovy,GLdouble aspect,GLdouble zNear,GLdouble zFar) <br />首先得设置gluPerspective,来看看它的参数都表示什么意思 fovy,这个最难理解,我的理解,眼睛睁开的...
  • gluPerspective

    千次阅读 2018-01-28 20:37:00
    首先得设置gluPerspective,来看看它的参数都表示什么意思 fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果设置为0,相当你上眼睛了,所以什么也看不到,如果为180,那么可以认为你的视界很广阔,
  • 关于gluPerspective(解释得很好)

    千次阅读 2013-08-05 18:06:53
    首先得设置gluPerspective,来看看它的参数都表示什么意思 fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果设置为0,相当你上眼睛了,所以什么也看不到,如果为180,那么可以认为你的视界很广阔,
  • gluPerspective()

    千次阅读 2013-03-10 21:43:22
    首先得设置gluPerspective,来看看它的参数都表示什么意思 fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果设置为0,相当你上眼睛了,所以什么也看不到,如果为180,那么可以认为你的视界很广阔,
  • 函数原型gluPerspective(GLdouble fovy,GLdouble aspect,GLdouble zNear,GLdouble zFar)首先得设置gluPerspective,来看看它的参数都表示什么意思fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果...
  • gluPerspective解释

    2012-09-13 17:47:23
    首先得设置gluPerspective,来看看它的参数都表示什么意思 fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果设置为0,相当你上眼睛了,所以什么也看不到,如果为180,那么可以认为你的视界很广阔,
  • opengl透视参数分析

    2011-08-17 19:40:00
    函数原型gluPerspective(GLdouble fovy,GLdouble aspect,GLdouble zNear,GLdouble zFar)首先得设置gluPerspective,来看看它的参数都表示什么意思fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果...
  • 函数原型gluPerspective(GLdouble fovy,GLdouble aspect,GLdouble zNear,GLdouble zFar)首先得设置gluPerspective,来看看它的参数都表示什么意思fovy,这个最难理解,我的理解,眼睛睁开的角度,即,视角的大小,如果...
  • 笔记:闭包

    2019-02-21 11:27:11
    今天大胖问我什么是"闭包'',我没有回答上来 之前对闭包的理解一直停留在私有变量,了“内部”的环境的阶段 直到看到了轮子哥的这句话: 闭包不是私有,意思不是“封闭内部状态”,而是“封闭外部状态”,当...
  • POJ1207解题报告

    千次阅读 2015-09-07 15:43:52
    题意这个题的意思是 :有一个数,按那个规则,最后能够转换到1,算出这个序列的长度 然后输入两个数,在这两个数构成的区间中,每个数都有其序列长度,求这个序列中最长的一个。 思路 先写出一个函数,求一个数的...

空空如也

空空如也

1 2
收藏数 37
精华内容 14
关键字:

闭函数是什么意思