python 全栈 python基础 (十三)匿名函数 与 内置函数

一、匿名函数

 1.定义: 

  匿名函数顾名思义就是指:是指一类无需定义标识符(函数名)的函数或子程序。
 2.语法格式:lambda 参数:表达式
  lambda语句中,开头先写关键字lambda,冒号前是参数,可以有多个,用逗号隔开;冒号右边的为表达式,需要注意的是只能有一个表达式。由于lambda返回的是函数对象(构建的是一个函数对象),所以需要定义一个变量去接收。
  3.注意点:lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。lambda 函数不能包含命令,包含的表达式不能超过一个。
  4.匿名函数优点:
    - 使用Python写一些脚本时,使用lambda可以省去定义函数的过程,让代码更加精简。
    - 对于一些抽象的,不会被别的地方再重复使用的函数,有时候函数起个名字也是个难题,使用lambda不需要考虑命名的问题
    - 使用lambda在某些时候然后代码更容易理解

5.应用:在内置函数 max() 求最大值,min()求最小值, map() 映射, reduce 合并, filter() 过滤 中会用到!

简单代码举例:

1 salaries={
2     ‘egon‘:3000,
3     ‘alex‘:100000000,
4     ‘wupeiqi‘:10000,
5     ‘yuanhao‘:2000
6 }
7 f = lambda k: salaries[k]
8 print(f)
9 print(f(‘egon‘))

执行结果:

<function <lambda> at 0x0000000000413E18>
3000

二、内置函数

    内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii

1.abs()   取绝对值  数据类型 必须是 整型!

1 print(abs(1))
2 print(abs(-1))
3 print(abs(‘a‘))

执行结果:

1
1
Traceback (most recent call last):
  File "F:/py_fullstack_s4/day25/内置函数.py", line 3, in <module>
    print(abs(‘a‘))
TypeError: bad operand type for abs(): ‘str‘

2.all(可迭代对象) 返回布尔值 只要任何一个值不为真,返回Flase,可迭代对象为空时,返回True

1 print(all(‘‘))
2 print(all((1,‘‘,None,0)))
3 print(all(i for i in range(1,10))) #从1开始取值,排除0

执行结果:

True
False
True

3.any(可迭代对象) 返回布尔值 只要任何一个值为真,返回True,可迭代对象为空时,返回Flase

1 print(any(‘‘))
2 print(any([None,1,2,‘‘]))

执行结果:

False
True

4.将十进制转换成 :bin() 二进制 hex() 十六进制 oct()八进制

1 print(bin(12)) #二进制
2 print(hex(12)) #十六进制
3 print(oct(12)) #八进制

执行结果:

1 0b1100
2 0xc
3 0o14

5.数据类型:int() 整型;str() 字符串;list()列表;tuple()元组;dict()字典;set() 集合;frozenset() 不可变集合

  is 判断身份,身份运算,根据id去判断身份

 1 num =1
 2 s = "adxz"
 3 l = [1,2.3,4]
 4 d = {1:1,"z":2}
 5 print(type(d))
 6 print(type(l))
 7 print(type(s))
 8 print(num is 1)
 9
10 d = dict(x=1,y=2,z="3")  #生成字典的另一种方式
11 print(d)
12 s = {1,2,3,4,4,3,2,5} #集合
13 print(s)
14 s.add((6,7))
15 print(s)
16 f = frozenset(s) #不可变集合
17 print(f)
18 print(type(f))

执行结果:

1 <class ‘dict‘>
2 <class ‘list‘>
3 <class ‘str‘>
4 True
5 {‘x‘: 1, ‘y‘: 2, ‘z‘: ‘3‘}
6 {1, 2, 3, 4, 5}
7 {1, 2, 3, 4, 5, (6, 7)}
8 frozenset({1, 2, 3, 4, 5, (6, 7)})
9 <class ‘frozenset‘>

6.bool()  判断布尔值

1 print(bool(2>1))
2 print(bool(2<1))

执行结果:

1 True
2 False

7.bytes() bytes 字节 指定编码格式否则报错     type() 查看变量 是 哪种数据类型

1 s = ‘abcdefg‘
2 print(s) #查看字符串s
3 print(type(s)) #查看字符串类型
4 s1 = bytes(s,encoding=‘utf-8‘)  #查看字符串类型
5 print(s1)

执行结果:

1 abcdefg
2 <class ‘str‘>
3 b‘abcdefg‘

8.ASCII码转换 :chr() ASCII转换 数字转换成字符;ord() ASCII转换 字符转换成数字

1 print(chr(81)) #根据位置找值
2 print(ord(‘A‘)) #根据值找位置

执行结果:

1 Q
2 65

9.callable() 判断是否为函数,括号内传入函数名      complex() 定义复数

1 x = complex(1-2j)  #定义一个复数
2 print(type(x))  #查看函数类型
3 print(x.real)   #打印x 的实部
4 print(x.imag)   #打印x 的虚部
5 print(callable(x))  #查看是否是函数
6
7 def test():  #定义函数
8     pass
9 print(callable(test))  #查看是否是函数

执行结果:

1 <class ‘complex‘>
2 1.0
3 -2.0
4 False
5 True

10.帮助   dir(对象)   查看对象都能调用什么方法;help()直接查看 函数 具体的帮助信息

1 a = ‘hnaxhoqihcqew0‘
2 print(dir(a))  #查看调用方法  help()直接查看具体的帮助信息

执行结果:

[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getnewargs__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__init_subclass__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mod__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__rmod__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘capitalize‘, ‘casefold‘, ‘center‘, ‘count‘, ‘encode‘, ‘endswith‘, ‘expandtabs‘, ‘find‘, ‘format‘, ‘format_map‘, ‘index‘, ‘isalnum‘, ‘isalpha‘, ‘isdecimal‘, ‘isdigit‘, ‘isidentifier‘, ‘islower‘, ‘isnumeric‘, ‘isprintable‘, ‘isspace‘, ‘istitle‘, ‘isupper‘, ‘join‘, ‘ljust‘, ‘lower‘, ‘lstrip‘, ‘maketrans‘, ‘partition‘, ‘replace‘, ‘rfind‘, ‘rindex‘, ‘rjust‘, ‘rpartition‘, ‘rsplit‘, ‘rstrip‘, ‘split‘, ‘splitlines‘, ‘startswith‘, ‘strip‘, ‘swapcase‘, ‘title‘, ‘translate‘, ‘upper‘, ‘zfill‘]

11.divmod(int1,int2) 两个数做除法 int1/int2;返回值是得到一个元组(整除的值,取余的值);主要应用于网页的分页

1 print(divmod(10,2))
2 print(divmod(10,3))

执行结果:

(5, 0)
(3, 1)

12.enumerate()

enumerate函数说明:

  • 函数原型:enumerate(sequence, [start=0])
  • 功能:将可循环序列sequence以start开始分别列出序列数据和数据下标(可自定义起始值)
  • 即对一个可遍历的数据对象(如列表、元组或字符串),enumerate会将该数据对象组合为一个索引序列,同时列出数据和数据下标,以元组的形式输出结果
1 list = [‘ni‘,‘hao‘,‘ma‘,‘hello‘,‘world‘]
2 for i in enumerate(list,1):
3     print(i)

执行结果:

(1, ‘ni‘)
(2, ‘hao‘)
(3, ‘ma‘)
(4, ‘hello‘)
(5, ‘world‘)

13.hash()  hash() 哈希算法,应用:进行数据校验

特性:
1、字符串改变,得到的数值必将改变
2、只要算法一致,得到的值永远不会变,长度也不会改变。
3、hash值不能逆推

1 #字符串类型
2 x = "hello"
3 y = ‘hello‘  #x和y 两个值相等
4 print(hash(x))
5 print(hash(y))
6 y = ‘hellobuxaoixax‘ #改变y
7 print(hash(x))
8 print(hash(y))

执行结果:

4282436752230277468
4282436752230277468
4282436752230277468
-397579801337672607

14.eval() 将字符串 转换成 表达式 形式 进行运算

15.id()    id() 查看唯一标识身份信息 字符串一样,数字超过一定长度就不同

 1 >>> x =10
 2 >>> y =10
 3 >>> print(id(x))
 4 1393927552
 5 >>> print(id(y))
 6 1393927552
 7 >>> x = 100000000000000000000000
 8 >>> y = 100000000000000000000000
 9 >>> print(id(x))
10 42716256
11 >>> print(id(y))
12 42716296
13 >>>

16.#拉链 zip()
zip(),放入两个迭代器,一一对应重新取值,以元组的形式输出。不管是某一方的个数多,都不会输出。

l1 = [1,2,3,4,5,6]
s = ‘hello‘
z = zip(l1,s)
for i in z:
    print(i)

执行结果:

(1, ‘h‘)
(2, ‘e‘)
(3, ‘l‘)
(4, ‘l‘)
(5, ‘o‘)

17.sorted() 排序 可迭代对象 得到一个新的返回值。返回值是列表,默认是升序;  reverse = True 反转。降序;    reversed() 取反,本末倒置

对字典排序,默认是按照字典的key去排序的

 1 salaries={
 2     ‘egon‘:3000,
 3     ‘alex‘:100000000,
 4     ‘wupeiqi‘:10000,
 5     ‘yuanhao‘:2000
 6 }
 7 print(sorted(salaries))  #按照keys排序,依次比较字母的大小 从小到大
 8 print(sorted(salaries,reverse = True))  #按照keys排序,依次比较字母的大小 从大到小
 9 print(sorted(salaries,key = lambda x:salaries[x]))  #按照values的值排keys的序,从小到大
10 l = [1,2,3,4

执行结果:

[‘alex‘, ‘egon‘, ‘wupeiqi‘, ‘yuanhao‘]
[‘yuanhao‘, ‘wupeiqi‘, ‘egon‘, ‘alex‘]
[‘yuanhao‘, ‘egon‘, ‘wupeiqi‘, ‘alex‘]
#reversed()应用
l = [1,2,3,45,7] #定义初始列表
l1= reversed(l)  #转换 会得到一个返回值
print(list(l1))  #list()一个一个的取值,生成一个列表

执行结果:

[7, 45, 3, 2, 1]

18.max() and min() 求最大值和最小值

max(*args,key=func)   key可有可无。当需要用函数判断的时候,添加key.    min与max的使用方法一致。

 1 #max和min
 2 print(max(1,2,3,4,10,3))   #直接比较
 3 print(min(1,2,3,4,10,3))
 4 print(max((1,‘a‘),(1,‘b‘)))
 5 salaries={
 6     ‘egon‘:3000,
 7     ‘alex‘:100000000,
 8     ‘wupeiqi‘:10000,
 9     ‘yuanhao‘:2500
10 }
11 def get_value(k):
12     return salaries[k]
13 print(max(salaries)) #比较keys
14 print(max(salaries,key=get_value))  #原始的定义一个函数
15 print(max(salaries,key=lambda k:salaries[k])) #使用lambda函数
16 print(min(salaries,key=lambda k:salaries[k]))

执行结果:

10
1
(1, ‘b‘)
yuanhao
alex
alex
yuanhao

19.map 映射

 map(func,list)

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

1 #map 映射 将原有的可迭代对象中的元素逐一拿出来处理后,返回一个新的可迭代对象
2 l = [1,2,3,45,7]
3 m = map(lambda item:item*2,l)
4 print(m)
5 print(list(m))

执行结果:

<map object at 0x00000000026E96A0>
[2, 4, 6, 90, 14]

20.reduce 合并规则 求多个数的和

reduce(fun,list,初始值)

    reduce依次把list中的数字赋值给fun进行计算

    注意fun必须是连个数字间的运算,list必须是整型数字,初始值可定义,也可以不定义。

reduce()传入的函数func 必须接收两个参数,reduce() 对list的每个元素反复调用函数func,并返回最终结果值。

from functools import reduce
l = range(100)
print(reduce(lambda x,y:x+y,l))
print(reduce(lambda x,y:x+y,l,100))

执行结果:

4950
5050

21.filter() 过滤器    会有一个判断,输出的结果是布尔值,会将布尔值为True的过滤出来。
filter(函数func,可迭代对象list)

  filter()函数接收一个函数 func 和一个list,这个函数 f 的作用是对每个元素进行判断,返回 True或 False,filter()根据判断结果自动过滤掉不符合条件的元素,返回由符合条件元素组成的新list。

 1 #filter  过滤
 2 name_l =[
 3     {"name":‘egon‘,‘age‘:120},
 4     {"name":"fsw","age":1000},
 5     {‘name‘:‘wang‘,‘age‘:2000},
 6     {‘name‘:‘jie‘,‘age‘:18}
 7 ]
 8 f = filter(lambda d:d[‘age‘]>100,name_l)
 9 for i in f:
10     print(i)

执行结果:

{‘name‘: ‘egon‘, ‘age‘: 120}
{‘name‘: ‘fsw‘, ‘age‘: 1000}
{‘name‘: ‘wang‘, ‘age‘: 2000}

23.其他

pow() 两个值求方,三个值是前两个求方然后值和第三个数再取余数

round() 带小数点的值,五舍六入

slice() 定义切片对象

vars() #局部变量

_import_(‘字符串‘) 将导入的字符串转成模块

 1 #其他
 2
 3 #pow()
 4 print(pow(3,2))
 5 print(pow(3,2,2))
 6
 7 #round() 五舍六入
 8 print(round(10.3))
 9 print(round(10.5))
10 print(round(10.6))
11 print(round(10.9))
12
13 # slice 切片
14 l=[1,2,3,4,5,6,7,9]
15 print(l[2:5:2])
16 s=slice(2,5,2)
17 print(l[s])
18
19 #vars()  等同于局部变量
20 print(vars() is locals())
21
22 #_import_() 自定义模块
23 import time
24 # time.sleep(3)
25 print(time)
26
27 m=__import__(‘time‘)
28 print(m)
29 m.sleep(3)

执行结果:

9
1
10
10
11
11
[3, 5]
[3, 5]
True
<module ‘time‘ (built-in)>
<module ‘time‘ (built-in)>
# #在面向对象里讲# classmethod# staticmethod# property## delattr# hasattr# getattr# setattr## issubclass## super
时间: 2024-10-08 23:14:22

python 全栈 python基础 (十三)匿名函数 与 内置函数的相关文章

Python学习之旅 —— 基础篇(四)内置函数、装饰器

本篇要点: 内置函数 装饰器 一.内置函数 # abs() :取绝对值 >>> res = abs(-10) >>> print(res) 10 # 0,None,"",{},[],() 布尔值都为空 # all(),any() 判断值的真假 # all() 所有为真才为真 p = all([0,1,2,3]) # 0为False,所有p 是False print(p) # any() 任意一个为真即为真 p = any((0,""

Python 基础第十四天(内置函数和匿名函数)

今天主要内容 1.生成器补充--生成器推导式 2.内置函数 3.匿名函数 1.生成器推导式 (1)列表推导式:一行搞定 ,简单,感觉高端.但是,不易排错. 例: l1 = [] for i in range(1,12):  l1.append('python%s期' % i) print(l1) 生成式: l2 = ['python%s期' %i  i  for i in range(1,12)] print(l2) 结构: 循环模式[经过加工的i for i in 可迭代对象] 筛选模式 [经

python协程函数、递归、匿名函数与内置函数使用、模块与包

目录: 协程函数(yield生成器用法二) 面向过程编程 递归 匿名函数与内置函数的使用 模块 包 常用标准模块之re(正则表达式) 一.协程函数(yield生成器用法二) 1.生成器的语句形式 a.生成器相关python函数.装饰器.迭代器.生成器,我们是如何使用生成器的.一个生成器能暂停执行并返回一个中间的结果这就是 yield 语句的功能 : 返回一个中间值给调用者并暂停执行. 我们的调用方式为yeild 1的方式,此方式又称为生成器的语句形式. 而使用生成器的场景:使用生成器最好的场景就

JavaScript原生函数(内置函数)

1.JavaScript原生函数(内置函数) JavaScript原生函数(内置函数)有: String() Number() Boolean() Array() Object() Function() RegExp() Date() Error() Symbol() 2.创建内置函数 <!DOCTYPE html> <html lang="zh"> <head> <meta charset="UTF-8" /> &l

python 全栈 python基础 (九)作用域 函数嵌套 闭包

名称空间与作用域 变量,函数 分成三种 #内置名称空间  内置函数, 系统函数内部自定义的. python查看内置函数,命令: import builtins dir(builtins) #全局名称空间  文件中 顶头写,没有任何缩进定义的函数或是变量. 定义之后,在整个文件的任何位置都可以用. #局部名称空间 定义之后,在局部环境内可以调用,例如在一个定义函数中定义的变量,只能在当前函数内部调用,往外全局或是其他函数均不能调用. 在外部,或是其他定义的函数调用的话,会报错! 内置和全局名称空间

python基础-匿名函数、内置函数、正则表达式、模块

1. 匿名函数 1.1 有名函数 有名函数:定义了一个函数名,函数名指向内存地址:通过函数名进行访问.函数名加括号就可以运行有名函数,例如:func() def func(x, y, z = 1): return x + y + z print(func(1,5,2)) 1.2 匿名函数 匿名函数:没有名字的函数,定义的时候不需要函数名:定义匿名函数的关键字是:lambda 特点: 1.没有函数名 2.函数自带return 应用场景: 1.应用于一次性的地方 2.临时使用 salaries={

python 全栈 python基础(六)前期基础整理

计算机中,有且仅有CPU具有执行权限,能够执行指令的只有CPU! 人在应用程序上输入的文字或文本,叫做明文! 在屏幕上输入或是输出的是字符,计算机保存的是 有字符编码的 二进制数. 变量赋值规则:例如:a=1 先在内存中开辟一块空间,存放数1,内存上会有一个相对应的id号,然后变量a指向这块内存区域和id号,python编译器有垃圾清除的功能,若开辟的这块内存区域一段时间内不调用,数据就会被清除,为其他的数据腾空间. python2 容错率高,自作聪明的完成转码拼接. python3 将字节类型

python基础之匿名函数、内置函数

一 匿名函数 匿名函数就是不需要显式的指定函数. lambda的主体是一个表达式,而不是一个代码块.仅仅能在lamba表达式中封装有限的逻辑进去. 语法:lambda函数的语法只包含一个语句,如下: lambda [arg1 [,arg2,.....argn]]:expression 先来个简单得: #这段代码 def calc(n): return n**n print(calc(10)) #换成匿名函数 calc = lambda n:n**n print(calc(10)) 换个高级点得:

Python基础(10)_内置函数、匿名函数、递归

一.内置函数 1.数学运算类 abs:求数值的绝对值 divmod:返回两个数值的商和余数,可用于计算页面数 >>> divmod(5,2) (2, 1) max:返回可迭代对象中的元素中的最大值或者所有参数的最大值 语法:max(iterable,key,default) 1 salaries={ 2 'egon':3000, 3 'alex':100000000, 4 'wupeiqi':10000, 5 'yuanhao':2000 6 } 7 8 print(max(salari