Python 思惟锻炼

时间 2019-11-06

标签 python 思惟锻炼栏目 Python 繁體版

原文原文链接

程序1：数字组合

【程序描述】

有四个数字：一、二、三、4，能组成多少个互不相同且无重复数字的三位数？各是多少？html

【程序分析】

可填在百位、十位、个位的数字都是一、二、三、4。组成全部的排列后再去掉不知足条件的排列。python

【程序实现】

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 i!=k:
                      print(i,j,k)

【程序结果】

程序2：猜猜这个数是多少？

【程序描述】

一个整数，它加上100和加上268后都是一个彻底平方数，请问该数是多少？git

【程序分析】

在10000之内判断，将该数i加上100后再开方，加上268后再开方，若是开方后的结果知足以下条件，便是结果。github

xx =（i+100）算法

yy=（i+268）编程

【程序实现】

import math

for i in range(1,10000):
        x=int(math.sqrt(i+100))
        y=int(math.sqrt(i+268))
        if (x*x==i+100)and(y*y==i+268):
             print(i)

【程序结果】

程序3：判断这是一年中的第几天？

【程序描述】

输入某年某月某日，判断这一天是这一年的第几天？api

【程序分析】

以3月5日为例，应该先把前两个月的加起来，而后再加上5天即本年的第几天，特殊状况，闰年且输入月份大于2时需考虑多加一天。app

【程序实现】

year=int(input("请输入年份"))
    month=int(input("请输入月份"))
    day=int(input("请输入日期"))
    months=(0,31,59,90,120,151,181,212,243,273,304,334)
    if 0<month<=12:
       sum=months[month-1]
    else:
        print('输入的月份有误')
    sum+=day
    leap=0
    if (year%400==0) or ((year%4==0) and (year%100!=0)):
        leap=1
        if(leap==1)and(month>2):
             sum+=1
    print("今天是第%d天"%sum)

【程序结果】

请输入年份2000

请输入月份3

请输入日期1

今天是第61天

程序4：判断整数大小

【程序描述】

输入三个整数x,y,z，请把这三个数由小到大输出。dom

【程序分析】

能够借助列表的sort方法完成排序。首先将用户输入的整数存放在列表中，列表从小到大排序后，经过遍历的方式输出列表中的值便可。ide

【程序实现】

x = int(input("请输入进行比较的第1个数："))
y = int(input("请输入进行比较的第2个数："))
z = int(input("请输入进行比较的第3个数："))

list = [x, y, z]
list.sort()
for i in range(len(list)):
    print(list[i])

【程序结果】

请输入进行比较的第1个数：34

请输入进行比较的第2个数：23

请输入进行比较的第3个数：55

23

34

55

程序5：斐波那契数列

【程序描述】

编写一个程序，实现斐波那契数列。

【程序分析】

斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：0、一、一、二、三、五、八、1三、2一、3四、……。

在数学上，费波那契数列是以递归的方法来定义：

F0 = 0 (n=0)

F1 = 1 (n=1)

Fn = F[n-1]+ F[n-2](n=>2)

【程序实现】

 def fib(n):
     if n==1 or n==2:
        return 1
     return fib(n-1)+fib(n-2)

print(fib(10))

【程序结果】

程序6：水仙花数

【程序描述】

编写程序，打印出全部的“水仙花数” 。

【程序分析】

所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数自己。例如：153是一个“水仙花数”，由于153=1的三次方＋5的三次方＋3的三次方。

【程序实现】

for i in range(100,1000):
        a=int(i/100)
        b=int(i/10)%10
        c=i%10
        if i==a**3+b**3+c**3:
             print(i)

【程序结果】

程序7：数字求和

【程序描述】

编写一个程序，经过用户输入两个数字，并计算这两个数字之和。

【程序分析】

根据程序描述，该程序实现过程大概分为以下几步：

提示用户输入第1个数字
提示用户输入第2个数字
对两个数字进行相加
输出两个数字相加的和

【程序实现】

num1 = input("请输入第1个数字：")
num2 = input("请输入第2个数字：")
sum = float(num1) + float(num2)
print("数字%s和%s相加之和是%.1f" % (num1, num2, sum))

【程序结果】

请输入第1个数字：12.3

请输入第2个数字：10.4

数字12.3和10.4相加之和是22.7

程序8：平方根

【程序描述】

平方根，又叫二次方根，表示为〔√￣〕，如：数学语言为：√￣16=4。语言描述为：根号下16=4。编写一个程序，经过用户输入一个数字，并计算这个数字的平方根。

【程序分析】

关于计算平方根的，可使用在指数运算符 ** 来计算改数的平方根，也可使用math函数中的sqrt，不一样的是，指数**只适用于正数，而sqrt适用于任何数。接下来，按照下列步骤实现程序：

提示用户输入一个数(必须将输入的数转为数字类型）
使用math函数的sqrt计算这个数的平方根
输出运算结果

【程序实现】

import math

num = int(input("请输入要计算平方根的数字："))
result = math.sqrt(num)
print("数字%d的平方根是%f" % (num, result))

【程序结果】

请输入要计算平方根的数字：12

数字12的平方根是3.464102

程序9：if语句

【程序描述】

编写程序，经过使用 if...elif...else 语句判断数字是正数、负数或零：

【程序分析】

正数、负数或零的判断很是简单，只须要判断这个数是否大于零，小于零或者等于零。因为判断的条件大于2个，这里咱们使用if…elif…else判断。

【程序实现】

num = float(input("输入一个数字: "))
    if num > 0:
        print("正数")
    elif num == 0:
        print("零")
    else:
        print("负数")

【程序结果】

输入一个数字: -2

负数

程序10：阿姆斯特朗数

【程序描述】

若是一个n位正整数等于其各位数字的n次方之和,则称该数为阿姆斯特朗数。例如1^3 + 5^3 + 3^3 = 153。

1000之内的阿姆斯特朗数： 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407。

请编写程序，检测用户输入的数字是否为阿姆斯特朗数。

【程序分析】

n位正整数等于其各位数字的n次方之和

【程序实现】

# 获取用户输入的数字

num = int(input("请输入一个数字: "))

# 初始化变量 sum

sum = 0

# 指数

n = len(str(num))

# 检测

temp = num

while temp > 0:

   digit = temp % 10

   sum += digit ** n

   temp //= 10

# 输出结果

if num == sum:

   print(num,"是阿姆斯特朗数")

else:

   print(num,"不是阿姆斯特朗数")

【程序结果】

请输入一个数字: 12

12 不是阿姆斯特朗数

或者

请输入一个数字: 153

153 是阿姆斯特朗数

程序11：输出指定范围的素数（else语句）

【程序描述】

素数（prime number）又称质数，有无限个。除了1和它自己之外再也不被其余的除数整除。请编写一个程序，输出指定范围内的素数：

【程序分析】

由程序描述可知，要想输出指定范围的素数，能够按照下列步骤开发：

提示用户输入指定的范围，分别是范围的最小值和最大值
使用for循环在指定范围内进行循环
因为知足素数的条件是只能被1和自己整除，因此可使用if语句判断是否能整除，若是能，则输出素数。

【程序实现】

lower = int(input("输入区间最小值: "))

upper = int(input("输入区间最大值: "))

for num in range(lower,upper + 1):

# 素数大于 1

if num > 1:

    for i in range(2,num):

        if (num % i) == 0:

            break

    else:

            print(num)

【程序结果】

输入区间最小值: 2

输入区间最大值: 50

2

3

5

7

11

13

17

19

23

29

31

37

41

43

47

程序12：生成日历

【程序描述】

请编写程序，用于生成指定日期的日历。

【程序分析】

Calendar模块有很普遍的方法用来处理年历和月历，例如打印某月的月历。

【程序实现】

# 引入日历模块
    import calendar
    # 输入指定年月
    yy = int(input("输入年份: "))
    mm = int(input("输入月份: "))
    # 显示日历
    print(calendar.month(yy,mm))

【程序结果】

输入年份: 2017

输入月份: 3

     March 2017

Mo Tu We Th Fr Sa Su

        1  2  3  4  5

 6  7  8  9 10 11 12

13 14 15 16 17 18 19

20 21 22 23 24 25 26

27 28 29 30 31

程序13：统计字符串中的字符

【程序描述】

输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

【程序分析】

开发步骤以下：

提示用户输入字符串
声明四个变量，分别用于统计英文字母、空格、数字和其余字符的个数
使用for循环遍历字符串中的字符，使用if判断语句判断遍历的字符知足哪一个条件，若是知足条件，则对应的变量加1

【程序实现】

str = input("请输入一个字符串：")
letters = 0
space = 0
digit = 0
others = 0
for c in str:
    if c.isalpha():
        letters += 1
    elif c.isspace():
        space += 1
    elif c.isdigit():
        digit += 1
    else:
        others += 1
print("字符串共有%d个英文字母，%d个空格，%d个数字，%d个其余字符" % (letters, space, digit, others))

【程序结果】

请输入一个字符串:hello world,i love you!

字符串共有18个英文字母，3个空格，0个数字，2个其余字符

程序14：文件的读取

【程序描述】

从键盘输入一个字符串，将小写字母所有转换成大写字母，而后输出到一个磁盘文件"test"中保存。

【程序分析】

开发步骤以下：

提示用户输入一个字符串
使用字符串的upper方法将字符串的小写字母所有转换为大写字母
使用write方法将字符串写入文件，须要注意的是，在写文件以前，首先要打开文件，完成写数据的操做后，要切记关闭文件。

【程序实现】

    fp = open('test.txt','w')
    string = input('please input a string:\n')
    string = string.upper()
    fp.write(string)
    fp = open('test.txt','r')
    print(fp.read())
    fp.close()

【程序输出】

please input a string:

Nice to meet you!

NICE TO MEET YOU!

程序15：十进制转二进制、八进制、十六进制

【程序描述】

编写程序，用于实现十进制转二进制、八进制、十六进制。

【程序分析】

不一样进制之间的转换，须要用到下列方法：

bin()：将十进制的数转为二进制
oct()：将十进制的数转为八进制
hex(): 将十进制的数转为十六进制

【程序实现】

# 获取用户输入十进制数

dec = int(input("输入数字："))

print("十进制数为：", dec)

print("转换为二进制为：", bin(dec))

print("转换为八进制为：", oct(dec))

print("转换为十六进制为：", hex(dec))

【程序结果】

输入数字：123

十进制数为： 123

转换为二进制为： 0b1111011

转换为八进制为： 0o173

转换为十六进制为： 0x7b

程序16：生成10个两位的随机素食

【程序描述】

请编写一个程序，输出生成10个两位的随机数，而且这两个随机数是素数。

【程序分析】

Python的random模块提供了随机数生成方法random.randint(a,b),它返回一个大于等于a，小于等于b的随机整数。

【程序实现】

import random

n = 0
while n < 10:
    x = random.randint(10, 99)  # 得到两位的随机整数
    # 判断x是否为素数
    a = 2
    while a < x - 1:
        if x % a == 0:
            break
        a += 1
    else:
        print(x)  # 若正常结束循环时，说明x是素数，输出
    n += 1  # 累计素数个数

【程序结果】（每次结果不同）

程序17：计算三角形面积

【程序描述】

经过用户输入三角形三边长度，并计算三角形的面积。

【程序分析】

要想计算三角形的面积，须要获取三角形的三边长度，假设三角形的三边分别是a，b，c，那么面积的计算方式以下：

三角形半周长s=(a+b+c)/2

三角形面积=(s*(s-a)*(s-b)*(s-c)) ** 0.5

【程序实现】

a = float(input('输入三角形第一边长: '))
    b = float(input('输入三角形第二边长: '))
    c = float(input('输入三角形第三边长: '))
    # 计算半周长
    s = (a + b + c) / 2
    # 计算面积
    area = (s*(s-a)*(s-b)*(s-c)) ** 0.5
    print('三角形面积为 %0.2f' %area)

【程序结果】

输入三角形第一边长: 12

输入三角形第二边长: 23

输入三角形第三边长: 21

三角形面积为 125.22

程序18：字符串大小写转换

【程序描述】

如何将字符串转换为大写字母，或者将字符串转为小写字母等。

【程序分析】

字符串str提供了不少转换字母的方法，具体以下：

upper():将全部字符中的小写字母转换为大写字母
lower()：把全部字符中的大写字母转为小写字母
capitalize()：把第一个字母转化为大写字母，其他小写
title()：把每一个单词的第一个字母转化为大写，其他小写

【程序实现】

    str = "www.runoob.com"
    print(str.upper())          # 把全部字符中的小写字母转换成大写字母
    print(str.lower())          # 把全部字符中的大写字母转换成小写字母
    print(str.capitalize())     # 把第一个字母转化为大写字母，其他小写
    print(str.title())          # 把每一个单词的第一个字母转化为大写，其他小写

【程序结果】

WWW.RUNOOB.COM

www.runoob.com

Www.runoob.com

Www.Runoob.Com

程序19：获取昨天日期

【程序描述】

经过导入 datetime 模块来获取昨天的日期。

【程序分析】

【程序实现】

# 引入 datetime 模块
    import datetime
    def getYesterday():
        today=datetime.date.today()
        oneday=datetime.timedelta(days=1)
        yesterday=today-oneday
        return yesterday
    # 输出
    print(getYesterday())

【程序结果】

2018-08-02

程序20：变量交换

【程序描述】

编写一个程序，将用户输入的两个变量进行相互交换。要求不使用临时变量实现。

【程序分析】

与其余语言不一样，Python中的变量能够经过下列方式进行赋值：

x,y = y,x

上述代码的做用就是将x的值赋给y，将y的值赋给x，即x和y值的互换。

【程序实现】

# 用户输入

x = input('输入 x 值: ')

y = input('输入 y 值: ')

# 不使用临时变量

x,y = y,x

print('交换后 x 的值为: {}'.format(x))

print('交换后 y 的值为: {}'.format(y))

【程序结果】

输入 x 值: 3

输入 y 值: 4

交换后 x 的值为: 4

交换后 y 的值为: 3

程序21：质数判断

【程序描述】

一个大于1的天然数，除了1和它自己外，不能被其余天然数（质数）整除（2, 3, 5, 7等），换句话说就是该数除了1和它自己之外再也不有其余的因数。

【程序实现】

# 用户输入数字
num = int(input("请输入一个数字："))
# 质数大于1
if num > 1:
    # 查看因子
    for i in range(2, num):
        if (num % i) == 0:
            print(num,"不是质数")
            break
        else:
            print(num,"是质数")
# 若是输入的数字小于或等于1，不是质数
else:
    print(num, "不是质数")

【程序结果】

请输入一个数字: 12

12 不是质数

程序22：简单计算器

【程序描述】

编写一个程序，实现简单计算器实现，包括两个数基本的加减乘除运算。

【程序分析】

简单计算器的开发流程以下：

打印菜单，提示用户选择要进行的运算

用户选择运算类型

接收用户输入的值，用于参与运算

输出运算的结果

须要注意的是，因为接受的用户输入是字符串，须要将字符串转为数值类型

【程序实现】

# 定义函数
def add(x, y):
    """相加运算"""
    return x + y


def subtract(x, y):
    """相减运算"""
    return x - y


def multiply(x, y):
    """相乘运算"""
    return x * y


def divide(x, y):
    """相除运算"""
    return x / y


# 用户输入
print("请选择运算：")
print("一、相加")
print("二、相减")
print("三、相乘")
print("四、相除")

choice = input("请输入你的选择（1/2/3/4）：")
num1 = int(input("输入第一个数字："))
num2 = int(input("请输入第二个数字："))
if choice == "1":
    print(num1, "+", num2, "=", add(num1, num2))
elif choice == "2":
    print(num1, "-", num2, "=", subtract(num1, num2))
elif choice == "3":
    print(num1, "*", num2, "=", multiply(num1, num2))
elif choice == "4":
    print(num1,"/",num2,"=", divide(num1,num2))
else:
    print("非法输入")

【程序结果】

加法运算：

选择运算：

一、相加

二、相减

三、相乘

四、相除

输入你的选择(1/2/3/4):1

输入第一个数字: 2

输入第二个数字: 3

2 + 3 = 5

减法运算：

选择运算：

一、相加

二、相减

三、相乘

四、相除

输入你的选择(1/2/3/4):2

输入第一个数字: 5

输入第二个数字: 1

5 - 1 = 4

乘法运算：

选择运算：

一、相加

二、相减

三、相乘

四、相除

输入你的选择(1/2/3/4):3

输入第一个数字: 2

输入第二个数字: 5

2 * 5 = 10

除法运算：

选择运算：

一、相加

二、相减

三、相乘

四、相除

输入你的选择(1/2/3/4):4

输入第一个数字: 10

输入第二个数字: 2

10 / 2 = 5.0

程序23：最大公约数

【程序描述】

编写一个程序，计算两个数的最大公约数。

【程序实现】

# 定义一个函数
def hcf(x, y):
    """该函数返回两个数的最大公约数"""
    # 获取最小值
    if x > y:
        smaller = y
    else:
        smaller = x
    for i in range(1, smaller + 1):
        if ((x % i == 0) and (y % i == 0)):
            hcf = i
    return hcf


# 用户输入两个数字
num1 = int(input("输入第一个数字："))
num2 = int(input("输入第二个数字："))
print(num1, "和", num2, "的最大公约数为", hcf(num1, num2))

【程序结果】

输入第一个数字: 12

输入第二个数字: 3

12 和 3 的最大公约数为 3

程序24：最小公倍数

【程序描述】

编写一个程序，计算两个数的最小公倍数。

【程序实现】

# 【程序描述】
#             编写一个程序，计算两个数的最小公倍数。

# 定义函数
def lcm(x, y):
    # 获取最大的数
    if x > y:
        greater = x
    else:
        greater = y
    while (True):
        if ((greater % x == 0) and (greater % y == 0)):
            lcm = greater
            break
        greater += 1
    return lcm


# 获取用户输入
num1 = int(input("输入第一个数字："))
num2 = int(input("输入第二个数字："))

print(num1, "和", num2, "的最小公倍数为", lcm(num1, num2))

【程序结果】

输入第一个数字: 12

输入第二个数字: 2

12 和 2 的最小公倍数为 12

程序25：字符串判断

【程序描述】

编写一个程序，演示Python字符串中和判断有关的方法的使用。

【程序分析】

字符串中常见的判断操做的方法以下所示：

isalnum(): 判断全部字符都是数字或者字母
isalpha(): 判断全部字符都是字母
isdigit():判断全部字符都是数字
islower():判断全部字符都是小写
isupper():判断全部字符都是大写
istitle():判断全部单词都是首字母大写，像标题
isspace():判断全部字符都是空白字符、\t、\n、\r

【程序实现】

print("示例1：")
str = "www.github.com"
# 判断全部字符都是数字或者字母
print(str.isalnum())
# 判断全部字符都是数字
print(str.isalpha())
# 判断全部字符都是数字
print(str.isdigit())
# 判断全部字符都是小写
print(str.islower())
# 判断全部字符都是大写
print(str.isupper())
# 判断全部单词都是首字母大写，像标题
print(str.istitle())
# 判断全部字符都是空白字符- \t ，\n , \r
print(str.isspace())
print("---------")
print("\n")
print("---------")
print("示例2：")
str = "oschina "
print(str.isalnum())
print(str.isalpha())
print(str.isdigit())
print(str.islower())
print(str.isupper())
print(str.istitle())
print(str.isspace())

【程序结果】

示例1：
False
False
False
True
False
False
False
---------

---------
示例2：
False
False
False
True
False
False
False

程序26：合并文件数据

【程序描述】

有两个磁盘文件A和B,各存放一行字母,要求把这两个文件中的信息合并(按字母顺序排列), 输出到一个新文件C中。

【程序实现】

fp = open("file1.txt")
r1 = fp.read()
fp.close()

fp = open("file2.txt")
r2 = fp.read()
fp.close()

fp = open("file3.txt", "w")
merge = list(r1 + r2)
merge.sort()
s = ""
s = s.join(merge)
fp.write(s)
fp.close()

【程序结果】

假设file1.txt文件中存放的是hello，file2.txt文件中存放的是world，那么程序运行后，file3.txt文件中的数据是：dehllloorw

程序27：猜数游戏

【程序描述】

编写一个猜数游戏，该游戏会随机产生一个数字，用户能够随意输入一个数进行比较，在比较过程当中，会不断提示用户输入的数是大了仍是小了，直到用户输入的数等于随机数，程序终止。

【程序实现】

import time
import random

play_it = input("Do you want to play it.(\'y\'or\'n\')")

while play_it == "y":
    c = input("input a character.\n")
    i = random.randint(0, 2 ** 32) % 100
    print("Please input number you guess:\n")
    start = time.clock()  # Python time clock() 函数以浮点数计算的秒数返回当前的CPU时间。用来衡量不一样程序的耗时，比time.time()更有用
    a = time.time()
    guess = int(input("input your guess:\n"))
    while guess != i:
        if guess > i:
            print("Please input a little smaller")
            guess = int(input("input your guess:\n"))
        else:
            print("Please input a little bigger.")
            guess = int(input("input your guess:\n"))
    end = time.clock()
    b = time.time()
    var = (end - start) / 18.2
    print(var)
    if var < 15:
        print("you are very clever!")
    elif var < 25:
        print("you are normal!")
    else:
        print("you are stuplid!")
    print("Congradulations")
    print("The number you guess id %d" % i)
    play_it = input("do you want to play it.")

【程序结果】

do you want to play it.('y' or 'n')y

input a character:

please input number you guess:

input your guess:

……

please input a little bigger

input your guess:

please input a little smaller

input your guess:

3.81868131868e-05

you are very clever!

Congradulations

The number you guess is 28

do you want to play it.

程序28：为数据加密

【程序描述】

某个公司采用公用电话传递数据，数据是四位的整数，在传递过程当中是加密的，加密规则以下：每位数字都加上5,而后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。

【程序实现】

from sys import stdout

a = int(input("input a number:\n"))
aa = []
aa.append(a % 10)
aa.append(a % 100 / 10)
aa.append(a % 1000 / 100)
aa.append(a / 1000)
for i in range(4):
    aa[i] += 5
    aa[i] %= 10
for i in range(2):
    aa[i], aa[3 - i] = aa[3 - i], aa[i]
for i in range(3, -1, -1):
    stdout.write(str(aa[i]))

【程序结果】

input a number:

76.25.125.012

程序29：平方运算

【程序描述】

编写程序，求输入数字的平方，若是平方运算后小于 50 则退出。

【程序实现】

TRUE = 1
FALSE = 0


def SQ(x):
    return x * x
print("若是输入的数字小于50，程序将中止运行。")
again = 1
while again:
    num = int(input("Please input number."))
    print("运算结果为 %d" %(SQ(num)))
    num = SQ(num)
    if num >= 50:
        again = TRUE
    else:
        again = FALSE

【程序结果】

若是输入的数字小于 50，程序将中止运行。

Please input number12

运算结果为 144

Please input number12

运算结果为 144

Please input number3

运算结果为 9

程序30：计算0-7组成的奇数个数

【程序描述】

编写一个程序，计算0—7所能组成的奇数个数。

【程序实现】

# 规律：这是规律：个位数一、三、五、7：是4个十位数是7*4：28个（十一、13...77）百位数是：7*4*8：224个7*4*8*8

sum = 4
s = 4
for j in range(2, 9):
    print(sum)
    if j <= 2:
        s *= 7
    else:
        s *= 8
    sum += s
print("sum = %d" % sum)

【程序结果】

256

2048

16384

131072

1048576

sum = 8388608

程序31：求值

【程序描述】

809*??=800*??+9*??+1 其中??表明的两位数,8*??的结果为两位数，9*??的结果为3位数。求??表明的两位数，及809*??后的结果。

【程序实现】

a = 809
for i in range(10, 100):
    b = i * a + 1
    if b >= 1000 and b <= 10000 and 8 * i < 100 and 9 * i >= 100:
        print(b, "/", i, "= 809 * ", i, " + ", b % i)

【程序结果】

9709 / 12 = 809 * 12 + 1

程序32：猴子分桃

【程序描述】

海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分红五份，又多了一个，它一样把多的一个扔入海中，拿走了一份，第3、第4、第五只猴子都是这样作的，问海滩上原来最少有多少个桃子？

【程序实现】

i = 0
j = 1
x = 0
while (i < 5):
    x = 4 * j
    for i in range(0, 5):
        if (x % 4 != 0):
            break
        else:
            i += 1
        x = (x / 4) * 5 + 1
    j += 1
print(x)

【程序结果】

3121.0

程序33：淘汰游戏

【程序描述】

有n我的围成一圈，顺序排号。从第一我的开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。

【程序实现】

nmax = 50
n = int(input("请输入总人数："))
num = []
for i in range(n):
    num.append(i + 1)
i = 0
k = 0
m = 0
while m < n - 1:
    if num[i] != 0:
        k += 1
    if k == 3:
        num[i] = 0
        k = 0
        m += 1
    i += 1
    if i == n:
        i = 0
i = 0
while num[i] == 0:
    i += 1
print(num[i])

【程序结果】

请输入总人数:23

程序34：分解质因子

【程序描述】

编写一个程序，用于对一个数进行分解质因子。

【程序实现】

n = int(input("Please input n:"))
result = []
i = 2
str1 = str(n) + "="
while n > 1:
    if n % i == 0:
        n /= i
        result.append(str(i))
        i -= 1
    i += 1
# Python join() 方法用于将序列中的元素以指定的字符链接生成一个新的字符串。
str1 += "*".join(result)
print(str1)

【程序结果】

please input n:16

16=2*2*2*2

程序35：取整数右端的4~7位

【程序描述】

编写程序，取一个整数a从右端开始的4〜7位。

【程序分析】

能够这样考虑：

(1)先使a右移4位。

(2)设置一个低4位全为1,其他全为0的数。可用~(~0<<4)

(3)将上面两者进行&运算。

【程序实现】

a = int(input("input a number:\n"))
b = a >> 4
c = ~(~0 << 4)
d = b & c
print("%o\t%o" % (a, d))

【程序结果】

input a number:

11 0

程序36：判断4位回文数

【程序描述】

用户输入一个4位的整数，若是是回文数显示True，若是不是回文数显示False。

【程序分析】

回文数，就是反过来的数字和正着的数字是相同的，如1221，倒过来的数仍是1221，这就是一个回文数，1234倒过来是4321，不相等，就不是回文数。

一个四位数abcd能够写为I1=a*1000+b*100+c*10+d

那么倒过来的数就能够写成I2=d*1000+c*100+b*10+a

若是I1和I2相等，那么这就是一个回文数。I1==I2的结果就是True，不然就是False。

一个四位数I1，分离各位数字的方法是：

千位：I1/1000

百位：I1/100%10

十位：I1/10%10

个位：I1%10

所以，判断回文数，若是使用a、b、c、d表示整数I1的千位、百位、十位、个位，开发步骤以下：

用户输入一个整数I1
分离千位、百位、十位、个位
组合出新数字I2=d*1000+c*100+b*10+a
比较I1==I2
输出结果

【程序实现】

I1 = int(input("请输入一个四位数："))
a = int(I1 / 1000)
b = int(I1 / 100 % 10)
c = int(I1 / 10 % 10)
d = int(I1 % 10)
I2 = d * 1000 + c * 100 + b * 10 + a
if I1 == I2:
    print("True")
else:
    print("False")

【程序结果】

例如，输入1221，结果输出True

请输入一个四位数：1221

True

输入1234，结果输出False

请输入一个四位数：1234

False

程序37：汉诺塔（递归函数）

【程序描述】

古代有一个梵塔，塔内有A、B、C三个基座，A座上有64个盘子，盘子大小不等，大的在下，小的在上。有人想把这64个盘子从A座移到C座，但每次只容许移动一个盘子，而且在移动的过程当中，3个基座上的盘子始终保持大盘在下，小盘在上。在移动过程当中盘子能够放在任何一个基座上，不容许放在别处。编写程序，用户输入盘子的个数，显示移动的过程。

【程序分析】

假定盘子从大到小依次编号为：盘一、盘二、…

若是只有一个盘子，则不须要利用B座，直接将盘子从A移动到C
若是有2个盘子，能够先将盘2移动到B，将盘1移动到C后，再将盘2移动到C
若是有3 个盘子，那么根据2个盘子的结论，能够借助C将盘2和盘3从A移动到B，将盘1从A移动到C，A变成空座；借助A座，将B上的两个盘子移动到C

上述思路能够一直扩展下去，根据以上的分析，能够写出下面的递归表达：

将一个盘子从A移动到C

借助C将n-1个盘子从A移动到B

将一个盘子从A移动到C n>1

借助A将n-1个盘子从B移动到C

借助B将n个盘子从A移动到C

为了编写一个递归函数实现“借助B将n个盘子从A移到C”，比较等式左右两边类似操做，会发现：

盘子的数量从n变化到n-1，问题规模缩小了，显然n是一个可变的参数
盘子的起始位置是变化的，等式左侧是A，右侧是A或B
盘子的最终位置是变化的，等式左侧是C、右侧是B或C
一样被借助的位置也是变化的

所以，递归函数共有盘子数、起始位置、借助位置和最终位置4个变量，所以函数有4个可变参数。假定函数的参数一次为盘子数、初始位置、借助位置和最终位置，则可写出下面函数。

【程序实现】

def Hanoi(n, ch1, ch2, ch3):
    if n == 1:
        print(ch1, "->", ch3)
    else:
        Hanoi(n - 1, ch1, ch3, ch2)
        print(ch1, "->", ch3)
        Hanoi(n - 1, ch2, ch1, ch3)


N = int(input("请输入盘子的数量："))
Hanoi(N, 'A', 'B', 'C')

【程序结果】

请输入盘子的数量：4

A -> B

A -> C

B -> C

A -> B

C -> A

C -> B

A -> B

A -> C

B -> C

B -> A

C -> A

B -> C

A -> B

A -> C

B -> C

程序38：判断闰年

【程序描述】

用户输入一个年份，若是是闰年输出True，若是不是，输出False。

【程序分析】

判断闰年的规则以下:

能被4整除且不能被100整除的为闰年
能被400整除的是闰年

在上述两个规则中，只要有一条规则成立，则年份为闰年。

【程序实现】

year = int(input("输入一个年份: "))
if (year % 4) == 0:
    if (year % 100) == 0:
        if (year % 400) == 0:
            print("{0} 是闰年".format(year))  # 整百年能被400整除的是闰年
        else:
            print("{0} 不是闰年".format(year))
    else:
        print("{0} 是闰年".format(year))  # 非整百年能被4整除的为闰年
else:
    print("{0} 不是闰年".format(year))

【程序结果】

输入一个年份: 2018
2018 不是闰年

程序39：寻找自幂数

【程序描述】

用户输入位数n，找出并显示出全部n位的自幂数。

【程序分析】

自幂数是指一个n位正整数，若是它的各位数字的n次方的和加起来等于这个数，数学家称这样的数为自幂数。例如，13+53+33=153，153就是一个3位的自幂数，3位自幂数也称为水仙花数。本程序设n的数值为1~6，当n大于6时，程序退出。

【程序实现】

import math

n = int(input("请输入自幂数位数：\n"))

while n != -1:
    if n == 1:
        print("独身数:")
        print("0\t")
    elif n == 2:
        print("两位自幂数:")
        print("没有自幂数！")
    elif n == 3:
        print("水仙花数:")
    elif n == 4:
        print("玫瑰花数:")
    elif n == 5:
        print("五角星数:")
    elif n == 6:
        print("六合数:")
    elif n == 7:
        print("北斗七星数:")
    elif n == 8:
        print("八仙数:")
    elif n == 9:
        print("九九重阳数:")
    elif n == 10:
        print("十全十美数:")
    else:
        print("其它自幂数:")
    # 定义一数字，从10^(n-1)开始自加,到10^n结束
    for i in range(int(math.pow(10, n - 1)), int(math.pow(10, n))):
        num = 0
        for j in str(i):
            num += int(math.pow(int(j), n))
        if i == num:
            print(i)
    n = int(input('请选择自幂数的位数(退出程序请输入：-1):'))
else:
    print("输入'-1'程序结束。")

【程序结果】

请输入自幂数位数：
3
水仙花数:
153
370
371
407
请选择自幂数的位数(退出程序请输入：-1):1
独身数:
0
1
2
3
4
5
6
7
8
9
请选择自幂数的位数(退出程序请输入：-1):4
玫瑰花数:
1634
8208
9474
请选择自幂数的位数(退出程序请输入：-1):2
两位自幂数:
没有自幂数！
请选择自幂数的位数(退出程序请输入：-1):-1
输入'-1'程序结束。

程序40：多维数据

【程序描述】

在现实生活中，常常须要处理多维数据，好比，二维矩阵，三维矩阵等。在Python中能够用嵌套列表来表示多维数据，好比，下面的一个列表表示的是3*3的二维数据。

M=[[1,2,3],[‘a’,’b’,’c’],[7,8,9]]

显然这种嵌套列表与一般意义的矩阵有所不一样，主要不一样表如今如下两个方面。

列表的每一个维度长度能够不一样
列表的元素数据类型能够不一样

尽管如此，使用嵌套列表表示多维矩阵依然是Python语句中的常见用法，好比列表N=[[1,2,3],[4,5,6],[7,8,9]]表示下面矩阵。

123

456

789

而对于第（i,j）位置的访问使用N[i][j]便可。

若是要经过键盘输入数据来初始化一个2*2的矩阵，可使用下面的语句。

【程序分析】

【程序实现】

a = []
for i in range(2):
    a.append([])
    for j in range(2):
        v = int(input("请输入元素："))
        a[i].append(v)
print(a)

【程序结果】

请输入元素：1

请输入元素：2

请输入元素：3

[[1, 2], [2, 3]]

程序41：验证哥德巴赫猜测

【程序描述】

哥德巴赫猜测说是说，任何一个超过2的偶数均可以写成两个素数之和，例如，4=2+2，8=5+3等。本例要求根据用户输入的偶数找出其素数和的分解形式

【程序分析】

一个简单的方法的，对于输入的偶数N，找出其全部分解，逐一验证每个知足N=k1+k2的分解中k1和k2是否都是素数。好比对于数字12，验证分解（2，10），（3，9）、（4，8）、（五、7）、（6，6）中有没有两个数都是素数的情形。若是有，哥德巴赫猜测该数就是成立的。这种算法对于只验证一个数字N的全部分解的情形是合适的。但对于须要验证多个偶数N的情形效率欠佳。好比须要验证十、十二、16三个数，它们有分解5+五、5+七、5+11，这样验证这几个分解时就要判断5是否是素数，重复的运算会不少。

本案例采用另外一种思路，首先创建一个素数表，该素数表要足够长，能够覆盖偶数N全部分解中可能遇到的素数。然后考察N的每一个分解，看看分解出来的两个数是否都包含在素数表中，如果，则找到一种素数分解。

【程序实现】

def main():
    # 输入待验证的偶数
    N = int(input("请输入待验证的偶数："))
    while N < 3 or N % 2 == 1:
        print("输入的数不符合要求")
        N = int(input("请输入待验证的偶数n (n>2):"))
    # 生成素数表
    Prime = set()
    for i in range(2, N + 1):
        Prime.add(i)
    for i in range(2, N + 1):
        if i in Prime:
            for k in range(2 * i, N + 1, i):
                if k in Prime:
                    Prime.remove(k)
    # 验证该偶数可否分解为两个素数之和
    for e in Prime:
        f = N - e
        if f >= e and f in Prime:
            print(N, '=', e, '+', f)


main()

【程序结果】

请输入待验证的偶数：12

12 = 5 + 7

程序42：解方程

【程序描述】

编写程序，解一元二次方程 ax2+bx+c=0。

【程序分析】

【程序实现】

from math import *

print("本程序求 ax^2+bx+c=0 的根")
a = float(input("请输入 a:"))
b = float(input("请输入 b:"))
c = float(input("请输入 c:"))
delta = b * b - 4 * a * c
if (delta >= 0):
    delta = sqrt(delta)
    x1 = (-b + delta) / (2 * a)
    x2 = (-b - delta) / (2 * a)
    print("两个实根分别为:", x1, x2)
else:
    print("没有实根")

【程序结果】

本程序求 ax^2+bx+c=0 的根

请输入 a:12

请输入 b:23

请输入 c:21

没有实根

或

本程序求 ax^2+bx+c=0 的根

请输入 a:2

请输入 b:-8

请输入 c:2

两个实根分别为: 3.732050807568877 0.2679491924311228

程序43：异常处理

【程序描述】

输入两个整数，打印它们相除以后的结果。对输入的不是整数或除数为零，进行异常处理。

【程序分析】

在对两个整数相除过程当中，若是遇到输入的不是整数或者除数为零，那么程序会终止，再也不执行其余语句，这就是出现了异常。系统自动的处理就是中止执行，给出提示，为了执行这种状况，不让程序结束，能够将会出现异常的代码写在try中，让except按照异常类名处理异常。

【程序实现】

k = 0
while (k < 3):
    try:
        x = int(input('请输入第一个整数:'))
        y = int(input('请输入第二个整数:'))
        print('x/y=', x / y)
    except ValueError:
        print('请输入一个整数。')
    except ZeroDivisionError:
        print('除数不能为零。')
    k = k + 1

【程序结果】

请输入第一个整数:12

请输入第二个整数:23

x/y= 0.5217391304347826

程序44：统计不及格人数（continue语句）

【程序描述】

有若干成绩，统计及格人的平均成绩。

【程序分析】

有若干成绩，其中有不及格的，如今要统计及格的这些人的平均成绩，可使用循环先求和，但遇到不及格的，不加入其中，最后除以及格的人数，假设成绩存储在一个列表中。

【程序实现】

x = [98, 72, 80, 45, 30, 89, 92, 54, 48, 82, 67, 76]
sum = 0
k = 0;
for item in x:
    if (item < 60):
        continue
    sum = sum + item
    k = k + 1;
if (k != 0):
    print("及格人数", k, "人,平均成绩是", sum / k)

【程序结果】

及格人数 8 人,平均成绩是 82.0

程序45：求直角三角形的斜边

【程序描述】

输入直角三角形的两个直角边长度a、b，求斜边c的长度。

数学公式 c=a2+b2

【程序分析】

在Python中，乘法使用“*”号表示，如a*a就是a的平方。

除此以外，还有开方根的运算，能够经过Python中math模块内置的函数来实现，为此，咱们能够在程序中使用import导入math模块，而后调用开方的函数sqrt实现。

【程序实现】

from math import *

a = float(input("请输入斜边 1 的长度"))  # 输入实数
b = float(input("请输入斜边 2 的长度"))  # 输入实数
c = a * a + b * b  # 计算,获得的是斜边的平方
c = sqrt(c)  # 开方，获得的是斜边长
print("斜边长为:", c)  # 显示，一项是字符串，一项是 c 表示的斜边长

【程序结果】

请输入斜边 1 的长度3

请输入斜边 2 的长度4

斜边长为: 5.0

程序46：问年龄

【程序描述】

有5我的坐在一块儿，问第五我的多少岁？他说比第4我的大2岁。问第4我的岁数，他说比第3我的大2岁。问第三我的，又说比第2人大两岁。问第2我的，说比第一我的大两岁。最后问第一我的，他说是10岁。请问第五我的多大？

【程序分析】

题目很是符合递归函数的过程，因此本题采用递归函数完成。

函数把问到的第几我的做为参数i，当i的值为1时，函数返回10，其它状况均为第i-1人年龄的基础上加2.

【程序实现】

def fun(i):

if i==1:

return 10

return fun(i-1)+2

print(fun(5))

【程序结果】

程序47：求相同数字的和

【程序描述】

求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。

【程序分析】

根据用户输入的个数（长度）决定循环的次数。

区分每次循环输出的内容，只要是最后一次循环，就直接输出最终的结果，其他皆为本次结果跟上加号。

先从个位的数字开始计算，每执行一次循环就把上次的结果数乘以10，使得每次的结果为30、330、3330，而后再加上个位的基本数字就行。

【程序实现】

def test():
    basis = int(input("输入一个基本的数字"))
    n = int(input("输入数字的长度"))
    b = basis
    sum = 0
    for i in range(0, n):
        if i == n - 1:
            print("%d" % (basis))
        else:
            print("%d +" % (basis))
        sum += basis
        basis = basis * 10 + b
    print("= %d" % (sum))


test()

【程序结果】

输入一个基本的数字:3

输入数字的长度:4

3 +

33 +

333 +

3333

= 3702

程序48：找出1000之内的全部完数

【程序描述】

一个数若是刚好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3.编程找出1000之内的全部完数。

提示：借助math模块的sqrt函数（求平方根）

【程序分析】

【程序实现】

from math import sqrt

n = int(input("输入一个数字："))
sum = n * -1
k = int(sqrt(n))
for i in range(1, k + 1):
    if n % i == 0:
        sum += n / i
        sum += i
if sum == n:
    print("YES")
else:
    print("NO")

【程序结果】

输入一个数字:6

YES

程序49：公民类

【程序描述】

定义公民类，实例成员变量有身份证号、姓名、年龄和性别。定义公民类的派生类:学生类和教师类。学生类增长实例成员变量学号、班级和分数;教师类增长实例变量工号、系别和工资。编写主程序，定义类的对象，设置对象的实例属性，显示对象的信息。

【程序分析】

使用super()方法调用父类的构造方法。

【程序实现】

class Citizen:
    def __init__(self, id, name, age, sex):
        self.id = id
        self.name = name
        self.age = age
        self.sex = sex


class Student(Citizen):
    def __init__(self, id, name, age, sex, stdno, grade, score):
        super(Student, self).__init__(id, name, age, sex)
        self.stdno = stdno
        self.grade = grade
        self.score = score


class Teacher(Citizen):
    def __init__(self, id, name, age, sex, thno, dept, salary):
        super(Teacher, self).__init__(id, name, age, sex)
        self.thno = thno
        self.dept = dept
        self.salary = salary  # 主程序


c = Citizen('101', 'zhang', 20, 'female')
print(c.id, c.name, c.age, c.sex)
s = Student('102', 'wang', 30, 'male', 1221, 'computer12', 630)
print(s.id, s.name, s.age, s.sex, end=" ")
print(s.stdno, s.grade, s.score)
t = Teacher('103', 'li', 36, 'male', 356, 'eie', 4500)
print(t.id, t.name, t.age, t.sex, end=" ")
print(t.thno, t.dept, t.salary)

【程序结果】

101 zhang 20 female

102 wang 30 male 1221 computer12 630

103 li 36 male 356 eie 4500

程序50：复数类

【程序描述】

定义一个复数类，包括实部和虚部成员变量、构造方法、以及两个复数的加法、乘法和比较大小运算符定义。

【程序实现】

class Complex:
    def __init__(self, r, i):
        self.real = r
        self.imag = i

    def __add__(self, c):
        return Complex(self.real + c.real, self.imag + c.imag)

    def __mul__(self, c):
        return Complex(self.real * c.real - self.imag * c.imag, self.real * c.imag + self.imag * c.real)

    def __gt__(self, c):
        if self.real > c.real:
            return True
        elif self.real < c.real:
            return False
        elif self.imag > c.imag:
            return True
        else:
            return False

    def show(self):
        print(self.real, "+", self.imag, "j")


# 主函数
c1 = Complex(3, 4)
c2 = Complex(6, -7)
(c1 + c2).show()
(c1 * c2).show()
print(c1 > c2)

【程序结果】

9 + -3 j

46 + 3 j

False

Python 思惟锻炼

程序1：数字组合

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序2：猜猜这个数是多少？

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序3：判断这是一年中的第几天？

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序4：判断整数大小

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序5：斐波那契数列

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序6：水仙花数

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序7：数字求和

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序8：平方根

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序9：if语句

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序10：阿姆斯特朗数

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序11：输出指定范围的素数（else语句）

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序12：生成日历

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序13：统计字符串中的字符

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序14：文件的读取

【程序描述】

【程序分析】

【程序实现】

【程序输出】

程序15：十进制转二进制、八进制、十六进制

【程序描述】

【程序分析】

【程序实现】

【程序结果】

程序16： 生成10个两位的随机素食

【程序描述】

【程序分析】

【程序实现】

程序16：生成10个两位的随机素食

程序17：计算三角形面积

程序19：获取昨天日期

程序20：变量交换

程序21：质数判断

程序22：简单计算器

程序23：最大公约数

程序24：最小公倍数

程序25：字符串判断

程序26：合并文件数据

程序27：猜数游戏

程序30：计算0-7组成的奇数个数