熟练应用Python
人脸识别：录入并识别不同人脸，并通过灯环反馈识别结果
本项目列举了如何在AIBox上使用摄像头进行人脸识别。
- 这段程序首先会读取摄像头，并自动截取一定数量的人脸用作训练。
- 然后将截取的人脸进行训练，生成一个训练模型。
- 最后通过摄像头实时识别人脸，未识别到人脸则灯环不亮，识别到已有人脸则亮绿色，识别到未知人脸或人脸置信度过低则亮红色。
提示
其中调用摄像头获取图片部分代码可以复用于其他项目。学习者可以举一反三，用于其他图像处理项目。
使用下方代码时，需要保证当前文件夹存在以下内容。（如必须在非当前目录执行，请替换相关路径为绝对路径，你可能需要根据自己的摄像头修改代码中的CID = 12的值）
-
dataSet文件夹
如不存在可自行创建一个空文件夹，注意大小写敏感。 -
haarcascade_frontalface_default.xml文件
如不存在可以点此下载 haarcascade_frontalface_default.xml 后移动至对应目录
from exboard import RGB
rgb = RGB()
import os
import cv2
import numpy as np
from PIL import Image
# 摄像头被分配到的设备ID，window通常为0，linux通常为1，AIBox通常为9~13
CID = 12
# 输入人脸,id为人脸对应的id，同个id的人脸会被识别为同一个人
def get_face(id="1"):
faceDetect = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
cam = cv2.VideoCapture(CID)
sampleNum = 0
while True:
ret, img = cam.read()
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = faceDetect.detectMultiScale(gray, 1.3, 5)
for x, y, w, h in faces:
sampleNum = sampleNum + 1
cv2.imwrite(
"dataSet/User." + str(id) + "." + str(sampleNum) + ".png",
gray[y : y + h, x : x + w],
)
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 2)
cv2.waitKey(100)
cv2.imshow("Face", img)
cv2.waitKey(1)
if sampleNum > 20:
break
cam.release()
cv2.destroyAllWindows()
# 训练数据
def trainer_face(path="dataSet"):
recognizer = cv2.face.LBPHFaceRecognizer_create()
imagePaths = [os.path.join(path, f) for f in os.listdir(path)]
faces = []
IDs = []
for imagePath in imagePaths:
faceImg = Image.open(imagePath).convert("L")
faceNp = np.array(faceImg, "uint8")
ID = int(os.path.split(imagePath)[-1].split(".")[1])
faces.append(faceNp)
IDs.append(ID)
cv2.imshow("training", faceNp)
cv2.waitKey(10)
recognizer.train(faces, np.array(IDs))
recognizer.save("trainningData.yml")
cv2.destroyAllWindows()
# 识别人脸
def recognizer(labels={"p1": 1, "p2": 2}):
# 加载人脸识别器
face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
# 加载已训练的人脸识别模型
recognizer = cv2.face.LBPHFaceRecognizer_create()
recognizer.read("trainningData.yml")
# 初始化摄像头
cap = cv2.VideoCapture(CID)
font = cv2.FONT_HERSHEY_COMPLEX_SMALL
while True:
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 检测人脸
faces = face_cascade.detectMultiScale(
gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)
)
rgb_color = (0, 0, 0)
for x, y, w, h in faces:
# 识别人脸
id, confidence = recognizer.predict(gray[y : y + h, x : x + w])
person = ""
if confidence < 100:
for name, label in labels.items():
if label == id:
person = name
break
confidence = int(100 - confidence)
if int(confidence) > 40:
rgb_color = (0, 255, 0) # 绿色
person = f"{person}: {confidence}%"
elif 0 < int(confidence) < 40:
rgb_color = (255, 0, 0) # 红色
person = "unkonw"
cv2.putText(
frame,
str(person),
(x, y + h),
cv2.FONT_HERSHEY_SIMPLEX,
1,
(0, 0, 255),
2,
) # 更新为cv2.putText()
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
rgb.set([rgb_color] * 24)
cv2.imshow("Face Recognition", frame)
if cv2.waitKey(1) & 0xFF == ord("q"):
rgb.set([(0, 0, 0)] * 24)
break
cap.release()
cv2.destroyAllWindows()
if __name__ == "__main__":
get_face(id="1")
trainer_face(path="dataSet")
recognizer()
人脸跟踪：实时跟踪人脸并显示在屏幕上
import cv2
from exboard import Servos
# 初始化舵机
servos = Servos()
servos_x = 0
# -90 在最左边，90 在最右边 ， 0 在中间
servos_y = 60
# 0 在最下边，90 在最上边
servos.update_x(servos_x)
servos.update_y(servos_y)
def servos_x_degree(degree):
if degree > 90:
degree = 90
if degree < -90:
degree = -90
return degree
def servos_y_degree(degree):
# y 限位 0-90
if degree > 90:
degree = 90
if degree < 0:
degree = 0
return degree
def update_servos(offset_x, offset_y):
global servos_x, servos_y # 声明 servos_x 和 servos_y 为全局变量
servos_x += offset_x
servos_y += offset_y
servos_x = servos_x_degree(servos_x)
servos_y = servos_y_degree(servos_y)
servos.update_x(servos_x)
servos.update_y(servos_y)
def calculate_offset(x, y, w, h, frame_shape):
offset_x = (frame_shape[1] / 2) - (x + w / 2)
offset_y = (frame_shape[0] / 2) - (y + h / 2)
max_offset = 1.5
offset_x = max(min(offset_x, max_offset), -max_offset)
offset_y = max(min(offset_y, max_offset), -max_offset)
return offset_x, offset_y
# 加载人脸检测模型
face_cascade = cv2.CascadeClassifier(
cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)
# 打开摄像头
cap = cv2.VideoCapture(10)
while True:
# 读取一帧图像
ret, frame = cap.read()
# 转换为灰度图像
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 进行人脸检测
# 较小的 scaleFactor 会增加检测时间但提高检测准确性，较大的 scaleFactor 会减少检测时间但可能降低检测准确性。
# 较小的 minNeighbors 会减少误检测，但可能会错过一些真实的人脸。较大的 minNeighbors 会增加误检测，但可能会检测到更多的人脸。
faces = face_cascade.detectMultiScale(gray,1.1, 10)
# 在循环中调用新的函数
for x, y, w, h in faces:
cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
offset_x, offset_y = calculate_offset(x, y, w, h, frame.shape)
update_servos(offset_x, offset_y)
# 显示图像
cv2.imshow("frame", frame)
# 如果按下 'q' 键，退出循环
if cv2.waitKey(1) & 0xFF == ord("q"):
break
# 释放摄像头
cap.release()
# 关闭 OpenCV 窗口
cv2.destroyAllWindows()
创新性图像处理应用：颜色量化
图片的颜色数量越多，图片就越难以压缩，图片的大小就越大，因此需要对图片进行颜色量化，减少图片的大小，将图像所需的颜色数量从96615减少到64（聚类算法），同时保持整体外观质量。
图像来源sklearn.datasets.load_sample_image("china.jpg")
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.metrics import pairwise_distances_argmin
from sklearn.datasets import load_sample_image
from sklearn.utils import shuffle
from time import time
n_colors = 64
# Load the Summer Palace photo
china = load_sample_image("china.jpg")
# Convert to floats instead of the default 8 bits integer coding. Dividing by
# 255 is important so that plt.imshow behaves works well on float data (need to
# be in the range [0-1])
china = np.array(china, dtype=np.float64) / 255
# Load Image and transform to a 2D numpy array.
w, h, d = original_shape = tuple(china.shape)
assert d == 3
image_array = np.reshape(china, (w * h, d))
print("Fitting model on a small sub-sample of the data")
t0 = time()
image_array_sample = shuffle(image_array, random_state=0)[:1000]
kmeans = KMeans(n_clusters=n_colors, random_state=0).fit(image_array_sample)
print("done in %0.3fs." % (time() - t0))
# Get labels for all points
print("Predicting color indices on the full image (k-means)")
t0 = time()
labels = kmeans.predict(image_array)
print("done in %0.3fs." % (time() - t0))
codebook_random = shuffle(image_array, random_state=0)[:n_colors]
print("Predicting color indices on the full image (random)")
t0 = time()
labels_random = pairwise_distances_argmin(codebook_random,
image_array,
axis=0)
print("done in %0.3fs." % (time() - t0))
def recreate_image(codebook, labels, w, h):
"""Recreate the (compressed) image from the code book & labels"""
d = codebook.shape[1]
image = np.zeros((w, h, d))
label_idx = 0
for i in range(w):
for j in range(h):
image[i][j] = codebook[labels[label_idx]]
label_idx += 1
return image
# Display all results, alongside original image
plt.figure(1)
plt.clf()
plt.axis('off')
plt.title('Original image (96,615 colors)')
plt.imshow(china)
plt.figure(2)
plt.clf()
plt.axis('off')
plt.title('Quantized image (64 colors, K-Means)')
plt.imshow(recreate_image(kmeans.cluster_centers_, labels, w, h))
plt.figure(3)
plt.clf()
plt.axis('off')
plt.title('Quantized image (64 colors, Random)')
plt.imshow(recreate_image(codebook_random, labels_random, w, h))
先进深度学习模型研发与应用
我们通常会通过参加一些算法大赛来检验自己的 学习成果。
譬如：
-
阿里云天池算法大赛：阿里巴巴集团主办的一系列比赛，涵盖了许多不同的领域和问题，如推荐系统、图像识别、预测等。
-
Kaggle竞赛：一个国际平台，我们之前火山下的文明一课就是Kaggle。
-
CCF大数据与计算智能大赛：由中国计算机学会（CCF）主办，涵盖了许多实际问题，如交通预测、社交网络分析等。
参加算法大赛可以帮助我们更好地理解机器学习的应用，获取一些实际问题的解决方案，提高自己的编程能力和数据分析能力。另外，这些算法大赛通常会提供大量的数据集和评测标准，我们需要根据数据集训练模型，并提交预测结果，最终根据评测标准来评价模型的性能。
提示
本项目仅评价工程能力，即项目完成度。
以日常中交通违法为例，交管在路口设有自动抓拍系统。
这个系统利用图片的相似性比较，如果发现有车辆闯红灯，或者违法停车，就会自动拍摄车辆的照片。
同时记录时间、摄像头位置等信息。
系统识别车牌。
然后通过车牌号码在信息库里获取车主 的号码，并自动发送短信。（如果我们自己需要完整的模拟整个流程，可以改成电子邮箱）
【交管通知】尊敬的XXX，您好，您的车辆在XX点XX分XXX路口违规，请XXXX,违法照片请点击XXXX，申诉请点击XXX。
这个流程非常清晰，车牌识别是一个非常重要的环节。
搜索数据集
我们从以上的算法大赛中选择一个数据集，然后通过数据集来训练模型。
这里以下面这个数据集（约200MB）为例：
下载方式1（Kaggle）：https://www.kaggle.com/datasets/andrewmvd/car-plate-detection/data
下载方式2（阿里云天池）：https://tianchi.aliyun.com/dataset/90055
观察数据集
我们把数据集下载下来，简单的研究一下。
发现里面有2个文件夹，一个是images（图像），另一个是annotations（注释）
通过观察我们可以轻松发现annotations中的文件名.xml和images中的文件名.png是一一对应的。
其中文件名.xml中包含了车牌的位置信息，如下：
<annotation>
<folder>图片</folder>
<filename>Cars0.png</filename>
<size>
<width>500</width>
<height>268</height>
<depth>3</depth>
</size>
<segmented>0</segmented>
<object>
<name>licence</name>
<pose>未指定</pose>
<truncated>0</truncated>
<occluded>0</occluded>
<difficult>0</difficult>
<bndbox>
<xmin>226</xmin>
<ymin>125</ymin>
<xmax>419</xmax>
<ymax>173</ymax>
</bndbox>
</object>
</annotation>
通过观察可以发现，我们可以通过解析文件名.xml文件，通过两点定位获取车牌的位置信息，然后通过文件名.png文件，获取车牌的图像信息。
提示
如果这个数据集没有标注，我们可以通过判断图片中矩形的位置，来获取车牌的位置信息。具体方法与火山下的文明一课中的方法类似。
处理数据集
根据下方代码提示补全，未提及内容已经补全，需要补全的内容已经标注。
正确处理之后的代码，可以将整个车牌的图像裁剪出来，保存到cropped_images目录下。
split_images.py
# 导入xml.etree.ElementTree库，用于处理XML文件
import xml.etree.ElementTree as ET
# 导入os库，用于处理文件和目录
import os
# 导入PIL库的Image模块，用于处理图像
from PIL import Image
# 定义一个函数parse_xml，参数为xml文件的路径
def parse_xml(xml_file) -> dict:
# 解析xml文件，获取ElementTree对象
tree = ET.parse(xml_file)
# 获取xml文件的根元素
root = tree.getroot()
# 初始化一个空字典来存储数据
data = {}
# 从xml文件中获取各个元素的值，并存储到字典中
data['folder'] = root.find('folder').text
data['filename'] = root.find('filename').text
data['width'] = root.find('size/width').text
data['height'] = root.find('size/height').text
data['depth'] = root.find('size/depth').text
data['segmented'] = root.find('segmented').text
# 初始化一个空列表来存储所有的对象数据
objects = []
# 遍历xml文件中的所有'object'元素
for obj in root.findall('object'):
# 初始化一个空字典来存储当前对象的数据
obj_data = {}
# 从'object'元素中获取各个子元素的值，并存储到字典中
obj_data['name'] = obj.find('name').text
obj_data['pose'] = obj.find('pose').text
obj_data['truncated'] = obj.find('truncated').text
obj_data['occluded'] = obj.find('occluded').text
obj_data['difficult'] = obj.find('difficult').text
obj_data['xmin'] = obj.find('bndbox/xmin').text
obj_data['ymin'] = obj.find('bndbox/ymin').text
obj_data['xmax'] = obj.find('bndbox/xmax').text
obj_data['ymax'] = obj.find('bndbox/ymax').text
# 将当前对象的数据添加到对象列表中
objects.append(obj_data)
# 将对象列表添加到数据字典中
data['objects'] = objects
# 返回数据字典
return data
# 定义一个函数get_coordinates，参数为从parse_xml函数返回的数据字典
def get_coordinates(data:dict) -> tuple:
# 获取数据字典中的第一个对象
# 返回对象的xmin, ymin, xmax, ymax值（转换为整数）
# 定义一个函数crop_image，参数为图片路径、坐标和新图片路径
def crop_image(image_path:str, coordinates:tuple,new_image_path:str) -> None:
# 打开图片 提示 .open
# 根据给定的坐标裁剪图片
cropped_img = img.crop(coordinates)
# 保存裁剪后的图片到新的路径 提示- .save
def split_bndbox():
# 遍历'annotations'目录下的所有文件
for annotations in os.listdir('annotations'):
# 构建annotations文件的完整路径
# 构建对应的图片文件路径
# 构建裁剪后的新图片路径
# 如果'cropped_images'目录不存在，则创建
# 解析annotations文件，获取数据
# 从数据中获取坐标
coordinates = get_coordinates(data)
# 根据坐标裁剪图片，并保存到新的路径
crop_image(image_path, coordinates , new_image_path)
if __name__ == '__main__':
split_bndbox()
车牌二次分割与人工标注
通过人眼的观察，对车牌进行标注，例如
此过程你也可以删除一些你认为不佳的图片，譬如：Cars129 以提高模型的训练效果。
我们可以把数据拆解并分类为一个个独立的车牌数字图片，例如Cars432应该被标注为DL49AK49，拆分为8个独立的小图片，分别为D/1.png、L/1.png、4/1.png、9/1.png、A/1.png、K/1.png、4/2.png、9/2.png。
表示字母D的图片保存在D文件夹下，表示数字1的图片保存在1文件夹下。
分类完成之后二值化（最后二值化是因为有些字母或数字二值化后难以分辨）
这样拆解完400+张照片后，假设每张照片有6个小图片，那么我们就有2400+张小图片。平均分布在26个字母和10个数字上，每个字母和数字大概有80张图片。
通过人工标注，检查这些小图片是否正确，如果不正确，可以移动到对应的文件夹，或者删除错误的图片。
另外我们从images文件夹中，选几张图片，标注后放在test文件夹下，用于测试模型的准确度。
提示
这个过程非常重要，直接影响模型的准确度。
课后有时间可以小组合作，体验下这个过程，把所有图片全部拆解完后的模型准确度应该会有一个较大的提升。
训练模型
解压后，我们当前的文件夹应该是这样的，
├── archive
│ ├── class_0
│ │ ├── 0_1.png
│ │ ├── 0_2.png
│ │ ├── ...
│ ├── class_1
│ │ ├── 1_1.png
│ │ ├── 1_2.png
│ │ ├── ...
│ ├── ...
├── annotations
│ ├── Cars0.xml
├── test
├── split_images.py
├── train_model.py
├── predict.py
现在其他文件夹都是过程文件，archive文件夹是结果文件，里面存放了所有分类好的车牌图片。
我们可以通过下方代码模板训练模型，至少完成一种。
train_model.py
import split_images
def model(model_name:str,img_path:str) -> str:
if model_name == 'model1':
return '识别结果1'
elif model_name == 'model2':
return '识别结果2'
elif model_name == 'model3':
return '识别结果3'
sklearn部分的参考代码（需要封装为函数）：
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
# 加载数据集
digits = datasets.load_digits()
# 数据预处理
X = digits.data
y = digits.target
# 分割数据集为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 数据标准化
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
# 创建 KNN 分类器
knn = KNeighborsClassifier(n_neighbors=3)
# 训练模型
knn.fit(X_train, y_train)
# 预测测试集结果
y_pred = knn.predict(X_test)
# 计算预测准确率
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy: ' + str(accuracy))
效果展示
我们可以通过下方代码，将模型应用到新的图片上。(固定格式，无需修改)
predict.py
import train_model
import os
for test_img in os.listdir('test'):
test_img_path = os.path.join('test',test_img)
print(test_img,':',end='')
for i in ['model1','model2','model3']:
model = train_model.model(i,test_img_path)
print(model,'|',end='')
print()
运行结果应该是这样的：
DZ17YXR.png :识别结果1 |识别结果2 |识别结果3 |
PGMN112.png :识别结果1 |识别结果2 |识别结果3 |
由于本项目侧重考察工程能力，因为不添加准确度判断，所以只要能够运行即可。
单选题
-
Python 中用于打印输出的函数是：
- A. print()
- B. printf()
- C. echo()
- D. println()
- 答案: A
-
Python 中表示列表的方法是：
- A.
{} - B.
[] - C.
() - D.
<> - 答案: B
- A.
-
Python 中如何计算 2 的 5 次方？
- A. 2^5
- B. 2**5
- C. pow(2, 5)
- D. 2*5
- 答案: B
-
Python 中用于检查数据类型的函数是：
- A. type()
- B. isinstance()
- C. checktype()
- D. datatype()
- 答案: A
-
Python 中定义函数的关键字是：
- A. def
- B. func
- C. function
- D. lambda
- 答案: A
-
Python 中表示注释的方法是：
- A. //
- B. #
- C. /*
- D. --
- 答案: B
-
Python 中用于获取列表长度的函数是：
- A. length()
- B. size()
- C. len()
- D. count()
- 答案: C
-
Python 中用于生成范围的函数是：
- A. range()
- B. xrange()
- C. interval()
- D. span()
- 答案: A
-
Python 中用于捕获异常的关键字是：
- A. try
- B. except
- C. catch
- D. finally
- 答案: A
-
Python 中表示布尔值 False 的常量是：
- A. None
- B. false
- C. 0
- D. False
- 答案: D
-
以下哪个方法可以用于将字符串转换为大写？
- A. str.upper()
- B. str.upcase()
- C. str.capitalize()
- D. str.toupper()
- 答案: A
-
Python 中用来检查字典中是否存在某个键的方法是：
- A. has_key()
- B. exists()
- C. in
- D. find()
- 答案: C
-
Python 中如何导入标准库模块 math？
- A. import mathlib
- B. include math
- C. import math
- D. load math
- 答案: C
-
Python 中用于创建空集合的方法是：
- A. set()
- B.
- C. []
- D. ()
- 答案: A
-
以下哪种 Python 数据类型是不可变的？
- A. 列表
- B. 字典
- C. 集合
- D. 元组
- 答案: D
-
Python 中如何读取文件内容？
- A. open(file).read()
- B. read(file)
- C. file.read()
- D. open(file, 'r').read()
- 答案: D
-
以下哪个函数可以用于将字符串转换为整数？
- A. str()
- B. int()
- C. float()
- D. chr()
- 答案: B
-
Python 中如何定义类？
- A. class MyClass:
- B. def MyClass:
- C. function MyClass:
- D. object MyClass:
- 答案: A
-
以下哪个 Python 内置函数可以用于排序？
- A. sort()
- B. sorted()
- C. arrange()
- D. order()
- 答案: B
-
Python 中用于表示换行的转义字符是：
- A. \t
- B. \r
- C. \n
- D. \b
- 答案: C
-
以下哪个方法可以用于删除字典中的一个键值对？
- A. dict.remove()
- B. dict.delete()
- C. dict.pop()
- D. dict.drop()
- 答案: C
-
以下哪种数据结构在 Python 中是线程安全的？
- A. 列表
- B. 字典
- C. 队列
- D. 集合
- 答案: C
- Python 中如何启动一个 HTTP 服务器？
- A. http.server.start()
- B. python -m http.server
- C. http.start()
- D. python -m SimpleHTTPServer
- 答案: B
- Python 中生成随机数的模块是：
- A. random
- B. randint
- C. numpy
- D. math
- 答案: A
- 以下哪个方法可以用于深拷贝对象？
- A. copy.copy()
- B. deepcopy()
- C. object.clone()
- D. copy.deepcopy()
- 答案: D
- 在 Python 中，如何定义一个生成器函数？
- A. 使用 return 语句
- B. 使用 yield 语句
- C. 使用 generate 语句
- D. 使用 yield from 语句
- 答案: B
- Python 中如何实现模块的相对导入？
- A. from . import module
- B. from ..module import class
- C. from module import class
- D. import .module
- 答案: A
- Python 中，以下哪种方法可以避免死锁？
- A. 使用锁
- B. 使用信号量
- C. 使用条件变量
- D. 使用上下文管理器
- 答案: D
- 在 Python 中，如何创建一个元类？
- A. class Meta(type):
- B. class Meta(object):
- C. class Meta(meta):
- D. class Meta(super):
- 答案: A
- 以下哪种方法可以用于提高 Python 代码的执行效率？
- A. 使用多线程
- B. 使用多进程
- C. 使用协程
- D. 使用 Cython
- 答案: D
判断题
-
Python 是一种编译型语言。
- 对
- 错
- 答案: 错
-
在 Python 中，
print()函数用于输出信息到控制台。- 对
- 错
- 答案: 对
-
Python 中，列表可以包含不同类型的元素。
- 对
- 错
- 答案: 对
-
Python 中的字典是通过键值对存储数据的。
- 对
- 错
- 答案: 对
-
在 Python 中，
if语句用于条件判断。- 对
- 错
- 答案: 对
-
Python 中的元组是可变的。
- 对
- 错
- 答案: 错
-
在 Python 中，
def关键字用于定义函数。- 对
- 错
- 答案: 对
-
Python 中，字符串是不可变的。
- 对
- 错
- 答案: 对
-
在 Python 中，
for循环用于遍历可迭代对象。- 对
- 错
- 答案: 对
-
Python 中，
break语句用于终止循环。- 对
- 错
- 答案: 对
-
Python 中的注释行以
#开头。- 对
- 错
- 答案: 对
-
在 Python 中，
range()函数用于生成数字序列。- 对
- 错
- 答案: 对
-
Python 中的类使用
class关键字定义。- 对
- 错
- 答案: 对
-
Python 中，
import语句用于引入模块。- 对
- 错
- 答案: 对
-
Python 的列表和元组都是可变的。
- 对
- 错
- 答案: 错
- 在 Python 中，
lambda函数可以包含多条语句。
- 对
- 错
- 答案: 错
- Python 中的生成器函数使用
yield关键字。
- 对
- 错
- 答案: 对
- 在 Python 中，
self是类方法的第一个参数。
- 对
- 错
- 答案: 对
- Python 中的元类是用于创建类的类。
- 对
- 错
- 答案: 对
- 在 Python 中，装饰器是用于修改函数行为的函数。
- 对
- 错
- 答案: 对
多选题
-
在 Python 中，下列哪些是数据类型？
- A. list
- B. dict
- C. set
- D. int
- 答案: A, B, C, D
-
在 Python 中，以下哪些是常用的字符串方法？
- A. upper()
- B. lower()
- C. split()
- D. append()
- 答案: A, B, C
-
在 Python 中，以下哪些是合法的变量名？
- A. _var
- B. var1
- C. 1var
- D. var_2
- 答案: A, B, D
-
Python 中的字典方法有哪些？
- A. keys()
- B. values()
- C. append()
- D. items()
- 答案: A, B, D
-
在 Python 中， 以下哪些模块是标准库的一部分？
- A. os
- B. sys
- C. random
- D. numpy
- 答案: A, B, C
-
Python 中，以下哪些运算符用于比较运算？
- A.
== - B.
!= - C.
<= - D.
+ - 答案: A, B, C
- A.
-
在 Python 中，以下哪些关键字用于异常处理？
- A. try
- B. except
- C. finally
- D. throw
- 答案: A, B, C
-
在 Python 中，哪些函数可以用于类型转换？
- A. int()
- B. str()
- C. float()
- D. list()
- 答案: A, B, C, D
-
Python 中，哪些方法可以用于文件操作？
- A. open()
- B. read()
- C. write()
- D. close()
- 答案: A, B, C, D
-
在 Python 中，哪些是常见的内置函数？
- A. map()
- B. filter()
- C. reduce()
- D. zip()
- 答案: A, B, D