自己家的电脑宽带50m做网站服务器2024年疫情还会封控吗

---恢复内容开始---

1. 函数也叫方法，比如你用手机打电话就是一个函数，你只管用就好，里面的功能别人已经帮你研发好了，你只需要输入手机号，按下拨打电话就好了，这个概念用在代码里尤为重要，比如重复某个功能，比如用户输入，你要判断用户输入，你要判断用户的输入不能为空，那么这个你可以定义一个函数，就是用来判断用户的输入是否为空，每次调用一下就可以，假如现在校验用户输入的需求变化了，那么你直接维护这个函数就好了，没必要再去所有的代码里找这个校验，一个个的去改，所有函数有以下两个显而易见的优点：
   1. 重复代码精简，简化复用性代码的编写，将重复性代码写成函数，要用的时候调用即可；
   2. 方便以后维护，你改一个函数，所有调用这个函数的地方的功能都能及时更新，避免修改代码遗漏
2. 函数在前面的字符串方法已经接触过了，像strip()这些，就是python内置的一些函数，当然还有很多，这些函数python已经帮我们写好了，直接用就好了，这样是不是很方便，什么时候需要什么时候就调用。显而易见，函数要调用的时候才会执行，调用函数就是在函数名后加（）就可以调用了，像strip()这些。
3. 函数初识
   1. 定义函数的时候，写的入参叫形参；
   2. 调用函数的时候，传的值叫实参；

   3. def sayName(name,age,sex):  #name,age,sex就是形式参数
          # name,age,sex函数的参数类型是位置参数、必填参数
          print('姓名：%s'%name)
          print('年龄：%s'%age)
          print('性别：%s'%sex)
          #上面这个就是函数体
      
      
      sayName('星星',18,'男')  #'星星',18,'男'这三个就是实际参数，调用的时候传进来的参数

       

4. 函数ruturn
   1. 函数如果需要返回值，用return即可，有两点需要注意：
      • 函数里，只要遇到return就结束，不会再往下运行
      • 如果函数没有指定return返回值，那么函数默认返回的是None

      • def call(a,b):
            return a+b
            return a*b
        def call2(a,b):
            print('函数内a,b运行结果：',a+b)
        
        print('call函数return结果：',call(1,2))
        print('call2函数return结果：',call2(1,2))
        
        #call函数return结果： 3    #因为函数里return了a+b的结果，所以这里的结果是3
        #函数内a,b运行结果： 3     #这个是call2函数体里运行的结果
        #call2函数return结果： None    #因为函数里没有return，所以这里的结果是None

         

5. 函数即变量
   1. 之前接触过变量，在内存里开放一个地方存变量，函数也是一样的，也是变量，存在内存里的某个地方，调用直接就是函数名（），就调用了，看一个有趣的调用方法，先定义一个字典，value存函数名，根据key来调用相应的函数

      1. def play():
             print('出去浪')
         def study():
             print('好好学习')
         def_method={'1':play,'2':study}
         while True:
             choice = input('请输入你的选择：1代表出去浪，2代表好好学习')
             if choice =='1' or choice =='2':
                 def_method[choice]()
                 print(type(def_method[choice]()))
                 break
             else:
                 print('请输入正确的选择')
                 continue

         while True：是死循环，这里只是写一个循环，真实的工作场景中，需要填写正确的条件判断
         　　

6. 入参类型
   1. 函数的入参有很多类型，上面已经了解过位置参数，还有默认参数，可变参数，关键字参数
   2. 注意参数有顺序，如果上述四种参数你都有用，那么参数类型顺序必须是：位置参数 -> 默认参数 -> 可变参数 -> 关键字参数，否则报错
      • • 位置参数：这个参数就和格式化输出里的占位一样，形参先把位置站好，然后就等着用户调用的时候输入实参，排队填坑，如果实参和形参个数不一致，多了或者少了都会报错，如下：

          • def add(a,b):
                print('%s+%s=%s'%(a,b,a+b))
                return a*b
            add(1,2)    #打印结果：1+2=3
            add(6,2)    #打印结果：6+2=8
            add(1,2,3)  #打印结果：报错，参数多了
            add(2)      #打印结果：报错，参数少了

             

      默认参数：
      • 这个参数就是程序会先给一个默认的，不传不会报错，会直接使用默认的这个参数值，如果传了就用你传的这个值；等于是定义函数的时候先定义了一个参数变量，调用的时候没传就用之前定义好的，如果传了就是覆盖之前的值，用传入的参数值：

        • def multi(a,b=2):
              print('%s**%s=%s'%(a,b,a**b))
          
          multi(3)   #不传参的时候默认b=2，这里求的是平方
          multi(4,3) #传的时候b=3，这里求的是立方
          multi(2,b=4) #和上面的这个调用是一样的，但是一般这样写，如果默认参数较多时，不会因为位置而出错
          multi(b=4,2) #报错，位置参数必须在前（positional argument follows keyword argument）

           

      • 可变参数：这里一般用的少，可变就是参数是变化的，考虑到了程序的扩展性，定义函数的时候并不确定会有多少个参数，这里就用到了可变参数，既然可变，那么在调用函数的时候也是可以不输入的：

        • # 可变参数
          def user(name,passwd,*args):   #一般是用args来命名的，当然也可以用其他你想要的名字
              print('用户名：%s,密码：%s'%(name,passwd))
              print('还有如下属性：\n',args)   #这里的args，就是用户输入参数的一个元祖
          
          user('chenmeng',12334,'男','180cm','60kg')
          # 打印结果：
          # 用户名：chenmeng,密码：12334
          # 还有如下属性：
          # ('男', '180cm', '60kg')

           

          　　
      • 关键字参数，也不是必填的，他是一个key-value的字典形式：

        • # 关键字参数:也不是必填的，他是一个key-value的字典形式
          def user(name,passwd,**args):
              print('用户名：%s，密码：%s'%(name,passwd))
              print('还有如下属性：\n',args)
          user('xingxing',123456,sex='男',height='180cm')
          # 打印结果：
          # 用户名：xingxing，密码：123456
          # 还有如下属性：
          # {'sex': '男', 'height': '180cm'}

           

7. 变量作用域
   1. 变量作用域有四种：全局作用域，局部作用域，内建作用域，闭包函数外的函数中，后两者用的少，全局作用域和局部作用域概念用的多。全局作用域就是变量在所有的范围都可以用，比如在代码开始定义一个变量，那么不论是在函数外部还是内部都可以用这个变量；局部作用域就是只能在某个区域内才能用，除了这个区域就用不了了，比如函数内定义的变量只能在函数体内用，出了函数就用不了 了。（建议不要使用全局变量，不安全，所有人都可以修改）
   2. 全局作用域

      • # 全局作用域
        hys=['屏幕','主机'] #全局变量
        def add(thing):
            hys.append(thing)
        add('麦克')
        print(hys)  #打印结果为：['屏幕', '主机', '麦克']

         

   3. 局部作用域

      • # 局部作用域
        def add(thing):
            desk=['显示器','鼠标']  #局部变量
            desk.append(thing)     #函体内修改局部变量      
        add(223)
        print(desk)                #函数体外调用局部变量报错

        值得一提的是，当全局变量是一个不可编辑的参数时，需要先申明才可以用全局变量（str/int/float等不可变变量函数在调用全局变量时，需要global才可以修改）

      • # 不可变变量的全局变量引用，如int、float、str
        money = 500
        def chage():
            money=1000
            print('函数内的money：',money)   #打印结果是1000，因为函数内部作用域中money=1000，不能修改外面的money
        chage()
        print('函数外的money：',money)   #打印结果为500，因为函数不可修改外部作用域中不可变变量的全局变量引用，如int、float、str
        
        def chage():
            global money    #global后就可以引用了，这就声明了money是一个全局变量，函数内可以修改
            money =1000
            print('函数内的money：',money)   #打印结果是1000
        chage()
        print('函数外的money：',money)     #打印结果是1000,因为global声明了全局变量，所以可以修改

         

   4. 1. 函数迭代，就是自己调用自己，一个死循环，一直调用下去，最多迭代999次，超过999次程序自动停止运行（while没有次数限制）
   5. 啊
8. 函数迭代
   1. 函数迭代，就是自己调用自己，一个死循环，一直调用下去，最多跌倒999次，超过999次程序自动停止运行（while没有次数限制）。既然这样，那么迭代肯定要有一些特性才可以正常调用：
      1. 必须有一个明确的结束条件
      2. 每次进入更深一层递归时，问题规模相比上次递归都因有所减少
      3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

      4. # 函数迭代，就是自己调用自己，一个死循环，调用下去
         def dd():
             print('学习学习努力学习')
             dd()    #函数内，又调用了函数本身，那么就会一直调用下去
         dd()   #迭代函数最多会调用999次，这里会打印999次'学习学习努力学习'

          

      5. 用函数迭代写斐波拉契数列：[1, 1, 2, 3, 5, 8, 13, 21, 34],数列从第3项开始，每一项都等于前两项之和。
      6. 先用之前的知识来写

         1. list=[]
            def fb(num):
                a=1
                b=1
                while num >0:
                    list.append(a)
                    a,b=b,a+b
                    print(b)
                    num-=1
            fb(9)
            print(list)

             

      7. 用迭代来写

         1. list=[]
            a=1
            b=1
            def fb(num):
                global a,b
                list.append(a)
                a,b=b,a+b
                num-=1
                if num>0:
                    fb(num)
            
            fb(9)
            print(list)