1. abs():返回一個數的絕對值
2. divmod(a,b): 結合除法和取模運算，返回一個包含商和模的元祖(a//b, a%b), 在 python 2.3 版本之前不允許處理復數。

>>> divmod(7,2)
(3, 1)
>>> divmod(-7,2)
(-4, 1)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)

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

>>> a = input("Please input:")
Please input:123
>>> a
123
>>> type(a)
<type ‘int‘>
>>> a = input("Please input:")
Please input:"Tom"
>>> a
‘Tom‘
>>> type(a)
<type ‘str‘>
>>> a = input("Please input:")
Please input:Tom
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name ‘Tom‘ is not defined
>>> a = input("Please input:")
Please input:1+2
>>> a
3
 

input()在Python3.x中

helloworld@LG-virtual-machine:~/code$ python3.5
Python 3.5.2 (default, Nov 23 2017, 16:37:01) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> a = input("Please input:")
Please input:123
>>> type(a)
<class ‘str‘>
>>> a
‘123‘

>>> a = input("Please input:")
Please input:Tom
>>> a
‘Tom‘
>>> type(a)
<class ‘str‘>

>>> a = input("Please input:")
Please input:"Tom"
>>> type(a)
<class ‘str‘>
>>> a
‘"Tom"‘
 

raw_input()在Python3.x中未定義

>>> a = raw_input("input:")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name ‘raw_input‘ is not defined

raw_input()在Python2.x中將所有的輸入當作字符串：

helloworld@LG-virtual-machine:~/code$ python
Python 2.7.12 (default, Dec  4 2017, 14:50:18) 
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = raw_input("input:")
input:123
>>> a
‘123‘
>>> a = raw_input("input:")
input:‘Tom‘
>>> a
"‘Tom‘"

>>> a = raw_input("input:")
input:Tom
>>> a
‘Tom‘

>>> a = raw_input("input:")
input:1+2
>>> a
‘1+2‘

1. staticmethod返回函數的靜態方法

# -*- coding: UTF-8 -*-                                                         
class C(object):
   @staticmethod
   def f():
       print "Hello World"

C.f() #靜態方法無需實例化

cobj = C() #也可以實例化再調用
cobj.f()

1. all(iterable)：iterable為列表或者元祖，用於判斷給定的可叠代參數中所有的參數是否都為True，如果是則返回Ture,否則返回False;等價於以下函數：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True  

• 註意：如果iterable得所有元素不為0，"", False或者iterable為空，all(iterable)返回True，否則返回False; 空元組或者空列表返回值為True

print all([])
print all(())
print all((1,2,3,0))
print all((‘1‘,‘2‘,‘‘,‘4‘))
print all((1,2,3,4)) 

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
True
True
False
False
True

1. enumerate(): 用於將一個可遍歷的數據對象（如列表，元祖，字符串）組合成一個索引序列，同時列出數據和數據下標，一般用在for循環中

   enumerate(seq [, start=0)):
   seq: 一個序列，叠代器或其他支持叠代對象
   start: 下標起始位置

>>> seasons = [‘Spring‘, ‘Summer‘, ‘Fail‘, ‘Winter‘]
>>> seasons
[‘Spring‘, ‘Summer‘, ‘Fail‘, ‘Winter‘]
>>> enumerate(seasons)
<enumerate object at 0x7f5b24858870>
>>> list(enumerate(seasons))
[(0, ‘Spring‘), (1, ‘Summer‘), (2, ‘Fail‘), (3, ‘Winter‘)]
>>> list(enumerate(seasons,start = 1))
[(1, ‘Spring‘), (2, ‘Summer‘), (3, ‘Fail‘), (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

使用enumerate的for循環

>>> for i, element in enumerate(seq):
...     print i,element
... 
0 one
1 two
2 three

1. int()函數：用於將一個字符串或數字轉換為整型

   int (x, base = 10)
   x: 字符串或者數字
   base: 進制數，默認十進制

>>> int() #不傳入參數時，得到結果0
0
>>> int(3) #可以傳入數字
3
>>> int(‘3‘) #也可以傳入字符串
3
>>> int(‘12‘,16)  #如果是要帶 base 的話，12要以字符串形式進行輸入，12為16進制數
18
>>> int(‘0xa‘,16)
10
>>> int(‘10‘,8)
8

1. ord()函數，以一個字符（長度為1的字符串）作為參數，返回對應的ASCII數值，或者 Unicode 數值，如果所給的 Unicode 字符超出了你的 Python 定義範圍，則會引發一個 TypeError 的異常。

>>> ord(‘a‘)
97
>>> ord(‘b‘)
98

1. str():返回一個對象的string格式

>>> str(123)
‘123‘
>>> dict = {‘a‘:123,45:‘abc‘}
>>> str(dict)
"{‘a‘: 123, 45: ‘abc‘}"
>>> dict
{‘a‘: 123, 45: ‘abc‘}

1. any():any() 函數用於判斷給定的可叠代參數 iterable 是否全部為 False，則返回 False，如果有一個為 True，則返回 True；元素除了0，空，False外都算True，等價於以下函數：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False   

測試：

print any(())
print any([])
print any([‘a‘,‘‘])
print any([False])
print any((0,))

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
False
False
True
False
False

1. eval()用來執行一個字符串表達式，並返回表達式的值

   eval(expression[, globals[, locals]])
   expression -- 表達式。
   globals -- 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象。
   locals -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。

>>> x = 7
>>> eval(‘3*x‘)
21
>>> eval(‘x*x‘)
49
>>> eval(‘(1+2j)*x‘)
(7+14j)

1. isinstance()判斷一個對象是否屬於一個已知的類型，與type()的區別在於：

   type()認為子類不屬於父類類型，不考慮繼承關系
   isinstance()認為子類是一種父類類型，考慮繼承關系
   如果要判斷兩個類型是否相同推薦使用isinstance

   • isinstance(object, classinfo)
     object: 實例對象
     classinfo: 可以直接或間接類名、基本類型或者由他們組成的元祖：

>>> a = 2
>>> isinstance(a,int)
True
>>> isinstance(a,str)
False
>>> isinstance(a,(str, int, list))
True

type()與isinstance()區別

# -*- coding: UTF-8 -*-                                                         
class father(object):
    pass
class son(father):
    pass
if __name__==‘__main__‘:
    print type(son())==father
    print isinstance(son(),father)
    print type(son())
    print type(son)

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
False
True
<class ‘__main__.son‘>
<type ‘type‘>

• type()主要用來獲取未知變量的類型
• isinstance()主要用於判斷A類是否屬於B類

1. pow(x, y[, z])與math.pow(): 計算 x 的 y 次方,分別相當於x ** y % z、x**y

• 通過內置的方法直接調用，內置方法會把參數作為整型，如果有 z，再對z取模
• 而 math 模塊則會把參數轉換為 float

>>> import math
>>> math.pow(2,1,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pow expected 2 arguments, got 3
>>> math.pow(2,1)
2.0
>>> pow(2,1)
2
>>> pow(2,1,2)
0

1. sum()函數：求序列的和

   sum(iterable[, start])
   iterable: 可叠代對象，如：列表，元祖，集合
   start: 在前面序列和的基礎上再加上 start, 如果沒有這個值，則默認為0

>>> sum((1,2,3))
6
>>> sum([1,2,3])
6
>>> sum([1,2,3],4)
10

1. basestring()是str和unicode的父類，也是抽象類，因此不能被調用和實例化，但是可以用來判斷一個對象是否是str或者unicode的實例

• isinstance(obj, basestring) 等價於 isinstance(obj, (str, unicode))。

>>> isinstance(‘Hello world‘,basestring)
True
>>> isinstance(‘Hello world‘,str)
True

1. execfile()：用來執行一個文件

   execfile(filename[, globals[, locals]])
   filename -- 文件名。
   globals -- 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象。
   locals -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。
   返回值：返回表達式的執行結果

>>> execfile(‘test.py‘)
False
True
<class ‘__main__.son‘>
<type ‘type‘>

• Python 3 中刪去了execfile()，代替如下：

with open(‘test.py‘,‘r‘) as f: 
    exec(f.read())

1. issubclass()函數：用於判斷參數 class 是否是類型參數 classinfo 的子類。

   issubclass(class, classinfo)

# -*- coding: UTF-8 -*-                                                         
class father(object):
    pass
class son(father):
    pass

print(issubclass(son,father))

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
True

1. print: print 在 Python3.x 是一個函數，但在 Python2.x 版本不是一個函數，只是一個關鍵字。
   print(*object, sep=‘ ‘, end=‘\n‘, file=sys.stdout)

   *object-----表示一次性可以接收多個對象，輸出多個對象時，需要用,隔開
   sep-----用來間隔多個對象，默認是一個空格
   end-----用來設定以什麽結尾，默認是一個換行符\n,可以更改換成其它字符
   file-----要寫入的文字對象

python 3下的測試

>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>> print("aaa","bbb",sep=‘---‘) #設置間隔符
aaa---bbb

1. super()函數：用於調用父類的方法，super 是用來解決多重繼承問題的，直接用類名調用父類方法在使用單繼承的時候沒問題，但是如果使用多繼承，會涉及到查找順序（MRO）、重復調用（鉆石繼承）等種種問題。MRO 就是類的方法解析順序表, 其實也就是繼承父類方法時的順序表

• Python3.x 和 Python2.x 的一個區別是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :

# -*- coding: UTF-8 -*-                                                         
class FooParent(object):
    def __init__(self):
        self.parent=‘I\‘m the parent‘
        print(‘Parent‘)
    def bar(self,message):
        print("%s from parent"%message)

class FooChild(FooParent):
    def __init__(self):
        super(FooChild,self).__init__()
        print(‘Child‘)

    def bar(self,message):
        super(FooChild,self).bar(message)
        print (‘Child bar function‘)
        print(self.parent)

if __name__==‘__main__‘:
    fooChild = FooChild()
    fooChild.bar(‘Hello World‘)

輸出：先調用父類，再調用自己的子類

helloworld@LG-virtual-machine:~/code$ python test.py 
Parent
Child
Hello World from parent
Child bar function
I‘m the parent

• __init__方法的第一參數永遠是self，表示創建的類實例本身，因此，在__init__方法內部，就可以把各種屬性綁定到self，因為self就指向創建的實例本身。（2）有了__init__方法，在創建實例的時候，就不能傳入空的參數了，必須傳入與__init__方法匹配的參數，但self不需要傳，Python解釋器會自己把實例變量傳進去

• 如果要讓內部屬性不被外部訪問，可以把屬性的名稱前加上兩個下劃線，在Python中，實例的變量名如果以__開頭，就變成了一個私有變量（private），只有內部可以訪問，外部不能訪問

• 在Python中，變量名類似__xxx__的，也就是以雙下劃線開頭，並且以雙下劃線結尾的，是特殊變量，特殊變量是可以直接訪問的，不是private變量，所以，不能用__name__、__score__這樣的變量名。

• 參考：self的用法詳解

1. bin()函數：返回一個整數 int 或一個長整型 long int的二進制表示

>>> bin(10)
‘0b1010‘
>>> bin(8)
‘0b1000‘

1. file()用於創建一個對象，與open()類似

   file(name[, mode[, buffering]])
   name-----文件
   mode-----打開模式
   buffering-----0表示不緩沖，如果為1則表示進行緩沖，大於1為緩沖大小

>>> f = file(‘b.txt‘,‘r+‘)
>>> f.read()
‘Hello world!!!‘

1. iter()用來生成一個叠代器

   iter(object[, sentinel])
   object-----支持叠代的集合對象
   sentinel-----如果傳遞了第二個參數，則參數 object 必須是一個可調用的對象（如，函數），此時，iter 創建了一個叠代器對象，每次調用這個叠代器對象的__next__()方法時，都會調用 object

>>> lst = [1,2,3]
>>> for x in iter(lst):
...     print x
... 
1
2
3

1. tuple()將列表轉換為元祖

>>> tuple([1,2,3,4])
(1, 2, 3, 4)
>>> tuple({1:2,3:4,‘xsd‘:7}) #針對字典，會返回字典的 key 組成的 tuple
(1, 3, ‘xsd‘)
>>> tuple((1,2,3,4)) #元祖則會返回元祖本身
(1, 2, 3, 4)

1. bool()用於將給定參數轉換為bool類型，如果沒有參數，則 返回False

>>> bool(0)
False
>>> bool(1)
True
>>> bool(19)
True
>>> bool(-1)
True
>>> issubclass(bool,int)
True
>>> isinstance(False,bool)
True

1. filter()函數用於過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表

   filter(function, iterable)
   該函數接收兩個參數，第一個為函數，第二個為序列；序列的每個元素分別作為函數的參數進行判斷，然後返回 True 或者 False ，最後將返回 True的元素放在新列表中

Python 2 實例1. 濾出列表中所有的奇數

# -*- coding: UTF-8 -*-                                                         
def is_odd(n):
    return n%2==1

list = [1,2,3,4,5,6]
newlist = filter(is_odd, list)
print newlist

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
[1, 3, 5]

Python 2 實例2. 濾出1-100中平方根是整數的數

# -*- coding: UTF-8 -*-
import math
def is_sqrt(x):
    return math.sqrt(x)%1==0
newlist = filter(is_sqrt, range(1,101))

print newlist 

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Python 2.x中filter()返回的是過濾後的列表，而Python3返回的是一個filter類

Python 3 運行輸出：

helloworld@LG-virtual-machine:~/code$ python3.5 test.py 
<filter object at 0x7f1cbecf3b00>
[0, 2, 4, 6, 8]

Python 2.5 運行輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
[0, 2, 4, 6, 8]
[0, 2, 4, 6, 8]

1. len()返回對象（元祖，列表，字符、字典等）的長度或者項目個數

>>> str = "Hello World"
>>> len(str)
11
>>> list = [1,2,3,4]
>>> len(list)
4
>>> tuple = (1,2,3,4)
>>> len(tuple)
4
>>> dict = {1:2,3:4}
>>> len(dict)
2

1. range(start, stop[, step])：創建一個整數列表，一般用在 for 循環中

   start: 計數從start開始，默認值為0，因此，range(5)等價於range(0,5)
   stop: 計數到stop結束，但不包括stop
   step: 步長，默認值為1，因此，range(3,2,1)等價於range(3,2)

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0,10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1,10,2)
[1, 3, 5, 7, 9]
>>> range(0)
[]
>>> range(10,1)
[]
>>> range(0,-10,-1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

1. callable():檢查一個函數是否是可調用的
   函數, 方法, lambda 函式, 類, 以及實現了 call 方法的類實例, 它都返回 True。
2. format()格式化函數
   通過{}和:來代替以前的%
   實例1.

>>> "{} {}".format("Hello","World")
‘Hello World‘
>>> "{0} {1}".format("Hello","World")
‘Hello World‘
>>> "{1} {0} {1}".format("Hello","World")
‘World Hello World‘

實例2.也可以設置參數：

>>> print ("Name:{name} Age:{age}".format(name="Tom",age=6))
Name:Tom Age:6

>>> info = {"name":"Jack","age":12} #通過設置元祖 但是要加雙星號
>>> print ("Name:{name} Age:{age}".format(**info)) 
Name:Jack Age:12

>>> list = ["Rose",20] #對於列表，要加 0
>>> print ("Name:{0[0]} Age:{0[1]}".format(list)) # 0 是必須的，代表括號中的列表名
Name:Rose Age:20

>>> print ("Name:{[0]} Age:{[1]}".format(list)) # 不帶 0 就會出錯
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range

實例3. 也可傳入對象

# -*- coding: UTF-8 -*-
class AssignValue(object):
    def __init__(self,value):
        self.value = value

my_value = AssignValue(7)
 
print ("value is :{0.value}".format(my_value))   #這裏的 0 則是可選的
print ("value is :{.value}".format(my_value))      # 這裏的 0 則是可選的，但是點 . 要留著

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
value is :7
value is :7

• 數字格式化

  ^ > < 　分別代表居中對齊，右對齊，左對齊，後面跟 寬度
  :　後面帶填充的字符，只能是一個字符，不指定則默認用空格填充
  + 　表示在正數面前顯示 +，在負數面前顯示 -，` `(空格)在正數面前加空格
  b, d, o, x 分別表示二進制， 十進制，八進制，十六進制

• 使用大括號{}來轉義大括號{}

>>> print("{}對應的位置是{{0}}".format("Hello"))
Hello對應的位置是{0}

>>> print("{0}對應的位置是{1}{{0}}".format("Hello","World"))
Hello對應的位置是World{0}

1. locals()以字典類型返回當前位置的全部局部變量

# -*- coding: UTF-8 -*-
def f(x):
    z = 1
    print(locals())

f(6)     

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
{‘x‘: 6, ‘z‘: 1}

1. reduce(function, iterable[, initializer])

   function----- 函數，有2個參數
   iterable-----可叠代對象
   initializer-----可選，初始參數
   功能： 先用集合 iterable 中的第 1, 2 兩個元素傳入給函數 function 的兩個參數進行操作，得到的結果再與第三個數據繼續傳入給 function 的兩個參數進行操作，直到得到最後一個結果

>>> def add(x, y):
...     return x+y
... 
>>> reduce(add, [1,2,3,4])
10
>>> reduce(lambda x, y: x + y, [1,2,3,4])
10

• 在Python 3中reduce()函數已經從全局名字空間中移除，被放置在functools模塊

# -*- coding: UTF-8 -*-                                                         
from functools import reduce
def add(x, y):
    return x+y

print (reduce(add, [1,2,3,4]))

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
10

實例2. 統計某字符串的重復次數

from functools import reduce
sentences = [‘The Deep Learning textbook is a resource intended to help students 
and practitioners enter the field of machine learning in general 
and deep learning in particular. ‘] 
word_count =reduce(lambda a,x:a+x.count("learning"),sentences,0)
print(word_count)

分析：
reduce()的源碼如下：

def reduce(function, iterable, initializer = None):
    it = iter(iterable)
    if initializer is None:
        value = next(it)
    else:
        value = initializer
    for element in it:
        value = function(value,element)
    return value

上面首先value=initializer=0,然後value=function(0, element)，即lambda匿名函數中的參數a = 0, x=序列的元素，因此不能互換 a 和 x的位置，因為只有序列有count方法，而 int 沒有，互換之後就會報錯，
File "test.py", line 16, in <lambda> word_count = reduce_1(lambda x,a:x.count(‘learning‘)+a,sentences,0) AttributeError: ‘int‘ object has no attribute ‘count‘
輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
2

1. next()返回叠代器的下一個項目

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

# -*- coding: UTF-8 -*-
 
# 首先獲得Iterator對象:
it = iter([1, 2, 3, 4, 5])
# 循環:
while True:
    try:
        # 獲得下一個值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循環
        break

輸出：

1
2
3
4
5

1. chr()用一個範圍在 range(256) 即0-255的整數（可以是十進制，也可以是十六進制,二進制等）做參數，返回一個對應的字符

>>> print chr(48), chr(49), chr(97)
0 1 a
>>> print chr(0x30),chr(0x31),chr(0x61)
0 1 a

1. frozenset()返回一個凍結的集合，凍結後集合不能再添加或刪除任何元素

   frozenset([iterable])
   iterable-------可叠代的對象，比如列表，字典，元祖等
   返回新的 frozenset 對象，如果不提供任何參數，默認生成空集合。

>>> a = frozenset(range(10))
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset("Hello World")
>>> b
frozenset([‘ ‘, ‘e‘, ‘d‘, ‘H‘, ‘l‘, ‘o‘, ‘r‘, ‘W‘])
>>> b[0]=1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: ‘frozenset‘ object does not support item assignment

1. long()將數字或字符串轉換為一個長整型

   long(x, base = 10)
   x -------- 字符串或者數字，當指定進制後，x 只能是字符串
   base --------可選，進制數，默認十進制

>>> long(123)
123L

>>> long(123,base = 10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: long() can‘t convert non-string with explicit base

>>> long(‘123‘,base = 10)
123L
>>> long(‘0b100‘,base = 2)
4L
>>> long(‘0x10‘,base = 16)
16L

1. reload()用於重新載入之前載入的模塊
   reload()會重新加載已加載的模塊，但原來使用的實例還是會使用舊的模塊，而新的實例會使用新的模塊
   reload()後還是使用原來的內存地址
   reload()不支持from xxx import xxx格式的模塊進行重新加載

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

>>> print(vars())
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__package__‘: None, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None}

>>> class Name:
...     x = 1
... 
>>> print(vars(Name))
{‘x‘: 1, ‘__module__‘: ‘__main__‘, ‘__doc__‘: None}

• 對於 x = 1，這樣一個賦值語句，在執行後，名稱 x 引用到值 1，這就像字典一樣，鍵引用值，當然，變量和所對應的值是個"不可見的"字典，可以使用vars()來返回這個字典

x = 2
>>> x = 2
>>> vars()[‘x‘] #vars()相當於返回當前變量的字典，其中就存在鍵值對應的(‘x‘: 1)，因此像字典一樣可以通過鍵取值
2

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

# -*- coding: UTF-8 -*-
class A(object):
    bar = 1
    def fun1(self):
        print("fun1")
    @classmethod
    def fun2(cls):
        print ("fun2")
        print (cls.bar)
        cls().fun1()
A.fun2() #不需實例化

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
fun2
1

1. getattr()用於獲取對象的屬性值

   getattr(object, name[, default])
   object------對象
   name-----字符串，對象屬性
   default------默認返回值，如果不提供該參數，在沒有對應屬性時，將觸發AttributeError

>>> class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a,‘bar‘)
1
>>> getattr(a, ‘bar2‘)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: ‘A‘ object has no attribute ‘bar2‘
>>> getattr(a, ‘bar2‘,3)
3

1. map()根據提供的函數對指定序列映射,Python2返回列表，Python3返回叠代對象

   map(function, iterable, ...)
   function ------函數，有兩個參數
   iterable ------一個或者多個序列
   函數function 調用序列中的每一個參數，最後返回包含每個function返回值的新列表

>>> map(square, [1,2,3,4])
[1, 4, 9, 16]
>>> map(lambda x, y: x**2, [1,2,3,4])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: <lambda>() takes exactly 2 arguments (1 given)
>>> map(lambda x: x**2, [1,2,3,4])
[1, 4, 9, 16]
>>> map(lambda x, y: x*y, [1,2,3,4],[1,2,3,4])
[1, 4, 9, 16]
>>> map(lambda x, y, z: x*y*z, [1,2,3,4],[1,2,3,4],[1,2,3,4])
[1, 8, 27, 64]

• 在Python3.x 如果函數含有多個參數，但每個參數序列的元素數量不一樣，會根據最少的序列進行，Python2.X中報錯

Python 3.5.2 (default, Nov 23 2017, 16:37:01) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.

>>> x = [1,2,3]
>>> y = [1,2]
>>> z = [1,2,3,4]
>>> print(map(lambda x,y,z:x+y+z,x,y,z))
<map object at 0x7f0e926c0d68>
>>> print(list(map(lambda x,y,z:x+y+z,x,y,z)))
[3, 6]

• map完成規範名字格式

# -*- coding: UTF-8 -*-                                                         
name_list = [‘tom‘,‘tony‘,‘jack‘]

def format_name(s):
    ss = s[:1].upper() + s[1:].lower()
    return ss

print(list(map(format_name, name_list)))

輸出：

helloworld@LG-virtual-machine:~/code$ python test.py 
[‘Tom‘, ‘Tony‘, ‘Jack‘]

1. repr()將對象轉化為供解釋器讀取的形式,返回一個對象的string格式

>>> s = ‘Hello world‘
>>> str(s)
‘Hello world‘
>>> repr(s)
"‘Hello world‘"
>>> s = {‘1‘:1,‘2‘:2}
>>> str(s)
"{‘1‘: 1, ‘2‘: 2}"
>>> repr(s)
"{‘1‘: 1, ‘2‘: 2}"

1. xrange()與range()相似,不同的是range生成的是一個數組，而xrange是一個生成器

>>> xrange(8)
xrange(8)
>>> list(xrange(8))
[0, 1, 2, 3, 4, 5, 6, 7]
>>> range(8)
[0, 1, 2, 3, 4, 5, 6, 7]
>>> xrange(0,6,2)
xrange(0, 6, 2)
>>> list(xrange(0,6,2))
[0, 2, 4]

1. cmp(x, y)用與比較兩個對象。
   如果 x<y, 則返回 -1；如果 x==y, 則返回0；如果 x>y, 則返回1

>>> cmp(80,9)
1
>>> cmp(8,9)
-1
>>> cmp(‘a‘,‘b‘)
-1
>>> cmp(‘a‘,‘ac‘)
-1
>>> cmp(‘x‘,‘bcd‘)
1

• Python3.X 已經沒有cmp()函數，若需實現比較功能，需引入operator模塊

operator.lt(a, b)  # less than 
operator.le(a, b) # less equal
operator.eq(a, b)  # equal
operator.ne(a, b)  # not equal 
operator.ge(a, b)   # greater equal
operator.gt(a, b)  # greater than
operator.__lt__(a, b)
operator.__le__(a, b)
operator.__eq__(a, b)
operator.__ne__(a, b)
operator.__ge__(a, b)
operator.__gt__(a, b)

1. globals()以字典類型返回當前位置的全部全局變量

>>> a = ‘Hello‘
>>> globals()
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘a‘: ‘Hello‘, ‘__package__‘: None}
>>> locals()
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘a‘: ‘Hello‘, ‘__package__‘: None}

1. max()返回當前參數的最大值

>>> max(1,2,3,4)
4
>>> max(‘a‘,‘b‘,‘c‘)
‘c‘
>>> max((1,2,3),(4,1,2)) #一個一個元素地進行對比，從左往右
(4, 1, 2)
>>> max({1:10,2:8,3:7}) #字典則先比較鍵值，鍵值相同再比較後面的 value
3
>>> max({1:10,1:8,1:7})
1

1. reverse()用於反向列表中的元素

>>> a = [1,2,3,4]
>>> a.reverse()
>>> a
[4, 3, 2, 1]

1. zip()函數用於將可叠代的對象作為參數，將對象中對應的元素打包成一個個元祖，然後返回由這些元祖組成的列表

• 如果各個叠代器的元素個數不一樣，則返回列表長度與最短的對象相同
• 利用*操作，可以將元祖解壓為列表
• 在Python3中返回的是一個對象，需要手動list()轉換

>>> a = [1,2,3,4]
>>> b=[5,6,7]
>>> c = [7,8,9]
>>> ac = zip(a,c)
>>> ac
[(1, 7), (2, 8), (3, 9)]
>>> bc = zip(b,c)
>>> bc
[(5, 7), (6, 8), (7, 9)]

>>> bc = zip(*bc)
>>> bc
[(5, 6, 7), (7, 8, 9)]

1. compile()將一個字符串編譯為字節代碼

   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,"
>>> exec(str)
0 1 2 3 4 5 6 7 8 9
>>> c = compile(str,‘‘,‘exec‘)
>>> c
<code object <module> at 0x7f9328f04db0, file "", line 1>
>>> exec(c)
0 1 2 3 4 5 6 7 8 9

1. hasattr()判斷對象是否包含對應的屬性

   hasattr(object, name)
   object------對象
   name-----字符串，屬性名
   如果對象有該屬性則返回 True, 否則返回 False

>>> class coordinate:
...     x = 10
...     y = -5
...     z = 0
... 
>>> point1 = coordinate()
>>> hasattr(point1, ‘x‘)
True
>>> hasattr(point1, ‘y‘)
True
>>> hasattr(point1, ‘no‘)
False

1. round()返回浮點數 x 的四舍五入值

   round(x[, n])

>>> round(10.0044,3)
10.004
>>> round(10.0045,3)
10.005

1. complex(real[, imag])用於創建一個值為real + imag * j的復數或者轉化一個字符串或數為復數，如果第一個參數為字符串，則不需要指定第二個參數

>>> complex(1,2)
(1+2j)
>>> complex(1.1,2.2)
(1.1+2.2j)
>>> complex("1+2j")
(1+2j)

>>> complex("1 + 2j")  # + 兩側不能有空格
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string

>>> complex("1")
(1+0j)
>>> complex("2j")
2j

1. hash()返回對象的哈希值

• 函數可以應用於數字、字符串和對象，不能直接應用於 list、set、dictionary。

>>> hash(1)
1
>>> hash(2)
2
>>> hash(‘hello‘)
840651671246116861
>>> hash(str([1,2,3]))
1335416675971793195

>>> hash([1,2,3]) 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: ‘list‘

1. min()返回多個參數的最小值

>>> min(1,2,3)
1
>>> min(‘a‘,‘b‘)
‘a‘
>>> min({1:10,2:8,3:7})
1
>>> min({1:10,1:8,1:7})
1

1. set(iterable)創建一個無序不重復元素集

• 可進行關系測試，刪除重復數據，還可以計算交集，並集等

>>> x = set(‘hello‘)
>>> y = set(‘google‘)
>>> x,y
(set([‘h‘, ‘e‘, ‘l‘, ‘o‘]), set([‘e‘, ‘o‘, ‘g‘, ‘l‘]))
>>> x
set([‘h‘, ‘e‘, ‘l‘, ‘o‘])
>>> y
set([‘e‘, ‘o‘, ‘g‘, ‘l‘])
>>> x & y  # 交集
set([‘e‘, ‘l‘, ‘o‘])
>>> x | y   # 並集
set([‘e‘, ‘g‘, ‘h‘, ‘l‘, ‘o‘])
>>> x -y   # 差集
set([‘h‘])

1. delattr(object, name)用於刪除屬性

>>> class coordinate:
...     x = 10
...     y = -5
...     z = 0
... 
>>> point1 = coordinate()
>>> point1.x
10

>>> delattr(point1,‘x‘)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: coordinate instance has no attribute ‘x‘

>>> delattr(coordinate,‘x‘)
>>> point1.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: coordinate instance has no attribute ‘x‘

1. help()返回對象的幫助信息

>>>help(‘sys‘)             # 查看 sys 模塊的幫助
……顯示幫助信息……
 
>>>help(‘str‘)             # 查看 str 數據類型的幫助
……顯示幫助信息……
>>>a = [1,2,3]
>>>help(a)                 # 查看列表 list 幫助信息
……顯示幫助信息……
 
>>>help(a.append)          # 顯示list的append方法的幫助
……顯示幫助信息……

1. setattr()對應於函數getattr()用於設置屬性值，可以增加屬性

   setattr(object, name, value)

>>> class coordinate:
...     x = 10
...     y = -5
...     z = 0
... 
>>> point1 = coordinate()
>>> point1.x
10
>>> setattr(point1,‘x‘,20)
>>> point1.x
20

>>> point1.m
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: coordinate instance has no attribute ‘m‘
>>> setattr(coordinate,‘m‘,9) #當以類名為參數時，實例的值也會修改
>>> point1.m
9
>>> setattr(point1,‘m‘,90) #當以實例為參數時，再以類名為參數，則不會改變
>>> point1.m
90
>>> setattr(coordinate,‘m‘,9)
>>> point1.m
90

1. dict()函數用於創建一個字典

>>> dict()  #創建一個空字典
{}
>>> dict(a=‘a‘,b=‘b‘,c=3) #傳入關鍵字
{‘a‘: ‘a‘, ‘c‘: 3, ‘b‘: ‘b‘}

>>> dict(zip([‘one‘,‘two‘,‘three‘],[1,2,3])) #映射函數方式來構造字典
{‘three‘: 3, ‘one‘: 1, ‘two‘: 2}

>>> dict([(‘one‘,1),(‘two‘,2),(3,‘three‘)])  # 可叠代對象來構造字典
{‘one‘: 1, 3: ‘three‘, ‘two‘: 2}

1. slice()實現切片，

   slice(start, stop[, step])
   返回一個切片對象

>>> myslice = slice(5)
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
range(0, 10)
>>> arr[myslice]
range(0, 5)
>>> list(arr[myslice])
[0, 1, 2, 3, 4]
>>> list(arr[slice(6,10,1)])
[6, 7, 8, 9]

1. dir()函數

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

>>> dir()
[‘__builtins__‘, ‘__doc__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, 
‘__spec__‘, ‘arr‘, ‘coordinate‘, ‘myslice‘, ‘p2‘, ‘point1‘]
>>> dir([])
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘,
 ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘,
 ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, 
‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, 
‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, 
‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, 
‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, 
‘reverse‘, ‘sort‘]

1. id()獲取對象的內存地址

>>> a = ‘Hello‘
>>> id(a)
140540780793224
>>> b = ‘Hello‘
>>> id(b)
140540780793224
>>> c = a
>>> id(c)
140540780793224

• 可以看到，對於同一個字符串對象，可以有多個引用 a,b,c但是其地址都是相同的

1. oct()將一個整數轉換為 8 進制字符串

>>> oct(0b1000)
‘0o10‘
>>> oct(8)
‘0o10‘
>>> oct(0x8)
‘0o10‘
>>> oct(0x10)
‘0o20‘

1. sorted()

Python 內置函數 2018-08-02