摘要：標準庫一譯廖雪峰內建函數內建函數內建函數內置類型真值的測試下面的值被視為假任何數值類型的零，例如，。該對象必須支持如下所述的迭代器協議。該協議的意圖是一旦迭代器的方法引發，后續調用將繼續這樣的行為。

http://python.usyiyi.cn

https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386820066616a77f826d876b46b9ac34cb5f34374f7a000

[TOC]

The Python interpreter has a number of functions built into it that are always available.

內建函數 http://python.usyiyi.cn/trans...

下面的值被視為假：

None
False
任何數值類型的零，例如，0、 0L、0.0、 0j。
任何空的序列，例如， ""、 ()、 []。
任何空的映射，例如，{}。
用戶定義的類的實例，如果該類定義一個__nonzero__()或__len__()的方法，在該方法返回整數零或布爾值False時。[1]

and or not

|嚴格地大于| 
=|大于或等于| 
==|等于| 
!= or <>|不等于|
is|對象的ID| 
is not|不同的對象ID|
類的非同一個實例比較時通常不相等，除非該類定義__eq__()或__cmp__()方法。
一個類的實例通常不能與同一個類的其它實例或者其他類型的對象排序，除非該類定義足夠豐富的比較方法（__ge__()、__le__()、__gt__()、__lt__()）或__cmp__()方法。

有四種不同的數值類型：普通整數、長整數、浮點數和復數。此外，布爾值是普通整數的一個子類型。普通整數（或者簡稱整數）使用C中的long實現，其精度至少為32位（sys.maxint始終設置為當前平臺最大的普通整數值，最小值是-sys.maxint - 1)。長整數具有無限的精度。浮點數字通常使用C中的double實現；有關你的程序所運行的機器上的浮點數精度及其內部表示形式的信息在sys.float_info中可以獲得。復數有實部和虛部，各是一個浮點數。若要從復數z中提取這些部分，請使用z.real和z.imag。（標準庫包括額外的數值類型，fractions支持有理數，decimal支持用戶自定義精度的浮點數。）

數值通過數字字面值或內建的函數和操作的結果創建。普通的整數字面值（包括二進制、十六進制和八進制數字）產生普通整數，除非它們指定的值太大以致不能用一個普通的整數表示，在這種情況下它們產生一個長整型。帶有"L"或"l"后綴的整數字面值產生長整數（偏向使用"L"，因為1l看起來太像十一）。包含小數點或指數符號的數字字面值產生浮點數。將"j"或"J"附加到數字字面值的尾部產生實部為零的復數。復數字面值是實部和虛部的和。

Python完全支持混合的算法：當二元算術運算符的操作數是不同的數值類型時，“較窄”類型的操作數會拓寬成另外一個操作數的類型，其中整數窄于長整數窄于浮點數窄于復數。比較混合型數字之間使用相同的規則。[2]構造函數int()、long()、float()和complex()可用于產生的一種特定類型的數值。

注：

1 對于（普通或長）整數除法，結果是一個整數。結果總是向負無窮舍入：1/2是0，(-1)/2是-1，1/(-2)是-1，（-1)/(-2)是0。請注意如果任何一個操作數是長整數，結果都會是一個長整數，與值大小無關。

2 使用int()或long()函數轉換浮點數會向零截斷，類似相關的函數math.trunc()函數。使用函數math.floor()以向下取整和math.ceil()以向上取整。

3 完整的說明請參閱內置函數。

4 從2.3版開始棄用：整除運算符、取模運算符和divmod()函數不再為復數定義。相反，如果合適，可以使用abs()函數轉換為浮點數。

5 也被稱為整數除法。結果是一個整數，但其類型不一定是int型。

6 浮點數還接受可帶有可選前綴 "+"或"-"的字符串"nan"和"inf"來表示非數字（NaN)）和正/負無窮。

7 在2.6版中新增。

8 Python定義pow(0,0)和0 ** 0為1，這對于編程語言很常見。

按位運算只有對整數才有意義。負數被視為它們2的補值（這假定操作過程中有足夠多的位數而沒有發生溢出）。

二元位運算的優先級都低于數值操作，但高于比較操作；一元操作~具有和其它的一元數值操作（+和-）相同的優先級。

下表按優先級升序排列列出位運算（在同一格中的操作具有相同的優先級）：

注
負的移位數目是非法的并導致引發一個ValueError。
左移n等同于乘以pow(2, n)。如果結果超過普通整數的范圍則返回一個長整數。
右移n位等同于除以pow(2, n)。

long.bit_length()
返回以二進制表示一個整數必須的位數，不包括符號和前導零：

>>> n = -37
>>> bin(n)
"-0b100101"
>>> n.bit_length()
6

float.is_integer() : 如果浮點數實例僅有整數，則返回True，否則返回False

float.fromhex(s)

Python支持容器上迭代的概念。這種實現使用兩種截然不同的方法；它們都用于允許用戶定義的類支持迭代。下面有更多細節描述的序列始終支持迭代方法。

容器對象需要定義一種方法以支持迭代：

container.__iter__()
返回迭代器對象。該對象必須支持如下所述的迭代器協議。如果一個容器支持不同類型的迭代，可以提供額外的方法來為這些迭代類型要求特定的迭代器。（對象支持多種迭代形式的一個示例是支持廣度和深度優先遍歷的樹結構）。此方法對應于Python/C API中Python對象的類型結構的tp_iter 部分。

迭代器對象本身需要支持以下兩種方法，它們組合在一起形成迭代器協議：

iterator.__iter__()
返回迭代器對象本身。這允許容器和迭代器都可以在for和in語句中使用。此方法對應于Python/C API中Python對象的類型結構的tp_iter slot。

iterator.next()
從容器中返回下一個元素。如果沒有元素，引發StopIteration異常。此方法對應于Python/C API中Python對象的類型結構的tp_iternext slot。

Python定義了幾個迭代器對象以支持在通用和特定的序列類型、字典以及其他更多特殊形式上的迭代。相比迭代器協議的實現，具體的類型并不重要。

該協議的意圖是一旦迭代器的next()方法引發StopIteration，后續調用將繼續這樣的行為。不遵守此性質的實現被認為是有問題的。（此約束在Python 2.3中添加；在Python 2.2中，有多個迭代器違背了此規則）。

Python的生成器提供一種方便的方法來實現迭代器協議。如果容器對象的__iter__()方法實現為一個生成器，它將自動返回一個提供__iter__()和next()方法的迭代器對象（從技術上講，是生成器對象）。生成器的更多信息可以在yield表達式的文檔中找到。

其他容器請參閱內建的dict和set類，以及collections模塊。

字符串常量寫在單引號或雙引號中："xyzzy"，"frobozz"。字符串字面值的更多信息請參閱字符串字面值。Unicode字符串與字符串非常相似，但是使用特殊的語法即一個前導的字符"u"指定：u"abc"，u"def"。除了這里描述的功能之外，字符串還有特定的方法在字符串方法一節中描述。列表使用方括號構造，元素以逗號分隔：[a, b, c]。元組通過逗號操作符構造（不在方括號中）， 帶或者不帶圓括號，但是空元組必須具有圓括號，例如a, b, c或()。單個元素的元組必須含有一個尾部的逗號，例如(d,)。

字節數組對象使用內置函數bytearray()來創建。

Python語法不直接支持緩沖區對象，但可以通過調用內置函數buffer()創建。它們不支持連接或重復。

xrange類型的對象類似于緩沖區，沒有特定的語法來創建它們，而是使用xrange()函數創建它們。它們不支持切片、 連接或重復，在它們上使用in，not in、 min()或max()效率較低。

大多數的序列類型支持以下操作。in和not in操作具有與比較操作相同的優先級。+和*的操作具有與相應的數值操作相同的優先級。[3]可變序列類型還提供其他的方法。

下標按優先級升序排列序列的操作（在相同格子中的操作具有相同的優先級）。在表中，s和t是類型相同的序列；n、i和j是整數：

#!C:/Python27/python
# -*- coding: utf8 -*-
import os
import sys

# str function

str1="test_string_str"
str11="胡畔"
## 返回字符串的副本，該副本第一個字符大寫，其余字符小寫
print(str1.capitalize())
##返回長度為width的字符串，并使得自身居中。使用指定的fillchar（默認為一個空格）做填充。
str2=str1.center(10,"-")
print(str2)
##返回在[start, end]范圍內的子串sub非重疊出現的次數?？蛇x參數start和end都以切片表示法解釋。
str2=str1.count("str")
print(str2)
##使用 encoding 中注冊的編解碼器，對字符串進行解碼。
str2=str11.decode("gbk")
print(str2)
## 返回該字符串編碼后的版本
str2=str2.encode("gbk")
print(str2)
## 如果字符串以指定的suffix結尾則返回True，否則返回False
str2=str1.endswith("str")
print(str2)

## 返回在字符串中找到的子字符串sub的最低索引，使得sub包含在切片s[start:end]中
str2=str1.find("str")
print(str2)

## 執行字符串格式化操作。調用此方法的字符串可以包含文本字面值或由花括號{}分隔的替換字段
print("The sum of 1 + 2 is {0}".format(1+2))

## 類似find()，但未找到子字符串時引發ValueError
str2=str1.index("str")
print(str2)

## 如果字符串中的所有字符都是數字或者字母，并且至少有一個字符，則返回true，否則返回false。
str2=str1.isalnum()
print(str2)

## 字符串至少有一個字符并且都是字母，則返回true，否則返回false
str2=str1.isalpha()
print(str2)

## 如果在字符串中的所有字符都是數字并且至少一個字符，則返回 true。否則返回false。
str1.isdigit()

## 如果在字符串中的所有套管井的字符[4]都小寫，還有套管井的至少一個字符虛假否則返回 true。
str1.islower()

## 返回一個字符串，為iterable可迭代對象中字符串的連接。元素之間的分隔符是提供該方法的字符串。
path1="/home/ap"
file1="log.log"
print("/".join([path1,file1]))

## 返回刪除前導字符的字符串的副本。Chars參數是一個字符串，指定要移除的字符集。如果省略或沒有 chars參數默認為刪除空格
print("/home/ap/".lstrip("/"))
print("www.example.com".lstrip("cmowz."))

## 在分隔符首次出現位置拆分字符串，并返回包含分隔符之前部分、分隔符本身和分隔符之后部分的3元組
print("/home/ap/cos/log.log".partition("/"))

## 返回字符串的一個拷貝，其中所有的子串old通過new替換。如果指定了可選參數count，則只有前面的count個出現被替換。
print("str_str_123".replace("str","haha"))

##如果給出maxsplit，則至多拆分maxsplit次（因此，列表中將最多有maxsplit+1個元素）。如果沒有指定maxsplit或為-1，那么分割的數量沒有限制（進行所有可能的分割）
print("/home/ap/cos/log.log".rsplit("/",1))

多帶帶掌握

xrange類型是不可變的序列，通常用于循環。xrange類型的好處是xrange對象始終占用相同數量的內存，無論它表示的范圍的大小。但它沒有始終一致的性能優勢

集合對象是一個不同可哈希對象組成的無序集合。常見的使用包括成員測試、從序列中刪除重復項和計算數學運算（如交、并、差和對稱差）。（其它容器請參閱內建的字典、列表和元組類和collections模塊。）

類似其它容器，集合支持x in set、 len(set)以及for x in set。作為一個無序的集合，集合不記錄元素位置和插入順序。因此，集合不支持索引、 切片、 或其它類似于序列的行為。

目前有兩個內置的集合類型，set和frozenset。

文件對象使用C的stdio包實現并可以用內置的open()函數創建。文件對象也會由一些其它內置的函數和方法返回，如os.popen()和os.fdopen()以及套接字對象的makefile()方法。臨時文件可以通過tempfile模塊創建，高級的文件操作如復制、移動和刪除文件和目錄可以通過shutil模塊完成。

f=open(r"C:UserslynnDesktop123 .txt")
try:
    for line in f:
        print(line.decode("utf-8"))
finally:
    f.close()

當with代碼塊退出時，下面的代碼將自動關閉f

from __future__ import with_statement # This isn"t required in Python 2.6

with open("hello.txt") as f:
    for line in f:
        print line,

注 Python中不是所有的"類文件式"類型支持用作with語句的上下文管理器。如果你的代碼是用于處理任何類似文件的對象，你可以使用函數contextlib.closing()而不是直接使用對象。

如果每次都這么手動轉換編碼嫌麻煩（寫程序怕麻煩是好事，不怕麻煩就會寫出又長又難懂又沒法維護的代碼），Python還提供了一個codecs模塊幫我們在讀文件時自動轉換編碼，直接讀出unicode：

import codecs
with codecs.open("/Users/michael/gbk.txt", "r", "gbk") as f:
    f.read() # u"u6d4bu8bd5"

既然變量可以指向函數，函數的參數能接收變量，那么一個函數就可以接收另一個函數作為參數，這種函數就稱之為高階函數。

>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: "int" object is not callable

def add(x, y, f):
    return f(x) + f(y)

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

>>> def f(x):
...     return x * x
...
>>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce把一個函數作用在一個序列[x1, x2, x3...]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素做累積計算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     return {"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9}[s]
...
>>> reduce(fn, map(char2num, "13579"))
13579

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

def is_odd(n):
    return n % 2 == 1

filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
# 結果: [1, 5, 9, 15]

def not_empty(s):
    return s and s.strip()

filter(not_empty, ["A", "", "B", None, "C", "  "])
# 結果: ["A", "B", "C"]

sorted:Python內置的sorted()函數就可以對list進行排序,此外，sorted()函數也是一個高階函數，它還可以接收一個比較函數來實現自定義的排序。比如，如果要倒序排序，我們就可以自定義一個reversed_cmp函數：

def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0

>>> sorted([36, 5, 12, 9, 21], reversed_cmp)
[36, 21, 12, 9, 5]

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
---------------------------
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f

當我們調用lazy_sum()時，返回的并不是求和結果，而是求和函數：

注意到返回的函數在其定義內部引用了局部變量args，所以，當一個函數返回了一個函數后，其內部的局部變量還被新函數引用，所以，閉包用起來簡單，實現起來可不容易。
另一個需要注意的問題是，返回的函數并沒有立刻執行，而是直到調用了f()才執行

map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

----------------------
def f(x):
    return x * x
    

def log(func):
    @functools.wraps(func)
    def warpper(*args,**kw):
        print "call %s()" % func.__name__
        return func(*args,**kw)
    return warpper

@log
def now():
    print "2013-12-25"

now()
print(now.__name__)

functools.partial就是幫助我們創建一個偏函數的，不需要我們自己定義int2()，可以直接使用下面的代碼創建一個新的函數int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2("1000000")
64
>>> int2("1010101")
85

導入模塊時，還可以使用別名，這樣，可以在運行時根據當前環境選擇最合適的模塊。比如Python標準庫一般會提供StringIO和cStringIO兩個庫，這兩個庫的接口和功能是一樣的，但是cStringIO是C寫的，速度更快，所以，你會經常看到這樣的寫法：

try:
    import cStringIO as StringIO
except ImportError: # 導入失敗會捕獲到ImportError
    import StringIO

類似__xxx__這樣的變量是特殊變量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊變量，hello模塊定義的文檔注釋也可以用特殊變量__doc__訪問，我們自己的變量一般不要用這種變量名；

類似_xxx和__xxx這樣的函數或變量就是非公開的（private），不應該被直接引用，比如_abc，__abc等；

之所以我們說，private函數和變量“不應該”被直接引用，而不是“不能”被直接引用，是因為Python并沒有一種方法可以完全限制訪問private函數或變量，但是，從編程習慣上不應該引用private函數或變量。

def _private_1(name):
    return "Hello, %s" % name

def _private_2(name):
    return "Hi, %s" % name

def greeting(name):
    if len(name) > 3:
        return _private_1(name)
    else:
        return _private_2(name)

pip install module_name (在線安裝)

pip search module_name

Commands:
  install                     Install packages.
  download                    Download packages.
  uninstall                   Uninstall packages.
  freeze                      Output installed packages in requirements format.
  list                        List installed packages.
  show                        Show information about installed packages.
  check                       Verify installed packages have compatible dependencies.
  search                      Search PyPI for packages.
  wheel                       Build wheels from your requirements.
  hash                        Compute hashes of package archives.
  completion                  A helper command used for command completion.
  help                        Show help for commands.

General Options:
  -h, --help                  Show help.
  --isolated                  Run pip in an isolated mode, ignoring environment variables and user configuration.
  -v, --verbose               Give more output. Option is additive, and can be used up to 3 times.
  -V, --version               Show version and exit.
  -q, --quiet                 Give less output. Option is additive, and can be used up to 3 times (corresponding to WARNING, ERROR, and CRITICAL logging levels).
  --log                 Path to a verbose appending log.
  --proxy              Specify a proxy in the form [user:passwd@]proxy.server:port.
  --retries          Maximum number of retries each connection should attempt (default 5 times).
  --timeout              Set the socket timeout (default 15 seconds).
  --exists-action     Default action when a path already exists: (s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort.
  --trusted-host    Mark this host as trusted, even though it does not have valid or any HTTPS.
  --cert                Path to alternate CA bundle.
  --client-cert         Path to SSL client certificate, a single file containing the private key and the certificate in PEM format.
  --cache-dir            Store the cache data in .
  --no-cache-dir              Disable the cache.
  --disable-pip-version-check
                              Don"t periodically check PyPI to determine whether a new version of pip is available for download. Implied with --no-index.

pip download module_name (離線安裝)

https://segmentfault.com/a/11...

1.在可以聯網的開發機器上安裝好需要的包

1.下載指定的包到指定文件夾

pip install --download d:python27packages -r requirements.txt

2 安裝指定的離線包

pip install --no-index --find-index=d:python27packages -r requirements.txt

pip install --no-index --find-links=/home/ap/hupan Pillow