Python3内置函数学习(五-完结)

Python3内置函数学习(五)

set

语法 set([iterable])

返回一个新的 set 对象/新的集合对象，可以选择带有从 iterable 获取的元素

>>> set('qwe') 
{'w', 'q', 'e'}

setattr

语法 setattr(object, name, value)

此函数与 getattr() 两相对应。 用于设置属性值，该属性不一定是存在的

其参数为一个对象、一个字符串和一个任意值

字符串指定一个现有属性或者新增属性。 函数会将值赋给该属性，只要对象允许这种操作

>>> class A(object):
...     bar=1
... 
>>> a = A()
>>> getattr(a,'bar') 
1
>>> setattr(a,'bar',100)
>>> a.bar
100

slice()

语法

class slice(stop)
class slice(start, stop[, step])

实现切片对象，主要用在切片操作函数里的参数传递

返回一个表示由 range(start, stop, step) 所指定索引集的 slice 对象。 其中 start 和 step 参数默认为 None

切片对象具有仅会返回对应参数值（或其默认值）的只读数据属性 start, stop 和 step。 它们没有其他的显式功能；不过它们会被 NumPy 以及其他第三方扩展所使用

>>> s=slice(5)      
>>> arr=range(10) 
>>> arr[s] 
range(0, 5)

sorted()

语法 sorted(iterable, *, key=None, reverse=False)

根据 iterable 中的项返回一个新的已排序列表

• sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）

>>> sorted([12222,223,34,354]) 
[34, 223, 354, 12222]

>>> sorted((12222,223,34,354)) 
[34, 223, 354, 12222]

>>> array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
>>> array = sorted(array,key=lambda x:x["age"])
>>> print(array)
[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]

staticmethod()

装饰器

将方法转换为静态方法， 静态方法无需实例化

静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

str()

语法

class str(object=’’)
class str(object=b’’, encoding=‘utf-8’, errors=‘strict’)

返回一个 str 版本的 object / 将对象转化为适于人阅读的形式

>>> s= 'qwe' 
>>> str(s) 
'qwe'

sum()

语法 sum(iterable, /, start=0)

从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串

对某些用例来说，存在 sum() 的更好替代。 拼接字符串序列的更好更快方式是调用 ‘’.join(sequence)

>>> sum((2, 3, 4), 1)
10

super()

语法 super([type[, object-or-type]])

返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。 这对于访问已在类中被重载的继承方法很有用。

用于调用父类(超类)的一个方法

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  # 3

tuple()

语法 tuple([iterable])

虽然被称为函数，但 tuple 实际上是一个不可变的序列类型

将可迭代系列（如列表）转换为元组

>>> l=['q','w','e'] 
>>> tuple1=tuple(l) 
>>> tuple1
('q', 'w', 'e')

type()

语法

class type(object)
class type(name, bases, dict)

传入一个参数时，返回 object 的类型。 返回值是一个 type 对象，通常与 object._class_ 所返回的对象相同。

推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况

>>> type(1)
<type 'int'>

vars()

语法 vars([object])

返回对象object的属性和属性值的字典对象

>>>print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}

zip()

语法 zip(*iterables)

创建一个聚合了来自每个可迭代对象中的元素的迭代器

返回一个元组的迭代器

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 ***** 号操作符，可以将元组解压为列表。

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]

import ()

语法 _import_(name, globals=None, locals=None, fromlist=(), level=0)

这是一个日常 Python 编程中不需要用到的高级函数

返回元组列表