General Python Notes

Python 3.8.2 (tags/v3.8.2:7b3ab59, Feb 25 2020, 23:03:10) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> # functions of dictionary
>>> # clear
>>> d1 = {"1": APPLE, "2":Ball}
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    d1 = {"1": APPLE, "2":Ball}
NameError: name 'APPLE' is not defined
>>> d1 = {1: "Apple", 2: "Ball"}
>>> d1.copy()
{1: 'Apple', 2: 'Ball'}
>>> d2 = d1.copy()
>>> d2
{1: 'Apple', 2: 'Ball'}
>>> type(d2)
<class 'dict'>
>>> d2.clear()
>>> d2
{}
>>> # 1.clear 2. copy 3. fromkeys = (it creates s new dict. from an iterable & it will use elements from iterable as Keys)
>>> # and for value it will use default values
>>> # example of fromkeys()
>>> a = {1:100, 2:200}
>>> b = (5,6,7) #tuple
>>> # tuple & list are iterables
>>> a.fromkeys(b)
{5: None, 6: None, 7: None}
>>> help(a.fromkeys(b))
Help on dict object:

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |  
 |  Methods defined here:
 |  
 |  __contains__(self, key, /)
 |      True if the dictionary has the specified key, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(self, /)
 |      Return a reverse iterator over the dict keys.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  get(self, key, default=None, /)
 |      Return the value for key if key is in the dictionary, else default.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(self, /)
 |      Remove and return a (key, value) pair as a 2-tuple.
 |      
 |      Pairs are returned in LIFO (last-in, first-out) order.
 |      Raises KeyError if the dict is empty.
 |  
 |  setdefault(self, key, default=None, /)
 |      Insert key with a value of default if key is not in the dictionary.
 |      
 |      Return the value for key if key is in the dictionary, else default.
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Create a new dictionary with keys from iterable and values set to value.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

>>> #a is used tp invoke the function ONLY
>>> dict.fromkeys(b)
{5: None, 6: None, 7: None}
>>> dict.fromkeys(a)
{1: None, 2: None}
>>> dict.fromkeys(b)
{5: None, 6: None, 7: None}
>>> dict
<class 'dict'>
>>> dict.fromkeys(b, 22)
{5: 22, 6: 22, 7: 22}
>>> dict.fromkeys(b, 22, 23)
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    dict.fromkeys(b, 22, 23)
TypeError: fromkeys expected at most 2 arguments, got 3
>>> # 4. get() function
>>> # it is used to acess values of dict.
>>> a.get(2)
200
>>> a.get(1)
100
>>> # dict has no support for INDEXES
>>> # 5. items() function
>>> # it makes a dict. iterable
>>> a.items()
dict_items([(1, 100), (2, 200)])
>>> # example for items()
>>> for i,j in a.items():
	print(i, j)

	
1 100
2 200
>>> # keys() ==> it return a list of keys from dict
>>> a.keys()
dict_keys([1, 2])
>>> b.keys()
Traceback (most recent call last):
  File "<pyshell#39>", line 1, in <module>
    b.keys()
AttributeError: 'tuple' object has no attribute 'keys'
>>> # values() fun. ==> it returns list of values from dict
>>> a.values()
dict_values([100, 200])
>>> # pop and popitem
>>> a.pop()
Traceback (most recent call last):
  File "<pyshell#43>", line 1, in <module>
    a.pop()
TypeError: pop expected at least 1 argument, got 0
>>> a.pop(1)
100
>>> a
{2: 200}
>>> a.popitem
<built-in method popitem of dict object at 0x0000017C150CD480>
>>> # setdefault
>>> it extends the existing dict
SyntaxError: invalid syntax
>>> # update fun.
>>> # it adds new itemto a dict / it can update new value to pre existing key
>>> a.update({3:300})
>>> a
{2: 200, 3: 300}
>>>