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
 11 结果：
 12 <enumerate object at 0x000001C7EC6F3E58>
 13 george 's index is 2 
 14
 15 ['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

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