• python学习day10


    # 函数
        # 可读性强 复用性强
    # def 函数名():
          # 函数体
          #return 返回值
    # 所有的函数 只定义不调用就一定不执行
                #先定义后调用
    
    #函数名()   #不接收返回值
    #返回值 = 函数名() #接收返回值
    
    #返回值
        # 没有返回值 :默认返回None
            # 不写return:函数内的代码执行完毕自动结束
            # 只写return:结束一个函数
            # return None
        # 返回一个值 :结束了函数且返回一个值,可以是任意的值
        # 返回多个值 : 多个值之间用逗号隔开,接收的时候可以用一个变量接收(元祖),也可以用等量的多个变量接收
    
    # def f(a):
    #     return '栗子'
    #
    # ret = f('苹果')
    # print(f('苹果'))
    
    #参数
        #形参  定义函数的时候
            # 位置参数 :必须传
            # *args :动态参数 可以接收任意多个按位置传入的参数
            # 默认参数 : 可以不传  —— 陷阱
            #     def qqxing(k,l = {}):
            #         # l.append(1)
            #         l[k] = 'v'
            #         print(l)
            #
            #     qqxing(1)     #[1]
            #     qqxing(2)     #[1,1]
            #     qqxing(3)     #[1,1,1]
            #
                # 如果默认参数的值是一个可变数据类型,
                # 那么每一次调用函数的时候,
                # 如果不传值就公用这个数据类型的资源
    
            # **kwargs : 动态参数 可以接受任意多个按关键字传入的参数
        #实参  调用函数的时候
            # 按照位置传参数
            # 按照关键字传参数
                # 可以混用 位置参数必须在关键字传参之前
                # 不能对一个参数重复赋值
    
    # def 娃哈哈(*args):
    #     print(args)
    #
    # # 娃哈哈(1,2,3,4)
    # l = [1,2,3,4]
    # 娃哈哈(*l)
    
    # #函数的命名空间和作用域
    # a = 1
    # def func():
    #     print(a)
    # func()
    
    # print()
    # input()
    # list
    # tuple
    # 命名空间有三种
    # 内置命名空间----哦樱桃红解释器
        #就是python解释器一启动就可以使用的函数名字
        #函数 启动时就被加载进了内存里
    #全局命名空间----就是自己写的代码
        #是按照从上到下的顺序加载到内存里的
        #放置了我们自己所设置的所有变量名和函数
    #局部命名空间
        #就是函数内部定义的变量
        #当函数被调用的时候才会产生,随着函数的结束而释放
    
    # 在局部:可以使用全局、内置
    # 在全局:可以使用内置
    # 在内置:不能使用局部、内置
    
    # def func():
    #     a = 1
    # func()
    # print(a)    #全局中不能使用局部变量
    
    # def len(l): #当我们定义了和内置空间相同的名字时,先用我们自己的
    #     print('in max func')
    # print(len([1,2,3]))
    
    # def input():
    #     print('in input now')
    # def func():
    #     print(input())
    # func()
    
    # func---->函数的内存地址
    # 函数名()--->函数的调用
    # 函数的内存地址()--->函数的调用
    
    #作用域
    #全局作用域----globals()
    #局部作用域----locals()
    
    # a = 1
    # def func():
    #     global a    #修改全局变量
    #     a = 2
    # func()
    # print(a)
    #对于不可变数据类型,可在局部查看但不可修改,
    # 如果想要修改就必须在之前家global
    # a = 1
    # b = 2
    # def func():
    #     x = 'aaa'
    #     y = 'bbb'
    #     print(locals())     #打印的是内存地址
    #     print(globals())    #打印的是内存地址
    # func()
    # print(globals())    #打印的是内存地址
    # print(locals())     #打印的是内存地址
    
    # a = 1
    # def func(a):
    #     a  =2
    #     return a
    # a =func(a)
    # print(a)
    # globals永远打印全局的名字
    # locals打印什么是基于它的位置
    
    #函数的嵌套
    # def max(a, b):
    #     return a if a > b else b
    #
    # def the_max(x,y,z):     #函数的嵌套调用
    #     c=max(x,y)
    #     return max(c,z)
    # print(the_max(1,2,3))
    
    #函数的嵌套定义
    #在内部函数中可以使用外部函数的变量
    # a = 1
    # def outer():
    #     a = 1
    #     def inner():
    #         a =2
    #         def inner2():
    #             nonlocal a
    #             a+=1
    #         inner2()
    #         print('##a##:',a)
    #     inner()
    #     print("**a**",a)
    # outer()
    # print('全局:',a)
    #nonlocal用于寻找最近的局部变量
    #对全局无效
    #对局部也只对最近的一层生效
    
    # a = 0
    # def outter():
    #     a=1
    #     def inner():
    #         a=2
    #         def inner2():
    #             nonlocal a
    #             print(a)
    #         inner2()
    #     inner()
    # outter()
    
    # def func():
    #     print(123)
    # func()  #函数名就是内存地址,并可以进行赋值操作
    # func2 = func
    # l = [func,func2]    #函数名可以作为容器类型的元素
    # print(l)
    # for i in l:
    #     i()     #执行函数
    
    # def func():
    #     print(123)
    # def wahaha(f):
    #     f()
    #     return f    #函数名可以当作返回值
    # qqxing = wahaha(func)   #函数名可以作为函数的参数
    # qqxing()
    
    #函数的闭包:嵌套函数,在外部直接调用内部函数
    # def outer():
    #     a = 1
    #     def inner():
    #         print(a)
    #     inner()
    # outer()
    
    # def outter():
    #     a = 1
    #     def inner():
    #         print(a)
    #     return inner
    # inn = outter()
    # inn()
    
    from urllib.request import urlopen
    # ret = urlopen('http://search.chongbuluo.com/').read()
    # print(ret)
    # def get_url():
    #     url='http://search.chongbuluo.com/'
    #     ret=urlopen(url).read()
    #     print(ret)
    # get_url()
    
    def get_url():
        url='http://search.chongbuluo.com/'
        def get():
            ret = urlopen(url).read()
            print(ret)
        return get
    get_func = get_url()
    get_func()
  • 相关阅读:
    Matplotlib
    Numpy&Pandas
    莫凡《机器学习》笔记
    李宏毅《1天搞懂深度学习》笔记
    Git客户端使用教程
    像素级压缩感知图像融合的论文
    二分图【洛谷P2175】 小Z的游戏分队
    模板【洛谷P3390】 【模板】矩阵快速幂
    模板 可并堆【洛谷P3377】 【模板】左偏树(可并堆)
    LCA SP913 QTREE2
  • 原文地址:https://www.cnblogs.com/wujunjie-sir/p/9192180.html
Copyright © 2020-2023  润新知