1. 语句

Python语言常用语句：赋值语句、if语句、for语句

语句通常是一行一条语句。如一行有多条语句，则用分号（；）分开，如语句太长要跨行时，可以用续行符（\）跨行表示一个语句。

print(1);print(1\     #如果不用; 和 \ 进行分割，就会报错
               )

Python 用于定义**代码块(语句块)**的符号是 空格

1.1 输入函数和输出函数

1.1.1 输入函数input()

input函数是 Python 内置的函数，可以实现从标准输入（键盘）中读入一个字符串。

  • 直接读入数据存入变量，只会是⭐字符串类型⭐。
>>> a = input()
100
>>> a
'100'
  • 如果不想要字符串类型，可以用内置的强制转换函数
    int() float() 等等
>>> a = int(input())
100
>>> a
100
  • 提示信息
>>> a = input("请输入")
请输入s
>>> a
's'

如上，在input函数中加入一个字符串参数，其就会作为提示信息出现在输入的时候。

split()

详见 “Python内置函数”

  • 一行输入多个值
    split函数：对字符串进行分割，默认的分割符号为空白符
>>> a = '1-2'
>>> a = a.split('-') #不用默认进行分割
>>> a
['1', '2'] #分割后的结果为列表

因此当我们输入时想要输入多个值，可以如下所示：

>>> a = input().split()
a a s
>>> a
['a', 'a', 's']

如果输入的多值想直接转换为需要的类型：

>>> a,b = map(int,input().split())
1 2
>>> print(a,b)
1 2

1.1.2 stdin 系统标准输入

import sys
lines=[]
for aLine in sys.stdin:
    lines.append(aLine)
print(lines)

输入：

-1
1
61
102

输出：

['-1\n', '1\n', '61\n', '102\n']

1.1.3 输出函数print(x,…)

print函数是Python 内置的函数，可以实现参数的输出

  • print输出的时候，字符串的 ’ ’ 和 " " 都会不显示
>>> a = 10
>>> b = '10'
>>> print(a,b)
 10 10
  • 指定输出项分隔符

print 多参数输出的时候，会将参数都转换成str，然后用" "(空格)进行连接，但是我们可以进行更改

>>> print(1,2,sep="-")
1-2
  • print函数末尾会自动添加换行符
print(10)
print(11)
#Result:
10
11

通过下面的方法，可以改变末尾添加的字符

print(x,end=‘s’)：x为变量，s为末尾添加的任意字符（可以为空）

a,b=10,11
print(a,end=" ")
print(b)
#Result:
10 11
格式化输出

主要是使用format函数、格式化运算符%，详见"各项数据类型"的6.6，6.7

测试例题：华氏-摄氏温度转换表

输入2个正整数lower和upper（lower<upper<100），输出一张取值范围为[lower，upper]、且每次增加2华氏度的华氏-摄氏温度转换表，结果小数部分保留一位。温度转换的计算方式：

C = 5 × ( F - 32 ) / 9 （其中：C表示摄氏温度，F表示华氏温度）

lower,upper = [int(i) for i in input("请输入lower和upper，用空格分割：").split()]
for i in range(lower,upper+1,2):
    print(i,"{:.1f}".format(5*(i-32)/9))
    
请输入lower和upper，用空格分割：10 20
10 -12.2
12 -11.1
14 -10.0
16 -8.9
18 -7.8
20 -6.7
常见错误
#当输入 str 时，需要加入其他类型，需要进行转换
student = ['张三', 18, '男', 180, 130]
print(student[0]+"的身高是"+student[3]) # 直接加上student[3]是错误的

1.2 赋值语句

  • 基本形式：变量 = 值
x = 1
y = 2
k = x + y
print(k)
  • 序列赋值：
  • 保证 左侧变量个数 和 值的数量相等，否则报错
>>> x,y=4,8  #值的数量 对应 变量的数量 ,实际上 4,8 是元组(4,8)的简写    元组
>>> print(x,y)
4 8
>>> a,b = [1,2]#     列表
>>> print(a,b)
1 2
>>> a,b="12"  #   字符串
>>> print(a,b)#字符的数量 对应 变量的数量；  a,b="1   2"是会报错的
1 2
>>> a,b = map(int,["2","451"])  #map函数的返回，其实也是list，但是直接输出map是访问不了内部信息的
>>> print(a,b)
2 451
>>> a,b=b,a #直接这条语句完成两个变量值的⭐交换，还可以更多个变量同时进行交换
>>> print(a,b)
2 1
  • 左右侧数量不等
>>> i,*j=[1,2,3]
>>> print(i,j)
1 [2, 3]  #j的类型为列表
  • 多变量赋值
>>> a=b=c=5
>>> print(a,b,c)
5 5 5
>>>b=b+6
>>>print(a,b,c)
5 11 5
  • 赋值符号和算术运算符组合
>>> i = 2
>>> i*=3
>>> i
6
>>> j=5
>>> j*=3+1 # + 优先于 *=
>>> j
20

1.3 条件语句

1.3.1 基本的条件语句

  • 格式：
if 条件:
	语句块1 #分支语句块，书写时必须缩进，除非和if写在同一行，如： if 条件:语句块

从if 下一行开始，所有缩进了的语句就是当条件成立（逻辑表达式计算的结果为True）的时候要执行的语句。

如果条件不成立，就跳过这些语句不执行，而继续下面的其他语句。

  • 流程图：

举例：

amount = int(input("请投币："))
if amount >= 10:
    print("***********")
    print("Python城际铁路专线")
    print("* 票价：10元 *")
    print("***********")
    print("找零：{}".format(amount-10))

1.3.2 有分支的条件语句

  • 格式
if 条件:
	语句块1 #分支语句块，条件成立时执行
else:
	语句块2 #分支语句块，条件不成立时执行
    
if 逻辑表达式 : #语句块1
else: #语句块2
  • 流程图

举例：

x,y = map(int,input().split())
if x > y:
    max = x
else:
    max = y
print(max)

1.3.3 嵌套的条件语句

分支语句（块）中包含另一个 if 语句，这种情况称为条件语句的嵌套

  • 格式（举例）
if code == 'R':
    if count < 20:
        print("一切正常")
    else:
        print("继续等待")

⭐语句块的分割我觉得是**基于代码格式**的：

x = int(input()) if x == 1: x=x+1 else: x=x+2 x=x+1 print(x) #输入：1 输出：2x = int(input()) if x == 1: x=x+1 else: x=x+2 x=x+1 print(x) #输入：1 输出：3

可以看出 x=x+1 没有tab就推出了语句块的范围。

缩进规则：
  • 确保 if 从句和 else 从句对齐。
  • if 从句和else 从句都要分别跟着一个语句块。
  • 语句块中语句的缩进是一致的。
  • 语句块与 if语句 之前的缩进不一定要是tab，可以是任意的空格。【建议：不同级别之间的缩进为一个tab】
  • if else 的语句块之间的缩进 可以不一致。【建议：同级别的语句块之间缩进一致】

python语言对嵌套if语句的规定是：else总是与缩进位置相同的且最近的if配对

1.3.4 连缀的if-elif-else

使用 if-elif-else 语句可方便地实现程序多分支结构。

  • 格式
if 条件1:
    语句块1
elif 条件2:
    语句块2
...
elif 条件n:
    语句块n
else:
    语句块n+1
# 其中的if，elif，else必须在同一列对齐。
  • 流程图

举例：分段函数

x = int(input())
f = 0
if x < 0:
    f = -1
elif x == 0:
    f = 0
else:
    f = 2 * x
print(f)

1.3.5 条件表达式(v1 if x else v2)

  • 条件表达式类似 if-else 语句，是用来直接得到值。
  • 条件表达式是三元的，需要三个值：
    值1 if 条件 else 值2
  • 条件满足时的值
  • 条件
  • 条件不满足时的值
  • 例子：
x = 20
y = 10 if x > 20 else 30
print(y)

Python 没有引入? :这个三目运算符

1.4 while循环

循环语句可以重复执行部分语句（循环语句/循环体），while 语句是一种循环语句，根据一个逻辑条件（循环条件），在条件成立时执行循环语句，不成立时结束循环。

1.4.1 无 else 子句
  • 格式
while 条件:
    语句块1
  • 流程图
1.4.2 有 else 子句
  • 格式
while 条件:
    语句块1
else:
    语句块2

else 的语句块2 ，将会在循环迭代正常完成之后执行。

  • 正常完成：
    循环体内没有break语句、没有return语句（在函数中时），或者没有异常出现。

一旦循环不是正常完成的，则 else 分支将不再被执行。

  • 流程图

避免死循环：

在循环体内部，应该有改变循环条件的语句，以控制循环的次数，避免产生无限循环（死循环）。

举例：计算 log2x（取整）

x = int(input())
count = 0
while x > 1:
    x //= 2
    count += 1
print(count)

举例：二-十进制转换

n = int(input())
lst = []
while n > 0:
    lst.insert(0,n%2)
    n //= 2
print("".join(map(str,lst))) #lst转换为 元素为str类型的map，join：用""字符串连接map中的字符串参数

举例：求最大公约数

a,b = map(int,input("请输入两个整数(a>=b):").split())
r = a % b
while r > 0:
    a,b = b,r
    r = a % b
print("最大公约数是{}".format(b))
1.4.3 循环内的控制
break 跳出循环

break语句的作用是跳出所在的循环。

举例：猜数游戏

import random
number = random.randint(0,100)
count = 0
while True: #循环条件是逻辑常量True，意味着无限循环
    a = int(input("输入你猜的数："))
    count += 1
    if a == number:
        break # 跳出当前循环，执行while后面的语句
    elif a > number:
        print("你猜的大了")
    else:
        print("你猜的小了")
print("猜中了！你用了{}次！".format(count))
continue 跳过一轮循环

continue 语句作用是跳过本次循环，进入到下一次循环。

举例：计算偶数的平均数

要求：输入一系列的整数，最后输入-1表示输入结束，然后程序计算出这些数字中的偶数的平均值，输出输入的数字中的偶数的平均数。

sum = 0
count = 0
while True:
    number = int(input())
    if number == -1:	break
    if number % 2 == 1:	continue #如果是奇数跳过当前的循环，进入下一次循环
    sum += number
    count += 1
average = sum / count
print(average)

1.5 for循环

当有一个序列，需要按照其顺序遍历其中的每一个单元的时候，就可以用for循环。

1.5.1 无 else 子句
  • 格式
for 循环变量 in 序列:
    语句块1
1.5.2 有 else 子句
  • 格式
for 循环变量 in 序列:
    语句块1
else:
    语句块2

else 的使用见 while 的解释

举例：

for i in [1,2,3,4]:
    print(i,end="")
    
# result:
# 1234
1.5.3 两种循环模式
计数器循环（len()+索引）

使用 len函数 和 索引的组合实现循环。

month = ['JAN','FEB','MAR','APR','MAY','JUN','JUL','AUG','SEP','OCT','NOV','DEC']
for i in range(len(month)):
    print(month[i])
迭代循环

直接使用（str，tuple，list，map(函数返回的是list)，range(函数返回的是list)，set，dict(循环变量为字典的键) ）实现循环。

for name in month:
    print(name)

name 和 month 之间的关系可以理解为遍历month的时候，将month的元素赋值给name。

这样的话，可以将赋值的其他方法应用进来：

a = [[1,3],{2,5,221},(6,1)] for i,*j in a: print(i,j)

举例：判断素数

输入一个大于等于2的正整数，判断是否为素数。素数是只能被1和自己整除的数，因数的范围是从1到自己。

  1. 直接用素数的定义求解
num = int(input())
lst = [factor for factor in range(1,num+1) if num%factor == 0]
if lst == [1,num]:
    print("是素数")
else:
    print("不是素数")
  1. for语句实现
num = int(input())
for i in range(2,num): #i 从2到num-1
    if num % i == 0:
        print("不是素数")
        break
else:
	print("是素数") #如果不是素数，则通过break跳出循环，不会执行else的语句块
  1. 优化
    如 m=a*b 则必有：a<=sqrt(m) 或 b<=sqrt(m)
import math
num = int(input())
for i in range(2,int(math.sqrt(num))+1):
    if num % i == 0:
        print("不是素数")
        break
else:
	print("是素数")

1.5.4 for&while的选择 & 循环常见错误

  1. for语句无法确定范围
    求大于2950的 37的 第一个倍数
for multi in range(37,???,37)
#for语句无法确定范围

所以这里需要使用 while语句

bound = 2950
multi = 37
while multi <= bound:
    multi+=37
print(multi)
  1. 累加误差带来的错误
    加0.01，0.02，0.03，…，0.99，1
  • 累加求解 while语句
    最后一项没有加上：浮点数累加实际上最后超过了1.0
sum = 0
i = 0.01
while i <= 1.0:
    sum += i
    i += 0.01
print("和是：{:.2f}".format(sum))
  • 用 for 语句
sum = 0
i = 0.01
for count in range(100):
    sum += i
    i += 0.01
print("和是：{:.2f}".format(sum))
  1. 列表运行时会改变
    猴子报数选大王
N = int(input())
ls = [i for i in range(1,N+1)]
print(ls)

ptr=1
while len(ls)>1:
    ptr += 2
    ptr = (ptr-1)%len(sl)+1
    print(ls[ptr-1],end=" ")
    del ls[ptr-1]
print()
print(ls[0])

这种方式是错误的，当删除列表的元素之后，后一个元素会占del元素之前的位置，所以索引再加2是错误的

1.6 异常

在程序运行过程中如果发生异常，Python会输出错误消息和关于错误发生处的信息，然后终止程序。

例如：

>>> short_list=[1,72,3]
>>> position = 6
>>> short_list[position]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
#程序由于访问了不存在的列表元素，而发生下标越界异常

1.6.1 try-catch语句

可使用try-catch语句实现异常的处理。

short_list=[1,72,3]
position = 6
try:
    short_list[position]
except:
    print("索引应该在0和",len(short_list)-1,"之间，但却是",position)

#result:
#索引应该在0和 2 之间，但却是 6
  • 完整格式
try:
    语句块1 #正常程序在语句块1中执行，如果程序执行中发生异常，中止程序运行，跳转到所对应的异常处理块中运行。
    # 在"except 异常类型"语句中找到对应的异常类型
except 异常类型1:#如果找到的话，执行后面的语句块；如果找不到，则执行"except"后面的语句块
    语句块2
except 异常类型2:
    语句块3
...
except 异常类型N:
    语句块N+1
except 异常类型N+1:
    语句块N+2
else: #只有当 try 块没有捕获到任何异常时，才会得到执行；反之，如果 try 块捕获到异常，即便调用对应的 except 处理完异常，else 块中的代码也不会得到执行。
    语句块N+3
finally: #finally最后都是会执行的
    语句块N+4

else 和 finally 可省

举例：

short_list=[1,72,3]
position = int(input())
try:
    print(short_list[position])
except:
    print("索引应该在0和",len(short_list)-1,"之间，但却是",position)
else:
    print("run else")
finally:
    print("finally")
  • 输入：3

索引应该在0和 2 之间，但却是 3
finally

  • 输入：2

3
run else
finally

1.6.2 Python常见的标准异常

异常名称

描述

SystemExit

解释器请求退出

FloatingPointError

浮点计算错误

OverflowError

数值运算超出最大限制

ZeroDivisionError

除（或取模）零（所有数据类型）

KeyboardInterrupt

用户中断执行（通常是输入^C）

ImportError

导入模块/对象失败

IndexError

序列中没有此索引（index）

RuntimeError

一般的运行时错误

AttributeError

对象没有这个属性

IOError

输入/输出操作失败

OSError

操作系统错误

KeyError

映射中没有这个键

TypeError

对类型无效的操作

ValueError

传入无效的参数

。。。。

。。。。

举例：

x = int(input())
y = int(input())
try:
    result = x/y
except ZeroDivisionError:
    print("division by zero!")
else:
    print("result is",result)
finally:
    print("executing finally clause")

输入：0

输出：
division by zero!
executing finally clause

1.6.3 except Exception as name

使用except Exception as name获取整个异常对象，可以用来进行异常的输出。

举例：

ls = [1,2,3]
while True:
    value = input("Position [q to quit]?")
    if	value == 'q':
        break
    try:
        position = int(value)
        print(ls[position])
    except IndexError as err:
        print("Bad index:",position)
    except Exception as other:
        print("Some else broke:",other)
Position [q to quit]?6
Bad index: 6
Position [q to quit]?a
Some else broke: invalid literal for int() with base 10: 'a'

1.6.4 raise函数抛出异常

使用raise语句能显式地触发异常，基本格式如下：

raise 异常类     #引发异常时会隐式地创建类对象
raise 异常类对象   #引发异常类实例对象对应的异常
raise         #重新引发刚刚发生的异常

在上述格式中，第1种方式和第2种方式是对等的，都会引发指定异常类对象。但是，第1种方式隐式地创建了异常类的实例，而第2种形式是最常见的，直接会提供一个异常类的实例。第3种方式用于重新引发刚刚发生的异常。

  1. 使用类名引发异常
    当raise语句指定异常的类名时，会（隐式地）创建该类的实例对象，然后引发异常。例如：
raise IndexError

程序运行的结果如下：

Traceback (most recent call last):
  File "C:\Users\itcast\PycharmProjects\Chapter09\异常.py", line 1, in <module>
    raise IndexError
IndexError
  1. 使用异常类的实例引发异常
    通过显式地创建异常类的实例，直接使用该实例对象来引发异常。例如：
index_error = IndexError()
raise index_error

程序运行的结果如下：

Traceback (most recent call last):
  File "C:\Users\itcast\PycharmProjects\Chapter09\异常.py", line 2, in <module>
    raise IndexError
IndexError
  1. 传递异常
    不带任何参数的raise语句，可以再次引发刚刚发生过的异常，作用就是向外传递异常。
    例如：
try:
    raise IndexError
except:
    print("出错了")
    raise

上述示例中，try里面使用raise抛出了IndexError 异常，程序会跳转到except子句中执行输出打印语句，然后使用raise再次引发刚刚发生的异常，导致程序出现错误而终止运行。程运行的结果如下：

出错了
Traceback (most recent call last):
  File "D:\Workspace\Thonny\test.py", line 2, in <module>
    raise IndexError
IndexError
  1. 指定异常的描述信息
    当使用raise语句抛出异常时，还能给异常类指定描述信息。例如：
raise IndexError("索引下标超出范围")

上述示例中，在抛出异常类时传入了自定义的描述信息。程序的运行结果如下：

D:\bili_new\Scripts\python.exe C:/Users/itcast/PycharmProjects/bili_new/test.py
Traceback (most recent call last):
  File "C:\Users\itcast\PycharmProjects\Chapter09\异常.py", line 1, in <module>
    raise IndexError("索引下标超出范围")
IndexError: 索引下标超出范围
  1. 异常引发异常

如果要在异常中抛出另外一个异常，可以使用raise-from语句实现。例如：

try:
    number
except Exception as exception:
    raise IndexError("下标超出范围") from exception

上述示例中，try里面只定义了变量number，并没有为其赋值，所以会引发NameError异常，使得程序跳转到except子句中执行。except子句能捕捉所有的异常，并且使用raise-from语句抛出NameError异常后再抛出 “下标超出范围” 的异常。

程序的运行结果如下：

Traceback (most recent call last):
  File "C:\Users\itcast\PycharmProjects\Chapter09\异常.py", line 1, in <module>
    raise IndexError("索引下标超出范围")
IndexError: 索引下标超出范围