Python TensorFlow库【深度学习框架】全面讲解与案例

一、TensorFlow 基础知识

1. 核心概念

• 张量 (Tensor): 多维数组，是 TensorFlow 的基本数据单位（标量、向量、矩阵等）。
• 计算图 (Graph): 早期版本中的静态图机制（TF2.x 默认启用动态图）。
• 会话 (Session): 在 TF1.x 中用于执行计算图（TF2.x 中已弃用）。

2. 基本操作

import tensorflow as tf# 创建张量
a = tf.constant([[1, 2], [3, 4]])  # 形状 (2, 2)
b = tf.constant([[5, 6], [7, 8]])# 张量运算
c = tf.add(a, b)        # 逐元素加法
d = tf.matmul(a, b)     # 矩阵乘法print("加法结果:\n", c.numpy())
print("矩阵乘法结果:\n", d.numpy())

---

二、高级用法

1. Keras API 快速建模

from tensorflow.keras import layers, models# 构建顺序模型
model = models.Sequential([layers.Dense(64, activation='relu', input_shape=(784,)),layers.Dropout(0.2),layers.Dense(10, activation='softmax')
])# 编译模型
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])# 打印模型结构
model.summary()

2. 自定义训练循环

# 自定义损失函数和训练步骤
@tf.function
def train_step(inputs, labels):with tf.GradientTape() as tape:predictions = model(inputs)loss = tf.keras.losses.sparse_categorical_crossentropy(labels, predictions)gradients = tape.gradient(loss, model.trainable_variables)optimizer.apply_gradients(zip(gradients, model.trainable_variables))return loss

---

三、深入进阶

1. 混合精度训练

# 启用混合精度策略
from tensorflow.keras.mixed_precision import set_global_policy
set_global_policy('mixed_float16')# 模型会自动使用混合精度
model = models.Sequential([layers.Dense(1024, activation='relu'),  # 自动转为 float16layers.Dense(10, dtype='float32')       # 输出层保持 float32
])

2. 分布式训练

# 多GPU训练策略
strategy = tf.distribute.MirroredStrategy()with strategy.scope():model = models.Sequential([...])model.compile(...)model.fit(train_dataset, epochs=10)

---

四、完整案例

案例1：图像分类（CNN）

# 加载数据
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()# 预处理
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255# 构建CNN模型
model = models.Sequential([layers.Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),layers.MaxPooling2D((2,2)),layers.Flatten(),layers.Dense(10, activation='softmax')
])# 训练配置
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])# 训练模型
history = model.fit(train_images, train_labels,epochs=5,validation_split=0.2)# 评估模型
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'Test accuracy: {test_acc}')

---

五、学习路径建议

1. 分阶段学习

1. 基础阶段（2周）：

   • 张量操作
   • 全连接网络
   • Keras API 基础

2. 中级阶段（3周）：

   • CNN/RNN实现
   • 数据管道（tf.data）
   • 模型保存/加载

3. 高级阶段（4周）：

   • 自定义训练循环
   • 分布式训练
   • TensorFlow Serving 部署

2. 推荐资源

• 官方文档：tensorflow.org
• 实战书籍：《Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow》
• 社区：Stack Overflow（标签 tensorflow）、GitHub 开源项目

---

六、关键代码示例

自定义层示例

class CustomDense(layers.Layer):def __init__(self, units=32):super().__init__()self.units = unitsdef build(self, input_shape):# 初始化权重self.w = self.add_weight(shape=(input_shape[-1], self.units),initializer="random_normal",trainable=True,)self.b = self.add_weight(shape=(self.units,), initializer="zeros", trainable=True)def call(self, inputs):# 前向传播计算return tf.matmul(inputs, self.w) + self.b# 使用自定义层
model = models.Sequential([CustomDense(64),layers.ReLU(),CustomDense(10)
])

---

六、模型部署与生产化

1. 模型保存与加载

# 保存整个模型（架构+权重+优化器状态）
model.save('my_model.keras')  # 或使用 SavedModel 格式# 加载模型
loaded_model = tf.keras.models.load_model('my_model.keras')# 仅保存权重
model.save_weights('model_weights.weights.h5')# 仅保存架构
with open('model_architecture.json', 'w') as f:f.write(model.to_json())

2. TensorFlow Serving 部署

# 安装 TensorFlow Serving
echo "deb [arch=amd64] http://storage.googleapis.com/tensorflow-serving-apt stable tensorflow-model-server tensorflow-model-server-universal" | sudo tee /etc/apt/sources.list.d/tensorflow-serving.list
curl https://storage.googleapis.com/tensorflow-serving-apt/tensorflow-serving.release.pub.gpg | sudo apt-key add -
sudo apt-get update && sudo apt-get install tensorflow-model-server# 启动服务
tensorflow_model_server \--rest_api_port=8501 \--model_name=my_model \--model_base_path=/path/to/saved_model

---

七、性能优化技巧

1. 使用 tf.data 构建高效数据管道

# 从内存数据创建 Dataset
dataset = tf.data.Dataset.from_tensor_slices((images, labels))# 优化操作链
dataset = dataset.shuffle(buffer_size=1000)\.batch(32)\.prefetch(tf.data.AUTOTUNE)\.map(lambda x, y: (augment_image(x), y), num_parallel_calls=tf.data.AUTOTUNE)# 使用并行化加速
options = tf.data.Options()
options.threading.private_threadpool_size = 8
dataset = dataset.with_options(options)

2. 图模式加速

# 使用 @tf.function 将 Python 代码转为计算图
@tf.function(jit_compile=True)  # 启用 XLA 加速
def fast_train_step(inputs, labels):# ...训练逻辑与之前相同...

---

八、案例：自然语言处理（文本分类）

使用预训练 BERT 模型

import tensorflow_hub as hub# 加载预训练 BERT
bert_preprocess = hub.KerasLayer("https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3")
bert_encoder = hub.KerasLayer("https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/4",trainable=True)# 构建分类模型
text_input = tf.keras.layers.Input(shape=(), dtype=tf.string)
preprocessed_text = bert_preprocess(text_input)
outputs = bert_encoder(preprocessed_text)
net = outputs['pooled_output']
net = tf.keras.layers.Dense(64, activation='relu')(net)
net = tf.keras.layers.Dense(1, activation='sigmoid')(net)
model = tf.keras.Model(text_input, net)# 训练配置
model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])# 示例数据
texts = ["This movie was great!", "Terrible acting..."]
labels = [1, 0]
model.fit(texts, labels, epochs=3)

---

九、调试与可视化

1. TensorBoard 集成

# 在回调中集成 TensorBoard
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=1,profile_batch='500,520')  # 分析特定批次model.fit(train_data, epochs=5, callbacks=[tensorboard_callback])# 命令行启动 TensorBoard
# tensorboard --logdir=./logs

2. 梯度检查技巧

# 检查梯度消失/爆炸
for layer in model.layers:if hasattr(layer, 'kernel'):kernel_values = layer.kernel.numpy()print(f"{layer.name} weight mean: {np.mean(kernel_values):.4f}, std: {np.std(kernel_values):.4f}")# 使用梯度裁剪
optimizer = tf.keras.optimizers.Adam(clipvalue=1.0)  # 限制梯度绝对值

---

十、生态系统工具链

工具名称	用途描述	典型场景
TensorFlow Lite	移动端/嵌入式部署	手机应用模型推理
TFX	端到端机器学习流水线	生产级模型训练与部署
TensorFlow.js	浏览器/Node.js 环境运行模型	Web 前端智能应用开发
TFLite Model Maker	快速迁移学习工具	移动端定制模型训练

---

十一、常见问题解决方案

1. GPU 内存不足问题

# 限制 GPU 内存增长
gpus = tf.config.list_physical_devices('GPU')
if gpus:try:for gpu in gpus:tf.config.experimental.set_memory_growth(gpu, True)except RuntimeError as e:print(e)# 或直接限制显存使用量
tf.config.set_logical_device_configuration(gpus[0],[tf.config.LogicalDeviceConfiguration(memory_limit=4096)])  # 限制 4GB

2. 自定义指标不更新

# 正确实现状态更新
class TruePositives(tf.keras.metrics.Metric):def __init__(self, name='true_positives', **kwargs):super().__init__(name=name, **kwargs)self.true_positives = self.add_weight(name='tp', initializer='zeros')def update_state(self, y_true, y_pred, sample_weight=None):y_pred = tf.reshape(tf.round(y_pred), [-1])y_true = tf.reshape(y_true, [-1])values = tf.logical_and(tf.equal(y_true, 1), tf.equal(y_pred, 1))values = tf.cast(values, self.dtype)self.true_positives.assign_add(tf.reduce_sum(values))def result(self):return self.true_positives

---

十二、学习路线图

高级主题专项训练

1. 模型量化（2周）：

   • 训练后量化 (Post-training quantization)
   • 量化感知训练 (QAT)

2. 模型解释性（1周）：

   • 使用 SHAP 或 LIME
   • Grad-CAM 可视化

3. 强化学习集成（3周）：

   • 使用 TF-Agents 库
   • 实现 DQN/PPO 算法

---

十三、高级模型优化技术

1. 模型剪枝与量化

权重剪枝（减少模型冗余参数）

import tensorflow_model_optimization as tfmot# 定义剪枝策略
prune_low_magnitude = tfmot.sparsity.keras.prune_low_magnitude# 应用剪枝到全连接层
model = models.Sequential([layers.Flatten(input_shape=(28, 28)),prune_low_magnitude(layers.Dense(128, activation='relu')),layers.Dropout(0.2),prune_low_magnitude(layers.Dense(10))
])# 配置剪枝回调
pruning_callback = tfmot.sparsity.keras.UpdatePruningStep()# 训练时自动剪枝
model.compile(optimizer='adam',loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),metrics=['accuracy'])
model.fit(train_images, train_labels,epochs=5,callbacks=[pruning_callback])

训练后量化（减小模型体积）

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]  # 启用默认量化
quantized_model = converter.convert()# 保存量化模型
with open('quantized_model.tflite', 'wb') as f:f.write(quantized_model)

---

十四、TensorFlow Extended (TFX) 生产级流水线

端到端机器学习流水线示例

from tfx.components import CsvExampleGen, Trainer, Pusher
from tfx.orchestration import pipeline# 1. 数据输入组件
example_gen = CsvExampleGen(input_base='data_path')# 2. 数据验证组件
statistics_gen = StatisticsGen(examples=example_gen.outputs['examples'])
schema_gen = SchemaGen(statistics=statistics_gen.outputs['statistics'])# 3. 训练组件
trainer = Trainer(module_file='train_module.py',  # 包含训练逻辑的Python模块examples=example_gen.outputs['examples'],schema=schema_gen.outputs['schema'],train_args=tfx.proto.TrainArgs(num_steps=1000),eval_args=tfx.proto.EvalArgs(num_steps=500))# 4. 模型推送组件
pusher = Pusher(model=trainer.outputs['model'],push_destination=tfx.proto.PushDestination(filesystem=tfx.proto.PushDestination.Filesystem(base_directory='serving_model_dir')))# 构建流水线
pipeline = pipeline.Pipeline(pipeline_name='my_pipeline',components=[example_gen, statistics_gen, schema_gen, trainer, pusher],enable_cache=True)

---

十五、TPU加速训练实战

Colab TPU配置与使用

# 检测并初始化TPU
try:tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()strategy = tf.distribute.TPUStrategy(tpu)
except ValueError:strategy = tf.distribute.MirroredStrategy()  # 回退到GPU/CPU# 在TPU策略范围内构建模型
with strategy.scope():model = tf.keras.Sequential([tf.keras.layers.Reshape((28, 28, 1), input_shape=(784,)),tf.keras.layers.Conv2D(32, 3, activation='relu'),tf.keras.layers.Flatten(),tf.keras.layers.Dense(10)])model.compile(optimizer=tf.keras.optimizers.Adam(0.001),loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),metrics=['accuracy'])# 必须使用tf.data.Dataset且设置固定批次大小
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)).shuffle(60000).batch(2048)  # TPU需要较大批次# 开始训练
model.fit(train_dataset, epochs=10)

---

十六、自定义训练高级技巧

梯度累积（解决显存不足问题）

accumulation_steps = 4  # 累积4个批次的梯度
optimizer = tf.keras.optimizers.Adam()@tf.function
def train_step(inputs, labels):with tf.GradientTape() as tape:predictions = model(inputs, training=True)loss = compute_loss(labels, predictions)gradients = tape.gradient(loss, model.trainable_variables)# 累积梯度if not hasattr(train_step, "accum_grads"):train_step.accum_grads = [tf.zeros_like(g) for g in gradients]for i in range(len(gradients)):train_step.accum_grads[i] += gradients[i] / accumulation_steps# 每 accumulation_steps 步更新一次权重if optimizer.iterations % accumulation_steps == 0:optimizer.apply_gradients(zip(train_step.accum_grads, model.trainable_variables))train_step.accum_grads = [tf.zeros_like(g) for g in gradients]  # 重置累积梯度return loss

---

十七、跨框架集成

TensorFlow与PyTorch模型互转

# 将PyTorch模型转为TensorFlow格式（需使用ONNX中转）
import torch
import onnx
from onnx_tf.backend import prepare# 1. 导出PyTorch模型到ONNX
dummy_input = torch.randn(1, 3, 224, 224)
torch.onnx.export(pytorch_model, dummy_input, "model.onnx")# 2. 转换ONNX到TensorFlow
onnx_model = onnx.load("model.onnx")
tf_rep = prepare(onnx_model)
tf_rep.export_graph("tf_model")  # 生成TensorFlow SavedModel

---

十八、前沿应用方向

多模态学习示例（图文匹配）

# 构建双输入模型
text_input = tf.keras.Input(shape=(None,), dtype=tf.string, name='text')
image_input = tf.keras.Input(shape=(224, 224, 3), name='image')# 文本处理分支
text_features = tf.keras.layers.TextVectorization(max_tokens=10000)(text_input)
text_features = tf.keras.layers.Embedding(10000, 128)(text_features)
text_features = tf.keras.layers.GlobalAveragePooling1D()(text_features)# 图像处理分支
image_features = tf.keras.applications.MobileNetV2(weights='imagenet', include_top=False)(image_input)
image_features = tf.keras.layers.GlobalAveragePooling2D()(image_features)# 特征融合
combined = tf.keras.layers.concatenate([text_features, image_features])
output = tf.keras.layers.Dense(1, activation='sigmoid')(combined)model = tf.keras.Model(inputs=[text_input, image_input], outputs=output)# 编译训练
model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])

---

十九、关键调试工具

TensorFlow Debugger (tfdbg)

# 在代码中插入调试器
from tensorflow.python import debug as tf_debug# 包装Session（TF2需使用兼容模式）
sess = tf.compat.v1.Session()
sess = tf_debug.TensorBoardDebugWrapperSession(sess, "localhost:6064")# 或通过命令行启动
# tensorboard --debugger_port 6064

---

二十、性能调优

1. 版本跟踪

• 定期查看 TensorFlow RFCs 了解最新发展方向
• 使用 tf_upgrade_v2 工具迁移旧代码

2. 性能调优黄金法则

1. 数据管道优先：确保 tf.data 不成为瓶颈
2. 混合精度标配：大部分现代GPU可启用 mixed_float16
3. XLA编译尝试：对固定形状输入模型使用 @tf.function(jit_compile=True)
4. 分布式策略选择：单机多卡用 MirroredStrategy，多机用 MultiWorkerMirroredStrategy

---

二十一、生成对抗网络（GAN）实战

1. 基础GAN实现（手写数字生成）

# 生成器模型
def build_generator(latent_dim=128):model = tf.keras.Sequential([layers.Dense(7*7*256, use_bias=False, input_shape=(latent_dim,)),layers.BatchNormalization(),layers.LeakyReLU(),layers.Reshape((7, 7, 256)),layers.Conv2DTranspose(128, (5,5), strides=(1,1), padding='same', use_bias=False),layers.BatchNormalization(),layers.LeakyReLU(),layers.Conv2DTranspose(64, (5,5), strides=(2,2), padding='same', use_bias=False),layers.BatchNormalization(),layers.LeakyReLU(),layers.Conv2DTranspose(1, (5,5), strides=(2,2), padding='same', use_bias=False, activation='tanh')])return model# 判别器模型
def build_discriminator():model = tf.keras.Sequential([layers.Conv2D(64, (5,5), strides=(2,2), padding='same', input_shape=(28,28,1)),layers.LeakyReLU(),layers.Dropout(0.3),layers.Conv2D(128, (5,5), strides=(2,2), padding='same'),layers.LeakyReLU(),layers.Dropout(0.3),layers.Flatten(),layers.Dense(1, activation='sigmoid')])return model# 训练循环
@tf.function
def train_step(real_images):# 生成随机噪声noise = tf.random.normal([BATCH_SIZE, latent_dim])with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:# 生成假图像generated_images = generator(noise, training=True)# 判别器判断结果real_output = discriminator(real_images, training=True)fake_output = discriminator(generated_images, training=True)# 计算损失gen_loss = generator_loss(fake_output)disc_loss = discriminator_loss(real_output, fake_output)# 更新梯度gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))

---

二十二、强化学习（TF-Agents）

DQN算法实现

import tf_agents
from tf_agents.agents.dqn import dqn_agent
from tf_agents.environments import suite_gym# 创建环境
env = suite_gym.load('CartPole-v1')
train_env = tf_agents.environments.TFPyEnvironment(env)# 构建Q网络
q_net = tf_agents.networks.Sequential([tf.keras.layers.Dense(128, activation='relu'),tf.keras.layers.Dense(128, activation='relu'),tf.keras.layers.Dense(env.action_spec().num_values)
])# 创建DQN Agent
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
agent = dqn_agent.DqnAgent(train_env.time_step_spec(),train_env.action_spec(),q_network=q_net,optimizer=optimizer,td_errors_loss_fn=tf_agents.losses.huber_loss)# 训练循环
def train_episode(env, agent):time_step = env.reset()episode_return = 0while not time_step.is_last():action_step = agent.collect_policy.action(time_step)next_time_step = env.step(action_step.action)episode_return += next_time_step.reward.numpy()[0]# 保存轨迹到Replay Buffertraj = tf_agents.trajectories.trajectory.from_transition(time_step, action_step, next_time_step)replay_buffer.add_batch(traj)# 采样训练experience, _ = next(replay_buffer.as_dataset(sample_batch_size=BATCH_SIZE,num_steps=2).take(1))agent.train(experience)time_step = next_time_stepreturn episode_return

---

二十三、图神经网络（GNN）

使用TensorFlow-GNN库

import tensorflow_gnn as tfgnn# 定义图结构
graph_schema = tfgnn.GraphSchema()
graph_schema.node_sets["node"] = tfgnn.NodeSetSchema(features={"feature": tf.float32},sizes=tf.TensorSpec(shape=(None,), dtype=tf.int32))graph_schema.edge_sets["edge"] = tfgnn.EdgeSetSchema(adjacency=tfgnn.AdjacencySpec(source="node", target="node"),features={"weight": tf.float32})# 构建GNN模型
class GNNModel(tf.keras.Model):def __init__(self):super().__init__()self.conv1 = tfgnn.keras.layers.GraphConv(units=64, message_fn=tfgnn.keras.layers.SimpleConv(message_fn=tf.keras.layers.Dense(32),reduce_type="sum")self.conv2 = tfgnn.keras.layers.GraphConv(units=32)self.dense = tf.keras.layers.Dense(1)def call(self, graph):graph = self.conv1(graph)graph = tfgnn.keras.layers.Readout(node_set_name="node")(graph)graph = self.conv2(graph)return self.dense(graph)

---

二十四、模型解释性工具

Integrated Gradients可视化

import matplotlib.pyplot as plt
from tensorflow.keras import applications# 加载预训练模型
model = applications.ResNet50(weights='imagenet')# 选择解释方法
@tf.function
def integrated_gradients(inputs, baseline, steps=50):inputs = tf.convert_to_tensor(inputs)baseline = tf.convert_to_tensor(baseline)# 生成插值路径interpolated_inputs = [baseline + (float(i)/steps)*(inputs - baseline)for i in range(steps+1)]# 计算梯度with tf.GradientTape() as tape:tape.watch(interpolated_inputs)preds = model(tf.stack(interpolated_inputs))grads = tape.gradient(preds, interpolated_inputs)avg_grads = tf.reduce_mean(grads[:-1], axis=0)integrated_grad = (inputs - baseline) * avg_gradsreturn integrated_grad# 可视化结果
plt.imshow(integrated_grad.numpy().sum(axis=-1)[0], cmap='viridis')
plt.colorbar()
plt.show()

---

二十五、自动机器学习（AutoML）

使用KerasTuner自动调参

import keras_tuner as ktdef model_builder(hp):model = tf.keras.Sequential()# 调节层数for i in range(hp.Int('num_layers', 2, 5)):model.add(layers.Dense(units=hp.Int(f'units_{i}', min_value=32, max_value=512, step=32),activation='relu'))model.add(layers.Dense(10, activation='softmax'))# 调节学习率hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=hp_learning_rate),loss='sparse_categorical_crossentropy',metrics=['accuracy'])return model# 启动搜索
tuner = kt.BayesianOptimization(model_builder,objective='val_accuracy',max_trials=20,executions_per_trial=2)tuner.search(train_images, train_labels,epochs=10,validation_split=0.2)# 获取最优模型
best_model = tuner.get_best_models(num_models=1)[0]

---

二十六、移动端部署（TensorFlow Lite）

Android模型集成示例

1. 模型转换：

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()with open('model.tflite', 'wb') as f:f.write(tflite_model)

2. Android推理代码：

// 加载模型
Interpreter tflite = new Interpreter(loadModelFile(context));// 输入输出张量
float[][] input = new float[1][224][224][3];
float[][] output = new float[1][1000];// 执行推理
tflite.run(input, output);// 后处理
int maxIndex = argmax(output[0]);

---

二十七、持续学习路径建议

专项突破计划

领域	推荐资源
生成模型	《Generative Deep Learning》书籍 + 官方GAN示例
强化学习	TF-Agents官方文档 + OpenAI Gym环境实践
移动端部署	TensorFlow Lite示例仓库 + Android ML Kit文档
模型压缩	TensorFlow Model Optimization Toolkit指南 + ICLR相关论文

---

二十八、前沿技术追踪

重点关注方向

1. JAX与TensorFlow融合：Google Brain团队正在整合JAX的自动微分能力
2. 分布式训练新范式：Parameter Server架构向AllReduce模式演进
3. 量子机器学习：TensorFlow Quantum库的量子-经典混合模型
4. 神经架构搜索（NAS）：使用AutoML自动发现高效模型结构

---

Python 图书推荐

书名	出版社	推荐
Python编程 从入门到实践 第3版（图灵出品）	人民邮电出版社	★★★★★
Python数据科学手册（第2版）（图灵出品）	人民邮电出版社	★★★★★
图形引擎开发入门：基于Python语言	电子工业出版社	★★★★★
科研论文配图绘制指南 基于Python（异步图书出品）	人民邮电出版社	★★★★★
Effective Python：编写好Python的90个有效方法（第2版 英文版）	人民邮电出版社	★★★★★
Python人工智能与机器学习（套装全5册)	清华大学出版社	★★★★★

JAVA 图书推荐

书名	出版社	推荐
Java核心技术 第12版：卷Ⅰ+卷Ⅱ	机械工业出版社	★★★★★
Java核心技术 第11版 套装共2册	机械工业出版社	★★★★★
Java语言程序设计基础篇+进阶篇 原书第12版 套装共2册	机械工业出版社	★★★★★
Java 11官方参考手册（第11版）	清华大学出版社	★★★★★
Offer来了：Java面试核心知识点精讲（第2版）(博文视点出品)	电子工业出版社	★★★★★