Python3 内置函数

#内置函数是Python自带的，不需要导入的函数
#查看各Python版本的内置函数：https://docs.python.org/3.5/library/functions.html

 

 

#coding:utf-8

#取绝对值
abs()



#判断传入all()的序列是否为真(可传入list,tuple,dict)
#如果传入的序列内容都为真。则返回值为True，否则返回值为false
print(all([1,2,3]))
#true

print(all([1,2,3,0]))
#false



#判断传入any()的序列是否为有一个为真(可传入list,tuple,dict)
#如果传入的序列内容有一个为真，则返回值为True。如果全部为假,则返回值为false
print(any(["1",[],(),None]))
#false

print(any(["",[],(),None]))
#false



#ascii() 相等于 __repr__()
#__repr__()是返回一个可以用来表示对象的可打印字符串

class Fool:
    def __repr__(self):
        return "aaaaa"

f = Fool()
ret = ascii(f)
print(ret)

ret = f.__repr__()
print(ret)



#取二进制
print(bin(10))



#转换成二进制
print(hex(10))



#转换成八进制
print(oct(10))



#判断是否为布尔值
print(bool(0))



#把对象转换成字节数组
print(bytearray("你好",encoding='utf-8')) #bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(bytearray([1,2,3]))   #bytearray(b'\x01\x02\x03')



#把对象转换成字节
print(bytes("你好",encoding='utf-8'))
print(bytes([1,2,3]))



#判断对象是否可被调用（返回true或false）
f = lambda x:x+2
print(callable(f))  #f函数可被调用，返回true

l = [1,2,3]
print(callable(l))  #l列表不能被调用，返回false



#把ASCII码对应的数字转换成字符串
print(chr(86))  #V



#把字符串转换成ASCII码对应的数字
print(ord("V")) #86



#compile()将source文件编译为代码或者AST可执行对象
str = "3 * 5 + 8"
a = compile(str,'','eval')
print(eval(a))



#转换成复数
print(complex(10))



#dir()查看当前对象所有方法的属性
print(dir(list()))



#vars()查看当前对象所有方法的属性和属性值的字典对象
print(vars(str))



#enumerate()#循环输出对象内容时，同时显示下标
li = ['eric','alex','tim']
for i,item in enumerate(li,1):  #数字1表示，初始的下标从1开始（默认从0开始）
    print(i,item)



#计算字符串中的算术表达式
#例如把一个表达式存在文本中，Python在来计算文本中的算术表达式，就可用eval方法
ret = "6*8"
print(eval(ret))



#把一个数字转换成浮点类型float()
print(float(10))    #10.0



#格式化字符串format()
##format() 等于 函数里的 __format__()
print(format(7))



#冻结类型的集合frozenset()
#因为集合可以被添加和删除，frozenset类型的集合则不可以
frozenset()



#显示当前所有的全局变量globals()
print(globals())



#hash()
#例子：
#有一个dict的key，它很长可能有100个字符，如果都存储在内存中可能会占用过多内存空间
#如果把dict的key转换为一个hash值，存储的话则能节省不少内存空间



#查看变量在的内存地址
print(id(10))



#输入input()
rest = input("你好")
print(rest)



#转换成int类型
print(int(10.11))



#判断对象是一个什么类型（返回true或false）
print(isinstance(1,int))
print(isinstance("你好",str))



#获取max()中的最大值
print(max(11,22,33,44,17,12))



#获取max()中的最小值
print(min(11,22,33,44,17,12))



#打开文件open(file,mode)
open("test.txt",'r')



#计算x的y次方pow(x,y)
print(pow(2,2))



#获取一个区间range()（3.x版本后没有xrange）
#3.x后它不会即可在内存中创建，只是在内存中创建一个对象，循环时才会逐个创建
result = range(0,10)
for n in result:
    print(n)



#repr()转化为供解释器读取的形式
#函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式



#反转reversed()
li = [1,2,3,4]
ret = reversed(li)
for n in ret:
    print(n)



#四舍五入round()
print(round(10.1))
print(round(2.9))



#切片slice()
mysplic = slice(5)
li = [n for n in range(0,100)]
print(li[mysplic])



#排序sorted()
li = [1,5,3,6,8,2,4]
print(sorted(li))



#转换成字符串str()
ret = str(88)
print(type(ret))



#求和sum()
#sum(iterable[, start]) ，iterable为可迭代对象
#sum([ ])                   #iterable为list列表
#sum(( ))                   #iterable为tuple元组
#sum({1: 'b',  7: 'a'})     #iterable为dict字典

result = sum([1,2,3,4])
print(result)   #10

result = sum([1,2,3,4],10)  #1+10+2+3+4 (1+10表示第一位加start位)
print(result)   #20

result = sum((1,2,3,4),10)
print(result)   #20

result = sum({1:"aa",2:"bb",3:"cc",4:"dd"},10)  #dict只会相加key的值
print(result)   #20



#元组
result = tuple([12,34,66])
print(result)           #(12, 34, 66)
print(type(result))     #<class 'tuple'>



#查看类型
result = "abc"
print(type(result))         #<class 'str'>




#map(def(),iterable)循环依次把iterable的数据传入到def()函数中，并得到一个新的iterable
#示例1：
#通过map()函数把list里面的num都加100，并得到一个新的可迭代的map对象
li = [1,2,3]
def js(num):
    num += 100
    return num

ret = map(js,li)
for n in ret:
    print(n)
#101
#102
#103

#示例2：
#通过map()函数，把list中大于100的数字，都乘以10，并得到一个新的可迭代的map对象
li = [n for n in range(50,200)]
def func(x):
    if x >= 100:
        x *= 10
    return x

result = map(func,li)
for n in result:
    print(n)
#50
#...
#98
#99
#1000
#1010
#...
#1990




#zip()把每个列表中，对应下标位置的值，组成一个新的元组
x = [1,2,3]
y = [4,5,6]
z = [7,8,9,0]
result = zip(x,y,z)
print(list(result))     #[(1, 4, 7), (2, 5, 8), (3, 6, 9)]




#getattr(object,'attr')                 #获取对象的属性
#setattr(object,'attr',value)           #设置一个新的属性并赋值，或者修改一个原有的属性的值
#setattr(object,'attr',value)           #设置一个新的属性并赋值，或者修改一个原有的属性的值
#delattr(object,'attr')                 #删除对象中的某一个属性

class A:
    def __init__(self):
        self.name = 'zhangjing'
        #self.age='24'
        def method(self):
            print("method print")

# getattr(object,'attr')                #获取对象的属性
ret = A()
print(getattr(ret,'name'))              #如果对象中有属性name则打印self.name的值，否则抛出错误'
print(getattr(ret,'age'))               #如果对象中有属性age则打印self.age的值，否则抛出错误
print(getattr(ret,'age','没有age'))      #如果对象中有属性age则打印self.age的值，否则打印“没有age”

#hasattr(object,'attr')                 #判断对象是否包含某个属性（包含返回true，不包返回false）
ret = A()
print(hasattr(ret,'name'))
print(hasattr(ret,'age'))

#setattr(object,'attr',value)           #设置一个新的属性并赋值，或者修改一个原有的属性的值
ret = A()
setattr(ret,'name','大王叫我来巡山')      #修改name属性的值
setattr(ret,'phone','1333333333')       #设置一个新的属性并赋值
print(ret.name)
print(ret.phone)

#delattr(object,'attr')                 #删除对象中的某一个属性
ret = A()
delattr(ret,'name')