Điều tốt nhất để làm là sử dụng
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
2. Tuy nhiên, để trả lời câu hỏi, bạn có thể sử dụng chức năng import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
3. Lợi ích của việc thực hiện theo cách này là bạn có thể làm điều này không phải mã cứng bất kỳ tên biến nào hoặc giới hạn bản thân để làm việc bên trong một chức năng.from numpy import array,matrix
temp = {'key':array[[1,2]],'b': 4.3,'c': 'foo','d':matrix[[2,2]]}
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = repr[temp[k]]]]
>>> key
array[[1, 2]]
>>> b
4.3
>>> c
'foo'
>>> d
matrix[[[2, 2]]]
Lưu ý: Điều này sẽ chỉ hoạt động nếu bạn đã nhập chức năng cụ thể từ các mô -đun. Nếu bạn không muốn làm điều này vì thực hành mã hoặc khối lượng chức năng tuyệt đối mà bạn sẽ cần nhập, bạn có thể viết một chức năng để kết hợp tên mô -đun trước mục nhập. Đầu ra giống như ví dụ trước. This will only work if you have imported the specific function from the modules. If you don't want to do this because of code practice or the sheer volume of function that you would need to import, you could write a function to concatenate the module name in front of the entry. Output is the same as the previous example.
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
Mặc dù đây không phải là cách thực hành mã tốt nhất, nhưng nó hoạt động tốt cho tất cả các ví dụ tôi đã thử nghiệm.
hoặc một trong đó chứa một danh sách các tác giả là khóa [dưới dạng chuỗi] và sách của họ [như một danh sách các chuỗi]:
Bài tập 3¶
Từ điển trong Python được tạo ra bằng cách sử dụng dấu ngoặc xoăn. Tạo một tệp mới có tên
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
4 và đặt nó vào đó:dict.py
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]
Những gì chúng tôi đã làm ở đây là tạo ra một từ điển trên dòng đầu tiên. Một từ điển được tạo bằng cách sử dụng dấu ngoặc xoăn [
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
5], theo cách tương tự như dấu ngoặc vuông được sử dụng để tạo danh sách. Từ điển chúng tôi đã tạo ở đây có ba mục trong đó mỗi mục bao gồm một khóa và một giá trị. Giá trị là dữ liệu thực mà chúng tôi muốn giữ và chìa khóa là cách chúng tôi có thể nhận được dữ liệu chúng tôi muốn. Khóa và giá trị được phân tách bằng một dấu hai chấm và mỗi cặp giá trị phím được phân tách bằng dấu phẩy.Trên dòng tiếp theo, chúng tôi truy cập dữ liệu trong Từ điển
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
6. Một lần nữa, như danh sách chúng tôi sử dụng dấu ngoặc vuông để đặt câu hỏi về dữ liệu của chúng tôi. Trong trường hợp này, chúng tôi yêu cầu từ điển cung cấp cho chúng tôi giá trị liên quan đến khóa import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
7 và do đó nó sẽ quay lại với chúng tôi import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
8.Vì từ điển có thể khá lớn và đôi khi có thể khó nhìn thấy phần nào là khóa và là giá trị nào, nên có thể viết từ điển trên nhiều dòng, một dòng trên mỗi mục giá trị khóa:
dict.py
sounds = { "cat": "meow", "dog": "woof", "horse": "neigh" } cat_sound = sounds["cat"] print[cat_sound]
Bài tập 1¶
Chỉnh sửa
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
4 để yêu cầu âm thanh cho con chó và con ngựa.- Điều gì xảy ra nếu bạn yêu cầu một con vật không có trong từ điển?
câu trả lời
Thêm dữ liệu mới vào từ điển Or
Như với danh sách, từ điển rất năng động để chúng ta có thể thêm các mục vào từ điển.
Hãy nói rằng chúng tôi muốn thêm một âm thanh mới cho một con bò vào từ điển
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
6 của chúng tôi. Khóa mà dữ liệu sẽ có là sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]1 và giá trị sẽ là
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]2. Để làm như vậy, chúng tôi đặt
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]3 ở phía bên trái của biểu thức gán biến, như thể chúng tôi tạo một biến mới. Ở bên phải đi dữ liệu mà chúng tôi muốn đưa vào từ điển:
dict.py
sounds = { "cat": "meow", "dog": "woof", "horse": "neigh" } sounds["cow"] = "moo" print[sounds]
Điều này nói rằng chúng tôi muốn giá trị
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]2 được liên kết với khóa
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]1 trong từ điển
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
6.Chạy nó, chúng ta thấy:
{'cat': 'meow', 'dog': 'woof', 'horse': 'neigh', 'cow': 'moo'}
Bài tập 2¶
Chỉnh sửa
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
4 để từ điển ban đầu được xác định chỉ với các mục mèo và chó. Thêm mục cho con ngựa và sau đó con bò tự động.câu trả lời
Thêm dữ liệu mới vào từ điển Or
Như với danh sách, từ điển rất năng động để chúng ta có thể thêm các mục vào từ điển.
Hãy nói rằng chúng tôi muốn thêm một âm thanh mới cho một con bò vào từ điển
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
6 của chúng tôi. Khóa mà dữ liệu sẽ có là sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]1 và giá trị sẽ là
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]2. Để làm như vậy, chúng tôi đặt
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]3 ở phía bên trái của biểu thức gán biến, như thể chúng tôi tạo một biến mới. Ở bên phải đi dữ liệu mà chúng tôi muốn đưa vào từ điển:
dict_loop.py
sounds = { "cat": "meow", "dog": "woof", "horse": "neigh" } for thing in sounds: print[thing]
Điều này nói rằng chúng tôi muốn giá trị
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]2 được liên kết với khóa
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]1 trong từ điển
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
6.Chạy nó, chúng ta thấy:
dict_loop.py
sounds = { "cat": "meow", "dog": "woof", "horse": "neigh" } for sound in sounds.values[]: print[sound]
Bài tập 2¶
dict_loop.py
sounds = { "cat": "meow", "dog": "woof", "horse": "neigh" } for animal, sound in sounds.items[]: print[animal, "goes", sound]
cat goes meow dog goes woof horse goes neigh
Chỉnh sửa
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
4 để từ điển ban đầu được xác định chỉ với các mục mèo và chó. Thêm mục cho con ngựa và sau đó con bò tự động.Vòng lặp qua từ điển Or
Khi thảo luận về các vòng lặp
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]8, bạn được thông báo rằng Python cho phép bạn lặp lại nhiều loại dữ liệu khác nhau như danh sách, chuỗi và
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]9s. Chúng ta có thể thêm từ điển vào bộ đó.
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
0Để khám phá cách thức hoạt động, trước tiên hãy làm điều ngây thơ và chỉ xem điều gì xảy ra khi chúng ta lặp qua một từ điển:
import numpy as np,numpy
temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]}
def exec_str[key,mydict]:
s = str[type[mydict[key]]]
if '.' in s:
start = s.index["'"] + 1
end = s.index["."] + 1
v = s[start:end:] + repr[mydict[key]]
else:
v = repr[mydict[key]]
return v
for k in temp:
exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
1Hy vọng, bạn nhận ra những thứ đó là chìa khóa từ từ điển. Vì vậy, dường như khi lặp qua một từ điển, chúng tôi sẽ được cung cấp các chìa khóa.
Điều gì sẽ xảy ra nếu, ví dụ, bạn muốn lặp qua các giá trị thay thế. Chà, có một phương pháp về từ điển gọi là
sounds = { "cat": "meow", "dog": "woof", "horse": "neigh" } cat_sound = sounds["cat"] print[cat_sound]0 cung cấp cho bạn những thứ đó để bạn có thể lặp lại chúng:
câu trả lời
Thêm dữ liệu mới vào từ điển Or
- Như với danh sách, từ điển rất năng động để chúng ta có thể thêm các mục vào từ điển.
- Hãy nói rằng chúng tôi muốn thêm một âm thanh mới cho một con bò vào từ điển
6 của chúng tôi. Khóa mà dữ liệu sẽ có làimport numpy as np,numpy temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]} def exec_str[key,mydict]: s = str[type[mydict[key]]] if '.' in s: start = s.index["'"] + 1 end = s.index["."] + 1 v = s[start:end:] + repr[mydict[key]] else: v = repr[mydict[key]] return v for k in temp: exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]
1 và giá trị sẽ làsounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]
2. Để làm như vậy, chúng tôi đặtsounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]
3 ở phía bên trái của biểu thức gán biến, như thể chúng tôi tạo một biến mới. Ở bên phải đi dữ liệu mà chúng tôi muốn đưa vào từ điển: - Điều này nói rằng chúng tôi muốn giá trị
sounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]
2 được liên kết với khóasounds = {"cat": "meow", "dog": "woof", "horse": "neigh"} cat_sound = sounds["cat"] print[cat_sound]
1 trong từ điển
6.import numpy as np,numpy temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]} def exec_str[key,mydict]: s = str[type[mydict[key]]] if '.' in s: start = s.index["'"] + 1 end = s.index["."] + 1 v = s[start:end:] + repr[mydict[key]] else: v = repr[mydict[key]] return v for k in temp: exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
- Chạy nó, chúng ta thấy:
- Bài tập 2¶
- Chỉnh sửa
4 để từ điển ban đầu được xác định chỉ với các mục mèo và chó. Thêm mục cho con ngựa và sau đó con bò tự động.import numpy as np,numpy temp = {'key':np.array[[1,2]],'b': 4.3,'c': 'foo','d':np.matrix[[2,2]]} def exec_str[key,mydict]: s = str[type[mydict[key]]] if '.' in s: start = s.index["'"] + 1 end = s.index["."] + 1 v = s[start:end:] + repr[mydict[key]] else: v = repr[mydict[key]] return v for k in temp: exec['{KEY} = {VALUE}'.format[KEY = k, VALUE = exec_str[k,temp]]]
- Vòng lặp qua từ điển Or