1.5 对象与变量¶

1.5 对象与变量.jpg

1.5.1 对象¶

Python中所有数字、序列、集合、映射、类、实例、异常、模块、类与类的实例、函数、方法、布尔值、空值等都被称为对象。

1.5.2 对象属性¶

每个对象都有3个基本属性：
__类型(type)__
__身份标识(id)__
__值(value)__

type(object) 函数可以返回对象 object 的数据类型，对象一旦创建其类型便不可再变。

id(object) 函数可返回表示对象object的身份标识，也就是系统为这个对象分配的内存的首地址编号，用一个整数表示。对象创建后，其身份标识 id 绝对不会改变。

value就是这个对象存储的值。

有些对象的值可以改变，称为可变数据类型，与之相对，值不可以改变的对象称为不可变数据类型。

print(type(500))  # 类型为：整型 <class 'int'>
print(id(500))    # 内存地址为：139798173271824，与机器有关，每次运行不同

<class 'int'>
139705958252336

程序先创建一个整数对象“500”
500 称为这个对象的值
该对象的数据类型为整型int，可用函数type(500)来获取。
系统会为其分配一个内存区域，可用函数id(500)获取，返回值“2562179721328”为该对象在内存地址的起始编号。

每个对象除了这三个基本属性以外，在使用过程中，用户经常会通过加标签的方式给对象附加一个标识符，也称为__名字（name）__，以方便在程序中通过这个名字引用该对象。
这个名字与其他程序设计语言中的变量作用相似，所以 Python 中也经常称之为__变量__。
Python中用__赋值符号（=）__给对象加标识符，也可以说是给对象增加名字或是没用传统称为给变量赋值。
同一个对象可以命多个名字，不同对象命相同名字时，应用时访问最邻近命名的那个对象。</font>

num = 500         # 名字为num

print(type(num))  # <class 'int'>
print(id(num))    # 2562179721328
print(num)        # 值为500

<class 'int'>
139814452362320
500

1.5.3 赋值¶

将一个标签名字绑定到一个对象上的操作，命名后可以用这个名字来引用或者说访问该对象，这个操作用赋值符号“=”完成。 Python中的变量在使用前不需要声明，也不需要声明其类型。但每个变量在使用前都必须先有值才可以使用，也就是说__变量首次出现必须是在赋值符号的左侧__。只有当一个对象被赋值给一个变量后，该变量才会被创建。</font>

x = 5             # 名字x 绑定到整数5上
print(x)

y = 'hello'       # 名字y 绑定到字符串'hello' 上
print(y)

z = [1, 2, 3, 4]  # 名字z 绑定到列表[1, 2, 3, 4]上
print(z)

x = (16 + (8 ** 2 - 4 * 6 * 2) ** 0.5) / (2 * 5)  
# 名字x 绑定到表达式求值得到的浮点数对象上
print(x)

5
hello
[1, 2, 3, 4]
2.0

在同一个程序中对一个变量重复赋值，或者说重复使用同一个变量名时，起作用的是最近的语句。下面程序中先将浮点型对象“3.14”和整型对象“4”分别与变量名“pi”和“radius”绑定，此时计算面积时，参与运算的是“3.14”和“4”，得到的浮点型对象“50.24”与变量名“area”绑定。
当程序执行到 radius = 6 时，“radius”这个名字将先与对象“4”解绑，再重新绑定到对象“6”上。
类似的操作，执行area = pi * (radius ** 2) 时，“area”也会与对象“50.24”解除绑定并重新绑定到对象“113.24”上。

pi = 3.14                  # 变量pi赋值为3.14
radius = 4                 # 变量radius赋值为4
area = pi * (radius ** 2)  # 计算圆面积
print(area)                # 输出面积值 50.24

radius = 6                 # 变量radius赋值为6，后面使用这个值计算
area = pi * (radius ** 2)  # 计算圆面积
print(area)                # 输出面积值 113.04

50.24
113.04

需要命名的对象可以是包含于圆括号、方括号、大括号或引号内的__可迭代对象。__（range、列表、元组、集合和字典等）
如果赋值号左边是一个名字，则将名字直接绑定到右侧对象上。

x = (1, 2)
print(x)        # (1, 2)，名字 x 绑定到元组(1, 2)上，后面用x访问这个元组

x = [1, 2]
print(x)        # [1, 2]，名字 x 绑定到列表[1, 2]上，后面用x访问这个列表

x = {1, 2}
print(x)        # {1, 2}，名字 x 绑定到集合{1, 2}上，后面用x访问这个集合

x = '1234'
print(x)        # '1234'，名字 x 绑定到字符串'1234'上，后面用x访问这个字符串

x = {'name':'Tom', 'age':18}
print(x)        
# {'name': 'Tom', 'age': 18}，名字 x 绑定到字典 {'name': 'Tom', 'age': 18}上，后面用x访问这个字典

若左边名字多于一个时，名字数量必须与右侧的可迭代对象中的元素或字符数量相同，这些名字将按从左至右的顺序被绑定到对应元素或字符，这种操作称为__同步赋值__。</font>

x, y= 1, 2    # 左侧有2个名字，右侧对象中有2个元素1和2，数量相同
print(x, y)     # 1 2，要求右侧对象中元素数量与左侧变量数量相同

1 2

x, y = {1, 2}
print(x, y)     # 1 2，要求右侧对象中元素数量与左侧变量数量相同

1 2

x, y, z = 'abc'
print(x, y, z)  # a b c，要求右侧对象中字符数量与左侧变量数量相同

a b c

x, y, z = '345'
print(x, y, z)  # x,y,z 的值分别为字符串'3', '4', '5'

3 4 5

m,n='ik'
print(m,n)

i k

利用同步赋值方法可以实现两个变量指向对象的交换：

m, n = 5, 10  # m,n = (5,10)，将5 赋值给m, 将10赋值给n
print(m, n)   # 输出 5 10
print(f'm = {m}, n = {n}')   # 输出 m = 5, n = 10

m, n = n, m   # 交换变量 m 和 n 所指向的对象
print(m, n)   # 输出 10 5
print(f'm = {m}, n = {n}')   # 输出 m = 10, n = 5

从上面输出中可以看到，同步赋值可以方便的交换两个变量的值。用f-string格式输出语义更清晰明了，推荐使用。

m, n = input().split()        # split()参数缺省时，可根据空格将输入切分为列表
# 例如输入 “100 200”，可被切分为[100,200],然后将列表中的元素分别赋值给m,n
print(m, n)                   # 输出 100，200
print(f'm = {m}, n = {n}')    # 输出 m = 5, n = 10

13 13
m = 13, n = 13

m,n = input().split(',')     # split()可根据逗号（','）将输入切分为列表
# 例如输入 “100,200”，可被切分为[100,200],然后将列表中的元素分别赋值给m,n
print(m, n)                  # 输出 100，200
print(f'm = {m}, n = {n}')   # 输出 m = 5, n = 10

练一练

# 补充你的代码

Python提供了“+=、-=、*=、/=、//=、%=、**%=”等__增强赋值语句__，在单个语句中将__二元运算__和__赋值语句__合为一体，具体描述参见下表。没有 C、C++、JAVA 中这样的表达：a=a++ 或a=++a

c = 100    # 将数字100命名为c
print(c)

c = c + 8  # 将 100 + 8 的运算结果命名为 c,c值为108
print(c)

c += 8  # 与c = c + 8相同，将 108 + 8 的运算结果命名为 c，c值为116
print(c)

100
108
116

符号	描述	实例	解释
+=	加法运算赋值符	c += a	c = c + a
-=	减法运算赋值符	c -= a	c = c - a
*=	乘法运算赋值符	c *= a	c = c * a
/=	除法运算赋值符	c /= a	c = c / a
%=	取模运算赋值符	c %= a	c = c % a
**=	幂运算赋值符	c **= a	c = c ** a
//=	整除运算赋值符	c //= a	c = c // a

Python 3.8 以后的版本增加了一个称为__赋值表达式__（也称海象运算符）的新特性，语法为：

name := expression

赋值表达式把一个表达式的值赋给一个标识符，返回表达式的值。例如，经常需要重复输入并进行处理，当输入回车时结束输入，实现代码如下：

# 下面代码作用是重复接受收入，输入非空时输出输入的字符串，输入为空时结束程序
while True:             # 构建无限循环
    user_name = input()  # 循环内重复输入用户名
    if not user_name:    # 若直接输入回车时，user_name为空字符串，值为False
        break            # 结束循环
    print(user_name)      # 输入非空字符串时输出

上述代码可用赋值表达式更简洁的实现（__解释器版本高于3.8时才可用__），代码如下：

# 下面代码作用是重复接受收入，输入非空时输出输入的字符串，输入为空时结束程序
while user_name := input():  # 输入回车时，user_name值为空字符串，表达式值为False，结束循环
    print(user_name)         # 输入不是回车时进入循环执行处理语句

a=1
a=a++

  File "/tmp/ipykernel_180/1235824716.py", line 2
    a=a++
         ^
SyntaxError: invalid syntax