第3章：Python 核心基础概念

3.1 Python 核心概念

Python是一种解释型编程语言，具有独特的设计哲学和语法特点。以下是Python的核心概念，这些概念是理解和使用Python的基础。

解释型语言

• 定义：Python是解释型语言，编写完代码后可以直接运行，无需编译成机器码
• 优势：开发效率高，调试方便，适合新手学习和快速原型开发
• 执行过程：Python解释器逐行读取代码，逐行执行，遇到错误会立即停止

缩进规则

• 定义：Python使用缩进来区分代码块，而不是使用大括号
• 要求：通常使用4个空格或1个Tab键进行缩进，同一代码块的缩进必须一致
• 重要性：缩进是Python的灵魂，不正确的缩进会导致语法错误

注释

• 定义：注释是用于解释代码的文本，不会被执行
• 作用：提高代码可读性，方便自己和他人理解代码
• 类型：
  • 单行注释：使用#开头
  • 多行注释：使用''' '''或""" """包裹

变量

• 定义：变量是存储数据的容器，可以存储不同类型的数据
• 命名规则：由字母、数字、下划线组成，不能以数字开头，区分大小写
• 赋值：使用等号(=)进行赋值，如name = "zhangsan"
• 使用：通过变量名来访问存储的数据

数据类型

• 定义：数据类型是数据的分类，不同类型的数据对应不同的操作
• 重要性：了解数据类型是编写Python代码的基础
• 常见类型：数字、字符串、布尔值、列表、元组、字典、集合

3.2 Python 核心数据类型

Python有多种内置数据类型，每种类型都有其特定的用途和操作方法。

数字类型

• 整数（int）：没有小数部分的数字，如1、2、3、-10等
• 浮点数（float）：带有小数部分的数字，如1.5、2.0、-3.14等
• 操作：支持加减乘除等算术运算

字符串类型

• 定义：字符串是由字符组成的序列，用于存储文本数据
• 表示方法：使用单引号(')、双引号(")或三引号(''')包裹
• 操作：支持拼接、切片、查找、替换等操作

布尔类型

• 定义：布尔类型只有两个值：True（真）和False（假）
• 用途：用于条件判断和逻辑运算
• 操作：支持and、or、not等逻辑运算

列表

• 定义：列表是有序、可重复的容器，可以存储多种类型的数据
• 表示方法：使用方括号([])包裹，元素之间用逗号分隔
• 特点：可变（可以修改元素）
• 操作：支持添加、删除、修改、切片等操作

元组

• 定义：元组是有序、不可修改的容器，可以存储多种类型的数据
• 表示方法：使用圆括号(())包裹，元素之间用逗号分隔
• 特点：不可变（不能修改元素）
• 操作：支持索引、切片等操作

字典

• 定义：字典是键值对容器，用于存储关联数据
• 表示方法：使用花括号({})包裹，键值对之间用逗号分隔，键和值之间用冒号(:)连接
• 特点：键必须唯一，值可以是任意类型
• 操作：支持添加、删除、修改、查找等操作

集合

• 定义：集合是无序、不可重复的容器
• 表示方法：使用花括号({})包裹，元素之间用逗号分隔
• 特点：元素不可重复
• 操作：支持添加、删除、集合运算（并集、交集、差集）等操作

3.3 数据类型转换

在Python中，不同数据类型之间可以相互转换，这在实际编程中非常常用。

转换为整数

• 函数：int()
• 用法：
  • int(1.5) → 1
  • int("123") → 123
  • int(True) → 1
  • int(False) → 0

转换为浮点数

• 函数：float()
• 用法：
  • float(1) → 1.0
  • float("1.5") → 1.5
  • float(True) → 1.0

转换为字符串

• 函数：str()
• 用法：
  • str(123) → "123"
  • str(1.5) → "1.5"
  • str(True) → "True"
  • str([1, 2, 3]) → "[1, 2, 3]"

转换为布尔值

• 函数：bool()
• 用法：
  • bool(0) → False
  • bool(0.0) → False
  • bool("") → False
  • bool([]) → False
  • bool({}) → False
  • bool(None) → False
  • 其他值 → True

转换为列表

• 函数：list()
• 用法：
  • list("hello") → ["h", "e", "l", "l", "o"]
  • list((1, 2, 3)) → [1, 2, 3]
  • list({1, 2, 3}) → [1, 2, 3]
  • list({"name": "zhangsan", "age": 18}) → ["name", "age"]

转换为元组

• 函数：tuple()
• 用法：
  • tuple("hello") → ("h", "e", "l", "l", "o")
  • tuple([1, 2, 3]) → (1, 2, 3)
  • tuple({1, 2, 3}) → (1, 2, 3)

转换为集合

• 函数：set()
• 用法：
  • set("hello") → {"h", "e", "l", "o"}（去重）
  • set([1, 2, 2, 3]) → {1, 2, 3}（去重）
  • set((1, 2, 3)) →

3.4 实操案例

让我们通过一个实操案例来理解Python的核心数据类型和基本操作。

案例：创建不同数据类型的变量并进行操作

# 数字类型
num1 = 10  # 整数
num2 = 3.14  # 浮点数
print("数字类型:")
print(f"num1 = {num1}, 类型: {type(num1)}")
print(f"num2 = {num2}, 类型: {type(num2)}")
print(f"num1 + num2 = {num1 + num2}")
print()

# 字符串类型
str1 = "Hello"
str2 = "Python"
print("字符串类型:")
print(f"str1 = {str1}, 类型: {type(str1)}")
print(f"str2 = {str2}, 类型: {type(str2)}")
print(f"str1 + str2 = {str1 + str2}")
print(f"str1 * 3 = {str1 * 3}")
print(f"str1[0] = {str1[0]}")  # 索引
print(f"str1[1:4] = {str1[1:4]}")  # 切片
print()

# 布尔类型
bool1 = True
bool2 = False
print("布尔类型:")
print(f"bool1 = {bool1}, 类型: {type(bool1)}")
print(f"bool2 = {bool2}, 类型: {type(bool2)}")
print(f"bool1 and bool2 = {bool1 and bool2}")
print(f"bool1 or bool2 = {bool1 or bool2}")
print(f"not bool1 = {not bool1}")
print()

# 列表
list1 = [1, 2, 3, "hello", True]
print("列表:")
print(f"list1 = {list1}, 类型: {type(list1)}")
print(f"list1[0] = {list1[0]}")
print(f"list1[1:4] = {list1[1:4]}")
list1.append(4)  # 添加元素
print(f"添加元素后: {list1}")
list1[0] = "first"  # 修改元素
print(f"修改元素后: {list1}")
print()

# 元组
tuple1 = (1, 2, 3, "hello")
print("元组:")
print(f"tuple1 = {tuple1}, 类型: {type(tuple1)}")
print(f"tuple1[0] = {tuple1[0]}")
print(f"tuple1[1:3] = {tuple1[1:3]}")
# tuple1[0] = "first"  # 尝试修改元组，会报错
print()

# 字典
dict1 = {"name": "zhangsan", "age": 18, "gender": "male"}
print("字典:")
print(f"dict1 = {dict1}, 类型: {type(dict1)}")
print(f"dict1['name'] = {dict1['name']}")
dict1["age"] = 20  # 修改值
print(f"修改年龄后: {dict1}")
dict1["city"] = "Beijing"  # 添加键值对
print(f"添加城市后: {dict1}")
print()

# 集合
set1 = {1, 2, 2, 3, "hello"}  # 自动去重
print("集合:")
print(f"set1 = {set1}, 类型: {type(set1)}")
set1.add(4)  # 添加元素
print(f"添加元素后: {set1}")
set1.remove(2)  # 删除元素
print(f"删除元素后: {set1}")
print()

# 数据类型转换
print("数据类型转换:")
print(f"int('123') = {int('123')}")
print(f"float(123) = {float(123)}")
print(f"str(123) = {str(123)}")
print(f"bool(0) = {bool(0)}")
print(f"list('hello') = {list('hello')}")
print(f"tuple([1, 2, 3]) = {tuple([1, 2, 3])}")
print(f"set([1, 2, 2, 3]) = {set([1, 2, 2, 3])}")

运行结果

数字类型:
num1 = 10, 类型: <class 'int'>
num2 = 3.14, 类型: <class 'float'>
num1 + num2 = 13.14

字符串类型:
str1 = Hello, 类型: <class 'str'>
str2 = Python, 类型: <class 'str'>
str1 + str2 = HelloPython
str1 * 3 = HelloHelloHello
str1[0] = H
str1[1:4] = ell

布尔类型:
bool1 = True, 类型: <class 'bool'>
bool2 = False, 类型: <class 'bool'>
bool1 and bool2 = False
bool1 or bool2 = True
not bool1 = False

列表:
list1 = [1, 2, 3, 'hello', True], 类型: <class 'list'>
list1[0] = 1
list1[1:4] = [2, 3, 'hello']
添加元素后: [1, 2, 3, 'hello', True, 4]
修改元素后: ['first', 2, 3, 'hello', True, 4]

元组:
tuple1 = (1, 2, 3, 'hello'), 类型: <class 'tuple'>
tuple1[0] = 1
tuple1[1:3] = (2, 3)

字典:
dict1 = {'name': 'zhangsan', 'age': 18, 'gender': 'male'}, 类型: <class 'dict'>
dict1['name'] = zhangsan
修改年龄后: {'name': 'zhangsan', 'age': 20, 'gender': 'male'}
添加城市后: {'name': 'zhangsan', 'age': 20, 'gender': 'male', 'city': 'Beijing'}

集合:
set1 = {1, 2, 3, 'hello'}, 类型: <class 'set'>
添加元素后: {1, 2, 3, 4, 'hello'}
删除元素后: {1, 3, 4, 'hello'}

数据类型转换:
int('123') = 123
float(123) = 123.0
str(123) = 123
bool(0) = False
list('hello') = ['h', 'e', 'l', 'l', 'o']
tuple([1, 2, 3]) = (1, 2, 3)
set([1, 2, 2, 3]) = {1, 2, 3}

通过这个案例，我们可以看到Python的各种数据类型及其基本操作。在实际编程中，我们会根据不同的需求选择合适的数据类型，以提高代码的效率和可读性。

现在，你已经了解了Python的核心基础概念，为后续学习Python的基础语法打下了坚实的基础。