前言：本文章是在已经学习了C语言之后作者角度下进行书写的一篇关于python当中基础的语法说明。

快速深入理解python当中的语法

Python 简介：
Python 是一种高级编程语言，因其简单易学、可读性强以及多功能性而备受欢迎。Python 支持多种编程范式，包括面向对象、过程化编程和函数式编程。

基本数据类型

整数类型 (int)：整数类型用于表示没有小数部分的数值，正负均可。
Python 中的整数不受大小限制，可以表示任意大的数

浮点数类型 (float)：浮点数表示带有小数部分的数值，可以是正数或负数。
Python 中浮点数是双精度的，通常可以提供足够的精度来处理大部分场景下的小数运算。

布尔类型 (bool)：布尔类型用于表示逻辑值，只有两个可能的值：True（真）和 False（假）。
布尔类型经常用于条件判断和逻辑操作。

字符串类型 (str)：字符串用于存储文本数据。它由一对单引号或双引号包围的字符序列构成。
字符串是不可变的，即一旦创建就不能修改其内容。

算数运算符

# 加法
add_result = 3 + 5
print("加法结果: 3 + 5 =", add_result)

# 减法
sub_result = 10 - 4
print("减法结果: 10 - 4 =", sub_result)

# 乘法
mul_result = 6 * 7
print("乘法结果: 6 * 7 =", mul_result)

# 除法
div_result = 15 / 3
print("除法结果: 15 / 3 =", div_result)

# 取整除法
floordiv_result = 15 // 4
print("取整除法结果: 15 // 4 =", floordiv_result)

# 取余
mod_result = 10 % 3
print("取余结果: 10 % 3 =", mod_result)

# 幂运算
pow_result = 2 ** 3
print("幂运算结果: 2 ** 3 =", pow_result)

以上就是python当中最基本的一些运算符
并且为了方便计算

1. 一元负号 (-)
2. 增量运算符 (+=)
3. 减量运算符 (-=)
4. 乘量运算符 (*=)
5. 除量运算符 (/=)
6. 幂量运算符 (**=)
7. 取余运算符 (%=)

示例：

# 基础算数运算符
add_result = 3 + 5
print("加法结果: 3 + 5 =", add_result)

sub_result = 10 - 4
print("减法结果: 10 - 4 =", sub_result)

mul_result = 6 * 7
print("乘法结果: 6 * 7 =", mul_result)

div_result = 15 / 3
print("除法结果: 15 / 3 =", div_result)

floordiv_result = 15 // 4
print("取整除法结果: 15 // 4 =", floordiv_result)

mod_result = 10 % 3
print("取余结果: 10 % 3 =", mod_result)

pow_result = 2 ** 3
print("幂运算结果: 2 ** 3 =", pow_result)

# 扩展运算符
neg_result = -5
print("一元负号结果: -5 =", neg_result)

x = 5
x += 3
print("增量运算结果: 5 += 3 =", x)

x = 10
x -= 4
print("减量运算结果: 10 -= 4 =", x)

x = 6
x *= 2
print("乘量运算结果: 6 *= 2 =", x)

x = 15
x /= 3
print("除量运算结果: 15 /= 3 =", x)

x = 2
x **= 3
print("幂量运算结果: 2 **= 3 =", x)

x = 10
x %= 3
print("取余运算结果: 10 %= 3 =", x)

类型的查看与转换

查看变量类型：
Python 提供了内置的 type() 函数，用于查看变量的类型。这个函数会返回对象的类型信息。
示例：

x = 10
y = 3.14
z = "Hello"
is_active = True

print(type(x))        # 输出: <class 'int'>
print(type(y))        # 输出: <class 'float'>
print(type(z))        # 输出: <class 'str'>
print(type(is_active)) # 输出: <class 'bool'>

type() 返回值为对象的类型，如 int、float、str、bool 等。
类型转换：
Python 提供了许多内置函数来进行不同数据类型之间的转换，常见的类型转换函数包括 int()、float()、str()、bool() 等。
示例：

#1. 整数转换 (int())
# 浮点数转换为整数
x = int(3.14)  # 输出: 3
print(x)

# 布尔类型转换为整数
z = int(True)  # 输出: 1
print(z)

#2. 浮点数转换 (float())
# 整数转换为浮点数
x = float(10)  # 输出: 10.0
print(x)

# 布尔类型转换为浮点数
z = float(False)  # 输出: 0.0
print(z)

# 3. 字符串转换 (str())
# 整数转换为字符串
x = str(10)  # 输出: '10'
print(x)

# 布尔类型转换为字符串
z = str(True)  # 输出: 'True'
print(z)

# 4. 布尔类型转换 (bool())
# 数字转换为布尔值
x = bool(0)  # 输出: False
print(x)

# 空字符串转换为布尔值
z = bool("")  # 输出: False
print(z)

变量的输入与输出

1. 输入变量
   使用 input() 函数可以从用户那里获取输入。
   input() 函数会将所有输入作为字符串返回，所以通常需要转换成合适的类型（如 int 或 float）。
   示例：

# 从用户获取输入并转换为整数
num = int(input("请输入一个数字: "))
print(f"你输入的数字是: {num}")

2. 输出变量
   使用 print() 函数可以将变量输出到屏幕。
   你可以直接输出变量，也可以通过格式化字符串来控制输出格式。
   示例：

# 简单输出
name = "Alice"
print(name)

# 格式化输出
age = 25
print(f"{name} 今年 {age} 岁")

3. 多个输入和输出也叫做f-string
   可以一次获取多个输入并同时输出多个变量，使用 split() 函数将输入字符串拆分为多个部分。
   示例：

# 输入多个变量
a, b = input("请输入两个数字，用空格分隔: ").split()
a = int(a)
b = int(b)
# 输出多个变量
print(f"第一个数字是: {a}, 第二个数字是: {b}")

示例：

1.变量插值：
name = "Bob"
print(f"Hello, {name}!")
# 输出: Hello, Bob!

2.表达式插值：
a = 5
b = 3
print(f"{a} + {b} = {a + b}")
# 输出: 5 + 3 = 8

3.格式化输出：
pi = 3.1415926535
print(f"圆周率的近似值: {pi:.2f}")  # 保留两位小数
# 输出: 圆周率的近似值: 3.14

4.调用函数：
def greet(name):
    return f"Hello, {name}!"
print(f"{greet('Alice')}")
# 输出: Hello, Alice!

5.多行 f-string：
name = "Eve"
age = 27
info = f"""
姓名: {name}
年龄: {age}
"""
print(info)

条件语句

比较运算符和逻辑运算符

比较运算符：“==”、“!=”、“<”、“>”、“>=”、“<=”

1. == (等于)
   检查两个值是否相等，如果相等返回 True，否则返回 False。

2. != (不等于)
   检查两个值是否不相等，如果不相等返回 True，否则返回 False。

3. < (小于)
   检查左边的值是否小于右边的值，如果小于返回 True，否则返回 False。

4. (大于) 检查左边的值是否大于右边的值，如果大于返回 True，否则返回 False。

5. = (大于等于)检查左边的值是否大于或等于右边的值，如果是，返回 True，否则返回 False。

6. <= (小于等于)
   检查左边的值是否小于或等于右边的值，如果是，返回 True，否则返回 False。

逻辑运算符：“and”、“or”、“not”

1. and (与)
   and 运算符用于同时检查多个条件。如果所有条件都为 True，则返回 True；如果有一个条件为 False，则返回 False。
2. or (或)
   or 运算符用于检查多个条件。如果其中一个条件为 True，则返回 True；只有当所有条件都为 False 时，才返回 False。
3. not (非)
   not 运算符用于取反。如果条件为 True，则 not 会将其变为 False；如果条件为 False，则 not 会将其变为 True。

if、elif、else

1. if 语句
   if 语句用于测试一个条件。如果条件为真（True），则执行 if 块中的代码。
   示例：

x = 10
if x > 5:
    print("x 大于 5")

2. elif 语句
   elif 是 “else if” 的缩写，用于测试另一个条件。如果前面的 if 条件为假（False），则程序会继续检查 elif 条件。如果该条件为真，执行相应的代码块。
   示例：

x = 10
if x > 15:
    print("x 大于 15")
elif x > 5:
    print("x 大于 5，但小于等于 15")

3. else 语句
   else 是最后的 “兜底” 语句，如果 if 和所有 elif 条件都为假（False），则会执行 else 后面的代码块。
   示例：

x = 3
if x > 5:
    print("x 大于 5")
elif x == 5:
    print("x 等于 5")
else:
    print("x 小于 5")

三目运算符

三目运算符（也叫条件表达式）是用来简洁地表达 if-else 语句的，它允许在一行中根据条件返回不同的值。
其语法：

结果1 if 条件 else 结果2

条件：这是一个布尔表达式，如果为真（True），将返回 结果1。
结果1：当条件为真时，返回的值。
结果2：当条件为假（False）时，返回的值。
示例：

x = 10
y = 20

# 使用三目运算符
result = "x 大于 y" if x > y else "x 小于或等于 y"
print(result)
#输出结果：x 小于或等于 y

三目运算符的优势：
可以在一行中实现 if-else 逻辑，使代码更简洁，并且增加代码的可读性。

循环语句

while循环

while 循环在条件为真（True）时，反复执行代码块。当条件变为假（False）时，循环结束。

while 条件:
    执行的代码

示例：

#打印从一到五
i = 1
while i <= 5:
    print(i)
    i += 1  # 每次循环后 i 加 1

for循环

for 循环用于遍历一个可迭代对象（如列表、字符串、元组、字典、集合等），对其中的每个元素执行相同的操作。

for 变量 in 可迭代对象:
    执行的代码

示例：

#遍历列表中的每个元素
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

break和continue

break：用于提前终止循环。
continue：跳过当前迭代，直接进入下一次循环。
这两个的使用用法在python当中与C当中使用情况是一样的

序列类型的操作

字符串的增删查改

字符串是不可变的序列类型，因此在修改字符串时只能创建一个新的字符串。

增（插入字符）
通过切片和拼接在字符串的指定位置插入字符。
示例：

my_string = "HelloWorld"

# 在索引5处插入字符 "Python"
new_string = my_string[:5] + " Python " + my_string[5:]
print(new_string)  # 输出：Hello Python World

删（删除字符）
通过切片或 replace() 方法删除字符或子串。
示例：

# 使用切片删除索引5的字符
my_string = "HelloWorld"
new_string = my_string[:5] + my_string[6:]
print(new_string)  # 输出：Helloorld

# 使用 replace() 删除所有的 "l"
new_string = my_string.replace("l", "")
print(new_string)  # 输出：HeoWord

查（查找字符或子串）
find()：查找子串第一次出现的位置，找不到返回 -1。
index()：与 find() 类似，但找不到会抛出异常。
count()：返回子串出现的次数。
in 运算符：检查子串是否存在。
示例：

my_string = "HelloWorld"
print(my_string.find("o"))     # 输出：4
print(my_string.index("World")) # 输出：5
print(my_string.count("l"))     # 输出：3
print("Hello" in my_string)     # 输出：True

改（修改字符）
通过切片和拼接，或使用 replace() 进行修改。
示例：

# 将 "World" 修改为 "Python"
new_string = my_string[:5] + "Python"
print(new_string)  # 输出：HelloPython

# 使用 replace() 修改字符
new_string = my_string.replace("l", "x")
print(new_string)  # 输出：HexxoWorxd

字符串中常见的转义字符

\：反斜杠
'：单引号
"：双引号
\n：换行
\t：制表符
\r：回车
示例

# 插入转义字符
my_string = "He said, \"Hello World!\""
print(my_string)  # 输出：He said, "Hello World!"

# 插入换行符
my_string = "Hello\nWorld"
print(my_string)
# 输出：
# Hello
# World

列表的增删查改

列表是可变的序列类型，因此可以直接进行增删查改操作。
增（插入元素）
append()：在列表末尾添加元素。
insert()：在指定索引处插入元素。
extend()：将另一个列表中的所有元素添加到列表末尾。
示例：

my_list = [1, 2, 3]

# 在末尾添加元素
my_list.append(4)
print(my_list)  # 输出：[1, 2, 3, 4]

# 在索引1处插入元素
my_list.insert(1, 5)
print(my_list)  # 输出：[1, 5, 2, 3, 4]

# 扩展列表
my_list.extend([6, 7])
print(my_list)  # 输出：[1, 5, 2, 3, 4, 6, 7]

删（删除元素）
remove()：删除第一次出现的指定元素。
pop()：删除并返回指定索引的元素，默认删除最后一个。
clear()：清空列表。
del 关键字：删除列表中的指定元素或整个列表。
示例：

my_list = [1, 2, 3, 4, 5]

# 删除指定元素
my_list.remove(3)
print(my_list)  # 输出：[1, 2, 4, 5]

# 删除指定索引的元素
my_list.pop(1)
print(my_list)  # 输出：[1, 4, 5]

# 清空列表
my_list.clear()
print(my_list)  # 输出：[]

# 使用 del 删除索引2的元素
my_list = [1, 2, 3, 4, 5]
del my_list[2]
print(my_list)  # 输出：[1, 2, 4, 5]

查（查找元素）
index()：返回第一次出现的元素索引。
count()：统计元素出现的次数。
in：判断元素是否在列表中。
示例：

my_list = [1, 2, 3, 4, 3]

# 查找元素3第一次出现的索引
print(my_list.index(3))  # 输出：2

# 统计元素3出现的次数
print(my_list.count(3))  # 输出：2

# 判断元素是否在列表中
print(4 in my_list)  # 输出：True

改（修改元素）
直接通过索引修改元素。
示例：

my_list = [1, 2, 3, 4, 5]

# 修改索引1的元素
my_list[1] = 10
print(my_list)  # 输出：[1, 10, 3, 4, 5]

列表推导表达式

列表推导式是简洁的方式来生成列表，通常用于替代 for 循环。它允许在一行代码中创建列表，并可以包含条件表达式。
语法：

[表达式 for 变量 in 可迭代对象 if 条件]

示例：

# 生成一个包含0到9的列表
numbers = [x for x in range(10)]
print(numbers)  # 输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 生成一个包含偶数的列表
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # 输出：[0, 2, 4, 6, 8]

# 将列表中的元素平方
squares = [x**2 for x in range(10)]
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

元组的操作

元组（tuple）是不可变的序列类型，不能直接修改其内容，但支持查找、切片、拼接等操作。

创建元组
元组用小括号创建，逗号分隔元素。
示例：

my_tuple = (1, 2, 3)
print(my_tuple)  # 输出：(1, 2, 3)

查（查找元素）
index()：返回元素第一次出现的索引。
count()：统计元素出现的次数。
in：检查元素是否在元组中。
示例：

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

# 查找元素3的索引
print(my_tuple.index(3))  # 输出：2

# 统计元素3的出现次数
print(my_tuple.count(3))  # 输出：2

切片
可以通过切片操作从元组中获取子元组。
示例：

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

# 获取元组的切片
print(my_tuple[1:4])  # 输出：(2, 3, 4)

拼接
可以通过 + 操作符拼接两个元组。
示例：

tuple1 = (1, 2, 3)
tuple2 = (4, 5)

# 拼接两个元组
new_tuple = tuple1 + tuple2
print(new_tuple)  # 输出：(1, 2, 3, 4, 5)

总结对比：
可变性：字符串和元组不可变，列表可变。
有序性：三者都是有序序列，支持索引和切片。
元素类型：列表和元组可以包含任意类型的数据，字符串只能包含字符。

散列类型的操作

散列类型（也称为哈希类型）主要包括 字典（dict） 和 集合（set）。它们的操作方式与序列类型不同，主要用于基于键值对（dict）或集合中独特元素（set）的快速查找。接下来将对这两种散列类型的操作进行详细总结。
1. 字典（dict）
字典是 Python 中的一种哈希映射类型，用于存储键值对，键必须是可散列的（通常是不可变类型，如字符串、数字、元组），值可以是任意类型。

字典的常见操作：
增（添加键值对）
可以通过使用键添加新值或修改现有的键值对。
示例：

my_dict = {"name": "Alice", "age": 25}

# 添加新键值对
my_dict["city"] = "New York"
print(my_dict)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}

# 修改已有的键值对
my_dict["age"] = 26
print(my_dict)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York'}

删（删除键值对）
pop(key)：删除指定键，并返回对应的值。
popitem()：删除并返回最后插入的键值对（字典是无序的，Python 3.7+ 中有顺序）。
clear()：清空字典。
del：使用 del 关键字删除键值对或整个字典。
示例：

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

# 删除指定键
my_dict.pop("age")
print(my_dict)  # 输出：{'name': 'Alice', 'city': 'New York'}

# 删除最后一个键值对
my_dict.popitem()
print(my_dict)  # 输出：{'name': 'Alice'}

# 清空字典
my_dict.clear()
print(my_dict)  # 输出：{}

# 使用 del 删除字典中的键
del my_dict["name"]

查（查找键值对）
通过键查找值，如果键不存在会抛出 KeyError 异常，可以使用 get() 方法避免异常。
keys()：返回字典中所有的键。
values()：返回字典中所有的值。
items()：返回字典中的所有键值对。
in：用于检查键是否存在于字典中。
示例：

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

# 查找键 "name" 对应的值
print(my_dict["name"])  # 输出：Alice

# 使用 get() 查找键（如果键不存在不会报错）
print(my_dict.get("age", "不存在"))  # 输出：25

# 获取所有键、值和键值对
print(my_dict.keys())    # 输出：dict_keys(['name', 'age', 'city'])
print(my_dict.values())  # 输出：dict_values(['Alice', 25, 'New York'])
print(my_dict.items())   # 输出：dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])

# 检查键是否存在
print("age" in my_dict)  # 输出：True

改（修改键值对）
通过指定键直接修改对应的值。
示例：

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

# 修改键 "age" 的值
my_dict["age"] = 30
print(my_dict)  # 输出：{'name': 'Alice', 'age': 30, 'city': 'New York'}

其他操作
update()：将另一个字典的键值对更新到当前字典中。
copy()：返回字典的浅拷贝。

my_dict = {"name": "Alice", "age": 25}
new_dict = {"city": "New York", "job": "Engineer"}

# 使用 update() 方法
my_dict.update(new_dict)
print(my_dict)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York', 'job': 'Engineer'}

2. 集合（set）
集合是一种无序、不重复的元素集合。集合主要用于成员资格测试、去重和集合操作（如并集、交集等）。

增（添加元素）
add()：向集合中添加单个元素。
update()：向集合中添加多个元素（可以是列表、元组等）。
示例：

my_set = {1, 2, 3}

# 添加单个元素
my_set.add(4)
print(my_set)  # 输出：{1, 2, 3, 4}

# 添加多个元素
my_set.update([5, 6, 7])
print(my_set)  # 输出：{1, 2, 3, 4, 5, 6, 7}

删（删除元素）
remove()：删除指定元素，若元素不存在则抛出异常。
discard()：删除指定元素，若元素不存在不会抛出异常。
pop()：删除并返回集合中的任意元素（集合无序）。
clear()：清空集合。
del：删除整个集合。
示例：

my_set = {1, 2, 3, 4}

# 删除指定元素
my_set.remove(2)
print(my_set)  # 输出：{1, 3, 4}

# 删除不存在的元素（不会抛异常）
my_set.discard(5)

# 删除集合中的任意元素
my_set.pop()
print(my_set)  # 输出：{3, 4}

# 清空集合
my_set.clear()
print(my_set)  # 输出：set()

查（查找键值对）
查（查找元素）
使用 in 运算符判断元素是否在集合中。
集合中无重复元素，所有的元素都独一无二。
示例：

my_set = {1, 2, 3, 4}

# 判断元素是否存在于集合中
print(3 in my_set)  # 输出：True
print(5 in my_set)  # 输出：False

集合运算
并集（| 或 union()）：返回两个集合的并集。
交集（& 或 intersection()）：返回两个集合的交集。
差集（- 或 difference()）：返回当前集合与另一个集合的差集。
对称差集（^ 或 symmetric_difference()）：返回只存在于其中一个集合中的元素。
示例：

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

# 并集
print(set1 | set2)  # 输出：{1, 2, 3, 4, 5}

# 交集
print(set1 & set2)  # 输出：{3}

# 差集
print(set1 - set2)  # 输出：{1, 2}

# 对称差集
print(set1 ^ set2)  # 输出：{1, 2, 4, 5}