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

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

รุ่นที่ใช้เปรียบเทียบในบทความนี้คือ python 3.7 และ ruby 2.6 อย่างไรก็ตาม ขอแค่เป็น python 3.x และ ruby 2.x เหมือนกันโดยรวมแล้วผลที่ได้ก็น่าจะไม่ต่างกัน






สิ่งที่เทียบเท่าหรือคล้ายกัน

ก่อนอื่นเพื่อไม่ให้สับสน ขอเปรียบเทียบสิ่งที่ทั้ง ๒​ ภาษาเหมือนหรือคล้ายกันแต่ใช้ชื่อต่างกัน

ไพธอน	รูบี
True	true
False	false
None	nil
int	Integer
float	Float
list, tuple	Array
dict	Hash
str	String, Symbol
range(a,b)	a...b

ลิสต์ ทูเพิล อาเรย์

อาเรย์ในรูบีจะเทียบเคียงได้กับลิสต์ในไพธอน ส่วนทูเพิลในไพธอนนั้นไม่มีสิ่งที่คล้ายกันอยู่ในรูบี

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

# python
a = [1,2]
a[1] = 3
a # [1, 3]
b = (1,2)
b[1] = 3 # TypeError: 'tuple' object does not support item assignment

ส่วนอาเรย์ในรูบีนั้นเขียนทับได้ จึงเหมือนกับลิสต์มากกว่า

# ruby
a = [1,2]
a[1] = 3
a # [1, 3]

สายอักขระและซิมโบล

ในทางตรงกันข้ามกับหัวข้อที่แล้ว ไพธอนมีสิ่งที่เรียกว่าเป็นสายอักขระอยู่แค่แบบเดียว (ใช้ชื่อว่า str) แต่ในรูบีมีสายอักขระ (String) และซิมโบล (Symbol)

ในรูบีข้อแตกต่างระหว่างสายอักขระกับซิมโบลก็คือ สายอักขระเขียนทับได้ แต่ซิมโบลเขียนทับไม่ได้

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

# ruby
a = 'กขค'
a[1] # "ข"
a[1] = 'ง'
a # "กงค"

ส่วนซิมโบลนั้นแค่ใช้ : นำหน้า

# ruby
s = :กขค
s[1] # "ข"
s[1] = 'ง' # NoMethodError (undefined method `[]=' for :กขค:Symbol)

จะเห็นว่าแก้อักษรในซิมโบลไม่ได้

ส่วนในไพธอนนั้นสายอักขระจะไม่สามารถแก้ค่าได้ เช่นเดียวกับทูเพิล หรือเหมือนกับซิมโบลในรูบี

# python
a = 'กขค'
a[1] # 'ข'
a[1] = 'ง' # TypeError: 'str' object does not support item assignment

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

# ruby
'ก'+'ข' # "กข"
:ก+:ข # NoMethodError (undefined method `+' for :ก:Symbol)

# python
'ก'+'ข' # 'กข'

เครื่องหมายคำพูดแบบเดี่ยวกับคู่

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

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

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

ในไพธอนไม่ว่าจะใช้เครื่องหมายคำพูดแบบไหนก็ไม่มีความแตกต่าง ความหมายเหมือนกัน จะต่างกันแค่ว่ากรณีที่ต้องการให้มี ' อยู่ข้างในก็ควรใช้แบบคู่ ถ้าต้องการให้มี " อยู่ข้างในควรใช้แบบเดี่ยว

แต่ว่าในรูบีนั้นการใช้แบบเดี่ยวกับแบบคู่มีความหมายต่างกัน คือถ้าใช้ ' ' จะไม่มีการตีความพวกสัญลักษณ์พิเศษพวกที่ใช้ \ นำหน้า เช่น \n ที่แทนการขึ้นบรรทัดใหม่

# ruby
'ก\nข' # "ก\\nข"
"ก\nข" # "ก\nข"
'ก\nข'=="ก\nข" # false
'ก\nข'=="ก\\nข" # true

ในไพธอนหากต้องการให้เหมือนกับเครื่องหมายคำพูดแบบเดี่ยวในรูบีจะต้องเติม r นำหน้า

# python
"ก\nข" # 'ก\nข'
r'ก\nข' # 'ก\\nข'
'ก\nข'=="ก\nข" # True
r'ก\nข'=='ก\\nข' # True

การขึ้นบรรทัดใหม่ในเครื่องหมายคำพูด

ในรูบีภายในเครื่องหมายคำพูดสามารถขึ้นบรรทัดใหม่ได้อย่างอิสระ

# ruby
"กขค
งจช"
# "กขค\nงจช"

แต่ในไพธอนเครื่องหมายคำพูดธรรมดาจะทำแบบนั้นไม่ได้ ต้องใช้เครื่องหมายคำพูดแบบ ๓ อันติดจึงจะทำแบบนั้นได้

# python
"""กขค
งจช"""
# 'กขค\nงจช'

ถ้าจะใช้ \ เพื่อขึ้นบรรทัดใหม่ก็ได้ แต่ก็จะไม่นับเป็นการขึ้นบรรทัดใหม่ แต่เหมือนเขียนต่อเนื่องกันไป

# python
"กขค\
งจช"
# 'กขคงจช'

จะเห็นว่าผลที่ได้ไม่มี \n โผล่มา

ซึ่งอันนี้หากทำในรูบีก็จะให้ผลแบบเดียวกัน

# ruby
"กขค\
งจช"
# 'กขคงจช'

ความจริงเท็จของค่าต่างๆ

ทั้งไพธอนและรูบีนั้นสามารถใช้ค่าที่ไม่ใช่ "จริง" หรือ "เท็จ" (เช่นพวกจำนวนตัวเลขหรือสายอักขระ) แทนลงไปเป็นเงื่อนไขใน if หรือ while แล้วค่าจะถูกตีความเป็นจริงเท็จ

ค่าความจริงเท็จสามารถหาได้โดยการเติม not not ลงไปข้างหน้าเหมือนกัน แต่ในรูบีสามารถใช้ !! ได้ด้วย ส่วนไพธอนก็อาจใช้ bool()

# ruby
not not 7 # true
!!8 # true

# python
not not 7 # True
bool(8) # True

ที่ต้องระวังคือการตีความจริงและเท็จของไพธอนและรูบีมีหลายส่วนที่แตกต่างกัน

ในรูบีค่านอกจาก false และ nil จะถูกตีความเป็นจริงทั้งหมด

# ruby
not not [] # true
not not {} # true
not not '' # true
not not 0 # true
not not false # false
not not nil # false

ในขณะที่ในไพธอน นอกจาก False และ None แล้วก็ยังมีอีกหลายกรณีที่อาจถูกตีความเป็นเท็จได้ เช่นลิสต์ว่าง [], สายอักขระเปล่า "" เลข 0

# python
not not [] # False
not not {} # False
not not '' # False
not not 0 # False
not not False # False
not not None # False

and or not

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

แต่ในรูบีสามารถใช้ && แทน and ใช้ || แทน or และใช้ ! แทน not ได้

อย่างไรก็ตาม ความหมายของ && || ! กับ and or not นั้นต่างกันเล็กน้อย แต่ขอไม่เขียนถึงตรงนี้เพราะเป็นรายละเอียดของภาษารูบีเอง

อนึ่ง รายละเอียดเรื่องการใช้ and และ or ในไพธอนดังที่กล่าวถึงในบทความนี้ก็สามารถใช้กับรูบีได้เหมือนกัน https://phyblas.hinaboshi.com/20190624

ความแตกต่างอย่างหนึ่งก็คือ ในรูบีเมื่อใช้ && หรือ || แล้วสามารถทำในสิ่งที่ไพธอนไม่สามารถทำได้ นั่นคือการเขียนแบบนี้

# ruby
a = nil
a ||= 5 # a กลายเป็น 5
a = 4
a ||= 5 # a เป็น 4 เหมือนเดิม

ในกรณีนี้หาก a มีค่าเดิมเป็น nil หรือ false แล้ว a จะถูกแทนด้วยค่าใหม่ที่อยู่หลัง ||= แต่ถ้านอกจากนั้นก็จะไม่มีการเปลี่ยนค่า

ให้ผลเหมือนกับการเขียนว่า

# ruby
a = 5 if(!a)

รูปแบบการเขียนแบบนี้หากใช้ or แทนจะเกิดข้อผิดพลาด ส่วนในไพธอนเองก็เช่นกัน ดังนั้นจึงทำแบบนี้ได้แค่ในรูบี

แต่ว่าการเขียนในแบบข้างต้นนั้นมีค่าเท่ากับการเขียนแบบนี้

# ruby
a = nil
a = a || 5
a = 4
a = a || 5

ซึ่งจะใช้ or แทน || ก็ได้เช่นกัน

ดังนั้นในกรณีที่เขียนแบบนี้จึงสามารถทำได้ในไพธอนเหมือนกัน

# python
a = None
a = a or 5 # a กลายเป็น 5
a = 4
a = a or 5 # a เป็น 4 เหมือนเดิม

จะให้ผลเหมือนการเขียนว่า

# python
if(not a): a = 5

การใช้เครื่องหมายเปรียบเทียบซ้อนกัน

ในไพธอนสามารถเอาเครื่องหมายเปรียบเทียบมาวางต่อกันกี่ตัวก็ได้

# python
a = 2
b = b
1 < a <= 3
2 > a >= 1
2 >= a < 3 < b
2 == a != b

ซึ่งจะมีค่าเท่ากับการเขียนโดยใช้ and เชื่อมแบบนี้

# python
1 < a and a <= 3 # True
2 > a and a >= 1 # False
2 >= a and a < 3 and 3 < b # True
2 == a and a != b # True

แต่ในรูบีไม่สามารถเอาเครื่องหมายเปรียบเทียบมาเรียงต่อกันได้ จึงเขียนได้แต่แบบล่างเท่านั้น

# ruby
a = 2
b = 4
1 < a and a <= 3 # true
2 > a and a >= 1 # false
2 >= a and a < 3 and 3 < b # true
2 == a and a != b # true

การแทนค่าเดียวใส่หลายตัวแปรพร้อมกัน

ทั้งในไพธอนและรูบีสามารถแทนค่าเดียวกันให้ตัวแปร ๒ ตัวในเวลาเดียวกันได้

# python และ ruby
a = b = 1

แบบนี้ผลก็คือการป้อนค่า 1 เข้าตัวแปร a และ b พร้อมกัน

เพียงแต่ว่าความหมายของการทำแบบนี้ต่างกันเล็กน้อย

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

อาจใส่วงเล็บเพื่อให้เห็นภาพง่าย แบบนี้ให้ผลเหมือนเดิม

# ruby
a = (b = 1)

แต่ในไพธอนกลไกจะต่างกันไป ดังนั้นการเขียนแบบนี้จะเกิดข้อผิดพลาด



ใช้คีย์เวิร์ดแทนในฟังก์ชัน

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

# python
def f(a,b):
    return [a,b]

f(3,4) # [3, 4]
f(4,3) # [4, 3]
f(a=3,b=4) # [3, 4]
f(b=3,a=4) # [4, 3]

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

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

# ruby
def f(a,b)
  return [a,b]
end

f(3,4) # [3, 4]
f(4,3) # [4, 3]
f(a=3,b=4) # [3, 4]
f(b=3,a=4) # [3, 4]

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

นั่นหมายความว่าการเขียน f(a=3,b=4) แบบนี้กลายเป็นการป้อนค่าให้ตัวแปร a และ b ไปด้วย แล้วยังป้อนให้ฟังก์ชัน f ไปด้วยในเวลาเดียวกัน ต่างจากไพธอนที่จะตีความว่าเป็นการป้อนให้พารามิเตอร์ a และ b ของฟังก์ชัน f

ดังนั้นต่อให้เขียนแบบนี้ก็ได้ผลแบบเดิมเหมือนกัน

# ruby
f(c=4,d=5) # [4, 5]

แต่ถ้าใส่แบบนี้ในไพธอนจะเกิดข้อผิดพลาด เพราะจะตีความเป็นการป้อนค่าให้พารามิเตอร์ c และ d ซึ่งไม่มีอยู่

# python
f(c=4,d=5) # TypeError: f() got an unexpected keyword argument 'c'

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

# ruby
def f(a:,b:)
  return [a,b]
end

f(a:7,b:8) # [7, 8]

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



การละวงเล็บเมื่อสร้างทูเพิลหรืออาเรย์

เวลาสร้างอาเรย์ปกติจะต้องล้อมด้วย [] แต่จริงๆเวลาที่แทนค่าเข้าตัวแปรสามารถละ [] ได้ เช่น ๒​ แบบนี้ใด้ผลเหมือนกัน

# ruby
a = [1,2]
a = 1,2

การสร้างลิสต์ในไพธอนนั้นไม่สามารถละวงเล็บได้ ต้องเขียนวงเล็บเหลี่ยมลงไปชัดเจน

# python
a = [1,2]

หากละวงเล็บแบบเดียวกับที่ทำในรูบีก็ได้ แต่จะกลายเป็นทูเพิล ดังนั้นการเขียน ๒​ แบบนี้มีค่าเท่ากัน

# python
a = (1,2)
a = 1,2

ป้อนค่าตัวแปรหลายตัวพร้อมกัน

ทั้งไพธอนและรูบีเวลาใช้ = เพื่อป้อนค่าให้ตัวแปร หากฝั่งซ้ายมีหลายตัวก็จะยัดค่าทีเดียวพร้อมกันได้

# python หรือ ruby
a,b,c = 3,5,7
a # 3
b # 5
c # 7

อย่างไรก็ตาม กรณีที่จำนวนฝั่งซ้ายขวาไม่เท่ากัน ในไพธอนจะเกิดข้อผิดพลาด

# python
a,b,c = 3,5 # ValueError: not enough values to unpack (expected 3, got 2)
d,e = 3,5,7 # ValueError: too many values to unpack (expected 2)

แต่ในรูบีจะไม่เกิดข้อผิดพลาดใดๆ แค่ถ้าฝั่งซ้ายมากกว่า ตัวที่เกินมาจะเป็น nil

# ruby
a,b,c = 3,5
a # 3
b # 5
c # nil

ส่วนถ้าฝั่งขวามากกว่า ตัวที่เกินมาจะแค่ไม่ถูกนำมาใช้ แต่ก็ไม่เกิดข้อผิดพลาด

# ruby
d,e = 3,5,7
d # 3
e # 5

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

# python
z = 8,9
z # (8, 9)
z.__class__ # tuple

# ruby
z = 8,9
z # [8, 9]
z.class # Array

การบวกลบอาเรย์และลิสต์

ลิสต์ในไพธอนและอาเรย์ในรูบีหากนำมาบวกกันก็จะเป็นการเอามาต่อกัน

# python หรือ ruby
a = [1,2,4]
b = [4,5]
a+b # [1, 2, 4, 4, 5]

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

# python
a-b # TypeError: unsupported operand type(s) for -: 'list' and 'list'

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

# ruby
a-b # [1, 2]

การใช้เซ็ต

ทั้งไพธอนและรูบีต่างก็มีออบเจ็กต์ในคลาสที่เรียกว่า Set อยู่ เอาไว้คำนวณในลักษณะของเซ็ต

จากข้อที่แล้ว ในไพธอนลิสต์และทูเพิลลบกันไม่ได้ แต่ถ้าเป็นเซ็ตสามารถลบกันได้

# python
a = {1,2,4}
b = {4,5}
a-b # {1, 2}

ในไพธอนแค่คร่อมด้วย {} ก็เป็นการสร้างเซ็ตแล้ว แต่ในรูบีถ้าจะใช้ Set จำเป็นต้อง require เข้ามา แล้วก็ใช้ Set.new

# ruby
require 'set'
a = Set.new([1,2,4])
b = Set.new([4,5])
a-b # #<Set: {1, 2}>

เซ็ตของทั้ง ๒ ภาษาเหมือนกันคือไม่สามารถใส่สมาชิกซ้ำได้ แต่ก็มีข้อแตกต่างคือ ของรูบีมีการคิดลำดับของข้อมูล ในขณะที่ไพธอนไม่มี

เช่นลองเทียบเวลาสร้าง ของไพธอนจะถูกเรียงให้ใหม่ไม่ว่าจะป้อนตัวไหนไปก่อน

# python
s1 = {7,2,5,1}
s1 # {1, 2, 5, 7}
s2 = {5,2,1,7}
s2 # {1, 2, 5, 7}
s1 == s2 # True

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

# ruby
s1 = Set.new([7,2,5,1])
s1 # #<Set: {7, 2, 5, 1}>
s2 = Set.new([5,2,1,7])
s2 # #<Set: {5, 2, 1, 7}>
s1 == s2 # true

การเข้าถึงดัชนีหรือคีย์ที่ไม่มีอยู่

ในไพธอนถ้าพยายามเข้าถึงดัชนีที่ไม่มีอยู่ในลิสต์หรือคีย์ที่ไม่มีอยู่ในดิกชันนารีจะเกิดข้อผิดพลาด

# python
a = [5,6]
a[3] # IndexError: list index out of range
h = {'ก': 1, 'ข': 2}
h['ค'] # KeyError: 'ค'

แต่อาเรย์และแฮชในรูบีถ้าแทนตัวที่ไม่มีก็แค่ได้ nil แต่ไม่เกิดข้อผิดพลาด

# ruby
a = [5,6]
a[3] # nil
h = {"ก"=>1,"ข"=>2}
h["ค"] # nil

อย่างไรก็ตาม ดิกชันนารีไพธอนสามารถใช้ .get แทนได้ กรณีนี้จะให้ผลเหมือนแฮชในรูบี คือถ้าไม่มีก็ให้ None

# python
h.get('ค') # None

การเพิ่มสมาชิกเข้าอาเรย์หรือลิสต์

ในไพธอน ปกติถ้าจะเพิ่มสมาชิกเข้าไปจะต้องใช้ append หรือ extend หรือ +=[]

# python
a = [7,8]
a += [0]
a.append(0)
a.extend([0])
a # [7, 8, 0, 0, 0]

ส่วนในรูบีอาจใช้ push หรือ concat หรือ +=[] หรือ <<

# ruby
a = [7,8]
a += [0]
a.push(0)
a.concat([0])
a << 0
a # [7, 8, 0, 0, 0, 0]

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

# ruby
a = [0,1]
a[6] = 9
a # [0, 1, nil, nil, nil, nil, 9]

ในไพธอนถ้าแทนตำแหน่งที่ไม่มีอยู่จะเกิดข้อผิดพลาด จึงทำแบบนี้ไม่ได้

# python
a = [0,1]
a[6] = 9 # IndexError: list assignment index out of range

อย่างไรก็ตาม ในรูบีกรณีที่ใช้ดัชนีเป็นค่าลบก็ไม่สามารถป้อนค่าได้เหมือนกัน

# ruby
b = [0,1,2]
b[-4] # nil
b[-4] = 4 # IndexError (index -4 too small for array; minimum: -3)

การเข้าถึงสมาชิกในลิสต์หรืออาเรย์ทีละหลายตัว

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

# python
a = list(range(10,20))
a # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
a[3:5] # [13, 14]

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

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

# ruby
a = (10..19).to_a
a # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
a[3,5] # [13, 14, 15, 16, 17]
a[3..5] # [13, 14, 15]
a[3...5] # [13, 14]

ถ้าหากตัวหน้ามากกว่าตัวหลัง ในไพธอนจะเกิดข้อผิดพลาด

# python
a[4,2] # TypeError: list indices must be integers or slices, not tuple

แต่ในรูบีจะแค่ได้อาเรย์เปล่า

# ruby
a[4..2] # []
a[4...2] # []

สามารถละตัวหน้าหรือตัวหลังได้ ถ้าละตัวหน้าจะหมายถึงไล่ตั้งแต่ตัวแรก ถ้าละตัวหลังจะหมายถึงไล่จนถึงสุดท้าย

ในไพธอนทำแบบนี้ได้ไม่ว่าจะในเวอร์ชันไหน

# python
a[3:] # [13, 14, 15, 16, 17, 18, 19]
a[:5] # [15, 16, 17, 18, 19]

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

# ruby 2.6
a[3...] # [13, 14, 15, 16, 17, 18, 19]
a[..5] # [10, 11, 12, 13, 14, 15]

อย่างไรก็ตาม ไพธอนมีวิธีการใช้ที่ยืดหยุ่นกว่า ซึ่งรูบีไม่สามารถทำได้ คือกำหนดขั้นให้โดดข้ามได้ ไม่ต้องเรียงติดกันเสมอไป

# python
a[1:6:2] # [11, 13, 15]
a[::3] # [10, 13, 16, 19]

การใช้ join เชื่อมสายอักขระ

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

ของไพธอน join จะถูกเรียกโดยสายอักขระที่เป็นตัวเชื่อม

# python
a = 'ก','ข','ค'
'-'.join(a) # ได้ 'ก-ข-ค'

ส่วนในรูบี join จะถูกเรียกจากตัวอาเรย์

# ruby
a = 'ก','ข','ค'
a.join('-') # ได้ "ก-ข-ค"