Python基础 第5章 条件、循环及其他语句（1）

1. print和import

1.1 打印多个参数

可用 + 连接多个字符串，可保证被连接字符串前无空格；

可用sep=“_”，自定义各种分隔符；

 print("I","wish","to","register","a","complaint",sep="_")
 结果：
 I_wish_to_register_a_complaint

可自定义结束字符串，以替换默认的换行符；

 print('Hello,',end='')
 print('World!')
 结果：
 Hello,World!

1.2 导入时重命名

导入某个模块时，通常使用如下方式：

 方法1：import somemodule
 方法2：from somemodule import somefunction
 方法3：from somemodule import somefuction,anotherfunction,yetanotherfunction
 方法4：from somemodule import *

如果导入的两个模块，都包含同一个函数，可用按如下方法调用函数：

 module1.open(...)
 module2.open(...)
也可以在语句末尾加as子句并指定别名
3 import math as foobar
4 foobar.sqrt(4)

2. 赋值

2.1 序列解包（可迭代对象解包）

将一个序列（或任何可迭代对象）解包，并将得到的值存储在一系列变量中。解释如下：

 values = 1,2,3
 print(values)
 x,y,z = values
 print(x)
 结果：
 (1, 2, 3)
 1

（1）同时（并行）给多个变量赋值

 x,y,z = 1,2,3
 print(x,y,z)
结果：
1 2 3

（2）交换多个变量的值

 x,y,z = 1,2,3
 x,y = y,x
 print(x,y,z)
 结果：
 2 1 3

*** 序列解包，在使用返回元组（或其他序列或可迭代对象）的函数或方法时很有用。

eg：随机从字典中获取或删除一个键-值对，用方法popitem，它随机获取一个键-值对并以元组的方式返回。然后将返回的元组解包到两个变量中。

 scoundre = {'name':'Robin','girlfriend':'Marion'}
 key, value = scoundre.popitem()
 print(key)
 print(value)
 结果：
 girlfriend
 Marion

（3）用星号运算符（*）收集多余的值，这样无需确保值和变量的个数相同

 a,b,*rest = [1,2,3,4,5]
 print(rest)
 结果：
 [3, 4, 5]
 
   # 带星号的变量可以放在其他位置
 name = "Albus Precival Wulfric Brain Dumbledore"
 first, *middle, last = name.split()
 print(middle)
 结果：
 ['Precival', 'Wulfric', 'Brain']

赋值语句的右边可以是任何类型的序列，但带星号(*)的变量最终包含的总是一个列表。

 a, *b, c = "abc"
 print(a,b,c)
 结果：
 a ['b'] c

（4）链式赋值

用于将多个变量关联到同一个值，链式赋值是一种快捷方式。

 x = y = somefunction()

 # 上述代码与下面等价
 y = somefunction
 x = y

（5）增强赋值

如代码 x = x + 1，可直接将右边表达式中的运算符（+）移到赋值运算符（=）前面，写成 x += 1。该方式称为增强赋值，适用于所有标准运算符。增强赋值，可让代码更紧凑、更简洁，增加可读性。

3. 代码块 - 缩进

代码块是通过缩进代码（即前面加空格）来创建的。

也可使用制表符，但标准做法是只使用空格来缩进，且每级缩进4个空格。

4. 条件和条件语句

（1） False，None，0，""，()，[]，{}，这些值均将被解释器视为假。

（2）if语句

（3）else子句

（4）elif子句

（5）代码块嵌套

5. 循环

（1）while循环

 name = ''
 while not name:
     name = input('plz enter your name:')
 print('Hllo, {}!'.format(name))
 结果：
 plz enter your name:elon
 Hllo, elon!

并未像书中所说：回车后再次出现提示信息。

书中修复该现象方法：将while not name 改为 while not name or name.isspace()或while not name.strip()。

（2）for 循环

该函数，可为序列（或其他可迭代对象）中每个元素执行代码块。基本上，可迭代对象是可使用for循环进行遍历的对象。

 words = ['this','is','an','ex','parrot']
 for word in words:
     # 用end=' '替代print默认输出的换行符合
     print(word, end=' ')
 结果：
 this is an ex parrot 

只要能使用for循环，就不用使用while循环！！！

创建范围函数range(0,10)，起始位置为0，不包含结束位置（10）

 print(list(range(0,10)))
 结果：
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

（3）迭代字典

　　1）遍历字典的所有关键字

 d = {'x':1,'y':2,'z':3}
 for key in d:
     print(key,end=', ')
     print(key, 'corresponds to', d[key])
 结果：
 x, x corresponds to 1
 y, y corresponds to 2
 z, z corresponds to 3

　　2）遍历字典的所有值，d.values()

 for value in d.values():
     print(value)
 结果：
 1
 2
 3

　　3）遍历字典，返回键-值对，d.items()

 for key,value in d.items():
     print(key, 'corresponds to', value)
 结果：
 x corresponds to 1
 y corresponds to 2
 z corresponds to 3

***字典元素的排列顺序不确定，如果所处理的键或值顺序非常重要，可将键或值存储在一个列表中，并对列表排序，再迭代。

（4）迭代工具

　　1）并行迭代 - zip内置函数，缝合序列

　　如，需同时迭代两个序列，方法（1）如下：

 names = ['anne','beth','george','damon']
 ages = [12,45,32,99]

 for i in range(len(names)):
     print(names[i], 'is', ages[i], 'years old')
 结果：
 anne is 12 years old
 beth is 45 years old
 george is 32 years old
 damon is 99 years old

　　方法（2）：用zip函数解包

 names = ['anne','beth','george','damon']
 ages = [12,45,32,99]

 #用zip缝合两个序列
 ziptool = list(zip(names,ages))
 print(ziptool)
 #缝合后，在循环中将元组解包
 for name,age in zip(names,ages):
     print(name, 'is', age, 'years old')
 结果：
 [('anne', 12), ('beth', 45), ('george', 32), ('damon', 99)]

 anne is 12 years old
 beth is 45 years old
 george is 32 years old
 damon is 99 years old

　　***函数zip可用于“缝合”任意数量的序列

　　***使用zip函数缝合时，当序列长度不同时，函数zip将在最短的序列用完后停止“缝合”

 listzip = list(zip(range(5), range(1000)))
 print(listzip)
 结果：
 [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

　　2）迭代时获取索引

　　使用内置函数enumerate，该函数能迭代索引-值对，其中的索引是自动提供的。

 names = ['anne','beth','george','damon']
 print(enumerate(names))

 for index,string in enumerate(names):
     if 'geo' in string:
         names[index] = '[censored]' # 将包含'geo'的元素替换为'[censored]'  
 7 print(string,'\'s index is', index)  
 8 
 print(names)
 10
  结果：
  <enumerate object at 0x000001C7EC6F3E58>
  george 's index is 2 
 14
  ['anne', 'beth', '[censored]', 'damon']

　　3）反向迭代和排序后再迭代

 lists = [4, 3, 5, 8, 6, 7]
 print(sorted(lists))
 print(list(reversed(lists)))
 结果：
 [3, 4, 5, 6, 7, 8]
 [7, 6, 8, 5, 3, 4]

 words = 'Hello, world!'
 print(sorted(words))
 结果：
 [' ', '!', ',', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

 print(list(reversed(words)))
 reversed_words = ''.join(reversed(words))
 print(reversed_words)
 结果：
 ['!', 'd', 'l', 'r', 'o', 'w', ' ', ',', 'o', 'l', 'l', 'e', 'H']
 !dlrow ,olleH

 # reversed和sorted，不会就地修改对象，而是返回反转和排序后的版本
 print(words)
 结果：Hello, world!

*** 要按字母表排序，可先转换为小写。可将sort或sorted的key参数设置为str.lower

 print(sorted("aBC", key=str.lower))
 结果：
 ['a', 'B', 'C']

（5）跳出循环

　　1）break - 结束（跳出）循环

 from math import sqrt

 for n in range(99, 0, -1):
     root = sqrt(n)
     if root == int(root):
         print(n)
         break

 结果：81

　　2）continue

　　结束当前迭代，并跳到下一次迭代开头（跳过循环体中余下语句，但不结束循环）。

　　continue不如break用得多。

　　3）while True/break

　　while True导致循环永不结束，但将条件放在了循环体内的一条if语句中，而这条if语句将在条件满足时调用break。（避免在代码中过多使用break）

 while True:
     word = input('please enter a word: ')
     if not word:
         break
     print('The word is ', word)
 结果：
 please enter a word: elon
 The word is  elon
 please enter a word: 

（6）循环中的else子句

　　通常，循环中使用break是因为“发现”了什么或“出现”了什么情况。若要判断循环是提前结束还是正常结束：

　　1）可在循环开始前定义一个布尔变量并将其设置为False，再在跳出循环时设置为True。便可在循环后用一条if语句来判断循环是否提前结束。

 from math import sqrt
 break_out = False
 for x in range(99,81,-1):
     root = sqrt(x)
     if root == int(root):
         break_out = True
         print(x)
         break
 if not break_out:
     print("I don't break out!")
 结果：
 I don't break out!

　　模板：

 # 模板
 break_out = False
 for x in seq:
     do_something()
     if condtion(x):
         break_out = True
         break
     do_something_else()
 if not break_out:
     print("I don't break out!")

　　2）***简单的方法，在循环中添加一条else子句，它仅在没有调用Break时才执行。

 from math import sqrt
 for n in range(99,81,-1):
     root = sqrt(n)
     if root == int(root):
         print(n)
         break
 else:
     print("Don't find it!")

 结果：Don't find it!

20190830

　　治军之道，以勤字为先。身勤则强，佚则病；家勤则兴，懒则衰；国勤则治，怠则乱；军勤则胜，惰则败。惰者，暮气也，常常提其朝气为要。——曾文正公，巳未二月