【Python基础知识-pycharm版】控制语句_棋盘_同心圆

admin管理员组

文章数量:1546482

Python011

• 控制语句
• • 选择结构
  • • 单分支选择结构
    • • 条件表达式详解
    • 双分支选择结构
    • 三元条件运算符
    • 多分支选择结构
    • 选择结构嵌套
  • 循环结构
  • • while循环
    • for循环和可迭代对象遍历
    • 可迭代对象
    • range对象
    • 嵌套循环
    • break语句
    • continue语句
    • else语句
    • 循环代码优化
    • 其他优化手段
  • 使用zip()并行迭代
  • 推导式创建序列
  • • 列表推导式
    • 字典推导式
    • 集合推导式
    • 生成器推导式（生成元组）
  • 【操作】绘制多个同心圆
  • 【操作】绘制18*18 棋盘

控制语句

流程控制语句是代码的组织方式

选择结构

选择结构通过判断条件是否成立，来决定执行哪个分支。选择结构有多种形式，分为：单分 支、双分支、多分支。流程图如下：

单分支选择结构

if语句单分支结构的语法形式如下：
if 条件表达式:
语句/语句块
其中：
1 ．条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等。
2 ．语句/语句块：可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一致。

num = input("输入一个数字：") 
if int(num)<10: 
	print(num)

条件表达式详解

在选择和循环结构中，条件表达式的值为 False的情况如下： False、0、0.0、空值 None、空序列对象（空列表、空元祖、空集合、空字典、空字 符串）、空range 对象、空迭代对象。
其他情况，均为True。这么看来，Python所有的合法表达式都可以看做条件表达式，甚至 包括函数调用的表达式。

if 3: #整数作为条件表达式 
	print("ok") 
a = [] #列表作为条件表达式，由于为空列表，是 False 
if a: 
	print("空列表，False") 
s = "False" #非空字符串，是True 
if s:
	print("非空字符串，是True")
c = 9 
if 3<c<20: 
	print("3<c<20") 
if 3<c and c<20: 
	print("3<c and c<20")
if True: #布尔值 
	print("True")
##执行结果
ok 
非空字符串，是True 
3<c<20 
3<c and c<20 
True

条件表达式中，不能有赋值操作符“=”
在Python中，条件表达式不能出现赋值操作符“=”，避免了其他语言中经常误将关系运 算符“==”写作赋值运算符“=”带来的困扰。如下代码将会报语法错误：

if 3<c and (c=20): 
	print("赋值符不能出现在条件表达式中")

双分支选择结构

双分支结构的语法格式如下：
if 条件表达式 : 语句 1/语句块 1
else: 语句 2/语句块 2

三元条件运算符

Python提供了三元运算符，用来在某些简单双分支赋值情况。三元条件运算符语法格式如 下：
条件为真时的值 if (条件表达式) else 条件为假时的值

num = input("请输入一个数字") 
print( num if int(num)<10 else "数字太大")

这种写法更加简洁，易读。

多分支选择结构

多分支选择结构的语法格式如下：
if 条件表达式 1 : 语句 1/语句块 1
elif 条件表达式 2: 语句 2/语句块 2
. . .
elif 条件表达式 n : 语句 n/语句块n
[else: 语句 n+1/语句块 n+1 ]
【注】计算机行业，描述语法格式时，使用中括号[]通常表示可选，非必选。
**多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。 **
每个分支都使用了独立的、完整的判断，顺序可以随意挪动，而不影响程序运行。

选择结构嵌套

选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了 代码的从属关系。语法格式如下：
if 表达式 1：语句块1 if 表达式 2： 语句块2 else: 语句块3
else: if 表达式 4： 语句块4

score = int(input("请输入一个在 0-100 之间的数字：")) 
grade = "" 
if score>100 or score<0: 
	score = int(input("输入错误！请重新输入一个在 0-100 之间的数字：")) else: 
	if score>=90: 
		grade = "A" 
	elif score>=80: 
		grade = 'B' 
	elif score>=70: 
		grade = 'C' 
	elif score>=60: 
		grade = 'D' 
	else: 
		grade = 'E' 
	print("分数为{0},等级为{1}".format(score,grade))

#或者也可以用下面代码更少的方法。不过，需要大家思考为什么这么写了 
score = int(input("请输入一个在 0-100 之间的数字：")) 
degree = "ABCDE" 
num = 0 
if score>100 or score<0: 
	score = int(input("输入错误！请重新输入一个在 0-100 之间的数字：")) else: 
	num = score//10 
	if num<6:
		num=5
	print("分数是{0},等级是{1}".format(score,degree[9-num]))

循环结构

循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反 复执行循环体里的语句。在每次执行完后都会判断一次条件是否为 True，如果 为True则重复执行循环体里的语句。图示如下：

循环体里面的语句至少应该包含改变条件表达式的语句，以使循环趋于结束；否 则，就会变成一个死循环。

while循环

while 循环的语法格式如下：
while 条件表达式： 循环体语句

for循环和可迭代对象遍历

for 循环通常用于可迭代对象的遍历。for 循环的语法格式如下：
for 变量 in 可迭代对象： 循环体语句

可迭代对象

Python包含以下几种可迭代对象：

1. 序列。包含：字符串、列表、元组
2. 字典
3. 迭代器对象（iterator）
4. 生成器函数（generator）
5. 文件对象

for x in "sxt001": 
	print(x)

d = {'name':'wps','age':18,'address':'西三旗 001 号楼'} 
for x in d: #遍历字典所有的key 
	print(x)
for x in d.keys():#遍历字典所有的key 
	print(x)
for x in d.values():#遍历字典所有的value 
	print(x)
for x in d.items():#遍历字典所有的"键值对" 
	print(x)

range对象

range 对象是一个迭代器对象，用来产生指定范围的数字序列。格式为：
range(start, end [,step])
生成的数值序列从start 开始到 end结束（不包含 end）。若没有填写start，则默认从 0 开始。step是可选的步长，默认为 1。如下是几种典型示例：
for i in range(10) 产生序列：0 1 2 3 4 5 6 7 8 9
for i in range(3,10) 产生序列：3 4 5 6 7 8 9
for i in range(3,10,2) 产生序列：3 5 7 9

嵌套循环

一个循环体内可以嵌入另一个循环，一般称为“嵌套循环”，或者“多重循环”。

#利用嵌套循环打印九九乘法表 
for m in range(1,10): 
	for n in range(1,m+1): 
		print("{0}*{1}={2}".format(m,n,(m*n)),end="\t") 
	print()

#用列表和字典存储下表信息，并打印出表中工资高于15000的数据
r1= dict(name="王小一",age=18,salary=30000,city="北京") 
r2= dict(name="王小二",age=19,salary=20000,city="上海") 
r3= dict(name="王小三",age=20,salary=10000,city="深圳") 
tb = [r1,r2,r3]
for x in tb: 
	if x.get("salary")>15000: 
		print(x)

break语句

break语句可用于 while 和for 循环，用来结束整个循环。当有嵌套循环时，break 语句只 能跳出最近一层的循环。

continue语句

continue 语句用于结束本次循环，继续下一次。多个循环嵌套时，continue 也是应用于最 近的一层循环。

else语句

while、for 循环可以附带一个 else 语句（可选）。如果for、while 语句没有被break 语句 结束，则会执行else 子句，否则不执行。语法格式如下：
while 条件表达式： 循环体
else: 语句块
或者：
for 变量 in 可迭代对象： 循环体
else: 语句块

循环代码优化

虽然计算机越来越快，空间也越来越大，仍然要在性能问题上“斤斤计较”。编写循环时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：

1. 尽量减少循环内部不必要的计算
2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。
3. 局部变量查询较快，尽量使用局部变量

# 循 环 代 码 优 化 测 试 import time
start = time.time() 
for i in range(1000): 
	result = [] 
	for m in range(10000): 
		result.append(i*1000+m*100)
end = time.time() 
print("耗时：{0}".format((end-start)))

start2 = time.time() 
for i in range(1000): 
	result = [] 
	c = i*1000 
	for m in range(10000): 
		result.append(c+m*100)
end2 = time.time() 
print("耗时：{0}".format((end2-start2)))

其他优化手段

1. 连接多个字符串，使用 join()而不使用+
2. 列表进行元素插入和删除，尽量在列表尾部操作

使用zip()并行迭代

通过 zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停止。

names = ("王小一","王小二","王小三","王小四") 
ages = (18,16,20,25) 
jobs = ("老师","程序员","公务员")
for name,age,job in zip(names,ages,jobs): 
	print("{0}--{1}--{2}".format(name,age,job))
#结果
王小一--18--老师 
王小二--16--程序员 
王小三--20--公务员

推导式创建序列

推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合， 从而避免冗长的代码。推导式是典型的Python 风格，会使用它代表你已经超过Python初 学者的水平。

列表推导式

列表推导式生成列表对象，语法如下：
[表达式 for item in 可迭代对象 ]
或者：{表达式 for item in 可迭代对象 if 条件判断}

字典推导式

字典的推导式生成字典对象，格式如下：
{key_expression : value_expression for 表达式 in 可迭代对象}
类似于列表推导式，字典推导也可以增加 if条件判断、多个 for 循环。
统计文本中字符出现的次数：

>>> my_text = 'i love you,i love wps'
>>> char_count = {c:my_text.count(c) for c in my_text}
>>> char_count
{'i': 2, ' ': 4, 'l': 2, 'o': 3, 'v': 2, 'e': 2, 'y': 1, 'u': 1, ',': 1, 'w': 1, 'p': 1, 's': 1}

集合推导式

集合推导式生成集合，和列表推导式的语法格式类似：
{表达式 for item in 可迭代对象 }
或者：{表达式 for item in 可迭代对象 if 条件判断}

>>> {x for x in range(1,100) if x%9==0}
{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}

生成器推导式（生成元组）

>>> (x for x in range(1,100) if x%9==0)
<generator object <genexpr> at 0x04083750>

提示的是“一个生成器对象”。显然，元组是没有推导式的。
一个生成器只能运行一次。第一次迭代可以得到数据，第二次迭代发现数据已经没有了。

>>> gnt = (x for x in range(1,100) if x%9==0) 
>>> for x in gnt: print(x,end=' ') 
9 18 27 36 45 54 63 72 81 90 99 
>>> for x in gnt: print(x,end=' ')
>>>

【操作】绘制多个同心圆

import turtle

t = turtle.Pen()

my_colors = ("red","green","yellow","black")

t.width(4)
t.speed(1)
for i in range(10):
    t.penup()
    t.goto(0,-i*10)
    t.pendown()
    t.color(my_colors[i%len(my_colors)])
    t.circle(15+i*10)

turtle.done() #程序执行完，窗口仍在

【操作】绘制18*18 棋盘

# 画 棋 盘 import turtle
width = 30 num = 18
x1 = [(-400,400),(-400+width*num,400)] 
y1 = [(-400,400),(-400,400-width*num)] 
t = turtle.Pen() 
t.speed(10) 
# t . g o t o ( x 1 [ 0 ] [ 0 ] , x 1 [ 0 ] [ 1 ] ) 
# t . g o t o ( x 1 [ 1 ] [ 0 ] , x 1 [ 1 ] [ 1 ] )
for i in range(0,19): 
	t.penup() 
	t.goto(x1[0][0],x1[0][1]-30*i) 
	t.pendown() 
	t.goto(x1[1][0],x1[1][1]-30*i)
for i in range(0,19): 
	t.penup() 
	t.goto(y1[0][0]+30*i,y1[0][1]) 
	t.pendown() 
	t.goto(y1[1][0]+30*i,y1[1][1])
t.hideturtle() # 隐 藏 画 笔
turtle.done() # 保 证 运 行 窗 口 不 被 自 动 关 闭

本文标签： 同心圆棋盘语句基础知识Python