python-ctypes模块中文帮助文档
内容：
.加载动态链接库
.从已加载的dll中引用函数
.调用函数1
.基本的数据类型
.调用函数2
.用自己的数据类型调用函数
.确认需要的参数类型（函数原型）
.返回值
.传递指针
.结构和联合
.结构或联合的对齐方式和字节的顺序
.结构和联合中的位
.数组
.指针
.类型转换
.未完成的类型
.回调函数
.访问dlls导出的值
.可变长度的数据类型
.bugs 将要做的和没有做的事情
注意：本文中的代码例子使用doctest确保他们能够实际工作。一些代码例子在linux和windows以及苹果机上执行有一定的差别
注意：一些代码引用了ctypes的c_int类型。它是c_long在32位机子上的别名，你不应该变得迷惑，如果你期望
的是c_int类型，实事上打印的是c_long，它们实事上是相同的类型。
加载动态链接库
ctypes加载动态链接库，导出cdll和在windows上同样也导出windll和oledll对象。
加载动态链接库后，你可以像使用对象的属性一样使用它们。cdll加载使用标准的cdecl调用约定的链接库，
而windll库使用stdcall调用约定，oledll也使用stdcall调用约定，同时确保函数返回一个windows HRESULT错误代码。这错误
代码自动的升为WindowsError Python exceptions，当这些函数调用失败时。
这有一些windows例子，msvcrt是微软的c标准库，包含大部分的标准c函数，同时使用cdecl调用约定。
注：cdecl和stdcall的区别请见https://www.sodocs.net/doc/5413690897.html,/log-20.html
>>> from ctypes import *
>>> print windll.kernel32 # doctest: +WINDOWS
>>> print cdll.msvcrt # doctest: +WINDOWS
>>> libc = cdll.msvcrt # doctest: +WINDOWS
>>>
windows自动添加常用的.dll文件后缀名
在linux上，需要使用包含扩展名的文件名来加载一个库，因此属性操作不能正常使用。或者使用dll加载器的
LoadLibrary方法，或者通过CDLL构造函数创建一个CDLL的一个实例
>>> cdll.LoadLibrary("libc.so.6") # doctest: +LINUX
>>> libc = CDLL("libc.so.6") # doctest: +LINUX
>>> libc # doctest: +LINUX
>>>
加载dll使用其中函数
使用函数就像对象的属性
>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print windll.kernel32.GetModuleHandleA # doctest: +WINDOWS
<_FuncPtr object at 0x...>
>>> print windll.kernel32.MyOwnFunction # doctest: +WINDOWS
Traceback (most recent call last):
File "
File "ctypes.py", line 239, in __getattr__
func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>00
注意win32系统dll像kernel32和user32大部分导出ANSI和UNICODE版本函数，UNICODE 版本以一个W结尾导出
而ANSI版本则以一个A结尾导出的。win32 GetModuleHandle函数，返回一个指定的module 名字的module句柄
下面c原型，GetModuleHandle的macro，依赖于它是不是UNICODE。
/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);
windll不会神奇的自已去选择一个，你必须显式确认GetModuleHandleA或者GetModuleHandleW去使用它们
去处理一般字符串或unicode字符串。
有时候，dll导出函数名，python无法识别，像"??2@YAPAXI@Z". 在这情况下，你必须使用getattr去使用这些函数
>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z") # doctest: +WINDOWS
<_FuncPtr object at 0x...>
>>>
在windows上，一些dllS不是导出函数名，而是以顺序，这些函数可以将这些数字当作dll 对象的索引来使用
这些函数。
>>> cdll.kernel32[1] # doctest: +WINDOWS
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0] # doctest: +WINDOWS
Traceback (most recent call last):
File "
File "ctypes.py", line 310, in __getitem__
func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>
调用函数
你可调用这些函数，像其它的python函数一样，下面的例子使用time()函数，它以秒为单位返回从unix新纪元的系统时间
，GetModuleHandleA()函数，返回一个win32模块句柄。
下面的例子用空指针调用函数（None作为空指针）
>>> print libc.time(None) # doctest: +SKIP
1150640792
>>> print hex(windll.kernel32.GetModuleHandleA(None)) # doctest: +WINDOWS
0x1d000000
>>>
ctypes尝试阻止你以错误的参数数量或调用约定来调用函数。不幸的是，这些仅仅能在windows上工作
它在函数返回后不会去检查这栈，尽管在调用函数后有错误发生。
>>> windll.kernel32.GetModuleHandleA() # doctest: +WINDOWS
Traceback (most recent call last):
File "
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>> windll.kernel32.GetModuleHandleA(0, 0) # doctest: +WINDOWS
Traceback (most recent call last):
File "
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>
产生了同样的exception，当你用cdecl调用约定去使用一个stdcall函数，反之亦然。
>>> cdll.kernel32.GetModuleHandleA(None) # doctest: +WINDOWS
Traceback (most recent call last):
File "
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>
>>> windll.msvcrt.printf("spam") # doctest: +WINDOWS
Traceback (most recent call last):
File "
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>
找到正确的调用约定，你必须检查c头文件或者你想调用的函数的文档。
在windows，ctypes使用win32结构exception处理一般的保护错误阻止crashes，当调用无效的参数值
>>> windll.kernel32.GetModuleHandleA(32) # doctest: +WINDOWS
Traceback (most recent call last):
File "
WindowsError: exception: access violation reading 0x00000020
>>>
然而有很多种可能性会发生crash,你使用python的ctypes，你应该足够的小心。
None,integers,longs,byte strings 和unicode string是python内置对象，可以直接的作为这些函数的参数
，None作为一个空指针，byte string和unicode string 当作一个内存块，它包含这些数据（char* 或者wchar_t*）
。python的int和long长整形作为c int类型,它们的值对应着c类型。
在调用带有参数的函数之前，我们必须学习更多的关于ctypes数据类型。
基础的数据类型
ctypes定义了许多主要的c兼容有数据类型
数据类型请见https://www.sodocs.net/doc/5413690897.html,/log-21.html
使用它们和一个可选的正确的值去创建所有的这些类型
>>> c_int()
c_long(0)
>>> c_char_p("Hello, World")
c_char_p('Hello, World')
>>> c_ushort(-3)
c_ushort(65533)
>>>
因此这些类型是可变的，他们的值在后面也是可以改变的
分配一个新值到这些指针类型c_char_p, c_wchar_p, 和c_void_p的一个实例上，改变它们指向的
内存位置，而不是这些内存块的内容（当然，因为python的string是不可改变的）
>>> s = "Hello, World"
>>> c_s = c_char_p(s)
>>> print c_s
c_char_p('Hello, World')
>>> c_s.value = "Hi, there"
>>> print c_s
c_char_p('Hi, there')
>>> print s # first string is unchanged
Hello, World
>>>
你应该注意，不要期望传给函数指针是指向可变的内存。如果你需要可变的内存块，ctypes 有一个
create_string_buffer 函数。这内存块内容通过这raw属性来访问或改变，如果你想访问一个以null结束
的字符串，使用这string属性
>>> from ctypes import *
>>> p = create_string_buffer(3) # create a 3 byte buffer, initialized to NUL bytes
>>> print sizeof(p), repr(p.raw)
3 '\x00\x00\x00'
>>> p = create_string_buffer("Hello") # create a buffer containing a NUL terminated string >>> print sizeof(p), repr(p.raw)
6 'Hello\x00'
>>> print repr(p.value)
'Hello'
>>> p = create_string_buffer("Hello", 10) # create a 10 byte buffer
>>> print sizeof(p), repr(p.raw)
10 'Hello\x00\x00\x00\x00\x00'
>>> p.value = "Hi"
>>> print sizeof(p), repr(p.raw)
10 'Hi\x00lo\x00\x00\x00\x00\x00'
>>>
create_string_buffer代替c_buffer（这个到目前是以别名存在的）函数，就像早期版本ctypes 的c_string
函数。create_unicode_buffe函数创建一个包含c类型wchar_t的unicode字符的可变的内存块
调用函数2
注意这printf打印到实际的标准的输出管道，而不是sys.stdout,所以这些例子仅仅工作在console下，而不能在
idle或pythonwin下工作。
>>> printf = libc.printf
>>> printf("Hello, %s\n", "World!")
Hello, World!
14
>>> printf("Hello, %S", u"World!")
Hello, World!
13
>>> printf("%d bottles of beer\n", 42)
42 bottles of beer
19
>>> printf("%f bottles of beer\n", 42.5)
Traceback (most recent call last):
File "
ArgumentError: argument 2: exceptions.TypeError: Don't know how to convert parameter 2 >>>
就像以前提到的，所有的python类型除了integer,string,unicode string以外必须以一个合适的ctypes类型包装，
这样它们才能转换成需要的c数据类型。
>>> printf("An int %d, a double %f\n", 1234, c_double(3.14))
Integer 1234, double 3.1400001049
31
>>>
使用你自定义的数据类型调用函数
你可以自定义ctypes参数，来让你自己的classes的实例作为函数的参数。ctypes寻找_as_parameter_ 属性
作为函数的参数。当然，它必须是整形，字符串，或unicode
>>> class Bottles(object):
... def __init__(self, number):
... self._as_parameter_ = number
...
>>> bottles = Bottles(42)
>>> printf("%d bottles of beer\n", bottles)
42 bottles of beer
19
>>>
如果你不想保存实例的数据在_as_parameter_ 实例的变量中，你应该定义一个属性使这个数据有效。
定义需要的参数类型（函数原型）
可以通过设置argtypes属性，定义从dll中导出的需要的参数类型。argtypes必须是c数据类型的一个列表
（这里的printf可能不是很好的例子，因为它是一个取决于format字符串的可变数目的，需要不同类型的参数
，使用这种特性是一种不错的特性）
>>> printf.argtypes = [c_char_p, c_char_p, c_int, c_double]
>>> printf("String '%s', Int %d, Double %f\n", "Hi", 10, 2.2)
String 'Hi', Int 10, Double 2.200000
37
>>>
定义一个format阻止了不兼容的参数类型（仅仅是一个c函数的原型），尝试转换这些参数到合适的类型。
>>> printf("%d %d %d", 1, 2, 3)
Traceback (most recent call last):
File "
ArgumentError: argument 2: exceptions.TypeError: wrong type
>>> printf("%s %d %f", "X", 2, 3)
X 2 3.00000012
12
>>>
如果你定义了你自己的类去传给调用函数，你必须使用from_param类方法，这样就可以在argtypes列表中使用它们。
from_param类方法接收传给函数的Python对象，它做一个类型检测，或者确保这个对象是可接受的就返回这个对象本身
，它的_as_parameter_属性，或者你想作为参数传递给c函数的任何东西。这结果必须是一个整数，字符串，unicode，一个
ctypes的实例，或者任何有_as_parameter_属性的对象。
返回值
主要的函数都返回c int类型，其它的返回类型可以通过设置function对象的restype属性这有一个更好的例子，它使用strchr函数，它期望一个string指针和一个char，同时返回一个指向string的
指针。
>>> strchr = libc.strchr
>>> strchr("abcdef", ord("d")) # doctest: +SKIP
8059983
>>> strchr.restype = c_char_p # c_char_p is a pointer to a string
>>> strchr("abcdef", ord("d"))
'def'
>>> print strchr("abcdef", ord("x"))
None
>>>
如果你想避免上面的ord("x")调用，你可以设置argtypes属性，这第二个参数会从一个python 字符到一个c char字符
>>> strchr.restype = c_char_p
>>> strchr.argtypes = [c_char_p, c_char]
>>> strchr("abcdef", "d")
'def'
>>> strchr("abcdef", "def")
Traceback (most recent call last):
File "
ArgumentError: argument 2: exceptions.TypeError: one character string expected
>>> print strchr("abcdef", "x")
None
>>> strchr("abcdef", "d")
'def'
>>>
你可以使用一个可以调用的python对象（一个函数或者一个class）作为这restype属性的值，如果外部函数
返回的是一个整数，这个可调用对象将调用这c函数返回的整数，这个可调用对象的结果将作为这个函数调用的结果，这个对于检查
返回值，同时产生一个错误很有帮助。
>>> GetModuleHandle = windll.kernel32.GetModuleHandleA # doctest: +WINDOWS
>>> def ValidHandle(value):
... if value == 0:
... raise WinError()
... return value
...
>>>
>>> GetModuleHandle.restype = ValidHandle # doctest: +WINDOWS
>>> GetModuleHandle(None) # doctest: +WINDOWS
486539264
>>> GetModuleHandle("something silly") # doctest: +WINDOWS
Traceback (most recent call last):
File "
File "
WindowsError: [Errno 126] The specified module could not be found.
>>>
WinError是一个函数，它调用Windows的FormatMessage() API函数去获取一个错误码的描述，同时返回一个exception
。WinError采取一个可选择的错误代码参数，如果没有，它调用GetLastError()。
请注意大量的错误检测机制是可行的，通过errcheck属性，更多的细节请参考手册。
传递指针和传递引用
有时候，一个c API函数期望一个指向某个数据类型的指针作为参数，可能要写入一些数据到相应的位置，如果这数据
太大而不能传值。这同样适用于通过引用传递参数。
ctypes导出这byref函数，它用作通过引用传递参数。使用指针可以达到相同的效果，尽管指针可以做更多的事情
，因为它初始化了一个指针对象，它比使用byref要快，但在python中你不需要指针对象
>>> i = c_int()
>>> f = c_float()
>>> s = create_string_buffer('\000' * 32)
>>> print i.value, f.value, repr(s.value)
0 0.0 ''
>>> libc.sscanf("1 3.14 Hello", "%d %f %s",
... byref(i), byref(f), s)
3
>>> print i.value, f.value, repr(s.value)
1 3.1400001049 'Hello'
>>>
结构和联合
Structures和unions必须继承Structure和Union基础类，它们都在ctypes模块中定义，每一个子类必须定义一个
_fields_属性，_fields_是一个2维tuples的列表，包含这field的name和field的type
这field类型必须是一个ctypes类型，像c_int,或者任何其它的继承ctypes的类型，structure,union,array,指针。
这里有一个简单的POINT结构，包含两个整型x和y,同样它也显示了如何在构造函数中初始化一个结构。
>>> from ctypes import *
>>> class POINT(Structure):
... _fields_ = [("x", c_int),
... ("y", c_int)]
...
>>> point = POINT(10, 20)
>>> print point.x, point.y
10 20
>>> point = POINT(y=5)
>>> print point.x, point.y
0 5
>>> POINT(1, 2, 3)
Traceback (most recent call last):
File "
ValueError: too many initializers
>>>
你可以创建很多更复杂的结构。结构可以通过包含一个结构类型的field来包含其它的结构。下面是一外RECT结构，包含两个POINT名为upperleft和lowerright。
>>> r = RECT(POINT(1, 2), POINT(3, 4))
>>> r = RECT((1, 2), (3, 4))
Field描述可以从类中找到，这在调试中是很有用的，它可以提供非常有用的信息。
>>> print POINT.x
>>> print POINT.y
>>>
Structure/union对齐和byte顺序
默认Structure/union的field对齐和c编译器的方式相同。通过在子类中定义一个_pack_ class 属性可以覆盖这个行为。这必须设置一个正数和为fields对齐设置一个最大值。这就是#pragma pack(n)在
MSVC中的作用。
ctypes使用结构和联合原始的byte顺序。使用一个非原始的byte顺序创建结构，你可以使用BigEndianStructure，
LittleEndianStructure，BigEndianUnion，LittleEndianUnion中的一个作为基础类。这些类不包含pointer的field。
Structure/union的byte field
它是可以创建包含byte field的structures 和unions byte field仅仅可以适合整型field，这bit 的width通过
这_fields_元组中第三项来指定。
>>> class Int(Structure):
... _fields_ = [("first_16", c_int, 16),
... ("second_16", c_int, 16)]
...
>>> print Int.first_16
>>> print Int.second_16
>>>
Array
Array是对列，包含一个固定数目的相同类型的实例。
被推荐的方法去创建array类型是对过一个数据类型与一个正数相乘。TenPointsArrayType = POINT * 10
下面是一个人造数据类型的例子，一个结构包含4个POINT和一些其它的东西。
>>> from ctypes import *
>>> class POINT(Structure):
... _fields_ = ("x", c_int), ("y", c_int)
...
>>> class MyStruct(Structure):
... _fields_ = [("a", c_int),
... ("b", c_float),
... ("point_array", POINT * 4)]
>>>
>>> print len(MyStruct().point_array)
4
>>>
使用一般的方法创建实例，通过调用class
arr = TenPointsArrayType()
for pt in arr:
print pt.x, pt.y
这上面打印了一系列的0,0行，因为这队列的内容都初始化为0。
正确类型的初始化也可以指定。
>>> from ctypes import *
>>> TenIntegers = c_int * 10
>>> ii = TenIntegers(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
>>> print ii
>>> for i in ii: print i,
...
1 2 3 4 5 6 7 8 9 10
>>>
指针
通过调用ctypes类型的指针函数来创建指针实例
>>> from ctypes import *
>>> i = c_int(42)
>>> pi = pointer(i)
>>>
指针实例有一个contents属性，返回这个指针指向的对象，上面的i对象。>>> pi.contents
c_long(42)
>>>
注意这ctypes不包含面向对象，它每次查看一个属性时就创建一个全新的等价的对象。>>> pi.contents is i
False
>>> pi.contents is pi.contents
False
>>>
分配另外一个c_int的实例到pointer的内容属性，将导致指针指向存储它本身的内存位置。
>>> i = c_int(99)
>>> pi.contents = i
>>> pi.contents
c_long(99)
>>>
指针的实例也可以用整数来索引
>>> pi[0]
99
>>>
分配一个整数索引将改变它指向的指针
>>> print i
c_long(99)
>>> pi[0] = 22
>>> print i
c_long(22)
>>>
你可以使用不同于0整型的索引的指针，但是你必须知道你正在做什么，就像在c里面，你可以访访问或武断改变内存位置
，一般而言，当你从一个c函数接收一个指针，同时你知道这个指针实例指向的是一个array 而不是单个项。
在这种场景下，这指针函数比简单的创建一个指针实例要困难多，它首先必须通过POINTER 函数创建一个可以
接收任何ctypes类型的指针类型，返回一个新类型。
>>> PI = POINTER(c_int)
>>> PI
>>> PI(42)
Traceback (most recent call last):
File "
TypeError: expected c_long instead of int
>>> PI(c_int(42))
>>>
不带参数的调用这指针类型创建一个NULL指针，NULL指针有一个False 布尔值。
>>> null_ptr = POINTER(c_int)()
>>> print bool(null_ptr)
False
>>>
ctypes检查NULL非引用指针（非引用非关联指针会crash Python）.
>>> null_ptr[0]
Traceback (most recent call last):
....
ValueError: NULL pointer access
>>>
>>> null_ptr[0] = 1234
Traceback (most recent call last):
....
ValueError: NULL pointer access
>>>
类型转换
一般而言，ctypes进行严格的类型检查，如果在函数参数列表中有一个POINT(c_int)类型或者
在作为结构定义中一个成员field，仅仅接收这相同类型的实例。有一些exception应用在这些规则上
当ctypes接收其它类型的对象。例如你传递一个兼容的array实例，代替指针类型。这样对于POINTER(c_int)
，ctypes可以接收c_int型array
>>> class Bar(Structure):
... _fields_ = [("count", c_int), ("values", POINTER(c_int))]
...
>>> bar = Bar()
>>> bar.values = (c_int * 3)(1, 2, 3)
>>> bar.count = 3
>>> for i in range(bar.count):
... print bar.values[i]
...
1
3
>>>
设置一个指针类型为空，你可以分配None：
>>> bar.values = None
>>>
有时候，你有一些不兼容类型的实例。在C中，你可以强制转换一个类型到另一个类型。ctypes 提供了一个有相同作用的转换
函数。这Bar structure定义了一个POINTER(c_int)指针，或者c_int的array的field，但是没有其它类型。
>>> bar.values = (c_byte * 4)()
Traceback (most recent call last):
File "
TypeError: incompatible types, c_byte_Array_4 instance instead of LP_c_long instance
>>>
对于这些例子，cast函数是很不错的。
使用cast函数将一个ctypes实例转换成一个不同的ctypes数据类型的指针。cast对象有两个参数，一个ctypes对象
是或者可以转换成某些类型的指针，或一个ctypes指针类型。它返回这第二个参数的实例，它引用第一个参数相同的内存块。
>>> a = (c_byte * 4)()
>>> cast(a, POINTER(c_int))
>>>
因此，cast可以使用来分配Bar的值域
>>> bar = Bar()
>>> bar.values = cast((c_byte * 4)(), POINTER(c_int))
>>> print bar.values[0]
>>>
未完成的类型
完成的类型包括成员还没有定义的structure或union，array.在c,他们是在前面声明，而在后面定义的：
struct cell; /* forward declaration */
struct {
char *name;
struct cell *next;
} cell;
直接转换为ctypes像这样，但是它不能工作：
>>> class cell(Structure):
... _fields_ = [("name", c_char_p),
... ("next", POINTER(cell))]
...
Traceback (most recent call last):
File "
File "
NameError: name 'cell' is not defined
>>>
但是，新类cell在它自己的类声明中是无效的。在ctypes，可以定义cell类，同时在类声明中设置_fields_属性
>>> from ctypes import *
>>> class cell(Structure):
... pass
...
>>> cell._fields_ = [("name", c_char_p),
... ("next", POINTER(cell))]
>>>
尝试一下，我们可以创建cell的两个实例，让他们指向他们自己。
>>> c1 = cell()
>>> https://www.sodocs.net/doc/5413690897.html, = "foo"
>>> c2 = cell()
>>> https://www.sodocs.net/doc/5413690897.html, = "bar"
>>> c1.next = pointer(c2)
>>> c2.next = pointer(c1)
>>> p = c1
>>> for i in range(8):
... print https://www.sodocs.net/doc/5413690897.html,,
... p = p.next[0]
...
foo bar foo bar foo bar foo bar
>>>
回调函数
ctypes可以从python可调用对象中创建一个c可调用的函数指针。这些通常被称为回调函数。
首先，你需要为回调函数创建一个类，这类知道这调用约定，返回类型，以及这函数需要接收的参数个数。
CFUNCTYPE工厂函数使用正常的cdecl调用约定创建回调函数的类型，同时在windows上，WINFUNCTYPE工厂函数
使用stdcall调用给定为回调函数创建类型。
这两个工厂函数的结果类型作为第一个参数，这些期望的参数类型回调函数作为这剩下的参数。
这而使用标准的c库qsort函数，它使用一个回调函数来帮助排序items。qsort将使用来排序一个整数array.
>>> IntArray5 = c_int * 5
>>> ia = IntArray5(5, 1, 7, 33, 99)
>>> qsort = libc.qsort
>>> qsort.restype = None
>>>
必须接收一个指向数据的指针来调用qsort函数排序，同时一个比较函数的指针，也就是回调函数。这回调函数
接收两个items的指针，如果第一个小于第二个它返回一个负数，如果相等，返回0，其它的就返回一个正数。
我们的回调函数接收整型指针，同时必须返回一个整数。首先我们创建这回调函数的类型。>>> CMPFUNC = CFUNCTYPE(c_int, POINTER(c_int), POINTER(c_int))
>>>
第一次使用这回调函数，我们简单的打印我们获得的参数，然后返回一个0.
>>> def py_cmp_func(a, b):
... print "py_cmp_func", a, b
... return 0
...
>>>
创建c可调用的回调函数
>>> cmp_func = CMPFUNC(py_cmp_func)
>>>
现在准备的差不多了
>>> qsort(ia, len(ia), sizeof(c_int), cmp_func) # doctest: +WINDOWS
py_cmp_func
我们知道如何访问指针的内容，我们重新定义回调函数：
>>> def py_cmp_func(a, b):
... print "py_cmp_func", a[0], b[0]
... return 0
...
>>> cmp_func = CMPFUNC(py_cmp_func)
>>>
这是我们在windows上得到的结果：
>>> qsort(ia, len(ia), sizeof(c_int), cmp_func) # doctest: +WINDOWS
py_cmp_func 7 1
py_cmp_func 33 1
py_cmp_func 99 1
py_cmp_func 5 1
py_cmp_func 7 5
py_cmp_func 33 5
py_cmp_func 99 5
py_cmp_func 7 99
py_cmp_func 33 99
py_cmp_func 7 33
>>>
在linux上这sort函数看起来工作的更有效，它进行了更少的对比，这很有趣。
>>> qsort(ia, len(ia), sizeof(c_int), cmp_func) # doctest: +LINUX
py_cmp_func 5 1
py_cmp_func 33 99
py_cmp_func 7 33
py_cmp_func 5 7
py_cmp_func 1 7
>>>
我们做的差不多了，这最后一步是实际的比较这两个items，并返回一个有用的结果。
>>> def py_cmp_func(a, b):
... print "py_cmp_func", a[0], b[0]
... return a[0] - b[0]
...
>>>
在windows上运行的最终结果
>>> qsort(ia, len(ia), sizeof(c_int), CMPFUNC(py_cmp_func)) # doctest: +WINDOWS
py_cmp_func 33 7
py_cmp_func 99 33
py_cmp_func 5 99
py_cmp_func 1 99
py_cmp_func 33 7
py_cmp_func 1 33
py_cmp_func 5 33
py_cmp_func 5 7
py_cmp_func 1 7
py_cmp_func 5 1
>>>
Linux:
>>> qsort(ia, len(ia), sizeof(c_int), CMPFUNC(py_cmp_func)) # doctest: +LINUX
py_cmp_func 5 1
py_cmp_func 33 99
py_cmp_func 7 33
py_cmp_func 1 7
py_cmp_func 5 7
>>>
在window上qsort函数需要比linux上进行更多的比较。
我们进行简单检查，我们的已排序的array：
>>> for i in ia: print i,
...
1 5 7 33 99
>>>
确保你对CFUNCTYPE对象的引用和使用c代码在同一空间下，ctypes不会处理，同时如果你不去处理，这将被回收，
当它调用时python会崩溃。
访问dll的导出值
有时候一个dll不仅仅导出函数，它也导出变量。一个python库自己的例子就是这Py_OptimizeFlag，一个整形
被设置成0,1,或者2，依赖于在启动中给定的-O 或者-OO标志。
ctypes可以使用in_dll类方法访问这种类型的值。pythonapi是一个预定义的符号用来访问python C api.
>>> opt_flag = c_int.in_dll(pythonapi, "Py_OptimizeFlag")
>>> print opt_flag
c_long(0)
>>>
如果解释器以-O启动，这例子将打印c_long(1), 如果是-OO 将会打印c_long(2)
一个扩展的例子，示范使用指针访问python导出的PyImport_FrozenModules指针。
引用python的docs：这指针初始化来指向一个struct _frozen记录array，终止于成员都是NULL或0.第三方代码
将提供一个动态创建一个frozen模块的集合。
操纵这些指针更加有效。限制这个例子折大小，仅仅展示如何使用ctypes来读取table.
>>> from ctypes import *
>>>
>>> class struct_frozen(Structure):
... _fields_ = [("name", c_char_p),
... ("code", POINTER(c_ubyte)),
... ("size", c_int)]
...
>>>
已经定义了struct _frozen数据类型，这样我们可以得到这table的指针。
>>> FrozenTable = POINTER(struct_frozen)
>>> table = FrozenTable.in_dll(pythonapi, "PyImport_FrozenModules")
>>>
因为table是一个指向struct_frozen记录array的指针，我们可以迭代，但是我们必须确保我们的loop正确的终止，
因为指针没有大小。过早或过晚，它因为访问违例或其它，会产生crash。所以最好是是在它遇到一个NULL入口就结束
>>> for item in table:
Process Monitor 中文帮助文档
Process Monitor 帮助文档 【介绍】 Process Monitor（进程监视器）是一个Windows下的高级监视工具，可以实时显示文件系统、注册表和进程/线程的活动。它将Sysinternals以前的两个实用程序Filemon（文件监视器）和Regmon（注册表监视器）结合在一起，并且添加了大量的改进功能，包括丰富的非破坏性的过滤器，全面的事件属性——如会话ID和用户名，可靠的进程信息，对每个操作带有集成的调试符号支持的完整线程堆栈，同步记录日志文件等等。Process Monitor独特的强大功能将使它成为你在系统故障排除和恶意软件查杀中使用的核心实用程序。 Process Monitor可以在Windows 2000 SP4 with Update Rollup 1、Windows XP SP2、Windows Server 2003 SP1、Windows Vista，以及64位版本的Windows XP、Windows Server 2003 SP1和Windows Vista等系统上运行。（译者注：Process Monitor不支持Windows 98、Windows NT等以前的系统，不过可以使用Filemon和Regmon来实现它的部分功能。） 【在Filemon和Regmon基础上的改进】 Process Monitor的用户界面和选项与Filemon和Regmon很相似，但它是从头全部重写的，并且包括许多重大改进，例如： （此处引用自wbpluto的汉化版说明） ? 监视进程和线程的启动和退出，包括退出状态代码 ? 监视映像(DLL 和内核模式驱动程序) 加载 ? 捕获更多输入输出参数操作 ? 非破坏性的过滤器允许你自行定义而不会丢失任何捕获的数据 ? 捕获每一个线程操作的堆栈，使得可以在许多情况下识别一个操作的根源 ? 可靠捕获进程详细信息，包括映像路径、命令行、完整性、用户和会话ID等等 ? 完全可以自定义任何事件的属性列 ? 过滤器可以设置为任何数据条件，包括未在当前视图中显示的 ? 高级的日志机制，可记录上千万的事件，数GB的日志数据 ? 进程树工具显示所有进程的关系
Revolve产品知识
产品名称BOSE SoundLink Revolve 产地墨西哥颜色灰/银 产品尺寸/重量 152×82×82mm/660g 续航时间 12小时 充电时间4小时 供电方式锂电池 音频接口 3.5mm/ USB接口（只限电脑音源）单元尺寸3英寸 NFC功能是 防水级别IPX4防水 通话功能是 语音提示是 APP 是 保修期一年（注册微信会员赠送延保6个月） 包装清单音箱本机x1 USB电源x1USB连接线 x1 交流电源适配器 x1 技术特点1360度全向发声：一个向下发声的全音域单元配合BOSE专利的声波导向技术，可以向四周发出均匀，无死角的声音 技术特点2独特优势：体积小巧 低音震撼 技术特点3优雅的设计：采用高品质阳极氧化铝金属材质配合全新的无缝连接一体成型工艺，是产品更为高雅，耐用 技术特点4蓝牙无线连接：方便，易用，可连接几乎是所有常规的智能手机，平板电脑的蓝牙设 备，可支持与蓝牙设备10米距离的无线连接。技术特点5内置锂电池：更好的便携性，4小时充满电可在正常音量下约12小时的使用时间。 技术特点6IPX4级防水：可以使您在室外环境中放心使用。技术特点7BOSE Connect APP ：轻松实现“派对模式”与“立体声模式”的切换，可以满足您更多声音需求。技术特点8支持有线连接：3.5mm与USB接口可以满足你有线音源的连接，连接更多的设备。 技术特点9可选配充电底座：充电方便，同时为扬声器在家中使用时提供了一个放置的地方。 技术特点10 远程操作：可通过配对的蓝牙设备控制扬声器的各项功能（如音量等）不需要携带其他产品说明
音效表现 Feature令人惊艳的宏亮气势，超乎想象的小巧体积。Benefit体积小巧 低音震撼 Advantage 精巧的外壳下装载了众多技术，展现出扬声器超乎想象的的低音效能，让人深深的沉醉在饱满的动人音色中。 Evidence X先生经常会带着家中的小朋友到户外和同事们野餐，因为有小孩子每次外出都需要随身带很多东西。聚会时大家喜欢拿出手机播放孩子们喜欢的音乐增加气氛，偶尔路过门店体验到我们的产品，十分满意。不仅可以满足了他外出携带需要，还提供了完美的音质 360°音效 Feature 可以向四周发出均匀的，无死角的声音。实现零死角的环绕音效。 Benefit随意摆放，一样可以体验到全方位的声音。 Advantage 一个向下发声的全音域单元配合BOSE专利的声波导向器，营造出全方位，无死角的震撼 Evidence X女士三口之家，每天晚上喜欢在客厅给孩子放放音乐，孩子太小总是跑来跑去，之前的音响固定的放在一个位置声音太大影响邻居，声音太小孩子跑来跑去还听不见。选择了我们产品后放在家里中间的位置不管孩子 精致设计 Feature 一体成型的采用高品质阳极氧化铝金属材质配合全新的无缝连接一体成型工艺。 Benefit使产品更为高雅，耐用。 Advantage 精密的设计，一体成型的阳极氧化铝材质，可以提供全方位的音效，不留一丝缝隙，外 Evidence X小姐喜欢游泳，喜欢做SPA ，喜欢泡温泉，更喜欢听音乐。自从购买了产品，她可以随意带着音响到她喜欢的地方，再也没有任何的顾虑。无论什么环境，我们的产品都可以
java中文帮助文档
所有类 chm格式可加Q 1281110301索要AbstractAction AbstractBorder AbstractButton AbstractCellEditor AbstractCollection AbstractColorChooserPanel AbstractDocument AbstractDocument.AttributeContext AbstractDocument.Content AbstractDocument.ElementEdit AbstractExecutorService AbstractInterruptibleChannel AbstractLayoutCache AbstractLayoutCache.NodeDimensions AbstractList AbstractListModel AbstractMap AbstractMethodError AbstractPreferences AbstractQueue AbstractQueuedSynchronizer AbstractSelectableChannel AbstractSelectionKey AbstractSelector AbstractSequentialList AbstractSet AbstractSpinnerModel AbstractTableModel AbstractUndoableEdit AbstractWriter AccessControlContext AccessControlException AccessController AccessException Accessible AccessibleAction AccessibleAttributeSequence AccessibleBundle AccessibleComponent AccessibleContext AccessibleEditableText AccessibleExtendedComponent
python-ctypes模块中文帮助文档
内容： .加载动态链接库 .从已加载的dll中引用函数 .调用函数1 .基本的数据类型 .调用函数2 .用自己的数据类型调用函数 .确认需要的参数类型（函数原型） .返回值 .传递指针 .结构和联合 .结构或联合的对齐方式和字节的顺序 .结构和联合中的位 .数组 .指针 .类型转换 .未完成的类型 .回调函数 .访问dlls导出的值 .可变长度的数据类型 .bugs 将要做的和没有做的事情 注意：本文中的代码例子使用doctest确保他们能够实际工作。一些代码例子在linux和windows以及苹果机上执行有一定的差别 注意：一些代码引用了ctypes的c_int类型。它是c_long在32位机子上的别名，你不应该变得迷惑，如果你期望 的是c_int类型，实事上打印的是c_long，它们实事上是相同的类型。 加载动态链接库 ctypes加载动态链接库，导出cdll和在windows上同样也导出windll和oledll对象。 加载动态链接库后，你可以像使用对象的属性一样使用它们。cdll加载使用标准的cdecl调用约定的链接库， 而windll库使用stdcall调用约定，oledll也使用stdcall调用约定，同时确保函数返回一个windows HRESULT错误代码。这错误 代码自动的升为WindowsError Python exceptions，当这些函数调用失败时。 这有一些windows例子，msvcrt是微软的c标准库，包含大部分的标准c函数，同时使用cdecl调用约定。 注：cdecl和stdcall的区别请见https://www.sodocs.net/doc/5413690897.html,/log-20.html >>> from ctypes import * >>> print windll.kernel32 # doctest: +WINDOWS
spring-3.1.0中文版api帮助文档
Spring 3.x权威开发指南：实施Java EE 6 的利器 2011年8月31日
目录 序 ............................................................................................................................................VIII 前言 ........................................................................................................................................... X 1借助Spring 3.1实施Java EE 6 . (1) 1.1Java EE 6编程模型讨论 (1) 1.1.1Java EE 6够敏捷，No！ (1) 1.1.2盘旋于具体与抽象之间 (2) 1.2挖掘Spring 3.1的架构价值 (3) 1.2.1精耕细作于Java EE 6平台 (3) 1.2.2面向Spring的SpringSource Tool Suite集成开发工具 (3) 1.2.3全面拥抱OSGi 4.2 (4) 1.2.4开发者决定一切 (4) 1.3下载及构建Spring 3.1 (5) 1.3.1下载Spring 3.1正式发布版 (5) 1.3.2基于SVN库持续构建Spring源码 (6) 1.4小结 (7) 2控制反转容器 (8) 2.1DI及Spring DI概述 (8) 2.1.1面向Java ME/Java SE的BeanFactory (8) 2.1.2面向Java EE的ApplicationContext (9) 2.2多种依赖注入方式 (9) 2.2.1设值注入 (9) 2.2.2构建器注入 (11) 2.2.3属性注入 (12) 2.2.4方法注入 (12) 2.3借助Autowiring策略智能注入协作者 (13)
CAD和TSSD快捷键(含探索者中文键名)
AutoCAD 简化命令 3A, *3DARRAY 3DO, *3DORBIT 3F, *3DFACE 3P, *3DPOLY A, *ARRAY ，阵列ADC, *ADCENTER AD, *ID AE, *AREA AL, *ALIGN AP, *APERTURE ATP, *ATTDISP AT, *DDATTE -AT, *ATTEDIT ATT, *DDATTDEF -ATT, *ATTDEF AV, *DSVIEWER B, *BREAK H, *BHATCH BL, *BMAKE -BL, *BLOCK BO, *BOUNDARY -BO, *-BOUNDARY CO, *COPY CC, *CHAMFER CH, *DDCHPROP -CH, *CHANGE DDC, *DDCOLOR C, *CIRCLE D, *DIM DD, *DDEDIT DDV, *DDVPOINT DI, *DIST DIV, *DIVIDE DO, *DONUT DST, *DIMSTYLE DT, *DTEXT DV, *DVIEW DX, *DDIM DXI, *DXFIN DXO, *DXFOUT E, *ERASE EL, *ELEV ELL, *ELLIPSE EN, *END EP, *EXPLODE EX, *EXTEND F, *FILLET FF, *FILL FI, *FILTER G, *GROUP GR, *DDGRIPS -GR, *GRID HI, *HIDE HE, *HATCHEDIT HT, *HATCH I, *DDINSERT -I, *INSERT IM, *IMAGE -IM, *-IMAGE L, *LINE LA, *LAYER -LA, *-LAYER LE, *LEADER LEN, *LENGTHEN LI, *LIST LS, *LTSCALE LT, *LINETYPE -LT, *-LINETYPE LTS, *LTSCALE M, *MOVE MA, *MATCHPROP ME, *MEASURE MI, *MIRROR ML, *MLINE MO, *DDMODIFY MN, *MENU MS, *MSPACE MT, *MTEXT -MT, *-MTEXT MV, *MVIEW N, *NEW O, *OFFSET OP, *OPEN OS, *OSNAP
总结的Javadoc转换chm帮助文档的四种方法
https://www.sodocs.net/doc/5413690897.html,/blog/1051688 李顺利 [2010年1月6日] 关键词 Javadoc chm 转换 jd2chm javadoc2chm javadoc2help Javadoc2chm 中文乱码李顺利 前言 朋友，当您在一个项目完成后，是不是需要把你的源码打包并且把注释打成Javadoc交给客户，Eclipse或者MyEclipse自动打成的Javadoc文档都是基于网页格式的，打开是很方便，不过真的用的时候，搜索每个方法或者什么的就很麻烦了，而chm帮助文档格式不但文件小，查阅都很方便，所以网上就出现了很多把Javadoc转换为chm格式的帮助文档的软件/工具或者方法。 自己最近需要真的需要这个方面的需求，查阅了网上很多方法，发现很多都是写的很不详细，对于我这种刚接触的很是不清楚，经过我的学习和理解，现提供从网上总结的Javadoc转换chm帮助文档的四种方法，详细提供各个转换的步骤供大家学习，并且提供英文版本和中文版本Javadoc转换过程中出现的问题，特别是中文的时候出现的乱码现象，也提供一些解决方案。 预处理 转换之前需要了解的是chm是微软公司发布的一种帮助文档格式，所有，要使用下面的方法转换，请先安装HTML Help Workshop（后面简称为HHW）（实际上后面的一些处理有些都是在上面操作的） https://www.sodocs.net/doc/5413690897.html,/en-us/library/ms669985.aspx，下载完毕后就是安装了，很简单。 还有一个很重要的问题，就是如何把项目打成Javadoc，这有人应该会说，很简单啊，就是使用Eclipse或者Myeclipse的Export功能，是的，这是可以，但是有些小的方面还是需要我们强烈注意的
python-os模块中文帮助文档
注此模块中关于unix中的函数大部分都被略过，翻译主要针对WINDOWS,翻译速度很快，其中很多不足之处请多多包涵。 这个模块提供了一个轻便的方法使用要依赖操作系统的功能。如何你只是想读或写文件，请使用open() ,如果你想操作文件路径，请使用os.path模块，如果你想在命令行中，读入所有文件的所有行，请使用 fileinput模块。使用tempfile模块创建临时文件和文件夹，更高级的文件和文件夹处理，请使用shutil模块。 os.error 内建OSError exception的别名。 https://www.sodocs.net/doc/5413690897.html, 导入依赖操作系统模块的名字。下面是目前被注册的名字：'posix', 'nt', 'mac', 'os2', 'ce', 'java', 'riscos'. 下面的function和data项是和当前的进程和用户有关 os.environ 一个mapping对象表示环境。例如，environ['HOME'] ，表示的你自己home文件夹的路径(某些平台支持，windows不支持) ，它与C中的getenv("HOME")一致。 这个mapping对象在os模块第一次导入时被创建，一般在python启动时，作为site.py处理过程的一部分。在这一次之后改变environment不 影响os.environ，除非直接修改os.environ. 注：putenv()不会直接改变os.environ，所以最好是修改os.environ 注：在一些平台上，包括FreeBSD和Mac OS X，修改environ会导致内存泄露。参考putenv()的系统文档。 如果没有提供putenv()，mapping的修改版本传递给合适的创建过程函数，将导致子过程使用一个修改的environment。 如果这个平台支持unsetenv()函数，你可以删除mapping中的项目。当从os.environ使用pop()或clear()删除一个项目时，unsetenv()会自动被调用（版本2.6）。 os.chdir(path) os.fchdir(fd) os.getcwd() 这些函数在Files和Directories中。
Cinema 4D 汉化帮助文档PDF.pdf
Cinema 4D 汉化帮助文档聚众翻译v2015.09.06 【前言】 这只是一个提议，希望有更多朋友的加入，目的没打算是把这玩意全部汉化完成，其中的困难非一小撮人可以解决的。只想能发动很多的朋友来共同学习，古语有云“眼过千遍不如手过一遍”。 其次，也是因为国内盗版盛行，官方是不会做中文帮助文档。倡议大伙多多支持正版软件以求获得官方中文帮助文档的发布 很早以前R13版本时，CG天下（论坛）曾发动过付费的帮助文档的汉化，最终任务艰巨而放弃（猜的）。我在想象，如果这一次的倡议，参与翻译的同学名字能在这个页面写上一千多位，那么真就是全民汉化的奇迹了，目前也就“呵呵”而已吧。做过总比想了不错的好，不怕失败就怕放弃。 话说回来，校对同学是很重要的，需要对C4D软件很了解，校正其中命令菜单的翻译。然后是翻译，还有不可缺少的编辑同学，翻译完成，需要填写进html文档中。估计会有很多同学不会编辑html，当然，若自己能编辑最好了，你可以独立发布，也可以整理在我发布的这个版本中。 支持的同学再多，也敌不过你的加入。 其中菜单命令的翻译，都是在软件中切换中英文来查找的官方中文命令。希望刚开始能有个严谨的态度吧。虽然我也不会英文，也是通过各种汉化工具来做的，每学习一两条，从此进步速速哒，哈哈。 【汉化方法】 方法有多中，首先打开软件安装目录。可以在桌面图标上右键→打开文件所在的位置。或者在这个目录下“X:\Program Files\MAXON\CINEMA 4D R17\help\US\html 全部都是html文件，三千多个。Ctrl+a 全选，右键→属性 取消“只读”的勾选，这样才能编辑文档。 一、使用 notepad++ 软件修改。全部代码编辑，适合码农，编辑性能卓越，操作指数困难。从C4D中打开帮助面板，选择一个你想翻译的页面。右键→属性 地址栏中“5425.html”便是文件名称。 然后在帮助文档的文件夹中“X:\Program Files\MAXON\CINEMA 4D R17\help\US\html”搜索“5425.html”使用notepad++软件打开。
中文帮助文件精选
英文版对应中文目录（2009） 3 执行概况 3 科研与开发 3 市场营销 4 生产 4 财务 5 公司的成功 5 传感器工业 5 传感器的顾客 5 各群体的购买标准 6 定位 7 价格, 年龄, 和可靠性 7 各群体的标准 8 Foundation?快讯 8 首页, 股票和债券总结, 财务报表和生产分析 8 群体分析 9 可达性、市场占有率和产品排行榜 10 市场份额报告和直观图 10 人力资源 / 全面质量管理报告 11 预计报告和年度报告11 资产负债表 11 现金流量表 11 收益表 12 购买决策 12 粗略删减 12 粗删阶段的定位 12 粗删阶段的价格 12 粗删阶段的可靠性 13 精细筛选 13 精选阶段的定位 13 精选阶段的价格 13 精选阶段的可靠性 14 年龄 14 市场因素 14 知名度 14 获得产品难易度 14 卖方市场 15 市场规模与发展 15 以销售量计算的市场规模 15 生产 15 科研与开发 16 改变速度, 尺寸和可靠性 16 开发新产品 16 项目管理 17 产品的年龄 18 市场营销 18 产品定价 18 宣传和销售预算 19 销售预测 20 生产 20 生产力 21 改变自动化程度 21 财务 21 短期债务 22 债券 23 股票 23 紧急贷款 23 信用政策 24 附加模块 24 人力资源 25 全面质量管理 25 形式分析 25 直观图 26 客户需求中心和需求的改变 26 理想点 27 工业需求分析 28 生产能力分析 29 边际分析 30 边际潜力 31 消费者调查报告 32 预测 32 基本预测方法 32 定性分析 33 年底顾客调查报告 33 预测, 预计报告和年底的现金状况 33 最坏情况 / 最好情况 34 六大基本策略34 以产品寿命周期为中心的成本领袖 策略 34 以产品寿命周 期为中心的区别策略 35 全面成本领袖策略 35 全面区别策略 35 壁龛成本领袖策略（低技术） 35 壁龛区别策略（高技术） 36 平衡计分卡36 对你公司的指导 37 索引
【资料】Airpak中文帮助文档(1.7部分)
Airpak中文帮助文档（1.7部分） 此文翻译来自Airpak帮助文档1.7部分 通过1.7部分，你将使用Airpak 建立一个问题、解决一个问题以及输出结果。这是 对Airpak 特点的基础介绍。 如有疑问可参考Airpak帮助文档的相关部分
1.7 示例 在下面的示例中，你将使用Airpak建立一个问题、解决一个问题以及输出结果。这是对Airpak特点的基础介绍。使用指南中的例子将提供更完整的程序特点。 1.7.1 问题描述 图1.7.1显示的所要解决的问题。房间中包含了一个开放的进风口、一个排气口和一个恒定温度的墙。房间的长是4.57 m，宽是 2.74 m，高是2.74m。房间外测量值是0.92 m ×0.46 m，同时引入一个冷空气射入房间使得空气流动。排气口的尺寸是0.91 m×0.45 m。惯性的力量、浮力的力量以及湍流混合的相互作用对所提供的空气的渗透及路径有着重要的影响。 1.7.2 主要的过程 图1.7.1显示的问题是一个稳定通风的情形。边界温度以及速度是被定义的。示例中的步骤简要如下： z打开和定义一项工作 z调整默认房间大小 z对于一个房间生成一个进风口（opening）、排气口（vent）以及墙 z生成网格 z计算
z检查结果 1.7.3 开始一个新工作 启动Airpak（1.5节）。图1.7.2.显示的是【Open job】面板。 在【Select the job to open】文本显示框中路径的最后将/sample写上。点击【Accept】打开一个新工作。Airpak将生成一个10 m×3 m×10 m默认房间，同时在图形窗口显示房间。 你可以使用鼠标左键围绕一个中心点旋转房间，或者使用鼠标中间键你可以将房间转移到屏幕的任意一点上。使用右键放大或缩小房间。为了将房间回复的默认方位，点击【Options】菜单下【Orient】，在下拉菜单中选择【Home】。 1.7.4 定义工作 通过定义房间的种类和设置环境温度来开始工作。这些参数在【Problem setup】面板中具体指明了。在【File】菜单中选择【Problem】可以打开【Problem setup】面板（如图1.7.3）。
Sapera LT帮助文档 中文版
Sapera帮助文档 简介：Sapera LT 是一套用于图像采集、显示和控制的独立于硬件以外的 C 和C++ 软件库，支持所有DALSA Coreco 硬件平台。它的综合功能集包括程序可移植性、多样化的相机控制、灵活的显示和管理功能，以及易于使用的应用开发向导。Sapera LT 与Microsoft Visual Studio C/C++、.Net、Visual Basic 6.0 和Borland C++ Builder 兼容，支持Windows XP、2000 和NT 平台。 一．Sapera++介绍 Sapera++是Sapera LT为用户提供的API. Sapera++ 包含两大类：基础应用类（Basic Classes）和GUI类（GUI Classes）。 1.基础应用类： 提供了用户进行图像开发的基本函数，命名方式为Sap＋类功能名，其结构如下图所示： Sapera Basic Class 函数功能介绍： Data Classes： 功能：下属多个数据类，每一个数据类管理了一种特定数据类型 下属数据类：SapData Class SapDataHSI Class SapDataHSV Class SapDataFloat Class SapDataFPoint Class SapDataFRGB Class SapDataMono Class SapDataPoint Class SapDataRGB Class
SapDataRGBA Class SapDataYUV Class ●SapAcquisition 功能：控制与板卡相连接的采集设备 常用函数：SapAcquisition::SapAcquisition SapAcquisition::Create SapAcquisition::Destroy SapAcquisition::ApplyLut SapAcquisition::GetParameter, SapAcquisition::SetParameter SapAcquisition::GetSignalStatus SapAcquisition::IsSignalStatusAvailable ●SapAcqCallbackInfo 功能：存储SapAcquisition类回调的内容 常用函数：SapAcqCallbackInfo::GetContext SapAcqCallbackInfo::GetSignalStatus ●SapAcqDevice 功能：由设备读、写信息，还可直接发送、寄存事件至设备。常用于直接连接电脑的相机（如GigE相机） 常用函数：SapAcqDevice::SapAcqDevice SapAcqDevice::Create SapAcqDevice::Destroy SapAcqDevice::GetConfigFile, SapAcqDevice::SetConfigFile SapAcqDevice::UpdateFeaturesFromDevice ●SapAcqDeviceCallbackInfo 功能：存储SapAcqDevice类回调的内容 常用函数：SapAcqDeviceCallbackInfo::SapAcqDeviceCallbackInfo SapAcqDeviceCallbackInfo::GetAcqDevice ●SapBayer 功能：Bayer转换操作（分为软件和硬件实现两种） 常用函数：SapBayer::WhiteBalance SapBayer::EnableLut SapBayer::GetAlign, SapBayer::SetAlign SapBayer::GetWBGain, SapBayer::SetWBGain ●SapBuffer 功能：操作buffer资源 常用函数：SapBuffer::SapBuffer SapBuffer::Create SapBuffer::Clear SapBuffer::Destroy SapBuffer::GetParameter, SapBuffer::SetParameter SapBuffer::GetPitch SapBuffer::GetPixelDepth, SapBuffer::SetPixelDepth SapBuffer::GetIndex, SapBuffer::SetIndex
pyevolve中文帮助文档
Pyevolve的用户手册中文版 1.1.6基本概念 Raw score:表示由适应度函数返回的还未进行比例换算的适应值。 Fitness score :对Raw score进行比例换算后的适应值，如果你使用线性的比例换算(Scaling.LinearScaling()),fitness score将会使用线性方法进行换算，fitness score代表个体与种群的相关程度。 Sample genome : 是所有genome进行复制的基础 1.2.3对pyevolve进行扩展 对pyevolve进行扩展首先要查看GenomeBase.GenomeBase类的源码。 扩展的基本步骤 1）创建染色体类 2）创建染色体的初始化函数 3）创建遗传算子：选择算子，交叉算子，和变异算子等。 1.3模块 1.3.2基本模块 a) Consts :常量模块 Pyevolve 提供了所有的默认遗传算子，这是为了帮助用户方便的使用API，在常量模块中，你可以找到这些默认的设置，最好的情况是查看常量模块，但是不改变常量模块中的内容。 b)Util :公用模块 公用模块中提供了一些公用的函数，比如列表项的交换，随机功能等。 list2DSwapElement(lst, indexa, indexb):交换矩阵中的元素项。 listSwapElement(lst, indexa, indexb)：交换列表中的元素项。 c)FunctionSlot :函数分片模块 Pyevolve中广泛使用函数分片的概念;这个想法是很简单的，每个遗传操作或者说是任何遗传操作能够被分配到一个片，按照这种想法，我们能够添加不止一种的遗传操作，比如说同时进行两种或者更多的变异操作，或者两种或更多的计算操作等，函数分片模块是以FunctionSlot.FunctionSlot类来实现的。 例子： Def fit_fun(genome): …. Def fit_fun2(genome): …. Genome.evaluator.set(fit_fun) Genome.evaluator.add(fit_fun2) Print Genome.evaluator #the result is “slot [evaluator] (count:2)” Print Genome.evaluator[0] # the result is “function fit_fun at <....>” Print Genome.evaluator[1] # the result is “function fit_fun2 at <...>”
EA帮助文档(中文)
## Enterprise Architect帮助文档 帮助文档翻译
目录 简介 (2) 从此处开始 (2) 使用EA (2) 用EA建模 (2) 模型管理 (2) 项目管理 (2) 编码工程 (2) 调试和配置文档 (2) 数据建模 (2) 一张数据表格 (2) 创建一个表格 (3) 设置表格属性 (4) 创建字段 (9) 创建Oracle包 (11) 主键 (11) 外键 (12) 存储过程 (17) 视图 (21) 索引，触发器和检查约束 (23) 生成DDL (25) 把一个包生成DDL (25) 进程的数据类型转换 (26) 包的数据类型转换 (27) 数据库管理系统数据类型 (28) 从开放式数据库中导入数据库模式 (29) 转化MDA (33) XML技术 (33) 生成文档 (33) EA扩展 (33) UML字典 (33) 项目角色和EA (33) 授权管理 (33) 术语 (33)
简介 从此处开始 使用EA 用EA建模 模型管理 项目管理 编码工程 调试和配置文档 数据建模 一张数据表格 下面展示了一个数据模型表，上面有三个表格，相互之间用主外键连接起来。上面同样展示了主外键的操作。你也可以添加其他操作：检验，触发器，约束性，索引。
一个数据模型表在EA中表现为一个类表，创建方法和其他类型的表一样。 创建一个表格 什么是表 关系模型数据库中，最基础的模型结构就是“表”。一个表代表了具有相同结构的一系列记录。UML数据模型配置文件中的表表现为一个衍型类，这就是说，一个带着衍型的类元素作用于它之上。一个表的图标表示在图表的右上方。 创建一个表 通过以下步骤创建一个表： 1、选择一个表； 2、选择工具条选项中的更多工具|扩展|数据模型菜单； 3、点击元素列中的表格元素，然后点击表。一个表格就展示在表上了；
@Material Studio中文版帮助手册
欢迎 欢迎使用Materials Studio Materials Studio是一个采用服务器/客户机模式的软件环境，它为你的PC机带来世界最先进的材料模拟和建模技术。 Materials Studio使你能够容易地创建并研究分子模型或材料结构，使用极好的制图能力来显示结果。与其它标准PC软件整合的工具使得容易共享这些数据。 Materials Studio的服务器/客户机结构使得你的Windows NT/2000/XP，Linux和UNIX服务器可以运行复杂的计算，并把结果直接返回你的桌面。 Materials Studio采用材料模拟中领先的十分有效并广泛应用的模拟方法。Accelry’s的多范围的软件结合成一个集量子力学、分子力学、介观模型、分析工具模拟和统计相关为一体容易使用的建模环境。卓越的建立结构和可视化能力和分析、显示科学数据的工具支持了这些技术。 无论是使用高级的运算方法，还是简单地利用Materials Studio增强你的报告或演讲，你都可以感到自己是在用的一个优秀的世界级材料科学与化学计算软件系统。 易用性与灵活性 Materials Studio可以在Windows 98,Me，NT，2000和XP下运行。用户界面符合微软标准，你可以交互控制三维图形模型、通过简单的对话框建立运算任务并分析结果，这一切对Windows用户都很熟悉。 Materials Studio的中心模块是Materials Visualizer。它可以容易地建立和处理图形模型，包括有机无机晶体、高聚物、非晶态材料、表面和层状结构。Materials Visualizer 也管理、显示并分析文本、图形和表格格式的数据，支持与其它字处理、电子表格和演示软件的数据交换。 Materials Studio是一个模块化的环境。每种模块提供不同的结构确定、性质预测或模拟方法。你可以选择符合你要求的模块与Materials Visualizer组成一个无缝的环境。你也可以把Materials Visualizer作为一个单独的建模和分子图形的软件包来运行。 如果你安装了Materials Studio的其它模块，后台运算既可以运行在本机，也可以通过网络运行在远程主机上。这取决于你建立运算时的选择和运算要求。Materials Studio的客户机/服务器模式支持服务器端运行在Windows NT/2000/XP，Linux或UNIX下，使得你可以最大化利用计算资源。 效率和交流 所以的研究人员都可以从Materials Studio强大功能中获益。这份文档的“演示”部分给出了一些简单的分子和材料的模型。这能使你获得对材料的更好的理解并能创建优秀的图形。与其它Windows软件的协同工作使得能容易地拷贝粘贴这些图形到其它文档。结构和性质的数据能容易地从电子表格和数据库中导入导出。Materials Studio帮助你显示和共享数据。Materials Visualizer也可以安装在研究部门、生产部门、
iText中文帮助文档
第一部分iText的简单应用 第一章创建一个Document 利用iText五步创建一个PDF文件：helloword。 第一步，创建一个 iTextSharp.text.Document对象的实例： Document document = new Document(); 第二步，为该Document创建一个Writer实例： PdfWriter.getInstance(document, new FileStream("Chap0101.pdf", FileMode.Create)); 第三步，打开当前Document document.Open(); 第四步，为当前Document添加内容： document.Add(new Paragraph("Hello World")); 第五步，关闭Document document.Close(); 完整的代码见示例代码0101。 在例中，不难看出，制作一个PDF文件是非常简单的。 注：如果你将例中“document.Add(new Paragraph("Hello World"));”中的字符串“Hello Word”换成中文，如“这是我的第一个PDF文件”，产生的结果一定让你大失所望，因为生成的PDF文件中并没有将中文显示出来，不要担心，在第9章中要专门讲解字体问题，中文显示也就迎刃而解了，如果不能正确显示中文，也就没有必要翻译本文了。 下面对这几步做详细介绍。 第一步创建一个Document实例： iTextSharp.text.Document-object共有三个构造函数：
public Document(); public Document(Rectangle pageSize); public Document(Rectangle pageSize, int marginLeft, int marginRight, int marginTop, int marginBottom); 第一个构造函数以A4页面作为参数调用第二个构造函数，第二个构造函数以每边36磅页边距为参数调用第三个构造函数 ◆页面尺寸： 你可以通过指定的颜色和大小创建你自己的页面，示例代码0102创建一个细长的浅黄色背景的页面： Rectangle pageSize = new Rectangle(144, 720); pageSize.BackgroundColor = new Color(0xFF, 0xFF, 0xDE); Document document = new Document(pageSize); 通常，你不必创建这样的页面，而可以从下面页面尺寸中选择： A0-A10, LEGAL, LETTER, HALFLETTER, _11x17, LEDGER, NOTE, B0-B5, ARCH_A-ARCH_E, FLSA 和 FLSE 大多数情况下使用纵向页面，如果希望使用横向页面，你只须使用rotate()函数： Document document = new Document(PageSize.A4.rotate()); 详细代码见示例代码0103。 ◆页边距： 当创建一个文件时，你还可以定义上、下、左、右页边距： Document document = new Document(PageSize.A5, 36, 72, 108, 180); 在示例代码0104中你可以看到该文档有一个0.5英寸的左边距和1英寸的右边距，上边距为1.5英寸，下边距为2.5英寸。
Fragstats4.1帮助文档中文版(谷歌翻译)
概述 什么是FRAGSTATS FRAGSTATS是空间格局的分析程序来表示景观结构的景观镶嵌模型分类地图。请注意，FRAGSTATS不适合代表景观结构的景观梯度模型的连续表面地图。景观受分析是用户定义的，并且可以表示任何空间的现象。FRAGSTATS简单量化作为分类地图所代表的景观空间异质性;这是义不容辞的用户建立了良好的基础定义和缩放景观的主题内容和分辨率和空间的粮食和程度方面。我们强烈建议您阅读使用该程序之前，FRAGSTATS背景部分。重要的是，从FRAGSTATS输出才有意义，如果定义的景观是有意义的相对于正在审议的现象。 规模的注意事项 FRAGSTATS需要的空间谷物或网格的分辨率是>0.001米，但它放置没有限制对景观本身的空间范围，虽然有对可加载的网格的尺寸存储器的限制。然而，在计算FRAGSTATS的移动距离和面积为基础的度量报道平方米，公顷，分别。因此，极端的程度和/或分辨率的景观可导致相当麻烦的数字和/或受舍入误差。然而，FRAGSTATS输出，可以使用任何数据库管理程序，以重新调整指标或将其转换为其他单位（例如，转换公顷亩）被操纵以ASCII格式的数据文件。 计算机要求 FRAGSTATS是一个用微软的Visual C单机+ +程序在Windows操作系统环境中使用，是一个32位进程（即使运行的是64位计算机上）。FRAGSTATS的开发和在Windows 7操作系统上进行测试，尽管它应该在所有的Windows操作系统上运行。请注意，FRAGSTATS是高度依赖于平台，因为它是在Microscroft环境下开发的，所以移植到其他平台上是不容易实现的。FRAGSTATS是计算密集型的程序;其性能取决于两个处理器速度和计算机存储器（RAM）。最后，处理的图像的能力依赖于足够的存储器可用，并且处理该图像的速度依赖于处理器速度。 特别值得注意的是该存储器的约束。FRAGSTATS是一个32位的过程，因此，最多只能使用2GB的内存;但如果正确配置Windows可以让32位进程看高达3GB的内存。FRAGSTATS加载输入电网到内存中，然后计算所有要求的计算。因此，你必须拥有足够的内存来加载网格，然后足够的剩余处理和其他操作系统的需求。作为一个指南，以帮助确定是否有足够的内存来处理特定的网格，你可以用下面的公式：＃电池*4字节。因此，如果你有256行，256列格，内存要求为256 KB（256*256* 4/1024字节/ KB）只是加载网格;你还需要其它更多的内存来处理电网，满足您的其他操作系统的需求。不幸的是，它几乎是不可能的，以确定准确的存储器需求超出了需要加载的网格，因为它取决于许多未知因素，例如有多少斑块有。内存要求并不特别限制在一个标准的分析，除非你正在使用大型图像和有限的内存。一个潜在的解决了这个问题，如果它出现了- 遗憾的是- 是让更多的内存，但这是有限度的，如上所述。另一个解决方案是重新取样网格较粗分辨率，有效地减少了网格大小，但是这是唯