Python3-1 流程控制（分支结构）
一、判断题
1-1.在 if...elif...else 的多分支语句中只会执行一个语句块。T
使用 if - elif - else 语句，有两个判断条件，如果 if 后的条件成立(为 True)，则执行 if 判断语句后带缩进的代码逻辑. 如果 elif 后的条件成功(为 True)，则执行 elif 判断语句后带缩进的代码逻辑，否则执行 else 后带缩进的代码逻辑。 值得注意的是，if - elif - else 语句中，仅有一个条件成立后，就会退出当前整个判断语句，简单来说，这三条判断路径，只会走其中一条。
条件表达式
age = 12
if age < 18:
s = 'minor'
else:
s = 'adult'
可以简化为：
s = 'minor' if age < 18 else 'adult'
二、单选题
2-1.下面程序的运行结果是什么？ 1
s=0
a,b=1,2 #a=1;b=2
if a>0: # true 退出循环
s=s+1
elif b>0:
s=s+1
print(s)
三、编程题
7-1 sdut-sel-10 直角坐标系象限判断
X是一个喜欢数学的小孩，现在刚刚学了坐标系。象限划分示意图如下：
他想知道点(X,Y)在第几象限内。输入数据保证点不在坐标轴及原点上。
输入格式:
多组输入。
每组输入两个整数X，Y，代表点（X，Y），中间用空格隔开。
输出格式:
输出一个整数代表点在第几象限内。
输入样例:
在这里给出一组输入。例如：
2 3
-2 -3
输出样例:
在这里给出相应的输出。例如：
1
3
结尾无空行
while 1: # 多组输入
try:
x,y=map(int,input().split())
if x>0 and y>0:
print(1)
elif x>0 and y<0:
print(4)
elif x<0 and y>0:
print(2)
else:
print(3)
except:
break
7-2 sdut-计算分段函数
计算下列分段函数g(x)的值：
输入格式:
在一行中输入实数x。
输出格式:
在一行中按“g(x) = result”的格式输出，其中x与result都保留3位小数。
输入样例1:
500
结尾无空行
输出样例1:
g(500.000) = 0.001
结尾无空行
输入样例2:
0
结尾无空行
输出样例2:
g(0.000) = 0.000
结尾无空行
x=float(input()) # 注意转化
if x==0:
re=0
print("g({:.3f}) = {:.3f}".format(x,re)) #注意输出格式
else:
re=1/(2*x)
print("g({:.3f}) = {:.3f}".format(x,re))
7-3 sdut-sel-2 汽车超速罚款（选择结构）
许多社区都有“雷达”标志，告诉司机他们的速度是多少，希望他们能够慢下来。
你将输出一个“雷达”标志的信息，根据司机驾驶车速的情况向他（她）显示信息。
在此，郑重地提醒各位小伙伴们：在道路上驾驶机动车一定要遵守交通规则，注意交通安全！道路千万条，安全第一条！！！
输入格式:
在一行内输入2个整数。第一个表示速度的限制，第二个表示司机的开车速度。
输出格式:
如果司机没有超速，输出应该是：Congratulations, you are within the speed limit!
如果司机超速行驶，输出为：You are speeding and your fine is F.（F为上表中描述的罚款数额）
输入样例1:
40 39
结尾无空行
输出样例1:
Congratulations, you are within the speed limit!
结尾无空行
输入样例2:
100 131
结尾无空行
输出样例2:
You are speeding and your fine is 500.
结尾无空行
输入样例3:
100 120
结尾无空行
输出样例3:
You are speeding and your fine is 100.
结尾无空行
x,y=map(int,input().split())
a=x-y
b=abs(a)
if a>=0:
print("Congratulations, you are within the speed limit!",end='')
else:
if b>=1 and b<=20:
print("You are speeding and your fine is {}.".format(100),end='')
elif b>=21 and b<=30:
print("You are speeding and your fine is {}.".format(270),end='')
else:
print("You are speeding and your fine is {}.".format(500),end='')
注意带上标点，俺因为个句号没提交上
7-4 sdut-运输计费问题
某运输公司对用户计算运费。路程（S）越远，每公里运费越低。标准如下：
其中，基本运输费用为：每吨每公里1元。
现请你帮助该运输公司设计计费程序，计算运输费用。
输入格式:
每次运输的载重（吨）、里程（公里），中间有一个空格。
输出格式:
输出其运输费用，精确到元。
输入样例1:
1 200
结尾无空行
输出样例1:
200
结尾无空行
输入样例2:
10 2500
输出样例2:
22500
结尾无空行
错误提交：
t,s=map(int,input().split())
al=t*s
if s<250:
print(al,end='')
elif s>=250 and s<500:
al=al*0.98
print(int(al),end='')
elif s >= 500 and s < 1000:
al = al * 0.95
print(int(al),end='')
elif s>=1000 and s<2000:
al=al*0.92
print(int(al),end='')
elif s>=2000 and s<3000:
al=al*0.90
print(int(al),end='')
else:
al = al * 0.85
print(int(al),end='')
提交之后只有第一个if语句是正确的，但是其他的都显示非零返回，
t,s=map(float,input().split())
al=t*s
if s<250:
print(round(al))
elif 250<= s <500:
print(round(al*0.98))
elif 500<= s < 1000:
print(round(al * 0.95))
elif 1000<= s <2000:
print(round(al*0.92))
elif 2000<= s <3000:
print(round(al*0.90))
else:
print(int(al * 0.85))
在上面的函数提交中，使用int函数和round函数结果都是一样的，都会对浮点数进行四舍五入，那为什么上一个提交会显示非零返回呢？
猛的一看 int（） round() math.floor() 这几个函数函数好像做的是同一件事情，很容易将他们弄混，下面是他们的一些不同之处：
int（）函数直接截去小数部分
floor（） 得到最接近原数但是小于原数的部分
round()得到最接近原数的整数（返回为浮点类型）
# round()
import math
print(round(80.45799613235,2))
print(round(80.45799613235,4))
# int
print(int(80.955414245))
# floor
print(math.floor(80.999))
7-5 sdut-阶梯电价
为了提倡居民节约用电，某省电力公司执行“阶梯电价”，安装一户一表的居民用户电价分为两个“阶梯”：
月用电量50千瓦时（含50千瓦时）以内的，电价为0.53元/千瓦时；
超过50千瓦时的，超出部分的用电量，电价上调 X 元/千瓦时。（不是上调为）
请编写程序计算电费。
输入格式:
在一行中，输入某用户的月用电量（单位：千瓦时）和电价上调的X值（单位：元），中间用空格分开。
输出格式:
在一行中输出该用户应支付的电费（元），结果保留两位小数，格式如：“cost=应付电费值”。
输入样例1:
10 0.05
结尾无空行
输出样例1:
cost=5.30
结尾无空行
输入样例2:
100 0.05
结尾无空行
输出样例2:
cost=55.50
结尾无空行
输入样例3:
-100 0.05
结尾无空行
输出样例2:
cost=0.00
结尾无空行
a,b=map(float,input().split())
if a>50:
print("cost={:.2f}".format(50*0.53+(a-50)*(b+0.53)),end='')
elif 0<a<=50:
print("cost={:.2f}".format(a*0.53),end='')
else:
print("cost={:.2f}".format(abs(a*0)),end='')
在这个题中我知道还有-0.00这个玩意儿，在计算机语言中输出的数字都是严格按照程序计算的，而不是符合我们平时的逻辑规则的，不是现实的数学里没有-0，计算机语言里就没有的。
7-6 sdut-分段计算居民水费
为鼓励居民节约用水，自来水公司采取按用水量阶梯式计价的办法，居民应交水费y（元）与月用水量x（吨）相关，请编写程序实现水费的计算。
（1）当x不超过15吨时，y=4x/3；
（2）超过后，y=2.5x−17.5。
输入格式:
在一行中给出非负实数x。
输出格式:
在一行输出应交的水费，精确到小数点后2位。
输入样例1:
12
结尾无空行
输出样例1:
16.00
结尾无空行
输入样例2:
16
结尾无空行
输出样例2:
22.50
结尾无空行
x=float(input())
if 0<x<15:
print("{:.2f}".format((4*x)/3))
else:
print("{:.2f}".format(2.5*x-17.5))
Python3-2 流程控制（循环结构）
一、判断题
1-1.在Python循环中，continue语句的作用是：退出循环的当前迭代，开启下一轮循环。T
Python continue 语句跳出本次循环，而break跳出整个循环。
continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
continue语句用在while和for循环中。
1-2.在Python循环中，对于带有else子句的循环，如果因为执行了break语句而退出的话，会执行else子句的代码。F
Python主要有for循环和while循环两种形式的循环结构，多个循环可以嵌套使用，并且还经常和选择结构嵌套使用。while循环一般用于循环次数难以提前确定的情况，当然也可以用于循环次数确定的情况；for循环一般用于循环次数可以提前确定的情况，尤其适用于枚举或遍历序列或迭代对象中元素的场合。对于带有else子句的循环结构，如果循环因为条件表达式不成立或序列遍历结束而自然结束时则执行else结构中的语句，如果循环是因为执行了break语句而导致循环提前结束则不会执行else中的语句。
1-3.在Python循环中，使用for i in range(10) 和 for i in range(10,20)，控制循环次数是一样的。T
print(list(range(10)))
print(list(range(10,20)))
'''
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
'''
range()函数左闭右开
1-5.下面程序输入5，输出是1。F
a=[3,5,7,11,13,16,21,24,28,32,36,40,46]
x = int(input())
found = -1
left = 0 #第一个元素下标
right = len(a)-1 #最后一个元素下标
while left<right:
mid = (left + right) // 2
if a[mid] > x:
right = mid - 1
elif a[mid] < x:
left = mid + 1
else: # a[mid]==x
found = mid
break
print(found)
输入5-->mid=(0+12)//2=6,a[mid]=21-->21>5,right=5,跳出循环，此时found=-1，输出found
实际上是二分查找：
二、单选题
2-3.下面程序中语句print(i*j)共执行了______15_______次。
for i in range(5):
for j in range(2,5):
print(i*j)
外层的循环执行了五次，里层的循环执行了5*3次，每次外面的循环执行一次，里层的循环就会执行三次。
2-4.下面那个语句不能完成1到10的累加功能? total初值为0。A
A.
for i in range(10,0):
total+=i
B.
for i in range(1,11):
total+=i
C.
for i in range(10,0,-1):
total+=i
D.
for i in (10,9,8,7,6,5,4,3,2,1):
total+=i
rang(10,0)里面什么也没有，是空的，但是range(10,0,-1)是倒序的，[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]，注意左闭右开，和D中一样。
2-5.下面程序输入1时，输出是什么？。是素数
num=int(input())
a=num-1
while a>1:
if num % a == 0:
print("不是素数")
break
a=a-1
else:
print("是素数")
输入1，a=0，不符合循环条件，所以执行else语句，输出是素数。
2-6.Python中，列表推导式在逻辑上等价于（ 循环语句）。
列表推导式可以使用非常简洁的方式对列表或其他可迭代对象的元素进行遍历和过滤，快速生成满足特定需求的列表，代码具有非常强的可读性，是Python程序开发时应用最多的技术之一。Python的内部实现对列表推导式做了大量优化，可以保证很快的运行速度，也是推荐使用的一种技术。列表推导式的语法形式为：
[表达式 for 变量 in 序列或迭代对象 if 条件表达式]
列表推导式在逻辑上等价于一个循环语句，只是形式上更加简洁。
2-7.a=[2,3,4,1,6,9,8],执⾏b = [index for index, value in enumerate(a) if value > 3]后，b=( )。
D.[2,4,5,6]
列表推导式，最外层的循环是下标、数值在由列表a构成的索引中，条件是数值大于三，然后返回下标。
2-9.有如下代码：
i = sum = 0
while i <= 4:
sum += i
i = i+1
print(sum)
以上代码输出的结果是？10
i从0开始，然后进入循环，sum=0,i=1-->sum=1,i=2-->sum=3,i=3-->sum=6,i=4-->sum=10,i=5 exit.
三、填空题
4-1
下面程序运行后输出是 150
l3=[i+j for i in range(1,6) for j in range(1,6)]
print(sum(l3))
双层循环，1+1，1+2，1+3，1+4，1+5；2+1...依次类推
4-2
下面程序运行后输出是 2
l3=[[(i,j) for i in range(1,6)] for j in range(1,6)]
print(l3[2][1][0])
看下面的代码：
l3=[[(i,j) for i in range(1,6)] for j in range(1,6)]
print(l3)
'''
[(1, 1), (2, 1), (3, 1), (4, 1), (5, 1)] [(1, 2), (2, 2), (3, 2), (4, 2), (5, 2)] [(1, 3), (2, 3), (3, 3), (4, 3), (5, 3)] [(1, 4), (2, 4), (3, 4), (4, 4), (5, 4)] [(1, 5), (2, 5), (3, 5), (4, 5), (5, 5)]
'''
上面是以元组组成的五个列表，先执行中括号中的循环，然后将外面的循环作为外层循环。
l3=[[[(i,j) for i in range(1,6)] for j in range(1,6)]]
print(l3)
'''
[[(1, 1), (2, 1), (3, 1), (4, 1), (5, 1)], [(1, 2), (2, 2), (3, 2), (4, 2), (5, 2)], [(1, 3), (2, 3), (3, 3), (4, 3), (5, 3)], [(1, 4), (2, 4), (3, 4), (4, 4), (5, 4)], [(1, 5), (2, 5), (3, 5), (4, 5), (5, 5)]]
'''
再加一个中括号就是嵌套列表。
4-3
下面程序的输出是 7
row=[0]*3
data=[row,row,row]
data[2][2]=7
print(data[0][2])
因为在data列表的每个元素中都是row，所以当其中一个元素更改，也就是row被更改，其余的元素也会跟着变。
row=[0]*3
print(row)
data=[row,row,row]
print(data)
data[2][2]=7
print(data)
print(data[0][2])
'''
[0, 0, 0]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 7], [0, 0, 7], [0, 0, 7]]
7
'''
4-4
下面程序运行后，位于最后一行的最后一个数字是
for i in range(1,5):
j=0
while j<i:
print(j,end=" ")
j+=1
print()
是一个双层循环，一个四行，一行需要j<i个，所以最后一个是3。
4-5
下面程序运行后，倒数第二行打印出 1xxx2xxx
i=5
while i>=1:
num=1
for j in range(1,i+1):
print(num,end="xxx")
num*=2
print()
i-=1
最外面的while循环决定一共五行，第二个循环决定行数，
四、编程题
7-8 sdut-入门-4 A+B for Input-Output Practice (IV)
你的任务是计算一些整数的和。
输入格式:
输入包含多个测试用例。
每个测试用例包含一个整数N，然后在同一行中跟随N个整数。以0开始的测试用例终止输入，并且这个测试用例不被处理。
输出格式:
对于每一组输入整数，您应该在一行中输出它们的和，输入的每一行都有一行输出。
输入样例:
在这里给出一组输入。例如：
4 1 2 3 4
5 1 2 3 4 5
0
输出样例:
在这里给出相应的输出。例如：
10
15
while 1:
try:
ls=[eval(x) for x in input().split()]
if ls[0]==0:
break
s=0
for i in range(0,ls[0]):
i+=1
s+=ls[i]
print(s)
except:
break
7-10 sdut-入门-6 A+B for Input-Output Practice (VI)
你的任务是计算一些整数的和。
输入格式:
输入包含多个测试用例，一个用例一行。每一种情况都以一个整数N开始，然后在同一行中跟随N个整数。
输出格式:
对于每个测试用例，您应该在一行中输出N个整数的和，并在输入的每一行中输出一行。。
输入样例:
在这里给出一组输入。例如：
4 1 2 3 4
5 1 2 3 4 5
输出样例:
在这里给出相应的输出。例如：
10
15
# 错误答案（暂时没找错误）：
while 1:
try:
ls=[eval(x) for x in input().split()]
s=0
for i in range(1,ls[0]+1):
s+=ls[i]
print(s)
except:
break
7-18 sdut-水仙花数
水仙花数是指一个N位正整数（N≥3），它的每个位上的数字的N次幂之和等于它本身。 例如：153=1×1×1+5×5×5+3×3×3。
请计算所有N位水仙花数。
输入格式:
在一行内，给出一个正整数N（3≤N≤5）。
输出格式:
按递增顺序输出所有N位水仙花数，每个数字占一行。
输入样例:
在这里给出一组输入。例如：
3
结尾无空行
输出样例:
在这里给出相应的输出。例如：
153
370
371
407
结尾无空行
错误1：
def f(a, n):
a=str(a)
l = [eval(x) for x in a]
s = 0
for x in l:
s += x ** n
if s == int(a):
return a
else:
return
n = int(input())
ls = [i for i in range(10 ** (n - 1), eval('9' * n) + 1)]
for x in ls:
if f(x, n):
print(x)
输入5的时候运行超时，在pc运行肉眼可见的慢，没找到改进的方法，但是找到两个投机取巧的方法：
n = int(input())
ls = [i for i in range(10 ** (n - 1), eval('9' * n) + 1)]
s=0
lst=list
for x in ls:
a=x//10000
b=x//1000%10
d=x//100%10
e=x//10%10
f=x%10
s=a**n+b**n+f**n+d**n+e**n
if s==x:
print(x)
或者更直接一点，就是输入3，4，5的时候分别等于哪些数，输出就行
找到了更简单的方法：
# 正确答案：
n = input()
n = int(n)
s = 10 ** (n - 1)
e = 10 ** n
for i in range(s, e):
if i==sum([int(j)**n for j in str(i)]):
print(i)
这是对最上面的错误答案的简化了，主要是忘了最简单的求和函数，把位数直接从字符中分离出来然后变成整数，所以说多交流也是很好的。（碎碎念不用理）
7-19 sdut-最大公约数和最小公倍数
给定2个正整数，求它们的最大公约数和最小公倍数，并输出。
输入格式:
输入有若干组。
每组数据，在一行中给出两个正整数M和N（≤1000），中间有1个空格。
输出格式:
对于每组输入，在一行中顺序输出M和N的最大公约数和最小公倍数，两数字间以1个空格分隔。
输入样例:
18 12
20 15
39 26
5 76
45 25
1993 343结尾无空行
输出样例:
在这里给出相应的输出。例如：
6 36
5 60
13 78
1 380
5 225
1 683599结尾无空行
while 1:
try:
a, b = map(int, input().split())
c=min(a,b)
for i in range(1, c+1):
if b % i == 0 and a % i == 0:
ma = i
t = a * b / ma
print("{} {}".format(ma,int(t)))
except:
break
上几次提交的时候被找到的答案完全带跑了，把range的范围定义子啊2--c+1，但是最大公约数是一的状况就被忽略掉了，我完全没有想过把范围改改，加了很多不必要的条件，还是错的，但是只要改一下范围就可以了，有时候过于相信答案也是非常不行的，最起码自己得有主见，得自信一点儿。（碎碎念，请忽略）
7-2 sdut-求π的近似值
用公式求π的近似值： 
当求和项小于误差时，求和结束。
输入格式:
在一行输入误差范围。
输出格式:
在一行输出π的近似值（保留6位小数）。
输入样例:
在这里给出一组输入。例如：
0.00000001
结尾无空行
输出样例:
3.141497
结尾无空行
import math
def fun(m):
suma=0
count=1
c=1
while count>m:
count=1.0/math.pow(c,2)
suma+=count
c+=1
return math.sqrt(suma*6)
m=float(input())
print("{:.6f}".format(fun(m)))
这个题的意思是求和项的最后一项小于输入的数时，就输出相应的值。
这里自定义了函数方法，循环的条件就是求和项的最后一项大于输入值，求和项的最后一项单独拿出来，然后执行求和，注意输出的和不是要求的值，需要在转化一布。
7-3 sdut-求误差小于输入值的e的近似值
7-3 sdut-求误差小于输入值的e的近似值 (10 分)
自然常数e可以用级数1+1/1!+1/2!+⋯+1/n!来近似计算。ei代表前i项求和。输入误差范围error，当 
，则表示e的近似值满足误差范围。
输入格式:
在一行输入误差范围，误差小于等于0.01。
输出格式:
在一行输出e的近似值（保留6位小数）。
输入样例1:
0.01
结尾无空行
输出样例1:
2.716667
结尾无空行
输入样例2:
0.01
结尾无空行
输出样例2:
2.716667
结尾无空行
n=float(input())
def e(n):
m=1
s=1
for i in range(1,n):
m*=i
s+=1/m
return s
cnt=1
while(True):
if abs(e(cnt)-e(cnt+1))<n:
print("{:.6f}".format(e(cnt+1)))
break
else:
cnt+=1
这个题和上一个题不同的是，这次是求和项的最后两项的差小于输入的数即为应该输出的正确答案。
和上一个题的思路有些相同，需要把最后两项拿出来，每一项的运算模式都是一样的，所以写成了函数方法，然后最后两项调用函数方法做差，在循环里实现函数这个求和序列。
7-4 求6+66+666+6666+66666。
输入2个正整数m和n。 求和：m+mm+mmm+mmmm+ ... +mmm……mmm（n个m)
例如：输入：6和5，则求和：6+66+666+6666+66666 并输出。
输入格式:
第一行表示正整数m；（0<=m<=9）
第二行输入正整数n。（0<=m<=1000）
输出格式:
在一行内输出按照要求计算的累加和。
输入样例:
在这里给出一组输入。例如：
6
2结尾无空行
输出样例:
在这里给出相应的输出。例如：
72
结尾无空行
from functools import reduce
m=input()
n=int(input())
def drop(x,y):
return x+y
ls=[eval(m*i) for i in range(1,n+1)]
print(reduce(drop,ls))
上面的求和每一项都是相同的，所以运用字符串相乘更加简单一些，求和那里整的难了，下面是简化了的程序：
m=input()
n=int(input())
ls=[eval(m*i) for i in range(1,n+1)]
print(sum(ls))
7-13 sdut-九九乘法表
九九乘法表是数学学习的基础，今天我们就来看看乘法表的相关问题。《九九乘法歌诀》，又常称为“小九九”,如下图所示。你的任务是写一个程序，对于给定的一个正整数 n ，输出“九九乘法表”的前 n 行。例如，输入 n 为 9，你的程序的输出将为下图：
输入格式:
输入包含多组测试数据，以 EOF 结束。每组测试数据只包含一个正整数 n (0 < n < 10)。
输出格式:
对于每组测试数据，输出上图所示“九九乘法表”的前 n 行。
输入样例:
2
3
结尾无空行
输出样例:
在这里给出相应的输出。例如：
1*1=1
1*2=2 2*2=4
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
结尾无空行
以下是错误错误代码：
while 1:
try:
n = int(input())
if 0 < n < 10:
for i in range(1, n + 1):
for j in range(1, i):
print("%d*%d=%d" % (j, i, i * j), end=" ")
print("%d*%d=%d" % (i, i, i * i))
else:
break
except:
break
在PC上运行没有错误，但是在pta上提交显示部分错误，有答案不正确。
7-23 sdut-单链表数据的拆分
输入N个整数顺序建立一个单链表，将该单链表拆分成两个子链表：
第一个子链表存放了所有的偶数，第二个子链表存放了所有的奇数。
两个子链表中数据的相对次序与原链表一致。
输入格式:
第一行输入整数N;
第二行依次输入N个整数，中间用空格隔开。
输出格式:
第1行分别输出偶数链表与奇数链表的元素个数；
第2行依次输出偶数子链表的所有数据；
第3行依次输出奇数子链表的所有数据。
输入样例:
10
1 3 22 8 15 999 9 44 6 1001
结尾无空行
输出样例:
4 6
22 8 44 6
1 3 15 999 9 1001
结尾无空行
n = int(input())
ls = [eval(x) for x in input().split()]
l1 = [i for i in ls if i % 2 == 0]
l3=' '.join(str(i) for i in ls if int(i)%2==0)
l2 = [i for i in ls if i % 2 == 1]
l4=' '.join(str(i) for i in ls if int(i)%2==1)
print(len(l1), len(l2))
print(l3)
print(l4)
想直接输出一个列表但是不想用循环，所以直接用了字符串。
偷懒，请大家不要学【狗头】
Python4 字符串
一、判断题
1-1
当输入是10.0时，下面程序的输出是f(10.0) = 0.1。F
x=int(input())
if x==0:
result=0
else:
result=1/x
print('f({0:.1f}) = {1:.1f}'.format(x,result))
这就涉及到了int函数的应用了:
class int(x,base=10) #x是数字或者字符串，base是进制数，默认是十进制，返回整型数据
int() #无参数时返回0
int(3.6) #3
int('12',16) #如果是带参数base的话，参数要用字符串形式，因为输入纯数字的时候int()的作用是取整
int("3.5",8) # 报错，str必须为整数
int("1010",2) # 1010是正确的二进制格式
总结：int()对纯数字的作用是取整，进行进制转换必须用字符串类型，而且字符串中的数字为整数，base为2时进行的是将前面的二进制转换为十进制，其余base则是将前面的字符串转换成对应的进制数。
1-2
下面程序中： F
m=int(input())
print('{:^5}'.format('*'*m))
print('{:^m}'.format('*'*m))
若输入是5，则输出是：
*****
*****
这又涉及到format函数的用法了：
-
format函数格式化输出：
-
位置：
print("{} {}".format("123","456")) # 默认顺序输出 print("{1} {0}".format("123","456")) # 颠倒位置 print("{1} {0} {0}".format("123","456")) # 重复输出 ''' 输出结果： 123 456 456 123 456 123 123 ''' -
设置参数：
print("名字:{name},年龄:{age}".format(name="sss",age="18")) # 通过字典 site={"name":"sss","age":"19"} print("名字：{name},年龄：{age}".format(**site)) #通过列表索引 list1=["sss","14"] print("名字：{0[0]},年龄：{0[1]}".format(list1)) #{0[0]},第一个0代表format中的第一个列表，第二个0代表列表中的第一个参数 ''' 输出结果： 名字:sss,年龄:18 名字：sss,年龄：19 名字：sss,年龄：14 ''' -
类方法：
class A(object): #类 def __init__(self,value): # 构造方法，value初始化 self.value=value A_value=A(45) # 初始化value print("value的值为{0.value}".format(A_value)) # 输出结果：value的值为45 -
数字格式化：
print("{:.2f}".format(3.1415926)) # 3.14 print("{:.3f}".format(3.456897)) # 3.457数字 格式 输出 描述 3.1415926 {:.2f} 3.14 保留小数点后两位 3.1415926 {:+.2f} +3.14 带符号保留小数点后两位 -1 {:+.2f} -1.00 带符号保留小数点后两位 2.71828 {:.0f} 3 不带小数 5 {:0>2d} 05 数字补零 (填充左边, 宽度为2) 5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4) 10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4) 1000000 {:,} 1,000,000 以逗号分隔的数字格式 0.25 {:.2%} 25.00% 百分比格式 1000000000 {:.2e} 1.00e+09 指数记法 13 {:>10d} 13 右对齐 (默认, 宽度为10) 13 {:<10d} 13 左对齐 (宽度为10) 13 {:^10d} 13 中间对齐 (宽度为10) 11 '{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)1011 11 13 b 0xb 0XB进制 ^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
此外还可以用{}来充当转义符：
print("{0}对应的第一个位置是{{0}}".format("123456")) #第一个大括号中的0可以省略 print("{1}对应的第一个位置是{{1}}".format("123456","absdf")) # 输出结果：123456对应的第一个位置是{0} # 输出结果：absdf对应的第一个位置是{1}
-
1-3
下面程序中， F
print("这是字符串输出格式{:5s}".format("123"))
执行后，输出是： 这是字符串输出格式□□123。 □表示空格。
1-4
下面程序中，T
print("这是字符串输出格式{:5d}".format(123))
执行后，输出是： 这是字符串输出格式□□123。 □表示空格。
在utf-8中汉字占3个字节，数字字母占1个字节，在format查看字符串所占的字节数要用到encode函数。
1-6
可以通过[]来访问字符串的某个字符，也可以将它修改成其他字符。F
字符串一旦被创建就不可以被修改，一旦“修改”就变成新的对象了。
1-8
print("12 "*3==" ".join(["12","12","12"])) 的输出是True。 F
a="12 "*3
b=" ".join(["12","12","12"])
print(a)
print(b)
print(type(a),type(b))
print(a==b)
print(a is b)
'''
12 12 12
12 12 12
<class 'str'> <class 'str'>
False
False
'''
# 这样看不是很明显，把它们全部变成列表：
print(list(a),list(b))
'''
['1', '2', ' ', '1', '2', ' ', '1', '2', ' ']
['1', '2', ' ', '1', '2', ' ', '1', '2']
'''
# 用*多了一个空格，但是join函数没有，join是split的逆函数。
1-9
语句print("输出结果是{:8s}".format("this"))的输出是：输出结果是 :□□□□this。 □表示空格。 F
输出默认为左对齐，这样看更直观一些：
print("输出结果是{:m>8s}".format("this"))
print("输出结果是{:a<8s}".format("this"))
print("输出结果是{:8s}".format("this"))
'''
输出结果是mmmmthis
输出结果是thisaaaa
输出结果是this
'''
1-10
语句print("输出结果是{:8d}".format(1234))的输出是：输出结果是 1234□□□□。 □表示空格。 F
print("int占八位：{:8d}".format(1234)) # 默认右对齐
print("字符串占八位：{:8s}".format("1234")) # 默认左对齐
print("浮点数占八位：{:8f}".format(1.123)) # 默认左对齐后面补0
print("浮点数占八位保留两位：{:8.2f}".format(1.234)) # 默认右对齐
'''
int占八位： 1234
字符串占八位：1234
浮点数占八位：1.123000
浮点数占八位保留两位： 1.23
'''
1-12
下面程序的输入是5，输出是否正确? F
m=int(input())
print('{:^5}'.format('*'*m))
print('{:^m}'.format('*'*m))
输出结果：
*****
*****
修改的代码：
m=int(input())
print('{:^5}'.format('*'*m))
print('{:^{}}'.format('*'*m,m))
1-13
在python中，字符串属于不可变有序序列。 T
1-14
Python可以利用字符串方法replace()对字符串对象进行原地修改。 F
这里理解为对原对象进行修改，就是对象可变，不知道对不对，待定
1-15
已知x为非空字符串，那么表达式 ''.join(x.split()) == x 的值一定为True。 T
二、单选题
2-7
假设s和t都是字符串变量，并且t不是s的子串，那么表达式s.find(t)的值是？ -1
用到了find函数，找不到返回的是-1
2-8
假设s和t都是字符串变量，并且t不是s的子串，那么表达式s.index(t)的值是？
报异常
s="123sdfaa79**"
print(s.index('t'))
'''
ValueError: substring not found
'''
2-9
表达式max('1111', '222', '33', '4')的值是？ 4
关于max函数怎么比较字符串的大小，是取决于字符串的第一个字符的ASCII码：
print(max('14', '222', '33', '4'))
print(ord('4'),ord('1'))
'''
4
52 49
'''
关于怎么查字符串的ASCII码，可以应用ord函数。
三、多选题
3-5
欲打印出信息：“我叫小明，今年 10 岁! ”（不包括双引号），可使用的语句包括： ABCD
(2分)
A.
print ("我叫%s,今年%d岁!" % ('小明', 10))
B.
class Student: # 类
def __init__(self, name,age): # 初始化
self.name = name # 形参转实参
self.age=age
stu = Student('小明', 10) # 调用类
print('我叫{0.name},今年{0.age}岁!'.format(stu))
C.
dct={'name':'小明','age':10}
print('我叫{name},今年{age}岁!'.format(**dct)) # 字典
D.
lst=['小明', 10]
print('我叫{0[0]},今年{0[1]}岁!'.format(lst)) # 列表的格式化输出
四、编程题
7-1 sdut-oop-8 分数四则运算（类和对象）
定义类Fraction，在其中定义属性:numerator和denominator，分别表示分子和分母。
然定再定义两个分数的加、减、乘、除运算的方法。
在主类中输入2个分数，计算它们的四则运算结果。
提示：若用Python语言来实现，不必自行创建类，可直接使用 fractions模块处理分数的表示与运算。
输入格式:
第一行是整数N，表示待进行分数四则运算式子的数量。接下来包含N行输入。
每行数据是一个字符串，格式是"a/boc/d"。
其中a, b, c, d为数字（每个数字保证在int类型范围内，为正数并且不存在正号）。o是运算符"+"或者"-","*",""。
输出格式:
对于每一行分数四则运算，输出一行计算结果。
注意：结果应符合书写习惯，没有多余的符号、分子、分母，并且化简至最简分数形式。
输入样例:
5
1/100+3/100
1/4-1/2
1/3-1/3
1/2*2/1
1/2\1/2结尾无空行
输出样例:
1/25
-1/4
0
1
1结尾无空行
from fractions import Fraction
n=int(input())
while n:
a = input()
if a.find('+')!=-1:
ls = a.split('+')
print(Fraction(ls[0]) + Fraction(ls[1]))
elif a.find('-')!=-1:
ls = a.split('-')
print(Fraction(ls[0]) - Fraction(ls[1]))
elif a.find('*')!=-1:
ls = a.split('*')
print(Fraction(ls[0]) * Fraction(ls[1]))
else:
ls = a.split('\\')
print(Fraction(ls[0]) / Fraction(ls[1]))
n-=1
做这个题的时候简直了，首先是我忘了find找不到要找的字符串的时候返回的是-1，而返回的-1布尔值又是true，所以只能执行第一个if语句，然后又是把a放在了最外面，就这个错误阻挡我往下做，然后我又尝试了好几个不同的方法，最后还是觉得第一个不错，又回来改。
7-6 sdut-逆序的N位数
读入一个正整数（前后可能有空白字符—空格或者Tab字符），位数不限，然后输出按位逆序的数字。
注意：当输入的数字含有结尾的0时，输出不应带有前导的0。比如输入700，输出7。
输入格式:
输入一个正整数。
输出格式:
输出按位逆序的数。
输入样例1:
123456789
结尾无空行
输出样例1:
987654321
结尾无空行
输入样例2:
10000000
结尾无空行
输出样例2:
1
结尾无空行
# 方法一：
n = input()
n = n.strip()
n = n.strip('0')
if not n:
print(0)
else:
n = n[::-1]
print(n)
# 方法二：
n=int(input())
s1=""
if not n:
print(0)
else:
while n:
if s1=="" and n%10==0:
pass
else:
s1+=str(n%10)
n//=10
print(s1)
方法一和二是两种不同的思路
方法一其实有两个需要注意的地方，输入0和输入空格或者制表符，只输入这个三个的话返回的是空，但是对于平台来说这个答案是错误的，所以需要单独拿出来判断是否为空，答案部分错误的时候其实是其中的特殊情况有错误，其余的答案没有错。
对于方法二，也判断了整数时为空的情况，整数比字符串好一点，输入空格会直接报异常，下面的算法是利用模算法来让整数倒置。
其实对于这道题来说用数字型比较好，毕竟不需要考虑两种特殊情况（可能也是我比较笨的原因【