Python-标准库

摘要：标准库一译廖雪峰内建函数内建函数内建函数内置类型真值的测试下面的值被视为假任何数值类型的零，例如，。该对象必须支持如下所述的迭代器协议。该协议的意图是一旦迭代器的方法引发，后续调用将继续这样的行为。

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非重叠出现的次数。可选参数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