python-内置函数

• map(function, iterable, ...),function为函数，iterable为序列（可以提供多个序列对应不同的位置参数）

返回一个返回包含每次 function 函数返回值的迭代器

function可以使用定义的函数，也可以使用匿名函数

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]

•  setattr(object, name, value)，object为对象，name为字符串（即对象属性），value为属性值

用于为对象设置属性值

class A(object):
     bar = 1 
a = A()
getattr(a, 'bar')          # 获取属性 bar 值
# 1
setattr(a, 'bar', 5)       # 设置属性 bar 值
a.bar
# 5

为已有的bar属性进行赋值

class A():
     name = "runoob" 
a = A()
setattr(a, "age", 28)
print(a.age)
# 28

当属性不存在时，其会创建一个新的对象属性，并且对属性进行赋值

• all(iterable)，iterable为元组或列表

如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False

all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
# True
all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
# False
all([0, 1，2, 3])          # 列表list，存在一个为0的元素
# False
all(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
# True
all(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
# False
all((0, 1, 2, 3))          # 元组tuple，存在一个为0的元素
# False
   
all([])             # 空列表
# True
all(())             # 空元组
# True

• dir([object])，object为对象，变量，类型

返回模块的属性列表

dir()   #  获得当前模块的属性列表
# ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']

• any(iterable)，iterable为元组和列表

如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true

any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
# True
any(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
# True
any([0, '', False])        # 列表list,元素全为0,'',false
# False
any(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
# True
any(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
# True
any((0, '', False))        # 元组tuple，元素全为0,'',false
# False
  
any([]) # 空列表
# False
any(()) # 空元组
# False

• id([object])，obeject为对象

返回对象的内存地址

a = 'runoob'
id(a)
# 4531887632
b = 1
id(b)
# 140588731085608

• sorted(iterable, key=None, reverse=False)，iterable为可迭代对象，key为主要进行比较的元素，即指定可迭代对象中的一个元素进行排序

返回重新排序的列表

key所指定的元素可以是序列中的元素（序列中单个元素可能含有多个元素），也可以是序列中的元素计算到的结果

sorted([5, 2, 3, 1, 4])
# [1, 2, 3, 4, 5]                      # 默认为升序
a=[5,2,3,1,4]
a.sort()
a
# [1,2,3,4,5]
sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
# [1, 2, 3, 4, 5]

可以使用键来进行排序，因为键也是序列中的一个元素

example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)
# [7, 6, 5, 4, 3, 2, 1, 0]
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'}]

• enumerate(sequence, [start=0])，sequence为一个可迭代对象，start为下标起始位置

返回 enumerate(枚举) 对象

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1))       # 小标从 1 开始
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print(i, element)
# 0 one
# 1 two
# 2 three

• eval(expression[, globals[, locals]]),expression为表达式，globals为全局变量作用域（需要提供字典对象），locals为局部变量作用域

返回表达式计算结果

x = 7
eval( '3 * x' )
# 21
eval('pow(2,2)')
# 4
eval('2 + 2')
# 4
n=81
eval("n + 4")
# 85

a,b=eval(input())
# 可以用于提取用户输入的多个值
eval 方法能使字符串本身的引号去掉，保留字符的原本属性。

 

• exec(object[, globals[, locals]])，object为指定的python代码语句

返回值为none，执行储存在字符串或文件中的 Python 语句

exec('print("Hello World")')
# Hello World
# 单行语句字符串
exec("print ('runoob.com')")
# runoob.com
#  多行语句字符串
exec ("""for i in range(5):
    print ("iter time: %d" % i)""")
# iter time: 0
# iter time: 1
# iter time: 2
# iter time: 3
# iter time: 4

• sum(iterable[, start])，iterable为可迭代对象，如：列表、元组、集合，start为指定要相加的参数

返回计算结果

sum([0,1,2])  
# 3  
sum((2, 3, 4), 1)        # 元组计算总和后再加 1
# 10
sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
# 12

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

• getattr(object, name[, default])，object为对象，name为对象属性，default为默认值，如果不提供该参数，在没有对应属性时，将触发 AttributeError

返回对象属性

class A(object):
     bar = 1
a = A()
getattr(a, 'bar')        # 获取属性 bar 值
1
getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
#AttributeError: 'A' object has no attribute 'bar2'
getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
# 3

• repr(object)

返回一个对象的 string 格式，为供解释器读取的形式

s = 'RUNOOB'
repr(s)
# "'RUNOOB'"
dict = {'runoob': 'runoob.com', 'google': 'google.com'};
repr(dict)
# "{'google': 'google.com', 'runoob': 'runoob.com'}"

• zip([iterable, ...])，iterable为多个迭代器

返回一个对象，返回一个由元组组成的对象，可以使用list来转换

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

• compile(source, filename, mode[, flags[, dont_inherit]])

将一个字符串编译为字节代码

• locals()和globals()分别返回当前位置的局部和全局变量
•  reversed(seq)，seq为序列

返回一个反转的迭代器

# 字符串
seqString = 'Runoob'
print(list(reversed(seqString)))
# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
# ['b', 'o', 'o', 'n', 'u', 'R']
# ['b', 'o', 'o', 'n', 'u', 'R']
# [8, 7, 6, 5]
# [5, 3, 4, 2, 1]

 

• delattr(object, name)

无返回值，用于删除对象的属性

• hasattr(object, name)，object为对象名，name为属性名

 如果对象有该属性返回 True，否则返回 False

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 没有该属性
# True
# True
# True
# False