Python Note -- Day 5. 内置函数 range(),zip()-高阶函数sorted(),map(),reduce(),filter()

本文介绍了Python中的内置函数，包括range()用于生成数字序列，zip()用于组合多个迭代器，以及其他数据类型、变量和数学相关函数。还详细讲解了高阶函数sorted()进行排序，map()和reduce()进行映射和累积计算，以及filter()用于过滤操作。并提供了相关示例和应用，如利用这些函数解决实际问题，如学生成绩排序、字符串转换等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

11. 内置函数 range(),zip(),数据类变量类数学类

python.org

11.1 range()函数

功能：生成一个指定的数字序列
参数：start,stop[,step] step:步进，可正可负，默认为1
返回值：可迭代的对象，数字序列

res = range(10)
#转为list列表数据
print(list(res))
#转为for循环
for i in range(10):
    print(i)
#转为迭代器，使用next（）函数调用
ree = iter(res)
print(next(ree))

11.2 zip()函数

功能：可接收多个可迭代对象，然后把每个可迭代对象中的第i个元素组合在一起，形成一个新的迭代器
参数：*iterables，任意个可迭代对象
返回值：返回一个元组的迭代器

var1 = '12345'
var2 = ['a','b','c','d']
var3 = ('A','B','C','D')
zip1 = zip(var1,var2,var3)
print(zip1,type(zip1))
for i in zip1:
    print(i)
'''
('1', 'a', 'A')
('2', 'b', 'B')
('3', 'c', 'C')
('4', 'd', 'D')
'''

zip()与运算符结合可以用来拆解一个列表：*

var2 = ['a','b','c']
var3 = ['A','B','C']
zip1 = zip(var2,var3)

print(list(zip1))
print(zip(var2,var3))  # 迭代器对象！！
print(*zip(var2,var3)) # 组合好的多个元组数据！！
v2,v3 = zip(*zip(var2,var3))
print(var3 == list(v3) and var2 == list(v2))
print(v2,v3)

dict1={'name':'lily','age':20,'address':'heaven'}
for k,v in dict.items():
    print(k,v)

for x,y in zip(var2,var3):
    print(f'make {x) become {y}')

11.3 其他内置函数

11.3.1 数据类型相关内置函数

int(); float(); bool(); complex(); str(); list(); tuple(); dict(); set();

python 中的正无穷或负无穷，使用 float(“inf”) 或 float(“-inf”) 来表示。

11.3.2 变量相关函数

id() 获取当前数据的ID标识
type() 获取当前数据的类型字符串
print() 打印数据
input() 获取输入的数据
isinstance() 检测是否为指定的数据类型

11.3.3 数学相关函数

1. abs() 返回一个数的绝对值
2. sum(iteralble[,start])
从start开始自左向右对iterable中的项求和并返回总值

print(sum([1,5,3,8]))

3. 获取最大，最小值 max(),min()

print(max([6,9,1])) print(max(6,9,1,88))

4. 幂运算pow(x,y,p) 返回x的y次幂,p为取余
5. round(number[,ndigits])
返回number舍入到小数点后ndigits位精度的值
若ndigits被省略或为None，返回最接近输入值的整数

r = round(3.1415926,6)
print(r)

* 当参数n不存在时，round()函数的输出为整数。
* 当参数n存在时，即使为0，round()函数的输出也会是一个浮点数。
* 此外，n的值可以是负数，表示在整数位部分四舍五入，但结果仍是浮点数。

round(2.5) 奇进偶退 1.5=2，2.5=2

print(round(2.5)) #2
print(round(2.6)) #3
print(round(3.6)) #4

11.4 进制相关函数及字符集（了解）

bin() 数值类型转为二进制
int() 二进制转为整型

oct() 转为八进制 01234567
hex() 转为十六进制 0123456789abcdef

ascii 字符转换
A-Z 65-90
a-z 97-122
0-9 48-57
将字符转为ascii
print(ord('a'))
将ascii转为字符
print(chr(65))

Unicode

12 内置函数-高阶函数 sorted(),map(),reduce(),filter()

12.1 sorted()排序

运行原理：把可迭代数据里的元素，一个一个取出来，放到key函数中进行处理，并按照函数中return的结果进行排序，返回一个新的列表
参数：iterable 可迭代对象(容器类型数据，range数据序列，迭代器)
     reverse  可选，是否反转，默认为False
     key      可选，函数，可自定义或内置
返回值：**排序后的结果**

arr = [3,7,-9,8,23,4]
res = sorted(arr,reverse=True)
re = sorted(arr,key=abs)
print(res)
print(re) # [3, 4, 7, 8, -9, 23]
# 自定义函数
def fu(n):
    return n % 2
r = sorted(arr,key=fu)
print(r)

优化版

arr = [3,7,-9,8,23,4]
R = sorted(arr,key=lambda x:x%2)
print(R)

练习假设我们用一组tuple表示学生名字和成绩：
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
请用sorted()对上述列表分别按名字排序：
再按成绩从高到低排序：

def by_name(t):
    #这个是list里有一个tuple
    #每次传进去一个tuple    t[0]代表姓名列,t[1]代表分数列 
    return t[0].lower()   #t[0]:取出姓名，按开头字母排序（不用取出姓名的第一个字母）

L2 = sorted(L, key=by_name)
print(L2)

def by_score(t):
    return -t[1]    #取出成绩，然后取反 （实现效果一样）

L2 = sorted(L, key=by_score)
print(L2)

12.2 map()

功能：对传入的可迭代数据中的每个元素进行处理，返回一个新的迭代器
参数：func 函数，自定义|内置函数
     iterables：可迭代数据
返回值：**迭代器**

把一个字符串数字的列表转为整型的数字列表

varlist = ['1','2','3','4']
newlist = []
for i in varlist:
    newlist.append(int(i))
print(newlist)

# map()函数处理
res = map(int,varlist)
print(res,type(res)) # 返回的是迭代器!!
print(tuple(res)) #!!
print(set(res))

[1,2,3,4] ==> [1,4,9,16]

优化版

alist = [1,2,3,4]
res1 = map(lambda x:x**2,alist)
print(list(res1))

['a','b','c','d'] ==> [65,66,67,68]

blist = ['a','b','c','d']
re2 = map(lambda x:ord(x)-32,blist)
print(list(re2))

12.3 reduce()

from functools import reduce
reduce(function, iterable[, initializer])

功能：每次从iterable中取出两个元素，放入到func函数中进行处理，得出一个计算结果，
然后把这个计算结果和iterable中的第三个元素，放入到func函数中继续运算，
得出的结果和之后的第四个元素，加入到func函数中进行处理，以此类推，直到最后元素都参与了运算  
参数：func： 内置函数、自定义函数  
     iterable：可迭代对象  
返回值：最终的运算处理结果  
注意：使用reduce函数时，需要导入from functools import reduce

实例 1. [5,2,1,1] ==> 5211 整型：

# 普通方法
varlist = [5,2,1,1]
res = ' '
for i in varlist:
    res += str(i)
res = int(res)
print(res,type(res))

# 使用reduce
def myfunc(x,y):
    return x*10+y
res = reduce(myfunc,varlist)
print(res,type(res))

实例 2. 字符串转为数字不使用int函数 '456' == > 456

from functools import reduce
# 定义函数，给定一个字符串数字，返回一个整型的数字
def fuc(s):
    vardict = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7}
    return vardict[s]
# 1.先使用map函数把数字字符串，转为整型的数字
it1 = map(fuc,'456')
# 2.把数字列表中的值，使用lambda进行二次处理
it2 = reduce(lambda x,y:x*10+y, it1)
print(it2)

实例 3. 编写一个prod()函数，可以接受一个list并利用reduce()求积：

from functools import reduce
def prod(L):
    def func(x,y):
        return x*y
    return reduce(func,L)

# updated
def prod(L):
    return reduce(lambda x, y: x * y, L)

print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
    print('测试成功!')
else:
    print('测试失败!')

实例 4. 利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456：

def str2float(s):
    i = s.index('.')
    return reduce(lambda x, y: x * 10 + y, map(int, s[:i])) + reduce(lambda x, y: x / 10 + y, map(int, s[i + 1:][::-1])) / 10

print('str2float(\'123.456\') =', str2float('123.456'))
if abs(str2float('123.456') - 123.456) < 0.00001:
    print('测试成功!')
else:
    print('测试失败!')

12.4 filter() 过滤器

filter(func,iterable)
功能：：过滤数据，把iterable中的每个元素拿到func函数中进行处理，若函数返回True就保留，否则丢弃
参数：func 自定义函数
     iterable 可迭代数据
返回值：保留下来的数据组成的 迭代器

示例：保留所有的偶数，丢弃所有的奇数

varlist = [1,2,3,4,5,6,7,8,9]
# 普通方法
newlist = []
for n in varlist:
    if n % 2 == 0:
        newlist.append(n)
print(newlist)

# 使用filter
def fun(n):
    if n % 2 == 0:
        return True
    else:
        return False
it = filter(fun,varlist)
print(it)

* 另一版
it = filter(lambda x:True if x % 2 == 0 else False , varlist)
print(it,list(it))

例子：

# 在一个list中，删掉偶数，只保留奇数
def is_odd(n):
    return n % 2 == 1

# 把一个序列中的空字符串删掉 !!
def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

# return s.strip()
# AttributeError: 'NoneType' object has no attribute 'strip'

注意:
filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

用filter求素数

素数一般指质数。质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。
计算素数的一个方法是埃氏筛法：
首先，列出从2开始的所有自然数，构造一个序列：
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉： 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉： 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一个数5，然后用5把序列的5的倍数筛掉： 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
不断筛下去，就可以得到所有的素数。

# 可以先构造一个从3开始的奇数序列：
def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n
# 注意这是一个生成器，并且是一个无限序列。

# 然后定义一个筛选函数：
def _not_divisible(n):
    return lambda x: x % n > 0

# 最后，定义一个生成器，不断返回下一个素数：
def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        it = filter(_not_divisible(n), it) # 构造新序列
# 这个生成器先返回第一个素数2，然后，利用filter()不断产生筛选后的新的序列。

由于primes()也是一个无限序列，所以调用时需要设置一个退出循环的条件：

# 打印1000以内的素数:
for n in primes():
    if n < 1000:
        print(n)
    else:
        break
# 注意到Iterator是惰性计算的序列，所以我们可以用Python表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。

练习回数是指从左向右读和从右向左读都是一样的数，例如12321，909。利用filter()筛选出回数

# -*- coding: utf-8 -*-

def is_palindrome(n):
    x = str(n)
    return x[::1]==x[::-1]


# 测试:
output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]:
    print('测试成功!')
else:
    print('测试失败!')