Python基礎_內置函數

時間 2019-11-17
原文原文鏈接
		Built-in Functions
`abs()`	`delattr()`	`hash()`	`memoryview()`	`set()`
`all()`	`dict()`	`help()`	`min()`	`setattr()`
`any()`	`dir()`	`hex()`	`next()`	`slice()`
`ascii()`	`divmod()`	`id()`	`object()`	`sorted()`
`bin()`	`enumerate()`	`input()`	`oct()`	`staticmethod()`
`bool()`	`eval()`	`int()`	`open()`	`str()`
`breakpoint()`	`exec()`	`isinstance()`	`ord()`	`sum()`
`bytearray()`	`filter()`	`issubclass()`	`pow()`	`super()`
`bytes()`	`float()`	`iter()`	`print()`	`tuple()`
`callable()`	`format()`	`len()`	`property()`	`type()`
`chr()`	`frozenset()`	`list()`	`range()`	`vars()`
`classmethod()`	`getattr()`	`locals()`	`repr()`	`zip()`
`compile()`	`globals()`	`map()`	`reversed()`	`__import__()`
`complex()`	`hasattr()`	`max()`	`round()`
# abs(x)
print(abs(-10))  # 10
# 取絕對值

###################################
# all(iterable)
print(all([1,2,3,4,5]))  # True
print(all((0,1,2,3,4)))  # False
# 可迭代對象中，若是存在一個以上bool爲False的，則總體爲False

###################################
# any(iterable)
print(any([None,False,(),[],{},]))  # False
print(any([None,False,(),[],{},10]))  # True
# 可迭代對象中，只要存在一個是True，則爲True

###################################
# ascii(object)
print(ascii("abcd"))  # 'abcd'
print(ascii("中國"))  # '\u4e2d\u56fd'

###################################
# bin(x)
print(bin(3))  # 0b11
print(bin(-10))  # -0b1010
# 二進制

###################################
# bool([x])
print(bool(None))  # False
print(bool(2))  # True

###################################
# breakpoint(*args, **kws)
# print(breakpoint())  # 3.6

###################################
# bytearray([source[, encoding[, errors]]])
print(bytearray())  # bytearray(b'')
print(bytearray([1,2,3]))  # bytearray(b'\x01\x02\x03')
print(bytearray('test', 'utf-8'))  # bytearray(b'test')
# 若是 source 爲整數，則返回一個長度爲 source 的初始化數組；
# 若是 source 爲字符串，則按照指定的 encoding 將字符串轉換爲字節序列；
# 若是 source 爲可迭代類型，則元素必須爲[0 ,255] 中的整數；
# 若是 source 爲與 buffer 接口一致的對象，則此對象也能夠被用於初始化 bytearray。
# 若是沒有輸入任何參數，默認就是初始化數組爲0個元素。
# bytearray() 方法返回一個新字節數組。這個數組裏的元素是可變的，而且每一個元素的值範圍: 0 <= x < 256。

###################################
# bytes([source[, encoding[, errors]]])
print(bytes("中國","utf-8"))  # b'\xe4\xb8\xad\xe5\x9b\xbd'
print(bytes("中國","gbk"))  # b'\xd6\xd0\xb9\xfa'
print(bytes("hello world","utf-8"))  # b'hello world'
print(bytes("hello world","gbk"))  # b'hello world'

###################################
# callable(object)
def test():
    pass

class T():
    pass
class T1():
    def __call__(self):
        pass

print(callable([1,2,3]))  # False
print(callable(test))  # True
print(callable(T()))  # False
print(callable(T1()))  # True
# 驗證對象是否實現了__call__方法

###################################
# chr(i)
print(chr(77))  # M
# 經過ascii碼得出對應的字符
print(ord("M"))  # 77
# 反向，查找出字符對應的ascii碼

###################################
# classmethod
# 類方法

###################################
# compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
str = "for i in range(0,10): print(i)"
c = compile(str,'','exec')   # 編譯爲字節代碼對象
exec(c)
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# compile() 函數將一個字符串編譯爲字節代碼。

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

###################################
# delattr(object, name)
# 反射

###################################
# dir([object])
# 查看對象的namespace

###################################
# divmod(a, b)
print(divmod(100,3))  # (33, 1)
# a被除數，b除數
# res：（商，餘數）

###################################
# enumerate(iterable, start=0)
for index,value in enumerate([123,32,2],start=3):
    print(index,value)
# 3 123
# 4 32
# 5 2

###################################
# eval(expression, globals=None, locals=None)
print(eval("1+2+3*4"))  # 15
print(eval("x+y",{"x":1,"y":2}))  # 3
# 計算指定表達式的值

###################################
# exec(object[, globals[, locals]])
class T():
    pass
exec("x = T()")
print(x)  # <__main__.T object at 0x05A81050>

x = 10
expr = """
z = 30
sum = x + y + z   #一大包代碼
print(sum)
"""
def func():
    y = 20
    exec(expr)  # 10+20+30
    exec(expr,{'x':1,'y':2})  # 30+1+2
    exec(expr,{'x':1,'y':2},{'y':3,'z':4})  # 30+1+3，x是定義全局變量1，y是局部變量
func()
# 60
# 33
# 34

# 動態執行python代碼，exec無返回值

###################################
# filter(function,iterable)
print(list(filter(lambda x:x>4,[1,2,3,4,5,6,7,8,9])))  # [5, 6, 7, 8, 9]
# filter對象是一個迭代器，篩選

###################################
# float([x])
print(float(-123))  # -123.0
print(float('1e-003'))  # 0.001
print(float('+1E6'))  # 1000000.0
print(float("-Infinity"))  # -inf

###################################
# format(value[, format_spec])
print(format(3,'b')) #轉換成二進制  '11'
print(format(314159267,'0.2E')) #科學計數法，指定保留2位小數，採用大寫E表示 '3.14E+08'

###################################
# frozenset([iterable])
print(frozenset([1,2,3,4]))  # frozenset({1, 2, 3, 4})
# 不能改變，沒有add,remove

###################################
# getattr(object, name[, default])
# 反射

###################################
# globals()
print(globals())
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x03B6B450>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Python相關/過程project/爬蟲複習/第一次review/tmp.py', '__cached__': None, 'test': <function test at 0x057F07C8>, 'T': <class '__main__.T'>, 'T1': <class '__main__.T1'>, 'index': 5, 'value': 2, 'x': 10, 'expr': '\nz = 30\nsum = x + y + z   #一大包代碼\nprint(sum)\n', 'func': <function func at 0x057F0780>}
# 全局變量

###################################
# hasattr(object, name)
# 反射

###################################
# hash(object)
print(hash('good good study'))  # -724571439
print(hash(1.0))  # 1
print(hash(1))  # 1
print(hash(1.0000))  # 1
# hash() 用於獲取取一個對象（字符串或者數值等）的哈希值。

###################################
# help([object])
help('str')
# help() 函數用於查看函數或模塊用途的詳細說明。

###################################
# hex(x)
print(hex(255))  # 0xff
print(hex(12))  # 0xc
print(type(hex(123)))  # <class 'str'>
# hex() 函數用於將10進制整數轉換成16進制，以字符串形式表示。

###################################
# id([object])
# id() 函數用於獲取對象的內存地址。

###################################
# input([prompt])
# input("input:")  # input:
# input() 函數接受一個標準輸入數據，返回爲 string 類型。

###################################
# class int(x, base=10)
print(int(3.2))  # 3
print(int('12',16))  # 18
print(int("16",8))  # 14
# int() 函數用於將一個字符串或數字轉換爲整型。

###################################
# isinstance(object, classinfo)
# isinstance() 函數來判斷一個對象是不是一個已知的類型，相似 type()。

###################################
# issubclass(class, classinfo)
# issubclass() 方法用於判斷參數 class 是不是類型參數 classinfo 的子類。

###################################
# iter(object[, sentinel])
l = iter([1,2,3])
print(next(l))  # 1
print(next(l))  # 2
# iter() 函數用來生成迭代器。

###################################
# len( s )
# Python len() 方法返回對象（字符、列表、元組等）長度或項目個數。

###################################
# list( seq )
# list() 方法用於將元組轉換爲列表。

###################################
# locals()
# locals() 函數會以字典類型返回當前位置的所有局部變量。

###################################
# map(function, iterable, ...)
print(list(map(lambda x:x**3,[1,2,3])))  # [1, 8, 27]
# map() 會根據提供的函數對指定序列作映射。

###################################
# max(iterable, *[, key, default])
# max(arg1, arg2, *args[, key])
d = {"a":10,"b":9,"c":8,"d":7,"e":6}
print(max(d))  # e
print(max(d,key=lambda x:d[x]))  # a

###################################
# memoryview(obj)
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])  # 98
print(v[-1])  # 103
print(v[1:4])  # <memory at 0x09F7D8B8>
print(v[1:4].tobytes())  # b'bce'
# memoryview() 函數返回給定參數的內存查看對象(Momory view)。
# 所謂內存查看對象，是指對支持緩衝區協議的數據進行包裝，在不須要複製對象基礎上容許Python代碼訪問。

###################################
# min(iterable, *[, key, default])
# min(arg1, arg2, *args[, key])
d = {"a":10,"b":9,"c":8,"d":7,"e":6}
print(min(d))  # a
print(min(d,key=lambda x:d[x]))  # e

###################################
# next(iterator[, default])
# next() 返回迭代器的下一個項目。

###################################
# oct(x)
print(oct(10))  # 0o12
print(oct(20))  # 0o24
# oct() 函數將一個整數轉換成8進制字符串。

###################################
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

###################################
# ord(c)
# ord() 函數是 chr() 函數（對於8位的ASCII字符串）或 unichr() 函數（對於Unicode對象）的配對函數，它以一個字符（長度爲1的字符串）做爲參數，返回對應的 ASCII 數值，或者 Unicode 數值，若是所給的 Unicode 字符超出了你的 Python 定義範圍，則會引起一個 TypeError 的異常。

###################################
# pow(x, y[, z])
print(pow(2,10))  # 1024
print(pow(2,10,10))  # 4，取模，等價於pow(x,y) %z
# 返回 xy（x的y次方） 的值。

###################################
# print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

###################################
# property(fget=None, fset=None, fdel=None, doc=None)

###################################
# range(stop)
# range(start, stop[, step])

###################################
# repr(object)
# repr() 函數將對象轉化爲供解釋器讀取的形式。

###################################
# reversed(seq)
seqRange = range(5, 9)
print(list(reversed(seqRange)))  # [8, 7, 6, 5]
# reversed 函數返回一個反轉的迭代器。

###################################
# round(number[, ndigits])
print ("round(70.23456) : ", round(70.23456))  # round(70.23456) :  70
print ("round(-100.000056, 3) : ", round(-100.000056, 3))  # round(-100.000056, 3) :  -100.0
# round() 方法返回浮點數x的四捨五入值。

###################################
# set([iterable])

###################################
# setattr(object, name, value)
# 反射

###################################
# slice(stop)
# slice(start, stop[, step])
myslice = slice(5)    # 設置截取5個元素的切片
myslice1 = slice(2,9)
myslice2 = slice(2,9,3)
arr = range(10)
print(arr[myslice])  # range(0, 5)
print(arr[myslice1])  # range(2, 9)
print(arr[myslice2])  # range(2, 9, 3)
# slice() 函數實現切片對象，主要用在切片操做函數裏的參數傳遞。

###################################
# sorted(iterable, *, key=None, reverse=False)
print(sorted([5, 2, 3, 1, 4]))  # [1, 2, 3, 4, 5]
print(sorted([5, 0, 6, 1, 2, 7, 3, 4], key=lambda x: x*-1))  # [7, 6, 5, 4, 3, 2, 1, 0]
# sorted() 函數對全部可迭代的對象進行排序操做。

###################################
# staticmethod

###################################
# str(object='')
# str(object=b'', encoding='utf-8', errors='strict')

###################################
# sum(iterable[, start])
print(sum((2, 3, 4), 1))        # 10 元組計算總和後再加 1
print(sum((range(3,5)), 3))        # 10 元組計算總和後再加 3
# sum() 方法對系列進行求和計算。

###################################
# super([type[, object-or-type]])
# super() 函數是用於調用父類(超類)的一個方法。

###################################
# tuple([iterable])
# tuple 函數將列表轉換爲元組。。

###################################
# type(object)
# type(name, bases, dict)
print(type(1))  # <class 'int'>
print(type("abc"))  # <class 'str'>
# 三個參數
class X():
    a = 1
z = type("X",(object,),dict(a=1))
print(z)  # <class '__main__.X'>

###################################
# vars([object])
class X(object):
    a = 1
print(vars(X))  # {'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'X' objects>, '__weakref__': <attribute '__weakref__' of 'X' objects>, '__doc__': None}
# vars() 函數返回對象object的屬性和屬性值的字典對象。

###################################
# zip(*iterables)
a = [1,2,3]
b = [4,5,6]
c = [7,8,9]
print(list(zip(a,b,c)))  # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

###################################
# __import__(name, globals=None, locals=None, fromlist=(), level=0)
# __import__() 函數用於動態加載類和函數 。