Ungkapan biasa Python - semak sama ada input terapung

Nombor titik terapung memainkan peranan penting dalam pelbagai tugas pengaturcaraan daripada pengiraan matematik kepada analisis data. Walau bagaimanapun, apabila berurusan dengan input pengguna atau data daripada sumber luaran, adalah penting untuk mengesahkan bahawa input ialah nombor titik terapung yang sah. Python menyediakan alat yang berkuasa untuk menangani cabaran ini, salah satunya ialah ungkapan biasa.

Dalam artikel ini, kami akan meneroka cara menggunakan ungkapan biasa dalam Python untuk menyemak sama ada input ialah nombor titik terapung. Ungkapan biasa (sering dipanggil regex) menyediakan cara yang ringkas dan fleksibel untuk menentukan corak dan mencari padanan dalam teks. Dengan memanfaatkan ungkapan biasa, kami boleh membina corak yang betul-betul sepadan dengan format titik terapung dan mengesahkan input dengan sewajarnya.

Dalam artikel ini, kami akan meneroka cara menggunakan ungkapan biasa dalam Python untuk menyemak sama ada input ialah nombor titik terapung. Ungkapan biasa (sering dipanggil regex) menyediakan cara yang ringkas dan fleksibel untuk menentukan corak dan mencari padanan dalam teks. Dengan menggunakan ungkapan biasa, kami boleh membina corak yang betul-betul sepadan dengan format titik terapung dan mengesahkan input dengan sewajarnya.

Memahami nombor titik terapung

Nombor titik terapung ialah jenis data yang digunakan untuk mewakili nombor nyata dalam sistem komputer. Ia dipanggil "titik terapung" kerana titik perpuluhan boleh "terapung" untuk mewakili nombor saiz yang berbeza. Dalam Python, nombor titik terapung diwakili menggunakan jenis data terapung.

Nombor titik terapung boleh mempunyai kedua-dua bahagian integer dan bahagian perpuluhan, dan boleh menjadi positif atau negatif. Mereka biasanya ditulis dalam bentuk m.n, di mana m mewakili bahagian integer dan n mewakili bahagian pecahan. Sebagai contoh, 3.14 dan -0.5 ialah nombor titik terapung yang sah.

Walau bagaimanapun, perlu diingatkan bahawa disebabkan oleh had perkakasan komputer, tidak semua perwakilan perpuluhan boleh diwakili dengan tepat sebagai nombor titik terapung. Ini kadangkala boleh membawa kepada keputusan yang tidak dijangka untuk pengiraan yang melibatkan nombor titik terapung. Oleh itu, adalah penting untuk mengesahkan input dan memastikan ia mematuhi format yang diharapkan.

Dalam bahagian seterusnya, kami akan meneroka ungkapan biasa dan mempelajari cara menggunakannya untuk menyemak sama ada input ialah nombor titik terapung yang sah.

Pengenalan kepada ungkapan biasa

Ungkapan biasa (sering disingkat regex) ialah alat berkuasa untuk padanan corak dan manipulasi teks. Mereka menyediakan cara ringkas dan fleksibel untuk menentukan corak dan mencari urutan aksara tertentu dalam rentetan.

Dalam Python, modul semula menyediakan fungsi dan kaedah untuk menggunakan ungkapan biasa. Kita boleh memanfaatkan kuasa ungkapan biasa untuk menyemak sama ada input ialah nombor titik terapung yang sah.

Untuk mengesahkan nombor titik terapung menggunakan ungkapan biasa, kita perlu menentukan corak yang sepadan dengan format yang dijangkakan. Berikut ialah komponen utama corak−

• Simbol pilihan − Nombor boleh bermula dengan tanda positif pilihan (+) atau tanda negatif (-) .

• Bahagian integer− Nombor boleh mempunyai bahagian integer pilihan, yang boleh terdiri daripada satu atau lebih digit .

• Titik perpuluhan pilihan − Nombor boleh mengandungi titik perpuluhan pilihan (.) untuk memisahkan bahagian integer dan perpuluhan bahagian .

• Bahagian perpuluhan− Nombor boleh mempunyai bahagian perpuluhan pilihan yang terdiri daripada satu atau lebih digit.

• Eksponen− Nombor mungkin mempunyai bahagian eksponen pilihan, diwakili oleh huruf "e" atau "E" , diikuti dengan simbol pilihan dan satu atau lebih nombor.

Dengan membina corak ungkapan biasa yang mengandungi komponen ini, kami boleh menyemak dengan berkesan sama ada rentetan input sepadan dengan corak titik terapung.

Dalam bahagian seterusnya, kita akan menyelidiki pelaksanaan program Python yang menggunakan ungkapan biasa untuk menyemak nombor titik terapung.

Program Python untuk menyemak nombor titik terapung

Untuk menyemak sama ada input yang diberikan ialah apungan menggunakan ungkapan biasa dalam Python, kita boleh mengikuti langkah ini−

• Import modul semula − Mula-mula import modul semula, yang menyediakan fungsi dan kaedah untuk menggunakan ungkapan biasa.

• Tentukan Corak Ungkapan Biasa − Buat corak ungkapan biasa yang sepadan dengan format jangkaan nombor titik terapung. Mod ini akan digunakan untuk mengesahkan input.

• Buat Fungsi − Tentukan fungsi, mari kita panggil ia is_float, yang mengambil rentetan input sebagai parameter.

• Corak padan − Gunakan fungsi re.match() untuk memadankan rentetan input dengan corak ungkapan biasa. Fungsi ini mengembalikan objek padanan jika corak sepadan dengan rentetan, atau Tiada jika ia tidak sepadan.

• Semak jika ada padanan −Gunakan pernyataan if untuk menyemak sama ada objek yang sepadan bukan Tiada. Jika tidak Tiada, rentetan input ialah nombor titik terapung yang sah.

• Kembali hasil− Dalam pernyataan if, kembalikan Benar untuk menunjukkan bahawa input ialah nombor titik terapung. Jika tidak, mengembalikan False.

Sekarang, mari kita susun semuanya dan tulis kod Python untuk menyemak nombor titik terapung menggunakan ungkapan biasa −

import re

def is_float(input_string):
    pattern = r'^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$'
    match = re.match(pattern, input_string)
    if match:
        return True
    return False

Dalam kod di atas, kami mentakrifkan corak ungkapan biasa r'^[-+]?[0-9]*.?[0-9]+([eE][-+]?[0-9 ] +) ?$', yang sepadan dengan format jangkaan nombor titik terapung. Kami menggunakan re.match() untuk memadankan rentetan input dengan corak dan mengembalikan True jika ia sepadan.

Dalam bahagian seterusnya, kami akan menguji fungsi is_float() dengan beberapa contoh input untuk melihat cara ia berfungsi.

Program ujian

Berikut adalah beberapa kes ujian yang boleh kita cuba -

• Kes Ujian 1 −

• Masukkan− “3.14”

• Output yang dijangkakan − Betul

• Penjelasan−Input ialah nombor titik terapung yang sah.

• Kes Ujian 2 −

• Masukkan− “-0.5”

• 预期输出− 正确

• 说明− 输入是有效的浮点数。

• 测试用例 3 −

• 输入 − “10”

• 预期输出 − 错误

• 说明− 输入不是浮点数，因为它没有小数部分。

• 测试用例 4 −

• 输入− “abc”

• 预期输出− 错误

• 说明− 输入不是浮点数，因为它包含非数字字符。

• 测试用例 5 −

• 输入− “1.23e-4”

• 预期输出 − 正确

• 说明− 输入是以科学计数法表示的有效浮点数。

您可以通过使用这些输入调用 is_float() 函数并将输出与预期结果进行比较来测试程序。如果输出与所有测试用例的预期结果相匹配，则表明程序运行正常。

# Testing the program
print(is_float("3.14"))        # Expected output: True
print(is_float("-0.5"))        # Expected output: True
print(is_float("10"))          # Expected output: False
print(is_float("abc"))         # Expected output: False
print(is_float("1.23e-4"))     # Expected output: True

结论

在本文中，我们探讨了如何在 Python 中使用正则表达式来检查给定输入是否为浮点数。我们了解了正则表达式在模式匹配中的重要性以及如何应用它们来验证数字输入。

我们首先了解浮点数的特征以及它们的常见表示格式。然后，我们深入研究 is_float() 函数的实现，使用正则表达式检查浮点数。我们还讨论了使用 re.match() 函数进行精确字符串匹配的重要性。

通过使用多个测试用例对程序进行测试，我们确保了其可靠性，并验证了它能够正确识别浮点数，同时拒绝无效输入。

Atas ialah kandungan terperinci Ungkapan biasa Python - semak sama ada input terapung. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!