条件、循环及其他语句

1.if语句

代码块：①一种为代码的分组机制；②代码块以缩进开始，直到代码恢复之前缩进为止

1.1单分支结构if

if <条件表达式> :
<代码块>

1.2二分支结构if-else

• if <条件表达式> :
  <代码块1>
  else :
  <代码块2>

• 一种特殊的简化表达方式：
  <表达式1> if <条件> else <表达式2>

#质数判断函数
def prime_judge(n):
    if int(n) != n | n < 2:#质数是指大于1的自然数
        print("n is not a prime!")
        return
    else:
        for i in range(2, n):
            if n % i == 0:#遍历看是否有其它因数
                print("%d is not a prime, it can be divided by %d" % (n, i))
                break
        else:
            print("%d is a prime number." % (n))

prime_judge(20)

#质数判断
n=float(input("请输入数："))#x为字符
if n%1!=0 or n<2:
    print("%s不是质数"%n)
else:
    n=int(n)
    for i in range(2,n):#range区间取值左闭右开
            if n%i==0:#余数=0代表整除
               print("%s不是质数"%n)
               break
    else:
        print("%s是质数"%n)

1.3多分支结构if-elif-else

利用多分支结构编写代码时要注意多个逻辑条件的先后关系。
if <条件表达式 >:
<代码块>
elif <条件表达式> :
<代码块>
elif <条件表达式> :
<代码块>
…
else :
<代码块>

2 循环语句

2.1while循环（无限循环）

（1）while三要素：
设置初始值/设定条件判断/变量做自增长
（2）while语法：

基本使用方式：

while <条件>:
     <语句块>

拓展模式：

while <条件>:
     <语句块1>
else:
     <语句块2>

s,idx="PY",0
while idx<len(s):
    print("循环执行中："+s[idx])
    idx+=1
else:
    s="循环正常结束"
print(s)

• 循环求和

#求解100内所有偶数和
i=0
s=0
while i<100:
    i+=2
    s+=i
print(s)

• 实现如下规则输出

i=0
while i<5:#列循环次数
    j = 0
    while j<5-i:#行循环次数
            print('*',end='')#,print函数自带换行功能end='\n'，end=''使之不换行
            j+=1
    print()  # 放一行空格实现换行
    i+=1

• 九九乘法表

i=0
while i<9:#列循环次数
    i += 1
    j = 0
    while j<i:#行循环次数
         j += 1
         #print(f'{j}*{i}={i*j}',end='\t')#end='\t'制表符
         print('%s*%s=%s'%(j,i,i*j), end='\t')  # end='\t'制表符
    print()  # 放一行空格，print函数自带换行功能end='\n'

2.2.for循环（遍历循环）

python通过保留字来实现遍历循环，使用方式如下：

for <循环变量> in <遍历结构>:
    <语句块>

其中遍历结构可以是字符串、文件、range()函数或组合数据类型等。

• 对于字符串，可以逐一遍历字符串中的每个字符

for <循环变量> in <字符串变量>:
    <语句块>

• 使用range()函数指定语句块的循环次数

for <循环变量> in <循环次数>:
    <语句块>

for i in range(10):
    print(i,'',end='')
#0 1 2 3 4 5 6 7 8 9 

• 遍历循环的一种扩展模式

for <循环变量> in <遍历结构>:
    <语句块1>
else:
	<语句块2>

2.3.迭代字典

d = {'x': 1, 'y': 2, 'z': 3}
# for key in d:
#     print(key, 'corresponds to', d[key])
for key, value in d.items():
    print(key, 'corresponds to', value)
'''
x corresponds to 1
y corresponds to 2
z corresponds to 3
'''

2.4.迭代工具举例

2.4.1并行迭代

names = ['anne', 'beth', 'george', 'damon']
ages = [12, 45, 32, 102]
#使用循环
for i in range(len(names)):
     print(names[i], 'is', ages[i], 'years old')
#使用并行迭代工具
list(zip(names, ages))#[('anne', 12), ('beth', 45), ('george', 32), ('damon', 102)]
for name, age in zip(names, ages):
    print(name, 'is', age, 'years old')

#输出结果如下：

4.循环控制：break和continue

4.1break（结束整个当前循环）

break 可以用来立即退出循环语句,包括else语句,退出循环后程序继续执行循环后续代码（如果有两层或更多层循环，break退出最内层循环）

while True:
    s=input("请输入一个名字（按Q退出）：")
    if s=="Q":
        break
    print("输入的名字是：",s)
print("程序退出")

4.2continue（结束本次循环）

for s in "python":
    if s=="y":
        continue
    print(s,end="")
#pthon

• 例：

i=0
while i<6:
    i += 1
    if i==3:
      #continue
      break 
    print(i)
else:
    print('不执行')

5.程序的异常处理（try,except)

python使用保留字try和except进行异常处理，基本语法格式如下：

#语句块1是正常执行的内容，当执行这个语句块发生异常时，则执行except保留字后面的语句块2
try:
	<语句块1>
except:
	<语句块2>

例子：

try:
    for i in range(5):
        print(10/i,end='')
except ZeroDivisionError:
    print('除数为零，产生除零错误！')
except:
    print('某原因，出错了！')
#除数为零，产生除零错误！

6.print函数

print 可用于打印一个表达式，这个表达式要么是字符串，要么将自动转换为字符串

#同时打印多个表达式，条件是用逗号分隔它们
print('Age:', 42)
#Age: 42

name = 'Gumby'
salutation = 'Mr.'
greeting = 'Hello,'
print(greeting, salutation, name)
#Hello, Mr. Gumby
#字符串变量添加逗号
print(greeting + ',', salutation, name)

#自定义分隔符
print("I", "wish", "to", "register", "a", "complaint", sep="_")
#I_wish_to_register_a_complaint

#自定义结束字符串，以替换默认的换行符
print('Hello,', end='')
print('world!')
#Hello, world!

7.import

import somemodule
import math as foobar#语句末尾添加as子句并指定别名

from somemodule import somefunction
#from math import sqrt as foobar

from somemodule import somefunction, anotherfunction, yetanotherfunction

from somemodule import *

8.赋值

7.1序列解包

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

#要解包的序列包含的元素个数必须与你在等号左边列出的目标个数相同
x, y, z = 1, 2, 3

scoundrel = {'name': 'Robin', 'girlfriend': 'Marion'}
key, value = scoundrel.popitem()
print(key, value)
#girlfriend Marion

#可使用星号运算符（ * ）来收集多余的值，这样无需确保值和变量的个数相同
a, b, *rest = [1, 2, 3, 4]
print(a, b, rest)
1 2 [3, 4]
#赋值语句的右边可以是任何类型的序列，但带星号的变量最终包含的总是一个列表。在变量和值的个数相同时亦如此。
a, *b, c = "abc"
print(a, b, c)
#a ['b'] c

7.2链式赋值

链式赋值是一种快捷方式，用于将多个变量关联到同一个值。这有点像前一节介绍的并行赋值，但只涉及一个值

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

7.3增强赋值

x = 2
x += 1
print(x)
#2

fnord = 'foo'
fnord += 'bar'
fnord *= 2
print(fnord)
#'foobarfoobar'