合法的python赋值语句_Python基础 | 控制语句

选择结构

选择结构有三种

单分支,双分支,多分支

单分支选择结构

if ...

1. 语法

if 条件表达式:

语句/语句块

其中:

1) 条件表达式: 可以是逻辑表达式,关系表达式,算术表达式等等

2) 语句/语句块: 可以是一条语句,也可以是多条语句. 注意: 多条语句缩进要保持一致.

# 单分支选择结构

# 输入一个数字，小于10，则打印这个数字

num = input("请输入一个数字: ")

if float(num) < 10 :

print("输入的数字为: {}".format(num))

条件表达式详解

在Python中,非空即为真

1. 在选择和循环结构中,条件表达式的值为False的情况如下:

False,0,0.0,None,空序列对象 => (),[],{},"",空range对象,空迭代对象

2. 除了上述情况,在python中表达式结果均为True.Python中所有合法的表达式都可以看作条件表达式,甚至包括函数调用的表达式.

3. Python中式不允许在条件表达式中代友赋值运算符(C,Java中允许)

if c=20: => 这个会报错

# 测试各种条件表达式

if 3: # 整数作为条件表达式

print("ok => (int)3")

a = [] # 列表作为条件表达式

if a: # []结果为False

print("ok => []")

s = "False" # 字符串作为条件表达式

if s: # 非"",结果为True

print("ok => (str)\"False\" ")

c = 9

if 3 < c < 20: # 逻辑比较作为条件表达式

print("ok => 3

if True: # 直接布尔值作为条件表达式

print("ok => True")

双分支选择结构

if ... else ...

# 双分支选择结构 if..else...

# 输入一个数字，小于10，则打印该数字；大于10，则打印“数字太大”

num = input("请输入一个数字: ")

if float(num) < 10:

print(num)

else:

print("数字太大")

三元运算符

真值 if 条件表达式 else 假值

Python 提供了三元运算符，用来在某些简单双分支赋值情况

# 三元运算符 真值 if 条件表达式 else 假值

# 三元运算符可以用来替代简单的双分支选择结构

# 输入一个数字，小于10，则打印该数字；大于10，则打印“数字太大”

num = input("请输入一个数字: ")

print(num if float(num) < 10 else "数字太大了!")

三元表达式例子

# 赋值语句在最前面且只有一次

st[l] = 6 if st[l] == 9 else 9 # Python的三元表达式

多分支选择结构

if ... elif ... elif ... [else]...

"""

输入一个学生的成绩，将其转化成简单描述：

不及格(小于60)、及格(60-79)、良好(80-89)、优秀(90-100)。

"""

score = float(input("请输入分数: "))

if score < 60:

grade = "不及格"

elif score < 80:

grade = "及格"

elif score < 90:

grade = "良好"

elif score <= 100:

grade = "优秀"

print("您的分数为: {score},等级为: {grade}".format(score=score, grade=grade))

"""

已知点的坐标(x,y)，判断其所在的象限

"""

x = float(input("请输入x:"))

y = float(input("请输入y:"))

if x == 0 and y == 0:

print("原点")

elif x > 0 and y > 0:

print("第一象限")

elif x > 0 and y < 0:

print("第四象限")

elif x < 0 and y > 0:

print("第二象限")

elif x < 0 and y < 0:

print("第三象限")

elif x == 0:

print("y轴")

elif y == 0:

print("x轴")

选择结构的嵌套

选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了代码的从属关系。

"""

在此基础上,首先对输入分数的正确性进行一个判断

输入一个学生的成绩，将其转化成简单描述：

不及格(小于60)、及格(60-79)、良好(80-89)、优秀(90-100)。

"""

score = float(input("请输入分数: "))

if 0 <= score <= 100:

if score < 60:

grade = "不及格"

elif score < 80:

grade = "及格"

elif score < 90:

grade = "良好"

elif score <= 100:

grade = "优秀"

print("您的分数为: {score},等级为: {grade}".format(score=score, grade=grade))

else:

print("请输入一个[0,100]的分数")

循环结构

循环结果重复执行一条或多条语句

循环内部一定要有一条语句让循环条件趋向边界,否则就死循环了

while循环

1. while循环语法:

while 条件表达式:

循环体语句

2. while结构固定的小段代码

while(True):

if(边界):

break

idx +=1

"""

利用while 循环打印从0-10 的数字。

"""

num = 0

while num <= 10:

print(num)

num += 1

"""

利用while 循环，

计算1-100 之间数字的累加和；

计算1-100 之间偶数的累加和，

计算1-100 之间奇数的累加和。

"""

sum_all = 0

sum_even = 0

sum_odd = 0

num = 1

while num <= 100:

sum_all += num

if num % 2:

sum_odd += num

else:

sum_even += num

num += 1

print("sum_all: {}".format(sum_all))

print("sum_odd: {}".format(sum_odd))

print("sum_even: {}".format(sum_even))

for循环和可迭代对象遍历

Python中的for循环和C,Java不太一样,需要配合一个可迭代对象使用

1. for循环语法

for 变量 in 可迭代对象:

循环体语句

2. 可迭代对象

1) 序列 => 字符串,列表,元组,集合,字典 (只要是可以转为一个序列的)

2) 迭代器对象(iterator)

3) 生成器函数(generator)

4) 文件对象

# for循环结构(要结合一个可迭代对象使用)

# 使用for循环遍历一个列表或元组

for x in (30, 40, 50): # for => 依次取出序列中的元素

print(x * 2, end="\t")

print()

# for 中的 x 依据局部变量

for x in "abcdef": # 遍历字符串

print(x, end="\t")

print()

a = set([1, 2, 3]) # 遍历集合

for x in a:

print(x, end="\t")

print()

# 遍历字典

a = dict(name="张三", age=23, job="coder")

for x in a: # 默认是使用的 a.keys()

print(x, end="\t")

print()

for x in a.keys(): # 指定使用的 a.keys()

print(x, end="\t")

print()

for x in a.values(): # 指定使用的 a.values()

print(x, end="\t")

print()

for x in a.items(): # 指定使用的 a.items()

print(x, end="\t")

print()

range对象

range([start,]end[,step])

1. range 对象是一个迭代器对象，用来产生指定范围的数字序列。格式为：

range([start,] end [,step])

生成的数值序列从start 开始到end 结束(不包含end)

若没有填写start，则默认从0开始

step 是可选的步长，默认为1

2. 典型的range示例

1) for i in range(10) => 0,1,2,3,4,5,6,7,8,9

2) for i in range(3,10) => 3,4,5,6,7,8,9

3) for i in range(3,10,2) => 3,5,7,9

"""

利用for + range

计算1-100 之间数字的累加和；

计算1-100 之间偶数的累加和，

计算1-100 之间奇数的累加和。

"""

sum_all = 0

sum_even = 0

sum_odd = 0

for num in range(1, 100 + 1):

sum_all += num

if num % 2:

sum_odd += num

else:

sum_even += num

print("sum_all: {}".format(sum_all))

print("sum_odd: {}".format(sum_odd))

print("sum_even: {}".format(sum_even))

嵌套循环和综合练习

一个循环体内可以嵌入另一个循环体,一般称为"嵌套循环"或"多重循环"

"""

打印如下图案

0 0 0 0 0

1 1 1 1 1

2 2 2 2 2

3 3 3 3 3

4 4 4 4 4

"""

# 分析:

# 行有5行,每一行重复输出5次

for x in range(5):

for i in range(5):

print(x, end="\t")

print()

"""

利用嵌套循环打印九九乘法表

"""

for R in range(1, 10):

for C in range(1, R+1):

print("{:2d} ×{:2d} ={:2d}".format(R, C, R * C), 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语句

在循环中跳出最近的一层循环

continue语句

用于结束本次循环,继续下一次

else语句

while ... [else ...] for ... [else ...]

这个语法的Python特有的

1. while、for 循环可以附带一个else 语句(可选)。

2. 如果for、while 语句没有被break 语句结束，则会执行else 子句，否则不执行。

语法格式如下：

while 条件表达式：

循环体

else:

语句块

for 变量in 可迭代对象：

循环体

else:

语句块

# for ... else ...

"""

指定循环的次数 3次

猜数游戏 => 猜数游戏 for ... else ... 是一个很好的应用

"""

import random

num = random.randint(1, 100)

print("您有5次猜数的机会")

# print(num)

for i in range(1, 5 + 1):

guess = int(input("请输入猜的整数:"))

print("第{}次: ".format(i), end=" ")

if guess == num:

print("恭喜你! 猜对了!")

break;

elif guess > num:

print("猜大了")

elif guess < num:

print("猜小了")

else:

print("猜数失败,超过5次了\t 正确答案为: {}".format(num))

循环代码优化(及其重要)

循环不要嵌套太深,能往外面放就尽量往外面放

虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。

编写循环时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：

1. 尽量减少循环内部不必要的计算

2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。

3. 局部变量查询较快，尽量使用局部变量

其他优化手段

1. 连接多个字符串,使用 join() 而不使用+

2. 列表进行元素插入和删除,尽量在列表尾部操作

使用zip()并行迭代

# 使用zip主要是可以并行迭代

# 这个列表的长度是 4 4 3

names = ("高淇", "高老二", "高老三", "高老四")

ages = (18, 16, 20, 25)

jobs = ("老师", "程序员", "公务员")

# 如果是 4 4 3 使用zip压缩的话,那么只会 3 3 3

# 取最短

print(list(zip(names,ages,jobs)))

# 现在遍历[(,),(,)] 每次遍历一个元组

for name, age, job in zip(names, ages, jobs):

print("{0} == {1} == {2}".format(name,age,job))

推导式创建序列

推导式和生成器 => 只是替代循环的一种方式

推导式是典型的Python风格,能够熟练使用推导式说明你已经有了Python初学者的水平

推导式就是把三四行的代码浓缩为一行,所以一定要好好学! 熟练使用

列表推导式

[表达式 for item in 可迭代对象 [if 条件判断]]

L1 = [x for x in range(1, 5)] # [1,2,3,4]

L2 = [x * 2 for x in range(1, 5)] # [2,4,6,8]

L3 = [x * 2 for x in range(1, 20) if x % 5 == 0] # [10,20,30]

# 生成字符串的列表

L4 = [x for x in "abcdfeg"] # ['a','b','c','d','f','e','g']

# 列表生成式 => 两重循环

L5 = [(x, y) for x in range(1, 3) for y in range(1, 3)] # [(1,1),(1,2),(2,1),(2,2)]

print(L1)

print(L2)

print(L3)

print(L4)

print(L5)

字典推导式

{key_expression : value_expression for item in 可迭代对象}

字典推导式与列表推导式基本一致,只是 [] => {}

集合推导式

集合是单列的字典

{key_expression for item in 可迭代对象 }

# 集合就是单列的字典

# 集合推导式和字典推导式类似

S = {k for k in "aaaabbbbc"} # 使用集合去重

print(S)

生成器推导式(生成元组)

元组是没有推导式的

可以tuple(生成器对象)

生成器是一个可迭代对象,可迭代对象也是可以被for的

1. 很多同学可能会问：“都有推导式，元组有没有？”，能不能用小括号呢？

>>> (x for x in range(1,100) if x%9==0)

at 0x0000000002BD3048>

我们发现提示的是“一个生成器对象”。显然，元组是没有推导式的。

2. 一个生成器只能运行一次。第一次迭代可以得到数据，第二次迭代发现数据已经没有了。

综合练习

1. 绘制多个同心圆

import turtle

pen = turtle.Pen()

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

pen.width(4) # 设置笔的宽度

pen.speed(0) # 设置画笔的速度

for i in range(20):

pen.penup(); # 抬笔

pen.goto(0, -i * 10)

pen.pendown()

pen.color(colors[i % len(colors)])

pen.circle(15 + 10 * i) # 每次的半径增加15

turtle.done() # 程序执行完,窗口还在

2. 画一个18*18的棋盘

画图没有想象的那么容易,还是要动点脑子的

# 画棋盘

import turtle

width = 30

num = 18

# 固定了第一条x,y (两个点)

# 后面的线都以这两条线为基准

x1 = [(-400, 400), (-400 + width * num, 400)]

y1 = [(-400, 400), (-400, 400 - width * num)]

t = turtle.Pen()

t.speed(10)

# t.goto(x1[0][0],x1[0][1])

# t.goto(x1[1][0],x1[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() # 保证运行窗口不被自动关闭