Larik pointer fungsi python

Memuat pustaka tautan dinamis

mengekspor cdll, dan pada Windows objek windll dan oledll, untuk memuat pustaka tautan dinamis

Anda memuat pustaka dengan mengaksesnya sebagai atribut objek ini. cdll memuat pustaka yang mengekspor fungsi menggunakan konvensi pemanggilan

>>> windll.kernel32.GetModuleHandleA(32)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OSError: exception: access violation reading 0x00000020
>>>

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

Berubah di versi 3. 3. Kesalahan Windows digunakan untuk menaikkan , yang sekarang menjadi alias dari.

Berikut adalah beberapa contoh untuk Windows. Perhatikan bahwa

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

>>> from ctypes import *
>>> print(windll.kernel32)  
<WinDLL 'kernel32', handle .. at ...>
>>> print(cdll.msvcrt)      
<CDLL 'msvcrt', handle .. at ...>
>>> libc = cdll.msvcrt      
>>>

Windows menambahkan akhiran file

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

Catatan

Mengakses pustaka C standar melalui

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

Di Linux, diperlukan untuk menentukan nama file termasuk ekstensi untuk memuat pustaka, sehingga akses atribut tidak dapat digunakan untuk memuat pustaka. Metode

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Mengakses fungsi dari dll yang dimuat

Fungsi diakses sebagai atribut objek dll

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Perhatikan bahwa sistem win32 dll seperti

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

windll tidak mencoba untuk memilih salah satunya dengan sihir, Anda harus mengakses versi yang Anda butuhkan dengan menentukan

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Terkadang, dll mengekspor fungsi dengan nama yang bukan pengidentifikasi Python yang valid, seperti

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Di Windows, beberapa fungsi ekspor dll bukan berdasarkan nama tetapi secara berurutan. Fungsi-fungsi ini dapat diakses dengan mengindeks objek dll dengan nomor urut

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Fungsi pemanggilan

Anda dapat memanggil fungsi-fungsi ini seperti callable Python lainnya. Contoh ini menggunakan fungsi

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Contoh ini memanggil kedua fungsi dengan pointer

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

dimunculkan saat Anda memanggil fungsi

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

>>> cdll.kernel32.GetModuleHandleA(None)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>

>>> windll.msvcrt.printf(b"spam")  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>

Untuk mengetahui konvensi pemanggilan yang benar, Anda harus melihat file header C atau dokumentasi untuk fungsi yang ingin Anda panggil

Di Windows, menggunakan penanganan pengecualian terstruktur win32 untuk mencegah crash akibat kesalahan perlindungan umum saat fungsi dipanggil dengan nilai argumen yang tidak valid

>>> windll.kernel32.GetModuleHandleA(32)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OSError: exception: access violation reading 0x00000020
>>>

Namun, ada cukup banyak cara untuk membuat crash Python dengan , jadi Anda tetap harus berhati-hati. Modul ini dapat membantu dalam men-debug crash (mis. g. dari kesalahan segmentasi yang dihasilkan oleh panggilan perpustakaan C yang salah)

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Sebelum kita melanjutkan pemanggilan fungsi dengan tipe parameter lain, kita harus mempelajari lebih lanjut tentang tipe data

Tipe data dasar

mendefinisikan sejumlah tipe data kompatibel C primitif

tipe ctypes

tipe C

Jenis ular piton

_Bool

minuman keras (1)

arang

objek byte 1 karakter

wchar_t

string 1 karakter

arang

int

tidak ditandatangani char

int

pendek

int

tidak ditandatangani pendek

int

int

int

tidak ditandatangani int

int

panjang

int

tidak bertanda tangan panjang

int

__int64 atau panjang panjang

int

tidak bertanda tangan __int64 atau tidak bertanda tangan panjang long

int

size_t

int

ssize_t atau

int

mengambang

mengambang

dobel

mengambang

panjang ganda

mengambang

char* (NUL dihentikan)

objek byte atau

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

wchar_t* (NUL dihentikan)

string atau

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

batal*

int atau

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

1. Konstruktor menerima objek apa pun dengan nilai kebenaran

Semua jenis ini dapat dibuat dengan memanggilnya dengan penginisialisasi opsional dari jenis dan nilai yang benar

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

Karena tipe ini bisa berubah, nilainya juga bisa diubah setelahnya

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Menetapkan nilai baru ke instance pointer types , , dan mengubah lokasi memori yang mereka tunjuk, bukan konten blok memori (tentu saja tidak, karena objek byte Python tidak dapat diubah)

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Namun, Anda harus berhati-hati agar tidak meneruskannya ke fungsi yang mengharapkan petunjuk ke memori yang dapat diubah. Jika Anda memerlukan blok memori yang dapat diubah, ctypes memiliki fungsi yang membuatnya dengan berbagai cara. Isi blok memori saat ini dapat diakses (atau diubah) dengan properti

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Fungsi menggantikan fungsi

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Memanggil fungsi, lanjutan

Perhatikan bahwa printf mencetak ke saluran output standar yang sebenarnya, bukan ke , jadi contoh ini hanya akan berfungsi di prompt konsol, bukan dari dalam IDLE atau PythonWin

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Seperti yang telah disebutkan sebelumnya, semua tipe Python kecuali objek integer, string, dan byte harus dibungkus dengan tipe yang sesuai, sehingga dapat dikonversi ke tipe data C yang diperlukan.

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Memanggil fungsi variadik

Pada banyak platform, pemanggilan fungsi variadic melalui ctypes sama persis dengan pemanggilan fungsi dengan jumlah parameter yang tetap. Pada beberapa platform, khususnya ARM64 untuk Platform Apple, konvensi pemanggilan untuk fungsi variadic berbeda dari fungsi biasa

Pada platform tersebut, diperlukan untuk menentukan atribut argtypes untuk argumen fungsi reguler, non-variadik

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Karena menentukan atribut tidak menghambat portabilitas, disarankan untuk selalu menentukan

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Memanggil fungsi dengan tipe data kustom Anda sendiri

Anda juga dapat menyesuaikan konversi argumen untuk mengizinkan instance kelas Anda sendiri digunakan sebagai argumen fungsi. mencari atribut

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Jika Anda tidak ingin menyimpan data instance dalam variabel instance

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Menentukan jenis argumen yang diperlukan (prototipe fungsi)

Dimungkinkan untuk menentukan jenis argumen yang diperlukan dari fungsi yang diekspor dari DLL dengan menyetel atribut

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Specifying a format protects against incompatible argument types (just as a prototype for a C function), and tries to convert the arguments to valid types

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Jika Anda telah menentukan kelas Anda sendiri yang Anda berikan ke panggilan fungsi, Anda harus menerapkan metode kelas

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Jenis pengembalian

Secara default fungsi diasumsikan mengembalikan tipe C int . Jenis pengembalian lainnya dapat ditentukan dengan menyetel atribut ________10______77 dari objek fungsi.

Here is a more advanced example, it uses the

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

If you want to avoid the

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

You can also use a callable Python object (a function or a class for example) as the

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Please note that a much more powerful error checking mechanism is available through the

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Passing pointers (or. passing parameters by reference)

Sometimes a C api function expects a pointer to a data type as parameter, probably to write into the corresponding location, or if the data is too large to be passed by value. This is also known as passing parameters by reference

exports the function which is used to pass parameters by reference. The same effect can be achieved with the function, although does a lot more work since it constructs a real pointer object, so it is faster to use if you don’t need the pointer object in Python itself

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Structures and unions

Structures and unions must derive from the and base classes which are defined in the module. Each subclass must define a

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

The field type must be a type like , or any other derived type. structure, union, array, pointer

Here is a simple example of a POINT structure, which contains two integers named x and y, and also shows how to initialize a structure in the constructor

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

You can, however, build much more complicated structures. A structure can itself contain other structures by using a structure as a field type

Here is a RECT structure which contains two POINTs named upperleft and lowerright

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Nested structures can also be initialized in the constructor in several ways

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Field s can be retrieved from the class, they are useful for debugging because they can provide useful information

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Warning

does not support passing unions or structures with bit-fields to functions by value. While this may work on 32-bit x86, it’s not guaranteed by the library to work in the general case. Unions and structures with bit-fields should always be passed to functions by pointer

Structure/union alignment and byte order

By default, Structure and Union fields are aligned in the same way the C compiler does it. It is possible to override this behavior by specifying a

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

uses the native byte order for Structures and Unions. To build structures with non-native byte order, you can use one of the , , , and base classes. These classes cannot contain pointer fields

Bit fields in structures and unions

It is possible to create structures and unions containing bit fields. Bit fields are only possible for integer fields, the bit width is specified as the third item in the

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Arrays

Arrays are sequences, containing a fixed number of instances of the same type

The recommended way to create array types is by multiplying a data type with a positive integer

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Here is an example of a somewhat artificial data type, a structure containing 4 POINTs among other stuff

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Instances are created in the usual way, by calling the class

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

The above code print a series of

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Initializers of the correct type can also be specified

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Pointers

Pointer instances are created by calling the function on a type

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Pointer instances have a attribute which returns the object to which the pointer points, the

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Note that does not have OOR (original object return), it constructs a new, equivalent object each time you retrieve an attribute

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Assigning another instance to the pointer’s contents attribute would cause the pointer to point to the memory location where this is stored

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Pointer instances can also be indexed with integers

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Assigning to an integer index changes the pointed to value

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

It is also possible to use indexes different from 0, but you must know what you’re doing, just as in C. You can access or change arbitrary memory locations. Umumnya Anda hanya menggunakan fitur ini jika Anda menerima pointer dari fungsi C, dan Anda tahu bahwa pointer sebenarnya menunjuk ke array, bukan satu item

Di belakang layar, fungsi melakukan lebih dari sekadar membuat instance pointer, ia harus membuat tipe pointer terlebih dahulu. Ini dilakukan dengan fungsi, yang menerima tipe apapun, dan mengembalikan tipe baru

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Memanggil tipe pointer tanpa argumen membuat

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

memeriksa

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Ketik konversi

Biasanya, ctypes melakukan pemeriksaan tipe yang ketat. Ini berarti, jika Anda memiliki

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Selain itu, jika argumen fungsi dinyatakan secara eksplisit sebagai tipe penunjuk (seperti

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> windll.kernel32.GetModuleHandleA(32)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OSError: exception: access violation reading 0x00000020
>>>

Untuk menyetel bidang jenis POINTER ke

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Terkadang Anda memiliki contoh tipe yang tidak kompatibel. Di C, Anda dapat memasukkan satu tipe ke tipe lain. menyediakan fungsi yang dapat digunakan dengan cara yang sama. Struktur

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Untuk kasus ini, fungsinya berguna

Fungsi ini dapat digunakan untuk mentransmisikan instance ctypes ke dalam pointer ke tipe data ctypes yang berbeda. mengambil dua parameter, objek ctypes yang sedang atau dapat dikonversi menjadi semacam pointer, dan tipe pointer ctypes. Ia mengembalikan instance dari argumen kedua, yang mereferensikan blok memori yang sama dengan argumen pertama

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Jadi, dapat digunakan untuk menetapkan bidang

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Jenis Tidak Lengkap

Tipe Tidak Lengkap adalah struktur, gabungan, atau larik yang anggotanya belum ditentukan. Di C, mereka ditentukan oleh deklarasi maju, yang ditentukan nanti

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Terjemahan langsung ke dalam kode ctypes adalah ini, tetapi tidak berhasil

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

karena

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Mari kita coba. Kami membuat dua contoh

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

Fungsi panggilan balik

memungkinkan membuat pointer fungsi callable C dari callable Python. Ini terkadang disebut fungsi panggilan balik

Pertama, Anda harus membuat kelas untuk fungsi callback. Kelas mengetahui konvensi pemanggilan, tipe pengembalian, dan jumlah serta tipe argumen yang akan diterima fungsi ini

Fungsi pabrik membuat tipe untuk fungsi callback menggunakan konvensi pemanggilan

>>> windll.kernel32.GetModuleHandleA(32)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OSError: exception: access violation reading 0x00000020
>>>

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

Kedua fungsi pabrik ini dipanggil dengan tipe hasil sebagai argumen pertama, dan fungsi callback tipe argumen yang diharapkan sebagai argumen yang tersisa

Saya akan menyajikan contoh di sini yang menggunakan fungsi

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Jadi fungsi panggilan balik kami menerima pointer ke bilangan bulat, dan harus mengembalikan bilangan bulat. Pertama kita membuat

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Untuk memulai, berikut adalah callback sederhana yang menunjukkan nilai yang diteruskan

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Hasil

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Sekarang kita benar-benar dapat membandingkan dua item dan mengembalikan hasil yang bermanfaat

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Karena kita dapat dengan mudah memeriksa, array kita sudah diurutkan sekarang

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Fungsi pabrik dapat digunakan sebagai pabrik penghias, jadi sebaiknya kita tulis saja

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Catatan

Pastikan Anda menyimpan referensi ke objek selama digunakan dari kode C. tidak, dan jika tidak, mereka mungkin mengumpulkan sampah, merusak program Anda saat panggilan balik dilakukan

Juga, perhatikan bahwa jika fungsi panggilan balik dipanggil di utas yang dibuat di luar kendali Python (mis. g. oleh kode asing yang memanggil panggilan balik), ctypes membuat utas Python dummy baru pada setiap doa. Perilaku ini benar untuk sebagian besar tujuan, tetapi itu berarti bahwa nilai yang disimpan dengan tidak akan bertahan di callback yang berbeda, meskipun panggilan tersebut dibuat dari utas C yang sama

Mengakses nilai yang diekspor dari dll

Beberapa pustaka bersama tidak hanya mengekspor fungsi, tetapi juga mengekspor variabel. Contoh di pustaka Python itu sendiri adalah , bilangan bulat yang disetel ke 0, 1, atau 2, tergantung pada tanda atau yang diberikan saat startup

dapat mengakses nilai seperti ini dengan metode kelas ________12______67 dari tipe tersebut. pythonapi adalah simbol standar yang memberikan akses ke api Python C

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Jika juru bahasa dimulai dengan , sampel akan dicetak

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Contoh tambahan yang juga mendemonstrasikan penggunaan pointer mengakses pointer yang diekspor oleh Python

Mengutip dokumen untuk nilai itu

Pointer ini diinisialisasi untuk menunjuk ke array catatan, diakhiri oleh satu yang anggotanya semuanya

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

13 atau nol. Saat modul yang dibekukan diimpor, modul tersebut dicari di tabel ini. Kode pihak ketiga dapat memainkan trik dengan ini untuk menyediakan kumpulan modul beku yang dibuat secara dinamis

Jadi memanipulasi penunjuk ini bahkan terbukti bermanfaat. Untuk membatasi ukuran contoh, kami hanya menunjukkan bagaimana tabel ini dapat dibaca

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Kita telah menentukan tipe datanya, sehingga kita bisa mengarahkan pointer ke tabel

>>> cdll.kernel32[1]  
<_FuncPtr object at 0x...>
>>> cdll.kernel32[0]  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 310, in __getitem__
    func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
>>>

Karena

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

Fakta bahwa Python standar memiliki modul beku dan paket beku (ditunjukkan dengan anggota negatif

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Kejutan

Ada beberapa sisi di mana Anda mungkin mengharapkan sesuatu selain dari apa yang sebenarnya terjadi

Perhatikan contoh berikut

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

Hm. Kami tentu mengharapkan pernyataan terakhir untuk mencetak ________12______84. Apa yang terjadi?

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

Perhatikan bahwa

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Perlu diingat bahwa mengambil sub-objek dari Structure, Unions, dan Arrays tidak menyalin sub-objek, melainkan mengambil objek pembungkus yang mengakses buffer dasar objek root

Another example that may behave differently from what one would expect is this

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

Catatan

Objects instantiated from can only have their value set to bytes or integers

Mengapa mencetak

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Tipe data berukuran variabel

menyediakan beberapa dukungan untuk array dan struktur berukuran variabel

The function can be used to resize the memory buffer of an existing ctypes object. Fungsi mengambil objek sebagai argumen pertama, dan ukuran yang diminta dalam byte sebagai argumen kedua. Blok memori tidak dapat dibuat lebih kecil dari blok memori alami yang ditentukan oleh tipe objek, a dinaikkan jika ini dicoba

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

Ini bagus dan bagus, tetapi bagaimana cara mengakses elemen tambahan yang terkandung dalam larik ini?

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

Cara lain untuk menggunakan tipe data berukuran variabel adalah dengan menggunakan sifat dinamis Python, dan (kembali) mendefinisikan tipe data setelah ukuran yang diperlukan sudah diketahui, berdasarkan kasus per kasus

Menemukan perpustakaan bersama

Saat memprogram dalam bahasa yang dikompilasi, pustaka bersama diakses saat mengompilasi/menautkan program, dan saat program dijalankan

Tujuan dari fungsi

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Modul

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Cobalah untuk menemukan perpustakaan dan kembalikan nama path. name adalah nama perpustakaan tanpa awalan seperti lib, akhiran seperti

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

The exact functionality is system dependent

Di Linux,

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Berubah di versi 3. 6. Di Linux, nilai variabel lingkungan

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Berikut beberapa contohnya

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

Di macOS,

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

Di Windows,

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Jika membungkus perpustakaan bersama dengan , mungkin lebih baik untuk menentukan nama perpustakaan bersama pada waktu pengembangan, dan meng-hardcode-nya ke dalam modul pembungkus daripada menggunakan

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Memuat pustaka bersama

Ada beberapa cara untuk memuat pustaka bersama ke dalam proses Python. Salah satu caranya adalah dengan menginstansiasi salah satu kelas berikut

Instance kelas ini mewakili pustaka bersama yang dimuat. Functions in these libraries use the standard C calling convention, and are assumed to return int .

Di Windows, pembuatan instance mungkin gagal meskipun nama DLL ada. Ketika DLL dependen dari DLL yang dimuat tidak ditemukan, kesalahan muncul dengan pesan "[WinError 126] Modul yang ditentukan tidak dapat ditemukan". Pesan galat ini tidak berisi nama DLL yang hilang karena Windows API tidak mengembalikan informasi ini membuat galat ini sulit didiagnosis. Untuk mengatasi kesalahan ini dan menentukan DLL mana yang tidak ditemukan, Anda perlu menemukan daftar DLL dependen dan menentukan mana yang tidak ditemukan menggunakan alat debugging dan penelusuran Windows

Lihat juga

Alat Microsoft DUMPBIN – Alat untuk menemukan tanggungan DLL

Jendela saja. Instance kelas ini mewakili pustaka bersama yang dimuat, fungsi dalam pustaka ini menggunakan konvensi pemanggilan

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

Berubah di versi 3. 3. used to be raised.

Hanya Windows. Instance kelas ini merepresentasikan pustaka bersama yang dimuat, fungsi dalam pustaka ini menggunakan konvensi pemanggilan

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

Python dirilis sebelum memanggil fungsi apa pun yang diekspor oleh pustaka ini, dan diperoleh kembali setelahnya

Instances of this class behave like instances, except that the Python GIL is not released during the function call, and after the function execution the Python error flag is checked. Jika bendera kesalahan disetel, pengecualian Python dimunculkan

Jadi, ini hanya berguna untuk memanggil fungsi Python C api secara langsung

Semua class ini dapat dibuat instance-nya dengan memanggilnya dengan setidaknya satu argumen, nama path dari shared library. Jika Anda memiliki pegangan yang ada untuk perpustakaan bersama yang sudah dimuat, itu dapat diteruskan sebagai parameter bernama

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Parameter mode dapat digunakan untuk menentukan bagaimana perpustakaan dimuat. Untuk detailnya, lihat dlopen(3) halaman manual. Di Windows, mode diabaikan. Pada sistem posix, RTLD_NOW selalu ditambahkan, dan tidak dapat dikonfigurasi

Parameter use_errno, jika disetel ke true, mengaktifkan mekanisme ctypes yang memungkinkan akses ke nomor kesalahan sistem dengan cara yang aman. menyimpan salinan thread-local dari variabel sistem;

Fungsi mengembalikan nilai salinan pribadi ctypes, dan fungsi mengubah salinan pribadi ctypes ke nilai baru dan mengembalikan nilai sebelumnya

Parameter use_last_error, jika disetel ke true, mengaktifkan mekanisme yang sama untuk kode kesalahan Windows yang dikelola oleh dan

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Parameter winmode digunakan pada Windows untuk menentukan bagaimana perpustakaan dimuat (karena mode diabaikan). Dibutuhkan nilai apa pun yang valid untuk parameter bendera Win32 API

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Berubah di versi 3. 8. Menambahkan parameter winmode.

Tandai untuk digunakan sebagai parameter mode. Pada platform di mana bendera ini tidak tersedia, itu didefinisikan sebagai bilangan bulat nol

Tandai untuk digunakan sebagai parameter mode. Pada platform yang tidak tersedia, ini sama dengan RTLD_GLOBAL

Mode default yang digunakan untuk memuat pustaka bersama. Di OSX 10. 3, ini adalah RTLD_GLOBAL, selain itu sama dengan RTLD_LOCAL

Instance dari kelas-kelas ini tidak memiliki metode publik. Fungsi yang diekspor oleh pustaka bersama dapat diakses sebagai atribut atau indeks. Harap perhatikan bahwa mengakses fungsi melalui atribut menyimpan hasil dan karena itu mengaksesnya berulang kali mengembalikan objek yang sama setiap saat. Di sisi lain, mengaksesnya melalui indeks mengembalikan objek baru setiap saat

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

The following public attributes are available, their name starts with an underscore to not clash with exported function names

Pegangan sistem yang digunakan untuk mengakses perpustakaan

Nama perpustakaan diteruskan dalam konstruktor

Pustaka bersama juga dapat dimuat dengan menggunakan salah satu objek prefabrikasi, yang merupakan turunan dari kelas, baik dengan memanggil metode

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Class which loads shared libraries. dlltype should be one of the , , , or types

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Muat pustaka bersama ke dalam proses dan kembalikan. Metode ini selalu mengembalikan instance perpustakaan yang baru

Pemuat perpustakaan prefabrikasi ini tersedia

Membuat instance

Jendela saja. Creates instances

Jendela saja. Creates instances

Membuat instance

Untuk mengakses api C Python secara langsung, tersedia objek pustaka bersama Python siap pakai

Contoh yang memperlihatkan fungsi Python C API sebagai atribut. Perhatikan bahwa semua fungsi ini diasumsikan mengembalikan C int , yang tentu saja tidak selalu benar, jadi Anda harus menetapkan atribut

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Memuat pustaka melalui salah satu objek ini memunculkan

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Mengakses fungsi pada pustaka yang dimuat memunculkan peristiwa audit

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Dalam kasus ketika hanya pegangan perpustakaan yang tersedia daripada objek, mengakses fungsi memunculkan acara audit

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Fungsi asing

Seperti yang dijelaskan di bagian sebelumnya, fungsi asing dapat diakses sebagai atribut pustaka bersama yang dimuat. Objek fungsi yang dibuat dengan cara ini secara default menerima sejumlah argumen, menerima instance data ctypes apa pun sebagai argumen, dan mengembalikan tipe hasil default yang ditentukan oleh pemuat pustaka. They are instances of a private class

Kelas dasar untuk fungsi asing C yang dapat dipanggil

Instance dari fungsi asing juga merupakan tipe data yang kompatibel dengan C;

Perilaku ini dapat dikustomisasi dengan menetapkan atribut khusus dari objek fungsi asing

Assign a ctypes type to specify the result type of the foreign function. Gunakan

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Dimungkinkan untuk menetapkan objek Python yang dapat dipanggil yang bukan tipe ctypes, dalam hal ini fungsi diasumsikan mengembalikan C int, and the callable will be called with this integer, allowing further processing or error checking. Using this is deprecated, for more flexible post processing or error checking use a ctypes data type as and assign a callable to the attribute.

Tetapkan tuple tipe ctypes untuk menentukan tipe argumen yang diterima fungsi. Fungsi yang menggunakan konvensi pemanggilan

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

Ketika fungsi asing dipanggil, setiap argumen aktual diteruskan ke metode kelas

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Baru. Sekarang dimungkinkan untuk meletakkan item dalam tipe arg yang bukan tipe ctype, tetapi setiap item harus memiliki metode

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

Tetapkan fungsi Python atau callable lainnya ke atribut ini. Callable akan dipanggil dengan tiga atau lebih argumen

hasilnya adalah apa yang dikembalikan oleh fungsi asing, seperti yang ditentukan oleh atribut

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

func is the foreign function object itself, this allows reusing the same callable object to check or post process the results of several functions

argumen adalah tupel yang berisi parameter yang awalnya diteruskan ke pemanggilan fungsi, ini memungkinkan mengkhususkan perilaku pada argumen yang digunakan

Objek yang dikembalikan fungsi ini akan dikembalikan dari pemanggilan fungsi asing, tetapi juga dapat memeriksa nilai hasil dan memunculkan pengecualian jika pemanggilan fungsi asing gagal

Pengecualian ini muncul saat pemanggilan fungsi asing tidak dapat mengonversi salah satu argumen yang diteruskan

Di Windows, ketika panggilan fungsi asing menimbulkan pengecualian sistem (misalnya, karena pelanggaran akses), itu akan ditangkap dan diganti dengan pengecualian Python yang sesuai. Selanjutnya, acara audit

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Beberapa cara untuk memanggil panggilan fungsi asing dapat menimbulkan peristiwa audit

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Prototipe fungsi

Fungsi asing juga dapat dibuat dengan instantiating prototipe fungsi. Prototipe fungsi mirip dengan prototipe fungsi di C; . Fungsi pabrik harus dipanggil dengan tipe hasil yang diinginkan dan tipe argumen dari fungsi, dan dapat digunakan sebagai pabrik penghias, dan dengan demikian, diterapkan ke fungsi melalui sintaks ________19______79. Lihat untuk contoh

Prototipe fungsi yang dikembalikan membuat fungsi yang menggunakan konvensi pemanggilan C standar. Fungsi ini akan melepaskan GIL selama panggilan berlangsung. Jika use_errno disetel ke true, salinan pribadi ctypes dari variabel sistem ditukar dengan nilai sebenarnya sebelum dan sesudah panggilan;

Jendela saja. Prototipe fungsi yang dikembalikan membuat fungsi yang menggunakan konvensi pemanggilan

>>> c_int()
c_long(0)
>>> c_wchar_p("Hello, World")
c_wchar_p(140018365411392)
>>> c_ushort(-3)
c_ushort(65533)
>>>

Prototipe fungsi yang dikembalikan membuat fungsi yang menggunakan konvensi pemanggilan Python. Fungsi tidak akan melepaskan GIL selama panggilan

Prototipe fungsi yang dibuat oleh fungsi pabrik ini dapat dibuat dengan cara yang berbeda, bergantung pada jenis dan jumlah parameter dalam panggilan

prototipe(alamat)

Mengembalikan fungsi asing di alamat yang ditentukan yang harus bilangan bulat

prototipe(dapat dipanggil)

Buat fungsi callable C (fungsi callback) dari callable Python

prototipe(func_spec[ , paramflags])

Mengembalikan fungsi asing yang diekspor oleh pustaka bersama. func_spec harus berupa 2-tuple

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

83. Item pertama adalah nama fungsi yang diekspor sebagai string, atau urutan fungsi yang diekspor sebagai bilangan bulat kecil. Item kedua adalah instance perpustakaan bersama

prototipe(vtbl_index , nama[, paramflags[, iid]])

Mengembalikan fungsi asing yang akan memanggil metode COM. vtbl_index adalah indeks ke dalam tabel fungsi virtual, bilangan bulat non-negatif kecil. nama adalah nama metode COM. iid adalah pointer opsional ke pengidentifikasi antarmuka yang digunakan dalam pelaporan kesalahan yang diperluas

COM methods use a special calling convention. They require a pointer to the COM interface as first argument, in addition to those parameters that are specified in the

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

62 tuple

Parameter paramflags opsional membuat pembungkus fungsi asing dengan lebih banyak fungsi daripada fitur yang dijelaskan di atas

paramflags must be a tuple of the same length as

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

62

Setiap item dalam tuple ini berisi informasi lebih lanjut tentang parameter, itu harus berupa tuple yang berisi satu, dua, atau tiga item

The first item is an integer containing a combination of direction flags for the parameter

1

Menentukan parameter input ke fungsi

2

Parameter keluaran. Fungsi asing mengisi nilai

4

Parameter input yang defaultnya adalah bilangan bulat nol

The optional second item is the parameter name as string. Jika ini ditentukan, fungsi asing dapat dipanggil dengan parameter bernama

Item ketiga opsional adalah nilai default untuk parameter ini

This example demonstrates how to wrap the Windows

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

>>> print(libc.time(None))  
1150640792
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
0x1d000000
>>>

Here is the wrapping with

>>> cdll.kernel32.GetModuleHandleA(None)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>

>>> windll.msvcrt.printf(b"spam")  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>

Fungsi asing

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

>>> cdll.kernel32.GetModuleHandleA(None)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>

>>> windll.msvcrt.printf(b"spam")  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>

A second example demonstrates output parameters. The win32

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

>>> cdll.kernel32.GetModuleHandleA(None)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>

>>> windll.msvcrt.printf(b"spam")  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>

Here is the wrapping with

>>> cdll.kernel32.GetModuleHandleA(None)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>

>>> windll.msvcrt.printf(b"spam")  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>

Functions with output parameters will automatically return the output parameter value if there is a single one, or a tuple containing the output parameter values when there are more than one, so the GetWindowRect function now returns a RECT instance, when called

Output parameters can be combined with the

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

>>> cdll.kernel32.GetModuleHandleA(None)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>

>>> windll.msvcrt.printf(b"spam")  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>

If the

>>> cdll.LoadLibrary("libc.so.6")  
<CDLL 'libc.so.6', handle .. at ...>
>>> libc = CDLL("libc.so.6")       
>>> libc                           
<CDLL 'libc.so.6', handle .. at ...>
>>>

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

>>> cdll.kernel32.GetModuleHandleA(None)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>

>>> windll.msvcrt.printf(b"spam")  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>

Fungsi utilitas

Mengembalikan alamat buffer memori sebagai bilangan bulat. obj must be an instance of a ctypes type

Raises an

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

Mengembalikan persyaratan penyelarasan dari tipe ctypes. obj_or_type must be a ctypes type or instance

Returns a light-weight pointer to obj, which must be an instance of a ctypes type. offset default ke nol, dan harus bilangan bulat yang akan ditambahkan ke nilai pointer internal

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

>>> cdll.kernel32.GetModuleHandleA(None)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>>

>>> windll.msvcrt.printf(b"spam")  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with too many arguments (4 bytes in excess)
>>>

The returned object can only be used as a foreign function call parameter. It behaves similar to

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

This function is similar to the cast operator in C. It returns a new instance of type which points to the same memory block as obj. type harus berupa tipe pointer, dan obj harus berupa objek yang dapat diinterpretasikan sebagai pointer

Fungsi ini membuat buffer karakter yang bisa berubah. The returned object is a ctypes array of

init_or_size harus berupa bilangan bulat yang menentukan ukuran array, atau objek bytes yang akan digunakan untuk menginisialisasi item array

Jika objek bytes ditentukan sebagai argumen pertama, buffer dibuat satu item lebih besar dari panjangnya sehingga elemen terakhir dalam array adalah karakter terminasi NUL. Bilangan bulat dapat diteruskan sebagai argumen kedua yang memungkinkan menentukan ukuran array jika panjang byte tidak boleh digunakan

Memunculkan

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Fungsi ini membuat buffer karakter unicode yang dapat diubah. Objek yang dikembalikan adalah array ctypes

init_or_size must be an integer which specifies the size of the array, or a string which will be used to initialize the array items

Jika string ditentukan sebagai argumen pertama, buffer dibuat satu item lebih besar dari panjang string sehingga elemen terakhir dalam array adalah karakter terminasi NUL. An integer can be passed as second argument which allows specifying the size of the array if the length of the string should not be used

Raises an

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>

>>> from ctypes import *
>>> libc.printf
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)  
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "ctypes.py", line 239, in __getattr__
    func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
>>>

Jendela saja. Fungsi ini adalah pengait yang memungkinkan penerapan server COM dalam proses dengan ctypes. Ini dipanggil dari fungsi DllCanUnloadNow yang diekspor dll ekstensi _ctypes

Jendela saja. Fungsi ini adalah pengait yang memungkinkan penerapan server COM dalam proses dengan ctypes. Dipanggil dari fungsi DllGetClassObject yang diekspor oleh ekstensi

>>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
<_FuncPtr object at 0x...>
>>>