python_內置函數

 

#內置函數
#一、abs  獲取絕對值
# abs(-10)
# --->10
#
# abs(10)
# --->10
#
# abs(0)
# --->0

#二、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

#三、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

#四、 ascii()返回一個表示對象的字符串
# >>> ascii('hello')
# "'hello'"

#五、bin() 返回一個整數 int 或者長整數 long int 的二進制表示。
# >>> bin(10)
# '0b1010'
# >>> bin(30)
# '0b11110'

#六、bool() 函數用於將給定參數轉換爲布爾類型，若是沒有參數，返回 False
# >>>bool()
# False
# >>> bool(0)
# False
# >>> bool(1)
# True
# >>> bool(2)
# True
# >>> issubclass(bool, int)  # bool 是 int 子類
# True

#七、bytearray() 方法返回一個新字節數組。這個數組裏的元素是可變的，而且每一個元素的值範圍: 0 <= x < 256。
# >>>bytearray()
# bytearray(b'')
# >>> bytearray([1,2,3])
# bytearray(b'\x01\x02\x03')
# >>> bytearray('runoob', 'utf-8')
# bytearray(b'runoob')

#八、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'>

#九、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

#十、chr() 用一個整數做參數，返回一個對應的字符。
# >>>chr(0x30)
# '0'
# >>> chr(97)
# 'a'
# >>> chr(8364)
# '€'

#十一、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()   # 不須要實例化

#十二、compile() 函數將一個字符串編譯爲字節代碼。
# >>> str = "3 * 4 + 5"
# >>> a = compile(str,'','eval')
# >>> eval(a)         #結果：17

#1三、complex() 函數用於建立一個值爲 real + imag * j 的複數或者轉化一個字符串或數爲複數。若是第一個參數爲字符串，則不須要指定第二個參數。
# >>>complex(1, 2)
# (1 + 2j)
#
# >>> complex(1)    # 數字
# (1 + 0j)

#1四、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)

#1五、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}

#1六、dir() 函數不帶參數時，返回當前範圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。若是參數包含方法__dir__()，該方法將被調用。若是參數不包含__dir__()，該方法將最大限度地收集參數信息
#print(dir())

#1七、divmod() 函數把除數和餘數運算結果結合起來，返回一個包含商和餘數的元組
# str=divmod(7, 2)
# print(str)        #結果：(3, 1)

#1八、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

#1九、eval() 函數用來執行一個字符串表達式，並返回表達式的值
# >>>x = 7
# >>> eval( '3 * x' )
# 21
# >>> eval('pow(2,2)')
# 4

#20、exec 執行儲存在字符串或文件中的 Python 語句，相比於 eval，exec能夠執行更復雜的 Python 代碼
# >>>exec('print("Hello World")')
# Hello World

#2一、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)

#2二、float() 函數用於將整數和字符串轉換成浮點數。
# >>>float(1)
# 1.0

#2三、格式化字符串的函數 str.format()
# >>>"{} {}".format("hello", "world")    # 不設置指定位置，按默認順序
# 'hello world'

#2四、frozenset() 返回一個凍結的集合，凍結後集合不能再添加或刪除任何元素
# a = frozenset(range(10))     # 生成一個新的不可變集合
# print(a)

#2五、getattr() 函數用於返回一個對象屬性值。
# >>>class A(object):
# ...     bar = 1
# ...
# >>> a = A()
# >>> getattr(a, 'bar')        # 獲取屬性 bar 值
# 1

#2六、globals() 函數會以字典類型返回當前位置的所有全局變量
# >>>a='runoob'
# >>> print(globals()) # globals 函數返回一個全局變量的字典，包括全部導入的變量。
# {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}

#2七、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'))  # 沒有該屬性

#2八、hash() 用於獲取取一個對象（字符串或者數值等）的哈希值。
# >>>hash('test')            # 字符串
# 2314058222102390712
# >>> hash(1)                 # 數字
# 1

#2九、help() 函數用於查看函數或模塊用途的詳細說明
# >>>help('sys')             # 查看 sys 模塊的幫助
# ……顯示幫助信息……
#
# >>>help('str')             # 查看 str 數據類型的幫助
# ……顯示幫助信息……

#30、hex() 函數用於將一個指定數字轉換爲 16 進制數。
# >>>hex(255)
# '0xff'
# >>> hex(-42)
# '-0x2a'

#3一、id() 函數用於獲取對象的內存地址
# >>>a = 'runoob'
# >>> id(a)
# 4531887632

#3二、input() 函數接受一個標準輸入數據，返回爲 string 類型
# a = input("input:")

#3三、int() 函數用於將一個字符串或數字轉換爲整型。
# >>> int(3)
# 3

#3四、isinstance() 函數來判斷一個對象是不是一個已知的類型
# >>>a = 2
# >>> isinstance (a,int)
# True
# >>> isinstance (a,str)
# False
# >>> isinstance (a,(str,int,list))    # 是元組中的一個返回 True
# True

#3五、issubclass() 方法用於判斷參數 class 是不是類型參數 classinfo 的子類。
# class A:
#     pass
# class B(A):
#     pass
#
# print(issubclass(B,A))    # 返回 True

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

#3七、len() 方法返回對象（字符、列表、元組等）長度或項目個數
# >>> l = [1,2,3,4,5]
# >>> len(l)               # 列表元素個數
# 5

#3八、list() 方法用於將元組或字符串轉換爲列表。
# aTuple = (123, 'Google', 'Runoob', 'Taobao')
# list1 = list(aTuple)
# print ("列表元素 : ", list1)

#3九、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]

#4一、max() 方法返回給定參數的最大值，參數能夠爲序列
# a=[1,3,10,20,5]
# print(max(a))   #結果爲20

#4二、memoryview() 函數返回給定參數的內存查看對象
# >>>v = memoryview(bytearray("abcefg", 'utf-8'))
# >>> print(v[1])
# 98
# >>> print(v[-1])
# 103

#4三、man() 方法返回給定參數的最大值，參數能夠爲序列
# a=[1,3,10,20,5]
# print(max(a))   #結果爲1

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

#4五、oct() 函數將一個整數轉換成8進制字符串
# >>>oct(10)
# '012'
# >>> oct(20)
# '024'

#4六、open() 方法用於打開一個文件
# >>>f = open('test.txt')
# >>> f.read()

#4七、ord() 函數是 chr() 函數（對於 8 位的 ASCII 字符串）的配對函數，它以一個字符串（Unicode 字符）做爲參數，返回對應的 ASCII 數值，或者 Unicode 數值。
# >>>ord('a')
# 97
# >>> ord('€')
# 8364

#4八、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

#4九、print() 方法用於打印輸出
#print 在 Python3.x 是一個函數，但在 Python2.x 版本不是一個函數，只是一個關鍵字。

#50、property() 函數的做用是在新式類中返回屬性值。

#5一、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)

#5二、repr() 函數將對象轉化爲供解釋器讀取的形式。
# >>>s = 'RUNOOB'
# >>> repr(s)
# "'RUNOOB'"
# >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
# >>> repr(dict)
# "{'google': 'google.com', 'runoob': 'runoob.com'}"

#5三、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]

#5四、round() 方法返回浮點數x的四捨五入值
# print (round(70.23456))    #結果：70
# print (round(56.659,1))    #結果「56.7

#5五、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'])

#5六、setattr() 函數對應函數 getattr()，用於設置屬性值，該屬性不必定是存在的
# >>>class A():
# ...     name = "runoob"
# ...
# >>> a = A()
# >>> setattr(a, "age", 28)
# >>> print(a.age)
# 28

#5七、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]

#5六、sorted() 函數對全部可迭代的對象進行排序操做，sort 是應用在 list 上的方法，sorted 能夠對全部可迭代的對象進行排序操做。
# >>>sorted([5, 2, 3, 1, 4])
# [1, 2, 3, 4, 5]                      # 默認爲升序

#5七、staticmethod 返回函數的靜態方法
# class C(object):
#     @staticmethod
#     def f():
#         print('hello');
#
# C.f();          # 靜態方法無需實例化
# cobj = C()
# cobj.f()

#5八、str() 函數將對象轉化爲適於人閱讀的形式。
# >>>s = 'Hello'
# >>> str(s)
# 'Hello'

#5九、sum() 方法對系列進行求和計算。
# >>>sum([0,1,2])
# 3
# >>> sum((2, 3, 4), 1)        # 元組計算總和後再加 1
# 10

#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

#6一、tuple 函數將列表轉換爲元組
# >>>list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
# >>> tuple1=tuple(list1)
# >>> tuple1
# ('Google', 'Taobao', 'Runoob', 'Baidu')

#6二、type() 函數若是你只有第一個參數則返回對象的類型，三個參數返回新的類型對象
# >>> type(1)
# <type 'int'>
# >>> type('hello')
# <type 'str'>

#6三、vars() 函數返回對象object的屬性和屬性值的字典對象

#6四、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]

#6五、__import__() 函數用於動態加載類和函數
# import sys
# __import__('a')        # 導入 a.py 模塊