Python cho người Việt

Python cho người Việt

Python 2.7 beta 1 ra mắt

written by Võ Đức Phương, on Apr 18, 2010 6:00:00 PM.

Python 2.7 là phiên bản cuối cùng của Python 2 trước khi chuyển sang chế độ chỉ sửa lỗi, không thêm tính năng vào họ phiên bản này nữa. Tương tự như 2.6, phiên bản này sẽ chú trọng vào việc thêm vào những tính năng của Python 3 (chính xác là Python 3.1). Những cải tiến của phiên bản này bao gồm:

  • Thêm loại từ điển có sắp xếp
  • Thêm một số tính năng cho unittest như bỏ qua kiểm tra hay các phương pháp kiểm định mới.
  • Mô đun io mới cho tốc độ nhanh hơn
  • Tự đánh số các trường với phương pháp str.format()
  • Mô đun sysconfig mới.

…cùng nhiều thay đổi khác nữa. Thông tin chi tiết về phiên bản này có thể được xem tại:

Có những gì mới trong Python 2.7?

Danh sách các thay đổi của Python 2.7

Lập trình web với Python (4)

written by Nguyễn Thành Nam, on Mar 10, 2010 12:46:00 PM.

Trong kỳ này, chúng ta sẽ xem xét một chương trình CGI có xử lý dữ liệu nhập.

Ở kỳ trước, chúng ta đã biết cấu trúc chung của một chương trình CGI. Chương trình CGI mà chúng ta dùng làm ví dụ không thật sự hữu dụng vì chúng chỉ xuất giá trị ngẫu nhiên.

Một chương trình CGI hữu dụng thường sẽ nhận dữ liệu nhập qua các mẫu đơn (form), xử lý các dữ liệu này, và trả về kết quả.

Các dữ liệu nhập được truyền đến ứng dụng web ở dạng bộ 2 (khóa, giá trị) (key-value pair). Ví dụ nếu chúng ta điền vào một mẫu đơn có trường nhập tên là name và giá trị của nó là Nguyễn Việt Nam thì khóa sẽ là name và giá trị là Nguyễn Việt Nam. Thông thường có hai phương thức truyền dữ liệu đến ứng dụng web là GET và POST.

Trong phương thức GET, các bộ 2 (khóa, giá trị) này sẽ được truyền qua URL. Với ví dụ ở trên, URL sẽ có dạng http://host/path?name=Nguyễn+Việt+Nam. Bạn đọc sẽ chú ý các điểm quan trọng sau:

  1. Đi ngay phía sau đường dẫn đến ứng dụng CGI là một dấu chấm hỏi (?). Ký tự này dùng để thông báo phần phía sau là dữ liệu nhập.
  2. Phân cách giữa khóa và giá trị của dữ liệu nhập là dấu bằng (=).
  3. Khóa và giá trị được chuyển mã theo dạng phù hợp. Chúng ta thấy rằng ký tự khoảng trắng được chuyển thành ký tự cộng (+). Việc chuyển mã này nhằm làm cho URL không chứa các ký tự đặc biệt có thể gây nhầm lẫn.
  4. Không được nêu rõ trong ví dụ là ký tự phân cách các bộ 2 (khóa, giá trị) là ký tự và (&).

Trong phương thức POST, các bộ 2 (khóa, giá trị) được truyền trong nội dung yêu cầu HTTP, và không hiện rõ cho người dùng.

Hãy thử nghiệm với chương trình ví dụ sau (đặt tên nó là fp.py):

#!c:/python26/python

print "Content-Type: text/html"
print

print """<html>
	<head>
		<title>CGI form processing</title>
	</head>
	<body>
		<fieldset>
			<legend>Number guessing game</legend>
			<form method="POST">
				<label for="number">Enter a number</label>
				<input type="text" name="number" value="" />
				<input type="submit" />
			</form>
		</fieldset>
	</body>
</html>
"""

Kết quả mà chúng ta nhận được là một mẫu đơn như hình:

/static/web-programming/cgi/form1.png

Một số điểm quan trọng trong chương trình này là sự sử dụng các thẻ liên quan đến mẫu đơn.

  1. Trước hết là thẻ form dùng để thông báo sự bắt đầu của một mẫu đơn. Các thuộc tính (attribute) thông thường của thẻ này gồm methodaction.
  2. Thuộc tính method xác định phương thức truyền dữ liệu. Chúng ta có thể sử dụng GET hoặc POST.
  3. Thuộc tính action xác định đường dẫn đến chương trình CGI sẽ xử lý mẫu đơn này. Nếu không xác định thì chính địa chỉ hiện tại sẽ được dùng.
  4. Thẻ input xác định một trường nhập. Thẻ này có các thuộc tính chính là type, name, và value.
  5. Thuộc tính type xác định kiểu nhập là một ô nhập (text box), một nút nhấn (button), một nút chọn (radio button), hoặc một tập tin (file). Ở ví dụ này chúng ta xác định một ô nhập với kiểu text.
  6. Thuộc tính name xác định khóa của bộ 2. Trong ví dụ này khóa nhập là number.
  7. Thuộc tính value xác định giá trị khởi đầu của trường nhập này. Chúng ta để trống.
  8. Thẻ input với thuộc tính typesubmit sẽ tạo một nút nhấn. Nút nhấn này đặc biệt vì nó sẽ gửi các giá trị chúng ta nhập vào mẫu đơn đến chương trình CGI.

Thông tin chi tiết về các thẻ HTML có thể được xem thêm từ các tài liệu từ W3C.

Chương trình này cũng chỉ là in ra một mẫu đơn nhưng chúng ta đã có thể nhấn nút để gửi mẫu đơn đó đi.

Chúng ta sẽ sửa nó để in lại những gì đã nhận từ trình duyệt.

#!c:/python26/python

import cgi

print "Content-Type: text/html"
print

print """<html>
	<head>
		<title>CGI form processing</title>
	</head>
	<body>
		<fieldset>
			<legend>Number guessing game</legend>
			<form method="POST">
				<label for="number">Enter a number</label>
				<input type="text" name="number" value="" />
				<input type="submit" />
			</form>
		</fieldset>
"""

form = cgi.FieldStorage()
if form.has_key('number'):
	print """You have entered: %s""" % form.getfirst('number')

print """</body>
</html>
"""

Điều đầu tiên chúng ta nhận ra là sự sử dụng mô-đun cgi. Mô-đun này cho phép chúng ta tạo một đối tượng FieldStorage. Đối tượng FieldStorage chứa các bộ 2 (khóa, giá trị) chúng ta nhận được từ trình duyệt trong một cấu trúc như kiểu từ điển. Do đó chúng ta có thể dùng phương thức has_key để kiểm tra sự tồn tại của khóa tương ứng. Để lấy giá trị từ FieldStorage ta có thể dùng form[’number’].value hoặc gọi các hàm như getvalue, getfirst, hay getlist. Các hàm này được đề cập đến một cách chi tiết trong bộ tài liệu sử dụng Python.

Nếu tinh ý, chúng ta sẽ thấy rằng khi dữ liệu nhập chứa các thẻ HTML hợp lệ thì kết quả xuất ra sẽ hiển thị cả những thẻ HTML này. Ví dụ khi ta nhập Nguyễn <b>Việt</b> Nam.

/static/web-programming/cgi/form2.png

Điều này có thể là đúng theo ý định, hoặc cũng thể nằm ngoài mong muốn. Chúng ta gọi đây là các lỗi kịch bản chéo trang (Cross Site Scripting, XSS). Cách khắc phục là trước khi hiển thị các chuỗi không nằm trong kiểm soát của chương trình (ví dụ như dữ liệu nhập, dữ liệu xuất từ hệ thống khác, v.v…), chúng ta sẽ cần chuyển mã các ký tự đặc biệt. Mô-đun cgi cung cấp hàm escape để làm việc này. Mã nguồn mới sẽ gói getfirst trong cgi.escape như sau:

#!c:/python26/python

import cgi

print "Content-Type: text/html"
print

print """<html>
	<head>
		<title>CGI form processing</title>
	</head>
	<body>
		<fieldset>
			<legend>Number guessing game</legend>
			<form method="POST">
				<label for="number">Enter a number</label>
				<input type="text" name="number" value="" />
				<input type="submit" />
			</form>
		</fieldset>
"""

form = cgi.FieldStorage()
if form.has_key('number'):
	print """You have entered: %s""" % cgi.escape( \
			form.getfirst('number'), True)

print """</body>
</html>
"""

Giờ đây, chuỗi được xuất ra sẽ giống hệt với chuỗi nhập.

/static/web-programming/cgi/form3.png

Chúng ta cũng có thể thử với phương thức GET bằng cách nhập thẳng URL http://localhost/cgi-bin/fp.py?number=Nguyễn+<b>Việt</b>+Nam. Chúng ta cũng sẽ nhận được kết quả tương tự.

Vậy là qua hai phần chúng ta đã tìm hiểu về cách hoạt động của một chương trình CGI. Điểm mạnh của giao thức CGI là tính đơn giản và an toàn cao vì mỗi yêu cầu được một tiến trình riêng xử lý. Cũng chính vì mô hình đơn giản như vậy nên CGI gặp phải nhiều cản trở trong việc phát triển. Cản trở đầu tiên là chương trình CGI phải tự xử lý trạng thái giữa các yêu cầu kế tiếp nhau, hay còn gọi là phiên làm việc (session). Cản trở thứ hai là chương trình CGI sẽ phải được thiết kế đặc biệt nếu muốn sử dụng các biến có phạm vi toàn ứng dụng (application scope). Cuối cùng, chương trình CGI chạy chậm hơn và tốn tài nguyên hơn vì mỗi yêu cầu phải được xử lý riêng.

Trong các phần tới, chúng ta sẽ xem qua cách hoạt động của những công nghệ tiên tiến, giải quyết được các điểm yếu của giao thức CGI.

Trao giải cuộc thi lập trình game bằng Python

written by Nguyễn Thành Nam, on Feb 5, 2010 10:56:00 AM.

Ngày 04 tháng 02 năm 2009, nhóm PCNV đã trao giải cuộc thi lập trình game với ngôn ngữ Python cho bạn Hoàng Quốc Thịnh.

Cuộc thi lập trình game với ngôn ngữ Python là một trong những hoạt động của nhóm PCNV nhằm lôi cuốn sự tham gia tìm hiểu và khuyến khích sáng tạo trong việc sử dụng ngôn ngữ Python.

Ngôn ngữ Python là một ngôn ngữ mạnh, đơn giản, và tổng quát. Ngoài việc được sử dụng trong các tổ chức lớn như Google, và NASA, Python còn được dùng để viết nên những trò chơi như EVE-Online với cả triệu người chơi, hay Ruồi Yêu Cứt với giải thưởng lập trình game bằng Python đầu tiên.

Xin chúc mừng bạn Hoàng Quốc Thịnh.

Hình bên dưới là bạn Nguyễn Thành Nam đại diện nhóm PCNV đang trao giải cho bạn Hoàng Quốc Thịnh trong bữa ăn thân mật. Hình chụp bởi nhiếp ảnh gia Thành Nguyễn (Malaysia) và sửa đôi chút bởi nhiếp ảnh gia Nguyễn Duy Thọ.

/static/game_programming_contest_prize.png

Lập trình web với Python (3)

written by Nguyễn Thành Nam, on Jan 28, 2010 4:52:25 PM.

Sau khi đã cài đặt máy chủ web, và Python ở hai bài trước, trong bài này chúng ta sẽ bước vào thế giới lập trình web với mô hình đơn giản nhất, mô hình CGI.

CGI là viết tắt của Common Gateway Interface, dịch chính xác là giao tiếp cổng chung. Giao thức này được sinh ra để chuẩn hóa (hay xác định rõ) cách thức một máy chủ web giao phó việc tạo trang web cho các ứng dụng console (các ứng dụng nhận dữ liệu từ bộ nhập chuẩn và xuất ra bộ xuất chuẩn). Các ứng dụng này được gọi là các ứng dụng CGI, hay kịch bản CGI vì chúng thường được viết bằng ngôn ngữ kịch bản, mặc dù chúng cũng có thể được viết bằng các ngôn ngữ khác như C, Java.

Mô hình hoạt động

Thông thường, một máy chủ web nhận yêu cầu từ máy khách và tìm kiếm trên hệ thống xem có tập tin mà máy khách cần truy xuất hay không. Nếu có thì máy chủ web sẽ xuất nội dung của tập tin này cho máy khách.

Trong giao thức CGI, máy chủ web nhận yêu cầu từ máy khách, tìm kiếm trên hệ thống xem có ứng dụng CGI đó không. Nếu có thì máy chủ web sẽ thực thi ứng dụng CGI, chuyển toàn bộ yêu cầu đến ứng dụng thông qua các biến môi trường và bộ nhập chuẩn. Ứng dụng CGI sẽ xử lý yêu cầu rồi gửi trả thông tin cho máy chủ web qua bộ xuất chuẩn. Máy chủ web sẽ nhận thông tin từ bộ xuất chuẩn của ứng dụng CGI để xuất trả lại cho máy khách. Mô hình hoạt động của giao thức CGI được miêu tả trong hình sau.

/static/web-programming/cgi/cgi-model.png

Hello World

Để hiểu rõ hơn cách hoạt động, chúng ta sẽ tạo một tập tin helloworld.py trong thư mục C:\Program Files\Apache Software Foundation\Apache2.2\cgi-bin với nội dung như sau:

#!c:/python26/python

print "Content-Type: text/html"
print ""
print "Hello world."

Trước khi giải thích từng dòng lệnh, chúng ta sẽ xem xem kết quả đạt được là gì. Chúng ta sẽ dùng trình duyệt để vào trang http://localhost/cgi-bin/helloworld.py. Dĩ nhiên chúng ta cũng phải đảm bảo rằng máy chủ Apache đang chạy. Và đây là hình mà chúng ta nhận được.

/static/web-programming/cgi/helloworld.png

Các yếu tố chính của chương trình CGI

Như thế, chương trình CGI đầu tiên đã thực thi hoàn chỉnh. Hãy quay lại xem các yếu tố căn bản của một chương trình CGI viết bằng ngôn ngữ Python.

Dòng đầu tiên được gọi là dòng shebang với hai ký tự đặc biệt #!. Phần đi ngay sau hai ký tự này là đường dẫn tuyệt đối đến trình thông dịch Python trên hệ thống. Dòng này nói cho máy chủ web biết rằng tập tin này cần được đọc bởi trình thông dịch Python.

Dòng lệnh print thứ nhất cung cấp một đầu mục (header) cho máy chủ web. Đầu mục này là Content-Type với nội dung là text/html. Đây là đầu mục bắt buộc trong giao thức HTTP, do đó các ứng dụng CGI thông thường phải cung cấp đầu mục này.

Dòng lệnh in thứ hai (in ra một dòng trống) báo hiệu sự kết thúc của các đầu mục, và những gì theo sau sẽ là dữ liệu nội dung. Dòng lệnh này là bắt buộc.

Dòng lệnh in thứ ba xuất nội dung chính, là chuỗi Hello world..

Các dòng lệnh này là những yếu tố chính cấu tạo nên một chương trình CGI viết bằng ngôn ngữ Python. Điểm quan trọng nhất mà chúng ta cần lưu ý là việc xuất dữ liệu thông qua bộ xuất chuẩn (stdout), và định dạng của dữ liệu cần xuất (đầu mục, dòng trống, nội dung).

Thêm vào các thẻ HTML

Chương trình của chúng ta khá buồn tẻ vì chúng ta khai báo Content-Typetext/html nhưng chúng ta không dùng thẻ HTML. Chúng ta hãy sửa lại chương trình như sau:

#!c:/python26/python

print "Content-Type: text/html"
print ""
print """<html>
	<head>
		<title>Python!</title>
	</head>
	<body>
		<font size="+3">H</font>ello <font color="red">HTML</font>.
	</body>
</html>"""

Quay lại trình duyệt và làm tươi (F5, hay Ctrl-R), chúng ta sẽ thấy hình như sau:

/static/web-programming/cgi/hellohtml.png

Content-Type là quan trọng

Những gì chúng ta vừa thực hiện là thay đổi nội mà chúng ta xuất ra bộ xuất chuẩn.

Bây giờ, giữ cùng nội dung đấy, nhưng chúng ta thay đổi đầu mục Content-Type thành text/plain.

#!c:/python26/python

print "Content-Type: text/plain"
print ""
print """<html>
	<head>
		<title>Python!</title>
	</head>
	<body>
		<font size="+3">H</font>ello <font color="red">HTML</font>.
	</body>
</html>"""

Thử xem trang này với các trình duyệt chuẩn ví dụ Opera, hoặc Firefox thì chúng ta sẽ nhận được hình tương tự như sau:

/static/web-programming/cgi/hellohtmlplain.png

Thay vì xử lý những thẻ HTML một cách đặc biệt thì trình duyệt đã không làm như vậy. Và đây là cách làm đúng bởi vì chúng ta nói cho trình duyệt biết rằng nội dung của chúng là ở dạng văn bản thường (plaintext) thông qua đầu mục Content-Type như trên. Trình duyệt IE không tuân theo chuẩn HTTP một cách triệt để nên vẫn sẽ hiển thị nội dung của chúng ta dưới dạng một trang HTML.

Một ít dữ liệu động

Mục đích của chương trình CGI là xử lý và xuất dữ liệu nên sẽ là vô ích nếu chương trình CGI của chúng ta chỉ xuất các trang web tĩnh. Chúng ta sẽ sửa lại chương trình một chút như sau:

#!c:/python26/python

import random

actions = ("rocks", "rules", "kicks butt", "constricts camel")

print "Content-Type: text/html"
print ""
print """<html>
	<head>
		<title>Python!</title>
	</head>
	<body>
		Python %s.
	</body>
</html>""" % random.choice(actions)

Trong chương trình này, chúng ta sử dụng mô-đun random và hàm choice để chọn một hành động ngẫu nhiên. Khi làm tươi trình duyệt, chúng ta có thể gặp các hình tương tự như sau.

/static/web-programming/cgi/dynamic1.png

/static/web-programming/cgi/dynamic2.png

Tóm tắt

Trong kỳ này chúng ta đã được giới thiệu về mô hình hoạt động của giao thức CGI, các yếu tố quan trọng trong một chương trình CGI viết bằng ngôn ngữ Python, một ít kiến thức về giao thức HTTP, và sự đa dạng của thế giới trình duyệt web. Ở kỳ sau chúng ta sẽ tìm hiểu cách nhận dữ liệu từ máy khách qua URL và mẫu đơn (form).

Python One-Liner

written by Phạm Thị Minh Hoài, on Jan 22, 2010 11:30:00 PM.

Python One-Liner là trường phái viết Python trên một dòng. Theo đó mỗi một hành động xác định được viết bởi các lệnh cô đọng gom lại trên một dòng duy nhất. Hành động xác định không phải là những hành động quá phức tạp, nhưng cũng không quá đơn giản. Ví dụ việc trao đổi giá trị giữa hai biến có thể coi là một hành động xác định như vậy. Python cho phép thực hiện điều này trên một dòng với một lệnh duy nhất, và với tôi đó là một trong những lệnh Python đẹp nhất:

>>> a, b = b, a

Python One-Liners cũng chính là tập hợp các mẹo (trick) Python nhằm giải quyết các bài toán nhỏ một cách ngắn gọn theo phương châm “do a lot with a little.”. Điều này thường khó thực hiện ở các ngôn ngữ khác. Nhưng chúng có thể thực hiện được trong Python do đặc trưng ngôn ngữ hỗ trợ cách viết như vậy. Chẳng hạn cách dùng hàm lambda, List Comprehensions, map, filter, zip, dict, set, … đã xây dựng những đặc trưng ngôn ngữ cho phép viết các mã ngắn gọn hơn các ngôn ngữ khác.

Trong bài viết này tôi sẽ tổng hợp một số các bài toán đơn giản mà triển khai Python có thể được viết trên một dòng. Chúng là các bài toán cơ bản có liên quan đến list. Tôi hi vọng những bạn chưa biết về các công thức trong bài này sẽ tìm thấy nhiều điểm lý thú, và qua đó càng hiểu được sức mạnh và sự hấp dẫn tuyệt vời của Python. Các công thức này một số được tôi thường xuyên sử dụng, một số được sưu tầm và các bạn có thể tìm thấy ở đâu đó trên internet.

1. Làm phẳng một list

Cho một list dạng hai chiều như sau: L = \[[1,2,3],[4,5,6], [7], [8,9]\] hãy biến nó thành dạng một chiều dạng [1, 2, 3, 4, 5, 6, 7, 8, 9]. Đây là một số lời giải một dòng của bài toán này:

>>> L = [[1,2,3],[4,5,6], [7], [8,9]]
>>> sum(L, [])
>>> reduce(lambda x, y: x + y, L)
>>> list(itertools.chain(L))  #import itertools.
>>> [item for sublist in L for item in sublist]

Python cung cấp cho bạn một tập hợp phong phú các cú pháp và hàm dựng sẵn cho phép bạn giải cùng một bài toán theo nhiều cách khác nhau. Trong các lời giải trên lời giải cuối cùng là nhanh nhất và nó cũng dễ hiểu nhất. Chi tiết các lời giải trên các bạn có thể xem trên trang: Making a flat list out of list of lists in python. Hàm reduce đã bị loại bỏ kể từ Python 3000 (Suggested by Guido van Rossum), tuy nhiên vẫn được giữa lại trong thư viện functools, do vậy bạn có thể dùng:

>>> functools.reduce(lambda x, y: x + y, L)

Nếu list L không phải là hai chiều, mà có thể chứa các list con đệ quy, bạn có thể dùng hàm sau:

def flatten(seq, a = list()):
    try:                          
        for item in seq:          
            flatten(item, a)      
    except TypeError:             
        a.append(seq)             
    return a

print flatten([[1,2, [3,4], 5], 6, [7, [8, 9]]])

2. Loại bỏ các phần tử trùng nhau trong list

Hãy tạo ra một list mới chứa các phần tử không trùng nhau của L. Một số cách giải trên một dòng:

>>> L = dict.fromkeys(L).keys()  # Python 3.x trả về iterator
>>> L = list(set(L))
>>> [x for i, x in enumerate(L) if i==L.index(x)]

Với L = [5,6,1,1,1,2,2,2,3,3,3] hai lời giải trên cho kết quả [1, 2, 3, 5, 6]. Lời giải cuối cùng cho kết quả [5, 6, 1, 2, 3]. Như vậy trong một số tình huống lời giải cuối cùng tốt hơn, do nó vẫn giữa được thứ tự các phần tử như ban đầu. Tuy vậy lời giải cuối cùng chạy rất chậm. Hãy xem kết quả đo thời gian chạy của các lời giải như sau:

>>> from timeit import Timer
>>> Timer("list(set(L))", "L = range(10**4)").timeit(10)
0.030437396173560671
>>> Timer("dict.fromkeys(L).keys()", "L = range(10**4)").timeit(10)
0.027800167602894277
>>> Timer("[x for i, x in enumerate(L) if i==L.index(x)]", "L = range(10**4)").timeit(10)
25.005568798618903

Việc so sánh thời gian chạy giữa các Python One-Liner rất hay được các tác giả thực hiện. Chúng đánh giá khả năng sử dụng thực tế của mỗi công thức. Lời giải cuối cùng như các bạn thấy dù có ưu điểm song không thể dùng được khi có test xấu trên 10000 phần tử.

3. Đếm số phần tử có trong một list

Nếu chỉ đếm một phần tử thì quá đơn giản, dùng list.count là xong, nhưng nếu để đếm tần số cho nhiều item một lúc thì làm thế nào. Chẳng hạn có L = [5,6,1,1,1,2,2,2,3,3] muốn tạo ra D={5:1, 6:1, 1:3, 2:3, 3:2}.

>>> dict([(x, L.count(x)) for x in set(L)])
>>> {x: L.count(x) for x in set(L)} # dict comprehensions, có từ Python 3.x
>>> collections.Counter(L) # import collections, có từ Python 3.x

Lời giải số một tuy dài nhưng có thể chạy trên hầu hết các bản Python > 2.4. Lời giải số hai chẳng qua là từ 1 ra nhưng với cú pháp mới của Python 3.x nó dễ hiểu và đơn giản hơn. Lời giải cuối cùng đơn giản đến mức bạn chỉ cần có import collections. Module collections chứa các phương tiện cho phép bạn viết các mã Python ngắn gọn, và chạy rất nhanh. Một ví dụ khác về cách dùng Counter trong module collections, đoạn mã này cho phép đếm tần số xuất hiện của các ký tự trong một string:

>>> collections.Counter("abcabca")
Counter({'a': 3, 'c': 2, 'b': 2})

Càng về sau này các phiên bản Python càng hỗ trợ nhiều hơn các cú pháp và thư viện cho phép bạn viết các mã ngắn gọn hơn. Đây là đặc trưng của Python: “Viết ít hơn làm nhiều hơn”. Việc gia tăng hiểu biết của bạn về các thư viện là một kinh nghiệm quan trọng.

4. Chia một list thành nhiều list

Bài toán chia một list thành nhiều list có thể gặp hai yêu cầu:

  1. Chia list thành nhiều list có độ dài bằng nhau
  2. Chia list thành n list con có độ dài tương đương nhau (với khác biệt kích thước nhỏ nhất).

Vấn đề số một có thể giải quyết bằng các hàm sau:

>>> SplitInto=lambda a,n: [a[i*n:(i+1)*n] \
... for i in range(len(a) % n and len(a)/n + 1 or len(a)/n)]
>>> SplitInto(range(10), 3)
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]

>>> SplitInto = lambda L, n: zip(*[chain(L, repeat(None, n-1))]*n)
>>> SplitInto(range(10), 3)
<zip object at 0x01D607D8>
>>> list(SplitInto(range(10), 3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, None, None)]

>>> SplitInto = lambda L, n: zip_longest(*[iter(L)]*n)
>>> list(SplitInto(range(10), 3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, None, None)]
>>> SplitInto = lambda L, n: zip_longest(*[iter(L)]*n, fillvalue=-1)
>>> list(SplitInto(range(10), 3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, -1, -1)]

>>> SplitInto= lambda L, n: [L[i:i+n] for i in range(0, len(L), n)]
>>> SplitInto(range(10), 3)
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]

Lời giải số 1, 4 dùng cho các phiên bản Python từ 2.3 trở đi. Hai lời giải 2, 3 sau đòi hỏi phải có lệnh from itertools import * và chỉ chạy từ Python 3.x trở đi. Chi tiết về các lời giải này các bạn có thể xem thêm: How do you split a list into evenly sized chunks in Python?

Vấn đề số 2 có thể có lời giải sau:

>>> SplitInto = lambda L, n: [L[i::n] for i in range(n)]
>>> SplitInto(range(10), 3) # SplitInto(list(range(10)), 3) với Python 3.x
[[0, 3, 6, 9], [1, 4, 7], [2, 5, 8]]

Lời giải trên là đơn giản đến mức …không cần tìm thêm các lời giải khác làm gì cho mệt. Tuy nhiên nó không chia theo đúng thứ tự. Đây là cách khác phức tạp hơn nhưng giữa nguyên được thứ tự các phần tử:

>>> SplitInto = lambda L, n: [L[int(i*1.0*len(L)/n):int((i+1)*1.0*len(L)/n)] \
... for i in range(n)]
>>> SplitInto(range(10), 3)
[[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
>>> SplitInto(range(10), 2)
[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
>>> SplitInto(range(10), 4)
[[0, 1], [2, 3, 4], [5, 6], [7, 8, 9]]

Cách viết này khá dài, nhưng giữa nguyên được thứ tự giữa các phần tử. Các dòng dài chính là đặc trưng của Python One-liner.

5. Kiểm tra một list là tập con của list khác

Cho hai list a, b. kiểm tra xem a có chứa b hay không. Danh sách a chứa danh sách b nếu tất cả các phần tử của b đều có trong a. Cách giải sau đã có lần tôi trình bày, dùng thư viện operator và hàm built-in reduce, có thể dùng với mọi phiên bản Python 2.x:

>>> a = [1,2,3,4,5]
>>> b = [2,3,6]
>>> c = [2,3,4]
>>> reduce(operator.and_, map(a.__contains__, b))
False
>>> reduce(operator.and_, map(a.__contains__, c))
True

Từ Python 2.4 bạn có thể sử dụng set:

>>> set(a+b) == set(a)
False
>>> set(a+c) == set(a)
True
>>> set(c).issubset(a)
True
>>> set(b).issubset(a)
False
>>> set(c) <= set(a)
True
>>> set(b) <= set(a)
False

Từ Python 2.5 bạn có thể viết:

>>> all([x in a for x in b])
False
>>> all([x in a for x in c])
True

Module operator cung cấp cách dùng các toán tử như các hàm. Trong ví dụ 1 thực tế chúng ta dùng toán tử in thông thường. Các toán tử dùng như các hàm cho phép kết hợp với các hàm built-in khác để viết các lệnh Python rất ngắn gọn và thuận tiện. Một ví dụ (được lấy trong tài liệu Python) tính tích vô hướng hai vector:

sum(map(operator.mul, vector1, vector2))

Thật khó để viết ngắn hơn và chạy nhanh hơn như vậy. Các ví dụ trên càng nói rõ hơn điều tôi đã nhấn mạnh ở mục 3: các phiên bản Python càng về sau càng hỗ trợ tốt hơn việc viết các mã ngắn gọn và hiệu quả. Tuy vậy bạn phải cân nhắc lựa chọn giải pháp đúng cho phiên bản Python mà nó sẽ chạy.

6. Sắp xếp nhiều column

Cho các column a,b,c…có cùng kích thước. Hãy sắp xếp chúng theo thứ tự a,b,c.... Nội dung các dòng không thay đổi. Dưới đây là một ví dụ triển khai với 2 cột a, b:

>>> a = [3,3,2,2,1,1]
>>> b = ["c", "b", "b", "a", "c", "a"]
>>> a, b = zip(*sorted(zip(a, b)))
>>> a
(1, 1, 2, 2, 3, 3)
>>> b
('a', 'c', 'a', 'b', 'b', 'c')

Thật tuyệt!!!. Chúng đơn giản đến mức khó có thể ngắn gọn hơn nữa. Công thức trên trọn vẹn trên một dòng có ít hơn 80 ký tự. Tất cả chỉ có 4 lệnh. Ít nhất nó cũng gây cho tôi nhiều sự phấn khích và ngạc nhiên. Và các bạn sẽ thấy trên nhiều forum Python, việc tìm kiếm các “One-Liner” thực sự là thú vị và là trò chơi hấp dẫn của các Python guru.

7. Tổng kết

Khi kích thước dữ liệu đầu vào lớn một số trong các hàm trả về list trên đây cần được thay thế bằng các hàm trạng thái. Chẳng hạn việc chia một list thành nhiều list bằng nhau nên viết thành hàm trạng thái, sẽ dùng ít bộ nhớ và nhanh hơn:

def SplitInto(a, n):
    start = 0
    end = len(a) % n and len(a)/n + 1 or len(a)/n
    
    while start < end:
        yield a[start * n: (start + 1) * n]
        start += 1

Chuẩn viết mã Python là không quá 80 ký tự trên một dòng. Python One-Liner viết hết các lệnh Python trên một dòng, làm cho các line dài hơn bình thường. Mã Python khó đọc và khó hiểu hơn do cách viết cô đọng, các biến được đặt tên ngắn. Với các bài toán không mang tính cơ bản, các bạn nên hạn chế viết theo cách này.

Các chương trình viết trên một dòng không có nghĩa là nhanh nhất. Thậm chí trong đa số các trường hợp để viết trên một dòng người ta phải chọn cách viết mất nhiều thời gian chạy hơn. Do vậy khi kích thước dữ liệu lớn, tốt hơn hết hãy lựa chọn cách viết tối ưu, và chấp nhận mã dài hơn.

Tôi hi vọng rằng các bạn sẽ thích thú với các ví dụ trên đây. Chắc chắn còn nhiều cách giải khác cho mỗi vấn đề mà tôi đã nêu ra. Nếu các bạn tìm thấy chúng xin hãy vui lòng comment để mọi người cùng biết. Điều sau cùng tôi muốn nhấn mạnh là tuy việc tìm kiếm các lời giải một dòng cho mỗi vấn đề chỉ đơn giản là thú vui, ít mang tính ứng dụng - nhưng chúng thực sự sẽ thúc đẩy việc học hỏi và tìm kiếm kinh nghiệm của chúng ta.

Một số bài tập Python có thể triển khai trên một dòng:

  • Tạo ma trận đơn vị kích thước bất kỳ
  • Triển khai sàng Sieve of Eratosthenes
  • Triển khai dãy số Fibonacci.
  • Tạo một list chứa tất cả các hoán vị của một list khác (các phần tử có thể bằng nhau).

Hoaiptm.

"Efficient arrays" có nhanh hơn list?

written by Phạm Thị Minh Hoài, on Jan 16, 2010 11:20:00 PM.

1. Giới thiệu về “Efficient arrays”

Kiểu dữ liệu list có thể chứa đựng bất kỳ cái gì thuộc bất kỳ cấu trúc nào. Khái niệm về list (hay danh sách) trong Python gần gũi với ý niệm về cái túi (a bag). Một bag có thể chứa bánh kẹo, hoa quả, quần áo,… Điểm khác biệt là list thì có thứ tự, các phần tử được truy cập qua một index duy nhất.

Về điểm này list khác với khái niệm về array - hay mảng trong các ngôn ngữ thông thường khác. Chẳng hạn trong VB.NET một array là một danh sách có thứ tự các phần tử có cùng cấu trúc. Bạn luôn luôn phải chỉ rõ kiểu của phần tử trong mỗi array qua khai báo array of type.

Chính vì list có thể chứa bất kỳ phần tử thuộc bất kỳ cấu trúc nào mà một số thao tác phụ thuộc vào cấu trúc dữ liệu trên mỗi phần tử có thể chậm đi đáng kể. Hay một số thao tác thông thường có sẵn trong các ngôn ngữ khác đã không được triển khai trong Python do kiểu dữ liệu có thể khác nhau giữa các phần tử. Chẳng hạn việc sắp xếp một danh sách sẽ chậm đi do phải xác định chính xác kiểu dữ liệu của mỗi phần tử khi so sánh. Việc đọc một list từ file text hoặc từ một string sẽ không được triển khai bằng các hàm built-in.

Python hỗ trợ bạn tạo ra các list hiệu quả và chặt chẽ hơn bằng khái niệm “Efficient arrays” có trong thư viện array. Tuy nhiên module này chỉ hỗ trợ kiểu dữ liệu số và ký tự. Bạn không thể dùng các “Efficient arrays” cho các string hay boolean.

Ví dụ:

>>> from array import array
>>> array('I', range(10))
array('I', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> array.array('u', "hello")
array('u', 'hello')

Ví dụ 1 khai báo một mảng (hay array) các số nguyên unsiged int chứa các giá trị từ 0 đến 9. ‘I’ gọi là type code - một giá trị quy định kiểu của mỗi item trong mảng. Đoạn mã phía sau đó khai báo một array của các ký tự unicode. Dưới đây là danh sách các type code được hỗ trợ trong Python 3.1:

Type codeC TypePython TypeMinimum size in bytes
‘b’signed charint1
‘B’unsigned charint1
‘u’Py_UNICODEUnicode character2 (see note)
‘h’signed shortint2
‘H’unsigned shortint2
‘i’signed intint2
‘I’unsigned intint2
‘l’signed longint4
‘L’unsigned longint4
‘f’floatfloat4
‘d’doublefloat8

Như trong tài liệu Python viết. Kích thước thực sự của một số type code như ‘i’, ‘I’, ‘l’, ‘L’ phụ thuộc vào kiến trúc máy tính triển khai python (thông thường là sự khác biệt giữa kiến trúc 32 bit và 64 bit - xem thêm: Integer - computer science). Kiểu của mỗi phần tử trong mảng chính xác là kiểu của ngôn ngữ C tương ứng trong bảng, vì vậy kích thước của mảng luôn có thể xác định chính xác. Điều này khác với list. Khi nhận được một list rất khó để xác định chính xác kích thước bộ nhớ của nó. Module array có các hàm buffer_info()itemsize cho phép thực hiện điều này. Hàm buffer_info() cho kết quả một tuple chứa địa chỉ bộ nhớ và số phần tử của mảng. Hàm itemsize cho biết kích thước của mỗi phần tử theo byte. Để tính kích thước bộ nhớ mà python cấp phát cho mảng dùng biểu thức: x.buffer_info()[1]*x.itemsize. Ví dụ:

>>> x = array.array('u', "python")
>>> x.itemsize
2
>>> x.buffer_info()
(29756264, 6)
>>> x.buffer_info()[1]*x.itemsize
12

Các mảng quy định rõ kiểu giá trị nó chứa, vì vậy không thể lưu các giá trị vượt phạm vi cho phép hoặc các giá trị không đúng kiểu. Python báo lỗi khi xảy ra sự kiện này:

>>> array.array("L", [2**32])
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
OverflowError: python int too large to convert to C unsigned long

>>> array('I', [])
array('I')
>>> array('I', [None])
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
TypeError: an integer is required

Trong python 3.* type code ‘c’ không còn được sử dụng do từ Python 3.0 trở đi kiểu dữ liệu string luôn luôn là unicode.

>>> array('c', ['a'])
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
ValueError: bad typecode (must be b, B, u, h, H, i, I, l, L, f or d)

Type code ‘u’ cũng sẽ khác nhau về kích thước trên các hệ điều hành khác nhau, khi chúng triển khai UCS2 (2 byte) hoặc UCS4 (4 byte). Để biết máy bạn dùng UCS mấy gõ lệnh sau:

>>> import sys
>>> sys.maxunicode
65535

Đó là UCS2, trên hệ thống mà python được compile với UCS4 kết quả phải lớn hơn.

Module array có hầu hết các phương thức tương tự list:

>>> dir(array('d', []))
['__add__', '__class__', '__contains__', '__copy__', '__deepcopy__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__format__', '__ge__',
 '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', 
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', 
'__subclasshook__', 'append', 'buffer_info', 'byteswap', 'count', 'extend', 'fromfile', 'fromlist', 'fromstring', 'fromunicode', 'index', 
'insert', 'itemsize', 'pop', 'remove', 'reverse', 'tofile', 'tolist', 'tostring', 'tounicode', 'typecode']

Trong danh sách trên ta thấy array không có phương thức sort giống như list. Để sắp xếp các array, bạn có thể dùng hàm sorted. Hàm sorted là hàm built-in, khác với list.sort nó tạo ra list mới và không thay đổi list gốc.

>>> from array import array
>>> example = array('d', [math.pi, math.e, math.log(10)])
>>> sorted(example)
[2.302585092994046, 2.718281828459045, 3.141592653589793]
>>> sorted(example, reverse = True)
[3.141592653589793, 2.718281828459045, 2.302585092994046]

2. “Efficient arrays” nhanh hơn list như nào?

Trong phần này chúng ta sẽ thực hiện một số kiểm tra performance giữa array và list trên một số thao tác điển hình. Chỉ một số thao tác được kiểm tra, kết quả thời gian có thể khác nhau với các phiên bản Python, hay các cấu hình máy khác. Tuy nhiên tôi cố gắng đặt các kiểm tra trong cùng một tập các điều kiện thí nghiệm, và chỉ xem xét tương quan giữa các con số nhằm rút ra một kết luận nào đó.

Đầu tiên là sắp xếp - thao tác cơ bản đặc trưng cho một list.

>>> from timeit import Timer
>>> Timer("a.sort()", "import random;a=list(range(10**4)); \
... random.shuffle(a)").timeit(100)
0.05681145858943637
>>> Timer("sorted(a)", "import random;a=list(range(10**4)); \
... random.shuffle(a)").timeit(100)
0.7554756694498792
>>> Timer("sorted(a)", "import random,array;a=array.array('L', range(10**4));\
... random.shuffle(a)").timeit(100)
0.8100354453472391

Ví dụ trên so sánh thời gian thực hiện của list.sort, sorted trên list, và sorted trên array khi sắp xếp mảng số nguyên 32 bit có 10 ngàn item. Chúng ta thấy thậm chí việc sắp xếp trên mảng bằng hàm sorted chậm hơn nhiều so với trên list.sort trong trường hợp này. Test này được thực hiện trên Python 3.1 với máy Pentium Dual Core 1.7MHz. Trên các phiên bản Python 2.x bạn chỉ cần viết a=range(104) thay vì a = list(range(104)) Tiếp tục khảo sát với số phần tử đến 100 ngàn, 1 triệu, 10 triệu phần tử:

>>> Timer("a.sort()", "import random;a=range(10**5);random.shuffle(a)").timeit(100)
1.0628812891800408
>>> Timer("sorted(a)", "import random;a=range(10**5);random.shuffle(a)").timeit(100)
13.890136599318794
>>> Timer("sorted(a)", "import random,array;a=array.array('L', range(10**5));\
... random.shuffle(a)").timeit(100)
14.082001048258462

>>> Timer("a.sort()", "import random;a=range(10**6);random.shuffle(a)").timeit(1)
1.8611051722955381
>>> Timer("sorted(a)", "import random;a=range(10**6);random.shuffle(a)").timeit(1)
1.9412927927796773
>>> Timer("sorted(a)", "import random,array;a=array.array('L', range(10**6));\
... random.shuffle(a)").timeit(1)
2.2266062190747107

>>> Timer("a.sort()", "import random;a=range(10**7);random.shuffle(a)").timeit(1)
25.894550537010218
>>> Timer("sorted(a)", "import random;a=range(10**7);random.shuffle(a)").timeit(1)
26.986440155994387
>>> Timer("sorted(a)", "import random,array;a=array.array('L', range(10**7));\
... random.shuffle(a)").timeit(1)
30.602503383151088

Hàm sort của list là in-place vì vậy nó nhanh hơn sorted do không phải thực hiện các thao tác cấp phát bộ nhớ để tạo list mới như sorted. Nó nhanh hơn đáng kể khi số phần tử là nhỏ. Trong test trên đây là khoảng 13 lần với 10 ngàn item và 100 ngàn item. Số các thao tác cấp phát bộ nhớ tăng tuyến tính theo số phần tử, trong khi số các phép so sánh tăng theo n*logn (hoặc nếu tốt hơn n*loglogn). Vì vậy khi tăng số lượng các item thì số các phép so sánh tăng nhanh hơn số các thao tác cấp phát bộ nhớ. Ở trên 1 triệu phần tử các phép toán so sánh chiếm đa số thời gian xử lý. Ta có thể thấy thời gian thực thi ở các hàm là tương đương nhau. Trên mức 10 triệu phần tử sự khác biệt không còn đáng kể nữa.

Hàm sorted thực thi trên array thường sẽ chậm hơn trên list trong sai khác thời gian tương đối nhỏ. Nguyên nhân có thể được giải thích là do sorted không tạo ra một array mà luôn luôn tạo ra một list. Rõ ràng sorted trên một array nhưng trả lại list sẽ chậm hơn khi sorted trên list trả lại list. Các Efficient arrays muốn nhanh hơn list thực sự cần một sort của riêng chúng.

Chuyển qua các thao tác khác với list. Chẳng hạn với hàm sum một list các số nguyên

>>> Timer("sum(x)", "x=range(1000)").timeit(10000)
0.60629310370359235
>>> Timer("sum(x)", "import array; x = array.array('d', range(1000))").timeit(10000)
0.74805731663627739

>>> Timer("sum(x)", "x=range(10000)").timeit(1000)
0.60768722812650822
>>> Timer("sum(x)", "import array; x = array.array('d', range(10000))").timeit(1000)
0.75720026176844613

>>> Timer("sum(x)", "x=range(10**5)").timeit(100)
1.1360591999478515
>>> Timer("sum(x)", "import array; x = array.array('d', range(10**5))").timeit(100)
0.73434230670147826

>>> Timer("sum(x)", "x=range(10**6)").timeit(10)
1.9724225132735
>>> Timer("sum(x)", "import array; x = array.array('d', range(10**6))").timeit(10)
0.73678350503251977

>>> Timer("sum(x)", "x=range(10**7)").timeit(10)
20.701364808722474
>>> Timer("sum(x)", "import array; x = array.array('d', range(10**7))").timeit(10)
7.399070781130149

Hàm sum với array chậm hơn khi số phần tử nhỏ và càng ngày càng nhanh hơn khi số phần tử lớn hơn. Test sau đây cũng chỉ ra join các string là nhanh hơn hàm tounicode của array.

>>> array('u', map(chr, range(65, 90))).tounicode()
'ABCDEFGHIJKLMNOPQRSTUVWXY'
>>> "".join(map(chr, range(65, 90)))
'ABCDEFGHIJKLMNOPQRSTUVWXY'
>>> Timer("array.array('u', map(chr, range(65, 90))).tounicode()", "import array").timeit()
14.721977927611988
>>> Timer("''.join(map(chr, range(65, 90)))", "").timeit()
8.788942485645748

Để loại bỏ các phần tử trùng nhau của một list từ python 2.4 trở đi bạn có thể dùng lệnh L = list(set(L)). Ví dụ:

>>> list(set([5,5,1,2,3,2,3]))
[1, 2, 3, 5]
>>> array('L', set([1,2,3,1,2,3]))
array('L', [1, 2, 3])

Ví dụ sau so sánh thời gian loại trùng của array và list sử dụng cú pháp này:

>>> Timer("array('L', set(x))", "from array import array; \
...  x = array('L', range(10**5))").timeit(10)
0.3053085107321749
>>> Timer("list(set(x))", "x = range(10**5)").timeit(10)
0.25598173543039593

>>> Timer("array('L', set(x))", "from array import array; \
... x = array('L', range(10**6))").timeit(10)
3.901955860623275
>>> Timer("list(set(x))", "x = range(10**6)").timeit(10)
2.275834090902208

>>> Timer("array('L', set(x))", "from array import array; \
... x = array('L', range(10**7))").timeit(1)
3.823739795026995
>>> Timer("list(set(x))", "x = range(10**7)").timeit(1)
2.216846163641094

Như vậy sử dụng array sẽ không hiệu quả bằng list trong tình huống này.

Việc đảo ngược một list cũng luôn luôn nhanh hơn đảo ngược một array. Ví dụ:

>>> Timer("x.reverse()", "x = range(10**7)").timeit(10)
0.30343171366575916
>>> Timer("x.reverse()", "import array; x = array.array('L', range(10**7))").timeit(10)
4.0138636612646224

Trên python 3.* bạn phải viết x = list(range(107)) do hàm range trong python 3.* trả về iterator chứ không phải list.

Với phép toán nhân list lại chậm hơn array. Ví dụ:

>>> Timer("100000*x", "from array import array; \
... x=array('u', u'hello world')").timeit(10)
0.077855393644313153
>>> Timer("100000*x", "x=list(u'hello world')").timeit(10)
0.20222266310884152

Dùng array sẽ kỳ hiệu quả hơn trong phép cộng:

>>> Timer("x + y", "from array import array;\
... x=array('L', range(10*7));y=x[:]").timeit(100)
0.00019484576660033781
>>> Timer("x + y", "x=range(10*7);y=x[:]").timeit(100)
0.0005318282637745142
>>> Timer("x + y", "from array import array;\
... x=array('L', range(1000));y=x[:]").timeit()
2.354171564954413
>>> Timer("x + y", "x=range(1000);y=x[:]").timeit()
20.363064586337714

Như vậy là không phải lúc nào array cũng nhanh hơn list. Ít nhất là trong thao tác đảo ngược mảng và sắp xếp. Trong hầu hết các tính toán với danh sách kích thước nhỏ, dùng list sẽ tiện và nhanh hơn.

Pygments 1.2 với kiểu Monokai

written by Nguyễn Thành Nam, on Jan 5, 2010 5:36:05 PM.

Ngày 01 tháng 01 năm 2010 (ngày đầu năm mới 2010), Georg Brandl đã công bố phiên bản 1.2, tên gọi Neujahr của gói Pygments.

Pygments là thư viện làm sáng cú pháp (syntax highlighter) tổng quát, và được sử dụng để tô điểm cho các phần mã nguồn ở chính trang PCNV này.

Người dùng có thể tải Pygments từ http://pypi.python.org/pypi/Pygments, hoặc xem qua một số ví dụ tại http://pygments.org/demo.

Phiên bản 1.2 không còn tương thích với Python 2.3, có hỗ trợ thêm một số cú pháp mới, và đặc biệt là thêm vào kiểu màu Monokai như các bạn có thể thấy tại trang PCNV.

..and..or..

written by Phạm Thị Minh Hoài, on Jan 2, 2010 11:25:00 PM.

Trong bài viết trước về Phần tử không tôi có nói về việc cần phải cẩn thận khi dùng phép toán có tương tác giữa phần tử không và None. Trong bài này tôi trình bày một ví dụ nhỏ minh họa rõ hơn một vấn đề mà nhiều bạn mới học có thể gặp phải. Đó là phép toán rút gọn ..and..or.. khi có sự tham gia của None.

Cấu trúc if.. else và phép gán giá trị theo điều kiện trong python:

if condition:
        x = somevalue
else:
        x = othervalue

Có thể được viết trên một dòng:

x = condition and somevalue or othervalue

Ví dụ:

>>> x = 1+1*2 == 3 and "OK" or "DUREX"
>>> x
'OK'

Thực tế có nhiều bạn thích cách viết này. Vì nó gọn hơn và mang tính python hơn. Tuy nhiên hãy cẩn thận khi sử dụng cấu trúc này. Chẳng hạn trong cấu trúc:

x = condition and func1() or func2()

Hàm func1()func2() có thể có giá trị None, khi đó kết quả kỳ vọng có thể không như bạn mong muốn. Xét ví dụ:

def func1():
        return None

def func2():
        return "some value"

x = 1 + 1 == 2 and func1() or func2()
print x

Kết quả:

some value

Biểu thức logic là True song vì func1() == None nên x = True and None or func2() = “some value”

Vì vậy hãy cẩn thận khi dùng cấu trúc ..and..or.. trừ khi bạn biết rõ các giá trị tham gia biểu thức này luôn luôn khác None.

Từ phiên bản 2.5 trở đi Python hỗ trợ cấu trúc:

x = TrueValue if Condition else FalseValue

Ví dụ:

x = "OK" if 1+1 == 2 else "DUREX"

Hoaiptm.

Lập trình web với Python (2)

written by Nguyễn Thành Nam, on Jan 1, 2010 10:05:04 AM.

Cài đặt Python

Sau khi cài đặt máy chủ web Apache, chúng ta cần cài đặt trình thông dịch Python. Chúng ta sẽ sử dụng phiên bản 2.6.4 trong chuỗi bài viết này. Bộ cài đặt Python 2.6.4 có thể được tải về từ http://www.python.org/download/.

Khi thực thi phần cài đặt, chúng ta sẽ gặp một hộp thoại như sau:

/static/web-programming/install-python/python-install-1.png

Chọn Install for all users và nhấn nút Next để tiếp tới hình chụp sau:

/static/web-programming/install-python/python-install-2.png

Nếu bạn muốn cài đặt vào nơi khác thì chọn đường dẫn, nếu không thì chúng ta sẽ sử dụng đường dẫn mặc định C:\Python26. Nhấn nút Next để tiếp tục.

/static/web-programming/install-python/python-install-3.png

Chúng ta sẽ nhấn tiếp Next ở hộp thoại này để bắt đầu quá trình cài đặt các phần thông dụng như trình thông dịch, tài liệu, ví dụ…

/static/web-programming/install-python/python-install-4.png

Hộp thoại trên cho chúng ta biết quá trình cài đặt đang diễn ra.

/static/web-programming/install-python/python-install-5.png

Khi kết thúc, chúng ta chỉ cần nhấn nút Finish.

Để kiểm tra Python có được cài vào máy chưa thì chúng ta sẽ cần mở màn hình dấu nhắc lệnh (command prompt) bằng cách nhấn vào nút Start và nhập cmd.exe sau đó gõ phím Enter như bình bên dưới.

/static/web-programming/install-python/python-install-6.png

Chúng ta sẽ nhận được một cửa sổ dòng lệnh. Nhập vào cửa sổ dòng lệnh c:\Python26\python.exe thì chúng ta sẽ thấy rằng trình thông dịch Python được thực thi, và nó hiện ra một dấu nhắc tương tác (interactive prompt) như trong hình sau:

/static/web-programming/install-python/python-install-7.png

Ngay tại đây chúng ta có thể nhập một câu lệnh Python print 'web programming in python'. Câu lệnh này sẽ được thực hiện và kết quả là chúng ta sẽ nhận được chuỗi web programming in python in ra trên màn hình như hình sau:

/static/web-programming/install-python/python-install-8.png

Để thoát khỏi trình thông dịch Python, chúng ta sẽ nhập vào dòng lệnh quit().

/static/web-programming/install-python/python-install-9.png

Để thoát khỏi dấu nhắc dòng lệnh thì chúng ta nhập tiếp lệnh exit.

Như vậy, chúng ta đã thật sự hoàn tất việc cài đặt trình thông dịch Python. Nếu bạn có nhu cầu tìm hiểu thêm về ngôn ngữ và các thư viện đi kèm thì bài chỉ dẫn Python 2.5 bằng tiếng Việt có lẽ sẽ giúp ích nhiều cho bạn.

Chúng ta sẽ sẵn sàng cho chương trình web đầu tiên trong bài viết sau! Hẹn gặp lại và chúc mừng năm mới.

Phần tử không trong python

written by Phạm Thị Minh Hoài, on Dec 25, 2009 1:30:00 PM.

Bài viết này nêu lên một số khía cạnh thú vị (nhưng cũng rắc rối) của kiểu dữ liệu None cùng các phép toán liên quan đến nó, qua đó giúp các bạn mới học hiểu sâu sắc hơn về các kiểu dữ liệu có trong Python. Bài viết này có sử dụng một số khái niệm có trong lý thuyết nhóm chỉ nhằm mục đích minh họa những ý đồ của người viết.

1. Khái niệm phần tử không

Trong lý thuyết nhóm có khái niệm về phần tử không hay phần tử trung hòa. Phần tử không θ của một tập S trên phép toán * là phần tử thỏa mãn: a*θ = θ*a = a với mọi a trên S.

Các kiểu dữ liệu cơ bản trong Python cũng có phần tử không như vậy. Xem bảng tổng kết sau:

Kiểu dữ liệuPhép toánPhần tử khôngVí dụ
Số nguyên+00 + 69 = 69 + 0
Số thực+0.00.0 + 96.0 = 96.0 + 0.0
Danh sách+, extend[][1] + [] = [] + [1] = [1]
tuple+()(1,) + () = () + (1,) = (1,)
Tập hợpunionset([])set([1]).union(set([])) = set([]).union(set([1])) = set([1])
Chuỗi+“”“abc” + “” = “” + “abc” = “abc”
Từ điểnupdate{}{1:1}.update({}) == {}.update({1:1}) = {1:1}
Số phức+0+ 0j
LogicorFalseFalse or True = True or False = True

2. None và các toán tử logic

None là một tập hợp đặc biệt, chỉ có chính nó, mà cũng không phải là chính nó. Không phải là chính nó vì None bao hàm ý nghĩa là thiếu giá trị (denoting lack of value):

>>> type(None)
<type 'NoneType'>

None tương tác với tất cả các phần tử không:

>>> assert(([] and None) == [])
>>> assert(({} and None) == {})
>>> assert((0.0 and None) == 0.0)
>>> assert(("" and None) == "")
>>> assert((set([]) and None) == set([]))
>>> assert((() and None) == ())
>>> assert((0j and None) == 0J)
>>> assert((False and None) == False)

Nếu ta gọi S là tập hợp các phần tử không, bao gồm chính None, thì với phép toán and, None chính là phần tử không bên phải của S. Ai bảo None không phải là giá trị.

Tuy nhiên:

>>> assert((None and []) == None)
>>> assert((None and {}) == None)
>>> assert((None and set([])) == None)
>>> assert((None and "") == None)
>>> assert((None and 0) == None) 

Tương tự:

>>> assert((None or set([])) == set([]))
>>> assert((None or []) == [])
>>> assert((None or {}) == {})
>>> assert((None or "") == "")
>>> assert((None or 0) == 0)
>>> assert((None or 0j) == 0j)
>>> assert((None or ()) == ())

Nghĩa là None là phần tử không bên phải đối với tập S nói trên trong phép toán or.

Và:

>>> assert(({} or None) is None)
>>> assert(([] or None) is None)
>>> assert((0 or None) is None)
>>> assert((set([]) or None) is None)
>>> assert(("" or None) is None)
>>> assert((0j or None) is None)
>>> assert((() or None) is None)
>>> assert((0.0 or None) is None)

Như vậy khi None tương tác với các phần tử không, thứ tự các toán hạng là điều bạn cần chú ý.

Phép toán or giữa None và object bất kỳ không phải là phần tử không là ánh xạ đồng nhất bất kể thứ tự phép toán:

>>> set(['a']) or None
set(['a'])
>>> None or set(['a'])
set(['a'])
>>> None or "abc"
'abc'
>>> "abc" or None
'abc'
>>> None or {1:1}
{1: 1}
>>> {1:1} or None
{1: 1}

Phép toán and thì luôn cho kết quả None với bất kỳ phần tử nào không phải là phần tử không, không kể thứ tự toán hạng:

>>> assert((None and 1) is None)
>>> assert((1 and None) is None)
>>> assert(([1] and None) is None)
>>> assert((None and [1]) is None)
>>> assert(("abc" and None) is None)
>>> assert((None and "abc") is None)

Một biểu thức Logic chứa None có thể trả về None, nghĩa là không có giá trị. Điều này làm cho None trong python trở lên phức tạp và không giống với null trong C# hay nothing trong VB.NET. Trong VB.NET một biểu thức logic luôn luôn trả về giá trị logic.

None là tận cùng, là nhỏ hơn tất cả.

>>> None < 0.0 == 0 < {} < [1] < "" < ()
True

None không có bất kỳ một method nào, thậm chí chính nó là một method khi được dùng với filter hoặc map (xem phần dưới).

Cuối cùng NoneNone - đừng băn khoăn (^-^):

>>> None is None
True
>>> None == None
True

Việc hiểu rõ bản chất của None cùng các tương tác của nó với các phần tử không qua các phép toán logic là RẤT quan trọng khi bạn viết các lệnh if, filter…

Một hàm bất kỳ có thể trả về None nếu bạn viết return None, hoặc không return ở bất kỳ chỗ nào trong hàm. Một hàm như vậy khi tham gia vào biểu thực logic sẽ tạo ra những hiệu ứng mà bạn cần phải nắm rõ bản chất.

3. Loại bỏ các phần tử không trong danh sách

Nói chung các phần tử không sẽ không có ý nghĩa khi nó nằm trong danh sách. Một trong những cách để loại bỏ phần tử không là dùng filter. filter cùng với hàm func sẽ loại bỏ tất cả các phần tử trong danh sách mà tác động của hàm func lên phần tử này tạo ra phần tử không. Diễn giải dễ hiểu của nó như sau:

filter(func, list) 

<==>

S = [0, 0.0, [], (), {}, set([]), "", 0j, False]
def filter(func, list):
    return [x for x in list if func(x) not in S]

Ví dụ:

>>> filter(lambda x: not x, [3, 4, False, True, {1: 0}, []])
[False, []]

Để loại bỏ các phần tử không trong danh sách L, đơn giản là bạn dùng hàm ánh xạ đồng nhất f(x) = x: filter(lambda x: x, L). Hàm này tương đương với:

def filter(func, list):
    return [x for x in list if x not in S]

Cuối cùng một cách viết gây khó hiểu là thay thế lambda x:x bằng hàm None.

filter(None, list) <==> filter(lambda x: x, list)

Ví dụ:

>>> filter(None, [0, 0.0, "", 0+0j, set([]), (), [], {}, False])
[]
>>> filter(None, ["", "abc", " "])
['abc', ' ']
>>> filter(None, [1, 0, 2, 0.0])
[1, 2]

Ở đây chúng ta có cảm giác như None được dùng như một hàm. Thực ra không phải vậy, None có nghĩa là không có hàm nào ở đây cả, nói cách khác đối số đầu tiên của filter bị khuyết. Python lúc đó sẽ dùng hàm mặc định gì đó tương tự như lambda x: x.

4. Dùng None với map

>>> map(None, [1, 2, {1:2}])
[1, 2, {1: 2}]

map không thay đổi danh sách khi nó bị khuyết hàm tác động. Khi đó hàm None tương đương với ánh xạ đồng nhất (mặc dù không chính xác, vì thực ra là không có hàm nào cả, python có thể đã sử dụng hàm mặc định). Tuy nhiên dùng hàm None khi có hai danh sách trở lên thì lại tạo ra khả năng đặc biệt.

>>> map(None, [1, 2], [3, 4])
[(1, 3), (2, 4)]
>>> map(None, [1, 2], [3, 4], [5, 6])
[(1, 3, 5), (2, 4, 6)]

Khả năng này tương đương với zip

>>> zip([1, 2], [3, 4], [5, 6])
[(1, 3, 5), (2, 4, 6)]
>>> zip([1, 2], [3, 4])
[(1, 3), (2, 4)]

Diễn giải của nó như sau:

>>> map(lambda x, y: (x, y), [1, 2], [3, 4])
[(1, 3), (2, 4)]
>>> map(lambda x, y, z: (x, y, z), [1, 2], [3, 4], [5, 6])
[(1, 3, 5), (2, 4, 6)]

Một lần nữa trong mục này, mặc dù None bao hàm ý nghĩa về sự khuyết giá trị, song trong triển khai của hàm bất kỳ việc khuyết giá trị dẫn đến việc sử dụng các hàm mặc định. Lúc đó None có ý nghĩa là những gì mặc định. Đôi khi có thể ngắn gọn coi nó cũng là một hàm đặc biệt, hàm None.

Chú ý quan trọng: Các test của bài viết này được thử trên python 2.5.x

Hoaiptm.