#_*_coding:utf-8_*_

__author__ = 'Linhaifeng'

import time

person_list=['alex','wupeiqi','yuanhao','linhaifeng']

def ask_way(person_list):

    print('-'*60)

    if len(person_list) == 0:

        return '没人知道'

    person=person_list.pop(0)

    if person == 'linhaifeng':

        return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' %person

    print('hi 美男[%s],敢问路在何方' %person)

    print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' %(person,person_list))

    time.sleep(3)

    res=ask_way(person_list)

    # print('%s问的结果是: %res' %(person,res))

    return res

res=ask_way(person_list)

print(res)

递归问路

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]

def binary_search(dataset,find_num):

    print(dataset)

    if len(dataset) >1:

        mid = int(len(dataset)/2)

        if dataset[mid] == find_num:  #find it

            print("找到数字",dataset[mid])

        elif dataset[mid] > find_num :# 找的数在mid左面

            print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])

            return binary_search(dataset[0:mid], find_num)

        else:# 找的数在mid右面

            print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])

            return binary_search(dataset[mid+1:],find_num)

    else:

        if dataset[0] == find_num:  #find it

            print("找到数字啦",dataset[0])

        else:

            print("没的分了,要找的数字[%s]不在列表里" % find_num)

binary_search(data,66)

二分查找

f=lambda x,y:x+y

print(f)

print(f(1,2))

'''

#结果

<function <lambda> at 0x0000000000A4E0D0>

3

'''

print(max(salaries))            # 默认以字典的key作为元素对比

res=zip(salaries.values(),salaries.keys())      # 使用zip函数进行转换，以values作为key，以key作为values进行max求最大值

print(res)          # 一个zip对象

# print(list(res))

print(max(res))     # 最大值根据key来判断，此时res的可以为salarise的values值

'''

yuanhao     # 错误值

<zip object at 0x0000000000A45348>

(100000000, 'alex')

'''

def func(k):

    return salaries[k]

print(max(salaries))        # 默认以key进行对比，输出错误

print(max(salaries,key=func))       # 以key进行对比，同时将key传给函数func，形如:func(key)-->salaries[k],此时salaries[k]对应的是字典中的values,再次进行max求最大值后，获取最大值

print(max(salaries,key=lambda k:salaries[k]))

print(min(salaries,key=lambda k:salaries[k]))

print(sorted(salaries))     # 默认的排序结果是从小到到，默认以key对比

print(sorted(salaries,key=lambda x:salaries[x])) # 根据values作为对比，从小到大排列，输出key

print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) # 设置reverse=True,从大到小

'''

yuanhao         # 错误值

alex

alex

yuanhao

['alex', 'egon', 'wupeiqi', 'yuanhao']

['yuanhao', 'egon', 'wupeiqi', 'alex']

['alex', 'wupeiqi', 'egon', 'yuanhao']

'''

map()函数

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9]

如果希望把list的每个元素都作平方，就可以用map()函数：

因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算：

def f(x):

    return x*x

print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

输出结果：

[1, 4, 9, 10, 25, 36, 49, 64, 81]

注意：map()函数不改变原有的 list，而是返回一个新的 list。

利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。

由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。

任务

假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list：

输入：['adam', 'LISA', 'barT']

输出：['Adam', 'Lisa', 'Bart']

def format_name(s):

    s1=s[0:1].upper()+s[1:].lower();

    return s1;

print map(format_name, ['adam', 'LISA', 'barT'])

li=['alex','egon','shuke']

res=map(lambda x:x+' Love me',li)     # 它接收一个函数(lambda)和一个 list，并通过把函数 lambda(可以是任何函数对象，\只要能够处理list中的数据) 依次作用在 list 的每个元素上，得到一个新的 list 并返回

print(res)

print(list(res))

'''

<map object at 0x0000000000B64588>

['alex Love me', 'egon Love me', 'shuke Love me']

'''

nums=(2,4,9,10)

res1=map(lambda x:x**2,nums)

print(list(res1))

'''

[4, 16, 81, 100]

'''

# python3中reduce函数需要导入

from functools import reduce

li=[1,2,3,4,5]

print(reduce(lambda x,y:x+y,li))  # 默认的初始值为列表中的第一个元素，即x=li[0],之后会遍历li列表中的每一个元素进行求和操作，从li[1]开始

print(reduce(lambda x,y:x+y,li,100))  # 此处10为第一次传入的初始值,即x = 100,之后会遍历li列表中的每一个值进行求和操作，从li[0]开始

'''

15

115

'''

# 示例1

li=['alex-old','wupeiqi-old','yuanhao','egon']

res=filter(lambda x:x.endswith('old'),li)       # x.endswith('old')值为真,则储存元素，list参数中所有为假的元素都将被删除。

print(res)

print(list(res))

'''

<filter object at 0x00000000006D4908>

['alex-old', 'wupeiqi-old']

'''

#示例2

nums=[0,1,2,3,4,5,6,7]

res = filter(None,nums)         # 如果filter参数值为None，就使用identity()函数，list参数中所有为假的元素都将被删除。

print(list(res))

'''

[1, 2, 3, 4, 5, 6, 7]

'''

'''

1、数学运算

'''

# abs(-5)  # 取绝对值，也就是5

# round(2.623423, 4)  # 四舍五入取整，也就是3.0, 4为精准到四位四舍五入

# pow(2, 3)  # 相当于2**3，如果是pow(2, 3, 5)，相当于2**3 % 5

# divmod(9, 2)  # 返回除法结果和余数

# max([1, 5, 2, 9])  # 求最大值

# min([9, 2, -4, 2])  # 求最小值

# sum([2, -1, 9, 12])  # 求和

# int("5")  # 转换为整数 integer

# float(2)  # 转换为浮点数 float

# str(2.3)  # 转换为字符串 string

# bool(0)  # 转换为相应的真假值，在Python中，0相当于False在Python中，下列对象都相当于False：[], (), {}, 0, None, 0.0, ''

# slice(5, 2, -1)  # 构建下标对象 slice，切片函数

# list((1, 2, 3))  # 转换为表 list

# tuple([2, 3, 4])  # 转换为定值表 tuple

# dict(a=1, b="hello", c=[1, 2, 3])  # 构建词典 dictionary

# set()          创建集合函数

# frozenset()　　创建一个不可修改的集合 如:s=frozenset({1,2}) # 定义不可变集合

ord("A")  # "A"字符对应的数值

chr(65)  # 数值65对应的字符

bin(56)  # 返回一个字符串，表示56的二进制数

hex(56)  # 返回一个字符串，表示56的十六进制数

oct(56)  # 返回一个字符串，表示56的八进制数

complex(3, 9)  # 返回复数 3 + 9j

all([True, 1, "hello!"])        # 是否所有的元素都相当于True值

any(["", 0, False, [], None])   # 是否有任意一个元素相当于True值

reversed([1,5,3])               # 返回反序的序列，也就是[3,5,1]

# repr(me)                         # 返回一个对象的字符串表示。有时可以使用这个函数来访问操作。

# compile("print('Hello')",'test.py','exec')       # 编译字符串成为code对象

# eval("1 + 1")                     # 解释字符串表达式。参数也可以是compile()返回的code对象

'''

# cmd='print("你瞅啥")'

#

# dic="{'a':1,'b':2}"

# d=eval(dic)

# print(type(d),d['a'])

#

# with open('user.db','w',encoding='utf-8') as f:

#     user_dic={'name':'egon','password':'123'}

#     f.write(str(user_dic))

#

# with open('user.db','r',encoding='utf-8') as f:

#     dic=f.read()

#     print(dic,type(dic))

#     dic=eval(dic)

#     print(dic['name'])

'''

# exec("print('Hello')")            #  exec()执行字符串或complie方法编译过的字符串，没有返回值

'''

6、帮助函数

'''

# dir()　　不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表

'''

l=[]

print(dir(l)) #查看一个对象下面的属性

'''

# help()　　返回对象的帮助文档

'''

print(help(l))

'''

# id()　　返回对象的内存地址

'''

# x=1

# y=x

# print(id(x),id(y))

#

# print(x is y) #判断的是身份

'''

# len()　　返回对象长度，参数可以是序列类型（字符串，元组或列表）或映射类型（如字典）

# challable()　　判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例

'''

def func():

    pass

print(callable(func))

'''

#globals()　　返回一个描述当前全局变量的字典

#locals()　　打印当前可用的局部变量的字典

#vars() #等于locals()

'''

8、迭代器函数

'''

'''

iter(o[, sentinel])

返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。

如果没有提供第二个参数，参数o必须是一个集合对象，支持遍历功能（__iter__()方法）或支持序列功能（__getitem__()方法），

参数为整数，从零开始。如果不支持这两种功能，将处罚TypeError异常。

如果提供了第二个参数，参数o必须是一个可调用对象。在这种情况下创建一个iterator对象，每次调用iterator的next()方法来无

参数的调用o，如果返回值等于参数sentinel，触发StopIteration异常，否则将返回该值。

'''

# next()　　返回一个可迭代数据结构（如列表）中的下一项

# enumerate()　　# 返回一个可以枚举的对象，该对象的next()方法将返回一个元组

# x=range(10)

# enumerate([1,2,3]).__next__()

# range()　　根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数

# hash() 哈希值用于快递比价字典的键。

# 1. 只要校验的内容一致，那hash得到结果永远一样

# 2. 不可逆

# 3. 只要采用的哈希算法一样，那无论被校验的内容有多长，hash的到的结果长度都一样

# print(hash('asdfasdfsadf'))

# print(hash('asdfasdfsadf'))

# filter()　　过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据

'''

filter(function, iterable)

参数function：返回值为True或False的函数，可以为None。

参数iterable：序列或可迭代对象。

>>> def bigerthan5(x):

...     return x > 5

>>> filter(bigerthan5, [3, 4, 5, 6, 7, 8])

[6, 7, 8]

'''

# format()　　#格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法

'''

"I am {0}, I like {1}!".format("wang", "moon")

"I am {}, I like {}!".format("wang", "moon")

"I am {name}, I like {msg}!".format(name = "wang", msg ="moon")

'''

# input()　　#获取用户输入内容

# open()　　打开文件

# print()　　输出函数

# zip()　　拉链函数将对象逐一配对

# s='helloo'

# l=[1,2,3,4,5]

#

# z=zip(s,l)

# print(z)

# for i in z:

#     print(i)

# import time

# m=__import__('time') #以字符串的形式导入模块

# m.sleep(3000)

'''

map(function, iterable,...)

对于参数iterable中的每个元素都应用fuction函数，并将结果作为列表返回。

如果有多个iterable参数，那么fuction函数必须接收多个参数，这些iterable中相同索引处的元素将并行的作为function函数的参数。

如果一个iterable中元素的个数比其他少，那么将用None来扩展改iterable使元素个数一致。

如果有多个iterable且function为None，map()将返回由元组组成的列表，每个元组包含所有iterable中对应索引处值。

参数iterable必须是一个序列或任何可遍历对象，函数返回的往往是一个列表(list)。

li = [1,2,3]

data = map(lambda x :x*100,li)

print(type(data))

data = list(data)

print(data)

运行结果：

<class 'map'>

[100, 200, 300]

'''

#super()　　调用父类的方法

# isinstance()　　检查对象是否是类的对象，返回True或False

# issubclass()　　检查一个类是否是另一个类的子类。返回True或False

# classmethod()　　# 用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法

# staticmethod

# property

# delattr()　　# 删除对象的属性

# hasattr

'''

hasattr(object，name)

判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。

参数object：对象

参数name：特性名称

>>> hasattr(list, 'append')

True

>>> hasattr(list, 'add')

False

'''

#getattr()　　获取对象的属性

#setattr()　　与getattr()相对应

字典的运算：最小值，最大值，排序

salaries={

    'egon':3000,

    'alex':100000000,

    'wupeiqi':10000,

    'yuanhao':2000

}

迭代字典，取得是key，因而比较的是key的最大和最小值

>>> max(salaries)

'yuanhao'

>>> min(salaries)

'alex'

可以取values，来比较

>>> max(salaries.values())

>>> min(salaries.values())

但通常我们都是想取出，工资最高的那个人名，即比较的是salaries的值，得到的是键

>>> max(salaries,key=lambda k:salary[k])

'alex'

>>> min(salaries,key=lambda k:salary[k])

'yuanhao'

也可以通过zip的方式实现

salaries_and_names=zip(salaries.values(),salaries.keys()) 

先比较值，值相同则比较键

>>> max(salaries_and_names)

(100000000, 'alex')

salaries_and_names是迭代器，因而只能访问一次

>>> min(salaries_and_names)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

ValueError: min() arg is an empty sequence

sorted(iterable，key=None,reverse=False)