Python全网最全基础课程笔记(二)——变量

#输出保留字列表
import keyword #import是导入包的意思，
 
print(keyword.kwlist) # 输出保留字列表

x = 5  # 声明一个名为x的变量，并将其赋值为5  
y = "Hello, World!"  # 声明一个名为y的变量，并将其赋值为字符串"Hello, World!"

x = 10 # 整数类型
y = "张三" # 字符串类型
o = 3.14 # 浮点数类型
z = [1,2,3,4] # 数组(列表)类型 后面会讲到
a = {'name':'李四','age':19} # 字典类型 后面会讲到
b = {'北京','上海','广州','深圳'} # 集合类型 后面会讲到
p = True # 布尔类型

print(type(x))  # 输出：<class 'int'>，因为x是一个整数
print(type(y))  # 输出：<class 'str'>，因为y是一个字符串
print(type(o))  # 输出：<class 'float'>，因为o是一个浮点数
print(type(z))  # 输出：<class 'list'>，因为z是一个数组
print(type(a))  # 输出：<class 'dict'>，因为a是一个字典
print(type(b))  # 输出：<class 'set'>，因为b是一个集合
print(type(p))  # 输出：<class 'bool'>，因为p是一个布尔值

x = 5
print(id(x))  # 输出x变量的内存地址：4367788464

y = "hello"
print(id(y))  # 输出y变量的内存地址：4368876848

a = 10
print(id(a))  # 变量a的内存地址：4309609040 

#给a变量重新赋值
a = 20
print(id(a))  # 变量a的内存地址：4309609360，与上一个不同，因为a现在引用了一个不同的对象

# 字符串是不可变的  
s = "hello"  
s_new = s.replace("e", "a")  # 创建一个新的字符串对象  
print(id(s) == id(s_new))  # 输出False，s和s_new的内存地址不同，因为s和s_new是不同的对象  
  
# 元组也是不可变的  
t = (1, 2, 3)  
t_new = (1, 2, 3, 4)  # 创建一个新的元组对象  
print(id(t) == id(t_new))  # 输出False，因为t和t_new是不同的对象  
  
# 尝试修改元组中的元素会抛出TypeError  
# t[1] = 20  # 这是不允许的

# 列表是可变的  
l = [1, 2, 3]
print(id(l)) # 输出列表l的内存地址：4336280832
l.append(4)  # 修改列表对象l,其实就是想列表l中添加了一个元素
print(id(l))  # 再次输出列表l的内存地址：4336280832，注意这个id在修改前后不会改变

# 字典也是可变的  
d = {'a': 1, 'b': 2}
print(id(d)) # 输出字典d的内存地址：4302206208
d['c'] = 3  # 修改字典对象d  
print(id(d))  # 再次输出字典d的内存地址：4302206208，同样在修改前后不会改变

# 集合也是可变的  
s = {1, 2, 3}
print(id(s)) # 输出集合s的内存地址：4310771072
s.add(4)  # 修改集合对象s  
print(id(s))  # 再次输出集合s的内存地址：4310771072，修改前后不会改变

# 定义全局变量
global_var = "I am global"
#定义一个名字叫做my_function的函数
def my_function():
    # 尝试访问全局变量
    print(global_var) 

    # ，
    '''
    尝试修改全局变量（错误的方式） 
    如果这样直接修改全局变量的值，会出现报错， 因为这样就会导致global_var变成一个局部变量
    上面还有一个输出global_var的语句呢，这个时候输出的就是局部变量的值，但是局部变量是在下面修改全局变量的时候才被创建
    所以上面的 print(global_var) 是获取不到 局部变量global_var的，所以会报错
    '''
    global_var = "I tried to modify global, but this creates a new local variable"
    print(global_var)

#访问my_function函数
my_function()

#输出运行之后的报错信息：UnboundLocalError: local variable 'global_var' referenced before assignment

# 定义全局变量
global_var = "I am global"
#定义一个名字叫做my_function的函数
def my_function():
    '''
        global表示声明全局变量，global global_var表示global_var是一个全局变量
        表示可以在局部去修改这个全局变量的值
        注意：在函数中使用global语句的时候最好写在函数的最上方
    '''
    global global_var

    # 尝试访问全局变量
    print(global_var) # 输出：I am global

    # 现在再次修改global_var，就是表示修改的全局变量的值
    global_var = "I am modified globally"
    print(global_var)  # 输出: I am modified globally

#访问my_function函数
my_function()
#在外部输出全局变量的值，查看全局变量的值是否被改变
print(global_var) # 输出：I am modified globally

#定义一个函数
def my_function():
    #在函数中声明一个变量，局部变量
    local_var = "I am local"
    print(local_var)  # 输出: I am local  
#调用函数
my_function()

# 尝试访问局部变量（会导致错误），因为local_var所在的函数已经执行完了，里面变量的资源已经被释放了
print(local_var)  # 报错信息：NameError: name 'local_var' is not defined

def outer_function(text):  
    # outer_function的局部变量  
    message = text  
      
    def inner_function():  
        # inner_function可以访问outer_function的局部变量message  
        print(message)  
      
    # 返回内部函数，此时就形成了一个闭包  
    return inner_function  
  
# 调用outer_function并获取闭包  
my_closure = outer_function("Hello from a closure!")  
  
# 调用闭包  
my_closure()  # 输出: Hello from a closure!

# 定义一个全局变量，并赋予它一个初始值："I am global"  
global_var = "I am global"  
  
# 定义一个名为 my_function 的函数  
def my_function():  
    # 使用 global 关键字声明，接下来的 global_var 引用将是指向全局作用域中的 global_var 变量  
    global global_var  
    # 修改全局变量 global_var 的值为："I was modified globally"  
    global_var = "I was modified globally"  
  
# 调用 my_function 函数  
my_function()  
# 在全局作用域中打印 global_var 的值，输出将会是："I was modified globally"  
print(global_var)  # 输出: I was modified globally

# 定义一个名为 outer_function 的外层函数
def outer_function():
    # 在 outer_function 内部定义一个变量 outer_var 并初始化为 "I am outer"
    outer_var = "I am outer"

    # 在 outer_function 内部定义一个名为 inner_function 的内层函数
    def inner_function():
        # 使用 nonlocal 关键字声明 outer_var 是非局部变量，即它引用的是外层函数的 outer_var
        nonlocal outer_var
        # 修改 outer_var 的值为 "I was modified by an inner function"
        outer_var = "I was modified by an inner function"
        # 打印修改后的 outer_var 的值
        print(outer_var) # 输出：I was modified by an inner function

        # 调用 inner_function

    inner_function()
    # 在 outer_function 内部再次打印 outer_var 的值，展示 inner_function 对它的修改
    print(outer_var)# 输出: I was modified by an inner function


# 调用 outer_function
outer_function()