เห็นได้ชัดว่า Python เป็นมิตรกับผู้ใช้มากกว่าการค้นหาอย่างรวดเร็วใน Google จะแสดงผลลัพธ์มากมายที่กล่าวว่าเนื่องจาก Python มีการคอมไพล์ไบต์มักจะเร็วกว่า ฉันพบสิ่งนี้ที่อ้างว่าคุณสามารถเห็นการปรับปรุงมากกว่า 2000% ในการดำเนินการตามพจนานุกรม
คุณมีประสบการณ์อย่างไรในเรื่องนี้? แต่ละคนเป็นผู้ชนะที่ชัดเจนในงานประเภทใด
คำตอบ:
กระแสเมนเฟรมทั่วไป ...
Input Disk/Tape/User (runtime) --> Job Control Language (JCL) --> Output Disk/Tape/Screen/Printer
| ^
v |
`--> COBOL Program --------'
ขั้นตอนทั่วไปของ Linux ...
Input Disk/SSD/User (runtime) --> sh/bash/ksh/zsh/... ----------> Output Disk/SSD/Screen/Printer
| ^
v |
`--> Python script --------'
| ^
v |
`--> awk script -----------'
| ^
v |
`--> sed script -----------'
| ^
v |
`--> C/C++ program --------'
| ^
v |
`--- Java program ---------'
| ^
v |
: :
ลินุกซ์เชลล์เช่น sh / ksh / bash / ... ให้สิ่งอำนวยความสะดวกในการกำหนดอินพุต / เอาต์พุต / การควบคุมการไหลเหมือนกับภาษาควบคุมงานเมนเฟรมแบบเก่า ... แต่เป็นสเตียรอยด์! พวกเขาเป็นภาษาทัวริงที่สมบูรณ์ตามสิทธิ์ของตนเองในขณะที่ได้รับการปรับให้เหมาะสมเพื่อส่งผ่านข้อมูลและควบคุมไปยังและจากกระบวนการดำเนินการอื่น ๆ ที่เขียนด้วยภาษาใด ๆ ที่ O / S รองรับ
แอปพลิเคชัน Linux ส่วนใหญ่ไม่ว่าโปรแกรมส่วนใหญ่จะเขียนด้วยภาษาใดขึ้นอยู่กับเชลล์สคริปต์และBashกลายเป็นสิ่งที่พบได้บ่อยที่สุด การคลิกไอคอนบนเดสก์ท็อปมักจะเรียกใช้สคริปต์Bashสั้น ๆ สคริปต์นั้นไม่ว่าทางตรงหรือทางอ้อมจะรู้ว่าไฟล์ทั้งหมดที่ต้องการอยู่ที่ใดและตั้งค่าตัวแปรและพารามิเตอร์บรรทัดคำสั่งในที่สุดก็เรียกโปรแกรม นั่นเป็นการใช้งานที่ง่ายที่สุดของเชลล์
อย่างไรก็ตาม Linux ที่เรารู้ว่าแทบจะไม่ใช่ Linux หากไม่มีเชลล์สคริปต์นับพันที่เริ่มต้นระบบตอบสนองต่อเหตุการณ์ควบคุมลำดับความสำคัญของการดำเนินการและคอมไพล์กำหนดค่าและรันโปรแกรม สิ่งเหล่านี้ค่อนข้างใหญ่และซับซ้อน
Shells เป็นโครงสร้างพื้นฐานที่ช่วยให้เราใช้ส่วนประกอบที่สร้างไว้ล่วงหน้าซึ่งเชื่อมโยงเข้าด้วยกันในขณะทำงานแทนที่จะรวบรวม ส่วนประกอบเหล่านี้เป็นโปรแกรมอิสระในสิทธิ์ของตนเองซึ่งสามารถใช้คนเดียวหรือในชุดอื่น ๆ ได้โดยไม่ต้องคอมไพล์ใหม่ ไวยากรณ์สำหรับการเรียกใช้นั้นแยกไม่ออกจากคำสั่งBash builtin และในความเป็นจริงมีคำสั่ง builtin จำนวนมากซึ่งมีปฏิบัติการแบบสแตนด์อโลนบนระบบซึ่งมักมีตัวเลือกเพิ่มเติม
ไม่มีความแตกต่างทั้งภาษาระหว่างPythonและBashในประสิทธิภาพ ทั้งหมดขึ้นอยู่กับวิธีการเข้ารหัสและเครื่องมือภายนอกที่เรียกว่า
ใด ๆในเครื่องมือที่รู้จักกันดีเช่นawk, sed, grep, BC, DC, TR,ฯลฯ จะออกจากการดำเนินงานทำผู้ที่อยู่ในภาษาใดในฝุ่น ทุบตีแล้วเป็นที่ต้องการสำหรับอะไรโดยอินเตอร์เฟซผู้ใช้แบบกราฟิกเพราะมันเป็นเรื่องง่ายและมีประสิทธิภาพมากขึ้นในการโทรและส่งข้อมูลกลับมาจากเครื่องมือเช่นผู้ที่มีทุบตีกว่างูหลาม
ขึ้นอยู่กับว่าโปรแกรมใดที่Bashเชลล์สคริปต์เรียกใช้และความเหมาะสมสำหรับงานย่อยที่ได้รับว่าทรูพุตและ / หรือการตอบสนองโดยรวมจะดีกว่าหรือแย่กว่าPython ที่เทียบเท่ากัน เพื่อทำให้เรื่องซับซ้อนPythonเช่นเดียวกับภาษาส่วนใหญ่ยังสามารถเรียกใช้ไฟล์ปฏิบัติการอื่นได้แม้ว่าจะยุ่งยากกว่าและไม่ได้ใช้บ่อยเท่าที่ควร
พื้นที่หนึ่งที่Pythonเป็นผู้ชนะที่ชัดเจนคือส่วนต่อประสานผู้ใช้ ที่ทำให้มันเป็นภาษาที่ดีเยี่ยมสำหรับการสร้างโปรแกรมท้องถิ่นหรือไคลเอนต์เซิร์ฟเวอร์เป็นมัน natively สนับสนุนกราฟิก GTK และอยู่ไกลที่ใช้งานง่ายกว่าทุบตี
Bashเข้าใจเฉพาะข้อความ ต้องเรียกเครื่องมืออื่น ๆ สำหรับ GUI และข้อมูลที่ส่งกลับจากเครื่องมือเหล่านี้ หลามสคริปต์เป็นทางเลือกหนึ่ง ตัวเลือกได้เร็วขึ้น แต่น้อยมีความยืดหยุ่นเป็นไบนารีเช่นYad, Zenity และ GTKDialog
ในขณะที่เปลือกหอยเช่นทุบตีทำงานได้ดีกับ GUIs เช่นYad , GtkDialog (ฝัง XML อินเตอร์เฟซเหมือนจะดี + ฟังก์ชั่น) , โต้ตอบและxmessage , งูใหญ่ที่มีความสามารถมากขึ้นและดีขึ้นสำหรับ Windows GUI ที่ซับซ้อน
การสร้างด้วยเชลล์สคริปต์ก็เหมือนกับการประกอบคอมพิวเตอร์ที่มีส่วนประกอบนอกชั้นวางในแบบเดสก์ท็อปพีซี
การสร้างด้วยPython , C ++หรือภาษาอื่น ๆ ส่วนใหญ่ก็เหมือนกับการสร้างคอมพิวเตอร์โดยการบัดกรีชิป (ไลบรารี) และชิ้นส่วนอิเล็กทรอนิกส์อื่น ๆ เข้าด้วยกันในแบบที่สมาร์ทโฟนเป็น
ผลลัพธ์ที่ดีที่สุดมักจะได้มาจากการใช้ภาษาร่วมกันซึ่งแต่ละภาษาสามารถทำสิ่งที่ทำได้ดีที่สุด นักพัฒนารายหนึ่งเรียกสิ่งนี้ว่า " การเขียนโปรแกรมหลายภาษา "
โดยทั่วไป bash จะทำงานได้ดีกว่า python เฉพาะในสภาพแวดล้อมที่ python ไม่พร้อมใช้งาน :)
อย่างจริงจังฉันต้องจัดการกับทั้งสองภาษาทุกวันและจะใช้ python เหนือ bash ทันทีหากได้รับเลือก อนิจจาฉันถูกบังคับให้ใช้ bash บนแพลตฟอร์ม "ขนาดเล็ก" บางแพลตฟอร์มเนื่องจากมีคน (เข้าใจผิดว่า IMHO) ตัดสินใจว่า python "ใหญ่เกินไป" ที่จะพอดี
แม้ว่าจะเป็นความจริงที่ bash อาจเร็วกว่า python สำหรับงานที่เลือก แต่ก็ไม่สามารถพัฒนาได้เร็วเท่าหรือง่ายต่อการดูแลรักษา (อย่างน้อยก็หลังจากที่คุณได้รับโค้ดเกิน 10 บรรทัดหรือมากกว่านั้น) จุดแข็งเพียงอย่างเดียวของ Bash คืองูหลามหรือทับทิมหรือหลัว ฯลฯ คือความแพร่หลาย
osหรือshutilโมดูลมาก
ประสิทธิภาพของนักพัฒนามีความสำคัญมากกว่าสำหรับฉันในสถานการณ์ที่ทั้ง bash และ Python เป็นตัวเลือกที่สมเหตุสมผล
งานบางอย่างยืมตัวได้ดีในการทุบตีและอื่น ๆ ให้กับ Python มันไม่ใช่เรื่องแปลกสำหรับฉันที่จะเริ่มต้นบางอย่างเป็นสคริปต์ทุบตีและเปลี่ยนเป็น Python เมื่อมันพัฒนาไปหลายสัปดาห์
ข้อได้เปรียบที่ยิ่งใหญ่ของ Python คือในกรณีมุมของการจัดการชื่อไฟล์ในขณะที่มีglob , shutil , subprocessและอื่น ๆ สำหรับความต้องการในการเขียนสคริปต์ทั่วไป
เมื่อคุณเขียนสคริปต์ประสิทธิภาพไม่สำคัญ (ในกรณีส่วนใหญ่)
หากคุณสนใจเกี่ยวกับประสิทธิภาพ 'Python vs Bash' เป็นคำถามที่ผิดพลาด
Python :
+ เขียน
ได้ง่ายขึ้น + ดูแลรักษา
ง่ายขึ้น + ใช้รหัสซ้ำได้ง่ายขึ้น (พยายามหาวิธีป้องกันข้อผิดพลาดสากลในการรวมไฟล์ที่มีรหัสทั่วไปshฉันกล้าให้คุณ)
+ คุณสามารถทำ OOP ได้ด้วย!
+ อาร์กิวเมนต์ที่ง่ายกว่าในการแยกวิเคราะห์ ดีไม่ง่ายขึ้นอย่างแน่นอน มันจะยังคงเป็นเรื่องที่ยุ่งยากเกินไปสำหรับรสนิยมของฉัน แต่ python มีargparseสิ่งอำนวยความสะดวกในตัว
- 'กระบวนการย่อย' ที่น่าเกลียดน่าเกลียด พยายามล่ามโซ่คำสั่งและอย่าร้องไห้แม่น้ำว่าโค้ดของคุณจะน่าเกลียดแค่ไหน โดยเฉพาะอย่างยิ่งหากคุณสนใจเกี่ยวกับรหัสทางออก
ทุบตี :
+ แพร่หลายอย่างที่กล่าวไว้ก่อนหน้านี้แน่นอน
+ คำสั่งง่ายๆผูกมัด นั่นคือวิธีที่คุณรวมคำสั่งต่างๆเข้าด้วยกันด้วยวิธีง่ายๆ นอกจากนี้Bash(ไม่sh) มีการปรับปรุงบางอย่างเช่นpipefailดังนั้นการผูกมัดมันสั้นและการแสดงออก
+ ไม่ต้องติดตั้งโปรแกรมของ บริษัท อื่น สามารถดำเนินการได้ทันที
- พระเจ้าเต็มไปด้วย gotchas IFS, CDPATH .. หลายพันแห่ง
หากมีคนเขียนสคริปต์ที่มีขนาดใหญ่กว่า 100 LOC: เลือกPython
หากต้องการการจัดการเส้นทางในสคริปต์ให้เลือกPython (3)
หากต้องการค่อนข้างเหมือนaliasแต่ซับซ้อนเล็กน้อยให้เลือกBash / sh
อย่างไรก็ตามเราควรลองทั้งสองฝ่ายเพื่อให้ได้แนวคิดว่าพวกเขามีความสามารถอะไร
บางทีคำตอบอาจขยายได้ด้วยบรรจุภัณฑ์และจุดรองรับ IDE แต่ฉันไม่คุ้นเคยกับด้านนี้
เช่นเคยคุณต้องเลือกจากแซนวิชเทอร์ดและดัชเช และจำไว้ว่าเมื่อไม่กี่ปีที่ผ่านมา Perl เป็นความหวังใหม่ ตอนนี้อยู่ที่ไหน.
bash ที่มีประสิทธิภาพเหนือกว่า python ในเวลาเริ่มต้นกระบวนการ
นี่คือการวัดบางส่วนจากแล็ปท็อป core i7 ของฉันที่ใช้ Linux Mint:
Starting process Startup time
empty /bin/sh script 1.7 ms
empty /bin/bash script 2.8 ms
empty python script 11.1 ms
python script with a few libs* 110 ms
* Python ที่โหลด libs ได้แก่ os, os.path, json, time, request, threading, subprocess
สิ่งนี้แสดงให้เห็นถึงความแตกต่างอย่างมากอย่างไรก็ตามเวลาในการประมวลผล bash จะลดลงอย่างรวดเร็วหากต้องทำอะไรที่สมเหตุสมผลเนื่องจากโดยปกติจะต้องเรียกกระบวนการภายนอก
หากคุณสนใจเกี่ยวกับประสิทธิภาพให้ใช้ทุบตีสำหรับ:
/bin/echoประสิทธิภาพดีกว่าทุบตีด้วยขนาดดังกล่าวมันยากที่จะวัด ดังนั้นแทนที่จะเรียกใช้ bash คุณสามารถใช้/bin/echo mycommand > named_pipe(เอาต์พุตคำสั่ง / ข้อความไปยังไพพ์หรือซ็อกเก็ตที่มีชื่อ) ... และให้กระบวนการ Python เป็นพื้นหลังอ่านคำสั่ง / คำสั่งจากไพพ์นั้นและเรียกใช้ ดังนั้นการทุบตีจึงไม่ใช่ "การเพิ่มประสิทธิภาพต้นทุนเริ่มต้น" ที่ดีจริงๆ
Bash เป็นภาษาสคริปต์แบบแบตช์ / เชลล์เป็นหลักโดยรองรับข้อมูลประเภทต่างๆน้อยกว่ามากและมีนิสัยแปลก ๆ เกี่ยวกับโครงสร้างการควบคุมไม่ต้องพูดถึงปัญหาความเข้ากัน
ไหนเร็วกว่ากัน? ไม่ใช่เพราะคุณไม่ได้เปรียบเทียบแอปเปิ้ลกับแอปเปิ้ลที่นี่ หากคุณต้องเรียงไฟล์ข้อความ ascii และคุณใช้เครื่องมือเช่น zcat, sort, uniq และ sed คุณจะสูบบุหรี่ Python ได้อย่างชาญฉลาด
อย่างไรก็ตามหากคุณต้องการสภาพแวดล้อมการเขียนโปรแกรมที่เหมาะสมซึ่งรองรับจุดลอยตัวและโฟลว์การควบคุมต่างๆ Python ก็ชนะ หากคุณเขียนว่าอัลกอริทึมแบบเรียกซ้ำใน Bash และ Python เวอร์ชัน Python จะชนะตามลำดับขนาดหรือมากกว่า
หากคุณกำลังมองหายูทิลิตี้ที่รวดเร็วโดยใช้ความพยายามเพียงเล็กน้อยการทุบตีเป็นสิ่งที่ดี สำหรับกระดาษห่อรอบแอปพลิเคชันทุบตีเป็นสิ่งล้ำค่า
สิ่งที่อาจทำให้คุณกลับมาซ้ำแล้วซ้ำอีกเพื่อเพิ่มการปรับปรุงอาจ (แม้ว่าจะไม่เสมอไป) เหมาะกับภาษาเช่น Python เนื่องจากรหัส Bash ที่มีมากกว่า 1,000 บรรทัดจะได้รับความเจ็บปวดอย่างมาก รหัส Bash ยังระคายเคืองต่อการดีบักเมื่อใช้งานนาน .......
ส่วนหนึ่งของปัญหาของคำถามประเภทนี้คือจากประสบการณ์ของฉันเชลล์สคริปต์มักจะเป็นงานที่กำหนดเองทั้งหมด มีงานเชลล์สคริปต์น้อยมากที่ฉันเจอซึ่งมีโซลูชันให้ใช้ได้ฟรีอยู่แล้ว
มี 2 สถานการณ์ที่ประสิทธิภาพของ Bash เท่ากับอย่างน้อยฉันเชื่อว่า:
โดยปกติแล้วฉันไม่ค่อยกังวลกับประสิทธิภาพของภาษาสคริปต์ หากประสิทธิภาพเป็นปัญหาจริงคุณไม่ได้เขียนสคริปต์ แต่เป็นโปรแกรม (อาจเป็น Python)
ฉันโพสต์คำตอบที่ล่าช้าเนื่องจาก Google ชอบคำถามนี้เป็นหลัก
ฉันเชื่อว่าปัญหาและบริบทควรเกี่ยวกับขั้นตอนการทำงานไม่ใช่เครื่องมือ ปรัชญาโดยรวมคือ "ใช้เครื่องมือที่เหมาะสมกับงาน" เสมอ แต่ก่อนหน้านี้มีสิ่งหนึ่งที่หลายคนลืมเมื่อหลงเครื่องมือ: "ทำงานให้ลุล่วง"
เมื่อฉันมีปัญหาที่ไม่ได้กำหนดไว้อย่างสมบูรณ์ฉันมักจะเริ่มต้นด้วย Bash ฉันได้แก้ไขปัญหาที่น่ากลัวบางอย่างในสคริปต์ Bash ขนาดใหญ่ที่ทั้งอ่านได้และบำรุงรักษาได้
แต่เมื่อไหร่ที่ปัญหาจะเริ่มเกินสิ่งที่ Bash ควรขอให้ทำ? ฉันมีการตรวจสอบบางอย่างที่ใช้เพื่อเตือนฉัน:
รายการต่อไป บรรทัดล่างสุดเมื่อคุณทำงานหนักขึ้นเพื่อให้สคริปต์ของคุณทำงานต่อไปซึ่งคุณได้เพิ่มคุณสมบัติแล้วก็ถึงเวลาออกจาก Bash
สมมติว่าคุณตัดสินใจย้ายงานไปที่ Python หากสคริปต์ Bash ของคุณสะอาดการแปลงครั้งแรกค่อนข้างตรงไปตรงมา มีแม้กระทั่งผู้แปลง / นักแปลหลายคนที่จะทำบัตรแรกให้คุณ
คำถามต่อไปคืออะไรที่คุณยอมแพ้ในการย้ายไป Python?
การโทรไปยังยูทิลิตี้ภายนอกทั้งหมดต้องถูกรวมไว้ในบางสิ่งจากsubprocessโมดูล (หรือเทียบเท่า) มีหลายวิธีในการทำเช่นนี้และจนถึง 3.7 ต้องใช้ความพยายามในการทำให้ถูกต้อง (3.7 ได้รับการปรับปรุงsubprocess.run()เพื่อจัดการกับกรณีทั่วไปทั้งหมดด้วยตัวเอง)
น่าแปลกที่ Python ไม่มียูทิลิตี้ที่ไม่บล็อกแพลตฟอร์มมาตรฐาน (พร้อมการหมดเวลา) สำหรับการสำรวจแป้นพิมพ์ (stdin) readคำสั่งBash เป็นเครื่องมือที่ยอดเยี่ยมสำหรับการโต้ตอบกับผู้ใช้ง่ายๆ การใช้งานส่วนใหญ่ของฉันคือการแสดงสปินเนอร์จนกว่าผู้ใช้จะกดแป้นขณะเดียวกันก็เรียกใช้ฟังก์ชันการสำรวจ (ด้วยขั้นตอนการหมุนแต่ละขั้น) เพื่อให้แน่ใจว่าสิ่งต่างๆยังคงทำงานได้ดี นี่เป็นปัญหาที่ยากกว่าที่จะปรากฏในตอนแรกดังนั้นฉันมักจะโทรไปที่ Bash: แพง แต่ก็ทำในสิ่งที่ฉันต้องการได้อย่างแม่นยำ
หากคุณกำลังพัฒนาบนระบบฝังตัวหรือระบบที่ จำกัด หน่วยความจำรอยเท้าหน่วยความจำของ Python อาจใหญ่กว่า Bash หลายเท่า (ขึ้นอยู่กับงานในมือ) นอกจากนี้ยังมีตัวอย่างของ Bash อยู่ในหน่วยความจำเกือบตลอดเวลาซึ่งอาจไม่ใช่กรณีของ Python
สำหรับสคริปต์ที่ทำงานครั้งเดียวและออกอย่างรวดเร็วเวลาเริ่มต้นของ Python อาจนานกว่า Bash มาก แต่ถ้าสคริปต์มีการคำนวณที่สำคัญ Python จะดึงไปข้างหน้าอย่างรวดเร็ว
Python มีระบบแพ็คเกจที่ครอบคลุมที่สุดในโลก เมื่อ Bash ซับซ้อนขึ้นเล็กน้อย Python อาจมีแพ็คเกจที่ทำให้ Bash ทั้งหมดกลายเป็นสายเดี่ยว อย่างไรก็ตามการค้นหาแพ็คเกจที่เหมาะสมเพื่อใช้เป็นส่วนที่ใหญ่ที่สุดและน่ากลัวที่สุดในการเป็น Pythonista โชคดีที่ Google และ StackExchange เป็นเพื่อนของคุณ
ฉันไม่รู้ว่ามันถูกต้องหรือเปล่า แต่ฉันพบว่า python / Ruby ทำงานได้ดีกว่ามากสำหรับสคริปต์ที่มีการคำนวณทางคณิตศาสตร์จำนวนมาก มิฉะนั้นคุณจะต้องใช้dcหรือ "เครื่องคำนวณความแม่นยำตามอำเภอใจ" อื่น ๆ มันกลายเป็นความเจ็บปวดที่ยิ่งใหญ่มาก ด้วย python คุณสามารถควบคุมการลอยตัวเทียบกับ ints ได้มากขึ้นและมันง่ายกว่ามากในการคำนวณจำนวนมากและบางครั้ง
โดยเฉพาะอย่างยิ่งฉันจะไม่ทำงานกับสคริปต์ทุบตีเพื่อจัดการข้อมูลไบนารีหรือไบต์ แต่ฉันจะใช้บางอย่างเช่น python (อาจจะ) หรือ C ++ หรือแม้แต่ Node.JS.
ประสิทธิภาพที่ชาญฉลาดทั้งสองสามารถทำได้เท่ากันดังนั้นคำถามจึงกลายเป็นว่าประหยัดเวลาในการพัฒนามากกว่า?
Bash อาศัยการเรียกคำสั่งอื่น ๆ และวางคำสั่งเพื่อสร้างคำสั่งใหม่ สิ่งนี้มีข้อดีคือคุณสามารถสร้างโปรแกรมใหม่ได้อย่างรวดเร็วเพียงแค่ใช้รหัสที่ยืมมาจากคนอื่นไม่ว่าพวกเขาจะใช้ภาษาโปรแกรมอะไรก็ตาม
นอกจากนี้ยังมีผลข้างเคียงจากการต่อต้านการเปลี่ยนแปลงคำสั่งย่อยค่อนข้างดีเนื่องจากอินเทอร์เฟซระหว่างคำสั่งเหล่านี้เป็นเพียงข้อความธรรมดา
นอกจากนี้ Bash ยังอนุญาตให้คุณเขียนมันได้ ซึ่งหมายความว่ามันจะทำงานได้ดีสำหรับบริบทที่หลากหลายขึ้น แต่ก็ต้องอาศัยโปรแกรมเมอร์ที่มีความตั้งใจในการเขียนโค้ดอย่างปลอดภัย มิฉะนั้น Bash จะไม่หยุดคุณจากการสร้างความยุ่งเหยิง
Python มีโครงสร้างที่มีสไตล์มากกว่าดังนั้นโปรแกรมเมอร์ที่ยุ่งเหยิงจะไม่ยุ่งเหยิง นอกจากนี้ยังทำงานบนระบบปฏิบัติการภายนอก Linux ทำให้เหมาะสมยิ่งขึ้นทันทีหากคุณต้องการการพกพาประเภทนั้น
แต่มันไม่ง่ายสำหรับการเรียกคำสั่งอื่น ๆ ดังนั้นหากระบบปฏิบัติการของคุณเป็น Unix คุณจะพบว่าการพัฒนาบน Bash เป็นวิธีที่เร็วที่สุดในการพัฒนา
เมื่อใดควรใช้ Bash:
เมื่อใดควรใช้ Python: