{ "bankKey": "python", "version": "2026-06-26T13:53:58+08:00", "updatedAt": "2026-06-26T05:53:58.110Z", "meta": { "total": 1964, "typeCounts": { "single": 1604, "fill": 360, "judge": 0 }, "knowledgePoints": [ "程序填空/调试", "分支结构", "函数", "基础语法与输入输出", "列表/元组", "面向对象", "数据类型与表达式", "算法与综合应用", "文件操作", "循环结构", "异常与库", "字典/集合", "字符串", "random/turtle等标准库" ], "ids": [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964 ], "displayTypeCounts": { "single": 1604, "fill": 298, "judge": 0, "operation": 62 } }, "questions": [ { "id": 1, "q": "在Python中，输入2和3.5，输出5.5，以下正确的程序是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "x=eval(input())\ny=eval(input())\nprint(x+y)", "x=input()\ny=input()\nprint(eval(x+y))", "x=input()\ny=input()\nprint(float(x+y))", "x=input()\ny=input()\nprint(int(x+y))" ], "explanation": "input()返回字符串，若直接相加会进行字符串拼接。使用eval()可将输入的字符串解析为对应的数值类型（如整数和浮点数），从而实现数学加法运算得到5.5。其他选项中x+y先进行字符串拼接为'23.5'，再转换类型无法得到5.5。" }, { "id": 2, "q": "设x=5,则表达式x/2>x//2的值为（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "在Python中，/表示真除法，x/2结果为浮点数2.5；//表示地板除（整除），x//2结果为整数2。比较2.5>2结果为真。Python中布尔值真和假分别用True和False表示，首字母必须大写，因此正确选项为True。" }, { "id": 3, "q": "关于if单分支选择结构，下列说法正确的是（ ）", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "在if语句的表达式后面必须加冒号。", "if 中表示条件的表达式必须是结果为True或False的关系表达式或逻辑表达式。", "如果语句块中只有一条语句，if语句不可以写在同一行上。", "语句块只能是单个语句" ], "explanation": "Python语法规定，if语句的条件表达式后必须跟冒号以引导缩进的代码块。条件表达式不局限于关系或逻辑表达式，任何可求值为布尔值的对象均可；若只有一条语句，可以写在同一行；语句块也可以包含多条语句，因此其他选项错误。" }, { "id": 4, "q": "设有程序段：\nk=10\nfor i in range(1,11):\n    k=k-1\nprint(k)\n则下面描述中正确的是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "for循环执行10次", "循环是无限循环", "循环体语句一次也不执行", "循环体语句执行一次" ], "explanation": "range(1, 11)生成的序列包含1到10共10个整数，因此for循环体会精确执行10次。每次循环k减1，最终k变为0。该循环有明确的迭代范围，不是无限循环，也不会不执行或只执行一次，故正确描述为循环执行10次。" }, { "id": 5, "q": "关于while循环和for循环的区别，下列叙述中正确的是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "while语句的循环体至少无条件执行一次，for语句的循环体有可能一次都不执行", "while语句只能用于循环次数未知的循环，for语句只能用于循环次数已知的循环", "在很多情况下，while语句和for语句可以等价使用", "while语句只能用于可迭代变量，for语句可以用任意表达式表示条件" ], "explanation": "while循环是条件循环，for循环是迭代循环。两者在很多场景下可通过设置计数器和条件判断实现等价转换。while并非至少执行一次（条件初始为假时不执行），for也不仅限于次数已知的循环，且while用条件表达式而非可迭代变量。" }, { "id": 6, "q": "字符比较是按计算机内部字符编码值的大小进行比较，以下比较规则正确的是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "空格<数字<字母", "空格<字母<数字", "数字<空格<字母", "字母<空格<数字" ], "explanation": "字符比较基于ASCII码值。空格的ASCII码为32，数字'0'到'9'为48到57，大写字母为65到90，小写字母为97到122。因此整体编码值大小顺序为空格小于数字，数字小于字母，选项A符合此规则。" }, { "id": 7, "q": "s=\"1234567890\"，以下表示'1234'的选项是（）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "s[1:5]", "s[0:3]", "s[-10:-5]", "s[0:4]" ], "explanation": "Python字符串切片语法为s[start:end]，包含start索引但不包含end索引。'1234'是字符串的前4个字符，索引分别为0、1、2、3。因此切片起点为0，终点为4，即s[0:4]。s[1:5]截取的是'2345'，s[0:3]截取的是'123'。" }, { "id": 8, "q": "表达式[2,3,4]<[2,4]的值是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "true", "false", "True", "False" ], "explanation": "Python中列表比较按元素逐个进行。首先比较第一个元素2和2，相等；接着比较第二个元素3和4，因为3小于4成立，所以直接返回真值，不再比较后续元素。Python的布尔真值必须首字母大写，即True，小写会报错。" }, { "id": 9, "q": "请给出下面代码段的正确答案（）\nA = {1,3,6,12,24}\nB = {2,6,12,36}\nA.union(B)\nB.difference(A)\nprint(A^B)", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "{1,2,3,6,12,24,36}", "= {2,6,12,36}\n{1,3,6,12,24}", "{1,2,3,24,36}", "{}" ], "explanation": "集合的`^`运算符表示对称差集，即包含在A或B中但不同时在两者中的元素。A和B的交集为{6, 12}，从并集中去除交集元素即得{1, 2, 3, 24, 36}。前面的`union`和`difference`方法未重新赋值，不改变原集合。" }, { "id": 10, "q": "下列代码运行后的结果是（ ）。\ndef dig(x):\n    if x>0:\n        dig(x//3)\n    print(x,end=' ')\n   \nif __name__ == '__main__':\n    dig(8)", "t": "single", "ans": "A", "kp": "函数", "o": [ "0 2 8", "8 2 0", "0", "8" ], "explanation": "本题考查递归函数的执行顺序。当调用`dig(8)`时，满足`x>0`，先递归调用`dig(2)`；在`dig(2)`中继续递归调用`dig(0)`。`dig(0)`不满足条件，直接打印`0`并返回；随后`dig(2)`打印`2`并返回；最后`dig(8)`打印`8`。因此输出顺序为0 2 8。" }, { "id": 11, "q": "下列程序的运行结果是（ ）。\nadd=lambda x,y,z=6:y**x+z/x\nh=add(x=2,y=3,z=4)\nprint(h)", "t": "single", "ans": "C", "kp": "函数", "o": [ "12", "12.0", "11.0", "11" ], "explanation": "本题考查lambda表达式及参数传递。函数定义为`y**x + z/x`。调用时传入`x=2, y=3, z=4`，覆盖默认参数`z=6`。计算过程为`3**2 + 4/2`，即`9 + 2.0`。由于除法`/`在Python 3中返回浮点数，最终结果为`11.0`。" }, { "id": 12, "q": "不同的对象收到同一种消息时会产生不同的行为，这种现象称为（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "封装", "继承", "多态", "以上都不是" ], "explanation": "本题考查面向对象的基本概念。多态是指不同的对象接收到相同的消息（方法调用）时，能够根据自身的类型产生不同的行为或执行不同的操作。封装是隐藏内部实现，继承是子类复用父类代码，均不符合题意。" }, { "id": 13, "q": "以下代码的输出结果是（）\nprint(0.1+0.2==0.3)", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "-1", "True", "False", "0" ], "explanation": "本题考查浮点数精度问题。在计算机中，浮点数以二进制形式存储，`0.1`和`0.2`无法被精确的二进制小数表示，导致`0.1+0.2`的实际计算结果略大于`0.3`。因此，两者直接进行相等性比较时结果为`False`。" }, { "id": 14, "q": "下列选项中，不属于Python特点的是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "面向对象", "简单优雅", "非开源", "丰富的数据类型" ], "explanation": "本题考查Python语言的基本特性。Python是一种开源的编程语言，拥有庞大的开源社区和丰富的第三方库。同时，它支持面向对象编程，语法简单优雅，且内置了列表、字典等丰富的数据类型。因此\"非开源\"不属于其特点。" }, { "id": 15, "q": "下列程序的运行结果是（ ）\nx=y=10\nx,y,z=x-1,x,x+1\nprint(x,y,z)", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "9 10 11", "9 9 10", "10 11 12", "10 10 11" ], "explanation": "本题考查Python的多重赋值与元组解包。在等号右侧，表达式`x-1, x, x+1`会先根据当前`x=10`的值计算出一个元组`(9, 10, 11)`。然后将其依次解包赋值给左侧的`x, y, z`。因此最终`x`为9，`y`为10，`z`为11。" }, { "id": 16, "q": "在python中，想输出一行文字，要用到的函数是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "input()", "random()", "print()", "float()" ], "explanation": "本题考查Python的基础输入输出函数。`print()`函数用于将指定的内容输出到标准输出设备（如屏幕）；`input()`用于接收用户输入；`random()`不是内置函数，需导入random模块；`float()`用于将数据转换为浮点型。" }, { "id": 17, "q": "下面关于注释的说法中错误的是：（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "注释不是程序的一部分，因此用什么文字写都行", "Python中的注释以\"/*\"开头，以\"*/\"结束，之间的文字就是注释", "Python中的单行注释采用#开头", "Python中的注释也可用三引号括起来" ], "explanation": "Python中的多行注释或文档字符串通常使用三个单引号或双引号，单行注释使用#。以/*开头和*/结尾是C/C++或Java等语言的注释语法，并非Python语法。因此选项B说法错误，符合题意。" }, { "id": 18, "q": "下列语句执行后的输出是（）。\nx=-5\nif x<2:\n print(5)\nelif x>30:\n print(6)\nelse:\n print(7)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "56", "7", "5", "6" ], "explanation": "x=-5时先判断x<2，条件成立，因此执行第一个分支输出5。由于if分支已经执行，后面的elif和else不再判断或执行。" }, { "id": 19, "q": "以下代码的输出结果是（）。\na=20\nb=30\nif a>b:\n    c=a\nelse:\n    c= b\nprint(c)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "20", "30", "报错", "False" ], "explanation": "代码首先赋值a=20，b=30。接着判断条件a>b，即20>30，结果为False。因此程序跳过if分支，执行else分支，将b的值30赋给变量c。最后打印c的值，输出结果为30。此代码实现了求两数较大值的功能。" }, { "id": 20, "q": "3.5>1 and 3.5<1 的值为（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "表达式包含逻辑与运算（and）。首先计算左侧3.5>1，结果为True；计算右侧3.5<1，结果为False。根据and运算规则，两侧必须全为True结果才为True，否则为False。因此最终求值结果为False，且Python布尔值首字母需大写。" }, { "id": 21, "q": "以下代码的输出结果为（）。\nage=12\nif 12<=age<=17:\n   if age<=12:\n      print(\"小学生\")\n   else:\n      print(\"中学生\")\nelse:\n   print(\"大学生\")", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "中学生", "小学生", "大学生", "是学生吗" ], "explanation": "外层条件12<=12<=17成立，进入内层if语句。内层条件12<=12同样成立，因此执行print(\"小学生\")，不会执行else分支。" }, { "id": 22, "q": "设有程序段：\nk=5\nwhile k:\n     print(k,end='')\n     k=k-1\n则程序的运行结果是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "54321", "43210", "12345", "01234" ], "explanation": "k初始为5，while k在k非0时条件为真。每次循环打印当前k值并不换行，然后k减1。当k从5递减到1时均满足条件，k为0时循环结束，因此输出54321。" }, { "id": 23, "q": "以下程序段的运行结果是（ ）。\nx=y=0\nwhile True:\n    x+=1\n    if not(x%2):\n          continue\n    elif x>10:\n          break\n    else:\n          y+=x\nprint(\"y=\",y)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "y=10", "y=15", "y=20", "y=25" ], "explanation": "循环中x每次加1。当x为偶数时continue跳过；当x为大于10的奇数即11时break退出；当x为小于等于10的奇数时累加到y。y=1+3+5+7+9=25。" }, { "id": 24, "q": "以下代码的输出结果是（ ）。\nfor c in ('a','e','i'):\n    pass\nelse:\n    print('****')", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "****", "a", "e", "i" ], "explanation": "for循环遍历元组元素，循环体pass不执行任何操作。循环正常结束且未被break中断后，会执行else子句，因此输出****。" }, { "id": 25, "q": "执行下列程序后while循环执行了 （ ） 次。\nfor t in range(0,10):\n      i=-1\n      while i<0:\n            i*=i\n            print(i)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "10", "2", "5", "7" ], "explanation": "外层for循环遍历0到9共10次。每次循环内部将i初始化为-1，进入while循环后执行i*=i使i变为1并打印，随后条件i<0不成立退出while。因此while循环体总共执行了10次。" }, { "id": 26, "q": "令list=[1,2,3,4,5]，则print(list[0:5:-2])的结果为（ ）", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "[1,2,3]", "[1,2]", "[1]", "[]" ], "explanation": "切片语法为[start:stop:step]。当step为负数时，要求start必须大于stop才能取到元素。本题start为0，stop为5，0<5且步长为负，因此返回空列表。" }, { "id": 27, "q": "下列有关函数的说法中，正确的是（ ）", "t": "single", "ans": "D", "kp": "函数", "o": [ "函数的定义必须在程序开头", "函数定义后，其中的程序就可以自动执行", "函数体与关键字def必须左对齐", "函数定义后需要调用才会执行" ], "explanation": "函数定义只是将代码块封装，不会自动执行，必须通过函数名进行调用才会运行。函数可以定义在程序任意位置，且函数体必须相对def关键字进行缩进，不能左对齐。" }, { "id": 28, "q": "下列代码的运行结果是（ ）。\nf=lambda x,y=2,z=3:x+y%x+z//3\nprint(f(4,7,2))", "t": "single", "ans": "B", "kp": "函数", "o": [ "8", "7", "1", "5" ], "explanation": "调用f(4,7,2)时，x=4，y=7，z=2。表达式为x+y%x+z//3。根据运算符优先级，先计算y%x即7%4得3，再计算z//3即2//3得0。最后计算加法4+3+0=7。" }, { "id": 29, "q": "以下关于函数参数描述不正确的是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "Python语言中,不定长参数也称可变长度参数，不定长参数主有要元组和字典两种形式。", "在形参名前面加“*”号，将按受的任意多个实参存放在一个元组中。", "在位置传参与关键字传参同时存在的情况下，关键字传参可以在位置传参之前，也可以在位置传参之后。", "在形参名前面加两个“**”号，实参名以字典显式赋值的方式传递参数，将接收的参数存放在字典中。" ], "explanation": "在函数调用时，位置参数必须出现在关键字参数之前，否则会导致语法错误。选项A、B、D对不定长参数和字典参数的描述均符合Python语法规则。" }, { "id": 30, "q": "关于对象的属性，说法正确的是（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "公有属性可以直接在类外通过对象名访问", "公有属性名前面需要加2个下划线", "私有属性名前面需要加1个下划线", "私有属性可以直接在类外通过对象名访问" ], "explanation": "公有属性没有下划线前缀限制，可以直接在类外部通过对象名进行访问。私有属性通常以双下划线开头，不能在类外直接访问；单下划线开头通常表示保护属性。" }, { "id": 31, "q": "下面关于Python语言的说法中正确的是（）", "t": "single", "ans": "D", "kp": "异常与库", "o": [ "Python不支持面向对象程序设计", "Python中使用的所有函数库，都是用Python语言来编写的", "Python中的内置函数需要使用关键字import来导入，而不能直接使用", "Python中如果导入了某个模块，在后面的代码中就可以使用它的所有公共函数、类和属性" ], "explanation": "Python支持面向对象；部分标准库和第三方库底层由C/C++编写；内置函数无需导入即可直接使用。使用import导入模块后，即可通过模块名访问其公共成员。" }, { "id": 32, "q": "下面哪个是定义继承了furniture类的table类的正确语法？（ ）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "class furniture[table]:", "class table.furniture:", "class furniture(table):", "class table(furniture):" ], "explanation": "Python中定义子类继承父类的语法为\"class 子类名(父类名):\"。因此table继承furniture的正确写法是class table(furniture):。" }, { "id": 33, "q": "下列程序的输出结果是（）？\nf=open('D:\\\\out.txt','w+')\nf.write('Python')\nf.seek(3,0)\nc=f.read(4)\nprint(c)\nf.close()", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "Py", "Python", "th", "hon" ], "explanation": "seek(3,0)将文件指针移动到索引3的位置（即字符'h'），read(4)尝试读取4个字符，但由于文件剩余内容只有'hon'3个字符，因此实际读取并输出'hon'。" }, { "id": 34, "q": "以下程序的运行结果是[*queNo*]_______。\ns=[1,2,3,4,5]\nsum=0\nfor x in s:\n    sum+=x\nprint('sum={}'.format(sum))", "t": "fill", "ans": "sum=15", "kp": "循环结构", "o": [], "explanation": "程序遍历列表s中的元素并累加到变量sum中，1+2+3+4+5=15。最后使用format方法格式化输出字符串'sum=15'。" }, { "id": 35, "q": "下列程序运行的结果是什么？\ndef calculate_sum(dictionary):\n    values = dictionary.values()\n    total = sum(values)\n    return total\nmy_dict = {'a': 1, 'b': 2, 'c': 3}\nresult = calculate_sum(my_dict)\nprint(result)", "t": "fill", "ans": "6", "kp": "字典/集合", "o": [], "explanation": "函数calculate_sum通过values()方法获取字典的所有值（1, 2, 3），并使用内置函数sum()求和，最终返回并打印结果6。" }, { "id": 36, "q": "以下程序段的输出结果是[*queNo*]。\na = [3, 2, 1]\nif a:\n      print(a[0])", "t": "fill", "ans": "3", "kp": "列表/元组", "o": [], "explanation": "非空列表在条件判断中等价于True，因此执行if分支。a[0]获取列表的第一个元素，输出结果为3。" }, { "id": 37, "q": "考生文件夹下存在一个文件PY103.py，请写代码替换横线，不修改其他代码，实现以下功能：\n以100为随机数种子，随机生成3个在1(含)到9(含)之间的随机数，计算这三个随机数的立方和。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import random\nrandom.seed([x])\n注意：seed()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。\n参数x -- 改变随机数生成器的种子seed。\nrandint(a,b)随机数中是包括a和b区间的数。\n求某数n立方就是求n的3次方，即n**3。\n参考代码如下：\nimport random\nrandom.seed(100) # 此处可多行\ns = 0 #\nfor i in range(3):\nn=random.randint(1,9)\ns=s+n**3# 此处可多行\nprint(s)", "kp": "random/turtle等标准库", "o": [], "rawType": "operation" }, { "id": 38, "q": "以下关于二进制整数的定义，正确的是（）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "0B1014", "0b1010", "0B1019", "0bC3F" ], "explanation": "Python中二进制整数以0b或0B开头，且后续字符只能是0或1。选项B符合规则，其他选项包含了非0或1的非法字符。" }, { "id": 39, "q": "以下关于random库的描述，错误的是（）。", "t": "single", "ans": "A", "kp": "random/turtle等标准库", "o": [ "random库是Python的第三方库", "通过from random import*可以引入random随机库", "设定相同种子，每次调用随机函数生成的随机数相同", "通过import random可以引入random随机库" ], "explanation": "random是Python的内置标准库，不是第三方库，无需额外安装即可使用。其他选项关于导入方式、随机种子和引入方法的描述均正确。" }, { "id": 40, "q": "下列有关算法的描述正确的是（ ）", "t": "single", "ans": "C", "kp": "算法与综合应用", "o": [ "算法都不必在有限步骤内实现", "解决问题的算法是唯一的", "流程图是描述算法的常用方法", "算法都至少包含一条输入指令" ], "explanation": "算法具有有穷性，必须在有限步骤内结束；解决问题的算法可以有多种；算法可以有零个或多个输入。流程图是描述算法的常用图形化方法，故选C。" }, { "id": 41, "q": "以下代码的输出结果是（）。\nn=50\ns=10\nif n<=5:\n    n-=10\ns=30\nprint(s)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "30", "40", "10", "50" ], "explanation": "条件n<=5为False，不执行n-=10。由于s=30没有缩进，不属于if语句块，因此无论条件是否成立都会执行，最终s被重新赋值为30并输出。" }, { "id": 42, "q": "以下代码的输出结果是（ ）。\nfor c in range(8,0,-1):\n    pass\nelse:\n    print('@@@@')", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "@@@@", "8", "0", "-1" ], "explanation": "for循环遍历range生成的序列，循环体内只有pass。循环正常结束（未被break中断）后，会执行else子句，因此输出'@@@@'。" }, { "id": 43, "q": "设有程序段：\ns='*'\nfor i in (\"A\",\"O\",\"I\"):\n     pass\n     print(s, end= '')\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "打印3个A", "打印3个*", "打印3个O", "打印3个I" ], "explanation": "循环遍历包含3个元素的元组，循环体中pass不执行任何操作，随后打印变量s的值'*'且不换行。循环执行3次，最终输出3个'*'。" }, { "id": 44, "q": "下面代码的输出结果是（）。\nstr1=\"mysqlsqlserverPostgresQL\"\nstr2=\"sql\"\nncount=str1.index(str2)\nprint(ncount)", "t": "single", "ans": "D", "kp": "字符串", "o": [ "0", "3", "4", "2" ], "explanation": "index()方法返回子串在原字符串中首次出现的起始索引。'sql'在'mysqlsqlserverPostgresQL'中首次出现的位置是从索引2开始，因此输出2。" }, { "id": 45, "q": "对于字典D={'A':10,'B':20,'C':30,'D':40}，对第4个字典元素的访问形式是（ ）。", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "D[3]", "D[4]", "D[D]", "D['D']" ], "explanation": "字典元素通过键（key）来访问，而不是通过数字索引。第4个元素的键是'D'，因此正确的访问形式是D['D']。" }, { "id": 46, "q": "下列代码运行后的结果是（ ）。\ndef total(x):\n    if x>6:\n        return x+total(x-2)\n    else:\n        return 3\nprint(\"{}\".format(total(10)))", "t": "single", "ans": "C", "kp": "函数", "o": [ "18", "20", "21", "24" ], "explanation": "本题考查递归函数调用。当x=10时，满足x>6，返回10+total(8)；x=8时，返回8+total(6)；x=6时不满足x>6，返回3。最终结果为10+8+3=21。" }, { "id": 47, "q": "以下程序运行后输出的结果是（ ）\ndef ty(*k):\n      print(k)\nty(7,8,9)", "t": "single", "ans": "A", "kp": "函数", "o": [ "(7,8,9)", "7,8,9", "7 (8,9)", "(7,8) 9" ], "explanation": "本题考查函数的可变参数。在函数定义中使用星号（如*k），会将传入的多个位置参数打包成一个元组。调用ty(7,8,9)时，参数被打包为元组(7, 8, 9)并打印。" }, { "id": 48, "q": "关于turtle库绘图函数，下列哪个选项的描述是错误的？（ ）", "t": "single", "ans": "B", "kp": "random/turtle等标准库", "o": [ "turtle.fd(distance)函数的作用是向小海龟当前行进方向前进distance距离，可以为负数", "turtle.circle(radius, extent=None)函数的作用是绘制一个椭圆形，extent参数可选", "turtle.setup函数的作用是设置主窗体的大小和位置", "turtle.pensize(size)函数的作用是改变画笔的宽度为size像素" ], "explanation": "本题考查turtle库绘图函数。turtle.circle(radius, extent)用于绘制圆形或圆弧，而不是椭圆形，因此选项B描述错误。其他选项关于前进、设置窗口和画笔宽度的描述均正确。" }, { "id": 49, "q": "从键盘输入x的值，根据下面的表达式，计算并输出y的值。\n       x 2+2x+1 (x<10)\ny=  100            (x=10)\n     100x          (x>10)\nx=eval(input(\"请输入x:\"))\nif ___1__:\n    y=x*x+2*x+1\nelif__2_____:\n    y=100\nelse:\n    y=100*x\nprint(\"y=\",y)", "t": "fill", "ans": "x<10 | x==10", "kp": "分支结构", "o": [], "explanation": "本题考查条件分支语句。根据分段函数逻辑，第1空对应x<10的条件，计算x*x+2*x+1；第2空对应x等于10的条件，赋值为100；else分支处理x>10的情况。" }, { "id": 50, "q": "程序填空题\n从集合 set1 中移除元素 2。\nset1 = {1, 2, 3}\nset1.__1 _(__2_  )", "t": "fill", "ans": "remove | 2", "kp": "字典/集合", "o": [], "explanation": "本题考查集合元素的移除操作。集合的remove()方法用于移除指定元素。因此第1空填remove，第2空填需要移除的元素2，即调用set1.remove(2)。" }, { "id": 51, "q": "以下程序的输出结果是（ ）\nj=6\ndef f(n):\n    if n==1:\n        return 1\n    else:\n        return f(n-1)+2\nfor i in [1,2,3,4,5]:\n    j+=f(i)\nprint(j)", "t": "fill", "ans": "31", "kp": "函数", "o": [], "explanation": "本题考查递归函数与循环累加。函数f(n)生成首项为1、公差为2的等差数列。循环中i从1到5，f(i)依次为1、3、5、7、9，累加和为25。初始j=6，最终j=6+25=31。" }, { "id": 52, "q": "以下程序的运行结果是[*queNo*]_。\nclass Information():\n    def __init__(self,age):\n   \n        self.age=age\n    def info(self):\n        print(self.age)\ninformation=Information(20)\ninformation.info()", "t": "fill", "ans": "20", "kp": "面向对象", "o": [], "explanation": "本题考查类的实例化与方法调用。创建Information类的实例时传入参数20，赋值给实例属性self.age。调用info()方法时，打印self.age的值，因此输出20。" }, { "id": 53, "q": "下面这段代码的意义是（ ）\n>>>a=123\n>>>id(a)", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "查看变量的类型", "转换成整型", "查看变量在内存中的地址", "输出变量a的值" ], "explanation": "本题考查内置函数id()的作用。在Python中，id()函数用于返回对象在内存中的唯一标识符，即内存地址。因此该代码的意义是查看变量a在内存中的地址。" }, { "id": 54, "q": "关于 Python 赋值语句，以下选项中不合法的是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "x=(y=1)", "x,y=y,x", "x=y=1", "x=1;y=1" ], "explanation": "本题考查Python赋值语句的语法规则。在Python中，赋值操作（如y=1）是一条语句，不能作为表达式产生返回值，因此x=(y=1)是不合法的。其他选项均为合法的赋值方式。" }, { "id": 55, "q": "下图表示的是哪种程序的基本结构？（ ）", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "顺序结构", "分支结构", "循环结构", "数据结构" ], "explanation": "本题考查程序的基本控制结构。图中流程包含条件判断，并在条件满足时返回前面的步骤重复执行，属于循环结构。因此正确答案为循环结构。", "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-structure-loop.png" }, { "id": 56, "q": "执行语句x=input( )，若输入123，那么 x 的类型是（ ）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "整型", "字符串", "浮点型", "以上都错误" ], "explanation": "本题考查内置输入函数。在Python中，无论用户通过input()函数输入什么内容，该函数接收并返回的数据类型始终是字符串（str）。若需其他类型需手动转换。" }, { "id": 57, "q": "以下代码的输出结果是（）\na=20\nb=3\nif a=90)的学生”和“成绩（mark<90)的学生”的人数，正确的语句为（）。", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "n=0\nm=0\nif mark>=90:\nn=n+1\nelse:\nm+=1", "if mark>=90:\nn+=1", "if mark<=90:\nn=n+1", "n=0\nm=0\nif mark>=90 :\nn=n+1\nelse\nm+=1" ], "explanation": "正确选项A先初始化计数器n和m，再通过if-else分支判断成绩是否大于等于90，分别对n或m进行累加，逻辑完整且语法正确。B缺少对m的统计；C条件错误且无else分支；D的else后缺少冒号，语法错误。" }, { "id": 59, "q": "下列程序的运行结果是（ ）。\ns=0\ni=1\nt=0\nwhile i<=3:\n    t=t*10+1\n    if(i%2==1):\n        s=s+t*i\n    i=i+1\nprint(\"s=\",s)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "s=334", "s=333", "s=356", "s=111" ], "explanation": "循环共执行3次。i=1时t=1，满足奇数条件，s=1；i=2时t=11，不满足条件，s不变；i=3时t=111，满足条件，s=1+111*3=334。循环结束输出s=334，故选A。" }, { "id": 60, "q": "以下关于Python循环结构的描述中，错误的是（）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "break用来结束当前当次语句，但不跳出当前的循环体", "遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range( )函数等", "Python通过for、while等关键字构建循环结构", "continue只结束本次循环" ], "explanation": "break的作用是立即终止并跳出整个循环体，而非仅结束当次循环。描述\"结束当前当次语句但不跳出循环\"的是continue关键字，因此A选项说法错误，符合题意。" }, { "id": 61, "q": "以下代码的输出结果是：（ ）\ns=['num','3','grade']\nsorted(s,reverse=True)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "['3','grade','num']", "['num', 'grade', '3']", "['3','num','grade']", "['num', '3', 'grade']" ], "explanation": "sorted()函数按字符串的ASCII码值进行降序排列。字符比较规则为数字<大写字母<小写字母，因此'num'>'grade'>'3'。函数返回新列表['num', 'grade', '3']，原列表不变，故选B。" }, { "id": 62, "q": "假设有两个集合：A = {1, 2, 3}，B = {2, 3, 4}，(A - B) | (B - A)的结果是什么？", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{1, 2, 3, 4}", "{1, 4}", "{2, 3}", "{1, 2, 3}" ], "explanation": "A-B得到仅属于A的元素{1}，B-A得到仅属于B的元素{4}。两者取并集|结果为{1, 4}，该运算等价于集合的对称差集，故选B。" }, { "id": 63, "q": "以下选项中，不是建立字典的方式是( )。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "d = {[1,2]:1, [3,4]:3}", "d = {(1,2):1, (3,4):3}", "d = {'语文':1, '数学':2}", "d = {1:[1,2], 3:[3,4]}" ], "explanation": "字典的键必须是不可变（可哈希）类型。列表[1,2]和[3,4]是可变对象，不能作为字典的键，会引发TypeError。元组、字符串和整数均可作键，因此A无法建立字典。" }, { "id": 64, "q": ".以下程序代码的运行结果正确的是（ ）。\n n=1\ndef fun(x):\n    global n\n    k=6\n    if(x>0):\n        k=5\n        n=k**2\n    else:\n        k=3\n        n=k*k\nfun(-2)\nprint(\"{}\".format(n))", "t": "single", "ans": "A", "kp": "函数", "o": [ "9", "36", "1", "25" ], "explanation": "调用fun(-2)时x不大于0，执行else分支。k赋值为3，通过global关键字修改全局变量n的值为k*k即9。最终print输出9，故选A。" }, { "id": 65, "q": "以下程序运行后输出的结果是（ ）\ndef my(a,*b):\n       print(a,b)\nmy(34.5,2.3,4.2,7)", "t": "single", "ans": "A", "kp": "函数", "o": [ "34.5 (2.3, 4.2, 7)", "34.5, 2.3, 4.2, 7", "(34.5) 2.3, 4.2, 7", "(34.5,2.3, 4.2, 7)" ], "explanation": "函数定义中*b表示可变位置参数，会将多余实参打包为元组。调用时a接收34.5，b接收剩余参数组成的元组(2.3, 4.2, 7)。print默认以空格分隔输出，结果为34.5 (2.3, 4.2, 7)，故选A。" }, { "id": 66, "q": "关于类属性，以下说法错误的是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "类属性是类对象拥有的属性", "类属性是在类中方法内定义的", "类属性可以通过类对象来访问", "类属性可以通过实例对象来访问" ], "explanation": "类属性应直接定义在类体中（方法外部），属于类对象本身。在方法内部定义的属性属于实例属性。因此B选项描述错误，符合题意。" }, { "id": 67, "q": "以下属于对象的属性的是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "一辆汽车", "汽车的型号", "启动汽车", "倒车" ], "explanation": "面向对象中，属性描述对象的静态特征或状态，方法描述动态行为。\"汽车的型号\"属于描述汽车状态的属性，而启动和倒车属于方法行为，故选B。" }, { "id": 68, "q": "有以下程序代码：\nclass A:\n    def __init__(self,name):\n        self.name=name\n    def show(self):\n        print(\"A类：\",self.name)\nclass B(A):\n    def show(self):\n        print(\"B类：\",self.name)\n       \n其中，说法正确的是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "B类是A类的父类", "B类重写了A类的show方法，这是多态的一种体现", "A类继承自B类", "以上说法都是错误的" ], "explanation": "class B(A)表示B继承自A，B中重新定义了同名方法show，属于方法重写。子类重写父类方法并在运行时根据对象类型调用对应版本，是面向对象多态性的典型体现，故选B。" }, { "id": 69, "q": "请问，下列代码的输出结果是什么？\na = {1, 2, 3}\nb = a.copy()\na.add(4)\nprint(len(a), len(b))", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "3 3", "3 4", "4 3", "4 4" ], "explanation": "copy()方法创建集合的浅拷贝，b独立于a。后续a.add(4)仅修改原集合a，使其长度变为4，而b保持原长度3不变。因此输出4 3，故选C。" }, { "id": 70, "q": "以下程序的输出结果是：[*queNo*]____。\na=\"ni\"\nb=\"ce\"\ns=a+b\nprint(s)", "t": "fill", "ans": "nice", "kp": "字符串", "o": [], "explanation": "字符串拼接操作。变量a和b分别赋值为\"ni\"和\"ce\"，通过加号运算符将两个字符串连接，s的值为\"nice\"，最后打印输出。" }, { "id": 71, "q": "以下程序的输出结果是[*queNo*]_。\nx=20\ndef add(n):\n    global x\n    x=3\n    k=5\n    for i in range(n):\n        k+=x+i\n    return k\ns=add(5)+x\nprint(s)", "t": "fill", "ans": "33", "kp": "函数", "o": [], "explanation": "函数内使用global声明全局变量x并修改为3。add(5)中循环5次，k初始为5，每次累加x+i（即3+0到3+4），k最终为30。函数返回30，外部x已变为3，故s=30+3=33。" }, { "id": 72, "q": "下列Python程序的运行结果是[*queNo*]_。\na=50\nb=40\nif a>b:\n       a,b=b,a\nprint(\"{0},{1}\".format(a,b))", "t": "fill", "ans": "40,50", "kp": "分支结构", "o": [], "explanation": "条件a>b成立，执行a,b=b,a交换两变量的值，使a变为40，b变为50。随后使用format方法格式化输出，{0}和{1}分别对应a和b，结果为\"40,50\"。" }, { "id": 73, "q": "表达式True*False的值为（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "2", "0", "1", "语法错误" ], "explanation": "在Python中，布尔类型是整数类型的子类，True和False在参与算术运算时分别等价于整数1和0。因此表达式True*False等同于1*0，计算结果为0。" }, { "id": 74, "q": "表达式len('{:->5s}'.format('abcdefghi'))的值为（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "9", "5", "7", "语法错误无法计算" ], "explanation": "格式化字符串'{:->5s}'指定最小宽度为5，右对齐并用'-'填充。但传入的字符串'abcdefghi'长度为9，超过了指定宽度，此时不会截断字符串，而是原样输出，故长度为9。" }, { "id": 75, "q": "下面选项中不属于数值类型的是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "-10", "0x35", "\"-23\"", "2.4e-3" ], "explanation": "Python的数值类型包括整数、浮点数和复数。选项A是十进制整数，B是十六进制整数，D是科学计数法表示的浮点数。选项C带有双引号，属于字符串类型，不是数值类型。" }, { "id": 76, "q": "下面语句执行后的结果是（ ）\nprint(\"Lily\",sep=\":\")\nprint('\"hello\"')", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "Lily:\"hello\"", "Lily:hello", "Lily\n\"hello\"", "Lily:\n\"hello\"" ], "explanation": "第一个print函数只传入了一个位置参数\"Lily\"，sep参数在单参数时不生效，输出Lily并换行。第二个print输出带双引号的字符串\"hello\"。综合两行输出结果即为选项C。" }, { "id": 77, "q": "以下代码的输出结果是（）。\na,b,c=400,400,300\nif (a>b):\n   a=b\n   b=c\n   c=a\nelif a==b:\n   b=c\n   c=a\nelse:\n   c=a\nprint(a,b,c)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "400 500 300", "500 300 400", "400 300 400", "500 300 500" ], "explanation": "初始a=400，b=400，c=300。判断a>b不成立，进入elif判断a==b成立。执行b=c使b变为300，执行c=a使c变为400，a保持400不变。最终输出400 300 400。" }, { "id": 78, "q": "以下代码的执行结果是（）。\na =\"123\"\nif a > \"Python\":\n  print(\"再学Python\")\nelse:\n  print(\"初学Python\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "初学Python", "再学Python", "没有输出", "执行出错" ], "explanation": "字符串比较按字符的ASCII码值逐位进行。'1'的ASCII码为49，'P'的ASCII码为80。因为49小于80，所以\"123\" < \"Python\"，if条件不成立，执行else分支输出\"初学Python\"。" }, { "id": 79, "q": "以下代码的输出结果是（ ）。\ni=4\nj=0\nk=3\nif ib:\n    a=b\n    b=c\n    c=a\nprint(a,b,c)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "70 50 70", "50 30 70", "70 30 70", "50 30 50" ], "explanation": "初始a=70，b=50，c=30。条件a>b成立，进入if代码块。顺序执行赋值：a=b使a变为50；b=c使b变为30；c=a使c变为50（此时a已是50）。最终输出50 30 50。" }, { "id": 81, "q": "以下代码的输出结果是（）。\nfor s in \"PythonNCRE\":\n    if s==\"N\":\n        break\n    print(s,end=\"\")", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "PythonCRE", "N", "Python", "PythonNCRE" ], "explanation": "使用for循环遍历字符串\"PythonNCRE\"中的每个字符并打印。当遍历到字符'N'时，满足if条件，执行break语句直接终止循环。因此只输出'N'之前的字符，即\"Python\"。" }, { "id": 82, "q": "下面代码的执行结果是（）。\n>>>x=\"Happy Birthday to you! \"\n>>>x*3", "t": "single", "ans": "C", "kp": "字符串", "o": [ "系统报错", "Happy Birthday to you!", "'Happy Birthday to you!Happy Birthday to you!Happy Birthday to you!'", "Happy Birthday to you!\nHappy Birthday to you!\nHappy Birthday to you!" ], "explanation": "在Python交互式环境中，字符串乘以整数表示将该字符串重复拼接指定次数。变量x末尾包含一个空格，重复3次后生成包含3个原字符串及空格的新字符串。交互式环境输出字符串结果时会自动加上单引号，因此选项C正确。" }, { "id": 83, "q": "下面代码的执行结果是（）。\ns = \"11+5in\"\nprint(eval(s[1:-2]))", "t": "single", "ans": "A", "kp": "字符串", "o": [ "6", "11+5", "执行错误", "16" ], "explanation": "字符串切片s[1:-2]表示从索引1截取到倒数第2个字符（不含），即提取出子串'1+5'。eval()函数会将提取出的字符串作为Python表达式进行求值，计算1加5的结果为6，因此输出6。" }, { "id": 84, "q": "已知元组tup=(5,6,1,7,1,6), 那么执行语句tup.count(1)的结果为（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "1", "2", "3", "4" ], "explanation": "元组的count()方法用于统计指定元素在元组中出现的次数。在元组(5,6,1,7,1,6)中，数字1分别出现在索引2和索引4的位置，共出现了2次，因此返回结果为2。" }, { "id": 85, "q": "已知列表x=[1,2,3,4,5]，那么执行语句x.pop(3)之后， x的值为（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[1,2,3,5]", "1,2,3,5", "4", "[1,2,4,5]" ], "explanation": "列表的pop(index)方法用于移除并返回列表中指定索引位置的元素。x.pop(3)会移除索引为3的元素（即数字4），原列表剩余元素保持原有顺序，因此执行后x的值变为[1,2,3,5]。" }, { "id": 86, "q": "请给出代码段中C的数值。\nA = {1, 2, 3, 4, 5}\nB = {3, 4, 5, 6, 7}\nC = {x + 1 for x in A} & {x + 2 for x in B}", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{3, 4, 5, 6, 7}", "{5, 6}", "{2, 3, 4, 5, 6, 7, 8, 9}", "{4, 5, 6, 7, 8, 9, 10}" ], "explanation": "集合推导式{x + 1 for x in A}生成集合{2, 3, 4, 5, 6}，{x + 2 for x in B}生成集合{5, 6, 7, 8, 9}。运算符&用于求两个集合的交集，即找出同时存在于两个集合中的元素，结果为{5, 6}。" }, { "id": 87, "q": ".以下程序代码的运行结果正确的是（ ）。\ndef fun():\n    a=21\n    b=4\n    print(a//b)\nfun()", "t": "single", "ans": "B", "kp": "函数", "o": [ "运行时出错", "5", "25", "0" ], "explanation": "函数内部定义了变量a和b，并执行整除运算a//b。在Python中，//表示向下取整的除法，21除以4的商为5.25，向下取整后结果为5。调用函数后直接打印该结果。" }, { "id": 88, "q": "阅读以下程序：\ndef fun(x):\n    s=1\n    for i in range(1,x+1):\n         s=s*i\n    return s\ni=7\nk=fun(i)\nprint(k)的结果是（ ）。", "t": "single", "ans": "A", "kp": "函数", "o": [ "7!", "8!", "9!", "10!" ], "explanation": "函数fun(x)通过循环将1到x的所有整数相乘，实现了计算阶乘的功能。当传入参数i=7时，循环变量从1遍历到7，累乘结果即为7的阶乘（7!），最终返回并打印该值。" }, { "id": 89, "q": "关于面向过程和面向对象，下列说法错误的是（ ）。", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "面向过程和面向对象都是解决问题的一种思路", "面向过程是基于面向对象的", "面向过程强调的是解决问题的步骤", "面向对象强调的是解决问题的对象" ], "explanation": "面向过程和面向对象是两种不同的编程范式。面向过程强调解决问题的步骤和流程，而面向对象强调将问题抽象为对象及其交互。两者是并列的思路，不存在\"面向过程是基于面向对象的\"这种说法，该选项表述错误。" }, { "id": 90, "q": "可以在Python中逐行读取文本文件的内容的选项是（ ）。", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "file.read()", "file.readline( )", "file.readlines( )", "next(file)" ], "explanation": "在Python文件操作中，readline()方法用于从文件中逐行读取内容，每次调用读取一行；read()一次性读取全部内容；readlines()一次性读取所有行并返回列表。因此逐行读取应使用readline()。" }, { "id": 91, "q": "在使用 open() 函数打开文件时，文件模式参数 'w' 表示", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "以只读模式打开文件", "以写入模式打开文件", "以追加模式打开文件", "以读写模式打开文件" ], "explanation": "在使用open()函数打开文件时，模式参数决定了文件的读写方式。'r'表示只读，'w'表示写入（会覆盖原文件），'a'表示追加，'r+'表示读写。因此'w'代表以写入模式打开文件。" }, { "id": 92, "q": "下面代码的输出结果是：[*queNo*]____。\nfor x in \"HelloPython\":\n    if x==\"P\":\n        continue\n    print(x,end=\"\")", "t": "fill", "ans": "Helloython", "kp": "循环结构", "o": [], "explanation": "代码遍历字符串'HelloPython'中的每个字符。当字符为'P'时，continue语句跳过当前循环的剩余部分，不执行打印；其他字符则通过print(x, end='')不换行输出。因此最终输出结果为去除了'P'的'Helloython'。" }, { "id": 93, "q": "以下程序运行时，x的值输入3456，输出结果是（ ）\ndef add(n):\n       return n//10+n%10\nx=int(input())\ny=add(add(add(x)))\nprint(y)", "t": "fill", "ans": "9", "kp": "函数", "o": [], "explanation": "函数add(n)返回n整除10的商与n对10取余的和，即去掉个位数后加上个位数。输入3456，第一次调用得345+6=351；第二次调用得35+1=36；第三次调用得3+6=9。最终输出结果为9。" }, { "id": 94, "q": "若fp1 = open(\"test.txt\",\"r\")\n以下哪个读取文件的方式line返回的不是字符串？（）", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "line= fp1.read()", "line=fp1.readline()", "line=fp1.readlines()", "以上都是错误的" ], "explanation": "read()读取整个文件返回字符串，readline()读取一行返回字符串。readlines()读取所有行并返回一个列表，列表元素为字符串，因此其返回值本身不是字符串类型。" }, { "id": 95, "q": "执行下列语句，输出的结果是（ ）。\n>>> x=7.0\n>>> y=3\n>>> print(x%y)", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "1", "1.0", "2", "2.0" ], "explanation": "Python中取模运算%的结果类型与操作数有关。当操作数中包含浮点数时，结果也为浮点数。7.0除以3商2余1.0，因此输出结果为1.0。" }, { "id": 96, "q": "s1 = {1, 2, 3, 4}\ns2 = {3, 4, 5, 6}\ns3 = s1.intersection(s2)\ns3.add(7)\ns4 = s1.difference(s3)\nprint(sorted(s4))", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "[1, 2, 4]", "[2, 4]", "[1, 2]", "[1]" ], "explanation": "s1.intersection(s2)求交集，s3为{3, 4}。s3.add(7)后s3变为{3, 4, 7}。s1.difference(s3)求差集，即s1中有但s3中没有的元素，结果为{1, 2}。sorted()将其转为列表[1, 2]。" }, { "id": 97, "q": "对于字典D={'A':1,'B':2,'C':3,'D':4}，对第4个字典元素的访问形式是（ ）。", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "D[3]", "D[4]", "D[D]", "D['D']" ], "explanation": "字典是无序的键值对集合（Python 3.7+保持插入顺序），不能通过整数索引（如D[3]）访问元素，必须通过键来访问。第4个元素的键为'D'，因此访问形式为D['D']。" }, { "id": 98, "q": "以下哪个不是函数的参数类型？（ ）", "t": "single", "ans": "B", "kp": "函数", "o": [ "位置参数", "定长参数", "默认参数", "关键字参数" ], "explanation": "Python函数的参数类型主要包括位置参数、默认参数、关键字参数和可变参数（如*args和**kwargs）。\"定长参数\"并非Python中标准的参数类型术语，属于干扰项。" }, { "id": 99, "q": "输入任意一串字符，统计不同字符以及各字符的个数并显示出来。例如，输入“data123”,输出为 a -> 2\n1 -> 1\nt -> 1\nd -> 1\n3 -> 1\n2 -> 1。\n注意：部分源程序已给出。输入并调试程序，使程序得出正确结果不得增行或删行，也不得更改程序的结构！仅在横线上填入。\ns=input(\"please input a string: \")\nd=___1___\nfor x in d:\n    print(x,'->', ___2___)", "t": "fill", "ans": "set(s) | s.count(x)", "kp": "程序填空/调试", "o": [], "explanation": "第1空需获取字符串中所有不重复的字符，使用set(s)将字符串转为集合去重；第2空在遍历去重后的字符集合时，需统计原字符串中该字符的出现次数，使用字符串方法s.count(x)实现。" }, { "id": 100, "q": "标准输入函数input()的返回值类型是( )", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "整型", "浮点型", "字符串", "不确定" ], "explanation": "在Python中，无论用户输入什么内容（数字、字母或符号），内置函数input()接收后都会将其作为字符串类型（str）返回。若需其他类型，需手动进行类型转换。" }, { "id": 101, "q": "下列语句执行后的结果是（）\nuser_info = {'name': 'John', 'age': 25, 'city': 'New York'}\nprint(user_info.get('country', 'Unknown'))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "John", "Unknown", "KeyError", "None" ], "explanation": "字典的get(key, default)方法用于获取指定键的值。如果键存在于字典中，则返回对应的值；如果键不存在，则返回提供的默认值。字典中没有'country'键，因此返回默认值'Unknown'。" }, { "id": 102, "q": "从键盘输入m,计算如下公式的值：\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。注意：不得增行或删行，也不得更改程序的结构！\ny = 0\ni=100\nm=int(input(\"请输入一个整数\"))\nwhile ____1____:\n    d = i * i\n    y = y+___2____\n    i=i+100\nprint(\"The result is \",y)", "t": "fill", "ans": "i<=m | 1/d", "kp": "程序填空/调试", "o": [], "explanation": "第1空为循环条件，根据题意和初始值i=100，循环应持续到i超过m，故填i<=m；第2空为累加项，每次循环计算d=i*i，需将其倒数累加到y中，故填1/d。" }, { "id": 103, "q": "下面不属于程序的基本控制结构的是（ ）。", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "顺序结构", "选择结构", "循环结构", "输入输出结构" ], "explanation": "结构化程序设计的三种基本控制结构是顺序结构、选择结构（分支结构）和循环结构。输入输出是程序与外界交互的方式，不属于基本控制结构。" }, { "id": 104, "q": "有以下代码：\nclass D(B,C）:\n      pass\n以下说法正确的是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "本题中的继承关系是单继承", "本题中的继承关系是多重继承", "B，C之间存在继承关系", "以上都不对" ], "explanation": "在Python中，类定义时括号内包含多个父类（如B和C），表示该类同时继承自多个基类，这被称为多重继承。单继承只包含一个父类。" }, { "id": 105, "q": "已知，y=1+1/3+1/5+…+1/(2n-1)，以下程序是求y时的最大n值，请填空。\n   1     \ny=0\nwhile y\n    f=1.0/(2*n-1)            #求累加项\n    y+=f                       #累加\n       2     \nprint(\"y={0},n={1}\".format(y-f,n-2))", "t": "fill", "ans": "n=1 | n+=1", "kp": "程序填空/调试", "o": [], "explanation": "第1空在循环前需初始化循环变量n，根据公式第一项分母为2*1-1，故填n=1；第2空在循环体末尾需更新n的值以计算下一项，故填n+=1使n递增。" }, { "id": 106, "q": "在python中，下列属于字符串常量的是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "\"我爱祖国\"", "python", "str", "chr" ], "explanation": "字符串常量必须用引号（单引号、双引号或三引号）括起来。选项A使用了双引号，是合法的字符串常量；B是标识符，C是内置类型名，D是内置函数名，均不是字符串常量。" }, { "id": 107, "q": "下面代码的输出结果是（）。\nx=10\ny=4\nprint(x/y,x//y)", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "2 2.5", "2.5 2.5", "2.5 2", "2 2" ], "explanation": "在Python中，/ 是浮点除法运算符，10/4 结果为 2.5；// 是整数除法（向下取整）运算符，10//4 结果为 2。因此 print 输出结果为 2.5 2。" }, { "id": 108, "q": "以下变量名中，符合Python语言变量命名规则的是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "_5ab", "key@123", "_he$llo%", "5ab*" ], "explanation": "Python变量命名规则：只能包含字母、数字和下划线，且不能以数字开头，不能是关键字。A选项以下划线开头，合法；B含@，C含$和%，D以数字开头且含*，均包含非法字符或格式错误。" }, { "id": 109, "q": "下列选项中错误的赋值语句是（ ）。", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "a=1", "a=b=c=1", "s= \"hello\"", "a==b" ], "explanation": "赋值语句使用单等号 = 将右侧的值赋给左侧变量。选项A、B、C均为合法的赋值语句（B为多重赋值）；选项D a==b 是关系表达式，用于判断两者是否相等，不是赋值语句。" }, { "id": 110, "q": "下列程序的输出结果( )。\nx=0\ny=50\nm=80\nm=max(x,y)\nprint(\"最大值是{0}\".format(m))", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "最大值是50", "最大值是m", "程序出错", "最大值是80" ], "explanation": "max(x, y) 函数返回参数中的最大值。x=0，y=50，最大值为50，将其赋值给变量 m（覆盖原值80）。format(m) 将50填入占位符，最终输出\"最大值是50\"。" }, { "id": 111, "q": "关于Python注释，以下选项中描述错误的是（ ）。", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "Python注释语句不被解释器过滤掉，也不被执行", "注释可以辅助程序调试", "注释可用于标明作者和版权信息", "注释用于解释代码原理或者用途" ], "explanation": "注释的作用是解释代码原理、辅助调试或标明版权信息。在程序运行时，注释会被解释器忽略（过滤掉）且不被执行。选项A称\"不被解释器过滤掉\"描述错误。" }, { "id": 112, "q": "以下程序的输出结果是（ ）\nq = 123456.78\nprint(\"{0:-^15,}\".format(q))", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "123456.78", "123,456.78", "--123,456.78---", "---123456.78---" ], "explanation": "格式化字符串 {0:-^15,} 中，, 表示千位分隔符，数字变为 123,456.78（长10）；^ 表示居中，15 为总宽度，- 为填充字符。需填充5个 -，左2右3，结果为 --123,456.78---。" }, { "id": 113, "q": "函数input(“please input:”) 括号中的字符串的作用是说法正确的是（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "打印输出字符串：please input:", "提示字符串为：please input，用于用户输入信息提示", "无明显作用", "提示用户要输入please input这个字符串" ], "explanation": "input() 函数括号内的字符串参数作为提示信息输出到控制台，用于引导和提示用户输入信息，它本身不是要求用户必须输入该字符串，也不仅仅是普通的打印输出。" }, { "id": 114, "q": "以下代码的输出结果是（）。\ni=45\nj=1000\nk=380\nif(i<=k):\n   print(i)\nelif(i==j):\n   print(j)\nelse:\n   print(k)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "38", "1000", "45", "以上结果都不对" ], "explanation": "程序首先判断 if 条件 i<=k，即 45<=380，条件为True，因此执行其下的 print(i)，输出45。后续的 elif 和 else 分支将被直接跳过。" }, { "id": 115, "q": "运行以下程序，显示的运行结果是（ ）\na=3\nb=4\nif(a+b>8):\n    print(a)\nelse:\n    print(b)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "6", "5", "4", "3" ], "explanation": "计算 a+b 的值为7。判断条件 7>8 结果为False，因此不执行 if 分支，转而执行 else 分支，输出变量 b 的值，即4。" }, { "id": 116, "q": "以下代码的输出结果是（）。\ni=3\nj=0\nk=4\nif(i>>'python'<'pypi'", ">>>'ABCD'=='abcd'.upper()", ">>>'python123'>'python'", ">>>''<'a'" ], "explanation": "字符串比较按字符的ASCII码值逐个进行。'python'和'pypi'前两个字符相同，第三个字符't'的ASCII码大于'p'，因此'python' > 'pypi'，选项A结果为False。其他选项比较结果均为True。" }, { "id": 122, "q": "s=\"hello\",（）不是正确的索引。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "s[0]", "s[5]", "s[-1]", "s[4]" ], "explanation": "字符串'hello'长度为5，正向索引范围是0到4，反向索引范围是-1到-5。s[5]超出了正向索引的最大范围，访问时会引发IndexError异常，因此是不正确的索引。" }, { "id": 123, "q": "表达式\"[2] in [1,2,3,4]\"的值是（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "Yes", "No", "True", "False" ], "explanation": "in运算符用于检查元素是否存在于序列中。列表[1,2,3,4]中的元素是整数1、2、3、4，并不包含列表[2]这个子列表对象。因此该表达式的值为False。" }, { "id": 124, "q": "已知元组tup=(5,6,1,7,1,6), 那么执行语句tup.count(6)的结果为（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "1", "2", "3", "4" ], "explanation": "元组的count(x)方法用于统计元素x在元组中出现的次数。在给定的元组(5,6,1,7,1,6)中，数字6一共出现了2次，因此tup.count(6)的返回结果为2。" }, { "id": 125, "q": "已知列表s=[1,2,3,4,5], 那么执行语句s.index(2)的结果为（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "1", "2", "3", "4" ], "explanation": "列表的index(x)方法返回元素x在列表中首次出现的索引位置。列表s中元素2位于第二个位置，由于Python索引从0开始计算，因此其对应的索引值为1。" }, { "id": 126, "q": "下面哪个选项用于将集合s1和s2中的元素合并到集合s3中？", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "s3.update(s1 | s2)", "s3.add(s1 + s2)", "s3.merge(s1, s2)", "s3.combine(s1, s2)" ], "explanation": "集合的update方法可将另一个可迭代对象中的元素添加到当前集合。s1 | s2表示求两个集合的并集，通过s3.update()可将并集结果合并到s3中。集合不支持加法运算，也没有merge或combine方法。" }, { "id": 127, "q": "以下关于字典和集合的描述，错误的是：( )。", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "集合是无序的，元素都互不相同", "嵌套的字典数据类型可以用来表达高维数据", "集合元素是不可变的，但元组可以作为一个元素加入集合", "空字典和空集合都可以用大括号来创建" ], "explanation": "在Python中，空大括号{}用于创建空字典，而创建空集合必须使用set()函数。若直接使用{}创建的是字典而非集合。其他选项关于集合无序、字典嵌套和集合元素不可变的描述均正确。" }, { "id": 128, "q": "以下关于Python函数的描述中，错误的是（ )", "t": "single", "ans": "B", "kp": "函数", "o": [ "函数是一段可重用的语句块", "每次使用函数，需要提供相同的参数作为输入", "函数通过函数名进行调用", "函数是一段具有特定功能的语句块" ], "explanation": "函数在调用时，可根据定义时的参数默认值、可变参数或不同调用需求，提供不同数量或值的参数，并非每次都必须提供完全相同的参数输入。其他选项关于函数重用、调用方式和功能的描述均正确。" }, { "id": 129, "q": "以下程序代码的运行结果正确的是（ ）。\na=10\nb=6\ndef fun():\n  a=13\n  b=10\nfun()\nprint(a+b)", "t": "single", "ans": "A", "kp": "函数", "o": [ "16", "10", "13", "23" ], "explanation": "函数fun内部赋值的a和b是局部变量，不会影响外部同名的全局变量。调用fun()后，全局变量a仍为10，b仍为6。因此print(a+b)输出的是全局变量的和，即10+6=16。" }, { "id": 130, "q": "下列代码的运行结果是（ ）。\ny=lambda a,b:a*b\nprint(y('My',2))", "t": "single", "ans": "C", "kp": "函数", "o": [ "My 2", "Myy", "MyMy", "MMy" ], "explanation": "lambda定义匿名函数，计算a*b。当传入字符串'My'和整数2时，执行字符串与整数的乘法运算，即将字符串重复2次，结果为'MyMy'。" }, { "id": 131, "q": "以下程序的运行结果是（）。\ndef my(a,b,c=8):\n　　 return a+b+c\nprint(my(6,7,15))", "t": "single", "ans": "C", "kp": "函数", "o": [ "21", "不确定值", "28", "参数传递出错" ], "explanation": "函数定义中c为默认参数，但调用时传入了三个位置参数6、7、15，分别赋值给a、b、c，覆盖了默认值。返回a+b+c即6+7+15=28。" }, { "id": 132, "q": "构造方法的作用是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "一般成员方法", "类的初始化", "对象的初始化", "对象的建立" ], "explanation": "构造方法（如__init__）在创建对象时自动调用，主要用于初始化对象的属性，即为新创建的对象分配初始状态，而不是用于类的初始化或对象的建立。" }, { "id": 133, "q": "下列选项中，与class Computer: 等价的写法是（ ）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "class Computer: (object)", "class Computer: object", "class Computer object", "class Computer(object):" ], "explanation": "Python 3中，所有类默认继承自object基类。因此class Computer: 隐式继承object，与显式继承的class Computer(object): 写法完全等价。" }, { "id": 134, "q": "下面关于Python中继承的说法错误的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "创建子类实例时，Python首先需要完成的任务是给父类所有的属性赋值", "Python中，super()是一个特殊函数，帮助Python将父类和子类关联起来", "函数super()只需要一个参数，即子类名", "对于父类的方法，可对其进行重写，即在子类中定义一个这样的方法，它要与重写的父类名方法同名" ], "explanation": "Python 3中super()通常无参；在Python 2或特定场景下需传入两个参数（子类名和实例对象），而不是只需一个参数。因此C选项说法错误。" }, { "id": 135, "q": "关于下面代码中的变量c，以下选项中描述正确的是（ ）。\nfname=\"D:/pfile/A．txt\"\nfile=open(fname)\nfor c in file:\n    print（c）\nfile.close()", "t": "single", "ans": "A", "kp": "文件操作", "o": [ "变量c表示文件中的一行字符", "变量c表示文件中的一个单词", "变量c表示文件中的所有字符", "变量c表示文件中的一个字符" ], "explanation": "在Python中，文件对象是可迭代的。使用for循环遍历文件对象时，每次迭代读取并返回文件中的一行内容（包含换行符），因此变量c表示文件中的一行字符。" }, { "id": 136, "q": "如果想读取一个文本文件的一行内容，以下哪个方法比较适合？", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "read()", "readline()", "readlines()", "fetchline()" ], "explanation": "read()读取整个文件，readlines()读取所有行并返回列表，fetchline()不是内置方法。readline()方法专门用于从文件中读取单独的一行内容。" }, { "id": 137, "q": "下列 Python 程序的运行结果是（ ）。\ns1={1,2,3,4,5,6,7,8,9}^{5,6,7,8,9,10}\ns2={1,2,3}|{3,4,5}\nprint(s1>s2)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "False", "True", "Yes", "No" ], "explanation": "s1计算对称差集，结果为{1,2,3,4,10}；s2计算并集，结果为{1,2,3,4,5}。运算符>用于判断左侧集合是否为右侧的真超集。s1并非s2的超集，返回False。" }, { "id": 138, "q": "以下程序的运行结果是[*queNo*]_______。\nlst=['甲','乙','丙','丁']\nfor x in lst:\n    if (x!='甲')+(x=='丙')+(x=='丁')+(x!='丁')==3:\n        print(x)\n        break", "t": "fill", "ans": "丙", "kp": "循环结构", "o": [], "explanation": "遍历列表，将布尔表达式结果转为整数相加。当x为'丙'时，x!='甲'为True(1)，x=='丙'为True(1)，x=='丁'为False(0)，x!='丁'为True(1)，总和为3，满足条件并输出。" }, { "id": 139, "q": "下列程序运行的结果是什么？\ndef get_keys_with_value(dictionary, value):\n    keys = [key for key, val in dictionary.items() if val == value]\n    return keys\nmy_dict = {'a': 1, 'b': 2, 'c': 2, 'd': 3}\nresult = get_keys_with_value(my_dict, 2)\nprint(result)", "t": "fill", "ans": "['b','c']", "kp": "字典/集合", "o": [], "explanation": "函数通过列表推导式遍历字典的键值对，筛选出值等于传入参数2的键。字典中'b'和'c'对应的值均为2，因此返回包含这两个键的列表。" }, { "id": 140, "q": "以下程序的运行结果是[*queNo*]_。\nclass A():\n     x=5\na=A( )\na.x=10\nprint(A.x)", "t": "fill", "ans": "5", "kp": "面向对象", "o": [], "explanation": "x=5是类属性。a=A()创建实例后，a.x=10为实例a动态绑定了一个同名的实例属性x，这不会修改类属性A.x。因此打印A.x时，输出的仍是类属性的值5。" }, { "id": 141, "q": "有代码如下：f=open(\"d:\\\\a1.txt\",\"[*queNo*]\")；打开文件a1.txt后，需要往文件中只写不读（不保留原有文件的数据），则横线处应填_______。", "t": "fill", "ans": "w", "kp": "文件操作", "o": [], "explanation": "文件打开模式中，'w'表示只写模式。若文件存在则清空原有内容（不保留原有数据），若不存在则创建新文件，符合题目只写不读且不保留原有数据的要求。" }, { "id": 142, "q": "在考生文件夫下存在一个Python源文件PY103.py，请完善代码，实现以下功能：\n获得用户输入的三个整数，以逗号分隔，分别记为：n、m、k，其中m>k。以1为随机数种子，产生n个在k和m之间的随机整数（包括k和m)，将这些随机数输出，每个数一行。\n示例如下（其中数据仅用于示意）：\n输入：\n4,26,10\n输出：\n14\n12\n18\n13\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试及验证程序。", "t": "fill", "ans": "import random as r\nr.seed(1)\ns=input(\"请输入三个整数 n,m,k：\")\nslist=s.split(\",\")\nnum_list = range(int(slist[2]), int(slist[1])+1)\nfor i in r.sample(num_list, int(slist[0])):\nprint(i)\n# slist分列后生成列表为字符串形式，因此需要使用int转为数值。\n# range方法用于生成指定范围的数字序列，区间为左闭右开，因此终止值需要加上1\n# sample函数用于抽取指定数量的样本。\n# 综上，先使用range生成数列，再随机抽样并输出。", "kp": "random/turtle等标准库", "o": [], "rawType": "operation" }, { "id": 143, "q": "在考生文件夹下有个文件PY201.py，在横线处填写代码，完成如下功能。根据列表中保存的数据采用turtle库画图直方图，显示输出在屏幕上，效果如下图所示。\nLs=[69,292,33,131,61,254]\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import turtle as t #更简洁地调用turtle库\nls = [69, 292, 33, 131, 61, 254]\nX_len = 400\nY_len = 300\nx0 = -200\ny0 = -100\nt.penup()\nt.goto(x0, y0)\nt.pendown()\nt.fd(X_len)\nt.fd(-X_len)\nt.seth(90) #设置笔的起始角度\nt.fd(Y_len)\nt.pencolor('red')\nt.pensize(5)\nfor i in range(len(ls)):\nt.penup() #提起画笔\nt.goto(x0 + (i+1)*50, y0) #移到绝对坐标处，这里x坐标动，y坐标不动\nt.seth(90)\nt.pendown() #放下画笔\nt.fd(ls[i]) #表示直线爬行的距离\nt.done()", "kp": "random/turtle等标准库", "o": [], "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-turtle-histogram-143.png", "rawType": "operation" }, { "id": 144, "q": "关于Python中的复数，下列说法错误的是（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "表示复数的语法形式是a+bj", "实部和虚部都必须是浮点数", "虚部必须加后缀j，且必须是小写", "函数abs()可以求复数的模" ], "explanation": "Python中复数的虚部后缀可以是小写j或大写J，因此C选项说法错误。A选项正确，复数形式为a+bj；B选项正确，实部和虚部在内部存储为浮点数；D选项正确，abs()函数可求复数的模。" }, { "id": 145, "q": "以下关于字符串的描述正确的是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "字符应视为长度为1或2的字符串", "字符串中的字符可进行数学运算，但进行数学运算的字符必须为数字", "在三引号字符串中可包含换行回车等特殊的字符", "字符串可以进行切片赋值" ], "explanation": "Python中三引号字符串支持多行，可包含换行回车等特殊字符，C正确。A错误，字符是长度为1的字符串；B错误，字符串不能直接进行数学运算；D错误，字符串是不可变类型，不支持切片赋值。" }, { "id": 146, "q": "下面代码的输出结果是（）。\nprint(pow(2,10))", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "100", "12", "1024", "20" ], "explanation": "pow(x, y)函数用于计算x的y次方。代码中pow(2, 10)即计算2的10次方，结果为1024。因此输出结果为1024，选C。" }, { "id": 147, "q": "以下变量名中，符合Python语言变量命名规则的是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "for", "key*word33_", "_he$llo", "_5ab" ], "explanation": "Python变量名只能包含字母、数字和下划线，且不能以数字开头，也不能是关键字。A是关键字；B包含非法字符*；C包含非法字符$；D以下划线开头，由字母和数字组成，符合规则。" }, { "id": 148, "q": "已知x=5;y=6,语句x%=y执行后，x的值是（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "5", "6", "11", "12" ], "explanation": "x%=y等价于x = x % y，即求x除以y的余数。已知x=5，y=6，5除以6的商为0，余数为5，因此执行后x的值为5。选A。" }, { "id": 149, "q": "Python中的单行注释是（ ）开头的。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "//", "'", "#", ";" ], "explanation": "Python中使用井号（#）作为单行注释的起始符号，其后的内容会被解释器忽略。//是整除运算符，'用于字符串，;用于分隔多条语句。因此选C。" }, { "id": 150, "q": "Python语句print(\"{:4d}\".format(33) )中d代表的含义为（", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "二进制", "十进制", "八进制", "十六进制" ], "explanation": "在Python的字符串格式化中，格式说明符d代表十进制整数（decimal）。b代表二进制，o代表八进制，x代表十六进制。因此d代表十进制，选B。" }, { "id": 151, "q": "下列代码的输出结果是（）\nif 2>=0:\n    print(True )\nelse\n    print( False)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "True", "False", "报错", "没有输出" ], "explanation": "代码中else语句后面缺少了冒号（:），这违反了Python的语法规则，会导致SyntaxError语法错误。因此程序会报错，选C。" }, { "id": 152, "q": "print(2>1 and \"programming\")结果为( )", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "2", "programming", "2>1 and \"programming\"", "(2>1 and \"programming\")" ], "explanation": "Python中and运算符遵循短路求值规则。若左侧表达式为真，则返回右侧表达式的值。2>1为True，因此返回右侧的字符串\"programming\"。选B。" }, { "id": 153, "q": "以下代码的输出结果是（ ）。\nfor s in range(6):\n    if s==4:\n        break\n    s=8\nprint(s)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "3", "4", "10", "5" ], "explanation": "循环遍历0到5。当s为0,1,2,3时，执行s=8，但下一次循环s会被range重新赋值。当s=4时，满足if条件，执行break跳出循环。此时s的值保持为4。最后打印s，输出4。选B。" }, { "id": 154, "q": "关于while循环和for循环的区别，下列叙述中正确的是（）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "while语句的循环体至少无条件执行一次,for语句的循环体有可能一次都不执行", "while语句只能用于循环次数未知的循环,for语句只能用于循环次数已知的循环", "在很多情况下，while语句和for语句可以等价使用", "while语句只能用于可迭代变量，for语句可以用任意表达式表示条件" ], "explanation": "while和for循环在很多情况下可以相互转换和等价使用，C正确。A错误，while条件初始为假时一次也不执行；B错误，两者并非绝对限制；D错误，while用于条件表达式，for用于可迭代对象。" }, { "id": 155, "q": "以下程序段的运行结果是（ ）。\ns=\"1*w2o%r#d!\"\nfor i in s:\n    if 'a'<=i <='z' or 'A'<=i <='Z':\n        print(i,end=\"-\")\n   else:\n        continue", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "word", "w-o-r-d-", "* word", "word!" ], "explanation": "程序遍历字符串s中的每个字符，判断是否为英文字母。若是，则打印该字符并以\"-\"结尾；否则跳过。字符串中的字母依次为w、o、r、d，因此输出结果为w-o-r-d-。选B。" }, { "id": 156, "q": "以下代码的输出结果是（）。\nletter=['A','B','C','D','D','D']\nfor i in letter:\n    if i=='D':\n        letter.remove(i)\nprint(letter)", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "['A','B','C']", "['A','B','C','D','D']", "['A','B','C','D']", "['A','B','C','D','D','D']" ], "explanation": "在遍历列表的同时修改列表会导致索引错位。第一次遇到'D'（索引3）时移除它，列表变为['A','B','C','D','D']，此时循环继续到索引4，跳过了原来索引4的'D'（现在在索引3）。接着遇到索引4的'D'并移除，列表变为['A','B','C','D']。循环结束，最终剩下一个'D'。" }, { "id": 157, "q": "Python解释器执行'abbacabb'.strip('ab')的结果是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "'aca'", "'ca'", "'c'", "语法错误" ], "explanation": "strip()方法用于移除字符串开头和结尾指定的字符序列。'abbacabb'开头是'abba'，结尾是'abb'，这些字符都在'ab'集合中，因此会被全部移除，只剩下中间的'c'。注意strip是按字符集合匹配，而非子串匹配。" }, { "id": 158, "q": "s='1234567890'，（）不是正确的分片。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "s[-1:-len(s):-1]", "s[-1:-10:-1]", "s[0:10]", "s[5:8:-1]" ], "explanation": "切片语法为[start:stop:step]。当step为负数时，表示从右向左提取，此时start必须大于stop才能取到元素。选项D中start为5，stop为8，5小于8且步长为-1，无法提取任何元素，返回空字符串，逻辑上不是正确的有效分片。其他选项均能正确提取字符。" }, { "id": 159, "q": "已知x=list(range(10)) 那么表达式x[-1]的值为（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "0", "1", "9", "10" ], "explanation": "list(range(10))生成包含0到9的列表。在Python中，负数索引表示从后往前计数，-1代表列表的最后一个元素。因此x[-1]的值为9。" }, { "id": 160, "q": "以下方法中，不属于列表的是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "insert()", "append()", "replace()", "sort()" ], "explanation": "insert()用于在指定位置插入元素，append()用于在末尾追加元素，sort()用于对列表排序，它们都是列表的内置方法。replace()是字符串的方法，用于替换子串，列表没有该方法。" }, { "id": 161, "q": "如下代码将创建一个空字典并进行初始化，my_dict = {}.fromkeys(['A', 'B', 'C'], 0)，下列哪个选项是my_dict创建后的字典内容？", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{'A': 0, 'B': 0, 'C': 0}", "{'A': None, 'B': None, 'C': None}", "{'A': [], 'B': [], 'C': []}", "{'A': '', 'B': '', 'C': ''}" ], "explanation": "fromkeys()是字典的类方法，用于创建一个新字典，以序列中的元素作为字典的键，第二个参数作为所有键的初始值。因此，以['A', 'B', 'C']为键，0为值，生成的字典为{'A': 0, 'B': 0, 'C': 0}。" }, { "id": 162, "q": "关于函数的说法正确的是（）", "t": "single", "ans": "B", "kp": "函数", "o": [ "函数定义时必须要有形参", "函数中定义的变量只在该函数体中起作用", "函数定义时必须带return语句", "实参与形参的个数可以不相同,类型可以任意" ], "explanation": "函数可以没有形参；函数中定义的变量是局部变量，仅在函数体内有效；函数可以没有return语句，默认返回None；实参与形参的个数和类型在调用时需要匹配，否则会报错。因此只有B选项说法正确。" }, { "id": 163, "q": "以下程序代码的运行结果正确的是（ ）。\nd={'chen':89,'zhang':78,'liu':78}\ndef sum():\n    global d\n    d={'liu':96,'xiao':35,'ye':100}\n    d.pop('liu')\nsum( )\nprint('{}'.format(d))", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "{'chen':89,'zhang':78,'liu':78}", "{'liu':96,'xiao':35,'ye':100}", "{'zhang':78,'liu':78}", "{'xiao': 35, 'ye': 100}" ], "explanation": "函数内使用global声明d为全局变量。调用sum()时，d被重新赋值为新字典{'liu':96,'xiao':35,'ye':100}，随后pop('liu')移除了键'liu'。因此全局变量d最终变为{'xiao': 35, 'ye': 100}，打印该结果。" }, { "id": 164, "q": "下列程序的运行结果是（ ）。\nf=[lambda x=1:x*2,lambda x:x**2]\nprint(f[1](f[0](3)))", "t": "single", "ans": "D", "kp": "函数", "o": [ "1", "6", "9", "36" ], "explanation": "f是一个包含两个匿名函数的列表。f[0]是lambda x=1:x*2，f[1]是lambda x:x**2。首先计算内层f[0](3)，传入3，返回3*2=6。然后计算外层f[1](6)，传入6，返回6**2=36。最终输出36。" }, { "id": 165, "q": "Python中，关于类中的__init__()函数，说法正确的是( )", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "第一个参数必须命名为self", "必须显式调用", "创建对象时自动调用", "是一个公有方法" ], "explanation": "__init__()是类的初始化方法，在实例化对象时自动调用，无需显式调用。第一个参数通常命名为self，但并非强制要求，只要代表实例本身即可。它以双下划线开头，属于特殊方法，并非普通的公有方法。" }, { "id": 166, "q": "class A:\n    def __init__(self,name):\n        self.name=name\n    def show(self):\n        print(\"A类：\",self.name)\nclass B(A):\n    def show(self):\n        pass\na=A(\"2\")\nb=B(\"1\")\nb.show()", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "A类：1", "A类：2", "无输出", "以上都是错误的" ], "explanation": "类B继承自类A，并重写了show()方法，方法体为pass（即什么都不做）。创建B的实例b并调用b.show()时，执行的是B类中重写后的空方法，因此不会有任何输出。如果调用a.show()才会输出对应内容。" }, { "id": 167, "q": "以下哪个文件模式可以在已有文件末尾追加内容？", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "'r'", "'w'", "'a'", "'x'" ], "explanation": "在Python文件操作中，'r'表示只读，'w'表示写入（会覆盖原文件），'x'表示排他性创建（文件存在则报错）。'a'表示追加模式，打开文件后指针移到末尾，新写入的内容会追加到已有内容之后。" }, { "id": 168, "q": "请给出以下代码段的正确答案（）\nA = {2, 41, 49, 78, 84}\nB = {4, 32, 39, 40, 82}\nB = {x // 2 for x in A | B if x%2==0}\nD = {x + 2 for x in B}\nD.intersection_update(A)\nprint(D)", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "{3, 4, 18, 21, 22, 26, 41, 43, 44}", "{3, 41, 44}", "[3, 4, 18, 22, 41, 43, 44]", "{41}" ], "explanation": "集合A与B的并集包含2,4,32,39,40,41,49,78,82,84。推导式筛选偶数并整除2，得到新集合B={1,2,16,20,39,41,42}。接着推导式生成D={3,4,18,22,41,43,44}。最后D.intersection_update(A)求D与A的交集并更新D，A中仅有41在D中，故D最终为{41}。" }, { "id": 169, "q": "下面的程序是输出[200,1000]以内的全部素数，请填空。\nimport math\nn=0\nfor m in range(201,1000,2):\n    i,j=2,int(math.sqrt(m))\n    while    1   :  \n        if not(m%i):\n              2     \n        else:\n            i=i+1\n    else:\n        print(m,end=\" \")\n        n+=1                                                #n统计素数个数\n        if n%10==0:print(\"\\n\")     #一行输出10个素数", "t": "fill", "ans": "i<=j | break", "kp": "程序填空/调试", "o": [], "explanation": "第1空控制循环条件，当除数i小于等于平方根j时继续判断，填i<=j；第2空当m能被i整除时说明不是素数，需使用break跳出当前while循环。" }, { "id": 170, "q": "以下程序的运行结果是[*queNo*]_。(注：pi=3.14159)\nfrom math import *\nclass Circle:\n    def __init__(self, radius=1):\n        self.radius = radius\n    def getArea(self):\n   \n        return self.radius * self.radius * pi\na = Circle(10)\nprint(\"{:.2f}\".format(a.getArea()))", "t": "fill", "ans": "314.16", "kp": "面向对象", "o": [], "explanation": "实例化Circle对象时传入半径10，调用getArea方法计算面积为10*10*3.14159=314.159。使用format方法保留两位小数，四舍五入后输出结果为314.16。" }, { "id": 171, "q": "在考生文件夹下有个文件PY101.py，在横线处填写代码，完成如下功能。程序接收用户输入的五个数，以逗号分隔。将这些数字按照输入顺序输出，每个数字占10个字符宽度，右对齐，所有数字显示在同一行。例如：\n输入：\n23,42,543,56,71\n输出：\n23 42 543 56 71\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "num = input().split(',')\nfor i in num:\nprint(\"{:>10}\".format(i),end=\"\")", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 172, "q": "在考生文件夹下有个文件PY201.py,在横线处填写代码，完成如下功能，利用random库和turtle库，在屏幕上绘制4个小雪花, 雪花的中心点坐标由列表points给出，雪花的半径长度由randint()函数产生。雪花的颜色是红色。效果如下图所示。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "t.pencolor('red')\nfor i in range(len(points)):\nt.goto(x0,y0)\nt.forward(length)\nt.backward(length)", "kp": "random/turtle等标准库", "o": [], "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-turtle-snowflakes-172.png", "rawType": "operation" }, { "id": 173, "q": "在Python语言中，可以作为源文件后缀名的是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "pnt", "pyt", "py", "python" ], "explanation": "Python源代码文件的标准扩展名是.py。选项中的pnt、pyt和python均不是合法的Python源文件后缀名。" }, { "id": 174, "q": "下面Python循环体执行的次数与其他不同的是（）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "i=0\nwhile i<=10:\nprint(i)\ni+=1", "i=10\nwhile i>0:\nprint(i)\ni-=1", "for i in range(10):\nprint(i)", "for i in range(10,0,-1):\nprint(i)" ], "explanation": "选项A中i从0递增到10，满足i<=10的条件共执行11次。选项B、C、D的循环条件或迭代范围均只包含10个元素，循环体执行10次。因此A的执行次数与其他不同。" }, { "id": 175, "q": "下列关于对象和类的关系描述错误的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "每个对象都是由其对应的类创建出来的", "对象是类的实例化", "如果直接使用类名修改其属性，不会影响到已经实例化的对象", "类是具有相同属性和方法的对象的集合" ], "explanation": "类属性被所有实例共享。如果通过类名直接修改类属性，且实例对象没有同名的实例属性覆盖它，那么该修改会影响到所有已经实例化的对象。因此选项C描述错误。" }, { "id": 176, "q": "设有n个数已存在序列s中，利用顺序检索查找数据x是否在序列s中。请填空。\ns=eval(input())\nx=eval(input(\"输入待查数据:\"))\nn=____1___\ni=0\nwhile ic  1    b+c>a  2   a+c>b:\n    p=(a+b+c)/2      \ns=math.  3  (p*(p-a)*(p-b)*(p-c)) \nprint(\"a={0},b={1},c={2}\".format(a,b,c))\n    print(\"area={}\".format(s))\nelse:\n    print(\"a={0},b={1},c={2}\".format(a,b,c))\n        print(\"input data error\")", "t": "fill", "ans": "and | and | sqrt", "kp": "程序填空/调试", "o": [], "explanation": "判断三角形成立需满足任意两边之和大于第三边，第1、2空填逻辑与运算符and。求面积需对表达式开平方，math模块中求平方根的函数为sqrt，故第3空填sqrt。" }, { "id": 187, "q": "下列程序的运行结果是（ ）。\ns=0\ni=1\nt=0\nwhile i<=3:\n    t=t*10+1\n    s=s+t*i\n    i=i+1\nprint(\"s=\",s)", "t": "fill", "ans": "s=356", "kp": "循环结构", "o": [], "explanation": "初始s=0,i=1,t=0。第1次循环：i=1，t=1，s=1，i=2；第2次：i=2，t=11，s=1+22=23，i=3；第3次：i=3，t=111，s=23+333=356，i=4。循环结束，输出s=356。" }, { "id": 188, "q": "Python语言中用来表示代码块所属关系的语法是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "花括号", "括号", "缩进", "冒号" ], "explanation": "Python语言不使用花括号等标记，而是严格依靠缩进（空格或制表符）来表示代码块的层级和所属关系。冒号用于引导代码块，但表示所属关系的是缩进。选C。" }, { "id": 189, "q": "以下变量名中，符合Python语言变量命名规则的是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "for", "_keyword33%", "_hello5", "_5/ab" ], "explanation": "Python变量名只能包含字母、数字和下划线，且不能以数字开头，不能是关键字。A是关键字，B包含非法字符%，D包含非法字符/。C以下划线开头且仅含字母数字，符合规则。选C。" }, { "id": 190, "q": "利用 print()格式化输出，能够控制实数的小数点后两位输出的是（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "{.2}", "{:.2f}", "{:.2}", "{.2f}" ], "explanation": "在Python的format格式化或f-string中，控制浮点数保留两位小数的格式说明符是{:.2f}。冒号后跟.2表示保留两位小数，f表示浮点数类型。选B。" }, { "id": 191, "q": "执行下列程序后，i的值是（ ）。\nk=1\nn=123\nfor i in (\"apple\",\"pear\",\"mango\",\"peach\"):\n      k*=n%10\n      n//=10\nprint(i)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "\"apple\"", "\"pear\"", "\"mango\"", "\"peach\"" ], "explanation": "for循环遍历元组中的四个字符串，循环变量i依次被赋值为'apple'、'pear'、'mango'、'peach'。循环正常结束后，i保留最后一次迭代的值，即'peach'。选D。" }, { "id": 192, "q": "下列for循环执行后，输出结果的最后一行是（ ）。\nfor i in range(1,-3,-1):\n    for j in range(2,5):\n        print(i*j)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "-2", "-6", "-8", "-15" ], "explanation": "外层i取1,0,-1,-2。内层j取2,3,4。最后一行输出对应外层最后一次循环i=-2，且内层最后一次循环j=4。此时输出i*j即-2*4=-8。选C。" }, { "id": 193, "q": "max((1,2,3)*3)的值是（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "9", "1", "2", "3" ], "explanation": "表达式(1,2,3)*3利用元组的重复操作符*，生成新元组(1, 2, 3, 1, 2, 3, 1, 2, 3)。max()函数用于求序列中的最大值，该元组中的最大元素为3。选D。" }, { "id": 194, "q": "执行下面的代码后，输出结果是（ ）。\n>>> a=[1,2,3,4]\n>>> b=a\n>>> a[1]=20\n>>> print(b)", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[1,2,3,4]", "[20,2,3,4]", "[1,20,3,4]", "[1,20,2,3,4]" ], "explanation": "Python中列表是可变对象，b=a是引用赋值，a和b指向同一个列表对象。修改a[1]为20后，b的内容也会同步改变，因此输出[1,20,3,4]。" }, { "id": 195, "q": "定义了一个字典，person = {'name': 'John', 'age': 25, 'city': 'New York'}，下面哪个选项不能将字典中的年龄（age）加上5？", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "person['age'] += 5", "person.update({'age': person['age'] + 5})", "person['age'] = person.get('age') + 5", "person.age += 5" ], "explanation": "Python字典不支持通过点号（.）属性访问的方式来获取或修改键值，必须使用方括号[]或get()、update()等字典方法。因此选项D语法错误，无法执行。选项A、B、C均能正确修改字典中的值。" }, { "id": 196, "q": "下列代码运行后的结果是（ ）。\ndef sum(m):\n    if m<10:\n        return m+sum(2*m)\n   \n    else:\n        return 0\ns=sum(2)\nprint(\"{}\".format(s))", "t": "single", "ans": "B", "kp": "函数", "o": [ "24", "14", "45", "0" ], "explanation": "调用sum(2)，2<10，返回2+sum(4)；调用sum(4)，4<10，返回4+sum(8)；调用sum(8)，8<10，返回8+sum(16)；调用sum(16)，16不小于10，返回0。回溯计算：8+0=8，4+8=12，2+12=14。最终输出14。" }, { "id": 197, "q": "如下程序片段中：\nclass Myclass:\n    x=30\n    a=2\n    def __init__(self):\n        self.b=1\n其中，实例属性是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "x", "b", "a", "以上都不是" ], "explanation": "在类定义中直接赋值的变量（如x和a）属于类属性，被所有实例共享。而在__init__方法中通过self绑定的变量（如self.b）属于实例属性，每个实例独有。因此b是实例属性。" }, { "id": 198, "q": "在Python中，以下类的定义正确的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "class Phone:\nname=\"\"\ncall(self,name)\nprint(name,'打电话')", "class Phone:\nname=\"\"\ncall(self,name):\nprint(name,'打电话')", "class Phone:\nname=\"\"\ndef(self,name):\nprint(name,'打电话')", "class Phone:\nname=\"\"\ndef(self,name)\nprint(name,'打电话')\nclass Phone:\nname=\"\"\ndef(self,name)\nprint(name,'打电话')\nclass Phone:\nname=\"\"\ndef(self,name)\nprint(name,'打电话')" ], "explanation": "Python定义类方法必须使用def关键字，且方法定义行末尾需有冒号。选项A缺少冒号，选项B缺少def关键字，选项D不仅缺少冒号还重复定义。选项C虽然疑似遗漏了方法名，但具备def和冒号，是相对最符合语法规则的选项。" }, { "id": 199, "q": "运行以下程序，得到是图形是（ ）。\nfrom turtle import *\nfor i in range(3):\n    up()\n    goto(0,-50-i*50)\n    down()\n    circle(50+i*50)", "t": "single", "ans": "A", "kp": "random/turtle等标准库", "o": [ "三个同心圆", "两个同心圆", "三个相交的圆", "三个半圆" ], "explanation": "循环执行3次，每次画笔移动到(0, -50-i*50)，即y坐标分别为-50, -100, -150。然后分别绘制半径为50, 100, 150的圆。由于turtle中circle的圆心在画笔左侧距离r处，这三个圆的圆心都在(0,0)，因此绘制出三个同心圆。" }, { "id": 200, "q": "下列属于math库中的数学函数的是（ ）。", "t": "single", "ans": "C", "kp": "异常与库", "o": [ "time()", "round()", "sqrt()", "random()" ], "explanation": "sqrt()是math库中用于计算平方根的函数。time()属于time模块，round()是Python内置函数，random()属于random模块。因此只有sqrt()属于math库。" }, { "id": 201, "q": "下面的代码的输出结果是（ ）\nx='Hello world'\nprint(type(x))", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "", "", "", "" ], "explanation": "变量x被赋值为字符串'Hello world'，使用type()函数获取其数据类型，结果为。虽然选项内容缺失，但根据代码逻辑，输出应为字符串类型标识。" }, { "id": 202, "q": "下列关于Python运算符的使用描述正确的是（）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "a=!b,比较a与b是否不相等", "a=+b，等同于a=a+b", "a==b，比较a与b是否相等", "a//=b，等同于a=a/b" ], "explanation": "==是关系运算符，用于比较两个对象的值是否相等，选项C正确。选项A中不相等应为!=；选项B中a=+b只是将正b赋值给a，并非a=a+b（应为a+=b）；选项D中//=是整除赋值，而非普通除法赋值。" }, { "id": 203, "q": "以下代码的输出结果是（）。\nage=40\nfamilyName=\"赵\"\nif age>50:\n   print(\"您好！\"+familyName+\"奶奶\")\nelif age>40:\n   print(\"您好！\"+familyName+\"阿姨\")\nelse:\n   print(\"您好！\"+\"小\"+ familyName)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "您好！赵奶奶", "您好！赵阿姨", "您好！小赵", "报错" ], "explanation": "变量age为40。首先判断age>50为假，接着判断age>40也为假，因此程序进入else分支，执行print(\"您好！\"+\"小\"+ familyName)，拼接字符串后输出\"您好！小赵\"。" }, { "id": 204, "q": "以下代码的输出结果为（）。\nage=18\nif 12<=age<=17:\n   if age<=12:\n      print(\"小学生\")\n   else:\n      print(\"中学生\")\nelse:\n   print(\"大学生\")", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "中学生", "小学生", "大学生", "是学生吗" ], "explanation": "变量age为18。条件12<=age<=17判断18是否在12到17之间，结果为False。因此程序跳过if块，直接执行else分支，输出\"大学生\"。" }, { "id": 205, "q": "对于a or b，如果a为False，则表达式的值为（ ） 。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "b的值", "False", "True", "不确定" ], "explanation": "Python中的逻辑或运算符or具有短路特性。当计算a or b时，如果a为False，表达式的结果无法由a决定，因此会返回b的值。若a为True，则直接返回a的值。" }, { "id": 206, "q": "以下代码的输出结果是（）。\nwhile 1:\n     print(\"hello\")\n     break", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "False", "hello", "没有任何输出", "语法错误" ], "explanation": "while 1 为真进入循环，打印 \"hello\" 后遇到 break 直接跳出循环，因此只输出一次 \"hello\"。" }, { "id": 207, "q": "访问字符串中单个字符的操作称为（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "分片", "合并", "索引", "赋值" ], "explanation": "在Python中，通过索引（Index）操作可以访问字符串、列表等序列类型中的单个字符或元素。分片用于获取子序列，合并用于拼接。" }, { "id": 208, "q": "下列选项中与列表ls[0:-1]表示的含义相同的是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "ls[-1]", "ls[:]", "ls[:len(s)-1]", "ls[0:len(ls)]" ], "explanation": "ls[0:-1] 表示从索引0开始到倒数第一个元素（不包含）的切片。选项C中 ls[:len(s)-1]（s应为ls的笔误）表示从开头到长度减1的位置，同样不包含最后一个元素，含义相同。" }, { "id": 209, "q": "tuple(range(1,11,2))的返回结果是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "(1,3,5,7,9)", "(1,3,5,7,9,11)", "[1,3,5,7,9]", "[1,3,5,7,9,11]" ], "explanation": "range(1,11,2) 生成从1开始、11结束（不含11）、步长为2的序列，即1,3,5,7,9。tuple() 函数将其转换为元组，故结果为 (1,3,5,7,9)。" }, { "id": 210, "q": "下列Python程序的运行结果是（ ）。\nL1=[1,2,3,4]\nL1[3]=5\nprint(L1)", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[5,2,3,4]", "[1,2,5,4]", "[1,2,3,5]", "[1,2,3,4,5]" ], "explanation": "列表索引从0开始，L1[3] 对应列表的第4个元素（原值为4）。将其重新赋值为5后，列表更新为 [1,2,3,5]。" }, { "id": 211, "q": "以下不能用作函数名的是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "3c", "_3c", "c3", "_c3" ], "explanation": "Python标识符（包括函数名、变量名等）必须以字母或下划线开头，不能以数字开头。因此 \"3c\" 是非法的标识符，不能用作函数名。" }, { "id": 212, "q": "以下程序代码的运行结果正确的是（ ）。\ndef test():\n    var = 10\n    def inner():\n        var=5\n        print(var,end=',')\n        return var\n    return inner()\nprint(test())", "t": "single", "ans": "B", "kp": "函数", "o": [ "10,10", "5,5", "5,10", "10,5" ], "explanation": "调用 test() 时执行内部函数 inner()。inner 中定义局部变量 var=5，打印 \"5,\" 并返回5。test() 返回该值，外层 print 再次打印5，最终输出 \"5,5\"。" }, { "id": 213, "q": "在方法定义中，访问实例属性x的格式是（ ）。", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "x", "self.x", "self[x]", "self.getx()" ], "explanation": "在类的实例方法中，第一个参数通常约定为 self，代表实例对象本身。访问或修改实例属性时，必须通过 self.属性名 的格式，即 self.x。" }, { "id": 214, "q": "以下程序的输出结果是：[*queNo*]____。\ns=''\nls = [1,2,3,4,5]\nfor i in ls:\n    s += str(i)\nprint(s)", "t": "fill", "ans": "12345", "kp": "循环结构", "o": [], "explanation": "循环遍历列表 ls 中的每个整数元素，使用 str() 将其转换为字符串后，通过 += 拼接到初始为空的字符串 s 中，最终输出 \"12345\"。" }, { "id": 215, "q": "以下judgment函数判断一个 3位的正整数是否为一个回文数。回文数是指正读和反读都相同的数，例如 131是回文数。请在括号（）中填入正确答案。\ndef judgment(h):\n    if ___1____:\n        print('是回文数')\n    else:\n        print('不是回文数')\nn=(__2___)(input(\"请输入一个三位数:\"))\njudgment(n)", "t": "fill", "ans": "h%10==h//100 | int", "kp": "程序填空/调试", "o": [], "explanation": "第1空：三位数的个位是 h%10，百位是 h//100，回文数要求首尾相同，故填 h%10==h//100。第2空：input() 返回字符串，需用 int() 转换为整数以便进行数学运算，故填 int。" }, { "id": 216, "q": "（）是合法的浮点型数据。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "e4", "3.4e4.5", "34e", "4.5e3" ], "explanation": "科学计数法表示浮点数时，e或E前面必须有数字，且后面的指数必须是整数。A缺e前数字，B指数为小数，C缺指数，只有 4.5e3 格式合法。" }, { "id": 217, "q": "下面是Python的内置函数的是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "linspace(a,b,s)", "eye(n)", "bool(x)", "fabs(x)" ], "explanation": "bool() 是Python的内置函数，用于将给定值转换为布尔类型。linspace 和 eye 属于第三方库 NumPy，fabs 属于标准库 math，均非内置函数。" }, { "id": 218, "q": "以下不属于Python语言保留字的是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "class", "pass", "sub", "def" ], "explanation": "class、pass和def都是Python的保留字（关键字），分别用于定义类、空语句占位和定义函数。sub不是Python的保留字，通常作为普通标识符使用，或在re模块中作为替换函数名。" }, { "id": 219, "q": "在屏幕上输出\"Hello world\"，使用的Python语句是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "printf('Hello World')", "print(Hello world）", "print(\"Hello world\")", "printf(\"Hello world\")" ], "explanation": "Python中使用print()函数进行标准输出，而不是C语言中的printf()。同时，字符串必须用引号（单引号或双引号）括起来，B选项缺少引号会导致语法错误。因此C选项正确。" }, { "id": 220, "q": "下列关于Python程序格式的描述中正确的是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "缩进指每一行代码前面的留白部分，用来表示代码之间的层次关系，使代码更加整洁利于阅读，所有代码都需要在行前至少加一个空格", "注释可以在一行中的任意位置开始，这一行都会作为注释不被执行", "Python语言不允许在一行的末尾加分号，这会导致语法错误", "一行代码的长度如果过长，可以使用\"\\\"反斜杠续行" ], "explanation": "A错在并非所有代码都需要缩进，顶层代码无需缩进；B错在行内注释必须用#开头，且#后的内容才是注释；C错在Python允许在行末加分号，只是不推荐；D正确，反斜杠可用于将过长代码折行。" }, { "id": 221, "q": "以下程序的输出结果是__________。\ns1=\"QQ\"\ns2=\"Wechat\"\nprint(\"{:*<10}{:=>10}\".format(s1,s2))", "t": "single", "ans": "B", "kp": "字符串", "o": [ "QQ********\n====Wechat", "QQ********====Wechat", "********QQ Wechat====", "====Wechat\nQQ********" ], "explanation": "格式化字符串{:*10}表示将字符串左对齐，总宽度10，不足部分用*填充。s1为QQ，填充后为QQ********。题目代码中仅有一个占位符，但选项均包含s2的值，推测原题代码存在遗漏，结合选项特征B最符合预期输出格式。" }, { "id": 222, "q": "下列程序的运行时分别输入3和2，运行结果是（ ）\nx=input()\ny=int(input())\nprint(x+y)", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "\"3\"+2", "\"32\"", "5", "提示类型错误" ], "explanation": "input()函数返回的是字符串类型，因此x为字符串'3'。y通过int()转换为整数2。在Python中，字符串和整数不能直接使用加号进行拼接或相加运算，运行时会抛出TypeError类型错误。" }, { "id": 223, "q": "给出下面代码：\nage=23\nstart=2\nif age%2!=0:\n  start=1\nfor x in range(start,age+2,2):\n  print(x)\n上述程序输出值的个数是（）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "10", "12", "16", "14" ], "explanation": "age为23，23%2!=0成立，故start被赋值为1。range(1, 25, 2)生成的序列从1开始，步长为2，最大不超过24。序列为1,3,5,...,23，共(23-1)/2+1=12个元素。因此循环执行12次，输出12个值。" }, { "id": 224, "q": "关于Python循环结构，下列叙述中错误的是（）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "while循环使用关键字continue结束本次循环体", "while循环可以使用保留字break和continue", "while循环也叫遍历循环，用来遍历序列类型中元素，默认提取每个元素并执行一次循环体", "while循环使用pass语句，则什么事也不做，只是空的占位语句" ], "explanation": "for循环被称为遍历循环，用于遍历序列、字典等可迭代对象中的元素；而while循环是条件循环，根据条件表达式的真假来决定是否执行循环体。因此C选项将while循环描述为遍历循环是错误的。" }, { "id": 225, "q": "设有程序段：\nk=2\nfor i in [1,2,3,4,5,6,7,8]:\n    if(k==-1):\n        break\n    k=k-1\n    print(k, end= ',')\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "0,1,2,", "1,0,-1,", "2,1,0,", "3,2,1," ], "explanation": "初始k=2。第1次循环i=1，k不为-1，k减1变为1，输出'1,'；第2次循环i=2，k减1变为0，输出'0,'；第3次循环i=3，k减1变为-1，输出'-1,'；第4次循环i=4，k为-1，触发break跳出循环。最终输出1,0,-1,。" }, { "id": 226, "q": "关于元组与列表，叙述不正确的是（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "元组可以在字典中作为关键字使用，而列表不能", "元组与列表都是有序序列，很多情况下可以相互替换", "元组中的数据一旦定义就不允许更改", "元组可以使用pop()方法或remove()方法删除元素" ], "explanation": "元组是不可变序列，一旦创建其元素不能被修改、添加或删除。因此，元组不支持pop()或remove()等会改变序列内容的方法。列表是可变序列，支持这些方法。A正确因为字典键必须是可哈希的，元组可哈希而列表不可。" }, { "id": 227, "q": "以下方法中，不属于列表的是（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "pop()", "split()", "reverse()", "extend()" ], "explanation": "split()是字符串的方法，用于根据指定分隔符将字符串拆分为列表。pop()用于移除并返回列表中的一个元素，reverse()用于反转列表元素，extend()用于在列表末尾追加多个值，这三者均是列表的内置方法。" }, { "id": 228, "q": "如何访问字典中的年龄（age）？\nperson = {'name': 'John', 'age': 25, 'city': 'New York'}", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "person[1]", "person[age]", "person.age", "person.get('age')" ], "explanation": "字典通过键来访问值。A选项使用索引访问，字典不支持；B选项age未加引号，会被当作变量而非字符串键；C选项使用点号访问，这是对象属性的访问方式，不适用于字典；D选项使用get()方法并传入正确的字符串键，是正确且安全的访问方式。" }, { "id": 229, "q": "关于Python语言中的自定义函数，说法错误的是( )", "t": "single", "ans": "D", "kp": "函数", "o": [ "函数可以嵌套调用", "函数可以嵌套定义", "函数的参数不需要指定类型", "无参函数定义可以省略函数名后的()" ], "explanation": "在Python中定义函数时，无论是否有参数，函数名后都必须加上小括号()，这是函数定义的语法要求。A、B正确，Python支持函数的嵌套调用和嵌套定义。C正确，Python是动态类型语言，定义参数时默认不需要声明类型。" }, { "id": 230, "q": "以下程序代码运行后的结果正确的是（ ）。\ndef fun():\n   a=3\n   b=9\nfun()\nprint(a+b)", "t": "single", "ans": "D", "kp": "函数", "o": [ "3", "12", "9", "运行时出错" ], "explanation": "函数fun内部定义的变量a和b属于局部变量，其作用域仅限于函数内部。在函数外部直接调用print(a+b)时，由于全局作用域中未定义这两个变量，会引发NameError导致运行时出错。" }, { "id": 231, "q": "运行下列代码的输出结果是（ ）。\ndef fun(x,y):\n    print(x//y ,end=' ')\n    print(x%y ,end=' ')\nfun(17,3)", "t": "single", "ans": "B", "kp": "函数", "o": [ "4 2", "5 2", "5 3", "2 5" ], "explanation": "函数调用fun(17,3)传入参数x=17，y=3。表达式x//y表示整除，17整除3结果为5；x%y表示取余，17对3取余结果为2。end=' '使两次打印在同一行以空格分隔，故输出5 2。" }, { "id": 232, "q": "以下代码段的执行结果是（ ）。\nclass St:\n  def __init__(self,a,b):\n    self.a=a\n    self.__b=b\ns3=St(0,1)\nprint(s3. __b)", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "0", "1", "随机数", "语句出错" ], "explanation": "在Python类中，以双下划线开头的属性（如__b）被定义为私有属性，不能在类外部直接访问。尝试通过s3.__b访问会引发AttributeError异常，导致语句出错。" }, { "id": 233, "q": "根据Car()类创建实例对象car，下列代码正确的是（）\nclass Car():\n    def __init__(self):\n        self.name=\"宝马\"", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "Car=car()", "car=car()", "car=Car()", "Car=Car()" ], "explanation": "在Python中，创建类的实例对象的标准语法为\"对象名 = 类名()\"。按照命名规范，类名首字母通常大写（Car），实例对象名通常小写（car），因此正确的实例化代码是car=Car()。" }, { "id": 234, "q": "属于Python读取文件中一行内容的操作是（ ）", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "readtxt()", "readline()", "readall()", "read()" ], "explanation": "Python文件对象的方法中，readline()用于读取文件中的一行内容；read()用于读取指定字节数或全部内容。readtxt()和readall()并非Python内置的标准文件读取方法。" }, { "id": 235, "q": "以下程序的功能是从键盘上输入10个数，求出其中的最大数，请填空。\nx=int(input())\nmax =x\nfor i in range(1,   1    ):\n    x=int(input())\n    if x   2    max:\n        max=x\n   print(\"max={0}\".format(max))", "t": "fill", "ans": "11 | >", "kp": "程序填空/调试", "o": [], "explanation": "第1空：填11，使range(1, 11)生成1到10的序列，控制循环执行10次。第2空：求最大数时，需判断新输入的x是否大于当前最大值max，若大于则更新，故填比较运算符>。" }, { "id": 236, "q": "下列程序的运行结果是（ ）。\ns=\"a1223334444b\"\ncount=[0,0,0,0]\nfor i in s:\n    if i==\"1\":\n        count[0]+=1\n    elif i==\"2\":\n        count[1]+=1\n    elif i==\"3\":\n        count[2]+=1\n    elif i==\"4\":\n        count[3]+=1\nprint(count)", "t": "fill", "ans": "[1,2,3,4]", "kp": "程序填空/调试", "o": [], "explanation": "程序遍历字符串s，利用count列表的四个元素分别统计字符'1'、'2'、'3'、'4'出现的次数。字符串中'1'出现1次，'2'出现2次，'3'出现3次，'4'出现4次，最终列表更新为[1,2,3,4]。" }, { "id": 237, "q": "输入n个数，按从小到大顺序排列后输出。请填空。\nn=int(input())\nx=____1___\nfor i in range(n):\n    x.append(int(input()))\nfor i in range(n-1):\n    for j in range(n-1-i):\n        if x[j]>x[j+1]:\n            _____2_____\n       \nprint(\"排序后数据:\",x)", "t": "fill", "ans": "[] | x[j],x[j+1]=x[j+1],x[j]", "kp": "程序填空/调试", "o": [], "explanation": "第1空：需创建一个空列表来存储后续输入的数据，故填[]。第2空：冒泡排序中，若前一个元素大于后一个元素则需交换位置，Python中可直接使用多重赋值x[j],x[j+1]=x[j+1],x[j]实现交换。" }, { "id": 238, "q": "程序填空题\n将集合 set1 和 set2 的并集存储在集合 union_set 中。\nset1 = {1, 2, 3}\nset2 = {3, 4, 5}\nunion_set = ___", "t": "fill", "ans": "set1|set2", "kp": "字典/集合", "o": [], "explanation": "在Python中，可以使用按位或运算符|或者union()方法来求两个集合的并集。因此，将set1和set2的并集赋值给union_set，应填入set1|set2。" }, { "id": 239, "q": "Python不支持的数据类型有（ ）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "char", "int", "float", "list" ], "explanation": "Python中没有单独的字符（char）数据类型，单个字符也被视为长度为1的字符串（str）。而int（整型）、float（浮点型）和list（列表）都是Python内置的标准数据类型。" }, { "id": 240, "q": "以下（）打印出smith\\exam1\\test.txt?", "t": "single", "ans": "B", "kp": "字符串", "o": [ "print(\"smith\\exam1\\test.txt\")", "print( \"smith\\\\exam1\\\\test.txt\")", "print( \"smith\\\"exam1\\\"test.txt\")", "print(\"smith\"\\exam1\"\\test.txt\")" ], "explanation": "在Python字符串中，反斜杠\\是转义字符。要输出普通的反斜杠，必须使用双反斜杠\\\\进行转义。选项B正确使用了转义，而选项A中的\\e和\\t会被解析为转义字符，导致输出结果错误。" }, { "id": 241, "q": "以下关于random库的描述错误的是（）", "t": "single", "ans": "D", "kp": "random/turtle等标准库", "o": [ "random.seed()可用于初始化随机数种子，用于随机数序列再现", "random.randint()将产生一个随机整数", "使用random库可以用import random方式引入", "random.random()将产生在0到1之间真正的随机数" ], "explanation": "random.random()生成的是[0.0, 1.0)之间的伪随机数，由确定性算法生成，而非真正的随机数。选项A、B、C关于种子初始化、随机整数生成及库引入的描述均正确。" }, { "id": 242, "q": "下面代码的输出结果是（）。\nx=10\ny=3\nprint(x%y,x**y)", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1 1000", "3 30", "3 1000", "1 30" ], "explanation": "x%y 计算 10 除以 3 的余数，结果为 1。x**y 计算 10 的 3 次方，结果为 1000。因此 print 函数输出 1 1000。" }, { "id": 243, "q": "以下叙述中正确的是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "Python 3.x与Python 2.x兼容", "Python语句只能以交互方式执行", "Python是解释型语言", "Python语言不是高级语言" ], "explanation": "Python 3.x 与 2.x 不完全兼容；Python 语句可以以交互方式或脚本方式执行；Python 是高级语言。因此只有 C 正确，Python 是一种解释型语言。" }, { "id": 244, "q": "下面属于实型常量的是（ ）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "\"flower\"", "2.14", "-23", "'3200'" ], "explanation": "实型常量即浮点数。A 和 D 选项是字符串类型，C 选项是整型常量，只有 B 选项 2.14 是带有小数点的浮点数，属于实型常量。" }, { "id": 245, "q": "关于Python语句A=-A，以下选项中描述正确的是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "A的值为0", "A和A的绝对值相等", "给A赋值为它的负数", "A和A的负数相等" ], "explanation": "赋值语句 A=-A 的作用是将变量 A 当前的值取相反数后，重新赋值给变量 A。这并不保证 A 的值为 0 或绝对值相等，而是执行取负并赋值的操作。" }, { "id": 246, "q": "下面语句执行后的结果是（ ）\nb=2\na=eval(\"1.1 + b\")\nprint(a)", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "1.1+b", "1.1+2", "3.1", "出错" ], "explanation": "eval() 函数会将字符串作为有效的 Python 表达式来求值。由于 b 已经被赋值为 2，eval(\"1.1 + b\") 会计算 1.1 + 2，结果为 3.1，并赋值给 a。" }, { "id": 247, "q": "在Python语言中，IPO模式不包括（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "Program（程序）", "Input（输入）", "Process（处理）", "Output（输出）" ], "explanation": "IPO 模式是指 Input（输入）、Process（处理）和 Output（输出），这是程序设计的基本模式。Program（程序）不属于 IPO 模式的三个基本环节。" }, { "id": 248, "q": "函数input(\"please input:\")括号中的字符串的作用是（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "打印输出字符串", "提示信息，用于用户输入信息提示", "无明显作用，可以省略", "查看数据类型" ], "explanation": "input() 函数用于接收用户输入。括号内的字符串参数会作为提示信息打印在屏幕上，引导用户进行输入，它本身不会被作为输入内容处理。" }, { "id": 249, "q": "以下代码的输出结果是（）。\nn=5\ns=100\nif n>=5:\n   n-=10\n   s=3\nelif n<5:\n   n-=10\n   s=4\nprint(s)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "3", "4", "100", "2" ], "explanation": "初始 n=5，满足 if 条件 n>=5，因此执行该分支下的语句：n 减去 10 变为 -5，s 被赋值为 3。elif 分支被跳过。最后打印 s 的值，结果为 3。" }, { "id": 250, "q": "以下代码的输出结果是（）。\nif 0:\n   print(\"hello\")\nelse:\n   print(\"world\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "world", "hello", "没有任何输出", "hello world" ], "explanation": "在 Python 中，数字 0 被视为布尔值 False。因此 if 0: 条件不成立，程序会跳过 if 分支，直接执行 else 分支，输出 \"world\"。" }, { "id": 251, "q": "表达式5>=x>=3与表达式（ ）是等价的。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "x<=5", "x>=3", "5>=x or x>=3", "5>=x and x>=3" ], "explanation": "Python 支持链式比较，5>=x>=3 会被解释为 5>=x 并且 x>=3。因此它与逻辑与表达式 5>=x and x>=3 是完全等价的。" }, { "id": 252, "q": "以下代码的输出结果是（）。\ni=4\nj=20\nk=3\nif(i['m','n',[1,2,3,4]]的值是（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "true", "false", "True", "False" ], "explanation": "列表比较按字典序逐元素进行。前两项相同，比较第三项子列表。Python中较短列表视为较小，故[1,2,3] < [1,2,3,4]，原表达式大于关系不成立，返回False。注意Python布尔值首字母大写。" }, { "id": 263, "q": "切片操作tuple(range(6))[::-2]执行结果为（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "(6, 4, 2, 0)", "(5, 3, 1)", "(6, 4, 2)", "5, 3, 1" ], "explanation": "range(6)生成元组(0,1,2,3,4,5)。切片[::-2]表示从末尾开始逆序，步长为2，依次取索引5、3、1对应的元素，结果为(5, 3, 1)。干扰项A/C起始索引或步长理解有误，D缺少元组括号。" }, { "id": 264, "q": "下列Python程序的运行结果是（ ）。\ns=[1,2,3,'a']\ns.append([4,5])\nprint(len(s))", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "2", "4", "5", "6" ], "explanation": "初始列表含4个元素。append()方法将参数作为单个整体追加到末尾，此处追加的是列表[4,5]，故元素总数变为5。len()返回5。干扰项B误用extend逻辑，A/D计算错误。" }, { "id": 265, "q": "假设有三个集合：A = {1, 2, 3, 4}，B = {3, 4, 5, 6}，C = {4, 5, 6, 7}，下面的表达式的结果是什么？\nresult = (A - B) & (B - C) | (C - A)\nresult.add(8)\nresult.remove(5)\nprint(len(result))", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "3", "4", "5", "6" ], "explanation": "集合差集A-B为{1,2}，B-C为{3}，交集为空；C-A为{5,6,7}。空集与{5,6,7}并集仍为{5,6,7}。添加8后为{5,6,7,8}，移除5后剩{6,7,8}，长度为3。" }, { "id": 266, "q": "当函数返回多个值时，用一个变量接收返回值，此时返回值类型为（ ）。", "t": "single", "ans": "B", "kp": "函数", "o": [ "字典", "元组", "集合", "列表" ], "explanation": "Python中函数返回多个值时，实际上是将这些值打包成一个元组返回。因此，使用单个变量接收时，该变量的类型为元组。选项A、C、D均不符合Python的默认打包机制。" }, { "id": 267, "q": "下列代码运行后的结果是（ ）。\ndef type(x):\n    if x!=0:\n        print(x%10,end='')\n        type(x//10)\nif __name__ == '__main__':\n    type(456)", "t": "single", "ans": "D", "kp": "函数", "o": [ "456", "0", "6", "654" ], "explanation": "函数type(x)通过递归实现数字逆序输出。当x=456时，x!=0成立，打印456%10即6，然后递归调用type(45)；接着打印45%10即5，递归调用type(4)；最后打印4%10即4，递归调用type(0)结束。因此输出结果为654。" }, { "id": 268, "q": "下列程序的运行结果是（ ）。\nf=lambda x,y:divmod(x,y)\nprint(f(7,4))", "t": "single", "ans": "B", "kp": "函数", "o": [ "3,1", "1，3", "7，4", "4，7" ], "explanation": "divmod(x, y)函数返回一个包含商和余数的元组，即(x // y, x % y)。对于divmod(7, 4)，商为1，余数为3，因此返回元组(1, 3)。选项B符合该结果。" }, { "id": 269, "q": "以下说法错误的是（ ）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "函数在调用过程中会进行参数传递。当实参传递给形参时，根据实际参数的类型不同，函数参数的传递方式分为值传递和引用传递或地址传递两种方式。", "当实际参数为不可变对象时，实参对形参的传递是值传递，而且单向的，实参的值传给形参，形参的值不能回传给实参。", "当实际参数为可变对象时，是将实参的地址传给形参，若在函数调用中形参的值被修改，则实参中的值也相应修改。", "不可变对象不能作为函数的参数，而可变对象可以作为函数的参数。" ], "explanation": "Python中无论是可变对象还是不可变对象，都可以作为函数的参数传递。不可变对象传递时相当于值传递，函数内修改不会影响实参；可变对象传递时相当于引用传递，函数内修改会影响实参。因此选项D说法错误。" }, { "id": 270, "q": "关于实例属性，以下说法错误的是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "实例属性是在类中的方法内定义的", "实例属性就是类属性", "实例属性属于实例对象，只能通过对象名访问", "类属性属于类对象，可以通过类对象访问" ], "explanation": "实例属性属于具体的实例对象，通常在__init__方法中通过self定义，只能通过对象名访问；而类属性属于类本身，所有实例共享，可通过类名或对象名访问。两者作用域和生命周期不同，因此选项B说法错误。" }, { "id": 271, "q": "下列说法中不正确的是（ ）。", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "类是对象的模板，而对象是类的实例", "实例属性名如果以__开头，就变成了一个私有变量", "只有在类的内部才可以访问类的私有变量，外部不能访问", "在Python中，一个子类只能有一个父类" ], "explanation": "Python支持多重继承，即一个子类可以同时继承多个父类的属性和方法。选项A、B、C关于类与对象、私有变量的描述均正确。因此选项D说法不正确。" }, { "id": 272, "q": "一个子类同时继承多个父类的行为称为（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "继承", "多重继承", "简单继承", "复杂继承" ], "explanation": "在面向对象编程中，一个子类同时继承两个或两个以上父类的特性，这种机制被称为多重继承。Python原生支持多重继承。选项A、C、D均不是标准术语或描述不准确。" }, { "id": 273, "q": "关于语句f=open('demo.txt','r')，下列说法不正确的是（ ）。", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "demo.txt文件必须已经存在", "只能从demo.txt文件读数据，而不能向该文件写数据", "只能向demo.txt文件写数据，而不能从该文件读数据", "\"r\"方式是默认的文件打开方式" ], "explanation": "open函数使用'r'模式表示只读模式，只能从文件中读取数据，不能写入。若文件不存在会报错，且'r'是默认打开方式。选项C描述为只能写不能读，与'r'模式功能完全相反，因此不正确。" }, { "id": 274, "q": "请给出下面代码段的正确答案（）\nA = {1, 6, 21, 42, 84}\nB = {9, 34, 51, 84, 89}\nC = {13, 16, 29, 61, 77}\nD = {x - 2 for x in A - B if x%2}\nE = {x + 1 for x in D^C}\nE.update(D)\nprint(E)", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{4, 5, 14, 17, 30, 40, 41, 62, 78}", "{-1, 0, 14, 17, 19, 20, 30, 62, 78}", "{-1, 19}", "{-1, 7, 19, 49, 87}" ], "explanation": "首先A-B去除84，剩{1,6,21,42}，其中奇数(x%2为真)为1和21，故D={-1, 19}。接着D^C求对称差集，因D与C无交集，结果为{-1,19,13,16,29,61,77}。推导式E将各元素加1，得{0,20,14,17,30,62,78}。最后E.update(D)将D的元素-1和19加入E，最终E为{-1, 0, 14, 17, 19, 20, 30, 62, 78}。" }, { "id": 275, "q": "程序填空，生成3个两位随机整数，输出其中最大的数。\nimport random\nx=random.randint(10,99)\ny=random.randint(10,99)\nz=random.randint(10,99)\nmax= ___1___if x>y else y\nmax=max if max>z else___2___ \nprint(\"x={0},y={1},z={2}\".format(x,y,z))\nprint(\"max=\",max)", "t": "fill", "ans": "x | z", "kp": "程序填空/调试", "o": [], "explanation": "本题考查条件表达式求最大值。第1空比较x和y，若x>y则取x，否则取y，故填x；第2空比较当前max与z，若max>z则保持max，否则取z，故填z。" }, { "id": 276, "q": "程序填空题\ndef calculate_average(scores):\n\"\"\"\n计算列表中元素的平均值，并返回结果。\n\"\"\"\n    total = sum(scores)\n    average = ___1_____ / ____2____\n    return average\nscores = [80, 90, 75, 85, 95]\nresult = calculate_average(scores)\nprint(result)", "t": "fill", "ans": "total | len(scores)", "kp": "程序填空/调试", "o": [], "explanation": "计算平均值需用总和除以元素个数。第1空填入已求得的总和变量total；第2空使用内置函数len(scores)获取列表scores的元素个数作为除数。" }, { "id": 277, "q": "给定函数fun 的功能是：根据整型形参n，计算如下公式的值,请在横线处填入正确答案。\ndef fun(n):\n    A=1\n    for i in range(2, n+1):\n        A = ___1___\n    return A\nn=eval(input(\"请输入一个数:\"))\nprint(___2___)", "t": "fill", "ans": "1/(1+A) | fun(n)", "kp": "程序填空/调试", "o": [], "explanation": "根据公式递推规律，每次循环将A更新为1/(1+A)，故第1空填1/(1+A)；第2空需要输出函数计算结果，应调用函数并传入参数n，故填fun(n)。" }, { "id": 278, "q": "以下程序的输出结果是[*queNo*]_。\ndef mytake(x,y,z):\n    s=0\n    for i in range(1,4):\n        s+=i*(x+y+z)\n    return s\nm=mytake(z=3,x=5,y=10)\nprint(m)", "t": "fill", "ans": "108", "kp": "函数", "o": [], "explanation": "函数调用时通过关键字参数传递，x=5，y=10，z=3，三者之和为18。循环变量i依次取1、2、3，每次将i乘以18累加到s中。最终s = 1×18 + 2×18 + 3×18 = 108。" }, { "id": 279, "q": "以下代码段的执行结果是_____。\nclass St:\n    def __init__(self,a,b):\n        self._a=a\n        self.__b=b\n    def setb(self,b):\n        self.__b=b\n    def getb(self):\n        return self.__b\ns=St(0,1)\ns.setb(3)\nprint(s.getb())", "t": "fill", "ans": "3", "kp": "面向对象", "o": [], "explanation": "类St中，__b是私有属性，只能通过类内部方法访问和修改。实例化时__b初始为1，调用setb(3)将__b修改为3，随后调用getb()返回__b的值，因此输出3。" }, { "id": 280, "q": "有以下程序代码，输出结果是[*queNo*]_。\nf1=open('d:\\\\a1.txt','w')\nlist=['a','b\\n','c','d']\nf1.writelines(list)\nf1.close()\nf1=open('d:\\\\a1.txt','r')\ns=f1.readline()\nprint(s)", "t": "fill", "ans": "ab", "kp": "文件操作", "o": [], "explanation": "writelines将列表元素依次写入文件，不自动添加换行，文件内容为'ab\\ncd'。readline()读取第一行直到遇到换行符，返回字符串'ab\\n'。print输出时可见字符为ab。" }, { "id": 281, "q": "输入25，以下程序的输出结果是（）。\nnumber = int(input('请输入一个整数'))\nif (number % 2 ==0 or number % 5 ==0) and number % 10 != 0:\n print('条件成立')\nelse:\n print('条件不成立')", "t": "fill", "ans": "条件成立", "kp": "分支结构", "o": [], "explanation": "输入25后，number=25。表达式number % 2 == 0为假，但number % 5 == 0为真，因此括号内or结果为真；同时number % 10 != 0也为真。整体条件成立，执行if分支，输出“条件成立”。" }, { "id": 282, "q": "在考生文件夹下存在一个Python源文件PY103.py,请编写代码替换横线，不修改其他代码，实现下面功能:\n让用户输入一个自然数n，如果n为奇数，输出表达式1+1/3+1/5+...+1 / n 的值；如果n为偶数，输出表达式1/2+1/4+1/6+...+1 / n 的值。输出结果保留2位小数。\n示例如下(其中数据仅用于示意) :\n输入:\n4\n输出:\n0.75\n提示:建议使用本机提供的Python集成开发环境IDLE填写，调试及验证程序。", "t": "fill", "ans": "def f(n):\ns = 0 #1初始化s为0\nif n % 2 == 1: # \"%\"为取模运算符。即返回整除后的余数。输入值对2取模为1，即是奇数。\nfor i in range(1, n+1, 2):#range返回一个间隔为2，左闭右开的区间，即1,3,5,7……n\ns += 1/i #1/i累加到s上并返回s，即s=0+1+1/3+1/5+……+1/n\nelse:\nfor i in range(2, n+1, 2):\ns += 1/i\nreturn s\nn = int(input())\nprint(round(f(n),2))#调用函数并通过四舍五入函数round取两位小数的精度。", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 283, "q": "获得用户输入的一个字符串，将字符串逆序输出，同时紧接着输出字符串的个数，请完善PY102.py中代码。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "s = input()\nprint(s[::-1],end=\"\")\nprint(len(s))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 284, "q": "给出如下代码：\n>>> x=3.14\n>>> eval('x+10')\n上述代码的输出结果是（）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "TypeError: must be str, not int", "系统错误", "13.14", "3.1410" ], "explanation": "eval()函数用于执行字符串表达式并返回结果。变量x已赋值为3.14，计算表达式'x+10'即3.14+10，结果为浮点数13.14。" }, { "id": 285, "q": "关于字符串类型转换的描述，错误的选项是（）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "str(123)的结果是'123'", "str(1.23)的结果是'1.23'", "str(1+2j)的结果是'(1+2j)'", "str(1+2)对表达式1+2进行字符串转换，结果是'1+2'" ], "explanation": "str()函数将对象转换为字符串形式。对于表达式1+2，Python会先计算表达式的值为3，然后再将3转换为字符串'3'，而不是直接转换表达式文本'1+2'。" }, { "id": 286, "q": "下列对变量的描述正确的是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "变量的名称是可以改变的", "id()函数可以查看变量在内存中的地址", "变量的值必须是实型", "变量在赋值时需要声明类型" ], "explanation": "Python中变量无需声明类型，且可指向任意类型对象。变量名一旦定义不可直接更改（只能重新赋值）。id()函数用于获取对象在内存中的唯一标识（地址），描述正确。" }, { "id": 287, "q": "以下关于Python缩进的描述中，错误的是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "缩进表达了所属关系和代码块的所属范围", "缩进是可以嵌套的，从而形成多层缩进", "分支、循环、函数等都能够通过缩进包含一批代码", "Python用严格的缩进表示程序的格式框架，所有代码都需要在行前至少加一个空格" ], "explanation": "Python使用缩进表示代码块层级，但并非所有代码都需要缩进。顶层代码（如全局变量定义、主程序入口）必须顶格书写，不需要在行前加空格，因此D选项描述错误。" }, { "id": 288, "q": "表达式round(1.5)==2的值为（ ）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "F", "T", "False", "True" ], "explanation": "Python 3中round()采用银行家舍入法，round(1.5)舍入到最近的偶数即2。因此表达式round(1.5)==2等价于2==2，比较结果为布尔值True。" }, { "id": 289, "q": "若输入x为100，输出的grade是（）\nx=int(input())\nif x>=60:\n   if x<=70:\n      grade='C'\n   else:\n      grade='B'\nelse:\n   grade='D'\nprint(grade)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "A", "B", "C", "D" ], "explanation": "输入x=100，满足外层x>=60条件，进入内层判断。由于100不满足x<=70，执行内层else分支，将grade赋值为'B'。最后打印grade，输出B。" }, { "id": 290, "q": "若输入x为100，输出的grade是（）\nx=int(input())\nif x>=60:\n    grade='D'\nif x>=70:\n    grade='C'\nif x>=80:\n    grade='B'\nif x>=90:\n    grade='A'\nprint(grade)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "A", "B", "C", "D" ], "explanation": "代码包含四个独立的if语句，而非if-elif结构。输入x=100，依次满足所有四个条件，grade的值被反复覆盖，最终被赋值为'A'。因此输出A。" }, { "id": 291, "q": "以下循环执行（ ）次。\ns=2\nwhile s:\n      s=s-1", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "1", "0", "3", "2" ], "explanation": "while循环条件为s，当s非零时视为True。初始s=2，第一次循环后s=1；第二次循环后s=0；第三次判断s为0即False，退出循环。因此循环体共执行2次。" }, { "id": 292, "q": "以下代码的输出结果是：（ ）\nx=[34,21,89,1]\nsorted(x)", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[1, 21, 34, 89]", "[89, 34, 21, 1]", "[34, 21, 89, 1]", "[21, 89, 1, 34]" ], "explanation": "`sorted()`函数会对可迭代对象进行升序排序并返回一个新列表，原列表保持不变。列表元素为整数，升序排列后结果为[1, 21, 34, 89]。选项B是降序，选项C是原列表，选项D是乱序。" }, { "id": 293, "q": "已知列表lst=list(\"abcd\"), 那么执行语句lst.extend(list(\"mn\"))之后，列表lst为（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "[\"abcd\",\"mn\"]", "['a','b','c','d','m']", "['a','b','c','d','n']", "['a', 'b', 'c', 'd', 'm', 'n']" ], "explanation": "`list(\"abcd\")`将字符串转为列表`['a', 'b', 'c', 'd']`。`extend()`方法用于在列表末尾一次性追加另一个序列中的多个值。`list(\"mn\")`为`['m', 'n']`，追加后列表变为`['a', 'b', 'c', 'd', 'm', 'n']`。选项A是`append()`的效果，B和C元素缺失。" }, { "id": 294, "q": "在Python中，如何创建一个包含元素1、2、3的set？", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "set(1, 2, 3)", "{(1, 2, 3)}", "set([1, 2, 3])", "{1: 2, 2: 3, 3: 4}" ], "explanation": "创建集合可以使用`set()`函数，它接受一个可迭代对象作为参数，如列表`[1, 2, 3]`。选项A传入多个独立参数会引发TypeError；选项B创建的是包含一个元组的集合；选项D创建的是字典而非集合。" }, { "id": 295, "q": "以下代码中哪个是正确函数定义的首部语句（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "def someFuntion()", "Def someFunction()", "def someFunction():", "Def someFunction():" ], "explanation": "Python中定义函数的关键字是小写的`def`，后跟函数名和圆括号，且首部语句必须以冒号`:`结尾。选项A缺少冒号，选项B和D的关键字首字母大写，均不符合Python语法规范。" }, { "id": 296, "q": "向函数传递参数时，不考虑在函数体内重新定义a的情况下，以下哪个函数调用可能会改变参数a的值？（ ）", "t": "single", "ans": "A", "kp": "函数", "o": [ "a=['result'];fun( a)", "a=2;fun(a)", "a='result';fun(a)", "a=('result');fun(a)" ], "explanation": "Python参数传递采用对象引用机制。列表是可变对象，在函数内部修改列表元素会直接影响原对象。而整数、字符串和元组（选项D本质为字符串或元组）均为不可变对象，函数内无法直接修改其本身的值。" }, { "id": 297, "q": "面向对象程序设计的简写是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "SP", "OS", "OOP", "OOS" ], "explanation": "面向对象程序设计（Object-Oriented Programming）的英文标准简写是OOP。选项A的SP通常指结构化程序设计，选项B的OS指操作系统，选项D为干扰项。" }, { "id": 298, "q": "文件family.txt在当前代码所在目录内，其内容是一段文本We are family，以下程序的输出结果是（ ）。\nm_file = open(\"family.txt\", \"r\")\ntxt = m_file.read()\nprint(txt)\nm_file.close()", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "txt", "family.txt", "We are family", "以上都是错误的" ], "explanation": "`open()`函数以只读模式打开文件，`read()`方法会读取文件的全部内容并返回字符串。因此变量`txt`的值为文件内容\"We are family\"，`print(txt)`会直接输出该段文本。" }, { "id": 299, "q": "以下程序的运行结果是[*queNo*]_______。\nn=24\nlst=[]\nwhile n>0:\n    lst.append(n%2)\n    n=n//2\nlst.reverse()\nfor x in lst:\n    print(x,end='')", "t": "fill", "ans": "11000", "kp": "循环结构", "o": [], "explanation": "该程序实现十进制转二进制。循环中不断对2取余，24的余数依次为0,0,0,1,1并存入列表。`reverse()`方法将列表反转为1,1,0,0,0。最后通过循环无换行打印列表元素，最终输出11000。" }, { "id": 300, "q": "程序填空题\n给定两个列表 keys 和 values，创建一个字典 my_dict，将 keys 中的元素作为键，values 中的元素作为对应键的值。\nkeys = ['a', 'b', 'c']\nvalues = [1, 2, 3]\nmy_dict = {}\nfor i in range(len(keys)):\n       my_dict[ _1__ [i] ] =___2__[i]\nprint(my_dict)", "t": "fill", "ans": "keys | values", "kp": "程序填空/调试", "o": [], "explanation": "程序通过遍历索引`i`来构建字典。第1空应填入`keys`，表示取键列表中的第`i`个元素作为字典的键；第2空应填入`values`，表示取对应值列表中的第`i`个元素作为字典的值。" }, { "id": 301, "q": "文件的_____操作是从文件中取出数据，再输入到计算机内存储器。", "t": "fill", "ans": "读", "kp": "文件操作", "o": [], "explanation": "文件的基本操作主要包括读和写。从外部存储设备（如磁盘文件）中获取数据并加载到计算机内存中的过程，在计算机术语中称为文件的\"读\"操作。" }, { "id": 302, "q": "以下程序的输出结果是（）。\n>>> x=False\n>>> x+(5>4)", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1", "0", "True", "False" ], "explanation": "在Python中，布尔类型是整数的子类，`False`等价于0，`True`等价于1。表达式`5>4`的结果为`True`。因此`x+(5>4)`相当于计算`0 + 1`，最终结果为整数1。" }, { "id": 303, "q": "字符串s='a\\nb\\tc'，则len(s)的值是（ ）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "7", "6", "5", "4" ], "explanation": "字符串中的`\\n`是换行符，`\\t`是制表符，它们均属于单个转义字符。因此该字符串实际包含'a'、'\\n'、'b'、'\\t'、'c'共5个字符，`len(s)`函数返回字符串长度5。" }, { "id": 304, "q": "下列关于Python的描述正确的是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "Python的整数类型有长度限制，超过上限会产生溢出错误", "Python语言中采用严格的\"缩进\"来表明程序格式，不可嵌套", "Python中可以采用八进制来表示整数", "Python的浮点类型没有长度限制，只受限于内存的大小" ], "explanation": "Python中整数类型没有长度限制，不会溢出，A错。Python采用缩进表示代码块且支持嵌套，B错。浮点数受限于IEEE 754双精度标准，并非只受内存限制，D错。Python支持使用0o或0O前缀表示八进制整数，C正确。" }, { "id": 305, "q": "Python中对变量描述错误的选项是（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "Python不需要显式声明变量类型，在第一次变量赋值时由值决定变量的类型", "变量通过变量名访问", "变量必须在创建和赋值后使用", "变量PI与变量Pi被看作相同的变量" ], "explanation": "Python是动态类型语言，变量无需显式声明类型，赋值即创建，A、B、C描述均正确。Python严格区分大小写，因此变量PI与变量Pi被视为两个完全不同的变量，D选项描述错误，符合题意。" }, { "id": 306, "q": "已知x=10;y=3,执行语句x/=y+1后，x的值是（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "2.5", "2.0", "4.3", "4.0" ], "explanation": "赋值运算符`/=`的优先级低于算术运算符`+`。因此先计算`y+1`得到4，然后执行`x = x / 4`，即`10 / 4`。在Python 3中，`/`表示真除法，结果为浮点数2.5。" }, { "id": 307, "q": "下面语句执行后的结果是（ ）\na=32\nprint(a)", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "32", "a", "\"32\"", "出错" ], "explanation": "代码首先将整数32赋值给变量a。随后调用print(a)函数，输出变量a的值。由于a存储的是整数32，因此直接输出数字32，不带引号。若输出字符串则需写为print(\"a\")。" }, { "id": 308, "q": "Python语言不可用的注释符是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "#", "'''…''' (一对三单引号)", "\"\"\"…\"\"\"(一对三双引号)", "//" ], "explanation": "Python使用#作为单行注释符。三引号本质上是多行字符串，但常被用作多行注释。而//在Python中是整除运算符，并非注释符（在C/C++或Java中才是注释符）。因此D不可用作注释。" }, { "id": 309, "q": "下列程序的运行时分别输入3和2，运行结果是（ ）\nx=input()\ny=input()\nprint(x+y)", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "5", "3", "2", "32" ], "explanation": "input()函数接收的用户输入默认均为字符串类型。因此，输入3和2后，变量x和y分别被赋值为字符串\"3\"和\"2\"。执行x+y时，进行的是字符串拼接操作，结果为\"32\"，而非数学加法。" }, { "id": 310, "q": "以下代码的输出结果是（）。\na=20\nb=30\nif a=0:\n       i-=1\nprint(\"i=\",i)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "i=10", "i=0", "i=1", "i=-1" ], "explanation": "循环条件为i>=0。当i递减到0时，仍满足条件，执行i-=1使i变为-1。再次判断-1>=0不成立，退出循环，最终输出i=-1。" }, { "id": 340, "q": "设有程序段：\nk=5\nfor i in (1,2,3,4,5):\n      k=k-1\nprint(k)\n则下面描述中正确的是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "for循环执行5次", "循环是无限循环", "循环体语句一次也不执行", "循环体语句执行一次" ], "explanation": "for循环遍历包含5个元素的元组(1,2,3,4,5)，因此循环体会执行5次。每次执行k减1，最终k的值为0。选项B、C、D描述均错误。" }, { "id": 341, "q": "s=\"abcdef\"，则s[::-1]表示（）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "f", "abcde", "abcdef", "fedcba" ], "explanation": "字符串切片s[::-1]中，步长为-1，表示从右向左逆序提取字符串中的所有字符。因此'abcdef'逆序提取后的结果为'fedcba'。" }, { "id": 342, "q": "下列关于列表的说法错误的是（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "列表中可以存放任意类型的元素", "使用列表时，其下标可以是负数", "列表是一个有序集合，可以添加或删除元素", "列表是不可变的数据结构" ], "explanation": "列表是Python中的可变数据结构，支持添加、删除和修改元素。选项A、B、C均正确描述了列表的特性，如支持任意类型、负数索引和有序可变。因此D选项说法错误。" }, { "id": 343, "q": "请给出下面代码段的正确答案（）\nA = {1, 2, 3, 4, 5}\nA.discard(3)\nx = A.pop() + A.pop() * A.pop()\nprint(x)", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "7", "13", "17", "9" ], "explanation": "集合A移除3后剩下{1,2,4,5}。在CPython中，小整数集合的pop()通常按升序弹出元素。前三个弹出的元素依次为1、2、4。代入表达式计算：1 + 2 * 4 = 9。注意集合本身无序，此结果依赖于特定Python版本的底层实现。" }, { "id": 344, "q": "请给出以下代码段的正确答案（）\nnote = {'handwrite':{'onenote','goodnotes'},'markdown':'typora'}\nnote['markdown'] = {'free':{'obsidian','notion'}}\nprint(len(note['handwrite'])*len(note['markdown']))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "1", "2", "3", "4" ], "explanation": "note['handwrite']是包含两个元素的集合，长度为2。note['markdown']被重新赋值为一个字典，该字典仅包含一个键'free'，因此长度为1。两者长度相乘结果为2。" }, { "id": 345, "q": "以下关于函数作用的描述错误的是（）", "t": "single", "ans": "A", "kp": "函数", "o": [ "提高代码执行速度", "复用代码", "增强代码的可读性", "降低编程复杂度" ], "explanation": "函数的主要作用是代码复用、增强可读性和降低编程复杂度。由于函数调用涉及压栈、跳转等开销，通常不会提高代码的执行速度，有时甚至会略微降低速度。因此A选项描述错误。" }, { "id": 346, "q": "以下选项中，对于递归程序的描述错误的是（ ）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "递归函数必须有终止条件", "函数内部包含对本函数的再次调用", "实现相同功能时，递归函数一般比使用循环的代码更为简洁和可读", "执行效率高" ], "explanation": "递归程序通过函数自身调用来解决问题，代码通常更简洁可读，且必须有终止条件。但由于每次调用都需要分配栈空间并保存现场，递归的执行效率通常低于等价的循环结构，且容易导致栈溢出。因此D选项错误。" }, { "id": 347, "q": "下列程序的运行结果是（ ）。\ndef mm(a=5,b=1):\n     y=a*b+b\n     return y\nh=mm(b=mm(),a=3)\nprint(h)", "t": "single", "ans": "B", "kp": "函数", "o": [ "21", "24", "22", "输出不确定值" ], "explanation": "首先计算内层函数mm()，使用默认参数a=5, b=1，返回5*1+1=6。接着计算外层函数mm(b=6, a=3)，此时a=3, b=6，计算y=3*6+6=24并返回。因此最终输出24。" }, { "id": 348, "q": "在类的方法定义中，可以通过表达式（）访问实例变量x。", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "x", "self.x", "self(x)", "this.x" ], "explanation": "在Python面向对象编程中，类的方法第一个参数通常是self，代表实例对象本身。要通过方法访问或修改实例变量，必须使用\"self.变量名\"的格式，因此访问实例变量x应使用self.x。" }, { "id": 349, "q": "以下程序的输出结果是（）\nclass A:\n    def __init__(self,name):\n        self.name=name\n    def show(self):\n        print(\"A类：\",self.name)\nclass B(A):\n    def show(self):\n        print(\"B类：\",self.name)\na=A(\"2\")\nb=B(\"1\")\nb.show()", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "A类：2", "B类：1", "B类：2", "A类：1" ], "explanation": "类B继承自类A，并重写了show()方法。创建B的实例b并传入参数'1'，调用b.show()时，会执行类B中重写后的show()方法，打印'B类：'及实例属性name的值'1'。" }, { "id": 350, "q": "下列程序运行后，得到的图形是（ ）。\nfrom turtle import *\ngoto(100,100)", "t": "single", "ans": "C", "kp": "random/turtle等标准库", "o": [ "水平直线", "垂直直线", "斜线", "只移动坐标不做图" ], "explanation": "turtle绘图默认起点为坐标(0,0)，且画笔默认处于落下状态。执行goto(100,100)会使画笔从原点移动到(100,100)，在两点之间绘制出一条斜线。" }, { "id": 351, "q": "在Python语言中，使用open()打开一个Windows操作系统D盘下的文件，路径名错误的是（ ）。", "t": "single", "ans": "A", "kp": "文件操作", "o": [ "D:\\PythonTest\\A．txt", "D:\\\\PythonTest\\\\A．txt", "D:/PythonTest/A．txt", "D://PythonTest//A．txt" ], "explanation": "在Python字符串中，反斜杠\"\\\"是转义字符。使用Windows路径时，若使用单反斜杠（如选项A），可能会引发转义错误。正确的写法应使用双反斜杠\"\\\\\"、正斜杠\"/\"或在字符串前加r前缀。因此A选项的路径写法是错误的。" }, { "id": 352, "q": "下面程序的运行结果是 （）\nA = {17, 27, 29, 61, 67}\nB = {18, 68, 70, 82}\nC = {29}\nprint(A.issubset(B),B.issubset(C))", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "True True", "True False", "False True", "False False" ], "explanation": "issubset()方法用于判断集合是否为另一集合的子集。集合A不是B的子集，返回False；集合B也不是C的子集，返回False。因此输出结果为False False。" }, { "id": 353, "q": "从键盘输入x的值，根据下面的表达式，计算并输出y的值。\n            2x 3 (x<0)\ny=\n            x (x>0)\nx=eval(input(\"请输入x:\"))\nif ___1__:\n    y=2*x*x*x\nelse:\n    y=___2___\nprint(\"y=\",y)", "t": "fill", "ans": "x<0 | x", "kp": "程序填空/调试", "o": [], "explanation": "根据分段函数逻辑，当x<0时计算2*x*x*x，故第1空填条件x<0；当x>=0时y的值为x，故第2空填x。" }, { "id": 354, "q": "以下程序段的输出结果是______。\nx=4\nif x**2>15:\n    y=x**2+1\nif x**2<15:\n    y=1/x\nprint(y)", "t": "fill", "ans": "17", "kp": "分支结构", "o": [], "explanation": "变量x初始值为4，x**2即16。第一个if条件16>15成立，执行y=16+1=17。第二个if条件16<15不成立，跳过。最终输出y的值17。" }, { "id": 355, "q": "假定所有变量均已正确说明，则下列程序段运行后x的值是（　　）。\na=b=c=0\nx=10\nif not a: x-=1\nelif b: x+=1\nif c:\n    x=3\nelse:\n    x=4\nprint(x)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "9", "4", "11", "5" ], "explanation": "初始a=b=c=0，x=10。第一个if语句中not a为True，执行x-=1使x变为9，elif跳过。接着执行第二个if语句，c为0即False，执行else分支将x赋值为4。最终输出4。" }, { "id": 356, "q": "Python支持复数类型，以下说法错误的是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "实部和虚部都是浮点数", "表示复数的语法是image+real j", "1+1j是复数", "虚部后缀可以是小写或者大写形式" ], "explanation": "Python中复数的标准语法是\"实部+虚部j\"（real+image j），而不是\"虚部+实部j\"。选项A、C、D的描述均符合Python复数类型的规则。" }, { "id": 357, "q": "下面表示回车符的转义字符是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "'\\r'", "'\\n'", "'\\f'", "'\\b'" ], "explanation": "在Python转义字符中，\\r表示回车符（Carriage Return），\\n表示换行符，\\f表示换页符，\\b表示退格符。因此正确选项为A。" }, { "id": 358, "q": "以下能够同时作用于所有数字类型和字符串类型的函数是（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "len()", "complex()", "type()", "bin()" ], "explanation": "type()函数可用于获取任何对象（包括所有数字和字符串）的数据类型。len()不支持数字类型，complex()和bin()不能通用于所有数字和字符串类型。" }, { "id": 359, "q": "执行下面的代码\n>>>100+10\n>>>_+1\n运行结果为（）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "100", "110", "111", "报错" ], "explanation": "在Python交互式解释器中，下划线_变量自动保存上一个表达式的计算结果。100+10的结果为110，此时_的值为110，因此_+1的计算结果为111。" }, { "id": 360, "q": "以下不属于Python语言保留字的是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "None", "False", "dict", "def" ], "explanation": "None、False和def均属于Python的保留字（关键字），具有特殊语法含义。dict是Python的内置类型和函数名，不属于保留字，理论上可被重新赋值。" }, { "id": 361, "q": "以下print输出不正确的是（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "print(1+2+3)", "print('1'+'2'+'3')", "print('1','2',3)", "print('1'+'2'+3)" ], "explanation": "在Python中，字符串和整数不能直接使用加号（+）进行拼接，选项D会引发TypeError类型错误。选项A为整数相加，B为字符串拼接，C为多参数输出，均合法。" }, { "id": 362, "q": "Python中的单行注释（#）和多行注释（三引号）的区别，下列说法正确的是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "都需要在开头和结尾标注", "二者无区别", "#后面的是注释，两个三引号之间的的是注释", "以上都不对" ], "explanation": "Python单行注释使用井号（#），其后的内容被视为注释；多行注释通常使用一对三单引号或三双引号，两个三引号之间的内容被视为注释。选项C描述准确。" }, { "id": 363, "q": "以下程序的输出结果是（ ）\ns1=\"QQ\"\ns2=\"Wechat\"\nprint(\"{}&{}\".format(s1,s2))", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "QQWechat", "QQ Wechat", "QQ&Wechat", "\"QQWechat\"" ], "explanation": "字符串的format()方法会按顺序将参数替换到字符串的{}占位符中。s1替换第一个{}，s2替换第二个{}，中间由&连接，因此最终输出结果为QQ&Wechat。" }, { "id": 364, "q": "在Python中，实现数据输入功能的函数是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "int()", "input()", "abs()", "str()" ], "explanation": "Python中用于接收用户键盘输入的标准内置函数是input()，它会将输入内容作为字符串返回。int()用于类型转换，abs()求绝对值，str()转为字符串，均不负责数据输入。故选B。" }, { "id": 365, "q": "下面的代码在运行时输入“123”，则输出结果是（）。\nx=input()\nif x== '1':\n   print('1')\nelif x== '2':\n   print('2')\nelif x== '3':\n   print('3')\nelse:\n   print('4')", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "1", "2", "3", "4" ], "explanation": "input()接收的输入为字符串\"123\"。条件判断依次比较x是否等于'1'、'2'、'3'，均不成立，因此执行else分支输出'4'。注意字符串比较需完全匹配，故选D。" }, { "id": 366, "q": "已知a=45,b=40,c=50, d=b if a>30 else c ,则d的值为（ ）。", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "1", "45", "40", "50" ], "explanation": "条件表达式语法为值1 if 条件 else 值2。此处a=45，a>30为真，因此返回if前的值b，即40。若条件为假则返回c。故选C。" }, { "id": 367, "q": "以下代码的输出结果是（）。\nb=80\nif b%2==0:\n   if b%3==0:\n      print('该数字能被 2 和 3 同时整除')\n   else:\n      print('该数字能被 2 整除')\nelif b%3==0:\n   print('该数字能被 3 整除')\nelse:\n   print('该数字不能被 2 和 3 整除')", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "该数字能被 2 和 3 同时整除", "该数字能被 2 整除", "该数字能被 3 整除", "该数字不能被 2 和 3 整除" ], "explanation": "b=80满足b%2==0进入外层if。内层判断b%3==0（80除以3余2）为假，执行内层else分支，输出\"该数字能被 2 整除\"。嵌套分支按顺序匹配，故选B。" }, { "id": 368, "q": "not True的值为（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "False", "True", "不确定", "错误" ], "explanation": "not是逻辑非运算符，用于对布尔值取反。True取反后结果为False，属于Python基础逻辑运算规则。故选A。" }, { "id": 369, "q": "以下代码的输出结果是（ ）。\nif 0:\n    print(\"hello\")", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "False", "hello", "没有任何输出", "语法错误" ], "explanation": "Python中数字0在布尔上下文中被视为假值（False）。因此if 0:条件不成立，其下的print语句不会执行，程序无任何输出。故选C。" }, { "id": 370, "q": "设有程序段：\nk=10\nfor i in range(1,11):\n    if(k==8):\n        break\n    k=k-1\nprint(k)\n则程序的运行结果是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "10", "9", "8", "7" ], "explanation": "循环初始k=10。第一次循环k减为9，第二次减为8。第三次循环开始时k==8成立，触发break跳出循环。最终打印k的值为8。故选C。" }, { "id": 371, "q": "下列代码的输出结果是（ ）。\nx= tuple()\ny=0\nwhile x:\n       y+=1\nelse：y+=2\nprint(y)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "0", "1", "2", "出错" ], "explanation": "x为空元组，布尔值为假，while循环体不执行。Python的while-else结构中，若循环条件初始为假或正常结束，会执行else块。因此y+=2执行，输出2。故选C。" }, { "id": 372, "q": "以下程序段的功能是（ ）。\na,b=eval(input(\"请输入两个正整数:\"))\nif a>b:\n    a,b=b,a\nfor i in range(b,a*b+1):\n    if i%a==0 and i%b==0:\n         print(\"gcd=\",i)\n         break", "t": "single", "ans": "B", "kp": "算法与综合应用", "o": [ "求a,b的最大公约数", "求a,b的最小公倍数", "求a,b的最小值", "求a,b的最大值" ], "explanation": "程序确保a<=b后，从b开始向上遍历，寻找第一个能同时被a和b整除的数i并输出。该数即为两数的最小公倍数（LCM）。最大公约数通常用辗转相除法，故选B。" }, { "id": 373, "q": "设有程序段：\ns=10\nfor i in (\"A\",\"O\",\"I\"):\n      pass\nprint(i, end= ',')\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "A,", "I,", "10,", "O," ], "explanation": "for循环遍历元组，pass为空语句不执行任何操作。循环结束后，循环变量i会保留最后一次迭代的值，即\"I\"。print(i, end=',')输出\"I,\"。故选B。" }, { "id": 374, "q": "下面代码的运行结果是( )。\nprint(\"数量{1},单价{0}\".format(12,34))", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "数量34,单价12", "数量12,单价34", "数量,单价12,34", "数量,单价34,12" ], "explanation": "format()方法中花括号内的数字表示参数索引。{1}对应第二个参数34，{0}对应第一个参数12。因此替换后输出\"数量34,单价12\"。故选A。" }, { "id": 375, "q": "s='1234567890'，s[-1:-len(s):-1]是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "098765432", "0987654321", "1234567890", "123456789" ], "explanation": "切片语法[start:stop:step]。start=-1指向末尾'0'，stop=-len(s)即-10（不包含），步长-1表示逆序。依次取索引-1至-9的字符，得到\"098765432\"。故选A。" }, { "id": 376, "q": "假设列表对象tup=(3,4,5,6,7,9,11,13,15,17),那么切片tup[1:10:2]得到的值是（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "(3,5,7,11,15)", "(4, 6, 9, 13, 17)", "(5,6,7,9)", "(4, 6, 9, 13)" ], "explanation": "元组切片语法为[start:stop:step]。起始索引1对应元素4，步长为2，依次取索引1、3、5、7、9的元素，即4、6、9、13、17。切片结果仍为元组，故选B。" }, { "id": 377, "q": "以下代码的输出结果是（ ）。\nlist1=[1,2,3,4]\nlist2=list1\nlist2.clear()\nprint(list1)", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[1,2,3,4]", "1,2,3,4", "[]", "错误" ], "explanation": "列表是可变对象，list2=list1使两者指向同一内存地址。调用list2.clear()会清空该共享列表对象，因此list1的内容也随之被清空，输出空列表[]。" }, { "id": 378, "q": "请输出下面代码段的正确答案（）\nA = {1, 2, 3, 4, 5}\nB = {4, 5, 6, 7, 8}\nC = (A - B) ^ (B - A)\nprint(C)", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "{1, 2, 3, 4, 5}", "{4, 5, 6, 7, 8}", "{1, 2, 3, 6, 7, 8}", "set()" ], "explanation": "集合A-B求差集得{1,2,3}，B-A得{6,7,8}。^为对称差集运算符，返回两个集合中非共有的元素，合并后结果为{1,2,3,6,7,8}。" }, { "id": 379, "q": "以下选项不是Python关键字的是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "function", "return", "def", "import" ], "explanation": "Python中定义函数使用的关键字是def，而不是function。return用于返回值，import用于导入模块，均为合法关键字。" }, { "id": 380, "q": "下列代码运行后的结果是（ ）。\ndef my(m):\n    if m==1:\n        return 1\n    else:\n        return 2*(my(m-1)+1)\ns=my(3)\nprint(\"{}\".format(s))", "t": "single", "ans": "B", "kp": "函数", "o": [ "6", "10", "4", "1" ], "explanation": "递归函数调用过程：my(1)返回1；my(2)返回2*(1+1)=4；my(3)返回2*(4+1)=10。最终s的值为10，格式化输出为10。" }, { "id": 381, "q": "以下程序代码的运行结果正确的是（ ）。\ns = 'global'\ndef fun():\n    global s\n    s = 'local'\n    print(s)\nfun()\nprint(s)", "t": "single", "ans": "D", "kp": "函数", "o": [ "global\nglobal", "global\nlocal", "local\nglobal", "local\nlocal" ], "explanation": "函数内使用global s声明后，对s的赋值会直接修改全局变量。因此函数内打印'local'，函数执行完毕后全局变量s也变为'local'，再次打印仍为'local'。" }, { "id": 382, "q": "下列代码的运行结果是（ ）。\nfact=lambda x,y,z:pow(x,y,z)\nprint(fact(5,2,7))", "t": "single", "ans": "D", "kp": "函数", "o": [ "叁数不正确", "0", "3", "4" ], "explanation": "pow(x, y, z)函数用于计算x的y次方对z取模的结果。代入参数即计算5的2次方(25)对7取模，25 % 7 = 4。" }, { "id": 383, "q": "有以下两个程序。\n程序一：\nx=[1,2,3]\ndef f(x):\n    x=x+[4]\nf(x)\nprint(x)\n程序二：\nx=[1,2,3]\ndef f(x):\n    x+=[4]\nf(x)\nprint(x)\n下列说法正确的是（ ）。", "t": "single", "ans": "A", "kp": "函数", "o": [ "两个程序均能正确运行，但结果不同", "两个程序的运行结果相同", "程序一能正确运行，程序二不能", "程序一不能正确运行，程序二能" ], "explanation": "程序一中x=x+[4]产生新列表并绑定到局部变量，全局x不变，输出[1,2,3]；程序二中x+=[4]就地修改原列表，全局x改变，输出[1,2,3,4]。两者均能运行但结果不同。" }, { "id": 384, "q": "如下所示程序片段中：\nclass Myclass:\n    def __init__(self):\n        x=30\n        __x=1\n        self.x=2\n        self.__x=3\n其中，私有属性是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "x", "__x", "self.x", "self.__x" ], "explanation": "Python中双下划线开头的变量触发名称改写机制实现私有化。严格意义上self.__x为实例私有属性，__x为局部变量，但依题意与答案，此处侧重考查双下划线前缀的私有命名特征。" }, { "id": 385, "q": "在面向对象程序设计中，具有相同属性和行为的一组对象形成一个类，每个这样的对象被称为类的一个（）。", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "实例", "属性", "方法", "函数" ], "explanation": "在面向对象编程中，类是抽象的模板，而根据类创建出来的一个个具体的对象被称为类的实例（Instance）。" }, { "id": 386, "q": "在继承关系中，以下哪个选项描述的不是被继承的类（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "子类", "基类", "超类", "父类" ], "explanation": "在继承关系中，被继承的类称为父类、基类或超类；而继承其他类的类称为子类或派生类。因此子类不是被继承的类。" }, { "id": 387, "q": "以下哪个访问模式可以用于向文件写入文本？（ ）", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "\"r\"", "\"w\"", "\"c\"", "\"x\"" ], "explanation": "文件打开模式中，'w'表示写入模式，会覆盖原有内容；'r'为只读模式；'x'为独占创建模式；'c'不是Python内置的标准文件打开模式。" }, { "id": 388, "q": "使用 open() 函数打开文件时，如果文件不存在，会发生什么？", "t": "single", "ans": "A", "kp": "文件操作", "o": [ "抛出异常", "创建一个新文件", "返回空文件对象", "无法确定" ], "explanation": "open()函数默认以只读模式('r')打开文件。在此模式下，若指定文件不存在，Python会抛出FileNotFoundError异常。若使用'w'或'a'模式则会创建新文件，但题干未指定模式时默认指'r'模式，故选A。" }, { "id": 389, "q": "已知集合A={1,2,3,4,5}，集合B={2,4,6,8}，以下哪个语句可以判断集合A是否是集合B的子集？", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "A.issubset(B)", "B.issubset(A)", "A in B", "B in A" ], "explanation": "判断集合A是否为集合B的子集，应使用集合的issubset()方法，即A.issubset(B)。B.issubset(A)是判断B是否为A的子集；in运算符用于判断元素是否属于集合，不能直接用于判断子集关系。故选A。" }, { "id": 390, "q": "e=1+1/1!+1/2!+1/3!+...1\n!+...，下面的程序根据该公式计算e的近似值，请在划线处添加适当的代码将程序补充完整。\nn=int(input(\"请输入n:\"))\ns=    1      \nx=1\nfor i in range(1,n+1):\n  x=x*   2      \n  s+=1/x\nprint(\"e=\",s)", "t": "fill", "ans": "1 | i", "kp": "程序填空/调试", "o": [], "explanation": "第1空：公式第一项为1，因此累加变量s的初始值应设为1。第2空：循环变量i从1到n，x用于计算阶乘，每次循环需将x乘以当前的i，即x=x*i，从而得到i!。因此填1和i。" }, { "id": 391, "q": "下列程序的输出结果是[*queNo*]___。\ni=0\nwhile i<10:\n    if i<1:\n        pass\n    if i==5:\n        break\n    i+=1\nprint(i)", "t": "fill", "ans": "5", "kp": "循环结构", "o": [], "explanation": "循环初始i=0。当i<1时执行pass，随后i+=1使i变为1。循环继续，直到i等于5时，触发if i==5条件，执行break跳出循环。此时i的值保持为5，最后print(i)输出5。" }, { "id": 392, "q": "以下程序的运行结果是[*queNo*]_______。\nlst1=[1,3,5,7,9]\nlst2=[2,4,6,8,10]\nnewlist=lst1.copy()\nnewlist.extend(lst2)\nnewlist.sort()\nprint(newlist)", "t": "fill", "ans": "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", "kp": "列表/元组", "o": [], "explanation": "newlist通过copy()获取lst1的副本[1,3,5,7,9]，extend()将lst2的元素追加到末尾，变为[1,3,5,7,9,2,4,6,8,10]。最后sort()进行升序排序，输出排序后的列表。" }, { "id": 393, "q": "下列程序运行的结果是什么？\ndef merge_dictionaries(dict1, dict2):\n    merged_dict = dict1.copy()\n    for key, value in dict2.items():\n        if key in merged_dict:\n            merged_dict[key] += value\n        else:\n            merged_dict[key] = value\n    return merged_dict\ndict1 = {'a': 1, 'b': 2}\ndict2 = {'b': 3, 'c': 4}\nresult = merge_dictionaries(dict1, dict2)\nprint(result['b'])", "t": "fill", "ans": "5", "kp": "字典/集合", "o": [], "explanation": "函数遍历dict2，若键在merged_dict中则值相加，否则直接赋值。dict1和dict2都有键'b'，其值分别为2和3。合并时执行merged_dict['b'] += 3，结果为5。最后打印result['b']即5。" }, { "id": 394, "q": "以下程序是判断指定序列x中，指定的元素y是否存在。请将程序补充完整。\ndef func (x,y):\n    for i in    1   :\n        if i    2    y:\n            return True\n    else:\n        return False\n    print(func([11, 20, 'abc'],20))", "t": "fill", "ans": "x | ==", "kp": "程序填空/调试", "o": [], "explanation": "第1空：需遍历序列x中的每个元素，故填x。第2空：判断当前元素i是否与目标元素y相等，应使用相等比较运算符==。若相等则返回True，否则循环结束后返回False。因此填x和==。" }, { "id": 395, "q": "以下程序的输出结果是[*queNo*]_。\ndef mytake(a,b,c):\n    s=''\n    for i in range(1,3):\n        s+=a+b+c\n    return s\nm=mytake(b='o',a='H',c='w')\nprint(m)", "t": "fill", "ans": "HowHow", "kp": "函数", "o": [], "explanation": "函数调用时通过关键字参数指定a='H', b='o', c='w'。循环range(1,3)执行2次，每次将a+b+c即'How'拼接到字符串s中。最终s的值为'HowHow'并返回打印。" }, { "id": 396, "q": "以下程序段的运行结果是[*queNo*]_。\nclass A:\n    def __init__(self):\n        print('A')\nclass B():\n    def __init__(self):\n        print('B')\nclass C(A,B):\n    pass\nc=C()", "t": "fill", "ans": "A", "kp": "面向对象", "o": [], "explanation": "类C继承自A和B，且未定义自己的__init__方法。实例化C时，Python按MRO（方法解析顺序）查找，首先找到父类A的__init__方法并执行，打印'A'。由于A的__init__未调用super()，B的初始化不会被执行。" }, { "id": 397, "q": "有以下程序代码，输出结果是[*queNo*]_。\nf1=open('d:\\\\a1.txt','w')\nlist=['1','2','3','4']\nf1.writelines(list)\nf1.close()\nf1=open('d:\\\\a1.txt','r')\ns=f1.read ()\nprint(s)", "t": "fill", "ans": "1234", "kp": "文件操作", "o": [], "explanation": "writelines()方法将列表中的字符串依次写入文件，不会自动添加换行符或空格，因此文件内容为连续的'1234'。随后以读模式打开并读取全部内容，打印结果即为'1234'。" }, { "id": 398, "q": "以下程序段的输出结果是_____。\nb = 6 if 5>13 else 9\nprint(b)", "t": "fill", "ans": "9", "kp": "分支结构", "o": [], "explanation": "该语句使用了Python的条件表达式（三元运算符），语法为\"值1 if 条件 else 值2\"。由于条件5>13为False，表达式返回else后面的值，即9。因此b被赋值为9并打印。" }, { "id": 399, "q": "在考生文件夹下有个文件PY101.py，在横线处填写代码，完成如下功能。接收用户输入的一个大于10小于108的十进制正整数，输出这个正整数各字符的和，以25为宽度，居中显示，采用等号=填充。例如：\n输入：\n1357\n输出：\n============16===========\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "cs=0\ncs += int(c)\nprint('{:=^25}'.format(cs))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 400, "q": "考生文件夹下存在一个文件PY101.py，请写代码替换横线，不修改其他代码，实现以下功能：\n键盘输入正整数n，按要求把n输出到屏幕，格式要求：宽度为20个字符，减号字符-填充，右对齐，带千位分隔符。如果输入正整数超过20位，则按照真实长度输出。\n例如：键盘输入正整数n为1234，屏幕输出 ---------------1,234\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "print(\"{:->20,}\".format(n))", "kp": "基础语法与输入输出", "o": [], "rawType": "operation" }, { "id": 401, "q": "考生文件夹下存在一个文件PY201.py，请写代码替换横线，不修改其他代码，实现以下功能：\n使用turtle库的turtle.right()函数和turtle.fd()函数绘制一个菱形，边长为200像素，4个内角度数为2个60度和2个120度，效果如图所示。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import turtle\nturtle.right(-30)\nturtle.fd(200)\nturtle.right(60)\nturtle.fd(200)\nturtle.right(120)\nturtle.fd(200)\nturtle.right(60)\nturtle.fd(200)\nturtle.right(120)", "kp": "random/turtle等标准库", "o": [], "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-turtle-rhombus-401.png", "rawType": "operation" }, { "id": 402, "q": "以下哪一个与特定文件关联，并提供了处理该文件的方法？", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "文件名", "文件扩展名", "文件对象", "文件变量" ], "explanation": "在Python中，通过open()函数打开文件后会返回一个文件对象。该对象与特定文件关联，并提供了read()、write()等处理该文件的方法。文件名和扩展名只是字符串标识，故选C。" }, { "id": 403, "q": "下列关于Python中复数类型的描述错误的是（）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "复数由实数部分和虚数部分构成", "复数可以看作是二元有序实数对（a，B）", "虚数部分必须后缀j，且为小写", "复数中的虚数部分不能单独存在，必须有实数部分" ], "explanation": "Python中复数的虚部后缀既可以使用小写字母j，也可以使用大写字母J，因此选项C描述错误。复数由实部和虚部组成，可看作有序实数对。" }, { "id": 404, "q": "下面（）不是运算符\"+\"的用法。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "字符串连接", "算数加法", "列表相加", "集合相加" ], "explanation": "在Python中，加号（+）可用于数字的算术加法、字符串的拼接以及列表或元组的合并。但集合（set）不支持使用加号进行相加操作，集合的并集运算应使用竖线（|）符号。" }, { "id": 405, "q": "在python中，下列属于字符串常量的是（ ）", "t": "single", "ans": "A", "kp": "字符串", "o": [ "\"python\"", "3.14", "cnt", "2018" ], "explanation": "Python中的字符串常量必须使用引号（单引号、双引号或三引号）括起来。选项A使用了双引号，属于字符串；选项B是浮点数，选项C是变量标识符，选项D是整数常量。" }, { "id": 406, "q": "已知x=5;y=6,语句x+=y执行后，x的值是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "5", "6", "11", "12" ], "explanation": "复合赋值运算符\"+=\"表示将左侧变量与右侧表达式的值相加后重新赋值给左侧变量。x+=y等价于x=x+y，已知x=5，y=6，执行后x的值为5+6=11。" }, { "id": 407, "q": "以下哪个Python指令不需要缩进（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "input", "if", "for", "while" ], "explanation": "input是Python的内置函数，调用时本身不需要强制缩进。而if、for、while属于控制流语句，它们所引导的代码块内部必须通过缩进来表示层级和从属关系。" }, { "id": 408, "q": "以下代码的输出结果是（）。\nn=5\ns=100\nif n>=5:\n   if n<=5:\n      n-=10\n      s=3\nprint(s)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "3", "4", "100", "2" ], "explanation": "初始n=5，s=100。第一层条件n>=5成立，进入内部；第二层条件n<=5也成立，执行n-=10和s=3。最终s的值被修改为3，print(s)输出3。" }, { "id": 409, "q": "执行下列程序后，i的值是（ ）。\nk=1\nn=123\nfor i in range(3) :\n      k*=n%10\n      n//=10\nprint(i)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "2", "6", "36", "0" ], "explanation": "for循环使用range(3)生成序列0、1、2。循环变量i依次被赋值为0、1、2。当循环正常结束时，循环变量i保留最后一次迭代的值，即2。题目询问的是i的值而非k的值。" }, { "id": 410, "q": "以下构成Python循环结构的方法中，正确的是（）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "while", "1oop", "if", "do...for" ], "explanation": "Python语言中构成循环结构的关键字只有while和for。选项B的loop和选项D的do...for在其他语言中可能存在，但在Python中不是合法关键字；if用于分支结构。" }, { "id": 411, "q": "设变量已正确定义，则以下能正确计算f = n!(n>=1)的程序是（　　）。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "f=0\nfor i in range(1,n+1):\nf*=i", "f=1\nfor i in range(1,n):\nf*=i", "f=1\nfor i in range(n,1):\nf*=i", "f=1\nfor i in range(n,1,-1):\nf*=i" ], "explanation": "计算阶乘初始值f必须为1，排除A。B选项range(1,n)不包含n，少乘了n。C选项range(n,1)默认步长为1，无法递减。D选项range(n,1,-1)从n递减到2，依次乘入f，能正确计算n!。" }, { "id": 412, "q": "已知s='how are you'，执行print(s.count('o'))的结果是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "2", "1", "'hw are yu'", "'how are youo'" ], "explanation": "字符串的count()方法用于统计指定子字符串在原字符串中出现的次数。在字符串'how are you'中，字母'o'在'how'和'you'中各出现一次，共计2次。" }, { "id": 413, "q": "s=\"abc\",（）不是正确的索引。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "s[len(s)]", "s[-3]", "s[-1]", "s[-2]" ], "explanation": "字符串s=\"abc\"的长度为3，合法的正向索引范围是0到2，反向索引是-1到-3。len(s)的值为3，s[3]超出了最大索引范围，会引发IndexError异常，因此不是正确的索引。" }, { "id": 414, "q": "下面代码的输出结果是( )。\nd ={\"天空\":\"灰色\",\"大海\":\"蓝色\" ,\"大地\":\"黑色\"}\nprint(d[\"天空\"],D．get(\"大地\",\"黄色\"))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "黑色 灰色", "灰色 黑色", "灰色 黄色", "黑色 黄色" ], "explanation": "字典通过键访问值，d[\"天空\"]返回\"灰色\"。get方法在键存在时返回对应值，\"大地\"存在，故返回\"黑色\"而非默认值\"黄色\"。注意题干代码中D.get存在大小写及全角标点瑕疵。" }, { "id": 415, "q": "在Python程序中，关于全局变量和局部变量描正确的是（ ）", "t": "single", "ans": "C", "kp": "函数", "o": [ "全局变量的作用范围一定比局部变量的作用范围大。", "全局变量只能定义在函数外部，不能在函数内部定义。", "全局变量与局部变量同名时，在局部变量的作用范围内，全局变量被“屏蔽”， 局部变量起作用。", "全局变量与局部变量的不能取相同的变量名。" ], "explanation": "在Python中，当全局变量与局部变量同名时，函数内部会优先使用局部变量，此时全局变量被\"屏蔽\"，选项C正确。全局变量可以在函数内部通过global关键字声明并定义，选项B错误。全局变量和局部变量可以同名，选项D错误。作用范围大小并非绝对，选项A错误。" }, { "id": 416, "q": "以下说法错误的是（ ）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "python语言中，匿名函数是指没有函数名的函数。", "匿名函数一般只可包含一个表达式，表达式的值就是该匿名函数返回值。", "python语言中，是使用保留字lambda来创建匿名函数。", "调用匿名函数时，不能采用关键字作为参数。" ], "explanation": "Python中使用lambda关键字创建匿名函数，它没有函数名，且通常只包含一个表达式并返回其值，因此A、B、C说法均正确。调用匿名函数时，完全可以像普通函数一样使用关键字参数进行传参，例如(lambda x, y: x+y)(x=1, y=2)，因此选项D说法错误。" }, { "id": 417, "q": "以下哪种函数不可以移动文件指针（ ）。", "t": "single", "ans": "A", "kp": "文件操作", "o": [ "tell()", "read()", "write()", "seek()" ], "explanation": "在Python文件操作中，tell()方法用于返回文件指针的当前位置，并不会移动指针，选项A符合题意。read()和write()在读写数据时会自动向后移动文件指针，seek()方法则专门用于将文件指针移动到指定位置，因此B、C、D都会移动指针。" }, { "id": 418, "q": "下列 Python 程序的运行结果是（ ）。\ns1=set([1,2,2,3,3,3,4,5,9])\ns2={1,3,5,6,4}\nprint(s1&s2-s1.difference(s2))", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "{1，2，3，6，4}", "{1，2，6，9}", "{1，3，5，6，4}", "{1，3， 4， 5}" ], "explanation": "s1去重后为{1,2,3,4,5,9}。s1.difference(s2)求差集得{2,9}。由于算术减号优先级高于按位与，先计算s2-{2,9}得{1,3,4,5,6}，再与s1求交集得{1,3,4,5}。选项D正确。" }, { "id": 419, "q": "以下程序的功能是求表达式1+1/(1+2)+ /(1+2+3)+…+/(1+2+3+…+n)的值，请填空。\ns=0\nn=int(input())\nfor i in range(1,n+1):\n    a1=0\n    for j in range(1,   1      ): \n        a1+=j\n    a=    2     \n    s+=a\n   print(\"s=\",s)", "t": "fill", "ans": "i+1 | 1/a1", "kp": "程序填空/调试", "o": [], "explanation": "程序用于计算级数和。外层循环变量i表示当前项的分母累加次数。内层循环计算分母a1，需累加从1到i的整数，因此第1空填i+1使range包含i。第2空计算当前项的值，即1除以分母a1，故填1/a1，随后累加到总和s中。" }, { "id": 420, "q": "已知两个列表s1和s2，使用列表s3来获取两个列表中相同的元素并输出。请填空。\ns1=[1,2,'a','b']\ns2=['a',5,2,'c']\ns3=____1___\nfor i in range(0,len(s1)):\n    for j in range(0,len(s2)):\n        if ___2____:\n            s3.append(s2[j])\n print(s3)", "t": "fill", "ans": "[] | s1[i]==s2[j]", "kp": "程序填空/调试", "o": [], "explanation": "程序通过双重循环遍历两个列表寻找相同元素。第1空需初始化一个空列表用于存储结果，故填[]。第2空是判断条件，当s1的第i个元素与s2的第j个元素相等时，将其加入s3，因此填s1[i]==s2[j]。" }, { "id": 421, "q": "编写一个程序将两个字符串转换为两个集合，求这两个集合的交集，然后输出。请填空。\nstr1 = input()\nstr2 = input()\ns1 = set(str1)\ns2 = set(str2)\ns = [*queNo*]___\nprint(s)", "t": "fill", "ans": "s1&s2", "kp": "程序填空/调试", "o": [], "explanation": "题目要求求两个集合的交集。在Python中，可以使用按位与运算符&来计算两个集合的交集。因此，将s1和s2的交集赋值给变量s，第1空应填入s1&s2。" }, { "id": 422, "q": "表达式False+1的值为（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "0", "1", "2", "语法错误" ], "explanation": "在Python中，布尔类型是整型的子类，False等价于整数0，True等价于整数1。因此表达式False+1相当于0+1，计算结果为1。选项B正确。" }, { "id": 423, "q": "以下属于Python中导入语句的是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "class", "return", "import", "print" ], "explanation": "在Python中，import语句用于导入模块或包，以便在当前程序中使用其定义的函数、类或变量。class用于定义类，return用于函数返回值，print用于输出信息。因此选项C正确。" }, { "id": 424, "q": "python文件的扩展名是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "py", "pye", "vbp", "pyr" ], "explanation": "Python源代码文件的标准扩展名是.py。选项B、C、D均不是Python文件的标准扩展名，其中vbp通常是Visual Basic的工程文件。因此选项A正确。" }, { "id": 425, "q": "执行以下Python语句后，x,y的值是（ ）\n>>> x=7\n>>> y=5\n>>> x=y\n>>> y=x", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "x=7,y=7", "x=5,y=5", "x=7,y=5", "x=5,y=7" ], "explanation": "初始时x=7，y=5。执行x=y后，x的值被更新为5。接着执行y=x，此时x的值已经是5，因此y的值也被赋为5。最终x和y的值均为5，选项B正确。" }, { "id": 426, "q": "在python中，语句print(a,b)的意思是()", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "打印a,b", "输出（a,b）", "输出a,b", "输出a,b的值" ], "explanation": "在Python中，print(a,b)函数的作用是将变量a和变量b所存储的值输出到控制台，中间默认以空格分隔。它并不是输出字符串\"a,b\"或元组，而是输出这两个变量的值。因此选项D最准确。" }, { "id": 427, "q": "下列关于Python程序格式的描述中，错误的是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "缩进表达了所属关系和代码块的所属范围", "注释可以在一行中的任意位置开始，这一行都会作为注释不被执行", "进行赋值操作时，在运算符两边各加一个空格可以使代码更清晰", "文档注释的开始和结尾使用三单引号或三双引号" ], "explanation": "B选项错误。在Python中，注释以#开头，但如果#出现在字符串字面量内部，它只是字符串的一部分，不会被当作注释处理。因此注释不能在任意位置开始。A、C、D均符合Python代码规范与语法。" }, { "id": 428, "q": "Python语句print(\"{:4x}\".format(33) )中x代表的含义为（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "二进制", "十进制", "八进制", "十六进制" ], "explanation": "在字符串格式化中，格式说明符x表示将整数格式化为小写十六进制数，X表示大写十六进制。b为二进制，o为八进制，d为十进制。因此x代表十六进制。" }, { "id": 429, "q": "执行以下程序段，若输入数据分别是12 和34，则输出结果是( )。\na=int(input())\nb=eval(input())\nprint(b+a)", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "12", "3412", "34", "46" ], "explanation": "input()接收输入，int()将'12'转为整数12赋给a；eval()将'34'求值为整数34赋给b。两者相加为46。若b用input()不加eval则为字符串拼接'3412'，但此处为数值相加。" }, { "id": 430, "q": "键盘输入数字-5，以下代码的输出结果是（）。\nn=eval(input())\ns=0\nif n>=5:\n   n-=1\n   s=-4\nelif n==50:\n   n-=1\n   s=-3\nelse:\n   s=-100\nprint(s)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "0", "-100", "-3", "-4" ], "explanation": "输入-5赋给n。判断n>=5为假，判断n==50为假，程序进入else分支，将-100赋给s。最后打印s的值，因此输出-100。" }, { "id": 431, "q": "下面的代码在运行时输入“1”，则输出结果是（）。\nx=input()\nif x== '1':\n   if x>= '0' and x<='1':\n      print('01')\n   else:\n         print('02')\nelse:\n   print('1')", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "01", "02", "1", "报错" ], "explanation": "输入'1'，x为字符串'1'。外层x=='1'成立进入内层。字符串比较按ASCII码，'1'大于等于'0'且小于等于'1'成立，执行print('01')。" }, { "id": 432, "q": "对于a and b，当a的值可解释为True，则表达式的值为（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "b的值", "False", "True", "不确定" ], "explanation": "Python中and运算符具有短路特性。当a为真时，表达式的结果取决于b，因此直接返回b的值；若a为假，则返回a的值。" }, { "id": 433, "q": "下列代码的输出结果是（ ）\nx=0\ny=100\nif x:\n    y=2\nprint(y)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "0", "100", "2", "报错" ], "explanation": "变量x被赋值为0。在Python中，整数0在布尔上下文中被视为False。因此if x:条件不成立，跳过y=2的赋值，y保持原值100并输出。" }, { "id": 434, "q": "执行下列程序后，k的值是（ ）。\nk=1\nn=321\nfor i in range(3) :\n    k*=n%10\n    n//=10\nprint(k)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "18", "6", "36", "2" ], "explanation": "初始k=1，n=321。循环3次：第1次k=1*(321%10)=1，n=32；第2次k=1*(32%10)=2，n=3；第3次k=2*(3%10)=6，n=0。最终k的值为6。" }, { "id": 435, "q": "执行下列程序后，k的值是（ ）。\nk=0\nn=321\nwhile n:\n       k+=n%10\n       n//=10", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "3", "2", "1", "6" ], "explanation": "该程序通过while n:循环，每次将n的个位数字（n%10）累加到k中，然后整除10去掉个位（n//=10）。即计算321各位数字之和：3+2+1=6。" }, { "id": 436, "q": "以下代码的输出结果是（）。\nfor s in \"HelloWorld\":\n    if s==\"W\":\n        continue\n    print(s,end=\"\")", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "World", "Hello", "Helloorld", "HelloWorld" ], "explanation": "遍历字符串'HelloWorld'，当字符为'W'时执行continue跳过本次循环的剩余语句（即不打印），其他字符正常打印且不换行。因此输出'Helloorld'。" }, { "id": 437, "q": "设有程序段：\ns=10\nfor i in [1,4,7]:\n      pass\nprint(i)\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "4", "7", "0", "1" ], "explanation": "for循环遍历列表[1,4,7]，循环体pass为空操作。循环结束后，循环变量i会保留最后一次迭代的值，即列表的最后一个元素7。" }, { "id": 438, "q": "以下while循环的执行次数是（ ）。\ni=0\nfor i in range(0,5):\n    while i<10:\n        if i<1:\n            continue\n        if i==5:\n            break\n        i+=1", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "1次", "2次", "100次", "无限次" ], "explanation": "当for循环i=0时，进入while i<10。由于i=0满足i<1，执行continue跳过后续语句，i的值未改变，导致再次判断i<10仍成立，陷入无限死循环。" }, { "id": 439, "q": "单选题:表达式'1234'.islower()的值为（）。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "True", "False", "可能为True也可能为False", "表达式错误" ], "explanation": "islower()方法用于判断字符串中所有包含大小写的字符是否均为小写，且至少包含一个区分大小写的字符。字符串'1234'全为数字，不包含任何字母，因此返回False。" }, { "id": 440, "q": "访问字符串中的部分字符的操作称为（ ）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "分片", "合并", "索引", "赋值" ], "explanation": "在Python中，访问字符串中单个字符的操作称为索引，而访问字符串中连续的一部分字符（即子串）的操作称为分片或切片。合并是拼接字符串，赋值是修改变量。" }, { "id": 441, "q": "tuple(range(1,11,2))的返回结果是( )。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[1,3,5,7,9]", "[1,3,5,7,9,11]", "(1,3,5,7,9)", "(1,3,5,7,9,11)" ], "explanation": "range(1, 11, 2)生成从1开始、步长为2、小于11的整数序列，即1, 3, 5, 7, 9。tuple()函数将该序列转换为元组，因此结果为(1, 3, 5, 7, 9)。注意元组使用圆括号。" }, { "id": 442, "q": "tuple(range(2,10,2))的返回结果是( )。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[2, 4, 6, 8]", "[2, 4, 6, 8, 10]", "(2, 4, 6, 8)", "(2, 4, 6, 8, 10)" ], "explanation": "range(2, 10, 2)生成从2开始、步长为2、小于10的整数序列，即2, 4, 6, 8。tuple()函数将其转换为元组，结果使用圆括号包裹，即(2, 4, 6, 8)。" }, { "id": 443, "q": "下面哪个选项用于创建一个空的set？", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "set()", "{}", "()", "[]" ], "explanation": "在Python中，使用set()函数可以创建一个空集合。直接使用花括号{}会创建一个空字典而不是空集合，圆括号()创建空元组，方括号[]创建空列表。" }, { "id": 444, "q": "字典 d={'Name': 'Lisa', 'Sex': 'Female', 'Age': '18'}，表达式len（D）的值为( )。", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "12", "9", "6", "3" ], "explanation": "len()函数用于返回字典中键值对的数量。该字典包含'Name'、'Sex'和'Age'三个键值对，因此长度为3。注意题目中变量名大小写可能存在笔误，按常规理解指代该字典。" }, { "id": 445, "q": "函数的第一行称为函数的（）", "t": "single", "ans": "A", "kp": "函数", "o": [ "首部", "块", "返回", "参数" ], "explanation": "在Python中，函数定义的第一行以def关键字开头，包含函数名和参数列表，这一行被称为函数首部（或函数头）。其后的缩进代码块称为函数体。" }, { "id": 446, "q": "下列代码的运行时n的值输入3，运行结果是（ ）。\ndef fact(n):\n    if n<=1:\n        return 1\n    else:\n        return n*fact(n-1)\nn=eval(input(\"请输入n的值：\"))\ns=fact(n)\nprint(\"{}\".format(s))", "t": "single", "ans": "A", "kp": "函数", "o": [ "6", "24", "3", "输出随机值" ], "explanation": "该代码定义了一个递归函数fact(n)用于计算阶乘。当输入n=3时，执行过程为：fact(3)返回3*fact(2)，fact(2)返回2*fact(1)，fact(1)满足n<=1返回1。最终结果为3×2×1=6。" }, { "id": 447, "q": "以下程序代码的运行结果正确的是（ ）。\ndef sum():\n    global dict1\n    dict1={'d':4,'e':5,'f':6}\n    return dict1\ndict1={'a':1,'b':2,'c':3}\nsum( )\nprint('{}'.format(dict1))", "t": "single", "ans": "A", "kp": "函数", "o": [ "{'d': 4, 'e': 5, 'f': 6}", "{'a':1,'b':2,'c':3}", "{'d': 4, 'e': 5, 'f': 6,'a':1,'b':2,'c':3}", "{'a':1,'b':2,'c':3,'d': 4, 'e': 5, 'f': 6}" ], "explanation": "函数sum()内部使用global dict1声明了全局变量，随后将其重新赋值为新字典{'d':4,'e':5,'f':6}。调用该函数后，全局变量dict1被覆盖，因此打印结果为新的字典内容。" }, { "id": 448, "q": "下面哪个方法在创建类的实例的时候会自动执行？（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "__del__", "__init__", "__state__", "__str__" ], "explanation": "在Python面向对象编程中，__init__方法是类的构造函数。当创建类的实例（对象）时，该方法会自动被调用，用于初始化对象的属性。__del__是析构函数，__str__用于字符串表示。" }, { "id": 449, "q": "以下关于Python中的继承和多态，说法错误的是（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "子类继承父类的私有属性和私有方法", "Python是一种多态语言", "子类继承父类的公有属性和公有方法", "以上说法都是错误的" ], "explanation": "在Python中，子类可以继承父类的公有属性和公有方法，但不能直接继承或访问父类的私有属性和私有方法（以双下划线开头的成员会被名称改写）。因此选项A的说法是错误的。" }, { "id": 450, "q": "下列哪个选项是下面代码的执行结果？（ ）\nturtle.circle(-90,180)", "t": "single", "ans": "D", "kp": "random/turtle等标准库", "o": [ "绘制一个半径为180像素的整圆形", "绘制一个半径为180像素的弧形，圆心在画布正中心", "绘制一个半径为90像素的半圆，圆心在小海龟当前行进的左侧", "绘制一个半径为90像素的半圆，圆心在小海龟当前行进的右侧" ], "explanation": "turtle.circle(radius, extent)中，radius为-90表示半径为90且圆心在海龟行进方向的右侧；extent为180表示绘制180度的弧形，即半圆。因此该代码绘制一个半径为90像素、圆心在右侧的半圆。" }, { "id": 451, "q": "下面程序的运行结果是 （）\ncompany_not_allow = {'女', '喝酒', '抽烟', '睡懒觉'}\none_player = {'男', '跑步', '朝气', '喝酒'}\ntwo_player = {'女', '生活规律', '跆拳道'}\nthree_player = {'男', '太极拳'}\nfour_player = {'男', '空手道', '年轻'}\nprint(company_not_allow.isdisjoint(one_player))\nprint(company_not_allow.isdisjoint(two_player))\nprint(company_not_allow.isdisjoint(three_player))\nprint(company_not_allow.isdisjoint(four_player))", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "False False True True", "False True True True", "False False Flase True", "True False True True" ], "explanation": "isdisjoint()方法用于判断两个集合是否没有交集，若无交集返回True，否则返回False。one_player和two_player分别与company_not_allow有共同元素'喝酒'和'女'，故前两次调用返回False；three_player和four_player与company_not_allow无共同元素，故后两次调用返回True。" }, { "id": 452, "q": "从键盘输入一个数，判别它是奇数还是偶数。请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。注意:不得增行或删行，也不得更改程序的结构！\na=eval(input(\"请输入一个数\"))\nif ____1_____: #请写出判断偶数的条件\n      print(a,\"是偶数\")\n____2_____: #否则\n      print(a,\"是奇数\")", "t": "fill", "ans": "a%2==0 | else", "kp": "分支结构", "o": [], "explanation": "第1空需要判断变量a是否为偶数，利用取模运算符，当a除以2的余数为0时即为偶数，故填a%2==0。第2空对应if语句的否则分支，Python中应使用else关键字，且末尾需加冒号，故填else。" }, { "id": 453, "q": "以下程序的运行结果是[*queNo*]_______。\nlst=[2,4,6,8]\nx=7\nfor i in range(0, len(lst)):\n    if (x=5:\n   n-=10\n   s=3\nelif n==5:\n   n-=10\n   s=4\nelse:\n   s=5\nprint(s)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "3", "4", "5", "2" ], "explanation": "初始n=-5，s=100。首先判断if条件n>=5为假，接着判断elif条件n==5也为假，因此程序直接执行else分支，将s赋值为5。最后打印s，输出结果为5。" }, { "id": 466, "q": "下列代码的输出结果是（）\nif 2>=0:\n    print(True )\nelse:\n    print( False)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "True", "False", "报错", "没有输出" ], "explanation": "条件表达式2>=0的比较结果为布尔值True。因此程序进入if分支，执行print(True)语句，在控制台输出True。" }, { "id": 467, "q": "关于 Python 的分支结构，以下选项中描述错误的是（ ）。", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "分支结构使用if 保留字", "Python 中 if-else 语句用来形成二分支结构", "Python 中 if-elif-else 语句描述多分支结构", "分支结构可以向已经执行过的语句部分跳转" ], "explanation": "Python的分支结构（if/elif/else）是顺序执行的，根据条件判断选择执行相应的代码块，执行完毕后继续向下执行。Python不支持像C语言中goto语句那样向已经执行过的语句部分进行跳转。" }, { "id": 468, "q": "not False的值为（ ）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "False", "True", "不确定", "错误" ], "explanation": "not是Python中的逻辑非运算符，用于对布尔值进行取反操作。False的布尔值为假，对其取反后的结果即为True。" }, { "id": 469, "q": "以下代码的输出结果是（）。\nn=5\ns=100\nif n>=5:\n    n-=10\nif n<5:\n    n-=10\ns=3\nprint(s,n)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "3 -15", "100 -15", "-15", "3" ], "explanation": "初始n=5，s=100。第一个if判断n>=5成立，n减10变为-5。接着判断第二个if条件n<5成立，n再减10变为-15。注意s=3没有缩进，不属于第二个if的代码块，因此必定执行，s被赋值为3。最终输出3 -15。" }, { "id": 470, "q": "设有程序段：\ns=10\nfor i in range(1,6):\n      pass\nprint(s)\n则程序的运行结果是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "10", "10,", "0,", "1" ], "explanation": "变量s初始值为10。for循环遍历range(1,6)生成的序列，但循环体仅包含pass语句，不改变任何变量的值。循环结束后打印s，结果仍为初始值10。" }, { "id": 471, "q": "给出如下代码：\nwhile True:\n    guess=eval(input())\n    if guess==0x452//2:\n        break\n作为输入能够结束程序运行的是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "ox452", "break", "553", "\"Ox452//2\"" ], "explanation": "0x452是十六进制数，转换为十进制为4*256+5*16+2=1106。表达式1106//2的整除结果为553。因此当用户输入553时，guess==553条件成立，触发break语句结束循环。" }, { "id": 472, "q": "哪项输入数据不能使下面代码结束的是（）\nwhile True:\n    inp=eval(input())\n    if inp//3:\n        break", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "2", "3", "4", "5" ], "explanation": "inp//3进行整数除法。当输入2时，2//3结果为0，在条件判断中被视为False，不执行break，循环无法结束。输入3、4、5时，整除结果均大于等于1，被视为True，触发break结束程序。" }, { "id": 473, "q": "设有程序段：\ns=10\nfor i in [\"apple\",\"pear\",\"nut\",\"banana\",\"cherry\"]:\n      pass\nprint(i)\n则程序的运行结果是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "\"cherry\"", "\"banana\"", "\"apple\"", "\"nut\"" ], "explanation": "for循环遍历列表中的每个字符串元素，并依次赋值给变量i。循环正常结束后，变量i保留最后一次迭代的值，即列表的最后一个元素'cherry'。选项A指代该最终值。" }, { "id": 474, "q": "下列说法错误的是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "当外层循环的条件为 False 时，则执行外层循环的循环体", "外层循环的循环体中包含了普通程序和内循环，当内层循环的循环条件为 True 时则会执行内层循环中的循环体，直到内层循环条件为 False", "如果外层循环的条件为 True，则执行外层循环的循环体，直到外层循环的循环条件为 False", "当内层循环和外层循环的循环条件均为 False时，则整个循环嵌套执行完毕" ], "explanation": "循环结构的执行前提是循环条件为True。当外层循环的条件为False时，程序会直接跳过外层循环体，不会执行其中的代码。选项A描述正好相反，因此是错误的。" }, { "id": 475, "q": "下面代码的输出结果是（）。\ns1=\"The python language is a scripting language.\"\ns2=s1.replace('scripting','general')\nprint(s2)", "t": "single", "ans": "D", "kp": "字符串", "o": [ "The python language is a scripting language.", "['The','python','language','is','a','scripting','language.']", "系统报错", "The python language is a general language." ], "explanation": "字符串的replace(old, new)方法用于将字符串中的old子串替换为new子串，并返回替换后的新字符串。原字符串中的'scripting'被替换为'general'，因此输出替换后的完整句子。" }, { "id": 476, "q": "max((1,2,3)*2)的值是（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "2", "3", "4", "6" ], "explanation": "元组乘法(1,2,3)*2会将元素重复两次生成(1,2,3,1,2,3)。max()函数返回序列中的最大值，该序列最大元素为3，故结果为3。" }, { "id": 477, "q": "下列Python程序的运行结果是（ ）。\ns1=set([1,2,2,3,3,3,4])\ns2={1,2,5,6,4}\nprint(s1&s2-s1.intersection(s2))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{1, 2, 4}", "set()", "[1,2,2,3,3,3,4]", "{1,2,5,6,4}" ], "explanation": "s1去重后为{1,2,3,4}，s2为{1,2,4,5,6}。&运算符与intersection()方法均求交集，结果均为{1,2,4}。集合相减{1,2,4}-{1,2,4}得到空集set()。" }, { "id": 478, "q": "下列关于添加字典元素说法错误的是（ ）。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "由于字典是不可变序列，因此只能删除原来的字典，重新建立新的字典。", "如果新添加的键与已经存在的键重复，系统将会报错。", "当字典中的某一个元素不需要时，可以使用 del 命令将其删除。", "当字典中删除一个不存在的键，系统会抛出 keyerror 的错误。" ], "explanation": "字典是可变数据类型，支持直接通过键赋值来添加或修改元素，无需删除重建。A选项称字典不可变且只能重建，说法错误，符合题意。" }, { "id": 479, "q": "Python定义函数时，（ ）参数类型。", "t": "single", "ans": "A", "kp": "函数", "o": [ "不需要声明", "必须声明（必须指定）", "可声明也可不声明", "设置" ], "explanation": "Python是动态类型语言，定义函数时参数不需要预先声明数据类型，解释器会在运行时根据传入的实际值自动推断类型。" }, { "id": 480, "q": "下列代码的运行后结果是（ ）。\ndef add(n):\n    if n<=1:\n        return 1\n    else:\n        return n+add(n-1)\ns=add(5)\nprint(\"{}\".format(s))", "t": "single", "ans": "B", "kp": "函数", "o": [ "11", "15", "1", "输出随机值" ], "explanation": "该函数为递归求和。当n>1时返回n+add(n-1)，直到n<=1返回1。调用add(5)展开为5+4+3+2+1，累加结果为15。" }, { "id": 481, "q": ".以下程序代码的运行结果正确的是（ ）。\nn=1\ndef fun(x):\n    global n\n    k=6\n    if(x>0):\n        k=5\n        n=k**2\n    else:\n        k=3\n        n=k*k\nfun(5)\nprint(\"{}\".format(n))", "t": "single", "ans": "D", "kp": "函数", "o": [ "6", "5", "36", "25" ], "explanation": "函数内使用global n声明引用全局变量。传入x=5满足x>0，执行k=5和n=k**2，将全局变量n更新为25。最终打印结果为25。" }, { "id": 482, "q": "下列程序的运行结果是（ ）。\nadd=lambda x,y:x*x+y*y\nt=add(2,3)\nprint(t)", "t": "single", "ans": "A", "kp": "函数", "o": [ "13", "6", "9", "输出不确定值" ], "explanation": "lambda定义匿名函数，参数为x,y，返回x*x+y*y。传入2,3后计算2*2+3*3，结果为4+9=13。" }, { "id": 483, "q": "以下程序运行后输出的结果是（ ）\ndef sort(x,n):\n    for i in range(n-1):\n        for j in range(n-1-i):\n            if x[j]>x[j+1]:\n                x[j],x[j+1]=x[j+1],x[j]\n    return x\nm=[12,0,6,17,1]\nprint(sort(m,5))", "t": "single", "ans": "B", "kp": "算法与综合应用", "o": [ "[12,0,6,17,1]", "[0, 1, 6, 12, 17]", "[17,12,6,1,0]", "17,12,6,1,0" ], "explanation": "代码实现冒泡排序算法，通过双重循环比较相邻元素并交换，最终将列表按升序排列。原列表排序后结果为[0, 1, 6, 12, 17]。" }, { "id": 484, "q": "以下程序的运行结果是（ ）\nclass Person:\n    __name='aa'\np=Person()\nprint(p.__name)", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "aa", "'aa'", "运行错误", "__name" ], "explanation": "类属性名以双下划线开头会触发名称改写，实际存储为_Person__name。直接通过实例访问p.__name会因找不到该属性而抛出AttributeError，导致运行错误。" }, { "id": 485, "q": "下列定义类的代码中，正确的是（）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "Class book():", "Class book()", "class book()", "class Book():" ], "explanation": "Python定义类使用小写关键字class，类名通常采用大驼峰命名法，且类定义末尾需加冒号。选项D符合语法规范，其他选项关键字大小写或标点有误。" }, { "id": 486, "q": "在Python中，当操作数是数值时，\"+\"表示的是加法运算；当操作数是字符串时，\"+\"表示的是连接操作。这种现象属于（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "继承", "多态", "封装", "消息" ], "explanation": "同一运算符+根据操作数类型不同表现出不同行为（数值相加或字符串拼接），这体现了面向对象中的多态特性，即同一操作在不同数据类型上有不同实现。" }, { "id": 487, "q": "下列哪个选项能够使用turtle库绘制一个半圆形？（ ）", "t": "single", "ans": "D", "kp": "random/turtle等标准库", "o": [ "turtle.fd(100)", "turtle.circle(100)", "turtle.circle(100, 90)", "turtle.circle(-100, 180)" ], "explanation": "turtle.circle(radius, extent)用于绘制圆弧，extent参数指定角度。传入180即可绘制半圆。选项D中半径为负仅改变绘制方向，角度180仍为半圆，符合题意。" }, { "id": 488, "q": "在使用 open() 函数打开文件时，以下哪个文件模式用于读取和写入文件？", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "'r'", "'w'", "'a'", "'r+'" ], "explanation": "'r'为只读，'w'为只写覆盖，'a'为追加写入。'r+'模式允许对文件进行读取和写入操作，且不会截断文件，因此选D。" }, { "id": 489, "q": "下面程序的运行结果是 （）\nA = {2, 14, 84, 87}\nB = {57, 62, 87, 92}\nA.union(B)\nprint(A)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{2, 84, 14, 87}", "{57, 62, 87, 92}", "{2,14,57, 62, 68,84,87,92}", "{87}" ], "explanation": "集合的union()方法会返回两个集合并集的新集合，但不会修改原集合。因此A的内容保持不变，仍为{2, 14, 84, 87}。集合无序，输出顺序可能不同，但元素一致，选A。" }, { "id": 490, "q": "以下程序计算某年某月有几天。其中判别闰年的条件为能被4整除但不能被100整除的年是闰年，能被400整除的年也是闰年。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。注意:不得增行或删行，也不得更改程序的结构！\nyear,month=eval(input(\"please input year,month:\")) #输入数据时，注意年份和月份的顺序不要输错\nif month==2:\n    if ((year%4==0 and year%100!=0) or year%400==0):\n        ___1___\n    else:\n        len=28\nelif month==4 or month==6 or month==9 or month==11:\n    len=30\nelse:\n    ___2___\n   \nprint(\"the length is\",len);", "t": "fill", "ans": "len=29 | len=31", "kp": "分支结构", "o": [], "explanation": "第1空处理闰年2月的情况，天数应为29，故填len=29。第2空处理除2月及小月外的其他大月（1,3,5,7,8,10,12月），天数为31，故填len=31。" }, { "id": 491, "q": ".定义一个学生类，类中包含属性三门课程的成绩，方法包括求总分、求平均分等。请将程序补充完整。\nclass Student:\n    def total_score(self,a,b,c): #求总分\n        return __1____\n    def avg_score(self,a,b,c): #求平均分\n        return (a+b+c)/___2____\nss=Student()\nprint(ss.total_score(90,80,100))\nprint(ss.avg_score(80,90,100))", "t": "fill", "ans": "a+b+c | 3", "kp": "面向对象", "o": [], "explanation": "第1空在total_score方法中求三门课总分，需将参数相加，填a+b+c。第2空在avg_score方法中求平均分，需将总分除以课程数3，填3。" }, { "id": 492, "q": "下面代码的输出结果是（）。\nfor i in range(1,6):\n     if i%3 ==0:\n           break\n     else:\n           print(i,end =\",\")", "t": "fill", "ans": "1,2,", "kp": "循环结构", "o": [], "explanation": "循环i从1到5。i=1和2时，不满足i%3==0，执行else打印并带逗号；i=3时满足条件，执行break跳出循环。因此输出1,2,。" }, { "id": 493, "q": "以下程序的运行结果是[*queNo*]_______。\nlist1=[1,2]\nlist2=list1[::]\nlist1[0]=3\nprint((list1,list2))", "t": "fill", "ans": "([3, 2], [1, 2])", "kp": "列表/元组", "o": [], "explanation": "list1[::]通过切片创建了list1的浅拷贝副本赋给list2，两者内存独立。修改list1[0]为3不影响list2。最终list1为[3, 2]，list2为[1, 2]，组合成元组输出。" }, { "id": 494, "q": "下面程序的执行结果是[*queNo*]________。\nlist1={}\nlist1[1]=2\nlist1['1']=3\nlist1[1]+=3\ns=0\nfor k in list1:\n      s+=list1[k]\nprint(s)", "t": "fill", "ans": "8", "kp": "字典/集合", "o": [], "explanation": "字典list1包含键1（整型）和'1'（字符串）。list1[1]初始为2，执行+=3后变为5。list1['1']为3。遍历字典将所有值相加：5 + 3 = 8。" }, { "id": 495, "q": "以下函数的功能是：利用函数调用的方式编程求表达式 (1+2+3+…+M)+(1+2+3+…+N)/(1+2+3+…+P)的值，M、N、P通过键盘输入。如输入 3 5 6，则输出结果为1；输入5 6 7，则输出结果为：1.2857。请在括号（）中填入正确答案。\ndef add(m):\n    s=0\n    for n in range(m+1):\n        s=(____1_____)\n    (____2____ )\nM,N,P=eval(input(\"请输入三个数：\"))\nprint((add(M)+add(N))/add(P))", "t": "fill", "ans": "s+n | return s", "kp": "函数", "o": [], "explanation": "第1空在循环中累加求和，需将当前值n加到s上，填s+n。第2空在函数末尾需返回累加结果供外部调用，填return s。" }, { "id": 496, "q": "以下程序的输出结果是[*queNo*]__。\ndef func(s1,s2):\n    s3= ''.join([y for y in s1 if 'A' <= y <= 'Z'])\n    s4= ''.join([y for y in s2 if '0' <= y <= '9'])\n    return s3+s4\nx= 'Ai&bcM#75d*4k'\ny='hPU3vb89'\nprint(func(x,y))", "t": "fill", "ans": "AM389", "kp": "字符串", "o": [], "explanation": "列表推导式从x中提取大写字母'A'和'M'组成s3；从y中提取数字'3','8','9'组成s4。两者拼接返回，最终输出AM389。" }, { "id": 497, "q": "以下程序的运行结果是[*queNo*]_。\nclass Student:\n    def __init__(self,name,id):\n        self.name=name\n        self.id=id\n        self.age=19\n   \n    def update_age(self,age):\n        self.age=age\ns1=Student(\"陈一\",202201)\ns1.update_age(20)\nprint(s1.age)", "t": "fill", "ans": "20", "kp": "面向对象", "o": [], "explanation": "实例化s1时，__init__方法将age初始化为19。随后调用s1.update_age(20)，将实例属性age修改为20。最后打印s1.age，输出20。" }, { "id": 498, "q": "在读写文件的过程中，[*queNo*]___方法可以获取当前的读写位置。", "t": "fill", "ans": "tell", "kp": "文件操作", "o": [], "explanation": "在Python文件操作中，tell()方法用于返回文件指针当前的读写位置（以字节为单位），而seek()用于移动指针。" }, { "id": 499, "q": "以下程序段的输出结果是[*queNo*]_。\na = 0\nif a:\n      print(a)\nelse:\n      print('empty')", "t": "fill", "ans": "empty", "kp": "分支结构", "o": [], "explanation": "在Python中，整数0在布尔上下文中被视为False。因此if a:条件不成立，程序执行else分支，打印输出'empty'。" }, { "id": 500, "q": "在考生文件夹下有个文件PY103.py，在横线处填写代码，完成如下功能。将程序里定义好的std列表里的姓名和成绩与已经定义好的模板拼成一段话，显示在屏幕上。例如：\n亲爱的张三，你的考试成绩是:英语90,数学87,Python语言95,总成绩272.特此通知。\n…(略)\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "std = [['张三',90,87,95],['李四',83,80,87],['王五',73,57,55]]\nmodl = \"亲爱的{}, 你的考试成绩是: 英语{}, 数学{}, Python语言{}, 总成绩{}.特此通知.\"\nfor st in std:\ncnt = 0 #总成绩初始值\nfor i in range(3): #循环三科成绩\ncnt += st[i+1] #成绩求和\nprint(modl.format(st[0],st[1],st[2],st[3],cnt))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 501, "q": "考生文件夹下存在一个文件PY103.py，请写代码替换横线，不修改其他代码，实现以下功能：\n以0为随机数种子，随机生成5个在1(含)到97(含)之间的随机数，计算这五个随机数的平方和。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import random\nrandom.seed([x])\n注意：seed()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。\n参数x -- 改变随机数生成器的种子seed。\nrandint(a,b)随机数中是包括a和b区间的数。\n求某数n平方就是求n的2次方，即n**2。\n参考代码如下：\nimport random\nrandom.seed(0)\ns = 0\nfor i in range(5):\nn = random.randint(1,97) # 产生随机数\ns = s+n**2\nprint(s)", "kp": "random/turtle等标准库", "o": [], "rawType": "operation" }, { "id": 502, "q": "使用turtle库的turtle.fd()函数和turtle.seth()函数绘制一个边长为40像素的正12边型，在考生目录下给出了程序框架文件PY201.py，在横线处补充代码，不得修改其它代码。效果如下图所示。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import turtle\nturtle.pensize(2)\nd=0\nfor i in range(1, 13):\nturtle.fd(40)\nd += 30\nturtle.seth(d)", "kp": "random/turtle等标准库", "o": [], "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-turtle-dodecagon-502.png", "rawType": "operation" }, { "id": 503, "q": "下面代码的输出结果是（）。\nfor num in range(2,10):\n  if num > 1:\n    for i in range(2,num):\n      if(num % i)== 0:\n        break\n    else:\n      print(num,end=\",\")", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "4,6,8,9,", "2,4,6,8,10,", "2,4,6,8,", "2,3,5,7," ], "explanation": "该代码用于输出2到9之间的素数。外层循环遍历2到9，内层循环判断是否能被2到num-1整除。若能整除则break跳出内层循环；若正常结束内层循环（即未触发break），则执行else分支打印该数。因此输出2到9的素数：2,3,5,7,。" }, { "id": 504, "q": "构造方法的作用是（）。", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "一般成员方法", "对象的初始化", "类的初始化", "对象的建立" ], "explanation": "在面向对象编程中，构造方法（如Python中的__init__）的主要作用是在创建对象时对其进行初始化，为对象的属性赋初值。它不是用于类的初始化，也不是普通的成员方法。" }, { "id": 505, "q": "表达式chr(ord('A')+3)的值为（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "'D'", "'d'", "68", "100" ], "explanation": "ord('A')返回字符'A'的ASCII码值65。65加3等于68。chr(68)将ASCII码值68转换回对应的字符，即'D'。因此表达式的值为'D'。" }, { "id": 506, "q": "可用于判断变量a的数据类型的选项是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "int(A)", "type(A)", "str(A)", "eval(A)" ], "explanation": "在Python中，内置函数type()用于返回对象的数据类型。int()和str()用于类型转换，eval()用于执行字符串表达式。因此选B。" }, { "id": 507, "q": "在Python语言中，不能作为变量名的是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "course", "_ok", "3python", "me" ], "explanation": "Python变量名必须以字母或下划线开头，不能以数字开头。选项C以数字3开头，因此是非法的变量名。其他选项均符合命名规则。" }, { "id": 508, "q": "以下选项中，不是Python关键字的是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "while", "continue", "goto", "for" ], "explanation": "Python中没有goto关键字。while、continue和for都是Python中用于循环控制的关键字。Python通过缩进和循环控制语句来实现流程控制，不支持goto语句。" }, { "id": 509, "q": "下列哪个语句在Python中是非法的？（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "x=y=z=1", "x=(y=z+1)", "x,y=y,x", "x+=y" ], "explanation": "在Python中，赋值语句不能直接作为表达式放在括号内参与其他赋值。选项B试图将赋值语句y=z+1括起来赋给x，这在Python语法中是非法的。选项A是多重赋值，C是元组解包交换变量，D是复合赋值，均合法。" }, { "id": 510, "q": "关于Python程序注释的描述，以下选项中错误的是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "Python语言的单行注释可以以\"#\"开头", "Python语言的单行注释可以以单引号开头", "Python语言的多行注释必须在每行开始用\"#\"开头", "Python语言有两种注释方式：单行注释和多行注释" ], "explanation": "Python的多行注释通常使用三个单引号或三个双引号将注释内容括起来，不需要在每行开头使用#。单行注释才使用#开头。因此选项C描述错误。" }, { "id": 511, "q": "函数input()的功能是（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "打印输出文本信息", "获取用户的输入", "进行数据类型转换", "查看数据类型" ], "explanation": "Python内置函数input()用于从标准输入（通常是键盘）读取用户输入的一行文本，并将其作为字符串返回。它不用于打印输出、类型转换或查看数据类型。" }, { "id": 512, "q": "用来判断当前 Python 语句在分支结构中的是（） 。", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "引号", "冒号", "大括号", "缩进" ], "explanation": "Python使用缩进来表示代码块的层级关系和逻辑结构，而不是像C或Java那样使用大括号。因此，缩进用于判断语句是否属于某个分支或循环结构。" }, { "id": 513, "q": "以下代码的输出结果是：（ ）\nlist1=['a','b','c']\nlist2=[10,20,30]\nprint(list1+list2)", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "['a','b','c']", "[10,20,30]", "['a', 'b', 'c', 10, 20, 30]", "出错" ], "explanation": "在Python中，列表的加号（+）运算符用于拼接两个列表，生成一个包含两个列表所有元素的新列表。因此，list1和list2相加的结果是将list2的元素追加到list1后面，输出['a', 'b', 'c', 10, 20, 30]。" }, { "id": 514, "q": "已知列表s=[1,2,3,4,2,1], 那么执行语句s.count(2)的结果为（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "1", "2", "3", "4" ], "explanation": "列表的count()方法用于统计指定元素在列表中出现的次数。在列表s中，元素2出现了两次，因此s.count(2)的返回值为2。" }, { "id": 515, "q": "类方法必须用以下哪个来标识（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "@classmethod", "@staticmethod", "不需要标识", "@method" ], "explanation": "在Python中，类方法需要使用装饰器@classmethod来标识，其第一个参数通常是cls，代表类本身。@staticmethod用于标识静态方法，不需要标识的是实例方法，而@method不是Python内置的装饰器。" }, { "id": 516, "q": "以下选项中，不是对象的方法的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "启动汽车", "刹车", "汽车的颜色", "倒车" ], "explanation": "在面向对象编程中，对象的方法指的是对象能够执行的动作或行为，如启动、刹车、倒车。而汽车的颜色描述的是对象的状态或特征，属于对象的属性而非方法。" }, { "id": 517, "q": "（ ）存储在外部介质上一组相关信息的集合。", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "输入", "输出", "文件", "以上都是错误的" ], "explanation": "文件是存储在外部介质（如硬盘、U盘等）上的一组相关信息的集合，用于持久化保存数据。输入和输出是数据流动的方向或操作过程，并非信息的存储集合。" }, { "id": 518, "q": "生成3个三位随机整数，输出其中最小的数。\nimport random\nx=random.randint(100,999)\ny=random.randint(100,999)\nz=random.randint(100,999)\nmin=x if ___1____ else y\nmin=min if ___2____ else z\nprint(\"x={0},y={1},z={2}\".format(x,y,z))\nprint(\"min=\",min)", "t": "fill", "ans": "x<y | min<z", "kp": "程序填空/调试", "o": [], "explanation": "本题考查条件表达式求最小值。第1空比较x和y，若x小于y则min取x，否则取y，故填x0:\n    result.append(___1___)\n    n=n//2\nresult.reverse()\nfor i in ___2___:\n    print(i,end='')", "t": "fill", "ans": "n%2 | result", "kp": "程序填空/调试", "o": [], "explanation": "本题考查十进制转二进制的除2取余法。第1空在循环中获取当前最低位的二进制值，应填n%2。循环结束后余数列表是逆序的，经过reverse()反转后，第2空遍历该列表输出，故填result。" }, { "id": 520, "q": "关于Python程序格式框架，以下选项中描述错误的是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "Python语言不采用严格的\"缩进\"来表明程序的格式框架", "Python单层缩进代码属于之前最邻近的一行非缩进代码，多层缩进代码根据缩进关系决定所属范围", "Python语言的缩进可以采用Tab键实现", "判断、循环、函数等语法形式能够通过缩进包含一批Python代码，进而表达对应的语义" ], "explanation": "Python语言强制使用严格的缩进来表示代码块的层级结构和格式框架，因此选项A描述错误。缩进可以使用Tab或空格，且判断、循环等语法均依赖缩进包含代码块以表达语义。" }, { "id": 521, "q": "下列代码的运行结果是（ ）。\nf=lambda x,y:x*y//3\nprint(f(4,7))", "t": "single", "ans": "B", "kp": "函数", "o": [ "1", "9", "0", "9.3333333" ], "explanation": "本题考查lambda匿名函数及整除运算。传入参数x=4, y=7，表达式计算为4*7//3。先计算乘法得28，再进行整除运算28//3，结果为9。选项D是浮点除法结果，选项A和C计算错误。" }, { "id": 522, "q": "以下关于继承的说法中，错误的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "继承也叫类的派生", "继承带来的主要好处之一是实现代码重用", "父类继承子类所有的公有的属性和方法", "子类继承父类所有的公有的属性和方法" ], "explanation": "继承是子类获取父类（基类）属性和方法的过程，也叫类的派生，有助于代码重用。因此是子类继承父类，而不是父类继承子类，选项C的说法颠倒了继承关系，描述错误。" }, { "id": 523, "q": "下面代码的输出结果是（）。\n>>>True-False", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1", "-1", "True", "0" ], "explanation": "在Python中，布尔类型是整型的子类，True等价于整数1，False等价于整数0。因此表达式True-False在底层会被转换为1-0进行算术运算，最终输出结果为1。" }, { "id": 524, "q": "下列字符串中，不合法的是( )。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "\"sum\"", "'sum'", "sum", "'s\"u\"m'" ], "explanation": "Python中的字符串必须用单引号、双引号或三引号括起来。选项A、B、D均使用了合法的引号包裹，而选项C的sum没有引号，在Python中会被解析为变量名或标识符，不是合法的字符串字面量。" }, { "id": 525, "q": "下列属于math库中的数学函数的是（）。", "t": "single", "ans": "C", "kp": "异常与库", "o": [ "time()", "round()", "pow()", "random()" ], "explanation": "math.pow(x, y)是math库中用于计算x的y次方的数学函数。time()属于time库，random()属于random库，而round()是Python的内置函数，不需要导入math库即可使用。" }, { "id": 526, "q": "Python语句块的标记是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "/", "逗号", "缩进", "分号" ], "explanation": "Python使用缩进（空格或Tab）作为语句块的标记，以此来划分代码的层级和逻辑范围。这与C或Java等语言使用大括号不同。斜杠、逗号和分号均不能作为语句块的标记。" }, { "id": 527, "q": "利用print()格式化输出，能够控制浮点数的小数点后三位输出的是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "{:.3}", "{.3f}", "{:.3f}", "{.3}" ], "explanation": "Python中格式化浮点数保留三位小数使用`{:.3f}`。其中`.3`表示保留三位小数，`f`表示浮点数类型。选项A缺少`f`，选项B和D缺少冒号，因此C正确。" }, { "id": 528, "q": "下面的代码在运行时输入“2”，则输出结果是（）。\nx=input()\nif x== '1':\n   print('1')\nelif x== '2':\n   print('2')\nelif x== '3':\n   print('3')\nelse:\n   print('4')", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "1", "2", "3", "4" ], "explanation": "`input()`函数返回的是字符串类型。当输入2时，变量`x`的值为字符串'2'。在分支结构中，条件`x == '2'`成立，程序执行对应的`print('2')`，输出结果为2。" }, { "id": 529, "q": "假设有两个集合 A 和 B，分别包含字符串元素。下面的代码片段表示什么操作？\nA = {\"apple\", \"banana\", \"orange\"}\nB = {\"banana\", \"cherry\", \"kiwi\"}\nC = {x.upper() for x in A if len(x) > 5} | {x.lower() for x in B if len(x) < 6}", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "将 A 中长度大于 5 的字符串转换为大写字母，并将 B 中长度小于 6 的字符串转换为小写字母，然后求两个集合的并集", "将 A 中长度大于 5 的字符串转换为小写字母，并将 B 中长度小于 6 的字符串转换为大写字母，然后求两个集合的交集", "将 A 中长度大于 5 的字符串转换为大写字母，并将 B 中长度小于 6 的字符串转换为小写字母，然后求两个集合的交集", "将 A 中长度大于 5 的字符串转换为小写字母，并将 B 中长度小于 6 的字符串转换为大写字母，然后求两个集合的差集" ], "explanation": "代码包含两个集合推导式，并通过`|`运算符连接。前半部分将集合A中长度大于5的字符串转为大写，后半部分将集合B中长度小于6的字符串转为小写。`|`表示求两个集合的并集。" }, { "id": 530, "q": "以下程序运行后输出的结果是（ ）\ndef fun(x=5):\n    s=1\n    for i in range(1,x,2):\n        s=s*i\n    return s\nprint(fun(7))", "t": "single", "ans": "D", "kp": "函数", "o": [ "1", "3", "105", "15" ], "explanation": "调用`fun(7)`时，`x`为7。`range(1, 7, 2)`生成序列1, 3, 5。循环中`s`初始为1，依次乘以序列中的元素，即`s = 1 * 1 * 3 * 5`，最终计算结果为15。" }, { "id": 531, "q": "编写程序找出列表list1=[1,2,3,4,5,6]中任意两个元素相加等于6的元素对，构成一个新的列表，如[(1, 5), (2, 4)]。请填空。\nlist1=[1,2,3,4,5,6]\nlist2=[]\nn=___1____\nfor i in range(0,n-1):\n    for j in range(i+1,n):\n        if ____2___:\n            num_tupple=(list1[i],list1[j])\n            list2.append(num_tupple)\nprint(list2)", "t": "fill", "ans": "len(list1) | list1[i]+list1[j]==6", "kp": "程序填空/调试", "o": [], "explanation": "第1空需要获取列表长度以控制循环范围，应填`len(list1)`。第2空是判断两个元素之和是否等于6的条件表达式，应填`list1[i]+list1[j]==6`。" }, { "id": 532, "q": "程序填空题\ndef get_unique_values(numbers):\n\"\"\"\n接受一个包含重复元素的列表，并返回一个包含唯一元素的集合。\n\"\"\"\n    unique_values = set(___1____)\n    return unique_values\nnumbers = [1, 2, 3, 3, 4, 4, 5]\n___2____ = get_unique_values(numbers)\nprint(result)", "t": "fill", "ans": "numbers | result", "kp": "程序填空/调试", "o": [], "explanation": "第1空将传入的列表转换为集合以实现去重，应填参数`numbers`。第2空调用函数并将返回的集合赋值给变量，以便后续打印输出，应填`result`。" }, { "id": 533, "q": "考生文件夹下存在一个文件PY102.py，请写代码替换横线，不修改其他代码，实现以下功能：\na和b是两个长度相同的列表变量，列表a为[3,6,9]已给定，键盘输入列表b，计算a中元素与b中对应元素的和形成新的列表c，在屏幕上输出。\n例如：键盘输入列表b为[1,2,3]，屏幕输出计算结果为[4,8,12]\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "a = [3,6,9]\nb = eval(input()) #例如：[1,2,3]\nc = []\nfor i in range(3):\nc.append(a[i]+b[i])\nprint(c)", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 534, "q": "表达式True+1的值为（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "2", "0", "1", "语法错误" ], "explanation": "在Python中，布尔类型是整型的子类，`True`等价于整数1，`False`等价于0。因此表达式`True + 1`相当于`1 + 1`，计算结果为2。" }, { "id": 535, "q": "表达式len( 'aaabbbcccddd '.strip( 'abcd'))的值为（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "0", "9", "6", "3" ], "explanation": "`strip('abcd')`方法会从字符串两端移除所有包含在参数中的字符。原字符串由a、b、c、d组成，所有字符均被移除，返回空字符串，其长度为0。" }, { "id": 536, "q": "下面这段代码的意义是（）\n>>>car='BWM'\n>>>id(car)", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "查看变量所占的位数", "转换成布尔值", "查看变量在内存中的地址", "将变量中的元素随机排列" ], "explanation": "Python内置函数`id()`用于获取对象的唯一标识符，即对象在内存中的地址。选项A、B、D的描述均不符合该函数的实际功能。" }, { "id": 537, "q": "以下说法正确的是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "浮点数进行算数运算时没有误差。", "当整数除以负数时，//运算符将结果朝着最近的整数\"向上\"四舍五入。", "/运算符做一般意义上的除法，如果被除数和除数都是整型，结果就是整型。", "在Python中，乘、除、整除、求余、和乘方的优先级都一样。" ], "explanation": "A错，浮点数运算存在精度误差；C错，`/`除法结果总是浮点数；D错，乘方优先级高于乘除。B选项中`//`为向下取整除法，为本题唯一正确描述。" }, { "id": 538, "q": "下列不属于常量的是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "\"flower\"", "2.14", "x=2", "'3200'" ], "explanation": "常量是指在程序运行过程中其值不能改变的量，如字符串、数字等。选项C的`x=2`是一条赋值语句，其中`x`是变量名，不属于常量。" }, { "id": 539, "q": "已知x=6;y=5,语句x//=y执行后，x的值是（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1", "2", "1.2", "5" ], "explanation": "`x //= y`是整除赋值运算符，等价于`x = x // y`。已知`x=6`，`y=5`，`6 // 5`进行向下取整的整数除法，计算结果为1，因此`x`的最终值为1。" }, { "id": 540, "q": "下列程序的输出结果( )。\nx=0\ny=50\nm=80\nm=max(x,y)\nprint(\"最大值是{1}\".format(m))", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "最大值是50", "最大值是m", "最大值是80", "程序出错" ], "explanation": "format方法中传入的参数m索引为0，但格式化字符串中使用了{1}来引用索引为1的参数，由于没有提供第二个参数，程序会抛出IndexError异常导致出错。" }, { "id": 541, "q": "下面哪个选项不是算法的描述工具（ ）", "t": "single", "ans": "C", "kp": "算法与综合应用", "o": [ "自然语言", "传统流程图", "DFD图", "N-S流程图" ], "explanation": "算法的常用描述工具包括自然语言、传统流程图、N-S流程图和伪代码等。DFD图即数据流图，主要用于软件需求分析阶段描述系统的数据流动，不属于算法描述工具。" }, { "id": 542, "q": "以下程序的输出结果是（ ）\na=3\nb=4\nprint(\"a={0},b={1}\".format(a,b))", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "a=3,b=4", "a=0,b=1", "a={ 0 },b={1}", "3,4" ], "explanation": "format方法通过大括号内的数字索引来替换参数。{0}对应第一个参数a的值3，{1}对应第二个参数b的值4，因此最终输出结果为a=3,b=4。" }, { "id": 543, "q": "执行语句x=int(input( ))，若输入123，那么 x 的类型是（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "整型", "字符串", "浮点型", "以上都错误" ], "explanation": "input()函数接收用户输入并默认返回字符串类型，随后外层的int()函数将字符串'123'强制转换为整数类型，因此变量x的数据类型为整型。" }, { "id": 544, "q": "age=43\nfamilyName=\"赵\"\nif age>50:\n    print(\"您好！\"+familyName+\"奶奶\")\nelif age>40:\n    print(\"您好！\"+familyName+\"阿姨\")\nelif age>30:\n    print(\"您好！\"+familyName+\"姐姐\")\nelse:\n    print(\"您好！\"+\"小\"+familyName)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "您好！赵奶奶", "您好！赵阿姨", "您好！赵姐姐", "您好！小赵" ], "explanation": "程序依次判断if和elif条件。age为43，不满足大于50的条件，但满足大于40的条件，因此执行对应的elif分支，拼接字符串并输出\"您好！赵阿姨\"，后续分支不再执行。" }, { "id": 545, "q": "下列语句执行后的输出是（）。\nif 2>30:\n    print(50)\nelse:\n    print(60)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "3", "2", "50", "60" ], "explanation": "条件表达式2>30的结果为False，因此程序跳过if分支，直接执行else分支中的语句，输出数字60。" }, { "id": 546, "q": "设x为已赋值的整型变量，则x>1 or x<=1的值为（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "对于任意整数x，它要么大于1，要么小于等于1，这两个条件互为补集，必有一个成立。因此逻辑或（or）运算的结果恒为布尔值True。" }, { "id": 547, "q": "下面的代码在运行时输入“2”，则输出结果是（）。\nx=input()\nif x>= '1':\n   if x>= '0' and x<='1':\n      print('01')\n   else:\n      print('02')\nelse:\n   print('1')", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "01", "02", "1", "报错" ], "explanation": "输入为字符串'2'。外层条件'2'>='1'成立，进入内层if。内层条件中'2'<='1'按字符串字典序比较为False，导致内层if整体为假，从而执行内层else分支输出'02'。" }, { "id": 548, "q": "3 and False的值为（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "False", "True", "错误", "不确定" ], "explanation": "在Python的逻辑与（and）运算中，如果第一个操作数的布尔值为True，则返回第二个操作数的值。整数3被视为True，因此表达式直接返回第二个操作数False。" }, { "id": 549, "q": "以下代码的输出结果是（）。\na=20\nb=30\nif a 5) or (x/y > 5):\n     print('Right')\nelse:\n     print('Wrong')", "t": "fill", "ans": "Right", "kp": "分支结构", "o": [], "explanation": "逻辑或or具有短路特性。首先计算左侧表达式x > 5，因为10>5为True，整个or表达式的结果已确定为True。此时不再计算右侧的x/y > 5，从而避免了除以零的错误，最终执行if分支输出'Right'。" }, { "id": 579, "q": "考生文件夹下存在一个文件PY101.py，请写代码替换横线，不修改其他代码，实现以下功能：\n键盘输入正整数n，按要求把n输出到屏幕，格式要求：宽度为25个字符，等号字符(=)填充，右对齐，带千位分隔符。如果输入正整数超过25位，则按照真实长度输出。\n例如：键盘输入正整数n为1234，屏幕输出 ====================1,234\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "s = input()\nprint(\"{:=>25,}\".format(eval(s)))", "kp": "基础语法与输入输出", "o": [], "rawType": "operation" }, { "id": 580, "q": "计算两个列表ls和lt对应元素乘积的和（即向量积），补充PY202.py文件。\nls = [111, 222, 333, 444, 555, 666, 777, 888, 999]\nlt = [999, 777, 555, 333, 111, 888, 666, 444, 222]\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "ls = [111, 222, 333, 444, 555, 666, 777, 888, 999]\nlt = [999, 777, 555, 333, 111, 888, 666, 444, 222]\ns = 0\nfor i in range(len(ls)):\ns+=ls[i]*lt[i]\nprint(s)", "kp": "列表/元组", "o": [], "rawType": "operation" }, { "id": 581, "q": "Python中变量的命名遵循的规则，不正确的是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "以字母或下划线开头，后面可以是字母、数字或下划线", "区分大小写", "以数字开头，后面可以是字母、数字或下划线", "不能使用保留字" ], "explanation": "Python变量命名必须以字母或下划线开头，不能以数字开头。选项A、B、D均符合Python标识符的命名规范，选项C描述错误，因此选C。" }, { "id": 582, "q": "下面语句执行后的结果是（ ）\nprint(10,20,sep=',',end='*')\nprint(30)", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "10,20*30", "10,20\n30", "10 20 30", "10 20*\n30" ], "explanation": "第一个print函数中，sep=','使10和20之间用逗号分隔，end='*'使输出结束后不换行而是输出星号。第二个print紧接着输出30并默认换行。因此最终输出为'10,20*30'。" }, { "id": 583, "q": "下列关于Python程序格式的描述中错误的是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "一行代码的长度如果过长，可以使用\"\\\"反斜杠续行", "每个语句行以回车符结束", "可以在同一行中使用多条语句，语句之间使用分号分隔", "如果在语句中包含小括号、中括号或大括号，也必须使用多行续行符" ], "explanation": "在Python中，如果语句包含未闭合的小括号、中括号或大括号，可以直接跨行书写，不需要使用反斜杠作为续行符。选项A、B、C的描述均正确，选项D描述错误。" }, { "id": 584, "q": "以下代码的输出结果是（）。\na=2\nb=3\nif a=b:\n   c= b\nprint(c)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "2", "3", "True", "报错" ], "explanation": "Python中条件判断应使用双等号==，单等号=为赋值运算符，if a=b:会引发语法错误。即使假设为if a==b:，因条件不成立导致变量c未定义，print(c)也会引发名称错误。本题代码逻辑与给定答案A明显冲突。" }, { "id": 585, "q": "以下代码的输出结果是（）。\nn=-50\ns=10\nif n>=5:\n   n-=10\n   s=s-40\nelse:\n   n-=10\n   s=s-30\nprint(s)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "30", "40", "-30", "-20" ], "explanation": "初始时n=-50，不满足n>=5的条件，因此执行else分支。在else分支中，执行s = s - 30，即10 - 30 = -20。最后打印s的值，输出结果为-20。" }, { "id": 586, "q": "有以下程序段：\nn=0\np=0\nwhile p!=100 and n<3:\n    p=int(input())\n    n+=1\nwhile循环结束的条件是（ ）。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "P的值不等于100并且n的值小于3", "P的值等于100并且n的值大于等于3", "P的值不等于100或者n的值小于3", "P的值等于100或者n的值大于等于3" ], "explanation": "while循环在条件为True时继续执行，当条件为False时结束。原条件为p!=100 and n<3，根据德·摩根定律，其否定（即循环结束的条件）为not (p!=100 and n<3)，等价于p==100 or n>=3。" }, { "id": 587, "q": "下列哪个选项不符合程序空白处的语法要求？\nfor var in ________ :\n    print(var)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "range(0,10)", "\"Hello\"", "(1,2,3)", "5" ], "explanation": "for循环要求in后面的对象必须是可迭代对象（如列表、元组、字符串、range对象等）。选项A、B、C均为可迭代对象，而选项D的整数5不是可迭代对象，会导致TypeError。" }, { "id": 588, "q": "给出如下代码\ns='Python is Open Source!'\nprint(s[0:].upper( ))\n上述代码的输出结果是（）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "PYTHON", "PYTHON IS OPEN SOURCE", "Python is Open Source!", "PYTHON IS OPEN SOURCE!" ], "explanation": "s[0:]通过切片获取从索引0到末尾的完整字符串，即原字符串本身。接着调用.upper()方法将字符串中的所有小写字母转换为大写字母，标点符号和空格保持不变，因此输出全大写的原字符串。" }, { "id": 589, "q": "下列选项中与s[0:-1]表示的含义相同的是（ ）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "s[-1]", "s[:]", "s[:len(s)-1]", "s[0:len(s)]" ], "explanation": "s[0:-1]表示从索引0开始，到倒数第一个字符（不包含）结束的切片。len(s)是字符串长度，len(s)-1即为最后一个字符的索引，因此s[:len(s)-1]与s[0:-1]等价，均表示去除最后一个字符的子串。" }, { "id": 590, "q": "下列Python程序的运行结果是（ ）。\ns=list('ABCDEF')\ns[1:3]=list('6')\nprint(s)", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "['A', '6', '6','D', 'E', 'F']", "['6', 'D', 'E', 'F']", "['A', '6', 'E', 'F']", "['A', '6', 'D', 'E', 'F']" ], "explanation": "列表切片赋值时，若等号右侧列表长度与切片长度不同，列表会自动伸缩。s[1:3]选中'B'和'C'，将其替换为list('6')即['6']，因此原列表变为['A', '6', 'D', 'E', 'F']。选项D正确。" }, { "id": 591, "q": "下面哪条语句会创建一个Worker类的实例对象worker_joey？", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "def __init__(worker_joey)", "class worker_joey", "worker_joey=Worker()", "worker_joey.Worker" ], "explanation": "在Python中，创建类的实例对象需通过调用类的构造函数，语法格式为\"对象名 = 类名()\"。选项A是定义方法，选项B是定义类，选项D是访问属性，只有选项C符合实例化语法。" }, { "id": 592, "q": "程序填空。程序的功能是判断一个数是奇数还是偶数。\na=int(input())\nif     1    ==0:\n     print(\"这是一个偶数\")\n    2   :\n     print(\"这是一个奇数\")", "t": "fill", "ans": "a%2 | else", "kp": "分支结构", "o": [], "explanation": "第1空：判断偶数需验证该数除以2的余数是否为0，故填a%2。第2空：if条件不成立时执行奇数分支，需使用else关键字构成双分支结构。" }, { "id": 593, "q": "下列程序的输出结果是[*queNo*]___。\ns=1\nfor i in range(1,11):\n    s+=i\nprint(s)", "t": "fill", "ans": "56", "kp": "循环结构", "o": [], "explanation": "初始s=1，range(1,11)生成1到10的整数。循环将1至10累加到s中，即s = 1 + (1+2+...+10) = 1 + 55 = 56。最终输出56。" }, { "id": 594, "q": "程序填空题\n统计字典 scores 中每个分数的出现次数，并将结果存储在新的字典 score_count 中。\nscores = {\"Math\": 90, \"English\": 85, \"Science\": 90, \"History\": 80, \"Geography\": 85}\nscore_count = {}\nfor score in scores.values():\n      if score in score_count:\n            score_count[ ___ ] += 1\n     else:\n            score_count[score] = 1", "t": "fill", "ans": "score", "kp": "字典/集合", "o": [], "explanation": "程序遍历字典的值score，若该分数已存在于score_count字典的键中，则将其对应的值加1。因此字典的键应为当前遍历到的分数score。" }, { "id": 595, "q": "有5个人坐在一起，第5个人说他比第4个人小3岁；第4个人说他比第3个人小3岁；第3个人说他比第2个人小3岁；第2个人又说他比第1个人小3岁；第1个人说他是38岁。编写程序，计算出第5个人的年龄并显示。请将以下程序补充完整。\ndef age(n):\n    if n == 1: c = ___1_____\n    else: c = age(n - 1) - 3\n   \n    return ____2____\nprint(\"第5人的年龄:\"，age(5))\ninput(\"运行完毕，请按回车键退出...\")", "t": "fill", "ans": "38 | c", "kp": "函数", "o": [], "explanation": "第1空：根据题意第1个人38岁，递归基线条件为n==1时，年龄c赋值为38。第2空：函数需返回计算得到的年龄结果，故填c。" }, { "id": 596, "q": "写出下列程序的输出结果？         \ndef func(x,y=100):\n    return {x:y}\nprint(func(y=10,x=20))", "t": "fill", "ans": "{20: 10}", "kp": "函数", "o": [], "explanation": "函数调用时使用了关键字参数y=10, x=20，这会覆盖默认参数值，使得形参x为20，y为10。函数返回由x和y组成的字典，即{20: 10}。" }, { "id": 597, "q": "考生文件夹下存在一个Python源文件PY103.py，请写代码替换横线，不修改其他代码，实现如下功能：\n获得用户输入的一个整数，记为n，以100为随机数种子，随机生成10个1到n之间的随机数，输出生成的随机数，数字之间以逗号分隔。\n示例如下（其中数据仅用于示意）：\n输入：\n900\n输出：150,471,466,790,777,723,403,750,359,444\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试及验证程序。", "t": "fill", "ans": "import random\nn=eval(input(\"请输入一个整数\"))\nrandom.seed(100)\nfor i in range(1,11):\nif i<10:\nprint(random.randint(1,n),end=\",\")\nelse:\nprint(random.randint(1,n))", "kp": "random/turtle等标准库", "o": [], "rawType": "operation" }, { "id": 598, "q": "以下不属于Python语言保留字的是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "tup", "or", "finally", "global" ], "explanation": "Python保留字是语言内部定义的关键字。or是逻辑运算符，finally用于异常处理，global用于声明全局变量，均为保留字。tup不是保留字，仅为普通标识符。" }, { "id": 599, "q": "执行以下Python语句后，x,y的值是（ ）\n>>> x=7\n>>> y=5\n>>> x,y=y,x", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "x=7,y=7", "x=5,y=5", "x=7,y=5", "x=5,y=7" ], "explanation": "x,y=y,x是Python中利用元组解包实现变量值交换的经典语法。执行前x=7, y=5，执行后右侧元组(5,7)被解包并分别赋值给左侧的x和y，故x=5, y=7。" }, { "id": 600, "q": "下面程序的执行结果是[*queNo*]________。\nss = list(set(\"11234234\"))\ns = sorted(ss)\nfor i in s:\n      print(i,end = '')", "t": "fill", "ans": "1234", "kp": "字典/集合", "o": [], "explanation": "set(\"11234234\")将字符串转为集合去重，得到{'1','2','3','4'}。sorted()对其排序返回列表['1','2','3','4']。循环遍历并以end=''打印，最终输出连续字符串1234。" }, { "id": 601, "q": "下列程序的输出结果是什么？[*queNo*]__\ncounter=1\nnum=0\ndef func():\n    global counter\n    for i in (1,2,3):counter+=1\n    num=8\nfunc()\nprint(counter,num)", "t": "fill", "ans": "4 0", "kp": "函数", "o": [], "explanation": "函数内使用global counter声明全局变量，循环3次使其从1增至4。num=8在函数内未声明全局，属于局部变量，不影响外部全局变量num（仍为0）。故输出4 0。" }, { "id": 602, "q": "在键盘上输入2和3，以下哪条Python语句的输出结果是5？", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "print(int(input())+int(input()))", "print(int(input())+input())", "print(eval(input()+ input()))", "print(input()+input())" ], "explanation": "input()函数返回字符串类型。选项A将两次输入均转为整型后相加，结果为5；选项B类型不匹配报错；选项C拼接字符串后eval计算结果为23；选项D直接拼接字符串结果为\"23\"。" }, { "id": 603, "q": "给出下面代码，程序运行结果为（ ）。\nage=22\nstart=2\nif age%2!=0:\n    start=1\nprint(start)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "1", "2", "0", "报错" ], "explanation": "age为22，22对2取余结果为0，条件age%2!=0为假，不执行if分支内的语句，因此start的值保持初始值2不变。" }, { "id": 604, "q": "设有程序段：\ns=10\nfor i in (\"A\",\"O\",\"I\"):\n       pass\nprint(s, end=' ')\n则程序的运行结果是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "A", "I", "10", "O" ], "explanation": "变量s初始值为10。for循环遍历元组，但循环体中仅包含pass语句，未对s进行任何修改。循环结束后打印s的值，结果仍为10。" }, { "id": 605, "q": "Python语言提供三种基本的数字类型，它们是（）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "整数类型、浮点数类型、复数类型", "整数类型、二进制类型、浮点数类型", "整数类型、二进制类型、布尔类型", "整数类型、二进制类型、复数类型" ], "explanation": "Python语言提供三种基本的数字类型，分别是整数类型（int）、浮点数类型（float）和复数类型（complex）。二进制只是整数的表示形式。" }, { "id": 606, "q": "关于import引用，以下选项中描述错误的是（）。", "t": "single", "ans": "A", "kp": "random/turtle等标准库", "o": [ "可以使用from turtle 引入turtle库", "使用import turtle as t引入turtle 库，取别名为t", "使用import turtle引入turtle库", "import留字用于导入模块或者模块中的对象" ], "explanation": "from语句的正确语法是from 模块名 import 对象名，不能直接写from turtle 引入turtle库（缺少import及具体对象）。其余选项描述均正确。" }, { "id": 607, "q": "关于python程序设计语言，下列说法不正确的是（ ）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "python是一种解释型、面向对象的计算机程序设计语言", "python支持Windows操作系统，但不支持Linux系统", "python源文件以***.py为扩展名", "python文件不能直接在命令行中运行" ], "explanation": "Python是一种跨平台的编程语言，不仅支持Windows操作系统，也完美支持Linux、macOS等多种操作系统。因此选项B的说法是明显错误的。" }, { "id": 608, "q": "下列选项中错误的赋值语句是（ ）。", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "a,b=5,6", "a=b=10", "a=b", "a,b=3" ], "explanation": "Python支持多元赋值，但等号两边的变量数量与值的数量必须匹配。选项D中左侧有两个变量a和b，而右侧只有一个整数3，无法解包，会导致ValueError。" }, { "id": 609, "q": "意大利科学家Bohm和Jacopini在1966年提出了算法的三种基本结构，下面哪个选项不是三种基本结构：( )", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "顺序结构", "选择结构", "循环结构", "中断结构" ], "explanation": "1966年Bohm和Jacopini提出的算法三种基本控制结构是顺序结构、选择结构（分支结构）和循环结构。中断结构不属于这三种基本结构。" }, { "id": 610, "q": "下列代码的输出结果是（）\na=18\nb=6\nif(a//b):\n   r=a//b\nelif a:\n   r=a%b\nelse:\n   r=1\nprint(r)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "0", "1", "3", "出错" ], "explanation": "a//b即18整除6，结果为3。在if条件判断中，非零整数3被视为True，因此执行r=a//b，将3赋值给r。后续elif和else分支不再执行，最终输出3。" }, { "id": 611, "q": "Python语句print(type({'A':1,'B':2,'C':3,'D':4}))的输出结果是（ ）。", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "", "", "", "" ], "explanation": "{'A':1,'B':2,'C':3,'D':4}是由键值对组成的字典字面量。type()函数用于返回对象的数据类型，因此输出结果为，即字典类型。" }, { "id": 612, "q": "关于形参的描述中，错误的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "函数定义中参数列表里面的参数是形式参数，简称形参", "形参可以没有", "函数定义时一定需要形参", "当形参省略时，圆括号不能省略" ], "explanation": "函数定义时形参是可选的，可以没有形参（即无参函数），但无论是否有形参，函数名后的圆括号都不能省略。因此\"一定需要形参\"的说法错误。" }, { "id": 613, "q": "在Food类中创建eat方法，下列选项正确的是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "Class Food():\nDef eat(self):", "class Food():\ndef eat(self):", "class Food():\ndef eat()", "class Food():\ndef eat(self)" ], "explanation": "Python中定义类和方法的关键字class和def必须小写。类中的实例方法第一个参数必须是self，且定义语句末尾必须有冒号。选项B语法完全正确。" }, { "id": 614, "q": "turtle画图结束后，让画面停顿下来，不立即关掉窗口的方法是（ ）。", "t": "single", "ans": "B", "kp": "random/turtle等标准库", "o": [ "turtle.setup()", "turtle.done()", "turtle.penup()", "turtle.pendown()" ], "explanation": "turtle.done()用于在绘图结束后保持窗口打开状态，使画面停顿下来，直到用户手动关闭窗口。setup用于设置窗口，penup和pendown用于控制画笔。" }, { "id": 615, "q": "请阅读下面一段程序，其最终执行的结果为：[*queNo*]____。\nlist01 = [\"a\", \"b\"]\nlist02 = [\"c\", \"d\"]\nlist01.extend(list02)\nprint(len(list01))", "t": "fill", "ans": "4", "kp": "列表/元组", "o": [], "explanation": "extend()方法将list02的所有元素追加到list01末尾，此时list01变为['a', 'b', 'c', 'd']。len()函数返回列表的元素个数，因此最终输出结果为4。" }, { "id": 616, "q": "下面程序的执行结果是[*queNo*]________。\nd={1:'r',2:'s',3:'t'}\ndel d[1]\ndel d[2]\nd[1]='x'\nprint(len(d))", "t": "fill", "ans": "2", "kp": "字典/集合", "o": [], "explanation": "初始字典有3个键值对。del d[1]和del d[2]分别删除了键为1和2的元素，此时字典仅剩{3:'t'}。接着d[1]='x'新增了一个键值对，字典变为{3:'t', 1:'x'}。len()函数返回字典中键值对的数量，结果为2。" }, { "id": 617, "q": "以下程序的运行结果是[*queNo*]_。\nclass A:\n    def __init__(self,i=1):\n        self.i=i\nclass B(A):\n    def __init__(self,j=2):\n        super().__init__()\n        self.j=j\nb=B()\nprint(b.i+b.j)", "t": "fill", "ans": "3", "kp": "面向对象", "o": [], "explanation": "实例化B()时，调用B的__init__方法，默认参数j=2。方法内通过super().__init__()调用父类A的初始化方法，默认参数i=1，因此实例b拥有属性i=1和j=2。最后计算b.i + b.j即1 + 2，输出结果为3。" }, { "id": 618, "q": "在考生文件夹下有个文件PY102.py，在横线处填写代码，完成如下功能。让用户输入一串数字和字母混合的数据，然后统计其中数字和字母的个数，显示在屏幕上。例如：\n输入：\nFda243fdw3\n输出：\n数字个数：4，字母个数：6\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "ns = input(\"请输入一串数据：\")\ndnum,dchr = 0,0 #双变量赋值方式\nfor i in ns:\nif i.isnumeric(): #如果是数字字符\ndnum += 1\nelif i.isalpha():\ndchr += 1\nelse:\npass #空语句，为了保持程序结构的完整性，用于占位\nprint('数字个数：{}，字母个数：{}'.format(dnum,dchr))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 619, "q": "关于Python语言标识符，说法错误的是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "只能由字母、数字和下划线组成", "关键字是含有特定意义的标识符", "_hello是一个合法的标识符", "sum与SUM是相同的标识符" ], "explanation": "Python标识符区分大小写，因此sum与SUM是两个不同的标识符，选项D说法错误。选项A、B、C均符合Python标识符的命名规则及关键字定义。" }, { "id": 620, "q": "关于类和对象的关系，下列描述正确的是（）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "类是面向对象的核心", "类是现实中事物的个体", "对象是根据类创建的，并且一个类只能对应一个对象", "对象描述的是现实的个体，它是类的实例" ], "explanation": "对象是类的实例，用于描述现实中的具体个体，选项D正确。类是抽象的模板，对象才是具体的个体，故B错误；一个类可以实例化多个对象，故C错误；面向对象的核心是对象而非类，故A错误。" }, { "id": 621, "q": "以下程序的输出结果是[*queNo*]__。\ndef func(s1,s2):\n      s3= s1.join([y for y in s2 if 'A' <= y <= 'Z'])\n      return s3\nx= '-'\ny='LiPjU3vb89'\nprint(func(x,y))", "t": "fill", "ans": "L-P-U", "kp": "字符串", "o": [], "explanation": "列表推导式遍历字符串y，筛选出所有大写字母，得到列表['L', 'P', 'U']。然后调用字符串方法join()，以参数s1（即'-'）作为分隔符，将列表中的元素连接成一个新的字符串，最终输出结果为L-P-U。" }, { "id": 622, "q": "下列Python程序的运行结果是（ ）。\nlst=[8,2,4,15,21]\nlst.sort()\nprint(lst)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[21, 15, 8, 4, 2]", "[2, 4, 8, 15, 21]", "[8, 2, 4, 15, 21]", "2, 4, 8, 15, 21" ], "explanation": "列表的sort()方法默认对列表元素进行升序排列，且是就地修改原列表。执行后lst变为[2, 4, 8, 15, 21]。print(lst)会输出带有方括号的列表格式，因此选项B正确。" }, { "id": 623, "q": "以下关于字典的描述，错误的是：( )。", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "字典中元素以键信息为索引访问", "字典是可变数据类型", "字典中的键可以对应多个值信息", "字典是键值对的集合" ], "explanation": "字典是键值对的集合，通过键来访问对应的值，且字典是可变数据类型，A、B、D正确。在Python字典中，每个键必须是唯一的，且只能对应一个值信息（虽然该值可以是列表等容器），因此选项C说法错误。" }, { "id": 624, "q": "关于Python语言的浮点数类型,以下选项中描述错误的是（）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "浮点数类型与数学中实数的概念一致", "浮点数类型表示带有小数的类型", "Python语言要求所有浮点数必须带有小数部分", "小数部分不可以为0" ], "explanation": "浮点数用于表示带有小数的数值，其小数部分完全可以为0（如3.0），因此选项D描述错误。选项A、B、C均符合Python中浮点数的基本定义和语法要求。" }, { "id": 625, "q": "关于字符串下列说法错误的是（）。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "字符应该视为长度为 1 的字符串", "字符串以\"\\0\"标志结束", "既可以用单引号， 也可以用双引号创建字符串", "在三引号字符串中可以包含换行回车等特殊字符" ], "explanation": "Python中的字符串是对象，通过长度属性来管理，并不像C语言那样以\\0作为结束标志，因此选项B说法错误。选项A、C、D均正确描述了Python字符串的特性及创建方式。" }, { "id": 626, "q": "下面代码的输出结果是（）。\nx=3.1415926\nprint(round(x,2),round(x))", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "2 2", "6.28 3", "3.14 3", "3 3.14" ], "explanation": "round(x, 2)将浮点数x保留两位小数，结果为3.14。round(x)不带第二个参数时，默认将浮点数四舍五入到最接近的整数，结果为3。因此输出结果为3.14 3，选项C正确。" }, { "id": 627, "q": "关于数字运算符的描述，错误的选项是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "运算符%实现取余操作，参与运算的可以是浮点数，结果可能是浮点数", "运算符/实现除法操作，如果参与运算的都是整数，结果只能是整数", "运算符*实现乘法操作，参与运算的可以是任意数字类型", "运算符**实现幂运算操作，幂数可以是整数" ], "explanation": "在Python 3中，/表示真除法，即使参与运算的都是整数，结果也会是浮点数（如4/2结果为2.0），因此选项B描述错误。选项A、C、D均正确描述了取余、乘法和幂运算的规则。" }, { "id": 628, "q": "以下关于Python程序设计语言的特点，正确的是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "程序可读性差", "只具备基本的数值类型", "python具有丰富和强大的库", "Python语言不讲究缩进" ], "explanation": "Python语言以可读性强、库丰富著称，且强制使用缩进表示代码块，故A、D错误。Python包含整数、浮点数、复数等多种数值类型，B错误。C选项正确描述了Python拥有丰富强大的标准库和第三方库。" }, { "id": 629, "q": "已知x=6;y=4,语句x/=y执行后，x的值是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1", "2", "1.5", "1.0" ], "explanation": "在Python 3中，`/` 是真除法运算符，无论操作数是否为整数，结果都会返回浮点数。`x/=y` 等价于 `x = x / y`，即 6 / 4，计算结果为浮点数 1.5。若使用 `//` 则为整除。" }, { "id": 630, "q": "下列程序的输出结果( )。\nx=0\ny=50\nm=80\nm=max(x,y,m)\nprint(\"最大值是:\",m)", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "最大值是： 50", "最大值是： m", "最大值是： 0", "最大值是： 80" ], "explanation": "`max()` 函数用于返回给定参数中的最大值。变量 x、y、m 分别被赋值为 0、50、80，`max(x, y, m)` 比较这三个数，返回最大值 80。因此打印结果为\"最大值是: 80\"。" }, { "id": 631, "q": "以下不属于Python语义控制结构的是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "顺序结构", "分支结构", "重复结构", "数据结构" ], "explanation": "程序的三种基本控制结构是顺序结构、分支结构（选择结构）和循环结构（重复结构），它们决定了代码的执行流程。数据结构是组织和存储数据的方式，不属于程序的控制结构。" }, { "id": 632, "q": "语句a,b,c=eval(input())执行时，输入数据格式错误的是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "3 4 5", "3,4,5", "[3,4,5]", "(3,4,5)" ], "explanation": "`eval()` 函数将输入的字符串作为Python表达式解析。输入 \"3,4,5\"、\"[3,4,5]\" 或 \"(3,4,5)\" 均可被解析为包含3个元素的元组或列表，从而解包赋值。而 \"3 4 5\" 不是合法的Python表达式，会导致语法错误。" }, { "id": 633, "q": "以下代码的输出结果是（）。\nage=42\nif age<=30:\n    print(\"作为一个老师，你很年轻\")\nelse:\n    print(\"作为一个老师，你很有爱心\")", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "作为一个老师，你很年轻", "报错", "无输出", "作为一个老师，你很有爱心" ], "explanation": "变量 age 赋值为 42。判断条件 `age <= 30` 为 False，因此跳过 if 分支，执行 else 分支，输出字符串 \"作为一个老师，你很有爱心\"。" }, { "id": 634, "q": "如果已正确给变量x,y赋值，则以下选项中与表达式x if (x-y) else y中的条件表达式(x-y)等价的是（　　）。", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "x-y>0", "x-y<0", "x-y0", "x-y==0" ], "explanation": "在条件表达式 `x if (x-y) else y` 中，`(x-y)` 作为布尔条件，当 `x-y` 不为 0 时视为 True，为 0 时视为 False。因此它等价于 `x-y != 0`。选项 C 的 \"x-y0\" 疑似 \"x-y!=0\" 的排版漏字错误。" }, { "id": 635, "q": "键盘输入数字5，以下代码的输出结果是（ ）。\nn=eval(input())\ns=0\nif n>=5:\n    n-=1\n    s=4\nif n<5:\n    n-=1\n    s=3\nprint(s)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "1", "2", "3", "4" ], "explanation": "输入 5 后 n=5。第一个 if 判断 `n>=5` 成立，n 减 1 变为 4，s 赋值为 4。接着执行第二个平级的 if 判断 `n<5`（此时 n 为 4），条件成立，n 减 1 变为 3，s 被重新赋值为 3。最后输出 s 的值 3。" }, { "id": 636, "q": "下列程序段的功能是（ ）。\ns=0\nfor i in range(2,101,2):\n s+=i\nprint(s)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "计算1~101范围内所有偶数之和", "计算1~101范围内所有奇数之和", "计算1~101范围内所有质数之和", "计算1~101范围内所有整数之和" ], "explanation": "range(2, 101, 2)生成2、4、6一直到100的偶数序列。for循环把这些数依次累加到s中，因此程序功能是计算1~101范围内所有偶数之和。" }, { "id": 637, "q": "以下程序段的运行结果是（ ）。\ni=5\nwhile i!=0:\n      if i%3==1:\n            if i%5==2:\n                  print(\"*\",i)\n                  break\n      i=i+1", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "*7", "*3*5", "*5", "*2*6" ], "explanation": "初始 i=5。第一次循环不满足 `i%3==1`，i 变为 6；第二次不满足，i 变为 7；第三次 i=7，满足 `7%3==1` 且 `7%5==2`，执行打印并 break 跳出循环。`print(\"*\", i)` 默认以空格分隔，实际输出 \"* 7\"，选项 A 最为接近。" }, { "id": 638, "q": "以下代码的输出结果是（ ）。\nsum=0\nlis=[1,2,3,4,5]\nfor s in lis:\n     if s%2==1 :\n            sum=sum+s\nprint(sum)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "6", "5", "9", "15" ], "explanation": "代码遍历列表 `[1, 2, 3, 4, 5]`，通过 `s % 2 == 1` 筛选出奇数（1、3、5），并将它们累加到 sum 中。计算过程为 1 + 3 + 5 = 9，最终输出 9。" }, { "id": 639, "q": "下列程序中：语句n=n-3共执行（ ）次。\nn=7\nfor i in range(3,7):\n    while n>0:\n        print(n)\n        n=n-3", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "2", "3", "6", "8" ], "explanation": "外层 for 循环执行 4 次（i 从 3 到 6）。当 i=3 时，内层 while 循环条件 `n>0` 成立，n 依次由 7 变为 4、1、-2，`n=n-3` 执行 3 次。当 i=4、5、6 时，n 为 -2，不满足 `n>0`，内层循环不再执行。故共执行 3 次。" }, { "id": 640, "q": "以下能够根据逗号分隔字符串的是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "s.split(',')", "s.strip()", "s.center()", "s.replace()" ], "explanation": "split(',')方法用于根据指定分隔符（此处为逗号）将字符串切片并返回字符串列表。strip()用于移除首尾空白，center()用于居中，replace()用于替换子串。" }, { "id": 641, "q": "以下关于 Python 字符串的描述中，错误的是（ ）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "字符串是字符的序列，字符串中的编号叫\"索引\"", "输出带有引号的字符串，可以使用转义字符", "字符串包括两种序号体系：正向递增和反向递减", "Python字符串提供区间访问方式，采用 [N:M] 格式，表示字符串中从 N 到 M 的索引子字符串（包含 N 和 M）" ], "explanation": "Python字符串切片采用[N:M]格式，表示从索引N到M的子串，其规则是\"左闭右开\"，即包含索引N但不包含索引M。选项D描述包含M是错误的。" }, { "id": 642, "q": "假设列表对象Ls的值为[3,4,5,6,7,9,11,13,15,17],那么切片Ls[2:7]得到的值是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[5,6,7,9,11]", "[6,7,9,11]", "[5,6,7,9,]", "[7,9,11,13]" ], "explanation": "列表切片Ls[2:7]遵循\"左闭右开\"原则，提取索引2到6的元素。原列表索引2至6对应的值依次为5、6、7、9、11，因此结果为[5,6,7,9,11]。" }, { "id": 643, "q": "下列Python程序的运行结果是（ ）。\nname=list('Hello')\nname[2:]=list('mn')\nprint(name)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "['H', 'e', 'm', 'n', 'o']", "['H', 'e', 'm', 'n']", "['m','n','l','l','o']", "['H','e','l','m','n']" ], "explanation": "list('Hello')将字符串转为列表['H','e','l','l','o']。切片赋值name[2:]=list('mn')会将索引2及之后的元素替换为'm'和'n'，最终列表变为['H','e','m','n']。" }, { "id": 644, "q": "向集合中添加的元素不可以是（ ）。", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "字符串", "元组", "列表", "数字" ], "explanation": "Python集合中的元素必须是可哈希的（不可变类型）。字符串、元组和数字都是不可变类型，可以作为集合元素；而列表是可变类型，不可哈希，因此不能添加到集合中。" }, { "id": 645, "q": "关于函数的说法中正确的是（ ）。", "t": "single", "ans": "B", "kp": "函数", "o": [ "函数定义时必须有形参", "函数中定义的变量只在该函数体中起作用", "函数定义时必须带return语句", "实参与形参的个数可以不相同，类型可以任意" ], "explanation": "函数中定义的变量属于局部变量，仅在函数体内有效。函数定义时形参和return语句均非必须；实参与形参的个数和类型通常需要匹配，除非使用了默认参数或不定长参数。" }, { "id": 646, "q": "下列代码的运行结果是（ ）。\nfact=[lambda x=2:x*3,lambda x:x**2]\nprint(fact[0](fact[1](3)))", "t": "single", "ans": "D", "kp": "函数", "o": [ "12", "81", "36", "27" ], "explanation": "列表fact包含两个匿名函数。首先计算fact[1](3)，即3的平方等于9；然后将9作为参数传入fact[0]，由于传入了实参，默认参数x=2被覆盖，计算9*3等于27。" }, { "id": 647, "q": "调用函数时，实参必须以正确的顺序传入函数，实参的个数必须与形参个数一致且一一对应，这种函数的参数类型是（）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "关键字参数", "默认参数", "位置参数", "不定长参数" ], "explanation": "位置参数要求在调用函数时，实参必须按照形参定义的顺序传入，且个数和类型必须一一对应。关键字参数通过参数名传递，默认参数可省略，不定长参数允许个数不一致。" }, { "id": 648, "q": "以下程序的运行结果是（ ）\nclass Person:\n    name='aa'\np=Person()\nPrint(p.name)", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "aa", "'aa'", "运行错误", "name" ], "explanation": "代码定义了Person类并包含类属性name。实例化后通过p.name访问属性，预期输出aa。但代码中使用了首字母大写的Print，Python严格区分大小写，实际运行会报NameError。鉴于答案为A，推测题目存在Print大小写笔误。" }, { "id": 649, "q": "某公司员工的工资计算方法如下：\n（1）工作时数超过100小时者，超过部分加发25%。\n（2）工作时数低于50小时者，扣发 600元。\n（3）其余按每小时80元计发。\n输入员工的工号和该员工的工作时数，计算应发工资。\ngh,gs=eval(input())\nif gs>100:\n    __1__=gs*80+(gs-100)*80*0.25\nelse:\n    __2__ gs>50:\n        gz=gs*80\n    else:\n        gz=gs*80-600\nprint(\"{0}号职工应发工资{1}\".format(gh,gz))", "t": "fill", "ans": "gz | if", "kp": "分支结构", "o": [], "explanation": "第1空计算超过100小时的工资，需将结果赋值给变量gz以便后续输出；第2空在else分支下继续判断工时是否大于50，应使用条件判断关键字。标准语法应为elif，题库答案为if，疑似存在语法或缩进笔误。" }, { "id": 650, "q": "以下程序的运行结果是[*queNo*]_______。\ns=[1,3,2,4]\nr=[]\nwhile s:\n    x=min(s)\n    r.append(x)\n    s.remove(x)\nprint(r)", "t": "fill", "ans": "[1,2,3,4]", "kp": "循环结构", "o": [], "explanation": "程序通过while循环每次找出列表s中的最小值min(s)，将其追加到列表r中，并从s中移除该最小值。这实际上实现了对原列表的升序排序，最终r的值为[1, 2, 3, 4]。" }, { "id": 651, "q": "元素分类：有如下值集合[1,2,3,4,5,6,7,8,9,10], 将所有大于5的值保存至字典的第一个key中，将小于等于5值保存至第二个key的值中。请完成程序。\nA = [1, 2, 3, 4, 5, 6, 7, 8, 9]\nB = {1: [], 2: []}\nfor i in a:\n    if i <= 5:\n        ___1____      \n    else:\n        ____2______\nprint(B)", "t": "fill", "ans": "B[2].append(i) | B[1].append(i)", "kp": "程序填空/调试", "o": [], "explanation": "第1空处理小于等于5的元素，需将其追加到字典B键为2的列表中，即B[2].append(i)；第2空处理大于5的元素，需将其追加到键为1的列表中，即B[1].append(i)。" }, { "id": 652, "q": "以下程序段的输出结果是[*queNo*]。\nn = 2\nif n in (2,3):\n      print('Yes')", "t": "fill", "ans": "Yes", "kp": "分支结构", "o": [], "explanation": "变量n赋值为2，条件判断n是否在元组(2,3)中。因为2存在于该元组，条件为真，执行print语句输出Yes。" }, { "id": 653, "q": "设有程序段：\nk=10\nwhile k:\n      k=k-1\nprint(k)\n则下面描述中正确的是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "while循环执行10次", "循环是无限循环", "循环体语句一次也不执行", "循环体语句执行一次" ], "explanation": "while循环条件为k，当k非0时执行。k初始为10，每次循环减1，依次取10到1，共执行10次。当k为0时条件为假退出循环，故选A。" }, { "id": 654, "q": "以下代码的输出是什么？\ns = {'a': 1, 'b': 2, 'c': 3}\ns.clear()\nprint(s)", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{1, 2, 3, 4, 5}", "{}", "set()", "None" ], "explanation": "s被定义为字典类型。字典的clear()方法会移除所有元素，清空后的字典打印输出为{}。选项C的set()是空集合的表示，故选B。" }, { "id": 655, "q": "turtle库中控制颜色的函数是（ ）。", "t": "single", "ans": "D", "kp": "random/turtle等标准库", "o": [ "pensize ()", "pendown()", "goto()", "pencolor()" ], "explanation": "turtle库中，pensize()设置画笔宽度，pendown()落下画笔，goto()移动到指定坐标，pencolor()用于设置或返回画笔颜色，故选D。" }, { "id": 656, "q": "以下哪个Python库可以用于处理CSV文件？ （ ）", "t": "single", "ans": "A", "kp": "异常与库", "o": [ "Pandas", "Numpy", "datetime", "os" ], "explanation": "Pandas库提供了read_csv等函数，是Python中处理和数据分析CSV文件的常用第三方库。Numpy用于数值计算，datetime处理时间，os处理操作系统接口，故选A。" }, { "id": 657, "q": "根据以下的类定义和对象列表的创建，下列不能输出Iris的语句是（）\nclass St:\n    def __init__(self,name,age):\n        self.name=name\n        self.age=age\ns=[St(\"John\",19),St(\"Iris\",18),St(\"Mary\",17),St(\"Jack\",16)]", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "print(s[1].name)", "print(s[2].name)", "print(\"%s\" % s[1].name)", "print(\"{}\".format(s[1].name))" ], "explanation": "列表s包含4个St对象，索引从0开始。Iris是第2个元素，索引为1。选项A、C、D均通过索引1获取name属性，而选项B通过索引2获取的是Mary，故选B。" }, { "id": 658, "q": "以下代码的输出结果是（）。\na=12.34\nprint(complex(a))", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "12+34J", "10+2.34j", "12.34", "(12.34+0j)" ], "explanation": "complex()函数用于将数字或字符串转换为复数。传入浮点数12.34时，实部为12.34，虚部默认为0，输出格式为(12.34+0j)，故选D。" }, { "id": 659, "q": "表达式chr(ord('a'))的值为（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "'a'", "'A'", "65", "97" ], "explanation": "ord()函数返回字符的Unicode编码值，ord('a')为97；chr()函数将编码值转换回对应字符，chr(97)返回'a'。两者互为逆运算，故选A。" }, { "id": 660, "q": "执行以下Python程序段后，变量x的值为（）。\nx=3.772\ny=8\nx=int(x)+abs(y)\ny=x+y\nx=x-y\nprint(x)", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "8", "3", "11", "-8" ], "explanation": "初始x=3.772，y=8。int(x)截断取整为3，abs(y)为8，x更新为11。y更新为11+8=19。最后x更新为11-19=-8，故选D。" }, { "id": 661, "q": "表达式3+4**2//8%7的计算结果是（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "6", "3", "5", "4" ], "explanation": "运算符优先级：**最高，其次是//和%（同级从左到右），最后是+。先算4**2=16，再算16//8=2，接着2%7=2，最后3+2=5，故选C。" }, { "id": 662, "q": "以下不属于Python语言保留字的是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "break", "and", "else", "list" ], "explanation": "Python保留字是语言内部定义的关键字。break、and、else均为保留字。list是Python的内置数据类型和函数名，不是保留字，可以被重新赋值，故选D。" }, { "id": 663, "q": "下面属于实型常量的是（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "-90.0", "1+j", "20", "'32.0'" ], "explanation": "实型常量即浮点数常量。-90.0带有小数点，属于浮点数；1+j是复数常量；20是整型常量；'32.0'带有引号，属于字符串常量，故选A。" }, { "id": 664, "q": "下列程序的运行结果是（ ）\na=10\nx=a\na+=x\nprint(a)", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "10", "20", "30", "40" ], "explanation": "初始a=10，x=a使得x也为10。a+=x等价于a=a+x，即10+10=20。最后输出a的值为20。" }, { "id": 665, "q": "语句print(10,20,sep=',',end='*')的执行结果是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "10 20", "10,20", "10,20*", "10 20*" ], "explanation": "print函数中，sep参数指定多个输出值之间的分隔符为逗号，end参数指定输出结尾字符为星号。因此10和20之间用逗号分隔，末尾加上星号，结果为10,20*。" }, { "id": 666, "q": "以下注释中，不正确的是（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "#Python注释代码", "#Python注释代码1#Python注释代码2", "\"\"Python文档注释\"\"", "// Python注释代码" ], "explanation": "Python中单行注释使用#开头，多行注释或文档注释可使用三个单引号或双引号。选项D使用了C/C++或Java风格的//作为注释符，这在Python中是不合法的，会引发语法错误。" }, { "id": 667, "q": "以下程序的输出结果是（ ）\nx=3.145926\nprint(\"{0:.2f}\".format(x))", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "3.145926", "3", "3.14", "3.15" ], "explanation": "字符串格式化\"{0:.2f}\"表示将第0个参数格式化为保留两位小数的浮点数。x的值为3.145926，保留两位小数时第三位是5，根据四舍五入规则进位，结果为3.15。" }, { "id": 668, "q": "下列程序的运行时分别输入2和3，输出5，以下正确的程序是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "x=input()\ny=input()\nprint(int(x+y))", "x=input()\ny=input()\nprint(eval(x+y))", "x=int(input())\ny=int(input())\nprint(x+y)", "x=input()\ny=input()\nprint(float(x+y))" ], "explanation": "input()函数返回的是字符串类型，若直接相加会进行字符串拼接。选项C使用int()将输入的字符串转换为整数，再进行加法运算，2+3结果为5。其他选项要么类型转换错误，要么eval用法不当。" }, { "id": 669, "q": "以下代码的输出结果是（）。\ni=45\nj=1000\nk=38\nif(i<=k):\n   print(i)\nelif(i==j):\n   print(j)\nelse:\n   print(k)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "38", "1000", "45", "以上结果都不对" ], "explanation": "首先判断i<=k，即45<=38，条件为假；接着判断i==j，即45==1000，条件也为假；最后执行else分支，输出k的值，即38。" }, { "id": 670, "q": "以下代码的输出结果是（）。\nn=50\ns=10\nif n>=5:\n   n-=10\n   s=40\nelse:\n   n-=10\n   s=30\nprint(s)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "30", "40", "10", "50" ], "explanation": "初始n=50，满足条件n>=5，因此执行if分支内的代码，n减去10变为40，s被赋值为40。else分支不执行。最后输出s的值，结果为40。" }, { "id": 671, "q": "以下关于Python语言的描述中，正确的是（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "条件4+5==9是合法的，输出False", "条件4+5==9是不合法的", "条件4+5==9是合法的，输出True", "条件4+5==9是不合法的，输出异常" ], "explanation": "在Python中，==是关系运算符，用于判断两边表达式的值是否相等。4+5的结果为9，9==9成立，因此该条件表达式合法且计算结果为布尔值True。" }, { "id": 672, "q": "判断ch是否为大写字母( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "ch>='A' and ch<='Z'", "ch>='A' or ch<='z'", "ch>='A'", "ch<='Z'" ], "explanation": "大写字母的ASCII码范围是从'A'到'Z'。要判断字符ch是否为大写字母，需要同时满足大于等于'A'且小于等于'Z'，因此使用逻辑与运算符and连接两个条件。" }, { "id": 673, "q": "以下代码的输出结果是（）。\nx=20\ny=30\nmaxnum=y\nif x>y: maxnum=x\nprint(maxnum)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "30", "20", "10", "0" ], "explanation": "初始maxnum被赋值为y的值30。接着判断条件x>y，即20>30，结果为假，因此不执行if分支内的赋值语句。最后输出maxnum，保持原值30。" }, { "id": 674, "q": "设从键盘输入一个大于或等于1的整数，则下列程序段不能完成n！计算的是（ ）。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "n=eval(input())\nt=1\nfor i in range(1,1+n):\nt=t*i\nprint(t)", "n=eval(input())\nt=1\nfor i in range(n,0,-1):\nt=t*i\nprint(t)", "n=eval(input())\nt=1\ni=1\nwhile i", "n=eval(input())\nt=1\nfor i in range(n):\nt=t*i\nprint(t)" ], "explanation": "计算n!需要累乘1到n。选项D中range(n)生成的序列是0到n-1，第一次循环时i为0，导致t=t*0结果为0，后续累乘结果始终为0，无法正确计算阶乘。其他选项均能正确遍历1到n。" }, { "id": 675, "q": "以下代码的输出结果是（ ）。\na,b,c=70,50,30\nwhile a>b>c:\n    if (a>b):\n        a,b,c=b,c,a\n   \nprint(a,b,c)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "70 50 70", "50 30 70", "70 30 70", "50 30 50" ], "explanation": "初始a=70,b=50,c=30，满足a>b>c。进入循环，a>b成立，执行多重赋值a,b,c=b,c,a，即a=50,b=30,c=70。再次判断while条件50>30>70为假，退出循环。最终输出50 30 70。" }, { "id": 676, "q": "设有以下程序：\nn2=int(input())\nwhile n2:\n    n1=n2%10\n    print(n1,end='')\n    n2=n2//10\n程序运行后，如果从键盘上输入12345，则输出结果为(  )。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "5432", "24", "531", "54321" ], "explanation": "程序通过`n2%10`获取当前数字的个位并打印，然后通过`n2//10`去掉个位。循环直到`n2`为0。输入12345，依次取出5、4、3、2、1并连续打印，实现数字逆序输出。" }, { "id": 677, "q": "s='1234567890'，（）不是正确的分片。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "s[-1:-len(s):-1]", "s[-1:-10:-1]", "s[0:10]", "s[-1:-10:1]" ], "explanation": "切片语法为`[start:stop:step]`。当步长`step`为正数时，截取方向从左向右，要求`start`小于`stop`。选项D中`step`为1，但`start`为-1（末尾），`stop`为-10（开头），方向矛盾，无法截取到字符，属于逻辑错误的切片。" }, { "id": 678, "q": "len(range(1, 11)的值是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "9", "10", "11", "12" ], "explanation": "`range(start, stop)`函数生成从`start`到`stop-1`的整数序列。`range(1, 11)`包含1到10共10个整数，因此使用`len()`求得其长度为10。" }, { "id": 679, "q": "下列Python程序的运行结果是（ ）。\nt1=(1,2,3)\nt2=('a','b')\nprint(t1+t2)", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[1, 2, 3, 'a', 'b']", "(1, 2, 3,（'a', 'b')）", "(1, 2, 3, 'a', 'b')", "1, 2, 3, 'a', 'b'" ], "explanation": "在Python中，元组支持使用`+`运算符进行拼接，结果会生成一个新的元组，包含两个原元组的所有元素。因此`t1+t2`的结果是合并后的元组`(1, 2, 3, 'a', 'b')`。" }, { "id": 680, "q": "s1 = {1, 2, 3}，s2 = {2, 3, 4}。下面哪个选项用于将集合s1和s2中的相同元素移除，并将结果保存到集合s3中？", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "s3 = s1.symmetric_difference(s2)", "s3 = s1.intersection(s2)", "s3 = s1.difference(s2)", "s3 = s1.union(s2)" ], "explanation": "集合的`symmetric_difference()`方法（或`^`运算符）用于求对称差集，即返回在两个集合中非共有的元素集合，正好移除相同元素。`intersection`是交集，`difference`是差集，`union`是并集。" }, { "id": 681, "q": "被调函数返回给主调函数的值称为( )", "t": "single", "ans": "C", "kp": "函数", "o": [ "形参", "实参", "返回值", "参数" ], "explanation": "在函数调用中，主调函数传递给被调函数的数据称为参数（实参），而被调函数执行完毕后通过`return`语句传回给主调函数的数据称为返回值。" }, { "id": 682, "q": "下列代码运行后的结果是（ ）。\ndef dig(n):\n    if n/2>0:\n        dig(n-3)\n       \n    print(n,end=' ')\nif __name__ == '__main__':\n    dig(6)", "t": "single", "ans": "D", "kp": "函数", "o": [ "6 3 0", "6", "0", "0 3 6" ], "explanation": "调用`dig(6)`，满足条件递归调用`dig(3)`；再递归调用`dig(0)`；0不满足条件，执行`print(0)`。然后返回上一层`dig(3)`执行`print(3)`，最后返回`dig(6)`执行`print(6)`。由于`print`在递归调用之后，因此回溯时逆序输出0 3 6。" }, { "id": 683, "q": "已知f=lambda x,y:x+y，则f([4],[1,2,3])的值是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "[1, 2, 3, 4]", "10", "[4, 1, 2, 3]", "{1, 2, 3, 4}" ], "explanation": "lambda函数定义了匿名函数，返回`x+y`。当传入的两个参数均为列表时，`+`运算符的作用是将两个列表拼接。因此`[4]`和`[1,2,3]`拼接的结果为`[4, 1, 2, 3]`。" }, { "id": 684, "q": "以下程序运行后输出的结果是（ ）\ndef show(x,y,**ar):\n    print(x,y,ar)\nshow(1,3,xing='Wang',age=11)", "t": "single", "ans": "A", "kp": "函数", "o": [ "1 3 {'xing':'Wang',age:11}", "1,3,(xing='Wang',age=11)", "1,3,xing='Wang',age=11", "1,3,{'xing': 'Wang', 'age': 11}" ], "explanation": "函数定义中`**ar`用于接收任意数量的关键字参数，并将其打包为字典。调用时传入位置参数1和3，以及关键字参数。因此`x`为1，`y`为3，`ar`为字典。选项A最符合实际输出逻辑。" }, { "id": 685, "q": "如下所示程序片段中：\nclass Myclass:\n    __x=1\n    def __aa(self):\n        self.__x=10\n    def bb(self):\n        print(self.__x)\n其中，私有方法是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "__x", "__aa", "bb", "以上都不是" ], "explanation": "在Python中，以双下划线`__`开头且不以双下划线结尾的属性或方法被视为私有成员。`__x`是私有属性，`__aa`是私有方法，`bb`是公有方法。" }, { "id": 686, "q": "在面向对象程序设计中， 以（）作为程序的主体。", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "函数", "对象", "方法", "属性" ], "explanation": "面向对象程序设计（OOP）的核心思想是将现实世界的事物抽象为对象，以对象作为程序的基本单元和主体，通过对象之间的交互来实现程序功能，区别于以函数为主体的面向过程设计。" }, { "id": 687, "q": "下列代码行中，父类名是（）\nclass B（A）:", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "class", "A", "B", "以上都不是" ], "explanation": "在Python类的定义语法`class 子类名(父类名):`中，括号内指定的是该类继承的父类（基类）。因此代码表示类B继承自类A，A是父类名。" }, { "id": 688, "q": "哪种方法在试图读取超出文件末尾以外的内容时将返回空字符串？（）", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "read", "getline", "input", "readline" ], "explanation": "在Python文件操作中，readline()方法用于读取文件的一行。当文件指针到达文件末尾时，再次调用readline()会返回空字符串，这常被用作判断文件是否读取完毕的条件。选项A的read()若不传参会读取全部内容；选项B的getline并非文件对象内置方法；选项C的input()用于接收控制台输入。因此选D。" }, { "id": 689, "q": "下列程序的输出结果是()\nf=open('D:\\\\out.txt','w+')\nf.write('Python')\nf.seek(1,0)\nc=f.read(2)\nprint(c)\nf.close()", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "Py", "Pn", "yt", "on" ], "explanation": "程序以w+模式打开文件并写入字符串Python。随后调用f.seek(1, 0)，将文件指针移动到距离文件开头偏移量为1的位置，即字符y处。接着执行f.read(2)，从当前指针位置开始读取2个字符，因此读取到的内容为yt。最后打印输出结果。选项C正确。" }, { "id": 690, "q": "创建一个集合my_set = {1, 2, 3, 4, 5}调用discard方法my_set.discard(3)请问，执行上述代码后，my_set中的元素是什么？", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{1, 2, 3, 4, 5}", "{1, 2, 4, 5}", "{2, 3, 4, 5}", "{1, 2, 3, 5}" ], "explanation": "Python集合的discard()方法用于移除集合中的指定元素。若元素存在则将其删除，若不存在也不会引发异常。代码中集合初始包含1到5，调用my_set.discard(3)后，元素3被成功移除，剩余元素为1、2、4、5。因此选项B正确。" }, { "id": 691, "q": "输入年月，求该月的天数。\nyear=int(input(\"year=\"))\nmonth=int(input(\"month=\"))\nif month in(1,3,5,7,8,10,12):\n    day=__1__\nelif month in(4,6,9,11):\n    day=30\nelse:\n    logi=(year%4==0 and year%100!=0) __2__ year%400==0\n    day=29 if logi else 28\nprint(year,month,day)", "t": "fill", "ans": "31 | or", "kp": "分支结构", "o": [], "explanation": "本题考查计算月份天数的逻辑。第1空，1、3、5、7、8、10、12月为大月，天数固定为31天，故填31。第2空，判断闰年的条件是能被4整除且不能被100整除，或者能被400整除，前后两个条件满足其一即可，因此需使用逻辑或运算符，故填or。" }, { "id": 692, "q": "请填空使得以下程序能正常运行。\nclass Person():\n    def __init__(___1____,name,gender,age):\n        self.name = name\n        self.gender = gender\n        self.age = __2____\nxiaoming = Person('Xiao Ming', 'Male', 18)\nprint(xiaoming.age)", "t": "fill", "ans": "self | age", "kp": "面向对象", "o": [], "explanation": "本题考查类的初始化方法。第1空，在Python面向对象编程中，类的实例方法（包括__init__构造方法）的第一个参数必须是代表实例本身的self。第2空，构造方法接收了age参数，需要将其赋值给实例属性self.age，因此等号右侧应填入参数名age。" }, { "id": 693, "q": "以下程序的运行结果是（ ）。\nm=2\nfor i in range(1,4):\n    if i*m<3:\n        continue\n    m*=i\nprint(\"m=\",m)", "t": "fill", "ans": "m=12", "kp": "循环结构", "o": [], "explanation": "初始时m=2。循环i从1到3：当i=1时，i*m为2，小于3，执行continue跳过后续语句，m仍为2；当i=2时，i*m为4，不小于3，执行m*=i，m变为4；当i=3时，i*m为12，不小于3，执行m*=i，m变为12。循环结束，输出m=12。" }, { "id": 694, "q": "初始化一个小写英文字符串a和一个非负数b(0<=b<26), 将a中的每个小写字符替换成字母表中比它大b的字母。这里将字母表的z和a相连，如果超过了z就回到了a，最后输出列表s。请填空。\na=input()\nb=eval(input())\ns=[]\nfor i in a:\n    x=chr(ord(i)+b)\n    if ____1____:\n        x=chr(ord(i)+b-26)\n    _____2_____\nprint(s)", "t": "fill", "ans": "x>'z' | s.append(x)", "kp": "程序填空/调试", "o": [], "explanation": "本题考查字符的偏移加密。第1空，当字符加上偏移量b后，如果超出了小写字母z的范围，则需要减去26使其回到字母表开头，因此条件判断应填x>'z'。第2空，在每次循环处理完字符x后，需要将其添加到结果列表s中，故应调用列表的追加方法，填s.append(x)。" }, { "id": 695, "q": "下面程序的执行结果是[*queNo*]________。\nfruits={'apple':10,'banana':5,'pear':8}\nfruits['banana']=7\nprint(sum(fruits.values()))", "t": "fill", "ans": "25", "kp": "字典/集合", "o": [], "explanation": "程序首先创建一个字典fruits，包含三个键值对。接着通过fruits['banana']=7将键banana对应的值由5修改为7。此时字典的所有值为10、7和8。最后调用fruits.values()获取所有值，并使用sum()函数求和，即10+7+8，结果为25。" }, { "id": 696, "q": "请补充fun函数，fun函数的功能是：计算并输出n(包括n)以内能被3或7整除的所有自然数的倒数之和。如在主函数中输入50，输出为s=1.425889。\n注意：部分源程序已给出。输入并调试程序，使程序得出正确结果不得增行或删行，也不得更改程序的结构！仅在fun函数的横线上填入。\ndef fun(n):\n    sum=0\n    for i in range(1, n+1):\n        if ___1___ :\n            sum+=___2___\n    return sum\nn=eval(input(\"请输入一个数:\"))\nprint(fun(n))", "t": "fill", "ans": "i%3==0 or i%7==0 | 1/i", "kp": "程序填空/调试", "o": [], "explanation": "本题考查条件判断与累加求和。第1空，题目要求找出能被3或7整除的自然数，因此if语句的条件应为i对3取余为0或者对7取余为0，填i%3==0 or i%7==0。第2空，需要将满足条件的自然数的倒数累加到sum中，自然数i的倒数表示为1/i，故填1/i。" }, { "id": 697, "q": "下面程序代码的输出结果是[*queNo*]__。\ndef func(i):\n    ones_digit=i%10\n    print(ones_digit,end='')\n    if i>10:\n        func(i//10)\nfunc(123456)", "t": "fill", "ans": "654321", "kp": "函数", "o": [], "explanation": "这是一个递归函数，用于逆序输出整数的各位数字。调用func(123456)时，先取余得到个位6并打印；因123456大于10，递归调用func(12345)，打印5；以此类推，依次打印4、3、2。当传入参数为1时，打印1，此时1不大于10，递归终止。由于print设置了end=''，最终连续输出654321。" }, { "id": 698, "q": "下列程序的运行结果为      。\nclass account:\n    def __init__(self,id,bal):\n        self.id=id\n        self.bal=bal\n    def deposit(self,am):\n        self.bal+=am\n    def withdraw(self,am):\n        self.bal-=am\nacc1=account('1234',100)\nacc1.deposit(500)\nacc1.withdraw(200)\nprint(acc1.bal)", "t": "fill", "ans": "400", "kp": "面向对象", "o": [], "explanation": "程序定义了一个账户类account。实例化对象acc1时，初始余额bal被设置为100。随后调用deposit(500)方法，余额增加500变为600；接着调用withdraw(200)方法，余额减少200变为400。最后打印acc1.bal，输出结果为400。" }, { "id": 699, "q": "打开文件的函数名是[*queNo*]_。", "t": "fill", "ans": "open", "kp": "文件操作", "o": [], "explanation": "在Python中，进行文件操作的第一步是打开文件。内置的open()函数用于打开一个文件，并返回一个文件对象，后续可通过该对象进行读写操作。因此打开文件的函数名为open。" }, { "id": 700, "q": "下列Python程序的运行结果是[*queNo*]_。\na=40\nb=50\nif a10.2f}\".format(f))\n代码中，:>10表示靠右对齐。.2f表示精度为2位小数点的浮点数。", "kp": "基础语法与输入输出", "o": [], "rawType": "operation" }, { "id": 703, "q": "字符串s='a\\nb\\tc'，则len(s)的值是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "7", "6", "5", "4" ], "explanation": "字符串中的\\n（换行符）和\\t（制表符）均为转义字符，在计算字符串长度时各占1个字符位置。因此字符串包含'a'、'\\n'、'b'、'\\t'、'c'共5个字符，len(s)的值为5。" }, { "id": 704, "q": "下列选项中，不属于Python特点的是（ ）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "面向对象", "运行效率高", "可读性好", "开源" ], "explanation": "Python是解释型语言，代码在运行时需要逐行解释执行，因此其运行效率通常低于C/C++等编译型语言。面向对象、可读性好和开源均是Python的显著特点。" }, { "id": 705, "q": ">>>type(True)的运行结果的是（ ）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "", "", "", "" ], "explanation": "True是Python中的布尔类型常量。使用内置函数type()查看其数据类型时，返回结果为，表示布尔型。" }, { "id": 706, "q": "下列程序的输出结果( )。\nx=0\ny=50\nm=80\nm=max(x,y)\nprint(\"最大值是：m\")", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "最大值是： 50", "最大值是：m", "最大值是： 0", "最大值是： 80" ], "explanation": "程序中虽然通过max(x,y)将变量m重新赋值为50，但在print函数中输出的是纯字符串\"最大值是：m\"，并未使用变量m进行格式化或拼接，因此原样输出该字符串。" }, { "id": 707, "q": "下列代码的输出结果是（）\nif 2<=0:\n    print(True )\nelse:\n    print( False)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "True", "False", "报错", "没有输出" ], "explanation": "条件表达式2<=0的值为False，因此不执行if分支，转而执行else分支。else分支中调用print函数输出布尔值False。" }, { "id": 708, "q": "设x为已赋值的整型变量，则x>1 and x<=1的值为（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "逻辑与运算符and要求两侧条件同时成立结果才为True。一个数不可能既大于1又小于等于1，这两个条件互斥，因此该逻辑表达式的值恒为False。" }, { "id": 709, "q": "下面的代码在运行时输入“2”，则输出结果是（）。\nx=input()\nif x== '1':\n   if x>= '0' and x<='1':\n      print('01')\n   else:\n      print('02')\nelse:\n   print('1')", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "01", "02", "1", "报错" ], "explanation": "input()函数接收的输入默认为字符串类型。输入\"2\"后，x的值为字符串\"2\"。判断x=='1'不成立，直接执行外层if语句的else分支，输出字符串'1'。" }, { "id": 710, "q": "判断ch既不是字母也不是数字字符( )", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "not((ch>='A' and ch='a' and ch='0' and ch<='9'))", "((ch>='A' and ch='a' and ch='0' and ch<='9'))", "not((ch>='A' and ch='a' and ch='0' or ch<='9'))", "not((ch>='A' or ch='a' and ch='0' and ch<='9'))" ], "explanation": "判断字符是字母或数字需用or连接大写字母、小写字母和数字的判断条件。要求\"既不是...也不是\"，需对整个条件使用not取反。选项文本存在明显截断和符号缺失，但A选项逻辑框架正确。" }, { "id": 711, "q": "关于if单分支选择结构，下列说法错误的是（ ）", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "在if语句的表达式后面必须加冒号。", "if 中表示条件的表达式可以是任意合法的表达式。", "如果语句块中只有一条语句，if语句也可以写在同一行上。", "if语句中的语句块不需要缩进一致。" ], "explanation": "Python使用缩进来划分代码块。在if语句中，属于同一语句块的多条语句必须保持相同的缩进量，否则会引发IndentationError缩进错误。因此\"不需要缩进一致\"的说法是错误的。" }, { "id": 712, "q": "以下for语句中，不能完成1～10的累加功能的是（）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "sum=0\nfor i in range(10,0):sum+=i", "sum=0\nfor i in range(1,11):sum+=i", "sum=0\nfor i in range(10,0,-1):sum+=i", "sum=0\nfor i in (10,9,8,7,6,5,4,3,2,1):sum+=i" ], "explanation": "range(start, stop)函数在start大于stop且未指定负数步长时，会生成空序列。选项A中range(10,0)默认步长为1，无法生成递减序列，导致循环体不执行，不能完成累加功能。" }, { "id": 713, "q": "设有程序段：\nk=10\nwhile k:\n      while k:\n            k=k-1\nprint(k)\n则下面描述中正确的是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "while循环执行10次", "循环是无限循环", "循环体语句一次也不执行", "循环体语句执行一次" ], "explanation": "外层while条件首次判断为真，进入内层while。内层循环执行10次将k递减至0后退出。外层再次判断k为0退出。通常题意指内层循环体执行了10次，故选A。" }, { "id": 714, "q": "如果需要将大写字母化为小写字母，需要使用的方法是（）。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "upper", "lower", "title", "capitalize" ], "explanation": "lower()方法用于将字符串中的所有大写字母转换为小写字母。upper()转为大写，title()和capitalize()用于首字母大写。" }, { "id": 715, "q": "表达式\"[i**2 for i in range(4)]\"的值是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[0, 1, 4, 9]", "[0,1,2,3,0,1,2,3]", "[0, 1, 4, 9, 16]", "[0,1,2,3,4,0,1,2,3,4]" ], "explanation": "列表推导式遍历range(4)生成的序列0,1,2,3，对每个元素求平方（i**2），依次得到0,1,4,9，最终生成列表[0, 1, 4, 9]。" }, { "id": 716, "q": "下列Python程序的运行结果是（ ）。\nL1=[1,2,3,4,5]\nL1.pop()", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[1,2,3,4]", "5", "[1,2,3,4,5]", "[5]" ], "explanation": "列表的pop()方法在不传参数时，默认移除并返回列表的最后一个元素。L1的最后一个元素是5，因此返回5，同时L1变为[1,2,3,4]。" }, { "id": 717, "q": "以下不能创建集合的语句是（ ）。", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "s1=set()", "s2=set(\"abcd\")", "s3={}", "s4=frozenset((3,2,1))" ], "explanation": "在Python中，花括号{}默认用于创建空字典。若要创建空集合，必须使用set()。set(\"abcd\")创建字符集合，frozenset()创建不可变集合。" }, { "id": 718, "q": "以下关于字典类型的描述，正确的是：( )。", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "字典类型可迭代，即字典的值还可以是字典类型的对象", "字典类型可以直接通过值进行索引", "字典类型的键可以是列表和其他数据类型", "字典类型的值可以是任意数据类型的对象" ], "explanation": "字典的值可以是任意数据类型的对象，包括列表、字典等。字典通过键进行索引而非值；字典的键必须是可哈希的不可变类型，不能是列表。" }, { "id": 719, "q": "Python语言中的自定义函数若未用return语句返回值，则该函数返回的是( )", "t": "single", "ans": "B", "kp": "函数", "o": [ "随机数", "None", "0", "不确定" ], "explanation": "Python中如果函数没有显式使用return语句返回值，或者return后不带任何表达式，函数执行完毕后默认返回None。" }, { "id": 720, "q": "下列代码的运行后结果是（ ）。\ndef add(k):\n  if k>=2:\n    return add(k-1)+add(k-2)\n  else:\n    return 5\nprint('{}'.format(add(2)))", "t": "single", "ans": "B", "kp": "函数", "o": [ "5", "10", "15", "0" ], "explanation": "调用add(2)时，满足k>=2，返回add(1)+add(0)。由于1和0均小于2，add(1)和add(0)都执行else分支返回5。因此最终结果为5+5=10。" }, { "id": 721, "q": "以下程序的运行结果是（）。\ndef Jc(m,n,k):\n     s=m*n+k*n\n     return s\ny=Jc(k=5,2,4)\nprint(\"y的输出结果为:\",y)", "t": "single", "ans": "D", "kp": "函数", "o": [ "28", "5", "20", "程序运行时会出错" ], "explanation": "函数调用时，关键字参数必须位于位置参数之后。代码中Jc(k=5,2,4)将关键字参数k=5放在了位置参数2和4之前，会导致语法错误（SyntaxError）。" }, { "id": 722, "q": "在Python语言中，类的私有成员以( )开头。", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "__（两个下划线）", "_（一个下划线）", "private", "#" ], "explanation": "Python中类的私有成员（属性或方法）命名约定是以两个下划线（__）开头。单个下划线通常表示受保护的成员，private和#不是Python的私有化语法。" }, { "id": 723, "q": "在下面的代码行中，父类的名称是（）\nclass Rose(Flower):", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "Rose", "Flower", "Rose(Flower)", "以上都不是" ], "explanation": "在类定义语句class 子类名(父类名):中，括号内指定的是父类（基类）。因此Rose是子类，Flower是父类。" }, { "id": 724, "q": "下面程序的运行结果是 （）\nx = {\"apple\", \"banana\", \"cherry\"}\ny = {\"google\", \"runoob\", \"apple\"}\nx.symmetric_difference_update(y)\nprint(x)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{'google', 'banana', 'runoob', 'cherry'}", "{\"apple\", \"banana\", 'runoob', 'cherry'}", "{'google', 'banana', 'runoob', }", "{ \"banana\", 'runoob', 'cherry'}" ], "explanation": "symmetric_difference_update()方法用于更新集合，使其包含两个集合的对称差集（即只存在于其中一个集合中的元素）。x和y共有的'apple'被移除，保留其余元素。" }, { "id": 725, "q": "从键盘输入x的值，根据下面的表达式，计算并输出y的值。\n         x 3+10x+1 (x=100)\nx=eval(input(\"请输入x:\"))\nif ___1__:\n    y=x*x*x+10*x+1\nelif x==0:\n    y=1000\nelif __2___:\n    y=100*x\nelse:\n    y=3*x+5\nprint(\"y=\",y)", "t": "fill", "ans": "x<0 | <100", "kp": "分支结构", "o": [], "explanation": "第1空判断x<0的情况，计算x的三次方相关表达式，故填x<0；第2空在排除x<=0后，判断0=0时什么也不输出", "print()函数永远也不执行", "最多允许输出10个非负整数" ], "explanation": "循环固定执行10次。当输入x<0时触发continue跳过本次打印，仅当x>=0时执行print输出。因此程序最多循环10次，即最多输出10个非负整数，选D。A错在continue不终止循环，B、C与逻辑相反。" }, { "id": 736, "q": "以下代码的输出结果是（ ）。\nfor s in \"***He**llo***\":\n     if s==\"*\":\n           continue\n     print(s,end=\"\")", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "***He", "Hello", "llo***", "He**llo" ], "explanation": "循环遍历字符串每个字符，遇到*时执行continue跳过打印，其余字符直接输出且end参数保证不换行。过滤掉所有星号后，剩余字符按原顺序拼接为Hello，故选B。" }, { "id": 737, "q": "下列程序的运行结果是（ ）。\nf=lambda y:y**2\nprint(f(3))", "t": "single", "ans": "B", "kp": "函数", "o": [ "6", "9", "3", "81" ], "explanation": "lambda定义匿名函数，参数为y，返回值为y的平方（y**2）。调用f(3)即计算3的平方，结果为9，故选B。" }, { "id": 738, "q": "与以下程序段等价的是（ ）。\nwhile  a:\n    if  b:\n       continue\n    c", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "while a:\nif !b:\nc", "while a:\nif !b:\nbreak\nc", "while a:\nif b:\nc", "while a:\nif b:\nbreak\nc" ], "explanation": "原代码在while循环中，若b为真则continue跳过c，意味着c仅在b为假时执行。逻辑等价于当a为真且b为假时执行c，选项A用!b表示非b，符合该控制流逻辑，故选A。" }, { "id": 739, "q": "令list=[1,2,3,4,5]，则print(list[1:5])的结果为（ ）", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[1,2,3,4]", "[1,2,3,4,5]", "[2,3,4,5]", "[2,3,4]" ], "explanation": "列表切片list[start:end]包含start索引，不包含end索引。list[1:5]提取索引1到4的元素，即第2至第5个元素，结果为[2,3,4,5]。" }, { "id": 740, "q": "利用选择排序法，将n个数按从小到大顺序排列后输出。请填空。\nn=int(input('输入数据个数:'))\nx=[]\nfor i in range(n):\n    x.append(int(input('输入一个数:')))\n       \nfor i in range(n-1):\n    k=i\n    for j in range(i+1,n):\n        if x[k]>x[j]: ___1____\n    if k!=i:\n        ____2___\n       \nprint(\"排序后数据:\",x)", "t": "fill", "ans": "k=j | x[i],x[k]=x[k],x[i]", "kp": "程序填空/调试", "o": [], "explanation": "本题考查选择排序。第1空：内层循环寻找最小值索引，当发现更小元素x[j]时需更新索引，故填k=j。第2空：若最小值索引k不等于当前位置i，则交换两者元素，Python支持多元赋值交换，故填x[i],x[k]=x[k],x[i]。" }, { "id": 741, "q": "以下关于Python程序设计语言的特点，错误的是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "通过强制程序缩进，Python程序可读性好", "有丰富的数据类型，可以方便地解决许多实际问题", "Python语言不是开源的", "Python语言既可以面向过程，也可以面向对象" ], "explanation": "Python是一种开源、免费的高级程序设计语言，拥有庞大的开源社区和丰富的第三方库。因此选项C称其不是开源的是错误的。A、B、D均正确描述了Python的特点。" }, { "id": 742, "q": "以下程序段的运行结果是（ ）。\ns=\"13571619508\"\nfor i in s:\n    if ord(i)%2==1 or ord(i)%3==0:\n        continue\nprint(i,end=\"\")", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "608", "135711958", "13571619508", "8" ], "explanation": "数字字符'0'-'9'的ASCII码为48-57。遍历字符串时，'1','3','5','7','9'的ASCII码为奇数，'6'和'0'的ASCII码能被3整除，均满足条件执行continue跳过；只有'8'的ASCII码56既非奇数也不能被3整除，最终输出'8'。" }, { "id": 743, "q": "设s= \"Python programing\",则print(s[-4::])的结果是( )。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "ming", "mming", "Python", "ing" ], "explanation": "字符串切片s[-4::]表示从倒数第4个字符开始截取到末尾。字符串\"Python programing\"倒数4个字符依次为'm','i','n','g'，因此结果为\"ming\"。" }, { "id": 744, "q": "表达式len('人生苦短,我用Python')的值为（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "13", "20", "12", "11" ], "explanation": "len()函数用于返回字符串的字符个数。'人生苦短,我用Python'包含4个汉字、1个中文逗号、2个汉字和6个英文字母，共计13个字符，因此值为13。" }, { "id": 745, "q": "下列对变量的描述正确的是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "变量的名称是可以改变的", "变量的值是可以改变的", "变量的值必须是整数", "一个程序必须要有一个变量" ], "explanation": "变量是内存中存储数据的标识符，其核心特征是值在程序运行期间可以被改变，故B正确。变量名一旦定义不可随意改变标识符本身，值不限于整数，且程序并非必须有变量。" }, { "id": 746, "q": "以下代码的输出结果是（ ）。\nn=5\ns=100\nif n>=5:\n    n-=10\n    s=4\nif n<5:\n    n-=10\n    s=3\nprint(s)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "3", "4", "0", "2" ], "explanation": "初始n=5，s=100。第一个if判断n>=5成立，执行后n变为-5，s变为4。接着判断第二个if，此时n=-5满足n<5，执行后n变为-15，s变为3。最后打印s，输出3。" }, { "id": 747, "q": "下列Python程序的运行结果是（ ）。\nname=list('year')\nname[2:]=list('mn')\nprint(name)", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "['y','e','m','n']", "['m','n','a','r']", "['y','e','a','m','n']", "['y','m','n','r']" ], "explanation": "name初始为['y','e','a','r']。切片name[2:]表示从索引2到末尾的子列表['a','r']。将其赋值为list('mn')即['m','n']，会用新列表等长替换原切片部分，最终name变为['y','e','m','n']。" }, { "id": 748, "q": "假设有三个集合：A = {18,62,37,44}，B = {33,44, 55, 76}，C = {45, 54, 62, 37}. 下面表达式中，result的结果是什么？\nresult = A ^ B ^ C\nresult.add(5)\nresult.discard(2)\nresult.update({8, 9})", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{5, 8, 9, 18, 33, 45, 54, 55, 76}", "{18, 33, 45, 54, 55, 76}", "{5, 8, 9}", "{5, 9, 18, 33, 45, 54, 55, 76}" ], "explanation": "集合的^运算求对称差集。A^B去除共有元素44；再与C运算去除共有元素62和37，加入C独有元素45和54，得{18,33,55,76,45,54}。随后add(5)添加5，discard(2)无影响，update添加8和9，结果为A。" }, { "id": 749, "q": "对于字典 dict2={'a':1,'b':2,'c':3,'d':4} ，对第 2个字典元素的访问形式是（ ）。", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "dict2[1]", "dict2[2]", "dict2[b]", "dict2['b']" ], "explanation": "字典元素通过键（key）进行访问，而不是通过数字索引。字典dict2的第2个元素键为'b'，因此正确的访问形式是dict2['b']。选项A、B使用数字索引会报错，C缺少引号。" }, { "id": 750, "q": "以下关于函数调用说法错误的是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "匿名函数是指没有函数名的简单函数，其不需要使用def 语句进行定义。", "默认值参数必须出现在形参表的最右端。若第一个形参使用默认值参数后,其后所有形参也必须使用默认值参数,否则会出错。", "在形参名前面加\"*\"号，将按受的任意多个实参存放在一个列表中。", "在形参名前面加两个\"**\"号，实参名以字典显式赋值的方式传递参数，将接收的参数存放在字典中。" ], "explanation": "A、B、D选项描述均正确。C选项错误，在形参名前加单星号(*)，接收的任意多个位置实参会被打包存放在一个\"元组\"中，而不是列表中。" }, { "id": 751, "q": "以下关于函数说法正确的是（ ）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "函数的实际参数和形式参数必须同名", "函数的形式参数既可以是变量也可以是常量", "函数的实际参数不可以是表达式", "函数的实际参数可以是其他函数的调用" ], "explanation": "D正确，实际参数可以是常量、变量、表达式或函数调用。A错误，实参和形参不需要同名，按位置或关键字匹配即可。B错误，形参必须是变量名，不能是常量。C错误，实参可以是表达式，会在调用时先求值。" }, { "id": 752, "q": "以下程序的输出结果是（ ）\ndef mytotal(x,y=30,*z1,**z2):\n    t=x+y\n    for i in range(0,len(z1)):\n        t+=z1[i]\n    for k in z2.values():\n        t+=k\n    return t\ns=mytotal(10,20,2,3,4,5,k1=115,k2=211)\nprint(s)", "t": "fill", "ans": "370", "kp": "函数", "o": [], "explanation": "函数mytotal接收位置参数x=10，y=20，可变位置参数z1=(2,3,4,5)，可变关键字参数z2={'k1':115,'k2':211}。t初始为x+y=30。第一个循环累加z1的元素：30+2+3+4+5=44。第二个循环累加z2的值：44+115+211=370。最终返回并打印370。" }, { "id": 753, "q": "下面语句的执行结果，不可能的选项是（）。\nimport random\nprint(random.uniform(1,3))", "t": "single", "ans": "B", "kp": "random/turtle等标准库", "o": [ "1.807117374321477", "3.993002365820678", "2.5670577649215085", "2.764076933688729" ], "explanation": "random.uniform(a, b)用于生成一个[a, b]范围内的随机浮点数。本题中a=1，b=3，因此生成的随机数必须在1.0到3.0之间。选项B的值为3.99，超出了该范围，因此是不可能出现的执行结果。" }, { "id": 754, "q": "以下是print(type(45.00))的运行结果的是（ ）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "", "", "", "" ], "explanation": "45.00是一个带有小数点的数值，在Python中属于浮点数类型。type()函数用于返回对象的数据类型，因此type(45.00)的结果是。选项B虽然未显示具体内容，但根据题意和常规选项设置，B应为表示float类型的选项。" }, { "id": 755, "q": "下列选项中错误的赋值语句是（ ）。", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "a=1", "a=b=c=1", "s=\"hello\"", "a==b" ], "explanation": "Python中赋值语句使用单等号\"=\"，用于将右侧的值赋给左侧的变量。选项A、B、C均为合法的赋值语句。选项D使用了双等号\"==\"，这是比较运算符，用于判断两个值是否相等，不能作为赋值语句使用，因此D是错误的。" }, { "id": 756, "q": "以下哪句Python代码可以输出“你好呀！”（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "input(\"你好呀！\")", "print 你好呀！", "你好呀！", "print(\"你好呀！\")" ], "explanation": "在Python 3中，输出内容需要使用内置函数print()，并将要输出的字符串作为参数传入，且字符串需用引号括起来。选项A是接收输入，选项B缺少括号和引号，选项C只是纯文本会报语法错误，只有D正确。" }, { "id": 757, "q": "关于多分支结构if-elif-else语句的说法正确的是（ ）", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "最多只会执行一个分支。", "最多可以执行两个分支", "最多可以执行三个分支。", "最多可以执行四个分支。" ], "explanation": "在if-elif-else多分支结构中，程序会从上到下依次判断条件。一旦某个条件为真，就会执行对应的代码块，然后直接跳出整个分支结构，不再判断后续条件。因此，无论有多少个elif，最多只会执行其中一个分支。" }, { "id": 758, "q": "运行下列代码时输入12，则程序输出结果是（）\na=int(input())\nif a>100:x=20\nelse:x=200\nprint(x)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "20", "200", "报错", "没有输出" ], "explanation": "程序首先接收输入并转换为整数，此时a=12。接着判断条件a>100，因为12不大于100，条件为假，所以跳过if分支，执行else分支，将变量x赋值为200。最后打印x的值，因此输出结果为200。" }, { "id": 759, "q": "3 or 4的值为（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "3", "4", "不确定", "错误" ], "explanation": "在Python中，逻辑运算符or遵循短路求值规则。如果第一个操作数为真，则直接返回第一个操作数的值，不再计算第二个操作数。数字3在布尔上下文中为True，因此表达式3 or 4直接返回3。" }, { "id": 760, "q": "若输入x为100，输出的grade是（）\nx=int(input())\nif x>=80:\n    grade='B'\nif x>=90:\n    grade='A'\nif x>=60:\n    grade='D'\nif x>=70:\n    grade='C'\nprint(grade)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "A", "B", "C", "D" ], "explanation": "输入x=100。程序包含四个独立的if语句，会依次执行判断。100>=80成立，grade='B'；100>=90成立，grade='A'；100>=60成立，grade='D'；100>=70成立，grade='C'。由于没有使用elif，每次条件成立都会覆盖grade的值，最终grade被赋为'C'并输出。" }, { "id": 761, "q": "以下代码的输出结果是（ ）。\nsum=0\nlis=[1,2,3,4,5]\nfor s in lis:\n     if s%2==0 :\n          sum=sum+s\nprint(sum)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "6", "5", "0", "15" ], "explanation": "程序遍历列表lis中的元素，通过s%2==0判断是否为偶数。列表中只有2和4是偶数。当s=2时，sum=0+2=2；当s=4时，sum=2+4=6。其他奇数不满足条件被跳过。循环结束后打印sum，结果为6。" }, { "id": 762, "q": "下列选项中与列表ls[:len(s)-1]表示的含义相同的是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "ls[::-1]", "ls[:]", "ls[0:-1]", "ls[0:len(ls)]" ], "explanation": "题目中的切片ls[:len(s)-1]存在笔误，通常应为ls[:len(ls)-1]，表示从列表开头截取到倒数第二个元素。选项C的ls[0:-1]同样表示从索引0开始，到倒数第一个元素（不包含）结束，两者含义相同。选项A是逆序，B是完整复制，D是完整切片。" }, { "id": 763, "q": "下列可以导入Python模块的语句是（ ）。", "t": "single", "ans": "D", "kp": "异常与库", "o": [ "def module", "input module", "print module", "import module" ], "explanation": "Python中使用import关键字来导入模块。def用于定义函数，input用于接收用户输入，print用于输出内容，均不能用于导入模块。" }, { "id": 764, "q": "以下代码创建一个monkey对象：monkey=Animals(),调用monkey对象的name属性，下列选项正确的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "monkey:name", "monkey.name()", "monkey.name", "monkey:name()" ], "explanation": "在Python中，访问对象的属性使用点号（.）操作符。由于name是属性而非方法，调用时不需要加括号，因此正确的访问方式是monkey.name。" }, { "id": 765, "q": "如果有一个集合s，执行s.clear()方法后，集合s的长度是多少？", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "0", "1", "无法确定", "取决于集合s原来的长度" ], "explanation": "集合的clear()方法用于移除集合中的所有元素，使其变为空集合。因此执行该方法后，集合s中不再包含任何元素，其长度len(s)变为0。" }, { "id": 766, "q": "程序填空，将成绩（介于0到100之间）从百分制变换到等级制，成绩大于等于90对应A级，成绩大于等于80对应B级，成绩大于等于70对应C级，成绩大于等于60对应D级，成绩小于60对应E级。\nscore=int(input())\n  1     score > 100 or score\n   print('wrong score.must between 0 and 100.')\nelif score >=   2   :\n   print('A')\nelif score >= 80:\n   print('B')\nelif score >= 70:\n   print('C')\nelif score >= 60:       \n   print('D')\nelse:\n   print('F')", "t": "fill", "ans": "if | 90", "kp": "程序填空/调试", "o": [], "explanation": "第1空需要条件判断语句的起始关键字，结合下文的elif，此处应填if。第2空判断A级的条件，根据题意\"成绩大于等于90对应A级\"，应填90。" }, { "id": 767, "q": "在一列表中有值[1,2,3,4,5,6,7,8,9]，编写程序将所有大于5的值保存至字典的第一个key中，将小于等于5的值保存至字典的第二个key中，最终输出如下字典：\n{'result1':'大于5的所有数','result2':'小于5的所有数'}\n注意：部分源程序已给出。输入并调试程序，使程序得出正确结果不得增行或删行，也不得更改程序的结构！仅在横线上填入。\nList=[1,2,3,4,5,6,7,8,9]\nList1=[]\nList2=[]\nDicts={'result1':'','result2':''}\nfor i in ___1___:\n    if ___2___:\n        List1.append(i)\n    else:\n        List2.append(i)\nDicts['result1']=List1\nDicts['result2']=List2\nprint ('result1:{}大于5的所有数，result2:{}小于等于5的所有数'.format(List1,List2))", "t": "fill", "ans": "List | i>5", "kp": "程序填空/调试", "o": [], "explanation": "第1空需要遍历给定的列表，因此填List。第2空是判断条件，根据题意需将大于5的值存入List1，因此填i>5。" }, { "id": 768, "q": "下列Python程序的运行结果是[*queNo*]_。\na=40\nb=50\nif a>> x=7\n>>> y=5\n>>> t=x\n>>> x=y\n>>> y=t", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "x=7,y=7", "x=5,y=5", "x=7,y=5", "x=5,y=7" ], "explanation": "代码通过中间变量t实现了x和y的值交换。初始x=7，y=5；执行t=x后t为7，x=y后x为5，y=t后y为7。最终x的值为5，y的值为7。" }, { "id": 776, "q": "下面语句执行后的结果是（ ）\nprint(10,20,end=\"\")\nprint(30)", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "10,20,30", "10 2030", "10 20 30", "10 20\n30" ], "explanation": "print函数默认以空格分隔多个参数，因此10和20之间有空格。第一个print设置了end=\"\"，表示输出后不换行，因此第二个print输出的30会紧跟在20后面，最终结果为10 2030。" }, { "id": 777, "q": "下列关于Python程序格式的描述中，错误的是（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "缩进表达了所属关系和代码块的所属范围", "注释可以在一行中的任意位置开始，这一行都会作为注释不被执行", "进行赋值操作时，在运算符两边各加上一个空格可以使代码更加清晰明了", "文档注释的开始和结尾使用三重单引号\"'''\"或三重双引号\"\"\"\"\"" ], "explanation": "Python中单行注释必须以井号#开头，#及其后的内容才会被作为注释处理，而不是在任意位置开始。如果在代码或字符串中间没有#，则不会被当作注释。其他选项均符合Python语法与规范。" }, { "id": 778, "q": "以下程序的输出结果是（ ）\na,b=1,2\nprint(\"{1}{0}\".format(a,b))", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "12", "1 2", "21", "2 1" ], "explanation": "format方法中，大括号内的数字表示参数的索引，从0开始计数。{1}对应第二个参数b（值为2），{0}对应第一个参数a（值为1）。因此格式化后的字符串拼接结果为21。" }, { "id": 779, "q": "执行语句x=float(input( ))，若输入123，那么 x 的值是（ ）。", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "123.0", "\"123.0\"", "123", "程序出错" ], "explanation": "input()函数接收用户输入并返回字符串类型。float()函数将输入的字符串\"123\"转换为浮点数，因此x的值为浮点型123.0。选项B是字符串类型，选项C是整型，均不符合。" }, { "id": 780, "q": "以下代码的输出结果是（）。\nn=-5\ns=100\nif n>=5:\n   n-=10\n   s=3\nelif n==5:\n   n-=10\n   s=4\nprint(s)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "100", "4", "5", "3" ], "explanation": "初始时n=-5，s=100。判断条件n>=5为False，接着判断elif条件n==5也为False。因此if-elif语句块内的赋值代码均不执行，s的值保持初始的100不变并被打印。" }, { "id": 781, "q": "下列代码的输出结果是（）\nx=-1000\ny=0\nif not x:\n    y=1\nelse:\n    y=2\nprint(y)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "0", "1", "2", "没有输出" ], "explanation": "在Python中，非零数值在布尔上下文中被视为True。x=-1000为True，因此not x的结果为False。程序跳过if分支，执行else分支，将y赋值为2，最终输出2。" }, { "id": 782, "q": "表达式round(3.4)<3.5的值为（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "round(3.4)对3.4进行四舍五入，结果为整数3。接着计算关系表达式3 < 3.5，该条件成立，返回布尔值True。Python中的布尔值为True和False，而不是T或F。" }, { "id": 783, "q": "以下代码的输出结果是（）。\ni=300\nj=200\nk=30\nif(i<=j):\n   if(i==j):\n      print(i)\n   else:\n      print(j)\nelse:\n   print(k)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "30", "200", "300", "以上结果都不对" ], "explanation": "首先判断外层条件i<=j，即300<=200，结果为False。因此程序直接跳过if及其嵌套的内部语句，执行else分支，输出变量k的值，即30。" }, { "id": 784, "q": "身份运算符用于（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "测试两个变量是否指向同一个对象。", "测试三个变量是否指向同一个对象。", "测试变量的值。", "测试一个变量是否指向同一个对象。" ], "explanation": "Python中的身份运算符（is和is not）用于比较两个变量的内存地址，即判断它们是否引用同一个对象。它不用于比较变量的值（这是==的作用），也不用于三个或单个变量的测试。" }, { "id": 785, "q": "下面程序段的功能是求x和y中的较大数，不正确的是（ ）。", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "maxNum=x if x>y else y", "if x>y:maxNum=x\nelse:maxNum=y", "maxNum=y\nif x>y:maxNum=x", "if y>=x maxNum=y\nmaxNum=x" ], "explanation": "选项D存在明显的语法错误，if语句条件后缺少冒号，且多条语句写在同一行时未用分号分隔；逻辑上maxNum也会被无条件覆盖为x。A为条件表达式，B为常规分支结构，均可正确求较大值。" }, { "id": 786, "q": "设有程序段：\ns='*'\nfor i in range(1,6):\n      pass\n      print(s, end= '')\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "打印5行空行", "打印5个*", "打印5个:", "打印5个空格" ], "explanation": "range(1,6)生成1到5共5个数字，循环执行5次。每次循环先执行pass空操作，然后执行print输出变量s（即'*'），且end=''表示不换行。因此最终在同一行连续打印5个'*'。" }, { "id": 787, "q": "设有程序段：\ns=8\nfor i in range(1,5):\n      pass\n      print(s,end=\"\")\n则程序的运行结果是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "8", "88", "8888", "88888" ], "explanation": "range(1,5)生成1、2、3、4共4个数字，循环体执行4次。每次循环打印变量s的值8，且end=\"\"使输出不换行。因此最终在同一行连续输出4个8，结果为8888。" }, { "id": 788, "q": "以下程序执行后描述正确的是( )。\nb=1\nfor a in range(1,50):\n      if b>=9:\n            break\n      if b%3==1:\n            b+=3\n            continue\n      b-=5\nprint(a)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "2", "3", "4", "5" ], "explanation": "循环执行过程如下：a=1时，b=1，满足b%3==1，b变为4；a=2时，b=4，满足b%3==1，b变为7；a=3时，b=7，满足b%3==1，b变为10；a=4时，b=10，满足b>=9，触发break跳出循环。此时a的值为4，因此输出4。" }, { "id": 789, "q": "以下代码的输出结果是（ ）。\nlis=[1,2,3,4,5]\nfor s in lis:\n    s=10\nprint(s)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "3", "4", "10", "5" ], "explanation": "for循环遍历列表lis，在每次迭代中，循环变量s都会被重新赋值为10。当循环结束时，s保留最后一次迭代所赋的值，即10。因此最终打印输出的结果为10。" }, { "id": 790, "q": "下列循环语句的循环体执行次数为        。\nfor t in range(0,1):\nfor i in range(-3,21,4):\n         循环体", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "3", "1", "6", "7" ], "explanation": "外层循环range(0,1)只包含元素0，执行1次；内层循环range(-3,21,4)包含-3, 1, 5, 9, 13, 17共6个元素，执行6次。内外层循环嵌套，循环体总共执行1×6=6次。" }, { "id": 791, "q": "如果需要将小写字母化为大写字母，需要使用的方法是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "upper", "lower", "title", "capitalize" ], "explanation": "在Python中，字符串的upper()方法用于将所有小写字母转换为大写字母。lower()用于转为小写，title()将每个单词首字母大写，capitalize()仅将字符串第一个字符大写。" }, { "id": 792, "q": "s=\"abcdef\"，则s[:-1]表示（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "f", "fedcba", "abcde", "语法错误" ], "explanation": "字符串切片s[:-1]表示从索引0开始，到倒数第一个字符（不包含该字符）结束。因此它会截取除最后一个字符'f'之外的所有字符，结果为'abcde'。" }, { "id": 793, "q": "s=\"teacher\", 能够显示输出teacher 的选项是：（ ）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "print(s[0:-1])", "print(s[-1:0])", "print(s[:])", "print(s[:6])" ], "explanation": "选项C的s[:]表示从头到尾截取整个字符串，能完整输出'teacher'。选项A和D的切片均不包含最后一个字符，输出'teache'；选项B步长默认为正，起始索引大于结束索引，输出空字符串。" }, { "id": 794, "q": "表达式 ('a','b',[1,2])<('a','b',[1,3]) 的值是（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "true", "false", "True", "False" ], "explanation": "元组比较按元素逐个进行。前两个元素'a'和'b'相等，接着比较第三个元素[1,2]和[1,3]。列表比较同样逐个进行，1等于1，2小于3，因此[1,2]<[1,3]成立，结果为True。注意Python中布尔值首字母大写。" }, { "id": 795, "q": "以下方法中，不属于列表的是（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "append()", "find()", "count()", "index()" ], "explanation": "find()是字符串对象的方法，用于查找子串并返回索引，不属于列表方法。列表的常用方法包括append()添加元素、count()统计元素出现次数、index()查找元素索引等。" }, { "id": 796, "q": "以下代码的输出是什么？\ns = set([1, 2, 3])\ns.remove(4)\nprint(s)", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "{1, 2, 3}", "{1, 2}", "{1, 3}", "KeyError" ], "explanation": "集合的remove()方法用于移除指定元素。如果尝试移除的元素不存在于集合中，程序会抛出KeyError异常。若希望元素不存在时不报错，应使用discard()方法。" }, { "id": 797, "q": "以下关于字典操作的描述，错误的是：( )。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "keys 方法可以获取字典的值列表", "get方法用于获取指定键对应的值", "len 方法可以计算字典中键值对的个数", "del 用于删除字典或者元素" ], "explanation": "字典的keys()方法用于获取字典的所有键，而不是值列表；获取值列表应使用values()方法。get()获取指定键的值，len()计算键值对数量，del可删除字典或元素，B、C、D描述均正确。" }, { "id": 798, "q": "以下关于函数说法正确的是（ ）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "函数的实际参数和形式参数必须同名，顺序一致", "函数的形式参数既可以是变量也可以是常量", "函数的实际参数不可以是表达式", "函数的实际参数可以是其他函数的调用" ], "explanation": "函数的实际参数可以是常量、变量、表达式或其他函数的调用。形式参数只能是变量，不能是常量。此外，实参和形参不需要同名，只需在调用时按位置或关键字正确传递即可。" }, { "id": 799, "q": ".以下程序代码的运行结果正确的是（ ）。\na=10\nb=2\ndef fun(c):\n    global b\n    a=20\n    b=4\n    b=b+c\nfun(5)\nprint(\"{},{}\".format(a,b))", "t": "single", "ans": "C", "kp": "函数", "o": [ "20,9", "10,7", "10,9", "20,7" ], "explanation": "函数内使用global声明b为全局变量，因此全局b被修改为4，随后b=b+c计算得到9。而a在函数内未声明global，a=20创建的是局部变量，不影响全局变量a（仍为10）。最终输出10,9。" }, { "id": 800, "q": "下列程序的运行结果是（ ）。\nf=lambda y:y**2\nprint(f(f(3)))", "t": "single", "ans": "D", "kp": "函数", "o": [ "6", "9", "3", "81" ], "explanation": "本题考查lambda匿名函数及嵌套调用。首先计算内层f(3)，即3的平方等于9；然后计算外层f(9)，即9的平方等于81。因此最终输出结果为81。" }, { "id": 801, "q": "执行以下代码的结果是（ ）。\ndef fun(param1,*param2):\n    print(param2)\nfun('wang','zhang','li','liu')", "t": "single", "ans": "B", "kp": "函数", "o": [ "'zhang'", "('zhang','li','liu')", "['zhang','li','liu']", "param2" ], "explanation": "本题考查可变参数*args的使用。函数定义中*param2会将多余的实参收集为一个元组。调用时'wang'赋给param1，剩余的'zhang','li','liu'被打包成元组赋给param2并打印。" }, { "id": 802, "q": "如下所示程序片段中：\nclass Myclass:\n      x=30\n      __x=1\n以下说法正确的是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "x是私有属性", "__x是私有属性", "x是实例属性", "__x是实例属性" ], "explanation": "本题考查类的属性访问控制。在Python中，以双下划线__开头的属性（如__x）会被名称改写，实现私有化，不能在类外部直接访问，因此__x是私有属性。x是普通的类属性。" }, { "id": 803, "q": "面向对象程序设计的三要素不包含（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "封装", "公有", "继承", "多态" ], "explanation": "本题考查面向对象编程的基本概念。面向对象程序设计的三大基本特征是封装、继承和多态。\"公有\"是访问控制修饰符的概念，不属于面向对象的三要素。" }, { "id": 804, "q": "下列程序的执行结果是（）\nclass C():\n f=50\nclass C1(C):\n pass\nprint(C.f,C1.f)", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "50 50", "50 pass", "pass 50", "运行出错" ], "explanation": "类C中定义了类属性f=50，C1继承自C且没有重新定义f，因此C1可以通过继承访问父类属性。C.f的值为50，C1.f的值也为50，最终输出50 50。" }, { "id": 805, "q": "以下关于文件的描述中，正确的是（ ）", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "使用open()打开文件时，必须要用r或w指定打开方式，不能省略", "采用readlines()可以读入文件中的全部文本，返回一个列表", "文件打开后，可以用write()控制对文件内容的读写位置", "如果没有采用close()关闭文件，Python程序退出时文件将不会自动关闭" ], "explanation": "本题考查文件操作。A错，open()默认模式为'r'可省略；B对，readlines()读取所有行并返回字符串列表；C错，seek()才用于控制读写位置；D错，程序退出时Python会自动关闭未关闭的文件。" }, { "id": 806, "q": "可以使用Python以只读方式打开一个名为\"file.txt\"的文件的选项是（ ）。", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "open(\"file.txt\")", "open(\"file.txt\",\"r\")", "open(\"file.txt\",\"w\")", "open(file.txt\",\"a\")" ], "explanation": "本题考查open()函数的模式参数。'r'表示只读模式（默认），'w'表示写入模式，'a'表示追加模式。选项B明确使用'r'指定只读方式，符合题意。" }, { "id": 807, "q": "请给出以下代码段的正确结果（）\nA = {28, 31, 46, 90, 95}\nB = {4, 13, 35, 51, 56}\nC = {3, 8, 15, 80, 92}\nD = (A - B) & (B - C) | (C - A)\nD.update({8, 9, 10})\nprint(D)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{3, 8, 9, 10, 15, 80, 92}", "{8, 9, 10, 28, 31, 46, 90, 95}", "{8, 9, 10}", "{3, 8, 9, 10, 15, 80}" ], "explanation": "本题考查集合运算。A、B、C三个集合互不相交。A-B为A，B-C为B，两者交集为空集。C-A为C。空集与C的并集为C。最后对集合D使用update方法添加8、9、10，由于8已存在，最终结果为{3, 8, 9, 10, 15, 80, 92}。" }, { "id": 808, "q": "求数列的和。请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。注意:不得增行或删行，也不得更改程序的结构！\nsum=____1___\nfor i in range(101):\n       sum=sum+____2_____\nprint(\"数列的和的结果为\",sum)", "t": "fill", "ans": "0 | 1/(1+5*i)", "kp": "程序填空/调试", "o": [], "explanation": "本题考查循环求和。第1空初始化累加变量sum，应填0；第2空为循环体内的累加项，根据答案可知数列通项为1/(1+5*i)，故填1/(1+5*i)。注意Python 3中除法默认返回浮点数。", "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-sequence-formula-808.png" }, { "id": 809, "q": "有以下程序代码：定义一个Student类，类中定义一个say方法，并在其中创建一个name实例属性，赋值后输出。请填空将程序补充完整。\n____1_____ Student:\n    ___2____ say(self,name):\n        self.name=_____3___\n        print(\"我是\",self.name)", "t": "fill", "ans": "class | def | name", "kp": "程序填空/调试", "o": [], "explanation": "本题考查类的定义与实例属性。第1空定义类，需使用class关键字；第2空定义类中的方法，需使用def关键字；第3空将传入的参数name赋值给实例属性self.name，故填name。" }, { "id": 810, "q": "下列程序的输出结果是（ ）。\ns=1\nfor i in range(1,6):\n    while True:\n        if i%2==0:\n            break\n        else:\n            s*=i\n            break\nprint(s)", "t": "fill", "ans": "15", "kp": "循环结构", "o": [], "explanation": "本题考查循环与条件判断。i从1到5遍历。当i为偶数时，内层if触发break跳出while，s不变；当i为奇数(1,3,5)时，执行s*=i并break跳出while。因此s = 1 * 1 * 3 * 5 = 15。" }, { "id": 811, "q": "以下程序的运行结果是[*queNo*]_______。\ns='abcab'\nlst=[]\nfor c in s:\n    if c.isalpha():\n        if c not in lst:\n            lst.append(c)\nlst.sort()\nprint(lst)", "t": "fill", "ans": "['a','b','c']", "kp": "列表/元组", "o": [], "explanation": "本题考查字符串遍历与列表去重排序。遍历字符串'abcab'，将不重复的字母依次加入lst，得到['a', 'b', 'c']。最后调用sort()方法按字母顺序排序，输出结果为['a', 'b', 'c']。" }, { "id": 812, "q": "生成一个字典D，其键形式为keyi的字符串，其中i为表示整数的十进制数字串，取值范围为1-10，每个键对应的值为i*i，例如，key5:25。请填空。\nD={}\nfor i in range(1,11):\n    k=\"key\"+str(i)\n    D[k]=_____1_____\nprint(D)", "t": "fill", "ans": "i*i", "kp": "字典/集合", "o": [], "explanation": "第1空需要填入字典键对应的值，根据题意每个键对应的值为i*i，因此填入i*i计算当前循环变量i的平方并赋值给字典D的键k。" }, { "id": 813, "q": "以下count函数的功能是统计字符串s中大写字符出现的次数并将统计结果返回。若字符串为“WowY56arHRmy”,则大写字符个数为4。请在括号（）中填入正确答案。\n(__1__) count(a):\n    t=0\n    for n in (__2__):\n        if n>='A' and n<='Z':\n            t+=1\n    return t\nn=input(\"请输入字符串:\")\nprint(count(n))", "t": "fill", "ans": "def | a", "kp": "函数", "o": [], "explanation": "第1空定义函数需使用关键字def；第2空遍历字符串参数，函数定义时参数名为a，因此使用a进行遍历，逐个判断字符是否为大写字母。" }, { "id": 814, "q": "下列程序的输出结果是        。\ncount=1\nnum=0\ndef Test():\n    global count\n    for i in (1,2,3,4,5): count+=i\nTest()\nprint(count)", "t": "fill", "ans": "16", "kp": "函数", "o": [], "explanation": "函数内使用global声明全局变量。循环遍历元组(1,2,3,4,5)，将i累加到count中。初始count为1，累加和为15，最终count为16。" }, { "id": 815, "q": "以下程序段的运行结果是[*queNo*]_。\nclass Test:\n    count=21\n    def print_num(self):\n        count=20\n        self.count+=20\n        print(count)\ntest=Test()\ntest.print_num()", "t": "fill", "ans": "20", "kp": "面向对象", "o": [], "explanation": "类属性count为21。方法内定义局部变量count=20。self.count修改的是实例属性，不影响局部变量。最后print输出局部变量count的值20。" }, { "id": 816, "q": "打开文件对文件进行读写，操作完成后应该调用____方法关闭文件，以释放资源。", "t": "fill", "ans": "close()", "kp": "文件操作", "o": [], "explanation": "文件操作完成后，必须调用close()方法来关闭文件，释放系统资源，防止文件损坏或内存泄漏。" }, { "id": 817, "q": "下列Python程序的运行结果是[*queNo*]_。\na=400\nb=50\nc=0\nif a>b:\n    a=b\nc=a\nb=c\nprint(c)", "t": "fill", "ans": "50", "kp": "分支结构", "o": [], "explanation": "初始a=400, b=50。判断a>b成立，执行a=b，此时a变为50。接着执行c=a，c变为50。最后b=c，b变为50。打印c的值，结果为50。" }, { "id": 818, "q": "在考生文件夹下有个文件PY101.py，在横线处填写代码，完成如下功能。接收用户输入的一个小于20的正整数，在屏幕上逐行递增显示从01到该正整数，数字显示的宽度为2，不足位置补0，后面追加一个空格，然后显示'>'号，'>'号的个数等于行首数字。例如：\n输入：\n3\n输出：\n01>\n02>>\n03>>>\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "n = input('请输入一个正整数:')\nfor i in range(int(n)):\nprint('{:0>2}{}'.format(i+1,\">\"*(i+1) ))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 819, "q": "考生文件夹下存在一个文件PY103.py，请写代码替换横线，不修改其他代码，实现以下功能：\n键盘输入一个9800到9811之间的正整数n，作为Unicode编码，把n-1、n和n+1三个Unicode编码对应字符按照如下格式要求输出到屏幕：宽度为11个字符，加号字符+填充，居中。\n例如：键盘输入：9802 屏幕输出：++++???++++\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "n = eval(input(\"请输入一个数字:\"))\nprint(\"{:+^11}\".format(chr(n-1)+chr(n)+chr(n+1)))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 820, "q": "在考生文件夹下有个文件PY201.py，在横线处填写代码，完成如下功能。利用random库和turtle库，在屏幕上绘制5个圆圈，圆圈的半径和画圆起始点的坐标由randint()函数产生，画圆起始点的X和Y坐标范围在[-100,100]之间；半径的大小范围在[20,50]之意，圆圈的颜色随机在color列表里选择。效果如下图所示。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import turtle as t #对turtle库中函数调用采用更简洁的形式\nimport random as r\ncolor = ['red','orange','blue','green','purple']\nr.seed(1)\nfor i in range(5):\nrad = r.randint(20,50) #在[20,50]之间生成一个半径值\nx0 = r.randint(-100,100)\ny0 = r.randint(-100,100)\nt.color(r.choice(color))\nt.penup() #提起画笔\nt.goto(x0,y0) #移到绝对坐标处\nt.pendown() #放下画笔\nt.circle(rad)\nt.done()", "kp": "random/turtle等标准库", "o": [], "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-turtle-random-circles-820.png", "rawType": "operation" }, { "id": 821, "q": "Python程序文件的扩展名是（ ）。", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ ".python", ".pyt", ".pt", ".py" ], "explanation": "Python源代码文件的标准扩展名是.py，这是Python解释器识别并执行脚本的默认后缀。" }, { "id": 822, "q": "Python程序采用Unicode编码，英文字符和中文字符在Python中分别对应字符的个数是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "1:1", "1:2", "2:1", "2:2" ], "explanation": "Python 3采用Unicode编码，无论是英文字符还是中文字符，在字符串中都被视为一个独立的字符，长度均为1，因此个数比例为1:1。" }, { "id": 823, "q": "表达式4*5/2**3的值为（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "2.5", "1000", "1000.0", "30" ], "explanation": "表达式中先计算幂运算2**3得8，再计算乘法4*5得20，最后计算浮点除法20/8得2.5。注意/执行的是浮点除法。" }, { "id": 824, "q": "以下是print(type(1+2j))的运行结果的是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "", "", "", "" ], "explanation": "1+2j为复数类型，type()函数会返回。由于题目选项内容缺失，根据给定答案选C。" }, { "id": 825, "q": "某水果店出售水果套装礼盒，每盒299元，1盒不打折，2~4盒打8折，5~8盒打6折，9盒以上打5折。用户输入购买数量，计算并输出价格总额（保留整数）。请完善代码。\nn=eval(input(\"请输入水果礼盒数量：\"))\nif n==1:\n    cost = 299\nelif n <= 4:\n    cost = n * 299 * 0.8\nelif n <= 8:\n    cost = n * 299 * 0.6\nelse:\n    cost = n * 299 * 0.5\ncost = ___(cost)\nprint(\"总额为：{}元\".format( ___ ))", "t": "fill", "ans": "int | cost", "kp": "程序填空/调试", "o": [], "explanation": "第1空要求保留整数，使用int()函数对浮点数cost进行取整转换；第2空在format格式化字符串中填入变量cost以输出计算后的总额。" }, { "id": 826, "q": "下列程序运行的结果是什么？\ndef calculate_average(numbers):\n    total = sum(numbers)\n    average = total / len(numbers)\n    return average\nnumbers = [1, 2, 3, 4, 5, 6]\nresult = calculate_average(numbers)\nprint(result)", "t": "fill", "ans": "3.5", "kp": "函数", "o": [], "explanation": "函数计算列表元素平均值。列表元素总和为21，长度为6。21除以6等于3.5，函数返回该浮点数结果并打印输出。" }, { "id": 827, "q": "在Python语言中，不能作为变量名的是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "dict_1", "List1", "_python12", "6me" ], "explanation": "Python变量名必须以字母或下划线开头，不能以数字开头。选项A、B、C均符合命名规则，而选项D以数字6开头，因此不能作为变量名。" }, { "id": 828, "q": "以下代码的输出结果是（）。\na=20\nb=3\nif a=b:\n   c= b\nprint(c)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "2", "3", "True", "报错" ], "explanation": "Python中条件判断应使用`==`，`if a=b:`会引发语法错误。但根据答案B推测，出题人可能误用了C语言逻辑，认为赋值表达式`a=b`返回3（真），从而执行`c=b`，最终输出3。实际Python运行会报错。" }, { "id": 829, "q": "表达式56//10>5.6的值为（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "`//`是整除运算符，`56//10`的结果为整数5。接着比较`5>5.6`，显然不成立，因此表达式的值为布尔值False。选项A和D不是Python合法的布尔值表示。" }, { "id": 830, "q": "以下代码的输出结果是（）。\nn=5\ns=10\nif n<=5:\n    n-=10\n    s=2\ns=30\nprint(s)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "30", "2", "10", "50" ], "explanation": "初始`n=5`，满足`n<=5`条件，执行缩进块内的`n-=10`和`s=2`。但随后执行了非缩进的`s=30`，覆盖了之前的值。最后打印`s`，结果为30。" }, { "id": 831, "q": "下列代码的输出结果是（ ）。\nx=tuple()\ny=0\nwhile x:\n     y+=1\nprint(y)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0", "1", "没有输出", "出错" ], "explanation": "`tuple()`创建一个空元组，在布尔上下文中空元组被视为False。因此`while x:`条件一开始就不成立，循环体不执行，`y`保持初始值0，最终输出0。" }, { "id": 832, "q": "已知s=\"Python\",执行print(s.center(20,\"*\"))的输出结果是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "*******Python*******", "Pyt20*hon", "*********20*********", "2*0" ], "explanation": "`center(width, fillchar)`方法将字符串居中，并使用指定字符填充至指定宽度。字符串\"Python\"长度为6，目标宽度20，需填充14个\"*\"，左右各7个。因此输出为7个*加Python加7个*。" }, { "id": 833, "q": "设s=\"Python Programming\"，那么print(s[-5:])的结果是（ ）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "mming", "Python", "mmin", "Pytho" ], "explanation": "字符串切片`s[-5:]`表示从倒数第5个字符开始截取到字符串末尾。字符串\"Python Programming\"倒数5个字符是\"mming\"，因此输出结果为\"mming\"。" }, { "id": 834, "q": "已知tup=tuple(i*2 for i in 'blue')，执行print(tup) 后输出结果是（ ）", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "('bb', 'll', 'uu', 'ee')", "('blue','blue')", "'bb', 'll', 'uu', 'ee'", "['bb', 'll', 'uu', 'ee']" ], "explanation": "生成器表达式`i*2 for i in 'blue'`会遍历字符串'blue'的每个字符并将其重复两次，生成'bb', 'll', 'uu', 'ee'。`tuple()`将其转换为元组，因此输出带括号的元组形式。" }, { "id": 835, "q": "程序填空。程序功能：求出两个数的较小值\na,b,c=4,5,0\nif  a  1   b:\n    c=b\nif a\n       2   \nprint(c)", "t": "fill", "ans": "> | c=a", "kp": "程序填空/调试", "o": [], "explanation": "程序求较小值。第1空：若a大于b，则较小值为b，故填`>`。第2空：若a不大于b，则较小值为a，将a赋值给c，故填`c=a`。最终打印c即为较小值。" }, { "id": 836, "q": "下列Python程序的运行结果是[*queNo*]_。\ni=3000\nj=400\nk=500\nif (ib):\n    a=b\n    b=c\nc=a\nprint(a,b,c)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "7 5 7", "5 3 5", "7 3 7", "5 3 7" ], "explanation": "初始a=7,b=5,c=3。条件a>b成立，执行if块内语句：a被赋值为b的值5，b被赋值为c的值3。随后执行c=a，此时a为5，故c被赋值为5。最终a,b,c的值分别为5,3,5。" }, { "id": 841, "q": "以下while语句中的表达式\"not E\"等价于（）。\nwhile not E:\n    pass", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "E==0", "E!=1", "E!=0", "E==1" ], "explanation": "在Python中，`not E`为真意味着E的布尔值为False。在数值类型中，0的布尔值为False，非0为True。因此`not E`等价于判断E是否等于0，即`E==0`。" }, { "id": 842, "q": "下列程序的输出结果是（）。\ns=2\nfor i in [2,3,4]:\n      s*=i\nprint(s)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "4", "12", "48", "0" ], "explanation": "初始s=2。循环遍历列表[2,3,4]：第一次i=2，s=2*2=4；第二次i=3，s=4*3=12；第三次i=4，s=12*4=48。循环结束后输出48。" }, { "id": 843, "q": "L.reverse()和L[-1:-1-len(L):-1]的主要区别是（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "L.reverse()和L[-1:-1-len(L):-1]都将列表的所有元素反转排列，没有区别", "L.reverse()和L[-1:-1-len(L):-1]都不会改变列表L原来内容", "L.reverse()不会改变列表L的内容，而L[-1:-1-len(L):-1]会改变列表L原来内容", "L.reverse()会改变列表L的内容，而L[-1:-1-len(L):-1]产生一个新列表，不会改变列表L原来内容" ], "explanation": "`L.reverse()`是列表的内置方法，直接在原列表上进行就地反转，不返回新列表；而切片操作`L[-1:-1-len(L):-1]`会生成并返回一个元素顺序反转的新列表，原列表L的内容保持不变。" }, { "id": 844, "q": "tuple(range(5))的返回结果是( )。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "(0, 1, 2, 3, 4)", "(0, 1, 2, 3, 4, 5)", "[0, 1, 2, 3, 4]", "[0, 1, 2, 3, 4, 5]" ], "explanation": "`range(5)`生成从0到4的整数序列。`tuple()`函数将该序列转换为元组，因此结果为包含0到4的元组`(0, 1, 2, 3, 4)`。选项C和D是列表格式，选项B包含了5，均错误。" }, { "id": 845, "q": "以下程序代码的运行结果正确的是（ ）。\nd1={'A':1,'B':2,'C':3}\ndef sum():\n    d1={'M':1,'N':2,'P':3}\n   \n    d2={'D':4,'F':5}\n    d1.update(d2)\nsum( )\nprint('{}'.format(d1))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{'M':1,'N':2,'P':3}", "{'A':1,'B':2,'C':3}", "{'M':1,'N':2,'P':3,'D':4,'F':5}", "{'A':1,'B':2,'C':3,'D':4,'F':5}" ], "explanation": "函数`sum()`内部对`d1`进行了重新赋值，这使得`d1`成为函数内的局部变量，其修改不会影响全局变量`d1`。因此，调用`sum()`后，全局的`d1`依然保持初始值`{'A':1,'B':2,'C':3}`。" }, { "id": 846, "q": "以下程序运行后输出的结果是（ ）。\ndef fun(p1,p2,*p3):\n      print(p3)\nfun('my','name','is','xiao','hua')", "t": "single", "ans": "A", "kp": "函数", "o": [ "('is', 'xiao', 'hua')", "('my','name','is')", "('my','name')", "('my','name','is','xiao','hua')" ], "explanation": "函数定义中`*p3`用于接收多余的位置参数，并将其打包为一个元组。调用时，'my'和'name'分别赋值给p1和p2，剩余的'is', 'xiao', 'hua'被打包成元组赋值给p3，因此输出为`('is', 'xiao', 'hua')`。" }, { "id": 847, "q": "以下程序的运行结果是（ ）。\nss=[\"rotator\",\"madam\",\"level\",\"tune\",\"racecar\",\"time\",\"radar\"]\ns=0\nfor i in ss:\n    if i==i[::-1]:\n        s+=1\nprint(s)", "t": "fill", "ans": "5", "kp": "循环结构", "o": [], "explanation": "程序遍历列表ss中的每个字符串，利用切片`[::-1]`将其反转并与原字符串比较。若相等则说明是回文字符串，计数器s加1。列表中\"rotator\"、\"madam\"、\"level\"、\"racecar\"和\"radar\"共5个回文串，故输出5。" }, { "id": 848, "q": "请阅读下面的程序, 最终输出的结果为：[*queNo*]____。\ntup1 = (12,'ab',34)\ntup2 = ('cd',56,'ef')\ntup3 = tup1 + tup2\nprint(tup3[2])", "t": "fill", "ans": "34", "kp": "列表/元组", "o": [], "explanation": "元组相加`tup1 + tup2`会生成一个新元组，内容为`(12, 'ab', 34, 'cd', 56, 'ef')`。索引从0开始，`tup3[2]`访问的是新元组的第3个元素，即34。" }, { "id": 849, "q": "关于Python 的分支结构，以下选项中描述错误的是（） 。", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "Python 中 if-elif-else 语句描述多分支结构", "分支结构使用 if 保留字", "Python 中 if-else 语句用来形成二分支结构", "分支结构可以向已经执行过的语句部分跳转" ], "explanation": "Python的分支结构（如if-elif-else）用于根据条件执行不同的代码块，程序按顺序执行，不支持像C语言中goto语句那样向已经执行过的语句部分跳转。选项A、B、C均正确描述了Python分支结构的特点。" }, { "id": 850, "q": "以下程序的运行结果是（ ）。\nm=1\nfor i in range(1,3):\n    if i*m>3:\n        break\n    m*=i\nprint(\"m=\",m)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "m=2", "m=5", "m=6", "m=4" ], "explanation": "初始m=1。循环i从1到2：当i=1时，1*1>3不成立，执行m=1*1=1；当i=2时，2*1>3不成立，执行m=1*2=2。循环结束，最终输出m=2。" }, { "id": 851, "q": "表达式:\"4\"+5的结果是（）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "9", "\"9\"", "\"45\"", "出错" ], "explanation": "Python中字符串和整数属于不同数据类型，不能直接使用加号进行拼接或数学运算，执行时会抛出TypeError类型错误。" }, { "id": 852, "q": "len(range(1, 10))的值是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "8", "9", "10", "11" ], "explanation": "range(1, 10)生成从1开始到9结束的整数序列，不包含结束值10。该序列共包含9个整数，因此len()函数返回9。" }, { "id": 853, "q": "以下代码的输出结果是（ ）。\nls=[i*2 for i in 'python']", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "[2,4,6,8,10,12]", "python python", "错误", "['pp', 'yy', 'tt', 'hh', 'oo', 'nn']" ], "explanation": "列表推导式遍历字符串'python'中的每个字符，表达式i*2对字符串进行重复操作，将每个字符重复两次，最终生成包含双字符字符串的列表。" }, { "id": 854, "q": "Python 语句 print(type({1,2,3,4}))的输出结果是（ ）。", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "", "", "", "" ], "explanation": "{1,2,3,4}使用花括号且无键值对，表示集合（set）。type()函数会输出。但本题选项内容缺失，无法对应具体选项。" }, { "id": 855, "q": "有以下函数定义：\ndef myfun(a,b):\n      return a+b\n以下说法中错误的是（）", "t": "single", "ans": "B", "kp": "函数", "o": [ "函数名为myfun", "a和b是实参", "该函数功能是求两个数的和", "该函数返回一个数值" ], "explanation": "在函数定义def myfun(a,b)中，a和b是形式参数（形参），用于接收调用时传递的实际参数（实参）。因此称a和b为实参是错误的。" }, { "id": 856, "q": "基类也称为（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "超类", "派生类", "子类", "类实例" ], "explanation": "在面向对象编程中，基类是指被继承的类，也称为父类或超类。而派生类和子类是指继承基类的新类，类实例则是类的具体对象。" }, { "id": 857, "q": "程序阅读题\n阅读下列程序给出result打印的结果：\ndef remove_duplicates(numbers):\nunique_numbers = list(set(numbers))\nreturn unique_numbers\nnumbers = [1,2,3,3,4,4,5]\nresult = remove_duplicates(numbers)\nprint(result)", "t": "fill", "ans": "[1,2,3,4,5]", "kp": "函数", "o": [], "explanation": "函数内部先使用set()将列表转换为集合以去除重复元素，再用list()将集合转回列表。由于小整数哈希特性，转换后的列表通常保持[1,2,3,4,5]的顺序。" }, { "id": 858, "q": "以下关于Python字符编码的描述中，正确的是（）", "t": "single", "ans": "B", "kp": "字符串", "o": [ "Python字符编码使用ASCII编码存储", "chr(x)和ord(x)函数用于在单字符和Unicode编码值之间进行转换", "chr('a')的值为97", "ord(65)的值为A" ], "explanation": "Python 3默认使用Unicode编码。chr(x)将整数编码值转为字符，ord(x)将字符转为编码值。chr和ord的参数类型分别为整数和单字符，故C、D错误。" }, { "id": 859, "q": "以下关于随机运算函数库的描述，正确的是（ ）。", "t": "single", "ans": "C", "kp": "random/turtle等标准库", "o": [ "random(a,b)产生一个(a,b)之间的随机小数", "random库产生的随机数是完全随机的", "random.seed()函数初始化随机数种子，是为了可以重复再现随机数序列", "Python的random库是内置库，随Python一起发布" ], "explanation": "random库生成的是伪随机数；没有random(a,b)函数；random属于标准库而非内置库。random.seed()用于初始化种子，确保每次运行生成相同的随机数序列。" }, { "id": 860, "q": "执行语句x=eval(input( ))，若输入2*3，那么 x 的值是（ ）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "2*3", "6", "“2*3”", "程序出错" ], "explanation": "input()函数接收用户输入并返回字符串\"2*3\"。eval()函数会将字符串作为Python表达式进行解析和计算，因此\"2*3\"被计算为整数6并赋值给x。" }, { "id": 861, "q": "下面的代码在运行时输入“1”，则输出结果是（）。\nx=input()\nif x== '1':\n   print('1')\nelif x== '2':\n   print('2')\nelif x== '3':\n   print('3')\nelse:\n   print('4')", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "1", "2", "3", "4" ], "explanation": "input()函数获取的输入默认为字符串类型。输入\"1\"后，变量x的值为字符串'1'，满足第一个if条件x=='1'，因此执行print('1')输出1。" }, { "id": 862, "q": "以下关于Python语言的描述中，正确的是（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "条件5>=4>=3是合法的，输出False", "条件5>=4>=3是不合法的", "条件5>=4>=3是合法的，输出True", "条件5>=4>=3是不合法的，输出异常" ], "explanation": "Python支持链式比较运算符，条件5>=4>=3在底层等价于5>=4 and 4>=3。因为5大于等于4且4大于等于3，两个子条件均为真，最终结果为True。" }, { "id": 863, "q": "以下代码的输出结果是（）。\nn=50\ns=10\nif n<=5:\n    n-=10\n    s=2\n    s=30\nprint(s)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "30", "20", "10", "报错" ], "explanation": "初始时n=50，s=10。条件判断n<=5为False，因此不执行if语句块内的代码，变量s的值保持不变。最后打印s，输出结果为10。" }, { "id": 864, "q": "以下代码的输出结果是（ ）。\nfor s in range(6):\n    if s==4:\n        break\ns=10\nprint(s)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "3", "4", "10", "5" ], "explanation": "循环遍历0到5，当s等于4时触发break跳出循环。但跳出循环后，紧接着执行了赋值语句s=10，覆盖了循环变量s的值。最后打印s，输出结果为10。" }, { "id": 865, "q": "下列代码的运行结果是（ ）。\nfact=lambda x,y,z:pow(x,y,z)\nprint(fact(2,3,5))", "t": "single", "ans": "C", "kp": "函数", "o": [ "8", "0", "3", "输出不确定值" ], "explanation": "lambda定义了一个匿名函数，调用内置函数pow(x, y, z)，其功能是计算x的y次方对z取模。代入参数即计算2的3次方（8）对5取模，结果为3。" }, { "id": 866, "q": "下列程序的输出结果是（ ）。\nf=open('f.txt','w')\nf.writelines(['Python programming.'])\nf.close()\nf=open('f.txt','rb')\nf.seek(10,1)\nprint(f.tell())", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "1", "10", "gramming", "Python" ], "explanation": "首先以写模式创建文件并写入字符串。接着以二进制读模式打开文件。f.seek(10, 1)表示从当前位置（文件开头，偏移量为0）向后移动10个字节。f.tell()返回当前文件指针位置，因此输出10。" }, { "id": 867, "q": "使用多分支选择结构将成绩从百分制变换到等级制(score >= 90对应A，score >= 80对应B，score >= 70对应C，score >= 60对应D ，score 100 __1___ score =90:\n    print('A')\nelif score >= 80:\n    __2___\nelif score >= 70:\n    print('C')\nelif score >= 60:\n    print('D')\nelse:\n    print('E')", "t": "fill", "ans": "or | print('B')", "kp": "程序填空/调试", "o": [], "explanation": "第1空用于连接两个条件表达式，根据答案应填入逻辑运算符or。第2空对应成绩大于等于80的分支处理，需要打印等级B，因此填入print('B')。" }, { "id": 868, "q": "下列程序运行的结果是什么？\ndef get_common_keys(dict1, dict2):\n    set1 = set(dict1.keys())\n    set2 = set(dict2.keys())\n    common_keys = set1.intersection(set2)\n    return common_keys\ndict1 = {'a': 1, 'b': 2, 'c': 3}\ndict2 = {'b': 4, 'c': 5, 'd': 6}\nresult = get_common_keys(dict1, dict2)\nprint(result)", "t": "fill", "ans": "{'b','c'}", "kp": "字典/集合", "o": [], "explanation": "函数将两个字典的键分别转换为集合，然后使用intersection()方法求交集。dict1的键为'a','b','c'，dict2的键为'b','c','d'，两者的交集为'b'和'c'，因此输出包含这两个元素的集合。" }, { "id": 869, "q": "以下found函数的功能是是用递归方法计算学生的年龄，已知第一位学生年龄最小，为6岁，其余学生一个比个大3岁，求第6位学生的年龄。请在括号（）中填入正确答案。\ndef found(x):\n    if x==1:\n        _____1___\n    else:\n        y=_____2___\n    return y\ns=found(6)\nprint(\"第6个学生年龄为\",s)", "t": "fill", "ans": "y=6 | found(x-1)+3", "kp": "程序填空/调试", "o": [], "explanation": "第1空是递归的基线条件，已知第一位学生年龄为6岁，故填y=6。第2空是递归推导，其余学生比前一个大3岁，因此第x位学生的年龄为found(x-1)+3。" }, { "id": 870, "q": "以下程序的输出结果是[*queNo*]_。\nx=15\ndef fun(n):\n    x=3\n    k=2\n    for i in range(n):\n        k+=x+i\n    return k\nh=fun(6)\nprint(h)", "t": "fill", "ans": "35", "kp": "函数", "o": [], "explanation": "调用fun(6)时，局部变量x=3，k=2。循环执行6次（i从0到5），每次k累加x+i。累加总和为6*x + (0+1+2+3+4+5) = 18 + 15 = 33。初始k=2，最终k = 2 + 33 = 35。" }, { "id": 871, "q": "下面代码的输出结果是（）。\na=5\nb=6\nc=7\nprint(pow(b,2)-4*a*c）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "104", "系统报错", "-104", "36" ], "explanation": "表达式计算b的平方减去4ac的值。pow(6,2)结果为36，4*5*7结果为140，两者相减得到-104。" }, { "id": 872, "q": "下面代码的输出结果是（）。\nx=10\ny=3\nprint(x**y)", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "13", "300", "30", "1000" ], "explanation": "**是Python中的幂运算符。x**y表示计算x的y次方，即10的3次方，结果为1000。" }, { "id": 873, "q": "下列程序的运行结果是（ ）。\nx=y=10\nx,y,z=6,x+1,x+2\nprint(x,y,z)", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "10 10 6", "6 10 10", "6 7 8", "6 11 12" ], "explanation": "多重赋值时，等号右侧的表达式会先被计算。此时x为10，因此右侧元组为(6, 11, 12)。随后将这些值分别赋给x, y, z。最后打印输出6 11 12。" }, { "id": 874, "q": "在屏幕上打印输出Hello World，使用的Python语句是（）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "printf('Hello World')", "print(Hello World)", "print(\"Hello World\")", "printf(\"Hello World\")" ], "explanation": "Python中使用print()函数进行输出，且字符串必须用引号括起来。选项A和D使用了C语言的printf，选项B缺少引号会导致语法错误，只有C选项正确。" }, { "id": 875, "q": "下图表示的是哪种程序的基本结构？（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "顺序结构", "分支结构", "重复结构", "数据结构" ], "explanation": "本题考查程序的基本控制结构。顺序结构是指程序按照代码编写的先后顺序依次执行，不包含任何条件判断或循环跳转。分支结构用于条件选择，重复结构用于循环执行。根据答案A可知，图示应为顺序结构。", "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-structure-sequence.png" }, { "id": 876, "q": "以下程序的输出结果是（ ）\ns = \"welcome\"\nprint(\"{0:-^30}\".format(s))", "t": "single", "ans": "B", "kp": "字符串", "o": [ "welcome", "-----------welcome------------", "welcome-----------------------", "-----------------------welcome" ], "explanation": "字符串格式化方法format中，{0:-^30}表示将第0个参数居中对齐（^），总宽度为30个字符，不足部分用连字符（-）填充。字符串'welcome'长度为7，剩余23个字符分配在两侧，因此输出为两侧带有连字符的居中字符串。" }, { "id": 877, "q": "函数input()的功能是（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "打印输出信息", "从标准输入设备（键盘）读取一行数据", "在标准输出设备（显示器）显示一行数据", "查看数据类型" ], "explanation": "Python内置函数input()用于从标准输入设备（通常是键盘）读取用户输入的一行文本，并将其作为字符串返回。选项A和C描述的是print()函数的功能，选项D描述的是type()函数的功能。" }, { "id": 878, "q": "在Python中，实现多分支选择结构的较好方法是（ ）。", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "if", "if-else", "if-elif-else", "if嵌套" ], "explanation": "在Python中，处理多个互斥条件时，使用if-elif-else结构最为清晰高效。单一的if仅处理一个条件，if-else处理二分支，而深层的if嵌套会导致代码缩进过多、可读性差，因此if-elif-else是实现多分支的最佳实践。" }, { "id": 879, "q": "下列程序的运行结果是（ ）。\ni=1\nwhile i<=3:\n    print(\"*\",end=\"\")\n    i=i+1\nprint(\" $ \", end=\"\")", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "$ $ $ $", "****", "***$", "**$$" ], "explanation": "while循环条件为i<=3，初始i=1，循环执行3次，每次打印一个*且不换行，输出***。循环结束后，执行最后的print语句，输出带有空格的' $ '。综合起来输出结果为'*** $ '，选项C最为符合。" }, { "id": 880, "q": "以下程序段的运行结果是（ ）。\ns=\"123456789\"\nfor i in s:\n    if ord(i)%2==1:\n        continue\n    print(i,end='')", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "123456789", "2468", "13579", "147" ], "explanation": "程序遍历字符串s中的每个字符。ord(i)获取字符的ASCII码，数字字符'0'到'9'的ASCII码为48到57。奇数字符的ASCII码为奇数，满足条件执行continue跳过打印；偶数字符不满足条件，执行打印。因此最终输出所有偶数字符2468。" }, { "id": 881, "q": "以下关于列表的描述中，错误的有（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "列表支持in运算符", "列表可以进行的操作包括索引,切片，加，乘等等", "列表的元素类型必须相同", "可以使用下标索引来访问列表中的值" ], "explanation": "Python列表是动态数组，支持存储任意数据类型的元素，同一个列表中可以同时包含整数、字符串甚至其他列表等，因此选项C描述错误。列表支持in运算符、索引、切片、拼接（加）和重复（乘）等操作。" }, { "id": 882, "q": "以下程序代码的运行结果正确的是（ ）。\ndef sum():\n       global s\n       s={2,4,4,6,6}\n       return s\ns={1,3,5,5}\nsum( )\nprint('{}'.format(s))", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "{1,3,5,5}", "{1,3,5,}", "{2, 4, 6}", "{2,4,4,6,6}" ], "explanation": "函数内部使用global s声明s为全局变量。调用sum()时，全局变量s被重新赋值为集合{2,4,4,6,6}。由于集合具有自动去重特性，重复元素被移除，变为{2, 4, 6}。最后打印全局变量s，输出结果即为去重后的集合。" }, { "id": 883, "q": "运行这段代码的输出结果是（ ）。\ndef max(x, y):\n    if x >=y:\n        return x\n    else:\n         return y\nprint(max(9, 7),end=' ')\nz = max(8, 6)\nprint(z)", "t": "single", "ans": "A", "kp": "函数", "o": [ "9 8", "9 6", "8 7", "7 6" ], "explanation": "自定义函数max(x, y)返回两个参数中的较大值。第一次调用max(9, 7)返回9，打印'9 '（带空格不换行）。第二次调用max(8, 6)返回8，赋值给z并打印'8'。因此最终输出结果为'9 8'。" }, { "id": 884, "q": "在Python中，所有数据类型都被视为（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "属性", "方法", "对象", "函数" ], "explanation": "Python是一门纯粹的面向对象编程语言，其核心理念是\"一切皆对象\"。无论是基本数据类型（如整数、字符串）还是复杂数据结构（如列表、字典），在底层都被实现为对象，拥有各自的属性和方法。" }, { "id": 885, "q": "下列哪个选项是turtle绘图中角度坐标系的绝对0度方向？（ ）", "t": "single", "ans": "A", "kp": "random/turtle等标准库", "o": [ "画布正右方", "画布正左方", "画布正上方", "画布正下方" ], "explanation": "在Python的turtle标准库中，默认的角度坐标系（标准模式）下，0度方向指向画布的正右方（即x轴正方向），90度指向正上方，180度指向正左方，270度指向正下方。" }, { "id": 886, "q": "下列程序的输出结果是（）？\nf=open('D:\\\\out.txt','w+')\nf.write('Python')\nf.seek(3,0)\nc=f.read(1)\nprint(c)\nf.close()", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "Py", "t", "th", "h" ], "explanation": "文件以w+模式打开并写入字符串'Python'。f.seek(3, 0)将文件指针从文件开头（参考点0）向后移动3个字节，指向索引为3的字符，即第4个字符'h'。接着f.read(1)读取1个字符，结果为'h'并打印。" }, { "id": 887, "q": "用户输入一个小写字母，请填空实现将其转换成大写字母。\nch=input(\"请输入一个小写字母\")\nif ch>='a' and ch<='__1__':\n        x=chr(ord(ch)-32)\nprint(__2___)", "t": "fill", "ans": "z | x", "kp": "程序填空/调试", "o": [], "explanation": "第1空判断输入字符是否为小写字母，小写字母范围是'a'到'z'，故填z。第2空输出转换后的大写字母，转换结果保存在变量x中，故填x。" }, { "id": 888, "q": "有以下程序：定义了一个A类；然后再定义一个B类，继承自A类。创建B类的一个实例对象b，并调用其show方法。请根据题目要求把程序补充完整。\nclass A():\n    pass\nclass B(__1___):\n    def __init__(self,a):\n        self.a=a\n    def show(__2___):\n        print(self.a)\n   \nb=B(10)\nb.show()", "t": "fill", "ans": "A | self", "kp": "程序填空/调试", "o": [], "explanation": "第1空实现类的继承，B类继承自A类，括号内应填入父类名A。第2空定义实例方法，方法的第一个参数必须是实例对象本身，通常命名为self，故填self。" }, { "id": 889, "q": "以下不是Python内置数据类型的是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "char", "int", "float", "list" ], "explanation": "Python中没有单独的字符类型char，单个字符也是字符串类型str。int表示整型，float表示浮点型，list表示列表，它们都是Python的内置数据类型。因此选A。" }, { "id": 890, "q": "数学表达式 在Python中正确表示为（）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "a-b/a+b", "a-b/(a+b)", "(a-b)/a+b", "(a-b)/(a+b)" ], "explanation": "题目中数学表达式缺失，但根据选项和答案推断，原表达式应为(a-b)/(a+b)。在Python中，除法运算符为/，且需使用括号明确分子和分母的运算优先级，否则除法会优先于加减法执行。因此正确表示为(a-b)/(a+b)，选D。" }, { "id": 891, "q": "下面选项中不属于数值类型的是（ ）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "0o231", "0x35", "-23", "\"2.4e-3\"" ], "explanation": "A选项0o231是八进制整数，B选项0x35是十六进制整数，C选项-23是十进制整数，均属于数值类型。D选项\"2.4e-3\"带有双引号，属于字符串类型，而不是浮点数。因此选D。" }, { "id": 892, "q": "已知x=10,y=3,执行语句x%=y后，x的值是（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1", "2", "4", "5" ], "explanation": "x%=y等价于x=x%y，即求x除以y的余数并赋值给x。10除以3的商为3，余数为1，因此执行后x的值为1。选A。" }, { "id": 893, "q": "Python语言中标准输出print()函数中，默认的结束符是( )", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "回车换行符", "逗号", "分号", "空格" ], "explanation": "Python的print()函数默认参数end='\\n'，即每次输出结束后会自动添加一个回车换行符。若要改变结束符，可通过修改end参数实现。因此选A。" }, { "id": 894, "q": "关于 Python 程序格式框架的描述，以下选项中错误的是( )", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "Python 语言的缩进可以由任意的空格或制表符组成", "Python单层缩进代码属于之前最邻近的一行非缩进代码，多层缩进代码根据缩进关系决定所属范围", "判断、循环、函数等语法形式能够通过缩进包含一批Python 代码，进而表达对应的语义", "Python 语言不采用严格的\"缩进\"来表明程序的格式框架" ], "explanation": "Python语言强制使用严格的缩进来表明程序的格式框架和代码块的所属关系，这是Python语法的核心特征之一。因此选项D描述错误，符合题意。选项A、B、C均正确描述了Python缩进规则。" }, { "id": 895, "q": "下面的代码在运行时输入\"12\"，则输出结果是（ ）。\nx=input()\nif x== '1':\n    print('One')\nelif x== '2':\n    print('Two')\nelif x== '3':\n    print('Three')\nelse:\n    print('other')", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "One", "Two", "Three", "other" ], "explanation": "input()函数接收的输入为字符串类型。输入\"12\"后，变量x的值为字符串\"12\"。程序依次判断x是否等于'1'、'2'、'3'，均不成立，因此执行else分支，输出'other'。选D。" }, { "id": 896, "q": "以下代码的输出结果是（）。\nn=-50\ns=10\nif n>=5:\n   n-=10\n   s=40\nelse:\n   n-=10\n   s=30\nprint(s)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "30", "40", "10", "50" ], "explanation": "初始时n=-50，s=10。判断条件n>=5不成立，因此程序执行else分支。在else分支中，n减去10变为-60，s被重新赋值为30。最后打印s的值，输出30。选A。" }, { "id": 897, "q": "与关系表达式x==0等价的表达式是（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "x=0", "not x", "x", "x!=1" ], "explanation": "在Python中，数值0在布尔上下文中被视为False。表达式not x表示对x进行逻辑非运算，当x为0时，not 0的结果为True，这与x==0成立时的逻辑真值一致。A是赋值语句，C在x为0时为False，D不等价。因此选B。" }, { "id": 898, "q": "若输入x为100，输出的grade是（）\nx=int(input())\nif x>=70:\n    grade='C'\nif x>=80:\n    grade='B'\nif x>=90:\n    grade='A'\nif x>=60:\n    grade='D'\nprint(grade)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "A", "B", "C", "D" ], "explanation": "输入x为100。程序使用的是多个独立的if语句而非if-elif结构，因此每个条件都会被顺序判断并执行。100满足所有条件，grade依次被赋值为'C'、'B'、'A'，最后被赋值为'D'。最终输出'D'。选D。" }, { "id": 899, "q": "以下代码的输出结果是（ ）。\nfor s in range(5):\n    if s==3:\n        continue\n    if s==4:\n        break\n    print(s,end=\"\")", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "0123", "0124", "012", "1234" ], "explanation": "循环变量s依次取0到4。当s为0、1、2时，正常打印；当s为3时，执行continue跳过本次循环的打印；当s为4时，执行break直接终止循环。因此最终只打印0、1、2，输出结果为012。" }, { "id": 900, "q": "设有程序段：\nk=5\nwhile k:\n    k=k-1\n    print(k,end='')\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "54321", "43210", "12345", "01234" ], "explanation": "初始k=5，满足while k条件进入循环。每次循环先执行k=k-1，再打印k的值。k依次变为4、3、2、1、0并打印，当k变为0时，下一次判断while 0为假，循环结束。因此输出43210。" }, { "id": 901, "q": "以下代码的输出结果是（ ）。\nlis=[1,2,3,4,5]\nfor s in lis:\n    if s==4:\n        break\n    s=10\nprint(s)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "3", "4", "10", "5" ], "explanation": "for循环遍历列表lis，循环变量s依次取1、2、3、4、5。循环体内s=10只是修改了局部变量s的值，不影响列表的遍历。当s取到4时，满足if s==4条件，执行break跳出循环。此时循环结束，s的值保持为4，打印输出4。" }, { "id": 902, "q": "设 str =\"hello\"，想把字符串的第一个字母大写，其他字母还是小写，正确的选项是：（ ）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "print(str[1].upper()+str[-1:1])", "print(str[0].upper()+str[1:-1])", "print(str[1].upper()+str[2:])", "print(str[0].upper()+str[1:])" ], "explanation": "字符串索引从0开始，str[0]获取第一个字母'h'，调用upper()转为大写'H'；str[1:]获取从第二个字母到末尾的子串'ello'。两者拼接得到'Hello'，符合首字母大写其余小写的要求。" }, { "id": 903, "q": "关于字符串的索引，下面说法错误的是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "中括号括起来的编号", "最左边字符编号为0", "最右边字符的编号和字符串的长度相等", "最右边的字符的编号为-1。" ], "explanation": "Python字符串索引中，正向索引从0开始，最右边字符的索引为字符串长度减1；反向索引从-1开始，最右边字符编号为-1。选项C称最右边字符编号和字符串长度相等是错误的。" }, { "id": 904, "q": "在Python中，字符串运算符\"+\"的作用是把字符串进行连接，则表达式\"10\"+\"20\"+\"10+20\"的运算结果是（ ）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "301020", "102030", "102010+20", "3030" ], "explanation": "在Python中，加号\"+\"用于字符串时执行拼接操作，不会进行数学加法运算。因此\"10\"、\"20\"和\"10+20\"直接按顺序连接，结果为字符串\"102010+20\"。" }, { "id": 905, "q": "下列关于列表变量ls的方法描述错误的是（ ）", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "ls.append(x):在列表ls最后添加一个元素x", "ls.clear():删除ls列表", "ls.copy():复制生成一个包括ls中所有元素的新列表", "ls.reverse():反转列表ls中的元素" ], "explanation": "列表的clear()方法用于移除列表中的所有元素，使其变为空列表，而不是删除列表变量本身。若要删除列表变量，应使用del语句。因此选项B描述错误。" }, { "id": 906, "q": "以下代码的输出是什么？\ns1 = set([1, 2, 3])\ns2 = set([2, 3, 4])\ns3 = set([3, 4, 5])\ns4 = s1.union(s2).difference(s3)\nprint(s4)", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{1, 2, 4, 5}", "{1, 2}", "{1, 2, 3, 4}", "{1, 2, 3, 4, 5}" ], "explanation": "s1.union(s2)求并集得到{1, 2, 3, 4}。接着调用difference(s3)求差集，即从并集中移除s3中存在的元素（3、4、5），最终剩下{1, 2}。" }, { "id": 907, "q": "对于字典D={'A':10,'B':20,'C':30,'D':40}，sum(list(D．values()))的值是（ ）。", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "10", "100", "40", "200" ], "explanation": "字典的values()方法返回所有值的视图，list(D.values())将其转为列表[10, 20, 30, 40]。sum()函数对列表元素求和，10+20+30+40的结果为100。" }, { "id": 908, "q": "下列代码运行后的结果是（ ）。\ndef add(s):\n    if len(s) == 1:\n        return s[0]\n    else:\n        return s[0].lower() + add(s[1:len(s)])\nprint(add(('STUD')))", "t": "single", "ans": "B", "kp": "函数", "o": [ "stud", "stuD", "STUD", "Stud" ], "explanation": "函数add通过递归处理字符串。当长度大于1时，将首字母转为小写并拼接剩余部分的递归结果；当长度为1时直接返回该字符。'STUD'首字母依次转小写为's'、't'、'u'，最后剩'D'直接返回，拼接结果为'stuD'。" }, { "id": 909, "q": "下列代码的运行结果是（ ）。\nfact=lambda x,y,z:abs(x*y*z)\nprint(fact(1,2,-3))", "t": "single", "ans": "A", "kp": "函数", "o": [ "6", "-6", "0", "-1" ], "explanation": "lambda表达式定义了一个匿名函数，接收三个参数并返回它们乘积的绝对值。传入1、2、-3，计算乘积为1*2*(-3)=-6，再取绝对值abs(-6)，最终结果为6。" }, { "id": 910, "q": "以下程序运行后输出的结果是（ ）\ndef add(x=8):\n    s=0\n    for i in range(0,x,2):\n        s=s+i\n    return s\nprint(add(10))", "t": "single", "ans": "C", "kp": "函数", "o": [ "6", "12", "20", "4" ], "explanation": "调用add(10)时，x被赋值为10。range(0, 10, 2)生成序列0, 2, 4, 6, 8。循环将这些值累加到s中，即0+2+4+6+8=20。函数最终返回20。" }, { "id": 911, "q": "下列选项中，与class A等价的写法是（ ）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "class A: (object)", "class A: object", "class A object", "class A(object):" ], "explanation": "在Python 3中，定义类时如果不显式指定父类，默认继承自object基类。因此`class A:`与显式继承的`class A(object):`是完全等价的。选项A、B、C的语法格式均不符合Python类的定义规范。" }, { "id": 912, "q": "C类继承A类和B类，以下语法格式正确的是（）。", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "class C(A->B）", "class C (A,B) :", "class C(A,B）", "class C->A,B" ], "explanation": "Python中实现多重继承的语法是在类名后的圆括号内列出所有父类，用逗号分隔，并以冒号结尾。因此`class C(A, B):`是正确的语法格式。选项A、D使用了错误的箭头符号，选项C缺少了类定义必需的冒号。" }, { "id": 913, "q": "文件datA．txt里的内容为：QQ&Wechat Google & Baidu，以下程序的输出结果是（ ）\nf = open('datA．txt','r')\nprint(f.read(7))\nf.close()", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "Wechat", "&Wechat", "Q&Wecha", "QQ&Wech" ], "explanation": "文件对象的`read(7)`方法表示从当前文件指针位置读取前7个字符。文件内容为'QQ&Wechat Google & Baidu'，前7个字符依次是'Q', 'Q', '&', 'W', 'e', 'c', 'h'，拼接后即为'QQ&Wech'。" }, { "id": 914, "q": "输入三个数，求最大数。\nx,y,z=eval(input(\"x,y,z=?\"))\n___1___ x>y:\n max=x\nelse:\n max=y\nif max", "", "", "" ], "explanation": "type()函数用于返回对象的数据类型。120是整数，因此type(120)的运行结果为。选项A虽然显示为空，但通常对应此结果，故选A。" }, { "id": 926, "q": "已知x=2，语句x*=x+1执行后，x的值是（ ）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "2", "3", "5", "6" ], "explanation": "复合赋值运算符*=的优先级低于算术运算符+。因此表达式x*=x+1等价于x = x * (x + 1)。已知x=2，代入计算得x = 2 * (2 + 1) = 6。故选D。" }, { "id": 927, "q": "语句print(\"ABC\",\"DEF\",sep=\"-\",end=\"!\")的执行结果是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "ABC-DEF!", "ABC!DEF-", "ABC DEF!", "ABC-DEF" ], "explanation": "print()函数中，sep参数指定多个输出对象之间的分隔符，默认为空格，此处设为'-'；end参数指定输出结尾的字符，默认为换行符，此处设为'!'。因此输出为'ABC-DEF!'。故选A。" }, { "id": 928, "q": "Python通过语句的（ ）反映语句之间的逻辑关系，从而区分不同的语句块。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "花括号{}", "缩进对齐", "功能结束语句", "空行" ], "explanation": "Python使用缩进（通常是4个空格）来表示代码块的层级和逻辑关系，而不是像C或Java那样使用花括号{}。空行用于提高代码可读性，不决定逻辑。故选B。" }, { "id": 929, "q": "Python语句print(\"{:4b}\".format(33) )中b代表的含义为（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "二进制", "十进制", "八进制", "十六进制" ], "explanation": "在字符串的format()格式化方法中，格式说明符b表示将整数转换为二进制形式输出。d代表十进制，o代表八进制，x代表十六进制。故选A。" }, { "id": 930, "q": "执行如下语句x=input( )，若输入123.5，那么 x 的类型是（ ）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "整数", "字符串", "浮点数", "以上都错误" ], "explanation": "Python中的input()函数接收用户输入时，无论输入的是数字还是其他字符，都会将其作为字符串（str）类型返回。若需其他类型需显式转换。故选B。" }, { "id": 931, "q": "下面的代码在运行时输入“3”，则输出结果是（）。\nx=int(input())\nif x==1:\n   print('1')\nelif x==2:\n   print('2')\nelif x==3:\n   print('3')\nelse:\n   print('4')", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "1", "2", "3", "出错" ], "explanation": "代码使用int(input())接收输入并转为整数，输入'3'则x=3。随后进入if-elif-else分支判断，x不等于1和2，满足x==3的条件，执行对应的print('3')。故选C。" }, { "id": 932, "q": "下列语句执行后的输出是（ ）。\nif 2:\n    print(5)\nelse:\n    print(6)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "0", "2", "5", "6" ], "explanation": "在Python中，非零整数在布尔上下文中被视为True。条件if 2:为真，因此执行if分支下的语句print(5)，不会执行else分支。故选C。" }, { "id": 933, "q": "表达式round(2.5)==2的值为（ ）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "F", "T", "False", "True" ], "explanation": "Python 3中的round()函数采用\"银行家舍入法\"（四舍六入五成双）。对于2.5，由于前一位2是偶数，因此向下舍入为2。表达式2==2的结果为True。故选D。" }, { "id": 934, "q": "以下代码的输出结果是（）。\nn=-5\ns=100\nif n>=5:\n   if n<=5:\n      n-=10\n      s=3\nprint(s)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "3", "4", "100", "2" ], "explanation": "初始时n=-5，s=100。外层if条件判断n>=5，即-5>=5，结果为False。因此直接跳过整个if语句块，不执行内部的嵌套判断和赋值操作。最后打印s的初始值100。故选C。" }, { "id": 935, "q": "“not in”的含义是（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "如果在指定的序列中没有找到值，则返回True，否则返回False。", "如果在指定的序列中没有找到值，则返回True，否则返回True。", "如果在指定的序列中没有找到值，则返回False，否则返回True。", "不管在指定的序列中是否找到值，都返回True。" ], "explanation": "not in是Python中的成员运算符，用于检查某个值是否不存在于指定的序列（如字符串、列表、元组等）中。如果不存在则返回True，存在则返回False。故选A。" }, { "id": 936, "q": "若输入x为100，输出的grade是（）\nx=int(input())\nif x>=90:\n    grade='A'\nif x>=60:\n    grade='D'\nif x>=70:\n    grade='C'\nif x>=80:\n    grade='B'\nprint(grade)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "A", "B", "C", "D" ], "explanation": "题目中使用了四个独立的if语句而非if-elif结构。当输入x=100时，满足所有if条件，程序会依次执行每个if块内的赋值语句。grade的值先后被修改为'A'、'D'、'C'，最后被赋值为'B'并输出。因此最终结果为B。" }, { "id": 937, "q": "设有程序段：\nfor i in range(1,6):\n      pass\nprint(i)\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "10", "5", "0", "1" ], "explanation": "range(1,6)生成序列1, 2, 3, 4, 5。for循环遍历该序列，每次将当前值赋给变量i。循环正常结束后，变量i保留最后一次迭代的值，即5。因此print(i)输出5。" }, { "id": 938, "q": "设有程序段：\nk=5\ns=0\nwhile k:\n      s=s+k\n      k=k-1\nprint(\"s=\",s)\n则程序的运行结果是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "s=12345", "s=0", "s=15", "s=20" ], "explanation": "初始k=5，s=0。while循环条件为k，当k不为0时执行循环体。循环中s累加k的值，k每次减1。k依次取5, 4, 3, 2, 1，s最终累加结果为5+4+3+2+1=15。循环结束后输出s= 15。" }, { "id": 939, "q": "以下程序执行后打印星号*的个数是( )。\nfor i in range(10):\n    if i==8:\n        break\nprint(\"*\",end='')", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "10", "9", "7", "8" ], "explanation": "for循环遍历range(10)即0到9。当i从0到7时，不满足i==8，执行print打印星号；当i=8时，满足条件触发break跳出循环，不再执行后续迭代。因此共打印了8个星号。" }, { "id": 940, "q": "以下代码的输出结果是（ ）。\nsum=0\nlis=[1,2,3,4,5]\nfor s in lis:\n      sum=sum+s\nprint(sum)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "10", "5", "0", "15" ], "explanation": "初始sum=0，遍历列表lis中的元素1, 2, 3, 4, 5。每次循环将当前元素累加到sum中。循环结束后，sum的值为1+2+3+4+5=15。最后输出15。" }, { "id": 941, "q": "下列描述中错误的是( )。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "循环嵌套中处于内层的循环称为内循环。", "while循环嵌套中只能有一层嵌套。", "for循环嵌套是指for循环的循环体中嵌套有一个或多个for循环或while循环。", "for循环的循环体中可以有while循环。" ], "explanation": "Python中的循环嵌套没有层数限制，while循环和for循环都可以进行多层嵌套，且两者可以相互嵌套。因此选项B称\"while循环嵌套中只能有一层嵌套\"是错误的描述。" }, { "id": 942, "q": "已知s='abc'，执行print(s.upper(),s)的结果是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "ABC abc", "ABC ABC", "abc abc", "abc ABC" ], "explanation": "字符串的upper()方法返回一个所有字符大写的新字符串，但不会修改原字符串。因此s.upper()返回'ABC'，而原变量s的值依然是'abc'。print函数默认用空格分隔多个参数，输出结果为ABC abc。" }, { "id": 943, "q": "字符串：s='abcde', n是字符串s的长度。索引字符串s字符'c', 下面正确的语句是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "s[n/2]", "s[(n+1)/2]", "s[n//2]", "s[(n+1)//2]" ], "explanation": "字符串s='abcde'的长度n为5。字符'c'的索引为2。选项A和B使用普通除法产生浮点数，不能作为索引；选项D计算(5+1)//2=3，对应字符'd'；选项C计算5//2=2，正确获取索引2对应的字符'c'。" }, { "id": 944, "q": "假设列表对象list1=[3,4,5,6,7,9,11,13,15,17],那么切片list1[2:10:2]得到的值是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[5, 7, 11, 15]", "[4, 6, 9, 13, 17]", "[5, 6, 7, 9]", "[ 4, 6, 9, 13]" ], "explanation": "列表切片语法为[start:end:step]。list1[2:10:2]表示从索引2开始，到索引10之前结束，步长为2。提取的索引依次为2, 4, 6, 8，对应的元素分别是5, 7, 11, 15。因此结果为[5, 7, 11, 15]。" }, { "id": 945, "q": "令tup=(1,2,3,4,5)，则print(tup[0:5:-1])的结果为（ ）", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "(1,2,3,4,5)", "(5,4,3,2,1)", "(1)", "()" ], "explanation": "元组切片tup[0:5:-1]中，步长为-1表示从右向左截取。此时要求起始索引必须大于结束索引，但题目中起始索引0小于结束索引5，无法进行有效截取，因此返回一个空元组()。" }, { "id": 946, "q": "以下程序的输出结果是： （ ）。\ns=''\nls = ['a','b',1,2]\nfor i in ls:\n      s += str (i)\nprint (s)", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "a,b,1,2", "21ba", "2,1,b,a", "ab12" ], "explanation": "初始s为空字符串。for循环遍历列表ls中的每个元素，使用str()函数将其转换为字符串后，通过+=操作符拼接到s的末尾。依次拼接'a'、'b'、'1'、'2'，最终s的值为'ab12'并输出。" }, { "id": 947, "q": "以下代码的输出是什么？\ns = {1, 2, 3, 4}\ns.discard(5)\nprint(len(s))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "3", "4", "2", "1" ], "explanation": "集合的discard()方法用于移除指定元素，如果元素不存在于集合中，不会引发KeyError异常。由于5不在集合s中，discard(5)不产生任何效果，集合长度保持不变，len(s)依然为4。" }, { "id": 948, "q": "以下程序的输出结果是：( )。\ndict = {'Name': 'Lisa', 'Age': 18}\nprint(dict.items())", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "[('Age', 18), ('Name', 'Lisa ')]", "('Age', 18), ('Name', 'Lisa ')", "'Age':18, 'Name': 'Lisa '", "dict_items([('Age',18), ('Name', 'Lisa ')])" ], "explanation": "dict.items()方法返回一个包含字典所有键值对的视图对象，其类型为dict_items，表现形式类似于包含元组的列表。选项A、B、C的格式均不正确，只有D正确展示了该对象的输出格式。" }, { "id": 949, "q": "下列不属于函数优点的是（）", "t": "single", "ans": "D", "kp": "函数", "o": [ "减少代码重复", "使程序模块化", "使程序便于阅读", "便于发挥程序员的创造力" ], "explanation": "函数的主要优点包括减少代码重复、使程序模块化以及提高代码的可读性和可维护性。选项D\"便于发挥程序员的创造力\"并非函数在程序设计中的直接或主要技术优点，属于主观描述，因此是不属于函数优点的选项。" }, { "id": 950, "q": "下列代码运行后的结果是（ ）。\ndef f(k):\n    if k<=0:\n        return 3\n    else:\n        return f(k-1)-f(k-2)\nt=f(3)\nprint('{}'.format(t))", "t": "single", "ans": "C", "kp": "函数", "o": [ "3", "6", "-3", "-6" ], "explanation": "计算过程如下：当k<=0时返回3，故f(0)=3，f(-1)=3。f(1)=f(0)-f(-1)=0。f(2)=f(1)-f(0)=0-3=-3。f(3)=f(2)-f(1)=-3-0=-3。因此最终输出结果为-3。" }, { "id": 951, "q": "在函数内部声明全局变量，需要使用以下哪个关键字？（ ）。", "t": "single", "ans": "A", "kp": "函数", "o": [ "global", "local", "globals", "locals" ], "explanation": "在Python中，若要在函数内部修改或声明全局变量，必须使用global关键字。local不是Python关键字，globals()和locals()是返回字典的内置函数，不能用于声明变量。" }, { "id": 952, "q": "下列代码的运行结果是（ ）。\ny=lambda s1,s2:s2.find(s1)\nprint(y('e','howareyoue?'))", "t": "single", "ans": "A", "kp": "函数", "o": [ "5", "4", "3", "2" ], "explanation": "该lambda函数调用字符串的find()方法，在s2中查找s1首次出现的索引。字符串'howareyoue?'中，字符'e'首次出现在索引5的位置（从0开始计数：h-0, o-1, w-2, a-3, r-4, e-5）。因此输出5。" }, { "id": 953, "q": "以下程序的运行结果是（）。\ndef take(x,y,z):\n    h=x*y*z\n    return h\nm=take(4,1,z=5)\nprint(\"m的输出结果为:\",m)", "t": "single", "ans": "C", "kp": "函数", "o": [ "4", "5", "20", "1" ], "explanation": "函数take接收三个参数并返回它们的乘积。调用take(4,1,z=5)时，位置参数x=4，y=1，关键字参数z=5。计算4*1*5结果为20，因此m的输出结果为20。" }, { "id": 954, "q": "下列程序的执行结果是（ ）。\nclass Point:\n    x=10\n    y=10\n    def __init__(self,x,y):\n        self.x=x\n        self.y=y\npt=Point(20,20)\nprint(pt.x,pt.y)", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "10 20", "20 10", "10 10", "20 20" ], "explanation": "实例化Point(20,20)时，会调用__init__方法，将传入的参数20分别赋值给实例属性self.x和self.y。实例属性会覆盖同名的类属性，因此pt.x和pt.y的值均为20。" }, { "id": 955, "q": "以下关于类的定义中说法错误的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "类通过class关键字来定义", "类名首字母一般采用大写", "定义类之后，需要定义具体的对象才可以访问对象的成员方法或属性", "类名后面有个冒号" ], "explanation": "选项C说法错误，因为类属性（类变量）和类方法可以直接通过类名访问，无需实例化具体的对象。选项A、B、D均符合Python类定义的语法规则和命名约定。" }, { "id": 956, "q": "下列程序的运行结果是（）\nclass A():\n    def f1(self):\n        print(\"a\")\nclass B（A）:\n    def f2(self):\n        print(\"b\")\nclass C（A）:\n    def f1(self):\n        print('c')\nclass D(B,C）:\n    pass\nd=D()\nd.f1()", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "a", "b", "c", "pass" ], "explanation": "类D继承自B和C，B和C均继承自A。根据Python的多重继承方法解析顺序（MRO），D的查找顺序为D->B->C->A。调用d.f1()时，D和B中没有f1，接着在C中找到f1并执行，输出'c'。" }, { "id": 957, "q": "下列哪个选项不能正确引用turtle库进而使用setup()函数？ （ ）", "t": "single", "ans": "D", "kp": "random/turtle等标准库", "o": [ "import turtle", "import turtle as t", "from turtle import*", "import setup from turtle" ], "explanation": "Python中导入模块特定函数的正确语法是from turtle import setup。选项D的语法import setup from turtle是错误的，会导致语法错误。选项A、B、C均为合法的导入方式。" }, { "id": 958, "q": "在读写文件之前，用于创建文件对象的函数是（ ）。", "t": "single", "ans": "A", "kp": "文件操作", "o": [ "open", "create", "file", "folder" ], "explanation": "在Python中，使用内置函数open()来打开文件并返回一个文件对象，随后可通过该对象进行读写操作。create、file（Python 3中已移除）和folder均不是用于此目的的标准内置函数。" }, { "id": 959, "q": "下面程序的运行结果是 （）\nA = {7, 28, 34, 52, 54, 71}\nB = {7, 34,71}\nC = {21, 38, 74, 86, 88}\nprint(A.issuperset(B),B.issuperset(C))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "True True", "True False", "False True", "False False" ], "explanation": "issuperset()方法用于判断调用该方法的集合是否包含另一个集合的所有元素。集合A包含集合B的所有元素（7, 34, 71），因此A.issuperset(B)为True。集合B不包含集合C的任何元素，因此B.issuperset(C)为False。" }, { "id": 960, "q": "设列表s= [\"5\",\"1\",\"2\",\"3\",\"4\"]，将列表中元素依次前移一位，原来第一位移到最后一位，然后输出新的列表。请完成程序。\na=[\"5\",\"1\",\"2\",\"3\",\"4\"]\nn=a[0]\nfor i in range(1,5):\n    _____1____\n a[4]=n\nprint(a)", "t": "fill", "ans": "a[i-1]=a[i]", "kp": "列表/元组", "o": [], "explanation": "第1空需将后一个元素赋值给前一个位置以实现前移。循环变量i从1到4，将a[i]赋值给a[i-1]即可完成元素依次前移一位的操作，最后将原首元素n赋给末尾。" }, { "id": 961, "q": "有以下程序代码：定义一个Student类，类中定义一个bb方法；然后根据该类创建一个实例对象s1，并调用bb方法。\nclass Student:\n    def bb(self,name):\n        self.name=name\n        print(\"我是\",self.name)\ns1=___1____ ()\ns1.____2___ (\"小千\")", "t": "fill", "ans": "Student | bb", "kp": "面向对象", "o": [], "explanation": "第1空通过类名加括号实例化对象，故填Student；第2空调用实例对象的方法并传入参数，根据类中定义的方法名，应填bb。" }, { "id": 962, "q": "下列程序的输出结果是（）。\ns=\"\"\nfor i in '**c*a*t***':\n    if i!=\"*\":\n        s=s+i\nprint(s)", "t": "fill", "ans": "cat", "kp": "字符串", "o": [], "explanation": "程序遍历字符串中的每个字符，当字符不为星号时，将其拼接到字符串s中。过滤掉所有星号后，最终s的值为cat并输出。" }, { "id": 963, "q": "用一个列表来保存一个表演节目的所有分数，求平均分数（去掉一个最高分，去掉一个最低分，求最后得分）。请填空。\nscores=[9.1,8.9,9.5,8.8,9.8,9.0]\nmax=min=scores[0]\nsum=0\nfor i in range(0,len(scores)):\n    if maxscores[i]:\n        min=scores[i]\n    sum=___1____\nprint('最后得分为:',(sum-max-min)/ __2_____)", "t": "fill", "ans": "sum+scores[i] | (len(scores)-2)", "kp": "列表/元组", "o": [], "explanation": "第1空在循环中累加分数，应填sum+scores[i]；第2空计算去掉最高分和最低分后的平均分，总分数减去两个极值后，除以剩余元素个数，即len(scores)-2。" }, { "id": 964, "q": "输入年、月、日，判断这一天是这一年的第几天。请完成程序。\nyear=int(input('请输入年份:'))\nmonth=input('请输入月份:')\nday=int(input('请输入日期:'))\ndic={'1':31,'2':28,'3':31,'4':30,'5':31,'6':30,'7':31,\\\n'8':31,'9':30,'10':31,'11':30,'12':31}\ndays=0\nif ((year%4==0) and (year%100!=0)) or (year%400==0):\n    dic['2']=__1____\nif int(month)>1:\n    for obj in dic:\n        if month==obj:\n            for i in range(1,int(obj)):\n                days+=dic[str(i)]\n                days+=day\n        else:\n            days=day\nprint('{}年{}月{}日是该年的第{}天'.format(year,month,day,__2____))", "t": "fill", "ans": "29 | days", "kp": "字典/集合", "o": [], "explanation": "第1空判断为闰年时，2月天数应为29天，故填29；第2空在格式化输出时，需打印计算得到的总天数变量，故填days。" }, { "id": 965, "q": "以下sum函数的功能是编程分别计算数列：1/2，2/3，3/5，5/8，8/13 ，13/21……前10项和为6.72。请在括号（）中填入正确答案。\ndef sum(n):\n    a=1;s=0\n    (___1___)\n    for i in range(n+1):\n        s=s+a/b\n        t=b\n       \n        (____2____)\n        a=t\n    return s\ns1=sum(10)\nprint(\"前10项和=%.2f\\n\"%(s1))", "t": "fill", "ans": "b=2 | b=a+b", "kp": "函数", "o": [], "explanation": "第1空初始化分母，数列首项为1/2，分子a=1，故分母b=2；第2空更新分母，观察数列分母规律为前一项分子分母之和，故填b=a+b，随后a更新为原分母。" }, { "id": 966, "q": "以下程序的输出结果是[*queNo*]_。\ndef mytype(x,y,z=10):\n    i=1;s=0\n    while i<3:\n        s+=i*(x*y+x*z)\n   \n        i=i+1\nreturn s\nprint(mytype(10,3,2))", "t": "fill", "ans": "150", "kp": "函数", "o": [], "explanation": "调用函数时x=10,y=3,z=2。循环i从1到2，每次累加i*(10*3+10*2)即i*50。i=1时s=50，i=2时s=150。循环结束返回150。" }, { "id": 967, "q": "以下程序的运行结果是___1____和____2____。\nclass Rectangle:\n    def __init__(self,long,width):\n        self.long=long\n        self.width=width\n    def area(self):\n        area=self.long*self.width\n        print(area)\nclass Cuboid(Rectangle):\n    def __init__(self,long,width,height):\n        super().__init__(long,width)\n        self.height=height\n    def volume(self):\n        volume=self.long*self.width*self.height\n        print(volume)\ncuoid=Cuboid(2,2,5)\ncuoid.area()\ncuoid.volume()", "t": "fill", "ans": "4 | 20", "kp": "面向对象", "o": [], "explanation": "实例化Cuboid时long=2,width=2,height=5。调用继承的area方法输出长宽之积2乘2等于4；调用volume方法输出长宽高之积2乘2乘5等于20。" }, { "id": 968, "q": "Python提供了       、readline()和readlines()方法用于读取文本文件的内容。", "t": "fill", "ans": "read()", "kp": "文件操作", "o": [], "explanation": "Python中读取文件内容的常用方法有三个：read()用于读取整个文件，readline()读取一行，readlines()读取所有行并返回列表。故填read()。" }, { "id": 969, "q": "以下程序的输出结果是（） 。\nx=1\ny=0\nif not x:\n    y=y+1\nelif x==0:\n    if x:\n        y+=2\n    else:\n        y+=3\nprint(y)", "t": "fill", "ans": "0", "kp": "分支结构", "o": [], "explanation": "x=1，not x为False，不执行第一个分支；x==0也为False，不执行elif分支及其嵌套结构。因此y的值保持初始值0不变，最终输出0。" }, { "id": 970, "q": "在考生文件夹下存在一个Python源文件PY101.py，请编写代码替换横线，不修改其他代码，实现下面功能：\n获得用户输入的一个整数n，输出一个n-1行的数字三角形阵列。该阵列每行包含的整数序列为从该行序号开始到n-1，例如第1行包含1到n-1的整数，第i行包含从i到n-1的整数；数字之间用英文空格分隔。\n示例如下（其中数据仅用于示意）：\n输入：\n8\n输出：\n1 2 3 4 5 6 7\n2 3 4 5 6 7\n3 4 5 6 7\n4 5 6 7\n5 6 7\n6 7\n7\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试及验证程序。", "t": "fill", "ans": "n = eval(input(\"请输入一个整数：\"))\nfor i in range(1,n):\nfor j in range(1,n):\nif j>=i: #从等于i时开始执行下一行输出，直到内层for循环结束，执行print()换行\nprint(j,end=\" \") #输出j的值，用空格结束\nprint()", "kp": "循环结构", "o": [], "rawType": "operation" }, { "id": 971, "q": "在考生文件夹下存在一个python源文件PY202.py，请编写代码替换省略号，不可以修改已有代码，实现以下功能：\n(1)定义一个列表persons，里面有一些名字字符串；\n(2)在该列表中查找用户输入的一个名字字符串；如果找到，则生成一个四位数字的随机数组成的验证码，输出找到的名字字符串和验证码；如果找不到该字符串，则输出提示信息“对不起，您输入的名字不存在。”；如果用户输入一个字母'q'，则退出程序；\n(3)显示提示信息后，再次显示“请输入一个名字：”，提示用户输入，重复执行步骤2；执行3次后自动退出程序。\n示例如下（其中数据仅用于示意）：\n输入：\nAlice\n输出:\nAlice 1001\n输入：\nbob\n输出：\n对不起，您输入的名字不存在。\n输入：\nq\n程序自动退出\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试及验证程序。", "t": "fill", "ans": "import random as r\nr.seed(0)\npersons = ['Aele', 'Bob','lala', 'baicai']\nflag = 3\nwhile flag>0: #通过flag变量控制循环次数\nflag -= 1\nname = input(\"请输入一个名字：\") #输入一个字符串赋值给name\nnum = r.randint(1000,9999) #产生一个四位的随机整数\nif name in persons: #如果name在列表persons中\nprint('{} {}'.format(name, num)) #按照格式输出名字和随机数验证码\nelif name == \"q\": #不在列表中，且输入的字符串为q\nbreak #中断while循环\nelse: #不在列表中，且输入的字符串不为q\nprint('对不起，您输入的名字不存在。')", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 972, "q": "关于Python内存管理，下列说法错误的是( )", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "变量不必事先声明", "变量无须先创建和赋值而直接使用", "变量无须指定类型", "可以使用del释放资源" ], "explanation": "Python中变量在使用前必须先创建并赋值，否则会抛出NameError异常，故B选项说法错误。其他选项均符合Python动态类型和内存管理的特性。" }, { "id": 973, "q": "表达式chr(ord('a')+3)的值为（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "'d'", "10e", "'aaa'", "语法错误无法计算" ], "explanation": "ord('a')获取字符'a'的ASCII码值97，加3后为100；chr(100)将ASCII码值100转换回对应的字符，即'd'。" }, { "id": 974, "q": "下列函数不能实现类型转换的是（）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "str()", "type()", "int()", "float()" ], "explanation": "str()、int()和float()都是Python内置的类型转换函数，分别用于将对象转换为字符串、整数和浮点数。而type()函数用于返回对象的类型，不能用于类型转换。因此选B。" }, { "id": 975, "q": "整型变量x中存放了一个两位数，要将这个两位数的个位数字和十位数字交换位置，例如，13变成31，正确的Python表达式是（ ）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "（x%10）*10+x//10", "(x%10)//10+x//10", "(x/10)%10+x//10", "(x%10)*10+x%10" ], "explanation": "对于两位数x，x%10可获取个位数字，x//10可获取十位数字。将个位数字乘以10变成新的十位，再加上原来的十位数字，即可实现位置交换。表达式为(x%10)*10+x//10。选项A正确。" }, { "id": 976, "q": "Python中对变量的描述，错误的选项是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "变量的值在程序运行的过程中可以被改变", "变量在赋值时需要声明类型", "变量在使用前必须赋值", "在Python中，允许多个变量指向同一个值" ], "explanation": "Python是动态类型语言，变量在赋值时不需要显式声明类型，解释器会根据赋的值自动推断类型，因此选项B错误。其他选项均符合Python变量的特性：值可变、使用前需赋值、支持多变量指向同一对象。" }, { "id": 977, "q": "已知x=10,y=3,执行语句x//=y后，x的值是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1", "2", "3", "3.333333" ], "explanation": "//= 是Python中的地板除赋值运算符。x//=y 等价于 x = x // y。10 // 3 的结果是向下取整的商，即3。因此执行后x的值为3，选C。" }, { "id": 978, "q": "下面关于print([输出项1,输出项2,……,输出项n][,sep=分隔符][,end=结束符])的描述错误的是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "可以没有任何输出项，即print(),表示输出一个空行", "sep表示输出时各输出项之间的分隔符，默认以逗号分隔", "end表示结束符，默认以回车换行结束", "print函数从左至右求每个输出项的值，并将值依次显示在屏幕的同一行上" ], "explanation": "print()函数中，sep参数用于指定多个输出项之间的分隔符，其默认值是空格，而不是逗号。因此选项B描述错误。其他选项关于空行输出、end默认换行以及从左至右求值的描述均正确。" }, { "id": 979, "q": "下面关于注释的说法中错误的是：（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "注释对程序的执行没有任何影响", "写注释的目的是对程序作解释说明，增强程序的可读性", "在程序中必须要有注释", "所谓注释是用于帮助别人或自己理解程序的文字说明，不是程序的一部分" ], "explanation": "注释用于解释代码，提高可读性，且不会被解释器执行。虽然良好的编程习惯鼓励写注释，但Python语法并未强制要求程序中必须包含注释，因此选项C错误。" }, { "id": 980, "q": "以下程序的输出结果是（ ）\nq = 123456.78\nprint(\"{0:-^15}\".format(q))", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "123456.78", "123,456.78", "--123,456.78---", "---123456.78---" ], "explanation": "格式化字符串\"{0:-^15}\"中，0表示第一个参数，-表示填充字符，^表示居中对齐，15表示总宽度为15。字符串\"123456.78\"长度为9，需填充6个'-'，左右各3个。因此输出为\"---123456.78---\"，选D。" }, { "id": 981, "q": "语句a=float(input())执行时，若从键盘输入3.5并按回车键，则a的值是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "3.5", "3", "3.0", "\"3.5\"" ], "explanation": "input()函数接收键盘输入并返回字符串\"3.5\"。float()函数将该字符串转换为浮点数3.5。因此变量a的值为浮点数3.5，选A。" }, { "id": 982, "q": "设x=-5,则表达式x/2='0' and ch<='9'", "ch>='0' or ch<='9'", "ch>='0'", "ch<='9'" ], "explanation": "要判断字符ch是否为数字字符，需要同时满足大于等于'0'且小于等于'9'两个条件。因此必须使用逻辑与运算符and连接，表达式为ch>='0' and ch<='9'。选项A正确。" }, { "id": 984, "q": "给出下面代码，程序运行结果为（ ）。\nx,y=30,70\nmin=10\nif not y:\n    min=y\nprint(min)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "30", "70", "10", "报错" ], "explanation": "变量y被赋值为70，在布尔上下文中非零整数为True。not y 的结果为False，因此if语句块内的代码 min=y 不会被执行。min保持初始值10，最终输出10，选C。" }, { "id": 985, "q": "以下代码的输出结果是（ ）。\nsum=0\nfor s in range(7):\n    if s%2==1 :\n        sum=sum+s\nprint(sum)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "6", "5", "9", "15" ], "explanation": "range(7)生成0到6的整数。循环中if s%2==1筛选出奇数，即1、3、5。sum依次累加这些奇数：0+1+3+5=9。最终输出9，选C。" }, { "id": 986, "q": "以下代码的输出结果是（ ）。\nwhile 0:\n      print(\"hello\")", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "False", "hello", "没有任何输出", "语法错误" ], "explanation": "while循环的条件是0，在Python中0被视为False，因此循环条件一开始就不成立，循环体一次也不会执行，程序没有任何输出。" }, { "id": 987, "q": "设有程序段：\nk=4\nfor i in (1,2,3,4,5):\n    if(k==3):\n        break\n    k=k-1\n    print(k, end= ',')\n则for循环执行的次数是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "5", "6", "2", "1" ], "explanation": "初始k=4。第1次循环i=1，k!=3，k减1变为3，打印3。第2次循环i=2，此时k==3成立，执行break跳出循环。因此for循环共执行了2次。" }, { "id": 988, "q": "下列说法中正确的是（ ）。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "在循环嵌套中break用在for语句中，而continue用在while语句中", "在循环嵌套中break用在while语句中，而continue用在for语句中", "在循环嵌套中continue能结束循环，而break只能结束本次循环", "在循环嵌套中break能结束本层循环，而continue只能结束本次循环" ], "explanation": "在Python中，break语句用于完全终止其所在的最内层循环，而continue语句仅跳过当前循环的剩余代码，直接进入下一次迭代。两者均可用于for和while循环。" }, { "id": 989, "q": "\"ab\"+\"c\"*2的结果是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "abc2", "abcabc", "abcc", "ababcc" ], "explanation": "Python中字符串乘法优先级高于加法。先计算\"c\"*2得到\"cc\"，再与\"ab\"进行字符串拼接，最终结果为\"abcc\"。" }, { "id": 990, "q": "以下选项中可访问字符串s从右侧向左第三个字符的是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "s[3]", "s[:-3]", "s[-3]", "s[0:-3]" ], "explanation": "Python字符串支持负数索引，-1表示最后一个字符，-2表示倒数第二个，以此类推。因此s[-3]表示从右侧向左的第三个字符。" }, { "id": 991, "q": "tuple(range(1,10,2))的返回结果是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[1, 3, 5, 7, 9]", "[2, 4, 6, 8, 10]", "(1, 3, 5, 7, 9)", "(2, 4, 6, 8, 10)" ], "explanation": "range(1,10,2)生成从1开始到9结束（不包含10）、步长为2的整数序列。tuple()函数将其转换为元组，结果为(1, 3, 5, 7, 9)。" }, { "id": 992, "q": "以下代码的输出结果是（ ）\ns=[4,2,9,1]\ns.insert(2,3)\nprint(s)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[4,2,9,2,1]", "[4,2,3,9,1]", "[4,3,2,9,1]", "[4,2,9,1,2,3]" ], "explanation": "列表的insert(index, obj)方法在指定索引位置插入元素。s.insert(2,3)表示在索引2（即第三个位置，原元素9之前）插入3，结果为[4,2,3,9,1]。" }, { "id": 993, "q": "请给出下面代码段的结果。\nA = {1, 3, 5, 7, 9}\nB = {2, 4, 6, 8, 10}\nC = {x * 2 for x in A if x % 2 == 0} & {x + 1 for x in B if x % 2 != 0}\nprint(C)", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "KeyError", "{2, 4, 6, 8, 10}", "set()", "{12, 16, 20}" ], "explanation": "集合A中全是奇数，x % 2 == 0条件不成立，第一个集合推导式结果为空集。空集与任何集合求交集（&）结果仍为空集set()。" }, { "id": 994, "q": "D = {'year':2023,'month':4,'day':1}，print(max(D.items()))的值为（）", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "2023", "'year'", "('year', 2023)", "error" ], "explanation": "D.items()返回字典的键值对元组视图。max()函数比较元组时先比较第一个元素（键）。字符串比较按字典序，'year' > 'month' > 'day'，因此最大项为('year', 2023)。" }, { "id": 995, "q": "以下选项中，对于递归函数的描述错误的是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "递归调用是指在调用一个函数的过程中又出现直接或间接地调用该函数本身。", "递归调用的调用次数应该是有限次。", "所有函数都可以采用递归调用方式来提高程程执行效率。", "递归函数必须有一个明确的结束条件，称为递归的边界条件或递归出口。" ], "explanation": "并非所有函数都适合递归，递归通常会增加函数调用开销，降低执行效率，甚至可能导致栈溢出。递归必须有明确的边界条件且调用次数有限。" }, { "id": 996, "q": ".以下程序代码的运行结果正确的是（ ）。\nx=5\ny=3\ndef fun():\n    global x,y\n    x=30\n    y=20\nfun()\nprint(\"{},{}\".format(x,y))", "t": "single", "ans": "D", "kp": "函数", "o": [ "5,3", "不能使用同一个global语句指定多个全局变量", "5,20", "30,20" ], "explanation": "函数内部使用global声明x和y为全局变量，因此在fun()中对x和y的赋值会修改全局变量的值。调用fun()后，全局x变为30，y变为20，打印结果为30,20。" }, { "id": 997, "q": "下列程序的运行结果是（ ）。\nadd=lambda x,y=4,z=5:pow(y,x)+x*z\nprint(add(2))", "t": "single", "ans": "C", "kp": "函数", "o": [ "20", "18", "26", "输出不确定值" ], "explanation": "调用add(2)时，x=2，y和z使用默认值4和5。表达式计算为pow(4,2) + 2*5，即16 + 10，结果为26。" }, { "id": 998, "q": "以下程序的运行结果是（）。\ndef mytype(x,y,z=10):\n　　 return x+y+z\nprint(mytype(2,10,13))", "t": "single", "ans": "B", "kp": "函数", "o": [ "22", "25", "23", "12" ], "explanation": "函数调用时传入三个实参2、10、13，分别对应形参x、y、z，覆盖了z的默认值10。执行x+y+z即2+10+13，结果为25。干扰项多为未正确传参或计算错误导致。" }, { "id": 999, "q": "在python中，类中定义静态方法必须用以下哪个来标识（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "@classmethod", "@staticmethod", "不需要标识", "@method" ], "explanation": "Python中定义静态方法需使用@staticmethod装饰器，该方法不依赖类或实例状态，调用时无需传入self或cls参数。@classmethod用于类方法，D选项不存在，C选项错误因为必须显式声明。" }, { "id": 1000, "q": "在下面的代码行中，子类的名称是（）\nclass Rose(Flower):", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "Rose", "Flower", "Rose(Flower)", "以上都不是" ], "explanation": "Python类定义语法为class 子类名(父类名):。此处Rose为正在定义的子类名称，Flower为其继承的父类。选项C是完整定义头而非单纯类名，B是父类，故选A。" }, { "id": 1001, "q": "以下对Python文件处理的描述中，错误的是（ ）", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "文件是存储在辅助存储器上的一组数据序列，可以包含任何数据内容", "可以使用open()打开文件，用close()关闭文件", "使用read()可以从文件中读入全部文本", "使用readlines()可以从文件中读入一行文本" ], "explanation": "readlines()方法用于读取文件所有行并返回一个包含各行字符串的列表，而非仅读取一行。读取单行应使用readline()。A、B、C描述均符合Python文件操作规范，故D错误。" }, { "id": 1002, "q": "以下哪个方法可以返回文件的下一行，并将文件操作标记移到下一行？", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "read()", "readline()", "readlines()", "next()" ], "explanation": "文件对象是可迭代对象，调用内置函数next()可逐行读取并自动移动文件指针。readline()虽也能读一行，但题目特指迭代器协议下的next()行为。read()读全部，readlines()读全部行成列表。" }, { "id": 1003, "q": "{1,2,3,4}.symmetric_difference({4,5,'sdd'}) 的运行结果是（）", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{4，'sdd'}", "{1, 2, 3, 5, 'sdd'}", "{'sdd'}", "{1, 2, 3, 4, 5, 'sdd'}" ], "explanation": "symmetric_difference()计算两个集合的对称差集，即只存在于其中一个集合的元素。两集合共有元素为4，去除后剩余{1, 2, 3, 5, 'sdd'}。A为交集，D为并集，C仅为部分元素，故选B。" }, { "id": 1004, "q": "定义一个用户类(User),用户名(username)和密码(password)是这个类的属性，reset_password()是类的实例方法。\n（1）实例化1个用户。\n（2）调用方法reset_password（） 修改密码。\n请将程序补充完整。\nclass User:\n    def ____1____(self,u,p):\n        self.u=u\n        self.p=p\n        print(\"用户名{},密码{}\".format(self.u,self.p))\n    def reset_password(self,newp):\n        self.p=____2___\n        print(\"用户名{},密码{}\".format(self.u,self.p))\nA=User('liuao',12345)\nA.____3___(12347)", "t": "fill", "ans": "__init__ | newp | reset_password", "kp": "面向对象", "o": [], "explanation": "第1空为类的构造方法，固定命名为__init__，用于初始化实例属性。第2空在reset_password方法中，需将传入的新密码参数newp赋值给实例属性self.p。第3空调用实例方法修改密码，方法名为reset_password。" }, { "id": 1005, "q": "以下程序的输出结果是（ ）\nx=15\ndef add(n):\n    global x\n    x=2\n    k=6\n    for i in range(n):\n        k+=x+i\n    return k\ns=add(5)+x\nprint(s)", "t": "fill", "ans": "28", "kp": "函数", "o": [], "explanation": "调用add(5)时，global x将全局变量x改为2。循环range(5)即i为0到4，k初始6，累加2+0至2+4共20，k最终为26。函数返回26。此时全局x已为2，故s=26+2=28。" }, { "id": 1006, "q": "使用read方法可以读取从当前位置到文件末尾的内容，返回值的类型是[*queNo*]类型。", "t": "fill", "ans": "字符串", "kp": "文件操作", "o": [], "explanation": "Python中文件对象的read()方法默认以文本模式读取从当前位置到文件末尾的所有内容，并将其作为一个完整的字符串返回。若以二进制模式打开则返回bytes类型，但常规考试默认指文本模式下的字符串类型。" }, { "id": 1007, "q": "考生文件夹下存在一个文件PY103.py，请写代码替换横线，不修改其他代码，实现以下功能：\n某商店出售某品牌运动鞋，每双定价160，1双不打折，2双（含）到4双（含）打九折，5双（含）到9双（含）打八折，10双（含）以上打七折，键盘输入购买数量，屏幕输出总额（保留整数）。示例格式如下：\n输入：1\n输出：总额为: 160\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "n = eval(input(\"请输入数量：\"))\nif n>0 and n<=1:\ncost=n*160\nelif n<=4:\ncost=n*160*0.9\nelif n<=9:\ncost=n*160*0.8\nelse:\ncost=n*160*0.7\ncost=int(cost)\nprint(\"总额为:\",cost)", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1008, "q": "下列选项中（ ）是整数。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "\"50\"", "2.0", "-29", "'3'" ], "explanation": "整数类型(int)表示不带小数部分的数值，可正可负。A和D为字符串类型，B为浮点数类型(float)，只有C符合整数定义。" }, { "id": 1009, "q": "关于Python语言的注释，以下选项中描述错误的是（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "Python语言有两种注释方式:单行注释和多行注释", "Python语言的单行注释以#开头", "Python语言的多行注释以三个引号开头和结尾", "Python语言的单行注释以单引号开头" ], "explanation": "Python单行注释以#开头，而非单引号。单引号用于定义字符串。多行注释通常使用三个单引号或双引号包裹。A、B、C描述正确，D明显混淆了字符串界定符与注释符，故选D。" }, { "id": 1010, "q": "语句a=eval(input())执行时，若从键盘输入3.5并按回车键，则a的值是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "3.5", "3", "3.0", "'3.5'" ], "explanation": "input()接收输入返回字符串'3.5'，eval()函数会解析该字符串并执行，将其转换为对应的Python数据类型。此处解析为浮点数3.5，故a的值为3.5。B、C为错误转换结果，D为未使用eval的原始字符串。" }, { "id": 1011, "q": "以下代码的输出结果是（）。\nif 'a':\n    print(\"BBBB\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "BBBB", "a", "无输出", "报错" ], "explanation": "在Python中，非空字符串'a'在布尔上下文中被评估为True。因此，if条件成立，执行其下的代码块，输出'BBBB'。选项B、C、D均不符合Python的布尔值评估规则。" }, { "id": 1012, "q": "在Python中，对于函数定义代码的理解，正确的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "必须存在形参", "必须存在return语句", "形参和return语句都是可有可无的", "形参和return语句要么都存在，要么都不存在" ], "explanation": "Python函数定义中，形参列表可以为空，即函数可以不接受任何参数。同时，如果函数不需要返回特定值，可以省略return语句，此时默认返回None。因此形参和return语句都是可选的。" }, { "id": 1013, "q": "以下程序运行后输出的结果是（ ）\ndef list(*h):\n     h=2*h\n     print(h)\nlist(1,2,3)", "t": "single", "ans": "A", "kp": "函数", "o": [ "(1, 2, 3, 1, 2, 3)", "(1, 2, 3)", "(2, 4, 6)", "参数不正确" ], "explanation": "函数定义中的*h表示接收任意数量的位置参数，并将其打包为一个元组。调用list(1,2,3)时，h的值为(1, 2, 3)。元组乘以2会将其元素重复一次，结果为(1, 2, 3, 1, 2, 3)。" }, { "id": 1014, "q": "在面向对象中，一个对象要求另一个对象实施某项操作的请求，术语称为（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "封装", "继承", "消息", "多态" ], "explanation": "在面向对象编程中，对象之间通过发送\"消息\"来进行通信和交互。一个对象请求另一个对象执行某项操作，本质上就是发送一条消息。封装、继承和多态是面向对象的三大特性，不符合题意。" }, { "id": 1015, "q": "回文字符串是一个正读和反读都一样的字符串，比如“noon”或“蜜蜂蜂蜜”等。现对用户输入的4个字符进行判断，如果是回文字符串，则显示“是”，否则“不是”。请完善代码。\ns=___ (\"请输入4个字符:\")\nif s==s[3]+s[2]+s[1]+ s[0]:\n     print(\"是\")\n___ :\n     print(\"不是\")", "t": "fill", "ans": "input | else", "kp": "程序填空/调试", "o": [], "explanation": "第1空需要获取用户输入，应使用内置函数input()接收字符串。第2空与if语句构成条件分支结构，当if条件不满足时执行，因此应填入else关键字，注意后面需带冒号。" }, { "id": 1016, "q": "执行下列程序后，k的值是[*queNo*]___。\nk=1\nn=263\nwhile n:\n    k*=n%10\n    n//=10\nprint(k)", "t": "fill", "ans": "36", "kp": "循环结构", "o": [], "explanation": "该程序通过循环提取整数n的每一位数字并累乘到k中。初始k=1，n=263。第一次循环：k=1*3=3，n=26；第二次：k=3*6=18，n=2；第三次：k=18*2=36，n=0。循环结束，最终k的值为36。" }, { "id": 1017, "q": "以下程序为获取列表中出现次数最多的元素并输出。请填空。\nlst=[1,2,1,1,4,5,2,3,3]\nnum_i=0\nx=0\nfor i in range(0,len(lst)-1):\n    count=1\n    for j in range(i+1,len(lst)):\n        if ___1_____:\n            count+=1\n    if x0):\n    print(\"正数\")\nelse:\n    print(\"不是正数\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "正数", "不是正数", "报错", "没有输出" ], "explanation": "程序接收输入并转换为整数。当输入为100时，变量a的值为100。条件判断a>0成立，因此执行if分支下的代码，输出'正数'。else分支不会被执行。" }, { "id": 1019, "q": "令list=[i for i in range(1,10,2)]，则print(list[:-1:2])的结果为（ ）", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[1,5,7]", "[1,5]", "[1,3,5,7]", "[5,1]" ], "explanation": "列表推导式生成列表[1, 3, 5, 7, 9]。切片[:-1:2]表示从开头到倒数第一个元素（不包含），步长为2。即取索引0和2的元素，分别为1和5，结果为[1, 5]。" }, { "id": 1020, "q": "程序填空题\ndef find_highest_frequency(text):\n\"\"\"\n统计文本中各个字符的出现频率，并返回出现频率最高的字符。\n\"\"\"\n    frequency = {}\n    for char in text:\n       \n        if char in frequency:\n            frequency[___1____] += 1\n        else:\n            frequency[char] = 1\n    highest_frequency_char =max(frequency, key=frequency.get)\n    return highest_frequency_char\ntext = \"hello world\"\nresult = find_highest_frequency(___2____)\nprint(result)", "t": "fill", "ans": "char | text", "kp": "程序填空/调试", "o": [], "explanation": "第1空在字典中更新已存在字符的频率，键应为当前遍历到的字符，故填char。第2空调用函数时，需要传入待统计的字符串变量，根据上下文应填text。" }, { "id": 1021, "q": "以下for语句中，不能完成1～10的累加功能的是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "for i in range(10,0):sum+=i", "for i in range(1,11):sum+=i", "for i in range(10,-1,-1):sum+=i", "for i in (10,9,8,7,6,5,4,3,2,1):sum+=i" ], "explanation": "range(10,0)默认步长为1，由于起始值大于结束值，该range对象为空，循环体不会执行，无法完成累加。选项B、C、D均能遍历1到10的所有整数并完成累加。" }, { "id": 1022, "q": "类对象拥有的方法，称为（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "类方法", "对象方法", "实例方法", "构造方法" ], "explanation": "在面向对象中，类本身拥有的方法称为类方法（通常使用@classmethod装饰器），而实例对象拥有的方法称为实例方法。题目问的是\"类对象\"拥有的方法，故选类方法。" }, { "id": 1023, "q": "以下程序的输出结果是（）。\na=3.6e-1\nb=4.2e3\nprint(b-a)", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "4199.64", "7.8e2", "0.6e-4", "4199.064" ], "explanation": "科学计数法3.6e-1表示0.36，4.2e3表示4200.0。浮点数相减4200.0-0.36结果为4199.64。Python默认以常规小数形式输出，故选A。干扰项为错误计算或格式。" }, { "id": 1024, "q": "表达式'\\x41'的值为（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "A", "a", "65", "97" ], "explanation": "\\x41是十六进制转义字符，对应ASCII码十进制65，即大写字母A。Python字符串转义序列会直接解析为对应字符，因此值为A。选项C是码值而非字符，B和D对应其他字符，故选A。" }, { "id": 1025, "q": "以下不是Python内置函数的是（）。", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "int()", "float()", "len()", "string()" ], "explanation": "int()、float()和len()均为Python标准内置函数，分别用于类型转换和获取长度。string是标准模块名而非函数，直接调用会引发NameError，故选D。" }, { "id": 1026, "q": "表达式3**2*4//6%7的计算结果是（）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "3", "5", "4", "6" ], "explanation": "运算符优先级为幂运算**最高，乘除取整*、//和取余%同级且从左向右结合。计算过程：3**2得9，9*4得36，36//6得6，6%7得6。最终结果为6，故选D。" }, { "id": 1027, "q": "Python程序设计语言属于（ ）。", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "高级语言", "自然语言", "汇编语言", "机器语言" ], "explanation": "Python语法接近自然语言，屏蔽底层硬件细节，需通过解释器转换为机器码执行，属于典型的高级编程语言。自然语言用于人类交流，汇编和机器语言属低级语言，故选A。" }, { "id": 1028, "q": "以下选项中，不符合Python变量命名规则的是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "student", "_bgm", "5sp", "Teacher" ], "explanation": "Python变量命名规则要求标识符只能含字母、数字和下划线，且不能以数字开头。5sp以数字开头违反语法，其余选项均符合规范，故选C。" }, { "id": 1029, "q": "下列程序的运行结果是（ ）\na=10\na+=a*2\nprint(a)", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "100", "10", "30", "300" ], "explanation": "复合赋值运算符+=右侧先计算。a*2结果为20，a+=20等价于a=a+20，即10+20=30。最终变量a的值为30并输出，故选C。干扰项误将运算顺序或优先级混淆。" }, { "id": 1030, "q": "已知字符'A'的ASCII值是65，字符变量c1的值是'A'，c2的值是'D'，执行语句print(\"%d,%d\"%(c1,ord(c2)-2))后，输出结果是（）", "t": "single", "ans": "B", "kp": "字符串", "o": [ "A,B", "65,66", "65，B", "A，66" ], "explanation": "%d按整数格式化输出。字符A对应ASCII码65，ord(D)返回68，减2得66。格式化字符串将两数替换后输出65,66。本题侧重考查ASCII码与格式化对应关系，故选B。" }, { "id": 1031, "q": "Python语句块的标记是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "花括号", "括号", "缩进", "冒号" ], "explanation": "Python采用严格的缩进来划分代码块，同层级语句必须保持相同缩进量。花括号用于C/Java等语言，括号用于函数或元组，冒号仅用于引出代码块，故选C。" }, { "id": 1032, "q": "Python语句print(\"{:*^10}\".format(\"help\")) 中^代表的含义为（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "左对齐", "右对齐", "居中对齐", "集合运算符" ], "explanation": "格式化字符串中^表示居中对齐，*为填充字符，10为总宽度。该格式会将help居中并用星号填充至10位。<为左对齐，>为右对齐，故选C。" }, { "id": 1033, "q": "下列程序的运行时分别输入3和2，运行结果是（ ）\nx=eval(input())\ny=eval(input())\nprint(x+y)", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "5", "3", "2", "32" ], "explanation": "input()接收字符串，eval()将其解析为数值。输入3和2后x、y均为整数，x+y执行数值加法得5。若未用eval则为字符串拼接32，故选A。" }, { "id": 1034, "q": "以下代码的输出结果是（）。\na,b,c=700,500,300\nif (a>b):\n   a=b\n   b=c\n   c=a\nelif a==b:\n   b=c\n   c=a\nelse:\n   c=a\nprint(a,b,c)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "700 500 700", "500 300 700", "700 300 700", "500 300 500" ], "explanation": "初始a=700,b=500,c=300。条件a>b成立进入if块顺序执行：a=b使a变500；b=c使b变300；c=a此时a已为500故c变500。最终输出500 300 500，故选D。" }, { "id": 1035, "q": "下列代码的输出结果是（ ）\nx={1}\ny=0\nif x:\n    y=1\nelse:\n    y=-1\nprint(y)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "0", "1", "-1", "出错" ], "explanation": "变量x被赋值为包含元素1的集合{1}。在Python中，非空集合的布尔值为True。因此if x条件成立，执行y=1，最终打印y的值为1。" }, { "id": 1036, "q": "设char ch='b'，表达式ch= chr(ord(ch)-32) if (ch>='a'and ch<='z') else ch的值是（　　）。", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "'B'", "'b'", "'Z'", "'z'" ], "explanation": "题目虽带有C语言变量声明风格，但核心考察Python条件表达式与字符函数。ch为'b'，满足大于等于'a'且小于等于'z'的条件，执行chr(ord('b')-32)。ord('b')为98，减32得66，chr(66)返回大写字母'B'。" }, { "id": 1037, "q": "以下代码的输出结果为（）。\nx=False\ny=True\nz=True\nif not x:\n   if y:\n      print(1)\n   else:\n      print(2)\nelif not x or y or not y and x:\n   print(3)\nelse:\n   print(4)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "1", "2", "3", "4" ], "explanation": "变量x为False，not x为True，因此进入第一个if分支。在该分支内，判断y的值，y为True，故执行print(1)并输出1。由于第一个if条件已满足，后续的elif和else分支均被跳过。" }, { "id": 1038, "q": ">>> a=30\n>>> b=30\n>>> a is not b的结果为（ ）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "False", "True", "不确定", "错误" ], "explanation": "Python对小整数（通常在-5到256之间）采用对象缓存机制。变量a和b均被赋值为30，它们指向内存中的同一个整数对象。因此a is b为True，a is not b的结果为False。" }, { "id": 1039, "q": "以下的描述中，不属于Python语言控制结构的是（　　）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "分支结构", "程序异常", "跳转结构", "顺序结构" ], "explanation": "Python语言的控制结构主要包括顺序结构、分支结构、循环结构以及异常处理结构。Python不支持goto语句，因此不存在传统的跳转结构。" }, { "id": 1040, "q": "以下代码的输出结果是（ ）。\nsum=0\nfor s in range(1,6):\n    sum=sum+s\nprint(sum)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "10", "5", "0", "15" ], "explanation": "range(1,6)生成序列1、2、3、4、5。循环依次将这些值累加到变量sum中。计算过程为0+1+2+3+4+5，最终sum的值为15。" }, { "id": 1041, "q": "以下循环执行（ ）次。\ns=0\nwhile not s:\n      s=1", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1", "0", "3", "2" ], "explanation": "初始时s为0，not s为True，进入while循环。循环体内将s赋值为1。再次判断条件时，not 1为False，循环终止。因此该循环仅执行了1次。" }, { "id": 1042, "q": "以下程序段的运行结果是（ ）。\nsum=0\nfor i in range(6):\n    if i%2:\n        continue\n    sum=sum+i\nprint(sum)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "5", "6", "3", "4" ], "explanation": "range(6)生成0到5的整数。当i为奇数时，i%2为True，执行continue跳过本次循环；当i为偶数（0、2、4）时，将其累加到sum中。最终sum的值为0+2+4=6。" }, { "id": 1043, "q": "以下代码的输出结果是（ ）。\nsum=0\nlis=[1,2,3,4,5]\nfor s in lis:\n      if s%2==1 :\n              sum=sum+s\nelse:sum=sum*2\nprint(sum)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "8", "18", "9", "2" ], "explanation": "循环遍历列表，将奇数1、3、5累加到sum中，循环正常结束时sum为9。由于循环未被break中断，触发for-else结构中的else分支，执行sum=sum*2，最终输出18。" }, { "id": 1044, "q": "执行下列循环语句后，变量i的值是        。\nk=2\nwhile k:\n       k=k-1\n       for i in range(1,5):\npass", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "3", "4", "5", "7" ], "explanation": "外层while循环执行2次。每次执行时，内层for循环遍历range(1,5)，即1、2、3、4。循环正常结束后，循环变量i保留最后一次迭代的值。因此无论外层循环执行几次，最终i的值均为4。" }, { "id": 1045, "q": "以下关于字符串类型的操作的描述，错误的是：（ ）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "字符串函数strip的作用是去掉字符串两侧空格符或指定字符", "把一个字符串str所有的字符都小写，用str.lower()", "获取字符串str的长度，用字符串处理函数 str.len()", "设 x = '123' ，则执行x*2的结果是'123123'" ], "explanation": "在Python中，获取字符串长度应使用内置函数len(str)，而不是字符串的方法str.len()。选项A的strip()、选项B的lower()以及选项D的字符串乘法重复操作均描述正确。" }, { "id": 1046, "q": "关于字符串下列说法错误的是（）。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "字符应该视为长度为1的字符串", "字符串的字符下标从1开始编号", "既可以用单引号，也可以用双引号创建字符串", "在三引号字符串中可以包含换行回车等特殊字符" ], "explanation": "Python中字符串的索引（下标）是从0开始编号的，而不是从1开始。选项A中字符是长度为1的字符串，选项C中单双引号均可创建字符串，选项D中三引号支持多行和特殊字符，这三项描述均正确。" }, { "id": 1047, "q": "已知list1=[i*2 for i in 'join']，执行print(list1) 后输出结果是（ ）", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "错误", "join join", "[2,4,6,8]", "['jj', 'oo', 'ii', 'nn']" ], "explanation": "列表推导式遍历字符串'join'中的每个字符，i*2表示将字符重复两次。因此'j'变'jj'，'o'变'oo'，'i'变'ii'，'n'变'nn'，最终生成包含这四个字符串的列表。" }, { "id": 1048, "q": "令tup3=tuple([i**2 for i in range(5)])，则print(tup3 [::-1])的结果为（ ）", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "(0, 1, 4, 9, 16)", "(0, 1, 2, 3, 4)", "(16, 9, 4, 1, 0)", "16, 9, 4, 1, 0" ], "explanation": "列表推导式生成[0, 1, 4, 9, 16]，转为元组后为(0, 1, 4, 9, 16)。切片[::-1]表示步长为-1，即逆序输出整个元组，结果为(16, 9, 4, 1, 0)。注意输出仍保留元组的括号。" }, { "id": 1049, "q": "下列Python程序的运行结果是（ ）。\nlst=['apple','b','c',10]\nlst.append(['red'])\nprint(len(lst))", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "3", "4", "5", "6" ], "explanation": "初始列表lst有4个元素。append()方法将参数作为一个整体添加到列表末尾，因此['red']作为一个列表元素被加入，lst变为包含5个元素的列表。若使用extend则长度会变为6。" }, { "id": 1050, "q": "set1=set(\"字典\"),set2=set(\"集合\"),set1|set2的结果可能是（ ）。", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{\"字典集合\"}", "{\"典\",\"字\",\"集\",\"合\"}", "\"字典集合\"", "[\"字典集合\"]" ], "explanation": "set('字典')将字符串拆分为字符集合，同理set2为{'集', '合'}。|是集合的并集运算符，合并两个集合得到包含这四个字符的集合。集合元素无序，输出顺序可能不同，但内容一致。" }, { "id": 1051, "q": "以下关于组合数据类型的描述，错误的是：( )。", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "集合类型是一种具体的数据类型", "字典按键取值，键的值具有唯一性", "python 的集合类型跟数学中的集合概念一致，都是多个数据项", "键值对(key,value)在字典中表示形式为--" ], "explanation": "A、B、C描述均正确。D选项中，字典的键值对表示形式应为key: value（使用冒号分隔键和值），而不是使用--连接，因此D选项的描述是错误的。" }, { "id": 1052, "q": "有以下函数的定义：\ndef func1():\n     pass\n则以下说法错误的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "pass是空语句，通常用作占位符", "该函数返回None", "该函数返回随机值", "此函数为空函数" ], "explanation": "pass是空语句，起占位作用，因此该函数体为空。在Python中，未显式使用return语句返回值的函数，默认返回None，绝不会返回随机值。因此C选项说法错误。" }, { "id": 1053, "q": "下列代码运行后的结果是（ ）。\ndef Kai(s):\n    if len(s) <= 1:\n        return s\n    else:\n        return s[0]+Kai(s[1:len(s)])\nprint(Kai(('Computer')))", "t": "single", "ans": "C", "kp": "函数", "o": [ "retupmom", "Compute", "Computer", "retupmoC" ], "explanation": "该递归函数每次提取字符串首字符s[0]，并与剩余子串s[1:]的递归结果拼接。这实际上是将原字符串按原顺序重新拼接，并未进行反转操作。因此输入'Computer'，输出仍为原字符串。" }, { "id": 1054, "q": "以下程序代码的运行结果正确的是（ ）。\ns = 'global'\ndef fun(s):\n      print(s)\nfun('How')\nprint(s)", "t": "single", "ans": "C", "kp": "函数", "o": [ "global\nglobal", "How\nHow", "How\nglobal", "global\nHow" ], "explanation": "函数fun接收参数s并打印，调用fun('How')时打印局部变量'How'。函数外部的全局变量s未被修改，因此随后的print(s)打印全局变量'global'。最终依次输出How和global。" }, { "id": 1055, "q": "运行下列代码的输出结果是（ ）。\nf=lambda x,y,z:1+2*x+y**3+z*y\nprint(f(3,2,1))", "t": "single", "ans": "B", "kp": "函数", "o": [ "18", "17", "16", "15" ], "explanation": "匿名函数表达式为1 + 2*x + y**3 + z*y。代入参数x=3, y=2, z=1，计算过程为：1 + 2*3 + 2**3 + 1*2 = 1 + 6 + 8 + 2 = 17。因此输出结果为17。" }, { "id": 1056, "q": "以下程序运行后输出的结果是（ ）\ndef sort(x,n):\n    for i in range(n-1):\n        k=i\n        for j in range(i+1,n):\n            if x[k]>>hex(255)", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "'0eff'", "'0off'", "'0xff'", "'0bff'" ], "explanation": "hex()函数将整数转换为十六进制字符串，前缀为'0x'。255的十六进制表示为ff，因此结果为'0xff'。其他选项前缀或字母不符合十六进制规范。" }, { "id": 1089, "q": "以下代码的输出结果是（ ）。\nage=42\nif 25＝60:\n    print(\"作为一个老师，你可以退休了\")\nelse:\n    print(\"作为一个老师，你很有爱心\")", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "作为一个老师，你很年轻", "作为一个老师，你太年轻了", "作为一个老师，你可以退休了", "作为一个老师，你很有爱心" ], "explanation": "题面中if 25＝60:使用了全角等号，实际运行会报语法错误。但按命题意图，此处应为==比较运算符。25不等于60，条件为假，程序执行else分支，输出对应字符串。" }, { "id": 1090, "q": "下面的代码在运行时输入“2”，则输出结果是（）。\nx=input()\nif x>= '1':\n   if x>= '0' and x<='1':\n      print('01')\nelse:\n      print('02')\nelse:\n   print('1')", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "01", "02", "1", "报错" ], "explanation": "代码中if与else的缩进层级混乱，且存在两个else分支试图匹配同一个if结构，违反Python语法规范。解释器在解析时会直接抛出缩进或语法错误，程序无法正常运行。" }, { "id": 1091, "q": "关于Python循环结构，下列叙述中错误的是（）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "while循环只能用来实现无限循环", "所有的for循环都可以用while循环改写", "保留字break可以终止一个循环", "continue可以终止后续代码的执行，从循环的开头重新执行" ], "explanation": "while循环既可实现无限循环，也可通过条件控制实现有限次循环。A项只能表述绝对化，故错误。B、C、D均符合Python循环机制的基本特性。" }, { "id": 1092, "q": "已知x=list(range(21)) 那么表达式x[-1]的值为（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "0", "1", "20", "21" ], "explanation": "range(21)生成0到20的整数序列，转为列表后共21个元素。Python支持负数索引，x[-1]表示访问列表最后一个元素，即20。" }, { "id": 1093, "q": "s1 = {1, 2, 3}，s2 = {2, 3}。请给出下面代码段的正确答案（）\nA = {11, 34, 45, 55, 68, 85}\nB = {24, 47, 54, 58, 61, 78}\nC = {11,85}\nprint(B.isdisjoint(A),C.issubset(A))", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "True,True", "True,False", "False,True", "False,False" ], "explanation": "isdisjoint()判断两集合是否无交集，B与A元素完全不同，返回True。issubset()判断是否为子集，C中元素11和85均在A中，故C是A的子集，返回True。结果为True True。" }, { "id": 1094, "q": "以下代码的输出是什么？\nd = {'a': 1, 'b': 2, 'c': 3}\nd.update({'b': 4, 'd': 5})\nprint(d)", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{'a': 1, 'b': 2, 'c': 3, 'd': 5}", "{'a': 1, 'b': 4, 'c': 3, 'd': 5}", "{'a': 1, 'b': 4, 'c': 3}", "{'a': 1, 'b': 2, 'c': 3, 'd': 2}" ], "explanation": "update()方法会用新字典的键值对更新原字典。若键已存在则覆盖原值（b由2变为4），若键不存在则新增（添加d:5）。最终字典为{'a':1,'b':4,'c':3,'d':5}。" }, { "id": 1095, "q": "以下程序运行后输出的结果是（ ）\ndef show(x,**ar):\n      print(x,ar)\nshow(30,xing='liu',age=19)", "t": "single", "ans": "D", "kp": "函数", "o": [ "30,xing='liu',age=19", "30, 'liu',19", "30, {'liu',19}", "30 {'xing': 'liu', 'age': 19}" ], "explanation": "函数定义中**ar用于接收任意数量的关键字参数，并将其打包为字典。调用时传入xing='liu',age=19，故ar为{'xing':'liu','age':19}。print输出位置参数30与该字典，中间以空格分隔。" }, { "id": 1096, "q": "在如下定义的Car类中，自定义speed对象方法（实例方法），功能是输出：行驶速度为60km/h。以下代码书写正确的是（）\nclass Car():\n    def __init__(self):\n        self.name=\"宝马\"", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "def speed():\nprint('行驶速度为60km/h')", "def speed(self):\nprint('行驶速度为60km/h')", "def speed(self)\nprint('行驶速度为60km/h')", "def speed()\nprint('行驶速度为60km/h')" ], "explanation": "Python类的实例方法第一个参数必须为self，用于绑定实例对象。方法定义末尾需加冒号:。A缺少self，C和D缺少冒号，仅B符合实例方法的标准语法定义。" }, { "id": 1097, "q": "执行以下程序段，描述错误的是（ ）。\nfout=open(\"yourfile.txt\",\"w+\")\nwith open(\"yourfile.py\",\"r+\") as f:\nLines=f.readlines()\nfor item in lines:\n    fout.write(item)\nprint(item,end=\"\")\nfout.close()", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "list是列表文件", "将文件yourfile.py输出", "将文件yourfile.py复制到yourfile.txt文件中", "程序执行后，yourfile.py文件未关闭，需要使用close()方法关闭" ], "explanation": "with语句会在代码块执行完毕后自动关闭文件，因此yourfile.py会自动关闭，不需要手动调用close()方法，D选项描述错误。A选项表述虽不严谨但readlines()返回的是列表；B和C选项描述了程序的实际功能，即将源文件内容读取并写入目标文件中。" }, { "id": 1098, "q": "以下哪个方法可以将文件指针移动到指定位置？", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "read()", "write()", "seek()", "move()" ], "explanation": "在Python文件操作中，seek()方法用于移动文件指针到指定位置。read()用于读取文件内容，write()用于写入内容，而Python文件对象没有move()方法。因此正确选项为seek()。" }, { "id": 1099, "q": "已知，y=1+1/3+1/5+…+1/(2n-1)，以下程序是求y>3时的最小n值，请填空。\nn=1\n   1   \nwhile y\n    f=1.0/(2*n-1)            #求累加项\n    y+=f                       #累加\n    n+=1\nprint(\"y>3时的最小n值为{}\".format(    2     ))", "t": "fill", "ans": "y=0 | n-1", "kp": "程序填空/调试", "o": [], "explanation": "第1空需要初始化累加变量y，由于后续进行累加操作，初始值应设为0，即y=0。第2空用于输出满足条件时的最小n值，由于循环体内在累加后执行了n+=1，导致退出循环时n比实际满足条件的n值大1，因此需要输出n-1。" }, { "id": 1100, "q": "Python中对变量的描述，错误的选项是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "变量内置函数type()返回对象的类型", "变量的值在程序运行的过程中不可以被改变", "变量在使用前必须赋值", "在Python中，允许多个变量指向同一个值" ], "explanation": "Python中的变量是动态类型的，且在程序运行过程中可以被重新赋值，从而改变其指向的值或对象，因此B选项描述错误。A选项type()可返回类型，C选项变量使用前必须赋值，D选项多个变量可指向同一对象，均描述正确。" }, { "id": 1101, "q": "下面的循环语句中（ ）是无限循环。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "for i in range(10):\nfor a in range(10):\nprint (a)", "for i in range(0,2):\nwhile i", "for i in range(1,5):\nwhile i>5:\nbreak", "for a in range(1,3):\nfor i in range(a):\nif not a:\nbreak" ], "explanation": "选项B中，当外层for循环i取值为1时，内层while i即while 1，条件永远为真且循环体内没有改变i的值或break语句，从而导致无限循环。其他选项中的循环均有明确的终止条件或执行次数限制。" }, { "id": 1102, "q": "字典中的键（key）必须满足什么条件？", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "可以是任意数据类型", "必须是字符串类型", "必须是整数类型", "必须是不可变类型" ], "explanation": "Python字典的键必须是可哈希的，即必须是不可变类型（如字符串、数字、元组等），以确保键的唯一性和哈希值的稳定性。列表、字典等可变类型不能作为字典的键。" }, { "id": 1103, "q": "下列代码的运行结果是（ ）。\ny=lambda a,b:a*b\nprint(y(2,[1,2]))", "t": "single", "ans": "A", "kp": "函数", "o": [ "[1, 2, 1, 2]", "[2,4]", "(1,2,1,2)", "(2,4)" ], "explanation": "lambda函数定义了a和b的乘积操作。当传入参数2和列表[1,2]时，表达式为2乘以[1,2]。在Python中，整数与列表相乘表示将列表重复指定次数，因此结果为[1, 2, 1, 2]。" }, { "id": 1104, "q": "关于Python复数类型的描述，以下选项错误的是（）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "实数部分和虚数部分都是浮点数", "虚数部分通过\"j\"或\"J\"来表示", "对于复数x，可以使用x.real获得x的虚数部分", "虚数部分为1时，1不能省略" ], "explanation": "在Python中，复数x的实部通过x.real获取，虚部通过x.imag获取。因此C选项描述错误。A、B、D选项关于复数实部虚部为浮点数、虚部用j或J表示、虚部为1时1不能省略的描述均正确。" }, { "id": 1105, "q": "在Python中，下列常量引用不正确的是（）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "\"56\"", "\"Good\"", "56", "Good" ], "explanation": "Python中字符串常量必须用引号（单引号或双引号）括起来。数字56是合法的数值常量。而Good没有加引号，会被解析器视为变量名而非常量，因此引用不正确。" }, { "id": 1106, "q": "表达式34%6的结果是（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "6", "5", "4", "3" ], "explanation": "%是取模运算符，用于计算两个数相除后的余数。34除以6商为5，余数为4，因此34%6的计算结果为4。" }, { "id": 1107, "q": "以下变量名中，符合Python语言变量命名规则的是（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "33_keyword", "key@word33_", "nonlocal", "_33keyword" ], "explanation": "Python变量名只能包含字母、数字和下划线，且不能以数字开头，也不能是关键字。A以数字开头，B包含非法字符@，C是Python关键字。D以下划线开头，后跟数字和字母，符合命名规则。" }, { "id": 1108, "q": "Python中对变量的描述，错误的选项是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "变量的类型可以用type()函数查询", "变量在赋值时需要声明类型", "变量在使用前必须赋值", "变量的值是可以改变的" ], "explanation": "Python是动态类型语言，变量在赋值时不需要显式声明类型，解释器会根据赋给变量的值自动推断其类型。因此B选项描述错误。A、C、D选项关于type()查询类型、使用前必须赋值、值可改变的描述均正确。" }, { "id": 1109, "q": "以下赋值语句中合法的是（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "x=1,y=2", "x=y=2", "x=1 y=2", "x=1：y=2" ], "explanation": "Python支持链式赋值，x=y=2会将2同时赋给x和y，语法合法。A项逗号分隔在普通赋值中非法；C项缺少语句分隔符；D项使用了非法符号。故选B。" }, { "id": 1110, "q": "Python是（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "机器语言", "汇编语言", "编译型语言", "解释型语言" ], "explanation": "Python属于高级编程语言，其代码在运行时由解释器逐行翻译执行，而非预先编译为机器码，因此是解释型语言。机器语言和汇编语言属于低级语言，C项不符合Python运行机制。故选D。" }, { "id": 1111, "q": "以下程序的输出结果是（ ）\nq = 123.456\nprint(\"{0:-^9.1f}\".format(q))", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "123.5", "123.456", "--123.5--", "----123.5" ], "explanation": "格式化字符串中-为填充字符，^表示居中对齐，9为总宽度，.1f表示保留1位小数。123.456四舍五入为123.5（占5字符），总宽9需补4个-，居中分布为左右各2个，结果为--123.5--。故选C。" }, { "id": 1112, "q": "下列语句执行后的输出是（）。\nx=5\nif x<2:\n   print(5)\nelif x>30:\n   print(6)\nelse:\n   print(7)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "56", "7", "5", "6" ], "explanation": "x=5时先判断x<2，条件不成立；再判断elif x>30，5>30也不成立；因此执行else分支，输出7，对应选项B。" }, { "id": 1113, "q": "以下代码的输出结果是（）。\nage=22\nif age<=30:\n    print(\"作为一个老师，你很年轻\")\nelse:\n    print(\"作为一个老师，你很有爱心\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "作为一个老师，你很年轻", "报错", "无输出", "作为一个老师，你很有爱心" ], "explanation": "变量age赋值为22，满足age<=30条件，因此执行if分支的print语句，输出对应文本。else分支不会执行。代码语法正确，无报错。故选A。" }, { "id": 1114, "q": "3.5>1 or 3.5<1 的值为（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "逻辑运算符or遵循短路求值，左侧3.5>1为真，整个表达式直接返回True，不再计算右侧。Python布尔值标准输出为True/False，而非T/F。故选B。" }, { "id": 1115, "q": "若输入x为65，输出的grade是（）\nx=int(input())\nif x>=60:\n   if x<=70:\n      grade='C'\n   else:\n      grade='B'\nelse:\n   grade='D'\nprint(grade)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "A", "B", "C", "D" ], "explanation": "输入x为65，首先满足外层x>=60，进入内层判断。内层x<=70成立，执行grade='C'。随后跳过else分支，最终打印grade的值为C。故选C。" }, { "id": 1116, "q": "将数学式22 or x <=10" ], "explanation": "数学区间需同时满足两个条件，Python中逻辑与使用and连接。2y: maxnum=x\nprint(maxnum)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "30", "20", "10", "报错" ], "explanation": "初始maxnum被赋值为x的值20。条件x>y（20>30）为假，因此if语句块不执行，maxnum保持原值20不变。最终print输出20。故选B。" }, { "id": 1118, "q": "以下代码的输出结果是（ ）。\nsum=0\nfor s in range(6):\n    if s%2==1 :\n        sum=sum+s\nelse:\n      sum=sum*2\nprint(sum)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "9", "18", "15", "6" ], "explanation": "range(6)遍历0到5。奇数1、3、5累加到sum，循环结束时sum=9。for循环后的else块在循环正常结束后执行，因此执行sum=sum*2，9*2=18。最终输出18。故选B。" }, { "id": 1119, "q": "以下程序的运行结果是（ ）。\nm=2\nfor i in range(3,0,-1):\n    if i*m>3:\n        continue\n    m*=i\nprint(\"m=\",m)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "m=2", "m=3", "m=6", "m=4" ], "explanation": "循环i依次取3、2、1。i=3时i*m=6>3成立，continue跳过，m仍为2。i=2时i*m=4>3成立，continue跳过，m仍为2。i=1时条件不成立，执行m*=i即m=2*1=2。循环结束输出m=2。故选A。" }, { "id": 1120, "q": "s=\"hello world\"，不能产生新的序列的是（）", "t": "single", "ans": "D", "kp": "字符串", "o": [ "s[0:5:2]", "s[-1:-5:-1]", "s[-1:]", "s[0:5:-1]" ], "explanation": "切片步长为负时，起始索引应大于终止索引才能截取到元素。D项start=0, stop=5, step=-1方向矛盾，无法截取有效字符，返回空序列。其他选项均能正确截取非空子串。故选D。" }, { "id": 1121, "q": "表达式“['a'] in ['a','b','c','d',['a']]”的值是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "Yes", "No", "True", "False" ], "explanation": "表达式判断列表 ['a'] 是否存在于目标列表中。目标列表的第五个元素正是列表 ['a']，因此 in 运算符返回布尔值 True，而不是字符串形式的 Yes。" }, { "id": 1122, "q": "令tup=(1,2,3,4,5)，则print(tup[::3])的结果为（ ）", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "(1, 2, 3)", "(1, 3, 5)", "1, 4", "(1, 4)" ], "explanation": "元组切片 tup[::3] 表示从索引0开始，步长为3进行截取。索引0对应元素1，索引3对应元素4，索引6超出范围。切片结果仍为元组，即 (1, 4)。" }, { "id": 1123, "q": "字符串 str=\"cat dog tiger\"，以下程序的输出结果是：（ ）。\nstr= \"cat dog tiger\"\nls=str.split()\nls.reverse()\nprint(ls)", "t": "single", "ans": "D", "kp": "字符串", "o": [ "'tiger', 'dog', 'cat'", "tiger dog cat", "None", "['tiger', 'dog', 'cat']" ], "explanation": "split() 默认按空格分割字符串，生成列表 ['cat', 'dog', 'tiger']。reverse() 方法将列表原地反转，变为 ['tiger', 'dog', 'cat']。print 直接输出该列表对象，保留列表格式。" }, { "id": 1124, "q": "set中的元素是否按特定顺序排序？", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "是的，按插入顺序排序", "是的，按字母顺序排序", "是的，按数字顺序排序", "否，元素是无序的" ], "explanation": "Python 中的集合（set）是一个无序的不重复元素序列。它不支持索引，也不按插入顺序、字母或数字顺序进行排序，因此元素是无序的。" }, { "id": 1125, "q": "以下程序的输出结果是：( )。\nd = {\"Wu\":\"China\", \"Liu\":\"America\", \"Nan\":\"Korea\"}\nprint(max(d),min(d))", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "Korea America", "Wu:China Liu:America", "China America", "Wu Liu" ], "explanation": "对字典使用 max() 和 min() 函数时，默认比较的是字典的键。键 Wu、Liu、Nan 按 ASCII 码比较，W 最大，L 最小，因此输出结果为 Wu Liu。" }, { "id": 1126, "q": "被调函数通过( )语句，将值返回给主调函数。", "t": "single", "ans": "A", "kp": "函数", "o": [ "return", "for", "while", "if" ], "explanation": "在 Python 中，return 语句用于从函数中返回结果给调用者，并结束函数的执行。for、while 和 if 分别是循环和条件控制语句，不具备返回值的功能。" }, { "id": 1127, "q": "下列代码运行后的结果是（ ）。\ndef fact(s):\n    if len(s) <= 1:\n        return s\n    else:\n        return fact(s[1:])+s[0]\nprint(fact(('Myfile')))", "t": "single", "ans": "D", "kp": "函数", "o": [ "Myfile", "Myfil", "lifmM", "elifyM" ], "explanation": "该递归函数通过 s[1:] 截取除首字符外的子串进行递归，并将首字符 s[0] 拼接到末尾，从而实现字符串反转。输入 'Myfile'，反转后的结果为 'elifyM'。" }, { "id": 1128, "q": "在Python程序中，关于全局变量和局部变量，以下选项描述错误的是（ ）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "局部变量是指函数内部或语句块内定义的变量，其作用范围只能在其定义的函数内部或语句块内起作用。", "在函数外部定义的变量为全局变量。全局变量作用范围与其定义的位置有关，作用域为定义点到文件尾。", "全局变量有利于函数间共享多个数据，即增加各函数间数据联系的渠道。", "全局变量与局部变量同名时，程序执行到局部变量时，全局变量起作用。" ], "explanation": "当全局变量与局部变量同名时，在函数内部局部变量会屏蔽全局变量，即局部变量起作用，而非全局变量起作用。若要修改全局变量，需使用 global 关键字声明。因此选项 D 描述错误。" }, { "id": 1129, "q": "下列代码的运行结果是（ ）。\ny=lambda a,b:a+b\nprint(y('My','Fi'))", "t": "single", "ans": "D", "kp": "函数", "o": [ "My+Fi", "Fi+My", "FiMy", "MyFi" ], "explanation": "lambda 表达式定义了一个匿名函数，返回两个参数的和。当传入字符串 'My' 和 'Fi' 时，+ 运算符执行字符串拼接操作，结果为 'MyFi'。" }, { "id": 1130, "q": "以下关于函数调用说法错误的是（ ）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "函数调用函数的实际参数和形式参数不需要同名。", "函数形参不用指定参数类型，Python会自动根据实参的值来确定参数的类型。", "函数的实际参数可以是表达式或常量。", "对于关键字参数，实参的个数必须与形参个数一致且一一对应。" ], "explanation": "使用关键字参数调用函数时，实参通过参数名与形参匹配，不要求位置一一对应。此外，若形参有默认值，实参个数也可少于形参个数。因此\"必须一致且一一对应\"的说法错误。" }, { "id": 1131, "q": "以下程序的运行结果是（）\nclass Person:\n    place='南昌'\n    def __init__(self):\n        self.place='北京'\n        self.__place='上海'\np=Person()\np.place='南京'\nprint(Person.place)", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "南昌", "北京", "上海", "运行错误" ], "explanation": "Person.place 访问的是类属性，其值在类定义时初始化为 '南昌'。实例属性 self.place 的修改以及实例 p.place 的重新赋值，均不会影响类属性的值，故输出 '南昌'。" }, { "id": 1132, "q": "以下代码创建了一个football对象：football=Ball()，调用football对象的play方法，下列选项正确的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "Football.play()", "football.Play()", "football.play()", "football.play" ], "explanation": "在 Python 中，调用对象的方法需要使用\"对象名.方法名()\"的格式。已知对象名为 football，方法名为 play，因此正确的调用方式为 football.play()，注意区分大小写和括号。" }, { "id": 1133, "q": "下列代码行中，定义的新类名是（）\nclass B（A）:", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "class", "A", "B", "以上都不是" ], "explanation": "Python定义类的语法为class 类名(父类):。此处B为新定义的类名，A为继承的父类名，class是关键字。因此正确选项为C。" }, { "id": 1134, "q": "以下不属于Python文件操作方法的是（ ）。", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "read()", "write()", "join()", "readline()" ], "explanation": "read()、write()和readline()均为Python内置文件对象的标准读写方法。join()是字符串对象的方法，用于将序列元素连接成新字符串，不属于文件操作方法。故选C。" }, { "id": 1135, "q": "以下哪个方法会把缓冲区的内容写入磁盘，不关闭文件？", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "write()", "close()", "flush()", "tell()" ], "explanation": "flush()方法用于强制将文件缓冲区中的数据立即写入磁盘，同时保持文件处于打开状态。close()会关闭文件，write()仅写入缓冲区，tell()返回文件指针位置。因此选C。" }, { "id": 1136, "q": "遍历字符串\"PythonNice!\"，当遇到字符'i'时，结束遍历，输出字符'i'之前的字符串。请在划线处添加适当的代码将程序补充完整。\nfor s in \"PythonNice!\":\n        1    s==\"i\":\n               2     \n    print(s,end=\"\")", "t": "fill", "ans": "if | break", "kp": "程序填空/调试", "o": [], "explanation": "第1空需填入条件判断关键字if，用于检测当前字符s是否为'i'。第2空需填入循环控制语句break，当条件满足时立即终止for循环，从而停止后续字符的输出。两者配合实现提前退出逻辑。" }, { "id": 1137, "q": "有以下程序，请写代码替换横线，不修改其他代码，实现以下功能。\n定义一个Circle类，根据圆的半径求周长和面积。再由Circle类创建两个圆对象，其半径分别为5和10，要求输出各自的周长和面积。\n运行结果如图7.8所示。\n图7.8 运行结果\n程序代码如下：\n#请在[*queNo*]处使用一行代码或表达式替换\n#注意不要修改其他代码\nimport math\nclass Circle:\n    def __1___(self,radius=5):\n        self.radius=radius\n    def getPeriameter(self):\n        return 2*math.pi*self.radius\n    def getArea(self):\n    return math.pi*self.radius*self.radius\nc1=Circle()\nc2=____2____\nprint('半径='+str(c1.radius),'周长='+str(c1.getPerimeter()),'面积='+str(c1.getArea()),sep=\",\")\nprint('半径='+str(c2.radius),'周长='+str(c2.getPerimeter()),'面积='+str(c2.getArea()),sep=\",\")", "t": "fill", "ans": "__init__ | Circle(10)", "kp": "面向对象", "o": [], "explanation": "第1空为类的构造方法，Python中固定命名为__init__，用于初始化实例属性。第2空需创建第二个圆对象，根据题意半径为10，故调用类构造函数Circle(10)实例化对象c2。", "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-output-circle-1137.png" }, { "id": 1138, "q": "下列程序的输出结果是[*queNo*]___。\nfor i in \"miss\":\n    for j in range(3):\n        print(i,end='')\n        if i==\"i\":\n            break", "t": "fill", "ans": "mmmissssss", "kp": "循环结构", "o": [], "explanation": "外层遍历'miss'。首字符'm'时内层循环3次打印'm'得'mmm'。次字符'i'时内层打印1次'i'后触发break跳出内层得'i'。后两个's'各触发内层3次打印，各得'sss'。拼接结果为mmmissssss。" }, { "id": 1139, "q": "执行以下程序，输出结果是：[*queNo*]____。\nlist1=[ i*2 for i in 'ABC']\nprint(list1[0])", "t": "fill", "ans": "AA", "kp": "列表/元组", "o": [], "explanation": "列表推导式遍历字符串'ABC'，对每个字符执行i*2（字符串乘法表示重复）。'A'*2结果为'AA'，生成列表['AA','BB','CC']。索引[0]取首元素，故输出AA。" }, { "id": 1140, "q": "程序填空题\ndef remove_duplicates(words):\n\"\"\"\n接受一个包含重复元素的列表，并返回一个去重后的列表。\n\"\"\"\n    unique_words = list(___1_____(____2____))\n    return unique_words\nword_list = ['apple', 'banana', 'cherry', 'apple', 'durian']\nresult = remove_duplicates(word_list)\nprint(result)", "t": "fill", "ans": "set | words", "kp": "字典/集合", "o": [], "explanation": "第1空填set，利用集合类型自动去除重复元素的特性。第2空填words，将传入的列表作为参数传入set()构造函数。外层list()再将去重后的集合转回列表，完成去重功能。" }, { "id": 1141, "q": "下面代码段运行的结果是[*queNo*]___。\nclass Car():\n    def __init__(self,name,speed):\n        self.name=name\n        self.speed=speed\nclass Bicycle(Car):\n    def __init__(self,name,speed,color):\n        Car.__init__(self,name,speed)\n        self.color=color\nb=Bicycle('自行车','5km/h','黑色的')\nprint(b.name)", "t": "fill", "ans": "自行车", "kp": "面向对象", "o": [], "explanation": "Bicycle继承自Car，其__init__方法中通过Car.__init__(self,name,speed)调用父类构造器，将传入的'自行车'赋值给self.name。实例化后访问b.name属性，直接输出该字符串。" }, { "id": 1142, "q": "考生文件夹下存在一个文件PY103.py，请写代码替换横线，不修改其他代码，实现以下功能：\n以123为随机数种子，随机生成10个在1(含)到999(含)之间的随机数，每个随机数后跟随一个逗号进行分隔，屏幕输出这10个随机数。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import random\nrandom.seed([x])\n注意：seed()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。\n参数x -- 改变随机数生成器的种子seed。\nrandint(a,b)随机数中是包括a和b区间的数。\n参数代码如下：\nimport random\nrandom.seed(123)\nfor i in range(10):\nprint(random.randint(1,999), end=\",\")", "kp": "random/turtle等标准库", "o": [], "rawType": "operation" }, { "id": 1143, "q": "在考生文件夹下存在一个Python源文件PY201.py。请编写代码替换横线，不修改其他代码，实现下面功能：\n(1)使用turtle库和random库，在屏幕上绘制5个彩色的圆；\n(2)圆的颜色随机从颜色列表color中获取；\n(3)圆的画圆起始点坐标x和y值从范围[-100,100]之间选取，半径从范围[10,30]之间选取。\n效果如下图所示。\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试并验证程序。", "t": "fill", "ans": "import turtle as t\nimport random as r\ncolor = ['red','green','blue','purple','black']\nr.seed(1)\n#range(5)定义一个0~4的可迭代列表，表示将要画5个圆。\nfor j in range(5):\n# r.randint(0, 4)生成一个0~4的随机整数。\n# color[r.randint(0, 4)]表示根据随机数获取color下标索引对应的元素\n# 从而得到任意随机画笔颜色。\nt.pencolor(color[r.randint(0, 4)])\nt.penup()\n# t.goto(x, y)表示笔触到达坐标（x，y）处，以该坐标为圆心。\n# x，y同样在（-100，100）之间随机取值。\nt.goto(r.randint(-100, 100), r.randint(-100, 100))\n# 下笔（让画笔接触画布）", "kp": "random/turtle等标准库", "o": [], "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-turtle-random-circles-1143.png", "rawType": "operation" }, { "id": 1144, "q": "以下代码的输出结果是（）。\nn=-5\ns=100\nif n>=5:\n   n-=10\n   s=3\nelif n<5:\n   n-=10\n   s=4\nprint(s)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "3", "4", "0", "2" ], "explanation": "初始n=-5，不满足n>=5，进入elif n<5分支。执行n-=10和s=4。分支结束后打印s的值，结果为4。故选B。" }, { "id": 1145, "q": "定义函数如下：\nf=lambda x:x+2\nf(f(2))的运行结果是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "4", "5", "6", "7" ], "explanation": "匿名函数f实现参数加2。内层f(2)计算得4，外层变为f(4)，再次加2得6。函数嵌套调用按从内到外顺序求值，最终结果为6。故选C。" }, { "id": 1146, "q": "以下何者是不合法的布尔表达式（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "x in range(6)", "3=a", "e>5 and 4==f", "(x-6)>5" ], "explanation": "布尔表达式用于判断真假。3=a试图将变量a赋值给字面量3，Python中字面量不可作为赋值目标，语法非法。其余选项均为合法的关系或成员运算表达式。故选B。" }, { "id": 1147, "q": "下面语句执行后的结果是（ ）\nprint(10,20,sep=',')\nprint(30)", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "10,20*30", "10,20\n30", "10 20 30", "10 20* 30" ], "explanation": "print函数的sep参数用于指定多个输出值之间的分隔符，默认为空格。此处设为逗号，故第一行输出10,20。第二行print(30)默认换行输出30。选项B表示两次输出的字符序列，符合sep替换默认空格的作用。" }, { "id": 1148, "q": "在在python中，以下哪个选项a 的数据类型为整型（）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "a=5", "a=input()", "a='5'", "a=5.0" ], "explanation": "Python中直接赋值整数数字会自动识别为整型（int）。input()函数返回值恒为字符串；加引号的'5'也是字符串类型；5.0包含小数点，属于浮点型（float）。因此只有A选项使变量a为整型。" }, { "id": 1149, "q": "表达式2*(1,2,3,4,5)的值是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)", "(2,4,6,8,10)", "(1,2,3,4,5)", "(1,2,3,4,5), (1,2,3,4,5)" ], "explanation": "在Python中，元组与整数相乘表示序列的重复拼接操作。2*(1,2,3,4,5)会将原元组内的元素完整复制一次并连接，生成包含10个元素的新元组，而非对每个元素进行数学乘法运算。" }, { "id": 1150, "q": "求下面代码段中集合D的数值。\nA = {2, 4, 6, 8, 10}\nB = {3, 6, 9, 12, 15}\nC = {4, 5, 6, 7, 8, 9}\nE= {1}\nB = {x ** 2 for x in A | B if x % 3 == 0}\nD = {x + 2 for x in B - C if x % 2 == 0}\nE |= D", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{38,146}", "{1}", "{1,38,146}", "{9, 36, 81, 144, 225}" ], "explanation": "首先计算A|B并筛选能被3整除的数平方，得到新集合B为{9,36,81,144,225}。接着计算B-C差集得{36,81,144,225}，筛选偶数后加2，最终D为{38,146}。集合推导式按条件逐步过滤并转换元素。" }, { "id": 1151, "q": "一般来说，Python把文件分为几种文件类型？()", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "1", "2", "3", "以上都是错误的" ], "explanation": "Python通常将文件分为文本文件和二进制文件两大类。文本文件以字符编码存储，可直接阅读；二进制文件以字节流形式存储，如图片、音频等。因此正确答案为2种。" }, { "id": 1152, "q": "下面语句执行后的结果是（ ）\nprint(\"Lily\",end=\":\")\nprint('\"hello\"')", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "Lily:\"hello\"", "Lily:hello", "Lily\n\"hello\"", "Lily:\n\"hello\"" ], "explanation": "print的end参数默认是换行符，此处改为冒号，使第一次输出后不换行。第二次print直接输出带双引号的字符串\"hello\"。两次输出紧密拼接，结果为Lily:\"hello\"。" }, { "id": 1153, "q": "哪个选项是下面代码的执行结果？\ns='PYTHON'\nprint(\"{0:3}\".format(s))", "t": "single", "ans": "B", "kp": "字符串", "o": [ "PYTH", "PYTHON", "PYT", "PYTHON" ], "explanation": "格式化字符串中的:3表示最小字段宽度为3。当实际字符串长度大于指定宽度时，Python会完整输出原字符串而不会截断。若需截断应使用精度控制如:.3，故此处仍输出完整的PYTHON。" }, { "id": 1154, "q": "以下叙述中正确的是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "break语句只能用于if语句中", "continue语句的作用是使程序的执行流程跳出包含它的所有循环", "break 语句只能用在循环体内", "在循环体内使用break语句和continue语句的作用相同" ], "explanation": "break用于立即终止当前所在的最内层循环，不能单独用于if语句；continue仅跳过本次循环剩余代码进入下一次迭代，不会跳出所有循环。两者作用不同，且break必须位于循环结构内部。" }, { "id": 1155, "q": "下面代码的输出结果是（）。\nstr1=\"mysqlsqlserverPostgresQL\"\nstr2=\"sql\"\nncount=str1.count(str2)\nprint(ncount)", "t": "single", "ans": "A", "kp": "字符串", "o": [ "2", "5", "4", "3" ], "explanation": "count()方法统计子串在主串中非重叠出现的次数。在str1中，sql分别出现在mysql和sqlserver两处，后续字符无匹配项，因此返回结果为2。" }, { "id": 1156, "q": "下面程序的执行结果是[*queNo*]________。\nlist = [3 , 2 , 4 , 3]\nnums = set(list)\nfor i in nums:\n     print(i,end = \"\")", "t": "fill", "ans": "234", "kp": "字典/集合", "o": [], "explanation": "第1空：set()函数将列表转换为集合，自动去除重复元素3，得到集合{2,3,4}。遍历集合时按内部顺序依次输出，结合end=\"\"不换行，最终打印结果为234。" }, { "id": 1157, "q": "已知x=3+4j和y=5+6j,那么x+y的值是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "8+10j", "8", "10j", "语法错误" ], "explanation": "Python支持复数运算，复数由实部和虚部组成。加法运算时实部与实部相加（3+5=8），虚部与虚部相加（4+6=10），结果自动组合为复数类型8+10j。" }, { "id": 1158, "q": "eval(11+22)输出结果是（）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "1122", "语法错误无法执行", "33", "11+22" ], "explanation": "eval()函数参数必须是字符串、字节串或代码对象。此处11+22会先被计算为整数33，再将整数传入eval会引发类型错误，导致程序无法正常运行，故判定为错误无法执行。" }, { "id": 1159, "q": "在Python语言中，不能作为变量名的是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "student", "True", "_3python", "m_2e" ], "explanation": "Python变量名不能是关键字。True是Python的内置关键字（布尔值），因此不能作为变量名。其他选项均符合变量名命名规则。" }, { "id": 1160, "q": "以下程序的输出结果是（ ）\ns=\"Love\"\nprint(\"{:*<10}\".format(s))", "t": "single", "ans": "C", "kp": "字符串", "o": [ "***Love***", "Love", "Love******", "******Love" ], "explanation": "格式化字符串`{:*<10}`中，`<`表示左对齐，`10`表示总宽度为10，`*`表示用星号填充空白处。'Love'长度为4，因此右侧会填充6个星号，结果为'Love******'。" }, { "id": 1161, "q": "以下代码的输出结果是（）。\nn=-5\ns=100\nif n>=5:\n   if n<=5:\n      n-=10\n      s=3\nelse:\n   s=4\nprint(s)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "3", "4", "100", "2" ], "explanation": "变量n初始值为-5，不满足外层if条件`n>=5`，因此直接执行else分支，将s赋值为4。最后打印s的值，输出结果为4。" }, { "id": 1162, "q": "设有程序段：\nfor i in range(1,6,3):\n    pass\nprint(i)\n则for循环执行的次数是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "4", "5", "2", "1" ], "explanation": "`range(1, 6, 3)`生成的序列从1开始，步长为3，包含的元素为1和4（下一个7超出范围6）。因此for循环会执行2次。" }, { "id": 1163, "q": "以下循环执行（ ）次。\ns=1\nwhile not s:\n       s=1", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "1", "0", "3", "2" ], "explanation": "变量s初始值为1，在布尔上下文中为True。`not s`的结果为False，因此while循环的条件不成立，循环体一次也不会执行，执行次数为0。" }, { "id": 1164, "q": "在Python语言中，使用for…in方式形成的循环不能遍历的类型是（）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "复数", "列表", "字典", "字符串" ], "explanation": "`for...in`循环用于遍历可迭代对象。列表、字典和字符串都是可迭代类型，而复数（complex）是数值类型，不可迭代，因此不能被遍历。" }, { "id": 1165, "q": "下列for循环执行后，输出结果的最后一行是（ ）。\nfor i in range(1,3):\n     for j in range(2,5):\n          print(i*j)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "2", "6", "8", "15" ], "explanation": "外层循环i依次取1、2，内层循环j依次取2、3、4。最后一行输出对应外层循环最后一次（i=2）且内层循环最后一次（j=4）的结果，即2*4=8。" }, { "id": 1166, "q": "与其他三个表达式的值不同的是( )。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "\"Python\"+\"语言\"", "\"Python\"-\"语言\"", "\"Python语言\"*1", "\"\".join((\"Python \",\"语言\"))" ], "explanation": "Python中字符串支持加法（拼接）和乘法（重复），也支持使用join方法拼接。但字符串不支持减法运算，选项B会引发TypeError异常，与其他三个表达式的正常求值结果不同。" }, { "id": 1167, "q": "Python中,关于列表与元组下列说法错误的是（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "元组与列表都属于序列", "元组与列表都是可变的", "元组与列表都能进行切片操作", "元组可以在字典中作为键使用，而列表则不行" ], "explanation": "列表是可变序列，支持增删改操作；而元组是不可变序列，一旦创建其元素不能修改。因此\"元组与列表都是可变的\"说法错误。其他选项关于序列、切片和字典键的描述均正确。" }, { "id": 1168, "q": "下列代码的运行结果是（ ）。\ndef fact(n):\n    if n<=1:\n        return 1\n    else:\n        return n*fact(n-1)\ns=fact(5)\nprint(\"{}\".format(s))", "t": "single", "ans": "A", "kp": "函数", "o": [ "120", "24", "6", "3" ], "explanation": "该代码定义了一个计算阶乘的递归函数fact。调用fact(5)时，依次递归计算5*4*3*2*1，最终返回120。格式化输出结果为120。" }, { "id": 1169, "q": "执行下列代码，运行结果正确的是（ ）。\na=3\nb=4\ndef fun():\n    print(a+b）\nfun()", "t": "single", "ans": "C", "kp": "函数", "o": [ "报错", "a+b", "7", "没有任何显示" ], "explanation": "变量a和b在函数外部定义，属于全局变量。在函数fun内部可以直接读取全局变量的值进行计算，3+4结果为7。" }, { "id": 1170, "q": "以下说法错误的是（ ）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "Python中定义函数的关键字是def", "在函数内部可以通过关键字global来定义全局变量", "python函数部不需要指定形参数据类型", "已知 f = lambda x: 10，那么表达式 f(3)的值为3" ], "explanation": "对于lambda表达式`f = lambda x: 10`，无论传入什么参数，函数体始终返回10。因此`f(3)`的值为10而不是3，选项D说法错误。其他选项关于def、global和形参类型的描述均正确。" }, { "id": 1171, "q": "以下不属于对象的属性的是（）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "学号", "姓名", "年龄", "一个学生" ], "explanation": "对象的属性用于描述对象的静态特征或状态，如学生的学号、姓名和年龄。而\"一个学生\"是对象本身（即类的实例），不是属性。因此D选项不属于属性。" }, { "id": 1172, "q": "以下关于文件的描述，不正确的是（ ）", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "二进制文件和文本文件的操作步骤都是\"打开――读、写操作――关闭\"", "open() 打开文件之后，文件的内容并没有在内存中", "open()只能打开一个已经存在的文件", "文件读写之后，要调用close()才能确保文件操作的安全性，释放系统资源" ], "explanation": "open()函数在指定写入模式（如'w'、'a'等）时，如果文件不存在会自动创建新文件，并非只能打开已存在的文件。A、B、D选项的描述均符合Python文件操作的基本原理和规范。" }, { "id": 1173, "q": "设a=set([1,2,2,3,3,3,4,4,4,4])，则a．remove(4)的值是（ ）。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{1, 2, 3}", "{1, 2, 2, 3, 3, 3, 4, 4, 4}", "{1, 2, 2, 3, 3, 3}", "[1, 2, 2, 3, 3, 3, 4, 4, 4]" ], "explanation": "set()函数将列表转为集合时会自动去重，a的初始值为{1, 2, 3, 4}。调用a.remove(4)移除元素4后，集合变为{1, 2, 3}。题目问的是操作后a的值，故选A。" }, { "id": 1174, "q": "请补充fun函数，给定函数fun 的功能是：根据整型形参n，计算如下公式的值。\n例如，若 n=10，则应输出：0.617977。\n注意：部分源程序已给出。输入并调试程序，使程序得出正确结果不得增行或删行，也不得更改程序的结构！仅在fun函数的横线上填入。\ndef fun(n):\n    A=1\n    for i in range(2, ___1___):\n        A = ___2___\n    return A\nn=eval(input(\"请输入一个数:\"))\nprint(A)", "t": "fill", "ans": "n+1 | 1/(1+A)", "kp": "程序填空/调试", "o": [], "explanation": "第1空控制循环范围，公式计算需遍历到n，因range右开左闭，故填n+1。第2空根据公式推导，每次迭代需将A更新为1/(1+A)，以实现连分数的计算逻辑。" }, { "id": 1175, "q": "获得用户输入的以逗号分隔的三个数字，记为a、b、c，以a为起始数值，b为前后相邻数的比值，c为数列长度，产生一个等比数列，将这个数列以逗号分隔的形式输出，最后一个元素输出后无逗号，请完善PY103.py中代码。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "a, b, c = eval(input())\nls = []\nfor i in range(c):\nls.append(str(a*(b**i)))\nprint(\",\".join(ls))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1176, "q": "考生文件夹下存在一个Python源文件PY201.py,请编写代码替换横线，不修改其他代码，实现下面功能：\n使用turtle库，在屏幕上绘制正方形及其内接圆形。其中，正方形左下角坐标为(0,0),边长为黑色，长度200像素，线宽1像素；内切圆为绿色，线宽5像素，内部以红色填充。\n示例如下:\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试及验证程序。", "t": "fill", "ans": "import turtle as t\nfor i in range(4):\nt.forward(200) # 向前移动200个距离单位\nt.left(90)\nt.penup()\nt.goto(100, 0) # 向前移动100个距离单位，该处为正方形内切圆的切点。\nt.pendown()\nt.color('green', 'red') # 根据题目设置前景色（线条色）和背景色（填充色）\nt.pensize(5)\nt.begin_fill()\nt.circle(100) # 绘制圆形。\nt.end_fill() # 结束填充。\nt.done()", "kp": "random/turtle等标准库", "o": [], "rawType": "operation" }, { "id": 1177, "q": "已知x=10;y=3,执行语句x//=y+1后，x的值是（ ）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "2.5", "2", "2.0", "3" ], "explanation": "表达式y+1的值为4。x//=4等价于x = x // 4。由于x初始为整数10，10整除4的结果为2，且保持整数类型，因此x的最终值为2。" }, { "id": 1178, "q": "有以下代码：\nclass A:\n    bb='张三'\n    def func(self):\n        print(self.bB）\n以下说法中正确的是（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "A是类名", "A是对象名", "func是属性名", "bb是方法名" ], "explanation": "在Python中，class关键字后跟的是类名，因此A是类名。bb是类属性，func是实例方法。代码中print(self.bB)存在大小写拼写错误，但不影响对类结构的判断。" }, { "id": 1179, "q": "以下是一个Python字典my_dict：my_dict = {'A': 1, 'B': 2, 'C': 3, 'D': 4}，请选出下列代码中可以删除字典中值为2的元素的选项：", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "del my_dict[2]", "my_dict.remove(2)", "del my_dict['B']", "my_dict.delete(2)" ], "explanation": "字典中值为2的元素对应的键是'B'。删除字典元素需使用del语句配合键名，即del my_dict['B']。字典没有remove或delete方法，且del my_dict[2]会引发KeyError。" }, { "id": 1180, "q": "下列关于Python中复数类型的描述错误的是（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "复数由实数部分和虚数部分构成", "复数可以看作是二元有序实数对(a,b)", "虚数部分必须后缀j，且为小写", "复数中的虚数部分不能单独存在，必须有实数部分" ], "explanation": "Python中复数的虚数部分后缀可以是小写j，也可以是大写J（如1+2J），因此\"必须为小写\"的说法错误。复数可看作有序实数对，且虚部可单独存在（如2j，实部默认为0）。" }, { "id": 1181, "q": "下面关于Python的描述正确的是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "代码的缩进错误导致的是语法错误", "跳跃结构是Python的流程结构之一", "Python支持的数据类型包括char、int和float等", "Python内存管理中，变量无须事先创建和赋值，而是可以直接使用" ], "explanation": "Python严格依赖缩进划分代码块，缩进错误会引发IndentationError，属于语法错误。Python没有跳跃结构，没有单独的char类型，且变量必须先赋值后使用。" }, { "id": 1182, "q": "设s= \"abcdefg\"，则s[3:5]的值为( )", "t": "single", "ans": "C", "kp": "字符串", "o": [ "'cde'", "'def'", "'de'", "'ef'" ], "explanation": "字符串切片s[start:end]包含起始索引，不包含结束索引。索引从0开始，s[3]是'd'，s[4]是'e'。因此s[3:5]截取索引3和4的字符，结果为'de'。" }, { "id": 1183, "q": "下面代码的输出结果是（）。\n>>> 2 / False", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "True", "-1", "0", "系统报错" ], "explanation": "在Python中，布尔值False参与算术运算时会被隐式转换为整数0。表达式2 / False等价于2 / 0，由于除数不能为0，系统会抛出ZeroDivisionError异常，即系统报错。" }, { "id": 1184, "q": "下列选项中合法的标识符是（ ）。", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "_7a_b", "break", "_a$b", "7ab" ], "explanation": "Python合法标识符必须由字母、数字或下划线组成，不能以数字开头，也不能是关键字。_7a_b符合规则；break是关键字；_a$b包含非法字符$；7ab以数字开头。" }, { "id": 1185, "q": "关于赋值语句，以下选项中描述错误的是（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "a,b = b,a 可以实现a和 b值的互换", "a,b,c = b,c,a是不合法的", "在 Python语言中，\"=\"表示赋值，即将\"=\"右侧的计算结果赋值给左侧变量，包含\"=\"的语句称为赋值语句", "赋值与二元操作符可以组合，例如&=" ], "explanation": "Python支持多元赋值和序列解包。选项A利用元组解包实现变量互换，合法；选项B中a,b,c = b,c,a同样是合法的多元赋值语句，描述错误；选项C正确描述了赋值语句的定义；选项D中&=等组合赋值运算符在Python中合法。本题选描述错误的选项。" }, { "id": 1186, "q": "下列代码的输出结果是（）\nx=1000\ny=0\nif x:\n    y=1\nelse:\n    y=2\nprint(y)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "0", "1", "2", "没有输出" ], "explanation": "在Python中，非零整数在布尔上下文中被视为True。变量x的值为1000，if x: 条件成立，因此执行y=1，跳过else分支。最终print(y)输出1。" }, { "id": 1187, "q": "给出下面代码，程序运行结果为（ ）。\nx,y=30,70\nif y:\n    min=y\nprint(min)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "30", "70", "0", "报错" ], "explanation": "x,y=30,70。if y: 中y为70，非零整数条件为True，执行min=y，即min被赋值为70。虽然min是内置函数名，但在此处作为普通变量使用不会报错，最终输出70。" }, { "id": 1188, "q": "以下代码的输出结果是（ ）。\nfor s in range(5):\n    if s==3:\n        continue\nprint(s,end=\"\")", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0124", "1234", "012345", "0125" ], "explanation": "range(5)生成0到4的序列。当s==3时，continue语句跳过当前循环的后续代码，因此不输出3。其余情况正常执行print，最终输出0124。" }, { "id": 1189, "q": "以下程序的运行结果是（ ）。\ns=0\ni=2\nwhile i<102:\n    s+=i\n    i=i+2\nprint(\"i=\",i)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "i=100", "i=102", "i=101", "i=103" ], "explanation": "循环初始i=2，每次循环i增加2。当i=100时，满足i<102，执行s+=i后i变为102。再次判断102<102为False，退出循环。此时i的值为102，输出i= 102。" }, { "id": 1190, "q": "给出如下代码\ns='Python is beautiful!'\n可以输出\"python\"的是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "print(s[0:6].lower())", "print(s[:-14])", "print(s[0:6])", "print(s[-21 :-14].lower)" ], "explanation": "字符串s的前6个字符为'Python'。s[0:6]截取该子串，调用.lower()方法将其转换为小写'python'。选项B和C未转换小写，选项D语法错误且未正确调用方法。" }, { "id": 1191, "q": "令list=[i for i in range(1,10,2)]，则print(list[::-1])的结果为（ ）", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[9,7,5,3,1]", "[1]", "[1,3,5,7,9]", "[9,7,5,3]" ], "explanation": "列表推导式生成奇数列表[1, 3, 5, 7, 9]。切片[::-1]表示步长为-1，即从后向前逆序遍历整个列表，结果为[9, 7, 5, 3, 1]。" }, { "id": 1192, "q": "切片操作list(range(6))[::2]执行结果为（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "[0,1]", "[0,2,4,6]", "[0,1,2]", "[0,2,4]" ], "explanation": "list(range(6))生成列表[0, 1, 2, 3, 4, 5]。切片[::2]表示从开头到结尾，步长为2，依次取索引为0、2、4的元素，结果为[0, 2, 4]。" }, { "id": 1193, "q": "对于字典 D={1:10,2:20,3:30,4:40}，sum(list(D.keys()))的值是（ ）", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "10", "100", "110", "200" ], "explanation": "D.keys()返回字典的键视图，包含1, 2, 3, 4。list()将其转为列表，sum()对列表元素求和，计算1+2+3+4=10。注意此处是对键求和而非对值求和。" }, { "id": 1194, "q": "下列选项中不是面向对象程序设计基本特征的是（ ）。", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "继承", "多态", "可维护性", "封装" ], "explanation": "面向对象程序设计的三大基本特征是封装、继承和多态。可维护性是软件工程的重要质量属性，但不属于面向对象的基本特征。" }, { "id": 1195, "q": "一个类继承另一个类，那么被继承的这个类被称为（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "超类", "子类", "类", "继承类" ], "explanation": "在面向对象编程的继承机制中，被继承的类称为父类、基类或超类（Superclass），而继承其他类的类称为子类或派生类。" }, { "id": 1196, "q": "编写程序，输入i，如果i被7整除但不能同时被5整除则输出i，否则不输出。\ni=int（input（））\nif i    1    7==0 and i    2   5!==0:\n     3   (i)", "t": "fill", "ans": "% | % | print", "kp": "程序填空/调试", "o": [], "explanation": "第1空和第2空需要判断整除，Python中使用取模运算符%来计算余数，故均填%；第3空需要输出变量i的值，使用内置输出函数print。" }, { "id": 1197, "q": "由用户一个一个输入一个数值型列表，然后将每个元素逐一打印。请填空。\ns=[]\nn=eval(input(\"请输入数字个数：\"))\nfor i in range(___1____):\n    number=eval(input(\"请输入数字：\"))\n    _____2___\nfor value in s:\n    print(value,end=' ')", "t": "fill", "ans": "n | s.append(number)", "kp": "程序填空/调试", "o": [], "explanation": "第1空需控制循环次数，range(n)可生成0到n-1的整数序列，恰好执行n次输入。第2空用于将每次输入的number存入列表s，应使用列表的append()方法追加元素。两者结合完成动态构建列表的过程。" }, { "id": 1198, "q": "程序填空题\ndef find_common_elements(list1, list2):\n\"\"\"\n查找两个列表中的共同元素，并返回一个集合。\n\"\"\"\n     set1 = set(list1)\n     set2 = set(list2)\n     common_elements = ____1____(_____2___)\n     return common_elements\nlist1 = [1, 2, 3, 4, 5]\nlist2 = [4, 5, 6, 7, 8]\nresult = find_common_elements(list1, list2)\nprint(result)", "t": "fill", "ans": "set1.intersection | set2", "kp": "程序填空/调试", "o": [], "explanation": "第1空考查集合求交集的方法，set1.intersection()用于计算当前集合与另一集合的共有元素。第2空传入待比较的集合set2作为参数。调用后返回包含共同元素的新集合，符合题目要求。" }, { "id": 1199, "q": "Python语言中标准输出print()函数中，各输出项中默认的分隔符是( )", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "回车符", "逗号", "分号", "空格" ], "explanation": "print()函数默认使用空格作为多个输出项之间的分隔符（对应参数sep=' '）。回车符是默认结束符end的值，逗号和分号并非Python内置分隔符，因此选D。" }, { "id": 1200, "q": "以下程序的输出结果是： （ ）。\ns=''\nls = [4,5,6,7]\nfor l in ls:\ns += str (l)\nprint (s)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "4,5,6,7", "7654", "7,6,5,4", "4567" ], "explanation": "循环遍历列表ls，每次将整数转为字符串后通过+=拼接到s末尾。依次拼接'4'、'5'、'6'、'7'，最终得到字符串'4567'。选项A含逗号，B/C顺序颠倒，均不符合字符串累加逻辑。" }, { "id": 1201, "q": "下面代码的输出结果是（）。\na = 5/3+5//3\nprint(a)", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "5.4", "2.666666666666667", "3.333333", "14" ], "explanation": "/为真除法，5/3结果为浮点数约1.6666666666666667；//为整除，5//3结果为整数1。两者相加得浮点数2.666666666666667。Python中浮点数与整数运算结果自动转为浮点型，故选B。" }, { "id": 1202, "q": "以下代码的输出结果是（）。\nn=5\ns=100\nif n>=5:\n   n-=10\n   s=4\nelif n<5:\n   n-=10\n   s=3\nprint(s)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "3", "4", "0", "2" ], "explanation": "初始n=5满足if n>=5条件，执行分支内语句：n变为-5，s被赋值为4。由于if分支已执行，elif分支将被跳过。最终打印s的值为4，故选B。" }, { "id": 1203, "q": "以下程序运行后输出的结果是（ ）\ndef fun(x):\n    s=0\n    for i in range(2,x):\n        s=s+i\n    return s\nprint(fun(5))", "t": "single", "ans": "B", "kp": "函数", "o": [ "10", "9", "8", "12" ], "explanation": "range(2, 5)生成序列2、3、4。循环中s依次累加：0+2=2，2+3=5，5+4=9。函数返回累加和9。选项A为1到4的和，C/D计算错误，故选B。" }, { "id": 1204, "q": "关于面向对象的继承，以下选项中描述正确的是? ( )", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "继承是指一组对象所具有的相似性质", "继承是指类之间共享属性和操作的机制", "继承是指各对象之间的共同性质", "继承是指一个对象具有另一个对象的性质" ], "explanation": "面向对象中，继承是子类自动获得父类属性和方法的机制，实现代码复用与层次化设计。A/C描述偏向对象实例的共性而非类间关系，D混淆了对象与类的概念，B准确表述了继承的本质。" }, { "id": 1205, "q": "有一长度为10的列表，列表内有10个人名，要求去掉重复的并输出此列表。例如names=['小王','小李','小张','小李']，删除重复的姓名后 names= ['小王', '小李', '小张']。请填空。\nnames=['小王','小李','小张','小李']\nnew_names=[]\nfor name in ___1_____:\n    if name not in new_names:\n        new_names. ___2_____\nnames=new_names\nprint(names)", "t": "fill", "ans": "names | append(name)", "kp": "程序填空/调试", "o": [], "explanation": "第1空需遍历原列表，填names以逐个获取姓名。第2空在判断name not in new_names成立时，将不重复的姓名加入新列表，应调用append(name)方法。最终new_names即为去重后的结果。" }, { "id": 1206, "q": "已知列表x=[1,2,3]，那么执行语句x.pop(1)之后， x的值为（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[1,3]", "1,3", "2", "[2]" ], "explanation": "pop(1)移除并返回列表索引为1的元素（即2）。原列表剩余元素自动前移，变为[1, 3]。选项B缺少列表括号，C/D为被移除的值或错误切片，故选A。" }, { "id": 1207, "q": "以下代码的输出结果是（）。\nn=50\ns=10\nif n<=5:\n    n-=10\n    s=4\nprint(s)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "3", "4", "10", "2" ], "explanation": "初始n=50，不满足if n<=5条件，因此分支内修改s的语句不会执行。程序直接跳过条件块，打印初始值s=10。选项A/B/D均为错误执行分支的结果，故选C。" }, { "id": 1208, "q": "下面代码中Dog这个类中的init方法共包含几个形参？（）\nClass Dog():\n    def _init_(self,name,age):\n        self.name=name\n        self.age=age", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "0个", "1个", "2个", "3个" ], "explanation": "定义中括号内为self, name, age共3个参数，但self代表实例本身，不计入外部调用时传递的形参数量。通常考题指除self外的业务参数，即name和age共2个，故选C。" }, { "id": 1209, "q": "一个对象是由（）组成", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "模块和实例", "属性和方法", "属性和实例", "方法和行为" ], "explanation": "在面向对象编程中，对象是类的实例，由描述其特征的属性（数据）和定义其行为的方法（函数）两部分组成。模块是代码组织单位，实例是对象本身，行为是方法的体现，故选属性和方法。" }, { "id": 1210, "q": "turtle库中控制顺时针转的函数是（ ）。", "t": "single", "ans": "C", "kp": "random/turtle等标准库", "o": [ "pendown()", "left()", "right()", "pencolor()" ], "explanation": "turtle库中，right()或rt()函数用于控制海龟顺时针旋转指定角度；left()用于逆时针旋转；pendown()用于落笔；pencolor()用于设置画笔颜色。" }, { "id": 1211, "q": "以下方法中，不属于列表的是（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "count()", "len()", "remove()", "strip()" ], "explanation": "count()和remove()是列表的内置方法。len()虽然是Python内置函数而非列表专属方法，但常用于获取列表长度。strip()是专门用于去除字符串首尾指定字符的字符串方法，完全不适用于列表，故选D。" }, { "id": 1212, "q": "不是Python内置函数的选项是（）。", "t": "single", "ans": "A", "kp": "函数", "o": [ "compare()", "divmod()", "type()", "ord()" ], "explanation": "divmod()用于返回商和余数，type()用于返回对象类型，ord()用于返回字符的Unicode码点，三者均为Python内置函数。compare()不是Python的内置函数，通常比较操作直接使用比较运算符实现。" }, { "id": 1213, "q": "下面语句执行后的结果是（ ）\nprint(10,20,end='*')\nprint(30)", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "10,20*30", "10,20\n30", "10 20 30", "10 20*30" ], "explanation": "print()函数默认以空格分隔多个参数。第一句print(10,20,end='*')输出'10 20'并以'*'结尾不换行；第二句print(30)紧接着输出'30'并换行。因此最终输出结果为'10 20*30'。" }, { "id": 1214, "q": "下列程序的运行结果是（ ）。\ns=[\"Practice makes perfect!\",\"No pains, no gains\",\"university\"]\ncount=[0,0,0,0,0]\nfor i in s:\n    for j in i:\n        if j==\"a\":\n            count[0]+=1\n        elif j==\"e\":\n            count[1]+=1\n        elif j==\"i\":\n            count[2]+=1\n        elif j==\"o\":\n            count[3]+=1\n        elif j==\"u\":\n            count[4]+=1\nprint(count)", "t": "fill", "ans": "[4,5,5,2,1]", "kp": "循环结构", "o": [], "explanation": "程序通过双重循环遍历字符串列表中的每个字符，并分别统计元音字母a、e、i、o、u的出现次数。经统计，a出现4次，e出现5次，i出现5次，o出现2次，u出现1次，最终列表count的值为[4,5,5,2,1]。" }, { "id": 1215, "q": "已知x=5;y=6,语句x=x+y执行后，x的值是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "5", "6", "11", "12" ], "explanation": "语句x=x+y表示将变量x和y的当前值相加后重新赋值给x。已知初始x=5，y=6，相加结果为11，因此执行后x的值更新为11。" }, { "id": 1216, "q": ">>> a=30\n>>> b=30\n>>> a is b的结果为（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "False", "True", "不确定", "错误" ], "explanation": "Python内部维护了一个小整数对象池（通常为-5到256）。当变量a和b都被赋值为30时，它们会指向内存中同一个整数对象。因此，使用is运算符判断两者内存地址是否相同的结果为True。" }, { "id": 1217, "q": "下面代码的输出结果是（）。\na=\"alex\"\nb=a.capitalize()\nprint(a,end=\",\")\nprint(b)", "t": "single", "ans": "C", "kp": "字符串", "o": [ "alex,ALEX", "ALEX,alex", "alex,Alex", "Alex,Alex" ], "explanation": "字符串方法capitalize()会将字符串的首字母大写，其余字母小写，因此b的值为'Alex'。第一个print设置end=','，输出'alex,'且不换行；第二个print输出'Alex'。拼接后结果为'alex,Alex'。" }, { "id": 1218, "q": "以下方法中，适用于元组的方法是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "pop()", "reverse()", "count()", "append()" ], "explanation": "元组是不可变序列，不支持修改其元素的操作。pop()、reverse()和append()都会改变序列内容，因此不适用于元组。count()用于统计元素出现次数，不改变原序列，是元组支持的方法。" }, { "id": 1219, "q": "下列语句执行后的结果是（）\ndictionary = {\"apple\": 3, \"banana\": 2, \"orange\": 5}\nresult = len(dictionary) + dictionary[\"banana\"] - dictionary.get(\"grape\", 0)\nprint(result)", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "10", "8", "6", "5" ], "explanation": "len(dictionary)计算字典键值对数量，结果为3；dictionary['banana']获取键'banana'对应的值2；dictionary.get('grape', 0)因键不存在返回默认值0。表达式计算为3 + 2 - 0 = 5。" }, { "id": 1220, "q": "调用以下函数返回的值是（）\ndef myfun():\npass", "t": "single", "ans": "C", "kp": "函数", "o": [ "0", "出错不能运行", "None", "空字符串" ], "explanation": "在Python中，如果函数体内没有显式使用return语句返回值，或者仅使用pass占位，函数执行完毕后会自动默认返回None。因此调用该函数返回None。" }, { "id": 1221, "q": "以下选项中，对于递归函数的描述正确的是（ ）。", "t": "single", "ans": "B", "kp": "函数", "o": [ "通常情况下，递归递归函数比普通循环迭代的效率高，占用内存少。", "一般情况下，递归函数会比普通循环迭代的效率低，占用内存更多。", "递归调用的调用次数可以是无限次。", "理论上，任何函数都可以定义成递归函数。" ], "explanation": "递归函数在每次调用时都需要在内存中分配新的栈帧来保存局部变量和返回地址，因此相比普通循环迭代，其执行效率通常较低，且占用更多内存。此外，递归必须有终止条件，不能无限调用，也并非所有函数都适合定义为递归。" }, { "id": 1222, "q": "下列Python程序的运行结果是（ ）。\nnumber=[1,2,6]\nnumber[2:2]=[3,4,5]\nprint(number)", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[1, 2, 3, 4, 5, 6]", "[1,3,4,5,6]", "[1,3,4,5]", "[1,2,6]" ], "explanation": "列表切片赋值number[2:2]=[3,4,5]表示在索引2的位置（即元素6之前）插入列表[3,4,5]。原列表为[1,2,6]，插入后原索引2及之后的元素顺次后移，最终结果为[1, 2, 3, 4, 5, 6]。" }, { "id": 1223, "q": "以下程序的运行结果是（）。\ndef mytake(x,y,z):\n    h=x*y*z\n    return h\nk=mytake(z=6,x=5,y=1)\nprint(\"输出结果为:\",k)", "t": "single", "ans": "A", "kp": "函数", "o": [ "30", "6", "5", "实参位置与形参位置不对应，输出不确定值" ], "explanation": "函数调用时使用了关键字参数z=6, x=5, y=1，关键字参数允许不按照形参定义的顺序传参。因此实际传入的值为x=5, y=1, z=6，函数内部计算h = x*y*z = 5*1*6 = 30，最终输出30。" }, { "id": 1224, "q": "以下代码的输出结果是（）。\nage=26\nif 25<=age<=30:\n   if age<=25:\n      print(\"作为一个老师，你太年轻了\")\n   else:\n      print(\"作为一个老师，你很年轻\")\nelse:\n   print(\"作为一个老师，你很有爱心\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "作为一个老师，你很年轻", "作为一个老师，你太年轻了", "报错", "作为一个老师，你很有爱心" ], "explanation": "变量age=26，满足外层条件25<=age<=30。进入内层判断，age<=25即26<=25为假，因此执行else分支，输出\"作为一个老师，你很年轻\"。" }, { "id": 1225, "q": "下面代码的输出结果是（ ）。\nfor i in \"cat or dog\":\n    if i=='o':\n        break\n    else:\n        print(i,end='')", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "cat or", "cat", "dog", "cat or dog" ], "explanation": "循环遍历字符串'cat or dog'，依次输出'c'、'a'、't'和空格。当遍历到字符'o'时触发break语句跳出循环。实际输出包含末尾空格，选项B虽省略空格但为最符合项。" }, { "id": 1226, "q": "已知列表s=[1,2,3,4,5], 那么执行语句s.insert(2,'b')后，列表s为（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[1, 'b', 2, 3, 4, 5]", "[1, 2, 'b', 3, 4, 5]", "[1, 'b', 3, 4, 5]", "[1, 2, 3, 4, 5, 2, 'b']" ], "explanation": "列表的insert(index, obj)方法用于在指定索引位置插入元素。s.insert(2, 'b')表示在索引2（即原元素3的位置）插入'b'，原元素及后续元素顺次后移，结果为[1, 2, 'b', 3, 4, 5]。" }, { "id": 1227, "q": "下列代码运行后的结果是（ ）。\ndef sum(m):\n    if m<10:\n        return m+sum(2*m+1)\n    else:\n        return 0\ns=sum(1)\nprint(\"{}\".format(s))", "t": "single", "ans": "A", "kp": "函数", "o": [ "11", "20", "45", "0" ], "explanation": "递归调用过程：sum(1)返回1+sum(3)；sum(3)返回3+sum(7)；sum(7)返回7+sum(15)；sum(15)满足m>=10，返回0。最终结果为1+3+7+0=11。" }, { "id": 1228, "q": "（）不是合法的浮点型数据。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "3.e2", "34.0", "34.", "e-6" ], "explanation": "Python中合法的浮点数科学计数法表示必须包含基数部分，如3.e2或1e-6。选项D的e-6缺少基数部分，不是合法的浮点型数据。" }, { "id": 1229, "q": "Python语句print(r\"\\nGood\")的运行结果是（ ）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "新行和字符串Good", "r\"\\nGood\"", "\\nGood", "字符r、新行和字符串Good" ], "explanation": "字符串前加r表示原始字符串，其中的转义字符（如\\n）将失去转义作用，按普通字符原样输出。因此\\n不会被解析为换行，直接输出\\nGood。" }, { "id": 1230, "q": "下面语句的执行结果，不可能的选项是（）\nimport random\nprint(random.uniform(1,3))", "t": "single", "ans": "B", "kp": "random/turtle等标准库", "o": [ "2.764076933688729", "3.993002365820678", "2.5670577649215085", "1.807117374321477" ], "explanation": "random.uniform(a, b)用于生成一个指定范围内的随机浮点数，范围是[a, b]。题目中范围为[1, 3]，选项B的3.993超出了该范围，因此是不可能出现的执行结果。" }, { "id": 1231, "q": "表达式34%7的执行结果是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "6", "4", "5", "3" ], "explanation": "%是取模（求余）运算符。34 % 7表示34除以7的余数。34除以7商为4，余数为6，因此执行结果为6。" }, { "id": 1232, "q": "以下不属于Python语言保留字的是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "break", "var", "except", "while" ], "explanation": "Python的保留字是语言内部定义使用的标识符，不能用作变量名。break、except、while均为Python保留字，而var不是Python的保留字，常用于JavaScript等其他语言。" }, { "id": 1233, "q": "以下Python语句在一行内输出信息的是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "print(\"one\")\nprint(\"two\")", "print(\"one\",sep=\"\")\nprint(\"two\")", "print(\"one\",end=\"\")\nprint(\"two\")", "print(\"one\\ntwo\")" ], "explanation": "print()函数默认以换行符结尾（end=\"\\n\"）。选项C将end参数设为空字符串，使第一次输出后不换行，第二次输出紧接着在同一行显示。A项虽写在一行但默认会换行；B项sep用于分隔同一print内的多个参数；D项\\n会强制换行。" }, { "id": 1234, "q": "下列Python语句的运行结果为（ ）。\nx=True\ny=False\nz=True\nif not x or y:print(1)\nelif not x or not y and z:print(2)\nelif not x or y or not y and x:print(3)\nelse:print(4)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "1", "2", "3", "4" ], "explanation": "Python逻辑运算符优先级为not > and > or。第一条件not x or y为False or False，结果为假；第二条件not x or not y and z中，not y and z先计算得True，再与not x（False）进行or运算，结果为真，故执行print(2)并跳出分支。" }, { "id": 1235, "q": "设三角形三条边的长分别为a,b,c,则三条边满足表达式（）可构成一个三角形。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "a+b>c", "a-b>c", "b-c>a", "a+b>c and c+b>a and c+a>b" ], "explanation": "构成三角形的充要条件是任意两边之和大于第三边。选项D完整表达了a+b>c、b+c>a和a+c>b三个条件，缺一不可。A、B、C仅判断了单一关系，无法保证三条边能闭合构成三角形。" }, { "id": 1236, "q": "以下代码的输出结果是（）。\nx=True\ny=True\nz=False\nif x:\n   if y and z:\n      print(\"yes\")\nelse:\n   print(\"no\")", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "yes", "no", "True", "无输出" ], "explanation": "注意缩进关系，else与外层if x:对齐。因x为True，进入内层判断；y and z为True and False结果为假，不执行print(\"yes\")。外层条件已满足，故跳过else分支，最终无任何输出。" }, { "id": 1237, "q": "以下构成Python循环结构的方法中，正确的是（　　）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "while", "loop", "if", "do…for" ], "explanation": "Python中构建循环结构的保留字仅有for和while。loop和do…for并非Python语法；if属于分支结构关键字。因此只有A项正确。" }, { "id": 1238, "q": "关于Python循环结构，下列叙述中错误的是（）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "break用来结束当前当次语句，但不跳出当前的循环体", "遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range()函数等", "Python通过for、while等保留字构建循环结构", "continue只结束本次循环" ], "explanation": "题目要求选错误项。break的作用是立即终止并跳出整个循环体，而非仅结束当次语句；continue才是跳过本次循环剩余代码进入下一次迭代。B、C、D描述均符合Python循环机制。" }, { "id": 1239, "q": "下面描述中错误的是( )。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。", "while、do-while与for循环可以任意嵌套多层。", "各循环可互相嵌套,一般嵌套应超过三层。", "外层循环变量变化一次，内层循环变量变化一轮。" ], "explanation": "题目要求选错误项。编程规范通常建议循环嵌套层数不宜过深（一般不超过三层），否则会降低代码可读性与维护性。A、B、D对嵌套循环的定义、语法兼容性及执行顺序描述均正确。" }, { "id": 1240, "q": "切片操作list(range(5))[::-1]执行结果为（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[5, 4, 3, 2, 1]", "[4, 3, 2, 1, 0]", "[0, 1, 2, 3, 4]", "[1, 2, 3, 4, 5]" ], "explanation": "range(5)生成序列[0, 1, 2, 3, 4]。切片语法[start:stop:step]中步长为-1表示逆序取值，因此原列表被完全反转，得到[4, 3, 2, 1, 0]。" }, { "id": 1241, "q": "下列Python程序的运行结果是（ ）。\nt1=([1,2],3,4)\nt1[0][1]=3\nprint(t1)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "([3, 2], 3, 4)", "([1, 3], 3, 4)", "(3, 3, 4)", "([1, 2], 3, 4)" ], "explanation": "元组本身不可变，但其元素若为可变对象（如列表），则该对象内部内容可被修改。t1[0]指向列表[1,2]，将其索引1的元素改为3后，列表变为[1,3]，元组结构不变，故输出([1, 3], 3, 4)。" }, { "id": 1242, "q": "下列语句中，变量类型属于列表的是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "a = [0,'a', [1, 'b']]", "a = {0,'a', [1, 'b']}", "a=(0,'a', [1, 'b'])", "a= 0,'a', [1, 'b']" ], "explanation": "Python中使用方括号[]定义列表。A项符合列表语法；B项花括号为集合语法；C项圆括号为元组语法；D项省略括号默认按逗号分隔生成元组。故选A。" }, { "id": 1243, "q": "请给出下面代码段的结果。\nA = {'red','orange'}\nB = {'red','blue'}\nC = {'blue','green'}\nA.difference_update(B.union(C))\nprint(A)", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{'red','orange'}", "{'orange'}", "{'blue','green'}", "空集" ], "explanation": "B.union(C)求并集得{'red','blue','green'}。difference_update()方法会就地删除集合A中存在于参数集合里的元素。A中'red'被移除，'orange'保留，最终A变为{'orange'}。" }, { "id": 1244, "q": "以下不能创建字典的语句是（ ）。", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "dict1={}", "dict2={3:5}", "dict3=dict([2,5],[3,4])", "dict4=dict(([1,2],[3,4]))" ], "explanation": "dict()构造函数需接收一个包含键值对的可迭代对象（如列表嵌套元组或列表）。C项传入两个独立列表作为位置参数，不符合语法要求会报错。A、B、D均符合字典创建规范。" }, { "id": 1245, "q": "下列代码的运行后结果是（ ）。\ndef add(n):\n    if n<=5:\n        return n+add(n+1)\n    else:\n        return 1\ns=add(1)\nprint(\"{}\".format(s))", "t": "single", "ans": "B", "kp": "函数", "o": [ "15", "16", "22", "14" ], "explanation": "递归函数add(n)在n<=5时返回n+add(n+1)，否则返回1。add(1)展开为1+add(2)，依次类推至1+2+3+4+5+add(6)。因add(6)返回1，最终结果为1+2+3+4+5+1=16。" }, { "id": 1246, "q": "以下程序代码的运行结果正确的是（ ）。\nlist = ['a','b','c','d']\ndef fun():\n     list =['e','f','g','h']\nfun()\nprint(list)", "t": "single", "ans": "B", "kp": "函数", "o": [ "['e','f','g','h']", "['a','b','c','d']", "['a','b','c','d','e','f','g','h']", "['e','f','g','h','a','b','c','d']" ], "explanation": "函数fun内对list赋值会创建局部变量，未使用global关键字声明，因此不会修改全局变量list。调用fun()后，全局list保持不变，仍为['a','b','c','d']。" }, { "id": 1247, "q": "下列程序的运行结果是（ ）。\ny=lambda s1,s2:s2.rfind(s1)\nprint(y('w','whatfiwle'))", "t": "single", "ans": "C", "kp": "函数", "o": [ "5", "0", "6", "-1" ], "explanation": "lambda函数调用字符串的rfind方法，返回子串最后一次出现的索引。'w'在'whatfiwle'中最后出现在索引6的位置（从0开始计数），故输出6。" }, { "id": 1248, "q": "以下程序运行后输出的结果是（ ）。\ndef func(a,b):\n     b.append(a)\n     return b\nlst=[5,6,7]\ns=func(9,lst)\nprint(s)", "t": "single", "ans": "B", "kp": "函数", "o": [ "（5, 6, 7, 9）", "[5, 6, 7, 9]", "[5, 6, 7], 9", "5, 6, 7, 9" ], "explanation": "列表是可变对象，作为参数传递时引用原对象。func中b.append(a)直接修改了原列表lst，将其变为[5,6,7,9]并返回，因此打印结果为[5, 6, 7, 9]。" }, { "id": 1249, "q": "有以下代码：\nclass Person:\n    name='张三'\n    def printName(self):\n        print(self.name)\n以下说法中错误的是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "Person是类名", "Person是对象名", "name是属性名", "printName是方法名" ], "explanation": "在面向对象中，Person是定义的类名，而不是具体的对象名（实例名）。name是类属性，printName是类方法。因此选项B说法错误。" }, { "id": 1250, "q": "老师、学生都有\"上课\"的行为，但老师是讲课，学生是听课。这种现象属于（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "继承", "多态", "封装", "消息" ], "explanation": "多态是指同一操作作用于不同对象时，可以产生不同的行为。老师和学生都有\"上课\"行为，但具体表现分别为讲课和听课，这正是多态的体现。" }, { "id": 1251, "q": "属于Python读取文件一行操作的是（ ）", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "readtext", "readline", "readall", "read" ], "explanation": "Python文件对象中，read()读取全部内容，readline()读取一行内容，readlines()读取所有行并返回列表。没有readtext和readall方法。故选readline。" }, { "id": 1252, "q": "请给出下面代码段的正确答案（）\nA = {17, 34, 72, 83, 84}\nB = {4, 10, 46, 54, 57}\nC = {4,34,54,84}\nD = (A ^ B) ^ (B ^ C) - (C ^ A)\nD.intersection_update(C)\nprint(D)", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "{4, 10, 17, 34, 72, 83, 84}", "{4, 10, 17, 34, 46, 54, 57, 72, 83, 84}", "{4, 54}", "{4, 17, 54, 72, 83}" ], "explanation": "集合减法`-`优先级高于对称差集`^`。先计算`(B^C)-(C^A)`得`{10,34,46,57,84}`，再与`A^B`求对称差集得`{4,17,54,72,83}`。最后`intersection_update(C)`与C取交集，结果为`{4,54}`。" }, { "id": 1253, "q": "执行下列程序后，s的值是（ ）。\nk,s=0,0\nn=12345\nwhile n:\n    s=s+1\n    k=k*10+n%10\n    n//=10\nprint(s)", "t": "fill", "ans": "5", "kp": "循环结构", "o": [], "explanation": "循环每次将n的个位数累加到k中（实现数字反转），同时s自增1记录位数，n整除10去掉个位。12345共有5位数，循环执行5次后n为0退出，s的值为5。" }, { "id": 1254, "q": "以下程序的运行结果是[*queNo*]_______。\nlst=[1,2,3,4]\nlst.insert(1,'a')\nlst.pop()\nlst.insert(9,'b')\nprint(lst)", "t": "fill", "ans": "[1, 'a', 2, 3, 'b']", "kp": "列表/元组", "o": [], "explanation": "insert(1,'a')在索引1处插入'a'；pop()移除末尾元素4；insert(9,'b')因索引9超出当前列表长度，直接将'b'追加到末尾。最终列表为[1, 'a', 2, 3, 'b']。" }, { "id": 1255, "q": "下面程序的执行结果是[*queNo*]________。\ns1=set([1,2,2,3,3,3,4])\ns2={1,2,5,6,4}\nprint((s1|s2)-(s1&s2))", "t": "fill", "ans": "{3,5,6}", "kp": "字典/集合", "o": [], "explanation": "s1去重后为{1,2,3,4}。s1|s2求并集得{1,2,3,4,5,6}，s1&s2求交集得{1,2,4}。两者相减即求对称差集，移除共有元素后剩下{3,5,6}。" }, { "id": 1256, "q": "以下sum函数的功能是：实现计算表达式1+3+……+（2n-1）值的函数。请在括号（）中填入正确答案。\ndef sum(n):\n    sum=0\n    for i in range(1,n+1):\n        temp=2*i-1\n        sum+=(___1____)\n   \n    return （___2___）\nk=eval(input(\"请输入n值：\"))\nprint (\"函数值为：\",sum(k))", "t": "fill", "ans": "temp | sum", "kp": "程序填空/调试", "o": [], "explanation": "第1空需将每次计算的奇数项temp累加到sum中，故填temp；第2空函数需返回累加后的总和，故填sum。两空分别实现累加和返回结果。" }, { "id": 1257, "q": "以下程序的运行结果是[*queNo*]_。\nclass Animal():\n    def move(self):\n        pass\nclass Rabbit(Animal):\n    def move(self):\n        print('兔子蹦蹦跳跳')\nr=Rabbit()\nr.move()", "t": "fill", "ans": "兔子蹦蹦跳跳", "kp": "面向对象", "o": [], "explanation": "子类Rabbit继承自Animal并重写了move方法。实例化Rabbit对象r后调用r.move()，会执行子类中重写的方法体，直接打印字符串\"兔子蹦蹦跳跳\"。" }, { "id": 1258, "q": "以下程序段的输出结果是[*queNo*]_。\nif 666:\n        print(9)", "t": "fill", "ans": "9", "kp": "分支结构", "o": [], "explanation": "Python中非零整数在布尔上下文中视为True。条件if 666成立，因此执行缩进后的print(9)语句，输出结果为9。" }, { "id": 1259, "q": "获得用户输入的一个数字，其中数字字符（0到9）用对应的中文字符“〇一二三四五六七八九”替换，输出替换后的结果，请完善PY102.py中的代码。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "n = input()\ns = \"〇一二三四五六七八九\"\nfor c in \"0123456789\":\nn=n.replace(c,s[int(c):int(c)+1])\nprint(n)", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1260, "q": "考生文件夹下存在一个文件PY101.py，请写代码替换横线，不修改其他代码，实现以下功能：\n键盘输入字符串s，按要求把s输出到屏幕，格式要求：宽度为20个字符，等号字符=填充，居中对齐。如果输入字符串超过20位，则全部输出。\n例如：键盘输入字符串s为\"PYTHON\"，屏幕输出 =======PYTHON=======\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "s = input(\"请输入一个字符串:\")\nprint(\"{:=^20}\".format(s))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1261, "q": "关于类型转换的描述，错误的选项是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "int('1.23')能将字符串转换为整数", "int(1+2j)不能将复数1+2j转换为整数类型，执行出错", "str(1+2j能将复数1+2j转换为字符串类型", "int(1.23)能将浮点数1.23转换为整数" ], "explanation": "int()函数转换字符串时，字符串必须表示合法的整数形式。'1.23'包含小数点，直接转换会引发ValueError，需先用float()转换。B、C、D描述均符合Python类型转换规则。" }, { "id": 1262, "q": "Python中对变量描述错误的选项是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "Python变量具有变量名、变量地址和变量值三个属性组成", "变量通过变量名访问", "变量名是内存单元的名称", "变量内置函数type()返回对象的内存地址" ], "explanation": "type()函数用于返回对象的数据类型，而非内存地址。获取内存地址应使用id()函数。A、B、C均正确描述了Python变量的基本特性与访问机制。" }, { "id": 1263, "q": "为了给整型变量x,y,z赋初值30，下列正确的Python语句是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "xyz=30", "x,y,z=30,30,30", "x=30,y=30,z=30", "x,y,z=30" ], "explanation": "Python支持多元赋值（解包赋值），x,y,z=30,30,30可一次性将右侧三个值分别赋给左侧三个变量。A会创建名为xyz的变量；C语法错误，逗号不能用于分隔独立赋值语句；D右侧值数量不足会引发解包错误。" }, { "id": 1264, "q": "驾照申请年龄要求。申请大型客车准驾车型驾照的年龄要求是：22周岁以上，60周岁以下。根据用户输入的年龄来判断，如果符合要求则提示：“可以申请！”，否则提示：“不可以申请！”。‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬请完善代码。‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬\nage = eval(input(\"请输入年龄：\"))\nif 22___     :\n      print(\"不可以申请！\")", "t": "fill", "ans": "age | else", "kp": "分支结构", "o": [], "explanation": "第1空需将输入的字符串转换为整数以便比较，结合上下文应填age（通常配合int(input())使用）；第2空用于处理不符合条件的情况，分支结构中与if配对的关键字为else。" }, { "id": 1265, "q": "程序填空题\ndef merge_dictionaries(dict1, dict2):\n    \"\"\"\n    合并两个字典，并返回合并后的字典。\n    \"\"\"\n    d = {}\n    d. ___1___ (___2_____)      \n   \n    d.update(dict2)\n    return d\n \ndict1 = {'a': 1, 'b': 2}\ndict2 = {'c': 3, 'd': 4}\nresult = merge_dictionaries(dict1, dict2)\nprint(result)", "t": "fill", "ans": "update | dict1", "kp": "字典/集合", "o": [], "explanation": "第1空调用字典的update方法，用于将另一个字典的键值对合并到当前字典d中；第2空传入dict1作为参数，先将dict1的内容合并到空字典d，随后再合并dict2，最终返回完整结果。" }, { "id": 1266, "q": "以下程序的运行结果是（ ）。\ns=0\ni=2\nwhile i<12:\n    s+=i\n    i=i+2\nprint(\"s=\",s)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "s=30", "s=42", "s=0", "s=24" ], "explanation": "循环初始i=2，每次增加2，直到i>=12停止。累加过程为2+4+6+8+10=30。循环结束后打印s=30，故选项A正确。" }, { "id": 1267, "q": "Python语句print(\"{:*^10}\".format(\"help\")) 中*代表的含义为（ ）", "t": "single", "ans": "C", "kp": "字符串", "o": [ "乘法", "乘方", "填充符号", "字符串的乘法" ], "explanation": "格式化字符串中，^表示居中对齐，10表示总宽度为10，*位于对齐符号前，代表用于填充空白位置的字符，即填充符号。" }, { "id": 1268, "q": "下列程序的输出结果是（）。\nfor x in range(2,8):\n    y=0\n    y+=x\nprint(y)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "27", "7", "8", "35" ], "explanation": "循环体内y=0在每次迭代时都会被重新赋值为0，因此y+=x实际只累加了当前x的值。循环最后一次x为7，执行后y等于7，最终打印结果为7。" }, { "id": 1269, "q": "已知列表s=list(\"apple\"), 那么执行语句s.remove('p')之后，列表s为（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "['a', 'l', 'e']", "['a', 'p', 'p', 'l', 'e']", "['p']", "['a', 'p', 'l', 'e']" ], "explanation": "list('apple')生成['a','p','p','l','e']。remove()方法默认删除列表中第一次出现的指定元素。因此只移除第一个'p'，剩余元素保持原顺序，结果为['a','p','l','e']。" }, { "id": 1270, "q": "下列语句执行后的结果是（ ）。\nd1={1:'food'}\nd2={1:'食品',2:'饮料'}\nd1.update(d2)\nprint(d1[1])", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "1", "2", "食品", "饮料" ], "explanation": "update()方法会用参数字典的键值对更新原字典。若键已存在，则覆盖原值。d2中的键1覆盖d1中键1的值'food'，变为'食品'，故打印结果为食品。" }, { "id": 1271, "q": "表达式str(10/2)的结果是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "va1ueError", "'5.0'", "'10/2'", "'5'" ], "explanation": "10/2在Python 3中执行真除法，结果为浮点数5.0。str()函数将其转换为字符串，因此结果为'5.0'。选项D的'5'是整除或Python 2的结果。" }, { "id": 1272, "q": "生成一个[1,99]之间随机整数的函数是（）。", "t": "single", "ans": "C", "kp": "random/turtle等标准库", "o": [ "random.randint(1,100)", "random.randint(0,99)", "random.randint(1,99)", "random.uniform(1,99)" ], "explanation": "random.randint(a, b)用于生成一个[a, b]闭区间内的随机整数。要生成[1, 99]之间的整数，参数应为1和99。uniform生成浮点数，其他选项区间不符。" }, { "id": 1273, "q": "s='1234567890'，以下表示'3456'的选项是（）。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "s[-8:-5]", "s[2:6]", "s[3:6]", "s[3:5]" ], "explanation": "字符串索引从0开始，'3'的索引为2，'6'的索引为5。切片s[2:6]包含索引2到5的字符，即'3456'。负数索引和错误边界会导致结果不符。" }, { "id": 1274, "q": "以下不能创建集合的语句是（ ）。", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "a=set()", "b=set(\"ABCD\")", "c={}", "d=frozenset((1,2,3))" ], "explanation": "在Python中，使用大括号{}且不带键值对时，创建的是空字典而非空集合。创建空集合必须使用set()函数。其他选项均能正确创建集合或冻结集合。" }, { "id": 1275, "q": "（）是一个变量，它接收传递给函数的参数。", "t": "single", "ans": "D", "kp": "函数", "o": [ "全局变量", "实参", "有名常量", "形参" ], "explanation": "形参（形式参数）是在函数定义时声明的变量，用于接收调用函数时传递的实参。全局变量作用域在函数外，实参是调用时传入的具体值。" }, { "id": 1276, "q": "以下程序运行后输出的结果是（ ）\ndef fun(a,b):\n     print(a%b,end=';')\n     print(a/b+a//b,end=' ')\nfun(19,2)", "t": "single", "ans": "B", "kp": "函数", "o": [ "1 18.5", "1; 18.5", "1 19.0", "1; 19.0" ], "explanation": "19%2结果为1，按end=';'输出'1;'。19/2为9.5，19//2为9，两者相加得18.5，按end=' '输出'18.5 '。拼接后结果为'1; 18.5'。" }, { "id": 1277, "q": "设a=set([1,2,2,3,3,3,4,4,4,4])，则A．remove(4)的值是（ ）。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{1, 2, 3}", "{1, 2, 2, 3, 3, 3, 4, 4, 4}", "{1, 2, 2, 3, 3, 3}", "[1, 2, 2, 3, 3, 3, 4, 4, 4]" ], "explanation": "集合的remove()方法用于移除指定元素，就地修改集合且返回None。题目表述实指执行移除操作后集合的内容。移除4后，集合去重并剩下{1, 2, 3}。" }, { "id": 1278, "q": "以下程序的输出结果是[*queNo*]__。\ndef func(str1):\n \n  str2 = ''\n  for i in range(len(str1)):\n    if '0' <= str1[i] <= '9':\n      str2 += str1[i].replace(str1[i],'*')\n    else:\n      str2 += str1[i]\n  return str2\nx = '23Me90'\nprint(func(x))", "t": "fill", "ans": "**Me**", "kp": "字符串", "o": [], "explanation": "程序遍历字符串，若字符为数字，则通过replace将其替换为'*'；若为字母则保留。'23Me90'中的数字均被替换为'*'，字母保留，故输出**Me**。" }, { "id": 1279, "q": "考生文件夹下存在一个文件PY101.py，请写代码替换横线，不修改其他代码，实现以下功能：\n键盘输入正整数n，按要求把n输出到屏幕，格式要求：宽度为14个字符，数字中间对齐，不足部分用=填充。\n例如：键盘输入正整数n为1234，屏幕输出=====1234=====\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "n = eval(input(\"请输入正整数:\"))\nprint(\"{:=^14}\".format(n))", "kp": "基础语法与输入输出", "o": [], "rawType": "operation" }, { "id": 1280, "q": "关于Python的数字类型，以下选项中描述错误的是（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "复数类型虚部为0时，表示为1+0j", "1.0是浮点数，不是整数", "浮点数也有十进制、二进制、八进制和十六进制等表示方式", "整数类型的数值一定不会出现小数点" ], "explanation": "浮点数只有十进制和科学计数法表示，不支持二进制、八进制和十六进制表示，这些进制前缀仅适用于整数类型。因此选项C描述错误。" }, { "id": 1281, "q": "以下是 print('\\nPython') 语句运行结果的是（）。", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "在新的一行输出：Python", "直接输出：'\\nPython'", "直接输出：\\nPython", "先输出n,然后新的一行输出 Python" ], "explanation": "\\n是转义字符，代表换行。print语句会先输出一个换行符，然后在新的一行输出Python，不会直接输出\\n字符本身。" }, { "id": 1282, "q": "下列导入math 库的语句中错误的是（ ）。", "t": "single", "ans": "D", "kp": "异常与库", "o": [ "import math", "import math as M", "from math import *", "import math from *" ], "explanation": "Python导入模块的正确语法包括import math、import math as M和from math import *。选项D的语法颠倒，属于错误语句。" }, { "id": 1283, "q": "表达式int('100/3')的执行结果是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "33.3", "va1ueError", "33", "'100/3'" ], "explanation": "int()函数只能将纯数字字符串或浮点数转换为整数。字符串'100/3'包含除号，不是合法的数字字面量，执行时会抛出ValueError异常。" }, { "id": 1284, "q": "下列选项中，不属于Python特点的是（ ）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "解释型", "运行效率高", "可读性好", "简单易学" ], "explanation": "Python是解释型语言，代码运行时逐行翻译，执行效率通常低于C/C++等编译型语言。其核心优势在于语法简洁、可读性强且易于学习。选项B\"运行效率高\"不符合Python实际特性，故为正确答案。" }, { "id": 1285, "q": "下面的代码的输出结果是（ ）\nx=56\nprint(type(x))", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "", "", "", "" ], "explanation": "变量x被赋值为整数56，type(x)函数用于获取对象的数据类型。在Python中，整数的类型为int，因此print(type(x))会输出。该题考查基础数据类型识别，正确选项对应此输出结果。" }, { "id": 1286, "q": "下列程序的运行结果是（ ）\nx=30\nx,y =12,x\nprint(x,y)", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "12 12", "12 30", "30 12", "程序出错" ], "explanation": "Python支持多重赋值，右侧表达式先整体求值再依次赋给左侧变量。执行x,y=12,x时，右侧先计算为(12,30)，随后将12赋给x，30赋给y。因此最终x为12，y为30，输出结果为12 30。" }, { "id": 1287, "q": "如果p=ord('a'),表达式print(p,chr((p+3)%26+ord('a')))的结果是（）", "t": "single", "ans": "D", "kp": "字符串", "o": [ "97 d", "97 c", "97 x", "97 w" ], "explanation": "ord('a')返回ASCII码97，故p=97。计算(97+3)%26+97时，先算100%26=22，再加97得119。chr(119)对应字符'w'。因此输出为97 w。该题考查ASCII码转换与取模运算。" }, { "id": 1288, "q": "以下关于语言类型的描述正确的是（）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "静态语言采用解释方式执行，脚本语言采用编译方式执行", "C语言是静态语言，Python是脚本语言", "编译是将目标代码转换成源代码的过程", "解释是将源代码一次性转换成目标代码同时逐条运行目标代码的过程" ], "explanation": "静态语言通常在编译时确定类型，C语言是典型代表；Python属于动态脚本语言，运行时确定类型且通常解释执行。A项混淆执行方式；C项编译是将源码转目标代码；D项解释是逐行翻译。故B正确。" }, { "id": 1289, "q": "以下程序的输出结果是（）\nastr='0\\n'\nbstr='A\\ta\\n'\nprint(\"{}{}\".format(astr,bstr))", "t": "single", "ans": "D", "kp": "字符串", "o": [ "0\na a", "0\nA A", "A a", "0\nA a" ], "explanation": "astr包含字符0和换行符，bstr包含A、制表符、a和换行符。format拼接后打印，换行符导致分行显示，制表符产生缩进。实际显示为第一行0，第二行缩进后显示A a。选项D符合该排版效果。" }, { "id": 1290, "q": "在Python程序设计语言中,用于输入和输出的函数分别是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "read( )和write( )", "input( )和output( )", "input( )和print( )", "cin( )和cout( )" ], "explanation": "Python标准库中，input()用于接收用户键盘输入并返回字符串，print()用于将数据输出到控制台。A项为文件操作方法，B项output非内置函数，D项为C++语法。故C为正确答案。" }, { "id": 1291, "q": "若输入x为74，输出的grade是（ ）\nx=int(input())\nif x>=60:\n    grade='D'\nelif x>=70:\n    grade='C'\nelif x>=80:\n    grade='B'\nelse:\n    grade='A'\nprint(grade)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "A", "B", "C", "D" ], "explanation": "if-elif结构按顺序判断，一旦条件满足即执行对应分支并跳出后续判断。输入74满足x>=60，直接执行grade='D'，后续elif不再执行。因此输出为D。该题考查分支结构的短路执行特性。" }, { "id": 1292, "q": "设x= 10; y = 20，下列语句能正确运行结束的是（）。", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "if x>y\nmax=x", "if xy else y", "if(x>y)\nprint(x)" ], "explanation": "A项缺少冒号；C项使用C语言三元运算符，Python不支持；D项条件判断缺少冒号。B项虽为单行写法，但在考题语境中代表条件分支的正确逻辑结构，且语法相对最接近规范，故为正确答案。" }, { "id": 1293, "q": "以下关于Python语言的描述中，正确的是（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "条件4<=5<=6是合法的，输出False", "条件4<=5<=6是不合法的", "条件4<=5<=6是合法的，输出True", "条件4<=5<=6是不合法的，输出异常" ], "explanation": "Python支持链式比较运算符，4<=5<=6等价于4<=5 and 5<=6。两个条件均成立，整体表达式返回布尔值True。该特性为Python独有语法糖，故C正确。" }, { "id": 1294, "q": "以下代码的输出结果是（）。\nx=True\ny=True\nz=False\nif x:\n   if y or z:\n      print(\"yes\")\nelse:\n   print(\"no\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "yes", "no", "True", "无输出" ], "explanation": "外层if x为True，进入内层判断。y or z中y为True，短路求值使表达式为True，执行print(\"yes\")。else与外层if对齐，因外层条件满足故不执行。最终输出yes。" }, { "id": 1295, "q": "成员测试运算符为（ ）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "and", "or", "not", "in" ], "explanation": "Python中in用于判断元素是否存在于序列或集合中，返回布尔值，属于成员测试运算符。and、or、not为逻辑运算符，用于布尔表达式组合与取反。故D正确。" }, { "id": 1296, "q": "以下代码的输出结果是（）。\nn=50\ns=10\nif n>=5:\n    n-=10\ns=4\nprint(s)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "3", "4", "10", "2" ], "explanation": "程序首先判断n>=5成立，执行n-=10。接着执行s=4，将变量s的值覆盖为4。最后打印s的值，因此输出结果为4。注意s=4没有缩进，属于顺序执行的语句。" }, { "id": 1297, "q": "下面代码的输出结果是（）。\nfor i in range(0,10,2):\n    print(i,end=\" \")", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0 2 4 6 8", "2 4 6 8", "0 2 4 6 8 10", "2 4 6 8 10" ], "explanation": "range(0, 10, 2)生成从0开始、步长为2、小于10的整数序列，即0, 2, 4, 6, 8。循环依次打印这些数字，并以空格分隔，因此输出为0 2 4 6 8。" }, { "id": 1298, "q": "有以下程序段：\nn=0\np=0\nwhile p!=100 and n<3:\n     p=int(input())\n     n+=1\nwhile循环结束的条件是（ ）。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "P的值不等于100并且n的值小于3", "P的值等于100并且n的值大于等于3", "P的值不等于100或者n的值小于3", "P的值等于100或者n的值大于等于3" ], "explanation": "while循环在条件表达式为假时结束。原条件为\"p!=100 and n<3\"，根据德摩根定律，其逻辑非（即结束条件）为\"p==100 or n>=3\"，即P的值等于100或者n的值大于等于3。" }, { "id": 1299, "q": "以下程序段的运行结果是（ ）。\nn=1\nwhile True:\n      if n%2==0:\n            continue\n      n=n+1\n      if n%3==0:\n            break\n      n=n+1\nprint(\"n=\",n)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "n=6", "n=5", "n=4", "死循环" ], "explanation": "初始n=1。第1次循环：n为奇数，n加1变2，不被3整除，n加1变3。第2次循环：n为奇数，n加1变4，不被3整除，n加1变5。第3次循环：n为奇数，n加1变6，能被3整除，触发break跳出循环。最终打印n=6。" }, { "id": 1300, "q": "设有程序段：\ns=\"str\"\nfor i in [\"1\",\"2\",\"3\",\"4\",\"5\"]:\n      pass\nprint(s)\n则程序的运行结果是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "str", "s", "t", "r" ], "explanation": "程序定义字符串变量s为\"str\"。随后的for循环遍历列表，但循环体内只有pass语句，未对s进行任何修改。循环结束后打印s，因此输出结果仍为原字符串\"str\"。" }, { "id": 1301, "q": "若输入为2，则下列程序的输出结果是（ ）。\nfor i in range(0,1):\n    num = int(input(\"请输入数字：\"))\n    n = 0\n        while n <= num:\n            print(n, end=\" \")\n            n += 1", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0 1 2", "0 1 1", "1 0 0", "0 2 1" ], "explanation": "外层循环仅执行1次。输入2后，num赋值为2。内层while循环从n=0开始，只要n<=2就打印n并让n加1。因此依次打印0、1、2。注意原题代码中while语句缩进有误，实际运行会报错，此处按逻辑意图解析。" }, { "id": 1302, "q": "执行下列语句后的显示结果是（ ）。\nworld=\"world\"\nprint(\"hello\"+worlD）", "t": "single", "ans": "A", "kp": "字符串", "o": [ "helloworld", "\"hello\"world", "hello world", "\"hello\"+world" ], "explanation": "该题考察字符串的拼接操作。使用加号\"+\"可以将两个字符串连接在一起。将\"hello\"与\"world\"拼接，结果为\"helloworld\"。注意原题代码中存在变量名大小写拼写错误及全角括号，实际运行会报错，此处按出题意图解析。" }, { "id": 1303, "q": "下面（）可以将字符串s正序打印出来", "t": "single", "ans": "C", "kp": "字符串", "o": [ "s[:-1]", "s[0:-1]", "s[0:len(s)]", "s[0:len(s)-1]" ], "explanation": "字符串切片语法为[start:end]，包含start但不包含end。要正序打印完整字符串，起始索引为0，结束索引应为字符串长度len(s)。选项C的s[0:len(s)]能截取从首字符到末尾的所有字符，实现正序完整打印。" }, { "id": 1304, "q": "对于列表L=['abc',2,[1,2,3],'hello']，L[-2]的值是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "'abc'", "2", "[1, 2, 3]", "'hello'" ], "explanation": "列表支持负数索引，-1表示最后一个元素，-2表示倒数第二个元素。列表L共有4个元素，倒数第二个元素是列表[1, 2, 3]，因此L[-2]的值为[1, 2, 3]。" }, { "id": 1305, "q": "表达式(1,2,3)<(1,2)的值是（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "true", "false", "True", "False" ], "explanation": "Python中元组的大小比较是按元素位置逐个进行的。前两个元素1和2均相等，但第一个元组有3个元素，第二个只有2个。在比较时，较短的元组被认为更小，因此(1,2,3)大于(1,2)，该表达式结果为False。" }, { "id": 1306, "q": "已知列表s=[4,3,1,2], 那么执行语句s.remove(2)之后，列表s为（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[4, 3]", "[4, 3, 2]", "[4, 3, 1]", "[4, 1, 2]" ], "explanation": "列表的remove(x)方法用于移除列表中第一个值等于x的元素。原列表s为[4, 3, 1, 2]，执行s.remove(2)后，元素2被移除，列表更新为[4, 3, 1]。" }, { "id": 1307, "q": "以下代码的输出是什么？\ns1 = set([1, 2, 3])\ns2 = set([2, 3, 4])\ns3 = set([3, 4, 5])\ns4 = s1.symmetric_difference(s2).intersection(s3)\nprint(s4)", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "{2, 3, 4}", "{2, 4}", "{3}", "{4}" ], "explanation": "symmetric_difference求对称差集，s1和s2的对称差集为{1, 4}。接着调用intersection求交集，{1, 4}与s3（{3, 4, 5}）的交集为{4}。因此最终s4的值为{4}。" }, { "id": 1308, "q": "执行以下代码的结果是（ ）。\ndict={'a':1,'b':2,'c':3}\ndel dict['b']\ndict['b']='4'\ndel dict['c']\nlen(dict)", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "0", "1", "2", "3" ], "explanation": "字典初始有3个键值对。`del dict['b']`删除键'b'，剩2个；`dict['b']='4'`新增键'b'，变为3个；`del dict['c']`删除键'c'，剩2个。最终字典包含'a'和'b'两个键，`len(dict)`返回键值对数量2。" }, { "id": 1309, "q": "关于函数的说法中正确的是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "函数定义时必须有形参", "python函数不需要指定函数名", "函数定义时可以不带return语句", "实参与形参的个数可以不相同，类型可以任意" ], "explanation": "Python函数定义时形参可以为空；使用`def`定义函数必须指定函数名；实参与形参个数通常需匹配。函数体中可以不写`return`语句，此时函数默认返回`None`，故C正确。" }, { "id": 1310, "q": "下列代码运行后的结果是（ ）。\ndef sub(n):\n    if n<=1:\n        return 1\n    else:\n        return n-sub(n-1)\ns=sub(5)\nprint(\"{}\".format(s))", "t": "single", "ans": "D", "kp": "函数", "o": [ "0", "1", "2", "3" ], "explanation": "递归函数`sub(n)`在`n<=1`时返回1。推导过程：`sub(1)=1`，`sub(2)=2-1=1`，`sub(3)=3-1=2`，`sub(4)=4-2=2`，`sub(5)=5-2=3`。最终`s`的值为3。" }, { "id": 1311, "q": "以下程序代码的运行结果正确的是（ ）。\ny=10\nk=5\ndef fun():\n    global y\n    y=3\n    k=2\n    print(\"y=%d,k=%d\"%(y,k))\nfun()\nprint(\"y=%d,k=%d\"%(y,k))", "t": "single", "ans": "A", "kp": "函数", "o": [ "y=3,k=2\ny=3,k=5", "y=10,k=2\ny=3,k=5", "y=3,k=2\ny=10,k=5", "y=10 ,k=2\ny=10,k=5" ], "explanation": "函数内使用`global y`声明`y`为全局变量，修改`y=3`会影响全局；而`k=2`未声明全局，是局部变量，不影响全局`k`。因此函数内打印`y=3,k=2`，函数外打印全局变量`y=3,k=5`。" }, { "id": 1312, "q": "下列代码的运行结果是（ ）。\nroud=lambda x,n:round(x,n)\nprint(roud(12.2367,2))", "t": "single", "ans": "B", "kp": "函数", "o": [ "12.23", "12.24", "12.2367", "12" ], "explanation": "`lambda`表达式定义了一个匿名函数`roud`，调用内置函数`round(x, n)`对`x`保留`n`位小数。`round(12.2367, 2)`根据四舍五入规则保留两位小数，结果为12.24。" }, { "id": 1313, "q": "执行以下代码的结果是（ ）。\nx=[]\ndef func(a,b):\n    x.append(b)\n    return a*b\ns=func(\"hello!\",2)\nprint(s,x)", "t": "single", "ans": "B", "kp": "函数", "o": [ "hello! [2]", "hello!hello! [2]", "hello! 2", "hello!hello! 2" ], "explanation": "列表`x`是全局可变对象，函数内`x.append(b)`将2加入列表，`x`变为`[2]`。`a*b`即字符串`\"hello!\"`乘以2，结果为`\"hello!hello!\"`。最终打印`s`和`x`的值。" }, { "id": 1314, "q": "Python类中定义的方法的第一个参数一般是（ ），它可以访问类的成员。", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "self", "me", "this", "与类同名" ], "explanation": "在Python面向对象编程中，类中定义的实例方法的第一个参数通常是`self`。它代表类的实例本身，通过`self`可以访问类的属性和其他方法。" }, { "id": 1315, "q": "以下程序的输出结果是（）\nclass Person:\n    name='aa'\n    def printName(self):\n        self.name='bb'\n        print(self.name)\n print(Person.name)", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "aa", "bb", "aabb", "bbaa" ], "explanation": "代码中定义了类属性`name='aa'`。虽然类中定义了`printName`方法会修改实例属性，但程序并未实例化对象，也未调用该方法，而是直接通过`Person.name`访问类属性，因此输出原值'aa'。" }, { "id": 1316, "q": "有以下代码：class D（A，B，C）：，以下说法正确的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "A是子类", "B是子类", "C是父类", "D是父类" ], "explanation": "在Python类的继承语法`class 子类(父类1, 父类2, ...):`中，括号内的是父类（基类），括号前的是子类（派生类）。因此D是子类，A、B、C均为父类。" }, { "id": 1317, "q": "以下关于turtle库的描述，错误的是（ ）。", "t": "single", "ans": "D", "kp": "random/turtle等标准库", "o": [ "在import turtle 之后，可以用turtle.penup()语句表示抬起画笔，海龟在飞行", "seth(x)是setheading(x)函数的别名，让画笔旋转x角度", "可以用import turtle 来导入turtle库函数", "home()函数设置当前画笔位置到原点，方向朝上" ], "explanation": "`turtle.home()`函数的作用是将画笔移动到原点(0,0)，并将画笔方向设置为朝东（即0度方向），而不是朝上（90度）。其他选项关于`penup`、`seth`和`import`的描述均正确。" }, { "id": 1318, "q": "下列程序的输出结果是（）？\nf=open('D:\\\\out.txt','w+')\nf.write('1:www.runoob.com')\nf.seek(3,0)\nc=f.read(10)\nprint(c)\nf.close()", "t": "single", "ans": "A", "kp": "文件操作", "o": [ "ww.runoob.", "1:www.runoob.com", "runoob.com", "1:www" ], "explanation": "文件写入`'1:www.runoob.com'`后，`seek(3, 0)`将文件指针从开头向后移动3个字节，指向第4个字符（即第二个'w'）。随后`read(10)`读取10个字符，结果为`'ww.runoob.'`。" }, { "id": 1319, "q": "下列 Python 程序的运行结果是（ ）。\ns1={4,3,2,1} &{7,8}\ns2={1,5,9,2,6}-{1,2}\ns1|=s2\nprint(s1)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{9, 5, 6}", "{1, 2}", "{1, 2, 3, 4}", "{1, 2, 9}" ], "explanation": "`s1`为两集合交集，无共同元素，结果为空集。`s2`为差集，去除1和2后剩`{5, 9, 6}`。`s1 |= s2`将`s2`元素并入`s1`，最终`s1`为`{9, 5, 6}`（集合输出顺序可能不同，但元素一致）。" }, { "id": 1320, "q": "用户输入一个大写字母，请填空实现将其转换成小写字母。\nch=input(\"请输入一个大写字母\")\nif ch>='A' __1__ ch<='Z':\n        x=chr(ord(ch)__2__32)\nprint(x)", "t": "fill", "ans": "and | +", "kp": "字符串", "o": [], "explanation": "第1空判断字符是否在大写字母范围内，需同时满足大于等于'A'且小于等于'Z'，故填逻辑与and。第2空大写字母转小写字母，其ASCII码值需加32，故填+。" }, { "id": 1321, "q": "有以下程序代码：定义一个Parent类， 类中包含mymethod方法；定义一个Child类，继承自Parent类，并重写父类的mymethod方法；基于Child类创建一个实例对象c1,并调用其mymethod方法。请将程序补充完整。\nclass Parent:\n    def mymethod(self):\n        print(\"调用父类方法\")\nclass Child(__1____):\n    def mymethod(___2__):\n        print('调用子类方法')\nc1=Child()\nc1.___3_____()", "t": "fill", "ans": "Parent | self | mymethod", "kp": "面向对象", "o": [], "explanation": "第1空子类继承父类，括号内填入父类名Parent。第2空定义实例方法时，第一个参数必须是self代表实例本身。第3空通过实例对象调用重写后的方法，填入方法名mymethod。" }, { "id": 1322, "q": "以下代码的输出结果是（）。\nfor s in \"PythonNice!\":\n    if s ==\"i\":\n        break\nprint(s,end =\"\")", "t": "fill", "ans": "i", "kp": "循环结构", "o": [], "explanation": "循环遍历字符串\"PythonNice!\"，当字符为\"i\"时触发break跳出循环。此时循环变量s的值停留在\"i\"。跳出循环后执行print(s)，因此输出结果为i。" }, { "id": 1323, "q": "执行以下程序，输出结果是：[*queNo*]____。\nlist1=[1,2,3]\nlist1.reverse()\nprint(list1[0])", "t": "fill", "ans": "3", "kp": "列表/元组", "o": [], "explanation": "reverse()方法将列表元素原地反转，list1变为[3, 2, 1]。随后通过索引[0]访问列表的第一个元素，即反转后的首元素，因此输出结果为3。" }, { "id": 1324, "q": "下列程序运行的结果是什么？\ndef remove_duplicates(text):\n    unique_chars = ''.join(set(text))\n    return unique_chars\ntext = \"abracadabra\"\nresult = remove_duplicates(text)\nprint(len(result))", "t": "fill", "ans": "5", "kp": "算法与综合应用", "o": [], "explanation": "set(text)将字符串转为集合以去除重复字符，\"abracadabra\"包含'a','b','r','c','d'共5个不重复字符。join将其转回字符串，len()求长度，故输出5。" }, { "id": 1325, "q": "以下count函数的功能是统计字符串s中数字字符出现的次数并将统计结果返回。若字符串为“how9y56ar02my”,则数字字符个数为5。请在括号（）中填入正确答案。\ndef count(__1___):\n    ___2___\n    for n in s:\n        if n>='0' and n<='9':\n            t+=1\n    return t\nn=input(\"请输入字符串:\")\nprint(count(n))", "t": "fill", "ans": "s | t=0", "kp": "函数", "o": [], "explanation": "第1空函数需接收待统计的字符串参数，结合下方循环for n in s，应填形参s。第2空在循环累加前需初始化计数器变量，故填t=0，以便后续执行t+=1。" }, { "id": 1326, "q": "下列程序的输出结果是        。\ncount=1\nnum=0\ndef Test():\n    global count\n    for i in (1,2,3,4,5,6):count+=1\n    num=10\nTest()\nprint(count)", "t": "fill", "ans": "7", "kp": "函数", "o": [], "explanation": "函数内使用global count声明全局变量，循环6次使count每次加1，最终count变为1+6=7。函数内的num=10是局部变量，不影响全局。最后打印全局count，输出7。" }, { "id": 1327, "q": "以下代码的执行结果是_____。\nclass St:\n    def __init__(self,name,age):\n        self.name=name\n        self.age=age\ns=[St(\"John\",19),St(\"Iris\",18),St(\"Mary\",17),St(\"Jack\",16)]\nt=0\nfor i in s:\n    t+=i.age\nt/=4\nprint(t)", "t": "fill", "ans": "17.5", "kp": "面向对象", "o": [], "explanation": "列表s包含4个St实例，年龄分别为19、18、17、16。循环累加所有实例的age属性，总和为70。随后t/=4计算平均年龄，70除以4等于17.5，故输出17.5。" }, { "id": 1328, "q": "有以下程序代码，输出结果是[*queNo*]_。\nf1=open('d:\\\\a1.txt','w')\nf1.write(\"1\")\nf1.write('2')\nf1.close()\nf1=open('d:\\\\a1.txt','r')\ns=f1.readline()\nprint(s)", "t": "fill", "ans": "12", "kp": "文件操作", "o": [], "explanation": "以写模式打开文件并依次写入\"1\"和\"2\"，文件内容为\"12\"。关闭后以读模式重新打开，readline()读取第一行内容即\"12\"。打印该字符串，输出结果为12。" }, { "id": 1329, "q": "以下代码的输出结果是[*queNo*]_。\ni=300\nj=40\nk=50\nif(i>j):\n    if(i>k):\n        print(i)\n    else:\n        print(j)\nelse:\n    if(ij（300>40）成立，进入第一层if块。接着判断i>k（300>50）也成立，进入第二层if块，执行print(i)。因此最终输出变量i的值300。" }, { "id": 1330, "q": "考生文件夹下存在一个文件PY101.py，请写代码替换横线，不修改其他代码，实现以下功能：\n随机选择一个手机品牌屏幕输出。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import random\nrandom.seed([x])\n注意：seed()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。\n参数x -- 改变随机数生成器的种子seed。\nrandint(a,b)随机数中是包括a和b区间的数。\n参数代码如下：\nimport random\nbrandlist = ['华为','苹果','诺基亚','OPPO','小米']\nrandom.seed(0)\ni=random.randint(0,4)\nname=brandlist[i]\nprint(name)", "kp": "random/turtle等标准库", "o": [], "rawType": "operation" }, { "id": 1331, "q": "考生文件夹下存在一个文件PY101.py，请写代码替换横线，实现以下功能：\n从键盘输入4个数字，各数字采用空格分隔，对应为变量x0,y0,x1,y1。计算两点（x0,y0）和（x1,y1）之间的距离，屏幕输出这个距离，保留2位小数。\n例如：键盘输入：0 1 3 5 屏幕输出：5.00\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "ntxt = input(\"请输入4个数字(空格分隔):\")\nnls=ntxt.split()\nx0 = eval(nls[0])\ny0 = eval(nls[1])\nx1 = eval(nls[2])\ny1 = eval(nls[3])\nr = pow(pow(x1-x0,2) + pow(y1-y0,2),0.5)\nprint(\"{:.2f}\".format(r))", "kp": "算法与综合应用", "o": [], "rawType": "operation" }, { "id": 1332, "q": "使用turtle库的turtle.fd()函数和turtle.seth()函数绘制一个边长为100的正五边形，在考生文件夹下给出了程序框架文件PY201.py，在横线处补充代码，不得修改其它代码。效果如下图所示。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import turtle\nturtle.pensize(2)\nd = 0\nfor i in range(1,6):\nturtle.fd(100)\nd += 72\nturtle.seth(d)", "kp": "random/turtle等标准库", "o": [], "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-turtle-pentagon-1332.png", "rawType": "operation" }, { "id": 1333, "q": "运行下列代码时输入120，则程序输出结果是（）\na=int(input())\nif a>100:x=20\nelse:x=200\nprint(x)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "20", "200", "报错", "没有输出" ], "explanation": "输入120并转为整型赋给a。判断条件a>100（120>100）为真，执行x=20，跳过else分支。最后打印x的值，因此输出结果为20，选A。" }, { "id": 1334, "q": "下面说法错误的是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "字符串的索引编号中，起始位置、结束位置和步长都可以省略。", "分片操作很灵活，开始和结束的索引值都可以超过字符串的长度。", "分片操作不会产生新的字符串，可以改变原来的字符串。", "索引编号只能是整数，不能是字符。" ], "explanation": "字符串在Python中是不可变数据类型。分片（切片）操作会提取子串并生成一个新的字符串对象，而不会改变原字符串的内容。因此选项C说法错误，符合题意。" }, { "id": 1335, "q": "已知列表list1=list(range(10)), 那么执行语句del list1[:4]之后, list1的值为（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[0,1,2,3]", "[4, 5, 6, 7, 8, 9]", "[ 4, 5, 6, 7, 8, 9, 10]", "[3, 4, 5，6, 7, 8]" ], "explanation": "list(range(10))生成包含0到9的列表。切片[:4]表示从开头到索引3的元素，即0、1、2、3。del语句删除这些元素后，列表剩余元素为4到9。因此结果为[4, 5, 6, 7, 8, 9]。" }, { "id": 1336, "q": "（）不是合法的浮点型数据。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "45e-5", "3.23", "0.0", "9e2.3" ], "explanation": "Python中浮点数的科学计数法表示形式为aeb或aEb，其中指数部分b必须是整数。选项D中的指数2.3是小数，不符合语法规则，因此不是合法的浮点型数据。" }, { "id": 1337, "q": "一个新类从已有的类那里获得其已有特性，这种现象称为（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "消息", "继承", "多态", "封装" ], "explanation": "面向对象编程中，一个新类从已有的类那里获得其已有特性（属性和方法）的现象称为继承。封装是隐藏内部实现，多态是同一接口不同实现，消息是对象间的通信机制。" }, { "id": 1338, "q": "以下程序的输出结果是（ ）\na,b=1,2\nprint(\"{1}{0}{0}\".format(a,b))", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "110", "112", "211", "221" ], "explanation": "format方法中，大括号内的数字代表参数的索引位置，从0开始。{1}对应第二个参数b（值为2），{0}对应第一个参数a（值为1）。因此格式化后的字符串拼接结果为211。" }, { "id": 1339, "q": "访问字符串中的部分字符的操作称为( )。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "切片", "索引", "合并", "赋值" ], "explanation": "在Python中，通过索引可以访问字符串中的单个字符，而通过切片操作可以访问或提取字符串中的部分字符（即子串）。合并是字符串拼接，赋值是修改变量。" }, { "id": 1340, "q": "以下说法正确的是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "4j不是合法的Python数值数据类型", "3+4j是合法的Python数值数据类型", "复数类型中的J表示1的平方根", "a+bj中a是虚部，b是实部" ], "explanation": "Python支持复数类型，虚数单位可以用j或J表示。在复数a+bj中，a是实部，b是虚部。4j和3+4j都是合法的复数数值类型，因此选项B说法正确。" }, { "id": 1341, "q": "Python语句print(\"Good+morning\")的运行结果是（）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "Goodmorning", "Good", "Good+morning", "morning" ], "explanation": "print函数输出字符串时，会原样打印引号内的所有字符，包括加号。由于\"Good+morning\"是一个完整的字符串字面量，加号不会被当作运算符处理，直接输出Good+morning。" }, { "id": 1342, "q": "下列函数中，不是Python内置函数的是（）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "range()", "abs()", "close()", "eval()" ], "explanation": "range()、abs()和eval()都是Python的内置函数，可直接调用。而close()通常是文件对象或网络连接等对象的方法（如file.close()），用于关闭资源，并非全局内置函数。" }, { "id": 1343, "q": "下列表达式中，值不是1的是（ ）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "4//3", "15 % 2", "5%3-1", "5/3" ], "explanation": "选项A中4//3为整除，结果为1；选项B中15%2为取余，结果为1；选项C中5%3-1先算取余得2，减1后为1；选项D中5/3为真除法，结果为浮点数1.666...，不等于1。" }, { "id": 1344, "q": "以下关于Python程序设计语言的特点，错误的是（ ）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "程序可读性好", "只具备基本的数值类型", "Python语言是一种解释型的语言", "Python语言既可以面向过程，也可以面向对象" ], "explanation": "Python不仅有基本的数值类型（如整型、浮点型、复数），还内置了丰富的数据结构（如列表、元组、字典、集合等），因此\"只具备基本的数值类型\"说法错误。其他选项均符合Python特点。" }, { "id": 1345, "q": "下面属于整型常量的是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "\"58\"", "5.14", "-21", "'32'" ], "explanation": "整型常量是不带小数部分的数字。选项A和D带有引号，属于字符串类型；选项B带有小数点，属于浮点型；选项C的-21是带有负号的整数，属于整型常量。" }, { "id": 1346, "q": "执行语句x=eval(input( ))，若输入123.5，那么 x 的类型是（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "整型", "字符串", "浮点型", "以上都错误" ], "explanation": "input()函数接收用户输入并返回字符串。eval()函数会将传入的字符串当作有效的Python表达式进行求值。输入\"123.5\"被eval解析后，会转换为浮点数123.5，因此x的类型是浮点型。" }, { "id": 1347, "q": "以下关于分支结构的描述中，错误的是（　　）。", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "if语句中语句块执行与否依赖于条件判断", "if语句中条件部分可以使用任何能够产生True和False的语句和函数", "二分支结构有一种紧凑形式，使用保留字if和elif实现。", "多分支结构用于设置多个判断条件以及对应的多条执行路径" ], "explanation": "Python的二分支紧凑形式为\"值1 if 条件 else 值2\"，而非使用if和elif。if-elif-else属于多分支结构，用于处理多个条件分支。因此C选项描述错误，为本题正确答案。" }, { "id": 1348, "q": "下面的代码在运行时输入“123”，则输出结果是（）。\nx=input()\nif x== '1':\n    print('One')\nelse:\n    print('other')", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "One", "没有输出", "报错", "Other" ], "explanation": "input()函数接收输入并返回字符串类型，此时x的值为\"123\"。条件判断x=='1'结果为False，程序跳过if块执行else分支，输出\"other\"。结合选项逻辑，D为正确结果。" }, { "id": 1349, "q": "设三角形三条边的长分别为a,b,c,则三条边满足表达式（）可构成一个等边三角形。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "a+b>c", "a==b and b==c", "b-c>a", "a+b>c and c+b>a and c+a>b" ], "explanation": "等边三角形的定义是三条边长度完全相等。在Python中，需使用逻辑与运算符and连接两个相等判断，即a==b and b==c。A和D选项仅为构成普通三角形的条件，故B正确。" }, { "id": 1350, "q": "以下代码的输出结果是（）。\nage=35\nif 25<=age<=30:\n   if age<=25:\n      print(\"作为一个老师，你太年轻了\")\n   else:\n      print(\"作为一个老师，你很年轻\")\nelse:\n   print(\"作为一个老师，你很有爱心\")", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "作为一个老师，你很年轻", "作为一个老师，你太年轻了", "报错", "作为一个老师，你很有爱心" ], "explanation": "变量age赋值为35，外层条件25<=age<=30判断结果为False，因此程序直接跳过内部嵌套的if-else结构，执行外层else分支，输出\"作为一个老师，你很有爱心\"。" }, { "id": 1351, "q": "判断m能否同时被n和p整除( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "m%n==0 and m%p==0", "m%n==0 or m%p==0", "m\n==0", "m%n=0" ], "explanation": "判断整除需使用取余运算符%，当余数为0时表示能整除。\"同时满足\"两个条件需使用逻辑与运算符and连接。D选项使用了赋值符号=而非比较符号==，故A正确。" }, { "id": 1352, "q": "以下代码的输出结果是（　　）。\nfor i in range(1,6):\n    if i%4==0:\n        continue\n    else:\n        print(i,end=\",\")", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "1,2,3,", "1,2,3,4", "1,2,3,5,", "1,2,3,5,6" ], "explanation": "range(1,6)依次生成1至5。当i为1、2、3时，i%4==0为假，执行else打印数字加逗号；i为4时条件为真，continue跳过本次循环剩余代码；i为5时再次打印。最终输出1,2,3,5,。" }, { "id": 1353, "q": "以下保留字不属于分支或循环逻辑的是（　　）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "while", "do", "elif", "for" ], "explanation": "Python语言中不存在do保留字，do-while循环常见于C或Java等语言。while和for用于循环结构，elif用于多分支结构，因此B选项不属于Python的分支或循环关键字。" }, { "id": 1354, "q": "以下程序执行后打印星号*的个数是( )。\nfor i in range(10):\n    if i<=8:\n        continue\n    print(\"*\",end='')", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1", "8", "5", "10" ], "explanation": "range(10)生成0到9的整数。循环中当i为0至8时，条件i<=8成立，执行continue跳过打印语句；仅当i等于9时条件不成立，执行一次print输出星号。故共打印1个。" }, { "id": 1355, "q": "设从键盘输入一个为大于或等于1的整数，则下列程序段不能完成n！计算的是（ ）。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "n=eval(input())\nt=1\nfor i in list(range(1,1+n)):\nt=t*i\nprint(t)", "n=eval(input())\nt=1\nfor i in list(range(n,0,-1)):\nt=t*i\nprint(t)", "n=eval(input())\nt=1\ni=1\nwhile i", "n=eval(input())\nt=1\nfor i in list(range(n)):\nt=t*i\nprint(t)" ], "explanation": "阶乘计算需累乘1到n的所有整数。D选项中range(n)生成的序列包含0，累乘过程中一旦乘以0，结果将恒为0，无法得到正确的阶乘值。其他选项均能正确遍历1至n进行累乘。" }, { "id": 1356, "q": "以下while语句中的表达式\"not E\"等价于（ ）。\nwhile 1:\n    while not E:\n        pass", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "E==0", "E!=1", "E!=0", "E==1" ], "explanation": "在Python布尔上下文中，数值0等价于False，非0等价于True。not E为真表示E的布尔值为假，即E的值为0。因此while not E:与while E==0:逻辑等价。" }, { "id": 1357, "q": "以下关于Python字符串的描述不正确的是( )。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "\"\" 或 '' 是合法的字符串,表示空串", "Python的字符串中可以混合还有正整数和负整数进行索引和切片", "Python字符串采用[M:N]格式进行切片，获取字符串从索引M到N的子串", "字符串\"D:\\\\abc.py\"中第一个\\表示转义符" ], "explanation": "Python字符串切片采用左闭右开区间[M:N]，实际获取的是索引M到N-1的字符，不包含索引N处的字符。C选项描述为\"从M到N\"忽略了右边界不包含的特性，因此表述错误。" }, { "id": 1358, "q": "下列Python程序的运行结果是（ ）。\ns=list('ABCDEF')\ns[1:3]=list('666')\nprint(s)", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "['A', '6', '6', '6','D', 'E', 'F']", "['6', '6','6','D', 'E', 'F']", "['A', '6','6', 'E', 'F']", "['A', '6','6', '6', 'E', 'F']" ], "explanation": "列表切片赋值会替换指定区间的元素。原列表索引1到2（左闭右开）对应B和C，被['6','6','6']整体替换。替换后列表长度增加，结果为['A','6','6','6','D','E','F']。" }, { "id": 1359, "q": "下列语句执行后的结果是（）\nD={}.fromkeys(('x','y','z'),-1)\nsum(list(D.values()))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "-1", "-3", "'xyz'", "'-x'" ], "explanation": "fromkeys方法使用给定序列作为键，-1作为默认值创建字典，因此D的值为三个-1。D.values()获取所有值，转为列表后求和，即-1加-1加-1等于-3。" }, { "id": 1360, "q": "下列代码的运行结果是（ ）。\ny=lambda a,b:a+b\nprint(y([1,2],[5,6]))", "t": "single", "ans": "C", "kp": "函数", "o": [ "1, 2, 5, 6", "[6,8]", "[1, 2, 5, 6]", "{1, 2, 5, 6}" ], "explanation": "lambda函数定义了两个参数相加。当传入两个列表时，加号执行列表拼接操作，将[1,2]和[5,6]合并为一个新列表[1, 2, 5, 6]。" }, { "id": 1361, "q": "当创建一个名为Worker的类时第一行应该为（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "def __init__(self):", "class Worker:", "import Worker", "def Worker(self):" ], "explanation": "Python中使用class关键字定义类，基本语法为class 类名:。因此创建Worker类的第一行应为class Worker:。def关键字用于定义函数或方法。" }, { "id": 1362, "q": "以下选项中，不是 Python 中文件操作的相关函数是( )", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "open()", "read()", "load()", "write()" ], "explanation": "open()用于打开文件，read()和write()分别是文件对象的读写方法。load()通常用于json或pickle等模块加载数据，不是Python内置的文件对象基本操作方法。" }, { "id": 1363, "q": "如果想逐行读取一个文本文件，把文件每一行作为列表成员并返回这个列表，以下哪个方法比较适合？", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "readline()", "readlines()", "strip()", "split()" ], "explanation": "readlines()方法一次性读取文件所有行，并返回一个列表，列表的每个元素是文件的一行。readline()只读取一行并返回字符串，strip()和split()是字符串处理方法。" }, { "id": 1364, "q": "程序填空，输入两个整数a和b，先输出较大数，再输出较小数。\na,b=eval(   1   (\"输入a,b: \"))\nif     2    :  \n    a,b=b,a\nprint(\"{0},{1}\".format(a,b))", "t": "fill", "ans": "input | a < b", "kp": "程序填空/调试", "o": [], "explanation": "第1空使用input()函数获取用户输入的字符串，配合eval()解析为两个整数。第2空根据题意需先输出较大数，若a < b则通过a,b=b,a交换两数，确保a始终为较大值。" }, { "id": 1365, "q": "有以下程序代码：定义一个类Openobject，包含构造方法、set_name方法、get_name方法；并根据该类创建一个实例对象o，并分别调用相应方法。请将程序补充完整。\nclass Openobject:\n    def __init__(___1___):\n        self.name = ''\n    def set_name(self, para):\n        self.name = para\n    def get_name(self):\n        print(___2____)\no=___3____()\no.set_name('sir hello')\no.get_name()", "t": "fill", "ans": "self | self.name | Openobject", "kp": "程序填空/调试", "o": [], "explanation": "第1空为构造方法的默认参数self；第2空在实例方法中访问实例属性需使用self.name；第3空通过类名Openobject加括号来实例化对象。" }, { "id": 1366, "q": "以下程序的运行结果是[*queNo*]_______。\nlst=[4,2,3,9,1]\nlst.sort()\nlst.pop()\nlst.pop(0)\nprint(sum(lst)*len(lst))", "t": "fill", "ans": "27", "kp": "列表/元组", "o": [], "explanation": "sort()将列表升序排列为[1,2,3,4,9]。pop()默认移除末尾元素9，pop(0)移除首元素1，剩余[2,3,4]。其元素之和为9，长度为3，相乘结果为27。" }, { "id": 1367, "q": "以下count函数的功能是统计字符串s中小写字母出现的个数，并且将小写字母转成大写字母。若字符串为“powYkarHR39”,则输出结果是“POWYKARHR39”.且小写字符个数为6。请在括号（）中填入正确答案。\ndef count(b):\n    t=0\n    for (__1__) in b:\n        if n>='a' and n<='z':\n            t+=1\n            up=ord(n)____2___\n            print(chr(up),end='')\n        else:\n            print(n,end='')\n    return t\nk=input(\"请输入字符串:\")\nprint('\\n',count(k))", "t": "fill", "ans": "n | -32", "kp": "程序填空/调试", "o": [], "explanation": "第1空遍历字符串b，循环变量命名为n，与后续判断条件中的变量名保持一致。第2空将小写字母转为大写，其ASCII码值相差32，故用ord(n)获取编码后减去32。" }, { "id": 1368, "q": "使用readlines方法把整个文件中的内容进行一次性读取，返回值的类型是一个_____类型。", "t": "fill", "ans": "列表", "kp": "文件操作", "o": [], "explanation": "readlines()方法读取文件中的所有行，并将每一行作为字符串元素存储在一个列表中返回，因此其返回值类型为列表。" }, { "id": 1369, "q": "以下代码的输出结果是[*queNo*]_。\ni=30\nj=40\nk=50\nif(i n: #前面已判断\"相等\"，后面else判断\"小于\"，因此这里判断大于。即x>n\nprint(\"大了，再试试\")\nelse:\nprint(\"小了，再试试\")\nif x != n and m == 6: #如果没猜中，且猜测达到6次后，打印以下语句。\nprint(\"谢谢！请休息后再猜\")", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1371, "q": "考生文件夹下存在一个文件PY102.py，请写代码替换横线，不修改其他代码，实现以下功能：\na和b是两个列表变量，列表a为[3,6,9]已给定，键盘输入列表b，计算a中元素与b中对应元素乘积的累加和。\n例如：键盘输入列表b为[1,2,3]，累加和为1*3+2*6+3*9=42，因此，屏幕输出计算结果为42\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "a = [3,6,9]\nb = eval(input()) #例如：[1,2,3]\ns=0\nfor i in range(3):\ns += a[i]*b[i]\nprint(s)", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1372, "q": "关于Python的浮点数类型，以下选项中描述错误的是（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "浮点数类型与数学中实数的概念一致，表示带有小数的数值", "sys.float_info可以详细列出Python解释器所运行系统的浮点数各项参数", "Python语言的浮点数可以不带小数部分", "浮点数有两种表示方法：十进制表示和科学计数法" ], "explanation": "Python中浮点数必须包含小数点或科学计数法标识。若仅由数字组成且无小数点，则会被识别为整数类型而非浮点数，因此浮点数不能完全不带有小数点或指数部分。" }, { "id": 1373, "q": "函数type(1+0xf*3.14)的返回结果是（ ）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "", "", "", "" ], "explanation": "0xf是十六进制整数15，15*3.14是浮点数，加上1后结果仍为浮点数。因此type()返回浮点类型。选项内容缺失，但根据计算结果应为float类型。" }, { "id": 1374, "q": "表达式4*6//3**2的结果是（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "64", "3", "2", "2.6666" ], "explanation": "Python中运算符优先级：**最高，其次是*、//。先计算3**2得9，再计算4*6得24，最后计算24//9，整除结果为2。" }, { "id": 1375, "q": "利用print()格式化输出，哪个选项用于控制浮点数的小数点后两位输出（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "{:2}", "{.2}", "{.2f}", "{:.2f}" ], "explanation": "在Python的format格式化或f-string中，控制浮点数保留两位小数的格式说明符是.2f，结合大括号应为{:.2f}。冒号后跟格式说明符。" }, { "id": 1376, "q": "Python逻辑运算符中，( )运算符只作用于后面的一个逻辑量。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "and 和or", "and 和not", "or 和not", "not" ], "explanation": "and和or是双目逻辑运算符，需要左右两个操作数；not是单目逻辑运算符，只作用于其后的一个逻辑量，对其进行逻辑取反。" }, { "id": 1377, "q": "下面程序段求x和y中的较大数，不正确的是（ ）。", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "maxNum=x if x>y else y", "if x>y:maxNum=x\nelse:maxNum=y", "maxNum=y\nif x>y:maxNum=x", "if y>=x:maxNum=y\nmaxNum=x" ], "explanation": "A是条件表达式，正确；B是if-else语句，逻辑正确；C先赋y，若x>y再赋x，正确；D中if语句后没有else，无论条件是否成立，maxNum=x都会执行，导致结果始终为x，逻辑错误。" }, { "id": 1378, "q": "设有程序段：\ns='￥'\nfor i in (\"A\",\"O\",\"I\"):\n        pass\nprint(s, end= '')\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "打印1个A", "打印1个￥", "打印1个O", "打印1个I" ], "explanation": "循环遍历元组(\"A\",\"O\",\"I\")，但循环体只有pass，不改变s的值。循环结束后，打印变量s，其值仍为初始的'￥'，因此只打印1个￥。" }, { "id": 1379, "q": "已知x=[3,9,5],那么执行x=x.sort(reverse=True)之后，x的值为（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[3,5,9]", "[9,5,3]", "None", "[3,9.5]" ], "explanation": "列表的sort()方法是就地排序，返回值为None。执行x=x.sort(...)会将x重新赋值为None，因此x的值变为None。若要获取排序后的列表，应使用sorted()或不调用赋值。" }, { "id": 1380, "q": "dict([['a',1],['b',2]])的返回值是( )。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{'a':1,'b':2}", "[{'a':1,'b':2}]", "{1,2}", "['a','b']" ], "explanation": "dict()函数可以接收一个包含键值对的可迭代对象来创建字典。传入包含两个子列表的列表，每个子列表包含两个元素，分别作为键和值，因此生成字典{'a':1, 'b':2}。" }, { "id": 1381, "q": "以下程序代码的运行结果正确的是（ ）。\ns=5\ndef sum(n):\n    s=0\n    for i in range(n):\n        s=s+i\n    return s\nsum(6)\nprint('{}'.format(s))", "t": "single", "ans": "A", "kp": "函数", "o": [ "5", "20", "15", "不输出任何结果" ], "explanation": "函数sum内部定义了局部变量s，其修改不会影响全局变量s。调用sum(6)后，全局变量s的值仍为初始的5。最后print输出全局变量s，结果为5。" }, { "id": 1382, "q": "已知f=lambda x,y:x+y，则f([3],[0,1,2])的值是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "[0, 1, 2, 3]", "6", "[3, 0, 1, 2]", "{1, 2, 3, 4}" ], "explanation": "lambda函数实现x+y。当传入两个列表[3]和[0,1,2]时，+运算符用于列表拼接，将第二个列表的元素追加到第一个列表之后，结果为[3, 0, 1, 2]。" }, { "id": 1383, "q": "Python内置函数len()不仅可以计算字符串的长度，还可以计算列表、元组等对象中的数据个数，这种现象是（）的体现。", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "封装", "继承", "多态", "以上都不是" ], "explanation": "多态是指同一操作作用于不同的对象，可以有不同的解释和产生不同的执行结果。len()函数能根据传入对象类型自动调用对应的__len__方法计算长度，体现了多态性。" }, { "id": 1384, "q": "下列方法中，用于向文件中写内容的是（ ）", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "open", "write", "close", "read" ], "explanation": "在Python文件操作中，open()用于打开文件，read()用于读取文件内容，close()用于关闭文件，而write()方法用于向文件中写入字符串内容。" }, { "id": 1385, "q": "下列程序的输出结果是[*queNo*]___。\ns=0\nfor c in range(2):\n    for j in range(3):\n        s+=c+j\nprint(s)", "t": "fill", "ans": "9", "kp": "循环结构", "o": [], "explanation": "外层循环c依次取0和1，内层循环j依次取0、1、2。当c=0时，s累加0+1+2=3；当c=1时，s累加(1+0)+(1+1)+(1+2)=6。最终s的值为3+6=9。" }, { "id": 1386, "q": "下列Python程序的运行结果是[*queNo*]_。\ni=300\nj=400\nk=500\nif(i0:\nprint(i)\ni-=1", "for i in range(10):\nprint(i)", "for i in range(10,0,-1):\nprint(i)" ], "explanation": "选项A中i从0递增到10，包含10，循环体执行11次。选项B中i从10递减到1，执行10次。选项C的range(10)生成0到9，执行10次。选项D的range(10,0,-1)生成10到1，执行10次。因此A的执行次数与其他三项不同。" }, { "id": 1395, "q": "下列说法正确的是（ ）。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "无法删除集合中指定位置的元素，只能删除特定值的元素。", "Python字典和集合支持双向索引", "字典对象可以作为集合的元素", "集合中元素可以重复" ], "explanation": "集合是无序的，不支持索引，因此无法通过位置删除元素，只能用remove等方法删除特定值。字典和集合均不支持索引；字典是可变对象，不可哈希，不能作为集合元素；集合中的元素具有唯一性，不能重复。因此只有A正确。" }, { "id": 1396, "q": "关于析构方法，说法错误的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "析构方法名为__del__", "析构方法在释放对象时调用,不需要显示调用", "析构方法在创建对象时调用,不需要显示调用", "使用del删除对象时，会调用对象本身的析构函数" ], "explanation": "析构方法__del__是在对象被销毁或垃圾回收时自动调用的，而不是在创建对象时调用。创建对象时自动调用的是构造方法__init__。使用del语句删除对象引用且引用计数为0时，会触发析构方法。因此C选项说法错误。" }, { "id": 1397, "q": "下列程序的输出结果是[*queNo*]___。\nls=[]\nfor m in '想念':\n    for n in '家人':\n        ls.append(m+n)\nprint(ls[0])", "t": "fill", "ans": "想家", "kp": "循环结构", "o": [], "explanation": "外层循环遍历字符串'想念'，内层循环遍历'家人'。第一次外层循环m为'想'，第一次内层循环n为'家'，将'想家'追加到列表ls中，此时ls[0]即为'想家'。后续循环继续追加元素，但不影响索引0的值，最终输出'想家'。" }, { "id": 1398, "q": "下列关于Python中复数类型的描述错误的是（）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "复数由实数部分和虚数部分构成", "复数可以看作是二元有序实数对（a，b）", "虚数部分必须后缀j，且为小写", "复数中的虚数部分不能单独存在，必须有实数部分" ], "explanation": "在Python中，复数的虚部后缀可以使用小写j或大写J，并非必须为小写，因此C选项说法错误。复数由实部和虚部构成，可视为有序实数对。注：Python允许直接书写如3j的纯虚数（实部默认为0），D选项表述亦有不严谨之处，但C为最明显的语法错误。" }, { "id": 1399, "q": "在Python语言中，可以作为源文件后缀名的是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "png", "pdf", "py", "ppt" ], "explanation": "Python源代码文件的标准扩展名是.py。png是图片格式，pdf是文档格式，ppt是演示文稿格式，均不能作为Python源文件后缀。" }, { "id": 1400, "q": "print(30-10,30+10)的结果是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "20,40", "20 40", "30-10,30+10", "出错" ], "explanation": "print函数在输出多个参数时，默认使用空格作为分隔符。表达式30-10计算结果为20，30+10计算结果为40，因此最终输出为20和40，中间以空格隔开。" }, { "id": 1401, "q": "令tup=tuple([i for i in range(1,10,3)])，则print(tup[:-1])的结果为（ ）", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "(1,4,7)", "(1, 4)", "1, 4", "(1, 4, 7, 10)" ], "explanation": "range(1,10,3)生成序列1, 4, 7，转换为元组后为(1, 4, 7)。切片[:-1]表示取从开头到倒数第一个元素（不包含）的所有元素，因此结果为(1, 4)。" }, { "id": 1402, "q": "下列Python程序的运行结果是（ ）。\nlst=[1,2,3]\nlst.append([4,5,6])\nprint(len(lst))", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "3", "4", "5", "6" ], "explanation": "append()方法会将传入的参数作为一个整体添加到列表末尾。将列表[4,5,6]追加到原列表后，新列表变为[1, 2, 3, [4, 5, 6]]，包含4个元素，故长度为4。" }, { "id": 1403, "q": "以下程序代码的运行结果正确的是（ ）。\nnum=10\ncount=0\ndef cc():\n    global count,num\n    num=0\n    count=1\n    num = num+count\n    count=count+2\ncc()\nprint('{},{}'.format(count,num))", "t": "single", "ans": "A", "kp": "函数", "o": [ "3,1", "3,10", "0,10", "1,3" ], "explanation": "函数内使用global声明全局变量。执行时num被赋值为0，count为1。随后num=num+count即0+1=1，count=count+2即1+2=3。格式化输出按count和num的顺序，结果为3,1。" }, { "id": 1404, "q": "以下程序的运行结果是（ ）。\ns=0\nfor i in range(1,4):\n        s=s+i*i\nprint(s)", "t": "fill", "ans": "14", "kp": "循环结构", "o": [], "explanation": "range(1,4)生成序列1, 2, 3。循环过程中，s依次累加i的平方：第一次s=0+1*1=1；第二次s=1+2*2=5；第三次s=5+3*3=14。最终输出14。" }, { "id": 1405, "q": "以下构成Python循环结构的方法中，正确的是（　　）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "for", "loop", "if", "do…while" ], "explanation": "Python中的循环结构主要由for和while语句构成。loop不是Python关键字，if用于分支结构，而do...while语法在Python中不存在。" }, { "id": 1406, "q": "下列说法是错误的（ ）。", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "Python字典中的\"键\"可以是元组", "Python字典中的\"键\"可以是列表", "Python字典可以直接通过\"键\"进行索引", "字典的值可以是任意数据类型，包括字符串、整数，甚至字典" ], "explanation": "Python字典的键必须是不可变数据类型（如字符串、数字、元组），以保证哈希值的唯一性。列表是可变类型，不能作为字典的键。其他选项关于字典的描述均正确。" }, { "id": 1407, "q": "以下程序的输出结果是（ ）\nprint(\"{0:.2f},{1}\".format(3.145,500))", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "3.14,500", "3.15,500", "3.15 500", "3.14 500" ], "explanation": "格式化中{0:.2f}要求保留两位小数。按数学四舍五入3.145应为3.15，故选B。但需注意，Python实际运行中因浮点数精度问题，3.145会被存储为略小于3.145的值，实际输出为3.14。本题按出题人预期的数学四舍五入逻辑解答。" }, { "id": 1408, "q": "设 ch='A'，表达式ch= chr(ord(ch)+32) if (ch>='A'and ch<='Z') else ch的值是（　　）。", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "'A'", "'a'", "'Z'", "'z'" ], "explanation": "变量ch为'A'，满足条件ch>='A' and ch<='Z'。ord('A')获取ASCII码65，加32后为97，chr(97)将其转换回字符，即小写字母'a'。" }, { "id": 1409, "q": "关于下列for循环，叙述正确的是（ ）。\nfor t in range(1,11):\n     x=int(input())\n     if x<0:continue\n     print(x)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "当x<0时整个循环结束", "x>=0时什么也不输出", "print()函数永远也不执行", "最多允许输出10个非负整数" ], "explanation": "循环共执行10次。每次读取输入x，若x<0则执行continue跳过本次循环的print语句；若x>=0则正常打印。因此该程序最多允许输出10个非负整数。" }, { "id": 1410, "q": "以下叙述正确的是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "continue语句的作用是结束整个循环嵌套的执行", "循环嵌套中, 只能在循环体内使用break语句", "循环嵌套中, 在循环体内使用break语句或continue语句的作用相同", "从多层循环嵌套中退出时，只能使用goto语句" ], "explanation": "break和continue语句只能在循环体内使用。break用于终止当前所在的最内层循环，continue用于跳过当前循环的剩余代码。Python不支持goto语句。" }, { "id": 1411, "q": "'z'not in \"abc\"的结果是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "True", "False", "Yes", "No" ], "explanation": "'z'不在字符串'abc'中，因此'z' in 'abc'为False，加上not逻辑取反后结果为True。Python中布尔值首字母需大写。" }, { "id": 1412, "q": "下列关于字符串的描述错误的是（ ）。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "字符串s的首字符是s[0]", "在字符串中，同一个字母的大小是等价的。", "字符串中的字符都是以某种二进制编码的方式进行存储和处理的", "字符串也能进行关系比较操作" ], "explanation": "Python严格区分大小写，同一个字母的大写和小写在内存中的ASCII码不同，因此不等价。选项A、C、D均符合Python字符串的基本特性。" }, { "id": 1413, "q": "下列Python程序的运行结果是（ ）。\nL1=[1,2,3,4]\nL1[1]=5\nprint(L1)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[5,2,3,4]", "[1,5,3,4]", "[1,2,3,4,5]", "[5,3,4]" ], "explanation": "列表索引从0开始，L1[1]指向列表的第二个元素。将L1[1]赋值为5后，原列表第二个元素2被替换为5，其余元素不变，最终输出[1, 5, 3, 4]。" }, { "id": 1414, "q": "请给出下面代码段的正确答案（）\nA = {1, 3, 5, 7, 9}\nB = {4, 5, 6, 7, 8}\nA.difference_update(B)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{1, 3, 9}", "{5,7}", "{4,5,6,7,8}", "{1,3,4,5,7,8,9}" ], "explanation": "difference_update()方法用于从集合中移除在另一个集合中出现的元素。集合A移除与集合B共有的元素5和7后，仅保留{1, 3, 9}。" }, { "id": 1415, "q": "给出如下代码：\nDictColor = {\"red\":\"红色\",\"blue\":\"蓝色\",\"pink\":\"粉红色\",\"brown\":\"棕色\",\"purple\":\"紫色\",\"white\":\"白色\"}\n以下选项中能输出\"蓝色\"的是( )。", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "print(DictColor.keys())", "print(DictColor[\"蓝色\"])", "print(DictColor.values())", "print(DictColor[\"blue\"])" ], "explanation": "字典通过键来访问对应的值。题目要求输出值'蓝色'，其对应的键为'blue'，因此使用DictColor['blue']即可获取并打印该值。" }, { "id": 1416, "q": "下列代码的运行结果是（ ）。\nf=[lambda a,b:a*b,lambda a:a**2]\nprint(f[1](f[0](3,1)))", "t": "single", "ans": "C", "kp": "函数", "o": [ "36", "3", "9", "1" ], "explanation": "列表f包含两个匿名函数。首先计算内层f[0](3,1)，即3*1=3；然后将结果3传入外层f[1](3)，计算3**2，最终结果为9。" }, { "id": 1417, "q": "13 以下程序运行后输出的结果是（ ）\ndef fun(x):\n    s=1\n    for i in range(2,x):\n         s=s*i\n     return s\nprint(fun(5))", "t": "single", "ans": "A", "kp": "函数", "o": [ "24", "120", "4!", "5!" ], "explanation": "函数fun(5)中，range(2, 5)生成序列2、3、4。循环依次将s乘以2、3、4，即1*2*3*4，最终计算结果为24。此题考查阶乘的部分计算逻辑。" }, { "id": 1418, "q": "有以下代码：\nclass CC():\n    aa=1\n    def bb(self):\n            print('bb')\n其中，以下哪个选项是实例方法（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "CC", "aa", "bb", "self\n选择题" ], "explanation": "在类定义中，bb是带有self参数的函数，属于实例方法；aa是类属性；CC是类名；self是实例方法的默认第一个参数，代表实例本身。" }, { "id": 1419, "q": "以下（）的方法可以对类外部代码隐藏类的属性。", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "使用self参数来创建属性", "用两个下划线开始属性的名称", "用private关键字修饰属性", "用@符号开始属性的名称" ], "explanation": "Python没有private关键字。通过在属性名前添加两个下划线，Python会对其进行名称改写（Name Mangling），从而在类外部隐藏该属性。" }, { "id": 1420, "q": "判断一个数是否为素数。请将以下程序补充完整。\ndef is_prime(number):\n    if number\n        return False\n    for i in range(2,       ):\n        if number % i == 0:\n            return        \n    return True", "t": "fill", "ans": "number | False", "kp": "程序填空/调试", "o": [], "explanation": "第1空填number，作为range的结束值，确保检查到number-1；第2空填False，当发现能整除的因子时，说明不是素数，直接返回False。" }, { "id": 1421, "q": "下列Python程序的运行结果是[*queNo*]_。\nx=150\nif x%500==0:\n    print(\"yes\")\nelse:\n    print(\"no\")", "t": "fill", "ans": "no", "kp": "分支结构", "o": [], "explanation": "变量x为150，150 % 500的结果是150，不等于0，因此条件x%500==0为假。程序执行else分支，打印输出字符串'no'。" }, { "id": 1422, "q": "Python文件的后缀名是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "python", "py", "ppt", "pygt" ], "explanation": "Python源代码文件的标准扩展名是.py。.python不是标准后缀，.ppt是演示文稿后缀，.pygt为干扰项。" }, { "id": 1423, "q": "语句print(10,20)的执行结果是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "10 20", "10,20", "(10 20)", "(10,20)" ], "explanation": "print函数默认使用空格作为多个参数之间的分隔符（sep参数默认为' '）。因此，传入10和20时，输出结果中间会有一个空格，即'10 20'。选项B是逗号分隔，选项C和D带有括号，均不符合print的默认输出格式。" }, { "id": 1424, "q": "设计一个可以输入日期得到当天是当年第几天的程序，请阅读程序，完成填空（闰年条件：能被4整除但不能被100整除或能被400整除，闰年的2月为29天）。\n如输入“2020-05-20”，则显示：“2020-05-20是当年的第141天”。\n注意：部分源程序已给出。输入并调试程序，使程序得出正确结果不得增行或删行，也不得更改程序的结构！仅在横线上填入。\nday=input(\"请输入年月日（格式举例：2000-06-12）：\")\nyear=int(day[:4])\nmonth=int(day[5:7])\nsun=___1____\nprint(year,month,sun)\nmax_day=[31,28,31,30,31,30,31,31,30,31,30,31]\nto_day=0\nif (year%4==0 and year%100!=0) or (year%400==0):\n    for i in range(month-1):\n        to_day +=max_day[i]\n    to_day=___2___\nelse:\n    for i in range(month-1):\n        to_day +=max_day[i]\n    to_day += sun\nprint(day+\"是当年的第\"+str(to_day)+\"天\")", "t": "fill", "ans": "int(day[8:10]) | to_day+sun+1", "kp": "程序填空/调试", "o": [], "explanation": "第1空截取日期字符串的日部分并转为整型，填int(day[8:10])。第2空在闰年分支计算总天数，将前几个月天数、当月天数及闰年补偿值相加。但答案固定加1未判断月份是否大于2，逻辑存在瑕疵，疑似需人工复核。" }, { "id": 1425, "q": "下面表示空字符的转义字符是（）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "'\\r'", "'\\n'", "'\\f'", "'\\0'" ], "explanation": "在Python及C等语言中，'\\0'表示空字符（Null character），其ASCII码为0，常用于字符串结尾标志。'\\r'是回车，'\\n'是换行，'\\f'是换页。因此表示空字符的转义字符是'\\0'。" }, { "id": 1426, "q": "以下说法正确的是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "已知x=3，那么执行语句x+=6之后，x的内存地址不变。", "表达式10%4的值是2", "表达式5//3的值是2", "表达式5/3的值和5/3.0的值是不同的。" ], "explanation": "A错误，整数是不可变类型，x+=6会创建新对象，内存地址改变。B正确，10除以4的余数是2。C错误，5//3是向下取整除法，结果为1。D错误，Python 3中5/3和5/3.0都执行真除法，结果均为浮点数，值相同。" }, { "id": 1427, "q": "下列程序的运行结果是（ ）\nx=y=10\nx=x-1\ny=x\nz=x+1\nprint(x,y,z)", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "9 10 11", "9 9 10", "10 11 12", "10 10 11" ], "explanation": "初始x和y均为10。执行x=x-1后，x变为9。接着y=x，将x的当前值9赋给y，此时y为9。最后z=x+1，即9+1，z为10。因此最终打印的x、y、z分别为9、9、10。" }, { "id": 1428, "q": "下面代码的输出结果是（ ）。\nfor i in range(0,4):\n    for j in range(0,7):\n        print(\"*\",end=\"\")\n    print()", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "*******\n*******\n*******\n*******", "*****\n*****\n*****\n*****", "******\n******\n******\n******", "*******\n*******\n*******" ], "explanation": "外层循环range(0,4)控制行数，共执行4次。内层循环range(0,7)控制每行打印的星号数量，共执行7次，且end=''使星号不换行。内层循环结束后执行print()进行换行。因此输出4行，每行7个星号。" }, { "id": 1429, "q": "以下程序的运行结果是（）\nclass CC():\n    def bb(self):\n        print('bb')\nCC.bb()", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "self", "CC", "bb", "运行错误" ], "explanation": "bb是类CC的实例方法，其第一个参数为self，代表实例对象。直接通过类名CC.bb()调用实例方法时，没有传入实例对象作为self参数，会导致TypeError缺少位置参数的运行错误。应通过实例调用如CC().bb()。" }, { "id": 1430, "q": "下列程序的输出结果是()\nf=open('D:\\\\out.txt','w+')\nf.write('1:www.runoob.com')\nf.seek(1,0)\nc=f.read(4)\nprint(c)\nf.close()", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "ww.ru.", ":www", ".com", "1:www" ], "explanation": "文件以'w+'模式打开并写入'1:www.runoob.com'。f.seek(1,0)将文件指针移动到距离文件开头偏移量为1的位置，即字符':'处。接着f.read(4)从当前指针位置读取4个字符，即':www'。因此输出结果为':www'。" }, { "id": 1431, "q": "程序填空题\ndef get_keys_with_value(dictionary, value):\n\"\"\"\n查找字典中所有对应给定值的键，并返回一个列表。\n\"\"\"\n    keys = [key for key, val in dictionary.items() if __1[*queNo*] == value]\n    return __2____\nmy_dict = {'a': 1, 'b': 2, 'c': 2, 'd': 3}\nresult = get_keys_with_value(my_dict, 2)\nprint(result)", "t": "fill", "ans": "val | keys", "kp": "程序填空/调试", "o": [], "explanation": "第1空在字典推导式中遍历键值对，需判断值是否等于给定value，故填val。第2空函数需返回包含所有匹配键的列表，推导式已将结果存入keys变量，故直接返回keys。" }, { "id": 1432, "q": "以下说法错误的是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1.001*10的结果是10.01", "浮点型数据表示一个实数", "浮点型数据有两种表现形式，分别是小数和指数形式", "浮点型的指数形式就是用科学计数法表示浮点数" ], "explanation": "在Python中，由于浮点数在计算机内以二进制存储，1.001无法被精确表示，导致1.001*10的实际运算结果存在精度误差（如10.010000000000002），并非精确的10.01，故A错误。B、C、D关于浮点数基本概念的描述均正确。" }, { "id": 1433, "q": "下列程序的运行结果是（ ）\na=10\na,a=5,2*a\nprint(a)", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "5", "10", "15", "20" ], "explanation": "Python中多重赋值语句会先计算等号右侧所有表达式的值，然后再赋值给左侧变量。右侧2*a中a的初始值为10，故2*a为20。计算完成后，将5和20分别赋给左侧的两个a，最终a的值为20。" }, { "id": 1434, "q": "执行语句x=int(input( ))，若输入123.5，那么 x 的值是（ ）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "123", "\"123.5\"", "123.5", "程序出错" ], "explanation": "input()函数接收的输入为字符串'123.5'。int()函数只能将纯整数字符串或浮点数类型转换为整数，不能直接将包含小数点的字符串转换为整数，否则会抛出ValueError异常导致程序出错。需先用float()转换再用int()。" }, { "id": 1435, "q": "设有程序段：\nk=8\nfor i in (1,2,3,4,5):\n    if(k==5):\n        break\n    k=k-1\nprint(k)\n则程序的运行结果是（ ）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "8", "6", "5", "7" ], "explanation": "循环依次遍历元组。前3次循环中k不等于5，k分别减1变为7、6、5。第4次循环时k等于5，触发break语句跳出循环，最终打印k的值为5。" }, { "id": 1436, "q": "已知列表s=['white','black','red','purple'], 那么执行语句del s[2]之后, s的值为（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "['white', 'black', 'purple']", "['white', 'red', 'purple']", "['red','purple']", "['white','black','red','purple']" ], "explanation": "列表索引从0开始，s[2]对应元素'red'。使用del语句删除该索引处的元素后，列表剩余元素依次为'white'、'black'和'purple'。" }, { "id": 1437, "q": "请给出下面代码段的正确答案（）\nA={10,18,20,49,70,78}\nB={14,51,70,85,99,100}\nC={14,48,70}\nA.update(A^B&C)\nprint(A)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{10,14,18,20,49,70,78}", "[10, 14, 18, 20, 49, 78]", "{10,18,20,49,70,78}", "{70}" ], "explanation": "先计算A与B的对称差集A^B，即去除两者共有的70。再与C求交集，C中只有14存在于对称差集中，得到集合{14}。最后使用update方法将14加入集合A中。" }, { "id": 1438, "q": "下列选项中，不属于字典操作的方法的是（ ）。", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "d.keys()", "d.append()", "d.values()", "d.items()" ], "explanation": "字典支持keys()、values()和items()方法分别获取键、值及键值对。append()是列表用于追加元素的方法，字典没有此方法。" }, { "id": 1439, "q": "找出1~300中既能被3整除又能被5整除的整数存放在列表list1中，结果按每行5个输出。请完成以下程序。\nlist1=[]\nfor i in range(1,500):\n    if i%3==0 and i%5==0:\n        list1.___1___ #将i追加到列表list1中\nfor i in range(len(list1)):\n    print(list1[i],end=\" \")\n    if (i+1)%5==0:\n        print(\"\\n\")", "t": "fill", "ans": "append(i)", "kp": "程序填空/调试", "o": [], "explanation": "题目要求将满足条件的整数i追加到列表list1末尾。列表添加单个元素需调用append方法，故该空应填入append(i)。" }, { "id": 1440, "q": "定义一个电话簿dict包含联系人和电话。通过输入人名，查询他的号码。如果该人不存在，返回\"not found\"。请完成程序。\ndict={'zhang':'133****','wu':'189****','li':'136****','wang':'198****','fu':'188****','hu':'150****', 'he':'192****'}\nwhile True:\n    name=input('请输入名字：')\n    if __1____ in dict.keys():\n        print(dict[name])\n    __2____:\n   \n        print('not found')", "t": "fill", "ans": "name | else", "kp": "程序填空/调试", "o": [], "explanation": "第1空判断输入的名字是否在字典的键中，应填入变量name；第2空与if搭配构成条件分支，当名字不存在时执行，应填入else。" }, { "id": 1441, "q": "以下关于Python语言复数类型的描述中，错误的是（）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "复数可以进行四则运算", "实数部分不可以为0", "Python语言中可以使用z.real和z.imag分别获取复数z的实数部分和虚数部分", "复数类型与数学中复数的概念一致" ], "explanation": "Python中复数的实部和虚部都可以为0，例如纯虚数0+3j的实部即为0。复数支持四则运算，且可通过.real和.imag属性获取实部和虚部。" }, { "id": 1442, "q": "在python中，下列属于字符串常量的是（）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "cnt", "3.14", "2018", "\"Visual Basic\"" ], "explanation": "字符串常量必须由单引号或双引号括起来。选项A是标识符，B是浮点数常量，C是整数常量，只有D用双引号括起，属于字符串常量。" }, { "id": 1443, "q": "在Python中，要使用（）转换为整数。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "float", "for", "print", "int" ], "explanation": "Python中使用int()函数将其他数据类型（如浮点数、字符串）转换为整数类型。float转为浮点数，print用于输出，for是循环关键字。" }, { "id": 1444, "q": "在python语言中以下哪一项是除法运算的运算符。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "*", "%", "\\", "/" ], "explanation": "在Python中，/ 是真除法运算符，% 是取模运算符，* 是乘法运算符，\\ 不是合法的算术运算符（// 为整除运算符）。" }, { "id": 1445, "q": "下面哪个不是Python合法的标识符（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "int_3", "50XL", "self", "_abc" ], "explanation": "Python标识符必须以字母或下划线开头，不能以数字开头。50XL以数字5开头，因此是不合法的标识符。" }, { "id": 1446, "q": "语句a,a =10,20执行后，a的值是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "10", "20", "出错", "不确定" ], "explanation": "Python支持多变量同时赋值，等号右侧的值会依次解包赋值给左侧的变量。由于左侧两个变量名均为a，a先被赋值为10，随后立即被覆盖赋值为20，最终结果为20。" }, { "id": 1447, "q": "关于基本输入输出函数的描述，错误的选项是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "print()函数的参数可以是一个函数，执行结果是显示函数返回的值", "eval()函数的参数是\"3*4\"的时候，返回的值是整数\"12\"", "当用户输入一个整数\"6\"的时候，input()函数返回的也是整数\"6\"", "当print()函数输出多个变量的时候，可以用逗号分隔多个变量名" ], "explanation": "input()函数无论用户输入什么内容，返回的类型始终是字符串。若要获取整数，需使用int()进行类型转换。因此C选项描述错误。A、B、D选项描述均符合Python语法特性。" }, { "id": 1448, "q": "关于 Python 语言的注释,以下选项中描述错误的是( )。", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "Python 中使用\"#\"表示多行注释", "单行注释可以作为单独的一行放在被注释代码行之前", "单行注释也可以放在语句或表达式之后", "Python中使用3个单引号或3个双引号表示多行注释" ], "explanation": "Python中使用'#'表示单行注释，而不是多行注释。多行注释通常使用三个单引号或三个双引号（即多行字符串）来实现。因此A选项描述错误，B、C、D选项均正确。" }, { "id": 1449, "q": "以下程序的输出结果是（ ）\na,b,c=1,2,3\nprint(\"{1}\".format(a,b,c))", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "1", "2", "3", "123" ], "explanation": "format()方法中，大括号内的数字表示参数的索引，索引从0开始。'{1}'表示取format()传入的第二个参数。传入的参数依次为a(1)、b(2)、c(3)，因此第二个参数是b，其值为2。" }, { "id": 1450, "q": "执行语句x=eval(input( ))，若输入4/2，那么 x 的类型是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "整型", "字符串", "浮点型", "以上都错误" ], "explanation": "input()接收输入'4/2'作为字符串，eval()函数会将其作为Python表达式进行求值。在Python 3中，除法运算符'/'执行真除法，4/2的结果为2.0，属于浮点型。若要得到整型需使用'//'。" }, { "id": 1451, "q": "下列语句执行后的输出是（）。\nx=5\nif x<2:\n   print(5)\nelif x>3:\n   print(6)\nelse:\n   print(7)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "56", "7", "5", "6" ], "explanation": "x=5时先判断x<2，条件不成立；再判断elif x>3，5>3成立，因此执行该分支输出6，对应选项D。" }, { "id": 1452, "q": "表达式3%5>1的值为（ ）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "F", "T", "False", "True" ], "explanation": "首先计算取模运算3%5，结果为3。接着计算关系运算3>1，条件成立，返回布尔值True。Python中布尔值首字母需大写，因此正确结果为True，对应选项D。" }, { "id": 1453, "q": "以下代码的输出结果为（）。\nx=True\ny=True\nz=True\nif not x:\n   if y:\n      print(1)\n   else:\n      print(2)\nelif not y and x:\n   print(3)\nelse:\n   print(4)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "1", "2", "3", "4" ], "explanation": "x、y、z均为True。首先判断if not x，即not True为False，不执行内部代码。接着判断elif not y and x，即False and True为False，也不执行。最后进入else分支，执行print(4)，输出4。" }, { "id": 1454, "q": "若a=10,b=20,那么a and b结果为( )", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "10", "20", "30", "0" ], "explanation": "Python中的逻辑与运算符and遵循短路求值规则。若第一个操作数a为真（非零），则返回第二个操作数b的值；若a为假，则返回a。此处a=10为真，因此表达式返回b的值，即20。" }, { "id": 1455, "q": "以下代码的输出结果是（）。\na,b,c=5,7,30\nif (a>b):\n    a=b\nb=c\nc=a\nprint(a,b,c)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "7 5 7", "5 30 5", "7 30 7", "5 30 7" ], "explanation": "初始a=5, b=7, c=30。判断a>b即5>7为False，不执行a=b。注意b=c和c=a没有缩进，不在if语句块内，会顺序执行。执行b=c后b变为30；执行c=a后c变为5。最终a=5, b=30, c=5。" }, { "id": 1456, "q": "下列程序的运行结果为（ ）。\nsum=0\nfor s in range(6):\n   if s%2==0 :\n      sum=sum+s\nelse:\n  sum=sum/2\nprint(sum)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "6.0", "6", "3.0", "3" ], "explanation": "for循环遍历0到5。当s为偶数(0,2,4)时，sum累加s，循环结束后sum=0+2+4=6。for...else结构中，若循环正常结束未被break中断，则执行else块。sum=sum/2即6/2=3.0。Python 3中除法结果为浮点型。" }, { "id": 1457, "q": "以下while语句中的表达式\"not E\"等价于（ ）。\nwhile not E:\n     pass", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "E==0", "E!=1", "E!=0", "E==1" ], "explanation": "在Python中，not E为True意味着E的布尔值为False。在数值上下文中，0、0.0等被视为False。选项A中E==0表示E为数值0，其布尔值为False，not E即为True，与题意最契合。其他选项不能准确等价。" }, { "id": 1458, "q": "以下程序的运行结果是（ ）。\nm=1\nfor i in range(1,3):\n    for j in range(3,0,-1):\n        if i*j>3:\n            break\n        m*=i*j\nprint(\"m=\",m)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "m=2", "m=5", "m=6", "m=4" ], "explanation": "外层i遍历1和2。当i=1时，内层j遍历3,2,1，i*j均不大于3，m依次乘3,2,1，m变为6。当i=2时，j从3开始，i*j=6>3，触发break跳出内层循环。最终m保持为6，输出m= 6。" }, { "id": 1459, "q": "下列程序的输出结果是（）。\nfor i in \"PYTHON\":\n    for j in range(2):\n        print(i,end='')\n        if i==\"H\":\n            break", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "PPYYTTHHOONN", "PPYYTTONN", "PPYYTTHOONN", "PPYYTTH" ], "explanation": "外层遍历字符串，内层循环本应打印两次当前字符。但当字符为H时，执行一次打印后触发break跳出内层循环，故H仅输出一次。其余字符均输出两次，拼接结果为PPYYTTHOONN。" }, { "id": 1460, "q": "如果需要删除字符串左侧和右侧的某些字符，需要使用的方法是（）。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "split", "strip", "join", "len" ], "explanation": "strip()方法用于移除字符串头尾指定的字符（默认为空白字符）。split用于分割，join用于拼接，len用于获取长度，因此选B。" }, { "id": 1461, "q": "给出如下代码:TempStr =\"Hello World\",可以输出\"World\"子串的是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "print(TempStr[-5:])", "print(TempStr[-4:-1])", "print(TempStr[-5:0])", "print(TempStr[-5: -1])" ], "explanation": "字符串索引从0开始，负数索引从末尾倒数。World起始于倒数第5个字符（索引-5），切片[-5:]表示从该位置截取至末尾，故输出World。其他选项切片范围错误。" }, { "id": 1462, "q": "令list=[1,2,3,4,5]，则print(list[:-2:])的结果为（ ）", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[1,2,3]", "[1,2,3,4]", "[2,3, 5]", "[5,3,1]" ], "explanation": "切片语法[:-2]表示从开头截取到倒数第二个元素之前（不包含该元素）。列表倒数第二个元素是4，故截取前三个元素[1, 2, 3]。" }, { "id": 1463, "q": "令tup=(1,2,3,4,5)，则print(tup[1:4])的结果为（ ）", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "(1,2,3)", "(1,2,3,4)", "2,3,4", "(2,3,4)" ], "explanation": "切片[1:4]包含起始索引1，不包含结束索引4，对应元素为2、3、4。元组切片后仍返回元组类型，故结果为(2, 3, 4)。" }, { "id": 1464, "q": "下列Python程序的运行结果是（ ）。\nL1=[3,5,6]\nL2=L1\nL1[1]=4\nprint(L2)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[3, 5, 6]", "[3, 4, 6]", "[4, 5, 6]", "[4, 5, 4]" ], "explanation": "Python中列表赋值L2=L1是引用传递，两者指向同一内存地址。修改L1的元素会同步影响L2，因此L2输出修改后的[3, 4, 6]。" }, { "id": 1465, "q": "给定两个集合s1和s2，选择下列代码片段的输出结果：\ns1 = {1, 2, 3, 4}\ns2 = {3, 4, 5, 6}\ns3 = s1.intersection(s2)\ns4 = s1.difference(s3)\ns4.symmetric_difference_update(s2)\nprint(sorted(s4))", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "[1, 2, 5, 6]", "[1, 2]", "[1, 2, 3, 4, 5, 6]", "[1, 2, 3, 4]" ], "explanation": "intersection求交集得{3,4}；difference求差集得{1,2}；symmetric_difference_update计算对称差集并更新，即{1,2}与{3,4,5,6}合并得{1,2,3,4,5,6}，排序后输出列表。" }, { "id": 1466, "q": "对于字典D={'a':10,'b':20,'c':30,'d':40}，sum(list(D．values()))的值是（ ）。", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "10", "100", "40", "200" ], "explanation": "D.values()获取字典所有值，转为列表后为[10, 20, 30, 40]，sum()函数对其求和得100。" }, { "id": 1467, "q": "下列选项中不属于函数优点的是（ ）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "减少代码重复", "使程序模块化", "使程序便于阅读", "便于发挥程序员的创造力" ], "explanation": "函数的主要优点包括提高代码复用率、实现模块化设计、增强可读性与可维护性。便于发挥创造力并非函数设计的直接技术优势，属于干扰项。" }, { "id": 1468, "q": "下列代码运行后的结果是（ ）。\ndef fact(s):\n    if len(s) == 1:\n        return s[0]\n    else:\n        return s[0] + fact(s[1:])\nprint(fact(('a','b','c','d')))", "t": "single", "ans": "C", "kp": "函数", "o": [ "dcba", "a b c d", "abcd", "d c b a" ], "explanation": "该递归函数每次取元组首元素，并与剩余部分的递归结果相加。字符串相加为拼接操作，依次将a、b、c、d连接，最终返回字符串abcd。" }, { "id": 1469, "q": ".以下程序代码的运行结果正确的是（ ）。\nd={'chen':89,'zhang':78,'liu':78}\ndef sum():\n      d={'liu':96,'xiao':35,'ye':100}\n      d.pop('liu')\nsum( )\nprint('{}'.format(d))", "t": "single", "ans": "C", "kp": "函数", "o": [ "{'chen':89,'zhang':78,'Liu':78}", "{'liu':96,'xiao':35,'ye':100}", "{'chen': 89, 'zhang': 78, 'liu': 78}", "{'xiao':35,'ye':100}" ], "explanation": "函数内部定义的d为局部变量，其修改不会影响外部全局变量d。调用sum()后全局字典保持不变，格式化输出原内容。" }, { "id": 1470, "q": "关于lambda函数，以下选项中描述错误的是（ ）。", "t": "single", "ans": "A", "kp": "函数", "o": [ "lambda不是Python的保留字", "lambda函数也称为匿名函数", "定义了一种特殊的函数", "lambda函数将函数名作为函数结果返回" ], "explanation": "lambda是Python的保留关键字，用于创建匿名函数。选项A称其不是保留字，表述错误，符合题意。其他选项均正确描述了lambda函数的特性。" }, { "id": 1471, "q": "下列程序的运行结果是（ ）。\ndef f(x=2,y=0):\n     return x-y\ny=f(y=f(),x=5)\nprint(y)", "t": "single", "ans": "B", "kp": "函数", "o": [ "-3", "3", "2", "5" ], "explanation": "函数调用时先计算内层f()，使用默认参数x=2,y=0，返回2。接着计算外层f(y=2,x=5)，返回5-2=3。因此y的值为3。" }, { "id": 1472, "q": "下列程序的执行结果是（ ）。\nclass A():\n      x=20\nclass A1(A):\n       y=30\nprint(A.x,A1.x,A1.y)", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "20 20 30", "20 30 20", "30 20 20", "运行出错" ], "explanation": "类A定义了类属性x=20。类A1继承自A，因此A1也拥有属性x=20，同时A1定义了自身属性y=30。打印A.x、A1.x和A1.y，结果依次为20、20、30。" }, { "id": 1473, "q": "关于面向对象和面向过程的说法，正确的是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "面向对象采用自顶向下的方法", "一个面向过程的程序一般由类的声明和类的使用两部分组成", "对于开发大规模的程序而言，面向对象程序设计方法可以提高软件开发的效率", "面向对象是基于面向过程的" ], "explanation": "面向过程采用自顶向下方法，由函数组成；面向对象适合大规模程序，能提高软件开发效率、可维护性和复用性。面向对象并非基于面向过程，两者是不同的编程范式。" }, { "id": 1474, "q": "在继承关系中，继承的类称为（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "子类", "基类", "超类", "父类" ], "explanation": "在继承关系中，被继承的类称为父类、基类或超类，而执行继承动作、继承其他类属性和方法的类称为子类或派生类。选项中基类、超类、父类同义，故选子类。" }, { "id": 1475, "q": "当使用'r'模式说明符打开文件时，哪个方法将以字符串形式返回文件的内容（）", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "write", "input", "get", "read" ], "explanation": "在Python文件操作中，使用'r'模式打开文件后，read()方法用于读取并返回文件的全部内容，且以字符串形式返回。write用于写入，input和get不是文件读取方法。" }, { "id": 1476, "q": "使用 open() 函数打开文件时，以下哪个参数用于指定文件的换行符处理方式？", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "mode", "encoding", "newline", "format" ], "explanation": "open()函数中，mode参数指定打开模式，encoding指定编码格式，而newline参数专门用于指定换行符的处理方式，如是否启用通用换行符模式。" }, { "id": 1477, "q": "下列 Python 程序的运行结果是（ ）。\ns={1,2,3,4}\nt=1\nfor x in s:\n    print(x,end='\\t')\n    t+=x\nprint(t)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "1 2 3 4", "11 1 2 3 4", "1 2 3 4 11", "11" ], "explanation": "集合s包含1到4，遍历时依次取出元素并打印，以制表符分隔。初始t=1，每次循环将x累加到t中，最终t=1+1+2+3+4=11。循环结束后打印t，因此输出1 2 3 4 11。" }, { "id": 1478, "q": "以下程序是求y=1+1/3+1/5+…+1/(2n-1)的前100项之和，请填空。\nn=1\ny=0\nwhile  n   1   :   \n    f=1.0/(2*n-1)            #求累加项\n    y+=  2                   #累加\n    n+=1\nprint(\"y={0}\".format(y))", "t": "fill", "ans": "<=100 | f", "kp": "循环结构", "o": [], "explanation": "第1空控制循环条件，求前100项和且n从1开始，故填<=100；第2空进行累加操作，将当前计算出的项f累加到总和y中，故填f。" }, { "id": 1479, "q": "以下程序的功能是：定义一个数学中的复数类Complex，该类有一个构造函数和一个显示函数，建立一个Complex对象，调用设计的显示函数并显示。请根据题目功能填空。\nclass Complex:\n    def ____1____(self,a):\n        self.a=a\n    def display(self):\n        print(self.a)\ncom=____2____('aaa')\ncom.display()", "t": "fill", "ans": "__init__ | Complex", "kp": "面向对象", "o": [], "explanation": "第1空定义类的构造函数，Python中固定为__init__；第2空通过类名实例化对象，根据上方类定义，应填入Complex来创建该类的实例。" }, { "id": 1480, "q": "以下程序中，for循环的循环次数是（ ）。\nk=0\nfor i in range(10):\n    k=k+1\n    if i<1:\n        s='Python'\n        continue\n    if i==5:\n        s='World'\n        break\nprint(k)", "t": "fill", "ans": "6", "kp": "循环结构", "o": [], "explanation": "循环变量i从0到9。i=0时k=1并continue；i=1到4时k依次累加至5；当i=5时，k累加为6，随后触发break跳出循环。因此循环共执行6次，k的值为6。" }, { "id": 1481, "q": "以下程序的运行结果是[*queNo*]_______。\nlist1=[1,2,3]\nlist2=list1*3\nprint(list2)", "t": "fill", "ans": "[1, 2, 3, 1, 2, 3, 1, 2, 3]", "kp": "列表/元组", "o": [], "explanation": "Python中列表与整数相乘表示将列表中的元素重复指定次数。list1包含3个元素，乘以3后生成包含9个元素的新列表，即原列表内容重复3次。" }, { "id": 1482, "q": "下列程序运行的结果是什么？\ndef find_longest_word(words):\n    longest_word = ''\n   \n    for word in words:\n        if len(word) > len(longest_word):\n            longest_word = word\n    return longest_word\nword_list = ['apple', 'banana', 'cherry', 'durian']\nresult = find_longest_word(word_list)\nprint(result)", "t": "fill", "ans": "banana", "kp": "函数", "o": [], "explanation": "函数遍历列表寻找最长单词。'apple'长5，更新为最长；'banana'长6，大于5，更新为最长；'cherry'和'durian'长度均为6，不满足严格大于条件，故不更新。最终返回'banana'。" }, { "id": 1483, "q": "以下prime函数的功能是：判断m 是否为素数(素数是除 1 以外只能被自身整除的自然数)。调用函数prime求输入的两个正整数 x 和 y(x=2），输出不大于100的序列元素。\n例如：屏幕输出实例为：\n0,1,1,2,3,…(略)\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "a, b = 0, 1\nwhile a<=100:\nprint(a, end=',')\na, b = b,a+b", "kp": "循环结构", "o": [], "rawType": "operation" }, { "id": 1489, "q": "考生文件夹下存在一个文件PY201.py，请写代码替换横线，不修改其他代码，实现以下功能：\n使用turtle库的turtle.fd()函数和turtle.seth()函数绘制一个每方向为100像素长度的十字形，效果如图所示。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import turtle\nfor i in range(4):\nturtle.fd(100)\nturtle.fd(-100)\nturtle.seth((i+1)*90)", "kp": "random/turtle等标准库", "o": [], "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-turtle-cross-1489.png", "rawType": "operation" }, { "id": 1490, "q": "以下不能创建集合的语句是（ ）。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "s1={}", "s2=set()", "s3=set(\"abcd\")", "s4={1,2,3,4}" ], "explanation": "在Python中，使用空花括号{}创建的是空字典而不是空集合。要创建空集合必须使用set()函数。选项B、C、D均能正确创建集合，因此A选项不能创建集合。" }, { "id": 1491, "q": "下面程序中的语句print(\"i=\",i,\" j=\",j) 共执行（ ）次。\ni=0\nwhile i<10:\n    for j in range(10):\n        print(\"i=\",i,\" j=\",j)\n         i=i+1", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "10", "9", "8", "100" ], "explanation": "外层while循环条件为i<10。内层for循环执行时，i=i+1语句使得i的值每次递增。当内层循环执行10次后，i的值变为10，此时外层while条件不再满足，循环结束。因此print语句共执行10次。" }, { "id": 1492, "q": "将字符串中全部字母转换为大写字母的字符串方法是（ ）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "swapcase", "capitalize", "uppercase", "upper" ], "explanation": "upper()方法用于将字符串中的所有小写字母转换为大写字母。swapcase()用于大小写翻转，capitalize()仅将首字母大写，Python中没有uppercase()方法。因此正确选项为D。" }, { "id": 1493, "q": "执行下面的代码，输出的结果为（）。\ns =0\nfor i in range(1,101):\n    if i%2 == 0:\n        s += i\n    else:\n        s -= i\nprint(s)", "t": "fill", "ans": "50", "kp": "循环结构", "o": [], "explanation": "循环遍历1到100的整数。当i为偶数时，s加上i；当i为奇数时，s减去i。可以将相邻的奇偶数配对：(2-1)+(4-3)+...+(100-99)，每对的结果均为1，共有50对，因此最终s的值为50。" }, { "id": 1494, "q": "下面关于Python内置函数说法错误的是（）", "t": "single", "ans": "D", "kp": "函数", "o": [ "内置函数是不需要关键字import导入而可以直接使用的函数", "求绝对值的函数abs(x)是Python的内置函数", "range(a,b,s)是Python的内置函数", "开平方函数sqrt(x)是Python的内置函数" ], "explanation": "sqrt()开平方函数属于math模块，并非Python的内置函数，使用前需要通过import math导入。而abs()、range()等均为无需导入即可直接使用的内置函数。因此D选项说法错误。" }, { "id": 1495, "q": "print('{:7.2f}{:2d}'.format(101/7,101%8))的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "{:7.2f}{:2d}", "□□14.43□5（□代表空格）", "□14.43□□5（□代表空格）", "□□101/7□101%8（□代表空格）" ], "explanation": "101/7约为14.428，{:7.2f}格式化为总宽7、保留2位小数的浮点数，即2个空格加14.43。101%8结果为5，{:2d}格式化为总宽2的整数，即1个空格加5。拼接后为2个空格、14.43、1个空格和5，对应选项B。" }, { "id": 1496, "q": "下列程序的运行时分别输入3和2，运行结果是（ ）\nx=input()\ny=input()\nprint(int(x+y))", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "5", "3", "2", "32" ], "explanation": "input()函数接收的输入默认为字符串类型。输入3和2后，x和y分别为字符串'3'和'2'。x+y执行字符串拼接操作得到'32'，最后通过int()将其转换为整数32并输出。" }, { "id": 1497, "q": "下列Python程序的运行结果是（ ）。\nx=0\ny=True\nprint(x>y and 'A'<'B')", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "True", "False", "true", "false" ], "explanation": "在Python中，布尔值True在比较时等价于整数1。因此x>y即0>1，结果为False。由于and运算符具有短路特性，左侧为False时不再计算右侧表达式，直接返回False。" }, { "id": 1498, "q": "键盘输入数字5，以下代码的输出结果是（）。\nn =eval(input(\"请输入一个整数:\"))\ns =0\nif n>=5:\n  n -= 1\n  s =4\nif n<5:\n  n -= 1\ns =3\nprint(s)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "4", "3", "0", "2" ], "explanation": "输入5后，第一个if条件成立，n变为4，s变为4。接着判断第二个if，此时n为4，条件n<5成立，n变为3。最后执行独立语句s=3，覆盖之前的s值，因此输出3。" }, { "id": 1499, "q": "以下循环执行（ ）次。\ns=0\nwhile not s:\n       pass", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "1", "无限次", "3", "2" ], "explanation": "初始时s为0，not s的值为True，进入while循环。由于循环体pass不执行任何操作，s的值始终保持为0，循环条件永远为真，从而导致无限次循环。" }, { "id": 1500, "q": "下列程序段的功能是（）。\ns=0\nlst=[2,4,6,8,10]\nfor i in lst:\n       s+=i\nprint(s)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "计算1~10范围内所有偶数之和", "计算1~10范围内所有奇数之和", "计算1~10范围内所有质数之和", "计算1~10范围内所有整数之和" ], "explanation": "列表lst包含了1到10范围内的所有偶数（2, 4, 6, 8, 10）。for循环遍历列表中的每个元素并累加到变量s中，因此该程序段的功能是计算1~10范围内所有偶数之和。" }, { "id": 1501, "q": "对于下述程序段，下面描述中正确的是______。\nk=10\nwhile k:\n    while 1:\n        k=k-1\n        print(k)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "while循环执行10次", "循环体语句一次也不执行", "内循环是无限循环", "循环体语句执行一次" ], "explanation": "外层循环条件为k，内层循环条件为1（永远为真）。程序进入内层循环后，由于没有break等跳出语句，内层循环将无限执行下去，导致外层循环实际上只进入了一次，内循环是无限循环。" }, { "id": 1502, "q": "已知列表L=list(range(9)), 那么执行语句del L[:3]之后, L的值为（ ）。", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "[5，7, 9]", "[0,1，2, 4, 5, 6, 7, 8]", "[0，1, 3, 5，7]", "[3, 4, 5，6, 7, 8]" ], "explanation": "list(range(9))生成列表[0, 1, 2, 3, 4, 5, 6, 7, 8]。切片L[:3]表示获取索引0到2的元素，即[0, 1, 2]。执行del L[:3]后，删除了前三个元素，列表剩余部分为[3, 4, 5, 6, 7, 8]。" }, { "id": 1503, "q": "以下不能创建字典的语句是（ ）。", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "dict1={'a':1,'b':2,'c':3}", "dict2={1:2}", "dict3=dict([1,2],[3,4])", "dict4=dict(name='allen',age=25)" ], "explanation": "选项A、B使用花括号直接创建字典，选项D使用关键字参数创建字典，均合法。选项C中dict()函数若通过可迭代对象创建字典，应传入包含键值对元组的单个列表，传入两个独立列表会导致参数错误。" }, { "id": 1504, "q": "在考生文件夹下存在一个Python源文件PY201.py，请写代码替换横线，不修改其他代码，实现下面功能：\n使用turtle库和random库，绘制四个彩色的正方形，正方形颜色随机从颜色列表color中获取；正方形边长从范围[50,200]之间选取，每个正方形左下角坐标x和y从范围[-100,100]之间选取。\n示例如下：\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试及验证程序。", "t": "fill", "ans": "import turtle as t\nimport random as r\ncolor = ['red','blue','purple','black']\nr.seed(1)\nfor j in range(4):\nt.pencolor(color[r.randint(0,3)])\nt.penup()\nt.goto(r.randint(-100,100), r.randint(-100,100))\nt.pendown()\nra = r.randint(50, 200)\nfor i in range(1, 5):\nt.fd(ra)\nt.seth(90*i)\nt.done()\n# t.pencolor(color[r.randint(0,3)])表示指定随机画笔颜色。", "kp": "random/turtle等标准库", "o": [], "rawType": "operation" }, { "id": 1505, "q": "表达式len( r'C:\\win\\note.exe')的值为（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "15", "13", "14", "17" ], "explanation": "字符串前的r表示原始字符串，其中的反斜杠不作为转义字符处理，而是作为普通字符计算长度。该字符串包含字母、冒号、反斜杠和点号等，共计15个字符。" }, { "id": 1506, "q": "Python表达式中，可以使用（ ）控制运算的优先顺序。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "圆括号()", "方括号[]", "大括号{}", "尖括号<>" ], "explanation": "在Python表达式中，圆括号()用于改变或控制运算的优先顺序，使其内部的表达式优先计算。方括号用于列表或索引，大括号用于字典或集合，尖括号在Python中不用于控制运算优先级。" }, { "id": 1507, "q": "下列不可以作为Python合法变量名的是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "c0", "a#", "a_3", "花朵" ], "explanation": "Python变量名只能包含字母、数字和下划线，且不能以数字开头。选项B中包含特殊字符\"#\"，不符合变量名命名规则。选项D的中文在Python 3中是合法的变量名。" }, { "id": 1508, "q": "下列不属于常量的是（ ）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "-23", "2.14", "\"hello\"", "x=212" ], "explanation": "常量是指在程序运行过程中值不发生改变的量，如选项A的整型、B的浮点型和C的字符串。选项D是一个赋值语句，将212赋值给变量x，不属于常量。" }, { "id": 1509, "q": "为了给整型变量x,y,z赋初值5，下列正确的Python语句是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "xyz=5", "x=5;y=5;z=5", "x=5,y=5,z=5", "x,y,z=5" ], "explanation": "在Python中，同一行写多条语句需使用分号分隔，因此选项B正确。选项A将5赋给变量xyz；选项C语法错误；选项D是序列解包，等号右侧需要提供包含三个元素的序列，直接写5会导致报错。" }, { "id": 1510, "q": "关于 Python 语言的注释,以下选项中描述错误的是( )。", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "Python 语言的单行注释以#开头", "Python 语言的多行注释以''' (三个单引号)开头和结尾", "Python 语言有两种注释方式:单行注释和多行注释", "Python 语言的单行注释以单引号'开头" ], "explanation": "Python的单行注释以井号（#）开头，而不是单引号。单引号用于定义字符串。多行注释通常使用三个单引号或三个双引号包裹。因此选项D描述错误。" }, { "id": 1511, "q": "以下程序的输出结果是（ ）\ns=\"Love\"\nprint(\"{:*>10}\".format(s))", "t": "single", "ans": "D", "kp": "字符串", "o": [ "***Love***", "Love", "Love******", "******Love" ], "explanation": "格式化字符串{:*>10}表示总宽度为10，右对齐，不足部分用*填充。字符串Love长度为4，因此左侧填充6个*，结果为******Love。" }, { "id": 1512, "q": "执行语句x= input( )，若输入0，那么 x 的值是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "0.0", "0", "“0”", "程序出错" ], "explanation": "input()函数接收用户输入时，无论输入什么内容，返回值始终是字符串类型。因此输入数字0，变量x接收到的是字符串\"0\"，而不是整数或浮点数。" }, { "id": 1513, "q": "以下代码的输出结果是（ ）。\nb=8\nif b%2==0 and b%3==0:\n    print('该数字能被 2 和 3 同时整除')\nelif b%2==0:\n    print('该数字能被 2 整除')\nelif b%3==0:\n    print('该数字能被 3 整除')\nelse :\n    print('该数字不能被 2 和 3 整除')", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "该数字能被 2 和 3 同时整除", "该数字能被 2 整除", "该数字能被 3 整除", "该数字不能被 2 和 3 整除" ], "explanation": "b=8，8%2==0为True，8%3==0为False。第一个if条件为False；进入elif，8%2==0为True，因此执行对应分支打印该数字能被2整除，后续分支不再执行。" }, { "id": 1514, "q": "设x>0,则表达式x>2*x的值为（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "已知x>0，不等式两边同乘2得2*x>0，且2*x必然大于x。因此x>2*x在数学上恒不成立，Python中布尔值False表示假，注意首字母大写。" }, { "id": 1515, "q": "以下代码的输出结果为（）。\nx=True\ny=False\nz=True\nif not x:\n   if y:\n      print(1)\n   else:\n      print(2)\nelif not x or y or not y and x:\n   print(3)\nelse:\n   print(4)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "1", "2", "3", "4" ], "explanation": "x为True，not x为False，跳过第一个if。计算elif条件：not x或y或(not y且x)。根据优先级先算and得True，再算or，最终结果为True，执行print(3)。" }, { "id": 1516, "q": "下面if语句统计\"成绩（mark）优秀的男生以及不及格的男生\"的人数，正确的语句为（ ）。", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "if gender==\"男\" and mark=90:n+=1", "if gender==\"男\" and mark=90:n+=1", "if gender==\"男\" and (mark=90):n+=1", "if gender==\"男\" or mark=90:n+=1" ], "explanation": "统计条件要求性别为男，且成绩优秀或不及格。由于and优先级高于or，必须用括号将成绩的两个条件括起来，再与性别条件进行and运算。C选项体现了正确的括号逻辑。" }, { "id": 1517, "q": "以下程序的输出结果是（ ）\nsum=0\nfor s in range(6):\n      if s%2==0 :\n            sum=sum+s\n      else:\n            sum=sum/2\nprint(sum)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "2.5", "6", "6.0", "3" ], "explanation": "range(6)生成0到5。s=0时sum=0；s=1时sum=0/2=0.0；s=2时sum=0.0+2=2.0；s=3时sum=2.0/2=1.0；s=4时sum=1.0+4=5.0；s=5时sum=5.0/2=2.5。最终输出2.5。" }, { "id": 1518, "q": "下列代码的输出结果是（ ）。\nx={0}\ny=0\nwhile not x:\n      y+=1\nelse:\n      y+=2\nprint(y)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "0", "1", "2", "出错" ], "explanation": "x是包含元素0的集合{0}，非空集合在布尔上下文中为True。因此not x为False，不执行while循环体，直接执行while...else结构中的else分支，y增加2，最终输出2。" }, { "id": 1519, "q": "以下代码的输出结果是（ ）。\nsum=0\ntup=(1,2,3,4,5)\nfor s in tup:\n    if s==5:\n        break\n    sum=sum+s\nprint(sum)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "10", "9", "7", "8" ], "explanation": "遍历元组，s依次为1,2,3,4时，累加到sum中，sum=1+2+3+4=10。当s=5时，触发break跳出循环，不再执行累加。因此最终sum的值为10。" }, { "id": 1520, "q": "以下代码的输出结果是（ ）。\nsum=0\nlis=[1,2,3,4,5]\nfor s in lis:\n    if s%2==0 :\n        sum=sum+s\nelse:\n    sum=sum/2\nprint(sum)", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "2.5", "3.0", "6.0", "6" ], "explanation": "for循环遍历列表，仅当元素为偶数时累加到sum，sum最终为2+4=6。由于循环正常结束未触发break，执行for...else的else分支，sum除以2得到3.0。" }, { "id": 1521, "q": "以下关于for循环嵌套的说法正确的是 （ ）。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "一个for循环的循环体中含有另外一个条件判断。", "一个for循环的循环体中含有另外一个不完整的循环。", "一个条件判断结构中含有一个完整的for循环结构。", "一个for循环的循环体中含有另外一个完整的循环。" ], "explanation": "循环嵌套是指在一个循环结构的循环体内部包含另一个完整的循环结构。选项A是条件判断，选项B是不完整循环，选项C是条件判断包含循环，均不符合循环嵌套的定义。" }, { "id": 1522, "q": "表达式 ['a'] in ('a', 'b', ['a'])的值是（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "Yes", "No", "True", "False" ], "explanation": "in运算符用于检查元素是否存在于序列中。元组('a', 'b', ['a'])的第三个元素正是列表['a']，两者值和类型均匹配，因此表达式返回布尔值True。" }, { "id": 1523, "q": "下列Python程序的运行结果是（ ）。\nnumber=[1,2,3,4,5]\nnumber[1:3]=[]\nprint(number)", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "[4,5]", "[1,5]", "[1,4,5]", "[3,4,5]" ], "explanation": "列表切片赋值。number[1:3]选取索引1和2的元素（即2和3），将其赋值为空列表，相当于删除这两个元素。原列表变为[1, 4, 5]。" }, { "id": 1524, "q": "以下表达式，正确定义了一个集合数据对象的是：( )。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "x = { 50, 'name', 10.2}", "x = (50, 'name', 10.2)", "x = [50, 'name', 10.2 ]", "x = {'name':10.2}" ], "explanation": "Python中集合使用花括号包裹元素，且元素间用逗号分隔，不包含键值对。选项B是元组，选项C是列表，选项D是字典。因此A正确定义了集合。" }, { "id": 1525, "q": "以下代码的输出是什么？\nd = {'name': 'John', 'age': 25, 'city': 'New York'}\nprint(d.get('gender', 'Unknown'))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "'name'", "'Unknown'", "'gender'", "None" ], "explanation": "字典的get(key, default)方法用于获取指定键的值。若键不存在，则返回默认值。字典中没有gender键，因此返回提供的默认值Unknown。" }, { "id": 1526, "q": "函数中的一组语句称为（ ）", "t": "single", "ans": "B", "kp": "函数", "o": [ "函数首部", "函数体", "返回", "参数" ], "explanation": "函数由函数首部和函数体组成。函数首部包含def关键字、函数名和参数列表，而函数内部执行具体逻辑的一组语句称为函数体。" }, { "id": 1527, "q": "下列代码的运行后结果是（ ）。\ndef add(k):\n    if k>=2:\n        return add(k-1)+add(k-2)\n    else:\n        return 3\nprint('{}'.format(add(2)))", "t": "single", "ans": "B", "kp": "函数", "o": [ "0", "6", "9", "1" ], "explanation": "递归函数调用。当k=2时，满足条件，返回add(1)+add(0)。对于add(1)和add(0)，均不满足条件，进入else分支返回3。因此结果为3+3=6。" }, { "id": 1528, "q": "以下程序代码的运行结果正确的是（ ）。\ns=5\ndef sum(n):\n    global s\n    s=0\n    for i in range(n):\n        s=s+i\n    return s\nsum(5)\nprint('{}'.format(s))", "t": "single", "ans": "B", "kp": "函数", "o": [ "15", "10", "9", "14" ], "explanation": "函数内使用global声明全局变量。调用sum(5)时，s被重置为0，循环range(5)即i从0到4，累加求和0+1+2+3+4=10。全局变量s被修改为10并打印。" }, { "id": 1529, "q": "下列代码的运行结果是（ ）。\ny=lambda s1,s2:s2.count(s1)\nprint(y('m','myfimoy'))", "t": "single", "ans": "B", "kp": "函数", "o": [ "1", "2", "3", "7" ], "explanation": "lambda表达式定义匿名函数，返回s2中s1出现的次数。调用时s1为'm'，s2为'myfimoy'。字符串'myfimoy'中包含两个'm'，故count方法返回2。" }, { "id": 1530, "q": "关类的方法描述错误的是（）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "实例方法最少也要包含一个 self 参数，Python 会自动完成绑定实例方法的类对象，因此，类对象直接调用实例方法。", "采用 @classmethod 修饰的方法为类方法,类方法最少也要包含一个参数，通常将其命名为 cls。", "静态方法需要使用＠staticmethod修饰，静态方法没有类似 self、cls 这样的特殊参数，不会对它包含的参数做任何类或对象的绑定，静态方法中无法调用任何类成员和类方法。", "实例方法既可以采用类对象调用，也可以直接通过类名调用。一般在类外推荐采用类名.实例方法的方式来调用实例对象方法。" ], "explanation": "实例方法必须通过实例对象调用，不能直接通过类名调用（除非手动传入实例作为第一个参数）。类方法通过类名调用，静态方法也可通过类名调用。选项D描述错误。" }, { "id": 1531, "q": "有以下代码：\nclass D(B,C）:\n      pass\n以下说法正确的是（）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "B是子类", "C是子类", "D是父类", "pass是空语句，起占位符的作用" ], "explanation": "在类定义中，D是子类，B和C是父类，体现了多继承。pass是Python中的空语句，不做任何操作，常用作占位符以保证语法完整性。选项D描述正确。" }, { "id": 1532, "q": "表达式writelines(lines)能够将一个元素是字符串的列表lines写入文件，以下选项中描述正确的是( )", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "列表lines中各元素之间默认采用换行分隔", "列表lines中各元素之间无分隔符", "列表lines中各元素之间默认采用逗号分隔", "列表lines中各元素之间默认采用空格分隔" ], "explanation": "writelines()方法将字符串序列写入文件，但它不会自动在元素之间添加任何分隔符（包括换行符）。若需换行，需手动在字符串末尾添加换行符。" }, { "id": 1533, "q": "以下哪个方法会把缓冲区的内容写入磁盘，关闭文件并释放文件对象？", "t": "single", "ans": "B", "kp": "文件操作", "o": [ "write()", "close()", "flush()", "tell()" ], "explanation": "close()方法用于关闭文件，它会先将缓冲区中未写入的数据刷新到磁盘，然后关闭文件并释放文件对象资源。flush()只刷新缓冲区不关闭文件。" }, { "id": 1534, "q": "下列 Python 程序的运行结果是（ ）。\ns1={4,3,2,1} &{7,8,9}\ns2={1,5,9,2,6,7}-{1,2}\ns1|=s2\ns1.remove(6)\nprint(s1)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{9, 5, 7}", "{1, 7, 9, 5}", "{1, 2, 6, 5}", "{1, 7, 4, 9, 6}" ], "explanation": "s1为两集合交集，无共同元素，故s1为空集。s2为差集，即{5,9,6,7}。s1|=s2使s1变为{5,9,6,7}。remove(6)移除6，最终s1为{9, 5, 7}，集合无序。" }, { "id": 1535, "q": "有以下程序代码：定义一个CC类，类中包含一个类属性ccc和构造方法，最后输出ccc属性的值。请将程序补充完整。\nclass CC:\n    ccc = 'ccc'\n    def ___1_____(self,a,b,c):\n        self.a=a\n        self.b=b\n        self.c=c\nprint( CC.__2____)", "t": "fill", "ans": "__init__ | ccc", "kp": "面向对象", "o": [], "explanation": "第1空为构造方法，Python中固定为__init__；第2空需输出类属性ccc，通过类名直接访问类属性，即CC.ccc，因此填ccc。" }, { "id": 1536, "q": "设有以下程序：\nn2=int(input())\nwhile n2:\n    if n2%2==1:\n        n2=n2//10\n        continue\n    n1=n2%10\n    print(n1,end='')\n    n2=n2//10\n程序运行后，如果从键盘上输入8921，则输出结果为         。", "t": "fill", "ans": "28", "kp": "循环结构", "o": [], "explanation": "输入8921。n2=8921为奇数，整除10得892；892为偶数，打印2，整除10得89；89为奇数，整除10得8；8为偶数，打印8，整除10得0。循环结束，输出28。" }, { "id": 1537, "q": "假设已有列表lst_sides=[ 3,4,5,6,8,10,6,6,6]依次存放了三个三角形的三条边长，编写程序利用海伦公式计算每个三角形的面积，并将结果存入列表lst_area。请填空。\nimport math\nlst_sides=[ 3,4,5,6,8,10,6,6,6]\nlst_area=[]\nfor i in range(0, ___1____,3):\n    a,b,c=lst_sides[i:i+3]\n    p=(a+b+c)/2\n    s=math.sqrt(p*(p-a)*(p-b)*(p-c))\n    _____2____\nprint(lst_area)", "t": "fill", "ans": "len(lst_sides) | lst_area.append(s)", "kp": "列表/元组", "o": [], "explanation": "第1空控制循环步长为3，需遍历整个列表，故填len(lst_sides)；第2空将计算出的面积s添加到结果列表中，使用列表的append方法，故填lst_area.append(s)。" }, { "id": 1538, "q": "程序阅读题\n给定如下程序，则运行结果是[*queNo*]。\nmy_dict = {}\nmy_dict['a'] = 1\nmy_dict['b'] = '2'\nmy_dict['c'] = my_dict['a'] + int(my_dict['b'])\nresult = ''\nfor key in my_dict:\n        result += str(my_dict[key])\nprint(result)", "t": "fill", "ans": "123", "kp": "字典/集合", "o": [], "explanation": "字典依次添加键值对'a':1, 'b':'2'。'c'的值为1加int('2')即3。遍历字典时，按插入顺序依次取出值1、'2'、3，转为字符串拼接，最终输出123。" }, { "id": 1539, "q": "使用readline方法读取文件中的当前行的内容，返回值的类型是一个_____类型。", "t": "fill", "ans": "字符串", "kp": "文件操作", "o": [], "explanation": "文件对象的readline()方法用于读取文件的一行内容，包含行尾的换行符，其返回值的数据类型为字符串（str）。" }, { "id": 1540, "q": "在考生文件夹下有个文件PY103.py，在横线处填写代码，完成如下功能。接收用户输入的以英文逗号分隔的一组数据，其中，每个数据都是整数或浮点数，打印输出这组数据中的最大值。例如：\n输入：\n1,3,5,7,9,7,5,3,1\n输出：\n9\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "ls = s.split(\",\")\nlt.append(eval(i))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1541, "q": "Python 语句 print(type({'A':10,'B':20,'C':30,'D':40}))的输出结果是（ ）", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "", "", "", "" ], "explanation": "大括号内包含键值对，这是字典（dict）的字面量表示法。type()函数返回对象的类型，因此输出结果为字典类型，对应选项B。" }, { "id": 1542, "q": "下面程序的运行结果是 （）\nx = {\"apple\", \"banana\", \"cherry\"}\ny = {\"google\", \"microsoft\", \"apple\"}\nx.difference_update(y)\nprint(x)", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "{'\"google\"', 'banana'}", "{'cherry', 'apple'}", "{'cherry', \"microsoft\"}", "{'cherry', 'banana'}" ], "explanation": "difference_update()方法用于移除两个集合中都存在的元素。x和y共有的元素是apple，移除后x剩下banana和cherry，对应选项D。" }, { "id": 1543, "q": "以下程序的输出结果是：( )。\nd = {\"Wu\":\"China\", \"Liu\":\"America\", \"Nan\":\"Korea\"}\nfor k in d:\n    print(k, end=\"\")", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "ChinaAmericaKorea", "Wu:China Liu:America Nan:Korea", "\"Wu\"\"Liu\"\"Nan\"", "WuLiuNan" ], "explanation": "直接遍历字典for k in d等同于遍历字典的键。依次取出键Wu、Liu、Nan，并使用end=\"\"取消换行，最终连续输出WuLiuNan，对应选项D。" }, { "id": 1544, "q": "以下程序的运行结果是[*queNo*]_______。\nx =[1,2,3,4,5,6,7,8,9,10]\ny = x[:5]\ny.sort()\nx[:5] = y\ny = x[5:]\ny.sort(reverse=True)\nx[5:] = y\nprint(x)", "t": "fill", "ans": "[1, 2, 3, 4, 5, 10, 9, 8, 7, 6]", "kp": "列表/元组", "o": [], "explanation": "y取x前5个元素[1,2,3,4,5]并升序排序，赋回x[:5]；y再取x后5个元素[6,7,8,9,10]并降序排序为[10,9,8,7,6]，赋回x[5:]。最终x为前5个升序、后5个降序的列表。" }, { "id": 1545, "q": "下列表达式的值为True的是（ ）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "2!=5 or 0", "3>2>2", "5+4j>2-3j", "1 and 5==0" ], "explanation": "A选项2!=5为True，True or 0短路求值结果为True；B选项3>2>2等价于3>2 and 2>2，为False；C选项复数不支持大小比较会报错；D选项1 and False为False。故选A。" }, { "id": 1546, "q": "在Python中，set对象的元素类型必须是什么？", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "可以是任意类型", "只能是数字类型", "只能是字符串类型", "只能是不可变类型" ], "explanation": "Python中集合（set）的元素必须是可哈希的，通常为不可变类型。但根据给定答案A，可能题目意在考察集合可容纳多种不同类型的数据（如同时包含整数和字符串），故选A。" }, { "id": 1547, "q": "以下能作为函数名的是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "int", "2c", "FOR", "-ss" ], "explanation": "Python标识符不能以数字开头（排除B），不能包含连字符（排除D）。int是内置类型名，不建议覆盖；FOR是大写字母，Python关键字for区分大小写，故FOR是合法标识符，选C。" }, { "id": 1548, "q": "以下代码的执行结果是（）。\na = 75\nif a > 60:\n  print(\"Should Work Hard!\")\nelif a > 70:\n  print(\"Good\")\nelse:\n  print(\"Excellent\")", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "执行出错", "Excellent", "Good", "Should Work Hard!" ], "explanation": "Python的if-elif-else分支结构按顺序判断条件。变量a为75，满足第一个条件a>60，因此执行对应的print语句输出指定内容，后续的elif和else分支将被直接跳过。" }, { "id": 1549, "q": "下列语句执行后的结果是（ ）。\nA={1:'啤酒',2:'饮料'}\nB={1:'花生',2:'瓜子'}\nA.update(B)\nprint(A[2])", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "啤酒", "饮料", "花生", "瓜子" ], "explanation": "字典的update()方法用于将另一个字典的键值对更新到当前字典中。若键已存在，则覆盖原有值。字典B中的键2对应的值为'瓜子'，更新后A[2]的值被覆盖为'瓜子'。" }, { "id": 1550, "q": "下列代码的输出结果是（）\nx=list()\ny=0\nwhile x:\n    y+=1\nprint(y)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0", "1", "没有输出", "出错" ], "explanation": "list()创建一个空列表，空列表在布尔上下文中求值为False。因此while循环的条件不成立，循环体不会执行，变量y保持初始值0，最终输出0。" }, { "id": 1551, "q": "以下说法错误的是（ ）。", "t": "single", "ans": "B", "kp": "函数", "o": [ "python语言中的匿名函数不需要使用def 语句进行定义。", "匿名函数的形参可以有一个或多个，但是，其参数不可以缺省。", "默认情况下，调用匿名函数时，相应位置上的实参传给对应的形参，实参的个数必须与形参个数一致且一一对应。", "匿名函数体只有一行代码，代码运行结果会被作为函数的返回值自动返回，而且只有一个返回值。" ], "explanation": "Python中的匿名函数使用lambda关键字定义。lambda函数的参数支持默认值（即缺省参数），例如`lambda x=1: x`是合法的。因此选项B中\"其参数不可以缺省\"的说法是错误的。" }, { "id": 1552, "q": "关于Python中的复数，下列说法错误的是（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "表示复数的语法是real+image j", "实部和虚部都是浮点数", "虚部必须后缀j，且必须是小写", "方法conjugate返回复数的共轭复数" ], "explanation": "Python中复数的虚部后缀可以使用小写字母'j'或大写字母'J'，例如`3+4j`和`3+4J`都是合法的复数表示。因此选项C中\"必须是小写\"的说法错误。" }, { "id": 1553, "q": "关于Python字符串，以下选项中描述错误的是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "字符串可以保存在变量中，也可以单独存在", "字符串是一个字符序列，字符串中的编号叫\"索引\"", "可以使用datatype()测试字符串的类型", "输出带有引号的字符串，可以使用转义字符" ], "explanation": "Python中用于获取对象数据类型的内置函数是type()，而不是datatype()。因此选项C描述错误。字符串可以保存在变量中、支持索引、可使用转义字符输出引号，这些描述均正确。" }, { "id": 1554, "q": "表达式str(10/2)的结果是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "ValueError", "'5.0'", "\"5'", "'10/2'" ], "explanation": "在Python 3中，除法运算符`/`执行真除法，`10/2`的结果为浮点数`5.0`。使用`str()`函数将其转换为字符串后，结果为`'5.0'`。" }, { "id": 1555, "q": "表达式3**2+5的值为（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "14", "11", "2187", "21" ], "explanation": "Python中`**`是幂运算符，优先级高于加法运算符`+`。因此表达式先计算`3**2`得到9，然后再计算`9+5`，最终结果为14。" }, { "id": 1556, "q": "以下关于Python语言技术特点的描述中，错误的是（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "对于需要更高执行速度的功能，例如数值计算和动画，Python语言可以调用C语言编写的底层代码", "Python比大部分编程语言具有更高的软件开发产量和简洁性", "Python语言是解释执行的，因此执行速度比编译型语言慢", "Python是脚本语言，主要用作系统编程和Web访问的开发语言" ], "explanation": "Python是一种通用编程语言，广泛应用于数据科学、人工智能、Web开发和自动化脚本等领域。虽然可用于编写系统管理脚本，但将其定义为\"主要用作系统编程\"是不准确的。" }, { "id": 1557, "q": "下面的代码的输出结果是（ ）\nx=12.0\nprint(type(x))", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "", "", "", "" ], "explanation": "变量x被赋值为12.0，属于浮点数。使用type()函数获取其数据类型，返回结果为``。题目选项文本缺失，但根据代码运行逻辑，正确选项应表示浮点数类型。" }, { "id": 1558, "q": "已知x=5;y=6,语句X=x+y执行后，x的值是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "5", "6", "11", "12" ], "explanation": "Python严格区分大小写，变量`x`和`X`是两个独立的标识符。语句`X=x+y`将`x`与`y`的和赋值给变量`X`，而原变量`x`的值并未发生任何改变，因此`x`的值依然是5。" }, { "id": 1559, "q": "若想要在屏幕上打印输出Hello Python,应该使用下列哪个语句（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "printf(\"Hello Python\")", "print(\"Hello Python\")", "printf(Hello Python)", "print(Hello Python)" ], "explanation": "Python中用于在控制台输出内容的内置函数是print()，且字符串内容需要用引号（单引号或双引号）括起来。因此正确的语句是print(\"Hello Python\")。" }, { "id": 1560, "q": "以下关于Python语言中“缩进”说法正确的是：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "缩进是非强制的，仅为了提高代码可读性", "缩进可以用在任何语句之后，表示语句间的包含关系", "缩进统一为4个空格", "缩进在程序中长度统一且强制使用" ], "explanation": "Python使用缩进来表示代码块和层级关系，这是强制性的语法要求，而非仅仅为了可读性。同一代码块内的缩进长度必须统一，通常推荐4个空格，但并非强制规定必须是4个，只要统一即可。因此D选项正确，A、B、C错误。" }, { "id": 1561, "q": "Python语句print(\"{:4o}\".format(33) )中o代表的含义为（ ）", "t": "single", "ans": "C", "kp": "字符串", "o": [ "二进制", "十进制", "八进制", "十六进制" ], "explanation": "在Python的字符串格式化中，格式说明符'o'代表将整数格式化为八进制形式。'b'代表二进制，'d'代表十进制，'x'代表十六进制。因此33会被转换为八进制的41，选项C正确。" }, { "id": 1562, "q": "语句x=input()执行时，如果从键盘输入12并按回车键，则x的值是（ ）。", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "12", "12.0", "1e2", "'12'" ], "explanation": "Python中的input()函数用于从标准输入读取一行文本，其返回值始终是字符串类型。即使用户输入的是数字12，函数也会将其作为字符串'12'返回。若需数值类型，需使用int()或float()进行显式转换。" }, { "id": 1563, "q": "下列语句执行后的输出是（）。\nif 2:\n   print(5)\nelif 3:\n   print(6)\nelse:\n   print(7)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "56", "567", "5", "6" ], "explanation": "在Python中，非零整数在布尔上下文中被视为True。条件if 2中，2为真，因此执行其下的代码块print(5)，输出5。由于if-elif-else结构在匹配到第一个为真的条件后就会跳出整个分支，后续分支不会被执行。" }, { "id": 1564, "q": "下列语句执行后的输出是（）。\nx=100\ny=20\nif x=0时什么也不输出", "print()函数永远也不执行", "最多允许输出81个非负整数" ], "explanation": "外层循环9次，内层循环9次，共执行81次输入。当x<0时，continue跳过本次循环的print语句，不输出；当x>=0时，执行print(x)。因此最多输出81个非负整数。continue仅跳过当前内层循环的剩余代码，不会结束整个循环。" }, { "id": 1574, "q": "如果需要对字符串进行分割，需要使用的方法是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "split", "strip", "join", "len" ], "explanation": "split()方法用于根据指定分隔符对字符串进行切片，返回分割后的字符串列表。strip()用于移除首尾指定字符，join()用于将序列元素连接成新字符串，len()用于返回对象长度。" }, { "id": 1575, "q": "字符串tstr='television',显示结果为vi的选项是（）。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "print(tstr[4:7])", "print(tstr[-6:6])", "print(tstr[4:-2])", "print(tstr[5:7])" ], "explanation": "字符串'television'中，'v'的正向索引为4，反向索引为-6；'i'的正向索引为5。切片操作包含起始索引，不包含结束索引。tstr[-6:6]从索引-6（即'v'）截取到索引6（即's'）之前，结果为'vi'。" }, { "id": 1576, "q": "对于列表L=[1,2,'Python',[1,2,3,4,5]]，L[-3]的是（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "1", "2", "'Python'", "[1,2,3,4,5]" ], "explanation": "列表L包含4个元素。正向索引从0开始，反向索引从-1开始。倒数第一个元素是列表[1,2,3,4,5]，倒数第二个是'Python'，倒数第三个是整数2。因此L[-3]的值为2。" }, { "id": 1577, "q": "以下方法中，适用于元组的方法是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "sort()", "remove()", "len()", "insert()" ], "explanation": "元组是不可变序列，不支持修改其元素的操作。sort()、remove()和insert()都会改变序列内容，因此不能用于元组。len()是内置函数，可用于获取元组的长度，适用于所有序列类型。" }, { "id": 1578, "q": "下列Python程序的运行结果是（ ）。\nL1=[1,2,3,4,5]\nL1.pop(5)", "t": "single", "ans": "D", "kp": "列表/元组", "o": [ "[1,2,3,4]", "5", "[1,2,3,4,5]", "出错" ], "explanation": "列表的pop(i)方法用于移除并返回指定索引i处的元素。列表L1的有效索引范围是0到4（或-5到-1）。传入参数5超出了列表的索引范围，会引发IndexError异常，导致程序出错。" }, { "id": 1579, "q": "下列选项中，不能使用索引运算的是（ ）。", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "列表（List）", "元组（tuple）", "集合（set）", "字符串（str）" ], "explanation": "列表、元组和字符串都是有序序列，支持通过索引访问元素。集合（set）是无序的不重复元素集，不支持索引、切片等序列操作，只能通过遍历或成员资格测试来访问元素。" }, { "id": 1580, "q": "下列语句执行后的结果是（ ）。\ndict={'A':3,'B':4,'C':5}\ndict['D']=6\nprint(sum(dict.values()))", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "7", "12", "18", "9" ], "explanation": "字典初始包含三个键值对，值分别为3、4、5。执行dict['D']=6后，新增键'D'，值为6。dict.values()返回所有值的视图，即3、4、5、6。sum()函数对这些值求和，结果为18。" }, { "id": 1581, "q": "在有返回值的函数中，关键字（）之后的表达式的值将被发送回程序调用该函数的地方。", "t": "single", "ans": "D", "kp": "函数", "o": [ "def", "result", "sent", "return" ], "explanation": "在Python中，def用于定义函数，return语句用于从函数中返回表达式的值并结束函数执行，将结果发送回调用处。result和sent不是Python的关键字。" }, { "id": 1582, "q": "下列代码运行后的结果是（ ）。\ndef add(s):\n   \n    if len(s) == 1:\n        return s[0]\n    else:\n        return s[0].upper() + add(s[1:])\nprint(add(('x','y','z','a')))", "t": "single", "ans": "D", "kp": "函数", "o": [ "AXYz", "xyza", "XYZA", "XYZa" ], "explanation": "函数add通过递归处理元组。当长度大于1时，将当前首元素转为大写，并拼接剩余元素的递归结果。递归过程：'x'转'X'，'y'转'Y'，'z'转'Z'；当剩余元素为('a',)时，长度为1，直接返回'a'（未转大写）。最终拼接结果为'XYZa'。" }, { "id": 1583, "q": ".以下程序代码的运行结果正确的是（ ）。\ndef sum():\n     s={'D','D','E','F'}\n     return s\ns={'A','A','B','C'}\nsum( )\nprint('{}'.format(s))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{'A','A','B','C'}", "{'A', 'B', 'C'}", "{'D','D','E','F'}", "{'D','E','F'}" ], "explanation": "全局变量s被赋值为集合{'A','A','B','C'}，集合自动去重后为{'A','B','C'}。调用sum()函数时，函数内部定义了局部变量s并返回，但这不会改变全局变量s的值。因此最后打印的全局变量s仍为去重后的{'A','B','C'}。" }, { "id": 1584, "q": "下列代码的运行结果是（ ）。\ny=lambda s1,s2:s2.find(s1)\nprint(y('n','myfile'))", "t": "single", "ans": "D", "kp": "函数", "o": [ "0", "返回错误信息", "1", "-1" ], "explanation": "lambda表达式定义了一个匿名函数，接收s1和s2两个参数，返回s2.find(s1)的结果。调用时传入'n'和'myfile'，即在字符串'myfile'中查找子串'n'。由于'myfile'中不包含'n'，find方法返回-1。" }, { "id": 1585, "q": "以下程序运行后输出的结果是（ ）\ndef my(a,b,*args):\n      print(a,b,args)\nmy(1,2,3,4,5,6,7)", "t": "single", "ans": "B", "kp": "函数", "o": [ "(1,2,3,4,5,6,7)", "1 2 (3, 4, 5, 6, 7)", "1,2,3,4,5,6,7", "(1 2) 3, 4, 5, 6, 7" ], "explanation": "函数定义中a和b为普通位置参数，*args用于接收多余的位置参数并打包为元组。调用时传入1到7，a和b分别接收1和2，剩余的3到7被打包为元组(3, 4, 5, 6, 7)赋给args。print默认以空格分隔输出各参数。" }, { "id": 1586, "q": "以下关于函数和方法的说法中错误的是（）", "t": "single", "ans": "A", "kp": "函数", "o": [ "函数和方法是同一个概念", "类里面定义的函数称为方法", "函数没有和类或对象进行绑定", "调用方法时前面要加对象名." ], "explanation": "函数和方法在Python中并非同一概念。函数是独立的代码块，不与类或对象绑定；而方法是定义在类内部的函数，与类或对象实例绑定，调用时通常需要以对象名或类名作为前缀。因此选项A说法错误。" }, { "id": 1587, "q": "以下程序的输出结果是（）\nclass CC:\n    a=10\n    b=20\n    def show(self):\n        print(abs(pow(self.a,2)-pow(self.b,2)))\nb=CC()\nb.show()", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "100", "200", "300", "-300" ], "explanation": "类CC定义了类属性a=10和b=20。实例化后调用show方法，计算abs(pow(10,2)-pow(20,2))。pow(10,2)为100，pow(20,2)为400，两者相减为-300，取绝对值abs后结果为300。" }, { "id": 1588, "q": "有以下代码段：\nclass B（A）:\n    def __init__(self,x,y):\n        self.x=x\n        self.y=y\n以下说法正确的是（）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "__init__方法必须显式调用", "A是子类", "B是父类", "x是实例属性" ], "explanation": "代码定义了类B继承自类A，因此A是父类，B是子类。__init__是构造方法，在实例化时自动调用，无需显式调用。在__init__中通过self.x=x将参数x绑定到实例，因此x是实例属性。" }, { "id": 1589, "q": "假设建立了一个customer文件对象，并且文件是使用'w'模式说明符打开的，那么如何将字符串'Mary Smith'写入该文件？（）", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "customer file.write('Mary Smith')", "customer.write('w', 'Mary Smith')", "customer.input('Mary Smith')", "customer.write('Mary Smith')" ], "explanation": "文件对象使用'w'模式打开后，可通过调用文件对象的write方法写入字符串。正确的语法是\"文件对象.write(字符串)\"，因此应使用customer.write('Mary Smith')将内容写入文件。" }, { "id": 1590, "q": "关于语句f=open('demo.txt','r')，下列说法不正确的是（）。", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "demo.txt文件必须已经存在", "只能从demo.txt文件读数据，而不能向该文件写数据。", "只能向demo.txt文件写数据，而不能从该文件读数据。", "\"r\"方式是默认的文件打开方式" ], "explanation": "open函数以'r'模式（只读模式，也是默认模式）打开文件时，要求文件必须已存在，且只能从中读取数据，不能写入。选项C称只能写不能读，与'r'模式的只读特性完全相反，因此说法不正确。" }, { "id": 1591, "q": "{1,2,3,4}.intersection({4,5,6},{4,5,'sdd'}) 的运行结果是（ ）", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "{1，2，3，4}", "{4，5，6}", "{'sdd'}", "{4}" ], "explanation": "intersection方法用于求多个集合的交集。题目求{1,2,3,4}、{4,5,6}和{4,5,'sdd'}三个集合的公共元素。观察可知，只有数字4同时存在于这三个集合中，因此交集结果为{4}。" }, { "id": 1592, "q": "判断三条线段a,b,c能否构成三角形?\na,b,c=eval(input(\"请输入三角形的三边:\"))\nif (a>0) ___1____ (b>0)and(c>0)and(a+b>c)and(a+c>b)and(b+c>a):\n        print(\"能构成三角形\")\n____2_____:\n       print(\"不能构成三角形\")", "t": "fill", "ans": "and | else", "kp": "分支结构", "o": [], "explanation": "第1空需要连接多个判断条件，构成三角形需同时满足各边大于0及任意两边之和大于第三边，故填and；第2空用于处理不满足if条件的情况，输出\"不能构成三角形\"，故填else构成完整的分支结构。" }, { "id": 1593, "q": "定义一个Person类，实现如下功能：\n1)使用构造函数初始化一个人的属性包括姓名（name），年龄（age）和人物标签（tag）；\n2)定义一个introduce()函数，实现输出人物信息的功能；\n3)实例化Person类为person1，并输出person1的个人信息；\n请根据以上需求，补全以下代码中的空缺。\nclass Person(object): #类的定义，object固定写法\n    def __init__(self,name,age,tag): #类的构造函数，即类的初始化\n        self.name = __1____\n        self.age = age\n        self.tag = tag\n    def introduce(self): # 类的方法\n        message = \"Name is {};Age is {};Tag is {}\".format(__2___, self.age, self.tag)\n        print(message)\nperson1 = Person(\"罗翔\",\"50\",\"教师\")\nperson1.introduce()", "t": "fill", "ans": "name | self.name", "kp": "面向对象", "o": [], "explanation": "第1空在构造函数中将传入的参数name赋值给实例属性self.name，故填name；第2空在格式化字符串时，需要获取实例的姓名属性进行输出，故填self.name以引用该实例属性。" }, { "id": 1594, "q": "下列程序的输出结果是（ ）。\na=[\"Tom \",\"buy \",\"hat \"]\ns=\"\"\nfor c in a:\n    for j in range(4):\n        s+=c[j]\nprint(s)", "t": "fill", "ans": "Tom buy hat", "kp": "循环结构", "o": [], "explanation": "外层循环遍历列表a中的每个字符串，内层循环通过索引0到3依次取出字符串的每个字符并拼接到s中。最终s为三个字符串的直接拼接。注意原字符串末尾含空格，但题库答案末尾无空格，存在细微出入。" }, { "id": 1595, "q": "编程求3~100之间的所有素数，并放在列表lst中。请填空。\nimport math\nlst=[]\nfor i in range(3,101):\n    for j in range (2,i):\n        if ___1____:\n            break\n    else:\n            ___2_____\nprint(lst)", "t": "fill", "ans": "i%j==0 | lst.append(i)", "kp": "算法与综合应用", "o": [], "explanation": "第1空用于判断i是否能被j整除，若余数为0说明不是素数，执行break跳出内层循环，故填i%j==0；第2空位于for-else结构的else分支，当内层循环未被break中断时执行，将素数i加入列表，故填lst.append(i)。" }, { "id": 1596, "q": "程序填空题\n将字典 inventory 中每个物品的数量增加 1。\ninventory = {\"apples\": 5, \"bananas\": 3, \"oranges\": 2}\n     1      item in inventory:\n    inventory[__2_] += 1", "t": "fill", "ans": "for | item", "kp": "字典/集合", "o": [], "explanation": "第1空填for，用于遍历字典的键；第2空填item，表示当前遍历到的键名。Python中直接遍历字典默认获取键，通过inventory[item]可访问并修改对应值，实现数量加1。" }, { "id": 1597, "q": "请补充sum函数，sum函数的功能是：实现计算表达式1+3+……+（2n-1）值的函数。如当n=10时，输出函数值sum为100。\n注意：部分源程序已给出。输入并调试程序，使程序得出正确结果不得增行或删行，也不得更改程序的结构！仅在sum函数的横线上填入。\ndef sum(n):\n    ___1___\n    for i in range(1,n+1):\n        temp=2*i-1\n        sum+=temp\n    return ___2___\nk=eval(input(\"请输入n值：\"))\nprint (\"函数值为：\",sum(k))", "t": "fill", "ans": "sum=0 | sum", "kp": "函数", "o": [], "explanation": "第1空填sum=0，用于初始化累加变量，避免引用未定义变量报错；第2空填sum，循环结束后返回累加结果。函数通过range生成1到n的整数，计算奇数序列和。" }, { "id": 1598, "q": "下列程序的输出结果是什么？[*queNo*]__\ndef func(str1):\n    str2 = ''\n    for i in range(len(str1)):\n        if i == 0 and 'a' <= str1[i] <= 'z':\n            str2 += chr(ord(str1[i])-32)\n        else:\n            str2 += str1[i]\n    return str2\nx = 'hello123'\nprint(func(x))", "t": "fill", "ans": "Hello123", "kp": "字符串", "o": [], "explanation": "函数遍历字符串，仅当索引为0且字符为小写字母时，通过ord和chr将其ASCII码减32转为大写。其余字符原样拼接。输入首字母h转为H，后续不变，故输出Hello123。" }, { "id": 1599, "q": "以下程序的运行结果是       。\nclass A:\n    def __init__(self,i=1):\n        self.i=i\nclass B(A):\n    def __init__(self,j=2):\n        super().__init__()\n        self.j=j\nb=B()\nprint(b.i+b.j)", "t": "fill", "ans": "3", "kp": "面向对象", "o": [], "explanation": "B继承A，实例化B()时调用super().__init__()执行父类初始化，默认参数使self.i=1；随后子类设置self.j=2。两者相加1+2结果为3。" }, { "id": 1600, "q": "在打开文件函数open中，文件操作方式是可选参数，默认值是[*queNo*]。（请填写字符）", "t": "fill", "ans": "r", "kp": "文件操作", "o": [], "explanation": "Python内置函数open()的mode参数为可选，若省略则默认以只读文本模式打开文件，对应字符为r。" }, { "id": 1601, "q": "下列Python程序的运行结果是[*queNo*]_。\na=400\nb=50\nc=0\nif a10}'.format(cs))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1603, "q": "获得用户输入的一个数字，对该数字以30字符宽度，十六进制，居中输出，字母小写，多余字符采用双引号(\")填充，请完善PY101.py中代码。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "s = input()\nprint(\"{:\\\"^30x}\".format(eval(s)))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1604, "q": "获得用户的非数字输入，如果输入中存在数字，则要求用户重新输入，直至满足条件为止，并输出用户输入字符的个数，完善PY202.py文件中的代码。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "while True:\ns = input(\"请输入不带数字的文本:\")\ni=0\nfor p in s:\nif \"0\"<=p<=\"9\":\ni=i+1\nif i==0:\nbreak\nprint(len(s))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1605, "q": "表达式type(eval(\"45\"))的结果是:（）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "", "", "None", "" ], "explanation": "eval(\"45\")将字符串解析为整数45，type()获取其数据类型为。根据Python类型系统，该表达式返回整型类对象，对应正确选项D。" }, { "id": 1606, "q": "在Python中，下列语句非法的是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "x=y=3", "x,y=3", "x,y=3,4", "x=x+y" ], "explanation": "Python解包赋值要求左右两侧元素数量一致。x,y=3试图将单个整数解包给两个变量，会引发ValueError，属于非法语句。A为链式赋值，C为元组解包，D为常规算术赋值，均合法。" }, { "id": 1607, "q": "以下程序的输出结果是（ ）\na,b=1,2\nprint(\"{1}{1}\".format(a,b))", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "22", "2 2", "11", "1 1" ], "explanation": "format()方法使用位置索引占位，{1}对应传入的第二个参数b（值为2）。因此\"{1}{1}\"被替换为两个2拼接，输出结果为22，对应选项A。" }, { "id": 1608, "q": "请在划线处选择合适的选项将程序补充完整，使程序的输出结果是False（ ）.\na=5\nb=8\nif _________:\n    print(\"True\")\nelse:\n    print(\"False\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "a>b", "ab即5>8结果为False，进入else分支打印。a num:\n print(\"大了\")\n以下选项中描述错误的是（）。", "t": "single", "ans": "B", "kp": "random/turtle等标准库", "o": [ "random.randint(1,10) 生成[1,10]之间的整数。", "\"import random\"这行代码是可以省略的。", "这段代码实现了简单的猜数字游戏。", "\"while True:\" 创建了一个永远执行的While 循环。" ], "explanation": "random.randint(1,10)会生成包含两端边界的1到10之间的整数，A正确。这段代码通过循环输入、比较大小和break退出，实现了猜数字游戏，C、D正确。random模块不是自动可用的内置名称，使用randint前需要import random，因此B“可以省略”是错误描述。" }, { "id": 1612, "q": "下列说法中正确的是（）。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "break用在for语句中，而continue用在while语句中", "break用在while语句中，而continue用在for语句中", "continue能结束循环，而break只能结束本次循环", "break能结束循环，而continue只能结束本次循环" ], "explanation": "break语句用于完全终止并跳出当前所在的整个循环结构；而continue语句仅用于跳过当前这一次循环的剩余代码，直接进入下一次循环迭代。两者均可用于for和while循环中，因此A、B、C选项的描述均存在概念混淆，只有D选项准确概括了二者的核心区别。" }, { "id": 1613, "q": "给出如下代码\ns='Python is Open Source!'\nprint(s[0:].upper())\n上述代码的输出结果是（）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "PYTHON", "PYTHON IS OPEN SOURCE", "Python is Open Source!", "PYTHON IS OPEN SOURCE!" ], "explanation": "切片s[0:]获取从索引0到末尾的完整字符串，即原字符串本身。随后调用.upper()方法将字符串中的所有小写字母转换为大写字母，标点符号和空格保持不变。因此最终输出全大写的PYTHON IS OPEN SOURCE!，包含末尾的感叹号。" }, { "id": 1614, "q": "下面（）可以将字符串s逆序打印出来", "t": "single", "ans": "A", "kp": "字符串", "o": [ "s[::-1]", "s[:-1]", "s[-1:]", "s[:-1:]" ], "explanation": "Python切片语法为[start:stop:step]。选项A中[::-1]省略了起止索引，步长为-1，表示从后向前逐个提取字符，从而实现整个字符串的逆序。B和D选项步长默认为1且截取了除最后一个字符外的子串；C选项仅截取最后一个字符。因此只有A能实现完整逆序。" }, { "id": 1615, "q": "下面代码的输出结果是（ ）。\nt1=('a','b','c',[ 'a','b','c'])\nt1[-1][-1]='d'\nprint(t1)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "('a','b','c','d')", "('a','b','c',[ 'a','b','d'])", "('a','b','c',[ 'a','b','c'],'d')", "异常" ], "explanation": "元组本身是不可变序列，不能直接修改其元素。但t1[-1]获取的是元组最后一个元素，即列表。列表是可变对象，[-1]进一步定位到列表的最后一个元素'c'并将其修改为'd'。元组内存储的列表引用未变，因此修改合法，输出结果为包含修改后列表的元组。" }, { "id": 1616, "q": "假设有两个字典，dict1 和 dict2，请问下面的代码片段会输出什么结果？\ndict1 = {'a': 1, 'b': 2, 'c': 3}\ndict2 = {'b': 4, 'd': 5}\ndict1.update(dict2)\nprint(dict1)", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{'a': 1, 'b': 2, 'c': 3, 'd': 5}", "{'a': 1, 'b': 4, 'c': 3, 'd': 5}", "{'a': 1, 'b': 2, 'c': 3}", "{'b': 4, 'd': 5}" ], "explanation": "字典的update()方法用于将另一个字典的键值对更新到当前字典中。如果键已存在，则覆盖原有值；如果键不存在，则添加新键值对。dict2中的'b'覆盖了dict1中的'b'（值变为4），'d'作为新键被添加（值为5），'a'和'c'保持不变。因此最终字典包含更新后的四个键值对。" }, { "id": 1617, "q": "下列代码运行后的结果是（ ）。\ndef sum(list):\n    if len(list) == 1:\n        return list[0]\n    else:\n        return list[0] + sum(list[1:])\nprint(sum([1,2,3,8,10]))", "t": "single", "ans": "B", "kp": "函数", "o": [ "5", "24", "14", "6" ], "explanation": "该函数通过递归实现列表元素求和。每次调用返回当前首元素与剩余子列表递归结果之和。当列表长度为1时触发基线条件返回该元素。执行过程为：1 + sum([2,3,8,10]) -> 1 + 2 + sum([3,8,10]) -> ... 最终累加所有元素 1+2+3+8+10，计算结果为24。" }, { "id": 1618, "q": "下列代码的运行结果是（ ）。\nfact=[lambda x=2:x*3,lambda x:x**2]\nprint(fact[1](fact[1](3)))", "t": "single", "ans": "B", "kp": "函数", "o": [ "12", "81", "36", "27" ], "explanation": "列表fact包含两个匿名函数，索引1对应lambda x:x**2（求平方）。表达式从内向外求值：内层fact[1](3)计算3的平方得9；外层将9作为参数传入，即fact[1](9)，计算9的平方得81。索引0的函数未被调用，其默认参数不影响结果。" }, { "id": 1619, "q": "以下程序运行后输出的结果是（ ）\ndef show(a,b,**args):\n      print(a,b,args)\nshow(10,20,m=50)", "t": "single", "ans": "C", "kp": "函数", "o": [ "10 20 50", "10 20 args=50", "10 20 {'m': 50}", "10 20 'm': 50" ], "explanation": "函数定义中**args用于接收任意数量的关键字参数，并将其打包为字典。调用时，10和20分别赋给位置参数a和b，而m=50作为关键字参数被**args捕获，生成字典{'m': 50}。print函数依次输出这三个变量的值，因此结果为10 20 {'m': 50}。" }, { "id": 1620, "q": "下面关于类的说法错误的是（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "类是一种实例", "在类进行实例化时会首先执行该类中的init方法", "在对类进行实例化时，传入的参数不用带上self，它在类执行过程中将自行带上", "类中的变量前带有前缀self意味着此变量在类中任意位置可以使用" ], "explanation": "类是创建对象的模板或蓝图，而实例是根据类创建的具体对象，两者概念不同，因此A选项说法错误。B选项中实例化时会自动调用初始化方法；C选项中self参数在调用时由解释器自动传入实例本身，无需手动传递；D选项中带self前缀的变量为实例属性，可在类的方法中广泛使用。" }, { "id": 1621, "q": "B类继承自A类，下列定义正确的是（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "class B（A）:", "class A（B）:", "class B->A:", "class A->B" ], "explanation": "在Python中，定义类并指定父类的语法为class 子类名(父类名):。因此B类继承A类的正确写法是class B(A):。选项B颠倒了父子类关系，选项C和D使用了类似其他语言的箭头继承符号，这在Python中是无效的语法。" }, { "id": 1622, "q": "编写程序，输入年份，判断当年的3月1日是当年的第几天？\nyear= 1 (input())\nif year%400==0 or (year%4==0 and year%100!=0):   #判断是否为闰年\n    day=31+29+1\nelse:\n     2  =31+28+1\nprint(day)", "t": "fill", "ans": "int | day", "kp": "程序填空/调试", "o": [], "explanation": "第1空：input()返回字符串，需转换为整数才能进行数学运算，故填int。第2空：根据上下文，else分支处理平年情况，需计算平年3月1日的天数并赋值给变量day，以保持与if分支变量名一致，确保后续print(day)正常输出，故填day。" }, { "id": 1623, "q": "执行下列程序后的输出结果是[*queNo*]______.\ni=-1\nwhile i<0:\n    i*=i\nprint(i)", "t": "fill", "ans": "1", "kp": "循环结构", "o": [], "explanation": "初始i为-1，满足i<0进入循环。执行i*=i即i=(-1)*(-1)=1。再次判断i<0不成立，退出循环。最终打印i的值为1。" }, { "id": 1624, "q": "下列Python程序的运行结果是[*queNo*]_。\na=40\nb=50\nif a", "", "", "" ], "explanation": "12.00是浮点数，type(12.00)的运行结果应为。但题目提供的选项内容均为空，无法对应正确答案，疑似需人工复核。" }, { "id": 1633, "q": "关于加、减、乘、除、乘方五种数字运算的描述，错误的选项是（）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "整数运算的结果可能是浮点数", "浮点数运算的结果仍然是浮点数", "整数运算的结果可能是整数", "浮点数类型运算的结果可能是整数" ], "explanation": "在Python中，浮点数参与算术运算的结果一定是浮点数类型，即使数值上等于整数（如2.0+1.0结果为3.0），其数据类型依然是float，不会自动转为整数。故D错误。" }, { "id": 1634, "q": "以下叙述中正确的是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "Python 3.x与Python 2.x兼容", "Python语句只能以程序方式执行", "Python是解释型语言", "Python语言出现得晚，具有其他高级语言的一切优点" ], "explanation": "Python是解释型语言，代码由解释器逐行翻译执行。A错误，Python 3不完全兼容Python 2；B错误，Python支持交互式执行；D错误，表述过于绝对。" }, { "id": 1635, "q": "以下是print(type(\"hello\"))的运行结果的是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "", "", "", "" ], "explanation": "type()函数用于返回对象的数据类型。字符串\"hello\"的类型是字符串，因此type(\"hello\")的返回结果为。本题选项内容缺失，根据答案C推测其对应正确结果。" }, { "id": 1636, "q": "下列选项中正确的赋值语句是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "x+y=5", "y=2x", "x=y=5", "0.5y=x" ], "explanation": "Python赋值语句中，等号左侧必须是合法的变量名，不能是表达式或以数字开头的标识符，且数学表达式中的乘号不能省略。选项C为连续赋值语句，将5同时赋给x和y，语法完全正确。" }, { "id": 1637, "q": "下面语句执行后的结果是（ ）\nprint(\"Lily\",'\"hello\"',sep=\":\")", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "Lily:\"hello\"", "Lily:hello", "Lily\n\"hello\"", "Lily:\n\"hello\"" ], "explanation": "print()函数中sep参数用于设置多个输出项之间的分隔符，本题设为冒号。第一个输出项是Lily，第二个输出项是带有双引号的字符串\"hello\"，两者用冒号连接，因此输出Lily:\"hello\"。" }, { "id": 1638, "q": "以下关于Python语句的叙述中，正确的是（ ）。", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "同一层次的Python语句必须对齐", "Python语句可以从一行的任意一列开始", "在执行Python语句时，可发现注释中的拼写错误", "Python程序的每行只能写一条语句" ], "explanation": "Python使用严格的缩进机制来划分代码块，同一逻辑层次的语句必须保持相同的缩进对齐。语句不能从任意列开始；注释内容不参与编译执行，不会检查拼写；单行内可通过分号分隔编写多条语句。" }, { "id": 1639, "q": "语句print('x=${:7.2f}'.format(123.5678))执行后的输出结果是（ ）。选项中的□代表空格。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "x=□123.56", "$□123.57", "x=$□123.57", "x=$□123.56" ], "explanation": "格式化字符串中{:7.2f}表示将浮点数格式化为总宽度7、保留2位小数。123.5678四舍五入为123.57，占6个字符宽度，因此左侧自动填充1个空格以满足总宽度7。结合前缀字符，最终输出x=$□123.57。" }, { "id": 1640, "q": "下列程序的运行时分别输入3和2，运行结果是（ ）\nx=int(input())\ny=int(input())\nprint(x+y)", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "5", "3", "2", "32" ], "explanation": "input()函数接收用户输入并返回字符串类型，通过int()函数将其转换为整数。程序分别接收3和2并转为整型，x+y执行的是整数加法运算而非字符串拼接，因此结果为5。" }, { "id": 1641, "q": "以下代码的输出结果是（）。\na,b,c=400,500,300\nif (a>b):\n   a=b\n   b=c\n   c=a\nelif a==b:\n   b=c\n   c=a\nelse:\n   c=a\nprint(a,b,c)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "400 500 300", "500 300 400", "400 500 400", "500 300 500" ], "explanation": "程序首先判断a>b即400>500，条件为假；接着判断a==b即400==500，条件也为假。因此程序执行else分支，将a的值400赋给c。最终a、b、c的值分别为400、500、400。" }, { "id": 1642, "q": "以下代码的输出结果是（）。\nn=50\ns=10\nif n>=5:\n   n-=10\n   s=s-40\nelse:\n   n-=10\n   s=s-30\nprint(s)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "30", "40", "-30", "-20" ], "explanation": "初始时n为50，s为10。判断条件n>=5即50>=5成立，进入if分支。执行n-=10后n变为40，执行s=s-40即10-40，s变为-30。最后打印s的值，输出-30。" }, { "id": 1643, "q": "设a=20，b=20,则表达式a-b==0的值为（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "False", "True", "F", "T" ], "explanation": "表达式a-b==0首先计算a-b，由于a和b均为20，相减结果为0。接着判断0==0，该关系表达式成立，返回布尔值True。注意Python中布尔值的首字母必须大写。" }, { "id": 1644, "q": "若输入x为50，输出的grade是（）\nx=int(input())\nif x>=60:\n   if x<=70:\n      grade='C'\n   else:\n      grade='B'\nelse:\n   grade='D'\nprint(grade)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "A", "B", "C", "D" ], "explanation": "程序接收输入x=50，首先判断外层条件x>=60，即50>=60，条件不成立。因此直接跳过内部的if-else嵌套结构，执行外层else分支，将字符'D'赋值给变量grade并输出。" }, { "id": 1645, "q": "判断ch是否为小写字母( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "ch>='a' and ch<='z'", "ch>='a' or ch<='z'", "ch>='a'", "ch<='z'" ], "explanation": "判断字符是否为小写字母，需要确保其ASCII码值同时满足大于等于'a'且小于等于'z'。在Python中，必须使用逻辑与运算符and来连接这两个条件，选项B的or会导致所有字符均被判定为真。" }, { "id": 1646, "q": "下列代码的输出结果是（ ）\nx=list()\ny=0\nif x:\n   y=1\nprint(y)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "0", "1", "没有输出", "出错" ], "explanation": "list()创建一个空列表赋值给x。在Python中，空列表的布尔值为False。因此if x:条件判断不成立，不会执行y=1，变量y保持初始值0。最后打印y，输出结果为0。" }, { "id": 1647, "q": "以下代码的输出结果是（ ）。\nsum=0\nfor s in range(1,7):\n    if s%2==0 :\n        sum=sum+s\nprint(sum)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "12", "10", "0", "6" ], "explanation": "range(1,7)生成1到6的整数。循环中判断s%2==0，即筛选出偶数2、4、6。将这些偶数累加到sum中，最终sum = 2 + 4 + 6 = 12。因此输出结果为12。" }, { "id": 1648, "q": "以下代码的输出结果是（）。\na,b,c=70,50,30\nwhile a>b>c:\n    if (a>b):\n        a=b\n        b=c\n        c=a\nprint(a,b,c)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "70 50 70", "50 30 70", "70 30 70", "50 30 50" ], "explanation": "初始a=70,b=50,c=30，满足a>b>c进入循环。执行a=b(50)，b=c(30)，c=a(此时a已变为50，故c=50)。第一轮结束后a=50,b=30,c=50。再次判断a>b>c即50>30>50不成立，退出循环。最终输出50 30 50。" }, { "id": 1649, "q": "以下程序段的运行结果是（ ）。\nsum=0\nfor i in range(6):\n    if i%2:\n        continue\n    sum=sum+1\nprint(sum)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "1", "2", "3", "4" ], "explanation": "range(6)生成0到5。当i为奇数(1,3,5)时，i%2为真，执行continue跳过本次循环；当i为偶数(0,2,4)时，i%2为假，执行sum=sum+1。偶数共有3个，因此sum最终累加3次，结果为3。" }, { "id": 1650, "q": "下面代码的输出结果是（）。\nfor i in \"Go ahead bravely!\":\n    if i==\"b\":\n        break\n    else:\n        print(i,end=\"\")", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "Go ahead ravely!", "bravely!", "Go ahead bravely!", "Go ahead" ], "explanation": "代码遍历字符串中的每个字符。当遇到字符'b'时，触发break语句直接跳出循环。因此只会打印'b'之前的所有字符，即'Go ahead '（包含空格）。选项D最符合输出结果。" }, { "id": 1651, "q": "下列for循环执行后，输出结果的最后一行是（）。\nfor i in range(1,3):\n    for j in range(2,5):\n        print(i*j)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "2", "6", "8", "15" ], "explanation": "外层循环i取1和2，内层循环j取2、3、4。当i=1时，依次输出2、3、4；当i=2时，依次输出4、6、8。循环的最后一行输出发生在i=2且j=4时，计算结果为2*4=8。" }, { "id": 1652, "q": "已知a=\"hello\"，b=\"hi\"，以下选项属于字符串运算会产生语法错误的是（）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "a+b", "a*2", "b is a", "a-b" ], "explanation": "字符串支持加法（拼接）和乘法（重复），也支持使用is进行身份比较（虽不推荐但不报语法错误）。但字符串不支持减法运算，执行a-b会引发TypeError异常。因此选项D会产生错误。" }, { "id": 1653, "q": "已知x=['a','b',0,1,2]，则all(x)的值是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "False", "True", "false", "true" ], "explanation": "all()函数用于判断可迭代对象中的所有元素是否都为True。列表x中包含整数0，在Python中0被视为False。因为存在False元素，all(x)的返回值为False。" }, { "id": 1654, "q": "以下代码的输出结果是：（ ）\nT=('2','3','a','b')\nsorted(T,reverse=True)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "('b', 'a', '3', '2')", "['b', 'a', '3', '2']", "('2', '3', 'a', 'b')", "['2', '3', 'a', 'b']" ], "explanation": "sorted()函数对可迭代对象进行排序，并始终返回一个新的列表，不会改变原元组。参数reverse=True表示降序排列。字符按ASCII码降序排列为'b', 'a', '3', '2'，故返回结果为列表['b', 'a', '3', '2']。" }, { "id": 1655, "q": "下列Python程序的运行结果是（ ）。\nlst=[8,2,4,15,21]\nlst.sort(reverse=True)\nprint(lst)", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[21, 15, 8, 4, 2]", "[2, 4, 8, 15, 21]", "[8, 2, 4, 15, 21]", "2, 4, 8, 15, 21" ], "explanation": "列表的sort()方法用于原地排序，reverse=True表示按降序排列。原列表[8,2,4,15,21]降序排序后变为[21, 15, 8, 4, 2]，并直接修改原列表，打印结果即为该降序列表。" }, { "id": 1656, "q": "假设有三个集合：A = {1, 2, 3, 4}，B = {3, 4, 5, 6}，C = {4, 5, 6, 7}，下面的表达式中result的结果是什么？\nresult = (A & B) | (B & C) | (C & A)\nresult.update({8, 9, 10})\nresult.difference_update({1, 2})", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{3, 4, 5, 6, 8, 9, 10}", "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}", "{4, 5, 6, 7, 8, 9, 10}", "{8, 9, 10}" ], "explanation": "A&B为{3,4}，B&C为{4,5,6}，C&A为{4}，三者取并集得到{3,4,5,6}。update({8,9,10})向集合添加元素，变为{3,4,5,6,8,9,10}。difference_update({1,2})尝试移除1和2，但集合中不存在，故集合不变。" }, { "id": 1657, "q": "Python语句print(type({1:1,2:2,3:3,4:4}))的输出结果是（ ）。", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "", "", "", "" ], "explanation": "{1:1,2:2,3:3,4:4}是字典的字面量表示法，type()函数会返回其数据类型，即。本题选项内容缺失，但根据答案B推测其对应字典类型的输出。" }, { "id": 1658, "q": "可以在函数体中调用自已本身的函数是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "匿名函数", "嵌套函数", "递归函数", "自定义函数" ], "explanation": "在函数体内部调用函数自身的编程技巧称为递归，实现这种调用的函数被称为递归函数。匿名函数是lambda，嵌套函数是函数内定义函数，自定义函数是普通函数。" }, { "id": 1659, "q": "在程序中，关于全局变量和局部变量，以下选项描述错误的是（ ）。", "t": "single", "ans": "B", "kp": "函数", "o": [ "程序中的变量包含两类：全局变量和局部变量", "全局变量与局部量不能重名", "局部变量只能在声明它的函数内部使用", "全局变量一般没有缩进" ], "explanation": "Python中全局变量和局部变量可以重名，当函数内部存在与全局变量同名的局部变量时，局部变量会屏蔽全局变量，因此B选项描述错误。其他选项均符合Python变量的作用域和定义规则。" }, { "id": 1660, "q": "以下说法错误的是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "用户自定义函数是不能直接运行，必须通过调用运行才能完成其功能。", "调用用户自定义函数与调用系统函数方式相同，凡是可以使用表达式的地方都可以出现函数的调用。", "python语言中，若函数体中无return语句，调用结束后会自动返回一个随机值。", "函数调用时是转去执行被调用函数中的语句，执行完毕后，回到函数的调用处，继续执行后面的语句。" ], "explanation": "在Python中，如果函数体中没有return语句，或者return后不带任何值，函数调用结束后会自动返回None，而不是随机值。因此C选项描述错误，其他选项均正确描述了函数的定义与调用机制。" }, { "id": 1661, "q": "如下所示程序片段中：\nclass Myclass:\n    __x=1\n    def __aa(self):\n        self.__x=10\n    def bb(self):\n        print(self.__x)\n其中，公有方法是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "__x", "__aa", "bb", "以上都不是" ], "explanation": "在Python类中，以双下划线\"__\"开头的属性或方法会被名称改写，视为私有成员，如__x和__aa。而不以双下划线开头的方法bb则是公有方法，可以在类的外部直接访问。因此bb是公有方法。" }, { "id": 1662, "q": "对象的特征称为（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "方法", "属性", "实例", "类" ], "explanation": "在面向对象编程中，对象的特征或状态被称为属性，而对象的行为或功能被称为方法。实例是类的具体化，类是对象的模板。因此描述对象特征的术语是属性。" }, { "id": 1663, "q": "对象根据所接收的消息而做出动作，同样的消息被不同的对象接收时可导致完全不同的行动，称之为（ ）。", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "对象的继承", "对象的多态性", "对象的封装", "对象的多样性" ], "explanation": "多态性是指同一个操作或消息作用于不同的对象时，可以产生不同的行为或结果。继承是子类获取父类特征，封装是隐藏内部实现细节。因此，同一消息导致不同行动的特性称为对象的多态性。" }, { "id": 1664, "q": "若文本文件abc．txt中的内容如下：abcdef,阅读下面的程序：\nfile = open(\"abc．txt\", \"r\")\ns = file.readline()\ns1 = list(s)\nprint(s1)\n上述程序执行的结果为（ ）。", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "['abcdef']", "['abcdef\\n']", "['a', 'b', 'c', 'd', 'e', 'f']", "['a', 'b', 'c', 'd', 'e', 'f', '\\n']" ], "explanation": "file.readline()用于读取文件的一行内容。由于文件内容为'abcdef'且未提及换行符，读取的字符串s为'abcdef'。list(s)会将字符串中的每个字符拆分为列表的独立元素，因此结果为['a', 'b', 'c', 'd', 'e', 'f']。" }, { "id": 1665, "q": "以下哪个方法可以判断文件指针是否已到达文件末尾？", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "read()", "write()", "seek()", "eof()" ], "explanation": "Python标准文件对象并没有提供eof()方法来判断文件末尾，通常通过read()返回空字符串来判断。但根据常见计算机基础考试题库的设定，eof()常被作为判断文件末尾的理论方法，故选D。本题在Python实际语法中存在瑕疵。" }, { "id": 1666, "q": "下列 Python 程序的运行结果是（ ）。 s1=set([1,2,2,3,3,3,4]) s2={1,2,5,6,4} print(s1&s2-s1.intersection(s2))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{1, 2, 4}", "set()", "[1,2,2,3,3,3,4]", "{1,2,5,6,4}" ], "explanation": "s1去重后为{1,2,3,4}。s1&s2求交集得到{1,2,4}，s1.intersection(s2)同样求交集得到{1,2,4}。由于集合的&运算符优先级高于-，表达式等价于(s1&s2) - s1.intersection(s2)，即{1,2,4}减去{1,2,4}，结果为空集合set()。" }, { "id": 1667, "q": "以下是求n！的程序，请填空。\nn=int(input())\nfact=1\nfor i in range(    1    ,n+1):\n                     fact=fact*    2     \nprint(fact)", "t": "fill", "ans": "1 | i", "kp": "循环结构", "o": [], "explanation": "计算n的阶乘需要从1乘到n。第1空控制循环起点，range应从1开始，故填1；第2空在循环体内累乘，每次将当前的循环变量i乘入fact中，故填i。两者结合即可正确计算阶乘。" }, { "id": 1668, "q": "以下程序的功能是：定义一个Person类，使用Person类，创建一个mayun对象后，添加company属性，值是\"阿里巴巴\"；创建一个wangjianlin对象，添加company属性，值是\"万达集团\"。请根据题目功能填空。\nclass Person(object):\n    pass\nmayan = Person()\nmayan.____1___ = \"阿里巴巴\"\nwangjianlin = ___2____()\nmayan.company = \"万达集团\"", "t": "fill", "ans": "company | Person", "kp": "面向对象", "o": [], "explanation": "第1空根据题意需为mayan对象添加company属性并赋值，故填company；第2空需创建wangjianlin对象，应通过调用Person类的构造函数来实例化，故填Person。注意题干代码最后一行存在将属性赋给mayan的笔误，但不影响填空逻辑。" }, { "id": 1669, "q": "以下while循环的循环次数是[*queNo*]____。\ni=0\ns=0\nwhile i<10:\n    s+=i\n    if i==5:break\n    i+=1", "t": "fill", "ans": "6", "kp": "循环结构", "o": [], "explanation": "初始i=0，每次循环先执行s+=i，然后判断i是否等于5。当i从0递增到4时，正常执行i+=1，共循环5次；当i=5时，满足i==5条件触发break跳出循环，这是第6次进入循环体。因此总循环次数为6次。" }, { "id": 1670, "q": "输入一个字符串，判断它是否是回文字符串。回文字符串是无论是从左读还是从右读都是一样的，如1234321就是一个回文字符串。请填空。\na=input('请输入一个字符串:')\nb=___1____\nif a==b:\n    print('%s是回文字符串'%a)\n___2____:\n    print('%s不是回文字符串'%a)", "t": "fill", "ans": "a[::-1] | else", "kp": "程序填空/调试", "o": [], "explanation": "第1空需要获取字符串a的逆序以判断回文，Python中通过切片a[::-1]可实现字符串反转；第2空与if语句配对，当a不等于b时执行不是回文的输出，故填else构成完整的条件分支结构。" }, { "id": 1671, "q": "程序填空题\ndef count_occurrences(numbers):\n\"\"\"\n统计列表中每个元素的出现次数，并返回一个字典。\n\"\"\"\n    occurrences = {}\n    for num in numbers:\n        if num in occurrences:\n            occurrences[[*queNo*]_] += [*queNo*]__\n        else:\n            occurrences[num] = 1\n    return occurrences\nnumbers = [1, 2, 3, 3, 4, 4, 5]\nresult = count_occurrences(numbers)\nprint(result)", "t": "fill", "ans": "num | 1", "kp": "字典/集合", "o": [], "explanation": "第1空填num，表示以当前遍历的元素作为字典的键；第2空填1，表示当键已存在时，将其对应的值累加1。结合else分支的初始赋值1，完整实现了统计频次的逻辑。" }, { "id": 1672, "q": "下函数的功能是求斐波那契数列第n项的值。斐波那契数列由0和1开始，后面的每一项数字都是前两项数字之和，用数学表达式如下：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）。请在括号（）中填入正确答案。\ndef F(n):\n    if n == 1 or n == 2:\n        return (__1__)\n    else:\n        return F(n-1) +(___2[*queNo*])\nprint(F(10))", "t": "fill", "ans": "1 | F(n-2)", "kp": "函数", "o": [], "explanation": "第1空填1，对应斐波那契数列前两项F(1)和F(2)的基准返回值；第2空填F(n-2)，根据递推公式F(n)=F(n-1)+F(n-2)，递归调用自身计算前第二项的值，两者相加即得第n项。" }, { "id": 1673, "q": "以下程序的输出结果是[*queNo*]__。\ndef func(n):\n   s=1\n   for i in range(1,n):\n       j=1\n       while j<6:\n           if i<2:\n               j=j+1\n           else:\n               s=s+i\n               j=j+1\n               break\n   return s;\nprint(func(5))", "t": "fill", "ans": "10", "kp": "程序填空/调试", "o": [], "explanation": "外层循环i从1到4。当i=1时，内层while循环因i<2执行j=j+1直到j=6退出，s不变仍为1。当i=2,3,4时，进入else分支，s累加i（即s=1+2+3+4=10），随后break跳出内层循环。最终返回10。" }, { "id": 1674, "q": "下面程序的输出是_____。\nclass Account:\n    def __init__(self,id):\n        self.id=id\n        id=1688\nacc=Account(100)\nprint(acc.id)", "t": "fill", "ans": "100", "kp": "面向对象", "o": [], "explanation": "在__init__方法中，self.id=id将传入的参数100绑定到实例属性self.id上。随后的id=1688仅修改了局部变量id的值，不影响实例属性。因此acc.id仍为初始化时传入的100。" }, { "id": 1675, "q": "考生文件夹下存在一个文件PY101.py，请写代码替换横线，不修改其他代码，实现以下功能：\n键盘输入正整数n，按要求把n输出到屏幕，格式要求：宽度为15个字符，数字右边对齐，不足部分用*填充。\n例如：键盘输入正整数n为1234，屏幕输出 ***********1234\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "n = eval(input(\"请输入正整数:\"))\nprint(\"{:*>15}\".format(n))", "kp": "基础语法与输入输出", "o": [], "rawType": "operation" }, { "id": 1676, "q": "下面代码的输出结果是（）。\nx=10\ny=-1+2j\nprint(x+y)", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "(9+2j)", "11", "2j", "9" ], "explanation": "Python支持整数与复数直接进行算术运算。x+y即10+(-1+2j)，实部相加得9，虚部保持2j，结果为复数(9+2j)。其他选项未正确执行复数加法或类型转换。" }, { "id": 1677, "q": "下面语句的执行结果，不可能的选项是（）\nimport random\nprint（random.uniform(1,3)）", "t": "single", "ans": "B", "kp": "random/turtle等标准库", "o": [ "2.764076933688729", "3.993002365820678", "2.5670577649215085", "1.807117374321477" ], "explanation": "random.uniform(a, b)返回[a, b]范围内的随机浮点数。本题范围为[1, 3]，选项B的值约为3.99，超出上限3，因此不可能出现。其余选项均在合法区间内。" }, { "id": 1678, "q": "以下代码的执行结果是（）。\nx=4＋3j\ny=-4-3j\nprint(x+y)", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "0j", "0", "", "无输出" ], "explanation": "复数相加时实部与虚部分别相加。4+(-4)=0，3j+(-3j)=0j。在Python中，纯虚数或零复数相加结果保留复数类型，故输出0j而非整数0。" }, { "id": 1679, "q": "执行语句x=float(input( ))，若输入123，那么 x 的类型是（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "整型", "字符串", "浮点型", "以上都错误" ], "explanation": "input()默认返回字符串，外层包裹的float()函数会将其强制转换为浮点数类型。因此输入123后，变量x的值为123.0，其数据类型为浮点型（float）。" }, { "id": 1680, "q": "以下代码的输出结果是（）。\ni=450\nj=450\nk=380\nif(i<=k):\n   print(i)\nelif(i==j):\n   print(j)\nelse:\n   print(k)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "380", "1000", "450", "以上结果都不对" ], "explanation": "首先判断i<=k（450<=380）为假，跳过。接着判断elif i==j（450==450）为真，执行print(j)输出450。分支结构一旦匹配成功即结束，不会执行else。" }, { "id": 1681, "q": "给出下面代码，程序运行结果为（ ）。\nx,y=30,70\nif x:\n    min=x\nprint(min)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "30", "70", "0", "报错" ], "explanation": "在Python中，非零数值在布尔上下文中视为True。if x:条件成立，执行min=x将30赋值给变量min。随后打印min，输出结果为30。" }, { "id": 1682, "q": "以下程序段的功能是（ ）。\na,b=eval(input(\"请输入两个整数:\"))\nif a>b:\n    a,b=b,a\nfor i in range(a,0,-1):\n    if a%i==0 and b%i==0:\n        print(\"gcd=\",i)\nbreak", "t": "single", "ans": "A", "kp": "算法与综合应用", "o": [ "求a,b的最大公约数", "求a,b的最小公倍数", "求a,b的最小值", "求a,b的最大值" ], "explanation": "程序先确保a为较小值，随后从a开始递减遍历。第一个能同时整除a和b的数即为两者的最大公约数，找到后立即break输出。该逻辑是典型的穷举法求最大公约数。" }, { "id": 1683, "q": "如果需要将字符进行替换，需要使用的方法是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "find", "rfind", "replace", "strip" ], "explanation": "Python字符串的replace(old, new)方法用于将字符串中的指定子串替换为新子串。find和rfind用于查找索引，strip用于去除首尾空白字符，均不具备替换功能。" }, { "id": 1684, "q": "下列Python程序的运行结果是（ ）。\ns=[1,2,3,4]\ns.append([5,6])\nprint(len(s))", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "2", "4", "5", "6" ], "explanation": "append()方法将参数作为一个整体添加到列表末尾。原列表有4个元素，添加[5,6]后，列表变为[1, 2, 3, 4, [5, 6]]，包含5个元素，因此len(s)为5。若用extend()则长度为6。" }, { "id": 1685, "q": "以下代码的输出是什么？\nd = {'a': 1, 'b': 2, 'c': 3}\ndel d['b']\nprint(d)", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "{'a': 1, 'b': 2}", "{'a': 1, 'c': 3}", "{'b': 2, 'c': 3}", "KeyError" ], "explanation": "字典d初始包含三个键值对。del d['b']语句删除了键为'b'的键值对。因此打印字典时，只剩下'a'和'c'对应的键值对，输出{'a': 1, 'c': 3}。" }, { "id": 1686, "q": "如下所示程序片段中：\nclass Myclass:\n    x=30\n    def __init__(self):\n        __x=1\n        self.__x=3\n其中，类属性是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "self.x", "x", "__x", "self.__x" ], "explanation": "在类定义中，直接定义在类体中且不在任何方法内的变量是类属性。x=30是类属性；__x=1是__init__方法内的局部变量；self.__x=3是实例属性。因此类属性是x。" }, { "id": 1687, "q": "以下__________不是面向对象程序设计的基本特征之一。", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "继承", "多态", "抽象", "封装" ], "explanation": "面向对象程序设计的三大基本特征是封装、继承和多态。抽象虽然也是面向对象设计中的重要概念，但通常不被列为三大基本特征之一。" }, { "id": 1688, "q": "哪个选项对turtle.done()的描述是正确的？（ ）", "t": "single", "ans": "A", "kp": "random/turtle等标准库", "o": [ "turtle.done()用来停止画笔绘制，但绘图窗体不关闭", "turtle.done()放在代码最后，是turtle绘图的必要要求，表示绘制完成", "turtle.done()用来暂停画笔绘制，用户响应后还可以继续绘制", "turtle.done()用来隐藏turtle绘制画笔，一般放在代码最后" ], "explanation": "turtle.done()用于在绘图结束后保持窗口打开状态，即停止画笔绘制但绘图窗体不关闭，以便用户查看结果。它不是暂停，也不是隐藏画笔。" }, { "id": 1689, "q": "以下关于Python文件打开模式的描述中，错误的是（ ）。", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "只读模式r", "覆盖写模式w", "追加写模式a", "创建写模式n" ], "explanation": "Python文件打开模式中，r为只读，w为覆盖写，a为追加写。不存在n（创建写）模式，创建新文件通常使用w或x（排他性创建）模式。因此D选项描述错误。" }, { "id": 1690, "q": "在Python中，实现数据输出功能的函数是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "printf()", "print()", "format()", "input()" ], "explanation": "在Python中，print()函数用于将数据输出到标准输出设备（如屏幕）。input()用于输入，format()用于字符串格式化，Python没有内置的printf()函数。" }, { "id": 1691, "q": "以下可以替代#用来当作Python语言注释的语法元素是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "字符串类型", "print()函数", "input()函数", "eval()函数" ], "explanation": "Python中单行注释使用#，而多行注释通常使用三引号括起来的字符串类型来实现。当多行字符串不被赋值给变量时，解释器会将其忽略，从而起到注释的作用。" }, { "id": 1692, "q": "下列代码的输出结果是（）\na=18\nb=6\nif(a//b):\n   r=a%b\nelif a:\n   r=a/b\nelse:\n   r=1\nprint(r)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "0", "1", "3", "出错" ], "explanation": "a//b即18//6结果为3，在if条件中视为True，因此执行r=a%b。18%6的结果为0，故r被赋值为0。后续elif和else分支不再执行，最终打印0。" }, { "id": 1693, "q": "以下关于字符串类型的操作的描述，错误的是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "str.split(x,y)方法把字符串str根据x分割出y块", "想把一个字符串str所有的字符都大写，用str.upper()", "想获取字符串str的长度，用字符串处理函数str.len()", "设x='aa'，则执行x*3的结果是'aaaaaa'" ], "explanation": "获取字符串长度应使用内置函数len(str)，而不是字符串的方法str.len()。split()用于分割，upper()用于转大写，字符串乘以整数表示重复拼接，A、B、D描述均正确。" }, { "id": 1694, "q": "s=\"abcd'12'34\"，下面（）可以输出字符'12'34。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "s[5:8]", "s[4:8]", "s[-1:-6]", "s[-6:]" ], "explanation": "字符串s长度为10。要截取'12'34（共6个字符），可从倒数第6个字符截取到末尾。正数索引为s[4:10]或s[4:]，负数索引为s[-6:]。选项D符合。" }, { "id": 1695, "q": "以下关于序列的描述中，错误的是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "列表和元组是由任意类型数据组成的序列", "Python中的字符串、列表和元组数据类型均属于序列类型", "列表的元素类型必须相同", "可以使用下标索引来访问元组中的值" ], "explanation": "Python中的列表是动态数组，其元素可以是任意数据类型，不要求类型必须相同，如[1, 'a', [2, 3]]是合法的。字符串、列表和元组均属序列，可通过下标访问。" }, { "id": 1696, "q": "下列代码运行后的结果是（ ）。\ndef fact(s):\n    if len(s) == 1:\n        return s[0]\n    else:\n        return s[0] - fact(s[1:])\nprint(fact([1,3,6,2]))", "t": "single", "ans": "B", "kp": "函数", "o": [ "-11", "2", "0", "-2" ], "explanation": "递归函数fact计算过程：fact([2])返回2；fact([6,2])返回6-2=4；fact([3,6,2])返回3-4=-1；fact([1,3,6,2])返回1-(-1)=2。最终输出2。" }, { "id": 1697, "q": "下列程序的运行结果是（ ）。\nadd=lambda x,y,z=12:y**x+z//x\nh=add(x=4,y=2,z=6)\nprint(h)", "t": "single", "ans": "D", "kp": "函数", "o": [ "19", "19.0", "17.0", "17" ], "explanation": "lambda函数中，x=4，y=2，z=6。计算y**x即2的4次方为16，z//x即6整除4为1。两者相加16+1=17，结果为整型17。" }, { "id": 1698, "q": "以下程序运行后输出的结果是（ ）\ndef swap(x,y):\n    temp=x\n    x=y\n    y=temp\n    print('x={},y={}'.format(x,y))\na=3\nb=4\nswap(a,b)\nprint('a={},b={}'.format(a,b))", "t": "single", "ans": "A", "kp": "函数", "o": [ "x=4,y=3\na=3,b=4", "x=4,y=3\na=4,b=3", "x=3,y=4\na=4,b=3", "x=3,y=4\na=3,b=4" ], "explanation": "函数内交换了局部变量x和y并打印。由于整数是不可变对象，参数传递不会改变外部变量a和b的值，因此外部打印a和b仍为原值3和4。" }, { "id": 1699, "q": "下面哪个方法在释放类的实例的时候会自动执行？（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "__del__", "__init__", "__state__", "__str__" ], "explanation": "__del__是析构方法，在对象被垃圾回收释放内存时自动执行。__init__是构造方法，__str__用于定义对象的字符串表示形式。" }, { "id": 1700, "q": "以下程序的输出结果是（）\nclass A:\n  def __init__(self,name):\n    self.name=name\n  def show(self):\n    print(\"A类：\",self.name)\nclass B(A):\n  def show(self):\n    print(\"B类：\",self.name)\na=A(\"4\")\nb=B(\"5\")\na.show()", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "A类：4", "B类：5", "B类：4", "A类：5" ], "explanation": "变量a是类A的实例，调用a.show()会执行类A中定义的show方法，打印A类和实例属性name的值4。子类B的重写不影响父类实例。" }, { "id": 1701, "q": "以下哪一项描述了将一段数据写入文件时发生的情况？（）", "t": "single", "ans": "A", "kp": "文件操作", "o": [ "数据从内存中的变量拷到文件", "数据从程序中的变量拷到文件", "数据从程序拷到文件", "数据从文件对象拷到文件" ], "explanation": "文件写入操作本质上是将程序运行时存储在内存中的变量数据，通过操作系统接口持久化保存并拷贝到磁盘文件中。" }, { "id": 1702, "q": "下面代码中，myfile.data文件的目录是（ ）。\nfile=open(\"myfile.data\",\"ab\")", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "C盘根目录下", "由path路径指明", "Python安装目录下", "与程序文件在相同的目录下" ], "explanation": "使用相对路径打开文件时，默认路径为当前工作目录，通常即为运行该Python程序文件所在的相同目录。" }, { "id": 1703, "q": "下列 Python 程序的运行结果是（ ）。\ns1=set([1,4,4,2,2,7])\ns2={3,4,7,6}\nprint(s1&s2-s1.difference(s2))", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{4,7}", "{1，2，7，8}", "{0, 1, 2, 3, 7, 8}", "{1，3， 5，8}" ], "explanation": "s1去重为{1,2,4,7}。运算符-优先级高于&，先算s2减去s1的差集{1,2}得{3,4,6,7}，再与s1求交集，最终结果为{4,7}。" }, { "id": 1704, "q": "下列程序的输出结果是（ ）。\ns=1\nfor i in range(1,6):\n    while True:\n        if i%2==0:\n            s= s*i*i\n            break\n        else:\n            break\nprint(s)", "t": "fill", "ans": "64", "kp": "循环结构", "o": [], "explanation": "循环i从1到5。当i为奇数时直接break；当i为偶数时，s累乘i的平方并break。i=2时s=1*4=4；i=4时s=4*16=64。最终输出64。" }, { "id": 1705, "q": "以下程序的运行结果是[*queNo*]_______。\nlist1=[1,2,3,4,5,6,7,8]\nlist2=list1[1::2]\nlist2.sort(reverse=True)\nlist1[1::2]=list2\nprint(list1)", "t": "fill", "ans": "[1, 8, 3, 6, 5, 4, 7, 2]", "kp": "列表/元组", "o": [], "explanation": "list1[1::2]提取索引为奇数的元素[2,4,6,8]；降序排序后为[8,6,4,2]；再通过切片赋值替换回原列表的奇数索引位置，得到最终列表。" }, { "id": 1706, "q": "有代码如下：f=open(\"d:\\\\a1.txt\",\"[*queNo*]\")；打开文件a1.txt后，需要往文件中只写不读（保留原有文件的数据），则横线处应填_______。", "t": "fill", "ans": "a", "kp": "文件操作", "o": [], "explanation": "文件打开模式a表示追加模式，允许只写不读，且保留文件原有数据，新写入的数据会追加到文件末尾。若用w则会清空原文件。" }, { "id": 1707, "q": "使用turtle库的turtle.fd()函数和turtle.left()函数绘制一个边长为200像素的正方形及一个紧挨四个顶点的圆形，在考生目录下给出了程序框架文件PY201.py，在横线处补充代码，不得修改其它代码。效果如下图所示。\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "import turtle\nturtle.pensize(2)\nfor i in range(4):\nturtle.fd(200)\nturtle.left(90) #正方形画完时画笔所处角度\nturtle.left(-45)#向左旋转-45度，设置圆的起始角度\nturtle.circle(100*pow(2,0.5))#利用a平方+b平方等于c平方求半径", "kp": "random/turtle等标准库", "o": [], "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-turtle-square-circle-1707.png", "rawType": "operation" }, { "id": 1708, "q": "以下程序的输出结果是（ ）\ns=0\ndef fun(x):\n    t=x\n    t=t+x\n    return t\nfor i in range(0,6):\n    s+=fun(i)\nprint(s)", "t": "fill", "ans": "30", "kp": "函数", "o": [], "explanation": "函数fun(x)中t=x，t=t+x即返回2*x。循环i从0到5，s累加fun(i)的返回值，即计算2*(0+1+2+3+4+5)=2*15=30。" }, { "id": 1709, "q": "下列Python程序的运行结果是[*queNo*]_。\ni=3000\nj=400\nk=5000\nif(i", "exam" ], "explanation": "open()函数返回一个文件对象，直接打印该对象会输出其类型、文件名、模式等属性信息，而不是文件内容。选项C内容可能因尖括号被过滤而显示为空，通常代表文件对象字符串。" }, { "id": 1719, "q": "下列 Python 程序的运行结果是（ ）\nmy_dict = {\"name\": \"Tom\", \"age\": 18, \"gender\": \"male\"}\nmy_dict.clear()\nprint(\"字典：\", my_dict)", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "'name': 'Tom', 'age': 18, 'gender': 'male'", "字典： {}", "'Tom','18','male'", "无法确定" ], "explanation": "字典的clear()方法用于清空字典中的所有键值对。执行该方法后，my_dict变为空字典。print函数输出字符串和空字典的表示形式，因此结果为\"字典： {}\"。" }, { "id": 1720, "q": "关于Python中的复数，下列说法错误的是（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "实部和虚部都是浮点数", "虚部必须有后缀j,且必须是小写", "表示复数的语法是real+imagj", "complex(x)返回以x为实部，虚部为0的复数" ], "explanation": "Python中复数的虚部后缀可以使用小写字母j，也可以使用大写字母J，因此\"必须是小写\"的说法错误。其他选项关于复数属性、语法及complex()函数的描述均正确。" }, { "id": 1721, "q": "表达式len('a\\b\\c\\d')的值为（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "6", "5", "7", "4" ], "explanation": "字符串中\\b是转义字符（退格），占1个字符；\\c和\\d不是有效转义字符，保留反斜杠和字母，各占2个字符；加上字母a占1个字符，总长度为1+1+2+2=6。" }, { "id": 1722, "q": "下列程序的运行结果是（ ）\nx=y=10\nx/=x*y\nprint(x)", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "10", "100", "0.1", "0.01" ], "explanation": "首先x和y均赋值为10。执行x/=x*y时，先计算右侧x*y得到100，然后执行x = x / 100。在Python 3中，/是真除法，结果为浮点数0.1。" }, { "id": 1723, "q": "下列程序的输出结果( )。\nx=0\ny=50\nm=80\nm=max(x,y)\nprint(\"最大值是%d\"%m)", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "最大值是50", "最大值是m", "最大值是0", "最大值是80" ], "explanation": "max(x, y)函数返回x和y中的最大值，即50，并将其赋值给m，覆盖了原来的80。格式化字符串%d将整数m替换到字符串中，最终输出\"最大值是50\"。" }, { "id": 1724, "q": "语句a=input()执行时，若从键盘输入3.5并按回车键，则a的值是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "3.5", "3", "'3.5'", "3.0" ], "explanation": "Python中的input()函数接收用户从键盘输入的内容，并统一将其作为字符串类型返回。因此输入3.5后，变量a的值是字符串'3.5'，而不是浮点数。" }, { "id": 1725, "q": "运行以下程序，显示的运行结果是（ ）\na=3\nb=4\nif(a+b<8):\n    print(a)\nelse:\n    print(b)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "6", "5", "4", "3" ], "explanation": "程序首先计算条件表达式a+b<8，因为3+4等于7，7小于8条件为真，所以执行if分支下的语句print(a)，输出变量a的值3。" }, { "id": 1726, "q": "设x=6,则表达式x/2==x//2的值为（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "x/2为真除法，结果是浮点数3.0；x//2为地板除，结果是整数3。在Python中，浮点数3.0和整数3在值上是相等的，因此==比较结果为True。" }, { "id": 1727, "q": "if语句实现单分支选择结构，其一般格式为：( )", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "if 表达式:\n语句块", "if 表达式\n语句块", "if （表达式:）\n语句块", "if （表达式: 语句块）" ], "explanation": "Python中if单分支选择结构的标准语法格式为if 表达式:后跟缩进的语句块。冒号是语法必需部分，且不需要像C语言那样使用括号将表达式括起来。" }, { "id": 1728, "q": "以下程序执行后描述正确的是( )。\nn=2\nwhile n<10:\n    if n<3:\n         continue\n    if n==5:\n        break\n    n=n+1\nprint(\"%d\"%(n))", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "n=10", "n=9", "n=5", "死循环" ], "explanation": "初始n=2，满足n<10进入循环。由于n<3成立，执行continue跳过本次循环剩余代码（包括n=n+1），直接进入下一次循环判断。此时n仍为2，导致条件永远成立，形成死循环。" }, { "id": 1729, "q": "在Python语言中，使用for…in…方式形成的循环不能遍历的类型是（　　）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "列表", "复数", "字符串", "字典" ], "explanation": "Python中的for...in...循环用于遍历可迭代对象，如列表、字符串、字典、元组等。复数（complex）是基本数值类型，不属于可迭代对象，因此不能被遍历。" }, { "id": 1730, "q": "Python解释器执行'*'.join('abcd')的结果是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "'a*b*c*d'", "'*abcd'", "'abcd*'", "'abcd'" ], "explanation": "join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串。这里以'*'为分隔符，连接字符串'abcd'中的每一个字符，结果为'a*b*c*d'。" }, { "id": 1731, "q": "以下代码的输出结果是：（ ）\nx=range(5)\nfor k in reversed(x):\n     print(k,end='')", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "01234", "12345", "54321", "43210" ], "explanation": "range(5)生成0到4的整数序列。reversed()函数将其反转，得到4、3、2、1、0的顺序。循环中print(k, end='')不换行输出，最终结果为43210。" }, { "id": 1732, "q": "对于元组T=('abc',2,[1,2,3],'hello')，T[-2][0]的值是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "1", "2", "[1, 2, 3]", "'hello'" ], "explanation": "元组T的倒数第二个元素（索引-2）是列表[1, 2, 3]。接着对该列表使用索引[0]获取其第一个元素，即整数1。" }, { "id": 1733, "q": "请给出下面代码段的正确答案（）\nA = {1, 3, 5,'a','b','c'}\nA.pop()\nprint(len(A))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "4", "5", "6", "7" ], "explanation": "集合A初始包含6个元素。pop()方法会随机移除并返回集合中的一个元素，执行后集合元素个数减1，变为5。因此len(A)输出5。干扰项C为初始长度，未考虑pop()的删除效果。" }, { "id": 1734, "q": "函数定义的第一行以（ ）结束", "t": "single", "ans": "C", "kp": "函数", "o": [ "分号", "逗号", "冒号", "句号" ], "explanation": "Python语法规定，使用def关键字定义函数时，函数声明行（包含函数名和参数列表）末尾必须使用冒号（:）表示代码块的开始，后续缩进代码属于函数体。分号、逗号、句号均不符合Python语法规范。" }, { "id": 1735, "q": "下列代码运行后的结果是（ ）。\ndef fact(s):\n    if len(s) == 1:\n        return s[0]\n    else:\n        return s[0] * fact(s[1:])\nprint(fact([1,2,3,1,2]))", "t": "single", "ans": "C", "kp": "函数", "o": [ "6", "8", "12", "1" ], "explanation": "该函数为递归实现列表元素连乘。基线条件为列表长度为1时返回该元素。递归过程为s[0] * fact(s[1:])，即依次取出首元素与剩余列表的乘积相乘。计算1*2*3*1*2结果为12。干扰项未正确执行连乘逻辑。" }, { "id": 1736, "q": "以下程序代码的运行结果正确的是（ ）。\nw=1\ndef wen():\n    global w\n    w = 22\ndef print_wen():\n    print(w)\nif __name__==\"__main__\":\n    wen()\n    print_wen()", "t": "single", "ans": "D", "kp": "函数", "o": [ "1", "1,22", "22,1", "22" ], "explanation": "全局变量w初始为1。调用wen()时，global w声明使其修改全局变量，w变为22。随后调用print_wen()，函数内部未定义局部变量w，故读取全局变量w的值并打印，输出22。程序仅执行一次打印，故结果为22。" }, { "id": 1737, "q": "下列程序的运行结果是（ ）。\ndef f(x=3,y=0):\n     return x+y\ny=f(y=f(),x=5)\nprint(y)", "t": "single", "ans": "D", "kp": "函数", "o": [ "5", "6", "7", "8" ], "explanation": "内层调用f()使用默认参数x=3, y=0，返回3+0=3。外层调用等价于f(x=5, y=3)，参数按关键字传递，返回5+3=8。最终y被赋值为8并打印。干扰项未正确区分默认参数与关键字传参的求值顺序。" }, { "id": 1738, "q": "下列哪个选项不能改变turtle画笔的运行方向？（ ）", "t": "single", "ans": "C", "kp": "random/turtle等标准库", "o": [ "turtle.right()", "turtle.seth()", "turtle.fd()", "turtle.left()" ], "explanation": "turtle.right()、turtle.left()和turtle.seth()均用于设置或旋转画笔朝向。turtle.fd()（forward）仅控制画笔沿当前方向前进指定距离，不改变运行方向。因此选C。" }, { "id": 1739, "q": "以下程序的功能是计算s=1+11+111+1111+11111。请填空。\nt,s=0,0\nfor i in range(5):\n    t=10*t+     1      \n    s=s+__2__\nprint(\"s=\",s)", "t": "fill", "ans": "1 | t", "kp": "程序填空/调试", "o": [], "explanation": "第1空填1，配合t=10*t+1实现每次循环将上一项乘10加1，依次生成1、11、111等数值。第2空填t，将当前生成的项累加到变量s中，最终实现数列求和。两空共同完成递推生成与累加逻辑。" }, { "id": 1740, "q": "有以下程序，请写代码替换横线，不修改其他代码，实现以下功能。\n定义一个Person类，实现如下功能：\n1） 使用构造函数初始化一个人的属性包括姓名（name），年龄（age）和人物标签（tag）。\n2） 定义个introduce()函数，实现输出人物信息的功能。\n3） 定义一个modif_tag()函数，实现修改人物标签（tag）的功能。\n4） 实例化Person类为person1，并输出person1的个人信息。\n运行结果如图7.9所示。\n图7.9 运行结果\n程序代码如下：\n#请在[*queNo*]处使用一行代码或表达式替换\n#注意不要修改其他代码\nclass Person():\n    def __init__(self,name,age,tag): #类的构造函数，即类的初始化\n        self.name = name\n        self.age = age\n        self.tag = tag\n    def introduce(self): #类的方法\n        print(\"name is:%s\\n age is: %s\\n tag is:%s\"%(___1___,self.age,self.tag))\n    def modif_tag(self,newtag):\n        _____2____=newtag #修改初始化的参数ag\nperson1=Person(\"罗翔\",\"50\",\"教师\")\nprint(person1.introduce())\nperson1.modif_tag(\"守法公民\")\nperson1.introduce()", "t": "fill", "ans": "self.name | self.tag", "kp": "程序填空/调试", "o": [], "explanation": "第1空位于字符串格式化中，需传入实例属性self.name以正确输出姓名。第2空用于修改实例的人物标签属性，应赋值为self.tag，使newtag更新到当前对象的状态中。两空均考查类实例属性的访问与修改语法。", "image": "https://tk.20070729.xyz/shuati/images/redrawn/python-output-person-1740.png" }, { "id": 1741, "q": "下面程序的执行结果是[*queNo*]________。\nd1={1:'水果'}\nd2={1:'蔬菜',2:'饮料'}\nd1.update(d2)\nprint(d1[1])", "t": "fill", "ans": "蔬菜", "kp": "字典/集合", "o": [], "explanation": "update()方法将字典d2的键值对更新到d1中。当键冲突时，后者的值会覆盖前者。此处键1在d2中对应值为\"蔬菜\"，覆盖d1原有的\"水果\"，故d1[1]输出\"蔬菜\"。" }, { "id": 1742, "q": "以下add函数的功能是：求  数列的和，请在括号（）中填入正确答案。\ndef add(n):\n    （ ___1___）\n    for i in range(1,n+1):\n        s=s+1/(2*i-1)\n       \n    (___2___) s\nn=int(input(\"请输入n值：\"))\nprint (add(n))", "t": "fill", "ans": "s=0 | return", "kp": "函数", "o": [], "explanation": "第1空需初始化累加变量s=0，否则循环中s=s+...会引发未定义变量错误。第2空需使用return关键字将计算结果s返回给调用者，否则函数默认返回None。两空分别完成变量初始化与结果返回。" }, { "id": 1743, "q": "以下程序的输出结果是（）。\nt = \"Python\"\nif t>=\"python\":\n      t = \"python\"\nelse:\n      t = \"None\"\nprint(t)", "t": "fill", "ans": "None", "kp": "分支结构", "o": [], "explanation": "字符串比较按ASCII码逐字符进行。大写字母'P'的ASCII码小于小写字母'p'，故条件t>=\"python\"为假，执行else分支将t赋值为字符串\"None\"，最终打印输出None。考查字符串大小写比较规则。" }, { "id": 1744, "q": "在考生文件夹下存在一个Python源文件PY102.py，请编写代码替换横线，不修改其他代码，实现下面功能：\n获得用户输入的5个小写英文字母，将小写字母变成大写字母，并逆序输出，字母之间用逗号分隔。\n示例如下（其中数据仅用于示意）：\n输入：\ngbcde\n输出：\nE,D,C,B,G\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试及验证程序。", "t": "fill", "ans": "s = input(\"请输入5个小写字母：\")\nls=s.upper()[-1::-1]\nprint(','.join(ls))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1745, "q": "类对象拥有的属性，称为（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "私有属性", "公有属性", "类属性", "类特征" ], "explanation": "在Python中，直接定义在类体中、不属于任何实例方法的属性称为类属性，被该类的所有实例对象共享。私有/公有属性通常指实例属性的访问权限控制，类特征非标准术语。故正确答案为类属性。" }, { "id": 1746, "q": "对于字典D={'a':10,'b':20,'c':30,'d':40}，len（D）的是（ ）", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "4", "8", "10", "12" ], "explanation": "字典的len()函数返回字典中键值对的数量。该字典包含'a'、'b'、'c'、'd'共4个键，因此长度为4。" }, { "id": 1747, "q": "关于Python的复数类型，以下选项中描述错误的是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "对于复数z,可以用z.imag 获得它的实数部分", "复数类型表示数学中的复数", "复数的虚数部分通过后缀\"J\"或者\"j\"来表示", "对于复数z，可以用z.real获得它的实数部分" ], "explanation": "Python中复数z的实部通过z.real获取，虚部通过z.imag获取。选项A称z.imag获取实数部分是错误的，符合题意。" }, { "id": 1748, "q": "Python文件的后缀名是（ ）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "pdf", "pyt", "pass", "py" ], "explanation": "Python源代码文件的标准扩展名是.py。pdf是文档格式，pyt和pass不是Python文件后缀。" }, { "id": 1749, "q": "以下程序的输出结果是（ ）\nq = 123.456\nprint(\"{0:->9.1f}\".format(q))", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "123.5", "123.456", "--123.5--", "----123.5" ], "explanation": "格式化字符串中，.1f表示保留1位小数，123.456四舍五入为123.5（占5个字符）；9表示总宽度为9，->表示右对齐并用-填充左侧。因此左侧填充4个-，结果为----123.5。" }, { "id": 1750, "q": "Python中标准输入函数是（）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "scanf()", "print()", "input()", "cin()" ], "explanation": "Python中用于从标准输入读取用户输入的内置函数是input()。scanf()属于C语言，print()用于输出，cin()属于C++。" }, { "id": 1751, "q": "以下代码的输出结果是（ ）。\nage=18\nif 12<=age<=17:\n    print(\"中学生\")\nelif age<=12:\n    print(\"小学生\")\nelif age<=20:\n    print(\"大学生\")\nelse:\n    print(\"是学生吗\")", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "中学生", "小学生", "大学生", "是学生吗" ], "explanation": "变量age为18。第一个条件12<=18<=17不成立；第二个条件18<=12不成立；第三个条件18<=20成立，因此执行对应的print输出大学生并结束分支。" }, { "id": 1752, "q": "以下代码的输出结果是（ ）。\nx=2\ny=2\nif x==y:\n    print(\"equal\")\nelse:\n    print(\"not equal\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "equal", "not equal", "运行异常", "以上结果都不对" ], "explanation": "变量x和y均被赋值为2。条件判断x==y成立，即2等于2，因此执行if分支下的代码，输出equal。" }, { "id": 1753, "q": "下列表达式的值为True的是（ ）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "3!=5 or 0", "4>3>3", "5*6>6**2", "2 and 4==1" ], "explanation": "A选项3!=5为True，True or 0结果为True；B选项4>3>3等价于4>3且3>3，为False；C选项30>36为False；D选项2 and 4==1即2 and False，为False。" }, { "id": 1754, "q": "判断年份year是否为闰年( )", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "(year%4==0 and year%100!=0) or year%400==0", "(year%4==0 and year%100!=0)", "year%400==0", "(year%4==0 and year%100!=0) and year%400==0" ], "explanation": "闰年的判断规则是：能被4整除且不能被100整除，或者能被400整除。选项A的逻辑表达式完美契合该规则，其他选项均遗漏了部分条件。" }, { "id": 1755, "q": "以下代码绘制的图形是（　　）。\nimport turtle as t\nfor i in range(1,7):\n    t.fd(50)\n    t.left(60)", "t": "single", "ans": "B", "kp": "random/turtle等标准库", "o": [ "正方形", "六边形", "三角形", "五角星" ], "explanation": "代码循环6次，每次海龟前进50像素并向左转60度。由于360除以60等于6，海龟刚好走完一个闭合的正六边形。" }, { "id": 1756, "q": "表达式2*[1,2,3,4]的值是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[1, 2, 3, 4, 1, 2, 3, 4]", "[2, 4, 6, 8]", "[1, 2, 3, 4 ]", "[1,2,3,4], [1,2,3,4]" ], "explanation": "在Python中，整数与列表相乘表示将列表中的元素重复指定次数。2与列表相乘会将原列表重复2次，生成包含8个元素的新列表。" }, { "id": 1757, "q": "对于字典D={'A':10,'B':20,'C':30,'D':40}，len（D）的是（ ）。", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "4", "8", "10", "12" ], "explanation": "len()函数用于返回字典中键值对的个数。字典D中包含A、B、C、D这4个键值对，因此len(D)的值为4。" }, { "id": 1758, "q": ".以下程序代码的运行结果正确的是（ ）。\nx=90\ndef wen():\n    x=100\ndef print_wen():\n    print(x)\n   \nif __name__==\"__main__\":\n    wen()\n    print_wen()", "t": "single", "ans": "C", "kp": "函数", "o": [ "100,90", "90,100", "90", "100" ], "explanation": "wen()函数内部定义了局部变量x=100，并未修改全局变量x。print_wen()函数打印的是全局变量x，其值仍为初始的90。因此程序最终输出结果为90。" }, { "id": 1759, "q": "对象的操作过程称为（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "方法", "行为", "模块", "实例" ], "explanation": "在面向对象编程中，对象的状态由属性来表示，而对象的操作过程或行为功能则由方法来定义和实现。因此，对象的操作过程被称为方法。" }, { "id": 1760, "q": "下面关于Python中类的继承，说法错误的是（）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "创建子类时，父类必须包含在当前文件夹且位于子类的前面", "定义子类时，必须在括号内指明子类所要继承的父类的名称", "如果调用的是继承的父类中的公有方法，可以在这个公有方法中访问父类中的私有属性和私有方法", "如果在子类中实现了一个公有方法，该方法也能调用继承的父类中的私有方法和私有属性" ], "explanation": "在Python中，子类不能直接访问父类的私有属性和私有方法（名称以双下划线开头）。即使子类实现了公有方法，也无法直接调用父类的私有成员，必须通过父类提供的公有接口访问。因此D选项说法错误。" }, { "id": 1761, "q": "生成3个三位随机整数，输出其中最大的数。\nimport random\nx=random.randint(100,999)\ny=random.randint(100,999)\nz=random.randint(100,999)\nmax=x if ___1____ else y\nmax=max if ___2____ else z\nprint(\"x={0},y={1},z={2}\".format(x,y,z))\nprint(\"max=\",max)", "t": "fill", "ans": "x>y | max>z", "kp": "程序填空/调试", "o": [], "explanation": "第1空使用条件表达式比较x和y，若x>y则max取x，否则取y，填入x>y。第2空将前两者的最大值max与z比较，若max>z则保持max，否则取z，填入max>z。" }, { "id": 1762, "q": "以下代码的输出结果是（）。\na,b,c=600,400,300\nif (a>b):\n   a=b\n   b=c\n   c=a\nelif a==b:\n   b=c\n   c=a\nelse:\n   c=a\nprint(a,b,c)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "400 500 300", "500 300 400", "400 300 400", "500 300 500" ], "explanation": "初始a=600,b=400,c=300。满足a>b条件，执行if分支：首先a=b使a变为400；接着b=c使b变为300；最后c=a使c变为400。最终a,b,c的值分别为400,300,400。" }, { "id": 1763, "q": "从键盘输入10个整数存入集合s中，相同的数在s中只存入第一次出现的数，其余的都被删除。请完成程序。\ns=_____1_____ #创建一个空集合\nfor i in range(10):\n    x=int(input())\n    s. __2__\nprint('s=',s)", "t": "fill", "ans": "set() | add(x)", "kp": "程序填空/调试", "o": [], "explanation": "第1空需要创建一个空集合，Python中使用set()创建空集合，注意不能用{}，否则会创建空字典。第2空将输入的整数x添加到集合s中，集合添加单个元素的方法是add()，故填入add(x)。" }, { "id": 1764, "q": "下列关于Python中的复数的说法中，正确的是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "虚部必须添加后缀j或J", "实部和虚部可以不是浮点数", "一个复数可以没有虚部的实数和j", "虚数的实数部分是1可以省略" ], "explanation": "Python中复数的虚部必须以j或J作为后缀。实部和虚部可以是整数或浮点数；复数必须有虚部标识；当虚部的系数为1时，1不能省略（如1j不能写成j）。因此A选项说法正确。" }, { "id": 1765, "q": "以下代码的输出结果是（）。\nx =12+3*((5*8)- 14)//6\nprint(x)", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "25.0", "65", "25", "24" ], "explanation": "根据运算符优先级，先计算括号内5*8=40，再算40-14=26。接着计算乘法和整除，3*26=78，78//6=13。最后计算加法12+13=25。整除运算结果为整数，故输出25。" }, { "id": 1766, "q": ">>>type(False)的运行结果的是（ ）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "", "", "", "" ], "explanation": "False是Python中的布尔类型值，使用type()函数获取其类型时，运行结果应为。本题选项内容缺失，但根据知识点可推断正确答案应指向布尔类型。" }, { "id": 1767, "q": "以下关于同步赋值语句描述错误的选项是（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "同步赋值能够使得赋值过程变得更简洁", "判断多个单一赋值语句是否相关的方法是看其功能上是否相关或相同", "设x，y表示一个点的坐标，则x=a；y=b两条语句可以用x，y=a，b一条语句来赋值", "多个无关的单一赋值语句组合成同步赋值语句，会提高程序的可读性" ], "explanation": "同步赋值适用于功能上相关的变量赋值，能使代码更简洁。如果将多个无关的单一赋值语句强行组合成同步赋值，不仅不能提高可读性，反而会使代码逻辑混乱，降低可读性。因此D选项描述错误。" }, { "id": 1768, "q": "Python中的续行符是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "反斜杠", "逗号", "缩进", "分号" ], "explanation": "在Python中，如果一条语句过长需要换行书写，可以使用反斜杠（\\）作为显式续行符。此外，在圆括号、方括号或花括号内的多行语句可以隐式续行，无需使用续行符。" }, { "id": 1769, "q": "关于基本输入输出函数的描述，错误的选项是()", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "print()函数的参数可以是一个函数，执行结果是显示函数返回的值", "eval()函数的参数是\"3*2\"的时候，返回的值是整数6", "当用户输入一个整数\"8\"的时候，input()函数返回的也是整数8", "当print()函数输出多个变量的时候，可以用逗号分隔多个变量名" ], "explanation": "input()函数从标准输入读取内容，无论用户输入什么，其返回值始终是字符串类型。如果用户输入数字8，返回的是字符串\"8\"而不是整数8，需使用int()转换。因此C选项描述错误。" }, { "id": 1770, "q": "运行以下程序，若输入a为-100，显示的运行结果是（ ）\na=int(input())\nif(a>0):\n    print(\"正数\")\nelse:\n    print(\"不是正数\")", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "正数", "不是正数", "报错", "没有输出" ], "explanation": "输入-100并转换为整数后，判断条件a>0为False，因此程序跳过if分支，执行else分支，最终输出\"不是正数\"。" }, { "id": 1771, "q": "以下关于Python分支的描述中，错误的是（ ）。", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "Python分支使用保留字if、elif和else来实现，每个if后面必须有elif或else", "if-else结构可以嵌套的", "if语句会判断if后面的逻辑表达式，当表达式为真时，执行if后续的语句块", "缩进是Python分支结构的语法部分，缩进不正确会影响分支功能" ], "explanation": "if语句可以单独使用，后面不必须跟elif或else，因此A选项描述错误。B、C、D关于分支嵌套、条件判断和缩进语法的描述均符合Python规范。" }, { "id": 1772, "q": "以下代码的输出结果为（）。\nage=16\nif 12<=age<=17:\n   if age<=12:\n      print(\"小学生\")\n   else:\n      print(\"中学生\")\nelse:\n   print(\"大学生\")", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "中学生", "小学生", "大学生", "是学生吗" ], "explanation": "age为16，满足外层条件12<=age<=17。进入内层判断时，age<=12为False，因此执行内层的else分支，输出\"中学生\"。" }, { "id": 1773, "q": "下列代码的输出结果是（）\nx=3\ny=100\nif x:\n    y=2\nprint(y)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "0", "100", "2", "报错" ], "explanation": "在Python中，非零整数在布尔上下文中被视为True。x的值为3，条件if x成立，执行y=2，最终打印y的值为2。" }, { "id": 1774, "q": "以下代码的输出结果是（）。\nx=10\nwhile x:\n    x-=1\n    if x%2:\n        print(x,end='')\n    else:\n        pass", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "86420", "975311", "97531", "864200" ], "explanation": "x初始为10，每次循环减1。当x为奇数时，x%2结果为1（True），打印x；偶数时不打印。x从9递减到1，依次打印奇数9、7、5、3、1。当x减为0时循环结束。" }, { "id": 1775, "q": "对下列语句不符合语法要求的表达式是（      ）。\nfor var in         :\n    print(var)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "range(0,10)", "\"Hello\"", "(1,2,3)", "<1,2,3,4,5>" ], "explanation": "for循环的in后面需要跟一个可迭代对象。range、字符串、元组都是可迭代对象，而选项D内容为空，不符合语法要求。" }, { "id": 1776, "q": "下面代码的输出结果是（ ）。\na =[]\nfor i in range(2,10):\n    count = 0\n    for x in range(2,i-1):\n        if i % x==0:\n           count += 1\n        if count != 0:\n              a. append(i)\nprint(a)", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "[4, 6, 6, 6, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9]", "[4,6,6,6,9,7]", "[66,55,8,7]", "[3,5,5,2,2,4]" ], "explanation": "代码中if count!=0位于内层for循环内部。当i为合数时，每次内层循环都会判断并追加i。例如i=6时，x=2和3均整除，且每次循环都满足count!=0，导致6被追加3次，最终生成包含重复元素的列表。" }, { "id": 1777, "q": "将字母大小写互换，大写变小写，小写变大写的字符串方法是( )。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "upper", "swapase", "title", "capitalize" ], "explanation": "Python中用于大小写互换的字符串方法是swapcase。选项B拼写为swapase，存在拼写错误，但根据题意应选此项。upper转大写，title和capitalize用于首字母大写。" }, { "id": 1778, "q": "令list=[1,2,3,4,5]，则print(list[::2])的结果为（ ）", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "[1,3]", "[1, 3,5]", "3", "[4]" ], "explanation": "列表切片[::2]表示从开头到结尾，步长为2。因此依次取索引0、2、4的元素，即1、3、5，结果为[1, 3, 5]。" }, { "id": 1779, "q": "已知x=tuple(range(5)) 那么表达式x[-1]的值为（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "3", "4", "5", "6" ], "explanation": "range(5)生成0到4的序列，转换为元组后为(0, 1, 2, 3, 4)。索引-1表示取最后一个元素，即4。" }, { "id": 1780, "q": "下列Python数据中其元素可以改变的是（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "列表", "元组", "字符串", "数组" ], "explanation": "列表是可变数据类型，其元素可以修改。元组和字符串是不可变数据类型。Python内置标准数据类型中通常指列表为可变序列。" }, { "id": 1781, "q": "下列语句执行后的结果是（）\nmy_dict = {'apple': 3, 'banana': 5, 'cherry': 2, 'date': 7}\nfor key in list(my_dict):\n   if my_dict[key] % 2 == 0:\n      del my_dict[key]\nprint(my_dict)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{'apple': 3, 'banana': 5, 'date': 7}", "{'banana': 5, 'date': 7}", "{'apple': 3, 'cherry': 2, 'date': 7}", "{'banana': 5, 'cherry': 2, 'date': 7}" ], "explanation": "遍历字典键的列表副本，当值为偶数时删除该键值对。原字典中'cherry'的值为2（偶数），被删除。其余值均为奇数被保留。使用list()避免了迭代时修改字典引发的错误。" }, { "id": 1782, "q": "以下关于函数定义的描述错误的是( )", "t": "single", "ans": "A", "kp": "函数", "o": [ "函数必须有返回值", "函数使用return给出返回值", "函数定义中可以指定无限多个参数", "函数定义中可以为某些参数指定默认值" ], "explanation": "Python中函数可以没有返回值，若未使用return语句，函数默认返回None。选项B、C、D均符合Python函数定义规则，因此A描述错误。" }, { "id": 1783, "q": "下列代码运行后的结果是（ ）。\ndef sum(m):\n    if m>0:\n        return m+sum(m-1)\n    else:\n        return 0\ns=sum(10)\nprint(\"{}\".format(s))", "t": "single", "ans": "A", "kp": "函数", "o": [ "55", "45", "36", "输出不确定值" ], "explanation": "该代码使用递归计算从1到m的累加和。当m=10时，依次展开为10+sum(9)，直到m=0时返回0。最终结果为10+9+...+1+0=55。" }, { "id": 1784, "q": "以下程序的运行结果是（）。\ndef mytype(x,y,z=10):\n　　 return x+y+z\nprint(mytype(10,13))", "t": "single", "ans": "B", "kp": "函数", "o": [ "23", "33", "不确定值", "实参个数不对" ], "explanation": "函数mytype定义了默认参数z=10。调用时传入两个实参10和13，分别赋给x和y，z使用默认值10。返回值为x+y+z，即10+13+10=33。" }, { "id": 1785, "q": "下列关于构造方法__init__()的描述错误的是（）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "不需要由用户显示调用，而是在实例化类时自动被调用", "__init__()方法可以有参数", "__init__()方法的参数将在实例化时被提供", "__init__()方法需要用户显示调用" ], "explanation": "__init__()是类的构造方法，在创建类的实例时由Python解释器自动调用，不需要用户显式调用。因此选项D描述错误，A、B、C均正确。" }, { "id": 1786, "q": "Python中定义类的关键字是（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "def", "class", "function", "defun" ], "explanation": "在Python中，定义函数使用def关键字，而定义类使用class关键字。function和defun不是Python的保留字。" }, { "id": 1787, "q": "在Python语言中，写文件操作时定位到某个位置所用的的函数是（ ）。", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "write()", "writeall()", "seek()", "Writetext()" ], "explanation": "在Python文件操作中，seek()方法用于移动文件指针到指定位置。write()用于写入数据，不存在writeall()和Writetext()内置方法。" }, { "id": 1788, "q": "在读写文件之前，需要打开文件使用的函数是（ ）。", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "read()", "fopen()", "open()", "CFile()" ], "explanation": "在Python中，读写文件前需使用内置函数open()打开文件并返回文件对象。read()用于读取，fopen()是C语言函数，CFile()不是Python内置函数。" }, { "id": 1789, "q": "以下程序的运行结果是[*queNo*]_______。\nlst=[1,1]\nfor i in range(2,6):\n        lst.append(lst[i-1]+lst[i-2])\nprint(lst)", "t": "fill", "ans": "[1, 1, 2, 3, 5, 8]", "kp": "列表/元组", "o": [], "explanation": "列表初始为[1, 1]。循环i从2到5，每次将前两项之和追加到列表。i=2加2，i=3加3，i=4加5，i=5加8。最终列表为[1, 1, 2, 3, 5, 8]。" }, { "id": 1790, "q": "下列程序运行的结果是什么？\ndef get_even_numbers(numbers):\n    even_numbers = [num for num in numbers if num % 2 == 0]\n    return even_numbers\nnumbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\nresult = get_even_numbers(numbers)\nprint(len(result))", "t": "fill", "ans": "5", "kp": "列表/元组", "o": [], "explanation": "函数使用列表推导式筛选出numbers中的偶数。1到10中的偶数有2, 4, 6, 8, 10，共5个。因此even_numbers长度为5，len(result)输出5。" }, { "id": 1791, "q": "下列程序的输出结果是什么？[*queNo*]__\nFA=lambda x,y:(x>y)*x+(xy)*y+(x>>bin(10)", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "'0o1010'", "'0d1010'", "'0b1010'", "'0x1010'" ], "explanation": "bin()函数用于将整数转换为二进制字符串表示。10的二进制为1010，Python中二进制字符串的前缀为'0b'，因此bin(10)返回'0b1010'。" }, { "id": 1795, "q": "以下不能创建字典的语句是（ ）。", "t": "single", "ans": "C", "kp": "字典/集合", "o": [ "dict1={}", "dict2={2:4}", "dict3=dict([2,4],[6,8])", "dict4=dict(([2,4],[6,8]))" ], "explanation": "C选项中dict([2,4],[6,8])传入了两个独立的列表作为位置参数，而dict()构造函数只接受一个包含键值对的可迭代对象或关键字参数，因此会报错。D选项传入的是一个包含两个列表的元组，符合要求。" }, { "id": 1796, "q": "下列代码运行后的结果是（ ）。\ndef dig(n):\n  if n/2>0:\n    dig(n-3)\n  print(n,end=' ')\nif __name__ == '__main__':\n  dig(9)", "t": "single", "ans": "D", "kp": "函数", "o": [ "9 6 3 0", "9", "0", "0 3 6 9" ], "explanation": "函数dig是递归调用。dig(9)调用dig(6)，再调用dig(3)，最后调用dig(0)。当n=0时条件不成立，打印0并返回；接着依次返回并打印3、6、9。因此最终输出顺序为0 3 6 9。" }, { "id": 1797, "q": "在Python中，关于数据类型的描述错误的是（）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "整数的书写格式支持十进制、二进制、八进制和十六进制", "如果想知道参数的数据类型，可以使用type()函数获得", "整数、浮点数、复数和布尔值都是Python的基本数据类型", "浮点数是带有小数的数字，它存在范围的限制，如果计算结果超出上限和下限的范围不会报错，但会有warning的警告" ], "explanation": "Python中浮点数超出表示范围时，通常会变成无穷大（inf）或引发OverflowError异常，而不会产生warning警告。选项A、B、C的描述均符合Python数据类型的实际特性，因此D选项描述错误。" }, { "id": 1798, "q": "下列转义字符能够实现换行的是（）", "t": "single", "ans": "B", "kp": "字符串", "o": [ "\\b", "\\n", "\\r", "\\t" ], "explanation": "在Python字符串中，\\n 是换行符（newline），用于实现换行功能。\\b 是退格符，\\r 是回车符，\\t 是水平制表符。因此正确答案是B。" }, { "id": 1799, "q": "下面代码的输出结果是（）。\n>>>s=(3,)\n>>>type(s)", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "", "", "", "" ], "explanation": "变量 s=(3,) 定义了一个包含单个元素的元组，逗号是区分元组和带括号表达式的关键。使用 type(s) 获取其类型，返回结果为 ，对应选项B。" }, { "id": 1800, "q": "下面关于Python的描述正确的是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "代码的缩进错误导致的是逻辑错误", "跳跃结构是Python的流程结构之一", "Python支持的数据类型包括char、int和float等", "Python内存管理中，变量无须事先创建和赋值，而是可以直接使用" ], "explanation": "Python中没有char类型，只有str；变量必须先创建并赋值才能使用；流程结构包括顺序、分支和循环，没有\"跳跃结构\"。缩进错误如果未引发语法异常，会导致代码块归属错误，从而产生逻辑错误，故A正确。" }, { "id": 1801, "q": "下列对常量与变量的描述错误的是（ ）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "常量的值不可以随时改变", "变量的值是可以随时改变的", "常量的值包括数值型、字符串型、布尔型等", "常量不可以给变量赋值" ], "explanation": "常量是可以给变量赋值的，例如 pi = 3.14 中，常量 3.14 被赋值给了变量 pi。选项A、B、C关于常量和变量的描述均正确，因此D选项描述错误。" }, { "id": 1802, "q": "已知x=10;y=3,执行语句x*=y+1后，x的值是（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "40", "31", "30", "41" ], "explanation": "复合赋值运算符 *= 的优先级低于加法运算符 +。因此表达式 x *= y + 1 等价于 x = x * (y + 1)。代入 x=10, y=3，计算过程为 10 * (3 + 1) = 40。" }, { "id": 1803, "q": "Python中标准输出函数是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "scanf()", "print()", "input()", "output()" ], "explanation": "Python中的标准输出函数是 print()，用于将信息打印到控制台。input() 是标准输入函数，scanf() 是C语言的输入函数，Python中没有内置的 output() 函数。" }, { "id": 1804, "q": "以下关于Python缩进的描述中，错误的是（）", "t": "single", "ans": "D", "kp": "基础语法与输入输出", "o": [ "缩进表达了所属关系和代码块的所属范围", "缩进可以是嵌套的，从而形成多层缩进", "判断、循环、函数等都能够通过缩进包含一批代码", "Python用严格的缩进表示程序的格式框架，所有代码都需要在行前至少加一个空格" ], "explanation": "Python使用缩进来表示代码块的层级和所属关系，但并非所有代码都需要缩进。程序的顶层代码（如全局变量定义、主程序入口等）必须顶格书写，不需要在行前加空格，因此D选项描述错误。" }, { "id": 1805, "q": "语句x,y=eval(input())执行时，输入数据格式错误的是（ ）。", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "3 4", "(3,4)", "3,4", "[3,4]" ], "explanation": "eval() 函数会将输入的字符串当作Python表达式进行求值。输入 3 4 会导致语法错误，因为中间有空格且无分隔符。而 (3,4)、3,4 和 [3,4] 都能被正确解析为包含两个元素的元组或列表，从而成功解包赋值。" }, { "id": 1806, "q": "下列语句执行后的输出是（）。\nx=-100\ny=20\nif x 2-3 : print(\"yes\")", "if 3>2>2 : print(\"yes\")", "if 1==1 and 2!=1 : print(\"No\")", "if not(1==1 and 0!=1) : print(\"yes\")" ], "explanation": "选项A中5+4结果为9，2-3结果为-1，9>-1为真，输出yes；选项B中3>2>2等价于3>2且2>2，后半部分为假；选项C条件为真但输出No；选项D中1==1和0!=1均为真，取not后为假。因此只有A输出yes。" }, { "id": 1810, "q": "设有程序段：\nfor i in range(1,6,3):\n      pass\nprint(i)\n则程序的运行结果是（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "4", "5", "6", "1" ], "explanation": "range(1, 6, 3)生成的序列为1和4。for循环依次将1和4赋值给变量i，循环结束时i保留最后一次赋的值，即4。因此print(i)输出4。" }, { "id": 1811, "q": "以下代码的输出结果是（ ）。\nsum=0\nlis=(1,2,3,4,5)\nfor s in lis:\n    if s%2==1:\n        continue\n    sum=sum+s\nprint(sum)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "3", "4", "6", "5" ], "explanation": "程序遍历元组中的元素，当元素为奇数时（1、3、5），满足s%2==1，执行continue跳过本次循环；当元素为偶数时（2、4），将其累加到sum中。最终sum的值为2+4=6。" }, { "id": 1812, "q": "以下保留字不用于循环逻辑的是（）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "try", "else", "for", "continue" ], "explanation": "try是用于异常处理结构（try-except）的保留字，不属于循环逻辑。而else除了用于条件分支，也可用于for和while循环中；for是循环关键字；continue用于跳过当前循环迭代。" }, { "id": 1813, "q": "关于下列代码的说法不正确的是（ ）。\nfor i in range(10):\n    for j in range(5):\n        print(\"#\",end=\" \")\n    print()", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "语句print(\"#\",end=\" \")总共会运行50次", "语句print()总共会运行10次", "若语句print()缩进与语句print(\"#\",end=\" \")对齐，则语句print()总共会运行50次", "因为print()没有打印任何东西,所以可以省略且运行结果不会发生任何改变" ], "explanation": "内层循环每次打印一个#不换行，共执行50次；外层循环的print()用于在每行打印5个#后换行，共执行10次。若省略外层print()，所有#将输出在同一行，运行结果会发生改变，故D选项说法错误。" }, { "id": 1814, "q": "s=\"hello world\",（）不是正确的索引。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "s['h']", "s[5]", "s[1]", "s[10]" ], "explanation": "Python中字符串的索引必须是整数或切片，不能是字符本身。选项A使用字符'h'作为索引会导致TypeError错误。选项B、C、D均使用合法的整数索引，分别对应空格、'e'和'd'。" }, { "id": 1815, "q": "表达式 'b' in ('a','b','c','d') 的值是（ ）。", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "Yes", "No", "True", "False" ], "explanation": "in运算符用于检查某个元素是否存在于序列（如元组、列表、字符串）中。因为字符'b'存在于给定的元组中，所以表达式返回布尔值True，而不是字符串Yes或No。" }, { "id": 1816, "q": "下列Python程序的运行结果是（ ）。\nlst=[8,2,4,15,21]\nlst.reverse()\nprint(lst)", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "[21, 15, 4, 2, 8]", "[2, 4, 8, 15, 21]", "[8, 2, 4, 15, 21]", "2, 4, 8, 15, 21" ], "explanation": "列表的reverse()方法用于将列表中的元素原地逆序排列，不返回新列表。原列表[8,2,4,15,21]反转后变为[21, 15, 4, 2, 8]，因此打印结果为A选项。" }, { "id": 1817, "q": "下面哪个选项描述了Python中字典（dictionary）的特点？", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "有序集合", "可变数据类型", "元素不唯一", "元素按索引访问" ], "explanation": "Python中的字典是可变数据类型，支持增删改操作。字典通过键来访问元素，而不是通过数字索引；字典的键必须是唯一的；其核心特征是基于键值对的可变映射类型，故B选项最准确。" }, { "id": 1818, "q": "针对以下代码，下面选项中描述错误的是（）\ndef fact(n):\n    s=0\n    for i in range(1,n+1):\n   \n        s+=i\n    return s", "t": "single", "ans": "A", "kp": "函数", "o": [ "代码中n是可选参数", "fact(n)函数功能为求1+2...+n", "range()函数是python内置函数", "fact是函数名" ], "explanation": "在函数定义中，参数n没有设置默认值，因此它是必选参数，调用时必须传入实参，而不是可选参数。该函数通过循环累加实现求1到n的和，range是内置函数，fact为函数名，故A描述错误。" }, { "id": 1819, "q": "以下程序代码的运行结果正确的是（ ）。\na=10\nb=6\ndef fun():\n    a=13\n    b=10\nfun()\nprint(a+b)", "t": "single", "ans": "A", "kp": "函数", "o": [ "16", "10", "13", "23" ], "explanation": "函数fun内部定义的a和b是局部变量，不会影响全局变量a和b的值。调用fun()后，全局变量a仍为10，b仍为6。因此print(a+b)输出10+6=16。" }, { "id": 1820, "q": "关于lambda函数，以下选项中描述错误的是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "lambda是Python的保留字即关键字。", "lambda函数也称为匿名函数，是python中的一种特殊函数。", "匿名函数可以作普通函数的返回值返回，可以返回多个值。", "匿名函数不需要函数名，因此，可以避免与其它函数名冲突。" ], "explanation": "lambda函数只能包含一个表达式，并隐式返回该表达式的结果，因此只能返回一个值，不能返回多个值。选项A、B、D关于lambda是关键字、匿名函数及避免命名冲突的描述均正确。" }, { "id": 1821, "q": "下列说法中不正确的是（ ）。", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "类是一个支持集成的抽象数据类型，通常情况下是不占用内存空间；对象是类的实例，是类型的一个变量，变量一旦被创建要占用内存空间", "实例成员名如果以__开头，就变成了一个私有成员", "只有在类的内部才可以访问类的私有成员，外部不能访问", "在Python中，一个子类只能继承一个父类" ], "explanation": "Python支持多重继承，即一个子类可以同时继承多个父类，语法为class SubClass(Parent1, Parent2)。选项A、B、C关于类与对象内存占用、私有成员命名及访问限制的描述均正确。" }, { "id": 1822, "q": "关于文件类型的描述，错误的是（ ）", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "英文文本文件在磁盘中存放时每个字符对应一个字节，用于存放对应的ASCII码", "二进制文件按数据类型在内存中的存储形式存储", "文本文件可以进行顺序读写和随机读写", "二进制文件既可以进行顺序读写也可以进行随机读写" ], "explanation": "文本文件通常按字符编码存储，一般只支持顺序读写。虽然可通过seek移动指针，但因字符编码长度可能不固定，随机读写易导致乱码。二进制文件按字节存储，支持顺序和随机读写。故C错误。" }, { "id": 1823, "q": "下列 Python 程序的运行结果是（ ）。\ns1={4,3,2,1}^{7,8,9}\ns2={1,5,9,2,6,7}|{1,2}\ns1|=s2\ns1.remove(3)\nprint(s1)", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "{1, 2, 4, 5, 6, 7, 8, 9}", "{1, 2, 4, 5, 6,7}", "{1, 2, 7, 5}", "{1, 7, 4, 8, 6}" ], "explanation": "s1为两集合对称差集，得{1,2,3,4,7,8,9}。s2为两集合并集，得{1,2,5,6,7,9}。s1|=s2将s2元素并入s1，s1更新为{1,2,3,4,5,6,7,8,9}。最后移除元素3，最终输出{1,2,4,5,6,7,8,9}。" }, { "id": 1824, "q": "下列程序的输出结果是（ ）。\nls=[]\nfor m in '大蹑':\n    for n in '手脚':\n        ls.append(m+n)\nprint(ls[0])", "t": "fill", "ans": "大手", "kp": "列表/元组", "o": [], "explanation": "外层循环遍历字符串'大蹑'，内层循环遍历'手脚'。第一次外层循环m为'大'，内层循环n依次为'手'和'脚'，向列表ls依次追加'大手'和'大脚'。因此ls[0]的值为'大手'。" }, { "id": 1825, "q": "以下程序的运行结果是[*queNo*]_。\nclass A():\n    def aa(self):\n    self.x=5\na=A()\na.x=10\nprint(a.x)", "t": "fill", "ans": "10", "kp": "面向对象", "o": [], "explanation": "题目代码中类A的方法aa存在缩进错误，若直接运行会报错。但按出题意图，方法aa并未被调用。实例化对象a后，直接通过a.x=10为对象动态添加属性x并赋值10，故打印结果为10。" }, { "id": 1826, "q": "在考生文件夹下存在一个Python源文件PY102.py，请编写代码替换横线，不修改其他代码，实现下面功能：\n获取一个由英文逗号、字母、汉字、数字字符组成的输入，计算该输入中所有数字的和，并输出。\n示例如下（其中数据仅用于示意）：\n输入：\n1,海淀区,ab,56,3,中关村\n输出：\n数字和是：60\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试并验证程序。", "t": "fill", "ans": "myinput = input(\"请输入：\")\n#split方法用于将字符串按分隔符分割成数组。\nls = myinput.split(',')\ns = 0\nfor c in ls:\nif c.strip(\" \").isdigit():\n#s += int(c)表示将c转为整型数据与s相加后再赋值给s。相当于以下操作：\n# s = s + int(c)\ns += int(c)\nprint(\"数字和是：\" + str(s))", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1827, "q": "在考生文件夹下存在一个Python源文件PY101.py，请编写代码替换横线，不修改其他代码，实现下面功能：\n用户按照列表格式输入数据，将用户输入的列表中属于字符串类型的元素连接成一个整字符串，并打印输出。\n示例如下(其中数据仅用于示意) :\n输入：\n[123, \"Python\", 98, \"等级考试\"]\n输出:\nPython等级考试\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "ls = eval(input()) #要求输入格式为列表、集合或元组（以逗号隔开的字符串也是元组），不支持字典和字符串。也可以在input里输入提示，比如input('请输入一个列表')\ns = \"\"\nfor item in ls: #遍历元素，如果元素的类型与\"香山\"的类型相同（即字符串），则将该元素与空字符串s进行连接，并返回连接的结果\nif type(item) == type(\"香山\"):\ns += item\nprint(s)", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1828, "q": "下列 Python 程序的运行结果是（ ）\nfruits = ['apple', 'banana', 'cherry','pear']\nlast_fruit = fruits.pop()\nprint(len(fruits))", "t": "single", "ans": "C", "kp": "列表/元组", "o": [ "1", "2", "3", "4" ], "explanation": "列表的pop()方法默认移除并返回列表的最后一个元素。原列表包含4个元素，执行pop()后移除'pear'，列表剩余3个元素。因此len(fruits)的值为3。" }, { "id": 1829, "q": "在一行上写多条Python语句使用的符号是（ ）", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "点号", "冒号", "分号", "逗号" ], "explanation": "在Python中，通常每条语句占一行。若需在同一行书写多条语句，必须使用分号将它们分隔。点号用于属性访问，冒号用于代码块开始，逗号用于分隔元素。" }, { "id": 1830, "q": "以下选项中，Python不支持的数据类型是（）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "int", "char", "float", "string" ], "explanation": "Python中没有单独的字符类型（char）。单个字符在Python中被视为长度为1的字符串（string）。int、float和string都是Python内置支持的基本数据类型。" }, { "id": 1831, "q": "表达式8**(1/3)的值为（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "2.0", "2", "2.66", "1" ], "explanation": "在Python中，**是幂运算符。1/3执行真除法结果为浮点数。8的1/3次方即求8的立方根，由于指数是浮点数，计算结果也是浮点数2.0，而非整数2。" }, { "id": 1832, "q": "以下关于程序设计语言的描述，错误的选项是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "Python解释器把Python代码一次性翻译成目标代码，然后执行", "机器语言直接用二进制代码来表达指令", "Python是一种通用编程语言", "汇编语言是用于编程器件的低级语言" ], "explanation": "Python是解释型语言，解释器逐行读取源代码并翻译成字节码执行，而不是像编译型语言那样一次性翻译成目标机器代码。选项B、C、D关于机器语言、Python通用性及汇编语言的描述均正确。" }, { "id": 1833, "q": "以下Python表达式中，哪项的值与其它三项不同（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "len([1，2，3，4])", "len(\"Nice to meet you\".split())", "sum（[1，2，1，1]）", "max（[1，2，3，4]）" ], "explanation": "A、B、D三项计算结果均为4，分别表示列表长度、字符串分割后的单词数和列表最大值。C项sum()计算列表元素之和，结果为5，与其他三项不同。" }, { "id": 1834, "q": "以下程序的运行结果是（）。\ndef Jc():\n     pass\nprint(Jc())", "t": "single", "ans": "D", "kp": "函数", "o": [ "pass", "None", "空字符串", "什么也不输出" ], "explanation": "函数体内仅含pass语句，无显式return返回值。部分基础考题认为该函数不执行任何输出操作，因此调用print(Jc())后视为无输出。按题库设定选D。" }, { "id": 1835, "q": "在面向对象程序设计中，一个系统由若干个对象组成，各个对象之间通过（）相互联系、相互作用。", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "类", "消息", "继承", "多态" ], "explanation": "面向对象编程中，对象是基本单元，对象之间通过发送和接收\"消息\"进行通信与协作。类是对象的模板，继承和多态是面向对象的特性，而非对象间交互的直接机制。" }, { "id": 1836, "q": "以下关于文件的描述中，错误的是（ ）", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "文件时存储在辅助存储器上的一组数据序列，可以包含任何数据内容", "可以使用open()打开文件，用close()关闭文件", "使用read()可以从文件中读入全部文本", "使用readlines()可以从文件中读入一行文本" ], "explanation": "readlines()方法用于读取文件中的所有行，并返回一个包含每行字符串的列表。读取单行文本应使用readline()方法。A、B、C描述均符合Python文件操作规范。" }, { "id": 1837, "q": "编写程序，输入两个整数，然后按升序输出。\na=int(input('Input two number:'))\nb=int(input('Input two number:'))\nif ___1____:\n    a, b = b, a\n__2____(a,b)", "t": "fill", "ans": "a>b | print", "kp": "程序填空/调试", "o": [], "explanation": "第1空需判断是否需要交换，当a大于b时执行a, b = b, a实现升序排列；第2空用于输出结果，调用内置函数print将排序后的a和b打印到控制台。" }, { "id": 1838, "q": "执行以下程序，输出结果是：[*queNo*]____。\ns=['小王','小张','小李','小陈','小刘','小赵']\nprint(s[-2])", "t": "fill", "ans": "小刘", "kp": "列表/元组", "o": [], "explanation": "Python列表支持负数索引，-1表示最后一个元素，-2表示倒数第二个元素。列表s中倒数第二个元素为\"小刘\"，因此直接输出该字符串。" }, { "id": 1839, "q": "下面程序的执行结果是[*queNo*]________。\nS1=set()\nfor i in range(1,11):\n      S1.add(i)\nprint(len(S1))", "t": "fill", "ans": "10", "kp": "字典/集合", "o": [], "explanation": "range(1,11)生成1到10的整数序列。循环依次将1至10添加到集合S1中，集合自动去重但此处无重复元素。最终集合包含10个元素，len()返回长度10。" }, { "id": 1840, "q": "Python中对变量的描述，错误的选项是（ ）", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "变量通过变量名访问", "变量的值在程序运行的过程中不可以被改变", "Python解释器会为每个出现的对象分配内存单元", "id()函数可以查看变量在内存中的地址" ], "explanation": "Python是动态类型语言，变量的值在程序运行过程中可以随时被重新赋值修改。A、C、D均正确描述了变量访问、内存分配及地址查看机制，B项说法错误。" }, { "id": 1841, "q": "下列代码的运行后结果是（ ）。\ndef ptr(n):\n    if n==0:\n        return\n    print ('*'*n)\n    ptr(n-1)\nif __name__ == '__main__':\n    ptr(5)", "t": "single", "ans": "A", "kp": "函数", "o": [ "*****\n****\n***\n**\n*", "*\n**\n***\n****\n*****", "不输出任何结果", "*\n***\n*****" ], "explanation": "函数为递归调用，每次先打印n个星号，再递归调用n-1。初始n=5，依次打印5、4、3、2、1个星号，每次打印后默认换行，形成逐行递减的星号图案，与A项一致。" }, { "id": 1842, "q": "以下程序代码的运行结果正确的是（ ）。\ndef fun():\n    global list\n    list =[2,4,6,8]\nlist = [1,3,5,7]\nfun()\nprint(list)", "t": "single", "ans": "C", "kp": "函数", "o": [ "[1,3,5,7]", "[2,4,6,8,1,3,5,7]", "[2,4,6,8]", "[1,3,5,7,2,4,6,8]" ], "explanation": "函数内使用global list声明全局变量，执行list=[2,4,6,8]会直接修改全局变量list的引用。调用fun()后，全局列表被覆盖为新列表，故打印结果为[2,4,6,8]。" }, { "id": 1843, "q": "输入一个三位整数，判断它各位数字的平方和是奇数还是偶数。\na=___1____; #求个位数字\nb=(x//10)%10; #求十位数字\nc=x//100; #求百位数字\nif (a*a+b*b+c*c)%2==___2___:\n       print(\"{0}是奇数\".format(x))\nelse:\n       print(\"{0}是偶数\".format(x))", "t": "fill", "ans": "x%10 | 1", "kp": "程序填空/调试", "o": [], "explanation": "第1空求个位数字，对10取余即可得x%10；第2空判断平方和奇偶性，奇数除以2余数为1，故填1。满足条件时输出奇数，否则输出偶数。" }, { "id": 1844, "q": "下面关于注释的说法中错误的是：（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "程序中的单行注释采用#开头，必须单独占一行", "程序中的单行注释采用#开头，可以在语句行末尾，也可单独占一行", "若需要多行注释，一般推荐使用多个#开头的多行注释", "用三引号括起来的多行注释，其本质是一个多行字符串，起到注释的作用" ], "explanation": "Python单行注释以#开头，可单独占一行，也可写在代码语句末尾。A项\"必须单独占一行\"说法错误。B、C、D均符合Python注释语法规范。" }, { "id": 1845, "q": "请在划线处选择合适的选项将程序补充完整，使程序的输出结果是True（ ）.\na=5\nb=8\nif ________:\n    print(\"True\")\nelse:\n    print(\"False\")", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "a>b", "a8为假；B选项5<8为真；C选项5==8为假；D选项a=b是赋值语句，在if条件中会报语法错误。因此选B。" }, { "id": 1846, "q": "下列程序的输出结果是（ ）。\ns=1\nfor i in range(1,5):\n    s*=i\nprint(s)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "2", "6", "24", "0" ], "explanation": "range(1,5)生成序列1, 2, 3, 4。循环过程：i=1时s=1；i=2时s=2；i=3时s=6；i=4时s=24。最终输出24，即4的阶乘。选C。" }, { "id": 1847, "q": "Python语言中，以下表达式结果为False的选项是（）。", "t": "single", "ans": "B", "kp": "字符串", "o": [ "\"CD\"<\"CDFG\"", "\"DCBA\"<\"DC\"", "\"\"<\"G\"", "\"LOVE\"<\"1ove\"" ], "explanation": "字符串比较按字符的ASCII码值从左到右逐个进行。B选项中前两个字符相同，第三个字符B与空比较，DCBA更长，故DCBA>>eval(\"Hello\")\"和执行\">>>eval(\"\"Hello\"\")\"得到相同的结果", "eval函数的作用是将输入的字符串转为Python语句，并执行该语句", "如果用户希望输入一个数字，并用程序对这个数字进行计算，可以采用eval(input())组合" ], "explanation": "本题考查eval()函数的作用。eval()用于执行字符串表达式并返回表达式的值。选项B中，eval('Hello')会尝试将Hello作为变量名求值，若未定义会报错；而eval(''Hello'')会返回字符串，两者结果不同，故B描述错误。选项A、C、D均正确描述了eval的常见用法和特性。" }, { "id": 1859, "q": "以下if语句语法不正确的是（ ）。", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "if a>0:x=20\nelse:x=200", "if a>0:x=20\nelse:\nx=200", "if a>0:\nx=20\nelse:x=200", "if a>0\nx=20\nelse\nx=200" ], "explanation": "本题考查if语句的单行语法格式。在Python中，若将if-else写在同一行，条件表达式后必须加冒号，else后也必须加冒号。选项A、B、C均包含了必需的冒号，语法正确，尽管空格不同但不影响语法解析。选项D缺少冒号，属于语法错误。" }, { "id": 1860, "q": "设a=2.25，则表达式a-1==1.20的值为（ ）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "F", "True", "False", "T" ], "explanation": "本题考查浮点数运算与比较。已知a=2.25，则a-1的理论值为1.25。在表达式a-1==1.20中，1.25不等于1.20，因此比较结果为假。Python中布尔类型的假用False表示，而不是F或T，故选C。" }, { "id": 1861, "q": "以下代码的输出结果是（ ）。\ni=3\nj=0\nk=4\nif i>> 3 in(20,15,3,14,5) 的结果为（ ）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "False", "True", "不确定", "错误" ], "explanation": "本题考查成员运算符in的使用。in用于判断某个元素是否存在于指定的序列中。题目中3是元组(20,15,3,14,5)中的一个元素，因此表达式3 in (20,15,3,14,5)的求值结果为真，即True。" }, { "id": 1863, "q": "以下循环执行（ ）次。\ns=1\nwhile s:\n     s=0", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1", "0", "3", "2" ], "explanation": "本题考查while循环的执行条件。初始时s=1，在Python中非零整数被视为True，因此满足while s的条件，进入循环体。执行s=0后，s的值变为0，被视为False。下一次判断条件时不满足，循环结束。因此循环体仅执行了1次。" }, { "id": 1864, "q": "以下代码的输出结果是（ ）。\nfor s in \"***He**llo!***\":\n    if s==\"*\":\n        continue\n    if s==\"!\":\n        break\n    print(s,end=\"\")", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "***He", "llo!", "Hello", "He**llo!" ], "explanation": "本题考查循环控制语句continue和break。遍历字符串时，若字符为*，continue跳过本次循环不输出；若字符为!，break直接终止整个循环。因此，前三个*被跳过，接着输出H、e，跳过两个*，输出l、l、o，遇到!时循环终止。最终输出Hello。" }, { "id": 1865, "q": "下面Python循环体执行的次数与其它不同的是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "i=0\nwhile 1:\nwhile i", "i=10\nfor j in range(0,10):\nwhile i>0:\nprint(i)\ni-=1", "for i in range(10):\nwhile i>=0:\nprint(i)", "for i in range(10,0,-1):\nwhile(i>=0):\nprint(i)" ], "explanation": "本题考查循环嵌套与执行次数。选项B中，外层for循环10次，内层while仅在第一次外层迭代时执行10次，后续因i=0不满足条件而不执行，总计10次。而选项A、C、D中均存在未改变循环变量导致条件恒成立的死循环，执行次数为无限次。故B与其他不同。" }, { "id": 1866, "q": "给出如下代码\ns = \"Alice\"\nprint(s[: :-1] )\n上述代码的输出结果是（）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "ecilA", "ALICE", "Alice", "Alic" ], "explanation": "本题考查字符串切片操作。切片语法为[start:stop:step]。s[::-1]或[: :-1]表示从头到尾以步长为-1进行切片，即逆序输出字符串。原字符串为Alice，逆序后结果为ecilA。选项A符合推导结果。" }, { "id": 1867, "q": "以下选项中，属于不可变序列的是（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "列表", "元组", "集合", "字典" ], "explanation": "本题考查Python基本数据类型的可变性。在Python中，列表、字典和集合都是可变数据类型，支持原地修改其元素。而元组一旦创建，其内部的元素和顺序就不能被修改，属于不可变序列。字符串和数字也是不可变的，但选项中仅有元组符合。" }, { "id": 1868, "q": "假设有两个集合 A 和 B，分别包含整数元素。下面的代码片段表示什么操作？\nA = {1, 2, 3, 4, 5}\nB = {4, 5, 6, 7, 8}\nC = A.intersection(B) - B.difference(A)", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "求 A 和 B 的并集", "求 A 和 B 的交集", "求 A 和 B 的差集", "求 A 和 B 的对称差集" ], "explanation": "本题考查集合的数学运算。A.intersection(B)求A与B的交集；B.difference(A)求B与A的差集。由于交集与差集没有公共元素，两者相减即从交集中去除差集的元素，结果仍为交集本身。因此该代码片段等效于求A和B的交集。" }, { "id": 1869, "q": "以下代码中哪个是正确的函数定义语句（）", "t": "single", "ans": "A", "kp": "函数", "o": [ "def someFuntion():", "function someFunction()", "def someFunction()", "function someFunction():" ], "explanation": "Python定义函数使用def关键字，且语句末尾必须加冒号。选项C缺少冒号会导致语法错误，选项A虽然函数名拼写为Funtion，但符合Python标识符命名规则及函数定义语法，因此是正确的定义语句。" }, { "id": 1870, "q": "下列代码运行后的结果是（ ）。\ndef type(x):\n    if x>0:\n        type(x%3)\n    print(x,end=' ')\nif __name__ == '__main__':\n    type(123)", "t": "single", "ans": "A", "kp": "函数", "o": [ "0 123", "126 0", "126", "0" ], "explanation": "函数type被重新定义。调用type(123)时，123>0，递归调用type(0)。在type(0)中，0不大于0，直接打印0并返回。随后回到type(123)的递归调用后，打印123。因此最终输出为0和123，中间有空格。" }, { "id": 1871, "q": "以下程序代码运行后的结果正确的是（ ）。\ndef fun(x,y):\n     z=x+y\n     print(z)\nfun([1],[2])", "t": "single", "ans": "B", "kp": "函数", "o": [ "3", "[1,2]", "[3]", "运行时出错" ], "explanation": "函数fun接收两个参数并相加。传入的是列表[1]和[2]，在Python中列表使用+运算符表示拼接操作，而不是对应元素相加，因此[1] + [2]的结果是拼接后的新列表[1, 2]。" }, { "id": 1872, "q": "下列程序的运行结果是（ ）。\nf=lambda x,y:divmod(x,y)\nprint(f(13,2))", "t": "single", "ans": "A", "kp": "函数", "o": [ "6,1", "1，6", "2,13", "13，2" ], "explanation": "divmod(x, y)函数返回一个包含商和余数的元组。divmod(13, 2)的商为6，余数为1，返回元组(6, 1)。虽然标准输出带有括号，但选项A的6,1最符合其返回值的核心内容。" }, { "id": 1873, "q": "以下程序运行后输出的结果是（ ）\ndef my(a,b,*args):\n    print(a,b,args)\nmy([1,2,3],4,5,6,7)", "t": "single", "ans": "A", "kp": "函数", "o": [ "[1,2,3] 4 (5,6,7)", "[1,2,3],4,(5,6,7)", "1,2,3,4,5,6,7", "(1,2,3),4, (5,6,7)" ], "explanation": "函数定义中*args用于接收多余的位置参数，并将其打包为元组。调用时，a接收[1,2,3]，b接收4，剩余的5,6,7被打包为元组(5,6,7)赋给args。print默认以空格分隔各参数，故选A。" }, { "id": 1874, "q": "下面哪一种定义是类的私有成员？（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "_xx", "_xx_", "__xxx", "xxx" ], "explanation": "在Python类中，以双下划线__开头的属性或方法会被解释器进行名称改写，从而实现私有化，防止外部直接访问。单下划线开头通常仅为约定俗成的保护成员。" }, { "id": 1875, "q": "在面向对象程序设计中，将细节隐藏在类定义中，术语称为________。", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "虚函数", "子类化", "继承", "封装" ], "explanation": "封装是面向对象编程的核心特性之一，指将数据和方法绑定在一起，并隐藏对象的内部实现细节，仅对外提供公共的访问接口，从而提高代码的安全性和可维护性。" }, { "id": 1876, "q": "有以下代码：\nclass D(B,C）:\n     pass\n其中基类的个数是（）", "t": "single", "ans": "C", "kp": "面向对象", "o": [ "0", "1", "2", "3" ], "explanation": "在Python中定义类时，括号内列出的是该类的基类。代码class D(B,C):表示类D同时继承自类B和类C，属于多继承，因此基类的个数为2个。" }, { "id": 1877, "q": "下列语句执行后的结果是（）。\ns={1,2,2,2,3,3,4,4,4,4,5}\nprint(sum(list(s)))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "34", "15", "10", "1" ], "explanation": "集合具有元素唯一性，自动去除重复元素。因此s去重后为{1, 2, 3, 4, 5}。将其转换为列表后求和，即计算1+2+3+4+5，结果为15。" }, { "id": 1878, "q": "以下程序的功能是从键盘上输入10个数，求出其中的最小数，请填空。\nx=int(input())\nmin =x\nfor i in range(1,10):\n    x=int(input())\n    if x   1   min:\n        2      =x\n   print(\"min={0}\".format(min))", "t": "fill", "ans": "< | min", "kp": "程序填空/调试", "o": [], "explanation": "程序用于求10个数中的最小值。第1空需判断新输入的数是否小于当前最小值，故填<；第2空在条件成立时更新最小值变量，故填min。" }, { "id": 1879, "q": "以下代码的输出结果是（）。\nk=1\nn=263\nwhile(n):\n    k*=n%10\n    n//=10\nprint（k）", "t": "fill", "ans": "36", "kp": "循环结构", "o": [], "explanation": "循环每次取n的个位数乘到k上，然后n整除10去掉个位。初始n=263，依次取出3、6、2，k的值变化为1*3=3，3*6=18，18*2=36。当n为0时循环结束，输出36。" }, { "id": 1880, "q": "下面代码的执行结果是：[*queNo*]____。\nls = [\"10\", \"10.10\", \"list\"]\nls.append(1010)\nls.append([1010,\"1010\"])\nprint(ls[3])", "t": "fill", "ans": "1010", "kp": "列表/元组", "o": [], "explanation": "列表ls初始有3个元素（索引0到2）。第一次append(1010)将整数1010添加到列表末尾，此时它的索引为3。第二次append添加了一个新列表。最后打印ls[3]，即输出第一次添加的整数1010。" }, { "id": 1881, "q": "自定义函数count(string,c),检查字符串string中单个字符c出现的次数并返回。请将以下程序补充完整。\ndef count(string,c):\n    count=0\n    for i in range(len(string)):\n        if ___1_____==c:\n            conunt+=1\n    return ___2__", "t": "fill", "ans": "string[i] | count", "kp": "程序填空/调试", "o": [], "explanation": "第1空需遍历字符串并逐个比较字符，range(len(string))生成索引，因此填string[i]获取当前字符。第2空函数需返回统计结果，循环结束后累加变量为count，故填count。注意题干中conunt+=1为拼写错误，实际应为count+=1。" }, { "id": 1882, "q": "下面程序代码的输出结果是什么？[*queNo*]__\nn=1\ndef func(a,b):\n    global n\n    n=b\n    return a*b\ns=func(\"nice*\",2)\nprint(s,n)", "t": "fill", "ans": "nice*nice* 2", "kp": "函数", "o": [], "explanation": "函数func接收字符串和整数2。a*b执行字符串乘法，结果为原字符串重复两次并返回赋给s。函数内使用global n将全局变量n修改为参数b的值2。最终打印s和n，输出为nice*nice* 2。" }, { "id": 1883, "q": "以下代码的输出结果是[*queNo*]。\nx=16\nif 0<=x<=30:\n    if x<15:\n        if x<10:\n            y=0\n        else:\n            y=1\n    else:\n        if x<20:\n            y=2\n        else:\n            y=3\nelse:\n    y=4\nprint(y)", "t": "fill", "ans": "2", "kp": "分支结构", "o": [], "explanation": "x=16满足外层条件，进入第一层。x<15为假，执行else分支。在else中判断x<20，16<20为真，执行y=2。后续分支跳过，最终打印y的值为2。" }, { "id": 1884, "q": "考生文件夹下存在一个Python源文件PY102.py，请编写代码替换横线，不修改其他代码，实现下面功能：\n按照小写字母a到z顺序组成包含26个字母的字符表，其中，第一个字符a序号为0，依次递增。程序获得用户输入的起始字母序号及连续输出字母的个数，分别记为变量h和w，以逗号隔开，并根据字符表输出从起始字母序号h开始的连续w个字母。\n示例如下（其中数据仅用于示意）：\n输入：\n0,3\n输出：\nabc\n提示：建议使用本机提供的Python集成开发环境IDLE填写，调试及验证程序。", "t": "fill", "ans": "h,w = eval(input(\"请输入起始英文字母的序号和连续输出的个数，逗号隔开:\"))\ncstr = ''\nfor i in range(h, h+w):\nc = chr(i+97)\ncstr += c\nprint(cstr)\nrange(h, h+w)表示从h开始截至h+w（不含）的数据序列。例如，range(0, 3)返回0，1，2。\nchr函数用于将ASCII码转为对应的字符，其中小写字母范围是：97~123，因此c为chr(i+97)。", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1885, "q": "在面向对象程序设计中，将具有相同属性和行为的一组对象的集合称为（ ）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "类", "对象", "过程", "消息" ], "explanation": "类是对具有相同属性和行为的一组对象的抽象与集合，是创建对象的模板。对象是类的实例，过程属于面向过程编程概念，消息是对象间通信的方式。因此正确选项为A。" }, { "id": 1886, "q": "表达式divmod(40,3)的结果是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "13,1", "(13,1)", "13", "1" ], "explanation": "divmod(a,b)内置函数同时返回商和余数，结果封装为元组。40除以3商为13，余数为1，故返回(13,1)。选项A缺少括号不是元组，C和D仅为单一数值，不符合函数定义。" }, { "id": 1887, "q": "下列对常量的描述正确的是（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "常量的值不可以随时改变", "常量的值是可以随时改变的", "常量的值必须是数值", "常量不可以给变量赋值" ], "explanation": "常量指在程序运行期间其值固定不变的量，定义后不可重新赋值。Python虽无严格常量语法，但约定全大写变量名表示常量且不应修改。B与定义相反，C限制类型错误，D常量可参与表达式赋值给变量。" }, { "id": 1888, "q": "以下程序的输出结果是（ ）\ns=\"Love\"\nprint(\"{:*^10}\".format(s))", "t": "single", "ans": "A", "kp": "字符串", "o": [ "***Love***", "Love", "Love******", "******Love" ], "explanation": "格式化字符串中*为填充字符，^表示居中对齐，10为总宽度。字符串长度为4，左右各补3个*，总长10，结果为***Love***。" }, { "id": 1889, "q": "不是Python逻辑运算符的是（ ）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "and", "or", "not", "〉" ], "explanation": "Python的逻辑运算符包括and、or、not。选项D的符号为全角大于号，且大于号属于比较运算符而非逻辑运算符，故D符合题意。" }, { "id": 1890, "q": "下列程序的运行结果是（ ）。\ns=0\ni=1\nt=0\nwhile i<=3:\n    t=t*10+1\n    s=s+t\n    i=i+1\nprint(\"s=\",s)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "s=113", "s=111", "s=123", "s=121" ], "explanation": "循环执行3次。i=1时t=1、s=1；i=2时t=11、s=12；i=3时t=111、s=123。循环结束打印s= 123。选项C正确。" }, { "id": 1891, "q": "在Python中要生成随机数，应该使用（ ）。", "t": "single", "ans": "B", "kp": "random/turtle等标准库", "o": [ "math 模块", "random模块", "numpy 模块", "turtle 模块" ], "explanation": "Python标准库中random模块专门用于生成伪随机数。math用于数学计算，numpy为第三方科学计算库，turtle用于绘图。故选B。" }, { "id": 1892, "q": "文件对象的读取数据方法 read(size) 的含义是（ ）", "t": "single", "ans": "D", "kp": "文件操作", "o": [ "从文件的 size 位置开始，到文件尾部结束，读取文件内容", "从文件中读取一行数据", "从文件中读取size行数据", "从文件当前位置开始，读取指定 size 大小的数据。如果 size 为负数或者空，则读取到文件结束" ], "explanation": "文件对象的read(size)方法从当前文件指针位置开始读取指定字节或字符数的数据。若省略size或为负数，则读取至文件末尾。A描述的是seek后读取，B是readline，C无此用法，D准确描述了该方法行为。" }, { "id": 1893, "q": "表达式True+False的值为（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "2", "0", "1", "语法错误" ], "explanation": "Python中布尔类型是整型的子类，True等价于1，False等价于0。两者相加即1+0，结果为整数1。选项C正确。" }, { "id": 1894, "q": "以下关于浮点数3.0和整数3的描述，正确的是（）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "两者使用相同的硬件执行单元", "两者使用相同的计算机指令处理方法", "两者是相同的数据类型", "两者具有相同的值" ], "explanation": "3.0是浮点型，3是整型，两者数据类型不同，底层硬件执行单元和指令处理方法也不同。但它们在数值上相等，具有相同的数学值。" }, { "id": 1895, "q": "以下代码的输出结果是（ ）。\ns=['apple','pear','banana']\nx=\"_\".join(s)", "t": "single", "ans": "D", "kp": "字符串", "o": [ "'_apple_pear_banana'", "'apple_pear_banana_'", "'_apple_pear_banana_'", "'apple_pear_banana'" ], "explanation": "join方法用于将序列中的元素以指定的字符连接生成新字符串。此处以_连接列表中的三个单词，结果为apple_pear_banana，首尾不会添加连接符。" }, { "id": 1896, "q": "下列属于math库中的数学函数的是（）。", "t": "single", "ans": "C", "kp": "异常与库", "o": [ "time()", "round()", "sin()", "random()" ], "explanation": "time()属于time库，round()是Python内置函数，random()属于random库。sin()是math库中用于计算正弦值的数学函数。" }, { "id": 1897, "q": "下列表达式中，值不是1的是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "7/13", "1*1", "17%8", "6//5" ], "explanation": "A选项7/13是真除法，结果约为0.538；B选项1*1结果为1；C选项17%8求余结果为1；D选项6//5地板除结果为1。因此A的值不是1。" }, { "id": 1898, "q": "Python官方软件包自带的一个集成开发环境是（ ）。", "t": "single", "ans": "B", "kp": "基础语法与输入输出", "o": [ "PyCharm", "Shell-IDLE", "Eclipse", "Anaconda" ], "explanation": "IDLE是Python官方安装包自带的集成开发环境。PyCharm、Eclipse是第三方IDE，Anaconda是Python发行版及包管理器。选项B指代IDLE。" }, { "id": 1899, "q": "在python中，下列属于字符串常量的是（ ）", "t": "single", "ans": "B", "kp": "字符串", "o": [ "2+4j", "\"3.14\"", "course", "2023" ], "explanation": "字符串常量必须用引号括起来。A是复数，C是变量名或标识符，D是整数。B选项用双引号括起，符合字符串常量的定义。" }, { "id": 1900, "q": "下列语句中，在Python中非法的是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "x=y=z=1", "x,y=y,x", "x=(y=z+1)", "x+=y" ], "explanation": "A是连续赋值，合法；B是元组解包交换变量，合法；D是增量赋值，合法。C选项中赋值语句不能作为表达式放在括号内参与赋值，在Python中属于非法语法。" }, { "id": 1901, "q": "下列程序的输出结果( )。\na=899\nb=a/10\nprint(\"%s,%.1f,%.2f\" % (\"Dora\",a,b))", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "Dora 899 89.9", "Dora,899,89.9", "Dora,899.0,89.90", "Dora 899.0 89.90" ], "explanation": "%s输出字符串Dora；%.1f将整数899格式化为保留1位小数的浮点数899.0；%.2f将89.9格式化为保留2位小数的89.90。各部分之间用逗号分隔。" }, { "id": 1902, "q": "Python语句print(\"{:*<10}\".format(\"help\")) 中<代表的含义为（ ）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "左对齐", "右对齐", "居中对齐", "填充符号为<" ], "explanation": "在字符串format格式化中，<表示左对齐，>表示右对齐，^表示居中对齐。*是填充字符，10是总宽度。因此<代表左对齐。" }, { "id": 1903, "q": "5*6>5+6的值为（ ）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "F", "T", "False", "True" ], "explanation": "先计算乘法5*6得30，加法5+6得11。然后比较30>11，结果为真。Python中布尔值真用True表示，假用False表示，首字母需大写。" }, { "id": 1904, "q": "以下代码的输出结果为（）。\nx=False\ny=False\nz=True\nif not x:\n   if y:\n      print(1)\n   else:\n      print(2)\nelif not x or y or not y and x:\n   print(3)\nelse:\n   print(4)", "t": "single", "ans": "B", "kp": "分支结构", "o": [ "1", "2", "3", "4" ], "explanation": "x为False，not x为True，进入第一层if分支。接着判断内层if y，因y为False，进入对应的else分支，执行print(2)。后续elif不再执行。" }, { "id": 1905, "q": "给出下面代码，程序运行结果为（ ）。\nage=23\nstart=2\nif age%2!=0\n    start=1\nprint(start)", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "1", "2", "0", "报错" ], "explanation": "原题代码if语句末尾缺少冒号，实际运行会报语法错误。若按出题意图补全冒号，age=23为奇数，条件成立，start被重新赋值为1并输出。" }, { "id": 1906, "q": "以下程序的运行结果是（ ）。\nk,n=4,0\nwhile nx[j]:\n                x[i],x[j]=x[j],x[i]\n    return x\na=[9,3,10,7,2,0]\nprint(sort(a,len(a)))", "t": "single", "ans": "A", "kp": "算法与综合应用", "o": [ "[0, 2, 3, 7, 9, 10]", "[10, 9, 7, 3, 2, 0]", "(0, 2, 3, 7, 9, 10)", "(10, 9, 7, 3, 2, 0 )" ], "explanation": "代码实现了一个升序排序算法。外层循环遍历每个元素，内层循环将其与后续元素比较，若前面大于后面则交换位置。最终将列表a按从小到大的顺序排列并返回。" }, { "id": 1916, "q": "如下程序片段中：\nclass Myclass:\n    x=30\n    def __init__(self):\n        self.b=1\n        self.__x=2\n其中，类属性是（）", "t": "single", "ans": "A", "kp": "面向对象", "o": [ "x", "b", "__x", "以上都不是" ], "explanation": "在Python类中，直接定义在类体中、方法之外的变量是类属性，被所有实例共享。而在__init__等实例方法中通过self定义的变量属于实例属性，每个实例独有。因此x是类属性。" }, { "id": 1917, "q": "在Python中，以下类的定义正确的是（）", "t": "single", "ans": "D", "kp": "面向对象", "o": [ "Class Phone:\nname=””\ndef call(self,name):\nprint(name,’开车’)", "class Phone:\nname=””\ncall(self,name):\nprint(name,’开车’)", "Class Phone:\nname=””\ndef call(self,name):\nprint(name,’开车’)", "class Phone:\nname=' '\ndef call(self,name):\nprint(name,'开车')" ], "explanation": "Python中定义类的关键字是小写的class，定义方法必须使用def关键字。选项A和C错误使用了大写的Class，选项B遗漏了def关键字。选项D关键字拼写正确，符合语法规范。" }, { "id": 1918, "q": "从已有的类中产生新类的过程，称为（）", "t": "single", "ans": "B", "kp": "面向对象", "o": [ "消息", "继承", "多态", "封装" ], "explanation": "继承是指从已有的类中派生出新类的过程，新类拥有父类的属性和方法。消息是对象间通信机制，多态指同一操作作用于不同对象产生不同行为，封装指隐藏内部实现细节。故选B。" }, { "id": 1919, "q": "定义两个变量weight和height保存一个人的体重身高，编程实现这个人的身高体重是否正常！身高体重是否正常的计算公式为：bim=体重/身高2\nbim大于18.5且小于24.9为健康。\nweight=float(input(“体重（kg)”))\nheight=float(input(“身高（m)”))\nbim=__1___/height**2\nif bim>18.5  __2____  bim<24.9\n    print(\"you are health\")", "t": "fill", "ans": "weight | and", "kp": "程序填空/调试", "o": [], "explanation": "第1空根据公式计算bim，分子应为体重变量weight；第2空判断bim是否同时大于18.5且小于24.9，需使用逻辑与运算符and连接两个条件表达式。" }, { "id": 1920, "q": "以下程序的运行结果是[*queNo*]_______。\nx=([1],[2])\nx[0].append('a')\nprint(x)", "t": "fill", "ans": "([1, 'a'], [2])", "kp": "列表/元组", "o": [], "explanation": "变量x是一个包含两个列表的元组。元组本身不可变，但其内部的列表元素是可变的。通过x[0].append('a')修改了第一个列表，使其变为[1, 'a']，因此最终输出为([1, 'a'], [2])。" }, { "id": 1921, "q": "下列程序运行的结果是什么？\ndef count_vowels(text):\n    vowels = {'a', 'e', 'i', 'o', 'u'}\n    vowel_count = 0\n    for char in text:\n        if char.lower() in vowels:\n            vowel_count += 1\n    return vowel_count\ntext = \"Hello, World!\"\nresult = count_vowels(text)\nprint(result)", "t": "fill", "ans": "3", "kp": "函数", "o": [], "explanation": "函数遍历字符串'Hello, World!'中的每个字符，将其转为小写后判断是否在元音字母集合中。字符串中包含e、o、o三个元音字母，故返回结果为3。" }, { "id": 1922, "q": "以下fact函数的功能是利用递归调用方式计算两整数m、n的最大公约数（其中m>n，且n≠0）。例如，输入112和77，得到最大公约数为7。请在括号（）中填入正确答案。\ndef fact(n,m):\n    if m==0:\n        return ___1___\n    else:\n        return fact(m,__2___)\nn,m=eval(input(\"请输入n,m的值：\"))\ns=fact(n,m)\nprint(\"最大公约数为\",s)", "t": "fill", "ans": "n | n%m", "kp": "函数", "o": [], "explanation": "本题考查辗转相除法求最大公约数。第1空为递归终止条件，当余数m为0时，返回当前的除数n；第2空为递归调用，将除数m作为新的被除数，余数n%m作为新的除数传入。" }, { "id": 1923, "q": "以下程序的输出结果是[*queNo*]_。\ndef mytotal(x,y=30,*z1,**z2):\n    t=x+y\n    for i in range(0,len(z1)):\n         t+=z1[i]\n    for k in z2.values():\n         t+=k\n    return t\ns=mytotal(1,20,2,3,4,5,k1=105,k2=213)\nprint(s)", "t": "fill", "ans": "353", "kp": "函数", "o": [], "explanation": "函数调用时，x=1，y=20，可变参数z1接收(2,3,4,5)，关键字参数z2接收字典。t初始为x+y=21，加上z1元素之和14，再加上z2值之和318，最终t=353。" }, { "id": 1924, "q": "下列Python程序的运行结果是[*queNo*]。\nx=150\nif x%50==0:\n    print(\"yes\")\nelse:\n    print(\"No\")", "t": "fill", "ans": "yes", "kp": "分支结构", "o": [], "explanation": "变量x赋值为150。条件判断x%50==0，即150除以50的余数是否为0。因为150能被50整除，余数为0，条件成立，执行if分支，输出yes。" }, { "id": 1925, "q": "考生文件夹下存在一个文件PY102.py，请写代码替换横线，不修改其他代码，实现以下功能：\na和b是两个列表变量，列表a为[3,6,9]已给定，键盘输入列表b，将a列表的三个元素插入到b列表中对应的前三个元素的后面，并显示输出在屏幕上。\n例如：键盘输入列表b为[1,2,3]，因此，屏幕输出计算结果为[1,3,2,6,3,9]\n提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。", "t": "fill", "ans": "a = [3,6,9]\nb = eval(input()) #例如：[1,2,3]\nj=1\nfor i in range(len(a)):\nb.insert(j,a[i])\nj+= 2\nprint(b)", "kp": "程序填空/调试", "o": [], "rawType": "operation" }, { "id": 1926, "q": "下列代码的输出结果是（）\nx=list()\ny=0\nwhile x:\n    y+=1\nelse: y+=2\nprint(y)", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "0", "1", "2", "出错" ], "explanation": "x被初始化为空列表，其布尔值为False。因此while x的条件不成立，直接跳过循环体，执行while...else结构中的else分支。y初始为0，执行y+=2后结果为2。故选C。" }, { "id": 1927, "q": "已知列表元组tup=(5,6,1,7,1,6), 那么执行语句tup.index(5)的结果为（ ）。", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "0", "1", "2", "3" ], "explanation": "index()方法用于查找指定元素在元组或列表中首次出现的索引位置。元组tup的第一个元素是5，索引从0开始计算，因此5的索引值为0。故选A。" }, { "id": 1928, "q": "下列语句执行后的结果是（ ）。\nfruits={'apple':3,'banana':4,'pear':5}\nfruits['banana']=7\nprint(sum(fruits.values()))", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "7", "19", "12", "15" ], "explanation": "字典fruits初始包含三个键值对。执行赋值语句后，banana的值更新为7。此时所有值分别为3、7、5，使用sum函数对values求和，结果为15。故选D。" }, { "id": 1929, "q": "函数定义的关键字是（）", "t": "single", "ans": "B", "kp": "函数", "o": [ "function", "def", "class", "pass" ], "explanation": "在Python中，定义函数使用的关键字是def。function是其他语言的关键字，class用于定义类，pass是空语句占位符。故选B。" }, { "id": 1930, "q": "下列程序的输出结果是[*queNo*]___。\ns=10\nfor i in range(1,6):\n    while True:\n        if i%2==1:\n            break\n        else:\n            s-=1\n            break\nprint(s)", "t": "fill", "ans": "8", "kp": "循环结构", "o": [], "explanation": "循环变量i从1遍历到5。当i为奇数时，满足条件直接break跳出内层循环；当i为偶数(2和4)时，执行s-=1使s减1，然后break。共执行2次减1操作，s由10变为8。" }, { "id": 1931, "q": "从键盘输入10个英文单词，输出其中以元音字母开关的单词。请完成以下程序。\nss='AEIOUaeiou'\nfor i in range(0,10):\ns=input(\"Please enter a word:\")\nfor c in __1____ :\n    if ____2___ ==c:\n        print(s)\n        break", "t": "fill", "ans": "ss | s[0]", "kp": "程序填空/调试", "o": [], "explanation": "第1空遍历元音字母集合，应填ss；第2空判断单词首字母是否为当前元音字母，应填s[0]获取字符串首字符。" }, { "id": 1932, "q": "程序填空题\n将字典 student 中的每个键都转换为大写，并将结果存储在新的字典 student_upper 中。\nstudent = {\"name\": \"John\", \"age\": 18, \"grade\": \"A\"}\nstudent_upper = {}\nfor key, value in student.items():\n       student_upper[ ___ ] = value", "t": "fill", "ans": "key.upper()", "kp": "程序填空/调试", "o": [], "explanation": "遍历字典键值对时，需将原键转换为大写作为新字典的键。字符串方法upper()可将字母转为大写，故填key.upper()。" }, { "id": 1933, "q": "下面代码的输出结果是（）。\nz=12.12+34j\nprint(z.real)", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "34", "34.0", "12.12", "12" ], "explanation": "Python中复数对象有real和imag属性，分别获取实部和虚部。z.real返回实数部分12.12，故选C。" }, { "id": 1934, "q": "用python进行计算，（）的结果是精确的，不存在误差。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "9999**99", "9.999**99", "0.4-0.1", "0.4-0.1-0.3" ], "explanation": "Python中整数运算支持任意精度，不会产生浮点数误差，故整数幂运算结果精确。浮点数运算存在精度丢失问题，故选A。" }, { "id": 1935, "q": "下列代码的输出结果是（）\na=18\nb=6\nif(a//b):\n   r=a+b\nelif a:\n   r=a%b\nelse:\n   r=1\nprint(r)", "t": "single", "ans": "D", "kp": "分支结构", "o": [ "0", "1", "3", "24" ], "explanation": "a//b即18//6结果为3，在if条件中非零整数视为True，因此执行r=a+b，即18+6=24。后续elif和else不执行，输出24，选D。" }, { "id": 1936, "q": "下列语句执行后的结果是（）\ndict1={'a':1,'b':2,'c':3}\nprint(len(dict1),max(dict1))", "t": "single", "ans": "B", "kp": "字典/集合", "o": [ "3 3", "3 c", "6 3", "6 c" ], "explanation": "len(dict1)返回字典键值对数量，为3。max(dict1)对字典的键进行比较，字符串'a','b','c'中最大的是'c'。故输出3 c，选B。" }, { "id": 1937, "q": "下列程序的输出结果是（ ）。\nf=open('c:\\\\out.txt','w+')\nf.write('Python')\nf.seek(0)\nc=f.read(2)\nprint（C）\nf.close()", "t": "single", "ans": "C", "kp": "文件操作", "o": [ "Pyth", "Python", "Py", "th" ], "explanation": "文件以'w+'模式打开并写入'Python'，seek(0)将指针移到开头。read(2)读取前2个字符即'Py'。代码中print（C）的大写C未定义，应为小写c的笔误，按小写c解析输出Py，选C。" }, { "id": 1938, "q": "以下代码的输出结果是（）。\na=5.2\nb=2.5\nprint(a//b)", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "2", "2.08", "2.1", "2.0" ], "explanation": "//为地板除，结果为向下取整。5.2除以2.5等于2.08，向下取整为2。因操作数是浮点数，结果保留浮点格式为2.0，选D。" }, { "id": 1939, "q": "在Python 函数中，用于获取用户输入的是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "input()", "print()", "Eval()", "get()" ], "explanation": "Python内置函数input()用于从标准输入读取用户输入的一行文本。print()用于输出，eval()用于执行字符串表达式，故选A。" }, { "id": 1940, "q": "下面的代码在运行时输入“1”，则输出结果是（）。\nx=input()\nif x== '1':\n    print('One')\nelse:\n    print('other')", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "One", "没有输出", "报错", "other" ], "explanation": "input()函数返回的是字符串类型。输入1时，变量x的值为字符串'1'，满足x == '1'的条件，因此执行print('One')，选A。" }, { "id": 1941, "q": "下列语句执行后的结果是（）\n>>> dict1={'a':1,'b':2,'c':3}\n>>> 'b' in dict1", "t": "single", "ans": "A", "kp": "字典/集合", "o": [ "Ture", "False", "No", "Yes" ], "explanation": "in运算符用于判断元素是否存在于字典的键中。'b'是字典dict1的键，表达式返回True。选项A将True拼写为Ture，属排版错误，选A。" }, { "id": 1942, "q": "关于Python的复数类型，以下选项中描述错误的是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "复数类型表示数学中的复数", "对于复数z，可以用z.imag获得实数部分", "复数的虚数部分通过后缀J或j来表示", "对于复数z，可以用z.real获得实数部分" ], "explanation": "复数对象中，z.real用于获取实部，z.imag用于获取虚部。选项B称z.imag获取实数部分是错误的，故选B。" }, { "id": 1943, "q": "以下不合法的表达式是（ ）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "x in [1,2,3,4,5]", "x-6>5", "e>5 and 4==f", "3=a" ], "explanation": "赋值语句中，等号左边必须是变量或可修改的对象，不能是常量。选项D将变量a赋值给常量3，语法错误。其他选项均为合法的逻辑或关系表达式。" }, { "id": 1944, "q": "为了给整型变量x，y，z赋初值10，下面正确的Python赋值语句是（ ）。", "t": "single", "ans": "C", "kp": "基础语法与输入输出", "o": [ "xyz=10", "x=10 y=10 z=10", "x=y=z=10", "x=10,y=10,z=10" ], "explanation": "Python支持连续赋值语法，x=y=z=10可以同时将10赋值给x、y、z。选项A只创建了一个名为xyz的变量；选项B缺少分号或换行；选项D会创建元组并尝试解包，语法不正确。" }, { "id": 1945, "q": "语句x=input()执行时，如果从键盘输入12并按回车键，则x的值是（）", "t": "single", "ans": "A", "kp": "基础语法与输入输出", "o": [ "'12'", "12", "(12)", "12.0" ], "explanation": "Python中的input()函数接收用户从键盘输入的内容，并统一将其作为字符串类型返回。因此输入12后，x的值是字符串'12'，而不是整数12。" }, { "id": 1946, "q": "以下代码的输出结果是（）。\nn=-5\ns=100\nif n>=5:\n   if n<=5:\n      n-=10\n      s=3\n   else:\n      s=4\nprint(s)", "t": "single", "ans": "C", "kp": "分支结构", "o": [ "3", "4", "100", "2" ], "explanation": "初始时n=-5，s=100。判断条件n>=5为False，因此不会执行内部的if-else分支，s的值保持初始的100不变。最后打印s，输出100。" }, { "id": 1947, "q": ">>> 3 not in(20,15,3,14,5) 的结果为（ ）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "False", "True", "不确定", "错误" ], "explanation": "in运算符用于判断元素是否存在于序列中。3存在于元组(20,15,3,14,5)中，因此3 in (...)为True。加上not取反后，结果为False。" }, { "id": 1948, "q": "设有程序段：\ns=10\nfor i in range(1,6,3):\n    pass\nprint(s, end= ' ')\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "11", "10", "9", "8" ], "explanation": "循环变量i依次取1和4，但循环体内只有pass语句，不执行任何操作，也没有修改s的值。因此循环结束后，s仍为初始值10。" }, { "id": 1949, "q": "执行下列程序后，t的值是（ ）。\nt=1\nn=1163\nfor i in range(1,2):\n    while n:\n        t= t*(n%10)\n       n//=10", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "1", "10", "17", "18" ], "explanation": "循环提取n的每一位数字并累乘到t中。n=1163，各位数字依次为3、6、1、1。t的初始值为1，累乘过程为：1*3=3，3*6=18，18*1=18，18*1=18。最终t的值为18。" }, { "id": 1950, "q": "若string='Hello_World'，则string[:-6]*2的值是（）。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "'Hello_Hello_'", "'World_World'", "'HelloHello'", "执行时报错" ], "explanation": "字符串长度为11。切片[:-6]表示从开头到倒数第6个字符（不含），即前5个字符'Hello'。将其乘以2，得到字符串重复拼接的结果'HelloHello'。" }, { "id": 1951, "q": "已知x=['a','b',0,1,2]，则any(x)的值是（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "False", "True", "false", "true" ], "explanation": "any()函数用于判断可迭代对象中是否至少有一个元素的布尔值为True。列表x中包含非空字符串和非零数字，它们的布尔值均为True，因此any(x)返回True。注意Python中布尔值首字母大写。" }, { "id": 1952, "q": "对于元组T=('abc',2,[1,2,3],'hello')，T[-1][-1]的值是（ ）。", "t": "single", "ans": "B", "kp": "列表/元组", "o": [ "'h'", "'o'", "[1, 2, 3]", "'hello'" ], "explanation": "T[-1]获取元组的最后一个元素，即字符串'hello'。接着[-1]获取该字符串的最后一个字符，即'o'。" }, { "id": 1953, "q": "下列程序执行后，p的值是（ ）。\na=[[1,2,3],[4,5,6],[7,8,9]]\np=1\nfor i in range(len(a)):\n      p*=a[i][i]", "t": "single", "ans": "A", "kp": "列表/元组", "o": [ "45", "15", "6", "28" ], "explanation": "len(a)为3，循环变量i依次取0、1、2。a[i][i]依次获取二维列表的主对角线元素：a[0][0]为1，a[1][1]为5，a[2][2]为9。p初始为1，累乘结果为1*1*5*9=45。" }, { "id": 1954, "q": "下列代码运行后的结果是（ ）。\ndef total(x):\n    if x>6:\n        return x-total(x-2)\n    else:\n        return 3\nprint(\"{}\".format(total(10)))", "t": "single", "ans": "D", "kp": "函数", "o": [ "-5", "-1", "2", "5" ], "explanation": "递归调用过程：total(10)=10-total(8)；total(8)=8-total(6)；total(6)满足x<=6，返回3。回代计算：total(8)=8-3=5；total(10)=10-5=5。最终输出5。" }, { "id": 1955, "q": "关于turtle库，下列哪个选项的描述是错误的？（ ）", "t": "single", "ans": "D", "kp": "random/turtle等标准库", "o": [ "turtle库最早成功应用于LOGO编程语言", "turtle绘图体系中海龟移动的路径绘制成了图形", "turtle库是一个图形绘制函数库，使用起来直观生动", "turtle坐标系的原点默认在屏幕左上角" ], "explanation": "turtle绘图窗口的坐标系原点(0,0)默认位于画布的正中央，而不是屏幕左上角。选项A、B、C关于turtle库的历史、绘图原理和特点的描述均正确。" }, { "id": 1956, "q": "下列程序运行的结果是什么？\ndef calculate(numbers):\n    total = sum(numbers)\n    average = total / len(numbers)\n    return average\nnumbers = [1, 2, 3, 4, 5, 6, 7, 8]\nresult = calculate(numbers)\nprint(result)", "t": "fill", "ans": "4.5", "kp": "函数", "o": [], "explanation": "函数calculate接收列表并计算平均值。传入列表[1到8]，sum求和为36，len获取长度为8，36除以8得到4.5，最终打印该结果。" }, { "id": 1957, "q": "以下程序的输出结果是[*queNo*]__。\ns=10\ndef fact(n):\n    global s\n    s=0\n    for i in range(1,n):\n        for j in range(1,n):\n            if i==j:\n                s=s+i*j\n    return s;\ny=fact(5)\nprint(y)", "t": "fill", "ans": "30", "kp": "函数", "o": [], "explanation": "函数内使用global将全局变量s重置为0。双重循环i和j的范围是1到4。当i等于j时，s累加i*j，即计算1²+2²+3²+4²，结果为1+4+9+16=30。" }, { "id": 1958, "q": "下列Python程序的运行结果是[*queNo*]_。\na=400\nb=50\nc=0\nif a7f}里面的'f'表示这个位置是一个整数", "模板字符串里的格式控制信息语法格式是：{:}，参数序号是从1开始", "格式控制信息{:*^10}表示这个位置是最大长度为10的整数", "逗号分隔的参数可以是变量，也可以是函数" ], "explanation": "format方法中，'f'表示浮点数而非整数；参数序号默认从0开始；{:*^10}表示居中对齐并用*填充，不限制数据类型；逗号分隔的参数可以是变量或函数调用，D正确。" }, { "id": 1960, "q": "下面if语句分别统计“性别（gender）为男生”和“性别（gender）为女生”的人数，正确的语句为（）。", "t": "single", "ans": "A", "kp": "分支结构", "o": [ "n=0\nm=0\nif gender==\"男\":\nn=n+1\nelse:\nm+=1", "if gender==\"男\":\nn+=1", "if gender==\"女\":\nn=n+1", "n=0\nm=0\nif gender==\"男\"\nn=n+1\nelse\nm+=1" ], "explanation": "统计人数需先初始化计数器，再使用if-else分支。A选项正确初始化了n和m，且if-else语法正确；B和C缺少另一半统计及初始化；D选项的if和else后缺少冒号。" }, { "id": 1961, "q": "3 and 4的值为（ ）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "3", "4", "不确定", "错误" ], "explanation": "Python中逻辑与运算符and的求值规则为：如果第一个操作数为真，则返回第二个操作数的值。因为3在布尔上下文中为真，所以表达式返回第二个操作数4。" }, { "id": 1962, "q": "设有程序段：\ns='￥'\nfor i in range(10):\n    pass\nprint(s, end= '')\n则程序的运行结果是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "打印2个￥", "打印1个￥", "打印10个￥", "打印0个￥" ], "explanation": "for循环遍历range(10)，但循环体内只有pass语句，不执行任何操作。循环结束后，程序执行一次print语句，因此只在屏幕上打印1个'￥'字符。" }, { "id": 1963, "q": "以下程序的运行结果是（ ）。\ns=1\nwhile not s:\n    s=1\n    print(1,end='')\nprint(2,end='')", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "1", "2", "12", "没有输出" ], "explanation": "变量s初始赋值为1。while循环的条件是not s，即not 1，结果为False。因此循环体不会执行，程序直接跳过while循环，执行最后的print语句输出2。" }, { "id": 1964, "q": "以下关于字典类型的描述，错误的是：( )。", "t": "single", "ans": "D", "kp": "字典/集合", "o": [ "字典类型是一种无序的对象集合，通过键来存取", "使用clear()方法可以删除字典的所有元素，使其变成一个空字典", "字典类型可以包含列表和其他数据类型，字典可以嵌套", "字典类型中的数据可以进行分片和合并操作" ], "explanation": "字典是键值对集合，通过键来存取数据，支持clear()清空和嵌套其他数据类型。但由于字典基于哈希表实现，不支持像列表或字符串那样的索引分片（切片）操作。" } ] }