python基础------内置函数、递归 匿名函数 map() filter() reduce() max()和min() sorted() enumerate() zip() homework 函数递归
匿名函数就是不需要显示的函数
# 这么写貌似和下面普通的函数没啥区别
f1 = lambda x: x**2
print(f1(10)) # 100
def f(x):
return x**2
print(f(10)) # 100
匿名函数奇淫用法
# 用max()方法计算下面工资最高的人
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
a = max(salaries, key=lambda x: salaries[x])
print(a) # alex
f = lambda x: salaries[x] < 10000 # 判断工资小于10000
print(f("egon")) # True
map()
map可以根据提供的函数对指定序列做映射，它接受一个函数f和一个list,并通过把函数f以此作用在list上的每个元素，然后返回一个新的list,map函数的入参也可以是多个.注意这个函数一定要有返回值.一定要有返回值.一定要有返回值.
map(func,*iterable)
def f(x):
return x**2
l =[1, 2, 3]
b = map(f, l)
print(list(b)) # [1, 4, 9]
# 此时的b是一个map 对象，他本身有__iter__和__next__方法，所以它是一个迭代器
a = map(lambda x: x**2, l)
print(list(a)) # [1, 4, 9]
filter()
filter函数接受一个函数f和一个list,这个函数f的作用是对每个元素进行判断,返回True或者False,这样可以过滤掉一些不符合条件的元素，然后返回符合条件的list.
# filter
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
#通过filter函数输出工资大于10000的人名
c = filter(lambda m:salaries[m] > 100000,salaries)
print(list(c)) # ['alex']
reduce()
reduce函数的用法和map很类似,也是一个函数f和一个list,但是函数的入口参数一定要是两个，reduce也是对每个元素进行反复调用，最后返回最终的值，而map是返回一个list.在python3里面reduce已经从全局函数里面移除了，需要用的话要from functools import reduce
from functools import reduce
l=[1, 2, 3]
b = reduce(lambda x,y: x+y,l)
print(b) # 6
max()和min()
max()返回一个可迭代对象的最大值,如果比较的是字典，默认会比较字典的key，如果制定关键字key，则比较关键key，返回仍是字典的key。
# max,找出工资最高的那个人
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
res = max(salaries, key=lambda x: salaries[x])
print(res)
sorted()
对一个可迭代对象进行排序，默认升序，返回一个新列表。
# sorted
l = [1, 3, 2, 5 ]
s= sorted(l)
print(s) # [1, 2, 3, 5]
根据字典的value进行排序，输出字典的key
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
# 通过key/函数进行排序
s = sorted(salaries,key=lambda x: salaries[x],reverse=True)
print(s) # 按value从大到小排序，输出key
# ['alex', 'wupeiqi', 'egon', 'yuanhao']
enumerate()
python中enumerate方法，返回一个enumerate类型。参数一般是一个可迭代对象。
enumerate(sequence, [start=0]) #不写start，默认从0开始
for i in enumerate(["a", "b", "c", "d", "e"],2):
print(i)
# (2, 'a')
# (3, 'b')
# (4, 'c')
# (5, 'd')
# (6, 'e')
zip()
zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表
# zip
l =[1, 2, 3, 4, 5]
s = "hello"
t = zip(l,s)
print(list(t)) # [(1, 'h'), (2, 'e'), (3, 'l'), (4, 'l'), (5, 'o')]
zip()奇淫之构建字典
# zip构建字典
l =[1, 2, 3, 4, 5]
s = "hello"
d = dict(list(t))
print(d) # {1: 'h', 2: 'e', 3: 'l', 4: 'l', 5: 'o'}
homework
# #用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb
name=['alex','wupeiqi','yuanhao']
# s = map(lambda x: x+"_sb", name)
# print(list(s)) # ['alex_sb', 'wupeiqi_sb', 'yuanhao_sb']
#用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
l=[{'name':'alex'},{'name':'y'}]
# s = map(lambda x: "_".join([x["name"],"sb"]), l)
# print(list(s)) # ['alex_sb', 'y_sb']
# =====================作业二
#用filter来处理,得到股票价格大于20的股票名字
shares={
'IBM':36.6,
'Lenovo':23.2,
'oldboy':21.2,
'ocean':10.2,
}
# name = filter(lambda x:shares[x] > 20 ,shares)
# print(list(name)) # ['Lenovo', 'IBM', 'oldboy']
# =====================作业三
#如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
# 1:map来得出一个包含数字的迭代器，数字指的是：购买每支股票的总价格
nums = map(lambda x: x["price"] * x["shares"], portfolio)
# print(list(nums)) # [9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]
# 2:基于1的结果，用reduce来计算，购买这些股票总共花了多少钱
from functools import reduce
total_price = reduce(lambda x,y:x+y,nums)
print(total_price) # 51009.75
# 3：用filter过滤出，单价大于100的股票有哪些
high_shares = filter(lambda x:x["price"] > 100, portfolio)
# print(list(high_shares)) # [{'shares': 50, 'price': 543.22, 'name': 'AAPL'}, {'shares': 75, 'price': 115.65, 'name': 'ACME'}]
n = map(lambda x:x["name"] ,high_shares)
print(list(n)) # ['AAPL', 'ACME']
函数递归
递归在内存中保留在栈中
递归必须有一个明确的结束条件
每次进入深一层递归，规模相比上次应该有所减少
递归效率不高，递归过深容易导致栈溢出
# 递归
def age(n):
if n == 1:
return 10
else:
return age(n-1) + 2
print(age(5)) # 18
# age(5) = age(4) + 2
# age(4) = age(3) + 2
# age(3) = age(2) + 2
# age(2) = age(1) + 2
# age(1) = 10
# age5 = ((((age(1) + 2) + 2) + 2) +2)
递归应用，二分法找数据
# 二分法找数据
data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
def search(num,data):
print(data)
if len(data) > 1:
mid_index = int(len(data)/2)
mid_value = data[mid_index]
if mid_value ==num:
print("find it")
return 0
elif mid_value > num:
data = data[:mid_index]
return search(num,data)
else:
data = data[mid_index:]
return search(num,data)
else:
if data[0] == num:
print("find it ")
else:
print("num not find")
search(19,data) # num not find
# [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
# [18, 20, 21, 22, 23, 30, 32, 33, 35]
# [18, 20, 21, 22]
# [18, 20]
# [18]
# num not find
二分法查找数据解法二：
data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
def search1(num,data):
min1 = 0
max1 = len(data)-1
if num in data:
while True:
center = int((min1+max1)/2)
if data[center]>num:
max1 = center
elif data[center]<num:
min1 = center
elif data[center]==num:
print("find it--"+str(num))
return 0
else:
print("没有该数字")
search1(3,data)
data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35, 37]
# python二分法
def search(data,num):
min_index = 0
max_index = len(data)-1
while min_index <= max_index:
middle_index = int((max_index+min_index) / 2)
print(data[min_index:max_index],"->",min_index,middle_index,max_index)
if data[middle_index] > num:
max_index = middle_index-1
elif data[middle_index] < num:
min_index = middle_index+1
elif data[middle_index] == num:
print("you find it")
return
print("找不到")
return
search(data,24)