Python 编程 | 连载 23 - 常用函数与高阶函数

一、常用函数

Python 中的常用的内置函数如下：

函数	参数	描述	返回值
abs()	number	返回数字的绝对值	正整型
all()	list	判断列表内容是否全是True	bool
any()	Iterable	判断内容是否有true值	bool
help()	object	用于查看函数或模块用途的详细说明	无返回值
enumerate()	iterable	迭代时记录索引	无返回值
input()	str	命令行中输入信息	str
isinstance()	object, type	判断对象是否是某种类型	bool
type()	object	返回对象的类型	str
vars()	instance	返回对象或者类的属性和属性值	dict
dir()	object	返回对象中所有可用方法和属性	list
hasattr()	object, key	判断对象中是否有某个属性	bool
setattr()	object, key, value	给实例化对象添加属性和值	无返回值
getattr()	object, key	获取对象的属性	object

abs()

print(abs(-1))
print(abs(-100.00))
print(abs(10))
# 只能接收数字类型作为参数，None和str都会报错
print(abs(None))
print(abs('s'))

abs() 函数的参数只能为数字类型，如果数字是正整数则返回结果不做任何改变。

all() 与 any()

res_01 = all(['a', 'c', 1, 3, (5, 7), {'name': 'stark', 'address': 'NYC'}])
print('全部不为空时,{}'.format(res_01))

res_02 = all(['a', 0, 1, 3, (5, 7), {'name': 'stark', 'address': 'NYC'}])
print('存在0时,{}'.format(res_02))

res_03 = all(['a', '', 1, 3, (5, 7), {'name': 'stark', 'address': 'NYC'}])
print('存在空字符串时,{}'.format(res_03))

res_04 = all(['a', None, 1, 3, (5, 7), {'name': 'stark', 'address': 'NYC'}])
print('存在None时，{}'.format(res_04))

res_05 = all(['a', 'c', 1, 3, [], {'name': 'stark', 'address': 'NYC'}])
print('存在空列表时，{}'.format(res_05))

res_06 = all(['a', 'c', 1, 3, {}, {'name': 'stark', 'address': 'NYC'}])
print('存在空字典时，{}'.format(res_06))

当包含空列表、空字符串、None、空字典或者0时，all()函数返回结果为False，all()函数的参数必须是可迭代的。

res_01 = any(['a', 'c', 1, 3, (5, 7), {'name': 'stark', 'address': 'NYC'}])
print('元素全部为True时,{}'.format(res_01))

res_02 = any(['a', 0, 1, 3, (5, 7), {'name': 'stark', 'address': 'NYC'}])
print('元组只包含一个False时,{}'.format(res_02))

res_03 = any([0, (), {}])
print('元素全部为False时'.format(res_03))

只有当列表的中的所有元素全部为False时，any()函数才返回False，而all()函数只要有一个元素为 False 就返回 False。

help()

print(help('abs'))

print(help('all'))

enumerate()

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

heros = ['stark', 'thor', 'hulk', 'clint']
print(list(enumerate(heros)))

print(list(enumerate(heros, start=1)))

# for 循环中使用enumerate

for idx, hero in enumerate(heros):
    print(idx, hero)

isinstance() 与 type()

a = 1
print(isinstance(a, str))
print(isinstance(a, int))
# 只要是元祖中的一个就会返回True
print(isinstance(a, (str, int, list)))
# 只能是元组，不能是字典
print(isinstance(a, [str, int, list]))

class Tesla():
    pass


class Roaster(Tesla):
    pass


tesla = Tesla()
print(isinstance(tesla, Tesla))
print(type(tesla) == Tesla)

roaster = Roaster()
print(isinstance(roaster, Tesla))
print(type(roaster) == Tesla)

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

vars()

class Tesla():
    name = 'Roadster'
    factory = '上海特斯拉超级工厂'


tesla = Tesla()
print("tesla实例所包含的属性和属性值，{}".format(vars(tesla)))
tesla.price = 88000.00
print('tesla实例所包含的属性和属性值，{}'.format(vars(tesla)))

print('Tesla类所包含的属性和属性值，{}'.format(vars(Tesla)))

print(vars())

dir()

dir()  函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

# 查看当前模块的属性和方法
print(dir())

# 查看字符串的属性和方法
print(dir(str))

hasattr()、getattr() 和 setattr()

class Roadster():
    name = 'roadster'
    factory = '上海特斯拉超级工厂'

roadster = Roadster()
print(hasattr(Roadster, 'name'))
print(hasattr(roadster, 'name'))
print(getattr(roadster, 'factory'))
setattr(roadster, 'price', 1200000.00)
print(getattr(roadster, 'price'))

二、高阶函数

filter()

filter() 函数可以对循环根据过滤条件进行过滤，过滤掉符合表达式的元素，返回符合条件的元素组成的新的列表。

filter(表达式, 可迭代对象)

def is_even(n):
    return n % 2 != 0

# 传入函数名称，不需要加()
nums = filter(is_even, [1, 2, 3, 4, 5, 6])
print(nums)

for num in nums:
    print(num)

map()

map()  会根据提供的函数对指定序列做映射，第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

map(条件表达式, 可迭代对象)

def div(x):
    return x / 2

nums = map(div, [1,2,3,4])
print(nums)

for num in nums:
    print(num)

frunts = ['apple', 'banana', 'orange']

def filter_func(item):
    if 'e' in item:
        return True

filter_result = filter(filter_func, frunts)
print(list(filter_result))

map_result = map(filter_func, frunts)  # > all
print(list(map_result))

filter()和map()的区别在于filter()返回的是符合条件的元素组成的列表，map()返回的是每个元素调用传入函数之后的返回组组成的列表。

reduce()

对循环前后两个数据进行累加

reduce(表达式, 可迭代对象)

from functools import reduce

frunts = ['apple', 'banana', 'orange']

# 返回1*1*2*4*4
reduce_result = reduce(lambda x, y: x * y, [1, 1, 2, 4, 4])
print(reduce_result)

# 返回 apple+banana+orange
reduce_result_str_add = reduce(lambda x, y: x + y, frunts)
print(reduce_result_str_add)

# 返回 apple*banana*orange
reduce_result_str = reduce(lambda x, y: x * y, frunts)
print(reduce_result_str)

字符串之间只能进行累加操作，不能进行乘法操作。