首页 > 编程语言 >python匿名函数、内置函数以及各类高阶函数等

python匿名函数、内置函数以及各类高阶函数等

时间：2024-04-30 16:15:13浏览次数：31  
标签：__ 函数 迭代 format python lst print 高阶

【一】匿名函数

【1】函数的分类

# 【1】正规函数
def login():
    ...
login()

# 【2】匿名函数(无名函数)
# 语法: lambda 参数: 表达式
# lambda: 匿名函数的关键字
# 参数可以放位置参数以及关键字参数...
# 表达式：其实本质上是返回值

【2】定义匿名函数

  • Python 使用 lambda 关键词来创建匿名函数，而非 def 关键词
lambda argument_list: expression
  • lambda:定义匿名函数的关键词。
  • argument_list:函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
  • expression:只是一个表达式，输入函数参数，输出一些值。
#正规函数
def add(x):
    return x + x


print(add(1)) # 2

#匿名函数
add = lambda x: x + x
print(add(1)) # 2

#正常写法
print([i+i for i in range(10)]) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

#匿名函数
add = lambda x:x+x
print([add(i) for i in range(10)]) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
  • 匿名函数可以配合高阶函数使用
# filter 过滤后面的参数 如果返回的结果为True，保留。否则删掉
templist = filter(lambda x: x % 2 == 1, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist)) # [1, 3, 5, 7, 9]

【二】内置函数

  • 内置函数就是python开发者当时开发python解释器的时候内置的函数

【1】数据类型强制转换（8）

# 【1】str()
# 【2】int()
# 【3】float()
# 【4】list()
# 【5】tuple()
# 【6】bool()
# 【7】set()
# 【8】dict()

【2】数学中的进制转换--（3）

# 【1】bin 十进制转二进制
# print(bin(999)) # 0b 1111100111 (只有0和1的就是二进制)
# 【2】oct 十进制转八进制
# print(oct(999)) # 0o 1747 (有7的就是八进制)
# 【3】hex 十进制转十六进制
# print(hex(999)) # 0x 3e7 (有e字符的就是十六进制)

【3】数学运算--（8）

（1）获取绝对值（abs）

  • abs() 返回绝对值
number = -1

# 获取当前整数的绝对值
number_abs = abs(number)

print(number_abs)
# 1

（2）获取商和余数（divmod）

  • divmod() 返回商和余数
number_start = 9
number_end = 4
# 获取商和余数 (被除数，除数)
result = divmod(number_start, number_end)
print(result)  # (2, 1)

# number_discuss : 商
# number_remainder : 余数
number_discuss, number_remainder = divmod(number_start, number_end)
print(number_discuss) # 2
print(number_remainder) # 1

（3）四舍五入（round）

  • 给定数字的四舍五入版本，有指定的小数位数。
  • 默认情况下，小数点的数量是0。
# 可以看到，对 4.51 的值为 5
print(round(4.51))
# 可以看到，对 4.50 的值为 4
print(round(4.50))
# 可以看到，对 4.49 的值为 4
print(round(4.49))

# 这里把浮点数作为第一个参数，把 1 作为第二个参数。
# 可以看到，对 4.051 的值为 4.1
print(round(4.051, 1))
# 可以看到，对 4.050 的值为 4.0
print(round(4.050, 1))
# 可以看到，对 4.049 的值为 4.0
print(round(4.049, 1))

# 这里把浮点数作为第一个参数，把 2 作为第二个参数。
# 可以看到，对 4.0051 的值为 4.01
print(round(4.0051, 2))
# 可以看到，对 4.0050 的值为 4.0
print(round(4.0050, 2))
# 可以看到，对 4.0049 的值为 4.0
print(round(4.0049, 2))

（4）a 的 b 次幂（pow）

  • pow(a,b) 求a的b次幂，如果有三个参数，则求完次幂后对第三个数取余
'''
参数介绍：
    x — 数值表达式(整数或者浮点数)；
    y — 数值表达式(整数或者浮点数)；
    z — 数值表达式(整数或者浮点数)，默认不设置z值；

返回值：返回 xy(x的y次方)的值；如果设置了z值,则再对结果进行取模,其结果等效于pow(x,y) %z；
'''

pow(x, y[, z])
  • pow 函数常规使用
print(pow(2,5)) # 等价 2**5 = 32
print(pow(2,3)) # 等价 2*2*2 = 8
print(pow(2,3,5)) # 等价 2*2*2%5 = 8 % 5 = 3
print(2*2*2%5)  # 等价 pow(2,3,5) = 3
  • 若 x,y 有一个浮点数，则结果将转换为浮点数
print(pow(2,3.2))
print(pow(2,3.0))

'''
输出结果：

9.18958683997628
8.0
'''

（5）求和（sum）

print(sum([1,2,3,4,5,6,7,8,9,10]))  

# 求和:55

（6）最小值（min）、最大值（max）

print(min(5,3,9,12,7,2))  

# 求最小值:2

print(max(7,3,15,9,4,13))  

# 求最大值:15

（7）复数转换（complex）

# complex(re, im) : 具有实部 re、虚部 im 的复数。im 默认为零。

start = complex(3, 4)
print(start)  # (3+4j)

second = complex(5, 9)
print(second)  # (5+9j)

res = start + second
print(res) # (8+13j)

【4】数据结构相关（5）

（1）翻转 reversed

  • reversed() 将一个序列翻转, 返回翻转序列的迭代器
lst = "你好啊"

# 不会改变原列表. 返回一个迭代器, 设计上的一个规则
it = reversed(lst)   

print(list(it))  
# ['啊', '好', '你']

（2）切片（slice）

  • 列表的切片
lst = [1, 2, 3, 4, 5, 6, 7]

print(lst[1:3:1])  
# [2,3]

s = slice(1, 3, 1)  
#  切片用的
print(lst[s])  
# [2,3]

（3）计算长度（len）

list_num = [i for i in range(10)]
print(len(list_num))  # 10

（4）排序（sorted）

  • 语法：sorted(Iterable, key=函数(排序规则), reverse=False)
    • Iterable: 可迭代对象
    • key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
    • reverse: 是否是倒叙. True: 倒叙, False: 正序
lst = [5, 7, 6, 12, 1, 13, 9, 18, 5]

# sort是list里面的一个方法, sort 方法没有返回值
lst.sort()
print(lst)
# [1, 5, 5, 6, 7, 9, 12, 13, 18]

# 内置函数. 返回给你一个新列表  新列表是被排序的
ll = sorted(lst)
print(ll)
# [1, 5, 5, 6, 7, 9, 12, 13, 18]

# 倒序
l2 = sorted(lst, reverse=True)
print(l2)
# [18, 13, 12, 9, 7, 6, 5, 5, 1]

# 根据字符串长度给列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']


def f(s):
    return len(s)


l1 = sorted(lst, key=f)
print(l1)  # ['one', 'two', 'six', 'four', 'five', 'three']

（5）枚举（enumerate）

lst = ['one', 'two', 'three', 'four', 'five']
# 把索引和元素一起获取,索引默认从0开始. 可以更改
# 下面更改默认索引从 0 开始
for index, el in enumerate(lst, 1):  
    print(index)
    print(el)

# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five

【5】字符相关 -- 4

（1）格式化输出（format）

  • 对齐方式
s = "hello world!"
print(format(s, "^20"))  # 居  中
#     hello world!
print(format(s, "<20"))  # 左对齐
# hello world!
print(format(s, ">20"))  # 右对齐
#         hello world!
  • 进制转换
print(format(3, 'b'))  # 二进制:11
print(format(97, 'c'))  # 转换成unicode字符:a
print(format(11, 'd'))  # ⼗进制:11
print(format(11, 'o'))  # 八进制:13
print(format(11, 'x'))  # 十六进制(⼩写字母):b
print(format(11, 'X'))  # 十六进制(大写字母):B
print(format(11, 'n'))  # 和d⼀样:11
print(format(11))  # 和d⼀样:11
  • 科学计数法
print(format(123456789, 'e'))  # 科学计数法. 默认保留6位小数:1.234568e+08
print(format(123456789, '0.2e'))  # 科学计数法. 保留2位小数(小写):1.23e+08
print(format(123456789, '0.2E'))  # 科学计数法. 保留2位小数(大写):1.23E+08
print(format(1.23456789, 'f'))  # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f'))  # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f'))  # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e+3, 'F'))  # 小数点计数法. 很大的时候输出INF:1234.567890

（2）字符串转bytes（bytes）

bs = bytes("今天吃饭了吗", encoding="utf-8")

print(bs) 
# b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'

（3）获取字节数组（bytearray）

  • 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值的范围是[0,256)
ret = bytearray("chosen", encoding='utf-8')

print(ret[0])
# 99

print(ret)
# bytearray(b'chosen')

ret[0] = 65
# 把65的位置A赋值给ret[0]

print(str(ret))
# bytearray(b'Ahosen')

（4）返回对象的字符格式（repr）

  • repr() 返回一个对象的string形式
word = "今天\n吃了%s顿\t饭" % 3
print(word)
# 今天
# 吃了3顿	饭

# 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
print(repr(word))
# '今天\n吃了3顿\t饭'

【6】字符编码相关--(3)

（1）字符编码找数字(ord)

  • ord() 根据字符编码找数字 ---> 去ASCII码表中查数据

    解释print(ord('a'))  
# 字母a在编码表中的码位:97

print(ord('中'))  
# '中'字在编码表中的位置:20013

（2）数字找字符编码(chr)

  • chr() 根据数字找字符编码 ---》 去ASCII码表中查数据

    解释print(chr(65))  
# 已知码位,求字符是什么:A

print(chr(19999))  
# 丟

（3）数字找ASCII码(ascii)

  • ascii() 是ascii码中的返回该值 不是就返回u

    for i in range(65536):  #打印出0到65535的字符
    print(chr(i), end=" ")

print(ascii("@"))  #'@'

【补充】数据集合

  • 创建一个冻结的集合(frozenset)
  • frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。
  • 注释: frozenset() 函数返回一个不可变的 frozenset 对象，适用于作为字典的键或集合的元素。
frozen_set = frozenset([1, 2, 3, 4, 5])
print(frozen_set)
# 输出：frozenset({1, 2, 3, 4, 5})

【补充】判断条件（2）

（1）所有为真（all）

  • all() 可迭代对象中全部是True, 结果才是True
print(all([1,'hello',True,9]))  #True

（2）任意为真（any）

  • any() 可迭代对象中有一个是True, 结果就是True
print(any([0,0,0,False,1,'good']))  #True

【三】高阶函数

【1】打包（zip）

  • 用于将可迭代的对象作为参数
  • 将对象中对应的元素打包成一个元组
  • 然后返回由这些元组组成的列表.
  • 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(zip(lst1, lst2, lst3))  # <zip object at 0x0000022F28B4AF00>
print(list(zip(lst1, lst2, lst3)))
# [(1, '醉乡民谣', '美国'), (2, '驴得水', '中国'), (3, '放牛班的春天', '法国'), (4, '美丽人生', '意大利'), (5, '辩护人', '韩国'), (6, '被嫌弃的松子的一生', '日本')]

# 按照最少的长度的可迭代类型总和
lst1 = [1, 2, 3, 4, 5]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(list(zip(lst1, lst3)))
# [(1, '美国'), (2, '中国'), (3, '法国'), (4, '意大利'), (5, '韩国')]

【2】过滤（filter）

  • 语法：filter(function. Iterable)
    • function: 用来筛选的函数.
      • 在filter中会自动的把iterable中的元素传递给function.
      • 然后根据function返回的True或者False来判断是否保留留此项数据
    • Iterable: 可迭代对象
  • filter() 过滤 (lamda)
def func(i):  # 判断奇数
    return i % 2 == 1


lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# l1是迭代器
print(filter(func, lst))  # <filter object at 0x000001CE3CA98AC8>
print(list(filter(func, lst)))
# [1, 3, 5, 7, 9]

【3】映射（map）

  • 语法 : map(function, iterable)
    • 可以对可迭代对象中的每一个元素进行映射. 分别去执行 function
  • map() 会根据提供的函数对指定序列列做映射(lamda)
def f(i):
    return i


lst = [1, 2, 3, 4, 5, 6, 7, ]
# 把可迭代对象中的每一个元素传递给前面的函数进行处理.
# 处理的结果会返回成迭代器print(list(it))

it = map(f, lst)
print(it)  # <map object at 0x000001EEDDE997B0>

# 如果要查看 map 的结果需要用 list 强转
print(list(it))
# [1, 2, 3, 4, 5, 6, 7]

【四】作用域

  • locals() 返回当前作用域中的名字
  • globals() 返回全局作用域中的名字
name = "chosen"


def func():
    a = 10
    # 当前作用域中的内容
    print(f"这是当前作用域中的内容 :>>>> {locals()}")
    # 全局作用域中的内容
    print(f"这是全局作用域中的内容 :>>>> {globals()}")

    print("我是函数func内部")


func()
# 这是当前作用域中的内容 :>>>> {'a': 10}

# 这是全局作用域中的内容 :>>>> {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002687A368910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:\\PythonProjects\\09Python的内置函数\\01start.py', '__cached__': None, 'name': 'dream', 'func': <function func at 0x000002687A3D35B0>}

# 我是函数func内部

【五】迭代器生成器（3）

【1】循环生成数据（range）

print(range(1, 10))
# range(1, 10)

print([i for i in range(1, 10)])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

【2】获取迭代器（iter）

  • 获取迭代器, 内部实际使用的是__ iter__()方法来获取迭代器
lst = [1, 2, 3, 4, 5]

# __iter__()获得迭代器
it = iter(lst)
print(it)
# <list_iterator object at 0x0000016162EC97B0>

【3】向下执行（next）

  • 迭代器向下执行一次, 内部实际使用了__ next__()方法返回迭代器的下一个项目
lst = [1, 2, 3, 4, 5]

# __iter__()获得迭代器
it = iter(lst)
print(it)
# <list_iterator object at 0x0000016162EC97B0>
print(next(it))
# 1
print(next(it))
# 2
print(next(it))
# 3
print(next(it))
# 4
print(next(it))
# 5

【六】字符串类型代码的执行（3）

【1】指定指令并返回结果（eval）

  • eval() 执行字符串类型的代码. 并返回最终结果
  • 函数和类执行不了
s1 = 'input("请输入a:").strip()'
res = eval(s1)
# 输入:4

# 可以动态的执行代码. 代码必须有返回值
print(res)
# 4

code_str = "[i for i in range(10)]"
print(eval(code_str))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

【2】指定指令不返回结果（exec）

  • exec() 执行字符串类型的代码
s2 = "for i in range(5): print(i)"
# exec 执行代码不返回任何内容
a = exec(s2)
# 0
# 1
# 2
# 3
# 4
print(a)  # None

# 动态执行代码
exec("""
def func():
    print(" 我是周杰伦")
""")
func()  # 我是周杰伦


code_str ='''
def add(x, y):
    print(x + y)
    
add(1,5)
'''
print(exec(code_str)) 
# 6
# None

【3】编码指令

  • compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值
  • compile 并不会执行你的代码，只是编译
code_str = '''
def add(x, y):
    print(x + y)
    
add(1,5)
'''
code = compile(code_str, '', mode='exec')
print(exec(code))
# 6
# None

code2 = "5+6+7"
com2 = compile(code2, "", mode="eval")
print(eval(com2))
# 18

code_str_one = 'print([i for i in range(10) if i %2 == 0])'
code = compile(code_str_one, '', mode='eval')
print(eval(code))
# [0, 2, 4, 6, 8]
# None

【七】输入输出函数

# 输入：input()
# 输出：print()

【八】算法

  • hash() :
    • 获取到对象的哈希值(int, str, bool, tuple).
  • 列表不允许hash
s = 'chosen'
print(hash(s))  
# 5405132401319935146

# 哈希的目的就是为了唯一性
# 字典的内部原理 --> 字典的键的内部原理就是哈希
  • hash算法：
    • (1) 目的是唯一性
    • (2) dict 查找效率非常高
  • hash表：
    • 用空间换的时间 比较耗费内存

【九】文件操作

f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()

【十】导入模块

# import

【十一】帮助

  • help() : 函数用于查看函数或模块用途的详细说明
# 查看字符串的用途
print(help(str))

【十二】调度函数

  • callable() : 用于检查一个对象是否是可调用的
    • 如果返回True, object有可能调用失败
    • 但如果返回False. 那调用绝对不会成功
a = 10
# 变量a不能被调用

print(callable(a))
# False  

def f():
    print("hello")

# 函数是可以被调用的
print(callable(f))
# True

【十三】查看内置属性

  • dir():
    • 查看对象的内置属性
    • 访问的是对象中的 __dir__() 方法
# 查看元组的方法
print(dir(tuple))

#查看变量名的属性
print(dir(ad))

【十四】调试器（breakpoint）

  • Debug

【十五】判断内存空间地址（id）

print(id('chosen'))
# 1469392953904

标签：__,函数,迭代,format,python,lst,print,高阶
From： https://www.cnblogs.com/chosen-yn/p/18168183

相关文章

  • C/C++、Java 与 Python 中未初始化变量的处理比较
    在C/C++中，未初始化的变量的值是不确定的，可能是随机的。 在Python中，如果直接使用未初始化的变量，会引发NameError异常。Python要求变量在使用前必须进行赋值或初始化。 而在Java中，直接使用未初始化的局部变量会导致编译错误，必须先对变量进行初始化。 C++和Java在字......
  • Python调用Graylog APi 分析401错误登录日志
    ret_lst处理完成后是一个list，内容如下：[{'c_ip':'10.10.202.139','uname':'ee'},{'c_ip':'10.10.202.139','uname':'tt'},{'c_ip':'192.168.195.131','uname......
  • Python: unZip
     importosimportsocketimportstructfromunidecodeimportunidecodeimportreimportjsonimportrequestsfrombs4importBeautifulSoupimportgzipimportzipfilefrompathlibimportPathfromzipfileimportZipFileclassCzip:"""......
  • python
                                搜索复制......
  • pip debug —— 查看当前版本的python解释器支持的wheel包类型
    在pip安装依赖时，我们可能会遇到依赖包无法下载成功的情况解决办法：去寻找对应版本的wheel包下载到本地搜寻wheel包网址：以python-ladp为例格式示例：python_ldap-2.5.1-cp27-cp27m-win32.whl2.5.1代表版本号cp27代表支持python27版本win32代表支持系统位数可以通过pipdeb......
  • 关于JSON转字符串后前端与python得到的结果不一致的问题，及对象按key排序
    背景：哈希码参数校验防参数篡改。前端下发接口时对参数按约定秘钥和逻辑进行加密，后端在获取到请求后对请求参数以同样的秘钥和逻辑加密计算得出哈希值，再与请求的哈希值对比，如果不一致则证明参数被篡改。前端代码：对json对象进行了按key排序1letdataTmp=this.de......
  • Go语言系列——自定义错误、panic和recover、函数是一等公民（头等函数）、反射、读取文件
    文章目录31-自定义错误使用New函数创建自定义错误使用Errorf给错误添加更多信息使用结构体类型和字段提供错误的更多信息使用结构体类型的方法来提供错误的更多信息32-panic和recover什么是panic？什么时候应该使用panic？panic示例发生panic时的deferrecoverpanic，re......
  • Go语言系列——数组和切片、可变参数函数、Maps、字符串、指针、结构体、方法、接口（一
    文章目录11-数组和切片数组数组的声明数组是值类型数组的长度使用range迭代数组多维数组切片创建一个切片切片的修改切片的长度和容量使用make创建一个切片追加切片元素切片的函数传递多维切片内存优化12-可变参数函数什么是可变参数函数语法通过一些例子理解可变参......
  • TypeScript入门1：注释、变量常量、数据类型、函数
    console.log('hits');//声明变量leta:number=10;//声明常量constb:number=20;//类型推断:如果⼀个变量或常量的声明包含了初始值，TS便可以根据初始值进⾏类型推断，此时可以不显式指定其类型letc=60;console.log(typeofc);//number//数字类型:整数和浮点......
  • Python-与-TensorFlow2-生成式-AI（五）
    Python与TensorFlow2生成式AI（五）原文：zh.annas-archive.org/md5/d06d282ea0d9c23c57f0ce31225acf76译者：飞龙协议：CCBY-NC-SA4.0第十二章：用生成式人工智能玩视频游戏：GAIL在之前的章节中，我们已经看到如何使用生成式人工智能来生成简单的（受限玻尔兹曼机器）和复杂的（变分自动......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99