函数--内置函数

内置函数一

 

 python官网源代码：https://docs.python.org/2/library/functions.html

 

 

abs()	绝对值
all()	当all里面的元素全部为真，返回结果为True ； 当all里的元素有一个为假，返回结果为False
any()	当any里的元素任意一个为真时，返回True；
ascii()	当执行这个函数时，会自动调用某个对象__repr__方法，并且返回__repr__的return值
bin()	把一个十进制转换二进制
oct()	把一个十进制转换八进制
hex()	把一个十进制转换十六进制
bool()	返回函数里的对象是否为True或者False  （以下常见的False对象：0,None,"",[],()）
bytes()	将字符串转换成字节类型， 转换格式为：bytes(只要转换的字符串，按照什么编码)
callable()	判断参数值是否能被执行调用
chr()	ascii码的对应关系：ascii码转成字符转
ord()	ascii码的对应关系：字符转成ascii码
classmethod()	类别的方法，面向对象中会讲
compile()	把一个字符串编译成一个python代码，然后通过exec()执行compile编译好的python代码
exec()	执行python代码，可以接收转换好了的python代码，或者将字符串转换成python代码；（但是没有返回值）
eval()	可以执行表达式，并且可以获取返回值；  eg：s = '8*8'    a= eval(s)  print(a) 等于64 &    s = 'print(123)'  a= eval(s)  print(a) 等于123
enumerate()	显示元素的索引
complex()	处理负数。
delattr()	反射，delattr,getattr,setattr,hasattr以后会讲
dir()	快速获取对象下面有什么方法
divmod()	获取商值，并获取余数，返回元祖；（可用于分页表达）
isinstance()	判断对象是否归属于某个类的实例，例如 s = "alex"  r= isinstance(s,str)  print(r)  #True  'alex'是个字符串，是属于str，所以返回一个True
filter()	过滤元素。格式：ret = filter(函数，可迭代的对象)  循环第二个可迭代的对象，然后逐个传值到第一个函数里，得出的结果返回给ret；
map()	过滤元素。与filter类似，区别： map将函数返回值，添加到结果中（无论真假）。filter函数体返回True，将元素添加到结果中。（如果是false，则丢弃）
float()	转换为浮点型
globals()	python在执行代码的时候，会把所有的全局变量放在这里
locals()	python在执行代码的时候，会把所有的局部变量放在这里
hash()	将对象转换成hash值，用于字典的key存入到内存中。
id()	查看内存地址
object()	所有类的父类
issubclass	查看某个类是不是这个类的子类
len()	查看长度
max()	最大值
min()	最小值
sum()	求和
round()	四舍五入
pow()	返回 xy（x的y次方） 的值。
range()	自定义数字范围
repr()	自动调用字符串下的__repr__的方法
open()	打开文本文件
print()	打印显示
input()	等待用户输入
tuple()	转换成元祖
type()	转换成类型
set()	转换集合
list()	转换成列表
dict()	转换成字典
int()	转换整数
str()	将字节转换成字符串，用什么样的字符集转成字节，就用什么字符集转成字符串，
vars()	当前模块都有那些变量
zip()	依次取出每一个数组的元素，然后组合   例如：zip([1,2,3],['a','b','c'],[4,5,6])       [(1, 'a', 4), (2, 'b', 5), (3, 'c', 6)]   如果没有对称的就不做匹配

 

 内置函数的练习

#!/usr/bin/env python
# -*- coding:utf8 -*-
# Author:Dong Ye

#abs()绝对值：
n = abs(-1)
print('n-->',n)
# n--> 1


#所有为真，才为真
n1 = all([1,2,3,4,5])
print('n1-->',n1)
# n1--> True


n2 = all([1,2,3,4,5,0])
print('n2-->',n2)
# n1--> True
# n2--> False


#任何一个为真，就为真
n3 = any([1,0,"",[],None])
print('n3-->',n3)
# n3--> True


#十进制转换二、八、十六进制：
print('二进制-->',bin(5))
print('十进制-->',oct(5))
print('十六进制-->',hex(5))
# 二进制--> 0b101
# 十进制--> 0o5
# 十六进制--> 0x5


#布尔值：
print('为假-->',bool([]))
print('为真-->',bool(-1))
# 为假--> False
# 为真--> True

#字符串转字节：
b = bytes('李杰',encoding='utf-8')
print('b-->',b)

b1 = bytes('李杰',encoding='gbk')
print('b-->',b1)


#字节转换成字符串：
s = str(bytes('李杰',encoding='gbk'),encoding='gbk')
print('s-->',s)
#字符串用什么样的编码变成字节了，也要用同样的编码转成字符串。



#判断参数是否能被调用执行：
def f1():
    pass

f2 = 123

c1  = callable(f1)
c2  = callable(f2)
print('callable(f1)-->',c1)
print('callable(f2)-->',c2)
# callable(f1)--> True
# callable(f2)--> False




#字符与ascii码的转换：
c = chr(65)
print(c)

o = ord("a")
print(o)

# A
# 97




#以下三个函数是一组：
# compile() ：把一个字符串编译成一个python代码
# eval()：
# exec()：执行一个python代码

'''
python解析器要打开文件的步骤：
1、加载：要读取文件内容open，将字符串加载到内存
2、编译：python内部把一个字符串->编译成一个特殊的代码 & 编译成python代码
3、执行：执行代码

注意:
编译有三种模式：single  eval  exec
single：把代码编译成单行的python程序
eval：把代码编译成表达式，并且有返回值
exec：把代码编译成python代码一模一样的东西


用途：有个exel，里面有列如下：
主机名     IP        内存
c1.com   1.1.1.1    8*8
c1.com   1.1.1.1    6*8

需求：如果想求IP为1.1.1.1的总内存多大
分析：
这时会就需要逐行读取内存列，然后通过计算8*8得出总内存结果。
当处理exel的时候，是一行一行的进行读取。
当读取到内存列的时候，应该是一个字符串，那问题来了？
怎么样让字符串8*8进行运算呢？
s = '8*8'
可以使用eval(s)函数，将字符串变成python表达式，这样就鞥查出结果。



参考视频教程：内置补充函数（二）
'''

#compile()将字符串编译成python代码
s = "print(123)"
#先编译：
#将字符串编译成python代码
r = compile(s,"<string>","exec")
print(r)
#exec执行python代码，可以接收代码或者字符串（但是没有返回值）
exec(r)
# <code object <module> at 0x00000000009E5C90, file "<string>", line 1>
# 123



#eval()可以执行表达式，并且可以获取返回值：
s = '8*8'
a = eval(s)
print(a)
#64



#获取商值，并获取余数，返回元祖；（可用于分页表达）
d1,d2 = divmod(100,10)
print(d1,d2)
#10 0



'''
对象和类的关系：
对象是类的实例：
例如：
汽车是类，对象是大汽车，小汽车，电动车等
人类是类，对象有大人，小孩，男人，女人等
'''
s="alex" #创建了个对象，对象就是s
r= isinstance(s,dict)
r1 = isinstance(s,str)
print(r)
print(r1)
# False
# True


s1 = [1,2,3]
r2 = isinstance(s,list)
print(r2)
# False


#filter  map
#需求：无filter，所有大于22的值取出，小于22的值放弃：
def f1(args):
    result = []
    for item in args:
        if item > 22:
            result.append(item)
    return result

li = [11,22,33,44,55,66]
ret = f1(li)
print('没有filter取大于22的值-->',ret)
#显示结果：
#没有filter取大于22的值 [33, 44, 55, 66]



#有filter(函数，可迭代的对象)的取值：
def f2(a):
    if a > 22:
        return  True

li = [11,22,33,44,55,66]
ret = filter(f2,li)
print('有filter取大于22的值-->',list(ret))
#显示结果：
# 有filter取大于22的值--> [33, 44, 55, 66]


#格式解释：
# ret = filter(函数，可迭代的对象)
# 1、先for循环第二个参数（可迭代的对象）。
# 2、在每一次循环的内部又会执行第一个参数（函数体）。
# 3、执行第一个参数拿到一个结果，如果为真；
# 4、则会把该元素添加到列表里，并返回结果；
# 5、可迭代的对象：列表，元祖，字典等


#filter与lambda表达式混用：
li = [11,22,33,44,55,66]
ret = filter(lambda a: a > 33,li)
print(list(ret))



#map的使用方式：
#需求：
#1、无map函数时，使每一个元素+100
li = [11,22,33,44,55,66]
def f3(args):
    result = []
    for i in args:
        result.append(100+i)

    return result

ret = f3(li)
print(list(ret))
#显示结果：
#[111, 122, 133, 144, 155, 166]



#2、map内置函数：
#格式：map(函数，可迭代的对象)
li = [11,22,33,44,55,66]

def f4(args):
   return  args+100

result = map(f4,li)
print(list(result))


#3、map+lambda表达式：
result = map(lambda a:a+100,li)
print(list(result))

#显示结果：
# [111, 122, 133, 144, 155, 166]
# [111, 122, 133, 144, 155, 166]
# [111, 122, 133, 144, 155, 166]


#####################两个函数区别##################
#filter：函数体返回True，将元素添加到结果中
#map：将函数返回值，添加到结果中
######################################



#gloabls() & local()
#例如：
name = 'alex'
def show():
    a = 123
    b = 123
    print(locals())
    print(globals())

show()

#显示结果：
# {'a': 123, 'b': 123}
# {'__package__': None, 'a': 64, '__builtins__': <module 'builtins' (built-in)>, 'ret': [111, 122, 133, 144, 155, 166], 'name': 'alex', '__doc__': None, '__file__': 'D:/软件/pychar/data/s13/day3/内置函数.py', 'r2': False, 'f2': <function f2 at 0x0000000000A5C378>, 'c2': False, 's1': [1, 2, 3], 'd2': 0, 'c': 'A', '__spec__': None, 'n2': False, 'f4': <function f4 at 0x0000000000A5C7B8>, '__cached__': None, 'result': <map object at 0x0000000000A79A20>, 'f3': <function f3 at 0x0000000000A5C840>, 'li': [11, 22, 33, 44, 55, 66], 's': 'alex', 'o': 97, 'b1': b'\xc0\xee\xbd\xdc', 'n3': True, 'r': False, 'f1': <function f1 at 0x0000000000A5C6A8>, 'b': b'\xe6\x9d\x8e\xe6\x9d\xb0', 'r1': True, 'c1': True, 'show': <function show at 0x0000000000A5C950>, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000678A58>, '__name__': '__main__', 'd1': 10, 'n1': True, 'n': 1}
#注意python在执行全局变量时，有很多的是内部定义好的全局变量。


s = 'u1'
print(len(s))
#2