Python และการเงิน – เพิ่มพลังให้กับสเปรดชีตของคุณ

บทสรุปผู้บริหาร

สำหรับอาชีพที่ต้องอาศัยการสืบค้นข้อมูลผ่านสเปรดชีตมาเป็นเวลานาน Python นั้นมีค่าอย่างยิ่ง Citigroup ธนาคารอเมริกัน ได้แนะนำหลักสูตรความผิดพลาดใน Python สำหรับนักวิเคราะห์ฝึกหัด - นักเศรษฐศาสตร์

ผู้เชี่ยวชาญด้านการเงินสามารถเข้าถึง VBA (Visual Basic for Applications) ใน Excel เพื่อสร้างฟังก์ชันการทำงานที่กำหนดเองและทำให้เวิร์กโฟลว์เป็นอัตโนมัติได้ ด้วยการปรากฏตัวของ Google ชีตในช่วงไม่กี่ปีที่ผ่านมาในฐานะคู่แข่งสำคัญในพื้นที่สเปรดชีต ขณะนี้ Google Apps Script เสนอทางเลือกเพิ่มเติม

อย่างไรก็ตาม ฉันต้องการดึงความสนใจไปที่ตัวเลือกที่สาม ภาษาโปรแกรม Python ซึ่งได้รับความนิยมอย่างมากในหลายสาขา

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

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

กรณีการใช้งาน: ตัวอย่างสิ่งที่ฉันใช้ Python For

การแนะนำการเขียนโปรแกรมของฉันคือการเรียนรู้พื้นฐานบน Oric 1 ในช่วงกลางทศวรรษ 1980 ย้อนกลับไปตอนนั้น BASIC เป็นภาษาเริ่มต้นที่ใช้กันทั่วไปมากที่สุด ภาษาอื่นๆ ที่ฉันใช้ในช่วงปลายยุค 80 จนถึงกลางทศวรรษ 90 คือภาษาปาสกาลและซี แต่ฉันไม่เคยใช้ภาษาเหล่านี้ในระดับมืออาชีพเลย และฉันไม่ได้คาดหวังว่าจะต้องใช้หรือใช้ทักษะการเขียนโปรแกรม ตามความรู้ของฉันในช่วงปลายทศวรรษ 90 การเงินและการเขียนโปรแกรมเป็นสาขาที่แตกต่างกันมาก เมื่อฉันเลือกที่จะเริ่มดำเนินการในเส้นทางอาชีพด้านการเงิน

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

ต่อไปนี้คือตัวอย่างบางส่วนที่แสดงให้เห็นว่าสเปรดชีตและ Python สามารถทำงานร่วมกันได้ดีเพียงใด:

1. การติดตามกิจกรรมหลายร้อยรายการในช่วงเวลาหนึ่งในการตั้งค่า PMO การรวม M&A

ฉันทำงานกับธุรกรรม M&A ทุกด้าน ไม่ใช่แค่การดำเนินการเท่านั้น แต่ยังรวมถึงการบูรณาการด้วย ในกรณีล่าสุด ทีม PMO ได้ตัดสินใจเกี่ยวกับโปรแกรมไฮบริดและแนวทางการจัดการโครงการ โดยใช้การวางแผนน้ำตกและแผนภูมิแกนต์สำหรับแผนระดับสูงสำหรับเวิร์กสตรีมการรวม 12 รายการ นอกเหนือจากบอร์ด Kanban สำหรับการติดตามกิจกรรมหลายร้อยรายการ ในเวลาใดก็ตาม ในแผน 100 วันแรกและอื่น ๆ เครื่องมือ Kanban ที่ได้รับเลือกคือ MeisterTask มีคุณลักษณะทางสถิติและการรายงานจำนวนหนึ่ง แต่ความต้องการของเรามีมากกว่านั้นในแง่ของการวิเคราะห์และการนำเสนอ ซึ่งจำเป็นต้องมีโซลูชันที่กำหนดเอง นี่คือเวิร์กโฟลว์ที่ฉันทำงานอัตโนมัติโดยใช้ Python:

1. บันทึกสถานะของทั้งกระดานทุกสัปดาห์เป็นไฟล์ CSV
2. อ่านไฟล์ CSV ที่ผ่านมาทั้งหมดลงใน Pandas DataFrame
3. จัดเรียง กรอง จัดกลุ่ม และจัดการข้อมูลให้อยู่ในรูปแบบที่ตกลงกันว่าเราต้องการติดตามความคืบหน้าอย่างไร (ตามสถานะของกิจกรรม สตรีมงาน ฯลฯ)
4. เขียนผลลัพธ์ไปยังไฟล์ Excel ด้วยข้อมูลจากการวิเคราะห์แต่ละครั้งภายในชีตของตัวเอง โดยจัดรูปแบบให้สามารถคัดลอกและวางลงในแผนภูมิเซลล์คิดได้อย่างง่ายดาย
5. สร้างตารางและแผนภูมิสำหรับแพ็คเกจการรายงานสำหรับการประชุมคณะกรรมการอำนวยการประจำเดือน

การพัฒนาสคริปต์ต้องใช้เงินลงทุนล่วงหน้าสองสามชั่วโมง แต่ตอนนี้ การอัปเดตชุดรายงานสำหรับการประชุมคณะกรรมการอำนวยการหรือการวิเคราะห์เฉพาะกิจใช้เวลาเพียงไม่กี่นาที ตามจริงแล้ว ประมาณ 30 วินาทีเพื่อไปยังโฟลเดอร์ที่ถูกต้องและเรียกใช้สคริปต์ด้วยคำสั่งหนึ่งบรรทัด จากนั้นไม่กี่นาทีเพื่อคัดลอกและวางเอาต์พุตลงในชุดสไลด์ ด้วยกิจกรรม (การ์ด) ประมาณ 500 กิจกรรมใน 12 เวิร์กสตรีมที่ดำเนินการไปแล้วประมาณหนึ่งเดือนแล้ว การติดตามรายสัปดาห์ของการเคลื่อนไหวภายในไทม์ไลน์ของโปรแกรมสองปี คุณจะพบว่าตัวเองต้องจัดการกับจุดข้อมูลนับพันอย่างรวดเร็ว และในที่สุด จุดข้อมูลนับหมื่นจากหลายสิบจุด ของไฟล์ หากไม่มีระบบอัตโนมัติ เรากำลังพูดถึงงานที่น่าเบื่อมากที่นี่

การแลกเปลี่ยน "มูลค่าตามเวลาของเงิน" ระหว่างการเริ่มทำสิ่งต่างๆ หรือการเพิ่มภาระงานเริ่มต้นโดยการตั้งค่าระบบอัตโนมัติเป็นหัวข้อทั่วไปในด้านการเงิน ฉันได้ตัดสินใจเช่นเดียวกันกับขั้นตอนแรกของกระบวนการนี้ โดยการส่งออกข้อมูลเป็นไฟล์ CSV MeisterTask ก็เหมือนกับเว็บแอปพลิเคชันสมัยใหม่หลายๆ ตัวที่มี API ซึ่งสามารถเชื่อมต่อกับแอปพลิเคชัน Python ของคุณได้ แต่เวลาที่ใช้ในการตั้งค่าจะมีค่ามากกว่าการประหยัดเวลาสำหรับกรณีการใช้งานของเราอย่างมาก

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

2. วิเคราะห์สถิติราคาบ้านโดยใช้ Web Scraping, Google Maps API และ Excel

อีกตัวอย่างหนึ่งคือบางสิ่งที่ฉันทำขึ้นเพื่อความสนใจส่วนตัว แต่ฉันต้องการเน้นมัน เพราะมันมีองค์ประกอบที่น่าสนใจอื่นๆ ของยูทิลิตี้ของ Python:

1. ขูดข้อมูลรายชื่ออสังหาริมทรัพย์ รวมถึงที่อยู่ ขนาด จำนวนห้อง ราคาขอ และคุณสมบัติอื่นๆ สำหรับพื้นที่ที่กำหนด รวมไม่กี่ร้อยถึงพันบรรทัด
2. บันทึกลงในโครงสร้างข้อมูล Python
3. เชื่อมต่อกับ Google Maps API และดึงข้อมูลระยะห่างระหว่างทรัพย์สินและสถานที่สำคัญ เช่น ทะเล ใจกลางเมือง สถานีรถไฟที่ใกล้ที่สุด สนามบินที่ใกล้ที่สุด เป็นต้น
4. ส่งออกข้อมูลเป็นไฟล์ Excel
5. ใช้ฟังก์ชัน Excel มาตรฐานเพื่อเรียกใช้การถดถอย คำนวณสถิติ และสร้างแผนภูมิในตัวชี้วัดมาตรฐาน เช่น ราคาต่อตารางเมตรและระยะทางไปยังจุดสังเกต

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

นี่เป็นเพียงสองตัวอย่างเท่านั้น ที่เน้นไปที่การทำงานอัตโนมัติที่เกี่ยวข้องกับสเปรดชีตและเพิ่มคุณสมบัติ แต่โอกาสของ Python นั้นแทบจะไม่มีที่สิ้นสุด ในหัวข้อถัดไป ฉันจะอธิบายเหตุผลที่ว่าทำไมมันถึงได้รับความนิยม ก่อนที่จะไปยังบทช่วยสอนการจำลอง Monte Carlo แบบทีละขั้นตอนใน Python

ทำไม Python เป็นตัวเลือกที่ยอดเยี่ยมสำหรับผู้เชี่ยวชาญด้านการเงิน

ภาษาโปรแกรม Python มีมาตั้งแต่ปี 1990 แต่ไม่นานมานี้ความนิยมของมันได้ระเบิดขึ้น

มีเหตุผลหลายประการ ลองพิจารณากันทีละข้อ

1. Python เป็นภาษาโปรแกรมระดับสูง

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

2. กระชับ

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

3. ง่ายต่อการเรียนรู้และทำความเข้าใจ

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

4. เหมาะสำหรับการพัฒนาอย่างรวดเร็ว วนซ้ำ

การลองผิดลองถูกที่รู้แจ้งนั้นมีประสิทธิภาพดีกว่าการวางแผนของสติปัญญาที่ไร้ที่ติ - เดวิด เคลลี่

Python เหมาะอย่างยิ่งสำหรับการสร้างต้นแบบและการพัฒนาแบบวนซ้ำอย่างรวดเร็ว (และใช่ การลองผิดลองถูก) เนื่องจากเครื่องมือล่ามเชิงโต้ตอบ เช่น เชลล์ Python, IPython และ Jupyter อยู่ด้านหน้าและตรงกลางใน Python toolchain ในสภาพแวดล้อมแบบโต้ตอบเหล่านี้ คุณสามารถเขียนและรันโค้ดแต่ละบรรทัดแยกกัน และดูผลลัพธ์ (หรือข้อความแสดงข้อผิดพลาดที่เป็นประโยชน์) ได้ทันที ภาษาอื่นก็มีสิ่งนี้เช่นกัน แต่โดยส่วนใหญ่แล้วจะไม่ดีเท่ากับ Python

5. สามารถใช้ได้ทั้งในการสร้างต้นแบบและรหัสการผลิต

นอกจากจะยอดเยี่ยมสำหรับการสร้างต้นแบบแล้ว Python ยังเป็นภาษาที่ยอดเยี่ยมและทรงพลังสำหรับแอปพลิเคชันที่ใช้งานจริงจำนวนมาก บริษัทซอฟต์แวร์ที่ใหญ่ที่สุดในโลกบางแห่งใช้ Python อย่างหนักในแอปพลิเคชันและกรณีการใช้งานที่หลากหลาย

6. มาพร้อมกับ “แบตเตอรี่ที่รวมอยู่:” The Python Standard Library

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

7. ห้องสมุดบุคคลที่สามที่ยอดเยี่ยมสำหรับการวิเคราะห์ทางการเงิน

สำหรับผู้เชี่ยวชาญด้านการเงิน Pandas ที่มี อ็อบเจ็กต์ DataFrame และ Series และ Numpy ที่มี ndarray เป็นตัวช่วยในการวิเคราะห์ทางการเงินด้วย Python เมื่อรวมกับ matplotlib และไลบรารีการสร้างภาพอื่นๆ คุณมีเครื่องมือที่ยอดเยี่ยมที่จะช่วยให้คุณทำงานได้อย่างมีประสิทธิภาพ

8. Python ฟรี!

Python ได้รับการพัฒนาภายใต้ลิขสิทธิ์โอเพ่นซอร์สทำให้ใช้งานได้ฟรีในเชิงพาณิชย์

บทช่วยสอนทีละขั้นตอนของการใช้ Python และ Finance ร่วมกัน

ต่อไปนี้เป็นบทช่วยสอนแบบทีละขั้นตอนที่แสดงวิธีสร้างแบบจำลอง Monte Carlo แบบง่ายที่อธิบายไว้ในบล็อกโพสต์ก่อนหน้าของฉัน แต่ใช้ Python แทนปลั๊กอิน @RISK สำหรับ Excel

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

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

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

จุดเริ่มต้นและผลลัพธ์ที่ต้องการ

ฉันเริ่มต้นด้วยแบบจำลองการประเมินค่า DCF ที่เรียบง่ายมากแบบเดียวกับที่ใช้ในบทช่วยสอนการจำลอง Monte Carlo มีรายการสำคัญบางรายการจากงบการเงินสามฉบับ และเซลล์อินพุตที่ไฮไลต์สามเซลล์ ซึ่งในเวอร์ชัน Excel มีการประมาณการจุดที่เราต้องการแทนที่ด้วยการแจกแจงความน่าจะเป็นเพื่อเริ่มสำรวจช่วงของผลลัพธ์ที่อาจเกิดขึ้น

แนวทางสองขั้นตอนในการพัฒนาสคริปต์ขนาดเล็ก

ทำให้ได้ผล ทำให้ถูกต้อง ทำให้เร็ว - Kent Beck

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

1. อันดับแรก ฉันพัฒนาต้นแบบการทำงานโดยใช้วิธีการที่ตรงไปตรงมา ซึ่งฉันคิดว่าง่ายต่อการติดตาม และไม่ต่างจากกระบวนการที่ใช้เริ่มโครงการนี้โดยสิ้นเชิง หากคุณต้องเริ่มต้นจากศูนย์
2. จากนั้น หลังจากที่ได้พัฒนาต้นแบบการทำงานแล้ว ฉันก็ดำเนินการตามขั้นตอนการปรับโครงสร้างใหม่ - เปลี่ยนโครงสร้างของโค้ดโดยไม่เปลี่ยนฟังก์ชันการทำงาน คุณอาจต้องการอยู่เฉยๆ ในส่วนนั้น - เป็นโซลูชันที่หรูหรากว่าส่วนแรก และในฐานะโบนัส จะใช้เวลาดำเนินการเร็วขึ้นประมาณ 75 เท่า

1. การพัฒนาต้นแบบการทำงาน

การตั้งค่า Jupyter Notebook

สมุดบันทึก Jupyter เป็นเครื่องมือที่ยอดเยี่ยมสำหรับการทำงานกับ Python แบบโต้ตอบ เป็นล่าม Python แบบโต้ตอบพร้อมเซลล์ที่สามารถมีโค้ด ข้อความ Markdown รูปภาพ หรือข้อมูลอื่นๆ สำหรับบทช่วยสอนนี้ ฉันใช้ Python Quant Platform แต่ยังสามารถแนะนำ Colaboratory โดย Google ซึ่งให้บริการฟรีและทำงานบนคลาวด์ เมื่อถึงที่นั่นแล้ว ให้เลือก "New Python 3 Notebook" ในเมนู "ไฟล์" เท่านี้ก็พร้อมใช้งานแล้ว

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

 import numpy as np import pandas as pd import matplotlib.pyplot as plt %matplotlib inline

หมายเหตุก่อนที่เราจะเริ่มตั้งชื่อตัวแปรแรกของเรา ดังที่ฉันได้กล่าวไปแล้ว ความสามารถในการอ่านเป็นจุดแข็งอย่างหนึ่งของ Python การออกแบบภาษาช่วยสนับสนุนสิ่งนั้นได้มาก แต่ทุกคนที่เขียนโค้ดมีหน้าที่ในการทำให้อ่านและเข้าใจได้ ไม่เพียงแต่สำหรับผู้อื่นแต่สำหรับตัวเองด้วย ดังที่กฎหมายของ Eagleson กล่าวไว้ว่า “รหัสใดๆ ที่คุณไม่ได้ดูเป็นเวลาหกเดือนหรือมากกว่านั้นอาจถูกเขียนโดยคนอื่นเช่นกัน”

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

โดยที่ในใจ ให้ไปต่อ

การสร้างงบการเงิน

มีหลายวิธีที่เราสามารถทำงานกับข้อมูลสเปรดชีตที่มีอยู่ใน Python ตัวอย่างเช่น เราสามารถอ่านชีตลงใน Pandas DataFrame ด้วยโค้ดหนึ่งบรรทัดโดยใช้คำสั่ง read_excel หากคุณต้องการบูรณาการที่แน่นแฟ้นยิ่งขึ้นและลิงก์แบบเรียลไทม์ระหว่างสเปรดชีตและโค้ด Python ของคุณ มีตัวเลือกทั้งแบบฟรีและเชิงพาณิชย์ที่พร้อมให้ฟังก์ชันดังกล่าว

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

ในขั้นแรกสู่การสร้าง Python แทนงบการเงิน เราจะต้องมีโครงสร้างข้อมูลที่เหมาะสม มีให้เลือกมากมาย บางตัวสร้างขึ้นใน Python อื่นๆ จากไลบรารีต่างๆ หรือเราจะสร้างเองก็ได้ ตอนนี้ ลองใช้ Series จากห้องสมุด Pandas เพื่อดูการทำงานของมัน:

 years = ['2018A', '2019B', '2020P', '2021P', '2022P', '2023P'] sales = pd.Series(index=years) sales['2018A'] = 31.0 sales

อินพุตนี้และเอาต์พุตที่เกี่ยวข้องแสดงอยู่ด้านล่าง:

ด้วยสามบรรทัดแรก เราได้สร้างโครงสร้างข้อมูลด้วยดัชนีที่ประกอบด้วยปี (แต่ละอันทำเครื่องหมายเพื่อแสดงว่าเป็นจริง งบประมาณ หรือที่คาดการณ์) ค่าเริ่มต้น (เป็นล้านยูโร เช่นเดียวกับในแบบจำลอง DCF ดั้งเดิม) และ เซลล์ว่าง (NaN, “ไม่ใช่ตัวเลข”) สำหรับการคาดการณ์ บรรทัดที่สี่พิมพ์การแสดงข้อมูล โดยทั่วไปแล้ว การพิมพ์ชื่อของตัวแปรหรืออ็อบเจกต์อื่นๆ ในล่ามแบบโต้ตอบมักจะให้การแทนค่าที่สมเหตุสมผลแก่คุณ

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

 growth_rate = 0.1 for year in range(1, 6): sales[year] = sales[year - 1] * (1 + growth_rate) sales

ตอนนี้เรามีประมาณการยอดขาย แทนที่จะเป็น NaN:

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

 ebitda_margin = 0.14 depr_percent = 0.032 ebitda = sales * ebitda_margin depreciation = sales * depr_percent ebit = ebitda - depreciation nwc_percent = 0.24 nwc = sales * nwc_percent change_in_nwc = nwc.shift(1) - nwc capex_percent = depr_percent capex = -(sales * capex_percent) tax_rate = 0.25 tax_payment = -ebit * tax_rate tax_payment = tax_payment.apply(lambda x: min(x, 0)) free_cash_flow = ebit + depreciation + tax_payment + capex + change_in_nwc free_cash_flow

สิ่งนี้ทำให้เรามีกระแสเงินสดอิสระ:

บรรทัดด้านบนที่อาจต้องการความคิดเห็นในขั้นตอนนี้คือการอ้างอิง tax_payment ที่สอง ในที่นี้ เราใช้ฟังก์ชันเล็กๆ เพื่อให้แน่ใจว่าในสถานการณ์ที่กำไรก่อนภาษีติดลบ เราจะไม่มีการชำระภาษีเป็นบวก นี่แสดงให้เห็นว่าคุณสามารถใช้ฟังก์ชันแบบกำหนดเองกับทุกเซลล์ใน Pandas Series หรือ DataFrame ได้อย่างมีประสิทธิภาพเพียงใด แน่นอนว่าการใช้งานจริงนั้นเป็นการทำให้เข้าใจง่ายขึ้น แบบจำลองที่สมจริงมากขึ้นสำหรับแบบฝึกหัดการประเมินมูลค่าที่ใหญ่ขึ้นจะมีแบบจำลองภาษีแยกต่างหากซึ่งคำนวณภาษีเงินสดจริงที่จ่ายตามปัจจัยเฉพาะของบริษัทจำนวนหนึ่ง

การดำเนินการประเมินค่า DCF

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

เราเข้าถึงองค์ประกอบโดยการเขียนวงเล็บเหลี่ยมหลังชื่อของโครงสร้างโดยตรง การทำดัชนีอย่างง่ายจะเข้าถึงองค์ประกอบตามตำแหน่ง โดยเริ่มจากศูนย์ หมายความว่า free_cash_flow[1] จะให้องค์ประกอบที่สองแก่เรา [-1] เป็นชวเลขสำหรับการเข้าถึงองค์ประกอบสุดท้าย (กระแสเงินสดของปีที่แล้วใช้ในการคำนวณค่าเทอร์มินัล) และการใช้เครื่องหมายทวิภาคจะทำให้เรามีการแบ่งส่วน หมายความว่า [1:] ให้องค์ประกอบทั้งหมดแก่เรา ยกเว้นองค์ประกอบแรก เนื่องจากเราไม่ต้องการรวมปี 2018A ในการประเมินค่า DCF ของเรา

 cost_of_capital = 0.12 terminal_growth = 0.02 terminal_value = ((free_cash_flow[-1] * (1 + terminal_growth)) / (cost_of_capital - terminal_growth)) discount_factors = [(1 / (1 + cost_of_capital)) ** i for i in range (1,6)] dcf_value = (sum(free_cash_flow[1:] * discount_factors) + terminal_value * discount_factors[-1]) dcf_value 

นั่นเป็นการสรุปส่วนแรกของต้นแบบของเรา - ตอนนี้เรามีโมเดล DCF ที่ใช้งานได้แม้ว่าจะเป็นโมเดลพื้นฐานใน Python

การส่งออกข้อมูล

ก่อนที่จะไปยังการจำลอง Monte Carlo จริง นี่อาจเป็นเวลาที่ดีที่จะกล่าวถึงความสามารถในการส่งออกที่มีอยู่ในแพ็คเกจ Pandas หากคุณมีอ็อบเจ็กต์ Pandas DataFrame คุณสามารถเขียนสิ่งนั้นลงในไฟล์ Excel ด้วยบรรทัดเดียวโดยใช้เมธอด to_excel มีฟังก์ชันการทำงานที่คล้ายคลึงกันในการส่งออกไปยังรูปแบบและปลายทางอื่น ๆ มากกว่าหนึ่งโหลเช่นกัน

 output = pd.DataFrame([sales, ebit, free_cash_flow], index=['Sales', 'EBIT', 'Free Cash Flow']).round(1) output.to_excel('Python DCF Model Output.xlsx') output 

การสร้างการแจกแจงความน่าจะเป็นสำหรับการจำลอง Monte Carlo ของเรา

ตอนนี้เราพร้อมที่จะจัดการกับความท้าทายต่อไป: เพื่อแทนที่อินพุตการประมาณจุดด้วยการแจกแจงความน่าจะเป็น ในขณะที่ขั้นตอนจนถึงจุดนี้อาจดูค่อนข้างยุ่งยากเมื่อเทียบกับการสร้างแบบจำลองเดียวกันใน Excel สองสามบรรทัดถัดไปนี้จะทำให้คุณเห็นว่า Python มีประสิทธิภาพเพียงใด

ขั้นตอนแรกของเราคือตัดสินใจว่าเราต้องการทำซ้ำกี่ครั้งในการจำลอง การใช้ 1,000 เป็นจุดเริ่มต้นทำให้เกิดความสมดุลระหว่างการได้รับจุดข้อมูลเพียงพอเพื่อให้ได้แผนภาพผลลัพธ์ที่สมเหตุสมผล กับการจำลองเสร็จสิ้นภายในกรอบเวลาที่เหมาะสม ต่อไป เราสร้างการแจกแจงจริง เพื่อความง่าย ฉันได้สร้างการแจกแจงแบบปกติสามแบบที่นี่ แต่ไลบรารี NumPy มีการแจกแจงจำนวนมากให้เลือก และยังมีที่อื่นๆ ให้ดูเช่นกัน รวมถึงไลบรารีมาตรฐาน Python หลังจากตัดสินใจว่าจะใช้การกระจายแบบใด เราจำเป็นต้องระบุพารามิเตอร์ที่จำเป็นในการอธิบายรูปร่างของพวกมัน เช่น ค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐาน และจำนวนผลลัพธ์ที่ต้องการ

 iterations = 1000 sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations) ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations) nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations) plt.hist(sales_growth_dist, bins=20) plt.show() 

ในที่นี้ คุณสามารถโต้แย้งได้ว่า EBITDA ไม่ควรเป็นตัวแปรสุ่มที่แยกจากกันโดยอิสระจากการขาย แต่มีความสัมพันธ์กับยอดขายในระดับหนึ่ง ฉันเห็นด้วยกับสิ่งนี้ และเพิ่มว่าควรได้รับแรงผลักดันจากความเข้าใจที่มั่นคงเกี่ยวกับพลวัตของโครงสร้างต้นทุน (ต้นทุนผันแปร ต้นทุนกึ่งตัวแปร และคงที่) และตัวขับเคลื่อนต้นทุนหลัก (ซึ่งบางส่วนอาจมีการแจกแจงความน่าจะเป็นของตัวเอง เช่น ป้อนราคาสินค้าโภคภัณฑ์) แต่ฉันทิ้งความซับซ้อนเหล่านั้นไว้ที่นี่ เพื่อประโยชน์ของพื้นที่และความชัดเจน

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

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

 def run_mcs(): # Create probability distributions sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations) ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations) nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations) # Calculate DCF value for each set of random inputs output_distribution = [] for i in range(iterations): for year in range(1, 6): sales[year] = sales[year - 1] * (1 + sales_growth_dist[0]) ebitda = sales * ebitda_margin_dist[i] depreciation = (sales * depr_percent) ebit = ebitda - depreciation nwc = sales * nwc_percent_dist[i] change_in_nwc = nwc.shift(1) - nwc capex = -(sales * capex_percent) tax_payment = -ebit * tax_rate tax_payment = tax_payment.apply(lambda x: min(x, 0)) free_cash_flow = ebit + depreciation + tax_payment + capex + change_in_nwc # DCF valuation terminal_value = (free_cash_flow[-1] * 1.02) / (cost_of_capital - 0.02) free_cash_flow[-1] += terminal_value discount_factors = [(1 / (1 + cost_of_capital)) ** i for i in range (1,6)] dcf_value = sum(free_cash_flow[1:] * discount_factors ) output_distribution.append(dcf_value) return output_distribution

ตอนนี้ เราสามารถเรียกใช้การจำลองทั้งหมดและวางแผนการกระจายเอาต์พุต ซึ่งจะเป็นมูลค่ากระแสเงินสดคิดลดของบริษัทนี้ในการทำซ้ำ 1,000 ครั้งด้วยรหัสต่อไปนี้ คำสั่ง %time ไม่ใช่โค้ด Python แต่เป็นโน้ตบุ๊กที่วัดเวลาในการเรียกใช้บางสิ่ง (คุณสามารถใช้ฟังก์ชัน Python จากไลบรารีมาตรฐานแทนได้) ขึ้นอยู่กับคอมพิวเตอร์ที่คุณใช้ แต่เวอร์ชันนี้ต้องใช้เวลา 1-2 วินาทีเพื่อเรียกใช้การวนซ้ำ 1,000 ครั้งและเห็นภาพผลลัพธ์

 %time plt.hist(run_mcs(), bins=20, color='r') plt.show() 

2. การปรับแต่งต้นแบบ

ความสงสัยที่ซุ่มซ่อนอยู่ว่าบางสิ่งบางอย่างสามารถทำให้ง่ายขึ้นเป็นแหล่งความท้าทายที่คุ้มค่าที่สุดในโลก - เอ็ดเจอร์ ไดค์สตรา

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

1. จัดระเบียบส่วนต่างๆ ให้เป็นระเบียบมากขึ้น
2. เปลี่ยนชื่อตัวแปรและฟังก์ชันเพื่อให้วัตถุประสงค์และการทำงานชัดเจนขึ้น
3. อนุญาตและเตรียมพร้อมสำหรับคุณสมบัติในอนาคต
4. ปรับปรุงความเร็วในการดำเนินการ พื้นที่หน่วยความจำ หรือการใช้ทรัพยากรอื่นๆ

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

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

ตอนนี้มันดูสะอาดตาและเข้าใจง่ายขึ้น:

 # Key inputs from DCF model years = 5 starting_sales = 31.0 capex_percent = depr_percent = 0.032 sales_growth = 0.1 ebitda_margin = 0.14 nwc_percent = 0.24 tax_rate = 0.25 # DCF assumptions r = 0.12 g = 0.02 # For MCS model iterations = 1000 sales_std_dev = 0.01 ebitda_std_dev = 0.02 nwc_std_dev = 0.01

 def run_mcs(): # Generate probability distributions sales_growth_dist = np.random.normal(loc=sales_growth, scale=sales_std_dev, size=(years, iterations)) ebitda_margin_dist = np.random.normal(loc=ebitda_margin, scale=ebitda_std_dev, size=(years, iterations)) nwc_percent_dist = np.random.normal(loc=nwc_percent, scale=nwc_std_dev, size=(years, iterations)) # Calculate free cash flow sales_growth_dist += 1 for i in range(1, len(sales_growth_dist)): sales_growth_dist[i] *= sales_growth_dist[i-1] sales = sales_growth_dist * starting_sales ebitda = sales * ebitda_margin_dist ebit = ebitda - (sales * depr_percent) tax = -(ebit * tax_rate) np.clip(tax, a_min=None, a_max=0) nwc = nwc_percent_dist * sales starting_nwc = starting_sales * nwc_percent prev_year_nwc = np.roll(nwc, 1, axis=0) prev_year_nwc[0] = starting_nwc delta_nwc = prev_year_nwc - nwc capex = -(sales * capex_percent) free_cash_flow = ebitda + tax + delta_nwc + capex # Discount cash flows to get DCF value terminal_value = free_cash_flow[-1] * (1 + g) / (r - g) discount_rates = [(1 / (1 + r)) ** i for i in range (1,6)] dcf_value = sum((free_cash_flow.T * discount_rates).T) dcf_value += terminal_value * discount_rates[-1] return dcf_value

ความแตกต่างหลักที่คุณจะสังเกตเห็นระหว่างเวอร์ชันนี้และเวอร์ชันก่อนหน้าคือการไม่มี for i in range(iterations) เมื่อใช้การดำเนินการอาร์เรย์ของ NumPy เวอร์ชันนี้จะทำงานใน 18 มิลลิวินาที เทียบกับ 1.35 วินาทีสำหรับเวอร์ชันต้นแบบ ซึ่งเร็วกว่าประมาณ 75 เท่า

 %time plt.hist(run_mcs(), bins=20, density=True, color="r") plt.show() 

ฉันแน่ใจว่าการเพิ่มประสิทธิภาพเพิ่มเติมเป็นไปได้ เนื่องจากฉันรวบรวมทั้งต้นแบบและเวอร์ชันที่ปรับปรุงแล้วในเวลาอันสั้นเพื่อจุดประสงค์ของบทช่วยสอนนี้เท่านั้น

ก้าวต่อไป

บทช่วยสอนนี้แสดงให้เห็นคุณสมบัติอันทรงพลังของ Python และหากคุณต้องพัฒนาสิ่งนี้ต่อไป โอกาสก็แทบจะไม่มีที่สิ้นสุด คุณสามารถตัวอย่างเช่น:

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

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

โดยสรุป: ภาษาที่มีประโยชน์สำหรับกล่องเครื่องมือทางการเงินของคุณ

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

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

แหล่งข้อมูลที่แนะนำสำหรับผู้เชี่ยวชาญด้านการเงินเพื่อเรียนรู้ Python

• หนังสือโอเรลลี ฉันสามารถแนะนำโดยเฉพาะอย่างยิ่ง:
  • Python for Finance by Yves Hilpisch
  • Learning Python by Mark Lutz
  • Fluent Python by Luciano Ramalho
• The Python Quants
• PyCon talks on YouTube
• Udemy