Python内建函数

分手后的思念是犯贱 2022-10-29 03:15 139阅读 0赞

是计算一个数的商和余数的时候，发现基础的内建函数还没有掌握，今天空了来补一下。以下的列子均是在Python3里面支持的。

那就从第一个开始求余数和商开始吧。

# 数字有关 #

### 数字计算 ###

*  divmod  
    python `divmod()`函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

![1][]

*  abs  
    提到数字计算还有用的最多的， `abs`，比如求任意一个数的x进制，如果是复数就可以用上这个 `abs，` 对应的加上一个 `signal -`。

digits = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    if base > len(digits):
        raise ValueError("Bases greater than 36 not handled in base_repr.")
    elif base < 2:
        raise ValueError("Bases less than 2 not handled in base_repr.")
    
    num = abs(number)
    res = []
    while num:
        num, r = divmod(num, base)
        #res.append(digits[num % base])
        #num //= base
        res.append(digits[r])
    
    if padding:
        res.append('0' * padding)
    if number < 0:
        res.append('-')
    return ''.join(reversed(res or '0'))

但是还可以用切片的方式来处理这个算法，

def numberToBase(n, b):
        if n == 0:
            return [0]
        digits = []
        while n:
            digits.append(int(n % b))
            n //= b
        return digits[::-1]

*  round
 *  pow  
    和math.pow 有点差别就是，后者是返回的float，前者类似于 `**`的计算结果， 比如pow(2,2) = 2\*\*2
 *  sum  
    有其他高级用法的可以参考numpy.sum这个求和
 *  min
 *  max

>>> round(2.456, 2)
    2.26
    >>> pow(3, 3)
    27
    >>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
    12
    >>> s = [2,3,4,1]
    >>> max(s)
    4
    >>> min(s)
    1

### 输入输出 ###

*  input
 *  print  
    在python3的时候是一个函数， 不只是一个关键字了，

> print(\*objects, sep=' ', end='\\n', file=sys.stdout, flush=False)

下面就是每个0.5s间隔打一个点，就是类似`loading.......`的动态效果

print("Loading",end = "")
    for i in range(20):
        print(".",end = '',flush = True)
        time.sleep(0.5)

### 数据类型 ###

*  bool

>>>issubclass(bool, int)  # bool 是 int 子类
    True

*  int

>>> int('0xa',16)  
    10

*  float
 *  complex

# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
    >>> complex("1+2j")
    (1 + 2j)

### 进制转换 ###

*  bin
 *  otc
 *  hex

>>> bin(10)
    '0b1010'
    >>> oct(20)
    '0o24'
    >>> hex(12)
    '0xc'

# 数据结构 #

### 序列 ###

*  list
 *  tuple

>>> tuple({1:2,3:4})    #针对字典 会返回字典的key组成的tuple
     
    (1, 3)

### 操作序列 ###

*  reverse
 *  slice  
    其实和\[::\]类似，可以巧妙的用步长为-1就可以反转，看看下面的列子

>>> s.reverse()
    >>> s
    [1, 4, 3, 2]
    
    >>>myslice = slice(5)    # 设置截取5个元素的切片
    >>> myslice
    slice(None, 5, None)
    >>> arr = range(10)
    >>> arr
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> arr[myslice]         # 截取 5 个元素
    [0, 1, 2, 3, 4]
    >>> s
    [1, 4, 3, 2]
    >>> s[::-1]
    [2, 3, 4, 1] #可以有reverse的效果

### 字符串 ###

*  str
 *  bytes (only for python3)  
    可以用于有些socket只接受byte类型的input
 *  ord  
    ord() 函数是 chr() 函数(对于8位的ASCII字符串)或 unichr() 函数(对于Unicode对象)的配对函数
 *  chr
 *  repr  
    repr() 函数将对象转化为供解释器读取的形式。  
    和str()效果类似

>>> str(s)
    '[1, 4, 3, 2]'
    >>> bytes('xxd', 'utf-8')
    b'xxd'
    >>> bytes('叉叉敌', 'utf-8')
    b'\xe5\x8f\x89\xe5\x8f\x89\xe6\x95\x8c'
    
    >>> ord('a')
    97
    >>> ord('A')
    65
    >>> chr(97)
    'a'
    >>> repr(s)
    '[1, 4, 3, 2]'

### 数据集合 ###

*  dict
 *  set  
    set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
 *  frozenset  
    返回一个冻结的集合，冻结后集合`不能再添加或删除任何元素`。对象可以list， dict，tuple等
 *  getattr  
    用于判断对象是否包含对应的属性

>>> dict(a='a', b='b', t='t')     # 传入关键字
    {'a': 'a', 'b': 'b', 't': 't'}
    
    >>> set(s)
    {1, 2, 3, 4}
    >>> ss = [2,3,4,5]
    >>> set(ss)
    {2, 3, 4, 5}
    
    >>> set1 = set(ss)
    >>> set2 = set(s)
    >>> set1 |set2
    {1, 2, 3, 4, 5}
    >>> set1 - set2
    {5}
    >>> set2 - set1
    {1}
    
    >>> adict = {}
    >>> fs = frozenset(s)
    >>> adict[fs] = 123
    >>> adict
    {frozenset({1, 2, 3, 4}): 123}
    
    # 获取对象属性后返回值可直接使用
    >>> class A(object):        
    ...     def set(self, a, b):
    ...         x = a        
    ...         a = b        
    ...         b = x        
    ...         print a, b   
    ... 
    >>> a = A()                 
    >>> c = getattr(a, 'set')
    >>> c(a='1', b='2')
    2 1

### 处理集合的函数 ###

*  len  
    Python len() 方法返回对象(字符、列表、元组等)长度或项目个数。
 *  sorted  
    sorted() 函数对所有可迭代的对象进行排序操作。
 *  enumerate  
    enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。  
    这样就不用再加一个参数来获取对于的位置，直接就可以获取到对于的index值。

>>> for i,v in enumerate(s):
    ...     print(i,v)
    ...
    0 1
    1 4
    2 3
    3 2

*  all  
    可迭代对象中全部是True, 结果才是True  
    比如用于 需要执行所有的操作， 但是要最后检查实际的结果其中有没有Fail。 先把结果保存到一个list，然后用all(list)。

> 元素除了是 0、空、None、False 外都算 True。 any下同。

*  any  
    any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
 *  zip  
    用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

> 在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

>>> zipped = list(zip(s,ss)) # 打包
    >>> zipped
    [(1, 2), (4, 3), (3, 4), (2, 5)]
    >>> zip(*zipped)
    <zip object at 0x105c89190>
    >>> list(zip(*zipped)) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
    [(1, 4, 3, 2), (2, 3, 4, 5)]

*  filter  
    filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

import math
    def is_sqr(x):
        return math.sqrt(x) % 1 == 0
     
    newlist = filter(is_sqr, range(1, 101))
    print(newlist)
    :: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

*  map  
    map() 会根据提供的函数对指定序列做映射。用法和filter有点类似，`不过map要多个迭代参数`

>>>def square(x) :            # 计算平方数
    ...     return x ** 2
    ... 
    >>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
    [1, 4, 9, 16, 25]
    >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
    [1, 4, 9, 16, 25]
     
    # 提供了两个列表，对相同位置的列表数据进行相加
    >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
    [3, 7, 11, 15, 19]

*  locals  
    locals() 函数会以字典类型返回当前位置的`全部局部变量`。

>>> def testlocals(arg):
    ...     x = 1
    ...     print(locals())
    ...
    >>> testlocals(4)
    {'arg': 4, 'x': 1}

*  globals  
    globals() 函数会以字典类型返回当前位置的`全部全局变量`。

>>> globals()
    {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 's': [1, 4, 3, 2], 'slice': slice(None, 2, None), 'ss': [2, 3, 4, 5], 'set1': {2, 3, 4, 5}, 'set2': {1, 2, 3, 4}, 'i': 3, 'v': 2, 'list1': <zip object at 0x105cd8410>, 'zipped': [(1, 2), (4, 3), (3, 4), (2, 5)], 'testlocals': <function testlocals at 0x105c497a0>}

### 迭代器和生成器 ###

*  range  
    用方法和切片参数类似
 *  next
 *  iter  
    iter和next搭配使用， 这样就节约内存的加载，就用的时候才会价值。

>>> while True:
    ...     x = next(it, 's')
    ...     print(x)
    ...     if x == 's':
    ...             break
    ...
    1
    2
    3
    4
    5
    s

### 执行字符串代码 ###

*  compile  
    compile() 函数将一个字符串编译为字节代码。
 *  eval
 *  exec  
    可以动态的拼接字符串后，然后执行字符串语句。

>>>str = "for i in range(0,10): print(i)" 
    >>> c = compile(str,'','exec')   # 编译为字节代码对象 
    >>> c
    <code object <module> at 0x10141e0b0, file "", line 1>
    >>> exec(c)
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> str = "3 * 4 + 5"
    >>> a = compile(str,'','eval')
    >>> eval(a)
    17

### 内存相关 ###

*  hash  
    hash() 用于获取取一个对象(字符串或者数值等)的哈希值。  
    返回的 hash 值都是固定长度的，也用于校验程序在传输过程中是否被第三方(木马)修改，如果程序(字符)在传输过程中被修改hash值即发生变化，如果没有被修改，则 hash 值和原始的 hash 值吻合。 有点类似文件的md5，不过md5也有可能重复，实际应该是shanum。

### 其他 ###

*  open

with open('file') as f:
        f.write('ccd\n')

*  **import**  
    用于动态加载类和函数 。  
    经常用于一个模块经常变化就可以使用 **import**() 来动态载入。
 *  callable  
    用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

>>> def add(a, b):
    ...     return a + b
    ... 
    >>> callable(add)             # 函数返回 True
    True

*  classmethod  
    修饰符对应的函数`不需要实例化`，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class A(object):
        bar = 1
        def func1(self):  
            print ('foo') 
        @classmethod
        def func2(cls):
            print ('func2')
            print (cls.bar)
            cls().func1()   # 调用 foo 方法
     
    A.func2()               # 不需要实例化

还有一个比较常见的例子

#创建一个类
    class Date(object):
        def __init__(self, year, month, day):
            self.year = year
            self.month = month
            self.day = day
    
        def print_date(self):
            print(self.year, self.month, self.day)
    
    #实例化类
    data_object = Date('2018','10','31')
    #执行输出函数
    data_object.print_date()
    2018 10 31
    
    #在上面的例子中可以看到类的实例化需要传递‘年月日’三个参数。并且是要求分别传递。那么假设用户不按照要求填写，他填写的2018-10-31这样的一个参数呢？
    #我们需要先对参数进行分割处理，然后再实例化类。例如下面的代码：
    
    #分割函数
    def from_string(date_as_string):
        return map(int, date_as_string.split('-'))
    
    #创建类
    class Date(object):
        def __init__(self, year, month, day):
            self.year = year
            self.month = month
            self.day = day
    
        def print_date(self):
            print(self.year, self.month, self.day)
    
    #先执行分割函数对数据进行处理
    year, month, day = from_string('2018-10-31')
    
    #实例化类
    data_object = Date(year, month, day)
    #执行输出函数
    data_object.print_date()
    2018 10 31
    
    #这样做视乎可以解决这个问题，但是from_string方法应该是属于类的一部分，现在需要写在外部，就导致了类功能外散，后期不便于管理，以后增加功能的时候会出现问题，所以我们就必须将from_string迁移到类里面去，并且还要在类的实例化之前调用它，我们都知道，一般情况下，如果想调用类中的方法，必须先实例化类，而我们现在的需求是要在实例化之前。这时就需要使用@classmethod咯。代码如下：
    
    #创建一个类
    class Date(object):
        def __init__(self, year, month, day):
            self.year = year
            self.month = month
            self.day = day
    
        def print_date(self):
            print(self.year, self.month, self.day)
        
        #声明类方法
        @classmethod
        def from_string(cls, date_as_string):
            year, month, day = map(int, date_as_string.split('-'))
            return cls(year, month, day) #实例化类并返回实例化对象
    
    data_object = Date.from_string('2018-10-31')
    #执行输出函数
    data_object.print_date()
    2018 10 31
    
    #这是一个比较经典的案例，来自于stackoverflow。我暂时没有想到更好的，就先对原案例进行了一些修改并且加上了一些注释。
    #使用@classmethod可以有效的防止类功能外散，可以将对属于当前类的功能集中起来，便于管理，并且对类的继承、重载、多态都是有一定的帮助，这个小例子只能算是一个用法说明，在实际的操作中会有更加复杂的用法，还需要以项目的实际业务逻辑来制定。

*  staticmethod  
    与上面的classmethod对应还有这个方法。`最大的差别就是，在这个方法里面不涉及其他类成员的功能函数方法。`因为这个方法声明后始终调用的是基类的方法。而classmethod始终是当前类的。
 *  super  
    提到类，那不得不说下这个。`super()有一个非常好的优势，就是可以隐式的调用父类的当前类重载掉的方法。`

[https://www.zky.name/article/67.html][https_www.zky.name_article_67.html]

#声明A类
    class A:
        def __init__(self):
            self.n = 2
    
        def plus(self, m):
            print('当前对象是 {} 来自 A类的plus方法'.format(self))
            self.n += m
    
    #声明B类，继承A类
    class B(A):
        def __init__(self):
            self.n = 3
    
        def plus(self, m):
            print('当前对象是 {} 来自 B类的plus方法'.format(self))
            #调用C类的plus方法
            super().plus(m)
            self.n += 3
    
    #声明C类，继承A类。
    class C(A):
        def __init__(self):
            self.n = 4
    
        def plus(self, m):
            print('当前对象是 {} 来自 C类的plus方法'.format(self))
            #调用A类的plus方法
            super().plus(m)
            self.n += 4
    
    #声明D类，继承B和C类，这样D类就有2个父类咯。B和C就成为了兄弟类。
    #D类的MRO是[D,B,C,A,Object]
    class D(B, C):
        def __init__(self):
            self.n = 5
    
        def plus(self, m):
            print('当前对象是 {} 来自 D类的plus方法'.format(self))
            #调用B类的plus方法
            #一定要记住一点，在这个例子里，所有类中的super()函数都没有指定参数，所以从D类一直super()到A类，所有的self都是D类的self。
            super().plus(m)
            self.n += 5
    
    #实例化D类
    d = D()
    
    #调用D类的plus()方法
    d.plus(2)
    
    #输出D类的n属性
    print(d.n)

out：

当前对象是 <__main__.D object at 0x000000000222DCF8> 来自 D类的plus方法
    当前对象是 <__main__.D object at 0x000000000222DCF8> 来自 B类的plus方法
    当前对象是 <__main__.D object at 0x000000000222DCF8> 来自 C类的plus方法
    当前对象是 <__main__.D object at 0x000000000222DCF8> 来自 A类的plus方法
    19

如果是多重继承，就需要 `设置MRO并指定起始类`

class D(B, C):
        def __init__(self):
            self.n = 5
    
        def plus(self, m):
            print('当前对象是 {} 来自 D类的plus方法'.format(self))
            super(C,self).plus(m)
            #super(C,D).plus(self,m) 和上一句效果相同。
            self.n += 5
    
    #实例化D类
    d = D()
    
    #调用D类的plus()方法
    d.plus(2)
    
    #输出D类的n属性
    print(d.n)

输出结果：

当前对象是 <__main__.D object at 0x000000000280DCF8> 来自 D类的plus方法
    当前对象是 <__main__.D object at 0x000000000280DCF8> 来自 A类的plus方法
    12

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

>>> dir()
    ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'i', 'it', 'list1', 's', 'set1', 'set2', 'slice', 'ss', 'testlocals', 'time', 'v', 'x', 'zipped']
    >>>

*  help  
    查看函数或模块用途的详细说明。

>>>help('sys')             # 查看 sys 模块的帮助
    ……显示帮助信息……

*  id  
    或者内存地址  
    比如查看list的是一个连续的地址。其实python的list不是一个连续的地址。
 *  isinstance  
    判断一个对象是否是一个已知的类型，类似 type()。  
    如果要判断两个类型是否相同推荐使用 isinstance()。  
    type有9中。

> int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple

*  issubclass  
    2个参数，是否是后一个参数的子类
 *  memoryview  
    主要作用是获取对象的内存视图对象，即对象的引用。无论将对象的全部或者部分赋值给他们对象，都不会创建新的对象，修改被赋值对象也直接会影响原对象的值。

> 参数必须支持缓冲协议，一般常用的就是`bytes以及bytearray`，由bytes和bytearray生成的元素都是单字节的，而由其他类型(例如array.array)生成的可能包含更大的元素

可以看到d和z都是一个地址

>>> z
    b'a'
    >>> memoryview(z)
    <memory at 0x105ee4a10>
    >>>
    
    >>> d = z
    >>> memoryview(z)
    <memory at 0x105ee4d50>
    >>> d
    b'a'
    >>> z
    b'a'
    >>> memoryview(d)
    <memory at 0x105ee4d50>

*  property  
    主要作用是设置类属性的方法，用于指定属性的获取、修改和删除的对应方法，可以增加对属性的限制，例如验证、过滤、二次处理等。也可以将这个函数理解为属性的“资源路由”，任何与这个属性有关的操作，都会被自动分配给对应的方法去处理。这个函数还可以用类的装饰器@property、@x.setter以及@x.deleter来替代(x为属性名)。

>>> class User:
    ...     def __init__(self):
    ...         self._age = 0
    ...     @property
    ...     def age(self):
    ...         '这是设置年龄的property属性'
    ...         print('正在获取年龄属性')
    ...         return self._age
    ...     @age.setter
    ...     def age(self, value):
    ...         print('正在设置年龄属性')
    ...         self._age = value
    ...     @age.deleter
    ...     def age(self):
    ...         print('正在删除年龄属性')
    ...         del self._age
    ...
    >>> u = User()
    >>> u.age = 18
    正在设置年龄属性
    >>> u.age
    正在获取年龄属性
    18
    >>> del u.age
    正在删除年龄属性

## read more ##

[https://docs.python.org/zh-cn/3/library/functions.html][https_docs.python.org_zh-cn_3_library_functions.html][https://www.runoob.com/python/python-built-in-functions.html][https_www.runoob.com_python_python-built-in-functions.html][https://www.zky.name/article/19.html][https_www.zky.name_article_19.html]

[1]: /images/20221024/4ba3e59641424d7bb59169901d78f7c8.png
[https_www.zky.name_article_67.html]: https://www.zky.name/article/67.html
[https_docs.python.org_zh-cn_3_library_functions.html]: https://docs.python.org/zh-cn/3/library/functions.html
[https_www.runoob.com_python_python-built-in-functions.html]: https://www.runoob.com/python/python-built-in-functions.html
[https_www.zky.name_article_19.html]: https://www.zky.name/article/19.html