python练习案例100例（每天坚持一粒，按时服下）

友情提示：本章所有的题目代码语法是基于python3.0版本以上的，2.0中可能部分不适用

题目1：有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？

程序分析：
可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。**
思路解析：
用三个for循环嵌套输出，并用range（）函数进行划定范围1到4，外加if条件语句进行判断三个数字不相等
代码解析：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
for i in range(1,5):
    for k in range(1,5):
        for j in range(1,5):
            if (i != k) and (i != j) and (k != j):
                print(i,j,k)

**

题目2：输入某年某月某日，判断这一天是这一年的第几天？

程序分析：
以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于2时需考虑多加一天：**
思路解析：
用列表存储每一个月份到12月份的天数，逐渐递增，用if条件判断语句判断月份，取列表的下表，下面对年份进行判断，如果为闰年，且输入的月份大于2月份，则将算出的天数加1
代码解析：

# -*- coding: UTF-8 -*-
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
if ((year % 400 == 0) or (year %4 == 0) and (year % 100 != 0)):
    if(month > 2):
        sum += 1
print('这一天是这一年的%d日'%sum)

**

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

程序分析：
我们想办法把最小的数放到x上，先将x与y进行比较，如果x>y则将x与y的值进行交换，然后再用x与z进行比较，如果x>z则将x与z的值进行交换，这样能使x最小。**
特别麻烦的思路一般是将一个值与另外两个值进行比较，代码如下，非常不建议：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
first = int(input("请输入第一个数："))
second = int(input("请输入第二个数字："))
last = int(input("请输入第三个数字："))

if((first > second) and (first > last) and (second > last)):
    print(first,second,last)
if((last > second) and (last > first) and (second > last)):
    print(last,second,last)
if((second > first) and (second > last) and (first > last)):
    print(second,first,last)

简单的代码实现（优化）实现了可以控制比较数字大小的个数，个人思想：
放上一个列表，采用sort()方法加上for循环比较后放入列表中
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
len = []
k = int(input("请输入比较的数字数目："))
for i in range(k):
    k = int(input("请逐个输入比较的数字："))
    len.append(k)
len.sort()
print("比较后从小到大排序为："+str(len))

**

题目4：斐波那契数列。

程序分析：斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……。
在数学上，费波那契数列是以递归的方法来定义：
F0 = 0 (n=0)
F1 = 1 (n=1)
Fn = F[n-1]+ F[n-2]’(n=>2)**
斐波那契数列就是将钱两个数字相加会得到第三个数字，所以可以采用迭代，或者循环相加的思路
牵扯到数学问题，本人数学很差劲，不过还好理解了题的意思：
思路一：利用递归结题，如果是1，2则返回1，如果大于2则进行迭代计算
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
n = int(input("请输入指定斐波那契的具体哪一个数值："))
def name(n):
    if (n == 1 or n == 2):
        return 1
    else:
        return name(n-1) + name(n - 2)
print(name(n))    

如果实现将所有的指定到输出具体的所有的数值那，可以这么做：
思路解析：将input（）函数强制转为int，然后封装一个方法，用if进行判断，若是第前三个数字，则直接进行返回即可，若是出了这三个数字的另外的数字，可以用循环for制定循环到指定的位数，然后用字符串拼接添加到列表中
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
n = int(input("请输入指定斐波那契输出到第几个数值："))
def name(n):
    if n == 1:
        return [1]
    if n == 2:
        return [1,1]
    fibs = [0,1,1]
    for i in range(2 , n):
        fibs.append(fibs[-1] + fibs[-2])
    return fibs
print(name(n)) 

如果不采用迭代，只是用循环如何实现那，代码如下：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
def fib(n):
    a,b = 1,1
    for i in range(n-1):
        a,b = b,a+b
    return a
 
# 输出了第10个斐波那契数列
print fib(10)

**

题目5：将一个列表的数据复制到另一个列表中。

程序分析：使用列表[:]**
方式一：
直接使用copy()方法进行列表的复制即可
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
cla = [0,1,2,3,4,5,6,7,8,9]
alc = []
alc = cla.copy()
print(cla)
print(alc)

方式二：
首先我们需要注意，在Python中是没有i++之列的，这个原因自行上网上搜索，所以只能用i =i + 1
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
cla = [1,2,3,4,5,6,7,8,9]
alc = []
i = 0
while (len(alc) < len(cla)):
    alc.append(cla[i])
    i = i + 1
print(alc)

此处为什么i变量为全局变量不能为局部变量那？
方式三：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
a = [1, 2, 3]
b = a[:]
print b

方式四：

# -*- coding: UTF-8 -*-
#讲列表复制到另一个列表里
a = [1,2,3,4,5,6,7,8,9]
b = a*1
print(b)

题目6：输出 9*9 乘法口诀表。 程序分析：分行与列考虑，共9行9列，i控制行，j控制列。

代码实现之一：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%d" % (i,j,i*j),end = " ")
    print()  

这个题目那有很多中方法，多到让你目不暇接那种感觉，反正有一个自己喜欢的方法就可以了，此处只列出一个方法，不管在什么语言中打印九九乘法表是特别经典的一个题，但是核心无非就是用嵌套循环进行实现

题目7：暂停一秒输出。 程序分析：使用 time 模块的 sleep() 函数。

代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time
 
myD = {1: 'a', 2: 'b',3:'c',4:'d'}
for key, value in dict.items(myD):
    print(key, value)
    time.sleep(2) # 暂停 2 秒

题目8：暂停一秒输出，并格式化当前时间。

Python time.strftime() 函数接收以时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定。
Python time.localtime() 函数类似gmtime()，作用是格式化时间戳为本地的时间。 如果sec参数未输入，则以当前时间为转换标准。 DST (Daylight Savings Time) flag (-1, 0 or 1) 是否是夏令时。

==Python time time() ==返回当前时间的时间戳（1970纪元后经过的浮点秒数）
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time
 
print time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
 
# 暂停一秒
time.sleep(1)
 
print time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))

加上循环可以设置为一个时间阅读器：

 #!/usr/bin/python
# -*- coding: UTF-8 -*-
import time
while True: 
    # 暂停一秒
    time.sleep(1)
 
    print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))

**

题目9：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

**
今天的这一题和第四题在本质上是一样的，都是围绕着斐波那契切数列进行的一道题，不过题目可能更好听了，叫做不死神兔，在我的其他的博客文章上，有过java的文章也对这道题目研究过，对java有兴趣朋友可以去看一下，下面进入正题：
程序的思路分析： 程序分析：兔子的规律为数列1,1,2,3,5,8,13,21…
我们仍然可以用迭代来进行实现，但是这里我们采用循环加上判断语句进行实现，此处输出的数列有一个特点就是能够被3进行整除，所以可以利用这一个特性对将要输出的数进行过滤
实现代码如下：

#不死神兔
# !/usr/bin/python
# -*- coding: UTF-8 -*-

f1 = 1
f2 = 1
for i in range(1, 22):
    print('%12ld %12ld' % (f1, f2))
    if (i % 3) == 0:
        print(' ')
    f1 = f1 + f2
    f2 = f1 + f2

我在网上还看到很多的写法，此处不一一做出解释，大部分人的思想就是采用递归来进行接替，但是采用递归有个缺陷就是执行效率较慢，所以在次才采用过滤判断进行输出

题目10：判断101-200之间有多少个素数，并输出所有素数。

程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。==
关于素数的概念请点击这里：质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。（传送门）
代码实现：

# !/usr/bin/python
# -*- coding: UTF-8 -*-

h = 0
leap = 1
from math import sqrt
from sys import stdout

for m in range(101, 201):
    k = int(sqrt(m + 1))
    for i in range(2, k + 1):
        if m % i == 0:
            leap = 0
            break
    if leap == 1:
        print('%-4d' % m)
        h += 1
        if h % 10 == 0:
            print('')
    leap = 1
print('输出的素数的个数是： %d' % h)

题目11：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。

#例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。

先来一个最容易理解的解法，就是对个位，十位与百位分别用for循环遍历，如果满足条件等于自己则输出，否则pass，这种思路是最容易想到的，也是最为普遍的。
代码分析：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
   for i in range(1,10):
   	 for j in range(0,10):
        for k in range(0,10):
            u1 = pow(i,3) + pow(j,3) + pow(k,3)
            u2 = i*100 + j*10 + k
            if u1 == u2:
                print("满足的水仙花数为:" + str(u1))
            elif u1 < u2 or u1 > u2:
                pass
            else:
                pass

另一种解法本人认为也是比较新鲜的解法，就是分别取出个位，十位与百位，这样做的好处只会循环一遍，节省系统资源，其重要步骤就是利用"/“与”%"符号进行运算
在这里我们需要声明一件事，很容易犯错的一件事，就是/与//的区别

" / " 表示浮点数除法，返回浮点结果;
" // " 表示整数除法,返回不大于结果的一个最大的整数

所以用的用/发现什么水仙花都没有，所以，这里请注意

代码解析：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
for n in range(100,1000):
    i = n // 100 	   #百位
    j = n // 10 % 10   #十位
    k = n % 10		   #个位
    if n == pow(i,3) + pow(j,3) + pow(k,3):
        print(n)

在进行if条件判断的时候可以写成if n == i ** 3 + j ** 3 + k ** 3:但是本人认为，python中有这么好用的pow方法干嘛不用那，这也与Python之禅的意义相反。
查看python之禅：import this
在想一下，我们可以将这一题扩大，干嘛非得输出指定的数列中的水仙花数，我们完全可以加上方法对其控制输出什么范围之内的水仙花数：
代码解析：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = int(input("请输入开始的数字："))
srt = int(input("请输入结束的数字"))
for n in range(str, srt):
    i = n // 100
    j = n // 10 % 10
    k = n % 10
    if n == i ** 3 + j ** 3 + k ** 3:
        print("输出的指定的范围的水仙花是：" + '%d'%n)

这里一定要注意将输入的数字转换为数值类型否则整形与字符类型不一致
**

题目12：学习成绩分类：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示

**程序分析：程序分析：(a>b)?a:b这是条件运算符的基本例子
此题是对条件判断进行考察，题偏简单，一般人也能想到用if-elif-else来解题
无非就是条件判断
代码解析：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
score = int(input('输入分数:\n'))
if score >= 90:
    grade = 'A'
elif score >= 60:
    grade = 'B'
else:
    grade = 'C'
 
print('%d 属于 %s' % (score,grade))

这里注意一个问题就是在python中没有switch与case这种写法，官方文档上说可以用if-elif-else代替，好，python的简洁，

题目13：获取当前的时间并输出指定格式的日期。

**程序分析：**使用 datetime 模块
这个模块有很多的方法，最好就是自己动手写一写，每一个方法我都有注释详解
如果需要python3的查询帮助文档，可以私信我，善于利用python的帮助文档可以进步的更快一些，python的计算生态是标准库加上第三方库构成的，有一些模块是自带的，不用二次下载，datetime就是其中的一个模块，直接导入即可
下面我们需要记忆一些东西：（不必完全记住，用的使用查询即可）
前言：
Python中提供了多个用于对日期和时间进行操作的内置模块：time模块、datetime模块和calendar模块。其中time模块是通过调用C库实现的，所以有些方法在某些平台上可能无法调用，但是其提供的大部分接口与C标准库time.h基本一致。time模块相比，datetime模块提供的接口更直观、易用，功能也更加强大。
（此处不需要进行详细的了解，但是下面的内容需要一定的记忆量）
datetime介绍：

datetime是date与time的结合体，包括date与time的所有信息。它的构造函数如下：datetime.datetime(year,> month, day[, hour[, minute[, second[, microsecond[,
tzinfo]]]]])，
各参数的含义与date、time的构造函数中的一样，要注意参数值的范围。

datetime类定义的类属性与方法：

•datetime.min、datetime.max：datetime所能表示的最小值与最大值；
•datetime.resolution：datetime最小单位；
•datetime.today()：返回一个表示当前本地时间的datetime对象；
•datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
•datetime.utcnow()：返回一个当前utc时间的datetime对象；
•datetime.fromtimestamp(timestamp[,
tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；
•datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
•datetime.combine(date, time)：根据date和time，创建一个datetime对象；
•datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；

date类：

date类表示一个日期。日期由年、月、日组成（地球人都知道~~）。date类的构造函数如下：

class datetime.date(year, month, day)：参数的意义就不多作解释了，只是有几点要注意一下：

•year的范围是[MINYEAR, MAXYEAR]，即[1, 9999]； •month的范围是[1,> 12]。（月份是从1开始的，不是从0开始的_{_}）； •day的最大值根据给定的year, month参数来决定。例如闰年2月份有29天；
date类定义了一些常用的类方法与类属性，方便我们操作：

•date.max、date.min：date对象所能表示的最大、最小日期；
•date.resolution：date对象表示日期的最小单位。这里是天。
•date.today()：返回一个表示当前本地日期的date对象；
•date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；
•datetime.fromordinal(ordinal)：将Gregorian日历时间转换为date对象；（Gregorian
Calendar：一种日历表示方法，类似于我国的农历，西方国家使用比较多，此处不详细展开讨论。）

time类：

time类表示时间，由时、分、秒以及微秒组成。（我不是从火星来的~~）time类的构造函数如下：

class datetime.time(hour[, minute[, second[, microsecond[, tzinfo]]]])
：各参数的意义不作解释，这里留意一下参数tzinfo，它表示时区信息。注意一下各参数的取值范围：hour的范围为[0,
24)，minute的范围为[0, 60)，second的范围为[0, 60)，microsecond的范围为[0, 1000000)。

time类定义的类属性：

•time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)，
time.max = time(23, 59, 59, 999999)； •time.resolution：时间的最小单位，这里是1微秒；
time类提供的实例方法和属性：

•time.hour、time.minute、time.second、time.microsecond：时、分、秒、微秒；
•time.tzinfo：时区信息；
•time.replace([hour[, minute[, second[,> microsecond[,> tzinfo]]]]])：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；
•time.isoformat()：返回型如"HH:MM:SS"格式的字符串表示；
•time.strftime(fmt)：返回自定义格式化字符串。

格式化代码输出：（可能看不懂，看到下面的代码解析，你就会恍然大悟）

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a> 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j> 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w> 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

举个例子：用time模块举个例子，简单易懂

#!/usr/bin/python3
import time

# 格式化成2016-03-20 11:45:39形式
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

# 格式化成Sat Mar 28 22:24:24 2016形式
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
  
# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))

这里我们拿datetime这个库进行解题
代码解析：

import datetime
# 输出今日日期，格式为 dd/mm/yyyy。
#strftime() 函数接收以时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定。
#  方法
print(datetime.date.today().strftime('%d/%m/%Y'))
# 创建日期对象
#直接获取指定的日期，按照参数放在哪个位置上
miyazakiBirthDate = datetime.date(1941, 1, 5)
print(miyazakiBirthDate.strftime('%d/%m/%Y'))

# 日期替换
miyazakiFirstBirthday = miyazakiBirthDate.replace(year=miyazakiBirthDate.year + 1)
print(miyazakiFirstBirthday.strftime('%d/%m/%Y'))

date与datetime很多方法做出来的效果看似都一样，那是不是用其中的一个模块就可以，但是我们往往忽略了一些差异，他们的不同之处在哪？
提示：
Date:代表xxxx年xx月xx日 只表示前面的日期

DateTime:代表xxxx年xx月xx日xx时xx分xx秒 精确到时分秒,用于做时间戳

题目14：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符输出的数并分别统计每一种类型的个数。

思路解析：
当看到这一题的时候，我首先想的是肯定是对单个字符进行判断，一个一个的进行，一直到一句话的结束，那么肯定离不开for循环或者while循环，另外是对输入的数进行类型判断，首先判断是这四种类型的哪一种，然后将其划定到相应的类型群中区，再进行下一个数字的判断，那么这个类型群应该是列表，那么个数就可以采用len()方法进行判断
另外这里还有重要的一点，就是可以采用几个方法：
isalpha() 判断是否为字母
isspace()判断是否为空字符
isdigit()判断是否为数字

代码解析：

#!/usr/bin/env python3
#先让其输入进行判断的字符串
InPut = input('输入任意字符:')
#列出四种类型的列表来盛放相应的字符
letters = []
spaces = []
digits = []
others = []
#这里用的是for循环
for i in iter(InPut):
    # 对输入的字符串进行判断
    if i.isalpha() == True:     #为字母
        letters.append(i)
    elif i.isspace() == True:   #为空字符就是空格
        spaces.append(i)
    elif i.isdigit() == True:   #为数字
        digits.append(i)        #为其他不识别的东西
    else:
        others.append(i)
#此处的输出方法有很多种，这里只是其中的一种
print('''
字母: {}, 个数: {};
空字符: {}, 个数: {};
数字: {}, 个数: {};
其他: {}, 个数: {}'''.format(letters, len(letters), spaces, len(spaces), digits, len(digits), others, len(others)))

我见其他的习题的模型，但是并未让输入的字符分门别类的输出，仅仅是统计其每一种类的个数，这一案例将其完善，可以说是创新一点吧。

题目15：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

思路分析：
首先想到的就用两个列表（数组）存储每次下落的高度与下落的总高度，此处需要注意的一点就是必须得设置一个/=,对每次下落后的路径进行一半的减除，但是需要注意的一点就是，第一小球所在的位置就是在100米处，所以需要一个if来进行判断，若在100米处则直接将路径添加到相应的列表中即可，否则对路径减半添加
代码解析：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

tour = []
cry = [] #储存小球的总高度

hei = 100 #小球的高度
cou = 10  #第10次

for i in range(1, cou + 1):
    if i ==1:
        tour.append(hei)
    else:
        tour.append(2 * hei)
    hei /= 2
    cry.append(hei)
print("小球高度为{}米".format(sum(tour)))
print("小球在第10次反弹的时候高度为：{}".format(cry[-1]))

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

思路解析：此题的解法有很多，这里我只说两种
方式一：
简单粗暴的方式，就是对个位数，十位数，百位数，，，，进行下一次对前面的所有的数进行相加，例如2222，实际上就是2+20+200+2000来进行计算的，所以这里我们必须要有循环，并设置一个初始值为0的变量，对数值进行循环相加
代码解析：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

n = int(input('请输入多少次： '))
a = int(input('请输入单个数字是多少： '))
sum = 0
total = 0
for i in range(n):
    sum += pow(10, i)
    total += sum * a
print(total)

方式二：
思路解析：
对待数值，将其看做是字符串，实行append()方法的字符串拼接，但是这种方式需要注意的是需要在对每次循环字符串进行强制转换为整形（int），否则。。。报错，字符串么，如何相加那
代码解析：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

def calculate(a,n):
    sum = 0
    for i in range(1,n+1):
        x = int(str(a)*i)
        sum+=x
    print(sum)
calculate(4,4)

题目17：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

思路分析：
逆向思维分析，倒着推理
方式一：
采用递归的方法，出口终止在第10天的时候
代码解析：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def taozi(n):
    if n == 1:
        return 1
    else:
        return (taozi(n-1)+1)*2
print(taozi(10))   #递归思路

方式二：
简单粗暴循环第一天到第九天，计算桃子的总和
代码解析：

#!/usr/bin/python3

x = 1
for day in range(0,9):
    x = (x+1)*2
print(x)

方式三：
采用将每一天的桃子数目放在列表中，然后利用下标获取最后一位
代码解析：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

m = [1]
Tn = 1
for i in range(9):
    Tn = (Tn+1)*2
    m.append(Tn)
print(m[len(m)-1])

题目18：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。

思路分析：
将a、b、c分别与x、y、z进行循环，然后加上题目中不满足的条件
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

for a in ['x','y','z']:
    for b in ['x', 'y', 'z']:
        for c in ['x', 'y', 'z']:
            if(a!='x') and (c!='x') and (c!='z'):
                if (a!=b)and(b!=c)and(c!=a): 
                    print('a和%s比赛，b和%s比赛，c和%s比赛' %(a,b,c))

**注意：**此种写法有一点需要注意，将a、b、c与x、y、z进行比对，为了避免类似于a与y配对，b也与y配对的情况，需要限定a与b与c为三个独立的个体，否则会出现下面的情况：

a和y比赛，b和x比赛，c和y比赛
a和y比赛，b和y比赛，c和y比赛
a和y比赛，b和z比赛，c和y比赛
a和z比赛，b和x比赛，c和y比赛
a和z比赛，b和y比赛，c和y比赛
a和z比赛，b和z比赛，c和y比赛

题目19，输出以下图形

这一道题很经典，我见过很多这样的的形式，有的是让输出半边的金字塔，有的是让输出倒立的金字塔，但是这道题就包含着前面的两道，
思路解析：
首先，利用循环是肯定的，而且肯定是嵌套循环，一个循环控制的是空格的输出，一个循环是控制的是*符号的输出，将这个图形拆开，实际上就是正着输出一遍，然后再倒着输出一遍，这里的循环采用的for循环，比较方便
方式一：
代码解析：

#!/usr/bin/python3

for i in range(1, 5):
    print(' ' * (4 - i), end="")
    for j in range(1, 2 * i):
        print('*', end="")
    print()
for i in range(3, 0, -1):
    print(' ' * (4 - i), end="")
    for j in range(1, 2 * i):
        print('*', end="")
    print()

此种写法，可以说是别具一格，巧妙在没有将空格进行循环输出，而真正核心的地方在于循环*的时候对于符号的控制，细细品来，别有一番风味。
此处的end=“”意思是以什么样的符号结尾，什么都不写会有结尾，但是看不见罢了，如果换成其他的符号看看效果如何。
方式二：
思路解析：
这里加了可以由键盘控制行数，而且也采用了在我高中时期学的一种数学运算，控制步长方面，需要注意，因为观察图形不难看出，图形的个数为1、3、5、7、9这样的个数，所以控制好步长特别重要
代码解析：

#!/usr/bin/python3
n = int(input('请输入选择的行数:')) 
for i in range(1,n+1,2):
    k = (n-i)//2
    print( ' '* k , '*' * i)
for p in range(n-2,0,-2):
    o = (n-p)//2
    print(' '*o, '*'*p)

可能会有人认为采用取整符号//是多余的，但是这里没有把空格与符号半个输出的。
方式三：
这种方式特别的简练，而且通俗易懂，也是最为推荐的解题方式
代码解析：

#usr/bin/env python3
#coding:utf-8
for i in range(4):
    print((3-i)*' '+(2*i+1)*'*')
for i in range(3):
    print((i+1)*' '+(5-2*i)*'*')

还有好多种解题的方式，但是这里不一一详解了，有特殊想法者可以在评论区留言

题目20：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。

思路解析：
观察分子与分母的规律不难看出，前一个分数的分子会成为下一个分数的分母，把分子与分母拆开，前两项之和一定等于第三项，另外再加入一个承接分子值传给分母的变量，用于中间值的传递
方式一：
代码解析：

#usr/bin/env python3
#coding:utf-8
a = 2.0 #分子
b = 1.0 #分母
s = 0
for i in range(1, 21):
    s += a / b
    q = a
    a += b
    b = q
print(s)

这道题，重点就是看明白分子与分母与前一项与后一项之间的关系
方式二：
代码解析：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
sum = 0
a, b = 1, 2
for i in range(1, 21):
    sum += b / a
    a, b = b, a + b
print(sum)

这种写法，需要注意的是在 a, b = b, a + b这一行b的值是传递给a，a+b的值是传递给b的，这样简化了代码，与a = a + b可以写成 a += b的道理一样，单也要明白透彻其中值传递的问题

题目21：求1+2!+3!+…+20!的和。

思路解析：
求1到20每一个数的阶乘，运用的巧妙之处在于简化代码的写法，即使是初学者也能一看就懂
代码解析：
方式一：

#usr/bin/env python3
#coding:utf-8
n = 0
k = 0
i = 1
for n in range(1,21):
    i *= n
    k += i
print('%d'%k)

方式二：
另一种方式更是便于理解：
将相加与相乘分别放在两个循环中，最后实现所有数值的加和

#!/usr/bin/env python3
s = 0
for i in range(1, 21):
    r = 1
    for j in range(1, i+1):
        r *= j
    s += r
print(s)

题目22：利用递归方法求5!。

思路解析：
当看到这一题的时候，求5的阶乘不是很容易么，但是若用递归去求5的阶乘那，
按照以前的我么你的例子，递归需要找出口，那么出口应该怎么找那？找循环结束的地方
代码解析：

#usr/bin/env python3
#coding:utf-8
def name(n):
    sum = 0
    if n == 1:
        sum = 1
    else:
        sum = n * name(n - 1)
        return sum 
print(name(5))

在else里面，我想直接与其他语言一样，直接return sum = n * name(n - 1) 但是发现，这是不行的，所以只能拆开来写，而且递归也就是这么用，暂时没有第二种方法来用递归，若有能力者，评论留言

题目23：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。

思路解析：题目中很明确，就是使用递归来解题
我们首先不用递归来实现，现将数正着输出：
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = input("请输入字符：")
for i in range(1,len(str),1):
    print(str[i])

将range中的参数改变，将数值倒着输出

#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = input("请输入字符：")
for i in range(len(str)-1,-1,-1):
    print(str[i])

如果我们用递归如何实现那，但是步骤相对来说比较繁琐，个人感觉有违背Python的主旨
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
def func(str, index):
    if (index + 1) == len(str):
        print(end = "")#这里这样写有独到的好处
    else:
        func(str, index + 1)
    print(str[index], end="")
func("abcdefg", 0)

题目24：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？

思路解析：
当看到这道题的时候不禁想起了弟弟做小学的算术题，其实抛开编程不说，我们心算一下就可以得到答案，除了第一个人，每个人都比前一个人大2岁，知道第一个人的岁数，往后推算即可，所以这里也存在递归和循环的的问题
代码解析:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
def age(n):
    if n == 1:
        c = 10
    else:
        c = age(n - 1) + 2
    return c
print(age(5))

当然或许有人说，根本不需要递归嘛，用个for循环的事整的这么麻烦，瞧，这样也行：
代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
def age():
   n = 10
   for i in range(1, 5):
      n = n + 2
   print("第5个人{0}岁".format(n))
age()

题目25：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字

方式一：
思路解析;
获取是几位数，最简单的方式就是将输入的数转型为列表，然后用len()函数将其长度输出，没必要去大动干戈，逆序打印则用列表的reverse()函数将其反转后遍历输出即可
代码解析：

num = list(input('输入一个最多5位的数字:'))
print("这个数值有" + "%d"%len(num) + "位数值")
num.reverse()
for i in range(len(num)):
    print(num[i],end='')

方式二：
思路解析：
直接采用列表切片的方式
代码解析：

#!/usr/bin/python3

x=input('请输入一个数:\n')
a = len(x)
print('这是一个{}位数'.format(a))
b = -1
while a != 0:
    a -= 1
    if b == -1:
        print(x[-1:],end=' ')
        b=b-1
    else :
        print(x[b:b+1],end=' ')
        b=b-1

前面这些题目，很多的都涉及列表，但是仔细想一想为什么要用列表，而不用元组那，答案显而易见。

1.元组声明与赋值 声明一个元组并赋值的语法与列表相同,不同之处是元组使用小括号,列表使用方…
2.元组的访问 元组的访问和列表相同,可以直接使用下标索引访问元组中的单个数据项,…
3.如何更新元组 元组是不可修改类型,虽然在程序运行过程中无法对元组的元素进行插入和…
4.元组的合并 可以把多个元组合并成一个元组,合并后的元组元素顺序保持不变。合并后的…
5.元组的遍历 元组的遍历方式和列表相同,都是应用for循环语句遍历元组的元素

题目26：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。

注意：
往下的结题思路不仅仅局限于5位数字，，若非得5位数字可以在代码中加入位数的判断
方式一：
思路解析：
直接使用字符串的切片功能，条件判断语句判断原字符串与反转后的字符串是否相等
代码解析：

cry = input("请输入一段字符串进行判断：")
if cry == cry[::-1]:
    print("%s"%cry + "\n你输入的数值是回文数")
else:
    print("%s"%cry + "\n不是回文数")

方式二：
思路解析：
也是利用切片功能，但是将一个数值分成左右两个部分，从头与从末尾同时开始遍历值是否相等，若相等与不相等用条件判断语句，但是注意要用break终止，否则循环会执行数值长度一半的次数
代码解析：

#!/usr/bin/env python3
a = list(input("请输入一个数字："))
for i in range(len(a)//2):
    if a[i]!=a[-1-i]:
        print("%s"%a + "不是回文数")
        break
    else:
        print("%s"%a + "是回文数")
        break

题目27：添加逗号分隔列表成字符串。

思路解析：
首先将列表转换为字符串，然后用join()函数加上循环进行遍历输出

join()解析：

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

join()代码示例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = "-";
seq = ("a", "b", "c"); # 字符串序列
s = str.join( seq )
print(s);

下面正式解题：
方式一：
代码分析：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
L = [1,2,3,4,5]
s1 = ','.join(str(n) for n in L)
print(s1)

方式二：
思路解析：
将列表进行遍历，如果不是最后一个字符则将字符添加逗号，否则什么都不添加，重点在于end方法的运用
代码解析：

a=[1,2,3,4]
for i in range(0,len(a)):
    if i!=(len(a)-1):
        print(a[i],end=',')
    else:
        print(a[i])

这一题重点就是将列表转化为字符串，然后将逗号进行拼接

题目28：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。 程序分析：用情况语句比较好，如果第一个字母一样，则判断用情况语句或if语句判断第二个字母

Monday、Tuesday、Wednesday、Thursday、Friday、Saturday、Sunday

字符串的首字母进行识别，但是在星期一到星期天中，有首字母相同的字母，例如星期二和星期四，星期六与星期天，这里是需要注意的地方
方式一：
思路解析：
采用字典的形式，对首字母相同的单词进行判断，，所以用到了条件判断语句分成两类
代码解析：

#!/usr/bin/python3
weeklist = {'M': 'Monday','T': {'u': 'Tuesday','h':'Thursday'}, 'W': 'Wednesday', 'F':'Friday','S':{'a':'Saturday','u':'Sunday'}}
sLetter1 = input("请输入首字母：")
sLetter1 = sLetter1.upper()

if (sLetter1 in ['T','S']):
    sLetter2 = input("请输入第二个字母：")
    print(weeklist[sLetter1][sLetter2])
else:
    print(weeklist[sLetter1])

方式二：
思路解析：
这种采用递归的解法是我没有想到的，看被人的代码，脑回路真是挺让人震惊的，但是将问题进行复杂化了，所以这里不推荐
代码解析：

#!/usr/bin/env python3
week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
def find(s,week):
    a = input("please input a letter\n")
    s=s+a
    #print(s)    
    result=[]
    for i in week:
        if i.startswith(s):
            result.append(i)
    #print (result)    
    if len(result)==1:
        return result
    else:
        return find(s,result)

s=''
print(find(s,week))

还是那句老话，方法思路很多，众人的智慧是无穷的，欢迎评论区留言，分享你的智慧

题目29：对random模块随机生成的10个数进行降序排序，排序法则

（这个题目原本的模样不是这样的，只是对10个数字进行降序排序，这里我们将题目改变一下）
方式一：
思路解析：
使用一个方法sort(),这个方法，介绍如下：

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）

举例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
 
# 降序
vowels.sort(reverse=True)
#升序
vowels.sort(reverse=False)
 
# 输出结果
print ( '降序输出:', vowels )

代码解析：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import random
a = []
for i in range(10):
    a.append(random.randint(0, 100))
a.sort(reverse = False)
print(a)

在上面的方法中导入了一个random模块，这个模块用于生成整形随机数字，这里手写规定1到100的随机数字，

random() 方法返回随机生成的一个实数，它在[0,1)范围内。 注意：random()是不能直接访问的，需要导入 random
模块，然后通过 random 静态对象调用该方法。

方式二：
这种解题方法是我从网络上找的，里面包含了大量的关于Python3的方法，如果想深入研究者请看此方法
代码解析：
enumerate()方法介绍：

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
Python 2.3. 以上版本可用，2.6 添加 start 参数。

min()方法介绍：

min() 方法返回给定参数的最小值，参数可以为序列。

import random
A = []
for i in range(10):
    A.append(random.randint(0,100))
#将随机生成的数列正序输出
print(A)
x = A
for i, j in enumerate(x):
    T = x[i+1:]
    if T == []:
        break

    if x[i] > min(T):
        t = x.index(min(T))
        x[i], x[t] = x[t], x[i]
print(A)

方式三：
这个题目中原来包含的提示为：

可以利用选择法，即从后9个比较过程中，选择一个最小的与第一个元素交换，下次类推，即用第二个元素与后8个进行比较，并进行交换。

那么接下来我们就按照这种解题思路来进行解题
代码解析：

题目30，两个 3 行 3 列的矩阵，实现其对应位置的数据相加，并返回一个新矩阵：

思路分析：
先初始化两个规定了参数的的二维数组，然后再定义初始化之后的和的二维数组，将两个二维数组之和循环遍历到最后的二维数组里面
举例：

X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

Y = [[5,8,1],
    [6,7,3],
    [4,5,9]]
result = [[0,0,0],
         [0,0,0],
         [0,0,0]]

代码实现：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

X = [[12, 7, 3],
     [4, 5, 6],
     [7, 8, 9]]

Y = [[5, 8, 1],
     [6, 7, 3],
     [4, 5, 9]]

result = [[0, 0, 0],
          [0, 0, 0],
          [0, 0, 0]]

# 迭代输出行
for i in range(3):
    # 迭代输出列
    for j in range(3):
        result[i][j] = X[i][j] + Y[i][j]

for r in result:
    print(r)

注意：若不将结果二维数组初始化，会报错，本人亲有体会

因为期末统考与java算法比赛，每天只能更新一粒，但是不定时。。。。。。

题目31：求输入数字的平方，如果平方运算后小于 50 则退出。

我才如果有人看到这道题肯定心里想，这有什么难的，好吧，确实不难，但是你能用几种方法做出来，
哪一种方法最为简单，效率更高那
我首先贡献一种：
代码实现：

while 1:
    str =  int(input("请输入数字进行判断："))
    if pow(str,2) < 50 :
        print("你输入的数字不满足条件，程序已经推出")
        quit()
    else:
        print(pow(str,2))

下面就是看读者的想象力了，看看你们能用什么奇思妙想的手法把这个给做出来