七. python进阶(内置函数和高阶函数)

一. 内置函数

查看链接

# zip
li1=["张三","李四","王五"]
li2=["22","33","55"]
li4=["15kg","85kg","99kg"]
bb=zip(li1,li2,li4)
# print("__iter__" in  bb)
print(bb)
for i in bb:
    print(i)


# eval()
ss="[22,33,'zhansg']"
ret=eval(ss)
print(ret)

st="8+9"
print(eval(st))


stre="for i in range(66): print(i)"
c=compile(stre,"","exec")
print(c)

 https://www.cnblogs.com/nickchen121/p/10796073.html

https://www.processon.com/view/link/5b4ee15be4b0edb750de96ac#map

https://www.runoob.com/python/python-built-in-functions.html

二. 内置高阶函数

高阶函数  函数接收的参是一个函数名 返回值包含函数
把函数当作一个参数传给另一个函数

def a(n):
  print(n)

def b(name):
   print('my name is 哈哈哈')
a(b('111111111111111111111111111111111'))

 # my name is 哈哈哈
 # None

def a(n):
  print(n)    #<function b at 0x000002EAA7B43E18>


def b():
   print('my name is 哈哈哈')
a(b)            

 1. sum() 方法对系列进行求和计算。

# sum() 方法对系列进行求和计算。
#
# 语法
# 以下是 sum() 方法的语法:
#
# sum(iterable[, start])
# 参数
# iterable -- 可迭代对象，如：列表、元组、集合。
# start -- 指定相加的参数，如果没有设置这个值，默认为0。"""


print(sum([0,1,2]))  #  3

print(sum((2, 3, 4), 1)  ) #  10 元组计算总和后再加 1

print( sum([0,1,2,3,4], 2) )  #  12 列表计算总和后再加 2

 2. callback()判断是否能调用 来检查函数能否调用

print(callable(print))   #   True
a=111
print(callable(a))  #   false
def aa():pass
print(callable(aa))  #   True

import  time
def callback():
    print("这是一个callback函数")
def test_callback(call):
    print("这是在test_callback中哦")
    #模拟延时效果
    time.sleep(1)
    print("开始调用callback函数")
    time.sleep(1)
    #开始回调
    call()
    print("调用完成")

# 这是在test_callback中哦
# 开始调用callback函数
# 这是一个callback函数
# 调用完成

test_callback(callback)
print(callable(test_callback))#   True
print(callable(callback))   #    True

3. 查看帮助信息help()

# 查看帮助信息help()
print(help(dict))
print(help(list))
print(help(tuple))
print(help(set))
print(help(str))

#  哈希
print(hash("aaaaaaaaaaaaaaaaaaa"))

 4. all(x)如果all(x)参数x对象的所有元素不为0、''、False或者x为空对象，则返回True，否则返回False

#  函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
# 元素除了是 0、空、None、False 外都算 True。
# all()
print(all(['a','',123])) # False
print(all(['aaa',123])) # True
print(all(['','',123]))  # False

 5.any(x)判断x对象是否为空对象，如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true

# 如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
# any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
# 元素除了是 0、空、FALSE 外都算 TRUE。
  # 列表list，元素都不为空或0
print(any(()))  # 空列表 False
print(any([])) #空元组 False
any((0, '', False))        # 元组tuple，元素全为0,'',false
print(any(('a', 'b', 'c', 'd'))) # 元组tuple，元素都不为空或0
any(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0 True

print(any([1,'',99]))  True

6. zip() 

函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
d=('*','**',[1,2],'6666')
f={'k1':1,'k2':3}
print(zip(a,b,c))
for i in zip(a,b,c,d,f):
    print(i)
# (1, 4, 4, '*', 'k1')
# (2, 5, 5, '**', 'k2')

print(list(zip(('a','n','c'),(1,2,3))))
 # [('a', 1), ('n', 2), ('c', 3)]

print(list(zip(('a','n','c'),(1,2,3,4))))
# [('a', 1), ('n', 2), ('c', 3)]

p={'name':'张三','age':18,'爱好':'上网','地址':'南充'}
print(list(zip(p.keys(),p.values())))
# [('name', '张三'), ('age', 18), ('爱好', '上网'), ('地址', '南充')]

# 求出列字典最大值 
aa={"age1":11,"age2":16,"age3":20,"age4":28,"age5":90}

# 这样比较不知到对应哪个key和value的值   不合理
print(max(aa.values()))  # 90
print(max(aa))           # age5


print('*********************1111111****************')


# 借用zip()函数来比较字典里面的大小  这样逻辑清晰   就是key和value都知道
cc={"age1":11,"age2":16,"age3":20,"age4":28,"age5":90}
q=max(zip(cc.values(),cc.keys()))
print(q)      # (90, 'age5')






print('********************2222222*****************')

E={"age1":11,"age2":16,"age3":20,"age4":28,"age5":90}
for item in zip(E.values(),E.keys()):
    print(item)
# (11, 'age1')
# (16, 'age2')
# (20, 'age3')
# (28, 'age4')
# (90, 'age5')




# 总结   早出最大的年龄和对应的人名
vv=[
   {"name":"张三","age":15},
   {"name":"哈哈","age":22},
   {"name":"往往","age":33},
   {"name":"李四","age":60},
]

B=max(vv,key=lambda dic:dic['age'])

print(B)    # {'name': '李四', 'age': 60}

7.filter() 函数

原型  : filter (fn,lsd)
参数1 为函数
参数2 为序列
功能: 过滤
白话文 ： 把传入的函数依次作用与序列每个元素，
            根据返回的是True还是False 决定是否保留改元素

listl=[1,2,3,4,5,6,7,8,9]
# 筛选条件
def func (num):
    # 偶数保留
    if num%2==0:
        return True
    # 奇数剔除
    return False
L=filter(func,listl)
print(list(L))  #[2, 4, 6, 8]

data=[["姓名","年龄","爱好"],["tom",25,"无"],["tom",2555500000,"金钱"]]
def func2(v):
    v=str(v)
    if v=="无":
      return False
    return True


for line in data:
    m=filter(func2,line)
    print(list(m))

# ['姓名', '年龄', '爱好']
# ['tom', 25]
# ['tom', 2555500000, '金钱']

v = [4,5,6,7]
def dd(x):
    return x%2==1
re=filter(dd,v)
print(re)
for i in re:
    print(i)
 #5 7
 
print("***********************************************8")


# 和上面filter同等
ret=[i for  i in [1,2,3,4,5,6] if i%2==1]
print(ret)   # [1, 3, 5]

def is_odd(n):
    return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
for i in newlist:
    print(i)

print("***********************************************8")

# 过滤列表中所有字符串
def st(n):
    if type(n)==str:
        return  True
aa=filter(st,[1,"hello","我是",2,77,"good"])
print(aa)
for i in aa:
    print(i)
# hello
# 我是
# good

print("***********************************************8")

# 过滤列表中所有空
def em(n):
    return  n and str(n).strip()
jj=filter(em,[1,"hello","我是",None,77,"",[],66])
for i in jj:
    print(i)
j=str([])
print(type(j))
jf=str(None)
print(type(jf))
# 1
# hello
# 我是
# 77
# 66
# <class 'str'>
# <class 'str'>

print("***********************************************8")

import math
def gg(n):
   if math.sqrt(n)%2==0:
      return n
l=filter(gg,[12,64,25,36,88,77])
for i in l:
    print(i)
# 64
# 36

8. map()函数

map函数的原型是map(function, iterable, …)，它的返回结果是一个列表。
参数function传的是一个函数名，可以是python内置的，也可以是自定义的。
参数iterable传的是一个可以迭代的对象，例如列表，元组，字符串这样的。

map 返回的是一个迭代器类型
原型: map(fn,lsd)
参数1 是函数
参数2 是序列
功能: 将传入的函数依次作用在序列的每一个元素,
    并把结果作为新的Iterator返回

# map() 会根据提供的函数对指定序列做映射。
# 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
ret=map(abs,[1,-3,-4,-5,6])
for i in ret:
    print(i)

print("***************************************")

def square(x) :            # 计算平方数
    return x**2
aa=map(square, [1,2,3,4,5])
for i in aa:
  print(i)

list2=[2,4,6,8,10]
res=map(lambda x:x-1,list2)
print(res)           # <map object at 0x000001AE389F9BE0>  
for  i in res:
 print(i)
# 1
# 3
# 5
# 7
# 9

def add (x):
    return x-1
list3=[2,4,6,8,10]
print(list(map(add,list3)))
# [1, 3, 5, 7, 9]

msg="abcdef"
print(list(map(lambda x:x.upper(),msg)))
# ['A', 'B', 'C', 'D', 'E', 'F']

9.reduce ()函数

# 求一序列的和
list2=[1,2,3,4,5]
# 1+2
# 1+2+3
# 1+2+3+4
# 1+2+3+4+5
def  aa(x,y):
    return x+y
r=reduce(aa,list2)  
print("r=",r)     #15

from functools import reduce
reduce(fn ,lsd)
参数1为函数
参数2为列表
功能  一个函数作用在序列上,这个函数必须接受两个参数,
      reduce 把结果继续和序列的下一个元素累计计算
例如:
     reduce(f,[a,b,c,d])  相当于 f(f(f(a,b),c),d)

num=[2,4,6,8,10]
res=0
for i in num: 
    res+=i
print(res)   # 30

print("**********************************************")

# 利用函数
def aa (arr):
     ser=0
     for i in arr:
       ser+=i
     return ser
b=aa(num)
print(b)  # 30

print("**********************************************")

from functools import reduce
# 利用   reduce
def  aa(x,y):
    return x+y
r=reduce(aa,num)  
print("r=",r)     #30


print("**********************************************")
# 利用匿名函数
num=[2,4,6,8,10]
def cc (func,arr):
    res=arr.pop(0)
    # print(res)     2
    for i in arr:
        res=func(res,i)
    return res
b=cc(lambda x,y:x*y,num)
print(b)   #  3840

print("**********************************************")

# 利用reduce函数
num2=[1,2,3,4,5,6]
AA=reduce(lambda x,y:x+y,num2)
print(AA) 
# 21 

10. sorted() 和 sort()

# sorted() 函数对所有可迭代的对象进行排序操作。  生成了个新列表
f=[5,7,-6,3,4,1,2]
print(sorted(f))
print(f)
# sort() 在原有的基础上排序
l=[1,-2,33,-4,-9]
l.sort(key=abs)
print(l)

# 按照列表长度排序
h=['   ',[1,2],'hellossaaa','66']
new=sorted(h,key=len)
print(new)
# [[1, 2], '66', '   ', 'hellossaaa']

# ord() 函数是 chr() 函数（对于8位的ASCII字符串）
# 或 unichr() 函数（对于Unicode对象）的配对函数
print(ord('A'))  # 65

#求 平方
print(pow(3,3))   #27


# 四舍五入
print(round(3.5))

# 把字符串变成字典
print(set('hello'))
# {'o', 'l', 'h', 'e'}




# 排序
l=[5,8,9,4]
print(sorted(l))
# [4, 5, 8, 9]

"""# 列表字典排序
vv=[
   {"name":"张三","age":15},
   {"name":"哈哈","age":90},
   {"name":"往往","age":222},
   {"name":"李四","age":60}
],

print(sorted(vv,key=lambda dic: dic ['age']))
# [{'name': '张三', 'age': 15}, {'name': '李四', 'age': 60}, {'name': '哈哈', 'age': 90}, {'name': '往往', 'age': 222}]
 """
 
 # 字典排序
name={
    "张三":52,
    "小孩":23,
    "校长":280,
    "吕老师":999,
    "A":8888,
    }

print(sorted(name))
# ['A', '吕老师', '小孩', '张三', '校长']    按照values字母大小排序 

print(sorted(name,key=lambda key:name[key]))
# ['小孩', '张三', '校长', '吕老师', 'A']   # 按照keys价钱从小到大排序 


print(sorted(zip(name.values(),name.keys()))) #keys和values 排序
# [(23, '小孩'), (52, '张三'), (280, '校长'), (999, '吕老师'), (8888, 'A')]

print(str('1'))  # 1
aa=str({'a':1})   
print(eval(aa))     # {'a': 1}


# 求和、
a=[1,5,9,5,10]
print(sum(a))    # 30 

print(sum(range(4)))  # 6

# 查看类型
print(type(1))   # <class 'int'>


"""
65
27
4
{'h', 'e', 'o', 'l'}
[4, 5, 8, 9]
['A', '吕老师', '小孩', '张三', '校长']
['小孩', '张三', '校长', '吕老师', 'A']
[(23, '小孩'), (52, '张三'), (280, '校长'), (999, '吕老师'), (8888, 'A')]
1
{'a': 1}
30
6
<class 'int'>
"""

11. enumerate() 

# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
# Python 2.3. 以上版本可用，2.6 添加 start 参数。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
p=list(enumerate(seasons))
print(p)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

print("********************************************")

i = 0
seq = ['one', 'two', 'three']
for element in seq:
    print(element,i)
    i += 1
# one 0
# two 1
# three 2

12.divmod() 函数把除数和余数运算结果结合起来

divmod() 函数把除数和余数运算结果结合起来，
# 返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(10,2))   #(4, 0)
print(divmod(11,2))   #(5, 1)
print(divmod(20,2))   #(10, 0)
print(divmod(11,3))   #(3, 2)

13.进制转换

# 进制转换
print(bin(10)) # 10进制到2进制 # 0b1010
print(hex(12)) # 10进制到16进制 # 0xc
print(oct(11)) # 10进制到8进制 0o13

14.isinstance() 函数来判断一个对象是否是一个已知的类型

# isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
print(isinstance(1,int))          # True
print(isinstance('abcdef',str))   # True
print(isinstance([],list))       # True
print(isinstance({},dict))       # True

15.functools模块用于高阶函数

import functools
# functools模块用于高阶函数：作用与或者返回其它函数的函数。
# 一般来说，对于该模块，任何可调用对象都可以视为一个函数。
# 偏函数


def int2(str,base=2):
    return int(str,base)
print(int2("11111"))


# 把一个参数固定住 形成一个新的函数


int3=functools.partial(int,base=2)
print(int3("111"))
# 进制的换算

# 31
# 7