Python มีคุณลักษณะอะไรบ้างที่ทำให้มีลักษณะเฉพาะเป็นภาษาของตัวเอง [ปิด]

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

ฉันเป็นคนใหม่ที่นี่ดังนั้นสิ่งที่เข้าใจง่ายอาจต้องอธิบาย .....

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

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

• Metaclass- based metaprogramming โดยพื้นฐานแล้วการรันโค้ด Arbitary ในการสร้างคลาส ทำการปรับแต่งคลาสที่ดีมากโดยมีงานน้อยมากที่จุดสิ้นสุดการรับเช่นสำหรับ Object-relational Mapping (ORM) คลาสไคลเอนต์สามารถเขียนได้ตามปกติโดยมีบรรทัดพิเศษสองสามบรรทัดattr = SomeDataType()และโค้ดจะถูกสร้างขึ้นโดยอัตโนมัติ ตัวอย่างนี้เป็นของ Django "รุ่น"
• คุณควรที่จะใช้ iterators สำหรับทุกอย่าง นี่เป็นสิ่งที่ชัดเจนโดยเฉพาะอย่างยิ่งใน 3.x ซึ่งทางเลือกที่อิงกับรายการส่วนใหญ่ที่มีการทำซ้ำตามตัววนซ้ำได้ถูกยกเลิกไปในทางกลับกัน Iterators ยังทำหน้าที่เป็นอินเทอร์เฟซใกล้สากลสำหรับคอลเลกชัน (ทั้งที่คุณมีอยู่ในหน่วยความจำและที่คุณต้องการเพียงครั้งเดียวเท่านั้นและสร้างด้วยคุณสมบัติด้านล่าง) คอลเลกชัน - ผู้ไม่เชื่อเรื่องพระเจ้าพื้นที่ - ประสิทธิภาพ ( O(1)พื้นที่สำหรับผลลัพธ์กลางมักตามธรรมชาติงานน้อยมากจริง ๆ ต้องรายการทั้งหมดในหน่วยความจำในครั้งเดียว), ข้อมูลที่เรียงกันได้ง่ายกว่าที่เคย
• นิพจน์ตัวสร้างที่เกี่ยวข้องกับข้างต้น หลายคนจะเคยได้ยินความเข้าใจในรายการ (การสร้างรายการจากการทำซ้ำอีกอันหนึ่งการกรองและการแมปในกระบวนการด้วยไวยากรณ์ที่สะดวกมาก) ลืมเกี่ยวกับพวกเขาพวกเขากำลังน้ำตาล syntactic กรณีพิเศษ การแสดงออกกำเนิดมีความใกล้ชิดในไวยากรณ์และในที่สุดส่งผลให้ในลำดับเดียวกันมากของรายการ แต่พวกเขาก่อให้เกิดผลอย่างเฉื่อยชา (และใช้O(1)พื้นที่เว้นแต่ว่าคุณได้ให้ผลรอบ)
• yieldซึ่งส่วนใหญ่ทำการเขียนตัววนซ้ำ (เรียกว่าเครื่องกำเนิดที่นี่) ที่ไกลกว่า พวกเขาเป็นพี่ชายคนโตของข้างต้นสนับสนุนการควบคุมทุกรูปแบบ C # มีบางสิ่งที่คล้ายกันโดยมีคำหลักเดียวกัน แต่yieldก็มีมากเกินไปที่จะสนับสนุน coroutines แบบ จำกัด (เช่น Lua มีการสนับสนุนที่ซับซ้อนมากขึ้น) ซึ่งได้รับการใช้งานอย่างดีโดยคนฉลาดที่ทำงานเกี่ยวกับปัญหาหนัก ตัวอย่างสองตัวอย่างที่อยู่ด้านบนของหัวของฉัน: การแยกวิเคราะห์แบบเรียกซ้ำด้วยการย้อนกลับและไม่มีการ จำกัด สแต็กและI / O แบบอะซิงโครนัส (พร้อมไวยากรณ์ที่สะดวก)
• การกำหนดเป้าหมายหลายเป้าหมายและการแกะกล่องออกซ้ำได้ การมอบหมายให้เตียรอยด์ ไม่เพียง แต่คุณสามารถกำหนดให้หลายค่าพร้อมกัน (แม้สำหรับการสลับค่าและเมื่อทำการวนซ้ำ - for key, value in mapping.items()) คุณสามารถคลายความยาวที่ทราบค่าได้ (โดยสุจริต tuples ส่วนใหญ่) เป็นตัวแปรหลายตัว ตั้งแต่ 3.x first, *everything_in_between, last = valuesก็จะยิ่งเป็นประโยชน์สำหรับคอลเลกชันของความยาวที่ไม่รู้จักในขณะที่คุณสามารถระบุตัวแปรไม่กี่ถ่ายรายการเดียวและหนึ่งสละสิ่งที่ยังคงอยู่:
• ตัวอธิบายอาจมีประสิทธิภาพมากที่สุดในบรรดาวิธีต่างๆในการกำหนดการเข้าถึงแอตทริบิวต์เอง มีคุณสมบัติ (เหมือนใน C # แต่ไม่มีการสนับสนุนภาษาพิเศษ) วิธีคงที่วิธีการเรียนและอื่น ๆ ทั้งหมดนำมาใช้เป็นตัวอธิบาย พวกมันเป็นวัตถุชั้นหนึ่งเช่นกัน เมื่อสัปดาห์ที่แล้วฉันต้องเผชิญกับโค้ดซ้ำ ๆ และเล่ห์เหลี่ยมในคุณสมบัติ - ดังนั้นฉันจึงเขียนฟังก์ชั่นเล็ก ๆ ที่สร้างส่วนที่ซ้ำและห่อมันไว้ในproperyวัตถุ
• กฎล้ำหน้าอย่างหมดจด (indentaion สำหรับการลบบล็อก) ฉันใส่ล่าสุดนี้โดยเจตนา แม้ว่ามันจะแยกแยะ Python แต่มันก็ไม่ได้โดดเด่นในการเขียนโปรแกรมทุกวันเมื่อคุณคุ้นเคย (หรืออย่างน้อยนั่นก็คือประสบการณ์ของฉัน)

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

หรืออาจมีสิ่งหนึ่งเล็กน้อย: ฉันไม่เห็นวิธีที่ Python ส่งผ่านอย่างชัดเจนselfเป็นพารามิเตอร์อย่างเป็นทางการไปยังฟังก์ชันสมาชิกวัตถุที่ทำในภาษาอื่น ๆ มันเป็นเรื่องเล็กน้อยและฉันไม่เห็นว่าสิ่งนี้จะเปลี่ยนแปลงอะไรจริงๆ

แต่ฉันไม่ชำนาญใน Python ดังนั้นอาจมีบางอย่างที่ขาดหายไปอย่างแน่นอน!

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

>>> class DocStringException(Exception):
...     """Error message is the same as docstring"""
...     def __str__(self):
...         return repr(self.__doc__)
... 
>>> class ExampleException(DocStringException):
...     """An example happened"""
... 
>>> raise ExampleException
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
__main__.ExampleException: 'An example happened'

คุณสมบัติวิปัสสนาอื่น ๆ ที่มีประโยชน์:

• help / help () - ความช่วยเหลือเกี่ยวกับล่าม / ช่วยเหลือเกี่ยวกับวัตถุ
• คำหลัก - คำหลักหลาม
• locals () - รับชื่อท้องถิ่น
• globals () - รับชื่อทั่วโลก
• dir () - รับคุณสมบัติและวิธีการของวัตถุ
• วิธี. mro , issubclass - ทำความเข้าใจกับการสืบทอด
• id () - รับที่อยู่หน่วยความจำของวัตถุ

1. Generator Expressions
2. input()ให้ฉันอธิบายฉันไม่เคยเห็นภาษา (จนถึงตอนนี้) ที่คุณสามารถกำหนดค่าให้กับข้อความที่พิมพ์บางอย่างมันเป็นเหมือนทับทิมprint/getsแต่ด้วยค่าที่กำหนดให้กับงานพิมพ์แทนที่จะเป็น:print "Foo" bar = gets
3. yield
4. ชุดข้อมูลหลายประเภท: ordereddict, namedtuple, array, list, tuple, dictionary

Python เป็นหนึ่งในไม่กี่ภาษาที่มีค่าใช้จ่ายด้าน syntactic ต่ำมากทำให้มีความสามารถในการแสดงออกอย่างมาก: list / set / dict comprehensions, ผลผลิต, decorators, eval, การเขียนโปรแกรม meta class, วิปัสสนา, โครงสร้างข้อมูลในตัวที่ดีที่สุด dicts, เซต) สิ่งเหล่านี้ทั้งหมดสมรู้ร่วมคิดในวิธีที่ดีมากที่จะให้คุณ (นักพัฒนา) มีอำนาจในการแสดงความคิดของคุณในรหัสที่รัดกุมและสง่างามเกือบจะเร็วที่สุดเท่าที่คุณสามารถคิด ฉันไม่สามารถนึกถึงภาษาอื่นใดกับชุดฟีเจอร์ชุดนี้ที่รวมเข้าด้วยกัน

ฉันจะบอกว่ามันใช้การเยื้องเพื่อแนบถ้างบและลูป ยังไม่เห็นว่าในภาษาอื่น ๆ

ฉันคิดว่ามันมีประโยชน์มากเพราะมันทำให้รหัส python ทำให้งงงวยมากขึ้น!

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