　　python提供的强大的内置函数，接下来我们看一看这些函数都有哪些作用。

　　abs()求绝对值。

print(abs(-1))
print(abs(0))
运行结果
1
0

abs

　　all()传递可迭代对象，可迭代对象每个值得bool值都为Ture返回Ture，有一个为False，结果返回False。

print(all(i for i in range(10)))#False
print(all(i for i in range(1,10)))#True

all()

　　sum()将对象转为可迭代对象求和。

res=sum(i for i in range(3))
print(res)#3

sum()

　　any()传递可迭代对象，可迭代对象中有一个值的bool值为Ture返回Ture，所有值都为False，结果返回False。

print(any([]))#False
print(any([None,0,'',{},1]))#True

any()

　　bin()将传入值转化为二进制。

print(bin(3))#0b11

bin()

　　bool()返回bool值。

print(bool(0))#False
print(bool(None))#False
print(bool(''))#False

bool()

　　bytes()把字符串转为字节模式。

print(bytes('hello',encoding='utf-8'))#b'hello'

bytes()

　　callable()能否被调用，返回bool值。

def test():
    pass
print(callable(test))#True
print(callable(sum))#True

callable()

　　chr()与ord()ASCII码对应关系。

print(chr(67))#C
print(chr(65))#A
print(ord('A'))#65

chr()ord()

　　classmethod，staticmethod，property面向对象三贱客。

　　classmethod

class people:
    country = 'china'
    # 类方法，用classmethod来进行修饰
    @classmethod
    def getCountry(cls):  #类方法自动将类作为cls传递进函数内
        return cls.country
    @classmethod
    def setCountry(cls, country):
        cls.country = country
p = people()
print(p.getCountry())  # 可以用过实例对象引用
print(people.getCountry())  # 可以通过类对象引用
p.setCountry('japan')
print(p.getCountry())
运行结果：
china
china
japan

classmethod

　　staticmethod

class people:
    country = 'china'
    @staticmethod
    # 静态方法使用装饰器方式绑定，并且作用和普通函数一样并不会自动传递self
    def getCountry():
        return people.country
print(people.getCountry())
运行结果：
china

staticmethod

　　property

class people:
    __name = 'jeff'
    __age = 12
    def set(self):
        print(self.__name)
        print(self.__age)
p = people()
#print(p.__name,p.__age)   #AttributeError: 'people' object has no attribute '__name'
p.set()
运行结果;
jeff
12

property

　　complex()复数，定义复数

x=complex(1-2j)
print(x.real)#1.0
print(x.imag)#-2.0
x=1-2j
print(x.real)#1.0
print(x.imag)#-2.0

complex()

　　数据类型

　　int()整型，isinstance()判断数据类型

num=1 #num=int(1)
print(type(num)) #查看num的类型<class 'int'>
print(isinstance(num,int)) #判断num是否为int类型True
print(num is 1) #is 是身份运算，根据id去判断身份Tr

int()isinstance()

　　float()把数转换成浮点类型。

　　str()转化为字符串。

　　list()把任何iterable转化为列表。

x=list(i for i in range(10))
print(x)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list()

　　tuple()转化为元组。

　　dict()

d={'a':1}
d=dict(x=1,y=2,z=3)
print(d)#{'z': 3, 'x': 1, 'y': 2}

dict()

　　set()转化为集合，是可迭代对象，可转化为list。

　　frozenset()不可变集合

s={1,2,3,4,4}
print(s)
s.add(5)
print(s)#set可以增但是不可变集合都不可以
f=frozenset({1,2,3,4})
print(type(f))

frozenset()

　　dir()对象下面有哪些可调用方法。

　　divmod()返回元组，tuple(x//y,x%y)，前端分页功能。

print(divmod(100,33))#(3, 1)

divmod()

　　enumerate()迭代器

for i in enumerate(['a','b','c','d']):
    print(i)
运行结果：
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
for i in enumerate({'x':1,'y':2}):
    print(i)
运行结果：
(0, 'y')
(1, 'x')

enumerate()

　　format()格式化输出

　　globals()获取全局变量的字典,locals()获取执行本方法所在命名空间内的局部变量的字典.

def func():
    x = 1
    y = 2
    print(locals())  #打印局部作用域中的名字
    print(globals()) #打印全局作用域中的名字

globals()locals()

　　hash()得到哈希值，用来校验数据完整性，不可逆推。

s='hello'
print(hash(s))#-6379790348615061731
s='h'
print(hash(s))#5735203904575971755

hash()

　　help()获取帮助。

　　hex()转16进制

print(hex(10))#0xa
print(hex(11))#0xb

hex()

　　id()查看唯一标识身份号，is就是判断id是否相同。

print(id('asdf'))
a=1
b=2
print(id(a))
print(id(b))
print(a is b)
x='a'
y='a'
print(id(x))
print(id(y))
print(x is y)

id()

　　input()输入

　　iter()把可迭代对象转化为迭代器。

　　len()统计长度

　　max(),min()最大最小值

　　zip()拉链函数？zip把传入的两个参数转为可迭代对象，两边各next()放到一个元组。

l1=[1,2,3,4]
s='hel'
for i in zip(l1,s):
    print(i)
运行结果：
(1, 'h')
(2, 'e')
(3, 'l')

zip()

　　sorted()把可迭代对象next一遍然后升序放到列表里。

l=[3,4,1,0,9,10]
print(sorted(l)) #返回值是列表，默认是升序
print(sorted(l,reverse=True)) #降序排列

sorted()

　　map()映射,右边每一个数都根据左边的规则映射出一个新的列表。

l=[1,2,3,7,5]
m=map(lambda item:item**2,l)
print(m)#<map object at 0x00000000027CDD68>
print(list(m))#print(list(m))

map()

　　from functools import reduce #合并

from functools import reduce #合并
l=list(range(100))
print(l)
print(reduce(lambda x,y:x+y,l,100))#5050#reduce可以传多个值

from functools import reduce

　　filter过滤

name_l=[
    {'name':'egon','age':18},
    {'name':'dragonFire','age':1000},
    {'name':'gaoluchuan','age':9000},
    {'name':'fsw','age':10000},
]

f=filter(lambda d:d['age'] > 100,name_l)#左边返回值ture过滤出来
print(list(f))#[{'name': 'dragonFire', 'age': 1000}, {'name': 'gaoluchuan', 'age': 9000}, {'name': 'fsw', 'age': 10000}]

filter

　　oct()八进制

　　open()取得文件句柄

　　pow(x,y,z),x**y%z

　　range()获得可迭代对象

　　rper()也是显示，str更人性化

　　reversed()反转顺序

　　slice()切片，一般也不用这个

　　vars() 返回局部名称空间的名字，字典形式。

　　__import__将字符串导入

__import__('time')

__import__

　　compile()把字符串编译成字节码在运行。

　　exec()执行代码或编译后的字符串,无返回值

　　eval() 将字符串中表达式转换为python表达式,有返回值

　　round(x,[,n]) 四舍五入取x的值，n表示取小数点几位

匿名函数

　　比较几位老师的工资，谁的工资最高。

salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':250
}

　　直接使用max()得到的是key的最大值，比较values得到的又是最多的钱，如何比较的是钱而得到的是这个钱对应的key呢。

def get_value(k):
    return salaries[k]
print(max(salaries,key=get_value))#alex

　　max在这里，把传入值变成可迭代对象，每次取一个值传入右边的函数再比较，最后得出最大值输出的到最大值的人。

　　这里我们定义的get_value函数很简单，只有单一功能，完全没有必要，我们可以使用简单的lambda来一步完成。

lambda k:salaries[k]

　　匿名函数的调用。

f=lambda k:salaries[k] #匿名函数也可以赋值一个名字，但是这便违反了匿名的初衷
print(f)#<function <lambda> at 0x0000000001D0CBF8>
print(f('egon'))#3000

　　解决上面的问题也更简便。

print(max(salaries,key=lambda k:salaries[k]))#alex
print(min(salaries,key=lambda k:salaries[k]))#yuanhao

　　zip()函数

print(salaries.keys(),salaries.values())
z=zip(salaries.values(),salaries.keys())
print(z)
print(max(z))#取出最大的元组
for i in z:
    print(i)

　　sorted()

print(sorted(salaries)) #默认是按照字典salaries的key去排序的
print(sorted(salaries,key=lambda x:salaries[x]))
print(sorted(salaries,key=lambda x:salaries[x],reverse=True))
运行结果：
['alex', 'egon', 'wupeiqi', 'yuanhao']
['yuanhao', 'egon', 'wupeiqi', 'alex']
['alex', 'wupeiqi', 'egon', 'yuanhao']

python学习网

分类

内置函数与匿名函数

匿名函数