เรียนรู้ Python จาก Ruby; ความแตกต่างและความคล้ายคลึงกัน

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

ฉันกำลังมองหารายการที่คล้ายกับไพรเมอร์ที่ฉันเขียนสำหรับLearning Lua สำหรับ JavaScripters : สิ่งง่ายๆเช่นความสำคัญของช่องว่างและโครงสร้างแบบวนซ้ำ ชื่อของnilใน Python และค่าใดที่ถือว่าเป็น "จริง" มันเป็นสำนวนที่จะใช้เทียบเท่าmapและeachหรือพึมพำ บางสิ่งบางอย่างเกี่ยว กับรายการความเข้าใจพึมพำกับบรรทัดฐานหรือไม่?

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

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

นี่คือความแตกต่างที่สำคัญสำหรับฉัน:

1. ทับทิมมีบล็อก Python ไม่ได้

2. Python มีฟังก์ชัน; ทับทิมไม่ได้ ใน Python คุณสามารถใช้ฟังก์ชันหรือวิธีการใดก็ได้และส่งต่อไปยังฟังก์ชันอื่น ใน Ruby ทุกอย่างเป็นวิธีการและไม่สามารถส่งผ่านวิธีการได้โดยตรง แต่คุณต้องห่อไว้ใน Proc เพื่อส่งต่อ

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

4. Python มีความเข้าใจในรายการซึ่งแสดงออกได้ค่อนข้างชัดเจน ตัวอย่างเช่นหากคุณมีรายการตัวเลขคุณสามารถเขียนได้

   [x*x for x in values if x > 15]

   เพื่อให้ได้รายการใหม่ของค่ากำลังสองของค่าทั้งหมดที่มากกว่า 15 ใน Ruby คุณจะต้องเขียนสิ่งต่อไปนี้:

   values.select {|v| v > 15}.map {|v| v * v}

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

   Python ยังให้ความเข้าใจแผนที่ที่คล้ายกัน

5. Python รองรับ tuples; ทับทิมไม่ได้ ใน Ruby คุณต้องใช้อาร์เรย์เพื่อจำลองสิ่งทูเปิล

6. Ruby รองรับคำสั่ง switch / case; Python ไม่ได้

7. Ruby รองรับตัวexpr ? val1 : val2ดำเนินการ ternary มาตรฐาน Python ไม่ได้

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

9. Python รองรับฟังก์ชันแลมด้าบรรทัดเดียวเท่านั้น บล็อก Ruby ซึ่งเป็นฟังก์ชันแลมบ์ดา / ประเภทสามารถมีขนาดใหญ่ได้ตามอำเภอใจ ด้วยเหตุนี้รหัส Ruby จึงมักเขียนในรูปแบบที่ใช้งานได้ดีกว่ารหัส Python ตัวอย่างเช่นในการวนซ้ำรายการใน Ruby คุณมักจะทำ

   collection.each do |value|
     ...
   end

   collection.eachบล็อกการทำงานอย่างมากเช่นฟังก์ชั่นที่ถูกส่งผ่านไปยัง หากคุณจะทำสิ่งเดียวกันใน Python คุณจะต้องกำหนดฟังก์ชันภายในที่มีชื่อแล้วส่งต่อไปยังคอลเลกชันแต่ละวิธี (หากรายการรองรับวิธีนี้):

   def some_operation(value):
     ...
   
   collection.each(some_operation)

   ที่ไม่ไหลลื่นมาก ดังนั้นโดยทั่วไปแล้ววิธีการที่ไม่ใช้งานต่อไปนี้จะถูกใช้ใน Python:

   for value in collection:
     ...

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

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

    ใน Python การส่งผ่านฟังก์ชั่นสำหรับการกระทำโดยพลการนั้นมีความซับซ้อนกว่าเล็กน้อยเนื่องจากคุณต้องเขียนชื่อฟังก์ชันภายใน (ดู # 9) Python ใช้withคำสั่งเพื่อความปลอดภัยในการจัดการทรัพยากร ดูฉันจะล้างวัตถุ Python อย่างถูกต้องได้อย่างไร สำหรับรายละเอียดเพิ่มเติม

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

ฉันหวังว่านี่จะช่วยได้: 'ความอัปลักษณ์' ของ Python

สองจุดที่จะทำให้คุณก้าวไปในทิศทางที่ถูกต้อง:

• ความดีในการเขียนโปรแกรมที่ใช้งานได้ทั้งหมดที่คุณใช้ใน Ruby อยู่ใน Python และง่ายยิ่งกว่านั้น ตัวอย่างเช่นคุณสามารถแมปฟังก์ชันได้ตรงตามที่คุณคาดหวัง:

  def f(x):
      return x + 1
  
  map(f, [1, 2, 3]) # => [2, 3, 4]

• Python ไม่มีเมธอดที่ทำหน้าที่เหมือนeach. เนื่องจากคุณใช้eachสำหรับผลข้างเคียงเท่านั้นสิ่งที่เทียบเท่าใน Python คือ for loop:

  for n in [1, 2, 3]:
      print n

• ความเข้าใจในรายการเป็นสิ่งที่ดีเมื่อ a) คุณต้องจัดการกับฟังก์ชันและคอลเลกชันออบเจ็กต์ร่วมกันและ b) เมื่อคุณต้องทำซ้ำโดยใช้ดัชนีหลายตัว ตัวอย่างเช่นหากต้องการค้นหา palindromes ทั้งหมดในสตริง (สมมติว่าคุณมีฟังก์ชันp()ที่ส่งกลับค่า true สำหรับ palindromes) สิ่งที่คุณต้องมีคือความเข้าใจในรายการเดียว:

  s = 'string-with-palindromes-like-abbalabba'
  l = len(s)
  [s[x:y] for x in range(l) for y in range(x,l+1) if p(s[x:y])]

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

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

ฉันรู้จัก Ruby ตัวน้อย แต่นี่เป็นหัวข้อย่อยเกี่ยวกับสิ่งที่คุณพูดถึง:

• nilค่าที่ระบุว่าไม่มีค่าจะเป็นNone(โปรดทราบว่าคุณตรวจสอบว่าเหมือนx is Noneหรือx is not Noneไม่ใช่ด้วย==- หรือโดยการบีบบังคับให้บูลีนดูจุดถัดไป)
• Noneศูนย์ฟีเจอร์ตัวเลข ( 0, 0.0, 0j(จำนวนเชิงซ้อน)) และคอลเลกชันที่ว่างเปล่า ( [], {}, set(), สตริงที่ว่างเปล่า""และอื่น ๆ ) ได้รับการพิจารณา falsy ทุกอย่างอื่นถือว่า truthy
• สำหรับผลข้างเคียงให้forวนซ้ำ( -) อย่างชัดเจน สำหรับการสร้างสิ่งใหม่ ๆ ที่ไม่มีผลข้างเคียงให้ใช้การทำความเข้าใจรายการ (หรือญาติของพวกเขา - นิพจน์กำเนิดสำหรับผู้ทำซ้ำครั้งเดียวที่ขี้เกียจเขียนตามคำบอก / ตั้งค่าความเข้าใจสำหรับคอลเล็กชันดังกล่าว)

เกี่ยวกับการวนซ้ำ: คุณมีforซึ่งดำเนินการซ้ำได้ (! ไม่นับ) และwhileซึ่งทำในสิ่งที่คุณคาดหวัง fromer นั้นทรงพลังกว่ามากด้วยการสนับสนุนที่กว้างขวางสำหรับตัวทำซ้ำ ไม่เพียง แต่เกือบทุกอย่างที่สามารถเป็นตัววนซ้ำแทนรายการได้คือตัววนซ้ำ (อย่างน้อยใน Python 3 - ใน Python 2 คุณมีทั้งสองอย่างและค่าเริ่มต้นคือรายการน่าเศร้า) มีเครื่องมือมากมายสำหรับการทำงานกับเครื่องวนซ้ำ - zipวนซ้ำจำนวนซ้ำ ๆ แบบขนานenumerateให้คุณ(index, item)(ในการทำซ้ำไม่ใช่เฉพาะในรายการ) แม้แต่การตัดซ้ำแบบผิด ๆ (อาจมีขนาดใหญ่หรือไม่สิ้นสุด)! ฉันพบว่าสิ่งเหล่านี้ทำให้งานวนซ้ำหลาย ๆ อย่างง่ายขึ้นมาก ไม่จำเป็นต้องพูดพวกเขารวมเข้าด้วยกันได้ดีกับความเข้าใจรายการนิพจน์ตัวสร้าง ฯลฯ

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

ใน Python เมธอดเป็นเพียงคลาสพิเศษของแอ็ตทริบิวต์: วิธีหนึ่งที่เรียกใช้งานได้

ตัวอย่างเช่น:

>>> class foo:
...     x = 5
...     def y(): pass
... 
>>> f = foo()
>>> type(f.x)
<type 'int'>
>>> type(f.y)
<type 'instancemethod'>

ความแตกต่างนั้นมีความหมายหลายอย่างเช่นการอ้างถึง fx หมายถึง method object แทนที่จะเรียกมัน อย่างที่คุณเห็น fx เป็นสาธารณะโดยค่าเริ่มต้นในขณะที่ใน Ruby ตัวแปรอินสแตนซ์จะเป็นแบบส่วนตัวตามค่าเริ่มต้น