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

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

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

เนื้อหานี้ได้เขียนเป็นภาษาญี่ปุ่นลงในเว็บ qiita ด้วย
　→ 似ているようで違うMATLABとPythonの多少の擦れ違い



แถวลำดับเริ่มที่ 0 หรือว่า 1

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

เลขชี้ลำดับของค่าภายในแถวลำดับของแมตแล็บนั้นเริ่มนับไล่จาก 1

ar = [5 6 7];
ar(1) % 5

ในขณะที่ไพธอนจะเริ่มจาก 0

ar = np.array([5,6,7])
print(ar[0]) # 5
print(ar[1]) # 6

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

นอกจากแมตแล็บแล้วก็ยังมีภาษาฟอร์แทรน, R, จูเลีย ที่เริ่มนับจาก 1 แต่ก็ต้องถือว่าเป็นส่วนน้อยอยู่ดี




ขอบเขตเวลาเข้าถึงสมาชักที่ลำดับเรียงกัน

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

แมตแล็บ

ar = [10 11 12 13 14];
ar(2:4) % 11 12 13

ในขณะที่ในไพธอนจะไม่รวมตัวสุดท้ายด้วย

ar = np.array([10,11,12,13,14])
print(ar[1:3]) # [11, 12]
print(ar[1:4]) # [11, 12, 13]

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




การแทนค่าเข้าไปยังลำดับที่ยังไม่มี

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

ar =  np.array([2,2,2])
ar[6] = 3 # IndexError: index 6 is out of bounds for axis 0 with size 3

แต่ในแมตแล็บนั้นถ้าหากเป็นการแทนค่าจะไม่เกิดข้อผิดพลาดอะไรขึ้น (แต่ถ้าแค่เข้าถึงเฉยๆไม่ได้แทนค่าก็เกิดข้อผิดพลาดเหมือนกัน)

ar = [2 2 2];
ar(6) = 3 % ได้ [2 2 2 0 0 3]

ที่จริงในภาษารูบีก็เป็นแบบนั้น ถ้าแค่นี้อาจจะไม่ได้แปลกอะไรเท่าไหร่

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

ara(4) = 5 % กลายเป็น [0 0 0 5]

หรือแม้แต่กรณีกลายมิติก็เกิดขึ้นได้

arb(3,4) = 3

ได้

     0     0     0     0
     0     0     0     0
     0     0     0     3

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




แทนค่าแล้วเป็นการคัดลอกหรือว่าแค่ใช้ข้อมูลร่วม

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

ar1 = [1 2];
ar2 = ar1;
ar1(1) = 3;
disp(ar1) % 3 2
disp(ar2) % 1 2

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

ar1 = np.array([1,2])
ar2 = ar1
ar1[0] = 3
print(ar1) # [3, 2]
print(ar2) # [3, 2]

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

การที่แมตแล็บไม่จำเป็นต้องมาคอยระวังตรงนี้ด้วยจึงถือว่าดีมากเลย นอกจากแมตแล็บแล้วก็มี PHP และ สวิฟต์ ด้วย แต่ว่าภาษาที่เป็นแบบนี้ถือเป็นส่วนน้อย




การคูณหารและยกกำลังแถวลำดับ

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

ปกติแล้วในไพธอนนั้นถ้าเอาแถวลำดับมาคูณกันก็จะเป็นการเอาสมาชิกภายในนั้นมาคูณกันทีละตัว

ar1 = np.array([[1,2],
                [3,4]])
ar2 = np.array([[5,6],
                [7,8]])
print(ar1*ar2)

ได้

[[ 5 12]
 [21 32]]

แบบนี้เรียกว่า ผลคูณอาดามาร์ โดยทั่วไปแล้วเข้าใจง่ายและดูจะตรงกับความรู้สึกคนทั่วไป

แต่ว่าในแมตแล็บการคูณกันของแถวลำดับนั้นจะถือว่าเป็นการคูณแบบเมทริกซ์ ก็คือเป็นผลคูณภายใน

ar1 = [1 2
       3 4];
ar2 = [5 6
       7 8];
ar1*ar2

ได้

    19    22
    43    50

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

ถ้าต้องการได้ผลคูณอาดามาร์เหมือนทั่วไปก็ต้องเติมจุด . เข้าไป กลายเป็น .* แทน

ar1.*ar2

ได้

     5    12
    21    32

ที่เป็นแบบนี้ก็เพราะว่าแมตแล็บจะถือว่าแถวลำดับสองมิติเป็นเมทริกซ์ ชื่อแมตแล็บเองจริงๆก็ย่อมากจาก MATrix LABoratory ดังนั้นจะเห็นว่าให้ความสำคัญกับการคำนวณเมทริกซ์

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

ar1/ar2

ได้

    3.0000   -2.0000
    2.0000   -1.0000

ถ้าไม่ต้องการให้เป็นแบบนั้นก็อย่าลืมเติม . ไปเป็น ./ ด้วย

ar1./ar2

ได้

    0.2000    0.3333
    0.4286    0.5000

นอกจากนั้นแล้วการยกกำลังก็เช่นกัน ถ้าเขียน A^n จะกลายเป็นการเอา A มาทำการคูณภายใน n ครั้งไป ดังนั้นถ้าต้องการแค่ให้แต่ละตัวยกกำลังแยกันไปก็ต้องเติม . ไปเป็น .^

ar = [5 5
      3 3];
ar^2
ar.^2

ได้

    40    40
    24    24

    25    25
     9     9

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




เมื่อเอาแถวลำดับหลายมิติมาเรียงในมิติเดียว

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

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

ar = [1 1 1
      2 2 2];
ar(:)' % 1 2 1 2 1 2

แต่ในไพธอนจะไล่ในแนวนอนก่อน โดยเริ่มจากทุกตัวในแถวบนสุดแล้วก็ไล่ลงไป

ar = np.array([[1,1,1],
               [2,2,2]])
print(ar.ravel()) # [1 1 1 2 2 2]

ฉะนั้นต้องระวังให้ดี ไม่เช่นนั้นจะเผลอเรียงพลาดได้ผลที่ต่างจากที่คิดไว้




การเข้าถึงแถวลำดับหลายมิติโดยละการระบุบางแกน

ในไพธอนนั้นเวลาเข้าถึงสมาชิกภายในด้วยการใส่เลขตัวเดียวใน [ ] จะหมายถึงการเอาค่าทั้งหมดในแกนแรกสุด เช่นถ้าเป็นสองมิติการเขียน [i]ก็จะหมายถึงเอาแถวแนวตั้งลำดับที่ i-1 จากบน

ar = np.array([[3,6,4],
               [4,4,4],
               [5,5,7]])
print(ar[0]) # [3 6 4]
print(ar[1]) # [4 4 4]
print(ar[6]) # IndexError: index 6 is out of bounds for axis 0 with size 3

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

ar = [3 6 4
      4 4 4
      5 5 7];

ar(1) % 3
ar(2) % 4
ar(6) % 5

ถ้าต้องการให้ได้ผลแบบไพธอนต้องใส่ : ไปด้วย เพื่อระบุว่าเราจะเอาทั้งหมดทุกตัวตามแกนนั้น

ar(1,:) % 3 6 4
ar(2,:) % 4 4 4

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




กลายเป็นเถวลำดับจตุรัสโดยไม่ตั้งใจ

ในแมตแล็บและไพธอนมีฟังก์ชันเช่น zeros ones randn ซึ่งสามารถสร้างแถวลำดับที่มีขนาดตามที่ระบุได้อย่างง่ายดาย

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

print(np.ones(3)) # ได้ [1. 1. 1.]
print(np.random.randn(3)) # ได้ [ 0.07970309 -1.28657592 -1.48870568]

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

disp(ones(3))
disp(randn(3))

ได้

    1     1     1
    1     1     1
    1     1     1

    0.5067   -0.7374    0.2785
    2.7564    0.7306   -1.2212
    1.0693    0.0502   -0.2428

เมื่อใช้วังวน for กับแถวลำดับ

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

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

ar = np.array([[5,6,7],
               [7,8,9]])

for a in ar:
    print(a)

ได้

[5 6 7]
[7 8 9]

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

ar = [5 6 7
      7 8 9];

for a = ar
  disp(a)
end

ได้

     5
     7

     6
     8

     7
     9

เมื่อรับค่าจากฟังกชันที่มีค่าคืนกลับหลายตัว

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

function [a,b,c] = fcn()
    a = 1;
    b = 2;
    c = 3;
end

[x,y,z] = fc

ได้

x =
     1

y =
     2

z =
     3

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

[x,y] = fc

ได้

x =
     1

y =
     2

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

fc

ได้

x =
     1

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

def fcn():
    return 1,2,3

x,y = fcn() # ValueError: too many values to unpack (expected 2)

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

x = fcn()
print(x) # (1, 2, 3)

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

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



สายอักขระที่สร้างจาก " " และ ' '

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

โดยทั่วไปแล้วในหลายกรณีทั้ง ๒ ชนิดนี้ใช้แทนกันได้ ไม่ต่างกัน แต่ก็มีบางกรณีที่ต่างกัน ต้องระวังการใช้ให้ดี

เช่นสายอักขระที่สร้างจาก " " นั้นจะใกล้เคียงกับสายอักขระในภาษาอื่นๆรวมถึงไพธอนมากกว่า เช่นสามาระนำมาบวกกันเพื่อต่อกันได้ อย่างที่ในไพธอนทำแบบนี้

a = 'อะฮะฮะ'
b = 'บะนะนะ'
print(a+b) # อะฮะฮะบะนะนะ

ในแมตแล็บถ้าสร้างสายอักขระโดยใช้ " " ก็ทำแบบนี้ได้

a = "อะฮะฮะ";
b = "บะนะนะ";
disp(a+b) % อะฮะฮะบะนะนะ

แต่ว่าถ้าสร้างโดยใช้ ' ' ก็จะได้ผลออกมาแปลกๆแบบนี้

a = 'อะฮะฮะ';
b = 'บะนะนะ';
disp(a+b) % 7239        7264        7239        7264        7239        7264

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

พอนำมาบวก ชนิดของข้อมูลก็เปลี่ยนไปด้วย

class(a) % 'char'
class(a+b) % 'double'

ไม่ใช่แค่นั้น เอามาลบคูณหารก็ทำได้ด้วย

disp(a-b) % -46 5 5
disp(a.*b) % 153189600 153673206 153673206

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



สถานะของเลขจำนวนเชิงซ้อน

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

ในไพธอน

type(1.) # float
type(1j) # complex

ส่่วนในแมตแล็บนั้นสร้างยังไงก็เป็น double เหมือนกัน

class(1.) % 'double'
class(1j) % 'double'

เพราะฉะนั้นเวลาคำนวณเช่นเมื่อหารากที่สองก็แสดงเป็นจำนวนเชิงซ้อนได้เลย

sqrt(-3) % 0.0000 + 1.7321i

แต่ว่าถ้าในไพธอนอาจจำเป็นต้องเปลี่ยนเป็นจำนวนเชิงซ้อนเองก่อน ไม่งั้นอาจไม่ได้ผลตามที่ต้องการ ทั้งนี้ก็ขึ้นอยู่กับวิธีการคำนวณ เช่นถ้าใช้ฟังก์ชัน sqrt ของ numpy จะได้ nan

print(np.sqrt(-3)) # nan
print(np.sqrt(complex(-3))) # 1.7320508075688772j

หรือถ้าใช้มอดูล math จะเกิดข้อผิดพลาด

from math import sqrt
print(sqrt(-3)) # ValueError: math domain error

การทำงานของ sprintf

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

แต่ว่า sprintf ในแมตแล็บก็มีบางส่วนที่ให้ผลต่างไปจากในไพธอน จึงต้องระวังด้วย เช่นเมื่อใช้ %s ในไพธอนไม่ว่าจะข้อมูลอะไรก็แทนลงใน %s ได้ ดังนั้นอะไรๆก็ใส่ %s แบบนี้สะดวกดี

'x%3sx'%1 # 'x  1x'
'x%5sx'%1.1 # 'x  1.1x'

แต่ว่าในแมตแล็บถ้าใช้แบบนั้นจะเกิดการแสดงผลแปลกๆ ไม่เป็นไปตามที่ต้องการ

sprintf('x%3sx',1) % 'x  x'
sprintf('x%5sx',1.1) % 'x1.100000e+00x'

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

นอกจากนี้ในไพธอนถ้าใช้ %x แต่พยายามแทนเลขทศนิยมก็จะเกิดข้อผิดพลาดได้

'%x'%1.1 # TypeError: %x format: an integer is required, not float

แต่ในแมตแล็บจะไม่เกิดข้อผิดพลาด แต่จะแสดงผลไม่ตรงตามที่ต้องการอยู่ดี

sprintf('%x',1.1) % '1.100000e+00'

วงเล็บปีกกา { }

ในไพธอนนั้นวงเล็บปีกกา { } ใช้เพื่อสร้าง set

c = {1,2,3}
type(c) # set

แต่ในแมตแล็บนั้น { } ใช้เพื่อสร้างแถบลำดับ cell

c = {1 2 3};
class(c) % 'cell'

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





(ที่มาของภาพ https://realpython.com/matlab-vs-python)