วิธีทำการแบ่งพื้นใน Python เพื่อปัดเศษลง

Withi Thakar Baeng Phun Ni Python Pheux Padses Lng



การหารพื้นของ Python เป็นการดำเนินการทางคณิตศาสตร์พื้นฐานที่มีฟังก์ชันในการหารตัวเลขสองตัวและรับจำนวนเต็มที่มากที่สุดซึ่งน้อยกว่าหรือเท่ากับผลลัพธ์ การดำเนินการนี้มีความสำคัญในสถานการณ์ที่การปัดเศษลงอย่างแม่นยำเป็นสิ่งจำเป็น ในคู่มือที่ครอบคลุมนี้ เราจะพิจารณาความซับซ้อนของการแบ่งชั้นและสำรวจตัวอย่างต่างๆ เพื่อแสดงตัวอย่างการใช้งานและทำความเข้าใจแต่ละขั้นตอนโดยละเอียด

ทำความเข้าใจกับแผนกพื้น

ไวยากรณ์นั้นเรียบง่าย เช่น “a // b” โดยที่ “a” เป็นตัวเศษและ “b” เป็นตัวส่วน ผลลัพธ์คือจำนวนเต็มที่แสดงถึงผลหารที่ถูกปัดเศษลงให้เป็นจำนวนเต็มที่ใกล้ที่สุด โดยจะกำจัดเศษที่เหลือออก

ตัวอย่างที่ 1: การเรียนรู้การแบ่งส่วนพื้นใน Python เพื่อการปัดเศษอย่างแม่นยำ

เรามาเริ่มด้วยตัวอย่างพื้นฐานเพื่อทำความเข้าใจแนวคิดพื้นฐานของการแบ่งพื้น:







เศษ = 10

ตัวส่วน = 3

ผลลัพธ์ = ตัวเศษ // ตัวส่วน

พิมพ์ ( 'ผลลัพธ์ของ {numerator} // {denominator} คือ {result}' )



ในตัวอย่างนี้ เราตั้งค่าตัวเศษเป็น 10 และตัวส่วนเป็น 3 การหารพื้นจะดำเนินการโดยใช้ '//' ซึ่งให้ผลลัพธ์เป็น 3 เนื่องจาก 10 หารด้วย 3 ได้ 3 โดยมีเศษ 1 และพื้น การหารจะปัดเศษลงให้เป็นจำนวนเต็มที่ใกล้ที่สุด



ตัวอย่างที่ 2: การจัดการกับจำนวนลบ

ในตัวอย่างนี้ เราจะสำรวจว่าการแบ่งส่วนพื้นใน Python จัดการจำนวนลบอย่างดีได้อย่างไร สถานการณ์นี้เกี่ยวข้องกับตัวเศษ '-7' และตัวส่วนของ '2' เมื่อเราดำเนินการแบ่งพื้นโดยใช้ “ // ” Python ปัดเศษผลลัพธ์ลงอย่างชาญฉลาดให้เป็นจำนวนเต็มที่ใกล้ที่สุด





เศษ = - - 7

ตัวส่วน = 2

ผลลัพธ์ = ตัวเศษ // ตัวส่วน

พิมพ์ ( 'ผลลัพธ์ของ {numerator} // {denominator} คือ {result}' )

แม้ว่าการหาร -7 ด้วย 2 จะทำให้ได้ผลหารเป็น -3.5 แต่การแบ่งพื้นจะทำให้เราได้จำนวนเต็มที่ใหญ่ที่สุดซึ่งน้อยกว่าหรือเท่ากับผลลัพธ์ ดังนั้น ผลลัพธ์ที่ปัดเศษลงคือ -4 พฤติกรรมนี้คล้ายกับการคาดการณ์ตามธรรมชาติของเราว่าตัวเลขที่เป็นลบควรถูกปัดเศษลงในทิศทางที่เป็นลบมากกว่าในบริบทของการแบ่งพื้น



ตัวอย่างที่ 3: การแบ่งพื้นพร้อมทุ่นลอย

ในตัวอย่างนี้ เราจะดูการประยุกต์ใช้การแบ่งพื้นด้วยตัวเลขทศนิยม ตัวอย่างประกอบด้วยตัวเศษ (15.8) และตัวส่วน (4) แม้จะมีจุดทศนิยม แต่การแบ่งพื้นก็ดำเนินการกับค่าจุดลอยตัวเหล่านี้ได้อย่างง่ายดาย ซึ่งแสดงให้เห็นถึงความสามารถรอบด้านมากกว่าจำนวนเต็ม

เศษ = 15.8

ตัวส่วน = 4

ผลลัพธ์ = ตัวเศษ // ตัวส่วน

พิมพ์ ( 'ผลลัพธ์ของ {numerator} // {denominator} คือ {result}' )

เรากำลังดำเนินการ 15.8 // 4 ใน Python ส่งผลให้มีความฉลาดทาง 3.0 ที่นี่ เราต้องสังเกตว่าผลลัพธ์จะถูกแปลงเป็นตัวเลขทศนิยมโดยอัตโนมัติเพื่อรักษาความแม่นยำ แม้ว่าผลลัพธ์อาจดูตรงกันข้ามกับความคาดหวังของเราสำหรับผู้ที่คุ้นเคยกับการหารจำนวนเต็มแบบดั้งเดิม แต่ก็สะท้อนกฎของการหารพื้นของ Python ไปสู่หลักการส่งคืนจำนวนเต็มที่มากที่สุดซึ่งน้อยกว่าหรือเท่ากับผลลัพธ์

ตัวอย่างที่ 4: การแบ่งชั้นที่มีตัวเลขขนาดใหญ่

การแบ่งชั้นของ Python จัดการกับจำนวนมากได้อย่างราบรื่น ลองพิจารณาตัวอย่างต่อไปนี้:

เศษ = 987654321

ตัวส่วน = 123456789

ผลลัพธ์ = ตัวเศษ // ตัวส่วน

พิมพ์ ( 'ผลลัพธ์ของ {numerator} // {denominator} คือ {result}' )

ผลลัพธ์ของการแบ่งชั้นนี้คือ 8 เมื่อปัดเศษผลหารของ 987654321 หารด้วย 123456789 ลง

ตัวอย่างที่ 5: การแบ่งชั้นในนิพจน์

การแบ่งชั้นสามารถรวมเข้ากับการแสดงออกที่ซับซ้อนมากขึ้นได้ เรามาสำรวจสถานการณ์ที่การแบ่งพื้นเป็นส่วนหนึ่งของสมการที่ใหญ่กว่า:

ค่า = 27

เพิ่มขึ้น = 4

ผลลัพธ์ = ( ค่า + 3 ) //เพิ่มขึ้น

พิมพ์ ( 'ผลลัพธ์ของ ({value} + 3) // {increat} คือ {result}' )

ในตัวอย่างนี้ นิพจน์ “(ค่า + 3) // ส่วนเพิ่ม” ได้รับการประเมินซึ่งให้ผลลัพธ์เป็น 7 จะใช้การแบ่งพื้นหลังจากบวก 3 เข้ากับค่า 27 แล้วหารด้วย 4

ตัวอย่างที่ 6: การแบ่งหลายชั้น

สามารถแบ่งชั้นหลายชั้นติดต่อกันได้ ลองดูตัวอย่างต่อไปนี้:

เศษ = 100

ตัวส่วน1 = 3

ตัวส่วน2 = 4

ผลลัพธ์ = ตัวเศษ // ตัวส่วน 1 // ตัวส่วน 2

พิมพ์ ( 'ผลลัพธ์ของ {numerator} // {denominator1} // {denominator2} คือ {result}' )

ในกรณีนี้ ผลลัพธ์คือ 8 อันดับแรก 100 หารด้วย 3 ซึ่งได้ผลลัพธ์เป็น 33 การแบ่งชั้นต่อมาหาร 33 ด้วย 4 ทำให้ผลลัพธ์สุดท้ายเป็น 8

ตัวอย่างที่ 7: การแบ่งชั้นในลูป

ในตัวอย่างนี้ เรามีสถานการณ์ที่ต้องประมวลผลสินค้า 'total_items' จำนวนหนึ่งเป็นชุดที่มีขนาดเฉพาะ ('items_per_batch') เราใช้การแบ่งชั้น “//” เพื่อกำหนดจำนวนแบทช์ทั้งหมด ผลลัพธ์จะถูกจัดเก็บไว้ในตัวแปร “แบทช์” ต่อจากนั้น จะมีการวนซ้ำเพื่อวนซ้ำแต่ละชุด ซึ่งจะแสดงข้อความที่บ่งชี้ถึงชุดปัจจุบันที่กำลังประมวลผล

รวม_รายการ = 17

items_per_batch = 5

แบตช์ = Total_items // items_per_batch

สำหรับ แบทช์ ใน พิสัย ( แบตช์ ) : :

พิมพ์ ( 'กำลังประมวลผลชุด {ชุด + 1}' )

ตัวอย่างนี้แสดงให้เห็นว่าการแบ่งพื้นมีประโยชน์อย่างยิ่งในสถานการณ์ที่ต้องแบ่งข้อมูลออกเป็นส่วนที่มีขนาดเท่ากันเพื่อการประมวลผล เพื่อให้แน่ใจว่ารายการทั้งหมดจะรวมอยู่ในจำนวนชุดทั้งหมด

ตัวอย่างที่ 8: การแบ่งชั้นพร้อมอินพุตของผู้ใช้

ตัวอย่างนี้เกี่ยวข้องกับการป้อนข้อมูลของผู้ใช้เพื่อแสดงลักษณะไดนามิกของการแบ่งพื้น โปรแกรมจะขอให้ผู้ใช้ป้อนค่าทั้งตัวเศษและส่วน จากนั้นจะทำการแบ่งชั้นตามค่าที่ผู้ใช้ระบุ โดยแสดงผลการปัดเศษลง

เศษ = ภายใน ( ป้อนข้อมูล ( 'ป้อนตัวเศษ:' ) )

ตัวส่วน = ภายใน ( ป้อนข้อมูล ( 'ป้อนตัวส่วน: ' ) )

ผลลัพธ์ = ตัวเศษ // ตัวส่วน

พิมพ์ ( 'ผลลัพธ์ของ {numerator} // {denominator} คือ {result}' )

นี่แสดงให้เห็นว่าการแบ่งส่วนพื้นสามารถรวมเข้ากับสถานการณ์ต่างๆ ได้อย่างง่ายดายโดยที่อินพุตของผู้ใช้หรือแหล่งที่มาภายนอกมีการเปลี่ยนแปลง ทำให้สามารถนำไปใช้ในสภาพแวดล้อมการเขียนโปรแกรมเชิงโต้ตอบและไดนามิก

ตัวอย่างที่ 9: การสมัครทางการเงิน

ลองสำรวจอีกตัวอย่างหนึ่งที่แอปพลิเคชันทางการเงินนี้มีเป้าหมายในการกำหนดจำนวนเดือนที่ต้องการเพื่อบรรลุเป้าหมายการออม

การออม_เป้าหมาย = 10,000

รายเดือน_ออมทรัพย์ = 850

months_จำเป็น = savings_goal // month_savings

พิมพ์ ( 'จะใช้เวลา {months_required} เดือนเพื่อบรรลุเป้าหมายการออมที่ {savings_goal}' )

เป้าหมายการออมรวม “savings_goal” และจำนวนเงินออมรายเดือน “monthly_savings” มีระบุไว้ในรหัส จากนั้นจึงใช้การแบ่งชั้นเพื่อคำนวณจำนวนเดือนทั้งหมดที่จำเป็นเพื่อให้บรรลุเป้าหมายการออม ตัวอย่างนี้แสดงให้เห็นว่าการแบ่งส่วนพื้นสามารถนำมาใช้ในการคำนวณทางการเงินเชิงปฏิบัติได้อย่างไร โดยจำเป็นต้องปัดเศษผลลัพธ์ที่แม่นยำและลง

ตัวอย่างที่ 10: การแปลงอุณหภูมิ

ตัวอย่างนี้เกี่ยวข้องกับการแปลงอุณหภูมิจากเซลเซียสเป็นฟาเรนไฮต์

องศาเซลเซียส_อุณหภูมิ = 28

การแปลง_ปัจจัย = 9 / 5

ฟาเรนไฮต์_อุณหภูมิ = ( celsius_temperature * การแปลง_ปัจจัย ) + 32

ปัดเศษ_ฟาเรนไฮต์ = องศาฟาเรนไฮต์_อุณหภูมิ // 1 #การใช้การแบ่งพื้นปัดเศษลง

พิมพ์ ( '{celsius_temperature} องศาเซลเซียส คือประมาณ {rounded_fahrenheit} องศาฟาเรนไฮต์' )

เราใช้สูตรการแปลงซึ่งส่งผลให้ได้ค่าจุดลอยตัวสำหรับอุณหภูมิฟาเรนไฮต์ เพื่อให้ได้จำนวนเต็มที่ปัดเศษลงสำหรับฟาเรนไฮต์ ให้ใช้การหารพื้นโดยมีตัวหาร 1 ซึ่งจะกำจัดส่วนทศนิยมของอุณหภูมิออกไป โดยจะได้จำนวนเต็มในหน่วยฟาเรนไฮต์ สิ่งนี้แสดงให้เห็นการใช้งานจริงของการแบ่งส่วนพื้นในสถานการณ์จริงที่จำเป็นต้องปัดเศษลงอย่างแม่นยำ เช่น ในการแสดงอุณหภูมิ

บทสรุป

ในบทความนี้ เราได้สำรวจความผันแปรของการแบ่งพื้นใน Python โดยเน้นความสำคัญของการปัดเศษลงอย่างแม่นยำ จากตัวอย่างพื้นฐานไปจนถึงสถานการณ์ที่ซับซ้อนมากขึ้น เราได้แสดงให้เห็นว่าการแบ่งพื้นจัดการกับสถานการณ์ต่างๆ ได้อย่างไร รวมถึงจำนวนลบ การลอยตัว และจำนวนเต็มขนาดใหญ่ แต่ละตัวอย่างเหล่านี้ได้รับการอธิบายโดยละเอียดเพื่อให้เข้าใจอย่างถ่องแท้เกี่ยวกับการใช้งานและความสำคัญของการแบ่งพื้นในบริบทการเขียนโปรแกรมต่างๆ การทำความเข้าใจแต่ละขั้นตอนของโค้ดตัวอย่างเป็นสิ่งสำคัญในการใช้พลังของการแบ่งพื้นใน Python เพื่อเป็นรากฐานที่มั่นคงสำหรับการดำเนินการทางคณิตศาสตร์ที่ต้องใช้ผลลัพธ์จำนวนเต็มแบบปัดเศษลง