blogs = Blog.objects.all()    # ได้ QuerySet ของบล็อกหลายๆ อัน
print blogs[0].title
print blogs[0].body
print blogs[1].title
print blogs[1].body

จะเห็นว่าเราใช้ QuerySet ได้เหมือนเป็นอาเรย์หรือ list เลย
แต่สิ่งที่ต้องระวังคือ blogs เป็น QuerySet ไม่ใช่ list

เวลาอัพเดทข้อมูลใน model ต้องระวัง

bug แบบนี้

1
2
3

blogs[0].title = "New Title"
blogs[0].body = "new content"
blogs[0].save()

ถ้ารันโค้ดข้างบนแล้ว blogs[0] จะไม่เปลี่ยนแปลงค่าอะไรเลย เพราะ:

• blogs[0] ในแต่ละบรรทัดเป็น object คนละอันกัน (คนละ instance กัน)
• การเรียก blogs[0] แต่ละครั้ง QuerySet จะให้ object ใหม่ทุกครั้ง ทำให้การกำหนดค่ามีผลกับ object ในบรรทัดนั้นเฉยๆ
• blogs[0].save() ในบรรทัดที่ 3 จะอ่านค่า blogs[0] จาก database และ save() กลับไปโดยยังไม่ได้แก้ไขอะไรเลย

ที่ถูกต้องควรเป็น

b = blogs[0]
b.title = "New Title"
b.body = "new content"
b.save()

แต่ถ้าอยากใช้ได้เหมือน list จริงๆ ก็ทำได้โดยบังคับให้ Django มัน evaluate QuerySet ให้กลายเป็น list ด้วยฟังก์ชัน list
เช่น

blogs = list(blogs)

มีข้อเสียคือ
* มี large memory overhead
* blogs.filter ต่อไม่ได้… เพราะโดน evaluate ไปแล้ว

rules = (
    ( 'foo', 1),
    ( 'spam', 2),
    ( 'bar', 3),
"""
    ( 'egg', 4),
    ( 'python', 5),
"""
)
 
for name, val in rules:
    print name, val

โค้ดข้างบนพอรันแล้วจะเจอ ValueError (too many values to unpack)
ตอนมองแว๊บแรก ก็คิดว่าโค้ดน่าจะโอเค แค่ comment egg กับ python ออกไปแบบหลายบรรทัด… แต่จริงๆ แล้วมันไม่ใช่

เราสร้าง list ที่มี (‘foo’, 1), (‘spam’, 2), (‘bar’, 3) และ “”" (‘egg’, 4),…”"” <– ก้อนนี้เป็น string แบบหลายบรรทัด ไม่ใช่ comment!!

ปล. ตอนนี้มีอยู่ 1 bug, เดี๋ยวมีอะไรเพิ่ม จะเอามาแปะอีกครับ

funcs = []
i=0
def funcfactory():
    global i
    i += 1
    j = i
    def callback():
        print j
    funcs.append(callback)
 
funcfactory()    # ได้ callback ที่มี j = 1
funcfactory()    # ได้ callback ที่มี j = 2
funcfactory()    # ได้ callback ที่มี j = 3
print funcs
for f in funcs:
    f()

list funcs จะเก็บ function ‘callback’ ที่มีโค้ดแบบเดียวกัน (print j) แต่มี context ต่างกัน (j = 1, 2, 3)

closure = (function, environment ของฟังก์ชั่น)

Edit: ข้อจำกัดสำคัญของ Closure ใน python คือ “อ่านได้อย่างเดียว” วิธีแก้ปัญหาทำได้โดยส่ง reference แทนตามตัวอย่างใน [ref]

ใน Python 3 มีคีย์เวิร์ด nonlocal ไว้ใช้อ้างถึงตัวแปรที่อยู่ใน Scope ก่อนหน้าได้

a = [1]
for i in a:
    print i
    if len(a) < 10:
        a.append(i+1)

ได้ผลลัพธ์เป็น
1
2
3
4
5
6
7
8
9
10

ตื่นเต้นดี for loop บน list ที่โตขึ้นเรื่อยๆ… ไม่รู้ว่าจะจบเมื่อไหร่

ผมเลยลองเขียนปลั๊กอินไว้ “กรองข้อความ” โดยใช้เงื่อนไขง่ายๆ ว่า

“ใน 1 ชม. ที่ผ่านมา ถ้าเธอยังไม่เคยส่งข้อความหาฉันเลย แล้วจู่ๆ ส่ง URL มาให้ ฉันจะขอโยนข้อความนั้นทิ้งซะ (มันต้องเป็น spam แน่เลย!)”

Anti MSN Spam

ลองเขียนไว้ 2 version ครับ เขียนด้วย Python กับ C

1. anti-msn-spam.py

ลองเขียนตัวต้นแบบด้วย Python ครับ ใช้ dbus คุยกับ pidgin เพื่อเช็คว่ามีข้อความส่งมารึเปล่า (หาอ่านเพิ่มเติมได้จาก wiki นี้)

คิดว่าใช้ได้บน linux เท่านั้น เพราะมันใช้ dbus น่ะครับ
วิธีใช้: เปิด pidgin แล้วเรียกคำสั่งต่อไปนี้

python anti-msn-spam.py

พอโปรแกรมจับ SPAM ได้มันก็จะบ่นออกมาทาง command line ว่า “ข้อความ…..โดน block ทิ้ง เพราะสงสัยว่าเป็น SPAM” (โค้ด version python น่าจะทำความเข้าใจได้ง่ายสุดครับ ลองแกะเล่นดูได้นะ )

2. anti_msn_spam_c.zip

version C นี้ไปเอาโค้ด message_filter.c ของคุณ Huy Phan มาโมดิฟาย… ของเดิมเค้าเขียนโปรแกรม “block ข้อความที่มีแต่ smiley”

วิธีใช้ ดาวน์โหลดไฟล์ zip ไปจะมี anti_msn_spam.c กับ anti_msn_spam.so
- สำหรับคนใช้ x86 กับ pidgin 2.5.5 (บน linux):
1. สามารถเอาไฟล์ anti_msn_spam.so ไปใส่ไว้ที่ /home/USERNAME/.purple/plugins/anti_msn_spam.so ได้เลย
2. เปิด pidgin ขึ้นมาใหม่ เลือกเมนู Tools->Plugins
3. ติ๊กถูกหน้า “Anti MSN Spam 1.0″ เป็นอันเสร็จ

- สำหรับคนอื่นๆ (เช่น คนใช้ pidgin บน windows)
น่าจะต้อง compile เองครับ ทำตามคู่มือนี้เลย เหมือนจะต้องใช้ MinGW มา compile ครับ ถ้าใครพยายามแล้วติดปัญหา ก็แปะคอมเม้นท์มาได้นะครับ

โม้ไว้นิ๊สนึง… ตั้งแต่ลองใช้มา 3-4 สัปดาห์ ก็ยังไม่เจอ SPAM กวนใจอีกเลย ไม่รู้ว่าเค้าเลิกส่ง SPAM กันแล้ว หรือว่า Plugin เราดีจริง หะๆ

JIT Compiler ตามความเข้าใจของผม (งูๆปลาๆ)

ตามปกติ Java VM ทำหน้าที่เป็น Interpreter เวลาเรารันโปรแกรมก็จะแปลโค้ดทีละบรรทัดเป็นภาษาเครื่องที่สอดคล้องกัน และเมื่อเจอโค้ดเดิมๆ Interpreter ก็ต้องแปลโค้ดเดิมซ้ำทำให้เสียเวลา

JIT Compiler เข้ามาช่วยเพิ่มความเร็วได้ โดยมันจะคอย cache ส่วนของโค้ดที่เคยแปลเป็นภาษาเครื่องไว้ ทำให้เวลาเจอโค้ดเดิมก็สามารถเรียกภาษาเครื่องที่ cache ไว้พ่นใส่ CPU ได้ทันที

แล้ว Python มี JIT Compiler ไหม?

มีครับ ชื่อว่า Psyco (ไม่ได้สะกดผิดนะ) ได้รู้จักมันครั้งแรกจากคอมเมนท์ข่าวใน blognone อีกเช่นเคย คำอธิบายสั้นๆ เกี่ยวกับ Psyco:

มันคืออะไร: Python extension ที่ช่วยให้รันโปรแกรมเดิมที่เขียนด้วย Python ให้เร็วขึ้นโดยไม่ต้องแก้โค้ดเดิม
ประโยชน์: โปรแกรมรันเร็วขึ้น 2 เท่า ถึง 100 เท่า (โดยทั่วไปเร็วขึ้น 4 เท่า)
ข้อเสีย: Psyco ใช้หน่วยความจำเยอะ และรันบน Intel 386-compatible processor ภายใต้ระบบปฏิบัติการใดๆ (ในยุคข้าวยาก หมากแพง แต่แรมถูก จะใช้แรมมากๆ ก็คงไม่เป็นไรมั้งครับ )

ทดลองกันหน่อย

# โปรแกรมปกติ
import time
start = time.clock()
 
 
 
def fib(n):
    if n == 0 or n == 1: return 1
    return fib(n-1)+fib(n-2)
 
print "Fib 40 = ", fib(40)
 
end =  time.clock()
print "Duration: ", (end-start), " seconds"
 
# Output:
# 165580141
# Duration:  106.025350987  seconds

# ใช้ psyco
import time
start = time.clock()
import psyco          ### เพิ่มโค้ดบรรทัดนี้
psyco.full()            ### กับบรรทัดนี้
 
def fib(n):
    if n == 0 or n == 1: return 1
    return fib(n-1)+fib(n-2)
 
print "Fib 40 = ", fib(40)
 
end =  time.clock()
print "Duration: ", (end-start), " seconds"
 
# Output:
# 165580141
# Duration:  6.715894129  seconds

เฮือก… จาก 106.0 วินาที ลดเหลือ 6.7 วินาที! พอลองเอา Psyco ไปใช้กับโปรแกรมตัดคำไทย cpskCut ปรากฏว่าบนข้อมูลทดสอบ 5 แสนคำ จากเดิมใช้เวลา 78 วินาที ลดเหลือ 34 วินาที (โดยเพิ่มโค้ดแค่ 2 บรรทัดด้านบนครับ)

ใครอยากลองเอาไปใช้บ้างก็ ดาวน์โหลด Psyco สำหรับ Python 2.6 ได้ที่นี่ ครับ

AVL Tree คือ binary search tree ที่คอยจัดตัวเองให้ balance อยู่เสมอ (subtree ทางซ้าย กับ subtree ทางขวามี depth แตกต่างกันไม่เกิน 2) และการจัดต้นไม้ให้ balance อยู่เสมอทำให้ binary search tree สามารถแทรก/ค้นหา ข้อมูลได้อย่างมีประสิทธิภาพ (ไม่มีปัญหาที่เกิดจากต้นไม้เอียงไปข้างใดข้างหนึ่ง)

AVL Tree ที่เขียนเป็น class มี method isLeaf (เช็คว่าเป็นโหนดลูก), depth (หาความลึกของต้นไม้), balance (คำนวณ balance factor สำหรับต้นไม้), LeftRotate (ทำการหมุนต้นไม้ไปทางซ้าย), RightRotate (หมุนต้นไม้ไปทางขวา), RLDoubleRotate (หมุนสองครั้งแบบขวา-ซ้าย), LRDoubleRotate (หมุนสองครั้งแบบซ้าย-ขวา), insert (แทรกโหนดลงไปในกราฟ), travel (ท่องไปในต้นไม้), printtree (พิมพ์ต้นไม้)

ตัวอย่างต้นไม้ที่ printtree พิมพ์ออกมา

    7
  6
    5
4
    3
  2
    1

ข้างบนเป็นต้นไม้ที่มี 4 เป็น root และมี 2 กับ 6 เป็นลูกทางซ้ายและขวาตามลำดับ โดย 2 มี 1 และ 3 เป็นลูก…. วิธี printtree แบบนี้ ได้เทคนิคมาจาก อ.ที่ค่าย สอวน. ศูนย์ ม.ศิลปากร ครับ

(โค้ดอยู่ด้านในนะครับ)

# author: Natt Piyapramote <nattster at googlemail>
class AVLTree:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
 
    def isLeaf(self):
        if self.left is None and self.right is None:
            return True
        return False
 
    def depth(self):
        if self.isLeaf():
            return 0
        depth = 0
        if self.left is not None:
            depth = self.left.depth()
        if self.right is not None:
            depth = max(self.right.depth(), depth)
        return depth+1
 
    def balance(self):
        if self.isLeaf():
            return 0
        if self.right is None:
            return self.left.depth()+1
        if self.left is None:
            return -(self.right.depth()+1)
        return self.left.depth() - self.right.depth()
 
    def LeftRotate(self, root):
        pivot = root.right
        root.right = pivot.left
        pivot.left = root
        return pivot
 
    def RightRotate(self, root):
        pivot = root.left
        root.left = pivot.right
        pivot.right = root
        return pivot
 
    def RLDoubleRotate(self, root):
        root.right = self.RightRotate(root.right)
        return self.LeftRotate(root)
 
    def LRDoubleRotate(self, root):
        root.left = self.LeftRotate(root.left)
        return self.RightRotate(root)
 
    def insert(self, node):
        # insert node
        if node.data < self.data:
            if self.left is None:
                self.left = node
            else:
                self.left = self.left.insert(node)
        else:
            if self.right is None:
                self.right = node
            else:
                self.right = self.right.insert(node)
 
        # rotation needed?
        if self.balance() == 2:
            if self.left and self.left.balance() > 0:
                return self.RightRotate(self)
            else:
                return self.LRDoubleRotate(self)
        elif self.balance() == -2:
            if self.right and self.right.balance() < 0:
                return self.LeftRotate(self)
            else:
                return self.RLDoubleRotate(self)
        return self
 
    def travel(self):
        if self.left is not None:
            self.left.travel()
        print self.data, 
        if self.right is not None:
            self.right.travel()
 
    def printtree(self, depth=0, padding=2):
        "pre order travel to print binary tree"
        if self.right: self.right.printtree(depth+1)
        print ' '*padding*depth + `self.data`
        if self.left: self.left.printtree(depth+1)
 
root = AVLTree(4)
for i in [6, 1, 2, 3, 7, 5]:
    root = root.insert(AVLTree(i))
root.printtree()

แต่ว่าโปรแกรมที่เอามาตรวจอาจรันแล้วเกิดอาการติดลูป หรือรันไม่รู้จบ เราจึงต้องกำหนด timeout ว่าให้รันได้ไม่เกินกี่วินาที ถ้าโปรแกรมรันนานเกินไป โปรแกรม grader จะต้องหยุดการทำงาน (End Process) ของโปรแกรมที่ถูกตรวจ

ปรากฏว่าผมไปค้นๆ ในเน็ตก็ไม่เจอตัวอย่างโปรแกรม python ที่สามารถ รันโปรแกรมอื่น แล้วกำหนด timeout แบบง่ายๆ เลย ผมก็เลยพยายามเขียนเอง ได้โค้ดมาดังนี้ (ใช้ thread และ subprocess)

import subprocess
from time import sleep
from threading import Thread
 
class process(Thread):
    # written by Natt Piyapramote <nattster at google mail>
    # requires: Python 2.6
    def __init__(self, filename, input_txt=None):
        Thread.__init__(self)
        self.filename = filename
        self.input_txt = input_txt
        self.status = 0
        self.output = ''
 
    def run(self):
        self.process = subprocess.Popen(self.filename,
                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE)
        self.output, self.err = self.process.communicate(self.input_txt)
        self.status = 1
 
def run_process(filename, input_txt=None, timeout=1):
    "run a process with timeout"
 
    p = process(filename, input_txt)
    p.start()
    p.join(timeout)
 
    if p.status == 0:   # process still running?
        p.process.terminate()
        while p.isAlive():
            sleep(0.1)
            print 'killing process...'
 
    return p.output

ตัวอย่างการใช้งานฟังก์ชันนี้ก็

run_process('c:\\windows\\notepad.exe', timeout=4)

ฟังก์ชัน run_process จะไปเรียกโปรแกรม notepad.exe ให้ทำงาน (ซึ่ง notepad จะรันไปเรื่อยๆ ไม่ปิดตัวเอง) ดังนั้นฟังก์ชัน run_process จะหยุดการทำงานของ notepad ภายในเวลา 4 วินาที

นอกจากนี้ถ้าเรารันโปรแกรมที่เป็น Console Application เราสามารถกำหนด Input ให้กับ Standard Input (stdin) และอ่านค่าจาก Standard Output (stdout) ของโปรแกรมที่รันได้ด้วย (กำหนด Input ให้ตัวแปร input_txt แล้วฟังก์ชันจะคืนค่าข้อความจาก stdout)

อ้อ… ฟังก์ชันนี้ต้องใช้ Python 2.6 นะครับ

lines = open('file.txt', 'r').read().split('\n')
for line in lines:
    # do something

คำสั่ง read() แบบไม่กำหนด parameter จะอ่านไฟล์ทั้งหมดเข้ามาไว้ในหน่วยความจำ ถ้าไฟล์มีขนาดเล็ก ก็คงไม่มีปัญหาอะไร แต่เมื่อคืนเขียนโปรแกรมตัดคำไฟล์ใหญ่ประมาณ 64mb ปรากฏว่าโปรแกรมทำงานช้าลงมาก (จากไฟล์เล็กๆ ~7000 คำ/วินาที พอเจอไฟล์ใหญ่ๆเหลือ ~700 คำ/วินาที)

พออ่าน Python Doc แล้วเปลี่ยนวิธีเขียนโปรแกรมอ่านไฟล์เป็นแบบนี้แทน (ซึ่งมีประสิทธิภาพมากกว่า เพราะค่อยๆ อ่านทีละบรรทัด)

f = open('file.txt', 'r')
for line in f:
    # do something
f.close()

ปรากฏว่า ไฟล์จะใหญ่แค่ไหน โปรแกรมก็ทำงานที่ความเร็ว ~7000 คำ/วินาที
ปล. มาเขียนบล็อกไว้เผื่อคนอื่นจะเจอปัญหาโง่ๆ แบบนี้ T_T (หรือไม่เค้าก็คงจะเขียนกันแบบล่างซะส่วนใหญ่ล่ะมั้ง)
ปล2. วิธีอ่านไฟล์แบบล่าง มีปัญหาคือ ถ้าโปรแกรมเราจำเป็นต้องกระโดดไปอ่านข้อความที่บรรทัดนู้นที บรรทัดนี้ทีก็คงจะทำไม่ได้ครับ

A = [1, 2, 3, 6, 7, 9, 12]
for x in A:
    if x % 3 == 0:
        A.remove(x)

List<int> A = new List<int>(new int[]{1, 2, 3, 6, 7, 9, 12});
foreach(int x in A)
{
    if(x % 3 == 0)
        A.Remove(x);
}

ในบล็อกนี้ขออนุญาตยกตัวอย่างแค่ 2 ภาษา คือ Python และ C# นะครับ สำหรับฝั่ง C# จะเจอกับ “Unhandled Exception: System.InvalidOperationException: Collection was modified;” (เขาบอกว่า เกิดการกระทำที่ไม่ถูกต้อง เนื่องจาก list ถูกแก้ไขระหว่างวนลูป) ส่วนคนใช้ Python จะไม่เจอปัญหาอะไรเวลารันครับ แต่พอลองพิมพ์ A ออกมาดูจะพบว่า

A = [1, 2, 6, 7, 12]

แงว… ทำไม 6 กับ 12 ยังโผล่ออกมา? ในเมื่อมันน่าจะ mod 3 ลงตัว… ในบล็อกนี้เราจะมาดูวิธีแก้ปัญหาที่มักจะเจอบ่อยๆ ปัญหานี้กันครับ

ปัญหาที่เจอใน Python คือ เลขจำนวนเต็มที่หารสามลงตัว ไม่โดนลบออกไปทุกตัว สาเหตุคือ ในการวนลูปบน list python จะมีตัวชี้ index ของ list สร้างขึ้นมา และในการวนลูปแต่ละรอบ index จะต้องโดนขยับไป 1 เสมอ ดังนั้นเมื่อตัวเลขโดนลบไป ตัวเลขอื่นๆ ที่อยู่ต่อท้ายจะเลื่อนมาแทนที่ตัวที่หายไป แล้วตัวที่เลื่อนมาแทนที่เนี่ยแหละครับ จะโดนข้ามไป (ไม่โดนตรวจสอบ)…. ถ้างง ลองดูตัวอย่างต่อไปนี้ครับ

A = 1 2 3 6 7 9 12

A = 1 2 3 6 7 9 12

A = 1 2 3 6 7 9 12

A = 1 2 6 7 9 12

จะเห็นว่ามีกรณีแบบนี้เกิดขึ้นได้ใน python และคนเขียนโปรแกรมก็ไม่รู้ว่าเกิดปัญหาขึ้นเลย (นอกจากมาดูผลลัพธ์) ดังนั้นใน C# เขาจึงห้ามวนลูปแบบ foreach แล้วแก้ไขข้อมูลใน list (เกิด InvalidOperationException นั่นเอง) ในเมื่อ foreach ใช้ไม่ได้ ขอลักไก่ใช้ for ธรรมดาแทนได้มั้ย? คำตอบคือ ไม่ได้ครับ ถ้าลองเขียนแล้วจะเจอปัญหาเหมือนกับที่เจอใน Python ครับ

แล้วเราจะแก้ปัญหานี้ยังไงดีหละ?

แบ่งได้เป็น 3 วิธีที่เจอบ่อยๆ ครับ

1. สร้าง List อีกอันมาเก็บเฉพาะผลลัพธ์ที่ต้องการ

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

B = []
for x in A:
    if x % 3 <> 0:
        B.append(x)

List B = new List<int>();
foreach(int x in A)
{
    if (x % 3 != 0)
	B.Add(x);
}

อ่าวๆๆแบบนี้ โปรแกรมก็ต้อง copy ตัวเลขทุกตัว ไปใส่ list B แทน ซึ่งมันต้องทำงานช้าแน่ๆ เลย สมมติว่าเราต้องการลบเลขแค่ตัวเดียวใน list A แต่ดันต้อง copy ตัวที่ต้องการเก็บไว้ไปใส่ใน list B ซึ่งเสียเวลาทำงานตั้งนาน (แต่! จะเร็วกว่าวิธีอื่นๆ ถ้ามีตัวเลขที่ต้องโดนลบเยอะๆ ครับ)

งั้นไปดูวิธีที่สองดีกว่า

2. วนลูปในตัวก๊อบปี้ของ List

วิธีนี้คือ สร้างตัวก๊อบปี้ของ List (เอาตัวเลขทุกตัว) มาเลยครับ เอามาใช้วนลูป แล้วเวลาลบข้อมูลก็ลบใน list ของจริง ผลลัพธ์ก็จะเก็บอยู่ใน list A ตามปกติ

for x in A[:]:
    if x % 3 == 0:
        A.remove(x)

foreach(int x in new List<int>(A))
{
    if (x % 3 == 0)
	A.Remove(x);
}

หลายๆ คนคงจะเห็นว่า มันก็คล้ายๆ กับวิธีที่ 1 แหละน๊า… แค่สร้างตัวก๊อบปี้ไว้วนลูป ต้องเสียเวลาสร้างตัวก๊อบปี้เหมือนกันไม่ใช่เรอะ?… ฮึ่ม! งั้นลองไปดูวิธีที่ 3 กันครับ

3. วนลูปถอยหลัง

ในเมื่อวนลูปจากหน้าไปหลัง (0 ไปจนถึงขนาดของ list) จะมีปัญหาเพราะว่า ตัวเลขใน list จะเลื่อนมาแทนที่ตัวที่ถูกลบ ดังนั้นเราแก้ปัญหาโดยวนลูปถอยหลัง แทนครับ นั่นก็คือ วนลูปจากขนาดของ list มาจนถึง 0 นั่นเอง

for i in reversed(range(len(A)))
    if x % 3 == 0:
        del A[i]

for(int i = A.Count - 1; i >= 0; i--)
{
    if (A[i] % 3 == 0)
	A.RemoveAt(i);
}

จากตัวอย่างโค้ดจะเห็นว่าเราใช้ del A[i] และ A.RemoveAt(i) เพื่อลบตัวเลข ที่ตำแหน่งใดๆ แทนที่จะใช้ Remove ที่ใช้ลบค่าใดๆ จะเห็นว่าวิธีที่สามนั้นน่าจะทำงานได้เร็วกว่าวิธีที่ 1 และ 2 เพราะไม่ต้องสร้างตัวก๊อบปี้ของ list นั่นเอง

สรุป

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

ส่วนตั๊วส่วนตัวจากคนเขียน

ปล. สาเหตุที่มานั่งเขียน blog นี้เพราะผมเขียนโปรแกรมไปแล้วก็เจอ bug… คือ “ของ” ใน list มันโดนลบออกไปไม่หมด (แต่ python ไม่ยอมเตือนเหมือน C# หง่ะ!!) ก็เลยนั่งหา bug จนมาเจอ… เอาเป็นว่า เพื่อนๆ คนอื่นที่อ่านมาเจอบล็อกนี้แล้ว คงไม่พลาดแบบผมละกันครับ

ปล2. เพิ่งรู้ว่าใช้ reversed() แล้วโค้ดสวยกว่าเดิมเยอะเลย ปกติเวลาต้องการวนลูปจากมากไปน้อย (9 ถึง 0) ก็เขียนโค้ดน่าเกลียดๆ แบบนี้

for i in range(9, -1, -1):
    print i

พอเขียนบล็อกนี้แล้วเพิ่งรู้ว่าเขียนเป็น

for i in reversed(range(0, 9)):
    print i

สวยกว่าเยอะเลย

ปล3. ใครอยากให้เขียนบล็อก แล้วยกตัวอย่างภาษาอื่นๆ นอกจาก Python และ C# ช่วยทิ้งคอมเม็นท์ไว้ด้วยครับ