python之内置函数

# -*- coding: utf8 -*-
#https://www.cnblogs.com/nulige/p/6121079.html
import math
"""""
#数学运算类：14个函数
#1 abs: Return the absolute value of a number
print(abs(-10))
print(abs(19.5))
print(abs(1+1j))     #等于a^2+b^2的开平方

#2 complex:返回复数
print(complex(1,2))  #=(1+2j)
print(complex(1,4j)) #等于(-3,0j)：实部=1-4=-3，虚部=0j
print(complex("19")) #=(19+0j)
print(complex("1+2j")) #=(1+2j)

#3 divmod:返回 取商取余
print(divmod(7,2))   #返回(3,1)
print(divmod(8,4))
print(divmod(8.8,1.7))
#print(divmod(1+2j,1+0.5j)) #不能是负数

#4 float：返回浮点数
print(float(10))  #=10.0
print(float(-1.5)) #=-1.5
print(float("123")) #=123.0
print(float("123.8")) #=123.8

#5 int(num,base=10)：返回整型
print(int())  #=0
print(int(1.2)) #=1
print(int('1',8)) #=1,如果指定进制数,第一参数必须为字符串
print(int("0x0a",16)) #=10
print(int("10",16))  #=16
print(int("10",8))  #=8

#6 pow：取幂
print(pow(10,2))  #=100
print(pow(10,2,7)) #=10^2%7=100%7=2
print(pow(2,0))  #=1

#7 range：产生一序列数
print(range(5))
for i in range(5):
    print(i)     #=0,1,2,3,4

#8 round:四舍五入
#round( x [, n]  )
#表示从小数点位数，其中 x 需要四舍五入，默认值为 0
print(round(1.5345,2))  #=1.53
print(round(1.5345))    #=2
print(round(1.5345,0))  #=2.0
print(round(1.5345,-1)) #=0.0

#9 sum:对集合求和
print(sum([1,2,3,4,5]))
print(sum((1,2,3,4,5)))
print(sum([1,2,3,4,5],10))
print(sum((1,2,3,4,5),10))

#10 oct:将一个数字转化为8进制
print(oct(10))  #=0o12
print(oct(28))  #=0o34

#11 hex:将整数x转换为16进制字符串
print(hex(12)) #=0xc
print(hex(-12)) #-0xc

#12 chr:返回整数x对应的ASCII字符:0~255
print(chr(0x31))  #16进制表示
print(chr(49))   #10进制表示

#13 bin: 将整数x转换为二进制字符串
print(bin(10))  #0b1010

#14 bool:返回一个布尔值
print(bool())   #false
print(bool(0))  #false
print(bool(1))  #true
print(bool(2))  #true


#集合类操作：12个函数
#1 format 格式化输出字符串，格式化的参数顺序从0开始
print("myname:{fistname},lastname:{lastname}".format(fistname="jason",lastname="diu"))  #myname:jason,lastname:diu
# 通过字典设置参数
name={"firstname":"jason","lastname":"diu"}
print("firstname:{firstname},lastname:{lastname}".format(**name))   #firstname:jason,lastname:diu
# 通过列表索引设置参数
name=["jason","diu"]
print("firstname:{0[0]},lastname:{0[1]}".format(name)) #firstname:jason,lastname:diu
#数字格式化
print(":.2f".format(3.143456))  #错误写法,表示格式需要加{}  =:.2f
print("{:.2f}".format(3.143456))  #3.14
print("{:,}".format(10000000))    #10,000,000


#2 enumberate 返回可枚举对象,该对象的next()方法将返回一个元组
name=["jason","yiyi","yanyan"]
print(list(enumerate(name)))   #[(0, 'jason'), (1, 'yiyi'), (2, 'yanyan')]
for i,element in enumerate(name,start=1):
    print(i,element)
#1 jason
#2 yiyi
#3 yanyan

#3 iter 生成一个对象的迭代器，第二个参数表示分隔符
lst=[1,2,3]
for i in iter(lst):
    print(i)       #1,2,3

#4 max 返回集合中的最大值
print(max(10,18,20))

#5 min 返回集合中的最小值
print(min(10,18,20))

#6 dict 创建一个数据字典
print(dict(zip(["one","two","three"],[1,2,3])))  #{'one': 1, 'two': 2, 'three': 3}
#print(dict([("one",1),("two",2),("three,3")]))

#7 list 创建一个列表，元素可修改
aTuple=("jason","yanyan","yiyi")
lst=list(aTuple)
print(lst)    #['jason', 'yanyan', 'yiyi']

#8 set 创建一个集合:不显示重复的字符
x=set("yanyan")
y=set("yiyi")
print(x,y)
print("交集:",x&y)   #交集x&y:返回一个新的集合，包括同时在集合 x 和y中的共同元素
print("并集:",x|y)   #并集x|y:返回一个新的集合，包括集合 x 和 y 中所有元素
print("差集:",x-y)   #差集x-y:返回一个新的集合,包括在集合 x 中但不在集合 y 中的元素
print("补集:",x^y)   #补集x^y:返回一个新的集合，包括集合 x 和 y 的非共同元素

#9 frozenset 创建一个不可变的集合
print(frozenset(range(10))) #frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

#10 str 创建一个字符串
astr="jason"
print(astr)
bstr=str("yiyi")
print(bstr)
cstr=str({"1":"jason","2":"yanyan","3":"yiyi"})  #{'1': 'jason', '2': 'yanyan', '3': 'yiyi'}
print(cstr)

#11 sorted 从可迭代项返回一个新的排序列表
a=(1,25,9,0,7)
b=[("jason","age",20),("yanyan","age1",18),("yiyi","age2",1)]
print(sorted(a))
print(sorted(b,key=lambda s:s[2])) #[('yiyi', 'age2', 1), ('yanyan', 'age1', 18), ('jason', 'age', 20)]

#12 tuple  创建一个元组
print(tuple([1,2,3,4]))     #将列表转换为元组 =(1, 2, 3, 4)
print(tuple({1:"jason",2:"yanyan",3:"yiyi"}))  #字典只返回key =(1, 2, 3)
print(tuple((1,2,3,4))) #输出元组本身 =(1, 2, 3, 4)

#逻辑判断函数：3个函数
#1 all :如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False
a=["ab","rt","ffg"]
b=["ab","","ffg"]
print(all(a))  #true
print(all(b))  #false

#2 cmp : 函数不再支持使用
#print(cmp(2,1))
#print(cmp(1,1))
#print(cmp(2,1))

#3 any:如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true
print(any(''))  #false
#print(any(0,'',False))
#print(0,'')

#反射类函数:
#1 callable:函数用于检查一个对象是否是可调用的,对于函数、方法、lambda 函式、
# 类以及实现了 __call__ 方法的类实例, 它都返回 True
def add1(a,b):  #函数
    return a+b
print(callable(add1))  #true

#2 classmemethod

#3 compile:函数将一个字符串编译为字节代码
astr="for i in range(1,3):print(i)"
bstr="2*3"
a=compile(astr,'','exec') #可以指定为 exec, eval, single
exec(a)   #1,2
b=compile(bstr,'','eval')
print(eval(b))   #=6

#4 eval:函数用来执行一个字符串表达式，并返回表达式的值
a=8
print(eval("a*a"))  #eval 蚕食必须为字符串 =64
print(eval('a*9'))  #72

#5 dir:函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；
# 带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。
# 如果参数不包含__dir__()，该方法将最大限度地收集参数信息
#print(dir())
#print(dir([]))

#6 global:返回全局变量的字典
print(globals())
#{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000215991A6D0

#7 delattr:函数用于删除属性

class axi:
    x=1.0
    y=2.0
    z=3.0
position=axi()
print(position.x,position.y,position.z)
delattr(axi,'z')  #delete attr 'z'
print(hasattr(axi,'z'))  #return false
#print(position.z) #return error

#8 getattr:函数用于返回一个对象属性值
class A:
    b=10
a=A()
print(getattr(a,'b')) #return 10
print(getattr(a,'c',11)) #return 11, output default(=11) if no attr
setattr(a,'b',20)  #修改a的属性‘b’的值
print(a.b)
setattr(a,'c',1) #给a增加属性'c'并赋值1
print(a.c)

#9 hasattr: see delattr above

#10 filter: 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
#该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，
# 最后将返回 True 的元素放到新列表中
def is_sqrt(x):
    return math.sqrt(x)%1==0
tmplist=filter(is_sqrt,range(1,101))
newlist=list(tmplist)
print(newlist)   #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]


#11 hash:用于获取取一个对象（字符串或者数值等）的哈希值
print(hash(10)) #10
print(hash("10")) #1375145331346203011
print(hash(str([1,2,3]))) #7376762723062468131
print(hash(str(sorted({1:'1'})))) #8370841957346914701

#12 di:返回对象的内存地址
print(id(1))  #2099681061168
print(id('abc')) #2099683237808

#13 isinstance :函数来判断一个对象是否是一个已知的类型，类似 type()
a=2
print(isinstance(a,int))  #a属于整型,返回True
print(isinstance(a,str))  #a不属于字符串,返回false
print(isinstance(a,(str,int,list))) #a属于元组中int整型,返回true

#14 issubclass:方法用于判断参数 class 是否是类型参数 classinfo 的子类
class A:
    pass
class B(A):
    pass
print(issubclass(B,A)) #B是A的子类，返回true
print(issubclass(A,B)) #false

#15 len:返回对象（字符、列表、元组等）长度或项目个数
print(len((1,2,3)))
print(len("qwertyoigfdxz"))

#16 locals:
a=1
print(locals())  # {......<module 'math' (built-in)>, 'a': 1}



#17 map
# 函数会根据提供的函数对指定序列做映射。
#第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表
def square(x):
    return x**2
print(map(square,[1,2,3,4,5])) #计算列表各个元素的平方 返回迭代器地址 <map object at 0x000001C0445DA460>
print(list(map(square,[1,2,3,4,5]))) #转换成列表
print(list(map(lambda x:x**2,[1,2,3,4,5]))) #使用匿名函数 lambda 

#18 memoryview:
v = memoryview(bytearray('abcdefg','utf-8')) #第二个参数为encoding
print(v[1],v[-1],v[1:5],v[1:5].tobytes())


#19 next:返回迭代器的下一个项目
#函数要和生成迭代器的 iter() 函数一起使用
it=iter([1,2,3,4])
while True:
    try:
        x=next(it)
        print(x)
    except StopIteration:
        break

#20 property: 函数的作用是在新式类中返回属性值

#21 reduce:

#21 setattr 见getattr

#22 repr:函数将对象转化为供解释器读取的形式
a=str('123456abcd')
b=[1,2,3,4]
#adict=dict({1:"jason",2:"yanyan",3:"yiyi"})
c={1:"jason",2:"yanyan",3:"yiyi"}
print(repr(a),repr(b),repr(c))


#23 staticmethod: 返回函数的静态方法
class C(object):
       @staticmethod  #声明函数A为静态方法
       def A(a):
           return a*a
b=C.A(2)   #直接调用类中的静态方法，无需实例化
print(b)
d=C()   #也可以实例化后调用
print(d.A(5))


#24 supper

#25 type
print(type(1),type('1'),type([1]),type({1:'1'}))
#type() 与 isinstance()区别
class A:
    pass
class B(A):
    pass
print(isinstance(A(),A))  #子类A()属于A本身，返回True
print(type(A())==A)  #返回True
print(isinstance(B(),A)) #B为A的子类，返回True
print(type(B())==A) #返回False

#26 vars:函数返回对象object的属性和属性值的字典对象
#返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()
class A:
    a=1
b=A()
print(vars(b))


#27 bytearray
print(bytearray([1,2,3]))
print(bytearray('12',"utf-8"))

#28 bytes
print(bytes([1,2,3]))
print(bytes('12',"utf-8"))

#29 zip
#函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，
# 这样做的好处是节约了不少的内存。
# 我们可以使用 list() 转换来输出列表。
#如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
a=[1,2,3]
b=[4,5,6]
c=[7,8,9,10,11]
azip=zip(a,b)
bzip=zip(a,c)  #元素个数与最短的列表一致
print(list(azip),list(bzip))
a1,a2=zip(*zip(a,b)) #与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
print(list(a1),list(a2))

#IO操作函数:
#1 file  已经弃用，使用open函数代替
#2 open: 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，
# 如果该文件无法被打开，会抛出 OSError。
afile=open("main.py",'r')
print(afile.read())


#3 input:
a=input("input:")
print(a)

#4 raw_input  2.x版本支持,3.x版本使用input代替
#help
help()

"""