#kumar's python study notes

Augmented assignment operators in Python combine addition and assignment in one statement. Instead of writing a = a + 1, you can write a += 1. This can make your code more concise and readable.

There are many augmented assignment operators in Python, including:

+= (addition)

-= (subtraction)

*= (multiplication)

/= (division)

//= (floor division)

%= (modulus)

**= (exponentiation)

&= (bitwise AND)

|= (bitwise OR)

^= (bitwise XOR)

<<= (bitwise left shift)

>>= (bitwise right shift)

Augmented assignment operators can be used with any Python variable, including numbers, strings, lists, and dictionaries.

Here are some examples of how to use augmented assignment operators in Python:

Python

# Add 1 to the variable a a = 1 a += 1 # Subtract 2 from the variable b b = 10 b -= 2 # Multiply 3 by the variable c c = 5 c *= 3 # Divide 4 by the variable d d = 10 d /= 4 # Floor divide 5 by the variable e e = 10 e //= 5 # Take the modulus of 6 by the variable f f = 10 f %= 6 # Raise 7 to the power of 2 g = 7 g **= 2 # Perform a bitwise AND operation on the variables h and i h = 10 i = 5 h &= i # Perform a bitwise OR operation on the variables j and k j = 10 k = 5 j |= k # Perform a bitwise XOR operation on the variables l and m l = 10 m = 5 l ^= m # Perform a bitwise left shift on the variable n by 1 bit n = 10 n <<= 1 # Perform a bitwise right shift on the variable o by 1 bit o = 10 o >>= 1

x or y - Logical or (y is evaluated only if x is false)

lambda args: expression - Anonymous functions (I don't know what the fuck is this, I have to look into it)

x and y - Logical and (Y is evaluated only if x is true)

<, <=, >, >=, ==, <>, != - comparison tests

is, is not - identity tests

in, in not - membership tests

x | y - bitwise or (I still have to learn bitwise operation)

x^y - bitwise exclusive or (I read this somewhere now I don't remember it)

x&y - bitwise and (again I have to read bitwise operations)

x<;<y, x>>y - shift x left or right by y bits

x+y, x-y - addition/concatenation , subtraction

x*y, x/y, x%y - multiplication/repetition, division, remainder/format (i don't know what format is this? should ask bard)

-x, +x, ~x - unary negation, identity(what identity?), bitwise complement (complement?)

x[i], x[i:j], x.y, x(...) - indexing, slicing, qualification (i think its member access), function call

Lists in Python are a type of sequence data type. They are mutable, meaning that they can be changed after they are created. Lists can store elements of any type, including strings, integers, floats, and even other lists.

Lists are represented by square brackets ([]) and contain elements separated by commas. For example, the following code creates a list of strings:

Python

my_list = ["apple", "banana", "cherry"]

Lists can be accessed using indices, which start at 0. For example, the following code prints the first element of the list my_list:

Python

print(my_list[0])

Output:

apple

Lists can also be sliced, which allows you to extract a subset of the list. For example, the following code prints a slice of the list my_list that contains the first two elements:

Python

print(my_list[0:2])

Output:

['apple', 'banana']

Lists can be modified by adding, removing, or changing elements. For example, the following code adds an element to the end of the list my_list:

Python

my_list.append("orange")

The following code removes the first element of the list my_list:

Python

my_list.pop(0)

The following code changes the second element of the list my_list:

Python

my_list[1] = "pear"

Lists can be used to perform a variety of tasks, such as storing data, iterating over data, and performing data analysis.

Here are some examples of how to use lists in Python:

Python

# Create a list of numbers numbers = [1, 2, 3, 4, 5] # Print the list print(numbers) # Add an element to the list numbers.append(6) # Remove an element from the list numbers.pop(0) # Sort the list numbers.sort() # Reverse the list numbers.reverse() # Iterate over the list for number in numbers:   print(numbers)

Output:

[1, 2, 3, 4, 5] [2, 3, 4, 5, 6] [3, 4, 5, 6] [6, 5, 4, 3] 3 4 5 6

The split() method in Python is used to split a string into a list of strings. It takes an optional separator argument, which is the delimiter that is used to split the string. If the separator is not specified, the string is split at any whitespace characters.

The syntax of the split() method is as follows:

Python

string_name.split(separator)

where:

string_name is the string object that is calling the split() method.

separator is the string that is being used as the separator.

For example, the following code splits the string my_string at the first occurrence of the " character:

Python

my_string = "This is a string with a \"quote\" in it." parts = my_string.split("\"") print(parts)

This code will print the following output:

['This is a string with a ', 'quote', ' in it.']

Here are some additional examples of how to use the split() method:

Python

my_string = "This is a string with multiple separators: -_--_-" parts = my_string.split("--") print(parts)

This code will print the following output:

['This is a string with multiple separators: ', '_', '_-']

Python

my_string = "This is a string without a separator." parts = my_string.split("@") print(parts)

This code will print the following output:

['This is a string without a separator.']

The partition() method in Python is used to split a string into three parts at the first occurrence of a specified separator string. It returns a tuple containing three elements: the part of the string before the separator, the separator itself, and the part of the string after the separator.

If the separator is not found in the string, the tuple will contain the original string and two empty strings.

The syntax of the partition() method is as follows:

Python

string_name.partition(separator)

where:

string_name is the string object that is calling the partition() method.

separator is the string that is being used as the separator.

For example, the following code partitions the string my_string at the first occurrence of the " character:

Python

my_string = "This is a string with a \"quote\" in it." parts = my_string.partition("\"") print(parts)

This code will print the following output:

('This is a string with a ', '"', 'quote\" in it.')

Here are some additional examples of how to use the partition() method:

Python

my_string = "This is a string with multiple separators: -_--_-" parts = my_string.partition("--") print(parts)

This code will print the following output:

('This is a string with multiple separators: -_', '--', '_-')

Python

my_string = "This is a string without a separator." parts = my_string.partition("@") print(parts)

This code will print the following output:

Python uses a technique called interning to store small and unchanging values in memory. Interning means that Python only stores one copy of an object in memory, even if multiple variables reference it. This saves memory and improves performance.

Integers are one of the types of objects that are interned in Python. This means that all integer objects from -5 to 256 are stored in the same memory location. This is why the integer object is the same in memory for the following code:

Python

a = 10 b = 10 print(a is b)

Output:

True

However, interning is not applied to all objects in Python. For example, lists and other more complex data types are not interned. This means that every time you create a new list, a new memory space is allocated for it, even if the list contains the same elements as an existing list.

It is important to note that interning can be disabled in Python. To do this, you can set the sys.intern variable to False. However, this is not recommended, as it can lead to performance problems.

Here are some additional benefits of interning:

It reduces the number of objects that need to be garbage collected.

It makes it easier to compare objects for equality.

It can improve the performance of operations that involve objects, such as hashing and object lookups.

Here is an example of summation of series in Python:

Python

def summation_of_series(series):   """Calculates the summation of a series of numbers.   Args:     series: A list of numbers.   Returns:     The summation of the series.   """   sum = 0   for number in series:     sum += number   return sum # Example usage: series = [1, 2, 3, 4, 5] sum = summation_of_series(series) print(sum)

Output:

15

This function can be used to calculate the summation of any series of numbers, regardless of the length of the series.

Here is another example of summation of series in Python, using the numpy library:

Python

import numpy as np def summation_of_series_numpy(series):   """Calculates the summation of a series of numbers using the `numpy` library.   Args:     series: A numpy array of numbers.   Returns:     The summation of the series.   """   sum = np.sum(series)   return sum # Example usage: series = np.array([1, 2, 3, 4, 5]) sum = summation_of_series_numpy(series) print(sum)

Output:

15

This function is similar to the previous function, but it uses the numpy library to calculate the summation of the series. This can be more efficient for large series of numbers.

Keyword arguments in Python are arguments that are passed to a function by name. This is in contrast to positional arguments, which are passed to a function in the order that they are defined in the function definition.

Keyword arguments are useful because they allow you to specify the exact values that you want to pass to a function, without having to worry about the order of the arguments. This can be useful for functions that have a large number of arguments, or for functions where the order of the arguments is not important.

To pass a keyword argument to a function, you simply need to specify the name of the argument, followed by an equal sign (=) and the value of the argument. For example, the following code passes the name keyword argument to the print() function:

Python

print(name="Alice")

This code is equivalent to the following code:

Python

print(name="Alice", end="")

The only difference is that the keyword argument is more explicit and easier to read.

Keyword arguments can also be used to pass default values to function arguments. For example, the following function definition specifies a default value of 10 for the count keyword argument:

Python

def my_function(count=10):   """Prints the number `count` times.   Args:     count: The number of times to print the number.   """   for i in range(count):     print(i)

This function can then be called with or without the count keyword argument. If the count keyword argument is not specified, the default value of 10 will be used. For example, the following code is equivalent:

Python

my_function() my_function(count=5)