Python Built-in Function 学习笔记

Python Built-in Function 学习笔记
1. 匿名函数
    1.1 什么是匿名函数
        python允许使用lambda来创建一个匿名函数，匿名是因为他不需要以标准的方式来声明，比如def语句

    1.2 匿名函数优点
        节省内存：如果不把它赋值给一个变量的话，由于是匿名的，不用分配栈空间
        不会重名
        可以嵌在推导式中，代码更简练
    1.3 举例
        lambda 参数列表:返回值
        a = lambda x,y=2:x+y
        a(5)  ==>  7
        a(2,3)==>  5


2. 内置函数
   2.1 abs():返回一个数值的绝对值，参数接受整数或浮点数，如果参数是复数，返回复数的模
   2.2 all(iterable): 可迭代对象为空或者元素全为True,返回True。 类似与and
   2.3 any(iterable): 可迭代对象中有一个元素为True返回True,否则返回False
   2.4 ascii():类似repr()
            print(ascii("abc
"))  #'abc
'

   2.5 bin(int):
            print(bin(100)) #0b1100100
            a = bin(100)
            print(type(a)) <class 'str'> 返回值是一个字符串
            将整数转换为二进制字符串，结果是一个有效的python表达式。
   2.6 bool(x):
            bool类型是int的子类，返回布尔True或False，使用真值测试标准对x进行转换。
            print(bool("123"))  --> True
   2.7 bytearray():返回一个字节数组
         source:
            如果是一个字符串，需要指定编码，以及可选的参数errors
            如果是一个可迭代对象，其整数元素取值范围0 <= x < 256
         a = bytearray("abc",encoding='utf-8',errors="失败")
         print(a,type(a)) # bytearray(b'abc') <class 'bytearray'>
         print(a[0]) # 97
         print(a[1]) # 98
         print(a[2]) # 99

   2.8 bytes(): 返回一个新的字节对象，是一个0 <= x < 256不可变的整数序列，是bytearray()不可变版本
   2.9 callable(object):
        如果object是可调用的，返回True。
        注：类是可以调用的，调用一个类会返回一个新的实例
   2.10 chr():
        ord()的逆操作,通过字符返回Unicode码值.
        print(chr(98)) #b
   2.11 classmethod():
        将函数包装成类方法。
        类方法隐式的将类作为第一个参数接收，就像实例方法接收实例一样
   2.12 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1):
        将source编译成代码或AST对象。代码对象可以被exec()或eval()执行
   2.13 complex():
        返回复数
   2.14 delattr(object,name):
        参数:对象,字符串(必须是对象属性之一的名称),该函数实现删除对象指定属性的操作，只要改对象允许
        delattr(x,'name')  ===>   del x.name

   2.15 dict(): 创建一个字典。dict对象是一个字典类，可以是实例化一个字典对象
        d = dict({'a':96})
   2.16 dir([object]):
        打印：
            --> 内置方法
            --> 内置属性
            --> 对象属性
            --> 对象方法
            --> 类属性
            --> 类方法

        1. 不带参数的时候：返回当前作用域的名称列表
        2. 带参数时：返回object有效属性列表
        3. 如果对象具有__dir__()方法，将会调用此方法，并且必须返回属性列表

        I.   如果对象是模块对象：列表包含模块的属性名
        II.  如果对象是类型或者类对象，列表包含其属性名称，并显示其父类的属性的递归。
        III. 否则列表包含对象的属性名称，其类属性的名称以及其类的基类的属性的递归。

   2.17 divmod(a,b):两个整数作为参数，返回商和余组成的元组。使用的整除(商,余数)
        print(divmod(1,2)) # (0,1)
        print(divmod(4,2)) # (2,0)
        print(divmod(10,3),type(divmod(10,3))) # (3,1)<class 'tuple'>

   2.18 enumerate(iterable,start=0):
        1. 返回一个enumerate object对象,索引默认从0开始
        2. 调用enumrate object的__next__()方法，返回一个元组
        3. 该元组包含一个计数,从start开始和iterable迭代的值

        for i in enumerate([1,2,3,4],start=0):
            print(i)

        (0, 1)   (start,iterable)
        (1, 2)
        (2, 3)
        (3, 4)

   2.19 eval(expression, globals=None, locals=None):
        参数是一个字符串和可选的全局变量和局部变量。
        也用于执行任意代码对象,支持语句的动态执行
        eval("print('Hello')")   --->   console打印：  Hello

   2.20 exec(object[, globals[, locals]):
        这个函数支持动态执行Python代码。object必须是一个字符串或代码对象。
        如果它是一个字符串，则将该字符串解析为一组Python语句，然后执行该语句（除非发生语法错误）。
        如果它是一个代码对象，只是简单地执行它。
        exec("print('Hello')")   --->   console打印：  Hello

        eval()和exec()区别:
            1. 如果是简单的表达是求值，eval()和exec()都可以
            2. exec()支持字符串、代码对象、复杂的Python代码
            3. eval()仅支持有效的表达式求值并返回计算结果

   2.21 filter(function, iterable):  类似表达式的过滤。比列表推导式省内存
            1. 如果function不是None，等效于生成器表达式，比列表推导式省内存
            2. 如果function是None,等效于列表推导式

            f = filter(None,shares)  # 函数为None,类似列表推导式，循环打印出每一个值
            print(f,type(f)) #<filter object at 0x00000242A5C585C0> <class 'filter'>
            for i in f:
                print(i)
                '''
                IBM
                Lenovo
                ocean
                '''

            # 类似可迭代对象的过滤工具：把每一项拿出来处理
            f = filter(lambda x:shares[x]>20,shares)  # 他会把每个元素拿出来，放到函数中，然后根据函数的返回值。返回一个filter对象
            print(f,type(f)) #<filter object at 0x00000242A5C585C0> <class 'filter'>
            for i in f:
                print(i)
            '''
            IBM
            Lenovo
            '''


   2.22 float():返回一个由数字或字符串x构造的浮点数。
   2.23 format():  字符串格式化
        I.
            print("{},{},{}".format(name,age,name)) # 不可以重复，有序
        II.
            print("{0},{1},{0}".format(name,age))  # 可以重复
        III.
            print("{name},{age},{name}".format(name=name,age=age))  # 可以重复，无序
   2.24 frozenset():返回一个新的frozenset对象，可选地使用iterable中的元素。
            set(可变集合)与frozenset(不可变集合)的区别：
            set无序排序且不重复，是可变的,有add（），remove（）等方法。既然是可变的，所以它不存在哈希值。基本功能包括关系测试和消除重复元素.
            frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add，remove方法。
   2.25 getattr(object,name[, default]):
            返回对象命名属性的值，name必须是字符串
            如果name是对象属性之一，则该结果是该属性的值。
                getattr(x,"name") ===>  x.name
            如果name不存在,则返回提供default值，否则引发AttributeError

   2.26 globals():
            返回当前全局变量名的字典
   2.27 hasattr(object,name):
            参数是一个对象和一个字符串。如果字符串是对象的一个属性，则返回True，否则返回False。
            它的实现是通过调用getattr(object, name)并查看它是否引发一个AttributeError。
            在getattr()之前判断object是否含有某个属性
   2.28 hash():
        返回该对象的哈希值（如果有的话）. 哈希值应该是一个整数。
        哈希值用于在查找字典时快速地比较字典的键。
        相等数值的哈希值相同（即使它们的类型不同，比如1和1.0）.

   2.29 help():调用内置的帮助系统。
   2.30 hex():将整数转换为以“0x”为前缀的小写十六进制字符串
   2.31 id(): 返回对象的内存地址
            返回一个对象的“身份”。
            这是一个整数，它保证在该对象的生命周期内是唯一的和恒定的。
            具有不重叠寿命的两个对象可以具有相同的id()值。
   2.32 input([prompt]):
            如果存在提示符参数，则将其写入标准输出而不带结尾换行符。
            然后该函数从输入中读取一行，将其转换为一个字符串（剥离尾随的换行符），然后返回该行。
            当读取到EOF时，会产生EOFError。
                input("Hello")  ---> console：Hello

   2.33 int():
            从数字或字符串（x）构造并返回一个整数对象
            如果没有给出参数，则返回0。
            如果 x 是一个数字，返回 x.__int__()。对于浮点数，这将截断为零。

   2.34 isinstance(object, classinfo):
            instance(实例,类型)
            如果object是clsaainfo的一个实例（或者是classinfo的直接、间接或虚拟子类的实例），那么则返回true。
            如果object不是给定类型的对象，则该函数始终返回false。

            如果classinfo是类型对象的元组（或者其他这样的元组），如果object是任何类型的实例，则返回true。
            如果classinfo不是类型或类型组成的元祖和此类元组，则会引发TypeError异常。

   2.35 issubclass(class, classinfo):
            issubclass(类,或父类)
            如果 class 是classinfo的子类(直接、 间接或 虚拟) 则返回 true 。
            一个类被认为是它自己的一个子类。

            任何其他情况下，会引发TypeError异常。

   2.36 iter(object[, sentinel]):
            1. 返回一个迭代器对象。
            2. 根据第二个参数:
                    没有第二个参数，object必须是一个支持迭代协议（__iter__()方法）的容器对象，或者它必须支持序列协议
                    第二个参数sentinel，那么object必须是一个可调用的对象。  object.__next__()

   2.37 len():返回对象的长度（项目数量）。
   2.38 list():list不是一个函数，它实际上是一个可变的序列类型
   2.39 locals():更新和返回表示当前局部符号表的字典。当locals()在函数代码块中调用时会返回自由变量，但是在类代码块中不会。
   2.40 map(function, iterable, ...):
            1. 返回一个迭代器
            2. 对iterable的每个项应用function，并yield结果。
   2.41 max():
            返回iterable中的最大项或两个或更多个参数中最大的项。
            max(iterable, *[, key, default])
            max(arg1, arg2, *args[, key])
   2.42 memoryview(obj):
            返回从给定参数创建的“内存视图”对象。
   2.43 min():
            返回可迭代中的最小项或两个或更多个参数中的最小项。
   2.44 next(iterator[, default]):
            通过调用__next__()方法从迭代器中检索下一个项目。如果给出default，则在迭代器耗尽时返回，否则引发StopIteration。
   2.45 object():
            返回一个新的无特征的对象。
            该函数不接受任何的参数。
   2.46 oct():将整数转换为八进制字符串。
   2.47 open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None):
            打开 file 并返回一个相应的 文件对象.如果文件不能被打开, 抛出 OSError 异常.

   2.48 ord():
            给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode代码点的整数。

   2.49 pow():返回x的y次方; 如果提供z参数， 返回x 的y次方再除以z的余数
   2.50 print(*objects, sep=' ', end='
', file=sys.stdout, flush=False):
                1. 将object打印到文本流file，由sep分隔，尾部接end。
                2. sep, end 和 file 如果提供这三个参数的话，必须以关键参数的形式。
   2.51 property():返回一个property 属性。
            class Person(object):
                def __init__(self,name,age):
                    self.name = name
                    self.age = age

                def gettx(self):
                    return self.name

                def setx(self,name):
                    self.name=name

                def delx(self):
                    del self.name
                x = property(gettx, setx, delx, "I'm the 'x' property.")

            p = Person(name,age)

            # 和@property一样。自定义托管属性
            print(p.x)
            p.x="haha"
            del p.x
   2.52 range():
            range(stop)
            range(start, stop[, step])
                range实际上是一个不可变的序列类型
   2.53 repr():
            返回一个包含对象可打印表示的字符串。
            一个类可以通过定义一个__repr__()方法来控制该函数为其实例返回的内容。
   2.54 reversed(seq):
            返回一个反向iterator。seq必须是具有__reversed__()方法或支持序列协议（__len__()方法和__getitem__()方法，整数参数从0开始）。
   2.55 round(number[, ndigits]):
            四舍五入
            返回number舍入到小数点后ndigits位的浮点值。如果省略ndigits，将返回最接近输入的整数。
   2.56 set():
            返回一个新的set对象，可选地使用iterable中的元素。
   2.57 setattr():
            它与getattr()相对应。参数是一个对象、一个字符串和一个任意值。
            该字符串可以命名现有的属性或新的属性。
            如果该对象允许，该函数将该值分配给该属性。
            setattr(x, 'foobar', 123)等同于x.foobar = 123

   2.58 slice():
            class slice(stop)
            class slice(start, stop[, step])
            返回表示由范围（start， stop， step）指定的一组索引的slice对象 T2>。


   2.59 sorted(iterable[, key][, reverse]):依据iterable中的元素返回一个新的排好序的列表。
            iterable[, key][, reverse]
            key指示一个带有一个参数的函数，它用于从列表的每个元素中提取比较的关键字：key=str.lower
            reverse是一个布尔值。如果设置为True，那么列表中元素反过来比较来排序。


   2.60 staticmethod():
            为函数返回一个静态方法。
   2.61 str()：
            返回一个object的str版本
            repr:对象以str形式表现出来，以便辨认
   2.62 sum(iterable[, start])：
            从左至右项目返回总数
            连接字符串序列的首选方法是通过调用''.join(sequence)的方式
   2.63 super(type[, object-or-type])：
            返回一个调用父类或者type同级类的委托方法
            访问类中被覆盖的继承方法时很有用
            1. 在单继承中，super()和其他编程语言类似，使用super()来引用父类，而不必明确命名它们
            2. 动态执行环境中，支持协同多继承。


   2.64 tuple([iterable]):
            tuple实际上是一个不可变的序列类型，而不是一个函数
   2.65 type():
            class type(object)
            class type(name, bases, dict)

            使用一个参数，返回对象的类型。
            返回值是一个类型对象，并且通常与object.__class__返回的对象相同。
            建议使用isinstance()内置函数来测试对象的类型，因为它考虑了子类。
            有三个参数，返回一个新的类型对象。这本质上是class语句的动态形式。

   2.66 vars([object]):
            返回一个模块、字典、类、实例或者其它任何一个具有__dict__属性的对象的__dict__属性。
   2.67 zip(*iterables):
            创建一个迭代器，聚合来自每个迭代器的元素。
            返回一个由元组构成的迭代器
            当最短的输入迭代耗尽时，迭代器停止。  以短的为标准

            zip()当迭代器元素不一致时，循环停止在较短的迭代器元素，较长的迭代器元素会被舍弃。
            zip()结合*运算符可用于解压缩列表

   2.68 __import__():
            通过 import 语句调用此函数。