Python学习：基础练习题

1.输出0到100的数字，如果数字是3的倍数输出Fizz，5的倍数输出Buzz。

同时是3和5的倍数输出FizzBuzz，其他情况则打印原数字

for i in range(100):
    if i==0:
        print(i)
    elif i%3==0 and i%5==0:
        print("FizzBuzz")
    elif i%3==0:
        print("Fizz")
    elif i%5==0:
        print("Buzz")
    else:
        print(i)

ps：条件语句依次执行，满足第一个条件后不会执行下一个条件。所以同时满足3和5的需要放在上面。

2.根据输入的数字，打印相对应层数的等腰三角形星星塔

ps：先打印空格，空格数量：总层数-当前层数。再打印星星，星星数量：当前层数*2-1

num = int(input("输入一个数字:"))
for i in range(1,num+1):#外层循环定义 星星塔层数
    y = num-i#计算出空格要打印的次数
    print(" "*y,end="")#打印空行
    for j in range(1,2*i):#每行星星的数量
        print("*",end="")
    print()

如range（1,7），生成的数列是1到6，所以需要通过num+1的方式来控制层数

print()里end=””可以让打印时不换行

2*i是星星的数量，利用range()自动减一。-、

使用while循环实现

num = int(input("输入一个数字:"))
row=1
while row<=num:
    print(" "*(num-row)+"*"*(2*row-1))
    row+=1

row为层数，默认为第一层

num-row为空格数量

2*row-1位星星数量

3.有1,2,3,4四个数字，能组成多少个互不相同且不重复的三位数字

list = []
sum = 0
for i in range(1,5):
    for j in range(1,5):
        for k in range(1,5):
            if i!=j and j!=k and k!=i:
                num=i*100+j*10+k
                list.append(num)
                sum+=1
print(list)
print(sum)

三个数字可填在个十百位上，组成所有排列然后去掉重复的

4.递归返回None值

def get_op():
    str = input("请输入你的选择1/2/3/4:")
    try:
        no = int(str)
        if no not in[1,2,3,4]:
            print("请输入正确的运算符")
            get_op()    #这里前面应该加上return
        else:
            return no
    except ValueError as f:
        print("请输入正确的运算符")
        get_op()    #这里前面应该加上return

operator = get_op()
print(operator)

输出

请输入你的选择1/2/3/4:a
请输入正确的运算符
请输入你的选择1/2/3/4:11
请输入正确的运算符
请输入你的选择1/2/3/4:1
None

在做下面一题的时候，我如果直接输1到4是没有问题的，但是如果输入不是数字，或者不是1到4的数字，会返回None值

后来查了很多才发现。这样写递归调用后产生的值并没有return出来，要在递归函数调用前加上return。把值一层层传出去。

def get_op():
    str = input("请输入你的选择1/2/3/4:")
    try:
        no = int(str)
        if no not in[1,2,3,4]:
            print("请输入正确的运算符")
            return get_op()
        else:
            return no
    except ValueError as f:
        print("请输入正确的运算符")
        return get_op()

operator = get_op()
print(operator)

输出

请输入你的选择1/2/3/4:a
请输入正确的运算符
请输入你的选择1/2/3/4:22
请输入正确的运算符
请输入你的选择1/2/3/4:2
2

5.编写一个程序，提示“选择运算符”，输入“1/2/3/4”后，继续输入要进行运算的两个数字后，打印出运算结果

def add(n1,n2):
    value = n1+n2
    print("%d + %d = %d"%(n1,n2,value))

def minus(n1,n2):
    value = n1-n2
    print("%d - %d = %d"%(n1,n2,value))

def multiply(n1,n2):
    value = n1*n2
    print("%d * %d = %d"%(n1,n2,value))

def divide(n1,n2):
    value = n1/n2
    print("%d / %d = %d"%(n1,n2,value))

dict={1:add,2:minus,3:multiply,4:divide}

def get_op():
    str = input("请输入你的选择1/2/3/4:")
    try:
        no = int(str)
        if no not in dict:
            print("请输入正确的运算符")
            return get_op()#一定要return 递归，不然返回值是none
        else:
            return no
    except ValueError as f:
        print("请输入正确的运算符")
        return get_op()

def get_num1():
    str = input("输入第一个数：")
    try:
        num = int(str)
        return num
    except ValueError as f:
        print("请输入整数")
        return get_num1()

def get_num2():
    str = input("输入第二个数：")
    try:
        num = int(str)
        return num
    except ValueError as f:
        print("请输入整数")
        return get_num1()

print("选择运算：
1 is +
2 is -
3 is *
4 is /")
operator = get_op()
num1=get_num1()
num2=get_num2()
dict[operator](num1,num2)

ps：这个做了很久，一个是递归返回值的问题。还有一个通过字典存放函数指针。减少代码量

前四个是加减乘除的函数，然后存放到字段里，然后字典名[key](函数的参数)这样的形式调用。就不用写很多判断的代码。

6.冒泡排序，数组之间相邻值，两两进行比较。然后从大到小，或者从小到大排序

"""
学习中遇到问题没人解答？小编创建了一个Python学习交流群：711312441
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
"""
ls = [7,12,34,4,24,20,11]
for i in range(len(ls)-1):#外层决定比较的轮次
    for j in range(len(ls)-1-i):#多少个数进行两两比较
        if ls[j] < ls[j+1]:#两两比较大小  <是从大到小排序  >是从小到大排序
            ls[j],ls[j+1] = ls[j+1],ls[j]#互换位置

print(ls)

输出

[34, 24, 20, 12, 11, 7, 4]

数组的下标是从0开始的

从大到小排是找出最小的放到最后面，从小到大排是找出最大的放到最后面

ps：以上图从大到小排序为例。第一轮是7个数进行比较，然后比较出最小的值放在最后。然后第二轮比较前6个值。以此类推。剩下2个数的时候，一次比完。所以需要比的轮次是 数组的长度减去1 。每轮需要比较数量，第一轮是数组长度，之后每轮减1.

7.二分查询，对一个有序的数组进行查询，从数组中间取出一个值，和需要查询的值进行对比。

如果大于需要查询的值，则取左边一半继续进行二分查询。如果小于需要查询的值，则取右边一半继续进行二分查询。如果相同，则给出下标。没有提示没找到

使用循环实现

ls = [10,20,30]
def binary_search(alist,item):
    left =0 #下标最小值
    right = len(alist)-1   #下标最大值
    while left<=right:  #一定要有=，不然数组第一或最后一个无法查询到
        numb = int((left+right)/2)  #中间值的下标
        if item == alist[numb]: #相等直接返回下标
            return numb
        elif item > alist[numb]:    #查询的值大于数组中间值
            left = numb+1  #更新区间下标
        else:
            right = numb-1    #更新区间下标
    return None
s = binary_search(ls,20)
print(s)

left和right确定数组下标区间，找到中间值，比较大小后，根据升序还是降序的排序方式。来确定更换左边还是右边的下标。

一定要<= 因为数组最小或最大时，left=right

left一定要+1，不然会导致查询数组最大时，取中间值下标这步出现死循环

使用递归实现

ls = [10,20,30]
def binary_search(alist,item,left,right):
    if left > right:
        return None
    numb = int((left+right)/2) 
    if alist[numb] == item:
        return numb
    elif item > alist[numb]:  
        return binary_search(alist,item,numb+1,right)
    else:
        return binary_search(alist,item,left,numb-1)
s = binary_search(ls,10,0,3)
print(s)