# data[].attributes.body
Hàm:
1 | Hàm len(dict)
Độ dài của dict. Nó sẽ là số item trong Dictionary này
2 | Hàm str(dict)
Tạo ra một biểu diễn chuỗi có thể in được của một dict
3 | Hàm type(variable)
Trả về kiểu của biến đã truyền. Nếu biến đã truyền là Dictionary, thì nó sẽ trả về một kiểu Dictionary

Phương thức:
1 | Hàm dict.clear()
Xóa tất cả phần tử của dict
2 | Hàm dict.copy()
Trả về bản sao của dict
3 | Hàm fromkeys(seq,value1)/ fromkeys(seq)
Được sử dụng để tạo một Dictionary mới từ dãy seq và value1. Trong đó dãy seq tạo nên các key và tất cả các key chia sẻ các giá trị từ value1. Trong trường hợp value1 không được cung cấp thì value của các key được thiết lập là None
4 | Hàm dict.get(key, default=None)
Trả về giá trị của key đã cho. Nếu key không có mặt thì phương thức này trả về None
5 | Hàm dict.has-key(key)
Trả về true nếu key là có mặt trong Dictionary, nếu không là false
6 | Hàm dict.items()
Trả về tất cả các cặp (key-value) của một Dictionary
7 | Hàm dict.keys()
Trả về tất cả các key của một Dictionary
8 | Hàm dict.setdefault(key, default=None)
Tương tự get(), nhưng sẽ thiết lập dict[key]=default nếu key là không tồn tại trong dict
9 | Hàm dict.update(dict2)
Được sử dụng để thêm các item của dictionary 2 vào Dictionary đầu tiên
10 | Hàm dict.values()
Trả về tất cả các value của một Dictionary

# data[].attributes.body
Sử dụng Set khi muốn dữ liệu là duy nhất và dễ dàng thực hiện các phép toán tập hợp như phép giao, hợp, trừ.

Sử dụng Tuple khi dữ liệu không thay đổi và cần tốc độ xử lý.

Sử dụng Dictionary khi dữ liệu thay đổi liên tục, có sự liên kết logic giữa khóa và giá trị và một điểm nhấn quan trọng là muốn truy xuất dữ liệu nhanh thông qua khóa.

# data[].attributes.body
Tuple thường được sử dụng cho các dữ liệu không cho phép sửa đổi. Chúng được tạo ra bằng cách đặt tất cả các items/elements bên trong dấu ngoặc đơn () và được phân tách bằng dấu phẩy ","

Tuple name = (value_1, key_2: value_2, ..., value_n)

# data[].attributes.body
Các phần tử trong tập hợp không có thứ tự.

Các phần tử này là duy nhất, không cho phép lặp lại.

Set có thể thay đổi (thêm bớt phần tử) nhưng các phần tử của tập hợp phải ở dạng không thể thay đổi (tức là xác định được dung lượng bộ nhớ ngay khi khai báo).

Chúng ta sử dụng các dấu ngoặc nhọn trong khai báo Set

Set name = {value_1, key_2: value_2, ..., value_n}

# data[].attributes.body
Dictionary trong Python được khai báo với cặp dấu ngoặc nhọn {} bao ngoài giống như với Set. Bên trong các phần tử theo cặp (khóa và giá trị) được phân tách bởi dấu phẩy, phân tách giữa khóa và giá trị của từng phần tử bởi dấu hai chấm. Cú pháp chung như sau:

dictionary_name = {key_1: value_1, key_2: value_2, ..., key_n: value_n}

# data[].attributes.body
Các giá trị (value) trong cặp key:value có thể nhận bất cứ kiểu dữ liệu nào, cũng có thể trùng nhau, nhưng

Khóa trong từ điển phải là duy nhất và phải thuộc kiểu dữ liệu bất biến như chuỗi ký tự, số, hay tuples.

# data[].attributes.body
Sự khác biệt giữa phương thức get() và cách truy cập vào phần tử bằng cách sử dụng khóa dict[key] đó là phương thức get() sẽ trả về giá trị mặc định nếu khóa không tồn tại trong đối tượng kiểu từ điển. Tuy nhiên, nếu khóa không được tìm thấy, việc sử dụng cú pháp dict[key] sẽ đưa ra một ngoại lệ KeyError.

# data[].attributes.body
Trường hợp chưa muốn định nghĩa giá trị, có thể định nghĩa một Tuple empty như sau:

tuple_empty = ()

Có điều empty thì dễ, nhưng có 1 thì nhớ thêm dấu phẩy (comma) vào. Mỗi dấu phẩy thôi nhưng mà quan trọng nha. Không add thì python không hiểu là Tuple đâu á.

# Nếu chưa có sẵn các giá trị nhưng vẫn muốn sử dụng tuple, ta có thể thoải mái định nghĩa tuple empty
tuple_empty = ("abc",)

# data[].attributes.body
Để truy cập đến các phần tử trong Tuple thì các bạn thực hiện tương tự như đối với chuỗi và list.

Các phần tử trong Tuple được đánh dấu từ 0 theo chiều từ trái qua phải.

Và ngược lại từ -1 theo chiều từ phải qua trái.

# data[].attributes.body
Chúng ta có thể truy cập các phần tử trong Dictionary bằng cách sử dụng key trong dấu ngoặc vuông [ ]. Ngoài ra, chúng ta cũng có thể sử dụng phương thức get( ).

# data[].attributes.body
Bạn có thể sử dụng vòng lặp for để truy cập các phần tử của một Set.

# data[].attributes.body
1 | Hàm len(tuple)
Trả về độ dài của tuple
2 | Hàm max(tuple)
Trả về item có giá trị lớn nhất từ một tuple đã cho
3 | Hàm min(tuple)
Trả về item có giá trị nhỏ nhất từ một tuple đã cho
4 | Hàm tuple(seq)
Chuyển đổi một dãy thành tuple

# data[].attributes.body
add() | Thêm một phần tử tới set
clear() | Xóa tất cả các phần tử của một set
copy() | Returns a copy of the set
difference() | Trả về một set chứa các phần tử khác nhau của 2 hoặc nhiều set
difference_update() | Xóa các phần tử của set này mà tồn tại trong set khác
discard() | Xóa phần tử được chỉ định.
intersection() | Trả về một set mà các phần tử của nó tồn tại trong cả 2 set đã cho.
intersection_update() | Xóa các phần tử của set này mà không tồn tại trong set kia.
isdisjoint() | Trả về true nếu không có phần tử nào trong một set trùng với phần tử nào trong set thứ 2. Trả về false nếu có bất kỳ phần tử nào trong set ban đầu giống với set thứ 2
issubset() | Trả về true nếu tất cả các phần tử trong một set tồn tại trong set2, ngược lại trả về false.
issuperset() | Trả về true nếu tất cả các phần tử trong set2 tồn tại trong một set, ngược lại trả về false.
pop() | Xóa phần tử cuối cùng của một set.
remove() | Xóa phần tử được chỉ định.
symmetric_difference() | Trả về một set mà chứa các phần tử của cả 2 set đã cho, sao cho các phần tử này tồn tại trong set này nhưng không tồn tại trong set kia.
symmetric_difference_update() | Cập nhật set ban đầu bằng việc loại bỏ phần tử của cả 2 set đã cho, sao cho các phần tử này tồn tại trong set này nhưng không tồn tại trong set kia.
union() | Trả về môt set mà được nối từ 2 set với nhau.
update() | Nối set này với set khác.

# data[].attributes.body
def string_length(str1):
count = 0
for char in str1:
count += 1
return count
print(string_length('w3resource.com'))

# data[].attributes.body
def char_frequency(str1):
dict = {}
for n in str1:
keys = dict.keys()
if n in keys:
dict[n] += 1
else:
dict[n] = 1
return dict
print(char_frequency('google.com'))

# data[].attributes.body
def string_both_ends(str):
if len(str) < 2:
return ''

return str[0:2] + str[-2:]

print(string_both_ends('w3resource'))
print(string_both_ends('w3'))
print(string_both_ends('w'))

# data[].attributes.body
def change_char(str1):
char = str1[0]
str1 = str1.replace(char, '$')
str1 = char + str1[1:]

return str1

print(change_char('restart'))

# data[].attributes.body
def chars_mix_up(a, b):
new_a = b[:2] + a[2:]
new_b = a[:2] + b[2:]

return new_a + ' ' + new_b
print(chars_mix_up('abc', 'xyz'))

# data[].attributes.body
def add_string(str1):
length = len(str1)

if length > 2:
if str1[-3:] == 'ing':
str1 += 'ly'
else:
str1 += 'ing'

return str1
print(add_string('ab'))
print(add_string('abc'))
print(add_string('string'))

# data[].attributes.body
def change_sring(str1):
return str1[-1:] + str1[1:-1] + str1[:1]

print(change_sring('abcd'))

# data[].attributes.body
def remove_char(str, n):
first_part = str[:n]
last_part = str[n+1:]
return first_part + last_part

# data[].attributes.body
def odd_values_string(str):
result = ""
for i in range(len(str)):
if i % 2 == 0:
result = result + str[i]
return result

print(odd_values_string('abcdef'))

# data[].attributes.body
def word_count(str):
counts = dict()
words = str.split()

for word in words:
if word in counts:
counts[word] += 1
else:
counts[word] = 1

return counts

print( word_count('the quick brown fox jumps over the lazy dog.'))

# data[].attributes.body
s=input("Nhập chuỗi: ")
def bien_doi_chuoi(s):
if s[0].islower():
print(s.upper())
if s[0].isupper():
print (s.lower())
bien_doi_chuoi(s)

# data[].attributes.body
Tên key không trùng.

Key sẽ cách nhau dấu phẩy và giá trị và biến đều đặt trong dấu ngoặc “ ” hay ‘ ’ trừ số.

Ta có thể để dict, list, tuple trong list .

Mỗi key cần có một giá trị và ngăn nhau bởi dấu hai chấm.

# data[].attributes.body
[ ] dùng khi khai báo List

( ) dùng khi khai báo Tuple

{ } dùng khi khai báo Dictionary hoặc Set

# data[].attributes.body
Các phần tử trong tập hợp không có thứ tự.
Các phần tử này là duy nhất, không cho phép lặp lại.
Set có thể thay đổi (thêm bớt phần tử) nhưng các phần tử của tập hợp phải ở dạng không thể thay đổi (tức là xác định được dung lượng bộ nhớ ngay khi khai báo).

# data[].attributes.body
Hãy xóa tất cả các phần tử ra khỏi dict d = {1: "one", 2: "two"}

d = {1: "one", 2: "two"}
d.clear()
print('d =', d)

Khi chạy chương trình này thì ta có được kết quả sau:
d = {}

# data[].attributes.body
khai báo một dictionary về bản thân người dùng tên là person
person = {
'name': 'ABC',
'age': 22,
'male': True,
'status': 'single'
}

# data[].attributes.body
tạo một Dictionary chứa 3 Dictionary khác.

myfamily = {
"child1" : {
"name" : "Van",
"birthday" : 2004
},
"child2" : {
"name" : "Minh",
"birthday" : 2007
},
"child3" : {
"name" : "Phuc",
"birthday" : 2011
}
}

print(myfamily)