python-内置函数

 

1.函数set()

功能：函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

语法：class set([iterable])

参数说明：

• iterable -- 可迭代对象对象；

返回值

返回新的集合对象。

c=[1,0,1,0,1]
c=np.array(c)
print(set(c))
print(list(set(c)))
输出结果
{0, 1}
[0, 1]

2.运算符*

功能：2.1.表示乘号，2.2.表示倍数

   2.3.单个 * 1）、定义函数参数时使用*——*parameter是用来接受任意多个参数并将其放在一个元组中

def f(*arg):
	print(arg)
if __name__ == "__main__":
	f(4,5,6)
输出结果
(4, 5, 6)

              2）、调用函数时使用*——在列表、元组、集合、字典及其他可迭代对象作为实参，并在前面加 *

               如   *（1,2,3）解释器将自动进行解包然后传递给多个单变量参数（参数个数要对应相等）。

def f(a,b,c):
	print a  #[1,2]
	print b  #[3,4]
	print c  #[5,6]
if __name__ == "__main__":
	arg=[[1,2],[3,4],[5,6]]
	f(*arg)

   2.4、两个 **  1）、定义函数参数时使用*——   **parameter用于接收类似于关键参数一样赋值的形式的多个实参放入字

                           典 中（即把该函数的参数转换为字典）

def f(**arg):
	print arg  #{'a': 1, 'b': 2}
if __name__ == "__main__":
	#arg=[[1,2],[3,4],[5,6]]
	f(a=1,b=2)

                 2）、调用函数时使用*——** 的作用则是把字典 kwargs 变成关键字参数传递

def f(a,b):
	print a   #1
	print b   #2
if __name__ == "__main__":
	arg={'a': 1, 'b': 2}
	f(**arg)

 3.函数reduce()

在python3中如果使用reduce需要先导入  from functools import reduce

功能：reduce() 函数会对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

语法：

reduce(function, iterable[, initializer])

• function -- 函数，有两个参数
• iterable -- 可迭代对象
• initializer -- 可选，初始参数

返回值：返回函数计算结果

>>>def add(x, y) :            # 两数相加
...     return x + y
... 
>>> reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
15

4.函数 map()

功能：会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

语法：    map(function, iterable, ...)

>>>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]

5.函数filter()

功能：用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法： filter(function, iterable)

• function -- 判断函数。
• iterable -- 可迭代对象。

返回值：一个迭代器对象

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

[1, 3, 5, 7, 9]

 6.函数 enumerate()

功能：用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

语法：enumerate(sequence, [start=0])

• sequence -- 一个序列、迭代器或其他支持迭代对象。
• start -- 下标起始位置。

7. 函数 zip()

功能：

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

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

语法：zip([iterable, ...])

      iterabl -- 一个或多个迭代器

返回值：返回一个对象。

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
 
>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>

8.进制转变函数

8.1函数 bin()

     一个整数 int 或者长整数 long int 的二进制表示。

8.2函数 oct()

    将一个整数转换成8进制字符串。

8.3 函数 hex()

    将10进制整数转换成16进制，以字符串形式表示。

9.max() 函数

功能：返回给定参数的最大值，参数可以为序列。

语法:max(iterable, *[, default=obj, key=func]) -> value
     max(arg1, arg2, *args, *[, key=func]) -> value

#key决定按某个维度的大小进行排序
dict=[('a',5),("b",7),("c",3),("d",4)]

out=max(dict,key=lambda x:x[-1])

print(out)

输出('b', 7)

10 .hasattr() 函数 

功能：用于判断对象是否包含对应的属性。缺点：无论是属性名还是方法名，都在 hasattr() 函数的匹配范围内。因此，我们只能通过该函数判断实例对象是否包含该名称的属性或方法，但不能精确判断，该名称代表的是属性还是方法。（通过"__call__"来解决）

语法：

    hasattr(object, name)
参数  object -- 对象。
     name -- 字符串，属性名。

class fun():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def myprint(self):
        print(self.name,self.age)
f=fun("sunxiaomin",19)
print(hasattr(f,"name"))   #"True"
print(hasattr(f,"myprint"))  #"True"
if hasattr(f,"name") and hasattr(f.name,"__call__"):
    print("属性")
if hasattr(f,"myprint") and hasattr(f.myprint,"__call__"):
    print("方法")

11.setattr() 函数

功能：用于设置属性值，该属性不一定是存在的（如果属性不存在会创建一个新的对象属性，并对属性赋值）。

语法：

setattr(object, name, value)
参数
    object -- 对象。
    name -- 字符串，对象属性。
    value -- 属性值。

   getattr() 函数 

功能：用于返回一个对象属性值

语法：

getattr(object, name[, default])
参数
    object -- 对象。
    name -- 字符串，对象属性。
    default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

class A():
    def __init__(self):
        self.name="sun"
a=A()
print(getattr(a,"name"))          #sun
setattr(a,"name_sub","sun")
print(getattr(a,"name_sub"))      #sun