2024软考《软件设计师》-Python专题知识（含历年真题解析）

        自2020年之后，软考软件设计师考试在综合知识部分开始增加Python编程语言相关考点，每年会考2~3分的样子。本文将结合近几年常考的内容，扩展一下Pyhton的基础知识！考前看一看，或许有所帮助。

 一、基础语法

标识符

• 第一个字符必须是字母表中字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。

在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。

注释

Python中单行注释以 # 开头

多行注释可以用多个 # 号，还有 ' ' ' 和 " " "

行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

二、数据类型

2.1、数字(Number)

python 支持三种不同的数值类型：

• 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。

• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

Python 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将x转换为一个整数。

• float(x) 将x转换到一个浮点数。

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

以下实例将浮点数变量 a 转换为整数：

>>> a = 1.0
>>> int(a)
1

Python 数字运算

Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。

表达式的语法很直白： +, -, * 和 /, 和其它语言（如Pascal或C）里一样。例如：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # 总是返回一个浮点数
1.6

注意：在不同的机器上浮点运算的结果可能会不一样。

在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：

>>> 17 / 3  # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 17 % 3  # ％操作符返回除法的余数
2
>>> 5 * 3 + 2 
17

注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 

Python 可以使用 ** 操作来进行幂运算：

>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128

2.2、字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Runoob"

Python 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号 [ ] 来截取字符串，字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

如下实例：

#!/usr/bin/python3
 
var1 = 'Hello World!'
var2 = "Runoob"
 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])


# 运行结果为：
var1[0]:  H
var2[1:5]:  unoo

Python 字符串更新

你可以截取字符串的一部分并与其他字段拼接，如下实例：

#!/usr/bin/python3
 
var1 = 'Hello World!'
 
print ("已更新字符串 : ", var1[:6] + 'Runoob!')


#运行结果为：
已更新字符串 :  Hello Runoob!

Python 字符串运算符

下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：

2.3、列表

序列是 Python 中最基本的数据结构。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

Python 有 6 个序列的内置类型，但最常见的是列表和元组。

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

访问列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

通过索引列表可以进行截取、组合等操作。

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

使用下标索引来访问列表中的值，同样你也可以使用方括号 [ ] 的形式截取字符，如下所示：

更新列表

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：

#!/usr/bin/python3

list = ['Google', 'Runoob', 1997, 2000]

print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)


#以上实例输出结果：
第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

删除列表元素

可以使用 del 语句来删除列表中的元素，如下实例：

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)


#输出结果为：
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 列表截取与拼接

Python 的列表截取与字符串操作类似，如下所示：

L=['Google', 'Runoob', 'Taobao']

>>> L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>

列表还支持拼接操作：

>>> squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

Python列表函数&方法

2.4、元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

#!/usr/bin/python3
 
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])


#以上实例输出结果：
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

#!/usr/bin/python3
 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)


#以上实例输出结果：
(12, 34.56, 'abc', 'xyz')

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

#!/usr/bin/python3
 
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)


#以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

元组运算符

与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')

运行实例如下：

>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')
>>>

元组内置函数

2.5、字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 { } 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

一个简单的字典实例：

tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

也可如此创建字典：

tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }

创建空字典

使用大括号 { } 创建空字典：

# 使用大括号 {} 来创建空字典
emptyDict = {}
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:", len(emptyDict))
 
# 查看类型
print(type(emptyDict))



#以上实例输出结果：
{}
Length: 0
<class 'dict'>

使用内建函数 dict( ) 创建字典：

emptyDict = dict()
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:",len(emptyDict))
 
# 查看类型
print(type(emptyDict))




#以上实例输出结果：
{}
Length: 0
<class 'dict'>

访问字典里的值

把相应的键放入到方括号中，如下实例:

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])


#以上实例输出结果：
tinydict['Name']:  Runoob
tinydict['Age']:  7

如果用字典里没有的键访问数据，会输出错误！

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "Python教程"  # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])


#以上实例输出结果：
tinydict['Age']:  8
tinydict['School']:  Python教程

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显式删除一个字典用del命令，如下实例：

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])



#但这会引发一个异常，因为用执行 del 操作后字典不再存在：
Traceback (most recent call last):
  File "/runoob-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined

字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

• 1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住（即第一个被覆盖）。
• 2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

字典内置函数&方法

2.6、集合

集合（set）是一个无序的不重复元素序列。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

创建格式：

parame = {value01,value02,...}
或者
set(value)


#以下是一个简单实例：
set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

更多实例演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}



#类似列表推导式，同样集合支持集合推导式(Set comprehension):
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

集合添加元素

语法格式如下：

s.add( x )

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )

x 可以有多个，用逗号分开。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>

移除元素

语法格式如下：

s.remove( x )

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop() 

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)


输出结果：
Runoob

多次执行测试结果都不一样。

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

计算集合元素个数

len(s)

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3

清空集合

s.clear()

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

判断元素是否在集合中存在

x in s

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>

集合内置方法完整列表

三、扩展知识

Python哪些模块支持深度学习模型

Python中支持深度学习模型的主要模块是Keras，它是TensorFlow或Theano框架的高级API。

另外一个流行的深度学习库是PyTorch，它提供了更灵活的方式来定义和训练模型。

四、历年真题汇总

【2024上半年】1、执行以下Python语句之后，列表y为（   ）。
x=[1,2,3]
y=x+[4,5,6]
A.出错
B.[1,2,3,4,5,6]
C.[5,7,9]
D.[1,2,3,[4,5,6]]

答案：B

解析：在python语言中，+属于拼接，对于y=[1,2,3]+ [4,5,6]两者的拼接情况为一个列表[1,2,3,4,5,6]。

---

【2024上半年】在Python语言中，（  ）是一种可变的、有序的序列结构，其中元素可以重复。
A.元组(tuple)
B.字符串(str)
C.列表(list)
D.集合(set)

答案：C

解析：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）。

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

A、tuple（元组）类似于list列表，元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

B、dict（字典）是除列表以外python之中最灵活的内置数据结构类型；列表是有序的对象集合，字典是无序的对象集合；字典用"{ }"标识；字典由索引（key）和它对应的值value组成。

C、list（列表）可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套或者叫多维列表，可以用来表示多维数组）。列表用 [ ] 标识，是 python 最通用的复合数据类型。本题描述的可变、有序、可重复的数据类型应该是C选项列表。

D、set（集合）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员；基本功能是进行成员关系测试和删除重复元素；可以使用大括号 { } 或者 set() 函数创建集合。

因此，ABD描述不符，本题选择C选项。

---

【2023上半年】关于Python语言的叙述中，不正确的是（  ）。
A.for语句可以用于在序列（如列表、元组和字符串）上进行迭代访问
B.循环结构如for和while后可以加else语句
C.可以用if...else和switch..case语句表示选择结构
D.支持嵌套循环

答案：C

解析：Python没有内置的switch...case语句，而是使用if...elif...else结构来表示选择结构。虽然可以使用字典和函数来实现类似switch...case的功能，但这不是Python语言本身的一部分。  

---

在Python语言中，语句x=（  ）不能定义一个元组。
A.(1,2,1,2)
B.1,2,1,2
C.tuple ()
D.(1)

答案：D

解析：在Python语言中，定义一个元组可将一组元素放在圆括号()中，元素之间用逗号,分隔，也可以使用没有显式圆括号的语法定义元组，还可以是创建一个空元组。
如果元组只包含一个元素，那么你也需要在该元素后面加上一个逗号，以区分它是一个元组而不是一个被圆括号包围的单独值。  
ABC的方式正确，本题选择D选项。

---

Python中采用（  ）方法来获得一个对象的类型。
A.str ()
B.type ()
C.id ()
D.object ()

答案：B

解析：str函数是Python的内置函数，它将参数转换成字符串类型。
type 函数可以用来查询对象的类型。
id函数返回对象的唯一标识符，标识符是一个整数。
object函数返回一个空对象，我们不能向该对象添加新的属性或方法。
因此，ACD描述与题意不符，本题选择B选项。

---

在Python语言中，（ ）是一种不可变的、有序的序列结构，其中元素可以重复。
A.tuple(元组)
B.dict(字典)
C.list(列表)
D.set(集合)

答案：A

解析：不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）。
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
tuple(元组)类似于list列表，元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
dict(字典)是除列表以外python之中最灵活的内置数据结构类型；列表是有序的对象集合，字典是无序的对象集合；字典用"{ }"标识；字典由索引(key)和它对应的值value组成。
list(列表)可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套或者叫多维列表，可以用来表示多维数组）。列表用 [ ] 标识，是 python 最通用的复合数据类型。
set(集合)是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员；基本功能是进行成员关系测试和删除重复元素；可以使用大括号 { } 或者 set() 函数创建集合。

---

某Python程序中定义了X=[1，2]，那么X*2的值为（ ）。
A.[1，2，1，2]
B.[1，1，2，2]
C.[2，4]
D.出错

答案：A

解析：列表（list）的乘法操作 * 并不是用于将列表中的每个元素都乘以某个数，而是用于将列表复制指定的次数。
所以，当你执行 X*2 时，实际上是在将列表 X 复制一次，然后将两个相同的列表拼接在一起。
给定 X = [1, 2]，执行 X*2 的结果将是 [1, 2, 1, 2]。  
因此，BCD描述与题意不符，本题选择A选项。  

---

以下Python语言的模块中，（  ）不支持深度学习模型。
A.TensorFlow
B.Matplotlib
C.PyTorch
D.Keras

答案：B

解析：

A选项TensorFlow：Tensorflow拥有多层级结构，可部署于各类服务器、PC终端和网页并支持GPU和TPU高性能数值计算，被广泛应用于谷歌内部的产品开发和各领域的科学研究，支持Python语言深度学习。

B选项Matplotlib：Matplotlib 是一个 Python 的 2D绘图库，它以各种硬拷贝格式和跨平台的交互式环境生成出版质量级别的图形，不支持深度学习。答案选B。

C选项PyTorch：PyTorch是一个针对深度学习，并且使用GPU和CPU来优化的tensor library（张量库）是由Torch7团队开发，是一个以Python优先的深度学习框架，不仅能实现强大的GPU加速，同时还支持动态的神经网络。

D选项Keras：Keras是一个由Python编写的开源人工神经网络库，可以作为Tensorflow、Microsoft-CNTK和Theano的高阶应用程序接口，进行深度学习模型的设计、调试、评估、应用和可视化。

因此，ACD描述不符，本题选择B选项。

---

Python 语言的特点不包括（  ）。
A.跨平台、开源
B.编译型
C.支持面向对象程序设计
D.动态编程

答案：B

解析：python语义的特点：
跨平台、开源、简单易学、面向对象、可移植性、解释性、开源、高级语言、可扩展性、丰富的库、动态编程等等
B选项错误，python不是编译型语言，而是解释型语言。
因此，ACD描述不符，本题选择B选项。