Python中的内建函数,可迭代对象,迭代器

短命女 2022-02-21 10:46 411阅读 0赞

## Python中的内建函数和可迭代对象，迭代器 ##

#### 求值标识 ####

*  id() \#标识id 返回对象的唯一标识，CPython返回内存地址
 *  hash() \#哈希， 返回对象的哈希值
 *  len(s) -->返回一个集合类型的元素个数
 *  range(start,stop\[,step\]) -->返回一个从start开始到stop结束，步长为step的可迭代对象。step默认为1

#### 类型判断 ####

*  type() \#返回对象的类型
 *  isinstance(obj,class\_or\_tuple) —>True|False \#判断obj是否属于某种类型或者元组中列出的某个类型
    
     *  例如 isinstance(True,int) \#判断True是否是int类型
 *  issubclass(cls,class\_or\_tuple)—>True|False \#判断类型cls是否是某种类型的子类或元组中列出的某个类的子类
    
     *  例如issubclass(bool,(int,str)) \#判断bool是否是（int，str）其中一个的子类。

#### 类型转换 ####

*  float() -->转换为浮点型
 *  int() -->转换为整形
 *  bin() -->转换为2进制
 *  hex() -->转换为16进制
 *  oct() -->转换为8进制
 *  bool() -->返回bool值
 *  list() —>返回列表
 *  tuple() —>返回元组
 *  dict() —>返回字典对象
 *  set() —>返回集合对象
 *  complex() —>虚数转换
 *  bytes() —> 返回字节数组
 *  bytearry() —>返回可变的字节数组
 *  str() —>返回字符类型

#### 字符转换 ####

*  chr(i)–>str \#将整数转换成对应的字符
 *  ord(str)—>int \#将字符转换成对应的整数
 *  repr()
 *  ascii()

#### 输入输出 ####

*  input(\[prompt\])–>str 接受用户输入,返回一个字符串
 *  print(\*object,sep=’ ‘,end=’\\n’,file=sys.stdout,flush=False) -->打印输出，默认使用空格分割，换行结尾，输出到控制台

#### 数学运算相关 ####

*  abs(x)–> 返回x的绝对值 x为数值
 *  max()—> 返回最大值
 *  min()—> 返回最小值
 *  round(x)—>四舍五入取偶， 例如：round(-0.5)==0
 *  pow(x,y)—>求  x y x^y xy
 *  divmod(x,y) —>返回x除以y的商和x除以y的余组成的二元组。等价于tuple(x//y,x%y)
 *  sum(iterable\[,start\])可迭代对象的所有数值元素求和
    
     *  start为初始值，即从几开始累加
     *  例如：
    
        sum(range(5))  #求0~4所有数的和
        sum(range(5),3)  # 等价于3+sum(range(5))
 *  sorted(iterable\[,key\]\[,reverse\])—>list \#排序，返回一个新的列表，默认升序
    
     *  revers 是反转，默认revers = False
     *  key 解决待排序中不同类型之间的排序。key是函数（**这个函数指定了数据的排序方式**），这个函数就可以吧元素强制转化为你指定的类型,但转换后的结果只是用来做比较大小，不会改变最后生成的列表中的元素本身。
     *  例如：
    
        ls = [1,2,5,6,7,4,3,5,3]
        ls2 = sorted(ls)  # 返回一个由ls内元素升序组成的列表
        ls3 = sorted(ls,reverse=True) # 返回一个由ls内元素降序组成的列表
        lss = [1,2,5,6,7,4,3,5,"3"]
        lss2 = sorted(lss,key=str)
        print(lss2)

#### 迭代器惰性求值 ####

*  reversed(seq) -->返回一个翻转元素的迭代器。**惰性求值**
    
     *  例如：
    
        ls = list("abcd")
        ls1 = reversed(ls)
        print(ls,ls1)
        next(ls1)
    
    ![buitinfun002][]
 *  enumerate(seq,start=0)–>枚举生成器对象，返回索引数字和元素构成的二元组
    
     *  seq 需要迭代的序列
     *  start 表示索引开始的数字，默认是0
 *  iter(iterable) \#将一个可迭代对象封装成一个迭代器
 *  next(iterator\[,default\]) \#对一个迭代器取下一个元素。如果元素全部都取过了，再次next会抛出StopIteration异常
    
     *  例如：
    
        it = reversed([1,3,4,5,6])
        next(it)
 *  zip(\*iterable)—>迭代器 \#拉链函数
    
     *  根据多个个可迭代对象，返回一个由对应下标元素组成的元组。迭代器可返回值的个数取决于多个可迭代对象的最小长度。
     *  把多个可迭代对象合并在一起，返回一个迭代器。将每次从不同对象中渠道的元素合并成一个元组
        
         *  常用例子：
        
            list(zip(range(10,range(10),range(10))))
            dict(zip(range(10),range(10)))
     *  例如：
        
            m = zip(range(9),range(6))
            for i in m:
                print(i)
            print("------------")
            m = zip(range(3),range(6))
            for i in m:
                print(i)
        
        ![buitinfun003][]
 *  filter(function,iterable)->iterab 返回一个迭代器，过滤等效为False的值（当function为None时过滤等效为False的值。如果不为None需要定过滤规则）
    
     *  function：是个参数函数，且返回值应当是bool类型，或其返回值等效布尔值。默认值是None则可迭代对象的每一个元素自身等效布尔值
     *  iterable 可迭代对象
    
        print([_ for _ in filter(None,range(5))]) # 注意0等效False，没输出
        print([_ for _ in filter(lambda x: x%3==0,range(10))]) # 注意不能被3整除的数等效Fasle,没输出
    
    ![higfun002][]
 *  map(function,\*iterables)-> map object返回可迭代对象。\#对多个可迭代对象的元素，按照指定的函数进行映射。(带入函数，返回函数计算出来的返回值)
    
     *  function:是个参数函数
     *  iterables:可迭代对象(如果是多个，需要用位置传参)
     *  **注意：map通常做的是元素的变形，而filter做的是元素的过滤**
 *  reduce(function,iterable\[,initializer\]) \#归纳计算。 通过指定函数将集合中的数据按照指定方式规整为一个数据。
    
     *  function 是个函数，用来定义规整方式
     *  iterables 可迭代对象
     *  initializer 设置规整时的初始值，默认值为None，会获取iterables中的第一个元素作为初始值。
     *  Python官方伪代码如下：
    
        def reduce(function, iterable, initializer=None):
            it = iter(iterable)
            if initializer is None:
                value = next(it)
            else:
                value = initializer
            for element in it:
                value = function(value, element)
            return value
 *  all(iterable)—>True|False \#判断所有元素是否都等效于True,如果都是就返回True,否则返回False。如果集合没有一个元素，返回True
 *  any(iterable)—>True|False \#判断所有元素中是否有等效为True的元素，如果有，返回True.如果集合没有一个元素，返回False  
    ![buitinfun004][]

##### 可迭代对象 #####

1.  能够通过迭代一次次返回**不同元素**的对象
2.  可迭代，但是未必有序，未必可索引
3.  可迭代对象有：list、tuple、string、bytes、bytearray、range、set、dict、生成器等
4.  可使用成员操作符in、not in

#### 迭代器 ####

1.  特殊的对象，一定是可迭代对象，具备可迭代对象的特征
2.  生成器对象，就是迭代器对象
3.  创建和使用：
    
     *  可以通过iter方法把一个可迭代对象封装成迭代器
     *  可以通过next()方法获取迭代器中的元素。

*  附加  
    ![buitinfun001][]

[buitinfun002]: /images/20220221/96686437682242bc885ce8f446b0f723.png
[buitinfun003]: /images/20220221/50b80dfaf32a46b6b8ab9824f1f1d37b.png
[higfun002]: /images/20220221/c6fc4a260fcb4c4bbbb8fd594a1c9e73.png
[buitinfun004]: /images/20220221/b4ca331e7f20462cbc99a7fe50d4b237.png
[buitinfun001]: /images/20220221/353ce7931b6649919e5ee26fcd3cf5f9.png