Làm việc với dữ liệu trong Python [10 Phút]

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

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.

>>> [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"]

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

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

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

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

>>> 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

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

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

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

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

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

>>> 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]

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

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

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

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

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

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

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

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

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

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

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

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

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

>>> factorial(4)
24

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

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

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

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

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

>>> 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]]

>>> 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]

>>> 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]

>>> 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]]

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

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

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

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

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

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

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

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

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

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

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

>>> len("abrakadabra")
11

>>> 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.



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ì 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]

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__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None}
>>> x = 1
>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'x': 1}
>>> x = 2
>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>, '__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/


---