• 周二. 2月 7th, 2023

python变量的详细用法

城主

12月 25, 2022 ,

在 Python 中,变量是一个用于存储数据值的命名容器。变量名由字母、数字、下划线组成,不能以数字开头。

Python 中的变量没有类型的限制,所以同一个变量可以在不同的时候存储不同类型的值。例如:





x = 5
print(x)
# Output: 5

x = "Hello"
print(x)
# Output: Hello

在 Python 中,变量的命名遵循一些规则:

  • 变量名只能包含字母、数字和下划线。
  • 变量名不能以数字开头。
  • 不能使用 Python 关键字作为变量名。

变量名应该清晰、简短并且能够准确地反映变量的用途。通常,变量名使用小写字母,多个单词之间使用下划线连接。例如:student_namecounter

在 Python 中,变量的值可以通过赋值语句来改变。例如:





x = 5
x = 10
print(x)
# Output: 10

在 Python 中,也可以使用同一个变量名给多个变量赋值。例如:





x = y = z = 10
print(x)
# Output: 10
print(y)
# Output: 10
print(z)
# Output: 10

这样做的结果是,所有变量的值都是 10。

全局变量和局部变量

在 Python 中,变量可以在函数内部或外部定义。如果在函数内部定义的变量称为局部变量,如果在函数外部定义的变量称为全局变量。

例如:





x = 10  # 全局变量

def foo():
    y = 5  # 局部变量

print(x)  # Output: 10
print(y)  # Output: NameError: name 'y' is not defined

在函数内部,可以使用 global 关键字来声明一个变量是全局变量。例如:





x = 10  # 全局变量

def foo():
    global x
    x = 5  # 全局变量

foo()
print(x)  # Output: 5

变量作用域

在 Python 中,变量的作用域决定了变量在哪里可以被访问。

例如:





def foo():
    x = 10  # 局部变量

print(x)  # Output: NameError: name 'x' is not defined

上面的代码会抛出一个 NameError 异常,因为在函数外部无法访问函数内部定义的局部变量。

但是,如果在函数内部使用了 global 关键字声明了一个变量是全局变量,那么在函数内部和外部都可以访问这个变量。

例如:





x = 10  # 全局变量

def foo():
    global x
    print(x)

常量

在 Python 中,常量是不能被改变的值。通常,常量的值在程序运行期间不会改变。

在 Python 中,常量的命名规则和变量类似,但是通常使用大写字母和下划线来表示。例如:PIMAX_VALUE

但是,在 Python 中并没有严格的常量的概念,所以你无法通过特定的方法来声明一个变量是常量。通常的做法是使用大写字母和下划线命名变量,并在程序中约定不对这些变量进行赋值。

例如:





MAX_VALUE = 100

def foo():
    MAX_VALUE = 10  # 可以赋值,但不应该

print(MAX_VALUE)  # Output: 100

但是,这样的方法并不能真正的阻止你对常量的赋值,只是在约定中告诉程序员不应该这样做。

默认参数

在 Python 中,函数的参数可以设置默认值。这样,如果在调用函数时没有传入对应的参数,函数就会使用默认值。

例如:





def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("John")  # Output: Hello, John!
greet("John", "Hi")  # Output: Hi, John!

可变参数

在 Python 中,可以使用 * 操作符来声明一个函数的参数是可变的。这样,在调用函数时,就可以传入任意数量的参数。

例如:





def sum(*numbers):
    result = 0
    for number in numbers:
        result += number
    return result

print(sum(1, 2, 3))  # Output: 6
print(sum(1, 2, 3, 4, 5))  # Output: 15

在函数内部,可变参数会被解包成一个元组。

阅读  Python运算符的详细用法

可以将可变参数和关键字参数混合使用,但是要注意,可变参数必须在关键字参数之前声明。

例如:





def foo(a, b, *c, **d):
    pass  # 函数体

在这个例子中,ab 是位置参数,c 是可变参数,d 是关键字参数。

关键字参数

在 Python 中,可以使用 ** 操作符来声明一个函数的参数是关键字参数。这样,在调用函数时,就可以传入任意数量的关键字参数。

例如:





def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="John", age=30)
# Output:
# name: John
# age: 30

print_info(name="John", age=30, gender="male")
# Output:
# name: John
# age: 30
# gender: male

静态变量

在 Python 中,可以使用静态方法和类方法来实现静态变量的功能。

静态方法是一种特殊的函数,它不需要通过对象来调用,而是直接通过类名来调用。静态方法通常用于定义一些与类本身有关的方法,比如工具函数或者常量。

例如:





class Counter:
    count = 0  # 静态变量

    @staticmethod
    def increment():
        Counter.count += 1

Counter.increment()
print(Counter.count)  # Output: 1

类方法是一种特殊的函数,它不需要通过对象来调用,而是直接通过类名来调用。类方法通常用于定义一些与类本身有关的方法,比如工具函数或者常量。

例如:





class Counter:
    count = 0  # 静态变量

    @classmethod
    def increment(cls):
        cls.count += 1

Counter.increment()
print(Counter.count)  # Output: 1

静态方法和类方法的区别在于,类方法可以访问类的内部数据,而静态方法不能。

变量解析

在 Python 中,可以使用 locals()globals() 函数来查看当前作用域内的变量。

例如:





x = 10
y = 20

def foo():
    z = 30
    print(locals())

变量解析

在 Python 中,可以使用 locals()globals() 函数来查看当前作用域内的变量。

例如:





x = 10
y = 20

def foo():
    z = 30
    print(locals())  # Output: {'z': 30}

print(globals())  # Output: {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'x': 10, 'y': 20, 'foo': <function foo at 0x7f63cdbd7a60>}

注意,locals()globals() 函数返回的是一个字典,可以使用字典的方法来查看变量。

另外,在 Python 中,还可以使用 vars() 函数来获取对象的变量。

例如:





class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

point = Point(1, 2)
print(vars(point))  # Output: {'x': 1, 'y': 2}

vars() 函数也返回一个字典,其中包含了对象的变量。

阅读  Python 构建系统

动态变量

在 Python 中,可以使用 setattr()getattr() 函数来动态设置和获取变量。

例如:





class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

point = Point(1, 2)
setattr(point, "z", 3)
print(point.z)  # Output: 3

print(getattr(point, "x"))  # Output: 1

变量交换

在 Python 中,可以使用下面的语句来快速交换两个变量的值:





x, y = y, x

这个语句是通过多个赋值语句的组合来实现的。

例如:





x = 10
y = 20

x, y = y, x
print(x)  # Output: 20
print(y)  # Output: 10

这个语句非常方便,可以用来快速交换两个变量的值。

变量解包

在 Python 中,可以使用解包的方式来快速获取变量的值。

例如:





point = (1, 2)
x, y = point
print(x)  # Output: 1
print(y)  # Output: 2

这个语句是通过多个赋值语句的组合来实现的。

解包的方法可以用来快速获取元组、列表、字典或者其他可迭代对象中的值。

例如:





data = [1, 2, 3]
a, b, c = data
print(a)  # Output: 1
print(b)  # Output: 2
print(c)  # Output: 3

这种方法非常方便,可以用来快速获取可迭代对象中的值。

变量作用域

在 Python 中,变量的作用域决定了变量的可访问性。 Python 中的作用域分为全局作用域和局部作用域。

全局作用域是指程序中的所有代码都可以访问的变量。全局作用域中的变量通常是程序的配置参数或者常量。

局部作用域是指函数内部的变量。局部作用域中的变量通常是函数的临时变量,在函数执行完毕后就会被销毁。

例如:





x = 10  # 全局变量

def foo():
    y = 20  # 局部变量
    print(y)

foo()  # Output: 20
print(x)  # Output: 10

在函数内部,可以访问全局作用域中的变量,但是不能修改它们的值。如果想要在函数内部修改全局变量的值,可以使用 global 关键字。

例如:





x = 10  # 全局变量

def foo():
    global x
    x = 20  # 修改全局变量
    print(x)

foo()  # Output: 20
print(x)  # Output: 20

注意,在函数内部声明的变量默认是局部变量,如果想要访问全局变量,必须使用 global 关键字。

变量的命名规则

在 Python 中,变量的命名是有一些规则的。主要有以下几条:

  • 变量名只能由字母、数字和下划线构成,不能以数字开头。
  • 变量名不能是 Python 中的关键字。
  • 变量名应该尽量简短,但是要尽量清晰。

下面是一些合法的变量名:





x
y
z
point
point_x
point_y
_private
__private
__private__

下面是一些不合法的变量名:





1x  # 不能以数字开头
if  # 不能是 Python 的关键字
x-y  # 只能由字母、数字和下划线构成

在 Python 中,一般使用小写字母和下划线的方式来命名变量,这种命名方式被称为 snake_case

但是,也有一种命名方式,称为 camelCase,使用小写字母开头,后面的单词首字母大写。这种命名方式更常见于其他语言,但是在 Python 中并不常用。

例如:





pointX
pointY

注意,在 Python 中,还有一种特殊的命名方式,称为 PascalCase,所有单词的首字母都大写。这种命名方式通常用于类的命名。

变量的默认值

在 Python 中,可以为函数的参数设置默认值,这样在调用函数时,如果没有传入相应的参数,就会使用默认值。

例如:





def greet(name="World"):
    print(f"Hello, {name}!")

greet()  # Output: Hello, World!
greet("John")  # Output: Hello, John!

在这个例子中,name 参数有一个默认值 "World"。当调用 greet 函数时没有传入参数时,就会使用默认值。

阅读  Python 包管理器的使用详解

默认值可以是任何类型的值,包括常量、变量、表达式等。

例如:





DEFAULT_NAME = "World"

def greet(name=DEFAULT_NAME):
    print(f"Hello, {name}!")

greet()  # Output: Hello, World!

在这个例子中,name 参数的默认值是 DEFAULT_NAME 常量。

注意,默认值是在函数定义的时候计算的,而不是在函数调用的时候计算。这意味着,如果默认值是一个可变类型,比如列表、字典等,那么每次调用函数都会使用相同的默认值。

变量的生命周期

在 Python 中,变量的生命周期决定了变量的存在时间。

在 Python 中,有两种变量的生命周期:静态生命周期和动态生命周期。

静态生命周期的变量是在程序启动时创建,在程序结束时销毁的变量。例如全局变量和静态变量。

动态生命周期的变量是在程序执行过程中创建,在不再使用时销毁的变量。例如局部变量和动态分配的内存。

例如:





x = 10  # 全局变量,静态生命周期

def foo():
    y = 20  # 局部变量,动态生命周期

foo()
print(x)  # Output: 10
print(y)  # Output: NameError: name 'y' is not defined

在这个例子中,x 是全局变量,它在程序启动时创建,在程序结束时销毁。y 是局部变量,它在函数 foo 执行时创建,在函数执行完毕后销毁。

注意,在 Python 中,变量的生命周期由变量的作用域和引用计数决定。

变量的类型转换

在 Python 中,变量的类型可以使用类型转换函数来转换。

例如:





x = 10
y = "20"

z = int(y) + x
print(z)  # Output: 30

在这个例子中,变量 x 是整数类型,变量 y 是字符串类型。使用 int() 函数将字符串类型的变量 y 转换为整数类型,然后变量 z 被赋值为 x + y 的结果。

Python 中提供了多种类型转换函数,包括:

  • int():将数值类型或字符串类型转换为整数类型。
  • float():将数值类型或字符串类型转换为浮点数类型。
  • str():将数值类型或其他类型转换为字符串类型。

例如:





x = 10
y = 20.5
z = "30"

a = str(x) + z
b = int(y) + x
c = float(x) + y

print(a)  # Output: '1030'
print(b)  # Output: 30
print(c)  # Output: 30.5

变量的比较

在 Python 中,变量可以使用比较运算符来比较。

例如:





x = 10
y = 20

print(x < y)  # Output: True
print(x > y)  # Output: False
print(x == y)  # Output: False
print(x != y)  # Output: True

在这个例子中,变量 xy 分别被赋值为整数值 1020。使用比较运算符 <>==!= 分别比较了变量 xy 的大小关系。

比较运算符的结果是布尔值,即 TrueFalse

Python 中还有一些其他的比较运算符,包括:

  • <=:小于等于
  • >=:大于等于

例如:





x = 10
y = 20

print(x <= y)  # Output: True
print(x >= y)  # Output: False

在这个例子中,使用比较运算符 <=>= 分别比较了变量 xy 的大小关系。

注意,比较运算符只能用于数值类型的变量。对于字符串类型的变量,可以使用比较运算符来比较字符串的字典序。