变量作用域和列表

1. 变量作用域
   - 变量按照作用域分类
     - 全局变量: 在函数外部定义
     - 局部变量:在函数内部定义
   - 变量的作用范围
    - 全局变量:在整个全局都可以用,在局部也可以使用
    -  局部变量只能在所在的函数内部使用,例如形参
   - LEGB原则
    - L(local) 局部
    - E(Elclosing function locale) 外部嵌套函数作用域
    - G(Global module) 函数定义所在模块作用域
    - B(Buildin) python内置模块的作用域
   
2. 提升局部变量为全局变量
   - 使用global
   -需要注意的是，需要先用global进行变量提升，然后在对变量进行赋值等操作，函数必须在调用之后，被提升的变量才可以使用
   

   a1 = 100
   def fun():
       global a2 
       b2 = 200
   
   
   fun() #只有在函数被调用后，提升的变量才能变成全局
   print(b2)

    

3. globals() 与 locals() 函数
   -  用来显示局部变量和全局变量

   a = 1
   
   def fun(b):
       e = 100
       print('globals is {0}'.format(globals()))
       print('locals is {0}'.format(locals()))
   
   fun(200)

    

4. eval() 函数
   - 把字符串当成一个表达式来执行
       eval(string_code, globals=None, locals=None)  globals和locals参数是可选的，如果提供了globals参数，那么它必须是dictionary类型；如果提供了locals参数，那么它可以是任意的map对象。
     恶意代码 ： eval("__import__('os').system('dir')")
   

   x = 1
   y = 2
   z = eval("x+y")
   print(z) # 3

    

5. exec() 函数
   -  将字符串当成代码执行，但是不返回结果，同样可以用来执行恶意代码
6. 递归函数
   - 函数直接或间接调用自身
   - 好处：简洁，容易理解
   -  缺点：消耗资源大
   - 对递归深度有限制，超过限制报错
   - 写递归程序的时候要    ===>  注意结束条件
   

   # 递归调用深度限制代码
   x = 0
   def fun():
       global x
       x += 1
       print(x)
       #函数调用自己
       fun()
   fun()

7. 斐波那契数列：一列数字，第一个值是1 ，第二个值是1，从第三个开始，每一个数字的值等于前两个数字的值的和
    - f(1) = 1 f(2) = 1 f(n)=f(n-1)+f(n+1)
    - 1 1 2 3 4 8 13 ...
   

   def fun(n):
       if n == 1:
           return 1
       if n == 2:
           return 1
       return fun(n - 1) + fun(n - 2)
   
   print(fun(6))  # 8

8. 汉诺塔问题
    假设有一个盘子 n = 1,A >C
              两个盘子 n = 2,A>B  A>C  B>C
              三个盘子 n = 3,把A上的两个小盘子移动到B上，把A上剩下的一个大盘子放到C上，把B上的两个盘子，借助A放到C上去
             n个盘子 把A上的n-1个盘子，借助C移动到B上，把A上剩下的最后一个大盘子，放到C上，把B上n-1个盘子，借助A放到C上
   

   def hannuota(n, a, b, c):
       """
           n 代表盘子的个数
           a ，代表第一个托盘，
           b 是第二个托盘
           c 是第三个托盘
       """
       if n == 1:
           print(a,'--->',c)
       #if n == 2:
         #  print(a,'--->',b)
          # print(a,'--->',c)
          # print(b,'--->',c)
          # return None
       hannuota(n-1, a, b, c)
       print(a, '--->', c)
       hannuota(n-1, b, a, c)
   
   
   a = 'A'
   b = 'B'
   c = 'C'
   hannuota(10,a,b,c)

    

   1.  
      1. 内置数据结构（变量类型）
         - list  列表    [1,2]
         - tuple  元组   (1,2,'a')
         - dict 字典 {'a':1, 'b':2}
         - set  集合
         ---  list 创建列表 a = list()    a =[]
           - 分片操作：实际上是新生成了一个list
            - 对列表进行任意一段的截取
            - list[indexStart : indexEnd : stride]  截取开始，截取结束，截取长度 结果不包含截取结束
            - list[1:3]、 list[:3]、 list[:]、list[2:]   list[::-1] 可以将列表倒序
          - 规定：从右向左数 最右边第一个下标为 -1 , 左边的值要小于右边的值，默认是从左向右进行分片，如果左边的值必须大于右边的值，则步长必须为负数
           列表的增删改：
            - 增 append()方法 a.append(1)
           - 删 del     del a[0] : 将下标为0的元素删除
           - 改 a[2] = 'b'
           - 列表相加 就是将列表接在一起 a=[0] b=[1] a+b => [0,1] 
           - 列表与一个整数相乘，相当于整数个列表相加
           - 列表成员资格运算：判断一个元素是否在列表中，关键词 in/not in ,例如： a=[1,2,3] b=3 c = b in a =>c =True   
           - 列表嵌套： a = [[1,2],[3,4],[5,6]]  
                              for k,v in a:  #这样使用有条件 列表中的每个列表的长度必须一致，for后面的变量必须与列表中的列表的元素个数一致
         　　　　          print(k,'------',v)
           - 列表内涵 list content
           - 将列表中的每个元素乘以10生成一个新的列表  a = [1,2,3]  b = [i*10 for i in a] print(b)
            - 过滤掉原来列表中的某个(些)元素，生成一个新的列表
               - a = [i for i in range(100)]    b = [i for i a if m%2 == 0]  print(b) #将a列表中的偶数放入到一个新的列表中
            - 列表生成式可以嵌套
                -  a = [i for i in range(1,5)]   b = [j for j in range(100,400) if j%100==0]   c = [m+n for m in a for n in b] print(c)
         - 列表的相关函数 len(list) 列表的长度 | max(list)  列表的最大值 | list() 将其他格式的转换为list格式
9. 内置函数 id() 显示一个变量或者数据的唯一确定的编号