1、一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

fib = **lambda** n: n **if** n <= 2 **else** fib(n - 1) + fib(n - 2)#解法1

image

2、冒泡排序：

 def qsort（lists):
     count = len(lists)
     for i in range(0, count): 
         for j in range (i+1,count):
             if lists[i] > lists[j]:
                 lists[i],lists[j] =  list[j],lists[i]
     return lists
 if __name__ == "__main__":
     lists = [3,1,8,4,3,5]
     qsort = qsort(lists) 
     print("冒泡排序："，qsort)

3.字典排序

>> d = {'a':98,'b':82,'c':79,'d':53,'e':78}
>>
>> a =list(zip(d.values(),d.keys()))
>>
>> print(sorted(a))
>> [(53, 'd'), (78, 'e'), (79, 'c'), (82, 'b'), (98, 'a')]

4.快排

 def quickSort(unsortedList): 
     if len(unsortedList)<2:
        return unsortedList 
        less=[]
        greater=[]
        middle=unsortedList.pop(0)
        for item in unsortedList:
        if item < middle:
            less.append(item)
        else:
            greater.append(item)
        return quickSort(less)+[middle]+quickSort(greater

5.栈

class Stack(object):
    # 初始化栈为空列表
    def __init__(self):
        self.items = []

    # 判断栈是否为空，返回布尔值
    def is_empty(self):
        return self.items == []

    # 返回栈顶元素
    def peek(self):
        return self.items[len(self.items) - 1]

    # 返回栈的大小
    def size(self):
        return len(self.items)

    # 把新的元素堆进栈里面（程序员喜欢把这个过程叫做压栈，入栈，进栈……）
    def push(self, item):
        self.items.append(item)

    # 把栈顶元素丢出去（程序员喜欢把这个过程叫做出栈……）
    def pop(self, item):
        return self.items.pop()


if __name__ == __main__:
    # 初始化一个栈对象
    my_stack = Stack()
    # 把'h'丢进栈里
    my_stack.push('h')
    # 把'a'丢进栈里
    my_stack.push('a')
    # 看一下栈的大小（有几个元素）
    print my_stack.size()
    # 打印栈顶元素
    print my_stack.peek()
    # 把栈顶元素丢出去，并打印出来
    print my_stack.pop()
    # 再看一下栈顶元素是谁
    print my_stack.peek()
    # 这个时候栈的大小是多少？
    print my_stack.size()
    # 再丢一个栈顶元素
    print my_stack.pop()
    # 看一下栈的大小
    print my_stack.size
    # 栈是不是空了？
    print my_stack.is_empty()