python数据结构与数学算法实例(持续更新中)

1.1求最小公因数

基础版：

x=1#计算初始值，因为是求最小公因数
while True:
    if x % 12 == 0 and x %15 == 0:#根据最小公因数的含义，可得此判断条件
        break
    x+=1
print('12和15的最小公因数是{}'.format(x))

输出效果如下：

12和15的最小公因数是60！

进阶版：

a=int(input('请输入第一个数(按回车进入下个指令)：'))
b=int(input('请输入第二个数：(按回车进入下个指令)：'))
x=1#计算初始值，因为是求最小公因数
while True:
    if x % a == 0 and x % b == 0:#根据最小公因数的含义，可得此判断条件
        break
    x+=1
print('{}和{}的最小公因数是{}！'.format(a,b,x))

输出效果如下：

请输入第一个数(按回车进入下个指令)：14
请输入第二个数：(按回车进入下个指令)：28
14和28的最小公因数是28！

1.2平方计算之等效转换成加法原理运算

基础版：

x=4#乘法平方值
counts=0
times=x
while times!=0:
    counts+=x
    times=times-1
print(str(x)+'*'+str(x)+'='+str(counts))

进阶版：

x=int(input('请输入要计算的平方数(按回车进入下个指令)：'))#乘法平方值
counts=0
times=x
while times!=0:
    counts+=x
    times=times-1
print(str(x)+'*'+str(x)+'='+str(counts))

输出效果：

请输入要计算的平方数(按回车进入下个指令)：6
6*6=36

1.3穷举法求某个数的整数立方根while循环

这个程序使用的算法技术称为穷举法，是猜测与检验算法的一个变种。我们枚举所有可能性，直至得到正确答案或者尝试完所有值。乍看上去，这是一种极其愚蠢的解决方法。但令人惊奇的是，穷举法经常是解决问题的最实用的方法。它实现起来特别容易，并且易于理解。还有，在很多情况下，它的运行速度也足够快。
穷举法是一种查找技术，只在被查找集合中包含答案时才有效。

代码：

x=int(input('请输入一个数(按回车进入下个指令)：'))
counts=0
while counts**3 <abs(x):#x为其绝对值，可以用作正整数和负整数算法
    counts+=1#结果为整数立方根
if counts **3 != abs(x):#没有整数立方根时的情况
    print('x不存在立方根！')
else:
    if x<0:#
        counts=-counts
    print('x的立方根为{}!'.format(counts))

输出效果：

请输入一个数(按回车进入下个指令)：-27
x的立方根为-3

即使数本身很大也会很快运算完成，几乎无区别，因为现代计算机的速度真是太快了，它执行一条指令只需1纳秒——10亿分之1秒：

请输入一个数(按回车进入下个指令)：1957816251
x的立方根为1251!

1.4for中range循环的问题：

range函数的参数在循环的第一次迭代之前就已经被解释器求值，随后的迭代中不会再次求值，也就是说for in range循环开始前使用对应的值，不会在中间影响的。

x = 4 
for j in range(x): 
    for i in range(x):
        print(i)
        x = 2

输出效果：

0
1
2
3
0
1
0
1
0
1

进程已结束，退出代码 0

1.5寻找完全立方数的立方根for循环：

x=int(input('请输入一个数(按回车进入下个指令)：'))
for i in range(0,abs(x)+1):#x为其绝对值，可以用作正整数和负整数算法
    if i **3 >= abs(x):
        break
if i **3 != abs(x):
    print('x不存在立方根！')#没有整数立方根时的情况
else:
    if x < 0:
        i=-i
    print('x的立方根为{}!'.format(i))

输出效果：

请输入一个数(按回车进入下个指令)：-8
x的立方根为-2!

1.5使用穷举法求近似平方根

基础版：

x = 25
epsilon = 0.01#精度误差
step = epsilon**2
ans = 0.0
while abs(ans**2 - x) >= epsilon and ans <= x:
     ans += step
if abs(ans**2 - x) >= epsilon:
    print('非负数{}不存在近似平方根!'.format(x))
else:
    print('非负数{0}存在近似平方根为{1}'.format(x,ans))

进阶版：

x = int(input('请输入一个非负数(按回车进入下个指令)：'))
epsilon = eval(input('请输入一个非负精度数(按回车进入下个指令)：'))#精度误差，建议为0.01
step = epsilon**2
ans = 0.0
while abs(ans**2 - x) >= epsilon and ans <= x:
     ans += step
if abs(ans**2 - x) >= epsilon:
    print('非负数{}不存在近似平方根!'.format(x))
else:
    print('非负数{0}存在近似平方根为{1}'.format(x,ans))

输出效果：

请输入一个非负数(按回车进入下个指令)：49
请输入一个非负精度数(按回车进入下个指令)：0.01
非负数49存在近似平方根为6.999299999997026

1.6使用二分查找求近似平方根

x = 25
epsilon = 0.01#精度误差
low=0.0#区间左端点
high=max(0.0,x)#区间右端点
ans = (low+high)/2.0#取平均值

while abs(ans**2 - x) >= epsilon :
    print('low =', low, 'high =', high, 'ans =', ans)#打印二分值过程
    if ans**2  < x:
        low=ans
    else:
        high=ans
    ans = (low + high) / 2
print('非负数{0}存在近似平方根为{1}'.format(x,ans))

输出效果：

low = 0.0 high = 25 ans = 12.5
low = 0.0 high = 12.5 ans = 6.25
low = 0.0 high = 6.25 ans = 3.125
low = 3.125 high = 6.25 ans = 4.6875
low = 4.6875 high = 6.25 ans = 5.46875
low = 4.6875 high = 5.46875 ans = 5.078125
low = 4.6875 high = 5.078125 ans = 4.8828125
low = 4.8828125 high = 5.078125 ans = 4.98046875
low = 4.98046875 high = 5.078125 ans = 5.029296875
low = 4.98046875 high = 5.029296875 ans = 5.0048828125
low = 4.98046875 high = 5.0048828125 ans = 4.99267578125
low = 4.99267578125 high = 5.0048828125 ans = 4.998779296875
low = 4.998779296875 high = 5.0048828125 ans = 5.0018310546875
非负数25存在近似平方根为5.00030517578125

1.7利用牛顿-拉弗森法寻找近似平方根

牛顿证明了一个定理：如果存在一个值guess是多项式p的根的近似值，那么guess -p(guess)/p’(guess)就是一个更好的近似值，其中p’是p的一次导数。
提示：比较牛顿-拉弗森法和二分查找法的效率，会发现牛顿-拉弗森法效率更高。

epsilon = 0.01#精度
x = 24.0
guess = x/2.0#初始值
while abs(guess**2 - x) >= epsilon:
    guess = guess - (((guess**2) - x)/(2*guess))#牛顿－拉弗森法定理使用表示
print('非负数{0}存在近似平方根为{1}'.format(x,guess))

输出效果：

非负数24.0存在近似平方根为4.8989887432139305

1.8乘法阶乘

(1)迭代版

def facts(n):#递归算法，假设n是正整数
    result=1
    while n >1:
        result=result*n
        n-=1
    return result
#以下为调用函数
n=int(input('请输入阶乘数：(按回车进入下个指令)：'))
counts=facts(n)
print(counts)

(2)递归版

def facts(n):#递归算法，假设n是正整数
    if n == 1:#递归基例
        return n
    else:
        return n*facts(n-1)#递归链条
#以下为调用函数
n=int(input('请输入阶乘数：(按回车进入下个指令)：'))
counts=facts(n)
print(counts)

输出效果：

请输入阶乘数：(按回车进入下个指令)：4
24

1.9斐波那契数列的递归实现

斐波那契数列是另一个经常使用递归方式定义的常用数学函数。1202年，意大利数学家比萨的列奥纳多（也称为斐波那契）得出了一个公式，用来计算兔子的繁殖情况。
问题如下：
假设一对新生的兔子被放到兔栏中（更坏的情况是放到野外），一只是公兔，一只是母兔。再假设兔子在一个月大时就可以交配（令人惊奇的是，有些品种确实可以），并有一个月的妊娠期（令人惊奇的是，有些品种确实如此）。最后，假设这些神话般的兔子永远不死，并且母兔从第二个月之后每月都能产下一对小兔（一公一母）。那么6个月后，会有多少只母兔？

使用简单迭代实现会更好。

def facts(n):#递归算法，假设n是正整数
    if n == 0 or n == 1:#根据算法调整基例条件
        return 1
    else:
        return facts(n-1) + facts(n-2)
#以下为调用函数
n=int(input('请输入经过多少个月：(按回车进入下个指令)：'))
counts=facts(n)
print('经过{0}个月后数量会变成{1}个'.format(n,counts))

输出效果：

请输入经过多少个月：(按回车进入下个指令)：5
经过5个月后数量会变成8个

2.0回文检测

基础版（递归使用）：

def doPalindrome(s):#回文处理主函数
    def dochars(s):#辅助函数，用于处理过滤字符串
        words=''
        s=s.lower()
        for i in s:
            if i in 'abcdefghijklmnopqrstuvwxyz':
                words = words + i
        return  words
    def checkPalindrome(s):#辅助函数，用于判断是否为回文
        if len(s) <= 1:
            return True
        else:
            return s[0] == s[-1] and checkPalindrome(s[1:-1])
    return checkPalindrome(dochars(s))
s=input('请输入所要检测的字符串(按回车进入下个指令)：')
results=doPalindrome(s)
if results == True:
    print('该字符串为回文！')
else:
    print('该字符串不是回文！')

输出效果：

请输入所要检测的字符串(按回车进入下个指令)：ABBA
该字符串为回文！

进阶版：

def doPalindrome(s):#回文处理主函数
    def dochars(s):#辅助函数，用于处理过滤字符串
        words=''
        s=s.lower()
        for i in s:
            if i in 'abcdefghijklmnopqrstuvwxyz':
                words = words + i
        return  words
    def checkPalindrome(s):#辅助函数，用于判断是否为回文
        return s[::1] == s[::-1]
    return checkPalindrome(dochars(s))
s=input('请输入所要检测的字符串(按回车进入下个指令)：')
results=doPalindrome(s)
if results == True:
    print('该字符串为回文！')
else:
    print('该字符串不是回文！')

输出效果：

请输入所要检测的字符串(按回车进入下个指令)：ABCBA
该字符串为回文！

2.1克隆列表

注意：在for循环中，Python使用一个内置计数器跟踪程序在列表中的位置，内部计数器在每次迭代结束时都会增加1。当计数器的值等于列表的当前长度时，循环终止。如果循环过程中列表没有发生改变，那么这种机制是有效的，但如果列表发生改变，就会产生出乎意料的结果。

（1）无克隆：

L1 = [1,2,3,4]
L2 = [1,2,5,6]
A=L1
for i in A:
    if i in L2:
        L1.remove(i)
print(L1)

输出效果：

[2, 3, 4]

（2）已经克隆：

L1 = [1,2,3,4] 
L2 = [1,2,5,6]
for i in L1[:]:#对列表进行切片操作
    if i in L2:
        L1.remove(i)
print(L1)

输出效果：

[3, 4]

2.2利用字典实现简单的英法-法英翻译程序

Ewords= {'bread':'pain', 'wine':'vin', 'with':'avec', 'I':'Je',
        'eat':'mange', 'drink':'bois', 'John':'Jean',
        'friends':'amis', 'and': 'et', 'of':'du','red':'rouge'}#英译法数据字典
Fwords= {'pain':'bread', 'vin':'wine', 'avec':'with', 'Je':'I',
        'mange':'eat', 'bois':'drink', 'Jean':'John',
        'amis':'friends', 'et':'and', 'du':'of', 'rouge':'red'}#法译英数据字典
dicts = {'English to French':Ewords, 'French to English':Fwords}#一个选择译法的字典，供translateword参数选择译法
def translateword(words, dictionary):#翻译单个词的函数
    if words in dictionary.keys():#翻译词
        return dictionary[words]
    return words#如果为句子符号或者超出程序能力范围内的词，则保留返回

def translate(sentences,dicts,languages):#主函数
    Big='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    Small= 'abcdefghijklmnopqrstuvwxyz'
    strs=Big+Small#英文和法文都为字母组成，可用作判断是否为单个词的条件
    words=''
    dictionary=dicts[languages]
    translations=''
    for i in sentences:
        if i in strs:
            words=words+i#返回单个词
        else:
            translations=translations+translateword(words,dictionary)+i#返回翻译后的内容
            words=''#将对象内容清空，留给下个词储存字符
    return translations
a=translate('I drink good red wine, and eat bread.', dicts,'English to French')
b=translate('Je bois du vin rouge.', dicts, 'French to English')
print(a)
print(b)

输出效果：

Je bois good rouge vin, et mange pain.
I drink of wine red.

2.3输入内容类型检查

（1）基础版：

while True:
    vals=input('请输入一个整数：')
    try:
        vals=int(vals)
        print('你输入的数字为:{}'.format(vals))
        break#满足整数条件跳出循环
    except ValueError:#类型错误响应
        print('你输入的不是数字！请重新输入！')

输出效果：

请输入一个整数：abc
你输入的不是数字！请重新输入！
请输入一个整数：9
你输入的数字为:9

（2）多处重复输入使用：

def inputInt():
    while True:
        vals = input('请输入一个整数：')
        try:
            return int(vals)
        except ValueError:  # 类型错误响应
            print('你输入的不是数字！请重新输入！')
inputInt()

（3）多处重复输入使用和类型，提示信息选择：

def intVal(valType, reMsg, errorMsg):#对应数据类型，输入内容提示，错误提示参数
    while True:
        vals = input(reMsg)
        try:
            return valType(vals)
        except ValueError:  # 类型错误响应
            print(errorMsg)
intVal(int,'请输入整数类型内容：','你输入的不是整数类型，请重新输入！')

输出效果：

请输入整数类型内容：a
你输入的不是整数类型，请重新输入！
请输入整数类型内容：7