Hướng dẫn dùng python gsub trong PHP

Chào mừng bạn đã quay trở lại với series Tự học Python trong 10 Phút.

Bài trước bạn đã được hướng dẫn Tự học Python Cơ bản trong 10 Phút.

Bạn đã hiểu nhanh về ngôn ngữ Python.

Hôm nay chúng ta hay đi sâu hơn với chủ đề "Làm việc với dữ liệu trong Python".

Làm việc với Dữ liệu trong Python

* Mục tiêu vẫn là 10 Phút =)).

Không hề đùa chút nào. Nếu bạn học kỹ bài trước thì bài này chỉ cần 10 phút là bạn đọc xong thôi.

Mục lục bài viết:

1. Làm việc với List

    1.1. Làm việc với list bằng for

    1.2. Sắp xếp list

2. Làm việc với Tuples

3. Làm việc với Set

4. Làm việc với String

5. Làm việc với File

    5.1. Ví dụ: Đếm từ

6. List comprehensions (Nội suy List)

7. Làm việc với Dictionaries

    7.1. Ví dụ: Tính tần suất từ trong chuỗi

8. Hiểu hơn về môi trường thực thi của Python

Tổng kết Tự học Làm việc với dữ liệu trong Python

(* Click vào mục lục để chuyển đến phần tương ứng)

OK. Chúng ta cùng bắt đầu nào!

1. Làm việc với kiểu dữ liệu List trong Python

Bài trước chúng ta đã được tìm hiểu sơ qua về List. Hôm nay hãy cùng làm việc nhiều hơn với List nhé.

> Bài này mình sẽ sử dụng command prompt bạn nhé. Bạn có thể sử dụng Pycharm nếu thích.

Một ví dụ nhanh về List:

>>> [1, 2, 3, 4]
[1, 2, 3, 4]
>>> ["hello", "world"]
["hello", "world"]
>>> [0, 1.5, "hello"]
[0, 1.5, "hello"]
>>> [0, 1.5, "hello"]
[0, 1.5, "hello"]

Một list có thể chứa một list khác như một thành viên của nó.

>>> a = [1, 2]
>>> b = [1.5, 2, a]
>>> b
[1.5, 2, [1, 2]]

Có một hàm được tích hợp sẵn trong Python gọi là range có thể được sử dụng để tạo ra một dãy số nguyên liên tục:

>>> x = range(1, 4)
>>> x
range(1, 4)
>>> x[0]
1
>>> len(x)
3

Lưu ý: range(1,4) sẽ tạo ra list [1, 2, 3]. Nó không bao gồm 4.

Hàm len (built-in function) cũng có thể được sử dụng để tính độ dài của list:

>>> a = [1, 2, 3, 4]
>>> len(a)
4

Và bạn cũng có thể sử dụng toán tử + và toán tử * với list:

>>> a = [1, 2, 3]
>>> b = [4, 5]
>>> a + b
[1, 2, 3, 4, 5]
>>> b * 3
[4, 5, 4, 5, 4, 5]

List là một tập hợp có thứ tự và có chỉ mục (index). Chỉ số index được đánh từ 0 đến Độ dài của list -1.

>>> x = [1, 2]
# Phần tử đầu tiên có chỉ số là 0
>>> x[0]
1
# Phần tử thứ 2
# có chỉ số là len(x) - 1
>>> x[1]
2

Khi bạn sử dụng sai chỉ số index. Python sẽ thông báo lỗi:

>>> x = [1, 2, 3, 4]
>>> x[6]
Traceback (most recent call last):
  File "", line 1, in ?
IndexError: list index out of range

Các chỉ số âm có thể được sử dụng để lập chỉ mục danh sách từ bên phải, ví dụ:

>>> x = [1, 2, 3, 4]
>>> x[-1]
4
>>> x [-2]
3

* Lưu ý: Lập chỉ mục từ bên phải với chỉ số âm thì -1 là phần tử cuối cùng của list, và cứ thế...

Bạn cũng có thể sử dụng kỹ thuật list slicing (cắt danh sách) để lấy một phần của list:

>>> x = [1, 2, 3, 4]
>>> x[0:2]
[1, 2]
>>> x[1:4]
[2, 3, 4]

* Lưu ý: Như bạn thấy, ví dụ trên cắt danh sách với [1:4]. Kết quả trả về không bao gồm phần tử có chỉ số 4.

Thậm chí chỉ số âm cũng có thể sử dụng trong kỹ thuật cắt lát danh sách (list slicing).

Cũng sử dụng danh sách x = [1, 2, 3, 4] ở trên:

>>> x[0:-1]
[1, 2, 3]

Như bạn thấy thấy, kết quả trả về không có phần tử cuối cùng.

Vậy nên, trong trường hợp bạn muốn bỏ bớt một số phần tử ở cuối danh sách mà không chắc chắn có bao nhiều phần tử trong list thì có thể sử dụng chỉ số âm như ví dụ trên.

Ví dụ: Bỏ 2 phần tử ở cuối list x

>>> x[0:-2]
[1, 2]

Và bạn cũng có thể bỏ qua cả 2 chỉ số này luôn.

• Nếu bỏ qua chỉ số đầu tiên thì nó mặc định cắt từ đầu list.

• Nếu bỏ qua chỉ số cuối cùng thì nó mặc định cắt đến cuối list.

• Nếu bỏ qua cả 2 thì nó cắt từ đầu đến cuối list

Ví dụ:

>>> x = [1, 2, 3, 4]
# Cắt từ đầu lis
>>> a[:2]
[1, 2]
# Cắt đến cuối list
>>> a[2:]
[3, 4]
# Cắt từ đầu đến cuối lis
>>> a[:]
[1, 2, 3, 4]

Kỹ thuật cắt chuỗi này còn có một chỉ số thứ 3 tùy chọn. Chỉ số này chỉ định phần tử tiếp theo được đếm như thế nào.

Ở ví dụ trước, phần tử tiếp theo mặc định là liên tiếp.

Nhưng nếu chúng ta muốn chỉ định cách cắt, vẫn hoàn toàn được:

>>> x = range(10)
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[0:6:2]
[0, 2, 4]

Và với chỉ số tùy chọn thứ 3 này. Bạn có thể tận dụng nó để đảo ngược list.

* Đây là cách mọi người thường làm để đảo ngược list trong Python.

>>> x[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

List là một tập hợp có thể chỉnh sửa.

Vì thế bạn có thể gán lại phần tử trong list:

>>> x = [1, 2, 3, 4]
>>> x[1] = 5
>>> x
[1, 5, 3, 4]

Còn để kiểm tra sự tồn tại của phần tử có trong list hay không, chúng ta có toán tử in

>>> x = [1, 2, 3, 4]
>>> 2 in x
True
>>> 10 in x
False

Đến đây có thể bạn tự hỏi: Thêm phần tử vào trong list có được không?

Câu trả lời là: Hoàn toàn được. Bởi vì list là tập hợp có thể chỉnh sửa mà.

Bạn có thể sử dụng phương thức append để thêm phần tử vào cuối list.

>>> a = [1, 2]
>>> a.append(3)
>>> a
[1, 2, 3]

OK. Bây giờ bạn đã hiểu kha khá về list rồi đấy. Và trước làm việc với list sâu hơn. Hãy cùng giải quyết một bài tập nhỏ nào!

Bài tập 1: Kết quả của chương trình Python bên dưới đây là gì?

x = [0, 1, [2]]
x[2][0] = 3
print(x)
x[2].append(4)
print(x)
x[2] = 2
print(x)

1.1. Làm việc với list bằng câu lệnh for

Python cung cấp câu lệnh for để lặp qua một danh sách.

Một Câu lệnh for trong Python thực thi các đoạn code quy định cho tất cả các phần tử nằm trong một list.

for x in [1, 2, 3, 4]:
    print(x)

for i  in range(10):
   print(i, i*i, i*i*i)

Bạn thấy không. Python đề cao tính dễ đọc, dễ sử dụng nên code python hoạt động cũng giống như cách bạn đọc vậy.

• Học làm chủ Python với Khóa học Python NIIT - ICT Hà Nội ngay hôm nay!

Chúng ta tiếp tục nào,

Nếu bạn muốn kết hợp 2 list thành các cặp thì bạn có thể sử dụng hàm tích hợp sẵn là zip

Ví dụ:

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

Hàm zip trong Python rất hữu ích khi chúng ta muốn lặp qua hai danh sách cùng nhau.

names = ["a", "b", "c"]
values = [1, 2, 3]
for name, value in zip(names, values):
    print(name, value)

Trong bài viết này (và cả các khóa học tại NIIT) không chỉ mong muốn giúp bạn biết, mà còn mong muốn có kỹ năng viết code tốt.

Vì thế, hãy cùng giải quyết vài bài tập nào.

Bài tập 2: Nếu bạn muốn cộng tổng của tất cả các phần tử trong danh sách? Bạn có thể sử dụng hàm tích hợp sẵn trong Python là sum

>>> sum([1, 2, 3])
>>> 6

Bài tập 3: Vậy nếu trong ví dụ trên, chúng ta thay thế các phần tử bằng chuỗi thì sao?. Hàm sum vẫn làm việc tốt với danh sách các chuỗi.

>>> sum(["hello", "world"])
"helloworld"
>>> sum(["aa", "bb", "cc"])
"aabbcc"

Bài tập 4: Hãy định nghĩa một hàm tên là product để tính số lượng sản phẩm trong một danh sách được cho sẵn.

Khi gọi hàm product như bên dưới thì cho kết quả:

>>> product([1, 2, 3])
6

Bài tập 5: Hãy viết một hàm có tên là factorial để tính giai thừa của một số. Và liệu bạn có thể sử dụng hàm product đã tạo ở trên để vận dụng tính giai thừa không?

Khi sử dụng hàm factorial sẽ cho kết quả như vậy:

>>> factorial(4)
24

Bài tập 6: Hãy viết một hàm tên là reverse để đảo ngược thứ tự của một list. Bạn có thể làm mà không cần kỹ thuật slicing không?

>>> reverse([1, 2, 3, 4])
[4, 3, 2, 1]
>>> reverse(reverse([1, 2, 3, 4]))
[1, 2, 3, 4]

Bài tập 7: Python có hàm tích hợp sẵn min và max để tìm giá trị nhỏ nhất và giá trị lớn nhất ở trong một danh sách. Vậy nếu sử dụng min và max cho một danh sách các chuỗi thì chuyện gì xảy ra?

Bài tập 8: Tổng tích lũy của một danh sách [a, b, c, ...] là [a, a + b, a + b + c, ...]. Hãy viết một hàm có tên là comulative_sum để tính tổng tích lũy của một list.

*Câu hỏi phụ: Khai triển của bạn có làm việc với danh sách các chuỗi không?

Hãy làm thế nào để khi gọi hàm comulative_sum thì cho kết quả như sau:

>>> cumulative_sum([1, 2, 3, 4])
[1, 3, 6, 10]
>>> cumulative_sum([4, 3, 2, 1])
[4, 7, 9, 10]

Bài tập 9: Hãy viết một hàm tên là cumulative_sum để tính tích lũy sản phẩm của một danh sách các số.

Để làm sao, khi gọi hàm cumulative_sum thì cho kết quả như sau:

>>> cumulative_product([1, 2, 3, 4])
[1, 2, 6, 24]
>>> cumulative_product([4, 3, 2, 1])
[4, 12, 24, 24]

Bài tập 10: Hãy viết hàm có tên là unique để tìm tất cả các phần tử duy nhất trong một danh sách:

>>> unique([1, 2, 1, 3, 2, 5])
[1, 2, 3, 5]

Bài tập 11: Viết một hàm có tên là dups để tìm tất cả các phần tử trùng lặp trong danh sách.

>>> dups([1, 2, 1, 3, 2, 5])
[1, 2]

Bài tập 12: Hãy viết một hàm group(list, size) lấy một list và chia nhỏ thành các list theo size (Mỗi size là một list có size phần tử được cắt ra từ list lớn):

Viết thế nào để hàm group(list, size) cho kết quả như thế này:

>>> group([1, 2, 3, 4, 5, 6, 7, 8, 9], 3)
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> group([1, 2, 3, 4, 5, 6, 7, 8, 9], 4)
[[1, 2, 3, 4], [5, 6, 7, 8], [9]]

1.2. Sắp xếp list trong Python

Khi lập trình, chúng ta thường xuyên phải sắp xếp dữ liệu theo những cách khác nhau.

Hãy cùng thử tìm hiểu cách sắp list trong Python xem thế nào nào.

Đầu tiên, Python cung cấp hàm sort để sắp xếp một list tại chỗ. (Có nghĩa là hàm sort sửa đổi ngay list được sắp xếp)

>>> a = [2, 10, 4, 3, 7]
>>> a.sort()

# List a đã bị thay đổi khi sử dụng sort để sắp xếp
>>> a
[2, 3, 4, 7 10]

Hàm sorted là một hàm trả về một list mới khi chưa được sắp xếp mà không sửa đổi list cũ.

Ví dụ:

>>> a = [4, 3, 5, 9, 2]

# Hàm sorted trả về list mới được sắp xếp
>>> sorted(a)
[2, 3, 4, 5, 9]
>>> a
# List a cũ vẫn giữ nguyên
[4, 3, 5, 9, 2]

Các hành vi sắp xếp của phương thức sort và sorted là như nhau. Ngoại trừ việc nó trả về danh sách mới hay là sửa đổi danh sách đã cho.

Phương thức sort hoạt động ngay cả khi danh sách có các loại đối tượng khác nhau và thậm chí cả khi nó chứa danh sách con.

>>> a = ["hello", 1, "world", 45, 2]
>>> a.sort()
>>> a
[1, 2, 45, 'hello', 'world']
>>> a = [[2, 3], [1, 6]]
>>> a.sort()
>>> a
[[1, 6], [2, 3]]

Chúng ta có thể tùy chọn sử dụng hàm sort theo key:

>>> a = [[2, 3], [4, 6], [6, 1]]
>>> a.sort(key=lambda x: x[1])
>>> a
[[6, 1], [2, 3],  [4 6]]

Hàm trên sắp xếp lại list a. Tuy nhiên, nó sắp xếp theo chỉ số của phần tử thứ 2 theo mỗi danh sách con trong a.

* Quay lại bài trước để tìm hiểu thêm về hàm lambada trong Python.

Bài tập 13: Hãy viết một hàm tên là lensort để sắp xếp dựa theo độ dài của từng chuỗi trong list.

>>> lensort(['python', 'perl', 'java', 'c', 'haskell', 'ruby'])
['c', 'perl', 'java', 'ruby', 'python', 'haskell']

Bài tập 14: Cải thiện hàm unique đã được viết trong Bài tập 10 để sử dụng tùy chọn hàm key làm đối số và sử dụng giá trị trả về của hàm key để kiểm tra tính duy nhất.

Làm thế nào để khi sử dụng hàm unique với đối số key chúng ta có thể có kết quả như sau:

>>> unique(["python", "java", "Python", "Java"], key=lambda s: s.lower())
["python", "java"]

2. Làm việc với kiểu dữ liệu Tuples trong Python

Tuple là một loại tập hợp dữ liệu giống như list trong Python, nhưng Tuple là bất biến.

Một tuple bao gồm một số giá trị được phân tách bằng dấu phẩy.

Sử dụng ngoặc đơn là đặc trưng để tạo ra một Tuple:

>>> a = (1, 2, 3)
>>> a[0]
1

Nhưng ngoặc đơn có thể có hoặc không.

>>> a = 1, 2, 3
>>> a[0]
1

Hàm tích hợp len và kỹ thuật slicing cũng có thể áp dụng với kiểu dữ liệu Tuple:

>>> len(a)
3
>>> a[1:]
2, 3

Vì dấu ngoặc đơn được sử dụng để tạo ra một tuple, nên nếu bạn muốn tạo ra một tuple chỉ có 1 phần tử thì bạn có thể thêm một dấu phẩy.

>>> a = (1)
>> a
1
>>> b = (1,)
>>> b
(1,)
>>> b[0]
1

Khi làm việc với Tuple bạn nên ghi nhớ là: Tuple là bất biến, vì thế các phương thức, hàm muốn thay đổi Tuple sẽ không áp dụng được.

3. Làm việc với kiểu dữ liệu Set trong Pyton

Một Set là kiểu dữ liệu được sử dụng cho tập hợp các phần tử duy nhất.

>>> x = set([3, 1, 2, 1])
set([1, 2, 3])

Kể từ Python 2.7. Chúng ta có thể tạo một set với ngoặc nhọn.

>>> x = {3, 1, 2, 1}
set([1, 2, 3])

Phần tử mới cũng có thể được thêm vào Set bằng phương thức add

>>> x = set([1, 2, 3])
>>> x.add(4)
>>> x
set([1, 2, 3, 4])

Giống như các list, chúng ta có thể kiểm tra sự tồn tại của một phần tử bằng toán tử in. Tuy nhiên, thao tác này nhanh hơn trong set.

>>> x = set([1, 2, 3])
>>> 1 in x
True
>>> 5 in x
False

Bài tập 15: Hãy viết lại hàm unique bằng cách sử dụng set. Bạn thấy thế nào?

4. Làm việc với kiểu dữ liệu String trong Python

String (Chuỗi) cũng hành xử như list theo nhiều cách.

Bạn cũng có thể tìm độ dài của một chuỗi bằng hàm len.

>>> len("abrakadabra")
11

Chỉ mục (indexing) và kỹ thuật Slicing cũng hành xử tương tự trong chuỗi.

>>> a = "helloworld"
# Ký tự thứ 2
>>> a[1]
'e'
# Ký tự thứ 2 tính từ bên trái
>>> a[-2]
'l'
# Cắt chuỗi từ ký tự thứ 2 đến 5 (không bao gồm 5)
>>> a[1:5]
"ello"
# Cắt chuỗi từ đầu cho đến 5 (không bao gồm 5)
>>> a[:5]
"hello"
# Cắt chuỗi từ ký tự thứ 5 đến cuối chuỗi
>>> a[5:]
"world"
# Cắt chuỗi từ phần tử thứ 2 tính từ cuối chuỗi
# đến cuối chuỗi
>>> a[-2:]
'ld'
# Bỏ đi 2 phần tử ở cuối chuỗi
>>> a[:-2]
'hellowor'
# Đảo ngược chuỗi
>>> a[::-1]
'dlrowolleh'ình

Mình viết comment để bạn dễ hiểu. Trong command line / Terminal / Shell / Command Prompt thì các bạn bỏ comment đi nhé.

Trong Python toán tử in cũng có thể được sử dụng để kiểm tra một chuỗi có tồn tại trong chuỗi hay không.

>>> 'hell' in 'hello'
True
>>> 'full' in 'hello'
False
>>> 'el' in 'hello'
True

Ngoài in, còn có rất nhiều phương thức hữu ích giúp bạn làm việc với chuỗi.

Phương thức split chia tách một chuỗi bằng cách sử dụng một dấu phân cách (Bạn có thể định nghĩa dấu phân cách này là cái gì)

Nếu không có dấu phân cách được chỉ định, nó sử dụng bất kỳ khoảng trắng nào làm dấu phân cách.

Ví dụ: Phân tách chuỗi theo dấu phân cách mặc định

>>> "hello world".split()
['hello', 'world']
>>> "a,b,c".split(',')
['a', 'b', 'c']

Đó, đó là cách split tách chuỗi.

Có tách thì phải có hợp chuỗi. Phương thức join được sử dụng để kết hợp một danh sách các chuỗi.

>>> " ".join(['hello', 'world'])
'hello world'
>>> ','.join(['a', 'b', 'c'])

Bạn đoán xem, câu lệnh thứ 2 sẽ đem lại kết quả gì?

Phương thức strip về một bản sao của chuỗi đã cho nhưng loại bỏ khoảng trắng ở đầu và cuối chuỗi.

Hình như hơi tương tự giống như hàm trim trong một số ngôn ngữ khác nhỉ? :D

Tùy chọn truyền vào hàm strip một chuỗi sẽ xóa các ký tự được truyền khỏi chuỗi đã cho thay vì xóa khoảng trắng.

>>> ' hello world\n'.strip()
'hello world'
>>> 'abcdefgh'.strip('abdh')
'cdefg'

Thực thế, phương thức strip không chỉ xóa khoảng trắng, nó còn xóa cả tab, xuống dòng... (Tham khảo về strip tại đây)

Thêm nữa, Python cũng hỗ trợ dạng giá trị vào chuỗi.

Mặc dù điều này có thể khá phức tạp, nhưng sử dụng cơ bản nhất là để chèn giá trị vào một chuỗi với %s (trình giữ chỗ).

Ví dụ:

>>> a = 'hello'
>>> b = 'python'
>>> "%s %s" % (a, b)
'hello python'
>>> 'Bạn có %d phút tự học %s' % (2, 'Python')
'Bạn có 10 phút tự học Python'

Như bạn thấy, chúng ta sử dụng %d và %s để giữ chỗ trong một chuỗi.

Sau đó tùy theo từng nhu cầu mà chúng ta điền giá trị vào chỗ mà ta đã giữ chỗ từ trước đó.

Bài tập 16: Hãy viết một hàm có tên là exsort để sắp xếp danh sách các tệp tin dựa theo phần mở rộng của nó.

Làm thế nào để khi gọi hàm chúng ta có kết quả:

>>> extsort(['a.c', 'a.py', 'b.py', 'bar.txt', 'foo.txt', 'x.c'])
['a.c', 'x.c', 'a.py', 'b.py', 'bar.txt', 'foo.txt']

5. Làm việc với File trong Python.

Làm việc với file là một phần quan trọng khi lập trình. Python cung cấp một hàm được tích hợp sẵn là open, nó sẽ trả về đối tượng tập tin.

Nó cũng cho thêm phép đối số tùy chọn, ví dụ:

f = open('foo.txt', 'r') # mở và đọc (read) file
f = open('foo.txt', 'w') # mở và ghi (write) file
f = open('foo.txt', 'a') # mở và thêm vào cuối (append) file

Đối số thứ 2 nếu không được truyền thì mặc định là 'r'. 

Có một lưu ý là: Hệ điều hành Unix không phân biệt tệp nhị phân với tệp văn bản nhưng Windows thì có.

Vì thế, trên Windows khi làm việc với tập tin nhị phân thì chúng ta thêm đối số như sau: 'rb', 'wb', 'ab'...

Cũng có một cách dễ dàng để đọc nội dung của một tập tin là sử dụng phương thức read()

>>> open('foo.txt').read()
'first line\nsecond line\nlast line\n'

Nội dung của một tập tin có thể được đọc theo dòng / nhiều dòng bằng cách sử dụng các phương thức readline và readlines.

Phương thức readline trả về chuỗi rỗng khi không còn gì để đọc trong tệp.

>>> open('foo.txt').readlines()
['first line\n', 'second line\n', 'last line\n']
>>> f = open('foo.txt')
>>> f.readline()
'first line\n'
>>> f.readline()
'second line\n'
>>> f.readline()
'last line\n'
>>> f.readline()
''

Phương thức write được sử dụng để viết dữ liệu vào một file đã được mở ở chế độ write hoặc là append.

>>> f = open('foo.txt', 'w')
>>> f.write('a\nb\nc')
>>> f.close()

>>> f.open('foo.txt', 'a')
>>> f.write('d\n')
>>> f.close()

Phương thức writelines được sử dụng để khi dữ liệu có sẵn dưới dạng danh sách các dòng.

>>> f = open('foo.txt')
>>> f.writelines(['a\n', 'b\n', 'c\n'])
>>> f.close()

5.1. Ví dụ về đếm từ trong File

Hãy thử viết chương trình tính số lượng ký tự, số lượng từ và số dòng trong một tệp.

Số lượng ký tự trong một tệp giống như cách tính độ dài nội dung của nó.

def charcount(filename):
    return len(open(filename).read())

Số từ trong một tập tin có thể được tìm thấy bằng cách tách nội dung của các tập tin dựa trên khoảng trắng.

def wordcount(filename):
    return len(open(filename).read().split())

Số dòng trong một tập tin có thể được tìm thấy từ phương thức readlines

def linecount(filename):
    return len(open(filename).readlines())

Bài tập 17: Hãy viết một chương trình lưu trong tệp reverse.py để in các dòng của tập tin theo thứ tự ngược lại.

Bài tập 18: Viết các hàm có tên là head và tail để lấy một tệp làm đối số và in 10 dòng đầu tiên và 10 dòng cuối cùng của tệp tương ứng.

Bài tập 19: Viết hàm có tên là grep lấy một chuỗi và một tệp làm đối số và in tất cả các dòng trong tệp có chứa chuỗi đã chỉ định.

Bài tập 20: Viết một chương trình wrap.py lấy tên tệp và width làm đối số để xuống dòng nếu câu đó có độ dài lớn hơn width.

Bài tập 21: Chương trình wrap.py ở trên có thể sẽ không đẹp lắm vì nó có thể ngắt dòng ở giữa bất kỳ từ nào.

Ví dụ: Câu "Tu hoc lap trinh Python trong 10 phut" bị ngắt như thế này
"Tu hoc lap trinh Python tro
ng 10 phut"

Vì thế, bạn có thể viết một chương trình wordwrap.py mới hoạt động như wrap.py, nhưng chỉ ngắt dòng mà không làm gãy các từ?

Bài tập 22: Viết một chương trình có tên là center.align.py để căn giữa tất cả các dòng trong tập tin nào đó.

6. List comprehensions

List comprehension (nội suy List) là một cách ngắn gọn để tạo list.

Thay vì nhiều tác vụ phức tạp, với cách nội suy list, list có thể được mô hình hóa trong một dòng duy nhất.

Đây là một số ví dụ đơn giản để chuyển đổi một list:

>>> a = range(10)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [x for x in a]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [x*x for x in a]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [x+1 for x in a]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Bạn cũng có thể thực hiện lọc một list bằng cách sử dụng if trong khi nội suy list.

>>> a = range(10)
>>> [x for x in a if x % 2 == 0]
[0, 2, 4, 6, 8]
>>> [x*x for x in a if x%2 == 0]
[0, 4, 8, 36, 64]

Lại phải nhấn mạnh điều này. Một điều mà mình thấy yêu thích Python là vì nó hoạt động đúng như những gì chúng ta đọc. Bạn có thấy như thế không?

Bạn cũng có thể lặp lại qua nhiều list bằng cách sử dụng hàm zip được tích hợp sẵn.

>>> a = [1, 2, 3, 4]
>>> b = [2, 3, 5, 7]
>>> zip(a, b)
[(1, 2), (2, 3), (3, 5), (4, 7)]
>>> [x+y for x, y in zip(a, b)]
[3, 5, 8, 11]

Không chỉ sử cụng if, zip. Chúng ta còn có thể sử dụng vòng lặp for trong khi nội suy list nữa.

>>> [(x, y) for x in range(5) for y in range(5) if (x+y)%2 == 0]
[(0, 0), (0, 2), (0, 4), (1, 1), (1, 3), (2, 0), (2, 2), (2, 4), (3, 1), (3, 3), (4, 0), (4, 2), (4, 4)]

>>> [(x, y) for x in range(5) for y in range(5) if (x+y)%2 == 0 and x != y]
[(0, 2), (0, 4), (1, 3), (2, 0), (2, 4), (3, 1), (4, 0), (4, 2)]

>>> [(x, y) for x in range(5) for y in range(x) if (x+y)%2 == 0]
[(2, 0), (3, 1), (4, 0), (4, 2)]

Ví dụ sau đây tìm thấy tất cả các bộ ba số nhỏ hơn 25 thỏa mãn định lý Py-ta-go. (x, y, z) là một bộ ba Pythagore nếu x * x + y * y == z * z.

>>> n = 25
>>> [(x, y, z) for x in range(1, n) for y in range(x, n) for z in range(y, n) if x*x + y*y == z*z]
[(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15), (12, 16, 20)]

Bài tập 23: Chúng ta đã biết cách làm việc của hàm zip. Vậy bây giờ, hãy viết một khai triển sử dụng cách nội suy list để có được hiệu quả như hàm zip xem nào:

>>> zip([1, 2, 3], ["a", "b", "c"])
[(1, "a"), (2, "b"), (3, "c")]

Bài tập 24: Python cung cấp một hàm tích hợp là map để áp dụng một hàm cho từng phần tử trong list. Hãy viết một khai triển cho map sử dụng cách nội suy list.

>>> def square(x): return x * x
...
>>> map(square, range(5))
[0, 1, 4, 9, 16]

Bài tập 25: Python cung cấp một hàm tích hợp là filter(f, a) nó trả về items của a khi f(items) là true.

Hãy viết một khai triển cho filter sử dụng cách nội suy list.

>>> def even(x): return x %2 == 0
...
>>> filter(even, range(10))
[0, 2, 4, 6, 8]

Bài tập 26: Viết một hàm tên là stripets lấy một số n làm đối số và trả về một danh sách các bộ ba số sao cho tổng của hai phần tử đầu tiên của bộ ba bằng với phần tử thứ ba sử dụng các số nhỏ hơn n.

Xin lưu ý rằng (a, b, c) và (b, a, c) đại diện cho cùng một bộ ba.

>>> triplets(5)
[(1, 1, 2), (1, 2, 3), (1, 3, 4), (2, 2, 4)]

Bài tập 27: Viết một hàm enumerate lấy một list và trả về một list các bộ dữ liệu chứa (index, item) cho mỗi item trong  list.

Ví dụ:

>>> enumerate(["a", "b", "c"])
[(0, "a"), (1, "b"), (2, "c")]
>>> for index, value in enumerate(["a", "b", "c"]):
...     print(index, value)
0 a
1 b
2 c

Bài tập 28: Viết một hàm tên là array để tạo một mảng 2 chiều. Hàm sẽ lấy 2 đối số để xác định kích thước của mảng. Giá trị của mỗi phần tử có thể khởi tạo ban đầu là None.

Kết quả nên như thế này:

>>> a = array(2, 3)
>>> a
[[None, None, None], [None, None, None]]
>>> a[0][0] = 5
[[5, None, None], [None, None, None]]

Bài tập 29: Viết một hàm là parse_csv để phân tích tệp csv (nội csv dung được phân tác bằng dấu phẩy , )

>>> print(open('a.csv').read())
a,b,c
1,2,3
2,3,4
3,4,5
>>> parse_csv('a.csv')
[['a', 'b', 'c'], ['1', '2', '3'], ['2', '3', '4'], ['3', '4', '5']]

Bài tập 30: Thực hiện biến giải pháp bên trên thành tổng quát hóa. Có nghĩa là chương trình có thể hỗ trợ phân tích tệp csv với bất kỳ dấu phân tách nào.

>>> print(open('a.txt').read())
# elements are separated by ! and comment indicator is #
a!b!c
1!2!3
2!3!4
3!4!5
>>> parse('a.txt', '!', '#')
[['a', 'b', 'c'], ['1', '2', '3'], ['2', '3', '4'], ['3', '4', '5']]

7. Làm việc với Kiểu dữ liệu Dictionaries trong Python

Dictionaries giống như List, nhưng chúng cũng có thể được lập chỉ mục với các key không phải kiểu int.

Không giống như list, dữ liệu kiểu dictionaries không có thứ tự.

Ví dụ:

>>> a = {'x': 1, 'y': 2, 'z': 3}
>>> a['x']
1
>>> a['z']
3
>>> b = {}
>>> b['x'] = 2
>>> b[2] = 'foo'
>>> b[(1, 2)] = 3
>>> b
{(1, 2): 3, 'x': 2, 2: 'foo'}

Từ khóa del có thể được sử dụng để xóa một item khỏi dictionary.

>>> a = {'x': 1, 'y': 2, 'z': 3}
>>> del a['x']
>>> a
{'y': 2, 'z': 3}

• Từ khóa keys trả về tất cả các key của dictionary.

• Từ khóa values trả về tất cả các value của dictionary.

• Phương thức items trả về tất cả cặp key - value của dictionary.

Ví dụ minh họa:

>>> a = {'x': 1, 'y': 2, 'z': 3}

>>> a.keys()
['x', 'y', 'z']
>>> a.values()
[1, 2, 3]
>>> a.items()
[('x', 1), ('y', 2), ('z', 3)]

Câu lệnh for được sử dụng để lặp qua một dictionary.

>>> for key in a: print(key)
...
x
y
z
>>> for key, value in a.items(): print(key, value)
...
x 1
y 2
z 3

Sự hiện diện của một key trong dictionary có thể được kiểm tra bằng toán tử in hoặc phương thức has_key.

>>> 'x' in a
True
>>> 'p' in a
False
>>> a.has_key('x')
True
>>> a.has_key('p')
False

Một vài phương thức khác hay sử dụng với dictionaries là get và setdefault.

Cú pháp get: get(keyname, value)

Trong đó:

• keyname là bắt buộc. Đây là tên của item bạn muốn lấy dữ liệu.
• value là tùy chọn. Đây là giá trị được trả về nếu keyname không tồn tại. Nếu không truyền thì mặc định là None.

Cú pháp setdefault: setdefault(keyname, value)

Trong đó:

• keyname là bắt buộc.
• value là tùy chọn. Nếu keyname tồn tại, nó không có hiệu quả gì. Nếu keyname chưa tồn tại, nó sẽ là giá trị của keyname. Giá trị mặc định là None.

>>> d = {'x': 1, 'y': 2, 'z': 3}
>>> d.get('x', 5)
1
>>> d.get('p', 5)
5
>>> d.setdefault('x', 0)
1
>>> d
{'x': 1, 'y': 2, 'z': 3}
>>> d.setdefault('p', 0)
0
>>> d
{'y': 2, 'x': 1, 'z': 3, 'p': 0}

Dictionaries có thể được sử dụng trong định dạng chuỗi để chỉ định các tham số được đặt tên.

Ví dụ:

>>> 'hello %(name)s' % {'name': 'python'}
'hello python'
>>> 'Tự học %(course)s trong %(duration)d phút' % {'duration': 10, 'course': 'Python'}
'Tự học Python trong 10 phút'

7.1. Ví dụ: Tính tần suất các từ trong chuỗi với Python.

Giả sử chúng ta muốn tìm số lần xuất hiện của mỗi từ trong một tệp. Dictionaries có thể được sử dụng để lưu trữ số lần xuất hiện cho mỗi từ.

Trước tiên hãy viết một hàm để đếm tần số của các từ, đưa ra một danh sách các từ.

def word_frequency(words):
    """Returns frequency of each word given a list of words.

        >>> word_frequency(['a', 'b', 'a'])
        {'a': 2, 'b': 1}
    """
    frequency = {}
    for w in words:
        frequency[w] = frequency.get(w, 0) + 1
    return frequency

Lấy các từ từ tập tin:

def read_words(filename):
    return open(filename).read().split()

Chúng ta có thể kết hợp hai hàm này để tìm tần suất của tất cả các từ trong một tệp.

def main(filename):
    frequency = word_frequency(read_words(filename))
    for word, count in frequency.items():
        print(word, count)

if __name__ == "__main__":
    import sys
    main(sys.argv[1])

Bây giờ, hãy cùng giải quyết một số bài tập nào!

Bài tập 31: Cải thiện chương trình trên để in ra các từ theo thứ tự giảm dần của số lần xuất hiện.

Bài tập 31: Viết chương trình đếm tần suất ký tự trong một tệp đã cho. Bạn có thể sử dụng tần suất ký tự để cho biết tệp đã cho là tệp mã Python, tệp mã C hay tệp văn bản thông thường hay không?

Bài tập 32: Viết chương trình tìm đảo chữ cái trong một danh sách các từ đã cho. Hai từ được gọi là đảo chữ nếu một từ có thể được hình thành bằng cách sắp xếp lại các chữ cái khác. Ví dụ: 'eat', 'ate' và 'tea' là đảo chữ.

>>> anagrams(['eat', 'ate', 'done', 'tea', 'soup', 'node'])
[['eat', 'ate', 'tea], ['done', 'node'], ['soup']]

Bài tập 33: Hãy viết một hàm có tên là valuesort để sắp xếp thứ tự của dictionary theo key:

>>> valuesort({'x': 1, 'y': 2, 'a': 3})
[3, 1, 2]

Bài tập 34: Viết hàm invertdict để hoán đổi các key và value trong một dictionary. Để đơn giản, giả sử rằng tất cả các giá trị là duy nhất.

Kết quả chương trình nên là như thế này:

>>> invertdict({'x': 1, 'y': 2, 'z': 3})
{1: 'x', 2: 'y', 3: 'z'}

8. Hiểu hơn về môi trường thực thi của Python

Python lưu trữ các biến chúng ta sử dụng như là một dictionary. Hàm globalals() trả về tất cả các biến toàn cục trong môi trường hiện tại.

>>> globals()
{'__builtins__': , '__name__': '__main__', '__doc__': None}
>>> x = 1
>>> globals()
{'__builtins__': , '__name__': '__main__', '__doc__': None, 'x': 1}
>>> x = 2
>>> globals()
{'__builtins__': , '__name__': '__main__', '__doc__': None, 'x': 2}
>>> globals()['x'] = 3
>>> x
3

Giống như globals, python cũng cung cấp một hàm locals cung cấp tất cả các biến cục bộ trong một hàm.

>>> def f(a, b): print(locals())
...
>>> f(1, 2)
{'a': 1, 'b': 2}

Thêm một ví dụ khác:

>>> def f(name):
...     return "Hello %(name)s!" % locals()
...
>>> f("NIIT")
Hello NIIT!

Tổng kết Tự học Làm việc với dữ liệu trong Python

Chúc mừng bạn, bạn đã tiến thêm một bước dài nữa để chinh phục Python bởi vì,...

Làm việc với dữ liệu là cực kỳ một phần cực kỳ quan trọng trong Lập trình Python nói riêng và Lập trình nói chung.

Mặc dù bài tự học Làm việc với dữ liệu trong Python này chưa đầy đủ nhưng mình hi vọng nó cung cấp cho bạn một bước đệm để hòa nhập (Phần lớn các ví dụ này là dễ hiểu và được sử dụng phổ biến) và nền tảng để tự tìm hiểu, phát triển thêm.

Khả năng của Python là vô cùng lớn, Python tại Việt Nam mới chỉ đang phát triển ở giai đoạn đầu. HỌC PYTHON ngay bây giờ để trở thành những người tiên phong, nắm giữ lợi thế đi đầu của ngôn ngữ đang HOT nhất trên thế giới này.

Chúc bạn học Python tốt!

* Tham khảo: https://www.python.org/doc/

---

HỌC VIỆN ĐÀO TẠO CNTT NIIT - ICT HÀ NỘI

Học Lập trình chất lượng cao (Since 2002). Học làm Lập trình viên. Hành động ngay!

Đc: Tầng 3, 25T2, N05, Nguyễn Thị Thập, Cầu Giấy, Hà Nội

SĐT: 02435574074 - 0914939543

Email:

Fanpage: https://facebook.com/NIIT.ICT/

#niit #niithanoi #niiticthanoi #hoclaptrinh #khoahoclaptrinh #hoclaptrinhjava #hoclaptrinhphp #python #java #php