Python Flashcards

Question

What are methods in Python classes, how are they invoked, and what is the role of the instance in method calls?

Answer 1

Methods are special functions associated with classes in Python. Invoked using the syntax `instance.method()`. The instance itself is passed as the first parameter to the method (usually named self). Methods can manipulate the state of the instance and may return values. Using a method in a Turtle class instance `alex.forward(50)` Calling a method with parameters ``` tess.forward(x + y) ``` Using methods to set attributes ``` alex.pensize(3) alex.color("red") ```

Answer 2

# Creating a user-defined class User-defined classes allow the creation of new types of objects. Instances of a class are created using a syntax similar to function calls. Each instance can have attributes (or instance variables) that are assigned values using assignment statements. Methods, which are special functions associated with classes, can be invoked on instances. These methods may modify attributes or perform other actions related to the class. In the example provided, the Turtle class has instances alex and tess, each with a price attribute. The forward method is invoked to make the turtles move, and attributes are accessed and manipulated in expressions. ``` class Turtle: def __init__(self, name): self.name = name self.price = 0 def forward(self, distance): print(f"{self.name} is moving forward by {distance} units.") ``` ** Creating instances of the Turtle class** ``` alex = Turtle("Alex") tess = Turtle("Tess") ``` **Assigning values to attributes** ``` alex.price = 500 tess.price = 600 ``` **Accessing and using attributes in an expression** ``` total_price = alex.price + tess.price print(f"Total price: {total_price}") ``` **Invoking methods of the Turtle class** ``` alex.forward(50) tess.forward(30) ```

Answer 3

A for loop is a control structure that executes a set of lines repeatedly in a non-linear fashion. Instead of evaluating code line by line, a for loop runs a specified number of times. The range function is often used with for loops to determine the number of iterations. In the example provided, lines inside the loop (line 4 and 5) execute three times, controlled by the range(3) parameter. ``` for _ in range(3): print("This line will execute three times") print("This line will also execute three times") print("But this line will only print once") ``` Indentation is crucial; indented lines are part of the loop, while non-indented lines are outside the loop. **Key Points:** Indentation controls the flow of the program within and outside the loop. The number of loop iterations is determined by the parameter passed to the range function. For loops provide an efficient way to execute repetitive tasks in Python. Another example: `numbers = list(range(53))`

Answer 4

# Strings **Strings:** Sequential collections of characters with a specific order. The empty string is represented by `''` or `""`. Example: `"hello"`. **Lists:** Sequential collections of data values, where each value is identified by an index. Elements can be of any type and enclosed in square brackets `([])`. Example: `[10, 20, 30, 40]`. **Tuples: ** Similar to lists but immutable, meaning their contents cannot be changed after creation. Represented by a comma-separated sequence of values enclosed in parentheses `()`. Example: `("Julia", "Roberts", 1967, "Duplicity")`. **Key Points:** - Elements in strings and lists maintain a specific order from left to right. - Lists allow different types of elements but are generally advised to be of the same type for simplicity. - Tuples are immutable, and their representation uses parentheses instead of square brackets. - To create a tuple with a single element, include a final comma after the element. **Examples:** #Strings word = "hello" #Lists numbers = [10, 20, 30, 40] names = ["spam", "bungee", "swallow"] Tuples celebrity_info = ("Julia", "Roberts", 1967, "Duplicity")` **Question for Further Understanding:** Explain why lists are considered more versatile than strings in Python, providing an example of a situation where a list's flexibility is advantageous. **Answer:** Lists are considered more versatile than strings in Python because they can hold elements of any data type and allow for a mix of different types within the same list. This flexibility is advantageous in situations where a collection of diverse data needs to be stored or manipulated. For example, consider a scenario where you want to store information about a group of students. A list could efficiently represent this data, including their names (strings), ages (integers), and average grades (floats) in a single structure. This flexibility allows for a concise and organized representation of varied information related to each student within a single list.

Answer 5

You can use the range() function to generate a sequence of numbers from 1 to 10 and then convert it to a list. Here is an example: my_list = list(range(1, 11)) or my_list = [] for i in range(1, 11): my_list.append(i) This creates a list named **my_list** with 10 elements: integers from 1 to 10. I hope this helps you study! Let me know if you have any more questions.

Answer 6

The indexing operator in Python is used to select a single element from a sequence, such as a character from a string or an item from a list or tuple. In the example `school[2]`, the indexing selects the character at index 2 (zero-based) in the string, and the variable m refers to this character. Therefore, `print(m)` will output the letter "t" since it is the character at index 2 in "Luther College". It's important to know that Python uses a zero-based index, meaning the first element is at index 0. This convention is crucial for accurate indexing and avoids off-by-one errors. The zero-based index applies to strings, lists, and tuples in Python.

Answer 7

In Python, square brackets [] serve a dual purpose. When used to enclose elements directly, as in `new_lst = []`they indicate list creation. This results in an empty list. Conversely, when used to access elements from an existing list or string, the brackets signify indexing. For example, `part_of_new_lst = new_lst[0]` retrieves the element at index 0 of new_lst. It's crucial to specify the target list during indexing because Python needs to know which list or string to reference. In the provided code snippet, `lst = [0] ` demonstrates list creation, and `n_lst = lst[0]` illustrates indexing by extracting the value associated with the first element of lst. ``` lst = [0] n_lst = lst[0] print(lst) print(n_lst) ``` The subsequent print statements emphasize the distinction between the created list ([0]) and the indexed value (0).

Answer 8

The len function in Python is employed to retrieve the length of a sequence, whether it's a string or a list. In the given code snippet, `sz = len(fruit)` calculates the length of the string "Banana." Since indexing starts from 0, accessing the last character is done using fruit[sz-1] to prevent an IndexError. An alternative and more concise option is to utilize negative indexing, making `fruit[-1]` a suitable choice for obtaining the last character in a sequence. The len function is versatile and extends its utility to lists, providing the count of items in the list. However, it's essential to clarify that it only considers the top-most length and does not account for nested sequences within the list. ``` nested_list = ["apple", [1, 2, 3], "orange", ["banana", "grape", "kiwi"]] top_level_length = len(nested_list) ``` ``` #Accessing the length of the first element in the list (a string) string_length = len(nested_list[0]) ``` ``` #Accessing the length of the second element in the list (a nested list) nested_length = len(nested_list[1]) ``` ``` print("Top-level length:", top_level_length) print("Length of the first element (string):", string_length) print("Length of the second element (nested list):", nested_length) ``` In the provided example, "banana" is part of a nested list. To get the length of "banana," you would access it through indexing and then apply the len function. Here's how you can do it: Accessing the nested list `nested_inner_list = nested_list[3]` Accessing the length of "banana" `banana_length = len(nested_inner_list[0])` `print("Length of 'banana':", banana_length)`

Answer 9

In Python, string slices are obtained using the slice operator [n:m]. This operation returns a substring starting from the character at index n and goes up to but does not include the character at index m. To clarify, the character at index n is included in the slice, but the character at index m is not. Omitting the starting index starts the slice from the beginning of the string, and omitting the ending index goes to the end. Example: s[3:8] retrieves characters from index 3 to 7 in the string "python rocks" or "hon r", excluding 'o'. Example: s = "python rocks" print(s[3:8])

Answer 10

List slices in Python, similar to string slices, use the syntax [n:m]. They return a sublist starting from the element at index n and going up to but not including the element at index m. Omitting the starting index starts the slice from the beginning of the list, and omitting the ending index goes to the end. In the example, a_list[1:3] retrieves elements from index 1 to 2 in the list ['a', 'b', 'c', 'd', 'e', 'f']. Example: a_list = ['a', 'b', 'c', 'd', 'e', 'f'] print(a_list[1:3])

Answer 11

In Python, the + operator concatenates lists. It creates a new list containing all the elements of the operands. For instance, given fruit = ["apple", "orange", "banana", "cherry"] and [6, 7, 8, 9], using result = fruit + [6, 7, 8, 9] produces a new list result with the combined elements of both lists. Example: fruit = ["apple", "orange", "banana", "cherry"] result = fruit + [6, 7, 8, 9] print(result) ['apple', 'orange', 'banana', 'cherry', 6, 7, 8, 9]

Answer 12

In Python, the * operator repeats the items in a list a specified number of times. For instance, with alist = [1, 3, 5], repeated_list = alist * 3 results in a new list where the elements of alist are repeated three times consecutively. alist = [1, 3, 5] repeated_list = alist * 3 print(repeated_list) [1, 3, 5, 1, 3, 5, 1, 3, 5]

Answer 13

The index method in Python is used to find the leftmost occurrence of a specified element and return its index. For strings, as in music.index("m"), it returns the index of the leftmost occurrence of the specified character, or 14. For lists, like bio.index("Metatarsal"), it returns the index of the leftmost occurrence of the specified element, or 0. Both examples illustrate how the index method functions. Example: music = "Pull out your music and dancing can begin" index_result_str = music.index("m") print(index_result_str) List Index Example bio = ["Metatarsal", "Metatarsal", "Fibula", [], "Tibia", "Tibia", 43, "Femur", "Occipital", "Metatarsal"] index_result_list = bio.index("Metatarsal") print(index_result_list)

Answer 14

The split method in Python is used to break a string into a list of words, with whitespace characters as the default word boundaries. Example: ``` song = "The rain in Spain..." wds = song.split() print(wds) ['The', 'rain', 'in', 'Spain...'] ``` Split Method with Delimiter Example** ``` song = "The rain in Spain..." wds_delimiter = song.split('ai') print(wds_delimiter) ['The r', 'n in Sp', 'n...'] ``` The join method, on the other hand, combines a list of strings into a single string using a specified separator (glue). Join Method Example** ``` wds_to_join = ["red", "blue", "green"] glue = ';' result_str = glue.join(wds_to_join) print(result_str) ['The r', 'n in Sp', 'n...'] ``` Join Method with Different Glue Examples** ``` print("***".join(wds_to_join)) print("".join(wds_to_join)) red***blue***green redbluegreen ```

Answer 15

The for loop in Python is a control flow statement that allows code to be repeatedly executed. It iterates over a sequence (such as a list or string) and performs the specified block of code for each element in the sequence. Syntax: ``` for in : # Indented block of code to be executed in each iteration ``` Example: ``` friends = ["Joe", "Amy", "Brad", "Angelina", "Zuki", "Thandi", "Paris"] for name in friends: print("Hi", name, "Please come to my party on Saturday!") ``` -Name is the loop variable or iterator variable. -The loop iterates over the sequence friends (list of names). -The indented block of code (loop body) is executed for each name in the list. -After each iteration, the loop variable (name) is updated to refer to the next item in the list. -The loop continues until all items in the sequence are processed. Key Points: The for loop is used for iteration. The loop variable takes on the values of the elements in the sequence. The loop body is indented and executed for each iteration.

Answer 16

When a for loop is used with a string, it automatically iterates over each character in the string. This process is known as "iteration by item." The loop variable is assigned the value of each character in the string successively, and the loop body is executed for each iteration. For example, in the code for achar in "Go Spot Go": print(achar), the loop variable achar takes on the values 'G', 'o', ' ', 'S', 'p', 'o', 't', ' ', 'G', 'o' as the loop iterates over each character in the string "Go Spot Go." The output would be each character printed on a new line. Example: ``` for achar in "Go Spot Go": print(achar) ``` Definition: When using a for loop with a string in Python, the loop iterates over each character in the string automatically. This type of sequence iteration is referred to as "iteration by item."

Answer 17

When a for loop is used with a list, it automatically iterates over each item in the list. This process is known as "iteration by item." The loop variable is assigned the value of each item in the list successively, and the loop body is executed for each iteration. For example, in the code for afruit in fruits: print(afruit), the loop variable afruit takes on the values 'apple', 'orange', 'banana', 'cherry' as the loop iterates over each item in the list "fruits." The output would be each item (fruit) printed on a new line. ``` fruits = ["apple", "orange", "banana", "cherry"] for afruit in fruits: # by item print(afruit) ``` Explanation: The loop variable afruit is automatically reassigned to each item in the list "fruits." The for loop processes each item in the list one at a time, printing the item in this example. The output would be each item (fruit) printed on a new line. apple orange banana cherry In Python, the for loop can be used to perform list traversal using "iteration by item." A list, being a sequence of items, allows the for loop to iterate over each item in the list automatically.

Answer 18

The accumulator pattern is a programming technique where you iterate through the elements of a list, accumulating a single value (e.g., sum) during the process. The process includes initializing the accumulator variable, iterating through the list, updating the accumulator by performing an operation (e.g., addition) on each element, and finally, using the accumulated value after processing all elements. In the example provided, the accumulator accum is initialized to 0, and for each element w in the list nums, the accumulator is updated by adding the current element. The final accumulated value is then printed, representing the sum of all elements in the list. ``` nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] accum = 0 # Initialize accumulator for w in nums: accum = accum + w # Update accumulator by adding each element print(accum) # Print the accumulated value (sum) ```

Python Flashcards

Fundamentals (43 cards)