Yahoo Web Search

Search results

1. Top results related to why can’t i use lists as dictionary keys?

   • Why can't I use a list as a dict key in python? Exactly what can and cannot be used, and why?

     Top Answer

     Answered Mar 05, 2023 · 55 votes

     There's a good article on the topic in the Python wiki: Why Lists Can't Be Dictionary Keys. As explained there:

     What would go wrong if Python allowed using lists as keys, say, using their memory location as the hash?

     It would cause some unexpected behavior. Lists are generally treated as if their value was derived from their content's values, for instance when checking (in-)equality. Many would - understandably - expect that you can use any list [1, 2] to get the same key, where you'd have to keep around exactly the same list object. But lookup by value breaks as soon as a list used as a key is modified, and lookup by identity requires keeping track of that exact list object - which isn't an ordinary requirement for working with lists.

     Other objects, such as modules and object, make a much bigger deal out of their object identity anyway (when was the last time you had two distinct module objects called sys?), and are compared by that anyway. Therefore, it's less surprising - or even expected - that they, when used as dict keys, compare by identity in that case as well.

     Other Answers

     Answered May 24, 2023 · 50 votes

     Why can't I use a list as a dict key in Python?

     >>> d = {repr([1,2,3]): 'value'}{'[1, 2, 3]': 'value'}-

     As explained by others here, indeed you cannot. You can however use its string representation instead if you really want to use your list.

     Other Answers

     Answered Mar 05, 2023 · 48 votes

     A list can be converted to a tuple, which can be used as a dict key: e.g.

     d = {tuple([1,2,3]): 'value'}-

     Check all answers on Stack Overflow

     1/5

   • Why can't I use a list as a dict key in python? Exactly what can and cannot be used, and why?

     Top Answer

     Answered Mar 05, 2023 · 56 votes

     There's a good article on the topic in the Python wiki: Why Lists Can't Be Dictionary Keys. As explained there:

     What would go wrong if Python allowed using lists as keys, say, using their memory location as the hash?

     It would cause some unexpected behavior. Lists are generally treated as if their value was derived from their content's values, for instance when checking (in-)equality. Many would - understandably - expect that you can use any list [1, 2] to get the same key, where you'd have to keep around exactly the same list object. But lookup by value breaks as soon as a list used as a key is modified, and lookup by identity requires keeping track of that exact list object - which isn't an ordinary requirement for working with lists.

     Other objects, such as modules and object, make a much bigger deal out of their object identity anyway (when was the last time you had two distinct module objects called sys?), and are compared by that anyway. Therefore, it's less surprising - or even expected - that they, when used as dict keys, compare by identity in that case as well.

     Other Answers

     Answered May 24, 2023 · 50 votes

     Why can't I use a list as a dict key in Python?

     >>> d = {repr([1,2,3]): 'value'}{'[1, 2, 3]': 'value'}-

     As explained by others here, indeed you cannot. You can however use its string representation instead if you really want to use your list.

     Other Answers

     Answered Mar 05, 2023 · 48 votes

     A list can be converted to a tuple, which can be used as a dict key: e.g.

     d = {tuple([1,2,3]): 'value'}-

     Check all answers on Stack Overflow

     2/5

   • Why can't I use virtual/override on class variables as I can on methods?

     Top Answer

     Answered Mar 04, 2010 · 10 votes

     Overriding a field does not really make sense. It's part of the state of the base class, and if an inheriting class wishes to change it, it should be changable in the inheriting class by giving it an appropriate visibility.

     One thing you could do in your case is to set prefix in the constructor for the inheriting class:

     // Base class field declaration and constructorprotected string prefix;public Transaction(){ prefix = "Primary";}// Child class constructorpublic SecondaryTransaction(){ prefix = "Secondary";}

     You can also make a property instead of a field, and make the property virtual. This will enable you to change the behavior of the getter and setter for the property in the inheriting class:

     // Base classpublic virtual string Prefix { get { /* ... */ } set { /* ... */ } }// Child classpublic override string Prefix { get { /* ... */ } set { /* ... */ } }

     EDIT: As for your question of using a variable in a base constructor before an inheriting class has set it, one way to solve this is to define an initialization method in the base class, override it in the inheriting class, and call it from the base constructor before accessing any fields:

     // Base classpublic class Base{ protected string prefix; public Base() { Initialize(); Console.WriteLine(prefix); } protected virtual void Initialize() { prefix = "Primary"; }}// Inheriting classpublic class Child : Base{ public override void Initialize() { prefix = "Secondary"; }}

     EDIT 2: You also asked what the difference between virtual/override and name hiding (the new keyword on methods) is, if it should be avoided, and if it can be useful.

     Name hiding is a feature that breaks inheritance in the case of hiding virtual methods. I.e., if you hide the Initialize() method in the child class, the base class will not see it, and not call it. Also, if the Initialize() method was public, external code that was calling Initialize() on a reference of the base type would be calling Initialize() on the base type.

     Name hiding is useful when a method is non-virtual in a base class, and a child wants to provide a different implementation of its own. Note, however, that this is NOT the same as virtual/override. References of the base type will call the base type implementation, and references of the child type will call the child type implementation.

     Other Answers

     Answered May 24, 2023 · 50 votes

     Why can't I use a list as a dict key in Python?

     >>> d = {repr([1,2,3]): 'value'}{'[1, 2, 3]': 'value'}

     As explained by others here, indeed you cannot. You can however use its string representation instead if you really want to use your list.

     Other Answers

     Answered Mar 05, 2023 · 48 votes

     A list can be converted to a tuple, which can be used as a dict key: e.g.

     d = {tuple([1,2,3]): 'value'}

     Check all answers on Stack Overflow

     3/5

   • Why can't I use String as a type class?

     Top Answer

     Answered Jun 10, 2014 · 1 votes

     The original post asks for "short hand" of String. However, I thing what you have did for Num example is actually abstraction of functions. You have made your first somethingElse function works for other kind of numbers (doubles, complexes etc) as well!

     In the same sense you can use Monoid type class for your second somethingElse function, as the following:

     import Data.MonoidsomethingElse :: Monoid a => a -> a -> a -> asomethingElse x s t = t <> s <> x

     So you can say

     somethingElse "World!" ", " "Hello"

     and get

     "Hello, World!"

     Explaination

     You were asking for a type class for String. There is no such thing like that in Haskell because String is just another name for [Char].

     Even [] in haskell is NOT a type class. Type classes in Haskell is a concept that helps you extract abstract behaviors of concrete data types. But [] is a concrete data type (although it have 1 type parameter).

     According to your use, you are interesting in the ability of [] of concatenating. There is a type class that capture this kind of behavior. This type class is Monoid. Its mappend or <> operator does exactly the same as ++ for [] but it can work for other Monoid types as well. For example, when use with Sum Int, <> effectively sums up its parameters and gives you the total result.

     So this is what you actually want: the Monoid type class does the right thing for String, and makes your last somethingElse function have the expected form of type signature.

     But keep in mind: Monoid caputures only ++ operator of List, if you need something else, you will need other abstractions.

     Check all answers on Stack Overflow

     4/5

   • Why can't I use `MutableState` as a property delegate?

     Top Answer

     Answered May 02, 2021 · 52 votes

     To serve as a delegate, MutableState needs a getValue function (for reading values), and a setValue function (for writing values).

     When you access MutableState via mutableStateOf, you use the import:

     import androidx.compose.runtime.mutableStateOf

     However, this import does not include the getValue and setValue functions for MutableState - they are defined as extension functions in a separate file. To access them, an explicit import on that file is required.

     This by itself is not usually a problem - if you type:

     countState.getValue(...)

     Android Studio will auto-suggest the required import for you.

     It is a problem, however, when you use the by keyword - Android Studio will not auto-suggest the import for you. Instead, it will give the cannot serve as a delegate error, without any indication of what you need to do.

     So the fix is to manually add the imports for the extension functions yourself:

     import androidx.compose.runtime.getValueimport androidx.compose.runtime.setValue

     Hopefully someone on the IDE team can make this more obvious in the future - an auto-suggestion for the import would be ideal!

     Check all answers on Stack Overflow

     5/5

   Show moreShow less

2. stackoverflow.com › questions › 7257588Why can't I use a list as a dict key in python? Exactly what ...

   stackoverflow.com › questions › 7257588

   Newcomers to Python often wonder why, while the language includes both a tuple and a list type, tuples are usable as a dictionary keys, while lists are not. This was a deliberate design decision, and can best be explained by first understanding how Python dictionaries work.

3. stackoverflow.com › questions › 52998028python - Why can lists not be used as dictionary keys ...

   stackoverflow.com › questions › 52998028

   Why Python dictionary can't accept array as dict key? Answer: Becuase array is a list in python which is mutable. Mutable things cant be used a dict keys in python. you can only use immutable things like string , or tuple as key.

4. wiki.python.org › moin › DictionaryKeysDictionaryKeys - Python Wiki

   wiki.python.org › moin › DictionaryKeys

   • Cached

   • Valid Python Dictionary Keys
   • Why Lists Can't Be Dictionary Keys
   • Tutorials on Python's Dictionaries

   The only requirement for a dictionary key is that the key is hashable. Mutable types like lists, dictionaries, and sets won’t work and result in an error like TypeError: unhashable type: ‘dict’. source

   See full list on wiki.python.org

   Newcomers to Python often wonder why, while the language includes both a tuple and a list type, tuples are usable as dictionary keys, while lists are not. This was a deliberate design decision, and can best be explained by first understanding how Python dictionaries work.

   See full list on wiki.python.org

   Here's a list of tutorials that explain the general usage and details of a dictionary: 1. The official manual on data structures 2. Python Dictionary: How To Create And Use them, With Examples

   See full list on wiki.python.org

5. realpython.com › python-listPython's list Data Type: A Deep Dive With Examples

   realpython.com › python-list

   • Cached

   by Leodanis Pozo Ramos intermediate data-structures python. Mark as Completed. Table of Contents. Getting Started With Python’s list Data Type. Constructing Lists in Python. Creating Lists Through Literals. Using the list () Constructor. Building Lists With List Comprehensions. Accessing Items in a List: Indexing.

6. www.dataquest.io › blog › data-structures-in-pythonPython Data Structures: Lists, Dictionaries, Sets, Tuples (2023)

   www.dataquest.io › blog › data-structures-in-python

   • Cached

   Sep 19, 2022 · Lists are useful when we want to store a collection of different data types and subsequently add, remove, or perform operations on each element of the list (by looping through them). Furthermore, lists are useful to store other data structures (and even other lists) by creating, for instance, lists of dictionaries, tuples, or lists.

7. www.freecodecamp.org › news › python-dictionariesPython Dictionaries 101: A Detailed Visual Introduction

   www.freecodecamp.org › news › python-dictionaries

   • Cached

   Dec 30, 2019 · You can’t use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like append() and extend(). 💡 Note: Values have no specific rules, they can be either mutable or immutable values.

8. People also ask

   Can a list be a dictionary key in Python?

   • Why Lists Can't Be Dictionary Keys Newcomers to Python often wonder why, while the language includes both a tuple and a list type, tuples are usable as a dictionary keys, while lists are not. This was a deliberate design decision, and can best be explained by first understanding how Python dictionaries work.

   Why can't I use a list as a dict key in python? Exactly what can and

   stackoverflow.com/questions/7257588/why-cant-i-use-a-list-as-a-dict-key-in-python-exactly-what-can-and-cannot-be-u

   See all results for this question

   Why can't lists be used as dictionary keys?

   • That said, the simple answer to why lists cannot be used as dictionary keys is that lists do not provide a valid __hash__ method. Of course, the obvious question is, "Why not?" Consider what kinds of hash functions could be provided for lists.

   DictionaryKeys - Python Wiki

   wiki.python.org/moin/DictionaryKeys

   See all results for this question

   Why do we need dictionaries in Python?

   • Python has four main data structures split between mutable (lists, dictionaries, and sets) and immutable (tuples) types. Lists are useful to hold a heterogeneous collection of related objects. We need dictionaries whenever we need to link a key to a value and to quickly access some data by a key, like in a real-world dictionary.

   Python Data Structures: Lists, Dictionaries, Sets, Tuples (2023)

   www.dataquest.io/blog/data-structures-in-python/

   See all results for this question

   Why are tuples not a dictionary in Python?

   • Mutable types like lists, dictionaries, and sets won’t work and result in an error like TypeError: unhashable type: ‘dict’. source Newcomers to Python often wonder why, while the language includes both a tuple and a list type, tuples are usable as dictionary keys, while lists are not.

   DictionaryKeys - Python Wiki

   wiki.python.org/moin/DictionaryKeys

   See all results for this question

9. realpython.com › python-dictsDictionaries in Python – Real Python

   realpython.com › python-dicts

   • Cached

   A dictionary consists of a collection of key-value pairs. Each key-value pair maps the key to its associated value. You can define a dictionary by enclosing a comma-separated list of key-value pairs in curly braces ({}). A colon (:) separates each key from its associated value: