|
Cython 将静态类型系统引入到了 Python 中，实现了基于类型的优化。但问题来了， 如果一个变量可能是不同的类型，该怎么办呢？比如一个变量既可能是整型，也可能是浮点型。 而 Cython 也考虑到了这一点，就是下面要介绍的融合类型。说融合类型可能让人感到陌生，如果说泛型是不是就很熟悉了。 Cython 目前提供了三种我们可以直接使用的融合类型，integral、floating、numeric，含义如下：
integral：等价于 C 的 short, int, long； floating：等价于 C 的 float, double； numeric：最通用的类型，包含上面的 integral、floating 以及复数；
当然这三个融合类型无法直接用，需要通过 cimport 导入。 from cython cimport integral
cpdef integral integral_max(integral a, integral b):
return a if a >= b else b
上面这段代码，Cython 将会创建三个版本的函数：1）参数 a 和 b 都是 short 类型；2）参数 a 和 b 都是 int 类型；3）参数 a 和 b 都是 long 类型。 在调用的时候可以显式指定类型，否则会选择范围最大的类型，举个例子： print(integral_max(<short> 1, <short> 2))
print(integral_max(<int> 1, <int> 2))
print(integral_max(<long> 1, <long> 2))
如果一个融合类型声明了多个参数，那么这些参数的类型都必须是融合类型中的同一种，所以下面的调用都是不合法的。 print(integral_max(<short> 1, <int> 2))
print(integral_max(<int> 1, <long> 2))
print(integral_max(<long> 1, <short> 2))
融合类型相当于多个类型的组合，比如 integral 是 short, int, long 的组合，至于 integral 最终会表现出哪一种，则取决于传递的参数。但融合类型在同一时刻，只能表示一种类型，什么意思呢？比如我们上面的参数 a 和 b 的类型是相同的，都是 integral 类型，那么最终 a 和 b 要么都是 short、要么都是 int、要么都是 long，不存在 a 是 int、b 是 short 这种情况。
当然这背后的原理我们也说了，如果出现了融合类型，那么 Cython 会根据融合类型里面的每一个类型都单独创建一个函数。在调用时，根据传递参数类型，来判断调用哪一个版本的函数。 到目前为止，总共出现了三个融合类型，都需要从 cython 这个名字空间里面 cimport 之后才能使用。那么问题来了，我们能不能自己创建融合类型呢？答案是可以的。 ctypedef fused list_tuple:
list
tuple
# a 和 b 要么都为列表、要么都为元组
# 但不可以一个是列表、一个是元组
cpdef list_tuple func(list_tuple a, list_tuple b):
return a + b
# Cython 会根据我们传递的参数来判断，调用哪一种函数
print(
func([1, 2], [3, 4])
) # [1, 2, 3, 4]
# 我们也可以显式指定要调用的函数版本
print(
func[list]([11, 22], [33, 44])
) # [11, 22, 33, 44]
print(
func[tuple]((111, 222), (333, 444))
) # (111, 222, 333, 444)
还是挺简单的，并且组合成融合类型的多个类型，可以是 C 的类型，也可是 Python 的类型。 另外再次强调，list_tuple 虽然既可以是 list，也可以是 tuple，但是在同一个函数中只能表现出一种类型。如果我们给 a 传递 list、给 b 传递 tuple，看看会有什么结果。 import pyximport
pyximport.install(language_level=3)
import cython_test
try:
cython_test.func([], ())
except TypeError as e:
print(e)
"""
Argument 'b' has incorrect type (expected list, got tuple)
"""
# 当 a 接收的是一个列表时
# 那么就可以将 list_tuple 看成是 list 了
# 于是 b 也必须接收一个列表
try:
cython_test.func((), [])
except TypeError as e:
print(e)
"""
Argument 'b' has incorrect type (expected tuple, got list)
"""
# 当 a 接收的是一个元组时
# 那么就可以将 list_tuple 看成是 tuple 了
# 于是 b 也必须接收一个元组
另外我们上面只出现了一种融合类型，我们还可以定义多种。 ctypedef fused list_tuple:
list
tuple
ctypedef fused dict_set:
dict
set
# 会生成如下四种版本的函数：
# 1) 参数 a、c 为列表，b、d 为字典
# 2) 参数 a、c 为列表，b、d 为集合
# 3) 参数 a、c 为元组，b、d 为字典
# 4) 参数 a、c 为元组，b、d 为集合
cdef func(list_tuple a,
dict_set b,
list_tuple c,
dict_set d):
print(a, b, c, d)
# 会根据我们传递参数来判断选择哪一个版本的函数
func([1], {"x": ""}, [], {})
"""
[1] {'x': ''} [] {}
"""
# 依旧可以显式指定类型，不让 Cython 帮我们判断
# 但由于存在多种混合类型
# 一旦指定、那么每一个混合类型都要指定
func[list, dict]([1], {"x": ""}, [], {})
"""
[1] {'x': ''} [] {}
"""
此外，我们必须写成 func[list, dict] 这种形式，不可以是 func[dict, list]。因为类型为 list_tuple 的参数先出现，类型为 dict_set 的参数后出现。所以中括号里面第一个出现的类型一定是 list_tuple 里面的类型（list 或 tuple），第二个是 dict_set 里面的类型（dict 或 set）。 因此一旦指定版本，那么只能是以下四种之一： func[list, dict](...) func[list, set](...) func[tuple, dict](...) func[tuple, set](...)
当然啦，别忘记在传参的时候务必保证参数类型正确。
多说一句题外话，如果你用过 Go 的话，你会发现 Go 的泛型和 Cython 的融合类型非常相似，我们举个栗子。
Go 泛型： 
Cython 融合类型：
对比一下之后，是不是发现两者非常像呢？但很明显，Cython 的融合类型、或者也叫泛型，在设计上要更优秀一些。比如定义完 T 之后，直接使用 T 即可；而 Go 里面在定义完 T 之后还不能直接用，必须要再起一个名字（T1），然后用这个新起的名字。 好了，言归正传，在定义函数时，不仅仅只有融合类型，还可以有具体的类型，举个例子： ctypedef fused list_tuple:
list
tuple
ctypedef fused dict_set:
dict
set
# 里面除了融合类型之外，还有一个 int 类型
cdef func(list_tuple a,
dict_set b,
int xxx,
list_tuple c,
dict_set d):
print(a, b, c, d, xxx)
# 显然调用是无影响的，因为在 func 后面的 [ ] 里面
# 只需要指定融合类型对应的具体类型，其它的不需要管
func[list, dict]([1], {"x": ""}, 123, [], {})
func[list, set]([1], {1, 2, 3}, 456, [], {2})
最后，上面的 func 函数还有一种调用方式，我们来看一下： cdef func(list_tuple a,
dict_set b,
int xxx,
list_tuple c,
dict_set d):
print(a, b, c, d, xxx)
# 声明一个函数指针，指向的函数接收五个参数
# 类型分别是 list, set, int, list, set，返回 object
# 此时必须将所有参数的类型全部指定，不能只指定融合类型
# 并且声明为同一种融合类型的参数的具体类型仍然要一致
cdef object (*func_with_list_set)(list, set, int, list, set)
# 赋值
func_with_list_set = func
func([], {1}, 123, [], {2})
"""
[] {1} [] {2} 123
"""
# 或者这种方式也是可以的
# 将 func 转成 <object (*)(list, set, int, list, set)>
# 相当于将函数指针转成了接收五个参数、返回一个object类型的指针
(<object (*)(list, set, int, list, set)> func)([], {1}, 123, [], {2})
"""
[] {1} [] {2} 123
"""
# 还有就是之前的方式，只不过可以拆开使用
# [] 里面只需要指定融合类型
cdef func_with_tuple_dict = func[tuple, dict]
func_with_tuple_dict((1, 2), {"a": "b"}, 456, (11, 22), {"b": "a"})
"""
(1, 2) {'a': 'b'} (11, 22) {'b': 'a'} 456
"""
到此，关于融合类型的创建和用法我们就说完了，总之融合类型不仅可以用在函数的参数和返回值中，也可以用于普通的变量声明。
但是变量到底是融合类型的哪一种，还需要我们动态判断。 ctypedef fused list_tuple_dict:
list
tuple
dict
# 在判断的时候，可以对 val 进行判断
# 比如使用 type 或者 isinstance
# 但是我们还可以对融合类型本身判断
cpdef func(list_tuple_dict val):
"""
Cython 会根据该函数生成以下三个函数
cdef func(list val)
cdef func(tuple val)
cdef func(dict val)
根据 val 类型的不同，调用不同版本的函数
所以不管最终调用的是哪一个版本的函数
类型都是确定的
"""
# 因此在编写代码的时候
# 根据融合类型本身就可以判断
if list_tuple_dict is list:
print("val 是 list 类型")
elif list_tuple_dict is tuple:
print("val 是 tuple 类型")
else:
print("val 是 dict 类型")
然后我们调用一下试试： import pyximport
pyximport.install(language_level=3)
import cython_test
cython_test.func([])
cython_test.func(())
cython_test.func({})
"""
val 是 list 类型
val 是 tuple 类型
val 是 dict 类型
"""
# 如果类型不是融合类型中的任意一种
# 那么就会报错
try:
cython_test.func(123)
except TypeError as e:
print(e)
"""
No matching signature found
"""
混合类型具体会是哪一种类型，在参数传递的时候便会得到确定。 因此 Cython 中的泛型编程还是很强大的，但是在工作中的使用频率其实并不是那么频繁。
|
