python_内置函数

#内置函数
#1、abs  获取绝对值
# abs(-10)
# --->10
#
# abs(10)
# --->10
#
# abs(0)
# --->0

#2、all()　　参数为可迭代对象，迭代对象为空时，返回True.如果迭代对象的所有元素都为真，那么返回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

#3、any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 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

#4、 ascii()返回一个表示对象的字符串
# >>> ascii('hello')
# "'hello'"

#5、bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
# >>> bin(10)
# '0b1010'
# >>> bin(30)
# '0b11110'

#6、bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False
# >>>bool()
# False
# >>> bool(0)
# False
# >>> bool(1)
# True
# >>> bool(2)
# True
# >>> issubclass(bool, int)  # bool 是 int 子类
# True

#7、bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
# >>>bytearray()
# bytearray(b'')
# >>> bytearray([1,2,3])
# bytearray(b'\x01\x02\x03')
# >>> bytearray('runoob', 'utf-8')
# bytearray(b'runoob')

#8、bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列
# >>>a = bytes([1,2,3,4])
# >>> a
# b'\x01\x02\x03\x04'
# >>> type(a)
# <class 'bytes'>
# >>>
# >>> a = bytes('hello','ascii')
# >>>
# >>> a
# b'hello'
# >>> type(a)
# <class 'bytes'>

#9、callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功
# >>>callable(0)
# False
# >>> callable("runoob")
# False
#
# >>> def add(a, b):
# ...     return a + b
# ...
# >>> callable(add)             # 函数返回 True
# True
# >>> class A:                  # 类
# ...     def method(self):
# ...             return 0
# ...
# >>> callable(A)               # 类返回 True
# True
# >>> a = A()
# >>> callable(a)               # 没有实现 __call__, 返回 False
# False
# >>> class B:
# ...     def __call__(self):
# ...             return 0
# ...
# >>> callable(B)
# True
# >>> b = B()
# >>> callable(b)               # 实现 __call__, 返回 True
# True

#10、chr() 用一个整数作参数，返回一个对应的字符。
# >>>chr(0x30)
# '0'
# >>> chr(97)
# 'a'
# >>> chr(8364)
# '€'

#11、classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
# class A(object):
#     bar = 1
#     def func1(self):
#         print('foo')
#     @classmethod
#     def func2(cls):
#         print('func2')
#         print(cls.bar)
#         cls().func1()   ## 调用 foo 方法
# A.func2()   # 不需要实例化

#12、compile() 函数将一个字符串编译为字节代码。
# >>> str = "3 * 4 + 5"
# >>> a = compile(str,'','eval')
# >>> eval(a)         #结果：17

#13、complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
# >>>complex(1, 2)
# (1 + 2j)
#
# >>> complex(1)    # 数字
# (1 + 0j)

#14、delattr 函数用于删除属性。
# class Coordinate:
#     x = 10
#     y = -5
#     z = 0
#
# point1 = Coordinate()
#
# print('x = ',point1.x)
# print('y = ',point1.y)
# print('z = ',point1.z)
# delattr(Coordinate, 'z')
# # 触发错误
# print('z = ',point1.z)

#15、dict() 函数用于创建一个字典
# >>>dict()                        # 创建空字典
# {}
# >>> dict(a='a', b='b', t='t')     # 传入关键字
# {'a': 'a', 'b': 'b', 't': 't'}
# >>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
# {'three': 3, 'two': 2, 'one': 1}
# >>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
# {'three': 3, 'two': 2, 'one': 1}

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

#17、divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组
# str=divmod(7, 2)
# print(str)        #结果：(3, 1)

#18、enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
# >>>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')]
#普通的for循环
# >>>i = 0
# >>>seq = ['one', 'two', 'three']
# >>>for element in seq:
# ...    print(i, seq[i])
# ...    i += 1
# ...
# 0 one
# 1 two
# 2 three

#19、eval() 函数用来执行一个字符串表达式，并返回表达式的值
# >>>x = 7
# >>> eval( '3 * x' )
#
# >>> eval('pow(2,2)')
#

#20、exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码
# >>>exec('print("Hello World")')
# Hello World

#21、filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换
# 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)

#22、float() 函数用于将整数和字符串转换成浮点数。
# >>>float(1)
# 1.0

#23、格式化字符串的函数 str.format()
# >>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
# 'hello world'

#24、frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
# a = frozenset(range(10))     # 生成一个新的不可变集合
# print(a)

#25、getattr() 函数用于返回一个对象属性值。
# >>>class A(object):
# ...     bar = 1
# ...
# >>> a = A()
# >>> getattr(a, 'bar')        # 获取属性 bar 值
#

#26、globals() 函数会以字典类型返回当前位置的全部全局变量
# >>>a='runoob'
# >>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
# {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}

#27、hasattr() 函数用于判断对象是否包含对应的属性
# 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'))  # 没有该属性

#28、hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
# >>>hash('test')            # 字符串
#
# >>> hash(1)                 # 数字
#

#29、help() 函数用于查看函数或模块用途的详细说明
# >>>help('sys')             # 查看 sys 模块的帮助
# ……显示帮助信息……
#
# >>>help('str')             # 查看 str 数据类型的帮助
# ……显示帮助信息……

#30、hex() 函数用于将一个指定数字转换为 16 进制数。
# >>>hex(255)
# '0xff'
# >>> hex(-42)
# '-0x2a'

#31、id() 函数用于获取对象的内存地址
# >>>a = 'runoob'
# >>> id(a)
#

#32、input() 函数接受一个标准输入数据，返回为 string 类型
# a = input("input:")

#33、int() 函数用于将一个字符串或数字转换为整型。
# >>> int(3)
#

#34、isinstance() 函数来判断一个对象是否是一个已知的类型
# >>>a = 2
# >>> isinstance (a,int)
# True
# >>> isinstance (a,str)
# False
# >>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
# True

#35、issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
# class A:
#     pass
# class B(A):
#     pass
#
# print(issubclass(B,A))    # 返回 True

#36、iter() 函数用来生成迭代器。
# >>>lst = [1, 2, 3]
# >>> for i in iter(lst):
# ...     print(i)
# ...
#
#
#

#37、len() 方法返回对象（字符、列表、元组等）长度或项目个数
# >>> l = [1,2,3,4,5]
# >>> len(l)               # 列表元素个数
#

#38、list() 方法用于将元组或字符串转换为列表。
# aTuple = (123, 'Google', 'Runoob', 'Taobao')
# list1 = list(aTuple)
# print ("列表元素 : ", list1)

#39、locals() 函数会以字典类型返回当前位置的全部局部变量
# >>>def runoob(arg):    # 两个局部变量：arg、z
# ...     z = 1
# ...     print (locals())
# ...
# >>> runoob(4)
# {'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
# >>>

#40、map() 会根据提供的函数对指定序列做映射
# >>>def square(x) :            # 计算平方数
# ...     return x ** 2
# ...
# >>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
# [1, 4, 9, 16, 25]

#41、max() 方法返回给定参数的最大值，参数可以为序列
# a=[1,3,10,20,5]
# print(max(a))   #结果为20

#42、memoryview() 函数返回给定参数的内存查看对象
# >>>v = memoryview(bytearray("abcefg", 'utf-8'))
# >>> print(v[1])
#
# >>> print(v[-1])
#

#43、man() 方法返回给定参数的最大值，参数可以为序列
# a=[1,3,10,20,5]
# print(max(a))   #结果为1

#44、next() 返回迭代器的下一个项目。
# 首先获得Iterator对象:
# it = iter([1, 2, 3, 4, 5])
# # 循环:
# while True:
#     try:
#         # 获得下一个值:
#         x = next(it)
#         print(x)
#     except StopIteration:
#         # 遇到StopIteration就退出循环
#         break

#45、oct() 函数将一个整数转换成8进制字符串
# >>>oct(10)
# '012'
# >>> oct(20)
# '024'

#46、open() 方法用于打开一个文件
# >>>f = open('test.txt')
# >>> f.read()

#47、ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
# >>>ord('a')
#
# >>> ord('€')
#

#48、pow() 方法返回 xy（x的y次方） 的值
# import math   # 导入 math 模块
#
# print ("math.pow(100, 2) : ", math.pow(100, 2))   #结果：math.pow(100, 2) :  10000.0
# # 使用内置，查看输出结果区别
# print ("pow(100, 2) : ", pow(100, 2))    #结果：pow(100, 2) :  10000

#49、print() 方法用于打印输出
#print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。

#50、property() 函数的作用是在新式类中返回属性值。

#51、Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表

# start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
# stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
# step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
# for i in range(0,5,2):
#     print(i)

#52、repr() 函数将对象转化为供解释器读取的形式。
# >>>s = 'RUNOOB'
# >>> repr(s)
# "'RUNOOB'"
# >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
# >>> repr(dict)
# "{'google': 'google.com', 'runoob': 'runoob.com'}"

#53、reversed 函数返回一个反转的迭代器,要转换的序列，可以是 tuple, string, list 或 range
# # 字符串
# seqString = 'Runoob'
# print(list(reversed(seqString)))      #结果['b', 'o', 'o', 'n', 'u', 'R']
# # 元组
# seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
# print(list(reversed(seqTuple)))    #结果['b', 'o', 'o', 'n', 'u', 'R']
#
# # range
# seqRange = range(5, 9)
# print(list(reversed(seqRange)))     #结果[8, 7, 6, 5]
#
# # 列表
# seqList = [1, 2, 4, 3, 5]
# print(list(reversed(seqList)))      #结果[5, 3, 4, 2, 1]

#54、round() 方法返回浮点数x的四舍五入值
# print (round(70.23456))    #结果：70
# print (round(56.659,1))    #结果“56.7

#55、set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等
# >>>x = set('runoob')
# >>> y = set('google')
# >>> x, y
# (set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
# >>> x & y         # 交集
# set(['o'])
# >>> x | y         # 并集
# set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
# >>> x - y         # 差集
# set(['r', 'b', 'u', 'n'])

#56、setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的
# >>>class A():
# ...     name = "runoob"
# ...
# >>> a = A()
# >>> setattr(a, "age", 28)
# >>> print(a.age)
#

#57、slice() 函数实现切片对象，主要用在切片操作函数里的参数传递
# >>myslice = slice(5)    # 设置截取5个元素的切片
# >>> myslice
# slice(None, 5, None)
# >>> arr = range(10)
# >>> arr
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# >>> arr[myslice]         # 截取 5 个元素
# [0, 1, 2, 3, 4]

#56、sorted() 函数对所有可迭代的对象进行排序操作，sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
# >>>sorted([5, 2, 3, 1, 4])
# [1, 2, 3, 4, 5]                      # 默认为升序

#57、staticmethod 返回函数的静态方法
# class C(object):
#     @staticmethod
#     def f():
#         print('hello');
#
# C.f();          # 静态方法无需实例化
# cobj = C()
# cobj.f()

#58、str() 函数将对象转化为适于人阅读的形式。
# >>>s = 'Hello'
# >>> str(s)
# 'Hello'

#59、sum() 方法对系列进行求和计算。
# >>>sum([0,1,2])
#
# >>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
#

#60、super() 函数是用于调用父类(超类)的一个方法
# class A:
#      def add(self, x):
#          y = x+1
#          print(y)
# class B(A):
#     def add(self, x):
#         super().add(x)
# b = B()
# b.add(2)  # 3

#61、tuple 函数将列表转换为元组
# >>>list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
# >>> tuple1=tuple(list1)
# >>> tuple1
# ('Google', 'Taobao', 'Runoob', 'Baidu')

#62、type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象
# >>> type(1)
# <type 'int'>
# >>> type('hello')
# <type 'str'>

#63、vars() 函数返回对象object的属性和属性值的字典对象

#64、zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
# a = [1,2,3]
# b = [4,5,6]
# c = [4,5,6,7,8]
# zipped = zip(a,b)
# print(zipped)      #结果：<zip object at 0x039E17D8>
# print(list(zipped))  #[(1, 4), (2, 5), (3, 6)]
# a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
# print(list(a1))    #结果[1, 2, 3]
# print(list(a2))    #结果[4, 5, 6]

#65、__import__() 函数用于动态加载类和函数
# import sys
# __import__('a')        # 导入 a.py 模块