โพสต์24 ต.ค. 2553, 0:53โดยWisit P.
[
อัปเดต 4 ก.พ. 2554, 18:43
]
พอดีไปเจอบทความหนึ่งเกี่ยวกับ เค้าอธิบายส่วนประกอบใน source code ของไพธอนว่า แต่ละ่ส่วนประกอบด้วยอะำไรบ้าง ซึ่งเค้าพยายามอธิบายเอาไว้ในหน้าเดียว เห็นว่ามีประโยชน์ ก็เลยอยากเอามาเผยแพร่ต่อ ลองเอาไปศึกษาดูครับ ว่าแต่ละคำสั่ง แต่ละฟังก์ชั่นของไพธอน มันอยู่ที่ไหนกันบ้างใน source code หนึ่ง
|
โพสต์17 ต.ค. 2553, 20:10โดยWisit P.
[
อัปเดต 4 ก.พ. 2554, 18:45
]
วันนี้ เราจะมาทดลองทำความรู้จักกับตัวแปร Dict ให้มากขึ้น ซึ่งถ้าหากเราสามารถเรียกใช้ method เหล่านี้ได้อย่างคล่องแคล่วแล้ว คาดว่า เพื่อนๆ คงจะเกิดไอเดีย มากมายในการเขียนโปรแกรมด้วยภาษาไพธอน ได้อีกเยอะแยะมากมายอย่างแน่นอน
เริ่มต้นด้วยการเรามาสร้างตัวแปร Dict กันก่อน เพื่อจะทดลอง ในที่นี้ เราสามารถสร้างตัวแปร Dict ได้ด้วยการกำหนดค่าตัวแปร ตาม syntax ของมัน หรือสร้างจากตัวแปรที่ mapping (Key, value) ไว้แล้ว ในแบบ List ก็ได้
Dictionary Syntax
รูปแบบการสร้างตัวแปร Dict
>>> MyInfo = {'name':'ple','age':33,'Address':'Korat'}
>>> type(MyInfo)
<type 'dict'>
สร้างตัวแปร List
>>> MyList = [('name','Mr.P'),('University','SUT')]
>>> type(MyList)
<type 'list'>
แล้วใช้คำสั่ง dict() เพื่อสร้างตัวแปร Dict
>>> d = dict(MyList)
>>> d
{'University': 'SUT', 'name': 'Mr.P'}
>>> type(d)
<type 'dict'>
เราก็จะได้ตัวแปร Dict จากการสร้างจากตัวแปร List
หรือสร้างโดยใช้รูปแบบนี้ก็ได้ d= dict(name='Mr.P',University='SUT') (บอกแล้ว ว่ามันเป็นภาษาที่ยืดหยุ่นจริงๆ )
Basic Dictionary Operations
โดยพื้นฐานแล้ว การทำงานกับตัวแปร Dict (Dictionary Operations) นั้น มีหลายวิธีมาก เช่น
การหาจำนวนคู่สมาชิกใน Dict เราใช้คำสั่ง len()
เพราะว่า MyInfo มีจำนวนสมาชิกที่จับคู่กันอยู่ 3 คู่
การแสดงค่า ที่สัมพันธ์กับ key ที่เราระบุ
>>> MyInfo['name']
'ple'
>>> MyInfo['age']
33
>>>
หรือแม้แต่การลบคู่สมาชิกในตัวแปร Dict เราก็สามารถทำได้ ด้วยคำสั่ง del
>>> del MyInfo['name']
>>> MyInfo
{'Address': 'Korat', 'age': 33}
ข้อควรจำ
- คีย์ในตัวแปร Dict ไม่ใช่จำนวนตัวเลข ถึงแม้ว่า มันมองดูแล้ว เหมือนจะใช่ แต่จริงๆแล้ว มันไม่ใช่
- เราสามรถแก้ไขค่าในคีย์ใดๆ ในตัวแปร Dict ไำด้ แต่ถ้ามันไม่มีคีย์นั้นอยู่ จะเป็นการสร้างคู่สมาชิกใหม่ในตัวแปร Dict แทน
สิ่งที่สำคัญอย่างแรกของของตัวแปรแบบ Dict ที่แตกต่างจากตัวแปร List ถึงแม้มันจะมีการจับคู่กับเป็นแบบ key ในลำดับสมาชิก แต่ตัวแปร List ไม่สามารถที่จะเพิ่มค่าลงไปในตัวแปร ที่ไม่มีลำดับ key นั้นอยู่ แต่ตัวแปร dict ทำได้ (พูดแล้วงง ดูตัวอย่างดีกว่า)
>>> x = []
>>> x[42] = 'Foobar''
File "<interactive input>", line 1
x[42] = 'Foobar''
^
SyntaxError: EOL while scanning single-quoted string
error เห็นๆ ถ้าเป็นตัวแปร List แต่ถ้าตัวแปรเป็น Dict หล่ะ
>>> x = {}
>>> x[42] = 'Foobar'
>>> x
{42: 'Foobar'}
ถึงแม้จะไม่มี key ที่ 42 อยู่ในตัวแปร Dict มันก็จะไม่ Error แต่จะเป็นการสร้างคู่สมาชิกใหม่ให้เลยทันที
มาดูตัวอย่างการนำตัวแปร Dict ไปใช้กันดีกว่า (อันนี้ ลอกเค้ามาเลย) เป็นตัวอย่างการประยุกต์เอาตัวแปร Dict ไปทำเป็น Database โดยเก็บชื่อคน แล้วก็ที่อยู่ และเบอร์โทรศัพท์ เอาไว้ให้ค้นหา
# A simple database
# A dictionary with person names as keys. Each person is represented as
# another dictionary with the keys 'phone' and 'addr' referring to their phone
# number and address, respectively.
people = {
'Alice': {
'phone': '2341',
'addr': 'Foo drive 23'
},
'Beth': {
'phone': '9102',
'addr': 'Bar street 42'
},
'Cecil': {
'phone': '3158',
'addr': 'Baz avenue 90'
}
}
# Descriptive labels for the phone number and address. These will be used
# when printing the output.
labels = {
'phone': 'phone number',
'addr': 'address'
}
name = raw_input('Name: ')
# Are we looking for a phone number or an address?
request = raw_input('Phone number (p) or address (a)? ')
# Use the correct key:
if request == 'p': key = 'phone'
if request == 'a': key = 'addr'
# Only try to print information if the name is a valid key in our dictionary:
if name in people: print "%s's %s is %s." % (name, labels[key], people[name][key])
ผลการรัน
เมื่อเราใส่ชื่อ Alice แล้วกดตัว p จะได้ผลลัพธ์
>>>
Alice's phone number is 2341.
เขียนไป เขียนมาชักจะเหนื่อยแหะ เรื่องของตัวแปร Dict ยังไม่หมดนะเนี่ย เหลืิอเยอะเลยหล่ัะ จะไหวไหมเนี้ย เอาน่าๆ ดูกันต่อ
อีกตัวอย่างหนึ่งที่น่าสนใจ ก็คือ เราสามารถส่งค่าของตัวแปร Dict เข้าไปในขั้นตอนการ print อันนี้ ผมไม่แน่ใจว่าเค้าเรียกว่าขั้นตอนอะไร คล้ายๆกับเราต้องการส่งค่าในตัวแปร เข้าไปใน printf("Hello, Mr. %s",name); ของภาษาซี ประมาณนี้ แต่เมื่อเป็นไพธอน เค้าก็สามารถทำได้เหมือนกัน แถมยังยืดหยุ่นกว่าอีก เรามาดูตัวอย่างการส่งค่าเข้าไปกัน
ในตัวอย่างนี้ เค้ามีตัวแปรที่เก็บค่า string ที่เป็น โค๊ด HTML แต่ว่า มันเป็นแค่ Template เท่านั้น โดยเค้าจะใส่เครื่องหมาย %(key)s ไว้ตามตำแหน่ง tag ที่เค้าต้องการให้มันเป็น dynamic code นั่นหมายความว่า เค้าสามารถใช้ code นี้ในการทำแม่แบบให้กับทุก page ได้ โดยใช้โค๊ดนี้ เพียงโค๊ดเดียว แล้วทำการส่งค่าเข้าไป ให้แตกต่างกัน
>>> template = '<html><head><title>%(title)s</title></head><body><h1>%(title)s</h1><p>%(text)s</p></body>'
>>> print template
<html><head><title>%(title)s</title></head><body><h1>%(title)s</h1><p>%(text)s</p></body>
>>> print template % data
<html><head><title>My Home Page</title></head><body><h1>My Home Page</h1><p>Welcome to my home page!</p></body>
Dictionary Methods
เมทธอดแรกที่เราจะได้เรียนรู้ นั่นก็คือ
เมทธอด clear เป็นเมทธอด ที่เอาไว้สำหรับล้างค่าสมาชิกในตัวแปร Dict ซึ่งชื่อมันก็บอกอยู่แล้ว ว่า clear ซึ่งเราสามารถเอาตัวแปรไปรับค่าที่มัน return มาได้ด้วย ซึ่งเมทธอดนี้ จะ return ค่า None มาให้ (ไม่รู้ จะเอาทำไม ) แล้วเราจะเอา เมทธอด clear ไว้ทำไร มาดูความแตกต่างของ 2 ตัวอย่างนี้ครับ
ตัวอย่างแรก เรา clear ค่าของตัวแปร dict โดยสร้างตัวแปร dict ค่าว่างๆ ทับลงไป
>>> x = {}
>>> y = x
>>> x['key'] = 'value'
>>> y
{'key': 'value'}
>>> x = {}
>>> x
{}
>>> y
{'key': 'value'}
ตัวอย่างที่สอง เรา clear ค่าโดยใช้เมทธอด clear
>>> x = {}
>>> y = x
>>> x['key'] = 'value'
>>> y
{'key': 'value'}
>>> x.clear()
>>> y
{}
เห็นความแตกต่างไหมครับ งงหล่ะสิ ผมก็งงเหมือนกัน 555+ ความหมายของมันก็คือ ทั้งตัวแปร x และ y อ้างไปถึงข้อมูล dictionary ที่เดียวกัน แต่เมื่อเราทำการ initial หรือกำหนดค่าว่างให้กับตัวแปร x จะไม่มีผลกับตัวแปร y แต่ถ้าเราเรียกใช้ method clear() เราจะพบว่าค่าในตัวแปร y ถูก clear ไปด้วยเหมือนกัน
เมทธอด copy ค่า dictionary ใหม่ โดยที่ได้ค่า key และ value เหมือนตัวที่มัน copy มาทุกประการ แล้วถ้าหากคุณทำการเปลี่ยนแปลงค่าในตัว copy จะไม่มีผลในตัวต้นฉบับ แต่ ถ้าคุณลบค่าในตัว copy ออกไป จะมีผลให้ตัวต้นฉบับ ค่าหายไปด้วยเช่นกัน (แปลกดีไหมหล่ะ)
>>> x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> y = x.copy()
>>> y['username'] = 'mlh'
>>> y['machines'].remove('bar')
>>> y
{'username': 'mlh', 'machines': ['foo', 'baz']}
>>> x
{'username': 'admin', 'machines': ['foo', 'baz']}
เพื่อหลีกเลี่ยงปัญหา เมื่อเวลาที่เราต้องการแก้ไขตัว copy แต่ไม่อยากให้ส่งผลถึงตัวต้นฉบับ เราสามารถเรียกใช้คำสั่ง deepcopy ซึ่งอยู่ใน module copy ได้
>>> from copy import deepcopy
>>> d = {}
>>> d['names'] = ['Alfred', 'Bertrand']
>>> c = d.copy()
>>> dc = deepcopy(d)
>>> d['names'].append('Clive')
>>> c
{'names': ['Alfred', 'Bertrand', 'Clive']}
>>> dc
{'names': ['Alfred', 'Bertrand']}
จะเห็นว่า เมื่อเราแก้ไข ตัว copy จะไม่ส่งผลถึงตัวต้นฉบับ เพราะตัว copy ถูกสร้างมาจากคำสั่ง deepcopy นั่นเอง
fromkeys เป็นเมทธอด ที่เอาไว้สร้างตัวแปร dict ซึ่งจะได้ค่า key ตาม parameter ที่ใส่เข้าไป แต่ค่า value ของตัวแปร dict จะมีค่าเป็น None ดูตัวอย่าง
>>> {}.fromkeys(['info1','info2'])
{'info1': None, 'info2': None}
หรือจะเรียกคำสั่งแบบนี้ก็ได้ (ซึ่งดูดีกว่า ดูเป็นมาตรฐาน OOP ดี)
>>> dict.fromkeys(['info1','info2'])
{'info1': None, 'info2': None}
แล้วถ้าเกิดเราไม่อยากให้ ค่้าเริ่มต้นมีค่าเป็น None หล่ะ เราจะกำหนดอย่างไร python ก็ยังมีคำตอบให้คุณเสมอ ดูตัวอย่าง
>>> dict.fromkeys(['info1','info2'],'Unknow')
{'info1': 'Unknow', 'info2': 'Unknow'}
มาถึง method สำคัญอีกตัวหนึ่ง ที่เห็นใช้บ่อยที่สุด แล้วปลอดภัยที่สุดในการอ้างถึงค่าในตัวแปร dict ซึ่งเป็นตัวที่ผมเห็นเค้าใช้บ่อยที่สุด
หากคุณจะต้องอ้างถึงค่าที่อยู่ในตัวแปร dict คุณสามารถทำได้โดย เพียงแค่ ระบุ key ที่ต้องการ เพียงเท่านี้ เราก็จะได้ค่าที่ต้องการออกมา
>>> d = {'name':'ple'}
>>> d['name']
'ple'
แล้วถ้าเกิด ในโปรแกรมของเรา มีการกระทำบางอย่างก่อนหน้านี้ ซึ่งมีผลทำให้ key 'name' หายไปหล่ะ โดยที่เราไม่ได้ทราบล่วงหน้ามาก่อน หรือคาดไม่ถึง จะเกิดอะไรขึ้น หากเราอ้างถึง key ตัวนั้น
>>> d.clear()
>>> d
{}
>>> d['name']
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
KeyError: 'name'
เกิด error ขึ้นสิครับ ที่หนักไปกว่านั้น โปรแกรมเราอาจจะหยุดทำงานได้ ปัญหานี้ เราสามารถป้องกันได้โดยใช้ method ที่ชื่อว่า get โดยเจ้า method ตัวนี้จะทำการดึงค่า value จาก key ที่เรากำหนด แต่ถ้าหากไม่เจอค่า key นั้นๆ มันก็จะ return ค่า None กลับมาให้เรา
หรือถ้าเราต้องการให้มัน return อย่างอื่นมาก็ได้ เช่น เราอาจให้มัน return เป็น error message มาให้ผู้ใช้ก็ได้ เช่น
>>> k = 'name'
>>> d.get(k,'Invalid key '+ k)
'Invalid key name'
เห็นไหมหล่ะ โปรแกรมเราดูดีขึ้นเยอะเลย หรือว่าเราจะเช็คว่ามี key นั้นอยู่ก่อนหรือเปล่า ก็สามารถทำได้ ด้วย method ที่ชื่อว่า has_key ดูตัวอย่างเลยหล่ะกัน
>>> d = {}
>>> d.has_key('name')
False
>>> d['name'] = 'Wisit'
>>> d.has_key('name')
True
items คือ คำสั่งอีกตัวหนึ่งที่เอาไว้ดึงค่าออกจาก dict โดยค่าที่ได้ออกมา จะกลายเป็นตัวแปรประเภท list
>>> d = {'title': 'My site', 'url': 'https://sites.google.com/site/pythonclassroom'}
>>> a = d.items()
>>> type(a)
<type 'list'>
>>> a
[('url', 'https://sites.google.com/site/pythonclassroom'),
('title', 'My site')]
>>> a[1]
('title', 'My site')
>>> a[0]
('url', 'https://sites.google.com/site/pythonclassroom')
เช่นเดียวกันกับเมทธอด values และ keys ที่เอาไว้ดึงค่า value และ ค่า key จากตัวแปร dictionary ค่าที่ได้ออกมาจะกลายเป็นตัวแปร list ดูตัวอย่างครับ
>>> d
{'title': 'My site', 'url': 'https://sites.google.com/site/pythonclassroom'}
>>> d.keys()
['url', 'title']
>>> d.values()
['https://sites.google.com/site/pythonclassroom', 'My site']
>>> v = d.values()
>>> type(v)
<type 'list'>
>>> k = d.keys()
>>> type(k)
<type 'list'>
แล้วถ้าหากเราต้องการดึงค่าออกมาจริงๆหล่ะ โดยให้ค่าที่ถูกดึงออกมาจากตัวแปร dict หายไปด้วย python ก็มีคำสั่งคล้ายๆกับภาษาอื่นๆ เพื่อนคงเคยได้ยิน นั่นคือ คำสั่ง pop สังเกตจากตัวอย่างครับ
>>> d = {'1':'one','2':'two','3':'three'}
>>> d
{'1': 'one', '2': 'two', '3': 'three'}
>>> d.pop('2')
'two'
>>> d
{'1': 'one', '3': 'three'}
>>>
คำสั่ง popitem ก็คล้ายๆคำสั่ง pop แต่ต่างกันตรงที่ คำสั่ง popitem จะดึงทั้ง key และ value ออกมาพร้อมกันเลยทีเดียว
>>> d
{'1': 'one', '3': 'three'}
>>> a = d.popitem()
>>> a
('1', 'one')
>>> d
{'3': 'three'}
แต่สิ่งหนึ่งที่ต้องระวังก็คือ คำสั่ง popitem มันจะ random คือ มันไม่สามารถที่จำกำหนดได้ ว่าเราจะเอาคู่ไหนออกมา
>>> d = {'1':'one','2':'two','3':'three','4':'four','5':'five'}
>>> d.popitem()
('1', 'one')
>>> d
{'2': 'two', '3': 'three', '4': 'four', '5': 'five'}
>>> d.popitem()
('3', 'three')
>>> d
{'2': 'two', '4': 'four', '5': 'five'}
>>>
จะเห็นว่า จู่ๆ มันก็ pop ค่า '3' ออกมาซะอย่างงั้น แทนที่จะเอา '2' ไปก่อน ก็อย่างที่บอก มัน random ครับ
คำสั่งต่อมา คือ setdefault คำสั่งนี้ มีบางอย่าง คล้ายๆคำสั่ง get แต่ต่างกันตรงที่ คำสั่ง setdefault จะเป็นการ set ค่า value ให้กับ key ที่เราระบุ แต่หากที่ key นั้น มีค่าอยู่แล้ว มันก็จะไม่ทำการ set ค่า value ใหม่ลงไปทับแต่อย่างไร (คล้ายๆ คำสั่ง get ตรงที่ระบุ key แล้ว ถ้ามันเจอว่ามีอยู่แล้ว ก็จะไม่ทำอะไร...คล้ายตรงไหนเนี้ย!!!) ดูตัวอย่าง ครับ
>>> d = {'1':'one','2':'two','3':'three','4':'four','5':'five'}
>>> d.setdefault('6','six')
'six'
>>> d
{'1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five', '6': 'six'}
>>>
>>> d.setdefault('1','First')
'one'
>>> d
{'1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five', '6': 'six'}
คำสั่งสุดท้าย ที่จะนำเสนอ นั่นก็คือ คำสั่ง update เป็นคำสั่งที่เอาไว้อัพเดทค่า value ในตัวแปร dictionary ด้วยค่าจากตัวแปร dictionary อีกตัวหนึ่ง หากค่า key ตรงกัน
>>> d = {'title':'Mr.','name':'Wisit P.','Position':'Engineer'}
>>> a = {'Posiotion':'Technician'}
>>> d.update(a)
>>> d
{'Posiotion': 'Technician',
'Position': 'Engineer',
'name': 'Wisit P.',
'title': 'Mr.'}
แต่ถ้า key ไม่ตรงกัน ก็จะไม่เกิดการ update ในตัวแปร d แต่อย่างใด
>>> b = {'Sex':'male'}
>>> d.update(b)
>>> d
{'Posiotion': 'Technician',
'Position': 'Engineer',
'Sex': 'male',
'name': 'Wisit P.',
'title': 'Mr.'}
จะเห็นว่า ตัวแปร dictionary นั้น มีลูกเล่นอีกหลากหลาย แล้วก็เป็นตัวแปรที่เค้าใช้กันบ่อยมากๆ ส่วนมาก จะพบเห็น เอาไว้สำหรับตั้งค่าเริ่มต้นต่างๆ แต่ถ้าต้องการแก้ไข หรืออ้างอิง หรือเปลี่ยนแปลงใดๆ เพื่อให้เหมาะสมกับงาน ณ ขณะนั้น เราก็สามารถกระทำได้อย่างง่ายดาย ลองๆไปหัดใช้ดูกันให้คล่องๆนะครับ
|
โพสต์27 ก.พ. 2553, 22:42โดยWisit P.
[
อัปเดต 4 ก.พ. 2554, 18:46
]
ความหมายที่แท้จริงของ string ในภาษาไพธอน นั้น อธิบายว่า " สตริง คือ ลำดับของตัวอักษรที่ถูกห่อหุ้มไว้ด้วยเครื่องหมาย single quote('...') หรือ double quote ("...") "
นี่เป็นตัวอย่างของ string
"How do you do?"
'My name is Mr.P'
"สวัสดี ประเทศไทย"
ไพธอนมีความสามารถในการนำสตริงมาต่อกัน ด้วยการนำสตริงแต่ละมาวางต่อกัน โดยเว้นช่องว่างไว้
a = "My name" ' is ' ' wisit '
print a
>>>
My name is wisit
ถ้าเรามีข้อมูลสตริงที่มีหลายๆ บรรทัด เราสามารถใช้เครื่องหมาย " \ " (backslash) ในการต่อสริงแต่ละบรรทัดเข้าด้วยกัน
msg = 'Python is a general-purpose high-level \
programming language.Its design philosophy \
emphasizes code readability '
print msg
>>>
Python is a general-purpose high-level programming language.Its design philosophy emphasizes code readability
หรือใช้ double quote 3 คู่
msg = """
Python supports multiple programming paradigms
(primarily object oriented, imperative, and functional)
and features a fully dynamic type system
and automatic memory management, similar to that of Perl,
Ruby, Scheme, and Tcl. Like other dynamic languages,
Python is often used as a scripting language".
"""
print msg
>>>
Python supports multiple programming paradigms
(primarily object oriented, imperative, and functional)
and features a fully dynamic type system
and automatic memory management, similar to that of Perl,
Ruby, Scheme, and Tcl. Like other dynamic languages,
Python is often used as a scripting language".
หากต้องการหาความยาวของ string ก็ไม่ยากครับ เราสามารถใช้คำสั่ง len() ได้เลย
print len(msg)
>>>
304
Escape Sequence คือรหัสพิเศษที่แทรกลงไปในค่าคงที่สตริง เพื่อใช้ควบคุมการแสดงผลของตัวอักษรในลักษณะต่างๆ โดยการเขียนจะต้องมีเครื่องหมาย \ (Back-Slash) นำหน้า รหัสควบคุมการแสดงผล
ในที่นี้เราต้องการให้แสดงประโยค ที่มีเครื่องหมายคำพูด " " (double quote) รวมอยู่ด้วย
print "\" You will never walk alone \""
>>>
" You will never walk alone "
นอกจากนี้ ยังมีรหัส Escape Sequence อีก ดูได้จากตาราง
ตารางรหัส Escape Sequence
| \n |
ขึ้นบรรทัดใหม่ |
| \' |
single quote |
| \" |
double quote |
| \\ |
backslash |
| \t |
แทปแนวนอน |
| \b |
backspace |
| \r |
Carriage return |
| \xhh |
มีค่าเท่ากับเลขฐานสิบหก |
| \ooo |
มีค่าเท่ากับเลขฐานแปด |
| \f |
Form feed |
| \a |
เสียงกระดิ่ง |
| \v |
แทปแนวตั้ง |
print '\x50\x79\x74\x68\x6f\x6e'
|
โพสต์25 ก.พ. 2553, 21:45โดยWisit P.
[
อัปเดต 4 ก.พ. 2554, 18:47
]
หลังจากเราได้รู้จักตัวแปรลิตส์ และตัวแปรทูเปิลไปแล้ว ซึ่งทั้งสองตัวนั้นก็เป็นตัวแปรที่เป็นตัวแปร array เหมือนกัน เพียงแต่ว่าการอ้างอิงถึงสมาชิกย่อยที่อยู่ในตัวแปรนั้น จะต้องอ้างอิงด้วยตัวเลข แต่ตัวแปร dictionary หรือบางครั้งเราเรียกสั้นๆ ว่าตัวแปร dict เป็นตัวแปร array ที่อ้างอิงข้อมูลของสมาชิกย่อยด้วยชื่อ (associate array)
การประกาศตัวแปร dict และการอ้างถึงสมาชิกในตัวแปร dict
mydict = {'nickName':'Mr.P','age':33}
print mydict['age']
print mydict['nickName']
print type(mydict)
>>>
33
Mr.P
<type 'dict'>
ตัวแปร dict เป็นตัวแปรที่เราสามารถเพิ่มค่าสมาชิกได้ แต่ชื่อที่อ้างถึงต้องไม่ซ้ำกับชื่อเก่าที่มีอยู่แล้ว ไม่เช่นนั้นจะเป็นการเปลี่ยนแปลงค่า แทนที่จะเป็นการเพิ่ม สังเกตจากตัวอย่างต่อไปนี้
mydict = {'nickName':'Mr.P','age':33}
print mydict
>>>
{'age': 33, 'nickName': 'Mr.P'}
mydict['blog'] = 'http://mechacity.blogspot.com'
print mydict
>>>
{'blog': 'http://mechacity.blogspot.com', 'age': 33, 'nickName': 'Mr.P'}
ลองทดลองใส่ชื่อซ้ำกับที่มีอยู่แล้ว
mydict = {'nickName':'Mr.P','age':33}
print mydict
mydict['blog'] = 'http://mechacity.blogspot.com'
print mydict
mydict['age'] = 18
print mydict
>>>
{'age': 33, 'nickName': 'Mr.P'}
{'blog': 'http://mechacity.blogspot.com', 'age': 33, 'nickName': 'Mr.P'}
{'blog': 'http://mechacity.blogspot.com', 'age': 18, 'nickName': 'Mr.P'} # อายุเปลี่ยนทันที
|
โพสต์25 ก.พ. 2553, 7:46โดยWisit P.
[
อัปเดต 11 ก.พ. 2554, 23:26
]
การตั้งชื่อตัวแปรในภาษาไพธอน
- ขึ้นต้นด้วยตัวอักษรภาษาอังกฤษ แล้วตามด้วยตัวอักษรหรือตัวเลขใดๆก็ได้
- ห้ามเว้นช่องว่าง และห้ามใช้สัญลักษณ์พิเศษนอกเหนือจาก underscore "_" เท่านั้น
- ตัวอักษรของชื่อจะคำนึงถึงความแตกต่างระหว่างอักษรตัวพิมพ์ใหญ่กับตัวพิมพ์เล็ก
- การตั้งชื่อมีข้อพึงระวังว่า จะต้องไม่้ซ้ำกับคำสงวน (Reserved word, Keyword)
- ควรจะตั้งชื่อโดยให้ชื่อนั้นมีสื่อความหมายให้เข้ากับข้อมูล สามารถอ่านและเข้าใจได้
- ห้ามใช้เครื่องหมายต่อไปนี้ในการตั้งชื่อตัวแปร !,@, #, $, %, ^, &, *, (, ), -, =, \, |, +, ~
- ตัวแปรที่มีพิมพ์ใหญ่และตัวพิมพ์เล็กผสมกันจะมีความหมายต่างกัน กับตัวพิมพ์เล็กเพียงอย่างเดียว
ที่มา เอกวิทยาการคอมพิวเตอร์ คณวิทยาศาสตร์ มหาวิทยาลัยนเรศวร
คำสงวนในภาษาไพธอน
เหมือนๆกับทุกภาษาที่จะต้องมีคำสงวนที่ห้ามให้โปรแกรมเมอร์ ห้ามตั้งชื่อตัวแปรซ้ำกับคำสงวน ภาษาไพธอนก็เป็นภาษาหนึ่งที่มีคำสงวนที่สงวนไว้สำหรับตัวแปลภาษาไพธอนเหมือนกัน ซึ่งเราก็ต้องรู้ไว้เหมือนกันว่าไพธอน มีคำใดบ้างที่เป็นคำสงวน ดังแสดงตามตารางด้านล่างนี้
| and |
assert |
break |
class |
continue |
| def |
del |
elif |
else |
except |
| exec |
finally |
for |
from |
global |
| if |
import |
in |
is |
lamda |
| not |
or |
pass |
print |
raise |
| return |
try |
while |
yield |
|
|
โพสต์24 ก.พ. 2553, 4:51โดยWisit P.
[
อัปเดต 24 ก.พ. 2553, 5:57
]
เฉกเช่นเดียวกันกับภาษาอื่นๆ ภาษาไพธอนก็มีตัวแปรที่เป็น array เหมือนกัน ตัวแปรลิตส์และตัวแปรทูเปิลของไพธอน เป็นตัวแปร array ชนิดหนึ่ง ซึ่งการที่จะเข้าถึงตำแหน่งของสมาชิกย่อย ที่อยู่ภายในตัวแปรทั้งสองนั้น จะต้องมีการอ้างอิงลำดับของสมาชิก ในบางครั้งเราเรียกตัวแปรทั้งสองชนิดนี้ว่า เป็นตัวแปรแบบลำดับ (Sequences) การประกาศตัวแปรลิสต์ ชื่อตัวแปร = [สมาชิกตัวที่1, สมาชิกตัวที่2, สมาชิกตัวที่3, สมาชิกตัวที่4,...,สมาชิกตัวที่ื n]ตัวอย่างการประกาศตัวแปรลิตส์ lists1 = [1,2,3,4] lists2 = ['a','b','c'] print lists1 print lists2 >>>
[1, 2, 3, 4]
['a', 'b', 'c']ในขณะที่การประกาศตัวแปรทูเปิลมีลักษณะ ชื่อตัวแปร = (สมาชิกตัวที่1, สมาชิกตัวที่2, สมาชิกตัวที่3, สมาชิกตัวที่4,...,สมาชิกตัวที่ื n)หรือ ชื่อตัวแปร = สมาชิกตัวที่1, สมาชิกตัวที่2, สมาชิกตัวที่3, สมาชิกตัวที่4,...,สมาชิกตัวที่ื nตัวอย่างการประกาศตัวแปรทูเปิล tuple1 = 1,2,3,4 tuple2 = (1,2,3,4) print tuple1 print tuple2 >>>
(1, 2, 3, 4)
(1, 2, 3, 4) จากตัวอย่างทั้งสองจะเห็นได้ว่าตัวแปรลิตส์มีการใช้เครื่องหมาย [] ในขณะที่ตัวแปรทูเปิลใช้เครื่องหมาย () หรือเพียงใช้แค่เครื่องหมายคอมม่าคั่นจำนวนสมาชิก นอกจากความแตกต่างเรื่องของการประกาศตัวแปรแล้ว ตัวแปรลิสต์และตัวแปรทูเปิลยังแตกต่างกันในแง่สิทธิการเข้าถึงจำนวนสมาชิกในตัวแปรอีกด้วย โดยที่ตัวแปรลิตส์เราสามารถเปลี่ยนแปลงแก้ไขสมาชิกย่อยในตัวแปรลิตส์ได้ (mutable) ในขณะที่ตัวแปรทูเปิลนั้น ไม่สามารถที่จะแก้ไขสมาชิกย่อย (immutable) หลังจากที่ได้ประกาศตัวแปรไว้แล้วได้ ข้อผิดพลาดอันเนื่องจากการพยายามเปลี่ยนแปลงค่าของสมาชิกย่อยในตัวแปรทูเปิล tuple1 = 1,2,3,4 tuple2 = (1,2,3,4) tuple1[0] = 'a' >>>
Traceback (most recent call last):
File "<string>", line 244, in run_nodebug
File "C:\Documents and Settings\Mr.P\My Documents\test.py", line 6, in ?
tuple1[0] = 'a'
TypeError: object does not support item assignment การอ้างถึงสมาชิกย่อยของตัวแปรลิตส์และตัวแปรทูเปิลในการเข้าถึงค่าที่อยู่ภายในตัวแปรลิสต์และตัวแปรทูเปิล ก็มีลักษณะคล้ายกับการเข้าถึงตัวแปร array ในภาษาอื่นๆ นั่นก็คือ จะต้องอ้างอิงลำดับของ index ที่ใช้ชี้ตำแหน่งของค่าสมาชิกย่อยในตัวแปรนั้นๆ ซึ่งลำดับการอ้างถึงสมาชิกตัวแรกในตัวแปร จะเริ่มจากสมาชิก index ที่ 0 (บางภาษาจะเริ่มจากที่ 1 ) ในขณะที่เราอ้างตำแหน่งท้ายสุด เราจะเริ่มนับจากค่า -1 ไปเรื่อยๆ พิจารณาค่าในตาราง ;) n = ลำดับสมาชิก
e = ค่าของสมาชิกนั้นๆ
สรุป สิ่งที่เหมือนกันของตัวแปรลิตส์และตัวแปรทูเปิล คือความเหมือนกันในการอ้างอิงตำแหน่งสมาชิก ความเป็นตัวแปร array เหมือนกัน
ส่วนสิ่งที่แตกต่างกัน คือการประกาศตัวแปร และสิทธิในการแก้ไขค่าของสมาชิกในตัวแปร
|
โพสต์9 ก.พ. 2553, 20:40โดยWisit P.
[
อัปเดต 24 ก.พ. 2553, 19:15
]
ในบางครั้งเรามีความจำเป็นที่จะต้องทำการเช็คชนิดของตัวแปร ก่อนที่จะทำการประมวลผลอย่างใดอย่างหนึ่ง คำสั่งในการตรวจสอบชนิดของตัวแปรในภาษาไพธอนคือ type(ตัวแปร)>>> a = "Hello World" >>> type(a) <type 'str'> จะเห็นว่าตัวแปร a เป็นตัวแปรชนิดที่เป็น string ในทำนองเดียวกันเราสามารถนำไปเช็คตัวแปรชนิดอื่นๆได้เช่นกัน ดูตัวอย่าง >>> b = {1:'one',2:'two',3:'three'} >>> type(b) <type 'dict'> >>> c = ('red','white','blue','yellow') >>> type(c) <type 'tuple'> >>> d = [1,2,3,4,5,6,7,8,] >>> type(d) <type 'list'> หรือแม้กระทั่งชนิดของตัวแปรที่เป็น method ก็สามารถทำได้เช่นกัน >>> type(sum) <type 'builtin_function_or_method'> ที่นี้ เรามาดูวิธีการนำไปใช้งานกัน ส่วนใหญ่คำสั่ง เรามักนิยมนำไปเช็คชนิดของตัวแปรก่อนที่จะทำการประมวลผลใด เพราะหากชนิดของตัวแปรที่รับมา ไม่ตรงตามที่เราต้องการ ก็อาจจะทำให้การคำนวณของโปรแกรมทำงานผิดพลาด ฉะนั้นจึงพบเห็นคำสั่ง type() ได้ตามคำสั่ง if elif เรามาดูตัวย่างการนำไปใช้งาน >>> a = '1' >>> if type(a) == type(1): ... print "a is integer variable" ... elif type(a) == type(""): ... print "a is string variable" ... a is string variable ส่วนการตรวจสอบตัวแปรอื่นๆ เราก็ทำในทำนองเดียวกัน เพียงแค่เปลี่ยนที่ if type(a) == type([]) # สำหรับตรวจสอบตัวแปร Lists if type(a) == type(()) # สำหรับตรวจสอบตัวแปร Tuple if type(a) == type({}) # สำหรับตรวจสอบตัวแปร Dict ก็จะเห็นได้ว่า คำสั่ง type() เป็นคำสั่งที่นิยมเอาไว้เช็คชนิดของตัวแปร ซึ่งใช้ร่วมกับคำสั่ง if elif ของไพธอน ลองเอาไปประยุกต์ใช้กันดูนะครับ |
โพสต์30 ม.ค. 2553, 3:01โดยWisit P.
[
อัปเดต 30 ม.ค. 2553, 3:35
]
ก่อนที่เราจะมาเริ่มเล่นกับภาษาไพธอน เราควรจะรู้จักเจ้าตัวนี้ไว้ก่อน '__builtins__" มันเป็นโมดูลหนึ่งที่ถูกโหลดเข้ามาในไพธอนทันทีทันใด โดยที่เราไม่ต้องโหลดเข้ามาใช้งาน เมื่อเราต้องการเรียกใช้ method หรือ object ที่อยู่ในโมดูลนี้ ซึ่ง object และ method ที่อยู่ในโมดูลนี้ จะเป็นสิ่งที่เราจำเป็นต้องใชอยู่แล้ว เหมาะกับงานทั่วๆไป ก็เลยทำให้พวกนี้ถูกบรรจุอยู่ในโมดูล __builtins__ ซึ่งการเรียกใช้ object และ method ทีอยู่ในโมดูลนี้ เราไม่จำเป็นต้อง import module เข้ามาแต่อย่างไร (ศึกษาการ import module เพิ่มเติม คลิก) แล้ว method และ object อะไรหล่ะ ที่อยู่ในโมดูล __builtins__ ?? เราสามารถตรวจสอบได้โดยใช้คำสั่ง dir(__builtins__) หรือจะดูใน help ของไพธอนก็ได้ ทดลองใช้คำสั่งที่ dir() เพื่อดูโมดูล ตัวแปร ออปเจคต์ที่โหลดเข้ามาในหน่วยความจำของเรา >>> dir(__builtins__)['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'IOError', 'ImportError', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'OverflowWarning', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__debug__', '__doc__', '__import__', '__name__', 'abs', 'apply', 'basestring', 'bool', 'buffer', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'min', 'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']เราสามารถเรียกใช้ method เหล่านี้ได้เลย โดยไม่ต้อง import module เข้ามา แต่หากต้องการเรียกใช้ method อื่นๆมากกว่านี้จะต้อง import module เข้ามา ซึ่งมีมากมาย เราจะได้ศึกษากันต่อไป |
โพสต์26 ม.ค. 2553, 7:02โดยWisit P.
[
อัปเดต 28 ม.ค. 2553, 8:13
]
การแปลงชนิดของข้อมูล
ในบางครั้งเรามีความจำเป็นจะต้องทำการแปลงข้อมูลที่ได้รับมา ก่อนที่จะนำไปกระทำการใดๆต่อไป เพื่อให้มั่นใจได้ว่าค่าของตัวแปรที่เราได้รับมานั้น ตรงตามความต้องการของฟังก์ชั่น เพราะไม่เช่นนั้นแล้วอาจจะเกิดข้อผิดพลาดขึ้น หรืออาจทำให้เกิดการปัดค่าของเศษส่วนผลลัพธ์ที่ได้ ซึ่งอาจจะทำให้ค่าที่ต้องการเกิดความคลาดเคลื่อนไปได้
การแปลงข้อมูลไปเป็นตัวเลข
int([x[,
base]]) การแปลงข้อมูลสตริงไปเป็นตัวเลขฐานสิบ >>> int('23') #ทำการแปลงข้อมูลสติรง '23' ไปเป็นตัวเลข 23 23 >>> int('AA',16) # ทำการแปลงข้อมูลสติรง 'AA' ซึ่งเป็นค่าที่อยู่ในตัวเลขในฐานสิบหก ให้ไปเป็นเลขฐานสิบ ได้เท่ากับ 170 170 long([x[, base]]) ทำการแปลงข้อมูลตัวอักษรไปเป็นข้อมูลตัวเลข คล้ายๆกับแบบ int() แต่ใช้หน่วยควมจำเยอะกว่า ใช้กับข้อมูลที่เราต้องการค่ามากๆ
float(x) แปลงข้อมูลให้เป็นตัวเลขแบบเลขมีทศนิยม ไม่ต้องอธิบายมาก ดูตัวอย่างกันเลย
>>> float(23)
23.0
>>> float(20L)
20.0
round(num[,digits]) ทำการแปลงเลขทศนิยมเป็นตัวเลขเต็ม และสามารถทำการแปลงเลขทศนิยมให้เป็นเป็นเลขทศนิยมที่เราต้องการ ซึ่งการแปลงตัวเลขใช้หลักการแปลงตัวเลขแบบนัยสำคัญ
>>> round(25.5321,2)
25.53
>>> round(2.23)
2.0
complex(real[, imaginary]) ทำการแปลงตัวเลขให้เป็นจำนวน complex ซึ่งเราจะต้องใส่ค่าจำนวนจริง และจำนวนจินตภาพ
>>> complex(23,4)
(23+4j)
การแปลงข้อมูลไปเป็นตัวอักษร
chr(x) และ unichr(x) ทำการแปลงค่า ASCII หรือค่า Unicode ให้เป็นตัวอักษร
>>> chr(98)
'b'
>>> chr(99)
'c'
>>> unichr(99)
u'c'
oct(x) และ hex(x) ฟังก์ชั่นทั้งสองนี้ ทำการแปลงจำนวนตัวเลขให้เป็นเลขฐานแปด และฐานสิบหก แต่ค่าที่ได้จะเป็นตัวอักษรนะครับ ไม่ใช่ตัวเลข
>>> oct(123)
'0173'
>>> hex(123)
'0x7b'
str(obj) จะทำการแปลงข้อมูล object ให้เป็นข้อมูลรูปแบบตัวอักษร
>>> str(5)
'5'
>>> str(5.5)
'5.5'
>>> str(3+2j)
'(3+2j)'
|
|
