网站首页> 文章专栏> 机器学习之python(2)：python的运算与变量
机器学习之python(2)：python的运算与变量
原创 时间:2025-02-20 21:23 作者:管理员 浏览量:305

在 Python 编程的领域中，变量就像是我们生活中的容器，有着不可或缺的作用。想象一下，你在厨房准备烹饪，需要用到各种食材，如面粉、鸡蛋、牛奶等。这时，碗、盆等容器就派上了用场，它们可以分别存放不同的食材，方便你在烹饪过程中随时取用和操作。在 Python 里，变量就是这样的 “容器”，它可以存储各种数据，比如数字、文本、列表等，让我们能够对这些数据进行处理和运算 。

变量在 Python 编程中扮演着举足轻重的角色。当我们需要编写一个程序来解决实际问题时，往往会涉及到各种数据。比如，编写一个计算个人所得税的程序，就需要用到工资收入、扣除项等数据。这些数据就可以存储在变量中，通过对变量的操作来完成复杂的计算逻辑。可以说，变量是程序与数据之间的桥梁，它使得程序能够灵活地处理各种数据，实现各种功能。
在 Python 中，定义变量非常简单，不需要像其他一些编程语言那样事先声明变量的类型，直接通过赋值语句就可以创建变量并赋予它一个初始值。例如，age = 25，这里就创建了一个名为age的变量，并将其赋值为 25。Python 会根据赋的值自动判断变量的类型，这种特性使得 Python 编程更加简洁和高效。
变量的类型丰富多样，常见的有整数型（int）、浮点型（float）、字符串型（str）、布尔型（bool）等。不同类型的变量适用于不同的场景。整数型变量通常用于表示数量、计数等，如班级里的学生人数；浮点型变量用于表示带有小数的数值，像商品的价格；字符串型变量用于存储文本信息，比如姓名、地址；布尔型变量则只有True和False两个值，常用于条件判断，如判断用户是否登录成功 。
在给变量命名时，也有一些规则和约定需要遵循。变量名只能由字母、数字和下划线组成，并且不能以数字开头，比如age1是合法的变量名，而1age则不合法。同时，要避免使用 Python 中的关键字作为变量名，因为关键字在 Python 中有特殊的含义，像if、for、while等。此外，为了提高代码的可读性，变量名应尽量做到见名知义，比如用student_name表示学生的名字，而不是使用含义模糊的a、b等单个字母。

一、变量的定义与赋值魔法

（一）定义的艺术

在 Python 中，变量定义的本质是在内存中开辟一块空间，用于存储数据。我们可以把变量看作是一个标签，这个标签指向内存中存储数据的位置。比如，当我们写下name = "Alice"时，就像是在内存中找了个地方存放 "Alice" 这个字符串，然后给这个存放位置贴上了name的标签 。通过name这个变量名，我们就能轻松访问到内存中存储的 "Alice"。
定义变量非常简单，使用赋值运算符 “=” 来连接变量名和值。变量名需要遵循一定的命名规则，前面已经提到，它只能由字母、数字和下划线组成，且不能以数字开头，不能是 Python 关键字。例如：
age = 20  # 定义一个整型变量age，赋值为20
height = 1.75  # 定义一个浮点型变量height，赋值为1.75
is_student = True  # 定义一个布尔型变量is_student，赋值为True

（二）赋值的奥秘

最基本的赋值方式就是将一个值赋给一个变量，如上面的例子。除此之外，Python 还支持一些特殊的赋值方式。
我们可以实现多变量赋相同值，比如x = y = z = 10，这就表示变量x、y、z都被赋值为 10 。也可以同时给多个变量赋不同的值，使用逗号分隔变量名和值，例如a, b, c = 1, 2, "hello"，这里a被赋值为 1，b被赋值为 2，c被赋值为 "hello" 。
Python 变量具有动态类型的特性，这意味着同一个变量在程序运行过程中可以随时改变其数据类型。例如：
num = 10  # num此时是整型
print(type(num))  # 输出<class 'int'>
num = "ten"  # num现在变成了字符串型
print(type(num))  # 输出<class 'str'>
这种动态类型特性使得 Python 编程更加灵活，但在编写代码时也需要更加注意变量类型的变化，以免出现类型错误。

二、变量类型大揭秘

（一）数字类型

  1. 整型：Python 中的整型（int）非常强大，它可以处理任意大小的整数，无论是小到-100，还是大到天文数字，都不在话下。这是因为 Python 内部使用了任意精度的算术，避免了像其他一些编程语言中可能出现的整数溢出问题。例如，我们可以轻松地表示一个非常大的整数：
big_number = 123456789012345678901234567890
print(big_number)
Python 还支持多种进制的整数表示法。除了常见的十进制，还可以使用二进制（以0b开头）、八进制（以0o开头）和十六进制（以0x开头）。比如：
binary_num = 0b1010  # 二进制整数，对应十进制的10
octal_num = 0o17    # 八进制整数，对应十进制的15
hex_num = 0xFF      # 十六进制整数，对应十进制的255
  1. 浮点型：浮点型（float）用于表示带有小数的数值，也就是我们常说的小数。在 Python 中，浮点数的运算遵循 IEEE 754 标准。例如：
price = 19.99
pi = 3.14159
需要注意的是，由于计算机使用二进制来存储浮点数，而一些十进制小数无法精确地用二进制表示，所以在进行浮点数运算时可能会出现精度问题。比如：
print(0.1 + 0.2)
输出结果可能并不是我们期望的0.3，而是类似0.30000000000000004这样的结果 。这并不是 Python 的缺陷，而是计算机存储和处理浮点数的方式导致的。如果需要高精度的计算，可以使用decimal模块 。例如：
from decimal import Decimal
result = Decimal('0.1') + Decimal('0.2')
print(result)  # 输出0.3
  1. 复数类型：复数在数学和工程领域中有着广泛的应用，Python 也提供了对复数类型的支持。复数由实部和虚部组成，其表示形式为a + bj，其中a是实部，b是虚部，j表示虚数单位。例如：
z = 3 + 4j
print(z)  # 输出(3+4j)
我们可以通过.real属性访问复数的实部，通过.imag属性访问复数的虚部：
print(z.real)  # 输出3.0
print(z.imag)  # 输出4.0
复数也可以进行加、减、乘、除等基本运算 。例如：
z1 = 1 + 2j
z2 = 3 + 4j
print(z1 + z2)  # 输出(4+6j)
print(z1 - z2)  # 输出(-2-2j)
print(z1 * z2)  # 输出(-5+10j)
print(z1 / z2)  # 输出(0.44+0.08j)

（二）布尔类型

布尔类型（bool）只有两个值：True和False，主要用于逻辑判断。在 Python 中，许多操作和函数的返回值都是布尔类型，它在条件判断、循环控制等方面起着关键作用。例如，在条件判断语句if中：
age = 20
if age >= 18:
    print("你已经成年了")
else:
    print("你还未成年")
这里age >= 18就是一个布尔表达式，当age的值大于等于 18 时，该表达式的值为True，会执行if后面的代码块；否则为False，执行else后面的代码块。 布尔类型还可以与逻辑运算符and（与）、or（或）、not（非）一起使用，进行更复杂的逻辑判断。例如：
is_student = True
is_graduate = False
if is_student and not is_graduate:
    print("你是一名在校学生")
在这个例子中，is_student and not is_graduate是一个复合逻辑表达式，只有当is_student为True且is_graduate为False时，整个表达式的值才为True，从而执行相应的代码块。

（三）字符串类型

  1. 定义与表示：字符串是由一系列字符组成的数据类型，在 Python 中，字符串用单引号（'）或双引号（"）括起来，两种方式没有本质区别，开发者可以根据个人习惯选择 。例如：
name1 = 'Alice'
name2 = "Bob"
字符串还支持拼接和重复操作。拼接是将多个字符串连接成一个新的字符串，使用+运算符；重复是将一个字符串重复多次，使用*运算符。例如：
greeting = "Hello, " + name1
print(greeting)  # 输出Hello, Alice
message = "Python " * 3
print(message)  # 输出Python Python Python
  1. 常用操作：Python 提供了丰富的字符串方法，方便我们对字符串进行各种操作。
  • 查找：使用find()方法可以查找子字符串在字符串中第一次出现的位置，如果找不到则返回-1。例如：
text = "I love Python, Python is amazing"
index = text.find("Python")
print(index)  # 输出7
  • 替换：replace()方法用于将字符串中的某个子字符串替换为另一个子字符串。例如：
new_text = text.replace("Python", "Java")
print(new_text)  # 输出I love Java, Java is amazing
  • 分割：split()方法可以根据指定的分隔符将字符串分割成一个列表。例如：
words = text.split(", ")
print(words)  # 输出['I love Python', 'Python is amazing']
除此之外，还有upper()（将字符串转换为大写）、lower()（将字符串转换为小写）、strip()（去除字符串两端的空白字符）等常用方法 。例如：
s = "  Hello, World!  "
print(s.upper())  # 输出HELLO, WORLD!
print(s.lower())  # 输出hello, world!
print(s.strip())  # 输出Hello, World!

（四）数据结构类型

  1. 列表：列表（list）是 Python 中最常用的数据结构之一，它是一个有序的可变序列，可以存储不同类型的元素，比如数字、字符串、甚至其他列表。列表使用方括号（[]）来表示，元素之间用逗号分隔。例如：
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]
我们可以通过索引来访问列表中的元素，索引从 0 开始。例如：
print(fruits[0])  # 输出apple
print(numbers[2])  # 输出3
还可以使用切片操作来获取列表的一部分，切片的语法是[start:stop:step]，其中start是起始索引（包含），stop是结束索引（不包含），step是步长（默认为 1）。例如：
print(fruits[1:3])  # 输出['banana', 'cherry']
print(numbers[::2])  # 输出[1, 3, 5]
列表还支持添加、修改和删除元素的操作。使用append()方法可以在列表末尾添加一个元素，使用insert()方法可以在指定位置插入一个元素，使用remove()方法可以删除指定元素，使用pop()方法可以删除指定索引位置的元素并返回该元素。例如：
fruits.append("date")
print(fruits)  # 输出['apple', 'banana', 'cherry', 'date']
fruits.insert(1, "kiwi")
print(fruits)  # 输出['apple', 'kiwi', 'banana', 'cherry', 'date']
fruits.remove("banana")
print(fruits)  # 输出['apple', 'kiwi', 'cherry', 'date']
removed_fruit = fruits.pop(2)
print(removed_fruit)  # 输出cherry
print(fruits)  # 输出['apple', 'kiwi', 'date']
  1. 元组：元组（tuple）也是一个有序的序列，与列表不同的是，元组一旦创建，其元素就不可修改，它使用圆括号（()）来表示。例如：
point = (10, 20)
names = ("Alice", "Bob", "Charlie")
元组的访问方式与列表类似，也是通过索引和切片。例如：
print(point[0])  # 输出10
print(names[1:])  # 输出('Bob', 'Charlie')
由于元组的不可变性，它在一些场景下比列表更适用，比如当我们需要存储一些固定的数据，不希望在程序运行过程中被意外修改时，就可以使用元组。元组的不可变特性也使得它在作为字典的键时很有用，因为字典的键必须是不可变的。 虽然元组本身不可变，但如果元组中包含可变对象（如列表），那么可变对象的内容是可以被修改的。例如：
mixed_tuple = (1, [2, 3], 4)
mixed_tuple[1][0] = 20
print(mixed_tuple)  # 输出(1, [20, 3], 4)
  1. 字典：字典（dict）是一种无序的键值对集合，也被称为关联数组或哈希表。字典中的每个元素由一个键（key）和一个值（value）组成，键必须是唯一且不可变的，通常使用字符串、数字或元组作为键，值可以是任意类型的数据。字典使用花括号（{}）来表示，键值对之间用冒号（:）分隔，不同键值对之间用逗号分隔。例如：
student = {"name": "Alice", "age": 20, "major": "Computer Science"}
我们可以通过键来访问字典中的值。例如：
print(student["name"])  # 输出Alice
print(student["age"])  # 输出20
如果访问一个不存在的键，会引发KeyError异常。为了避免这种情况，可以使用get()方法，它在键不存在时返回None或指定的默认值。例如：
print(student.get("gender"))  # 输出None
print(student.get("gender", "Unknown"))  # 输出Unknown
字典也支持添加、修改和删除键值对的操作。当我们给一个不存在的键赋值时，就会在字典中添加一个新的键值对；给一个已存在的键赋值时，会修改其对应的值。使用del语句可以删除指定的键值对。例如：
student["phone"] = "123-456-7890"  # 添加新键值对
print(student)  # 输出{'name': 'Alice', 'age': 20,'major': 'Computer Science', 'phone': '123-456-7890'}
student["age"] = 21  # 修改值
print(student)  # 输出{'name': 'Alice', 'age': 21,'major': 'Computer Science', 'phone': '123-456-7890'}
del student["phone"]  # 删除键值对
print(student)  # 输出{'name': 'Alice', 'age': 21,'major': 'Computer Science'}
字典还提供了一些有用的方法，如keys()方法返回字典中所有的键，values()方法返回字典中所有的值，items()方法返回字典中所有的键值对（以元组形式）。例如：
print(student.keys())  # 输出dict_keys(['name', 'age','major'])
print(student.values())  # 输出dict_values(['Alice', 21, 'Computer Science'])
print(student.items())  # 输出dict_items([('name', 'Alice'), ('age', 21), ('major', 'Computer Science')])

三、变量命名的规则与技巧

（一）硬性规则

变量名由字母、数字和下划线构成，数字不能开头，这是 Python 变量命名的基本要求。例如，user_name、age_20、_count等都是合法的变量名，而2user、name@123则是不合法的。变量名区分大小写，Student和student是两个不同的变量，在编程时一定要注意大小写的一致性，否则可能会导致程序出现意想不到的错误。
同时，要避免使用 Python 的关键字和系统保留字作为变量名。关键字是 Python 语言中具有特殊含义的标识符，比如if用于条件判断，for用于循环遍历，def用于定义函数等 。如果使用关键字作为变量名，会导致语法错误，例如if = 10是不合法的，因为if是关键字 。常见的关键字还有while、import、class等，在命名变量时需要牢记这些关键字，避免冲突。

（二）PEP 8 规范

Python 社区广泛遵循的 PEP 8 风格指南对变量命名也有明确的规范。变量名应该用小写字母拼写，多个单词之间用下划线连接，这种命名方式也被称为 “蛇形命名法”。例如，student_age、total_price、is_valid等。这种命名方式使得变量名清晰易读，能够准确地表达变量的含义 。
对于类中受保护的实例属性，应该以一个下划线开头，比如_protected_variable。这是一种约定俗成的方式，用来表示该属性虽然可以在类外部访问，但不建议直接访问，它主要是为了类内部的使用和子类的继承。例如，在一个Person类中，可能有一个_age属性，外部代码可以访问它，但最好通过类提供的方法来间接操作，以保证数据的一致性和安全性 。
私有的实例属性则用两个下划线开头，比如__private_variable。Python 会对这种命名进行 “名称改写”，将其转换为_类名__private_variable的形式，这使得在类外部直接访问私有属性变得困难，从而达到一定的封装效果 。例如，在一个Secret类中，有一个__secret_message私有属性，在类外部不能直接通过__secret_message来访问，需要通过类内部定义的方法来操作这个属性 。

（三）命名建议

变量命名应遵循见名知意的原则，一个好的变量名能够让代码阅读者一眼就明白变量的用途和含义。比如，使用student_name来表示学生的姓名，product_price来表示产品的价格，这样的命名清晰明了，有助于提高代码的可读性和可维护性 。
对比不好的命名，如用a、b等单个字母作为变量名，在复杂的代码逻辑中，很难让人理解它们代表的是什么。如果在一个计算商品总价的函数中，使用a表示商品数量，b表示商品单价，那么阅读代码的人很难快速理解代码的意图 。而使用quantity和unit_price这样有意义的变量名，代码的逻辑就一目了然。
在变量命名时，还应避免使用中文和拼音命名。使用中文命名可能会导致编码问题，而且在不同的开发环境中可能会出现显示异常。拼音命名则会降低代码的可读性，尤其是对于非中文母语的开发者来说，理解起来会非常困难 。例如，用nianling表示年龄，不如直接用age直观易懂。

四、Python 运算的魔法世界

（一）算术运算

Python 中的算术运算符用于执行基本的数学运算，包括加（+）、减（-）、乘（*）、除（/）、取余（%）、幂运算（**）和整除（//）。
加、减、乘运算符的使用非常直观，就像我们在数学中使用的一样。例如：
a = 5
b = 3
print(a + b)  # 输出8
print(a - b)  # 输出2
print(a * b)  # 输出15
除法运算/的结果总是浮点数，即使结果是整数也会保留小数部分。例如：
print(4 / 2)  # 输出2.0
取余运算符%用于计算两个数相除的余数，例如：
print(7 % 3)  # 输出1
幂运算**用于计算一个数的指定次幂，例如：
print(2 ** 3)  # 输出8，即2的3次方
整除运算符//用于计算两个数相除的商，结果向下取整为整数。例如：
print(7 // 3)  # 输出2
算术运算符的优先级与数学中的运算优先级类似，先乘除后加减，有括号时先计算括号内的表达式。例如：
print(2 + 3 * 4)  # 先计算3 * 4，再加上2，输出14
print((2 + 3) * 4)  # 先计算括号内的2 + 3，再乘以4，输出20
在复杂的算术运算中，合理使用括号可以明确运算顺序，避免出现错误。例如：
result = (1 + 2) * (3 - 4) / (5 ** 2) + 6 // 2
print(result)  # 输出1.88，按照运算符优先级和括号顺序进行计算

（二）赋值运算

赋值运算符用于将一个值赋给一个变量。最基本的赋值运算符是 “=”，例如：
x = 10
这表示将 10 赋给变量x。
除了基本赋值运算符，Python 还提供了复合赋值运算符，它们是赋值运算符与其他运算符的结合，用于简化对变量的操作。常见的复合赋值运算符有+=、-=、*=、/=、%=、**=、//=等。
以+=为例，a += b 等价于 a = a + b ，它将变量a与b相加的结果再赋给a 。例如：
a = 5
a += 3  # 等价于a = a + 3
print(a)  # 输出8
同样，*=用于乘法赋值，a *= b 等价于 a = a * b 。例如：
a = 4
a *= 2  # 等价于a = a * 2
print(a)  # 输出8
复合赋值运算符的简写原理就是将运算符左边的变量与右边的值进行相应的运算，然后将结果重新赋给左边的变量。这种简写方式不仅使代码更加简洁，还能提高代码的执行效率，在实际编程中经常使用。例如，在循环中进行累加操作时，使用+=就非常方便：
sum_num = 0
for i in range(1, 11):
    sum_num += i  # 等价于sum_num = sum_num + i
print(sum_num)  # 输出55，计算1到10的累加和

（三）比较运算

比较运算符用于比较两个值的大小或是否相等，其返回值为布尔类型（True或False）。常见的比较运算符有等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）、小于等于（<=）。
等于运算符==用于判断两个值是否相等，例如：
a = 5
b = 5
print(a == b)  # 输出True
不等于运算符!=则判断两个值是否不相等，例如：
a = 5
b = 3
print(a!= b)  # 输出True
大于、小于、大于等于、小于等于运算符用于比较两个值的大小关系。例如：
a = 5
b = 3
print(a > b)  # 输出True
print(a < b)  # 输出False
print(a >= b)  # 输出True
print(a <= b)  # 输出False
在条件判断语句中，比较运算符起着关键作用。例如，我们可以使用比较运算符来判断一个数是否大于 10：
num = 15
if num > 10:
    print("这个数大于10")
else:
    print("这个数不大于10")
在这个例子中，num > 10是一个比较表达式，其结果为True，所以会执行if后面的代码块，输出 “这个数大于 10”。比较运算符还可以用于字符串的比较，比较时会按照字符的 ASCII 码值从左到右依次进行比较。例如：
str1 = "apple"
str2 = "banana"
print(str1 < str2)  # 输出True，因为'a'的ASCII码值小于'b'

（四）逻辑运算

逻辑运算符用于对布尔值进行操作，以实现更复杂的逻辑判断。Python 中的逻辑运算符有与（and）、或（or）、非（not）。
and运算符表示 “与” 关系，只有当两个条件都为True时，整个表达式才为True，否则为False。例如：
a = 5
b = 3
if a > 0 and b > 0:
    print("a和b都大于0")
在这个例子中，a > 0和b > 0都为True，所以a > 0 and b > 0的结果为True，会执行if后面的代码块。
or运算符表示 “或” 关系，只要两个条件中有一个为True，整个表达式就为True，只有当两个条件都为False时，表达式才为False。例如：
a = 5
b = -3
if a > 0 or b > 0:
    print("a或b大于0")
这里a > 0为True，虽然b > 0为False，但根据or的运算规则，a > 0 or b > 0的结果为True，会执行if后面的代码块。
not运算符表示 “非” 关系，用于对一个条件取反。如果条件为True，not该条件则为False；反之，如果条件为False，not该条件则为True。例如：
a = 5
if not a < 0:
    print("a不小于0")
因为a < 0为False，not a < 0就为True，所以会执行if后面的代码块。
在复杂的逻辑判断中，逻辑运算符可以组合使用。例如，判断一个数是否在 10 到 20 之间（包括 10 和 20），可以这样写：
num = 15
if num >= 10 and num <= 20:
    print("num在10到20之间")
再比如，判断一个人是否是学生或者有身份证可以进入某个场所：
is_student = False
has_id_card = True
if is_student or has_id_card:
    print("可以进入")
通过逻辑运算符，我们能够构建出各种复杂的逻辑条件，使程序能够根据不同的情况做出相应的决策 。

（五）位运算

位运算直接对整数在内存中的二进制位进行操作。Python 中的位运算符有按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）、右移（>>）。
按位与运算符&将两个数的二进制位进行与操作，只有当对应位都为 1 时，结果位才为 1，否则为 0。例如：
a = 5  # 二进制为101
b = 3  # 二进制为011
print(a & b)  # 输出1，二进制为001
按位或运算符|将两个数的二进制位进行或操作，只要对应位中有一个为 1，结果位就为 1。例如：
print(a | b)  # 输出7，二进制为111
按位异或运算符^将两个数的二进制位进行异或操作，当对应位不同时，结果位为 1，相同时为 0。例如：
print(a ^ b)  # 输出6，二进制为110
按位取反运算符~对一个数的二进制位进行取反操作，0 变为 1，1 变为 0。需要注意的是，在 Python 中，整数是以补码形式存储的，所以按位取反的结果需要考虑补码的转换。例如：
a = 5  # 二进制为00000101
print(~a)  # 输出-6，因为对00000101取反后得到11111010，这是-6的补码
左移运算符<<将一个数的二进制位向左移动指定的位数，右边空出的位用 0 填充，相当于乘以 2 的指定次幂。例如：
a = 5  # 二进制为101
print(a << 1)  # 输出10，二进制为1010，相当于5 * 2
右移运算符>>将一个数的二进制位向右移动指定的位数，左边空出的位用符号位填充（正数用 0，负数用 1），相当于整除 2 的指定次幂。例如：
a = 5  # 二进制为101
print(a >> 1)  # 输出2，二进制为10，相当于5 // 2
位运算在一些特定的场景中非常有用，比如图像处理、加密算法等。虽然在日常编程中使用频率相对较低，但了解位运算可以让我们更好地理解计算机底层的工作原理，在需要优化性能或处理二进制数据时，能够运用位运算来实现高效的算法 。例如，通过位运算可以快速判断一个数是否为偶数：
num = 6
if num & 1 == 0:
    print(f"{num}是偶数")
else:
    print(f"{num}是奇数")
这里利用了按位与运算，因为偶数的二进制最低位为 0，与 1 进行按位与运算结果为 0；奇数的二进制最低位为 1，与 1 进行按位与运算结果为 1 。

（六）成员运算与身份运算

成员运算符用于判断一个值是否为某个序列（如列表、元组、字符串、字典等）的成员，Python 中的成员运算符有in和not in。
in用于检查一个值是否在序列中，如果在则返回True，否则返回False。例如：
fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)  # 输出True
print("orange" in fruits)  # 输出False
not in则是in的相反操作，用于检查一个值是否不在序列中。例如：
print("orange" not in fruits)  # 输出True
身份运算符用于比较两个对象的内存地址，判断它们是否为同一个对象，Python 中的身份运算符有is和is not。
is用于判断两个对象是否是同一个对象，如果是则返回True，否则返回False。例如：
a = [1, 2, 3]
b = a
print(a is b)  # 输出True，因为a和b指向同一个列表对象
is not则是is的相反操作，用于判断两个对象是否不是同一个对象。例如：
c = [1, 2, 3]
print(a is not c)  # 输出True，虽然a和c的值相同，但它们是不同的列表对象，内存地址不同
需要注意的是，is和==是不同的。is比较的是对象的身份（内存地址），而==比较的是对象的值。例如：
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # 输出True，因为a和b的值相同
print(a is b)  # 输出False，因为a和b是不同的列表对象，内存地址不同
在实际编程中，根据具体的需求选择合适的运算符。如果需要判断两个对象的值是否相等，使用==；如果需要判断两个对象是否为同一个对象，使用is 。成员运算和身份运算在数据处理和逻辑判断中经常用到，能够帮助我们更准确地处理各种数据和对象之间的关系 。

五、运算与变量的实战演练

（一）简单数学计算

以计算圆的面积和周长为例，让我们来看看变量定义、数据类型转换和算术运算的综合应用。圆的面积公式为\(S = \pi r^2\)，周长公式为\(C = 2\pi r\)，其中\(r\)是圆的半径，\(\pi\)是圆周率，通常取 3.14 。在 Python 中，我们可以这样实现：
import math
# 获取用户输入的半径，input()函数返回的是字符串类型，需要转换为浮点数
radius_str = input("请输入圆的半径：")
radius = float(radius_str)
# 计算圆的面积和周长
area = math.pi * radius ** 2
circumference = 2 * math.pi * radius
print(f"圆的半径为{radius}，面积为{area:.2f}，周长为{circumference:.2f}")
在这段代码中，首先使用input()函数获取用户输入的半径，由于input()函数返回的是字符串类型，为了进行后续的数学运算，需要使用float()函数将其转换为浮点数类型，并存储在变量radius中 。接着，利用算术运算中的乘方（**）和乘法（*）运算符，结合math.pi（Python 中math模块提供的圆周率）来计算圆的面积和周长 。最后，使用print()函数输出结果，其中{:.2f}是格式化字符串，用于将浮点数保留两位小数输出 。通过这个例子，我们可以清晰地看到变量在存储数据、数据类型转换在适应运算需求以及算术运算在实现数学计算中的紧密配合 。

（二）数据处理与分析

以统计学生成绩为例，展示列表、字典等数据结构类型的使用，以及运算在数据处理中的应用。假设我们有一个班级学生的成绩数据，需要统计每个学生的总分、平均分，以及班级的最高分、最低分和平均分。我们可以使用列表来存储每个学生的成绩，使用字典来存储学生的姓名和对应的成绩列表。以下是实现代码：
# 定义学生成绩数据，字典的键为学生姓名，值为成绩列表
students_scores = {
    "Alice": [85, 90, 78],
    "Bob": [92, 88, 95],
    "Charlie": [76, 85, 80]
}
# 遍历每个学生的成绩，计算总分和平均分
for student, scores in students_scores.items():
    total_score = sum(scores)  # 使用sum()函数计算总分
    average_score = total_score / len(scores)  # 计算平均分
    students_scores[student].append(total_score)  # 将总分添加到成绩列表末尾
    students_scores[student].append(average_score)  # 将平均分添加到成绩列表末尾
# 提取所有学生的成绩，用于计算班级最高分、最低分和平均分
all_scores = []
for scores in students_scores.values():
    all_scores.extend(scores[:-2])  # 排除每个学生成绩列表中的总分和平均分
# 计算班级最高分、最低分和平均分
highest_score = max(all_scores)  # 使用max()函数计算最高分
lowest_score = min(all_scores)  # 使用min()函数计算最低分
class_average = sum(all_scores) / len(all_scores)  # 计算班级平均分
# 输出结果
for student, scores in students_scores.items():
    print(f"{student}的成绩为：{scores[:-2]}，总分：{scores[-2]}，平均分：{scores[-1]:.2f}")
print(f"班级最高分：{highest_score}")
print(f"班级最低分：{lowest_score}")
print(f"班级平均分：{class_average:.2f}")
在这段代码中，首先定义了一个字典students_scores，用于存储学生姓名和对应的成绩列表 。通过for循环遍历字典的键值对，使用sum()函数计算每个学生的总分，再除以成绩数量得到平均分 。然后将总分和平均分添加到每个学生的成绩列表中 。为了计算班级的最高分、最低分和平均分，先创建一个空列表all_scores，通过遍历students_scores字典的值（即每个学生的成绩列表），使用extend()方法将每个学生的成绩（排除总分和平均分）添加到all_scores列表中 。接着，使用max()、min()和sum()函数分别计算班级的最高分、最低分和平均分 。最后，通过循环遍历输出每个学生的成绩、总分和平均分，以及班级的最高分、最低分和平均分 。这个例子充分展示了列表和字典在数据存储和组织方面的优势，以及各种运算在数据处理和分析中的重要作用 。

（三）条件判断与逻辑控制

以判断用户输入的年份是否为闰年为例，展示比较运算、逻辑运算和条件判断语句的结合使用。闰年的判断规则是：能被 4 整除但不能被 100 整除的年份为闰年，此外能被 400 整除的年份也是闰年 。以下是 Python 实现代码：
# 获取用户输入的年份，input()函数返回的是字符串类型，需要转换为整数
year_str = input("请输入一个年份：")
year = int(year_str)
# 判断是否为闰年
if (year % 4 == 0 and year % 100!= 0) or year % 400 == 0:
    print(f"{year}是闰年")
else:
    print(f"{year}不是闰年")
在这段代码中，首先使用input()函数获取用户输入的年份，并通过int()函数将其转换为整数类型，存储在变量year中 。然后使用比较运算符（%、==、!=）和逻辑运算符（and、or）构建判断闰年的条件表达式 。如果条件表达式(year % 4 == 0 and year % 100!= 0) or year % 400 == 0为True，则说明该年份是闰年，使用print()函数输出相应信息；否则，说明该年份不是闰年，输出对应的提示 。这个例子很好地体现了比较运算用于比较数值关系、逻辑运算用于组合条件以及条件判断语句根据条件执行不同代码块的协同工作过程 。
动动小手 !!!
来说两句吧
最新评论