python的相关问题（此文包含6个）

问题1.

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

推理过程：

当百位为1时	从2，3，4中取两个数，就有3 * 2 = 6种取法
当百位为2时	从1，3，4中取两个数，同样有3 * 2 = 6种取法
当百位为3时	从1，2，4中取两个数，就有3 * 2 = 6种取法
当百位为4时	从2，3，4中取两个数，同样有3 * 2 = 6种取法

如上表可发现：百位有 4 种取法 ,所以百位结合十位和个位就有4 * 3 * 2种取法，这和阶乘很相似，因为 * 1并不影响最终结果。因此第一问代码如下（当然，先遍历出最终结果再计算个数也可以，我只是发现这个东西和阶乘很相似，可以用阶乘来计算个数而已）：

def arr(n):
    if n==1:
        return 1
    return n*arr(n-1)                           #发现阶乘也可以求其个数
print("能组成",arr(4),"个互不相同且无重复数字的三位数")

第二问：直接通过嵌套的for循环来求即可，代码如下：

lista=[1,2,3,4]                                  #创建数组对象
for i in range(1,len(lista)+1):                  #遍历百位
    for j in range(1,len(lista)+1):              #遍历十位
        for z in range(1,len(lista)+1):          #遍历个位
            if i!=j and j!=z and i!=z:           #百位！=十位；十位！=个位；百位！=个位
                print(i,j,z)                     #满足以上条件打印
            else:
                pass

问题2.

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

推理过程：

递归函数的特点就是先压栈，当满足某个条件时，再进行出栈。即遵从后进先出的规则。然后结合题意和我自己的想法结合起来

代码如下：

def fun(stri):                                    #先定义递归函数
    if len(stri)==0 or len(stri)==1:              #如果切片字符串的长度为0，或者为1
        return stri                               #满足临界值，返回当前字符串，即逐层释放临时内存
    else:
        return fun(stri[1:])+stri[0]#返回切掉第一个元素后的列表以及被切掉的第一个元素，其中被切掉的元素存储在临时内存里
while True:
    stri=input("请从键盘输入5个字符：")             #获取键入的内容
    n=len(stri)                                   #计算长度
    if stri=='q':                            #因为我应用了while循环，所以加了个退出条件
        print("已退出程序")                     
        break
    else:                                      
        if n!=5:                             #如果输入的字符串长度不等于5
            print("输入有误，请重新输入！")    
        else:
            print(fun(stri))                 #满足条件，调用递归函数并打印输出
        print("直接键入'q'键可退出！")

问题3.

求100之内的素数。

推理过程：

素数（质数）：即除数为大于1的任何正整数，只有当除数等于被除数本身时，模才为0的数为素数。
由于我利用了被除数为除数的遍历范围，并且range本身不包含上界的特点，即除数始终介于2~被除数之间，因此总结出，以下代码中，只要模不为0，方为素数。

代码如下：

lista=[]                    #定义一个空列表，为了存储素数
for i in range(2,100):      #遍历2~100之间的数作为被除数
    for j in range(2,i): #由于被除数大于除数才有意义，所以被除数为除数的遍历范围
        if (i%j==0):        #求模（求余数）
            break
    else:
        lista.append(i)  #只有余数不为零时，为素数，并追加到列表
print(lista)                #打印生成的素数列表

问题4.

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

推理过程见下表：

排号列表	1	2	3	4	5
报数	1	2	3	1	2
去掉	–	–	3	–	–
新列表	1	2	–	4	5
报数	3	1	–	1	2
去掉	1	–	–	–	–
新列表	–	2	–	4	5
报数	–	1	–	2	3
去掉	–	–	–	–	5
新列表	–	2	–	4	–
报数	–	1，3	–	2	–
去掉	–	2	–	–	–
最终	–	–	–	4	–

每行报数中的粗体1是开始报数的人的位置

具体代码如下：

num = int(input("请输入人数n(n>0):"))          #获取从键盘输入的值
lista = list(range(1, num + 1))               #生成列表lista
def reserve(lista, num):                      #定义递归函数
    if num == 1 or num == 2:                  #当用户输入1或2时
        return lista[num - 1]                 #直接返回（推导可得）
    else:
        index = num % 3                       #求模
        m = num // 3                          #整除三，算出有几个人退出
        for i in range(m, 0, -1):
            lista.remove(lista[3 * i - 1])    #从lista表中通过下标移除对应元素
            ln = lista[-index:] + lista[:-index] #生成新的列表
        return reserve(ln, num - m)             #返回新列表，以及新列表对应的元素个数
re = reserve(lista, num)                       #创建函数对象
print("最后留下来的是原来第{0}号的那位".format(re)) #打印最后列表中剩下的元素

问题5.

使用装饰器是实现性能测试，在每次调用某个函数的时候，都要计算一下被调用的函数所消耗的时间。

装饰器：

有利于代码重用，增加灵活性,打印日志，性能测试，事务管理。装饰器其实就是一个函数，当装饰器装饰了其他的函数时，会替代其他的函数执行。外部装饰器函数必须返回内部函数，回调机制

代码如下：

import time
def dec(f):
    def wrapper():
        startTime = time.clock()
        f()                   #f()即代表调用 实体函数login()
        endTime = time.clock()
        print(endTime-startTime)
        pass
    return wrapper             #外部装饰器函数必须返回内部函数，回调机制

@dec  # @装饰器名称，后面开始定义被装饰的函数
def login():
    print("100行代码")
    print("春眠不觉晓")
    print("处处蚊子咬")
    print("北京真是好")
    print("知了真不少")
    time.sleep(0.5)             #让程序休眠0.5s后执行
    pass

login()

问题6.

AOP编程思想，写出自己的总结和思考。

Aspect Orentied Programming (AOP,面向切面编程)
Object Orentied Programming (OOP,面向对象编程)
AOP编程是以OOP为基础,OOP侧重点是对象抽象和封装,
AOP侧重点是共通处理部分的封装和使用.用于改善共通组件和目标组件之间的关系(低耦合:耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。目的是使程序模块的可重用性、移植性大大增强。)

如有纰漏，请多指教