Saya andaikan anda yang ingin membaca artikel ini tahu apa itu skrip taip. Pembangun Javascript mencipta skrip taip untuk menjadikan javascript lebih selamat jenis. Typesafe menjadikan kod lebih mudah dibaca dan mempunyai kurang pepijat tanpa menulis sebarang ujian. Bolehkah typesafety dicapai dalam python?.
Bayangkan fungsi yang kelihatan tidak bersalah ini
def send_email(sender, receiver, message):
...
Saya sengaja menyembunyikan pelaksanaan kodnya. Bolehkah anda meneka fungsi untuk apa dan parameter apa yang kita perlukan untuk menggunakan fungsi ini hanya dengan nama dan parameter fungsinya?. Kami tahu dari nama fungsinya ia berfungsi untuk menghantar e-mel. Bagaimana pula dengan parameternya, apakah yang perlu kita letakkan untuk menggunakan fungsi ini?.
Pengirim tekaan pertama ialah str e-mel, penerima ialah str e-mel, mesej ialah str kandungan e-mel.
send_email(sender="john@mail.com", receiver="doe@mail.com", message="Hello doe! How are you?")
Tekaan paling mudah. tetapi ia bukan satu-satunya tekaan.
Penghantar tekaan kedua ialah int user_id pada db, penerima ialah int user_id pada db, mesej ialah str kandungan e-mel.
john_user_id = 1 doe_user_id = 2 send_email(sender=1, receiver=2, message="Hello doe! How are you?")
Bayangkan bekerja pada aplikasi. Kebanyakan aplikasi menggunakan beberapa pangkalan data. Pengguna biasanya diwakili oleh idnya.
Penghantar tekaan ketiga ialah kamus, penerima ialah kamus, mesej ialah kamus.
john = {
"id": 1,
"username": "john",
"email": "john@mail.com"
}
doe = {
"id": 2,
"username": "doe",
"email": "doe@mail.com"
}
message = {
"title": "Greeting my friend doe",
"body": "Hello doe! How are you?"
}
send_email(sender=john, receiver=doe, message=message)
Mungkin send_email memerlukan lebih daripada e-mel dan id pengguna. Untuk menambah lebih banyak data pada setiap parameter, ia menggunakan beberapa struktur kamus. Anda perasan bahawa mesej itu bukan sekadar str mungkin ia memerlukan tajuk dan kandungan.
Penghantar tekaan keempat ialah Pengguna kelas, penerima ialah Pengguna kelas, mesej ialah kamus.
class User():
def __init__(self, id, username, email):
self.id = id
self.username = username
self.email = email
john = User(id=1, username="john", email="john@mail.com")
doe = User(id=2, username="doe", email="doe@mail.com")
message = {
"title": "Greeting my friend doe",
"body": "Hello doe! How are you?"
}
send_email(sender=john, receiver=doe, message=message)
Mungkin send_email berintegrasi dengan beberapa orm pangkalan data seperti Django ORM atau Sqlalchemy. Untuk memudahkan pengguna akhir, ia menggunakan kelas ORM secara langsung.
Jadi yang mana satu jawapan yang betul? salah satunya boleh menjadi jawapan yang betul. Mungkin jawapan yang betul boleh menjadi gabungan dua tekaan. Seperti penghantar dan penerima ialah Pengguna kelas (Tekaan Keempat) tetapi mesej itu str (Tekaan pertama). Kami tidak pasti melainkan kami membaca pelaksanaan kodnya. Yang membuang masa jika anda pengguna akhir. Sebagai pengguna akhir yang menggunakan fungsi ini, kami hanya perlukan fungsi apa, parameter apa yang diperlukan dan output fungsi apa.
Python telah membina dokumentasi fungsi menggunakan docstring. Di sini contoh docstring.
def add(x, y):
"""Add two number
Parameter:\n
x -- int\n
y -- int\n
Return: int
"""
return x + y
def send_email(sender, receiver, message):
"""Send email from sender to receiver
Parameter:\n
sender -- email sender, class User\n
receiver -- email receiver, class User\n
message -- body of the email, dictionary (ex: {"title": "some title", "body": "email body"}\n
Return: None
"""
...
Apa yang menarik tentang docstring ia serasi dengan editor. Dalam vscode ia akan menunjukkan docstring apabila anda menuding pada fungsi. Kebanyakan perpustakaan dalam python menggunakan docstring untuk mendokumentasikan fungsinya.
Masalah dengan docstring ialah penyegerakan dokumen. Cara anda memastikan bahawa docstring sentiasa disegerakkan dengan pelaksanaan kod. Anda tidak boleh mengujinya dengan betul. Saya mendengarnya daripada orang rawak di internet "Memiliki dokumentasi yang lapuk adalah lebih teruk daripada tidak mempunyai dokumentasi".
Btw Anda boleh menguji docstring menggunakan doctest kinda. Doctest menguji docstring anda dengan menjalankan contoh pada docstring anda. Doctest sudah diprapasang dalam python jadi anda tidak memerlukan pergantungan luaran. mari lihat contoh ini buat fail baharu bernama my_math.py kemudian letakkan kod ini.
# my_math.py
def add(x, y):
"""Add two integer
Parameter:\n
x -- int\n
y -- int\n
Return: int
>>> add(1, 2)
3
"""
return x + y
if __name__ == "__main__":
import doctest
doctest.testmod()
Ia adalah kod yang sama seperti contoh docstring tetapi saya menambah contoh dan doctest pada baris terakhir kod. Untuk menguji docstring hanya jalankan fail python my_math.py. Jika tiada output bermakna contoh anda lulus ujian. Jika anda mahu melihat output menjalankannya dalam mod verbose python my_math.py -v, anda akan melihat output ini.
Trying:
add(1, 2)
Expecting:
3
ok
1 items had no tests:
__main__
1 items passed all tests:
1 tests in __main__.add
1 tests in 2 items.
1 passed and 0 failed.
Test passed
Jika anda membuat kesilapan pada contoh kod ia akan mengembalikan ralat.
# my_math.py
def add(x, y):
"""Add two integer
Parameter:\n
x -- int\n
y -- int\n
Return: int
>>> add(2, 2) # <-- I change it here
3
"""
return x + y
if __name__ == "__main__":
import doctest
doctest.testmod()
keluaran:
**********************************************************************
File "~/typescript-in-python/my_math.py", line 12, in __main__.add
Failed example:
add(2, 2) # <-- I change it here
Expected:
3
Got:
4
**********************************************************************
1 items had failures:
1 of 1 in __main__.add
***Test Failed*** 1 failures.
Hebat! kini saya boleh menguji docstring saya. Tetapi kaveatnya ialah:
Kadangkala anda tidak perlu menjalankan kod untuk menyemak sama ada kod betul atau tidak. Anda hanya memerlukan jenis input dan jenis output. Bagaimana? Pertimbangkan contoh ini.
def add(x, y):
"""Add two integer
Parameter:\n
x -- int\n
y -- int\n
Return: int
"""
return x + y
def sub(x, y):
"""Substract two integer
Parameter:\n
x -- int\n
y -- int\n
Return: int
"""
return x - y
a = add(2, 1)
b = add(1, 1)
c = sub(a, b)
fungsi tambah kembalikan int dan sub fungsi memerlukan dua int sebagai parameter input. Jika saya menggunakan dua pulangan dari fungsi tambah kemudian letakkannya pada sub paramater seperti contoh di atas adakah ia ralat? sudah tentu bukan kerana sub fungsi memerlukan int dan anda meletakkan int juga.
Memandangkan python 3.5 python telah dibina dalam jenis yang dipanggil menaip. Dengan menaip anda boleh menambah jenis pada fungsi anda seperti contoh di bawah.
def add(x: int, y: int) -> int:
"""Add two integer"""
return x + y
a = add(1, 2)
Instead put it on your docstring you put it on the function. Typing is supported on many editor. If you use vscode you can hover on variable and it will shown it's type.
Nice now our code will have a type safety. eeehhhh not realy. If I intentionally use function incorrectlly like this.
def add(x: int, y: int) -> int:
"""Add two integer"""
return x + y
res = add(1, [])
print(res)
It will show error
Traceback (most recent call last):
File "~/typescript-in-python/main.py", line 5, in <module>
res = add(1, [])
^^^^^^^^^^
File "~/typescript-in-python/main.py", line 3, in add
return x + y
~~^~~
TypeError: unsupported operand type(s) for +: 'int' and 'list'
But it doesn't show that you put incorrect type. Even worse if you use it like this.
def add(x: int, y: int) -> int:
"""Add two integer"""
return x + y
res = add("hello", "world")
print(res)
It will succeed. It must be error because you put incorrect type.
helloworld
Why python typing doesn't have type checker by default??. Based on pep-3107 it said
Before launching into a discussion of the precise ins and outs of Python 3.0’s function annotations, let’s first talk broadly about what annotations are and are not:
- Function annotations, both for parameters and return values, are completely optional.
- Function annotations are nothing more than a way of associating arbitrary Python expressions with various parts of a function at compile-time. By itself, Python does not attach any particular meaning or significance to annotations. Left to its own, Python simply makes these expressions available as described in Accessing Function Annotations below.
The only way that annotations take on meaning is when they are interpreted by third-party libraries. ...
So in python typing is like a decorator in typescript or java it doesn't mean anything. You need third party libraries todo type checking. Let's see some library for typechecking.
Here are libraries for typechecking in python. For example we will typecheck this wrong.py file
def add(x: int, y: int) -> int:
"""Add two integer"""
return x + y
res = add("hello", "world")
print(res)
1.mypy
The "OG" of python type checker. To install it just using pip pip install mypy. Now let's use mypy to typecheck this file. Run mypy wrong.py. It will shown type error which is nice.
wrong.py:5: error: Argument 1 to "add" has incompatible type "str"; expected "int" [arg-type] wrong.py:5: error: Argument 2 to "add" has incompatible type "str"; expected "int" [arg-type] Found 2 errors in 1 file (checked 1 source file)
btw you can run mypy on entire project by using mypy ..
2.pyright
Another typechecker is pyright. It created by microsoft. It's same like mypy install through pip pip install pyright. Then run it pyright wrong.py. It will shown this error.
~/typescript-in-python/wrong.py
~/typescript-in-python/wrong.py:5:11 - error: Argument of type "Literal['hello']" cannot be assigned to parameter "x" of type "int" in function "add"
"Literal['hello']" is incompatible with "int" (reportArgumentType)
~/typescript-in-python/wrong.py:5:20 - error: Argument of type "Literal['world']" cannot be assigned to parameter "y" of type "int" in function "add"
"Literal['world']" is incompatible with "int" (reportArgumentType)
2 errors, 0 warnings, 0 informations
It said that it's more faster than mypy but I found that's not much diffrent. Maybe my code base it's to small. Also pyright implement more python standard than mypy you can see on https://microsoft.github.io/pyright/#/mypy-comparison. Personaly I prefer mypy than pyright because the error message were more readable.
3.pylyzer
Speaking of performance and speed another new python typechecker pylyzer. It's written in rust. You can install it through pip pip install pylyzer or through cargo (rust package manager) cargo install pylyzer --locked. Then run it pylyzer wrong.py. It will shown this error.
Start checking: wrong.py
Found 2 errors: wrong.py
Error[#2258]: File wrong.py, line 5, <module>.res
5 | res = add("hello", "world")
: -------
: |- expected: Int
: `- but found: {"hello"}
TypeError: the type of add::x (the 1st argument) is mismatched
Error[#2258]: File wrong.py, line 5, <module>.res
5 | res = add("hello", "world")
: -------
: |- expected: Int
: `- but found: {"world"}
TypeError: the type of add::y (the 2nd argument) is mismatched
So far this is the most readable and beautiful error message. It's reminds me of rust compiler error. Speed, performance and most readable error message, I think I will choose to using pylyzer if the package already stable. The problem is at the time I write this blog, pylyzer still in beta. It can only typecheck your code base, it haven't support external depedencies.
Alright we successfully write python code like typescript (kinda). There is more way to using python typing module other than check simple type (str, int, bool etc). Maybe I will cover more advance type it in next blog. Maybe you guys have opinion about this, know better typechecker other then those 3, found other way to do typecheck in python or other. let me know on comment section below. As always Happy Coding.
Atas ialah kandungan terperinci Menulis kod Python seperti Typescript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
