题目：已知二次函数y=x^2-3x+4的图像如图。将函数图像绕其顶点旋转180度后得到新的图像，求新的图像的解析式。
 

  
 
 
思路与分析：
 
1、二次函数的图像为一抛物线。区别平面直角坐标系中的不同抛物线，一是“形状”--也即是抛物线的开口方向和开口大小，二是抛物线的“位置”--也就是顶点坐标。
 
2、在二次函数y=ax^2+bx+c的系数a、b、c中，a决定图像的开口方向和开口大小，a、b、c共同决定图像顶点的坐标。
 
3、题目中两条抛物线，其开口方向不同，开口大小相同，顶点坐标相同，我们可利用这些关系解答本题
 
解：设函数y=x^2-3x+4的顶点坐标为(a，b)，则
 

  
  
(* 直接代入二次函数顶点坐标公式计算即可)
 
 
∵ 待求的函数，图像与原函数图像顶点相同
 
∴ 待求的函数可以写作：
 

  
  
两个函数图像的顶点相同
 
 
又∵ 待求的函数，图像与原函数图像开口大小相同，开口方向相反
 
∴ k=-1
 
即待求的函数为：
 

  
  
两个函数图像的开口方向相反，开口大小相同
 
 
或写作：
 

  
  
最好保留成“一般式”的形式
 

Canvas没有画点的函数，我们就用某一点到其右下相邻点的连线来代替。然后自定义一个函数Graph()，把给定函数f(x)在指定区间里的点 (x, f(x)) 依次画出，步进间隔小到一定程度就会连成f(x)对应的曲线。
 
for ... in range()的步进值只能是整数，所以引入numpy库的arange()，其步进可以是小数，例： for i in numpy.arange(0,2,0.01) # 表示区间[0,1)上步进0.01，共循环200次。
 
函数解析式的图像
 
import tkinter as tk
import pyautogui as ag
from math import *
from numpy import arange as np

def Window_Open(W, H):
    X, Y = ag.size()
    winSize = str(W)+"x"+str(H)
    winPos = winSize + "+" + str((X - W) // 2)
    winPos += "+" + str((Y - H) // 2)
    win.geometry(winPos)
    win.resizable(False, False)
    title = u'桌面分辨率：' + str(X) + "x" + str(Y)
    title += ' ' * 5 + u'窗体大小：' + winSize
    win.title(title)
    win.update()

def Graph(func,x0,y0,xmin,xmax,w,h,c='blue',step=0.001):
    'xmin,xmax 自变量的取值范围； c 图像颜色'
    'x0,y0 原点坐标  w,h 横纵轴半长 step 步进'
    coord = x0-w,y0,x0+w,y0
    tCanvas.create_line(coord,fill='black')
    coord = x0,y0-h,x0,y0+h
    tCanvas.create_line(coord,fill='black')
    w1,w2=100,120 # w1,w2为自变量和函数值在横纵轴上的放大倍数
    for x in np(xmin,xmax+step,step):
        y = func(x)
        coord = x0+w1*x,y0-w2*y,x0+w1*x+1,y0-w2*y+1
        if abs(x*w1)<w and abs(y*w2)<h:
            tCanvas.create_line(coord,fill=c)
    tCanvas.update()

if __name__ == '__main__':
    
    win = tk.Tk()
    Window_Open(800,480)
    tCanvas = tk.Canvas(win, width=win.winfo_width(), height=480, bg='white')
    tCanvas.pack(side="top")

    x0,y0=400,240   # 原点坐标
    xmax=pi*2       # 自变量最大值，超过横坐标最大值被截短
    w,h=380,220     # 横纵轴的正向最大值
    
    fx1 = lambda x : sin(x)+cos(x)
    fx2 = lambda x : sin(x)*cos(x)
    gx1 = lambda x : exp(abs(x/4))-2
    gx2 = lambda x : (x/2)**3-2*(x/2)**2+x/2-1
    
    Graph(sin,x0,y0,-xmax,xmax,w,h)
    Graph(cos,x0,y0,-xmax,xmax,w,h,'red')
    Graph(fx1,x0,y0,-xmax,xmax,w,h,'lime')
    Graph(fx2,x0,y0,-xmax,xmax,w,h,'orange')
    Graph(gx1,x0,y0,-xmax,xmax,w,h,'magenta')
    Graph(gx2,x0,y0,-xmax,xmax,w,h,'limegreen')

    win.mainloop()
 
 效果图：
 
 
心形曲线参数方程的图像
 
把Graph()函数稍作改进，就能画出参数方程对应的曲线图像，如下例：心形曲线的图像
 
import tkinter as tk
import pyautogui as ag
from math import *
from numpy import arange as np

def Window_Open(W, H):
    X, Y = ag.size()
    winSize = str(W)+"x"+str(H)
    winPos = winSize + "+" + str((X - W) // 2)
    winPos += "+" + str((Y - H) // 2)
    win.geometry(winPos)
    win.resizable(False, False)
    title = u'桌面分辨率：' + str(X) + "x" + str(Y)
    title += ' ' * 5 + u'窗体大小：' + winSize
    win.title(title)
    win.update()

def Graph(funcx,funcy,x0,y0,tmin,tmax,w,h,c='blue',step=0.001):
    'xmin,xmax 自变量的取值范围； c 图像颜色'
    'x0,y0 原点坐标  w,h 横纵轴半长 step 步进'
    coord = x0-w,y0,x0+w,y0
    tCanvas.create_line(coord,fill='black')
    coord = x0,y0-h,x0,y0+h
    tCanvas.create_line(coord,fill='black')
    w1,w2=100,110 # w1,w2为自变量和函数值在横纵轴上的放大倍数
    for t in np(tmin,tmax+step,step):
        x = funcx(t)
        y = funcy(t)
        coord = x0+w1*x,y0-w2*y,x0+w1*x+1,y0-w2*y+1
        if abs(x*w1)<w and abs(y*w2)<h:
            tCanvas.create_line(coord,fill=c)
    tCanvas.update()

if __name__ == '__main__':
    
    win = tk.Tk()
    Window_Open(480,480)
    tCanvas = tk.Canvas(win, width=win.winfo_width(), height=480, bg='white')
    tCanvas.pack(side="top")

    x0,y0=240,240   # 原点坐标

    a = 0.7
    
    fx = lambda t : a*(2.0*sin(t)-sin(2*t))
    fy = lambda t : a*(1.6*cos(t)-cos(2*t))+0.5

    Graph(fx,fy,x0,y0,-pi,pi,220,200,c='red')

    win.mainloop()

 
效果图：
 
 
椭圆、双曲线、抛物线的图像
 
import tkinter as tk
import pyautogui as ag
from math import *
from numpy import arange as np

def Window_Open(W, H):
    X, Y = ag.size()
    winSize = str(W)+"x"+str(H)
    winPos = winSize + "+" + str((X - W) // 2)
    winPos += "+" + str((Y - H) // 2)
    win.geometry(winPos)
    win.resizable(False, False)
    title = u'桌面分辨率：' + str(X) + "x" + str(Y)
    title += ' ' * 5 + u'窗体大小：' + winSize
    win.title(title)
    win.update()

def Graph(funcx,funcy,x0,y0,tmin,tmax,w,h,c='blue',step=0.001):
    'xmin,xmax 自变量的取值范围； c 图像颜色'
    'x0,y0 原点坐标  w,h 横纵轴半长 step 步进'
    coord = x0-w,y0,x0+w,y0
    tCanvas.create_line(coord,fill='black')
    coord = x0,y0-h,x0,y0+h
    tCanvas.create_line(coord,fill='black')
    w1,w2=100,100 # w1,w2为自变量和函数值在横纵轴上的放大倍数
    for t in np(tmin,tmax+step,step):
        x = funcx(t)
        y = funcy(t)
        coord = x0+w1*x,y0-w2*y,x0+w1*x+1,y0-w2*y+1
        if abs(x*w1)<w and abs(y*w2)<h:
            tCanvas.create_line(coord,fill=c)
    tCanvas.update()

if __name__ == '__main__':
    
    win = tk.Tk()
    Window_Open(480,480)
    tCanvas = tk.Canvas(win, width=win.winfo_width(), height=480, bg='white')
    tCanvas.pack(side="top")

    x0,y0=240,240
    a,b = 1,1.2
    p = 0.5
    
    f1x = lambda t : a*cos(t)
    f1y = lambda t : b*sin(t)

    f2x = lambda t : a/cos(t)
    f2y = lambda t : b*tan(t)

    f3x = lambda t : 2*p*t**2
    f3y = lambda t : 2*p*t

    Graph(f1x,f1y,x0,y0,-pi,pi,220,200)
    Graph(f2x,f2y,x0,y0,-pi,pi,220,200,c='red')
    Graph(f3x,f3y,x0,y0,-pi,pi,220,200,c='green')
    
    win.mainloop()

 
 效果图：
 
 
附：圆锥曲线的参数方程
 
椭圆
 x = a*cost
 y = b*sint
 双曲线
 x = a*sect
 y = b*tant
 抛物线
 x = 2*p*t²
 y = 2*p*t

 
Python内置函数
 
Python abs()函数
Python all() 函数
Python any() 函数
Python basestring() 函数
Python bin() 函数
Python bool() 函数
Python bytearray() 函数
Python callable() 函数
Python chr() 函数
Python classmethod 修饰符
Python cmp() 函数
Python compile() 函数
Python complex() 函数
Python delattr() 函数
Python dict() 函数
Python dir() 函数
Python divmod() 函数
Python enumerate() 函数
Python eval() 函数
Python execfile() 函数
Python file() 函数
Python filter() 函数
Python float() 函数
Python format 格式化函数
Python frozenset() 函数
Python getattr() 函数
Python globals() 函数
Python hasattr() 函数
Python hash() 函数
Python hash() 函数
Python hex() 函数
Python id() 函数
Python3 input() 函数
Python int() 函数
Python issubclass() 函数
Python iter() 函数
Python len()方法
Python List list()方法
Python locals() 函数
Python long() 函数
Python map() 函数
Python max() 函数
Python min() 函数
Python next() 函数
Python object()函数
Python oct() 函数
Python open() 函数
Python ord() 函数
Python pow() 函数
Python print() 函数
Python property() 函数
Python range() 函数用法
Python raw_input() 函数
Python reduce() 函数
Python reload() 函数
Python repr() 函数
Python List reverse()方法
Python round() 函数
Python set() 函数
Python setattr() 函数
Python slice() 函数
Python sorted() 函数
Python staticmethod() 函数
Python str() 函数
Python sum() 函数
Python super() 函数
Python Tuple(元组) tuple()方法
Python type() 函数
Python unichr() 函数
Python unicode() 函数
Python vars() 函数
Python xrange() 函数
Python3 zip() 函数
Python __import__() 函数
Python exec 内置语句

 
Python abs()函数
 
描述：
 abs() 函数返回数字的绝对值。
 
abs() 方法的语法:
 abs( x )
 
参数：
 
 
 
x – 数值表达式。
 
 
返回值：
 函数返回x（数字）的绝对值。
 
实例：
 
print "abs(-45) : ", abs(-45)
print "abs(100.12) : ", abs(100.12)
print "abs(119L) : ", abs(119L)
 
输出结果：
 
abs(-45) :  45
abs(100.12) :  100.12
abs(119L) :  119
 
Python all() 函数
 
描述：
 all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 True，如果是返回 True，否则返回 False。
 元素除了是 0、空、None、False 外都算 True。
 
以下是 all() 方法的语法:
 all(iterable)
 
参数：
 
 
 
iterable – 元组或列表。
 
 
返回值：
 如果iterable的所有元素不为0、’’、False或者iterable为空，all(iterable)返回True，否则返回False；
 注意：空元组、空列表返回值为True，这里要特别注意。
 
all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0

True

all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素

False

all([0, 1，2, 3])          # 列表list，存在一个为0的元素

False  

all(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0

True

all(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素

False

all((0, 1, 2, 3))          # 元组tuple，存在一个为0的元素

False  

all([])             # 空列表

True

all(())             # 空元组

True
 
Python any() 函数
 
描述：
 any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
 元素除了是 0、空、False 外都算 True。
 
any() 方法的语法:
 any(iterable)
 
参数：
 
 
 
iterable – 元组或列表。
 
 
返回值：
 如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
 
实例：
 
any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True
 
any(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
True
 
any([0, '', False])        # 列表list,元素全为0,'',false
False
 
any(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
True
 
any(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
True
 
any((0, '', False))        # 元组tuple，元素全为0,'',false
False
  
any([]) # 空列表
False
 
any(()) # 空元组
False
 
Python basestring() 函数
 
描述：
 basestring() 方法是 str 和 unicode 的超类（父类），也是抽象类，因此不能被调用和实例化，但可以被用来判断一个对象是否为 str 或者 unicode 的实例，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。
 
basestring() 方法的语法:
 basestring()
 
参数：
 无
 
返回值：
 无
 
实例：
 
isinstance("Hello world", str)
True

isinstance("Hello world", basestring)
True
 
Python bin() 函数
 
描述：
 bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
 
bin() 方法的语法:
 bin(x)
 
参数：
 
 
 
x – int 或者 long int 数字
 
 
返回值：
 字符串
 
实例：
 
bin(10)
'0b1010'
bin(20)
'0b10100'
 
Python bool() 函数
 
描述：
 
bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
 bool 是 int 的子类。
 
bool() 方法的语法:
 class bool([x])
 
参数：
 
 
 
x – 要进行转换的参数。
 
 
返回值：
 返回 Ture 或 False。
 
实例：
 
bool()
False

bool(0)
False

bool(1)
True

bool(2)
True

issubclass(bool, int)  # bool 是 int 子类
True
 
Python bytearray() 函数
 
描述：
 bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
 
bytearray()方法语法：
 class bytearray([source[, encoding[, errors]]])
 
参数：
 
 
 
如果 source 为整数，则返回一个长度为 source 的初始化数组；
 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
 如果 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')
>>>
 
Python callable() 函数
 
描述：
 callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
 对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。
 
callable()方法语法：
 callable(object)
 
参数：
 object – 对象
 
返回值：
 可调用返回 True，否则返回 False。
 
实例：
 
>>>callable(0)
False
>>> callable("runoob")
False
 
>>> def add(a, b):
...     return a + b
... 
>>> callable(add)             # 函数返回 True
True
>>> class A:                  # 类
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False
>>> class B:
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 实现 __call__, 返回 True
True
 
Python chr() 函数
 
描述：
 chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
 
chr() 方法的语法:
 chr(i)
 
参数:
 
 
 
i – 可以是10进制也可以是16进制的形式的数字。
 
 
返回值:
 返回值是当前整数对应的 ASCII 字符。
 
实例:
 
>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a
 
Python classmethod 修饰符
 
描述:
 classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
 
classmethod 语法：
 classmethod
 
参数:
 无。
 
返回值:
 返回函数的类方法。
 
实例:
 class A(object):
 bar = 1
 def func1(self):
 print (‘foo’)
 @classmethod
 def func2(cls):
 print (‘func2’)
 print (cls.bar)
 cls().func1() # 调用 foo 方法
 
A.func2()               # 不需要实例化
 
输出结果为：
 
func2
1
foo
 
Python cmp() 函数
 
描述:
 cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
 
cmp() 方法的语法:
 cmp( x, y )
 
参数:
 
 
 
x – 数值表达式。
 y – 数值表达式。
 
 
返回值
 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
 
以下展示了使用 cmp() 方法的实例：
 
print "cmp(80, 100) : ", cmp(80, 100)
print "cmp(180, 100) : ", cmp(180, 100)
print "cmp(-80, 100) : ", cmp(-80, 100)
print "cmp(80, -100) : ", cmp(80, -100)
 
以上实例运行后输出结果为：
 
cmp(80, 100) :  -1
cmp(180, 100) :  1
cmp(-80, 100) :  -1
cmp(80, -100) :  1
 
Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象，包含的方法有：
 
operator.lt(a, b)
 operator.le(a, b)
 operator.eq(a, b)
 operator.ne(a, b)
 operator.ge(a, b)
 operator.gt(a, b)
 operator.lt(a, b)
 operator.le(a, b)
 operator.eq(a, b)
 operator.ne(a, b)
 operator.ge(a, b)
 operator.gt(a, b)
 实例
 
import operator
operator.eq('hello', 'name');
operator.eq('hello', 'hello');
 
结果：
 
False
True
 
Python compile() 函数
 
描述:
 compile() 函数将一个字符串编译为字节代码。
 
compile() 方法的语法:
 compile(source, filename, mode[, flags[, dont_inherit]])
 
参数:
 
 
 
source – 字符串或者AST（Abstract Syntax Trees）对象。。
 filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
 mode – 指定编译代码的种类。可以指定为 exec, eval, single。
 flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
 flags和dont_inherit是用来控制编译源码时的标志
 
 
返回值
 返回表达式执行结果。
 
以下展示了使用 compile 函数的实例：
 
>>>str = "for i in range(0,10): print(i)" 
>>> c = compile(str,'','exec')   # 编译为字节代码对象 
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
 
Python complex() 函数
 
描述
 
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
 
complex 语法：
 class complex([real[, imag]])
 
参数说明：
 
 
 
real – int, long, float或字符串；
 imag – int, long, float；
 
 
返回值
 返回一个复数。
 
以下实例展示了 complex 的使用方法：
 
>>>complex(1, 2)
(1 + 2j)
 
>>> complex(1)    # 数字
(1 + 0j)
 
>>> complex("1")  # 当做字符串处理
(1 + 0j)
 
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)
 
Python delattr() 函数
 
描述:
 
delattr 函数用于删除属性。
 delattr(x, ‘foobar’) 相等于 del x.foobar。
 
delattr 语法：
 delattr(object, name)
 
参数：
 
 
 
object – 对象。
 name – 必须是对象的属性。
 
 
返回值：
 无。
 
以下实例展示了 delattr 的使用方法：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)
 
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
 
# 触发错误
print('z = ',point1.z)

输出结果：

('x = ', 10)
('y = ', -5)
('z = ', 0)
--删除 z 属性后--
('x = ', 10)
('y = ', -5)
Traceback (most recent call last):
  File "test.py", line 22, in <module>
    print('z = ',point1.z)
AttributeError: Coordinate instance has no attribute 'z'
 
Python dict() 函数
 
描述:
 dict() 函数用于创建一个字典。
 
dict 语法：
 class dict(**kwarg)
 class dict(mapping, **kwarg)
 class dict(iterable, **kwarg)
 
参数说明：
 
 
 
**kwargs – 关键字
 mapping – 元素的容器。
 iterable – 可迭代对象。
 
 
返回值:
 返回一个字典。
 
以下实例展示了 dict 的使用方法：
 
>>>dict()                        # 创建空字典
{}
>>> 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}
>>>
 
Python dir() 函数
 
描述:
 dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
 
dir 语法：
 dir([object])
 
参数说明：
 
 
 
object – 对象、变量、类型。
 
 
返回值:
 返回模块的属性列表。
 
以下实例展示了 dir 的使用方法：
 
>>>dir()   #  获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ])    # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>>
 
Python divmod() 函数
 
描述：
 python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
 
函数语法:
 divmod(a, b)
 Python divmod() 函数
 
Python 内置函数 Python 内置函数
 
python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
 
在 python 2.3 版本之前不允许处理复数。
 函数语法
 
divmod(a, b)
 
参数说明：
 
 
 
a: 数字
 b: 数字
 
 
实例
 
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)
 
Python enumerate() 函数
 
描述:
 enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
 
enumerate() 方法的语法:
 enumerate(sequence, [start=0])
 
参数:
 
 
 
sequence – 一个序列、迭代器或其他支持迭代对象。
 start – 下标起始位置。
 
 
返回值:
 返回 enumerate(枚举) 对象。
 
以下展示了使用 enumerate() 方法的实例：
 
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (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
 
for 循环使用 enumerate
 
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 
0 one
1 two
2 three
 
Python eval() 函数
 
描述:
 eval() 函数用来执行一个字符串表达式，并返回表达式的值。
 
eval() 方法的语法:
 eval(expression[, globals[, locals]])
 
参数:
 
 
 
expression – 表达式。
 globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
 locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
 
 
返回值:
 返回表达式计算结果。
 
以下展示了使用 eval() 方法的实例：
 
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
 
Python execfile() 函数
 
描述：
 
execfile() 函数可以用来执行一个文件。
 
execfile() 方法的语法:
 execfile(filename[, globals[, locals]])
 
参数
 
 
 
filename – 文件名。
 globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
 locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
 
 
返回值
 返回表达式执行结果。
 
以下展示了使用 execfile 函数的实例：
 
假设文件 hello.py，内容如下：
 
print('runoob');
 
execfile 调用该文件
 
>>>execfile('hello.py')
runoob
 
Python file() 函数
 
描述
 file() 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。
 更多文件操作可参考：Python 文件I/O。
 
file() 方法的语法:
 file(name[, mode[, buffering]])
 
参数
 
 
 
name – 文件名
 mode – 打开模式
 buffering – 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小。
 
 
返回值
 文件对象。
 实例
 
测试文件 test.txt，内容如下：
 
RUNOOB1
RUNOOB2

>>>f = file('test.txt')
>>> f.read()
'RUNOOB1\nRUNOOB2\n'
 
Python filter() 函数
 
描述
 filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
 
注意: Pyhton2.7 返回列表，Python3.x 返回迭代器对象，具体内容可以查看：Python3 filter() 函数
 
filter() 方法的语法:
 filter(function, iterable)
 
参数
 
 
 
function – 判断函数。
 iterable – 可迭代对象。
 
 
返回值
 返回列表。
 
以下展示了使用 filter 函数的实例：
 过滤出列表中的所有奇数：
 
def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
 
输出结果 ：
 
[1, 3, 5, 7, 9]
 
过滤出1~100中平方根是整数的数：
 
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
newlist = filter(is_sqr, range(1, 101))
print(newlist)
 
输出结果 ：
 
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 
Python float() 函数
 
描述
 float() 函数用于将整数和字符串转换成浮点数。
 
float()方法语法：
 class float([x])
 
参数
 
 
 
x – 整数或字符串
 
 
返回值
 返回浮点数。
 
以下实例展示了 float() 的使用方法：
 
>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123')     # 字符串
123.0
 
Python format 格式化函数
 
以下实例展示了format（）的使用方法：
 
"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
"{0} {1}".format("hello", "world")  # 设置指定位置
"{1} {0} {1}".format("hello", "world")  # 设置指定位置
 
输出结果：
 
'hello world'
'hello world'
'world hello world'
 
Python frozenset() 函数
 
描述
 
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
 
frozenset() 函数语法：
 
class frozenset([iterable])
 
参数
 
 
 
iterable – 可迭代的对象，比如列表、字典、元组等等。
 
 
返回值
 
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
 
以下实例展示了 frozenset() 的使用方法：
 
>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
>>>
 
Python getattr() 函数
 
描述
 getattr() 函数用于返回一个对象属性值。
 
getattr 语法：
 
getattr(object, name[, default])
 
参数
 
 
 
object – 对象。
 name – 字符串，对象属性。
 default – 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
 返回值
 返回对象属性值。
 
 
以下实例展示了 getattr 的使用方法：
 
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
3
>>>
 
Python globals() 函数
 
描述
 
globals() 函数会以字典类型返回当前位置的全部全局变量。
 
globals() 函数语法：
 
globals()
 
参数
 
无
 
返回值
 
返回全局变量的字典。
 
以下实例展示了 globals() 的使用方法：
 
>>>a='runoob'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
 
Python hasattr() 函数
 
描述
 
hasattr() 函数用于判断对象是否包含对应的属性。
 
hasattr 语法：
 
hasattr(object, name)
 
参数
 
 
 
object – 对象。
 name – 字符串，属性名。
 返回值
 如果对象有该属性返回 True，否则返回 False。
 
 
以下实例展示了 hasattr 的使用方法：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 没有该属性
 
输出结果：
 
True
True
True
False
 
Python hash() 函数
 
描述
 
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
 
hash 语法：
 
hash(object)
 
参数说明：
 
 
 
object – 对象；
 返回值
 返回对象的哈希值。
 
 
以下实例展示了 hash 的使用方法：
 
>>>hash('test')            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
>>>
 
Python hash() 函数
 
描述
 hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
 
hash 语法：
 
hash(object)
 
参数说明：
 
 
 
object – 对象；
 返回值
 返回对象的哈希值。
 
 
以下实例展示了 hash 的使用方法：
 
>>>hash('test')            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
>>>
 
Python hex() 函数
 
描述
 
hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
 
hex 语法：
 
hex(x)
 
参数说明：
 
 
 
x – 10进制整数
 返回值
 返回16进制数，以字符串形式表示。
 
 
以下实例展示了 hex 的使用方法：
 
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'>      # 字符串
 
Python id() 函数
 
描述
 
id() 函数用于获取对象的内存地址。
 
id 语法：
 
id([object])
 
参数说明：
 
 
 
object – 对象。
 返回值
 返回对象的内存地址。
 
 
以下实例展示了 id 的使用方法：
 
>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
 
Python3 input() 函数
 
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
 注意：在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。
 
函数语法
 
input([prompt])
 
参数说明：
 
 
 
prompt: 提示信息
 
 
input() 需要输入 python 表达式
 
>>>a = input("input:")
input:123                  # 输入整数
>>> type(a)
<class 'str'>              # 字符串
>>> a = input("input:")    
input:runoob              # 正确，字符串表达式
>>> type(a)
<class 'str'>             # 字符串
 
Python int() 函数
 
描述
 
int() 函数用于将一个字符串或数字转换为整型。
 
以下是 int() 方法的语法:
 
class int(x, base=10)
 
参数
 
 
 
x – 字符串或数字。
 base – 进制数，默认十进制。
 返回值
 返回整型数据。
 
 
以下展示了使用 int() 方法的实例：
 
>>>int()               # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0xa',16)  
10  
>>> int('10',8)  
8
 
#Python isinstance() 函数
 
描述
 isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
 isinstance() 与 type() 区别：
 type() 不会认为子类是一种父类类型，不考虑继承关系。
 isinstance() 会认为子类是一种父类类型，考虑继承关系。
 如果要判断两个类型是否相同推荐使用 isinstance()。
 
以下是 isinstance() 方法的语法:
 
isinstance(object, classinfo)
 
参数
 
 
 
object – 实例对象。
 classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
 返回值
 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。
 
 
以下展示了使用 isinstance 函数的实例：
 
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True
 
type() 与 isinstance()区别：
 
class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
 
Python issubclass() 函数
 
描述
 
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
 
以下是 issubclass() 方法的语法:
 
issubclass(class, classinfo)
 
参数
 
 
 
class – 类。
 classinfo – 类。
 返回值
 如果 class 是 classinfo 的子类返回 True，否则返回 False。
 
 
以下展示了使用 issubclass 函数的实例：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class A:
    pass
class B(A):
    pass
    
print(issubclass(B,A))    # 返回 True
 
Python iter() 函数
 
描述
 
iter() 函数用来生成迭代器。
 
以下是 iter() 方法的语法:
 
iter(object[, sentinel])
 
参数
 
 
 
object – 支持迭代的集合对象。
 sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
 打开模式
 返回值
 迭代器对象。
 
 
实例
 
>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3
 
Python len()方法
 
描述
 
Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
 
len()方法语法：
 
len( s )
 
参数
 
 
 
s – 对象。
 返回值
 返回对象长度。
 
 
以下实例展示了 len() 的使用方法：
 
>>>str = "runoob"
>>> len(str)             # 字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l)               # 列表元素个数
5
 
Python List list()方法
 
描述
 list() 方法用于将元组转换为列表。
 
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
 
list()方法语法：
 
list( tup )
 
参数
 
 
 
tup – 要转换为列表的元组。
 返回值
 返回列表。
 
 
以下实例展示了 list()函数的使用方法：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
aTuple = (123, 'xyz', 'zara', 'abc');
aList = list(aTuple)
 
print "列表元素 : ", aList
以上实例输出结果如下：

列表元素 :  [123, 'xyz', 'zara', 'abc']
 
Python locals() 函数
 
描述
 
locals() 函数会以字典类型返回当前位置的全部局部变量。
 对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
 
locals() 函数语法：
 
locals()
 
参数
 
无
 
返回值
 
返回字典类型的局部变量。
 
以下实例展示了 locals() 的使用方法：
 
>>>def runoob(arg):    # 两个局部变量：arg、z
...     z = 1
...     print (locals())
... 
>>> runoob(4)
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
>>>
 
Python long() 函数
 
描述
 
long() 函数将数字或字符串转换为一个长整型。
 
long() 函数语法：
 
class long(x, base=10)
 
参数
 
 
 
x – 字符串或数字。
 base – 可选，进制数，默认十进制。
 返回值
 返回长整型数。
 
 
以下实例展示了 long() 的使用方法：
 
>>>long()
0L
>>> long(1)
1L
>>> long('123')
123L
>>> 
>>>
 
Python map() 函数
 
描述
 
map() 会根据提供的函数对指定序列做映射。
 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
 
map() 函数语法：
 
map(function, iterable, …)
 
参数
 
 
 
function – 函数
 iterable – 一个或多个序列
 
 
返回值
 
Python 2.x 返回列表。
 Python 3.x 返回迭代器。
 
以下实例展示了 map() 的使用方法：
 
>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
 
Python max() 函数
 
描述
 
max() 方法返回给定参数的最大值，参数可以为序列。
 
以下是 max() 方法的语法:
 
max( x, y, z, … )
 
参数
 
 
 
x – 数值表达式。
 y – 数值表达式。
 z – 数值表达式。
 
 
返回值
 
返回给定参数的最大值。
 
以下展示了使用 max() 方法的实例：
 
实例(Python 2.0+)
#!/usr/bin/python
 
print "max(80, 100, 1000) : ", max(80, 100, 1000)
print "max(-20, 100, 400) : ", max(-20, 100, 400)
print "max(-80, -20, -10) : ", max(-80, -20, -10)
print "max(0, 100, -400) : ", max(0, 100, -400)

实例（Python 3.0+）
print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))
 
以上实例运行后输出结果为：
 
max(80, 100, 1000) :  1000
max(-20, 100, 400) :  400
max(-80, -20, -10) :  -10
max(0, 100, -400) :  100
 
#　Python memoryview() 函数
 
描述
 
memoryview() 函数返回给定参数的内存查看对象(Momory view)。
 所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
 
memoryview 语法：
 
memoryview(obj)
 
参数说明：
 
 
 
obj – 对象
 返回值
 返回元组列表。
 
 
以下实例展示了 memoryview 的使用方法：
 
Python2.x 应用：
 
>>>v = memoryview('abcefg')
>>> v[1]
'b'
>>> v[-1]
'g'
>>> v[1:4]
<memory at 0x77ab28>
>>> v[1:4].tobytes()
'bce'
 
Python3.x 应用：
 
>>>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'
>>>
 
Python min() 函数
 
描述
 
min() 方法返回给定参数的最小值，参数可以为序列。
 
以下是 min() 方法的语法:
 
min( x, y, z, … )
 
参数
 
 
 
x – 数值表达式。
 y – 数值表达式。
 z – 数值表达式。
 
 
返回值
 
返回给定参数的最小值。
 
以下展示了使用 min() 方法的实例：
 
#!/usr/bin/python

print "min(80, 100, 1000) : ", min(80, 100, 1000)
print "min(-20, 100, 400) : ", min(-20, 100, 400)
print "min(-80, -20, -10) : ", min(-80, -20, -10)
print "min(0, 100, -400) : ", min(0, 100, -400)
 
以上实例运行后输出结果为：
 
min(80, 100, 1000) :  80
min(-20, 100, 400) :  -20
min(-80, -20, -10) :  -80
min(0, 100, -400) :  -400
 
Python next() 函数
 
描述
 
next() 返回迭代器的下一个项目。
 
next 语法：
 
next(iterator[, default])
 
参数说明：
 
 
 
iterator – 可迭代对象
 default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
 
 
返回值
 
返回对象帮助信息。
 
以下实例展示了 next 的使用方法：
 
#!/usr/bin/python
# -*- 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
 
Python object()函数
 
Python object() 函数
 
Python oct() 函数
 
描述
 
oct() 函数将一个整数转换成8进制字符串。
 
oct 语法：
 
oct(x)
 
参数说明：
 
 
 
x – 整数。
 返回值
 返回8进制字符串。
 
 
以下实例展示了 oct 的使用方法：
 
>>>oct(10)
'012'
>>> oct(20)
'024'
>>> oct(15)
'017'
>>>
 
Python open() 函数
 
python open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
 
更多文件操作可参考：Python 文件I/O
 
函数语法
 
open(name[, mode[, buffering]])
 
参数说明：
 
 
 
name : 一个包含了你要访问的文件名称的字符串值。
 mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。
 buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
 
 
不同模式打开文件的完全列表：
 
模式
描述
r
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+
打开一个文件用于读写。文件指针将会放在文件的开头。
rb+
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w
打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb
以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+
打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+
以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a
打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+
打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
file 对象方法
 
file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。
 
file.readline()：返回一行。
 
file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。
 
for line in f: print line ：通过迭代器访问。
 
f.write(“hello\n”)：如果要写入字符串以外的数据,先将他转换为字符串。
 
f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。
 
f.seek(偏移量,[起始位置])：用来移动文件指针。
 
偏移量: 单位为比特，可正可负
 起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
 f.close() 关闭文件
 
Python ord() 函数
 
描述
 
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
 
以下是 ord() 方法的语法:
 
ord©
 
参数
 
 
 
c – 字符。
 返回值
 返回值是对应的十进制整数。
 
 
以下展示了使用 ord() 方法的实例：
 
>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
 
Python pow() 函数
 
描述
 
pow() 方法返回 xy（x的y次方） 的值。
 
以下是 math 模块 pow() 方法的语法:
 
import math
 
math.pow( x, y )
 
内置的 pow() 方法
 
pow(x, y[, z])
 
函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
 注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
 
参数
 
 
 
x – 数值表达式。
 y – 数值表达式。
 z – 数值表达式。
 
 
返回值
 
返回 xy（x的y次方） 的值。
 
以下展示了使用 pow() 方法的实例：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
import math   # 导入 math 模块
 
print "math.pow(100, 2) : ", math.pow(100, 2)
# 使用内置，查看输出结果区别
print "pow(100, 2) : ", pow(100, 2)
 
print "math.pow(100, -2) : ", math.pow(100, -2)
print "math.pow(2, 4) : ", math.pow(2, 4)
print "math.pow(3, 0) : ", math.pow(3, 0)
 
以上实例运行后输出结果为：
 
math.pow(100, 2) :  10000.0
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0
 
Python print() 函数
 
描述
 
print() 方法用于打印输出，最常见的一个函数。
 print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。
 
以下是 print() 方法的语法:
 
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)
 
参数
 
 
 
objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
 sep – 用来间隔多个对象，默认值是一个空格。
 end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
 file – 要写入的文件对象。
 
 
返回值
 
无。
 
以下展示了使用 print 函数的实例：
 Python3 下测试
 
>>>print(1)  
1  
>>> print("Hello World")  
Hello World  
 
>>> a = 1
>>> b = 'runoob'
>>> print(a,b)
1 runoob
 
>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>> 
 
>>> print("I","Love","Python",sep=".")  # 设置间隔符
I.Love.Python
 
Python property() 函数
 
描述
 
property() 函数的作用是在新式类中返回属性值。
 
以下是 property() 方法的语法:
 
class property([fget[, fset[, fdel[, doc]]]])
 
参数
 
 
 
fget – 获取属性值的函数
 fset – 设置属性值的函数
 fdel – 删除属性值函数
 doc – 属性描述信息
 
 
返回值
 
返回新式类属性。
 
实例
 
定义一个可控属性值 x
class C(object):
    def __init__(self):
        self._x = None
 
    def getx(self):
        return self._x
 
    def setx(self, value):
        self._x = value
 
    def delx(self):
        del self._x
 
    x = property(getx, setx, delx, "I'm the 'x' property.")
 
如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。
 如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。
 将 property 函数用作装饰器可以很方便的创建只读属性：
 
class Parrot(object):
    def __init__(self):
        self._voltage = 100000
 
    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage
 
上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
 property 的 getter,setter 和 deleter 方法同样可以用作装饰器：
 
class C(object):
    def __init__(self):
        self._x = None
 
    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x
 
    @x.setter
    def x(self, value):
        self._x = value
 
    @x.deleter
    def x(self):
        del self._x
 
这个代码和第一个例子完全相同，但要注意这些额外函数的名字和 property 下的一样，例如这里的 x。
 
Python range() 函数用法
 
描述
 python range() 函数可创建一个整数列表，一般用在 for 循环中。
 
函数语法
 
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(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)
[]
 
以下是 range 在 for 中的使用，循环出runoob 的每个字母:
 
>>>x = 'runoob'
>>> for i in range(len(x)) :
...     print(x[i])
... 
r
u
n
o
o
b
>>>
 
Python raw_input() 函数
 
描述
 python raw_input() 用来获取控制台的输入。
 raw_input() 将所有输入作为字符串看待，返回字符串类型。
 
注意： input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
 除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
 
注意： python3 里 input() 默认接收到的是 str 类型。
 
函数语法
 
raw_input([prompt])
 
参数说明：
 
 
 
prompt: 可选，字符串，可作为一个提示语。
 
 
实例
 raw_input() 将所有输入作为字符串看待
 
>>>a = raw_input("input:")
input:123
>>> type(a)
<type 'str'>              # 字符串
>>> a = raw_input("input:")
input:runoob
>>> type(a)
<type 'str'>              # 字符串
>>>
 
input() 需要输入 python 表达式
 
>>>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'>
 
Python reduce() 函数
 
描述
 
reduce() 函数会对参数序列中元素进行累积。
 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
 
reduce() 函数语法：
 
reduce(function, iterable[, initializer])
 
参数
 
 
 
function – 函数，有两个参数
 iterable – 可迭代对象
 initializer – 可选，初始参数
 
 
返回值
 
返回函数计算结果。
 
以下实例展示了 reduce() 的使用方法：
 
>>>def add(x, y) :            # 两数相加
...     return x + y
... 
>>> reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
15
 
Python reload() 函数
 
Python3.0+ 重要!!!
 
说明：Python 3.0 把 reload 内置函数移到了 imp 标准库模块中。它仍然像以前一样重载文件，但是，必须导入它才能使用。
 
方法一：
 
from imp import reload
 reload(module)
 方法二：
 
import imp
 imp.reload(module)
 
描述
 
reload() 用于重新载入之前载入的模块。
 
reload() 函数语法：
 
reload(module)
 
参数
 
module – 模块对象。
 
返回值
 
返回模块对象。
 
以下实例展示了 reload() 的使用方法：
 
重新载入 sys 模块，并设置默认编码为 utf8
>>>import sys
>>> sys.getdefaultencoding()            # 当前默认编码
'ascii'
>>> reload(sys)                         # 使用 reload
<module 'sys' (built-in)>
>>> sys.setdefaultencoding('utf8')      # 设置编码
>>> sys.getdefaultencoding()
'utf8'
>>>
 
Python repr() 函数
 
描述
 
repr() 函数将对象转化为供解释器读取的形式。
 
以下是 repr() 方法的语法:
 
repr(object)
 
参数
 
 
 
object – 对象。
 
 
返回值
 
返回一个对象的 string 格式。
 
以下展示了使用 repr() 方法的实例：
 
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
>>>
 
Python List reverse()方法
 
描述
 
reverse() 函数用于反向列表中元素。
 
reverse()方法语法：
 
list.reverse()
 
参数
 
 
 
NA。
 
 
返回值
 
该方法没有返回值，但是会对列表的元素进行反向排序。
 
以下实例展示了 reverse()函数的使用方法：
 
#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc', 'xyz']

aList.reverse()
print "List : ", aList
以上实例输出结果如下：

List :  ['xyz', 'abc', 'zara', 'xyz', 123]
 
Python round() 函数
 
描述
 
round() 方法返回浮点数x的四舍五入值。
 
以下是 round() 方法的语法:
 
round( x [, n] )
 
参数
 
 
 
x – 数值表达式。
 n – 数值表达式。
 
 
返回值
 返回浮点数x的四舍五入值。
 
以下展示了使用 round() 方法的实例：
 
#!/usr/bin/python

print "round(80.23456, 2) : ", round(80.23456, 2)
print "round(100.000056, 3) : ", round(100.000056, 3)
print "round(-100.000056, 3) : ", round(-100.000056, 3)
 
以上实例运行后输出结果为：
 
round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0
 
Python set() 函数
 
描述
 
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
 
set 语法：
 
class set([iterable])
 
参数说明：
 
 
 
iterable – 可迭代对象对象；
 
 
返回值
 
返回新的集合对象。
 
以下实例展示了 set 的使用方法：
 
>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])
>>>
 
Python setattr() 函数
 
描述
 setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
 
setattr() 语法：
 
setattr(object, name, value)
 
参数
 
 
 
object – 对象。
 name – 字符串，对象属性。
 value – 属性值。
 
 
返回值
 无。
 
以下实例展示了 setattr() 函数的使用方法：
 
对已存在的属性进行赋值：
 
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')          # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5)       # 设置属性 bar 值
>>> a.bar
5
 
如果属性不存在会创建一个新的对象属性，并对属性赋值：
 
>>>class A():
...     name = "runoob"
... 
>>> a = A()
>>> setattr(a, "age", 28)
>>> print(a.age)
28
>>>
 
Python slice() 函数
 
描述
 
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
 
slice 语法：
 
class slice(stop)
 class slice(start, stop[, step])
 
参数说明：
 
 
 
start – 起始位置
 stop – 结束位置
 step – 间距
 
 
返回值
 
返回一个切片对象。
 
以下实例展示了 slice 的使用方法：
 
>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(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]
>>>
 
Python sorted() 函数
 
描述
 
sorted() 函数对所有可迭代的对象进行排序操作。
 sort 与 sorted 区别：
 sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
 list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
 
sorted 语法：
 
sorted(iterable[, cmp[, key[, reverse]]])
 
参数说明：
 
 
 
iterable – 可迭代对象。
 cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
 key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
 reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
 
 
返回值
 
返回重新排序的列表。
 
以下实例展示了 sorted 的使用方法：
 
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>>
 
Python staticmethod() 函数
 
描述
 python staticmethod 返回函数的静态方法。
 该方法不强制要求传递参数，如下声明一个静态方法：
 
class C(object):
    @staticmethod
    def f(arg1, arg2, ...):
        ...
 
以上实例声明了静态方法 f，类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 C().f()。
 
函数语法
 staticmethod(function)
 
参数说明：
 
无
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class C(object):
    @staticmethod
    def f():
        print('Python');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用
 
以上实例输出结果为：
 
Python
Python
 
Python str() 函数
 
描述
 
str() 函数将对象转化为适于人阅读的形式。
 
以下是 str() 方法的语法:
 
class str(object=’’)
 
参数
 
 
 
object – 对象。
 返回值
 返回一个对象的string格式。
 
 
以下展示了使用 str() 方法的实例：
 
>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
>>>
 
Python sum() 函数
 
描述
 
sum() 方法对系列进行求和计算。
 
以下是 sum() 方法的语法:
 
sum(iterable[, start])
 
参数
 
 
 
iterable – 可迭代对象，如：列表、元组、集合。
 start – 指定相加的参数，如果没有设置这个值，默认为0。
 
 
返回值
 
返回计算结果。
 
以下展示了使用 sum 函数的实例：
 
>>>sum([0,1,2])  
3  
>>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
12
 
Python super() 函数
 
描述
 super() 函数是用于调用父类(超类)的一个方法。
 
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
 
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
 
以下是 super() 方法的语法:
 
super(type[, object-or-type])
 
参数
 
 
 
type – 类。
 object-or-type – 类，一般是 self
 
 
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :
 
Python3.x 实例：
 
class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  # 3
 
Python2.x 实例：
 
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class A(object):   # Python2.x 记得继承 object
    def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super(B, self).add(x)
b = B()
b.add(2)  # 3
 
返回值
 
无。
 
以下展示了使用 super 函数的实例：
 
#!/usr/bin/python
# -*- 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) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')
 
执行结果：
 
Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.
 
Python Tuple(元组) tuple()方法
 
描述
 
Python 元组 tuple() 函数将列表转换为元组。
 
tuple()方法语法：
 
tuple( seq )
 
参数
 
 
 
seq – 要转换为元组的序列。
 
 
返回值
 
返回元组。
 
以下实例展示了 tuple()函数的使用方法：
 
实例 1
 
>>>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)
 
实例 2
 
#!/usr/bin/python
 
aList = [123, 'xyz', 'zara', 'abc'];
aTuple = tuple(aList)
 
print "Tuple elements : ", aTuple
 
以上实例输出结果为：
 
Tuple elements :  (123, 'xyz', 'zara', 'abc')
 
Python type() 函数
 
描述
 
type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
 isinstance() 与 type() 区别：
 type() 不会认为子类是一种父类类型，不考虑继承关系。
 isinstance() 会认为子类是一种父类类型，考虑继承关系。
 如果要判断两个类型是否相同推荐使用 isinstance()。
 
以下是 type() 方法的语法:
 
type(object)
 type(name, bases, dict)
 
参数
 
 
 
name – 类的名称。
 bases – 基类的元组。
 dict – 字典，类内定义的命名空间变量。
 
 
返回值
 
一个参数返回对象类型, 三个参数，返回新的类型对象。
 
以下展示了使用 type 函数的实例：
 
# 一个参数实例
>>> type(1)
<type 'int'>
>>> type('runoob')
<type 'str'>
>>> type([2])
<type 'list'>
>>> type({0:'zero'})
<type 'dict'>
>>> x = 1          
>>> type( x ) == int    # 判断类型是否相等
True
 
# 三个参数
>>> class X(object):
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
>>> X
<class '__main__.X'>
type() 与 isinstance()区别：
class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
 
type() 与 isinstance()区别：
 
class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
 
Python unichr() 函数
 
描述
 
unichr() 函数 和 chr()函数功能基本一样， 只不过是返回 unicode 的字符。
 
以下是 unichr() 方法的语法:
 
unichr(i)
 
参数
 
 
 
i – 可以是10进制也可以是16进制的形式的数字。
 
 
返回值
 
返回 unicode 的字符。
 
以下展示了使用 unichr() 方法的实例：
 
>>>unichr(97)
u'a'
>>> unichr(98)
u'b'
>>> unichr(99)
u'c'
 
Python unicode() 函数
 
unicode()
 
Python vars() 函数
 
描述
 
vars() 函数返回对象object的属性和属性值的字典对象。
 
vars() 函数语法：
 
vars([object])
 
参数
 
 
 
object – 对象
 
 
返回值
 
返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
 
以下实例展示了 vars() 的使用方法：
 
>>>print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class Runoob:
...     a = 1
... 
>>> print(vars(Runoob))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> runoob = Runoob()
>>> print(vars(runoob))
{}
 
Python xrange() 函数
 
描述
 
xrange() 函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。
 
xrange 语法：
 
xrange(stop)
 xrange(start, stop[, step])
 
参数说明：
 
 
 
start: 计数从 start 开始。默认是从 0 开始。例如 xrange(5) 等价于 xrange(0， 5)
 stop: 计数到 stop 结束，但不包括 stop。例如：xrange(0， 5) 是 [0, 1, 2, 3, 4] 没有 5
 step：步长，默认为1。例如：xrange(0， 5) 等价于 xrange(0, 5, 1)
 
 
返回值
 
返回生成器。
 
以下实例展示了 xrange 的使用方法：
 
>>>xrange(8)
xrange(8)
>>> list(xrange(8))
[0, 1, 2, 3, 4, 5, 6, 7]
>>> range(8)                 # range 使用
[0, 1, 2, 3, 4, 5, 6, 7]
>>> xrange(3, 5)
xrange(3, 5)
>>> list(xrange(3,5))
[3, 4]
>>> range(3,5)               # 使用 range
[3, 4]
>>> xrange(0,6,2)
xrange(0, 6, 2)              # 步长为 2
>>> list(xrange(0,6,2))
[0, 2, 4]
>>>
 
Python3 zip() 函数
 
描述
 zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
 我们可以使用 list() 转换来输出列表。
 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
 
zip 语法：
 
zip([iterable, …])
 
参数说明：
 
 
 
iterabl – 一个或多个迭代器;
 
 
返回值
 
返回一个对象。
 
以下实例展示了 zip 的使用方法：
 
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
 
>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>
 
Python import() 函数
 
描述
 
import() 函数用于动态加载类和函数 。
 如果一个模块经常变化就可以使用 import() 来动态载入。
 
import 语法：
 
import(name[, globals[, locals[, fromlist[, level]]]])
 
参数说明：
 
 
 
name – 模块名
 
 
返回值
 
返回元组列表。
 
以下实例展示了 import 的使用方法：
 
a.py 文件代码：
 
#!/usr/bin/env python    
#encoding: utf-8  
 
import os  
 
print ('在 a.py 文件中 %s' % id(os))
 
test.py 文件代码：
 
#!/usr/bin/env python    
#encoding: utf-8  
 
import sys  
__import__('a')        # 导入 a.py 模块
 
执行 test.py 文件，输出结果为：
 
在 a.py 文件中 4394716136
 
Python exec 内置语句
 
描述
 
exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。
 需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。
 
以下是 exec 的语法:
 
exec obj
 
参数
 
 
 
obj – 要执行的表达式。
 
 
返回值
 exec 返回值永远为 None。
 
以下展示了使用 exec 的实例：
 
实例 1
 
>>>exec 'print "Hello World"'
Hello World
# 单行语句字符串
>>> exec "print 'runoob.com'"
runoob.com
 
#  多行语句字符串
>>> exec """for i in range(5):
...   print "iter time: %d" % i
... """
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
 
实例 2
 
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr)
    exec(expr, {'x': 1, 'y': 2})
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
    
func()
 
输出结果：
 
60
33
34
 
其余参考原文
 菜鸟教程

 
用待定系数法求二次函数的解析式
 
【学习目标】
 
1. 能用待定系数法列方程组求二次函数的解析式；
 
2. 经历探索由已知条件特点，灵活选择二次函数三种形式的过程，正确求出二次函数的解析式，
 
二次函数三种形式是可以互相转化的．
 
 【知识点梳理】
 
1、用待定系数法求二次函数解析式
 
① 二次函数解析式常见有以下几种形式 ：
 
(1)一般式：
 

  
 
 
(2)顶点式：
 

  
 
 
(3)交点式：
 

  
 
 
② 确定二次函数解析式常用待定系数法，用待定系数法求二次函数解析式的步骤如下：
 
第一步，
 
设：先设出二次函数的解析式，
 
如 y = ax2 + bx + c 或 y = a(x - h)2 + k 或 y = a(x - x1)(x - x2)，其中 a ≠ 0；
 
第二步，
 
代：根据题中所给条件，代入二次函数的解析式中，得到关于解析式中待定系数的方程(组)；
 
第三步，
 
解：解此方程或方程组，求待定系数；
 
第四步，
 
还原：将求出的待定系数还原到解析式中．
 
注：
 
在设函数的解析式时，一定要根据题中所给条件选择合适的形式：
 
① 当已知抛物线上的三点坐标时，可设函数的解析式为 y = ax2 + bx + c ；
 
② 当已知抛物线的顶点坐标或对称轴或最大值、最小值时．
 
可设函数的解析式为 y = a(x - h)2 + k；
 
③ 当已知抛物线与x轴的两个交点 ( x1，0 )，( x2，0 )时，
 
可设函数的解析式为 y = a(x - x1)(x - x2). 
 
【典型例题】
 
类型一、用待定系数法求二次函数解析式
 
【例题1】已知抛物线 y = ax2 + bx + c (a ≠ 0) 经过 A，B，C 三点，当时 x ≥ 0 时，
 
其图象如图1所示 . 求抛物线的解析式，写出顶点坐标 . 
 

  
 
 
【答案与解析】
 

  
 
 
注：
 
这道题的一个特点是题中没有直接给出所求抛物线经过的点的坐标，需要从图象中获取信息.
 
已知图象上三个点时，通常应用二次函数的一般式列方程求解析式.
 
要特别注意：如果这道题是求 “图象所表示的函数解析式”，那就必须加上自变量的取值范围 x ≥ 0 .
 
【例题2】一条抛物线 y = 1/4 x2 + mx + n 经过点 (0 , 3/2)与 (4 , 3/2).
 
求这条抛物线的解析式 .
 
【答案与解析】
 

  
 
 
注：
 
解析式中的 a 值已经知道，只需求出 m , n 的值 . 
 
已知条件给出了两个点 , 因此可以从二次函数的一般式入手列方程组解答 .
 
还可以从所给两点(0 , 3/2)与 (4 , 3/2)的特征入手：
 
这两点关于抛物线的对称轴对称，因此可知对称轴是直线 x = 2，这样又可以从抛物线的顶点式入手.
 
当点 M(x1, y1)和 N(x2 , y2)都是抛物线上的点时，
 
若 y1 = y2，则对称轴方程为 x = 1/2(x1 + x2)，这一点很重要也很有用.
 
【例题3】已知抛物线 y = ax2 + bx + c (a ≠ 0) 的顶点坐标为(－1，4)，
 
与 x 轴两交点间的距离为 6，求此抛物线的函数关系式 . 
 
【答案与解析】
 
因为顶点坐标为(－1，4)，所以对称轴为 x = -1，
 
又因为抛物线与 x 轴两交点的距离为 6，
 
所以两交点的横坐标分别为：x1 = -1 - 3 ，x2 = -1 + 3， 则两交点的坐标为(-4，0)、(2，0)；
 
求函数的函数关系式可有两种方法：
 

  
 
 
注：在求函数的解析式时，要根据题中所给条件选择合适的形式.
 
类型二、用待定系数法解题
 
【例题4】已知二次函数的图象如图所示，根据图中的数据，
 
(1)求二次函数的解析式；
 
(2)设此二次函数的顶点为 P，求 △ABP 的面积．
 

  
 
 
【答案与解析】 
 

  
 
 

  
 
 
注：
 
此题主要考查二次函数图象的性质，对称轴及顶点坐标，
 
另外巧妙设函数的解析式，从而来减少计算量.