变量作用域

• 变量由作用范围限制

• 分类: 按照作用域分类

  • 全局(global):在函数外部定义
  • 局部(local) :在函数内部定义

• 变量的作用范围

  • 全局变量: 在整个全局范围都有效
  • 局部变量: 在局部的范围可以使用(变量在超出一定的范围(函数、类)则不能够使用)

• LEGB原则：

  • L(Local) :局部作用域
  • E(Enclising function locale): 外部嵌套函数作用域
  • G(Global module): 函数定义所在模块作用域
  • B(Buildin): Python内置模块的作用域

# 变量作用域案例
# 全局变量 a1
a1 = 100

def fun():
    print("I am in fun")
    print("a1={0}".format(a1))
    # 局部变量a2
    a2 = 99
    print("a2={0}".format(a2))
    

fun()
print("a1={0}".format(a1))
print("a2={0}".format(a2))

I am in fun
a1=100
a2=99
a1=100



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-7-d5a37a91dcc5> in <module>
     13 fun()
     14 print("a1={0}".format(a1))
---> 15 print("a2={0}".format(a2))


NameError: name 'a2' is not defined

# 使用Global 提升变量的作用域
def fun():
    global b1
    b1 = 100
    print(b1)
    
fun()
print(b1)

100
100

globals 和 locals函数

• 使用globals 和 locals函数来显示全局变量和局部变量

# globals 和 locals 函数
a = 1
b = 2

def fun(e,f):
    c = 10
    d = 20
    print("Locals={0}".format(locals()))
    print("Globals={0}".format(globals()))
fun(100,200)    

eval() 和exec函数

eval()

• 把一个字符串当成一个表达式来执行,返回表达式执行后的结果

• 语法:

   eval(string_code,global=None,local=None)
  

exec()

• 功能关于eval类似,但是不返回结果

• 语法

     exec(string_code,global=None,local=None)
  

#eval函数 案例
x = 100
y = 200

z1 = x + y
z2 = eval("x + y")

print("z1={0}".format(z1))
print("z2={0}".format(z2))

z1=300
z2=300

#exec 案例
x = 100
y = 200

z1 = x + y
# 执行print内的代码: 注意引号的使用
z2 = exec("print('x+y:',x+y)")

print("z1={0}".format(z1))
print("z2={0}".format(z2))

x+y: 300
z1=300
z2=None

递归

• 函数直接或者间接的调用自身
• 优点: 简洁,理解容易
• 缺点: 对递归深度有限制,消耗资源大
• Python中对递归的深度有限制,超过限制报错
• 在使用递归的时候,注意结束条件

# 递归深度层次案例

def fun():
    # 变量要先定义在使用
    xx = 0
    xx += 1
    print("第{0}层".format(xx))
    fun()
    
#调用函数
fun()

# 斐波拉契数列
#一列数字，第一个数值是１　第二个也是１，从第三个开始，每一个数字是前两个数之和
# 1,1,2,3,4,8,13,............

# n 表示第n个斐波拉契数列的值
def fib(n):
    if n==1 or n==2:
        return 1
    return fib(n-1) + fib(n-2)

#调用
fib(7)

13

内置数据结构(变量类型)

• 四大结构
  • list
  • set
  • dict
  • tuple

list

- 一组有序的数据组合
- 创建类型
    - 空列表    list = []
    - 默认列表 list = [1,2,3,4]
    - list() : ls = list()
        - ls.append(value)
- 列表数值的访问
    - 使用下标操作(索引值)
    - 下标从0开始

- 分片
    - list[startValue:endValue]
    - startValue和endValue可以为空
        - startValue不写,则为从第一个数开始截取
        - endValue不写,则为截取到最后一个数
    - list[startValue:endValue:addNum]
        -  addNum 可控的增长幅度
    - 下标可以超出列表的范围,超出后不考虑多余的下标范围
    
    - 下标数可以为负数
        - 如果为负数,则表示顺序为从右往左
        - 最后一个值的下标为-1

#LIst 
# 创建列表-空列表
ls = []
print(type(ls))
# 创建列表-默认值
ls2 = [100,200]
print(type(ls2))
print(ls2)

#使用lest() 来创建
ls4 = list()
ls4.append(1)
print(type(ls4))
print(ls4)

<class 'list'>
<class 'list'>
[100, 200]
<class 'list'>
[1]

# 下标访问
ls2 = [1,2,3,4,5,6,7,8,9,0]
print(ls2[1])

# 分片
#截取下标 0-3 数
print(ls2[0:4])
print(ls2[:])
print(ls2[:4])
print(ls2[4:])

2
[1, 2, 3, 4]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[1, 2, 3, 4]
[5, 6, 7, 8, 9, 0]

# 增长幅度
print(ls2[0:4:2])

[1, 3]

# 分片的负下标
print(ls2)
# 默认分片是从左往右
# 正常情况下,分片的左边的下标值要小于右边的值
print(ls2[-2:-4])
print(ls2[-4:-2])

#如果分片一定要从左往右开始,则步长设置为负数
print(ls2[-2:-4:-1])

[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[]
[7, 8]
[9, 8]

分片操作

- 分片操作是生成一个新的list
    - 内置函数id() : 负责显示一个变量或者数据的唯一确定编号

# id()函数
print(id(ls2))
print(id(ls2[:]))

139629234604552
139629232457672