Hướng dẫn python create variable name from dictionary key - python tạo tên biến từ khóa từ điển

Đ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)))
1

Hy 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
    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:
  • Đ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:
  • 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.
  • Vòng lặp qua từ điển Or

Làm thế nào để bạn tạo một tên biến động trong Python?

Việc tạo ra một tên biến động trong Python có thể đạt được với sự trợ giúp của phép lặp. Cùng với vòng lặp For, hàm Globals () cũng sẽ được sử dụng trong phương pháp này. Phương thức Globals () trong Python cung cấp đầu ra như một từ điển của bảng biểu tượng toàn cầu hiện tại.with the help of iteration. Along with the for loop, the globals() function will also be used in this method. The globals() method in Python provides the output as a dictionary of the current global symbol table.

Bạn có thể sử dụng một biến làm khóa trong một python từ điển không?

Các khóa là duy nhất trong một từ điển trong khi các giá trị có thể không.Các giá trị của từ điển có thể thuộc bất kỳ loại nào, nhưng các khóa phải thuộc loại dữ liệu bất biến như chuỗi, số hoặc bộ dữ liệu.. The values of a dictionary can be of any type, but the keys must be of an immutable data type such as strings, numbers, or tuples.

Làm thế nào để bạn gán một biến cho một khóa trong Python?

Sử dụng eval () để tạo các khóa từ điển từ các biến CALL EVAL (biến_name) để trả lại giá trị được lưu cho biến_name.Sử dụng cú pháp gán từ điển Dictax dict [key] = giá trị để gán giá trị cho khóa trong dict.Use the dictionary assignment syntax dict[key] = value to assign value to key in dict .

Giá trị từ điển Python có thể là một biến không?

Bất cứ điều gì có thể được lưu trữ trong một biến Python đều có thể được lưu trữ trong một giá trị từ điển.Điều đó bao gồm các loại có thể thay đổi bao gồm danh sách và thậm chí là Dict - có nghĩa là bạn có thể làm tổ từ điển bên trong một loại khác.Các phím ngược phải có thể băm và bất biến - đối tượng băm không được thay đổi sau khi tính toán.. That includes mutable types including list and even dict — meaning you can nest dictionaries inside on another. In contrast keys must be hashable and immutable — the object hash must not change once calculated.