ในภาษาไพธอนมีชนิดของข้อมูลอยู่หลายชนิดด้วยกัน โดยอาจแบ่งใหญ่ๆออกเป็น ๒ กลุ่มคือ ข้อมูลแบบเดี่ยว กับ ข้อมูลแบบกลุ่ม

ข้อมูลแบบเดี่ยวนั้นได้แก่ข้อมูลที่เป็นค่าตัวเลขต่างๆ ได้แก่ จำนวนเต็ม (int), จำนวนจริง (float) และจำนวนเชิงซ้อน (complex) นอกจากนี้ยังมีข้อมูลอีกชนิดหนึ่งซึ่งเก็บค่าความจริงเท็จทางตรรกศาสตร์ เรียกว่าบูล (bool)

ข้อมูลแบบกลุ่มนั้นได้แก่ข้อมูลที่เป็นสายอักขระ (str) และข้อมูลชนิดที่เป็นรายการของข้อมูลชนิดอื่นอีกที ได้แก่ ลิสต์ (list), ทูเพิล (tuple), ดิกชันนารี (dict), เซ็ต (set), เรนจ์ (range) เป็นต้น



ชนิดของข้อมูล

ตารางสรุปชนิดของข้อมูลหลักๆ

ชื่อย่อ	ความหมาย	ตัวอย่าง
int	จำนวนเต็ม	12345
float	จำนวนจริง	123.45
complex	จำนวนเชิงซ้อน	123+45j
bool	บูล	True
str	สายอักขระ	'12345'
list	ลิสต์	[1,2,3,4,5]
tuple	ทูเพิล	(1,2,3,4,5)
set	เซ็ต	{1,2,3,4,5}
dict	ดิกชันนารี	{'ก':1,'ข':2,'ค':3,'ง':4,'จ':5}
range	เรนจ์	range(1,6)

จำนวนเต็ม int

คือข้อมูลที่เป็นตัวเลขที่ไม่มีจุดทศนิยม เช่น

1
300
32549

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

***ในไพธอน 2 มีจำนวนเต็มอยู่ ๒ ชนิด คือ int กับ long แต่ในไพธอน 3 จึงยุบลงมาเหลือชนิดเดียวคือ int
>>> อ่านรายละเอียด



จำนวนจริง float

คือข้อมูลที่เป็นตัวเลขที่ประกอบด้วยจุดทศนิยม เช่น

129.3
6.61

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

111.00000

จำนวนจริงในที่นี้เป็นจำนวนที่อยู่ในรูปทศนิยมแบบจุดลอย (floating point) หรือมักเรียกว่า float ซึ่งหมายถึงเลขทศนิยมที่อยู่ในรูปของจำนวนจริงตั้งแต่ 0 ถึงไม่เกิน 10 คูณด้วย 10 ยกกำลังเท่าไหร่ๆ เช่น $3.11×10^{-8}$ , $1.293×10^2$

ข้อมูลชนิดนี้ปกติแล้วจะถูกเก็บในรูปของจำนวนที่ใช้ e เช่น

3.11e-8 # เท่ากับ 0.0000000311
1.293e2 # เท่ากับ 129.3

วิธีการเขียนแบบนี้ใช้บ่อย และสะดวกในกรณีที่เลขเป็นจำนวนใหญ่มากเป็นล้านหรือเล็กมากจนมี 0 หลังทศนิยมหลายตัว



จำนวนเชิงซ้อน complex

คือข้อมูลที่ประกอบด้วยส่วนจริงและส่วนจินตภาพ โดยส่วนจินตภาพจะเขียนโดยต่อท้ายด้วย j เช่น

1+2j
5.32j

ต่อให้ตัวเลขนำหน้า j เป็น 0 ซึ่งหมายถึงส่วนจินตภาพเป็น 0 แต่ถ้ามีการเขียน 0j อยู่ก็ยังถือเป็นจำนวนเชิงซ้อน

1+0j

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



บูล bool

ข้อมูลชนิดบูลคือข้อมูลที่มีค่าเป็นเพียง ๒ แบบ คือจริงกับเท็จเท่านั้น ซึ่งเขียนแทนด้วย

True
False

โดยให้ระวังว่าจำเป็นต้องขึ้นต้นด้วยตัวพิมพ์ใหญ่เท่านั้น

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



สายอักขระ str

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

'คนที่ไม่ทำงานก็จะไม่มีกิน!!'
"あのチビは調子に乗りすぎた。いつか私が然るべき報いを"

แม้ว่าจะเป็นตัวเลข แต่หากถูกคร่อมด้วยเครื่องหมายคำพูดก็จะถือว่าเป็นสายอักขระ เช่น

"111111111111111111111111111111"
'๑๒๙.๓'  

รายละเอียดเกี่ยวกับเรื่องของสายอักขระจะเขียนถึงอย่างละเอียดในบทที่ ๑๐ และ บทที่ ๑๑



ข้อมูลชนิดที่เป็นรายการของข้อมูลชนิดอื่น

เป็นกลุ่มข้อมูลที่ประกอบไปด้วยข้อมูลชนิดอื่นมารวมกันอยู่ด้วยกันเป็นองค์ประกอบย่อย

ข้อมูลกลุ่มนี้ได้แก่ ลิสต์ (list), ทูเพิล (tuple), ดิกชันนารี (dict), เซ็ต (set), เรนจ์ (range), ฯลฯ ในบทนี้จะยังไม่กล่าวถึงโดยละเอียด แต่จะเริ่มพูดถึงในบทที่ ๘



การใช้ตัวแปร

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

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

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

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

ชื่อตัวแปรในทางภาษาคอมพิวเตอร์มักจะนิยมใช้ตัวอักษรแทน เช่นเดียวกับตัวแปรทางคณิตศาสตร์

c = 299792458
pi = 3.14159265359

แต่ว่าบางทีก็อาจจะเป็นชื่อยาว

constante_gravitationnelle = 6.67408e-11
Lorem_ipsum = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua...'

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

อย่างไรก็ตามก็มีชื่อที่ตั้งได้และไม่ได้ จำเป็นต้องเข้าใจกฏเกณฑ์ในการตั้งชื่อ



การกำหนดชนิดของตัวแปร

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

• หากเป็นตัวเลขที่ไม่มีทศนิยม เช่น 2, 47839, 589837549829 จะเป็นตัวแปรชนิดจำนวนเต็ม
• หากเป็นตัวเลขที่มีทศนิยม เช่น 3.1, 0.0003894 จะเป็นจำนวนจริง แม้แต่จำนวนที่ในทางคณิตศาสตร์เป็นจำนวนเต็ม ก็กำหนดให้เป็นตัวแปรชนิดจำนวนจริงได้โดยใส่จุดต่อท้าย เช่น 1.0 หรืออาจเขียนแค่ 1. เฉยๆก็ได้
• หากมีเครื่องหมายคำพูดคร่อมจะเป็นตัวแปรชนิดสายอักขระ เช่น 'กขค', '131'
• True หรือ False เป็นตัวแปรชนิดบูล

เป็นต้น

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



หลักการตั้งชื่อตัวแปร

• ห้ามมีการเว้นวรรคในชื่อ ต้องเป็นอักษรติดกัน
• ห้ามใช้สัญลักษณ์พิเศษ เช่น ~ ! @ # $ % ^ & * ( ) - = + ` \ | < > ? , . / : ; ' " [ ] { }
• สัญลักษณ์ที่ใช้ได้มีแค่สัญลักษณ์ขีดล่าง _ มักเอาไว้ใช้แทนการเว้นวรรคเนื่องจากชื่อตัวแปรห้ามมีเว้นวรรค เช่น dot_A แทนที่จะเป็น dot A
• สามารถประกอบด้วยตัวเลขได้ เช่น ak47, AKB48, nogisaka46
• แต่ตัวเลขต้องไม่ใช่ตัวขึ้นต้น เช่น 07show แบบนี้ไม่ได้
• อักษรโรมันตัวพิมพ์เล็กและพิมพ์ใหญ่ถือเป็นคนละตัวกัน เช่น PYTHON, PyThOn, Python, python ถือเป็นตัวแปรคนละตัวกันหมด
• ห้ามซ้ำกับคำสงวน เพราะคำเหล่านั้นมีความหมายพิเศษในภาษาไพธอน ซึ่งได้แก่

  and  as  assert  break  class
  continue  def  del  elif  else
  except  exec  finally  for  from
  global  if  import  in  is
  lambda  nonlocal  not  or  pass
  raise  return  try  while  with
  yield  True  False  None

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

เพียงแต่ว่าภาษาโปรแกรมโดยปกติแล้วจะไม่สามารถใช้อักษรอื่นนอกจากอักษรโรมัน ๒๖ ตัวหลักในการตั้งชื่อ แต่ว่าในไพธอน 3 นั้นสามารถตั้งชื่อตัวแปรด้วยอักษรอะไรก็ได้ เช่น

ความเร็วแสงในสูญญากาศ = 299792458
ดัชนีหักเหแสงของน้ำ = 1.33
ความเร็วแสงในน้ำ = ความเร็วแสงในสูญญากาศ / ดัชนีหักเหแสงของน้ำ
print(ความเร็วแสงในน้ำ)

ผลลัพธ์

225407863.15789473

แต่ก็เขียนแบบนี้ได้แค่ในไพธอน 3 เท่านั้น ถ้าเขียนแบบเดียวกันในไพธอน 2 โปรแกรมจะขัดข้อง รวมทั้งภาษาอื่นๆส่วนใหญ่ก็ใช้แบบนี้ไม่ได้
>>> อ่านเพิ่มเติมเรื่องความต่างระหว่าง 3 และ 2

ดังนั้นไม่ค่อยแนะนำให้ใช้อักษรไทยสักเท่าไหร่ หากอยากใช้ภาษาไทยบางทีใช้การเขียนทับศัพท์เอาอาจจะดีกว่า
>>> หลักการเขียนทับศัพท์แบบมาตรฐาน



การย้ายและคัดลอกข้อมูลระหว่างตัวแปร

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

a = 129.3
b = a

ในที่นี้จะเห็นว่าในบรรทัดแรก a ถูกป้อนค่าให้เท่ากับ 129.3 ซึ่งเป็นการป้อนค่าโดยตรง

แต่ในบรรทัดที่สอง b ถูกป้อนค่าโดยรับค่าจาก a นั่นก็คือ b จะได้ค่าเป็นเท่ากับที่ a มีอยู่ในตอนนั้น คือเป็น 129.3

การเขียนแบบนี้ต่างจากการเขียนสมการทางคณิตศาสตร์ ต้องพยายามไม่สับสน

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

หากสลับข้างของสมการความหมายก็จะเปลี่ยนทันที a = b จะหมายความว่า นำค่าของ b ไปป้อนให้กับ a

หรือกรณีที่ทำกับตัวเลขก็สลับไม่ได้เช่นกัน ถ้าลอง

129.3 = a

จะได้

SyntaxError: can't assign to literal

นั่นเพราะเราไม่สามารถนำค่าของตัวแปรมาป้อนให้กับตัวเลขได้

หรือจะเปลี่ยนเป็นตัวเลขหรือตัวหนังสืออยู่ซ้ายก็จะได้ผลขัดข้องแบบเดียวกัน

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

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

a,b,c = 158,162,165

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

อย่างไรก็ตาม ถ้าจำนวนตัวแปรกับตัวเลขมีไม่เท่ากัน เช่น

a,b,c = 158,162,165,171

ก็จะได้

ValueError: too many values to unpack

การเขียนทับตัวแปร

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

a = 500
print(a)
a = 0.002
print(a)

ผลลัพธ์จะได้

500
0.002

จะเห็นว่าตอนแรก a ถูกป้อนให้มีค่า 500 แต่ตอนหลังใส่ค่าลงไปใหม่ก็เปลี่ยนเป็น 0.002

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

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

a = 20
a = a+2

จะได้ว่า a มีค่าเพิ่มขึ้นอีก 2 เป็น 22

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



การสลับข้อมูลในตัวแปร

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

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

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

ตัวอย่างการสลับข้อมูลระหว่างตัวแปร

a = 23
b = 32
c = a
a = b
b = c
print(a,b) # ได้ 32 23

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

a,b = b,a

เพียงเท่านี้ค่าของตัวแปรใน a กับ b ก็สลับกัน

หรือจะสลับจำนวนมากกว่านั้นก็ได้เช่นกัน

a,b,c = c,a,b

ข้อมูลจะถูกย้ายจากตัวแปรทางขวาไปยังตัวแปรทางซ้ายโดยเทียบแหน่งตามลำดับ



การลบตัวแปร

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

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

ดังนั้นบางครั้งหากไม่ต้องการใช้ตัวแปรไหนแล้วก็อาจจะลบตัวแปรทิ้งไป

การลบตัวแปรทิ้งทำได้ด้วยคำสั่ง del

a = 100
del a
print(a) # ได้ NameError: name 'a' is not defined

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



รู้จักกับคำว่าออบเจ็กต์และคลาส

มีเรื่องหนึ่งที่อาจต้องกล่าวเกริ่นไว้ก่อนแม้ว่าอาจจะเป็นเรื่องเข้าใจยากและ อาจทำให้งงในตอนแรก นั่นคือเรื่องที่ภาษาไพธอนเป็นภาษาที่ใช้แนวคิดการเขียนโปรแกรมเชิงวัตถุ (object-oriented programming, ย่อว่า OOP)

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

คำว่า "วัตถุ" ในภาษาอังกฤษใช้คำว่าออบเจ็กต์ (object) โดยทั่วไปในไทยนิยมเรียกทับศัพท์มากกว่าที่จะเรียกว่าวัตถุไปตรงๆ

ในแนวคิดนี้ ข้อมูลชนิดต่างๆก็ถือเป็นอ็อบเจ็กต์ชนิดต่างๆ โดยเป็นออบเจ็กต์ชนิดข้อมูล ซึ่งก็แบ่งย่อยออกไปอีกตามชนิดข้อมูล

เช่น ข้อมูลชนิดจำนวนเต็ม ก็ถือเป็นออบเจ็กต์ชนิดจำนวนเต็ม และข้อมูลชนิดสายอักขระ ก็คือเป็นออบเจ็กต์ชนิดสายอักขระ

รวมถึงฟังก์ชันเองก็ถือเป็นออบเจ็กต์ชนิดหนึ่งด้วย

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

"ชนิด" ของออบเจ็กต์นั้นมักเรียกว่าคลาส (class) ความจริงแล้วคำว่าคลาสแปลตรงๆควรจะหมายถึง "ชั้น" แต่ในทางการเขียนโปรแกรมเชิงวัตถุแล้วเป็นคำที่มักใช้เรียกแทนชนิดของออบเจ็กต์

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

แนวคิดนี้จะต่างจากบางภาษาที่ใช้แนวคิดการเขียนโปรแกรมเชิงกระบวนการ (procedural programming) เช่นภาษาซีซึ่งคนส่วนใหญ่คุ้นเคยกันดีมาเป็นเวลานาน

แนวคิดการเขียนโปรแกรมเชิงวัตถุนั้นค่อนข้างใหม่กว่า แต่ก็เป็นที่นิยมในภาษาที่ถูกคิดขึ้นมาใหม่ๆในยุคหลังๆ ภาษาซีเองก็ถูกพัฒนากลายเป็นซี++ โดยเพิ่มแนวคิดเชิงวัตถุเข้าไป



การหาชนิดของข้อมูล

ชนิด (หรือคลาส) ของข้อมูลสามารถตรวจสอบได้โดยพิมพ์ type ตามด้วยข้อมูลที่ต้องการหาชนิดใส่อยู่ในวงเล็บ () เช่น

type(3) # ได้ int
type(3.0) # ได้ float
type(3+0j) # ได้ complex
type('3') # ได้ str
type(True) # ได้ bool

อนึ่ง จะเห็นความแตกต่างระหว่างการพิมพ์ลงในเชลเฉยๆโดยไม่ใส่คำสั่ง print กับใส่คำสั่ง print

ถ้าใส่ print จะเห็นคำว่า class โผล่ขึ้นมาด้วย เช่น

print(type(3.0)) # ได้ <class 'float'>

การแปลงชนิดของข้อมูล

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

ตัวอย่างการเปลี่ยนค่าระหว่างจำนวนจริงและจำนวนเต็ม

float(3) # ได้ 3.0
int(3.9) # ได้ 3 ***เศษถูกปัดลงเสมอ
int(-4.3) # ได้ -4 ***สำหรับจำนวนลบจะถูกปัดขึ้น  

สายอักขระที่เก็บตัวเลขก็สามารถเปลี่ยนเป็นจำนวนตัวเลขได้ เช่น

float('2.16') # ได้ 2.16
int('666666') # ได้ 666666
float('3.6e10') # ได้ 36000000000.0
int(float('191.919191')) # ได้ 191 ***สายอักขระที่มีทศนิยมจะแปลงเป็น int โดยตรงไม่ได้ต้องแปลงเป็น float ก่อน  

ข้อมูลชนิดบูลสามารถแปลงเป็นตัวเลขได้ โดย True เป็น 1 ส่วน False เป็น 0

int(True) # ได้ 1
int(False) # ได้ 0

ในทางกลับกันตัวเลขก็สามารถแปลงเป็นข้อมูลชนิดบูลได้เช่นกัน เช่น bool(1) ก็จะได้เป็น True

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

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

***แต่ในไพธอน 2 ไม่สามารถทำได้
>>> อ่านรายละเอียด

ตัวอย่าง

float('๑๗๖๒.๓๖๒') # เลขไทย 1762.362
float('໓໕໙໖໘໗.໒') # เลขลาว 359687.2
float('៩១៨.៩៥') # เลขเขมร 918.95
int('၃၆၅၇၂၁၀၈') # เลขพม่า 36572108
int('໖၇៩๖8၃៩໒๒0') # ปนกันหลายชนิด 6796839220

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

str(5.6e-3) # ได้ '0.0056'
str(0.0000003794) # ได้ '3.794e-07'
str(1.0+1.0j) # ได้ '(1+1j)'

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

ส่วนเลขจีน 一二三四五六七八九十百千万 ถือว่าเป็นตัวหนังสือจึงไม่สามารถแปลงเป็นตัวเลขได้



สรุปเนื้อหา

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



อ้างอิง