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

时间 2020-01-17 标签 python 练习案例天天坚持一粒按时服下

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

python练习案例100册之无脑解题法

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

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

#!/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)

**git

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

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

# -*- 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最小。**
特别麻烦的思路通常是将一个值与另外两个值进行比较，代码以下，很是不建议：sql

#!/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三、2一、3四、……。
在数学上，费波那契数列是以递归的方法来定义：
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制定循环到指定的位数，而后用字符串拼接添加到列表中
代码实现：app

#!/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=“”意思是以什么样的符号结尾，什么都不写会有结尾，可是看不见罢了，若是换成其余的符号看看效果如何。
方式二：
思路解析：
这里加了能够由键盘控制行数，并且也采用了在我高中时期学的一种数学运算，控制步长方面，须要注意，由于观察图形不难看出，图形的个数为一、三、五、七、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位的正整数，要求：1、求它是几位数，2、逆序打印出各位数字

方式一：
思路解析;
获取是几位数，最简单的方式就是将输入的数转型为列表，而后用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]]