python 内置函数02

1. lambda 匿名函数
lambda 参数: 返回值

#常规计算两个数相加的函数
def func(a,b):
    return a+b
print(func(1,9))
#lambda函数
my_add=lambda a,b:a+b
print(my_add(1,2))

2. sorted 排序
sorted(iterable, key=func, reverse=True/False)
执行流程:
把可迭代对象中的每一个元素拿出来, 放到func中运行. 返回一个数字. 根据数字进行排序

lis=["s","as","good","bash"]
new_lis1=sorted(lis)#['as', 'bash', 'good', 's']
new_lis2=sorted(lis,key=lambda el:ascii(el))#['as', 'bash', 'good', 's']
new_lis3=sorted(lis,key=lambda el:ascii(el),reverse=True)#['s', 'good', 'bash', 'as']
new_lis4=sorted(lis,key=lambda el:ascii(el),reverse=False)#['as', 'bash', 'good', 's']
print(new_lis1)
print(new_lis2)
print(new_lis3)
print(new_lis4)

3. filter 筛选
filter(func, Iterable)
执行流程:
把可迭代对象中的每一个元素拿出来, 放到func中运行.返回True/False. 根据返回的True和False来决定这个数据是否保留

lst = [{"id": 1, "name": 'bgm', "age": 18},
    {"id": 2, "name": 'girl', "age": 16},
    {"id": 3, "name": 'cat', "age": 17},
       {"id": 4, "name": 'salt', "age": 37}]
#现在按照年龄筛选大于等于18的
f=list(filter(lambda dic:dic["age"]>=18,lst))
print(f)#[{'id': 1, 'name': 'bgm', 'age': 18}, {'id': 4, 'name': 'salt', 'age': 37}]

4. map 映射
map(func, Iterable)
执行流程:
把可迭代对象中的每一个元素拿出来, 放到func中运行.返回数据就是结果

lst=[1,3,4,6,8,9,13,15]
s=list(map(lambda x:x**2,lst))
print(s)#[1, 9, 16, 36, 64, 81, 169, 225]

5. 递归(难点)
自己调用自己
递归的入口
递归的出口: return
递归的循环条件：动
循环树形结构:

#用递归来数1-100
def func(num):
    print(num)
    if num==100:
        return
    func(num+1)
func(1)

6. 二分法查找
核心思想: 掐头结尾取中间.
前提条件: 有序.

lst=[1, 1, 1, 1, 2, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 7, 8, 8, 9, 16, 32, 44, 55, 78, 89]
n=9
left=0
right=len(lst)-1
while left<=right:
    mid = (right+left) // 2
    if n>lst[mid]:
        left=mid+1
    elif n<lst[mid]:
        right=mid-1
    else:
        print("这个数在里面")
        break
else:
    print("这个数不在此列表")

1，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
name=[‘oldboy’,'alex','wusir']

name=["hahah",'xxx','class']
new_name=list(map(lambda el:el+"_sb",name))
print(new_name)

1，用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
l=[{'name':'alex'},{'name':'y'}]

l=[{'name':'skt'},{'name':'y'}]
new_l=list(map(lambda dic:dic["name"]+"_sb",l))
print(new_l)

6，用filter来处理,得到股票价格大于20的股票名字

shares={
       'IBM':36.6,
       'Lenovo':23.2,
      'baidu':21.2,
    'ocean':10.2,
    }
# for i in shares:
#     print(i)
f=list(filter(lambda key:shares[key]>20,shares))
print(f)

7,有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。

结果：list一下[9110.0, 27161.0,......]

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}]

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}]
portfolio_new=list(map(lambda dic:dic["shares"]*dic["price"],portfolio))
print(portfolio_new)#[9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]

8,还是上面的字典，用filter过滤出单价大于100的股票。

 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}]
 f=list(filter(lambda dic:dic["price"]>100,portfolio))
 print(f)

9,有下列三种数据类型，

l1 = [1,2,3,4,5,6]
l2 = ['oldgirl','any','wsbsir','太白','日天']
tu = ('**','***','****','*******')

写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个）

[(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。

l1 = [1,2,3,4,5,6]
l2 = ['oldgirl','any','wsbsir','太白','日天']
tu = ('**','***','****','*******')

f=list(filter(lambda lis:lis[0]>=3,zip(l1,l2,tu)))

print(f)#[(3, 'wsbsir', '****'), (4, '太白', '*******')]

有如下数据类型：

l1 = [ {'sales_volumn': 0},
      {'sales_volumn': 108},
      {'sales_volumn': 337},
      {'sales_volumn': 475},
      {'sales_volumn': 396},
      {'sales_volumn': 172},
      {'sales_volumn': 9},
      {'sales_volumn': 58},
      {'sales_volumn': 272},
      {'sales_volumn': 456},
      {'sales_volumn': 440},
      {'sales_volumn': 239}]

将l1按照列表中的每个字典的values大小进行排序，形成一个新的列表。

 l1 = [ {'sales_volumn': 0},
         {'sales_volumn': 108},
         {'sales_volumn': 337},
         {'sales_volumn': 475},
         {'sales_volumn': 396},
         {'sales_volumn': 172},
         {'sales_volumn': 9},
         {'sales_volumn': 58},
         {'sales_volumn': 272},
         {'sales_volumn': 456},
         {'sales_volumn': 440},
         {'sales_volumn': 239}]
 ll_new=sorted(l1,key=lambda dic:dic['sales_volumn'])
 print(ll_new)