python练习题

一，冒泡排序

data=[11334,123,1,3,2,123,4324,435,46,57,768,87,89,79,79,9,79879,8979,799]
# 冒泡排序，将前一位元素和之后的元素进行比对，继续进行下一次循环
l=len(data)
for i in range(l):
    for j in range(l-1):
        if data[i] < data[j]:
            data[i],data[j] = data[j],data[i]
print(data)

二，判断水仙花数

水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153）

for i in range(2,1000):
    #先获取数的百位，十位和个位数，用他们的3次方和来判断是否等于数的本身
    #获取数的百位数int(i / 100)
    #获取数的十位数int(i / 10 % 10)
    #获取数的个位数int(i % 10)
    if (int(i / 100) ** 3) + (int(i / 10 % 10) ** 3) + (int(i % 10) ** 3) == i:
        print("{}:是水仙数".format(i))

三，回文数判断

回文数：从左往右和从右往左读都是一样的数

1，判断一定范围的回文数：

def huiwen(num):
    snum = str(num)
    lenth = len(snum)
    if lenth < 3 or lenth > 7:
        print('您输入的数据{}不在判断范围，请重新输入长度为3-7的数据'.format(num))
    if lenth == 3:
        if snum[0] == snum[-1]:
            print('{}:是回文数'.format(num))
        else:
            print('{}:不是回文数'.format(num))
    elif lenth == 4 or lenth == 5:
        if snum[0] == snum[-1] and snum[1] == snum[-2]:
            print('{}:是回文数'.format(num))
        else:
            print('{}:不是回文数'.format(num))
    elif lenth == 6 or lenth == 7:
        if snum[0] == snum[-1] and snum[1] == snum[-2] and snum[2] == snum[-3]:
            print('{}:是回文数'.format(num))
        else:
            print('{}:不是回文数'.format(num))


inputData = input("请输入数据:")
huiwen(inputData)

2，直接翻转字符串判断

def huiwen2(num):
    snum =str(num)
    if snum == snum[::-1]:
        print('{}是回文数'.format(snum))
    else:
        print('{}不是回文数'.format(snum))
inputData = input("请输入数据:")
huiwen2(inputData)

 四，实现斐波那契数列

斐波那契数列的定义：

斐波那契数列指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）

1，迭代实现

#首先定义斐波那契的前两个数据
fib = [1,1]
max=int(input("请输入一个整数:"))
for i in range(2,max):
    #fib的前两个数据之后相加等于下一个数据
    x = fib[i-1]+fib[i-2]
    fib.append(x)
print(fib)

2，递归实现

def diguiFib(num):
    if num <= 2:
        return 1
    else:
        return diguiFib(num - 1) + diguiFib(num - 2)
for i in range(1, 21):
    print(diguiFib(i), end=' ')

五：输出九九乘法口诀表

#输出99乘法口诀表
for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d==%d"%(j,i,i*j),end='  ')
    print()

 六，插入排序

插入排序的原理如下：

1. 将待排序列表的第一个元素当做已排序序列，第二个元素到最后一个元素当成未排序序列。

2. 取未排序序列中的第一个数据，插入到已排序序列中顺序正确的位置。将未排序的第一个数据与相邻的前一个数据(已排序序列的最后一个数)据进行比较，如果顺序错误则交换位置，交换位置后继续与相邻的前一个数据进行比较，直到不需要交换则插入完成。每次插入数据后，已排序序列都是排好序的。

3. 重复上一步，继续插入下一个数据。每进行一次插入，已排序序列的长度加1，未排序序列的长度减1，直到列表中的所有数据都插入到已排序序列了，则列表排序完成。

data = [1,23,4,45,566,7,889,90]
#1,将数据的第一个元素当做是已知的序列
for i in range(len(data)):
    #将未排序的第一个元素和之前的数据进行比较
    #相当于，抓一个牌
    tag = i
    while tag -1 >0 and data[tag-1] > data[tag]:
        #如果无序的小于有序的最后一个，则交换他两的位置，继续循环
        data[tag-1],data[tag] = data[tag],data[tag-1]
        #无序的牌的下标-1
        tag = tag-1
print(data)

 二分查找和线性查找：

二分查找的原理：

二分搜索是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

def erfen(data, dataLong,tag):
    #起始值
    left = 0
    #终止值
    right = dataLong - 1
    #如果起始值小于终止值，证明还有值，还需要继续查找
    while left <= right:
        #取出中间值的索引
        mid = (left + right) // 2
        #如果中间值的索引的值等于目标值则返回中间值的索引
        if data[mid] == tag:
            return mid
        # 如果中间值的索引的值大于目标值，则终止值等于中间值的索引-1
        elif data[mid] > tag:
            right = mid - 1
        # 如果中间值的索引的值小于目标值，则起始值等于中间值的索引+1
        elif data[mid] < tag:
            left = mid + 1
    else:
        return False

线性查找的原理：

直接一个个元素进行查找：

def lin_search(data,tag):
    #直接循环需要查找的数据
    for i in data:
        if i ==tag:
            #找到数据之后，拿到对应数据的索引值
            return data.index(i)
    else:
        return False
def inder_search(data,tag):
    #直接循环索引值，根据索引的值找到对应的数据
    for i in range(len(data)):
        if data[i] ==tag:
            return i
    else:
        return False
if __name__ == '__main__':
    data = [1, 2, 3, 4, 123, 5, 6, 7, 8, 9]
    #二分查找需要查找一个有序的序列
    data.sort()
    tag = 7
    dataLong = len(data)
    print(inder_search(data, 4))
    print(erfen(data,dataLong,tag))
    print(lin_search(data,3))