国产一级a片免费看高清,亚洲熟女中文字幕在线视频,黄三级高清在线播放,免费黄色视频在线看

本節(jié)主要講述python的內置函數、變量以及常用內置模塊的函數。

abs：求數值的絕對值

返回一個數的絕對值。參數可以是普通的整數，長整數或者浮點數。如果參數是個復數，返回它的模

divmod：返回兩個數值的商和余數，以元組形式返回

>>> divmod(5,2)(2, 1)>> divmod(5.5,2)(2.0, 1.5)
1
2
3
4
1
2
3
4

max：返回可迭代對象中的元素中的最大值或者所有參數的最大值

min：返回可迭代對象中的元素中的最小值或者所有參數的最小值

>>> min(1,2,3) # 傳入3個參數 取3個中較小者1>>> min('1234') # 傳入1個可迭代對象，取其最小元素值'1'>>> min(-1,-2) # 數值默認去數值較小者-2>>> min(-1,-2,key = abs)  # 傳入了求絕對值函數，則參數都會進行求絕對值后再取較小者-1
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

pow：返回兩個數值的冪運算值或其與指定整數的模值

pow(x,y) 等價于 x**y
pow(x,y,z) 等價于 x**y%z

round：對浮點數進行四舍五入求值

第一個參數是一個浮點數，第二個參數是保留的小數位數，可選，如果不寫的話默認保留到整數
round函數有個坑，比較好的解釋請參見：http://www.runoob.com/w3cnote/python-round-func-note.html

>>> round(1.1314926,1)1.1>>> round(1.1314926,5)1.13149
1
2
3
4
1
2
3
4

近似計算我們還有其他的選擇：
使用math模塊中的一些函數，比如math.ceiling（天花板除法）。
python自帶整除，python2中是/，3中是//，還有div函數。
字符串格式化可以做截斷使用，例如 “%.2f” % value（保留兩位小數并變成字符串如果還想用浮點數請披上float()的衣）。
當然，對浮點數精度要求如果很高的話，用decimal模塊。

sum：對元素類型是數值的可迭代對象中的每個元素求和

bool： 函數用于將給定參數轉換為布爾類型，如果沒有參數，返回 False

>>> bool() #未傳入參數False>>> bool(0) #數值0、空序列等值為FalseFalse>>> bool(1)True
1
2
3
4
5
6
1
2
3
4
5
6

int：函數用于將一個字符串或數字轉換為整型

默認語法：class int(x, base=10)

float：函數用于將整數和字符串轉換成浮點數。

默認語法：class float([x])

>>>float(1)1.0>>> float(112)112.0>>> float(-123.6)-123.6>>> float('123')     # 字符串123.0
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

str：函數將對象轉化為適于人閱讀的形式。

默認語法：class str(object=”)

bytearray：根據傳入的參數創(chuàng)建一個新的字節(jié)數組，這個數組里的元素是可變的，并且每個元素的值范圍: 0 <= x < 256

默認語法：class bytearray([source[, encoding[, errors]]])
如果 source 為整數，則返回一個長度為 source 的初始化數組；
如果 source 為字符串，則按照指定的 encoding 將字符串轉換為字節(jié)序列；
如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數；
如果 source 為與 buffer 接口一致的對象，則此對象也可以被用于初始化 bytearray。
如果沒有輸入任何參數，默認就是初始化數組為0個元素。

>>>bytearray()bytearray(b'')>>> bytearray([1,2,3])bytearray(b'\x01\x02\x03')>>> bytearray('runoob', 'utf-8')bytearray(b'runoob')>>> bytearray('中文','utf-8')bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

bytes：根據傳入的參數創(chuàng)建一個新的不可變字節(jié)數組

memoryview：根據傳入的參數創(chuàng)建一個新的內存查看對象

默認語法：memoryview(obj)
所謂內存查看對象，是指對支持緩沖區(qū)協(xié)議的數據進行包裝，在不需要復制對象基礎上允許Python代碼訪問。
返回元組列表

>>>v = memoryview(bytearray('abcefg', 'utf-8'))>>> print(v[1])98>>> print(v[-1])103>>> print(v[1:4])<memory at 0x10f543a08>>>> print(v[1:4].tobytes())b'bce'
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

ord：返回Unicode字符對應的整數

ord() 函數是 chr() 函數（對于8位的ASCII字符串）或 unichr() 函數（對于Unicode對象）的配對函數，它以一個字符（長度為1的字符串）作為參數，返回對應的 ASCII 數值，或者 Unicode 數值，如果所給的 Unicode 字符超出了你的 Python 定義范圍，則會引發(fā)一個 TypeError 的異常。

chr：返回整數所對應的Unicode字符

chr() 用一個范圍在 range（256）內的（就是0～255）整數作參數，返回一個對應的字符。

>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六進制0 1 a>>> print chr(48), chr(49), chr(97)         # 十進制0 1 a
1
2
3
4
1
2
3
4

bin：將整數轉換成2進制字符串

bin() 返回一個整數 int 或者長整數 long int 的二進制表示。

oct：將整數轉化成8進制數字符串

oct() 函數將一個整數轉換成8進制字符串。

>>>oct(10)'012'>>> oct(20)'024'>>> oct(15)'017'
1
2
3
4
5
6
1
2
3
4
5
6

hex：將整數轉換成16進制字符串

hex() 函數用于將10進制整數轉換成16進制，以字符串形式表示。

tuple：根據傳入的參數創(chuàng)建一個新的元組

默認語法：tuple( seq )，seq – 要轉換為元組的序列

>>>tuple([1,2,3,4])(1, 2, 3, 4)>>> tuple({1:2,3:4})    #針對字典 會返回字典的key組成的tuple (1, 3)>>> tuple((1,2,3,4))    #元組會返回元組自身 (1, 2, 3, 4)
1
2
3
4
5
6
1
2
3
4
5
6

list：根據傳入的參數創(chuàng)建一個新的列表

dict：根據傳入的參數創(chuàng)建一個新的字典

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

>>>dict()                        # 創(chuàng)建空字典{}>>> 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
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

set：根據傳入的參數創(chuàng)建一個新的集合

set() 函數創(chuàng)建一個無序不重復元素集，可進行關系測試，刪除重復數據，還可以計算交集、差集、并集等。

frozenset：根據傳入的參數創(chuàng)建一個新的不可變集合

class frozenset([iterable])
frozenset() 返回一個凍結的集合，凍結后集合不能再添加或刪除任何元素。

>>> a = frozenset(range(10))>>> afrozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})>>> b = frozenset('runoob') >>> bfrozenset(['b', 'r', 'u', 'o', 'n'])   # 創(chuàng)建不可變集合
1
2
3
4
5
6
1
2
3
4
5
6

enumerate：根據可迭代對象創(chuàng)建枚舉對象

enumerate() 函數用于將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在 for 循環(huán)當中。
enumerate(sequence, [start=0])

range：根據傳入的參數創(chuàng)建一個新的range對象

range(start, stop[, step])
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)
range() 函數可創(chuàng)建一個整數列表，一般用在 for 循環(huán)中。

>>>range(10)        # 從 0 開始到 10[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> range(1, 11)     # 從 1 開始到 11[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> range(0, 30, 5)  # 步長為 5[0, 5, 10, 15, 20, 25]>>> range(0, 10, 3)  # 步長為 3[0, 3, 6, 9]>>> range(0, -10, -1) # 負數[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]>>> range(0)[]>>> range(1, 0)[]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

iter：根據傳入的參數創(chuàng)建一個新的可迭代對象

iter(object[, sentinel])
object – 支持迭代的集合對象。
sentinel – 如果傳遞了第二個參數，則參數 object 必須是一個可調用的對象（如，函數），此時，iter 創(chuàng)建了一個迭代器對象，每次調用這個迭代器對象的next()方法時，都會調用 object。
iter() 函數用來生成迭代器。

slice：根據傳入的參數創(chuàng)建一個新的切片對象

class slice(stop)
class slice(start, stop[, step])
start – 起始位置
stop – 結束位置
step – 間距
slice() 函數實現(xiàn)切片對象，主要用在切片操作函數里的參數傳遞。

>>>myslice = slice(5)    # 設置截取5個元素的切片>>> mysliceslice(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]
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

super：根據傳入的參數創(chuàng)建一個新的子類和父類關系的代理對象

super() 函數是用于調用父類(超類)的一個方法。
super 是用來解決多重繼承問題的，直接用類名調用父類方法在使用單繼承的時候沒問題，但是如果使用多繼承，會涉及到查找順序（MRO）、重復調用（鉆石繼承）等種種問題。
MRO 就是類的方法解析順序表, 其實也就是繼承父類方法時的順序表。
super(type[, object-or-type])
type – 類。
object-or-type – 類，一般是 self
Python3.x 和 Python2.x 的一個區(qū)別是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx

filter：使用指定方法過濾可迭代對象的元素

filter()接收一個函數和一個序列。和map()不同的是，filter()把傳入的函數依次作用于每個元素，然后根據返回值是True還是False決定保留還是丟棄該元素

>>> a = list(range(1,10)) #定義序列>>> a[1, 2, 3, 4, 5, 6, 7, 8, 9]>>> def if_odd(x): #定義奇數判斷函數    return x%2==1>>> list(filter(if_odd,a)) #篩選序列中的奇數[1, 3, 5, 7, 9]
1
2
3
4
5
6
7
1
2
3
4
5
6
7

map：使用指定方法去作用傳入的每個可迭代對象的元素，生成新的可迭代對象

map()函數接收兩個參數，一個是函數，一個是Iterable，map將傳入的函數依次作用到序列的每個元素，并把結果作為新的Iterator返回

reduce：對參數序列中元素進行累積，生成新的可迭代對象

reduce(function, iterable[, initializer])
function – 函數，有兩個參數
iterable – 可迭代對象
initializer – 可選，初始參數
reduce把一個函數作用在一個序列[x1, x2, x3, …]上，這個函數必須接收兩個參數，reduce把結果繼續(xù)和序列的下一個元素做計算

>>>def add(x, y) :            # 兩數相加...     return x + y... >>> reduce(add, [1,2,3,4,5])   # 計算列表和：1+2+3+4+515>>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函數15
1
2
3
4
5
6
7
1
2
3
4
5
6
7

next：返回可迭代對象中的下一個元素值

next(iterator[, default])
iterator – 可迭代對象
default – 可選，用于設置在沒有下一個元素時返回該默認值，如果不設置，又沒有下一個元素則會觸發(fā) StopIteration 異常

reversed：反轉序列生成新的可迭代對象

>>> a = reversed(range(10)) # 傳入range對象>>> a # 類型變成迭代器<range_iterator object at 0x035634E8>>>> list(a)[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
1
2
3
4
5
1
2
3
4
5

sorted：對可迭代對象進行排序，返回一個新的列表

sorted(iterable[, cmp[, key[, reverse]]])
iterable – 可迭代對象。
cmp – 比較的函數，這個具有兩個參數，參數的值都是從可迭代對象中取出，此函數必須遵守的規(guī)則為，大于則返回1，小于則返回-1，等于則返回0。
key – 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自于可迭代對象中，指定可迭代對象中的一個元素來進行排序。
reverse – 排序規(guī)則，reverse = True 降序 ， reverse = False 升序（默認）。
sorted() 函數對所有可迭代的對象進行排序操作。
sort 與 sorted 區(qū)別：
sort 是應用在 list 上的方法，sorted 可以對所有可迭代的對象進行排序操作。
list 的 sort 方法返回的是對已經存在的列表進行操作，而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操作。

zip：聚合傳入的每個迭代器中相同位置的元素，返回一個新的元組類型迭代器

zip() 函數用于將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表。
如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓為列表。

>>>a = [1,2,3]>>> b = [4,5,6]>>> c = [4,5,6,7,8]>>> zipped = zip(a,b)     # 打包為元組的列表[(1, 4), (2, 5), (3, 6)]>>> zip(a,c)              # 元素個數與最短的列表一致[(1, 4), (2, 5), (3, 6)]>>> zip(*zipped)          # 與 zip 相反，*zipped 可理解為解壓，返回二維矩陣式[(1, 2, 3), (4, 5, 6)]
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

all：all(iterable)

函數用于判斷給定的可迭代參數 iterable 中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。
元素除了是 0、空、FALSE 外都算 TRUE。
注意：空元組、空列表返回值為True，這里要特別注意。

any：any(iterable)

any() 函數用于判斷給定的可迭代參數 iterable 是否全部為 False，則返回 False，如果有一個為 True，則返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。

def any(iterable):    for element in iterable:        if element:            return True    return False
1
2
3
4
5
1
2
3
4
5

id：返回對象的唯一標識符

id() 函數用于獲取對象的內存地址。

hash：獲取對象的哈希值

>>>hash('test')            # 字符串2314058222102390712>>> hash(1)                 # 數字1>>> hash(str([1,2,3]))      # 集合1335416675971793195>>> hash(str(sorted({'1':1}))) # 字典7666464346782421378
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

type：返回對象的類型，或者根據傳入的參數創(chuàng)建一個新的類型

class type(name, bases, dict)
name – 類的名稱。
bases – 基類的元組。
dict – 字典，類內定義的命名空間變量。
type() 函數如果你只有第一個參數則返回對象的類型，三個參數返回新的類型對象。
isinstance() 與 type() 區(qū)別：
type() 不會認為子類是一種父類類型，不考慮繼承關系。
isinstance() 會認為子類是一種父類類型，考慮繼承關系。
如果要判斷兩個類型是否相同推薦使用 isinstance()。
一個參數返回對象類型, 三個參數，返回新的類型對象。

len：返回對象的長度

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

>>>str = 'runoob'>>> len(str)             # 字符串長度6>>> l = [1,2,3,4,5]>>> len(l)               # 列表元素個數5
1
2
3
4
5
6
1
2
3
4
5
6

vars：返回當前作用域內的局部變量和其值組成的字典，或者返回對象的屬性列表

vars() 函數返回對象object的屬性和屬性值的字典對象。
返回對象object的屬性和屬性值的字典對象，如果沒有參數，就打印當前調用位置的屬性和屬性值 類似 locals()。

isinstance：判斷對象是否是類或者類型元組中任意類元素的實例

isinstance(object, classinfo)
object – 實例對象。
classinfo – 可以是直接或間接類名、基本類型或者由它們組成的元組。
isinstance() 函數來判斷一個對象是否是一個已知的類型，類似 type()。
isinstance() 與 type() 區(qū)別：
type() 不會認為子類是一種父類類型，不考慮繼承關系。
isinstance() 會認為子類是一種父類類型，考慮繼承關系。
如果要判斷兩個類型是否相同推薦使用 isinstance()。
如果對象的類型與參數二的類型（classinfo）相同則返回 True，否則返回 False。

>>>a = 2>>> isinstance (a,int)True>>> isinstance (a,str)False>>> isinstance (a,(str,int,list))    # 是元組中的一個返回 TrueTrue
1
2
3
4
5
6
7
1
2
3
4
5
6
7

issubclass：判斷類是否是另外一個類或者類型元組中任意類元素的子類

issubclass(class, classinfo)
class – 類。
classinfo – 類。
issubclass() 方法用于判斷參數 class 是否是類型參數 classinfo 的子類。如果 class 是 classinfo 的子類返回 True，否則返回 False。

hasattr：檢查對象是否含有屬性

hasattr(object, name)
object – 對象。
name – 字符串，屬性名。
hasattr() 函數用于判斷對象是否包含對應的屬性。

>>> class Student:    def __init__(self,name):        self.name = name        >>> s = Student('Aim')>>> hasattr(s,'name') #a含有name屬性True>>> hasattr(s,'age') #a不含有age屬性False
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

getattr：獲取對象的屬性值

getattr(object, name[, default])
object – 對象。
name – 字符串，對象屬性。
default – 默認返回值，如果不提供該參數，在沒有對應屬性時，將觸發(fā) AttributeError。
getattr() 函數用于返回一個對象屬性值。

setattr：設置對象的屬性值

setattr(object, name, value)
object – 對象。
name – 字符串，對象屬性。
value – 屬性值。
setattr 函數對應函數 getatt()，用于設置屬性值，該屬性必須存在。

>>> class Student:    def __init__(self,name):        self.name = name        >>> a = Student('Kim')>>> a.name'Kim'>>> setattr(a,'name','Bob')>>> a.name'Bob'
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

delattr：刪除對象的屬性

delattr(object, name)
object – 對象。
name – 必須是對象的屬性。
delattr(x, ‘foobar’) 相等于 del x.foobar。

callable：檢測對象是否可被調用

callable(object)
callable() 函數用于檢查一個對象是否是可調用的。如果返回True，object仍然可能調用失敗；但如果返回False，調用對象ojbect絕對不會成功。
對于函數, 方法, lambda 函式類, 以及實現(xiàn)了 call 方法的類實例, 它都返回 True。

>>> class B: #定義類B    def __call__(self):        print('instances are callable now.')        >>> callable(B) #類B是可調用對象True>>> b = B() #調用類B>>> callable(b) #實例b是可調用對象True>>> b() #調用實例b成功instances are callable now.
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

globals：返回當前作用域內的全局變量和其值組成的字典

globals() 函數會以字典類型返回當前位置的全部全局變量。

locals：返回當前作用域內的局部變量和其值組成的字典

locals() 函數會以字典類型返回當前位置的全部局部變量。
對于函數, 方法, lambda 函式, 類, 以及實現(xiàn)了 call 方法的類實例, 它都返回 True。

>>> def f():    print('before define a ')    print(locals()) #作用域內無變量    a = 1    print('after define a')    print(locals()) #作用域內有一個a變量，值為1   >>> f<function f at 0x03D40588>>>> f()before define a {} after define a{'a': 1}
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13

print：向標準輸出對象打印輸出

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)
objects – 復數，表示可以一次輸出多個對象。輸出多個對象時，需要用 , 分隔。
sep – 用來間隔多個對象，默認值是一個空格。
end – 用來設定以什么結尾。默認值是換行符 \n，我們可以換成其他字符串。
file – 要寫入的文件對象。
print() 方法用于打印輸出，最常見的一個函數。
print 在 Python3.x 是一個函數，但在 Python2.x 版本不是一個函數，只是一個關鍵字。

input：讀取用戶輸入值

Python3.x 中 input() 函數接受一個標準輸入數據，返回為 string 類型。
Python2.x 中 input() 相等于 eval(raw_input(prompt)) ，用來獲取控制臺的輸入。
raw_input() 將所有輸入作為字符串看待，返回字符串類型。而 input() 在對待純數字輸入時具有自己的特性，它返回所輸入的數字的類型（ int, float ）
注意：input() 和 raw_input() 這兩個函數均能接收 字符串 ，但 raw_input() 直接讀取控制臺的輸入（任何類型的輸入它都可以接收）。而對于 input() ，它希望能夠讀取一個合法的 python 表達式，即你輸入字符串的時候必須使用引號將它括起來，否則它會引發(fā)一個 SyntaxError 。
除非對 input() 有特別需要，否則一般情況下我們都是推薦使用 raw_input() 來與用戶交互。
注意：python3 里 input() 默認接收到的是 str 類型。

>>>a = input('input:')input:123                  # 輸入整數>>> type(a)<type 'int'>               # 整型>>> a = input('input:')    input:'runoob'           # 正確，字符串表達式>>> type(a)<type 'str'>             # 字符串>>> a = input('input:')input:runoob               # 報錯，不是表達式Traceback (most recent call last):  File '<stdin>', line 1, in <module>  File '<string>', line 1, in <module>NameError: name 'runoob' is not defined<type 'str'>>>>a = raw_input('input:')input:123>>> type(a)<type 'str'>              # 字符串>>> a = raw_input('input:')input:runoob>>> type(a)<type 'str'>              # 字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

eval：執(zhí)行動態(tài)表達式求值

eval(expression[, globals[, locals]])
expression – 表達式。
globals – 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象。
locals – 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。
eval() 函數用來執(zhí)行一個字符串表達式，并返回表達式的值。

compile：將字符串編譯為代碼或者AST對象，使之能夠通過exec語句來執(zhí)行或者eval進行求值

compile() 函數將一個字符串編譯為字節(jié)代碼。
compile(source, filename, mode[, flags[, dont_inherit]])
source – 字符串或者AST（Abstract Syntax Trees）對象。。
filename – 代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值。
mode – 指定編譯代碼的種類?？梢灾付?exec, eval, single。
flags – 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。。
flags和dont_inherit是用來控制編譯源碼時的標志

>>>str = 'for i in range(0,10): print(i)' >>> c = compile(str,'','exec')   # 編譯為字節(jié)代碼對象 >>> c<code object <module> at 0x10141e0b0, file '', line 1>>>> exec(c)0123456789>>> str = '3 * 4 + 5'>>> a = compile(str,'','eval')>>> eval(a)17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

exec：執(zhí)行動態(tài)語句塊

repr：返回一個對象的字符串表現(xiàn)形式(給解釋器)

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

>>>s = 'RUNOOB'>>> repr(s)''RUNOOB''>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};>>> repr(dict)'{'google': 'google.com', 'runoob': 'runoob.com'}'
1
2
3
4
5
6
1
2
3
4
5
6

property：標示屬性的裝飾器

property() 函數的作用是在新式類中返回屬性值。
class property([fget[, fset[, fdel[, doc]]]])
fget – 獲取屬性值的函數
fset – 設置屬性值的函數
fdel – 刪除屬性值函數
doc – 屬性描述信息

classmethod：標示方法為類方法的裝飾器

classmethod 修飾符對應的函數不需要實例化，不需要 self 參數，但第一個參數需要是表示自身類的 cls 參數，可以來調用類的屬性，類的方法，實例化對象等。

>>> class C:    @classmethod    def f(cls,arg1):        print(cls)        print(arg1)>>> C.f('類對象調用類方法')<class '__main__.C'>類對象調用類方法>>> c = C()>>> c.f('類實例對象調用類方法')<class '__main__.C'>類實例對象調用類方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

staticmethod：標示方法為靜態(tài)方法的裝飾器

返回函數的靜態(tài)方法。

好了，寫了三天了，內置函數就先寫這么多，以上三個函數，需要在面向對象的詳細理解并說明。
以下就說一下內置全局變量

vars()查看內置全局變量

以字典方式返回內置全局變量

print(vars())#輸出# {'__builtins__': <module 'builtins' (built-in)>, '__spec__': None, '__package__': None, '__doc__': None, '__name__': '__main__', '__cached__': None, '__file__': 'H:/py/index.py', '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000000AC32C66A58>}
1
2
3
1
2
3

_doc_ ：獲取文件的注釋

_file_ 【重點】獲取當前文件的路徑

_file_ ，一般配合os模塊的os.path.dirname()，os.path.basename() ，os.path.join() 模塊函數來使用

import osa = __file__    # __file__全局變量獲取當前文件路徑print(a) b = os.path.dirname(a) #獲取文件當前目錄：注意：os.path.dirname()疊加一次向上找一次 如下print(b) b2 = os.path.dirname(b) #獲取文件當前目錄的上級目錄，注意：os.path.dirname()疊加一次向上找一次print(b2) c = os.path.basename(a) #獲取文件名稱print(c)#輸出# H:/py/lib/ska/mk.py# H:/py/lib/ska# H:/py/lib# mk.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

_package_ ：獲取導入文件的路徑多層目錄以點分割，注意：對當前文件返回None

_cached_ ：獲取導入文件的緩存路徑

from lib.ska import mk  #導入mk模塊文件print(mk.__cached__) #__cached__ ：獲取導入文件的緩存路徑#輸出# H:\py\lib\ska\__pycache__\mk.cpython-35.pyc
1
2
3
4
1
2
3
4

_name_ 獲取導入文件的路徑加文件名稱路徑以點分割，獲取當前文件返回_main_

ok，這一節(jié)就寫到這吧，還有一些關于文件操作的函數沒寫出來，文件操作需要另寫一篇，才能加深理解，而且現(xiàn)在文件操作用的還不是很熟悉，等用熟悉了在寫吧。