Python 之 递归 字典 集合

马山要期末考试了，又要开始卑微的学习了

递归的使用

• 递归函数的书写，踩坑： 函数语句中都会有if else 语句中，每句都有return，如果if语句中没有return，起步递归将返回None；如果else语句中没有return语句，递归将会返回None

"""
递归
"""


def function1(number):  # 非递归函数，求阶乘
    result = 1
    for i in range(1, number + 1):
        result = i * result
    return result


def function2(number):  # 递归函数，求阶乘
    if number == 1:
        return 1
    else:
        return number * function2(number - 1)  # return必须有，否则返回None，你知道为什么吗？？


n = int(input("请输入一个数："))
print("%d的阶乘是%d" % (n, function1(n)))  # 6的阶乘是720
print('%d的阶乘是%d' % (n, function2(n)))  # 6的阶乘是720

斐波那契数列的递归与迭代书写

斐波那契数列的递归书写:

• 可以看出，递归书写更加符合斐波那契数列函数以及人类的思维
• 递归可以使代码简洁，可读性增加，但同时也会增加时间 空间的复杂度

def f1(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return f1(n - 1) + f1(n - 2)
print(f1(12))  # 144

斐波那契数列的迭代书写:

• 利用迭代的思想可以完成斐波那契数列的书写，但理解起来需要下一番功夫
• 合理运用递归操作在以后的代码生涯是非常必要的

def f2(n):
    n1 = 1
    n2 = 1
    n3 = 1
    while (n - 2) > 0:
        n3 = n2 + n1  # n3在这里没啥实际意义，就是为了完成下面n1 n2 的赋值操作
        n1 = n2
        n2 = n3
        n -= 1
    print(n)
    if n == 1:
        return n1
    else:
        return n2
print(f2(12))  # 144        

运用递归完成汉诺塔问题

汉诺塔是一种益智玩具，源自古老的印度。如图1、图2及图3所示，有三根柱子，若干个大小不等的圆盘按顺序依次叠落在起点（左侧）的柱子上，通过多次移动后，全部圆盘要叠落在终点（右侧）的柱子上。移动必需遵守两个原则：

1. 每次只能移动一个圆盘
2. 移动过程中，大圆盘不允许覆盖在小圆盘上。
   
   
   

def h(n, x, y, z):
    if n == 1:
        print(x, '--->', z)
    else:
        h(n - 1, x, z, y)  # 这一步可以理解为先把n-1层移动到y柱
        print(x, '--->', z)  # 在上一步的基础上，把最大的那个从x柱移动到z柱
        h(n - 1, y, x, z)  # 以上两步的基础上，发现跟n层的变化就是起始位置x柱变成了y柱，故，将y柱与x柱变换

唯一的映射类型 —— 字典

• 字典是键 值的组合，属于Python中唯一的映射类型
• 可以利用可迭代序列（iterable）和遍历赋值 来创建字典
• 可以利用可迭代序列（iterable）构成的映射关系来创建字典
• 利用工厂函数dict() 关键字参数来创建字典
• 根据键对字典进行修改时，如果字典中没有指定的 键 ，则会直接增加一对键值对

d = {}  # 创建空字典
d1 = dict()
print(d)
print(d1)
dict1 = {'name': "cc雪影", 'sex': '男', 'age': '21'}  # 创建非空字典
print(dict1['name'], dict1['age'])
iterable = ((1, 'one'), (2, 'two'))  # 利用可迭代序列构成的
for k, v in iterable:
    d[k] = v
print(d)
dict2 = dict(((1, 'one'), (2, 'two'), (3, 'three')))  # 利用元组或列表构成映射关系(maping)来创建字典
print(dict2)  # dict2: {1: 'one', 2: 'two', 3: 'three'}
dict3 = dict(name='cc雪影', sex='男', age='21')  # 用关键字参数来创建字典
print(dict3)  # dict3: {'name': 'cc雪影', 'sex': '男', 'age': '21'}
print(dict3['name'])  # cc雪影
dict3['name'] = '老王'  # 字典值的修改 dict3: {'name': '老王', 'sex': '男', 'age': '21'}
dict3['heigh']='187cm'  # 字典键值对的修改 {'name': '老王', 'sex': '男', 'age': '21', 'heigh': '187cm'}

字典的常用方法

• fromkeys(iterable，value)，创建字典，而且不会在原有字典的基础上修改，而是直接创建一个新的字典
• keys() 以列表的形式（并非直接的列表，若要返回列表值还需调用list函数）返回字典所有的键
• values() 以列表的形式（并非直接的列表，若要返回列表值还需调用list函数）返回字典所有的值
• items() 以列表的形式（并非直接的列表，若要返回列表值还需调用list函数）返回字典所有可遍历的(键, 值) 元组数组
• get() 可以根据键来获取 值，也可以根据键对来获取 值，如果字典中不存在该键值对，则自动增加并返回 值
• in 与 not in 用来判断 键 是否在字典里，返回值为Bool类型
• copy() 浅copy，不同与赋值，浅copy是将字典复制产生新的字典
• popitem() 随机弹出（键，值），可以进行赋值，会改变原字典
• pop() 根据 键 弹出 值，可以进行赋值，会改变原字典
• setdefault() 给字典增加键值对
• update() 将字典并入字典中,dict.update(dict)
• clear() 清空字典

dict0 = {}
dict1 = dict0.fromkeys((1, 2, 3))  # dict1: {1: None, 2: None, 3: None}
dict2 = dict0.fromkeys((1, 2, 3), "hello")  # dict2:{1: 'hello', 2: 'hello', 3: 'hello'}
dict3 = dict0.fromkeys((1, 2, 3), ('one', 'two', 'three'))
# dict3: {1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}
dict2 = dict2.fromkeys((1, 3), 'hi')  # 重新创建一个新的字典 {1: 'hi', 3: 'hi'}而不是在原有字典的基础上修改，
dict4=dict0.fromkeys(range(6),'牛')  # {0: '牛', 1: '牛', 2: '牛', 3: '牛', 4: '牛', 5: '牛'}
for eachKey in dict4.keys():  # 打印 键
    print(eachKey,end=' ')  # print:  0 1 2 3 4 5
for eachValue in dict4.values():  # 打印 值
    print(eachValue,end=' ')  # print:  牛 牛 牛 牛 牛 牛
for eachItem in dict4.items():  # 打印 象
    print(eachItem,end=' ') # print:  (0, '牛') (1, '牛') (2, '牛') (3, '牛') (4, '牛') (5, '牛')
print(dict4.get(5))  # 牛
print(dict4.get(4,'牛'))  # 牛
print(dict4.get(6,"B"))  # B
print(dict4)  # dict4: {0: '牛', 1: '牛', 2: '牛', 3: '牛', 4: '牛', 5: '牛'}
print(4 in dict4)   # 查找的是键而不是值,打印的是 True
a=dict4.copy()  # 浅copy，把子字典复制后让 a 管理
b=dict4  # 赋值操作，dict4 和 b 共同管理字典{0: '牛', 1: '牛', 2: '牛', 3: '牛', 4: '牛', 5: '牛'}
print('id(a):',id(a)," ",'id(b):',id(b)," ",'id(dict4):',id(dict4))
str1=dict4.popitem() # 随机弹出一个像，可以进行赋值 str1='(5, '牛')'
str2=dict4.pop(1)  # pop()根据 键 弹出 值，可以进行赋值 str2='牛'
print(dict4)  # dict4: {0: '牛', 2: '牛', 3: '牛', 4: '牛'},可以看出popitem(),pop()均会改变原字典
dict4.setdefault(7) # {0: '牛', 2: '牛', 3: '牛', 4: '牛', 7: None}
dict4.setdefault(8,'赞赞赞')  # {0: '牛', 2: '牛', 3: '牛', 4: '牛', 7: None, 8: '赞赞赞'}
dict5={7:'update'}
dict4.update(dict5)  # dic4: {0: '牛', 2: '牛', 3: '牛', 4: '牛', 7: 'update', 8: '赞赞赞'}
dict4.clear()  # 清空字典 dict4: {}

我们熟悉的 集合

• 集合的唯一性：集合的元素不重复
• 集合的无序性：不可以通过索引来获取元素
• in , not in 可以用来判断元素是否在集合中
• add() 增加集合的元素
• remove() 去除集合中指定的元素
• frozen() 不可变集合，没有add() remove()

num1 = {1, 2, 3}  # 创建一个集合
num2 = set([1, 2, 3])  # 利用set工厂函数创建集合,参数是一个可迭代序列（iterable）
num3 = {1, 3, 4, 2, 1}  # 集合的唯一性,num2: {1, 2, 3, 4} 注：集合是无序的
print(num2)
# 关于去除列表中重复元素的两种常见方法
# 1、使用遍历去除列表重复的元素
list1 = [1, 3, 4, 3, 4, 2, 1, 3, 0, 1]
list2 = []
for each in list1:
    if each not in list2:
        list2.append(each)
print(list2)  # [1, 3, 4, 2, 0]
# 2、利用集合元素唯一性去除列表重复的元素
list3 = list1.copy()
set1 = set(list3)
list4 = list(set1)
print(list4)  # [0, 1, 2, 3, 4]
# 判断元素是否在集合中 in 、not in
print(1 in set1)
print('1'in set1)
set1.add(5)  # 增加集合的元素 set1: {0, 1, 2, 3, 4, 5}
set1.remove(5)  # 去除集合中的指定元素 set1: {0, 1, 2, 3, 4}
set2=frozenset([1,2,3])  # 不可变集合，没有add() remove()