List</th>	Tuple</th></tr></thead>
Lists are mutable</td>	Tuples are immutable</td></tr>
Lists are not hashable since they are mutable.</td>	Tuples are hashable</td></tr>
Defined using []</td>	Defined using ()</td></tr>
Lists take more memory due to the overhead of managing dynamic memory allocation</td>	Tuples take less memory compared to lists</td></tr>
It is slower for accessing elements due to dynamic memory allocation</td>	Tuples are faster in accessing elements</td></tr>
It is suitable for situations when elements are needed to be frequently added or removed</td>	Tuples are suitable for situations where data needs to be fixed and does not need to be modified</td></tr> </tbody></table> 🔗</a>What are virtual environments in Python?</h3> Virtual environments are isolated environments which contain their own Python version and packages.</p> </li> They allow you to create a separate environment for each project or application you are working on, with its own set of dependencies, without affecting the global environment or other projects.</p> </li> This can be especially useful when working on multiple projects that require different versions of the same package or library.</p> </li> Python virtual environments can be created using the venv module, which is included with Python 3.3 and later versions.</p> </li> Example: `python3 -m venv env_name</code></p> </li> </ul>` 🔗</a>What is the difference between a function and a method in Python?</h3> Function</th> Method</th></tr></thead> A block of usable code that performs a task</td> A function that is associated with an object</td></tr> Defined outside of a class</td> Defined inside a class</td></tr> Can be called anywhere in the program</td> Can only be called on an instance of the class</td></tr> Accepts arguments and returns a value</td> Accepts arguments but also can access and modify the attributes of the instance on which it is called upon</td></tr> It is defined with the def keyword followed by function name and parameters</td> Defined with def keyword followed by method name and parameters</td></tr> It doesn’t have self parameter</td> Implicit first argument is the object on which the method is called, self by convention</td></tr> Example: len("world")</code></td> Example: "world".lower()</code></td></tr> </tbody></table> 🔗</a>What is an exception in Python?</h3> An exception is an error that happens during execution of a program.</p> </li> When an exception occurs, the normal flow of the program is disrupted and interpreter raises an exception object (of Exception class).</p> </li> If exception is not handled then program will terminate.</p> </li> Python provides built-in exceptions for common error conditions, such as IndexError</code>, ValueError</code>, TypeError</code>, etc.</p> </li> You can also create your own exception by inheriting from base Exception class.</p> </li> </ul> 🔗</a>How to handle Exceptions in Python?</h3> Python provides a mechanism to handle exception using try-except</code> blocks.</p> </li> A try</code> block contains the code that may cause the exception.</p> </li> And except</code> block contains the code that handles the exception.</p> </li> </ul> try</span>:</span></span> x</span> =</span> 1</span> /</span> 0</span></span> except</span> ZeroDivisionError</span>:</span></span> print</span>(</span>"this is not how maths work"</span>)</span></span></code></pre> You can also use a finally</code> block after the except block to specify code that should be executed regardless of whether an exception was raised or not. The finally</code> block is optional, but it’s useful for releasing resources or cleaning up after the code in the try block.</p> </li> We also can have else</code> block. The else</code> block contains the code that is executed if no exception is raised in the try block. It is optional and executes after the try</code> block but before the finally</code> block.</p> </li> </ul> 🔗</a>How do you handle file I/O in Python?</h3> Python provides built-in function open()</code> to handle file I/O.</p> </li> The open()</code> function takes two arguments: name of the file and the mode in which to open the file (e.g. read, write, append, etc.).</p> </li> To read data from a file, you can use the read()</code> method, which reads the entire contents of the file, or the readline()</code> method, which reads one line at a time.</p> </li> To write data to a file, you can use the write()</code> method, which writes a string to the file, or the writelines()</code> method, which writes a list of strings to the file.</p> </li> After you are done working with the file, you should close the file using the close()</code> method.</p> </li> </ul> 🔗</a>What is a static method?</h3> Static method is a method which belongs to class rather than instance of the class.</p> </li> It does not have access to the instance or it’s attributes.</p> </li> It does not require self</code> parameter that instance method usually have.</p> </li> Static methods are defined using the @staticmethod</code> decorator.</p> </li> </ul> class</span> FooClass</span>:</span></span> @</span>staticmethod</span></span> def</span> my_static_method</span>():</span></span> print</span>(</span>"calling static method"</span>)</span></span> </span> # Calling the static method without creating an instance of the class</span></span> FooClass</span>.</span>my_static_method</span>()</span></span></code></pre>🔗</a>What is a class method?</h3> A class method is method that is bound to the class and not to the instance of the class.</p> </li> Class method knows about the class and it’s attributes, but it can’t access individual instance or their attributes.</p> </li> </ul> class</span> BarClass</span>:</span></span> class_attribute</span> =</span> "a class attribute."</span></span> </span> @</span>classmethod</span></span> def</span> my_class_method</span>(</span>cls</span>):</span></span> print</span>(</span>"Class attribute:"</span>,</span> cls</span>.</span>class_attribute)</span></span> </span> # Calling the class method on the class itself</span></span> BarClass</span>.</span>my_class_method</span>()</span></span></code></pre>🔗</a>What are difference between static method and class method?</h3> Static Method</th> Class Method</th></tr></thead> Static method do not depend on the state of the class or instance</td> Class method operate on the class</td></tr> It does not take any special parameter</td> Takes a special parameter called cls which refers to the class itself</td></tr> Can be called on the class or instance of the class</td> It can be called on the class but not on instance of the class</td></tr> Cannot access or modify the class or instance state</td> It can access and modify class state but not the instance state</td></tr> </tbody></table> 🔗</a>What is the difference between an instance method and a class method in Python?</h3> coming soon</em></p> 🔗</a>What is the Global Interpreter Lock (GIL) in Python?</h3> The Global Interpreter Lock (GIL) is a mechanism used in Python to manage access to shared resources, such as the Python interpreter itself.</p> </li> The GIL is a mutex that prevents multiple threads from executing Python bytecodes at once.</p> </li> The GIL is necessary because Python interpreter is not thread-safe, meaning that it is not designed to handle multiple threads executing Python code simultaneously.</p> </li> The GIL is a feature of the CPython implementation of Python, which is the most widely used implementation.</p> </li> The GIL can prevent multi-core processors from fully utilizing all available cores.</p> </li> The GIL can be released using the threading</code> module’s Lock</code> object, the multiprocessing module, or by using an extension module written in C that releases GIL.</p> </li> </ul> 🔗</a>What is Python package?</h3> A package is a way of organizing related modules into a single namespace.</p> </li> A package is a directory that contains one or more Python modules, as well as an optional __init__.py</code> file that initializes the package.</p> </li> Packages can be imported using import</code> statement.</p> </li> Packages can be installed and distributed using tools such as pip</code> and setuptools</code>.</p> </li> </ul> 🔗</a>What is Python module?</h3> A module is a file containing Python code that can be imported and used in other Python code.</p> </li> A module can define classes, functions and variables that can be used in other Python code.</p> </li> A module can be imported using import</code> statement.</p> </li> Modules can be organized into package which is a directory that contains one or more modules.</p> </li> </ul> 🔗</a>What is the difference between a shallow copy and a deep copy in Python?</h3> coming soon</em></p> 🔗</a>Intermediate</h2> 🔗</a>What is a Python namespace?</h3> coming soon</em></p> 🔗</a>What is the difference between a class and an object in Python?</h3> coming soon</em></p> 🔗</a>How do you implement inheritance in Python?</h3> coming soon</em></p> 🔗</a>How do you implement a singleton pattern in Python?</h3> coming soon</em></p> 🔗</a>What is a decorator?</h3> A decorator is higher-order function that takes a function as input and returns a modified function as output.</p> </li> Decorators are used to modify or enhance the behaviour of a function without changing it’s source code.</p> </li> Decorators can be used with syntax @decorator_name</code> where decorator_name</code> is the name of decorator function.</p> </li> </ul> def</span> my_decorator</span>(</span>func</span>):</span></span> def</span> wrapper</span>():</span></span> print</span>(</span>"Before function is called."</span>)</span></span> func</span>()</span></span> print</span>(</span>"After function is called."</span>)</span></span> return</span> wrapper</span></span> </span> @my_decorator</span></span> def</span> say_hello</span>():</span></span> print</span>(</span>"Hello!"</span>)</span></span></code></pre>🔗</a>What is a lambda function in Python?</h3> A lambda function is an anonymous function that can be defined in a single line of code.</p> </li> A lambda function is defined using lambda</code> keyword followed by the function parameters, a colon and then the function body.</p> </li> Example: lambda i, j: i * j</code></p> </li> Lambda functions can take any number of arguments, but they can have only one expression in the body.</p> </li> Lambda functions are often used as a shortcut for simple functions that are only used once.</p> </li> </ul> 🔗</a>What is a generator in Python?</h3> A generator is type of iterable, like a list or a tuple, but it generates values on the fly instead of storing them in memory.</p> </li> Since it doesn’t store values in memory, it is very memory efficient.</p> </li> Generators can be iterated just like a list or a tuple but indexing is not possible.</p> </li> Generators can be created using generator function or generator expression.</p> </li> A generator function is created using one or more yield</code> statements.</p> </li> Whereas a generator expression is similar to list comprehension but instead of list it returns a iterator.</p> </li> </ul> # generator function</span></span> def</span> gen_number</span>(</span>limit</span>):</span></span> n</span> =</span> 0</span></span> while</span> n</span> <=</span> limit</span>:</span></span> yield</span> n</span></span> n</span> +=</span> 1</span></span> </span> # generator expression</span></span> numbers</span> =</span> (i</span> for</span> i</span> in</span> range</span>(</span>5</span>))</span></span></code></pre>🔗</a>What is the difference between a list comprehension and a generator expression in Python?</h3> coming soon</em></p> 🔗</a>What is a Python iterator?</h3> coming soon</em></p> 🔗</a>What is the difference between iterator and generator in Python?</h3> coming soon</em></p> 🔗</a>Advanced</h2> 🔗</a>What is a context manager in Python?</h3> In Python, a context manager is an object that defines the methods __enter__()</code> and __exit__()</code>, which allows you to define a block of code that should be executed before and after a specific operation.</p> </li> A context manager is used in a with</code> statement, which guarantees that the __enter__()</code> method is called before the block of code is executed, and the __exit__()</code> method is called after the block of code is executed.</p> </li> __enter__()</code> method returns an object that can be used within the with</code> block, and the __exit__()</code> method is used to clean up or release any resources that were used by the with</code> block.</p> </li> </ul> class</span> CustomContextManager</span>:</span></span> def</span> __enter__</span>(</span>self</span>):</span></span> print</span>(</span>"Entering the context."</span>)</span></span> return</span> self</span></span> </span> def</span> __exit__</span>(</span>self</span>,</span> exc_type</span>,</span> exc_value</span>,</span> traceback</span>):</span></span> print</span>(</span>"Exiting the context."</span>)</span></span> </span> def</span> do_something</span>(</span>self</span>):</span></span> print</span>(</span>"Doing something."</span>)</span></span> </span> # Use the context manager to manage a resource</span></span> with</span> CustomContextManager</span>()</span> as</span> cm</span>:</span></span> cm</span>.</span>do_something</span>()</span></span></code></pre>🔗</a>How do you implement multithreading in Python?</h3> coming soon</em></p> 🔗</a>How do you handle data serialization in Python?</h3> coming soon</em></p> 🔗</a>What is the difference between pickle and cPickle in Python?</h3> coming soon</em></p> 🔗</a>What is a Python coroutine?</h3> coming soon</em></p> 🔗</a>What is the difference between a coroutine and a thread in Python?</h3> coming soon</em></p> 🔗</a>How do you implement operator overloading in Python?</h3> coming soon</em></p> 🔗</a>How do you implement garbage collection in Python?</h3> coming soon</em></p> 🔗</a>How do you handle memory management in Python?</h3> coming soon</em></p> 🔗</a>What is a metaclass in Python?</h3> A metaclass is used to define the behavior of a class, such as how it is instantiated or how its attributes are accessed.</p> </li> A metaclass is defined by creating a new class that inherits from type</code>.</p> </li> When a new class is defined, Python looks for a metaclass definition in the class definition, and if one is found, it uses that metaclass to create a new class.</p> </li> </ul> class</span> MyMeta</span>(</span>type</span>):</span></span> def</span> __new__</span>(</span>cls</span>,</span> name</span>,</span> bases</span>,</span> attrs</span>):</span></span> # Modify attributes of the class being created</span></span> attrs[</span>'additional_attr'</span>]</span> =</span> 42</span></span> return</span> super</span>()</span>.</span>__new__</span>(</span>cls</span>,</span> name</span>,</span> bases</span>,</span> attrs)</span></span> </span> class</span> MyClass</span>(</span>metaclass</span>=</span>MyMeta</span>):</span></span> pass</span></span> </span> # Accessing the additional attribute added by the metaclass</span></span> print</span>(MyClass</span>.</span>additional_attr)</span> # Output: 42</span></span></code></pre> Hope you benefited from the curation of these questions and answers. For further study you can also explore official python docs</a>.</p> LeetCode 347: Top K Frequent Elements \| Python 2023-05-12T00:00:00+00:00 Let’s solve Leetcode 347</a> using Python.</p> 🔗</a>Problem Statement</h2> You are given an array nums</code> and an integer k</code>, you need to return k</code> most frequent elements.</p> Leetcode 347: Top K Frequent Elements </figcaption></figure> 🔗</a>Problem Explanation</h2> Given array consists of repeated elements and we need to return k</code> which is the number of elements that are most repeated in the array. The length of array is between 1 and 10^5, and it is guaranteed that the answer is unique and there will always be k</code> unique elements.</p> 🔗</a>Solution 1</h2> Step 1</strong>: To solve this, we would need to find how many times each element is occurring. To do this in the most efficient manner we can go through each element once and store the frequency in a dictionary.</p> record</span> =</span> dict</span>()</span></span> for</span> num</span> in</span> nums</span>:</span></span> record[num]</span> =</span> record</span>.</span>get</span>(num</span>,</span> 0</span>)</span> +</span> 1</span></span></code></pre> Step 2</strong>: Sort the record dictionary in descending order of their occurrence.</p> We are using sorted</code> function which takes an iterable, and we are passing dictionary with .items()</code> it will convert key and value into tuple format.</p> record = sorted(record.items(), key=lambda x:x[1], reverse=True)</p> Step 3: Since now record is ordered in descending order of occurrence of elements, we can return the first k</code> elements.</p> 🔗</a>Final Code</h3> class</span> Solution</span>:</span></span> def</span> topKFrequent</span>(</span>self</span>,</span> nums</span>:</span> List[</span>int</span>]</span>,</span> k</span>:</span> int</span>)</span> -></span> List[</span>int</span>]:</span></span> record</span> =</span> dict</span>()</span></span> for</span> num</span> in</span> nums</span>:</span></span> record[num]</span> =</span> record</span>.</span>get</span>(num</span>,</span> 0</span>)</span> +</span> 1</span></span> </span> record</span> =</span> sorted</span>(record</span>.</span>items</span>()</span>,</span> key</span>=</span>lambda</span> x</span>:x[</span>1</span>]</span>,</span> reverse</span>=</span>True</span>)</span></span> return</span> [elem[</span>0</span>]</span> for</span> elem</span> in</span> record[</span>:</span>k]]</span></span></code></pre>🔗</a>Algorithm Analysis</h3> Time Complexity: O(n log n)</p> Space Complexity: O(n)</p> 🔗</a>Solution 2</h2> The above solution had the time complexity of O(n log n), can we do better than that? In above solution, the time complexity comes from sorting the dictionary value, so if somehow we don’t need to sort then we might achieve O(n) of time complexity.</p> To do that we can take a hint from Bucket Sort strategy. We can create a lists of list, where index of the list represents occurrence of an element and then we can return the k</code> number of elements from that bucket list (tail first).</p> Step 1:</strong> Count the occurrence of each element and store it in the dictionary.</p> record</span> =</span> dict</span>()</span></span> for</span> num</span> in</span> nums</span>:</span></span> record[num]</span> =</span> record</span>.</span>get</span>(num</span>,</span> 0</span>)</span> +</span> 1</span></span></code></pre> Step 2:</strong> Store the occurrences in a list bucket</code>. bucket</code> is a list of list, initialized to the length of the array+1, each index represents occurrence, and since there can be more than 1 element of same occurrence therefore we have used list of list.</p> bucket</span> =</span> [[]</span> for</span> _</span> in</span> range</span>(</span>len</span>(nums)</span>+</span>1</span>)]</span></span> for</span> num</span>,</span> freq</span> in</span> record</span>.</span>items</span>()</span>:</span></span> bucket[freq]</span>.</span>append</span>(num)</span></span></code></pre> Step 3:</strong> Iterate over the bucket</code> list from the tail till we get k</code> number of elements and then return the resulting array.</p> 🔗</a>Final Code</h3> class</span> Solution</span>:</span></span> def</span> topKFrequent</span>(</span>self</span>,</span> nums</span>:</span> List[</span>int</span>]</span>,</span> k</span>:</span> int</span>)</span> -></span> List[</span>int</span>]:</span></span> record</span> =</span> dict</span>()</span></span> bucket</span> =</span> [[]</span> for</span> _</span> in</span> range</span>(</span>len</span>(nums)</span>+</span>1</span>)]</span></span> </span> for</span> num</span> in</span> nums</span>:</span></span> record[num]</span> =</span> record</span>.</span>get</span>(num</span>,</span> 0</span>)</span> +</span> 1</span></span> </span> for</span> num</span>,</span> freq</span> in</span> record</span>.</span>items</span>()</span>:</span></span> bucket[freq]</span>.</span>append</span>(num)</span></span> </span> res</span> =</span> []</span></span> for</span> i</span> in</span> range</span>(</span>len</span>(bucket)</span>-</span>1</span>,</span> 0</span>,</span> -</span>1</span>)</span>:</span></span> for</span> x</span> in</span> bucket[i]</span>:</span></span> res</span>.</span>append</span>(x)</span></span> if</span> len</span>(res)</span> ==</span> k</span>:</span></span> return</span> res</span></span></code></pre>🔗</a>Algorithm Analysis</h3> Time Complexity: O(n)</p> Space Complexity: O(n)</p>

Vivek Shukla - Python

Python Poetry Cheat Sheet

2023-10-30T00:00:00+00:00

Poetry is an amazing tool for dependancy management in Python, it solves a lot of problems of pip. Here in this Poetry Cheat Sheet we have useful commands that we may need frequently.</p>

🔗</a>Initializing</h2>

🔗</a>New Project</h3>

poetry</span> new poetry-demo</span></span></code></pre>🔗</a>In Pre-existing Directory</h3>
cd</span> pre-existing-project</span></span>
poetry</span> init</span></span></code></pre>🔗</a>Environments</h2>
🔗</a>Displaying the environment information</h3>
poetry</span> env info</span></span></code></pre>🔗</a>Using your own virtual environment</h3>
Keep virtualenv in project root</strong></p>
More on this here</a>.</p>
This will also let VS Code discover your porject’s virtual env.</p>
poetry</span> config virtualenvs.in-project</span> true</span> --local</span></span></code></pre>
External virtual environment management</strong></p>
Poetry will detect and respect an existing virtual environment that has been externally activated. This is a powerful mechanism that is intended to be an alternative to Poetry’s built-in, simplified environment management.</p>
You can use pyenv</a> to create external virtual environment.</p>
🔗</a>Switching between environments</h3>
poetry</span> env use /full/path/to/python</span></span></code></pre>poetry</span> env use</span> 3.7</span></span></code></pre>poetry</span> env use system</span></span></code></pre>🔗</a>Listing the environments associated with the project</h3>
poetry</span> env list</span></span></code></pre>🔗</a>Deleting the environments</h3>
poetry</span> env remove /full/path/to/python</span></span>
poetry</span> env remove python3.7</span></span>
poetry</span> env remove</span> 3.7</span></span>
poetry</span> env remove test-O3eWbxRl-py3.7</span></span></code></pre>
Use the --all</code></strong> option to delete all virtual environments at once.</p>
poetry</span> env remove</span> --all</span></span></code></pre>🔗</a>Dependencies</h2>
🔗</a>Add new dependency</h3>
poetry</span> add</span> <</span>package nam</span>e</span>></span></span></code></pre>🔗</a>Removing dependency</h3>
poetry</span> remove</span> <</span>package nam</span>e</span>></span></span></code></pre>🔗</a>Installing dependencies</h3>
poetry</span> install</span></span></code></pre>🔗</a>Updating dependencies to their latest versions</h3>
This will fetch the latest matching versions (according to your pyproject.toml</code></strong> file) and update the lock file with the new versions. (This is equivalent to deleting the poetry.lock</code></strong> file and running install</code></strong> again.)</p>
poetry</span> update</span></span></code></pre>🔗</a>Adding a dependency to a group</h3>
poetry</span> add pytest</span> --group</span> test</span></span></code></pre>poetry</span> add isort</span> --group</span> dev</span></span></code></pre>🔗</a>Installing group dependencies</h3>
without</code></p>
poetry</span> install</span> --without</span> test, docs</span></span></code></pre>
with</code></p>
poetry</span> install</span> --with</span> docs</span></span></code></pre>
only</code></p>
poetry</span> install</span> --only</span> main</span></span></code></pre>🔗</a>Removing dependencies from a group</h3>
poetry</span> remove mkdocs</span> --group</span> docs</span></span></code></pre>🔗</a>Synchronizing dependencies</h3>
Poetry supports what’s called dependency synchronization. Dependency synchronization ensures that the locked dependencies in the poetry.lock</code></strong> file are the only ones present in the environment, removing anything that’s not necessary.</p>
poetry</span> install</span> --sync</span></span></code></pre>poetry</span> install</span> --without</span> dev</span> --sync</span></span>
poetry</span> install</span> --with</span> docs</span> --sync</span></span>
poetry</span> install</span> --only</span> dev</span></span></code></pre>🔗</a>Export</h2>
poetry</span> export</span> -f</span> requirements.txt</span> --output</span> requirements.txt</span></span></code></pre>


--format (-f)</code></strong>: The format to export to (default: requirements.txt</code></strong>). Currently, only constraints.txt</code></strong> and requirements.txt</code></strong> are supported.</p>
</li>

--output (-o)</code></strong>: The name of the output file. If omitted, print to standard output.</p>
</li>

--extras (-E)</code></strong>: Extra sets of dependencies to include.</p>
</li>

--without</code></strong>: The dependency groups to ignore.</p>
</li>

--with</code></strong>: The optional dependency groups to include.</p>
</li>

--only</code></strong>: The only dependency groups to include.</p>
</li>

--without-hashes</code></strong>: Exclude hashes from the exported file.</p>
</li>

--without-urls</code></strong>: Exclude source repository urls from the exported file.</p>
</li>

--with-credentials</code></strong>: Include credentials for extra indices.</p>
</li>
</ul>
🔗</a>Packaging</h2>
🔗</a>Build</h3>
poetry</span> build</span></span></code></pre>🔗</a>Publish</h3>
poetry</span> publish</span></span></code></pre>🔗</a>Configuration</h2>
You can find all the configuration options here</a>.</p>



pyenv Cheat Sheet
2023-10-22T00:00:00+00:00
Here is the pyenv cheat sheet of all the basic commands list.</p>
🔗</a>What is pyenv</h2>
pyenv is Python</a> version management tool, it lets you easily switch between multiple versions of Python.</p>
🔗</a>What it does</h2>


Lets you change the global Python version on a per-user basis.</p>
</li>

Provides support for per-project Python versions.</p>
</li>

Allows you to override the Python version with an environment variable.</p>
</li>
</ul>
🔗</a>List available python versions to install</h2>
This will list all the available version of python</p>
pyenv</span> install</span> --list</span></span></code></pre>
You can filter it using grep. Here we are filtering list by python version:</p>
pyenv</span> install</span> --list</span> |</span> grep</span> " 3\.11"</span></span></code></pre>🔗</a>Installing Python Version</h2>
pyenv</span> install</span> <</span>versio</span>n</span>></span></span></code></pre>
add -v</code> flag to see install progress output</p>
🔗</a>List Installed Python Versions</h2>
pyenv</span> versions</span></span></code></pre>
Astrick (*) indicate current active version.</p>
🔗</a>See List Of All pyenv Commands</h2>
pyenv</span> commands</span></span></code></pre>🔗</a>Activating Python Version</h2>
🔗</a>global</h3>


Sets the given version as global python version.</p>
</li>

It overrides system’s default python version.</p>
</li>
</ul>
pyenv</span> global</span> <</span>versio</span>n</span>></span></span></code></pre>🔗</a>local</h3>


Use it to set directory / project specific python version.</p>
</li>

It can override python version set by global</code></p>
</li>
</ul>
pyenv</span> local</span> <</span>versio</span>n</span>></span></span></code></pre>🔗</a>shell</h3>


Sets shell specific python version.</p>
</li>

The python version stays active until shell has been closed or by using --unset</code> flag.</p>
</li>

It can override python version set by local</code> and global</code></p>
</li>
</ul>
pyenv</span> shell</span> <</span>versio</span>n</span>></span></span></code></pre>🔗</a>Virtual Environments</h2>
🔗</a>Create Virtual Environments</h3>
pyenv</span> virtualenv</span> <</span>versio</span>n</span>> <</span>env_nam</span>e</span>></span></span></code></pre>🔗</a>Set virtual environment as default for dir/project</h3>
pyenv</span> local</span> <</span>env_nam</span>e</span>></span></span></code></pre>🔗</a>Activate Virtual Environment</h3>
pyenv</span> activate</span> <</span>env_nam</span>e</span>></span></span></code></pre>🔗</a>Deactivate Virtual Environment</h3>
pyenv</span> deactivate</span></span></code></pre>🔗</a>Recommended Reading Materials</h2>


Official Page of pyenv</a></p>
</li>

Real Python: Managing Multiple Python Versions With pyenv</a></p>
</li>
</ul>


How to convert datetime to different timezone in Python using pytz
2023-06-20T00:00:00+00:00
🔗</a>Create datetime instance with timezone info</strong></h2>
import</span> datetime</span></span>
import</span> pytz</span></span>
dt</span> =</span> datetime</span>.</span>datetime</span>(</span>2021</span>,</span> 1</span>,</span> 6</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>)</span></span>
tz</span> =</span> pytz</span>.</span>timezone</span>(</span>'Asia/Kolkata'</span>)</span></span>
tzinfo_dt</span> =</span> tz</span>.</span>localize</span>(dt)</span></span>
tzinfo_dt</span></span>
</span>
# output:</span></span>
# datetime.datetime(2021, 1, 6, 0, 0, tzinfo=<DstTzInfo 'Asia/Kolkata' IST+5:30:00 STD>)</span></span></code></pre>
Note: Passing tzinfo</code> in datetime is not recommended by pytz</a>.</p>
🔗</a>Convert datetime to different timezone</strong></h2>
import</span> datetime</span></span>
import</span> pytz</span></span>
</span>
#creating timezone aware datetime instance</span></span>
dt</span> =</span> pytz</span>.</span>utc</span>.</span>localize</span>(datetime</span>.</span>datetime</span>.</span>now</span>())</span></span>
# converting to IST</span></span>
ist_dt</span> =</span> dt</span>.</span>astimezone</span>(pytz</span>.</span>timezone</span>(</span>'Asia/Kolkata'</span>))</span></span>
ist_dt</span></span>
# output:</span></span>
# datetime.datetime(2021, 1, 6, 9, 28, 57, 974939, tzinfo=<DstTzInfo 'Asia/Kolkata' IST+5:30:00 STD>)</span></span>
</span>
us_east</span> =</span> dt</span>.</span>astimezone</span>(pytz</span>.</span>timezone</span>(</span>'US/Eastern'</span>))</span></span>
# output:</span></span>
# datetime.datetime(2021, 1, 5, 23, 1, 49, 588549, tzinfo=<DstTzInfo 'US/Eastern' EST-1 day, 19:00:00 STD>)</span></span></code></pre>


Master Python Interview Questions with Answers
2023-05-22T00:00:00+00:00
Prepare for Python</a> interview questions using this extensive list of questions and answers. This list takes you from beginner to intermediate to advanced level of python concepts in question-answer format.</p>
You might want to bookmark</strong> this page as new contents will added and updated with time.</p>
🔗</a>Beginner</strong></h2>
🔗</a>What is Python?</h3>


Python is an interpreted, object-oriented, high-level programming language with dynamic semantics.</p>
</li>

Its high-level built in data structures, combined with dynamic typing and dynamic binding, make it very attractive for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together.</p>
</li>

It was created by Guido van Rossum and first released in 1991.</p>
</li>
</ul>
🔗</a>What are some of the benefits of using Python?</h3>


Python has a vast number of third-party modules and libraries that make it easy to incorporate additional functionality into your projects.</p>
</li>

Python’s simple, easy to learn syntax emphasizes readability and therefore reduces the cost of program maintenance.</p>
</li>

Python supports modules and packages, which encourages program modularity and code reuse.</p>
</li>

It has a large and active community that provides support, resources, and libraries.</p>
</li>

Python has a vast number of third-party modules and libraries that make it easy to incorporate additional functionality into your projects.</p>
</li>

Python is an interpreted language, which means that it does not need to be compiled before running, making it faster to write and test code.</p>
</li>
</ul>
🔗</a>What is the difference between str and repr in Python?</h3>
coming soon</em></p>
🔗</a>What is PEP8?</h3>


PEP8 is a coding style guide for Python.</p>
</li>

It provides guidelines on how to write Python code that is easy to read and maintain.</p>
</li>

PEP 8 covers topics such as indentation, naming conventions, comments and documentation, code layout and structure, imports, error handling, and best practices.</p>
</li>

PEP 8 is not a strict set of rules, but rather a set of guidelines that are intended to be flexible and adaptable to different projects and contexts.</p>
</li>

PEP stands for Python Enhancement Proposal, which is a design document providing information to the Python community, or describing a new feature for Python or its processes or environment.</p>
</li>
</ul>
🔗</a>What is a List?</h3>


In Python, List is a data structure which is used to hold multiple items at once.</p>
</li>

It is mutable and ordered sequence of elements.</p>
</li>

They are similar to an array in other programming languages.</p>
</li>

Python Lists are mutable and can hold items of different types simultaneously.</p>
</li>

Lists are defined using []</code></p>
</li>

Example: data = ["a", 1, "b", 2]</code></p>
</li>

Elements in a list can be accessed using indexing, for example data[0]</code> would return first element in the list.</p>
</li>
</ul>
🔗</a>What is a Tuple?</h3>


Tuple is an immutable and ordered sequence of elements.</p>
</li>

Tuples are immutable which means they cannot be modified once created.</p>
</li>

Since tuples are immutable, this also makes them hashable.</p>
</li>

Tuples are defined using ()</code></p>
</li>

Example: a_tuple = (1, 2, "a", 4)</code></p>
</li>

Just like lists, tuples can also be accessed using indexing, i.e. a_tuple[0]</code></p>
</li>
</ul>
🔗</a>What is the difference between a List and a Tuple?</h3>
List</th> Tuple</th></tr></thead>

Lists are mutable</td> Tuples are immutable</td></tr>
Lists are not hashable since they are mutable.</td> Tuples are hashable</td></tr>
Defined using []</td> Defined using ()</td></tr>
Lists take more memory due to the overhead of managing dynamic memory allocation</td> Tuples take less memory compared to lists</td></tr>
It is slower for accessing elements due to dynamic memory allocation</td> Tuples are faster in accessing elements</td></tr>
It is suitable for situations when elements are needed to be frequently added or removed</td> Tuples are suitable for situations where data needs to be fixed and does not need to be modified</td></tr>
</tbody></table>
🔗</a>What are virtual environments in Python?</h3>


Virtual environments are isolated environments which contain their own Python version and packages.</p>
</li>

They allow you to create a separate environment for each project or application you are working on, with its own set of dependencies, without affecting the global environment or other projects.</p>
</li>

This can be especially useful when working on multiple projects that require different versions of the same package or library.</p>
</li>

Python virtual environments can be created using the venv module, which is included with Python 3.3 and later versions.</p>
</li>

Example: python3 -m venv env_name</code></p>
</li>
</ul>
🔗</a>What is the difference between a function and a method in Python?</h3>
Function</th> Method</th></tr></thead>

A block of usable code that performs a task</td> A function that is associated with an object</td></tr>
Defined outside of a class</td> Defined inside a class</td></tr>
Can be called anywhere in the program</td> Can only be called on an instance of the class</td></tr>
Accepts arguments and returns a value</td> Accepts arguments but also can access and modify the attributes of the instance on which it is called upon</td></tr>
It is defined with the def keyword followed by function name and parameters</td> Defined with def keyword followed by method name and parameters</td></tr>
It doesn’t have self parameter</td> Implicit first argument is the object on which the method is called, self by convention</td></tr>
Example: len("world")</code></td> Example: "world".lower()</code></td></tr>
</tbody></table>
🔗</a>What is an exception in Python?</h3>


An exception is an error that happens during execution of a program.</p>
</li>

When an exception occurs, the normal flow of the program is disrupted and interpreter raises an exception object (of Exception class).</p>
</li>

If exception is not handled then program will terminate.</p>
</li>

Python provides built-in exceptions for common error conditions, such as IndexError</code>, ValueError</code>, TypeError</code>, etc.</p>
</li>

You can also create your own exception by inheriting from base Exception class.</p>
</li>
</ul>
🔗</a>How to handle Exceptions in Python?</h3>


Python provides a mechanism to handle exception using try-except</code> blocks.</p>
</li>

A try</code> block contains the code that may cause the exception.</p>
</li>

And except</code> block contains the code that handles the exception.</p>
</li>
</ul>
try</span>:</span></span>
    x</span> =</span> 1</span> /</span> 0</span></span>
except</span> ZeroDivisionError</span>:</span></span>
    print</span>(</span>"this is not how maths work"</span>)</span></span></code></pre>


You can also use a finally</code> block after the except block to specify code that should be executed regardless of whether an exception was raised or not. The finally</code> block is optional, but it’s useful for releasing resources or cleaning up after the code in the try block.</p>
</li>

We also can have else</code> block. The else</code> block contains the code that is executed if no exception is raised in the try block. It is optional and executes after the try</code> block but before the finally</code> block.</p>
</li>
</ul>
🔗</a>How do you handle file I/O in Python?</h3>


Python provides built-in function open()</code> to handle file I/O.</p>
</li>

The open()</code> function takes two arguments: name of the file and the mode in which to open the file (e.g. read, write, append, etc.).</p>
</li>

To read data from a file, you can use the read()</code> method, which reads the entire contents of the file, or the readline()</code> method, which reads one line at a time.</p>
</li>

To write data to a file, you can use the write()</code> method, which writes a string to the file, or the writelines()</code> method, which writes a list of strings to the file.</p>
</li>

After you are done working with the file, you should close the file using the close()</code> method.</p>
</li>
</ul>
🔗</a>What is a static method?</h3>


Static method is a method which belongs to class rather than instance of the class.</p>
</li>

It does not have access to the instance or it’s attributes.</p>
</li>

It does not require self</code> parameter that instance method usually have.</p>
</li>

Static methods are defined using the @staticmethod</code> decorator.</p>
</li>
</ul>
class</span> FooClass</span>:</span></span>
    @</span>staticmethod</span></span>
    def</span> my_static_method</span>():</span></span>
        print</span>(</span>"calling static method"</span>)</span></span>
</span>
# Calling the static method without creating an instance of the class</span></span>
FooClass</span>.</span>my_static_method</span>()</span></span></code></pre>🔗</a>What is a class method?</h3>


A class method is method that is bound to the class and not to the instance of the class.</p>
</li>

Class method knows about the class and it’s attributes, but it can’t access individual instance or their attributes.</p>
</li>
</ul>
class</span> BarClass</span>:</span></span>
    class_attribute</span> =</span> "a class attribute."</span></span>
</span>
    @</span>classmethod</span></span>
    def</span> my_class_method</span>(</span>cls</span>):</span></span>
        print</span>(</span>"Class attribute:"</span>,</span> cls</span>.</span>class_attribute)</span></span>
</span>
# Calling the class method on the class itself</span></span>
BarClass</span>.</span>my_class_method</span>()</span></span></code></pre>🔗</a>What are difference between static method and class method?</h3>
Static Method</th> Class Method</th></tr></thead>

Static method do not depend on the state of the class or instance</td> Class method operate on the class</td></tr>
It does not take any special parameter</td> Takes a special parameter called cls which refers to the class itself</td></tr>
Can be called on the class or instance of the class</td> It can be called on the class but not on instance of the class</td></tr>
Cannot access or modify the class or instance state</td> It can access and modify class state but not the instance state</td></tr>
</tbody></table>
🔗</a>What is the difference between an instance method and a class method in Python?</h3>
coming soon</em></p>
🔗</a>What is the Global Interpreter Lock (GIL) in Python?</h3>


The Global Interpreter Lock (GIL) is a mechanism used in Python to manage access to shared resources, such as the Python interpreter itself.</p>
</li>

The GIL is a mutex that prevents multiple threads from executing Python bytecodes at once.</p>
</li>

The GIL is necessary because Python interpreter is not thread-safe, meaning that it is not designed to handle multiple threads executing Python code simultaneously.</p>
</li>

The GIL is a feature of the CPython implementation of Python, which is the most widely used implementation.</p>
</li>

The GIL can prevent multi-core processors from fully utilizing all available cores.</p>
</li>

The GIL can be released using the threading</code> module’s Lock</code> object, the multiprocessing module, or by using an extension module written in C that releases GIL.</p>
</li>
</ul>
🔗</a>What is Python package?</h3>


A package is a way of organizing related modules into a single namespace.</p>
</li>

A package is a directory that contains one or more Python modules, as well as an optional __init__.py</code> file that initializes the package.</p>
</li>

Packages can be imported using import</code> statement.</p>
</li>

Packages can be installed and distributed using tools such as pip</code> and setuptools</code>.</p>
</li>
</ul>
🔗</a>What is Python module?</h3>


A module is a file containing Python code that can be imported and used in other Python code.</p>
</li>

A module can define classes, functions and variables that can be used in other Python code.</p>
</li>

A module can be imported using import</code> statement.</p>
</li>

Modules can be organized into package which is a directory that contains one or more modules.</p>
</li>
</ul>
🔗</a>What is the difference between a shallow copy and a deep copy in Python?</h3>
coming soon</em></p>
🔗</a>Intermediate</h2>
🔗</a>What is a Python namespace?</h3>
coming soon</em></p>
🔗</a>What is the difference between a class and an object in Python?</h3>
coming soon</em></p>
🔗</a>How do you implement inheritance in Python?</h3>
coming soon</em></p>
🔗</a>How do you implement a singleton pattern in Python?</h3>
coming soon</em></p>
🔗</a>What is a decorator?</h3>


A decorator is higher-order function that takes a function as input and returns a modified function as output.</p>
</li>

Decorators are used to modify or enhance the behaviour of a function without changing it’s source code.</p>
</li>

Decorators can be used with syntax @decorator_name</code> where decorator_name</code> is the name of decorator function.</p>
</li>
</ul>
def</span> my_decorator</span>(</span>func</span>):</span></span>
    def</span> wrapper</span>():</span></span>
        print</span>(</span>"Before function is called."</span>)</span></span>
        func</span>()</span></span>
        print</span>(</span>"After function is called."</span>)</span></span>
    return</span> wrapper</span></span>
</span>
@my_decorator</span></span>
def</span> say_hello</span>():</span></span>
    print</span>(</span>"Hello!"</span>)</span></span></code></pre>🔗</a>What is a lambda function in Python?</h3>


A lambda function is an anonymous function that can be defined in a single line of code.</p>
</li>

A lambda function is defined using lambda</code> keyword followed by the function parameters, a colon and then the function body.</p>
</li>

Example: lambda i, j: i * j</code></p>
</li>

Lambda functions can take any number of arguments, but they can have only one expression in the body.</p>
</li>

Lambda functions are often used as a shortcut for simple functions that are only used once.</p>
</li>
</ul>
🔗</a>What is a generator in Python?</h3>


A generator is type of iterable, like a list or a tuple, but it generates values on the fly instead of storing them in memory.</p>
</li>

Since it doesn’t store values in memory, it is very memory efficient.</p>
</li>

Generators can be iterated just like a list or a tuple but indexing is not possible.</p>
</li>

Generators can be created using generator function or generator expression.</p>
</li>

A generator function is created using one or more yield</code> statements.</p>
</li>

Whereas a generator expression is similar to list comprehension but instead of list it returns a iterator.</p>
</li>
</ul>
# generator function</span></span>
def</span> gen_number</span>(</span>limit</span>):</span></span>
    n</span> =</span> 0</span></span>
    while</span> n</span> <=</span> limit</span>:</span></span>
        yield</span> n</span></span>
        n</span> +=</span> 1</span></span>
</span>
# generator expression</span></span>
numbers</span> =</span> (i</span> for</span> i</span> in</span> range</span>(</span>5</span>))</span></span></code></pre>🔗</a>What is the difference between a list comprehension and a generator expression in Python?</h3>
coming soon</em></p>
🔗</a>What is a Python iterator?</h3>
coming soon</em></p>
🔗</a>What is the difference between iterator and generator in Python?</h3>
coming soon</em></p>
🔗</a>Advanced</h2>
🔗</a>What is a context manager in Python?</h3>


In Python, a context manager is an object that defines the methods __enter__()</code> and __exit__()</code>, which allows you to define a block of code that should be executed before and after a specific operation.</p>
</li>

A context manager is used in a with</code> statement, which guarantees that the __enter__()</code> method is called before the block of code is executed, and the __exit__()</code> method is called after the block of code is executed.</p>
</li>

__enter__()</code> method returns an object that can be used within the with</code> block, and the __exit__()</code> method is used to clean up or release any resources that were used by the with</code> block.</p>
</li>
</ul>
class</span> CustomContextManager</span>:</span></span>
    def</span> __enter__</span>(</span>self</span>):</span></span>
        print</span>(</span>"Entering the context."</span>)</span></span>
        return</span> self</span></span>
</span>
    def</span> __exit__</span>(</span>self</span>,</span> exc_type</span>,</span> exc_value</span>,</span> traceback</span>):</span></span>
        print</span>(</span>"Exiting the context."</span>)</span></span>
</span>
    def</span> do_something</span>(</span>self</span>):</span></span>
        print</span>(</span>"Doing something."</span>)</span></span>
</span>
# Use the context manager to manage a resource</span></span>
with</span> CustomContextManager</span>()</span> as</span> cm</span>:</span></span>
    cm</span>.</span>do_something</span>()</span></span></code></pre>🔗</a>How do you implement multithreading in Python?</h3>
coming soon</em></p>
🔗</a>How do you handle data serialization in Python?</h3>
coming soon</em></p>
🔗</a>What is the difference between pickle and cPickle in Python?</h3>
coming soon</em></p>
🔗</a>What is a Python coroutine?</h3>
coming soon</em></p>
🔗</a>What is the difference between a coroutine and a thread in Python?</h3>
coming soon</em></p>
🔗</a>How do you implement operator overloading in Python?</h3>
coming soon</em></p>
🔗</a>How do you implement garbage collection in Python?</h3>
coming soon</em></p>
🔗</a>How do you handle memory management in Python?</h3>
coming soon</em></p>
🔗</a>What is a metaclass in Python?</h3>


A metaclass is used to define the behavior of a class, such as how it is instantiated or how its attributes are accessed.</p>
</li>

A metaclass is defined by creating a new class that inherits from type</code>.</p>
</li>

When a new class is defined, Python looks for a metaclass definition in the class definition, and if one is found, it uses that metaclass to create a new class.</p>
</li>
</ul>
class</span> MyMeta</span>(</span>type</span>):</span></span>
    def</span> __new__</span>(</span>cls</span>,</span> name</span>,</span> bases</span>,</span> attrs</span>):</span></span>
        # Modify attributes of the class being created</span></span>
        attrs[</span>'additional_attr'</span>]</span> =</span> 42</span></span>
        return</span> super</span>()</span>.</span>__new__</span>(</span>cls</span>,</span> name</span>,</span> bases</span>,</span> attrs)</span></span>
</span>
class</span> MyClass</span>(</span>metaclass</span>=</span>MyMeta</span>):</span></span>
    pass</span></span>
</span>
# Accessing the additional attribute added by the metaclass</span></span>
print</span>(MyClass</span>.</span>additional_attr)</span>  # Output: 42</span></span></code></pre>

Hope you benefited from the curation of these questions and answers. For further study you can also explore official python docs</a>.</p>


LeetCode 347: Top K Frequent Elements | Python
2023-05-12T00:00:00+00:00
Let’s solve Leetcode 347</a> using Python.</p>
🔗</a>Problem Statement</h2>
You are given an array nums</code> and an integer k</code>, you need to return k</code> most frequent elements.</p>

  
      Leetcode 347: Top K Frequent Elements
    </figcaption></figure>
🔗</a>Problem Explanation</h2>
Given array consists of repeated elements and we need to return k</code> which is the number of elements that are most repeated in the array. The length of array is between 1 and 10^5, and it is guaranteed that the answer is unique and there will always be k</code> unique elements.</p>
🔗</a>Solution 1</h2>
Step 1</strong>: To solve this, we would need to find how many times each element is occurring. To do this in the most efficient manner we can go through each element once and store the frequency in a dictionary.</p>
record</span> =</span> dict</span>()</span></span>
for</span> num</span> in</span> nums</span>:</span></span>
    record[num]</span> =</span> record</span>.</span>get</span>(num</span>,</span> 0</span>)</span> +</span> 1</span></span></code></pre>
Step 2</strong>: Sort the record dictionary in descending order of their occurrence.</p>
We are using sorted</code> function which takes an iterable, and we are passing dictionary with .items()</code> it will convert key and value into tuple format.</p>
record = sorted(record.items(), key=lambda x:x[1], reverse=True)</p>
Step 3: Since now record is ordered in descending order of occurrence of elements, we can return the first k</code> elements.</p>
🔗</a>Final Code</h3>
class</span> Solution</span>:</span></span>
    def</span> topKFrequent</span>(</span>self</span>,</span> nums</span>:</span> List[</span>int</span>]</span>,</span> k</span>:</span> int</span>)</span> -></span> List[</span>int</span>]:</span></span>
        record</span> =</span> dict</span>()</span></span>
        for</span> num</span> in</span> nums</span>:</span></span>
            record[num]</span> =</span> record</span>.</span>get</span>(num</span>,</span> 0</span>)</span> +</span> 1</span></span>
</span>
        record</span> =</span> sorted</span>(record</span>.</span>items</span>()</span>,</span> key</span>=</span>lambda</span> x</span>:x[</span>1</span>]</span>,</span> reverse</span>=</span>True</span>)</span></span>
        return</span> [elem[</span>0</span>]</span> for</span> elem</span> in</span> record[</span>:</span>k]]</span></span></code></pre>🔗</a>Algorithm Analysis</h3>
Time Complexity: O(n log n)</p>
Space Complexity: O(n)</p>
🔗</a>Solution 2</h2>
The above solution had the time complexity of O(n log n), can we do better than that? In above solution, the time complexity comes from sorting the dictionary value, so if somehow we don’t need to sort then we might achieve O(n) of time complexity.</p>
To do that we can take a hint from Bucket Sort strategy. We can create a lists of list, where index of the list represents occurrence of an element and then we can return the k</code> number of elements from that bucket list (tail first).</p>
Step 1:</strong> Count the occurrence of each element and store it in the dictionary.</p>
record</span> =</span> dict</span>()</span></span>
for</span> num</span> in</span> nums</span>:</span></span>
    record[num]</span> =</span> record</span>.</span>get</span>(num</span>,</span> 0</span>)</span> +</span> 1</span></span></code></pre>
Step 2:</strong> Store the occurrences in a list bucket</code>. bucket</code> is a list of list, initialized to the length of the array+1, each index represents occurrence, and since there can be more than 1 element of same occurrence therefore we have used list of list.</p>
bucket</span> =</span> [[]</span> for</span> _</span> in</span> range</span>(</span>len</span>(nums)</span>+</span>1</span>)]</span></span>
for</span> num</span>,</span> freq</span> in</span> record</span>.</span>items</span>()</span>:</span></span>
    bucket[freq]</span>.</span>append</span>(num)</span></span></code></pre>
Step 3:</strong> Iterate over the bucket</code> list from the tail till we get k</code> number of elements and then return the resulting array.</p>
🔗</a>Final Code</h3>
class</span> Solution</span>:</span></span>
    def</span> topKFrequent</span>(</span>self</span>,</span> nums</span>:</span> List[</span>int</span>]</span>,</span> k</span>:</span> int</span>)</span> -></span> List[</span>int</span>]:</span></span>
        record</span> =</span> dict</span>()</span></span>
        bucket</span> =</span> [[]</span> for</span> _</span> in</span> range</span>(</span>len</span>(nums)</span>+</span>1</span>)]</span></span>
</span>
        for</span> num</span> in</span> nums</span>:</span></span>
            record[num]</span> =</span> record</span>.</span>get</span>(num</span>,</span> 0</span>)</span> +</span> 1</span></span>
</span>
        for</span> num</span>,</span> freq</span> in</span> record</span>.</span>items</span>()</span>:</span></span>
            bucket[freq]</span>.</span>append</span>(num)</span></span>
</span>
        res</span> =</span> []</span></span>
        for</span> i</span> in</span> range</span>(</span>len</span>(bucket)</span>-</span>1</span>,</span> 0</span>,</span> -</span>1</span>)</span>:</span></span>
            for</span> x</span> in</span> bucket[i]</span>:</span></span>
                res</span>.</span>append</span>(x)</span></span>
                if</span> len</span>(res)</span> ==</span> k</span>:</span></span>
                    return</span> res</span></span></code></pre>🔗</a>Algorithm Analysis</h3>
Time Complexity: O(n)</p>
Space Complexity: O(n)</p>

`🔗</a>Packaging</h2> 🔗</a>Build</h3> poetry</span> build</span></span></code></pre>🔗</a>Publish</h3> poetry</span> publish</span></span></code></pre>🔗</a>Configuration</h2> You can find all the configuration options here</a>.</p>`

🔗</a>Build</h3>
`poetry</span> build</span></span></code></pre>`
🔗</a>Publish</h3>
`poetry</span> publish</span></span></code></pre>`
🔗</a>Configuration</h2>
You can find all the configuration options here</a>.</p>

🔗</a>Publish</h3>
`poetry</span> publish</span></span></code></pre>`
🔗</a>Configuration</h2>
You can find all the configuration options here</a>.</p>

🔗</a>Configuration</h2>
You can find all the configuration options here</a>.</p>

🔗</a>What is pyenv</h2>
pyenv is Python</a> version management tool, it lets you easily switch between multiple versions of Python.</p>

🔗</a>Deactivate Virtual Environment</h3>
`pyenv</span> deactivate</span></span></code></pre>`
🔗</a>Recommended Reading Materials</h2>

Official Page of pyenv</a></p> </li>

Real Python: Managing Multiple Python Versions With pyenv</a></p> </li> </ul>

🔗</a>Recommended Reading Materials</h2>

Official Page of pyenv</a></p> </li>

Real Python: Managing Multiple Python Versions With pyenv</a></p> </li> </ul>

LeetCode 347: Top K Frequent Elements | Python

🔗</a>Algorithm Analysis</h3>
Time Complexity: O(n)</p>
Space Complexity: O(n)</p>

Vivek Shukla - Python

Python Poetry Cheat Sheet

pyenv Cheat Sheet

How to convert datetime to different timezone in Python using pytz

Master Python Interview Questions with Answers

Vivek Shukla - Python

Python Poetry Cheat Sheet

pyenv Cheat Sheet

🔗</a>What it does</h2> Lets you change the global Python version on a per-user basis.</p> </li> Provides support for per-project Python versions.</p> </li>

🔗</a>See List Of All pyenv Commands</h2> pyenv</span> commands</span></span></code></pre>🔗</a>Activating Python Version</h2> 🔗</a>global</h3> Sets the given version as global python version.</p> </li>

🔗</a>Activating Python Version</h2> 🔗</a>global</h3> Sets the given version as global python version.</p> </li>

🔗</a>global</h3> Sets the given version as global python version.</p> </li>

🔗</a>local</h3> Use it to set directory / project specific python version.</p> </li>

🔗</a>shell</h3> Sets shell specific python version.</p> </li> The python version stays active until shell has been closed or by using --unset</code> flag.</p> </li>

How to convert datetime to different timezone in Python using pytz

Master Python Interview Questions with Answers

LeetCode 347: Top K Frequent Elements | Python