print('----------------------------------------------------------------')


del list # 如果之前定义了List变量 使用list（）方法之前 必须删除 否则python无法识别指定的是函数还是变量 所以python命名应该避免用函数名用作变量名
x=list(prices.values())
print(x)
# << [2.5, 4.0, 5.0] # 拿下

# 通过values找到与之对应key的方法（语法：list(dict.keys())[list(dict.values()).index(values)]）
print(list(prices.keys())[list(prices.values()).index(5.0)])
# >> 薯条 完成

#　通过元组创建字典 语法：dict.fromkeys(seq,val) seq指定键值 val指定键值对应元素(为同一个)
m={}
l=[1,2,3]
k=[4,5,6]
dict01=m.fromkeys(l,k)
print(dict01)
# >> {1: [4, 5, 6], 2: [4, 5, 6], 3: [4, 5, 6]}
# 修改一个键值对应的数值
dict01[1]=[1,2,3]
print(dict01)
# >> {1: [1, 2, 3], 2: [4, 5, 6], 3: [4, 5, 6]}
# 怎么修改成功了。。。

# Python 集合（无序，不重复的元素序列）
# 语法：集合名={value1,values2,value3...} 或 集合名=set{value} 之前表述错误 该value包含了组成集合的所有元素
# 创建空集合必须使用set（），因为{}是规定为创建空字典
friend={'ly','zc','zy','scs','ly','zy','dky','scs'}
print(friend)
# >> {'dky', 'ly', 'scs', 'zy', 'zc'} 重复元素被过滤掉
'ly'in friend
# >> 判断元素是否在指定集合中 返回值为 true or false
# 集合间的运算
a=set('qwertyuasder')
print(a)
# >> {'e', 'd', 's', 'r', 'u', 'y', 'w', 'q', 'a', 't'} 也是自动过滤重复的元素
b=set('gfsfhdjsjyxuztwnfm')

c=a-b # 差集
print(c)
# >> {'e', 'a', 'r', 'q'} 返回一个a有b没有的数据元素的集合

# c=a+b
# print(c)
# >> TypeError: unsupported operand type(s) for +: 'set' and 'set' 用set创建的集合不支持+？
# d={'a','b','c'}
# e={'d','e','f'}
# c=d+e
# print(c)
# >> TypeError: unsupported operand type(s) for +: 'set' and 'set' 看来集合不支持 ’+‘运算

c=a|b
print(c) # 并集

c=a&b # 交集

c=a^b # 不同时包含于a和b的元素 交集的补集

# 集合同样支持集合推导式

# 集合的基本操作

# 添加元素
# 1
a={1,2,3}
a.add('wdnmd')
print(a)
# >> {1, 2, 3, 'wdnmd'} 添加成功
# 2
a.update('dqz') # 该方法的的参数可以为 列表 元组 和字典
print(a) # 添加字符串
# >> {1, 2, 3, 'z', 'q', 'd', 'wdnmd'} 类似于set（）方法 添加的是单个字符 而不是整个字符串

a.update([4,5,6])
print(a) # 列表
# >> {1, 2, 3, 4, 5, 6, 'd', 'wdnmd', 'z', 'q'} # 添加的为列表中的元素，而不是整个列表整体作为集合的一个元素对象
# 强化记忆 []列表 （）元组 {}字典or集合

# 移除元素
# 1
# a.remove()
# 移除不存在的元素会发生错误
# 2
a.discard(1) # 可以删除指定元素 如果删除元素不存在 不会报错
# 3
a.pop() # 随机删除集合中的一个元素 pop 方法首先会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除

# 计算集合元素个数
print(len(a))

# 清空集合
a.clear()
print(a)
#　>> set() 清空成功

# 判断元素是否在集合中
# 语法:x in 集合名 （返回 true or false）

# Python集合内置方法

# add() 为集合添加元素

# clear()   移除集合中的所有元素

# copy()    拷贝一个集合

# difference()  返回多个集合的差集
a={1,2,3,4,5}
b={1,4,6,8,9}
c=a.difference(b)
print(c)
# print(a) 做差集后a集合不变
# >> {2, 3, 5} 返回a-b（差集）

# difference_update()   移除集合中与指定集合相同的元素
c=a.difference_update(b)
print(c)

# discard() 删除集合中指定的元素
a.discard(5)

# intersection()    返回集合的交集
c=a.intersection(b)
print(c)
# >> {1,4} 返回a 与b的交集

# intersection_update() 返回集合的交集。
c=a.intersection(b)
print(c) # a与b的交集

# isdisjoint()  判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
c=a.isdisjoint(b)

# issubset()    判断指定集合是否为该方法参数集合的子集。

# issuperset()  判断该方法的参数集合是否为指定集合的子集

# pop() 随机移除元素

# remove()  移除指定元素

# symmetric_difference()    返回两个集合中不重复的元素集合。

# symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

# union()   返回两个集合的并集
a.union(b)

# update()  给集合添加元素
a.update('wdnmd') # 添加元素不能为整型 否则报错
print(a)
# >> {2, 3, 'm', 'd', 'w', 'n'}
a.clear()
a.update({'wdnmd'})
print(a)
# >> {'wdnmd'}
# a.update('字符串') 将字符串拆分为单个字符 一一添加到集合中去 重复的字符只会出现一次
# a.update({字符串}) 是将其作为一个集合添加到该集合中去
# 注意两者的区分
# 同样 若待添加的元素为元组时也要注意
a.update(('dqz'))
print(a) # 同样拆分为单个字符逐一添加
# >> {'z', 'q', 'd', 'wdnmd'}
# 若想要整个元组整体添加
a.clear()
a.update(('wdnmd',))
print(a)
# >> {'wdnmd'} 整体添加成功的关键是元组里面的逗号

#　集合注意事项
# set()创建集合与update（）函数的规则基本一致
a.clear()
a=set('wdnmd')
print(a)
# >> {'d', 'm', 'n', 'w'} 拆分为多个元素 排除重复元素
a=set(('wdnmddqz'))
print(a)
# >> {'q', 'd', 'w', 'z', 'n', 'm'} 同样摆脱不了被拆分的命运
a.clear()
a=set({'wdnmd'})
print(a)
# >> {'wdnmd'} 集合可以避免被拆分
a=set(('wdnmd','dqz'))
print(a)
# >> {'dqz', 'wdnmd'} # 元组有多个元素时也可以避免被拆分

# 使用set 方法创建集合时 列表和元组类型的作为参数 会被拆分去掉重复的元素
a.clear()
list1=[1,2,3,4,5]
a=set(list1)
print(a)
# >> {1, 2, 3, 4, 5}
tuple1=(2,3,4,5,6,2)
a=set(tuple1)
print(a)
# >> {2, 3, 4, 5, 6}
# 集合对list和tuple 具有升序排序的作用

# pop（）对于字典和字符转换的集合来说是随机删除的 但对于由列表和元组通过set方法创建的集合来讲 总是删除最左侧的
# 一个元素，也就是最小的元素，且总是最小的元素。

# 总结
# 添加元素
# setx.add(string|tuple|bool|number):void # 添加
# setx.update(y [,z...]):void # y、z 为 list|tuple|dict # 更新添加
# setx.clear():void # 清空
# setx.copy():set # 深拷贝（指向新的内存地址） 复制
print(a);print(id(a))
# >> {2, 3, 4, 5, 6} id1541843919360
b=set()
b=a.copy()
print(b);print(id(b))
# >> {2, 3, 4, 5, 6} id1955571705888 id发生变化指向新的内存

# 删除元素
# setx.remove(y):void|KeyError #如删除不存在的元素，有报错
# setx.discard(y):void # 删除指定元素
# setx.pop():mixed # 随机删除集合元素，并返回被删除的元素
# a.remove('a')
# >>  KeyError: 'a' 删除不存在的元素出现报错
a.discard(1)
# 删除不存在的元素不会报错
print(a.pop())
# 2 >> 总是删除最左侧第一个元素 但由于集合具有升序排序的作用 所以每次总是删除最小的元素
print(a)

# 右全包含布尔真：判断 setx 集合的所有元素是否都包含在 sety 集合中
# setx.issubset(sety):bool
# >>> x = {"a", "b", "c"}
# >>> y = {"f", "e", "d", "c", "b", "a"}
# >>> x.issubset(y)
# True
# setx ->sety 所谓右全包是指判断子集的方向
b={3,4,5,6,7}
print(a.issubset(b))
# >> True

# 左全包含布尔真: 判断 sety 集合的所有元素是否都包含在原始 setx 的集合中
# setx.issuperset(sety):bool
# >>> x = {"a", "b", "c"}
# >>> y = {"f", "e", "d", "c", "b", "a"}
# >>> y.issuperset(x)
# True
# setx <- sety  箭头指判断子集的方向为左
a={1,2,3,4}
b={1,2}
print(a.issuperset(b))
# >> true

# 右半包含布尔取反：判断集合 sety 中是否有集合 setx 的任一元素（包含返回 False，不包含返回 True）
# setx.isdisjoint(sety):bool

# 合并集合（并集）：(注意：集合元素的去重、唯一性)
# setx.union(sety [, setz...]):set
# >>> x = {"a", "b", "c"}cao.liu
# >>> y = {"f", "d", "a"}
# >>> z = {"c", "d", "e"}
# >>> x.union(y, z)
# {'c', 'd', 'f', 'e', 'b', 'a'}

# 左包含差集: 返回集合的差集，即返回的集合元素包含在第一个集合 x 中，但不包含在第二个集合 y(方法的参数)中
# setx.difference(sety):set

# 左引用删除交集（无返回值，即直接修改原内存指向）
# setx.difference_update(sety):void
# >>> x,y
# ({'banana', 'cshit', 'vipkwd.com', 'alipay'}, {'google', 'runoob', 'facebook', 'alipay'})>>> type(x.difference_update(y))
# <class 'NoneType'>
# >>> x,y
# ({'banana', 'cshit', 'vipkwd.com'}, {'google', 'runoob', 'facebook', 'alipay'})

# 左右差集：返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素
# setx.symmetric_difference(sety):set

# 左引用删除交集且引用追加右差集（引用操作，无返回值）
# setx.symmetric_difference_update(sett):void

# 左右交集：返回两个或更多集合中都包含的元素，即交集
# setx.intersection(sety[, seyz....]):set

# 左引用交集
# setx.intersection_update(sety):void

# 辅助理解：所有提到 “引用” 俩字的都是函数内部直接操作内存指向，故无返回值；
# 反之：如果一个函数没有实质返回值，那么它一定是在函数内部改变了其他位置内容，
# 否则这个函数就是 dog shit，因为它不具有实质的意义。

# Python 编程第一步
# 斐波那契函数（两元素的总和确定下一个函数）
a,b=0,1
while b<10:
    print(b)
    a,b=b,a+b # 相当于引入了两个中间变量 (n=b,m=a+b,a=n,b=m) 先计算等式右边 后赋值给等式右边的变量（迭代）
# >>
# 1
# 1
# 2
# 3
# 5
# 8
# 右边的表达式会在赋值变动之前执行，右边表达式的执行顺序是从左往右的
# 等号两边的表达式中 右边的表达式会先执行 而表达式执行的顺序是从左到右

a,b=0,1
while b<1000:
    print(b,end=',')
    a,b=b,a+b
# >> 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

# 递归方法
def fab(n):
    if n<1:
        print('输入有误')
        return -1
    if n==1 or n==2:
        return 1
    else:
        return fab(n-1)+fab(n-2)

print(fab(12))
# >> 144

# 利用字典实现
n=int(input("请输入一个整数："))
def fab(n):
     if n<1:
         print('输入有误')
         return  -1;
     if n==1 or n==2:
         return  1
     else:
         return fab(n-1)+fab(n-2)
result=[]
for i in  range(1,n+1):
    result.append(fab(i))
print(result)  # 列表返回

n=int(input('请输入一个整数:'))
dic={0:0,1:1}
def fib(n):
    if n in dic:
        return dic[n]
    else:
        temp=fib(n-1)+fib(n-2)
        dic[n]=temp
        return temp
for i in range(n):
    print(fib(i+1),end='')
# <<20 >> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
# <<20 >> 11235813213455891442333776109871597258441816765 存储成功

# r.py
import sys, getopt
# 递归算法 填充斐波拉契数列
x, y = 0, 1
f_len, f_max = [], []
f_len.append(x);
f_len.append(y)
f_max.append(x);
f_max.append(y)

# 按最大个数填充
def Fsqe_Len(n):
    if len(f_len) < n:
        Fsqe_Len(n - 1)
    m = f_len[n - 1] + f_len[n - 2]
    f_len.append(m)

# 按最大值填充
def Fsqe_Max(fmx):
    fmlen = len(f_max) - 1
    if f_max[fmlen] > fmx:
        del f_max[fmlen]
    else:
        m = f_max[fmlen - 1] + f_max[fmlen]
        f_max.append(m)
        Fsqe_Max(fmx)

lens = int(input('Fsqe_Len 输入最大个数：'))
maxs = int(input('Fsqe_Max 输入最大值：'))
if __name__ == '__main__':
    Fsqe_Len(lens)
    Fsqe_Max(maxs)
    print(f_len)
    print(f_max)


print('----------------------------------------------------------------')