python内置函数

目录

• 一 python内置函数
  • 1 abs(x)
  • 2 all(iterable)
  • 3 any(iterable)
  • 4 bin(x)
  • 5 callable(object)
  • 6 chr(i)
  • 7 dir([object])
  • 8 divmod(a,b)
  • 9 eval(expression[,gloable[,locals]])
  • 10 isinstance(obj, cls)
  • 11 issubclass(sub, super)
  • 12 python面向对象中的反射：
    • 12.1 hasattr(object, name)
    • 12.2 getattr(object, name, default=None)
    • 12.3 setattr(x, y, v)
    • 12.4 delattr(x, y)
  • 13 @classmethod
  • 14 enumerate
  • 15 filter(function, iterable)
  • 16 globals()
  • 17 locals()
  • 18 max()
  • 19 min()
  • 20 sorted()
  • 21 zip(*iterables)

一 python内置函数

1 abs(x)

	# 返回一个数的绝对值。参数可以是一个整数或浮点数。

2 all(iterable)

	# 如果iterable的所有元素均为真值(或可迭代对象为空) 则返回True。

3 any(iterable)

	# 如果iterable的任一元素为真值则返回True。

4 bin(x)

# 将一个证书转变为一个前缀为“0b”的二进制字符串。
>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

5 callable(object)

	如果参数object是可调用的就返回True，否则就返回False。如果返回True，调用可能失败，但如果返回False，则调用object将一定失败。

6 chr(i)

	返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。这是 ord() 的逆函数。

7 dir([object])

	# 如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

8 divmod(a,b)

	# 它将两个(非复数) 数字作为实参，并在执行整行除法时返回一对商和余数。

9 eval(expression[,gloable[,locals]])

# 	基础用法：实参是一个字符串，可以忽略字符串执行内部的代码。>>> x = 1>>> eval('x+1')2

10 isinstance(obj, cls)

# 检查obj是否是类cls的对象class Foo(object):    passobj = Foo()isinstance(obj, Foo)  # True

11 issubclass(sub, super)

# 检查sub 类是否是super 类的派生类class Foo(object):    passclass Bar(Foo):    passissubclass(Bar, Foo)  # True

12 python面向对象中的反射：

	通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射) 。	四个可以实现自省的函数，适用于类和对象(一切皆对象，类本身也是一个对象) 。

12.1 hasattr(object, name)

#	判断object中有没有一个name字符串对应的方法或属性。class Foo:    def __init__(self, x, y):        self.x = x        self.y = y    def f1(self):        print('from f1')obj = Foo(111, 222)print(hasattr(obj, 'x'))  # True

12.2 getattr(object, name, default=None)

# 获取属性class Foo:    def __init__(self, x, y):        self.x = x        self.y = y    def f1(self):        print('from f1')obj = Foo(111, 222)print(getattr(obj, 'xxx', '没有这个值'))  # 没有这个值

12.3 setattr(x, y, v)

# 设置属性class Foo:    def __init__(self, x, y):        self.x = x        self.y = y    def f1(self):        print('from f1')obj = Foo(111, 222)setattr(obj, 'xxx', 1111)  # obj.xxx = 1111print(obj.xxx)  # 1111

12.4 delattr(x, y)

# 删除属性class Foo:    def __init__(self, x, y):        self.x = x        self.y = y    def f1(self):        print('from f1')obj = Foo(111, 222)delattr(obj, 'xxx')  # def obj.xxxprint(obj.xxx)  # AttributeError: 'Foo' object has no attribute 'xxx'

13 @classmethod

	把一个方法封装成类方法。	一个类方法把类自己作为第一个实参，就像一个实例(对象) 方法把实例自己作为第一个实参。

class C:    aaa = 'CCC'    @classmethod    def fk(cls):        print('fk u————>from class C', cls, cls.aaa)C.fk()  # fk u————>from class C <class '__main__.C'> CCCobj1 = C()obj1.fk()  # fk u————>from class C <class '__main__.C'> CCCclass D(C):    aaa = 'DDD'    def dk(self):        print('fk u————>from class D')D.fk()  # fk u————>from class C <class '__main__.D'> DDDobj2 = D()obj2.fk()  # fk u————>from class C <class '__main__.D'> DDD        

	类方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。 其所属类以外的类实例会被忽略。 如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入。

14 enumerate

enumerate(iterable, start=0)	返回一个枚举对象。iterable 必须是一个序列，或 iterator，或其他支持迭代的对象。 enumerate() 返回的迭代器的 __ next __() 方法返回一个元组，里面包含一个计数值(从 start 开始，默认为 0) 和通过迭代 iterable 获得的值。

15 filter(function, iterable)

	用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。iterable 可以是一个序列，一个支持迭代的容器，或一个迭代器。如果 function 是 None ，则会假设它是一个身份函数，即 iterable 中所有返回假的元素会被移除。	请注意， filter(function, iterable) 相当于一个生成器表达式，	当 function 不是 None 的时候为 (item for item in iterable if function(item))；	function 是 None 的时候为 (item for item in iterable if item) 。

def is_odd(n):    return n % 2 == 1tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])print(list(tmplist))  # [1, 3, 5, 7, 9]

16 globals()

	会以字典类型返回当前位置的全部全局变量。这总是当前模块的字典(在函数或方法中，不是调用它的模块，而是定义它的模块) 。

17 locals()

	更新并返回当前位置的全部局部变量，以字典类型的形式。 在函数代码块但不是类代码块中调用 locals() 时将返回自由变量。 请注意在模块层级上，locals() 和 globals() 是同一个字典。

18 max()

max(iterable, *[, key, default])max(arg1, arg2, *args[, key])	返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。	如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。	有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。	如果有多个最大元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

salary = {'egon': 4.4,"lqz": 3.3,'yj': 2.2}res = max(salary, key=lambda k: salary[k])print(res)  # egon

19 min()

min(iterable, *[, key, default])min(arg1, arg2, *args[, key])	返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。	如果只提供了一个位置参数，它必须是 iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。	有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。	如果有多个最小元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

salary = {'egon': 4.4,"lqz": 3.3,'yj': 2.2}res = sorted(salary, key=lambda k: salary[k], reverse = True)print(res)  # ['egon', 'lqz', 'yj']

20 sorted()

sorted(iterable, *, key=None, reverse=False)	根据 iterable 中的项返回一个新的已排序列表。	具有两个可选参数，它们都必须指定为关键字参数。	key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。	reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。	内置的 sorted() 确保是稳定的。 如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的 --- 这有利于进行多重排序(例如先按部门、再按薪级排序) 。

salary = {'egon': 4.4,"lqz": 3.3,'yj': 2.2}res = sorted(salary, key=lambda k: salary[k])print(res)  # ['yj', 'lqz', 'egon']########### 按照年龄排序 ##############    li = [{'name': 'zs', "age": 18},          {'name': 'ls', "age": 27},          {'name': 'xm', "age": 20},          ]    # sorted(iterable, cmp=None, key=None, reverse=False)    res = sorted(li, key=lambda li: li['age'])    print(res)

21 zip(*iterables)

zip(*iterables) 创建一个聚合了来自每个可迭代对象中的元素的迭代器。返回一个元组的迭代器，其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。 当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。 当只有一个可迭代对象参数时，它将返回一个单元组的迭代器。 不带参数时，它将返回一个空迭代器。