Python 循环语句：for...in 和 while

• This section discusses loops in Python and how to use dictionaries (dict) and sets (set).

循环 (Loops)

• Loops are used to perform repetitive calculations.
• Python offers two types of loops: for...in and while.

for...in 循环

• This loop iterates through each element in a list or tuple.
• Example:

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

• This code prints each name in the names list.

• The loop assigns each element to the variable x, then executes the indented block.

• To calculate the sum of integers from 1-10 the following code can be used:

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)

• The range() function generates a sequence of integers. list(range(5)) creates a list [0, 1, 2, 3, 4]. range(101) generates a sequence from 0-100.

while 循环

• The while loop continues as long as a condition is met.

• The loop exits when the condition is no longer true.

• Example for sum of odd numbers less than 100:

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

• Inside the loop, n decrements until it becomes -1, at which point the while condition is no longer met, and the loop terminates.

break 语句

• The break statement exits the loop prematurely.

• Example:

n = 1
while n <= 100:
    if n > 10:
        break
    print(n)
    n = n + 1
print('END')

• This code prints numbers 1-10 and then prints 'END'.

continue 语句

• The continue statement skips the current iteration and proceeds to the next.

• Example:

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0:
        continue
    print(n)

• This code prints odd numbers less than 10.

循环小结

• Loops automate repetitive tasks.
• break exits a loop, while continue skips an iteration.
• Use if statements with break and continue.
• Avoid overuse of break and continue to keep code clear.

dict (Dictionaries)

• Dictionaries store key-value pairs (key-value).
• They offer fast lookups.
• Example:

names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]

• In this case, to look up the grade of a student, one would need to search the names list and get the index, and then use the index to look up the grade in the scores list.

• With dict, you create a table of "name"-"score" correspondences, and can look this up directly

• Dictionary example:

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d['Michael']) # Output: 95

• The key is a name, and the value is the corresponding score.
• Dictionaries are fast because they use lookups similar to a dictionary index.
• Data can be put into a dict using:

d['Adam'] = 67

• If a key is assigned multiple values, the last value overwrites previous values.

d['Jack'] = 90
d['Jack'] = 88
print(d['Jack']) # Output: 88

• If a key does not exist, an error occurs. To avoid this:

  • Check if the key exists using in: 'Thomas' in d returns False.
  • Use get(): d.get('Thomas') returns None, and d.get('Thomas', -1) returns -1.

• The pop(key) method removes a key-value pair: d.pop('Bob') removes Bob's entry.

• Key features of dict:

  • Fast lookups and insertions.
  • Large memory usage due to wasted space.

• Key features of list are the opposite of dict:

  • Lookups and insertions slow as elements increase.
  • Small memory footprint.

• Use immutable objects as dictionary keys eg strings.

set

• Similar to dict, a set is a collection of keys, without associated values.
• Keys in a set do not repeat.
• To create a set, provide a list as input:

s = set([1, 2, 3])
print(s) # Output: {1, 2, 3}

• Duplicate elements are automatically filtered out.

s = set([1, 1, 2, 2, 3, 3])
print(s) # Output: {1, 2, 3}

• add(key) adds elements to the set. Adding an element multiple times has no effect.

• remove(key) removes elements from the set.

• Sets can be used for mathematical operations like intersection and union.

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1 & s2) # Intersection: {2, 3}
print(s1 | s2) # Union: {1, 2, 3, 4}

• Sets can't hold mutable objects because they can't determine whether the two mutable objects are equal and can't ensure the 'no repeat element' condition.

不可变对象 (Immutable Objects)

• str is immutable, while list is mutable.
• For a mutable object, such as list, the internal content changes when you modify the list.

a = ['c', 'b', 'a']
a.sort()
print(a) # Output: ['a', 'b', 'c']

• For immutable objects like str, operations don't change the object.

a = 'abc'
a.replace('a', 'A')
print(a) # Output: abc

• The replace() method doesn't change the original string, but creates a new string.
• The variable a still points to the original string 'abc'.

a = 'abc'
b = a.replace('a', 'A')
print(b) # Output: Abc
print(a) # Output: abc

• When you call an attribute method you create a new object, which is why immutable objects stay immutable, even after method calls such as replace().

总结

• Dictionaries are useful for key-value storage and immutable objects such as strings are chosen as keys, tuples also work in dictionaries and sets, but must use immutable objects.