python基础---1.变量、运算符和表达式、基本数据结构

🎈个人主页：靓仔很忙i
💻B 站主页：👉B站👈
🎉欢迎 👍点赞✍评论⭐收藏
🤗收录专栏：python
🤝希望本文对您有所裨益，如有不足之处，欢迎在评论区提出指正，让我们共同学习、交流进步！

---

一 变量

定义变量

在Python中，定义变量非常简单，只需要使用等号(=)进行赋值操作即可。Python是一种动态类型语言，因此你不需要显式声明变量的类型，Python会根据你赋予变量的值来推断其类型。以下是一些定义变量的示例：

# 定义整数变量
age = 25

# 定义浮点数变量
temperature = 98.6

# 定义字符串变量
name = "Alice"

# 定义布尔变量
is_student = True

# 定义列表变量
numbers = [1, 2, 3, 4, 5]

# 定义字典变量
person = {'name': 'Bob', 'age': 30}

# 定义空变量
empty_variable = None

在上面的例子中，每个变量名（例如age、temperature、name等）都被赋予了一个值，并且Python会自动确定每个变量的数据类型。

关键字

Python中的关键字是一些具有特殊用途的保留字，这些关键字用于识别语法结构和控制程序流程。关键字不能用作变量名或标识符。以下是Python的关键字列表（截至Python 3.9）：

False      await      else       import     pass
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield

命名规则

变量名：通常使用小写字母，单词之间可以用下划线分隔（例如：my_variable）或者使用驼峰命名法（例如：myVariable）。
函数名：通常使用小写字母，单词之间用下划线分隔（例如：calculate_sum）。
类名：通常使用驼峰命名法，即每个单词的首字母大写，单词之间没有下划线（例如：MyClass）。
常量：通常使用全大写字母，单词之间用下划线分隔（例如：MAX_SIZE）。

# 变量名示例
age = 30
first_name = "John"

# 函数名示例
def calculate_sum(a, b):
    return a + b

# 类名示例
class MyClass:
    def __init__(self):
        self.my_attribute = 0

# 常量示例
MAX_SIZE = 1000

基本数据类型

在Python中，有几种基本的数据类型，每种类型具有特定的特征和用途。以下是Python中常见的基本数据类型：

1. 整数（int）：
   表示整数值，例如：-5, 0, 100.
2. 浮点数（float）：
   表示带有小数部分的数值，例如：3.14, 2.718.
3. 布尔值（bool）：
   表示逻辑上的真或假，只有两个取值：True 和 False.
4. 字符串（str）：
   表示文本数据，用单引号 ’ 或双引号 " 括起来，例如：“Hello, World!”.
5. 列表（list）：
   表示一组有序的元素，可以是不同类型的数据，用方括号 [] 表示，例如：[1, 2, 3, 4].
6. 元组（tuple）：
   类似于列表，但是元组是不可变的（immutable），用圆括号 () 表示，例如：(1, ‘two’, 3.0).
7. 集合（set）：
   表示一组独特的元素（即没有重复项），用大括号 {} 表示，例如：{1, 2, 3}.
8. 字典（dict）：
   表示键值对的集合，用大括号 {} 表示，每个键值对用冒号 : 分隔，例如：{‘name’: ‘Alice’, ‘age’: 30}.
9. NoneType：
   表示一个特殊的空值或者空对象，只有一个值 None。

类型转换

在Python中，类型转换（type conversion）是将一个数据类型的值转换为另一个数据类型的过程。Python提供了几个内置函数来执行类型转换，这些函数可以帮助在不同数据类型之间进行转换，例如：

1. 整数转换（int）：
   将其他数据类型转换为整数类型。
   使用 int() 函数进行转换，例如：int(3.14) 将返回整数 3.
2. 浮点数转换（float）：
   将其他数据类型转换为浮点数类型。
   使用 float() 函数进行转换，例如：float(5) 将返回浮点数 5.0.
3. 字符串转换（str）：
   将其他数据类型转换为字符串类型。
   使用 str() 函数进行转换，例如：str(123) 将返回字符串 ‘123’.
4. 布尔值转换（bool）：
   将其他数据类型转换为布尔值类型。
   使用 bool() 函数进行转换，空值或者值为零的情况会返回 False，其他情况会返回 True，例如：bool(0) 将返回 False，而 bool(1) 将返回 True.
5. 列表、元组、集合、字典的互相转换：
   可以使用 list(), tuple(), set(), dict() 函数将这些数据类型相互转换。
6. 显式转换：
   在某些情况下，可以通过直接赋值或者运算符实现显式类型转换，例如：
   x = 10.5 # 将浮点数赋值给变量 x
   y = int(5.7) # 将浮点数转换为整数并赋值给变量 y
   z = float(“3.14”) # 将字符串转换为浮点数并赋值给变量 z
   在进行类型转换时，需要注意可能会出现的精度损失或者数据丢失的问题，特别是在数值类型之间的转换时。

二 运算符和表达式

算术运算符（Arithmetic Operators）

这些运算符用于执行基本的数学运算：

• +：加法，例如 2 + 3 结果为 5.
• -：减法，例如 5 - 2 结果为 3.
• *：乘法，例如 4 * 3 结果为 12.
• /：除法，返回浮点数结果，例如 7 / 2 结果为 3.5.
• //：整数除法，返回商的整数部分，例如 7 // 2 结果为 3.
• %：取模运算，返回除法的余数，例如 7 % 2 结果为 1.
• **：幂运算，例如 2 ** 3 结果为 8（表示2的3次方）.

比较运算符（Comparison Operators）

这些运算符用于比较两个值：

• ==：等于，例如 3 == 3 结果为 True.
• !=：不等于，例如 4 != 3 结果为 True.
• >：大于，例如 5 > 2 结果为 True.
• <：小于，例如 2 < 5 结果为 True.
• >=：大于等于，例如 5 >= 5 结果为 True.
• <=：小于等于，例如 2 <= 5 结果为 True.

逻辑运算符（Logical Operators）

这些运算符用于组合表达式的逻辑值：

• and：逻辑与，如果两个操作数都为 True，则结果为 True.
• or：逻辑或，如果两个操作数中有一个为 True，则结果为 True.
• not：逻辑非，用于反转操作数的逻辑值，not True 结果为 False, not False 结果为 True.

赋值运算符（Assignment Operators）

这些运算符用于将值分配给变量：

• =：赋值运算符，将右边的值赋给左边的变量，例如 x = 5.
• +=, -=, *=, /=：复合赋值运算符，例如 x += 3 相当于 x = x + 3.

成员运算符（Membership Operators）

这些运算符用于检查值是否存在于序列中：

• in：如果在序列中找到指定的值，则返回 True.
• not in：如果在序列中没有找到指定的值，则返回 True.

身份运算符（Identity Operators）

这些运算符用于比较对象的内存地址：

• is：如果两个变量引用同一个对象，则返回 True.
• is not：如果两个变量引用不同的对象，则返回 True.

位运算符（Bitwise Operators）

这些运算符用于对整数的二进制位进行操作：

• &：按位与
• |：按位或
• ^：按位异或
• ~：按位取反
• <<：左移位
• >>：右移位

表达式

表达式是由运算符和操作数组成的组合，可以计算出一个值。例如：

x = 5
y = 3
result = x + y  # 这是一个表达式，计算结果为 8

在Python中，使用运算符和表达式可以进行各种数学运算、逻辑判断、赋值操作等，是编写程序时不可或缺的基本元素。

三 基本数据结构

字符串

在Python中，字符串是一种非常重要和常用的数据类型，用于表示文本数据。字符串是不可变的（immutable），这意味着一旦创建，它们不能被修改。以下是关于Python字符串的一些重要特性和常用操作：

创建字符串

在Python中，可以使用单引号 ’ ’ 或双引号 " " 来创建字符串。例如：

message = "Hello, World!"

访问字符串中的字符

可以通过索引访问字符串中的单个字符，索引从0开始，可以使用负数索引从末尾开始计数。例如：

message = "Hello"
print(message[0])  # 输出 'H'
print(message[-1])  # 输出 'o'

字符串切片

除了单个字符外，还可以使用切片（slice）来访问字符串的子串。切片可以提取字符串的一部分。语法为 string[start:end :step]，其中 start 是起始索引（包含），end 是结束索引（不包含），step 是步长（可选，默认为1）。例如：

message = "Hello, World!"
print(message[0:5])  # 输出 'Hello'
print(message[7:])   # 输出 'World!'
print(message[:5])   # 输出 'Hello'
print(message[::2])  # 输出 'Hlo ol!'

字符串长度

可以使用内置函数 len() 获取字符串的长度（即包含的字符数）。例如：

message = "Hello, World!"
print(len(message))  # 输出 13

字符串拼接

可以使用 + 运算符将两个字符串拼接在一起。例如：

greeting = "Hello"
name = "Alice"
message = greeting + ", " + name + "!"
print(message)  # 输出 'Hello, Alice!'

字符串方法

Python提供了丰富的字符串方法（methods），用于执行各种操作，例如：

• lower()：将字符串转换为小写。
• upper()：将字符串转换为大写。
• strip()：去除字符串两端的空白字符。
• split()：将字符串分割成列表。
• join()：将列表中的字符串连接成一个字符串。

text = "   Hello, World!   "
print(text.strip())           # 输出 'Hello, World!'
print(text.lower())           # 输出 '   hello, world!   '
print(text.upper())           # 输出 '   HELLO, WORLD!   '
print(text.split(','))        # 输出 ['   Hello', ' World!   ']

格式化字符串

Python支持多种字符串格式化方式，包括使用 % 格式化符号和 .format() 方法，以及更现代的 f-string 方法（Python 3.6+）。例如

name = "Alice"
age = 30

# 使用百分号格式化
message = "My name is %s and I am %d years old." % (name, age)

# 使用 .format() 方法
message = "My name is {} and I am {} years old.".format(name, age)

# 使用 f-string 方法（推荐）
message = f"My name is {name} and I am {age} years old."

字符串在Python中是非常灵活和强大的数据类型，可以进行各种操作，包括索引、切片、拼接、格式化等，是编写和处理文本数据的基础。

列表

在Python中，列表（List）是一种非常常用和灵活的数据结构，用于存储一组有序的元素。列表是可变的（mutable），这意味着可以动态地添加、删除和修改其中的元素。以下是关于Python列表的一些重要特性和常用操作：

创建列表

可以使用方括号 [] 来创建列表，并在其中放置逗号分隔的元素。例如：

numbers = [1, 2, 3, 4, 5]
fruits = ["apple", "banana", "cherry"]
mixed_list = [1, "hello", True, 3.14]
empty_list = []

访问列表中的元素

可以使用索引访问列表中的单个元素，索引从0开始，可以使用负数索引从末尾开始计数。例如：

numbers = [1, 2, 3, 4, 5]
print(numbers[0])    # 输出 1
print(numbers[-1])   # 输出 5

列表切片

除了单个元素外，还可以使用切片（slice）来访问列表的子列表。切片可以提取列表的一部分。语法为 list[start:end :step]，其中 start 是起始索引（包含），end 是结束索引（不包含），step 是步长（可选，默认为1）。例如：

numbers = [1, 2, 3, 4, 5]
print(numbers[1:4])   # 输出 [2, 3, 4]
print(numbers[:3])    # 输出 [1, 2, 3]
print(numbers[2:])    # 输出 [3, 4, 5]
print(numbers[::2])   # 输出 [1, 3, 5]

修改列表元素

列表是可变的数据结构，可以通过索引直接修改其中的元素。例如：

fruits = ["apple", "banana", "cherry"]
fruits[1] = "orange"
print(fruits)   # 输出 ["apple", "orange", "cherry"]

添加和删除元素

可以使用以下方法修改列表的大小和内容：

• append()：在列表末尾添加一个元素。
• insert()：在指定位置插入一个元素。
• extend() 或 + 运算符：将另一个列表的所有元素添加到当前列表。
• remove()：删除指定值的第一个匹配项。
• pop()：移除指定位置的元素并返回该元素。
• del 关键字：删除指定位置的元素。

fruits = ["apple", "banana", "cherry"]
fruits.append("orange")       # ["apple", "banana", "cherry", "orange"]
fruits.insert(1, "grape")     # ["apple", "grape", "banana", "cherry", "orange"]
fruits.extend(["melon", "peach"])  # ["apple", "grape", "banana", "cherry", "orange", "melon", "peach"]
fruits.remove("banana")       # ["apple", "grape", "cherry", "orange", "melon", "peach"]
popped = fruits.pop(2)        # popped = "cherry", fruits = ["apple", "grape", "orange", "melon", "peach"]
del fruits[0]                 # ["grape", "orange", "melon", "peach"]

列表方法

Python提供了许多内置方法用于操作列表，例如：

• sort()：对列表进行排序。
• reverse()：反转列表中的元素顺序。
• index()：返回指定值的第一个索引。
• count()：返回指定值的出现次数。

numbers = [5, 2, 8, 1, 3]
numbers.sort()           # [1, 2, 3, 5, 8]
numbers.reverse()        # [8, 5, 3, 2, 1]
index = numbers.index(3)  # index = 2
count = numbers.count(5)  # count = 1

复制列表

要复制列表，可以使用切片或者 copy() 方法，以避免原始列表和复制列表之间的关联：

original = [1, 2, 3]
copy1 = original[:]      # 使用切片复制
copy2 = original.copy()  # 使用 copy() 方法复制

列表的嵌套

列表可以包含其他列表，形成嵌套结构：

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[1][1])  # 输出 5

列表在Python中是非常灵活和强大的数据结构，可以用来存储和操作任意数量和类型的元素，是编程中常用的基础数据结构之一。

元组

在Python中，元组（Tuple）与列表类似，也是一种有序的集合数据类型，但与列表不同的是，元组是不可变的（immutable）。这意味着一旦创建，元组的内容不可修改，包括添加、删除或修改元素。

创建元组

元组可以使用圆括号 () 来创建，其中包含逗号分隔的元素。例如：

my_tuple = (1, 2, 3, 4, 5)

如果元组只包含一个元素，则需要在元素后面加上逗号 ,，以区分它与表达式中的括号。例如：

single_element_tuple = (42,)

访问元组中的元素

可以使用索引访问元组中的单个元素，索引同样从0开始，也支持负数索引。例如：

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0])    # 输出 1
print(my_tuple[-1])   # 输出 5

元组切片

与列表类似，元组也支持切片操作，用于获取元组的子集。切片语法为 tuple[start🔚step]。例如：

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[1:4])   # 输出 (2, 3, 4)
print(my_tuple[:3])    # 输出 (1, 2, 3)
print(my_tuple[::2])   # 输出 (1, 3, 5)

元组的不可变性

由于元组是不可变的，因此不能对元组进行修改，包括添加、删除或修改元素的操作。尝试修改元组的操作会导致 TypeError 错误。例如：

my_tuple = (1, 2, 3)
my_tuple[1] = 5  # TypeError: 'tuple' object does not support item assignment

元组的优点

• 不可变性：适合存储那些不希望被修改的数据，例如函数返回多个值时。
• 性能：由于元组不可变，其操作速度通常比列表稍快。

元组的应用场景

• 函数返回值：函数可以返回多个值的元组，然后通过解构或索引来获取这些值。
• 数据保护：当程序中的数据不应该被修改时，使用元组可以提供额外的保护。

解构元组（Tuple Unpacking）

可以将元组的元素解构到多个变量中，例如：

my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a)   # 输出 1
print(b)   # 输出 2
print(c)   # 输出 3

比较元组

可以使用比较运算符对元组进行比较，Python会按照元素的顺序逐个比较，直到找到不同的元素或者比较完所有元素为止。例如：

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
print(tuple1 == tuple2)   # 输出 False
print(tuple1 < tuple2)    # 输出 True

元组特别适合用于表示和操作不需要变化的数据集合。

集合

在Python中，集合（Set）是一种无序且元素唯一的集合数据类型。集合是通过大括号 {} 来创建的，其中包含逗号分隔的元素。集合中的元素不能重复，且集合是无序的，因此不能通过索引访问集合中的元素。

创建集合

可以使用大括号 {} 或者 set() 函数来创建集合。例如：

my_set = {1, 2, 3, 4, 5}

如果要创建空集合，必须使用 set() 函数，因为 {} 创建的是空字典。例如：

empty_set = set()

添加和删除元素

可以使用以下方法来修改集合的内容：

• add()：向集合中添加单个元素。
• update()：向集合中添加多个元素。
• remove()：从集合中移除指定的元素，如果元素不存在，则抛出 KeyError 错误。
• discard()：从集合中移除指定的元素，如果元素不存在，则不执行任何操作。
• pop()：随机删除并返回集合中的一个元素。

my_set = {1, 2, 3}
my_set.add(4)         # {1, 2, 3, 4}
my_set.update([5, 6]) # {1, 2, 3, 4, 5, 6}
my_set.remove(3)      # {1, 2, 4, 5, 6}
my_set.discard(2)     # {1, 4, 5, 6}
popped = my_set.pop() # popped 可能是 1, 4, 5, 或者 6，因为集合是无序的

访问集合元素

由于集合是无序的，不能通过索引来访问集合中的元素。可以使用循环或者 in 关键字来检查元素是否存在于集合中。例如：

my_set = {1, 2, 3, 4, 5}
for element in my_set:
    print(element)

if 3 in my_set:
    print("3 is in the set")

集合的运算

Python支持集合之间的多种运算，包括交集、并集、差集和对称差集等。例如：

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1 | set2         # 并集 {1, 2, 3, 4, 5}
intersection_set = set1 & set2  # 交集 {3}
difference_set = set1 - set2    # 差集 {1, 2}
symmetric_difference_set = set1 ^ set2  # 对称差集 {1, 2, 4, 5}

不可变集合

Python还提供了一种叫做不可变集合（frozenset）的类型，它是一种不可变的集合，一旦创建后就不能修改。不可变集合可以作为字典的键或者其他集合的元素使用。创建不可变集合使用 frozenset() 函数。例如：

my_frozenset = frozenset([1, 2, 3])

集合特别适合存储唯一值且不关心元素顺序的场景。

字典

在Python中，字典（Dictionary）是一种非常有用的数据结构，用于存储键-值对（key-value pairs）。字典是无序的，即没有固定的顺序，而是通过键来索引和访问值。字典中的键必须是唯一的，但值可以重复。

创建字典

可以使用花括号 {} 和键值对（key-value pairs）来创建字典，每对键值对之间使用冒号 : 分隔，键和值之间使用逗号 , 分隔。例如：

my_dict = {"name": "Alice", "age": 30, "city": "New York"}

也可以使用 dict() 构造函数来创建字典，传入键值对作为参数。例如：

another_dict = dict(name="Bob", age=25, city="San Francisco")

访问字典中的值

可以通过键来访问字典中的值，通过使用键来索引。例如：

print(my_dict["name"])   # 输出 'Alice'
print(another_dict["age"])  # 输出 25

如果访问不存在的键，会引发 KeyError 错误。可以使用 get() 方法来避免这种错误，如果键不存在，则返回默认值（默认为 None）。例如：

print(my_dict.get("city"))   # 输出 'New York'
print(my_dict.get("hobby"))  # 输出 None

添加或修改字典中的元素

可以直接为字典中不存在的键赋值来添加新的键值对，或者直接为已有的键赋新的值来修改对应的值。例如：

my_dict["email"] = "alice@example.com"  # 添加新键值对
my_dict["age"] = 31  # 修改已有键的值
print(my_dict)

删除字典中的元素

可以使用 del 关键字或者 pop() 方法来删除字典中的元素。del 关键字用于删除指定键的键值对，而 pop() 方法用于删除指定键并返回其对应的值。例如：

del my_dict["city"]   # 删除键为 'city' 的键值对
print(my_dict)

age = my_dict.pop("age")  # 删除键为 'age' 的键值对，并返回其值
print(age)
print(my_dict)

字典方法

Python提供了丰富的内置方法来操作和处理字典，例如：

• keys()：返回字典中所有的键。
• values()：返回字典中所有的值。
• items()：返回字典中所有的键值对（以元组形式返回）。
• update()：用一个字典中的键值对更新另一个字典。
• clear()：清空字典中的所有元素。

print(my_dict.keys())    # 输出 dict_keys(['name', 'email'])
print(my_dict.values())  # 输出 dict_values(['Alice', 'alice@example.com'])
print(my_dict.items())   # 输出 dict_items([('name', 'Alice'), ('email', 'alice@example.com')])

字典的应用场景

• 存储键值对数据：适合存储属性-值对，例如用户信息、配置选项等。
• 快速查找：通过键快速访问值，比列表更高效。
• 数据整合：用于整合和处理多个相关联的数据项。