Available Python Modules
Interested in helping us improve these docs? Let us know!
-
builtins
abs
Help on built-in function abs in module __builtin__: abs(...) abs(number) -> number Return the absolute value of the argument.
allHelp on built-in function all in module __builtin__: all(...) all(iterable) -> bool Return True if bool(x) is True for all values x in the iterable. If the iterable is empty, return True.
anyHelp on built-in function any in module __builtin__: any(...) any(iterable) -> bool Return True if bool(x) is True for any x in the iterable. If the iterable is empty, return False.
binHelp on built-in function bin in module __builtin__: bin(...) bin(number) -> string Return the binary representation of an integer or long integer.
chrHelp on built-in function chr in module __builtin__: chr(...) chr(i) -> character Return a string of one character with ordinal i; 0 <= i < 256.
dirHelp on built-in function dir in module __builtin__: dir(...) dir([object]) -> list of strings If called without an argument, return the names in the current scope. Else, return an alphabetized list of names comprising (some of) the attributes of the given object, and of attributes reachable from it. If the object supplies a method named __dir__, it will be used; otherwise the default dir() logic is used and returns: for a module object: the module's attributes. for a class object: its attributes, and recursively the attributes of its bases. for any other object: its attributes, its class's attributes, and recursively the attributes of its class's base classes.
filterHelp on built-in function filter in module __builtin__: filter(...) filter(function or None, sequence) -> list, tuple, or string Return those items of sequence for which function(item) is true. If function is None, return the items that are true. If sequence is a tuple or string, return the same type, else return a list.
getattrHelp on built-in function getattr in module __builtin__: getattr(...) getattr(object, name[, default]) -> value Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn't exist; without it, an exception is raised in that case.
globalsHelp on built-in function globals in module __builtin__: globals(...) globals() -> dictionary Return the dictionary containing the current scope's global variables.
hasattrHelp on built-in function hasattr in module __builtin__: hasattr(...) hasattr(object, name) -> bool Return whether the object has an attribute with the given name. (This is done by calling getattr(object, name) and catching exceptions.)
hashHelp on built-in function hash in module __builtin__: hash(...) hash(object) -> integer Return a hash value for the object. Two objects with the same value have the same hash value. The reverse is not necessarily true, but likely.
hexHelp on built-in function hex in module __builtin__: hex(...) hex(number) -> string Return the hexadecimal representation of an integer or long integer.
inputHelp on built-in function input in module __builtin__: input(...) input([prompt]) -> value Equivalent to eval(raw_input(prompt)).
isinstanceHelp on built-in function isinstance in module __builtin__: isinstance(...) isinstance(object, class-or-type-or-tuple) -> bool Return whether an object is an instance of a class or of a subclass thereof. With a type as second argument, return whether that is the object's type. The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for isinstance(x, A) or isinstance(x, B) or ... (etc.).
issubclassHelp on built-in function issubclass in module __builtin__: issubclass(...) issubclass(C, B) -> bool Return whether class C is a subclass (i.e., a derived class) of class B. When using a tuple as the second argument issubclass(X, (A, B, ...)), is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).
lenHelp on built-in function len in module __builtin__: len(...) len(object) -> integer Return the number of items of a sequence or mapping.
mapHelp on built-in function map in module __builtin__: map(...) map(function, sequence[, sequence, ...]) -> list Return a list of the results of applying the function to the items of the argument sequence(s). If more than one sequence is given, the function is called with an argument list consisting of the corresponding item of each sequence, substituting None for missing values when not all sequences have the same length. If the function is None, return a list of the items of the sequence (or a list of tuples if more than one sequence).
maxHelp on built-in function max in module __builtin__: max(...) max(iterable[, key=func]) -> value max(a, b, c, ...[, key=func]) -> value With a single iterable argument, return its largest item. With two or more arguments, return the largest argument.
minHelp on built-in function min in module __builtin__: min(...) min(iterable[, key=func]) -> value min(a, b, c, ...[, key=func]) -> value With a single iterable argument, return its smallest item. With two or more arguments, return the smallest argument.
octHelp on built-in function oct in module __builtin__: oct(...) oct(number) -> string Return the octal representation of an integer or long integer.
openHelp on built-in function open in module __builtin__: open(...) open(name[, mode[, buffering]]) -> file object Open a file using the file() type, returns a file object. This is the preferred way to open a file. See file.__doc__ for further information.
ordHelp on built-in function ord in module __builtin__: ord(...) ord(c) -> integer Return the integer ordinal of a one-character string.
powHelp on built-in function pow in module __builtin__: pow(...) pow(x, y[, z]) -> number With two arguments, equivalent to x**y. With three arguments, equivalent to (x**y) % z, but may be more efficient (e.g. for longs).
quitHelp on Quitter in module site object: quit = class Quitter(__builtin__.object) | Methods defined here: | | __call__(self, code=None) | | __init__(self, name) | | __repr__(self) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined)
rangeHelp on built-in function range in module __builtin__: range(...) range(stop) -> list of integers range(start, stop[, step]) -> list of integers Return a list containing an arithmetic progression of integers. range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0. When step is given, it specifies the increment (or decrement). For example, range(4) returns [0, 1, 2, 3]. The end point is omitted! These are exactly the valid indices for a list of 4 elements.
raw_inputHelp on built-in function raw_input in module __builtin__: raw_input(...) raw_input([prompt]) -> string Read a string from standard input. The trailing newline is stripped. If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError. On Unix, GNU readline is used if enabled. The prompt string, if given, is printed without a trailing newline before reading.
reduceHelp on built-in function reduce in module __builtin__: reduce(...) reduce(function, sequence[, initial]) -> value Apply a function of two arguments cumulatively to the items of a sequence, from left to right, so as to reduce the sequence to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). If initial is present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty.
reprHelp on module repr: NAME repr - Redo the builtin repr() (representation) but with limits on most sizes. FILE /usr/lib/python2.7/repr.py MODULE DOCS http://docs.python.org/library/repr CLASSES Repr class Repr | Methods defined here: | | __init__(self) | | repr(self, x) | | repr1(self, x, level) | | repr_array(self, x, level) | | repr_deque(self, x, level) | | repr_dict(self, x, level) | | repr_frozenset(self, x, level) | | repr_instance(self, x, level) | | repr_list(self, x, level) | | repr_long(self, x, level) | | repr_set(self, x, level) | | repr_str(self, x, level) | | repr_tuple(self, x, level) FUNCTIONS repr(self, x) method of Repr instance DATA __all__ = ['Repr', 'repr']
roundHelp on built-in function round in module __builtin__: round(...) round(number[, ndigits]) -> floating point number Round a number to a given precision in decimal digits (default 0 digits). This always returns a floating point number. Precision may be negative.
sortedHelp on built-in function sorted in module __builtin__: sorted(...) sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
sumHelp on built-in function sum in module __builtin__: sum(...) sum(sequence[, start]) -> value Return the sum of a sequence of numbers (NOT strings) plus the value of parameter 'start' (which defaults to 0). When the sequence is empty, return start.
xrangeHelp on class xrange in module __builtin__: class xrange(object) | xrange(stop) -> xrange object | xrange(start, stop[, step]) -> xrange object | | Like range(), but instead of returning a list, returns an object that | generates the numbers in the range on demand. For looping, this is | slightly faster than range() and more memory efficient. | | Methods defined here: | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __iter__(...) | x.__iter__() <==> iter(x) | | __len__(...) | x.__len__() <==> len(x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __reversed__(...) | Returns a reverse iterator. | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T
zipHelp on built-in function zip in module __builtin__: zip(...) zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)] Return a list of tuples, where each tuple contains the i-th element from each of the argument sequences. The returned list is truncated in length to the length of the shortest argument sequence.
-
math
math.acos
Help on built-in function acos in math: math.acos = acos(...) acos(x) Return the arc cosine (measured in radians) of x.
math.acoshHelp on built-in function acosh in math: math.acosh = acosh(...) acosh(x) Return the hyperbolic arc cosine (measured in radians) of x.
math.asinHelp on built-in function asin in math: math.asin = asin(...) asin(x) Return the arc sine (measured in radians) of x.
math.asinhHelp on built-in function asinh in math: math.asinh = asinh(...) asinh(x) Return the hyperbolic arc sine (measured in radians) of x.
math.atanHelp on built-in function atan in math: math.atan = atan(...) atan(x) Return the arc tangent (measured in radians) of x.
math.atan2Help on built-in function atan2 in math: math.atan2 = atan2(...) atan2(y, x) Return the arc tangent (measured in radians) of y/x. Unlike atan(y/x), the signs of both x and y are considered.
math.atanhHelp on built-in function atanh in math: math.atanh = atanh(...) atanh(x) Return the hyperbolic arc tangent (measured in radians) of x.
math.ceilHelp on built-in function ceil in math: math.ceil = ceil(...) ceil(x) Return the ceiling of x as a float. This is the smallest integral value >= x.
math.cosHelp on built-in function cos in math: math.cos = cos(...) cos(x) Return the cosine of x (measured in radians).
math.coshHelp on built-in function cosh in math: math.cosh = cosh(...) cosh(x) Return the hyperbolic cosine of x.
math.degreesHelp on built-in function degrees in math: math.degrees = degrees(...) degrees(x) Convert angle x from radians to degrees.
math.expHelp on built-in function exp in math: math.exp = exp(...) exp(x) Return e raised to the power of x.
math.fabsHelp on built-in function fabs in math: math.fabs = fabs(...) fabs(x) Return the absolute value of the float x.
math.factorialHelp on built-in function factorial in math: math.factorial = factorial(...) factorial(x) -> Integral Find x!. Raise a ValueError if x is negative or non-integral.
math.floorHelp on built-in function floor in math: math.floor = floor(...) floor(x) Return the floor of x as a float. This is the largest integral value <= x.
math.hypotHelp on built-in function hypot in math: math.hypot = hypot(...) hypot(x, y) Return the Euclidean distance, sqrt(x*x + y*y).
math.logHelp on built-in function log in math: math.log = log(...) log(x[, base]) Return the logarithm of x to the given base. If the base not specified, returns the natural logarithm (base e) of x.
math.log10Help on built-in function log10 in math: math.log10 = log10(...) log10(x) Return the base 10 logarithm of x.
math.powHelp on built-in function pow in math: math.pow = pow(...) pow(x, y) Return x**y (x to the power of y).
math.radiansHelp on built-in function radians in math: math.radians = radians(...) radians(x) Convert angle x from degrees to radians.
math.sinHelp on built-in function sin in math: math.sin = sin(...) sin(x) Return the sine of x (measured in radians).
math.sinhHelp on built-in function sinh in math: math.sinh = sinh(...) sinh(x) Return the hyperbolic sine of x.
math.sqrtHelp on built-in function sqrt in math: math.sqrt = sqrt(...) sqrt(x) Return the square root of x.
math.tanHelp on built-in function tan in math: math.tan = tan(...) tan(x) Return the tangent of x (measured in radians).
math.tanhHelp on built-in function tanh in math: math.tanh = tanh(...) tanh(x) Return the hyperbolic tangent of x.
math.truncHelp on built-in function trunc in math: math.trunc = trunc(...) trunc(x:Real) -> Integral Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.
-
matplotlib.pyplot
matplotlib.pyplot.axis
Help on function axis in matplotlib.pyplot: matplotlib.pyplot.axis = axis(*v, **kwargs) Convenience method to get or set axis properties. Calling with no arguments:: >>> axis() returns the current axes limits ``[xmin, xmax, ymin, ymax]``.:: >>> axis(v) sets the min and max of the x and y axes, with ``v = [xmin, xmax, ymin, ymax]``.:: >>> axis('off') turns off the axis lines and labels.:: >>> axis('equal') changes limits of *x* or *y* axis so that equal increments of *x* and *y* have the same length; a circle is circular.:: >>> axis('scaled') achieves the same result by changing the dimensions of the plot box instead of the axis data limits.:: >>> axis('tight') changes *x* and *y* axis limits such that all data is shown. If all data is already shown, it will move it to the center of the figure without modifying (*xmax* - *xmin*) or (*ymax* - *ymin*). Note this is slightly different than in MATLAB.:: >>> axis('image') is 'scaled' with the axis limits equal to the data limits.:: >>> axis('auto') and:: >>> axis('normal') are deprecated. They restore default behavior; axis limits are automatically scaled to make the data fit comfortably within the plot box. if ``len(*v)==0``, you can pass in *xmin*, *xmax*, *ymin*, *ymax* as kwargs selectively to alter just those limits without changing the others. The xmin, xmax, ymin, ymax tuple is returned .. seealso:: :func:`xlim`, :func:`ylim` For setting the x- and y-limits individually.
matplotlib.pyplot.clfHelp on function clf in matplotlib.pyplot: matplotlib.pyplot.clf = clf() Clear the current figure.
matplotlib.pyplot.plotHelp on function plot in matplotlib.pyplot: matplotlib.pyplot.plot = plot(*args, **kwargs) Plot lines and/or markers to the :class:`~matplotlib.axes.Axes`. *args* is a variable length argument, allowing for multiple *x*, *y* pairs with an optional format string. For example, each of the following is legal:: plot(x, y) # plot x and y using default line style and color plot(x, y, 'bo') # plot x and y using blue circle markers plot(y) # plot y using x as index array 0..N-1 plot(y, 'r+') # ditto, but with red plusses If *x* and/or *y* is 2-dimensional, then the corresponding columns will be plotted. An arbitrary number of *x*, *y*, *fmt* groups can be specified, as in:: a.plot(x1, y1, 'g^', x2, y2, 'g-') Return value is a list of lines that were added. By default, each line is assigned a different color specified by a 'color cycle'. To change this behavior, you can edit the axes.color_cycle rcParam. Alternatively, you can use :meth:`~matplotlib.axes.Axes.set_default_color_cycle`. The following format string characters are accepted to control the line style or marker: ================ =============================== character description ================ =============================== ``'-'`` solid line style ``'--'`` dashed line style ``'-.'`` dash-dot line style ``':'`` dotted line style ``'.'`` point marker ``','`` pixel marker ``'o'`` circle marker ``'v'`` triangle_down marker ``'^'`` triangle_up marker ``'<'`` triangle_left marker ``'>'`` triangle_right marker ``'1'`` tri_down marker ``'2'`` tri_up marker ``'3'`` tri_left marker ``'4'`` tri_right marker ``'s'`` square marker ``'p'`` pentagon marker ``'*'`` star marker ``'h'`` hexagon1 marker ``'H'`` hexagon2 marker ``'+'`` plus marker ``'x'`` x marker ``'D'`` diamond marker ``'d'`` thin_diamond marker ``'|'`` vline marker ``'_'`` hline marker ================ =============================== The following color abbreviations are supported: ========== ======== character color ========== ======== 'b' blue 'g' green 'r' red 'c' cyan 'm' magenta 'y' yellow 'k' black 'w' white ========== ======== In addition, you can specify colors in many weird and wonderful ways, including full names (``'green'``), hex strings (``'#008000'``), RGB or RGBA tuples (``(0,1,0,1)``) or grayscale intensities as a string (``'0.8'``). Of these, the string specifications can be used in place of a ``fmt`` group, but the tuple forms can be used only as ``kwargs``. Line styles and colors are combined in a single format string, as in ``'bo'`` for blue circles. The *kwargs* can be used to set line properties (any property that has a ``set_*`` method). You can use this to set a line label (for auto legends), linewidth, anitialising, marker face color, etc. Here is an example:: plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2) plot([1,2,3], [1,4,9], 'rs', label='line 2') axis([0, 4, 0, 10]) legend() If you make multiple lines with one plot command, the kwargs apply to all those lines, e.g.:: plot(x1, y1, x2, y2, antialised=False) Neither line will be antialiased. You do not need to use format strings, which are just abbreviations. All of the line properties can be controlled by keyword arguments. For example, you can set the color, marker, linestyle, and markercolor with:: plot(x, y, color='green', linestyle='dashed', marker='o', markerfacecolor='blue', markersize=12). See :class:`~matplotlib.lines.Line2D` for details. The kwargs are :class:`~matplotlib.lines.Line2D` properties: agg_filter: unknown alpha: float (0.0 transparent through 1.0 opaque) animated: [True | False] antialiased or aa: [True | False] axes: an :class:`~matplotlib.axes.Axes` instance clip_box: a :class:`matplotlib.transforms.Bbox` instance clip_on: [True | False] clip_path: [ (:class:`~matplotlib.path.Path`, :class:`~matplotlib.transforms.Transform`) | :class:`~matplotlib.patches.Patch` | None ] color or c: any matplotlib color contains: a callable function dash_capstyle: ['butt' | 'round' | 'projecting'] dash_joinstyle: ['miter' | 'round' | 'bevel'] dashes: sequence of on/off ink in points drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] figure: a :class:`matplotlib.figure.Figure` instance fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] gid: an id string label: string or anything printable with '%s' conversion. linestyle or ls: [``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``] and any drawstyle in combination with a linestyle, e.g., ``'steps--'``. linewidth or lw: float value in points lod: [True | False] marker: unknown markeredgecolor or mec: any matplotlib color markeredgewidth or mew: float value in points markerfacecolor or mfc: any matplotlib color markerfacecoloralt or mfcalt: any matplotlib color markersize or ms: float markevery: None | integer | (startind, stride) path_effects: unknown picker: float distance in points or callable pick function ``fn(artist, event)`` pickradius: float distance in points rasterized: [True | False | None] sketch_params: unknown snap: unknown solid_capstyle: ['butt' | 'round' | 'projecting'] solid_joinstyle: ['miter' | 'round' | 'bevel'] transform: a :class:`matplotlib.transforms.Transform` instance url: a url string visible: [True | False] xdata: 1D array ydata: 1D array zorder: any number kwargs *scalex* and *scaley*, if defined, are passed on to :meth:`~matplotlib.axes.Axes.autoscale_view` to determine whether the *x* and *y* axes are autoscaled; the default is *True*. Additional kwargs: hold = [True|False] overrides default hold state
matplotlib.pyplot.showHelp on function show in matplotlib.pyplot: matplotlib.pyplot.show = show(*args, **kw) Display a figure. When running in ipython with its pylab mode, display all figures and return to the ipython prompt. In non-interactive mode, display all figures and block until the figures have been closed; in interactive mode it has no effect unless figures were created prior to a change from non-interactive to interactive mode (not recommended). In that case it displays the figures but does not block. A single experimental keyword argument, *block*, may be set to True or False to override the blocking behavior described above.
matplotlib.pyplot.titleHelp on function title in matplotlib.pyplot: matplotlib.pyplot.title = title(s, *args, **kwargs) Set a title of the current axes. Set one of the three available axes titles. The available titles are positioned above the axes in the center, flush with the left edge, and flush with the right edge. Parameters ---------- label : str Text to use for the title fontdict : dict A dictionary controlling the appearance of the title text, the default `fontdict` is: {'fontsize': rcParams['axes.titlesize'], 'verticalalignment': 'baseline', 'horizontalalignment': loc} loc : {'center', 'left', 'right'}, str, optional Which title to set, defaults to 'center' Returns ------- text : :class:`~matplotlib.text.Text` The matplotlib text instance representing the title Other parameters ---------------- Other keyword arguments are text properties, see :class:`~matplotlib.text.Text` for a list of valid text properties. See also -------- See :func:`~matplotlib.pyplot.text` for adding text to the current axes
matplotlib.pyplot.xlabelHelp on function xlabel in matplotlib.pyplot: matplotlib.pyplot.xlabel = xlabel(s, *args, **kwargs) Set the *x* axis label of the current axis. Default override is:: override = { 'fontsize' : 'small', 'verticalalignment' : 'top', 'horizontalalignment' : 'center' } .. seealso:: :func:`~matplotlib.pyplot.text` For information on how override and the optional args work
matplotlib.pyplot.ylabelHelp on function ylabel in matplotlib.pyplot: matplotlib.pyplot.ylabel = ylabel(s, *args, **kwargs) Set the *y* axis label of the current axis. Defaults override is:: override = { 'fontsize' : 'small', 'verticalalignment' : 'center', 'horizontalalignment' : 'right', 'rotation'='vertical' : } .. seealso:: :func:`~matplotlib.pyplot.text` For information on how override and the optional args work.
-
numpy
numpy.arccos
arccos(x[, out]) Trigonometric inverse cosine, element-wise. The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``. Parameters ---------- x : array_like `x`-coordinate on the unit circle. For real arguments, the domain is [-1, 1]. out : ndarray, optional Array of the same shape as `a`, to store results in. See `doc.ufuncs` (Section "Output arguments") for more details. Returns ------- angle : ndarray The angle of the ray intersecting the unit circle at the given `x`-coordinate in radians [0, pi]. If `x` is a scalar then a scalar is returned, otherwise an array of the same shape as `x` is returned. See Also -------- cos, arctan, arcsin, emath.arccos Notes ----- `arccos` is a multivalued function: for each `x` there are infinitely many numbers `z` such that `cos(z) = x`. The convention is to return the angle `z` whose real part lies in `[0, pi]`. For real-valued input data types, `arccos` always returns real output. For each value that cannot be expressed as a real number or infinity, it yields ``nan`` and sets the `invalid` floating point error flag. For complex-valued input, `arccos` is a complex analytic function that has branch cuts `[-inf, -1]` and `[1, inf]` and is continuous from above on the former and from below on the latter. The inverse `cos` is also known as `acos` or cos^-1. References ---------- M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", 10th printing, 1964, pp. 79. http://www.math.sfu.ca/~cbm/aands/ Examples -------- We expect the arccos of 1 to be 0, and of -1 to be pi: >>> np.arccos([1, -1]) array([ 0. , 3.14159265]) Plot arccos: >>> import matplotlib.pyplot as plt >>> x = np.linspace(-1, 1, num=100) >>> plt.plot(x, np.arccos(x)) >>> plt.axis('tight') >>> plt.show()
numpy.arcsinarcsin(x[, out]) Inverse sine, element-wise. Parameters ---------- x : array_like `y`-coordinate on the unit circle. out : ndarray, optional Array of the same shape as `x`, in which to store the results. See `doc.ufuncs` (Section "Output arguments") for more details. Returns ------- angle : ndarray The inverse sine of each element in `x`, in radians and in the closed interval ``[-pi/2, pi/2]``. If `x` is a scalar, a scalar is returned, otherwise an array. See Also -------- sin, cos, arccos, tan, arctan, arctan2, emath.arcsin Notes ----- `arcsin` is a multivalued function: for each `x` there are infinitely many numbers `z` such that :math:`sin(z) = x`. The convention is to return the angle `z` whose real part lies in [-pi/2, pi/2]. For real-valued input data types, *arcsin* always returns real output. For each value that cannot be expressed as a real number or infinity, it yields ``nan`` and sets the `invalid` floating point error flag. For complex-valued input, `arcsin` is a complex analytic function that has, by convention, the branch cuts [-inf, -1] and [1, inf] and is continuous from above on the former and from below on the latter. The inverse sine is also known as `asin` or sin^{-1}. References ---------- Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, 10th printing, New York: Dover, 1964, pp. 79ff. http://www.math.sfu.ca/~cbm/aands/ Examples -------- >>> np.arcsin(1) # pi/2 1.5707963267948966 >>> np.arcsin(-1) # -pi/2 -1.5707963267948966 >>> np.arcsin(0) 0.0
numpy.arctanarctan(x[, out]) Trigonometric inverse tangent, element-wise. The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. Parameters ---------- x : array_like Input values. `arctan` is applied to each element of `x`. Returns ------- out : ndarray Out has the same shape as `x`. Its real part is in ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). It is a scalar if `x` is a scalar. See Also -------- arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) and the positive `x`-axis. angle : Argument of complex values. Notes ----- `arctan` is a multi-valued function: for each `x` there are infinitely many numbers `z` such that tan(`z`) = `x`. The convention is to return the angle `z` whose real part lies in [-pi/2, pi/2]. For real-valued input data types, `arctan` always returns real output. For each value that cannot be expressed as a real number or infinity, it yields ``nan`` and sets the `invalid` floating point error flag. For complex-valued input, `arctan` is a complex analytic function that has [`1j, infj`] and [`-1j, -infj`] as branch cuts, and is continuous from the left on the former and from the right on the latter. The inverse tangent is also known as `atan` or tan^{-1}. References ---------- Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, 10th printing, New York: Dover, 1964, pp. 79. http://www.math.sfu.ca/~cbm/aands/ Examples -------- We expect the arctan of 0 to be 0, and of 1 to be pi/4: >>> np.arctan([0, 1]) array([ 0. , 0.78539816]) >>> np.pi/4 0.78539816339744828 Plot arctan: >>> import matplotlib.pyplot as plt >>> x = np.linspace(-10, 10) >>> plt.plot(x, np.arctan(x)) >>> plt.axis('tight') >>> plt.show()
numpy.arctan2arctan2(x1, x2[, out]) Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is the signed angle in radians between the ray ending at the origin and passing through the point (1,0), and the ray ending at the origin and passing through the point (`x2`, `x1`). (Note the role reversal: the "`y`-coordinate" is the first function parameter, the "`x`-coordinate" is the second.) By IEEE convention, this function is defined for `x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see Notes for specific values). This function is not defined for complex-valued arguments; for the so-called argument of complex values, use `angle`. Parameters ---------- x1 : array_like, real-valued `y`-coordinates. x2 : array_like, real-valued `x`-coordinates. `x2` must be broadcastable to match the shape of `x1` or vice versa. Returns ------- angle : ndarray Array of angles in radians, in the range ``[-pi, pi]``. See Also -------- arctan, tan, angle Notes ----- *arctan2* is identical to the `atan2` function of the underlying C library. The following special values are defined in the C standard: [1]_ ====== ====== ================ `x1` `x2` `arctan2(x1,x2)` ====== ====== ================ +/- 0 +0 +/- 0 +/- 0 -0 +/- pi > 0 +/-inf +0 / +pi < 0 +/-inf -0 / -pi +/-inf +inf +/- (pi/4) +/-inf -inf +/- (3*pi/4) ====== ====== ================ Note that +0 and -0 are distinct floating point numbers, as are +inf and -inf. References ---------- .. [1] ISO/IEC standard 9899:1999, "Programming language C." Examples -------- Consider four points in different quadrants: >>> x = np.array([-1, +1, +1, -1]) >>> y = np.array([-1, -1, +1, +1]) >>> np.arctan2(y, x) * 180 / np.pi array([-135., -45., 45., 135.]) Note the order of the parameters. `arctan2` is defined also when `x2` = 0 and at several other special points, obtaining values in the range ``[-pi, pi]``: >>> np.arctan2([1., -1.], [0., 0.]) array([ 1.57079633, -1.57079633]) >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) array([ 0. , 3.14159265, 0.78539816])
numpy.arrayHelp on built-in function array in numpy: numpy.array = array(...) array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0) Create an array. Parameters ---------- object : array_like An array, any object exposing the array interface, an object whose __array__ method returns an array, or any (nested) sequence. dtype : data-type, optional The desired data-type for the array. If not given, then the type will be determined as the minimum type required to hold the objects in the sequence. This argument can only be used to 'upcast' the array. For downcasting, use the .astype(t) method. copy : bool, optional If true (default), then the object is copied. Otherwise, a copy will only be made if __array__ returns a copy, if obj is a nested sequence, or if a copy is needed to satisfy any of the other requirements (`dtype`, `order`, etc.). order : {'C', 'F', 'A'}, optional Specify the order of the array. If order is 'C' (default), then the array will be in C-contiguous order (last-index varies the fastest). If order is 'F', then the returned array will be in Fortran-contiguous order (first-index varies the fastest). If order is 'A', then the returned array may be in any order (either C-, Fortran-contiguous, or even discontiguous). subok : bool, optional If True, then sub-classes will be passed-through, otherwise the returned array will be forced to be a base-class array (default). ndmin : int, optional Specifies the minimum number of dimensions that the resulting array should have. Ones will be pre-pended to the shape as needed to meet this requirement. Returns ------- out : ndarray An array object satisfying the specified requirements. See Also -------- empty, empty_like, zeros, zeros_like, ones, ones_like, fill Examples -------- >>> np.array([1, 2, 3]) array([1, 2, 3]) Upcasting: >>> np.array([1, 2, 3.0]) array([ 1., 2., 3.]) More than one dimension: >>> np.array([[1, 2], [3, 4]]) array([[1, 2], [3, 4]]) Minimum dimensions 2: >>> np.array([1, 2, 3], ndmin=2) array([[1, 2, 3]]) Type provided: >>> np.array([1, 2, 3], dtype=complex) array([ 1.+0.j, 2.+0.j, 3.+0.j]) Data-type consisting of more than one element: >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')]) >>> x['a'] array([1, 3]) Creating an array from sub-classes: >>> np.array(np.mat('1 2; 3 4')) array([[1, 2], [3, 4]]) >>> np.array(np.mat('1 2; 3 4'), subok=True) matrix([[1, 2], [3, 4]])
numpy.asarrayHelp on function asarray in numpy: numpy.asarray = asarray(a, dtype=None, order=None) Convert the input to an array. Parameters ---------- a : array_like Input data, in any form that can be converted to an array. This includes lists, lists of tuples, tuples, tuples of tuples, tuples of lists and ndarrays. dtype : data-type, optional By default, the data-type is inferred from the input data. order : {'C', 'F'}, optional Whether to use row-major ('C') or column-major ('F' for FORTRAN) memory representation. Defaults to 'C'. Returns ------- out : ndarray Array interpretation of `a`. No copy is performed if the input is already an ndarray. If `a` is a subclass of ndarray, a base class ndarray is returned. See Also -------- asanyarray : Similar function which passes through subclasses. ascontiguousarray : Convert input to a contiguous array. asfarray : Convert input to a floating point ndarray. asfortranarray : Convert input to an ndarray with column-major memory order. asarray_chkfinite : Similar function which checks input for NaNs and Infs. fromiter : Create an array from an iterator. fromfunction : Construct an array by executing a function on grid positions. Examples -------- Convert a list into an array: >>> a = [1, 2] >>> np.asarray(a) array([1, 2]) Existing arrays are not copied: >>> a = np.array([1, 2]) >>> np.asarray(a) is a True If `dtype` is set, array is copied only if dtype does not match: >>> a = np.array([1, 2], dtype=np.float32) >>> np.asarray(a, dtype=np.float32) is a True >>> np.asarray(a, dtype=np.float64) is a False Contrary to `asanyarray`, ndarray subclasses are not passed through: >>> issubclass(np.matrix, np.ndarray) True >>> a = np.matrix([[1, 2]]) >>> np.asarray(a) is a False >>> np.asanyarray(a) is a True
numpy.copyHelp on function copy in numpy: numpy.copy = copy(a, order='K') Return an array copy of the given object. Parameters ---------- a : array_like Input data. order : {'C', 'F', 'A', 'K'}, optional Controls the memory layout of the copy. 'C' means C-order, 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, 'C' otherwise. 'K' means match the layout of `a` as closely as possible. (Note that this function and :meth:ndarray.copy are very similar, but have different default values for their order= arguments.) Returns ------- arr : ndarray Array interpretation of `a`. Notes ----- This is equivalent to >>> np.array(a, copy=True) #doctest: +SKIP Examples -------- Create an array x, with a reference y and a copy z: >>> x = np.array([1, 2, 3]) >>> y = x >>> z = np.copy(x) Note that, when we modify x, y changes, but not z: >>> x[0] = 10 >>> x[0] == y[0] True >>> x[0] == z[0] False
numpy.coscos(x[, out]) Cosine element-wise. Parameters ---------- x : array_like Input array in radians. out : ndarray, optional Output array of same shape as `x`. Returns ------- y : ndarray The corresponding cosine values. Raises ------ ValueError: invalid return array shape if `out` is provided and `out.shape` != `x.shape` (See Examples) Notes ----- If `out` is provided, the function writes the result into it, and returns a reference to `out`. (See Examples) References ---------- M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972. Examples -------- >>> np.cos(np.array([0, np.pi/2, np.pi])) array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) >>> >>> # Example of providing the optional output parameter >>> out2 = np.cos([0.1], out1) >>> out2 is out1 True >>> >>> # Example of ValueError due to provision of shape mis-matched `out` >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: invalid return array shape
numpy.coshcosh(x[, out]) Hyperbolic cosine, element-wise. Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. Parameters ---------- x : array_like Input array. Returns ------- out : ndarray Output array of same shape as `x`. Examples -------- >>> np.cosh(0) 1.0 The hyperbolic cosine describes the shape of a hanging cable: >>> import matplotlib.pyplot as plt >>> x = np.linspace(-4, 4, 1000) >>> plt.plot(x, np.cosh(x)) >>> plt.show()
numpy.dotHelp on built-in function dot in numpy: numpy.dot = dot(...) dot(a, b, out=None) Dot product of two arrays. For 2-D arrays it is equivalent to matrix multiplication, and for 1-D arrays to inner product of vectors (without complex conjugation). For N dimensions it is a sum product over the last axis of `a` and the second-to-last of `b`:: dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]) Parameters ---------- a : array_like First argument. b : array_like Second argument. out : ndarray, optional Output argument. This must have the exact kind that would be returned if it was not used. In particular, it must have the right type, must be C-contiguous, and its dtype must be the dtype that would be returned for `dot(a,b)`. This is a performance feature. Therefore, if these conditions are not met, an exception is raised, instead of attempting to be flexible. Returns ------- output : ndarray Returns the dot product of `a` and `b`. If `a` and `b` are both scalars or both 1-D arrays then a scalar is returned; otherwise an array is returned. If `out` is given, then it is returned. Raises ------ ValueError If the last dimension of `a` is not the same size as the second-to-last dimension of `b`. See Also -------- vdot : Complex-conjugating dot product. tensordot : Sum products over arbitrary axes. einsum : Einstein summation convention. Examples -------- >>> np.dot(3, 4) 12 Neither argument is complex-conjugated: >>> np.dot([2j, 3j], [2j, 3j]) (-13+0j) For 2-D arrays it's the matrix product: >>> a = [[1, 0], [0, 1]] >>> b = [[4, 1], [2, 2]] >>> np.dot(a, b) array([[4, 1], [2, 2]]) >>> a = np.arange(3*4*5*6).reshape((3,4,5,6)) >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) >>> np.dot(a, b)[2,3,2,1,2,2] 499128 >>> sum(a[2,3,2,:] * b[1,2,:,2]) 499128
numpy.emptyHelp on built-in function empty in numpy: numpy.empty = empty(...) empty(shape, dtype=float, order='C') Return a new array of given shape and type, without initializing entries. Parameters ---------- shape : int or tuple of int Shape of the empty array dtype : data-type, optional Desired output data-type. order : {'C', 'F'}, optional Whether to store multi-dimensional data in C (row-major) or Fortran (column-major) order in memory. See Also -------- empty_like, zeros, ones Notes ----- `empty`, unlike `zeros`, does not set the array values to zero, and may therefore be marginally faster. On the other hand, it requires the user to manually set all the values in the array, and should be used with caution. Examples -------- >>> np.empty([2, 2]) array([[ -9.74499359e+001, 6.69583040e-309], [ 2.13182611e-314, 3.06959433e-309]]) #random >>> np.empty([2, 2], dtype=int) array([[-1073741821, -1067949133], [ 496041986, 19249760]]) #random
numpy.empty_likeHelp on built-in function empty_like in numpy: numpy.empty_like = empty_like(...) empty_like(a, dtype=None, order='K', subok=True) Return a new array with the same shape and type as a given array. Parameters ---------- a : array_like The shape and data-type of `a` define these same attributes of the returned array. dtype : data-type, optional .. versionadded:: 1.6.0 Overrides the data type of the result. order : {'C', 'F', 'A', or 'K'}, optional .. versionadded:: 1.6.0 Overrides the memory layout of the result. 'C' means C-order, 'F' means F-order, 'A' means 'F' if ``a`` is Fortran contiguous, 'C' otherwise. 'K' means match the layout of ``a`` as closely as possible. subok : bool, optional. If True, then the newly created array will use the sub-class type of 'a', otherwise it will be a base-class array. Defaults to True. Returns ------- out : ndarray Array of uninitialized (arbitrary) data with the same shape and type as `a`. See Also -------- ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. empty : Return a new uninitialized array. ones : Return a new array setting values to one. zeros : Return a new array setting values to zero. Notes ----- This function does *not* initialize the returned array; to do that use `zeros_like` or `ones_like` instead. It may be marginally faster than the functions that do set the array values. Examples -------- >>> a = ([1,2,3], [4,5,6]) # a is array-like >>> np.empty_like(a) array([[-1073741821, -1073741821, 3], #random [ 0, 0, -1073741821]]) >>> a = np.array([[1., 2., 3.],[4.,5.,6.]]) >>> np.empty_like(a) array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000],#random [ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]])
numpy.fillno Python documentation found for 'numpy.fill'
numpy.fullHelp on function full in numpy: numpy.full = full(shape, fill_value, dtype=None, order='C') Return a new array of given shape and type, filled with `fill_value`. Parameters ---------- shape : int or sequence of ints Shape of the new array, e.g., ``(2, 3)`` or ``2``. fill_value : scalar Fill value. dtype : data-type, optional The desired data-type for the array, e.g., `numpy.int8`. Default is is chosen as `np.array(fill_value).dtype`. order : {'C', 'F'}, optional Whether to store multidimensional data in C- or Fortran-contiguous (row- or column-wise) order in memory. Returns ------- out : ndarray Array of `fill_value` with the given shape, dtype, and order. See Also -------- zeros_like : Return an array of zeros with shape and type of input. ones_like : Return an array of ones with shape and type of input. empty_like : Return an empty array with shape and type of input. full_like : Fill an array with shape and type of input. zeros : Return a new array setting values to zero. ones : Return a new array setting values to one. empty : Return a new uninitialized array. Examples -------- >>> np.full((2, 2), np.inf) array([[ inf, inf], [ inf, inf]]) >>> np.full((2, 2), 10, dtype=np.int) array([[10, 10], [10, 10]])
numpy.onesHelp on function ones in numpy: numpy.ones = ones(shape, dtype=None, order='C') Return a new array of given shape and type, filled with ones. Parameters ---------- shape : int or sequence of ints Shape of the new array, e.g., ``(2, 3)`` or ``2``. dtype : data-type, optional The desired data-type for the array, e.g., `numpy.int8`. Default is `numpy.float64`. order : {'C', 'F'}, optional Whether to store multidimensional data in C- or Fortran-contiguous (row- or column-wise) order in memory. Returns ------- out : ndarray Array of ones with the given shape, dtype, and order. See Also -------- zeros, ones_like Examples -------- >>> np.ones(5) array([ 1., 1., 1., 1., 1.]) >>> np.ones((5,), dtype=np.int) array([1, 1, 1, 1, 1]) >>> np.ones((2, 1)) array([[ 1.], [ 1.]]) >>> s = (2,2) >>> np.ones(s) array([[ 1., 1.], [ 1., 1.]])
numpy.ones_likeHelp on function ones_like in numpy: numpy.ones_like = ones_like(a, dtype=None, order='K', subok=True) Return an array of ones with the same shape and type as a given array. Parameters ---------- a : array_like The shape and data-type of `a` define these same attributes of the returned array. dtype : data-type, optional .. versionadded:: 1.6.0 Overrides the data type of the result. order : {'C', 'F', 'A', or 'K'}, optional .. versionadded:: 1.6.0 Overrides the memory layout of the result. 'C' means C-order, 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, 'C' otherwise. 'K' means match the layout of `a` as closely as possible. subok : bool, optional. If True, then the newly created array will use the sub-class type of 'a', otherwise it will be a base-class array. Defaults to True. Returns ------- out : ndarray Array of ones with the same shape and type as `a`. See Also -------- zeros_like : Return an array of zeros with shape and type of input. empty_like : Return an empty array with shape and type of input. zeros : Return a new array setting values to zero. ones : Return a new array setting values to one. empty : Return a new uninitialized array. Examples -------- >>> x = np.arange(6) >>> x = x.reshape((2, 3)) >>> x array([[0, 1, 2], [3, 4, 5]]) >>> np.ones_like(x) array([[1, 1, 1], [1, 1, 1]]) >>> y = np.arange(3, dtype=np.float) >>> y array([ 0., 1., 2.]) >>> np.ones_like(y) array([ 1., 1., 1.])
numpy.ones_likeHelp on function ones_like in numpy: numpy.ones_like = ones_like(a, dtype=None, order='K', subok=True) Return an array of ones with the same shape and type as a given array. Parameters ---------- a : array_like The shape and data-type of `a` define these same attributes of the returned array. dtype : data-type, optional .. versionadded:: 1.6.0 Overrides the data type of the result. order : {'C', 'F', 'A', or 'K'}, optional .. versionadded:: 1.6.0 Overrides the memory layout of the result. 'C' means C-order, 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, 'C' otherwise. 'K' means match the layout of `a` as closely as possible. subok : bool, optional. If True, then the newly created array will use the sub-class type of 'a', otherwise it will be a base-class array. Defaults to True. Returns ------- out : ndarray Array of ones with the same shape and type as `a`. See Also -------- zeros_like : Return an array of zeros with shape and type of input. empty_like : Return an empty array with shape and type of input. zeros : Return a new array setting values to zero. ones : Return a new array setting values to one. empty : Return a new uninitialized array. Examples -------- >>> x = np.arange(6) >>> x = x.reshape((2, 3)) >>> x array([[0, 1, 2], [3, 4, 5]]) >>> np.ones_like(x) array([[1, 1, 1], [1, 1, 1]]) >>> y = np.arange(3, dtype=np.float) >>> y array([ 0., 1., 2.]) >>> np.ones_like(y) array([ 1., 1., 1.])
numpy.ones_likeHelp on function ones_like in numpy: numpy.ones_like = ones_like(a, dtype=None, order='K', subok=True) Return an array of ones with the same shape and type as a given array. Parameters ---------- a : array_like The shape and data-type of `a` define these same attributes of the returned array. dtype : data-type, optional .. versionadded:: 1.6.0 Overrides the data type of the result. order : {'C', 'F', 'A', or 'K'}, optional .. versionadded:: 1.6.0 Overrides the memory layout of the result. 'C' means C-order, 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, 'C' otherwise. 'K' means match the layout of `a` as closely as possible. subok : bool, optional. If True, then the newly created array will use the sub-class type of 'a', otherwise it will be a base-class array. Defaults to True. Returns ------- out : ndarray Array of ones with the same shape and type as `a`. See Also -------- zeros_like : Return an array of zeros with shape and type of input. empty_like : Return an empty array with shape and type of input. zeros : Return a new array setting values to zero. ones : Return a new array setting values to one. empty : Return a new uninitialized array. Examples -------- >>> x = np.arange(6) >>> x = x.reshape((2, 3)) >>> x array([[0, 1, 2], [3, 4, 5]]) >>> np.ones_like(x) array([[1, 1, 1], [1, 1, 1]]) >>> y = np.arange(3, dtype=np.float) >>> y array([ 0., 1., 2.]) >>> np.ones_like(y) array([ 1., 1., 1.])
numpy.reshapeHelp on function reshape in numpy: numpy.reshape = reshape(a, newshape, order='C') Gives a new shape to an array without changing its data. Parameters ---------- a : array_like Array to be reshaped. newshape : int or tuple of ints The new shape should be compatible with the original shape. If an integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions. order : {'C', 'F', 'A'}, optional Read the elements of `a` using this index order, and place the elements into the reshaped array using this index order. 'C' means to read / write the elements using C-like index order, with the last axis index changing fastest, back to the first axis index changing slowest. 'F' means to read / write the elements using Fortran-like index order, with the first index changing fastest, and the last index changing slowest. Note that the 'C' and 'F' options take no account of the memory layout of the underlying array, and only refer to the order of indexing. 'A' means to read / write the elements in Fortran-like index order if `a` is Fortran *contiguous* in memory, C-like order otherwise. Returns ------- reshaped_array : ndarray This will be a new view object if possible; otherwise, it will be a copy. Note there is no guarantee of the *memory layout* (C- or Fortran- contiguous) of the returned array. See Also -------- ndarray.reshape : Equivalent method. Notes ----- It is not always possible to change the shape of an array without copying the data. If you want an error to be raise if the data is copied, you should assign the new shape to the shape attribute of the array:: >>> a = np.zeros((10, 2)) # A transpose make the array non-contiguous >>> b = a.T # Taking a view makes it possible to modify the shape without modifying the # initial object. >>> c = b.view() >>> c.shape = (20) AttributeError: incompatible shape for a non-contiguous array The `order` keyword gives the index ordering both for *fetching* the values from `a`, and then *placing* the values into the output array. For example, let's say you have an array: >>> a = np.arange(6).reshape((3, 2)) >>> a array([[0, 1], [2, 3], [4, 5]]) You can think of reshaping as first raveling the array (using the given index order), then inserting the elements from the raveled array into the new array using the same kind of index ordering as was used for the raveling. >>> np.reshape(a, (2, 3)) # C-like index ordering array([[0, 1, 2], [3, 4, 5]]) >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape array([[0, 1, 2], [3, 4, 5]]) >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering array([[0, 4, 3], [2, 1, 5]]) >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F') array([[0, 4, 3], [2, 1, 5]]) Examples -------- >>> a = np.array([[1,2,3], [4,5,6]]) >>> np.reshape(a, 6) array([1, 2, 3, 4, 5, 6]) >>> np.reshape(a, 6, order='F') array([1, 4, 2, 5, 3, 6]) >>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2 array([[1, 2], [3, 4], [5, 6]])
numpy.sinsin(x[, out]) Trigonometric sine, element-wise. Parameters ---------- x : array_like Angle, in radians (:math:`2 pi` rad equals 360 degrees). Returns ------- y : array_like The sine of each element of x. See Also -------- arcsin, sinh, cos Notes ----- The sine is one of the fundamental functions of trigonometry (the mathematical study of triangles). Consider a circle of radius 1 centered on the origin. A ray comes in from the :math:`+x` axis, makes an angle at the origin (measured counter-clockwise from that axis), and departs from the origin. The :math:`y` coordinate of the outgoing ray's intersection with the unit circle is the sine of that angle. It ranges from -1 for :math:`x=3pi / 2` to +1 for :math:`pi / 2.` The function has zeroes where the angle is a multiple of :math:`pi`. Sines of angles between :math:`pi` and :math:`2pi` are negative. The numerous properties of the sine and related functions are included in any standard trigonometry text. Examples -------- Print sine of one angle: >>> np.sin(np.pi/2.) 1.0 Print sines of an array of angles given in degrees: >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) Plot the sine function: >>> import matplotlib.pylab as plt >>> x = np.linspace(-np.pi, np.pi, 201) >>> plt.plot(x, np.sin(x)) >>> plt.xlabel('Angle [rad]') >>> plt.ylabel('sin(x)') >>> plt.axis('tight') >>> plt.show()
numpy.sinhsinh(x[, out]) Hyperbolic sine, element-wise. Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or ``-1j * np.sin(1j*x)``. Parameters ---------- x : array_like Input array. out : ndarray, optional Output array of same shape as `x`. Returns ------- y : ndarray The corresponding hyperbolic sine values. Raises ------ ValueError: invalid return array shape if `out` is provided and `out.shape` != `x.shape` (See Examples) Notes ----- If `out` is provided, the function writes the result into it, and returns a reference to `out`. (See Examples) References ---------- M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972, pg. 83. Examples -------- >>> np.sinh(0) 0.0 >>> np.sinh(np.pi*1j/2) 1j >>> np.sinh(np.pi*1j) # (exact value is 0) 1.2246063538223773e-016j >>> # Discrepancy due to vagaries of floating point arithmetic. >>> # Example of providing the optional output parameter >>> out2 = np.sinh([0.1], out1) >>> out2 is out1 True >>> # Example of ValueError due to provision of shape mis-matched `out` >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: invalid return array shape
numpy.tantan(x[, out]) Compute tangent element-wise. Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. Parameters ---------- x : array_like Input array. out : ndarray, optional Output array of same shape as `x`. Returns ------- y : ndarray The corresponding tangent values. Raises ------ ValueError: invalid return array shape if `out` is provided and `out.shape` != `x.shape` (See Examples) Notes ----- If `out` is provided, the function writes the result into it, and returns a reference to `out`. (See Examples) References ---------- M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972. Examples -------- >>> from math import pi >>> np.tan(np.array([-pi,pi/2,pi])) array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) >>> >>> # Example of providing the optional output parameter illustrating >>> # that what is returned is a reference to said parameter >>> out2 = np.cos([0.1], out1) >>> out2 is out1 True >>> >>> # Example of ValueError due to provision of shape mis-matched `out` >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: invalid return array shape
numpy.tanhtanh(x[, out]) Compute hyperbolic tangent element-wise. Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. Parameters ---------- x : array_like Input array. out : ndarray, optional Output array of same shape as `x`. Returns ------- y : ndarray The corresponding hyperbolic tangent values. Raises ------ ValueError: invalid return array shape if `out` is provided and `out.shape` != `x.shape` (See Examples) Notes ----- If `out` is provided, the function writes the result into it, and returns a reference to `out`. (See Examples) References ---------- .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972, pg. 83. http://www.math.sfu.ca/~cbm/aands/ .. [2] Wikipedia, "Hyperbolic function", http://en.wikipedia.org/wiki/Hyperbolic_function Examples -------- >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) >>> # Example of providing the optional output parameter illustrating >>> # that what is returned is a reference to said parameter >>> out2 = np.tanh([0.1], out1) >>> out2 is out1 True >>> # Example of ValueError due to provision of shape mis-matched `out` >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: invalid return array shape
numpy.tolistno Python documentation found for 'numpy.tolist'
numpy.zerosHelp on built-in function zeros in numpy: numpy.zeros = zeros(...) zeros(shape, dtype=float, order='C') Return a new array of given shape and type, filled with zeros. Parameters ---------- shape : int or sequence of ints Shape of the new array, e.g., ``(2, 3)`` or ``2``. dtype : data-type, optional The desired data-type for the array, e.g., `numpy.int8`. Default is `numpy.float64`. order : {'C', 'F'}, optional Whether to store multidimensional data in C- or Fortran-contiguous (row- or column-wise) order in memory. Returns ------- out : ndarray Array of zeros with the given shape, dtype, and order. See Also -------- zeros_like : Return an array of zeros with shape and type of input. ones_like : Return an array of ones with shape and type of input. empty_like : Return an empty array with shape and type of input. ones : Return a new array setting values to one. empty : Return a new uninitialized array. Examples -------- >>> np.zeros(5) array([ 0., 0., 0., 0., 0.]) >>> np.zeros((5,), dtype=numpy.int) array([0, 0, 0, 0, 0]) >>> np.zeros((2, 1)) array([[ 0.], [ 0.]]) >>> s = (2,2) >>> np.zeros(s) array([[ 0., 0.], [ 0., 0.]]) >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype array([(0, 0), (0, 0)], dtype=[('x', '<i4'), ('y', '<i4')])
-
operator
operator.abs
Help on built-in function abs in operator: operator.abs = abs(...) abs(a) -- Same as abs(a).
operator.addHelp on built-in function add in operator: operator.add = add(...) add(a, b) -- Same as a + b.
operator.and_Help on built-in function and_ in operator: operator.and_ = and_(...) and_(a, b) -- Same as a & b.
operator.concatHelp on built-in function concat in operator: operator.concat = concat(...) concat(a, b) -- Same as a + b, for a and b sequences.
operator.containsHelp on built-in function contains in operator: operator.contains = contains(...) contains(a, b) -- Same as b in a (note reversed operands).
operator.countOfHelp on built-in function countOf in operator: operator.countOf = countOf(...) countOf(a, b) -- Return the number of times b occurs in a.
operator.delitemHelp on built-in function delitem in operator: operator.delitem = delitem(...) delitem(a, b) -- Same as del a[b].
operator.divHelp on built-in function div in operator: operator.div = div(...) div(a, b) -- Same as a / b when __future__.division is not in effect.
operator.eqHelp on built-in function eq in operator: operator.eq = eq(...) eq(a, b) -- Same as a==b.
operator.floordivHelp on built-in function floordiv in operator: operator.floordiv = floordiv(...) floordiv(a, b) -- Same as a // b.
operator.geHelp on built-in function ge in operator: operator.ge = ge(...) ge(a, b) -- Same as a>=b.
operator.getitemHelp on built-in function getitem in operator: operator.getitem = getitem(...) getitem(a, b) -- Same as a[b].
operator.gtHelp on built-in function gt in operator: operator.gt = gt(...) gt(a, b) -- Same as a>b.
operator.indexHelp on built-in function index in operator: operator.index = index(...) index(a) -- Same as a.__index__()
operator.indexOfHelp on built-in function indexOf in operator: operator.indexOf = indexOf(...) indexOf(a, b) -- Return the first index of b in a.
operator.invHelp on built-in function inv in operator: operator.inv = inv(...) inv(a) -- Same as ~a.
operator.is_Help on built-in function is_ in operator: operator.is_ = is_(...) is_(a, b) -- Same as a is b.
operator.is_notHelp on built-in function is_not in operator: operator.is_not = is_not(...) is_not(a, b) -- Same as a is not b.
operator.leHelp on built-in function le in operator: operator.le = le(...) le(a, b) -- Same as a<=b.
operator.lshiftHelp on built-in function lshift in operator: operator.lshift = lshift(...) lshift(a, b) -- Same as a << b.
operator.ltHelp on built-in function lt in operator: operator.lt = lt(...) lt(a, b) -- Same as a<b.
operator.modHelp on built-in function mod in operator: operator.mod = mod(...) mod(a, b) -- Same as a % b.
operator.mulHelp on built-in function mul in operator: operator.mul = mul(...) mul(a, b) -- Same as a * b.
operator.neHelp on built-in function ne in operator: operator.ne = ne(...) ne(a, b) -- Same as a!=b.
operator.negHelp on built-in function neg in operator: operator.neg = neg(...) neg(a) -- Same as -a.
operator.not_Help on built-in function not_ in operator: operator.not_ = not_(...) not_(a) -- Same as not a.
operator.or_Help on built-in function or_ in operator: operator.or_ = or_(...) or_(a, b) -- Same as a | b.
operator.posHelp on built-in function pos in operator: operator.pos = pos(...) pos(a) -- Same as +a.
operator.powHelp on built-in function pow in operator: operator.pow = pow(...) pow(a, b) -- Same as a ** b.
operator.rshiftHelp on built-in function rshift in operator: operator.rshift = rshift(...) rshift(a, b) -- Same as a >> b.
operator.setitemHelp on built-in function setitem in operator: operator.setitem = setitem(...) setitem(a, b, c) -- Same as a[b] = c.
operator.subHelp on built-in function sub in operator: operator.sub = sub(...) sub(a, b) -- Same as a - b.
operator.truthHelp on built-in function truth in operator: operator.truth = truth(...) truth(a) -- Return True if a is true, False otherwise.
operator.xorHelp on built-in function xor in operator: operator.xor = xor(...) xor(a, b) -- Same as a ^ b.
-
processing
processing.arc
no Python documentation found for 'processing.arc'
processing.backgroundno Python documentation found for 'processing.background'
processing.blueno Python documentation found for 'processing.blue'
processing.colorModeno Python documentation found for 'processing.colorMode'
processing.ellipseno Python documentation found for 'processing.ellipse'
processing.ellipseModeno Python documentation found for 'processing.ellipseMode'
processing.exitpno Python documentation found for 'processing.exitp'
processing.fillno Python documentation found for 'processing.fill'
processing.frameRateno Python documentation found for 'processing.frameRate'
processing.getno Python documentation found for 'processing.get'
processing.greenno Python documentation found for 'processing.green'
processing.imageno Python documentation found for 'processing.image'
processing.lineno Python documentation found for 'processing.line'
processing.loadImageno Python documentation found for 'processing.loadImage'
processing.loadPixelsno Python documentation found for 'processing.loadPixels'
processing.loopno Python documentation found for 'processing.loop'
processing.mouseXno Python documentation found for 'processing.mouseX'
processing.mouseYno Python documentation found for 'processing.mouseY'
processing.noFillno Python documentation found for 'processing.noFill'
processing.noLoopno Python documentation found for 'processing.noLoop'
processing.noSmoothno Python documentation found for 'processing.noSmooth'
processing.noStrokeno Python documentation found for 'processing.noStroke'
processing.pointno Python documentation found for 'processing.point'
processing.quadno Python documentation found for 'processing.quad'
processing.rectno Python documentation found for 'processing.rect'
processing.rectModeno Python documentation found for 'processing.rectMode'
processing.redno Python documentation found for 'processing.red'
processing.rotateno Python documentation found for 'processing.rotate'
processing.runno Python documentation found for 'processing.run'
processing.scaleno Python documentation found for 'processing.scale'
processing.setno Python documentation found for 'processing.set'
processing.sizeno Python documentation found for 'processing.size'
processing.smoothno Python documentation found for 'processing.smooth'
processing.strokeno Python documentation found for 'processing.stroke'
processing.strokeCapno Python documentation found for 'processing.strokeCap'
processing.strokeJoinno Python documentation found for 'processing.strokeJoin'
processing.strokeWeightno Python documentation found for 'processing.strokeWeight'
processing.textno Python documentation found for 'processing.text'
processing.translateno Python documentation found for 'processing.translate'
processing.triangleno Python documentation found for 'processing.triangle'
-
pygal
Overviewpygal is a dynamic charting library for python. A variety of chart types are available including:
- Line
- StackedLine
- Bar
- StackedBar
- HorizontalBar
- StackedHorizontalBar
- XY
- Radar
- Pie
pygal.Barpygal.HorizontalBarpygal.Linepygal.Piepygal.Radarpygal.StackedBarpygal.StackedHorizontalBarpygal.StackedLinepygal.XYpygal.addpygal.render -
random
random.choice
Help on method choice in random: random.choice = choice(self, seq) method of random.Random instance Choose a random element from a non-empty sequence.
random.randintHelp on method randint in random: random.randint = randint(self, a, b) method of random.Random instance Return random integer in range [a, b], including both end points.
random.randomHelp on built-in function random in random: random.random = random(...) random() -> x in the interval [0, 1).
random.randrangeHelp on method randrange in random: random.randrange = randrange(self, start, stop=None, step=1, _int=<type 'int'>, _maxwidth=9007199254740992L) method of random.Random instance Choose a random item from range(start, stop[, step]). This fixes the problem with randint() which includes the endpoint; in Python this is usually not what you want.
random.seedHelp on method seed in random: random.seed = seed(self, a=None) method of random.Random instance Initialize internal state from hashable object. None or no argument seeds from current time or from an operating system specific randomness source if available. If a is not None or an int or long, hash(a) is used instead.
random.shuffleHelp on method shuffle in random: random.shuffle = shuffle(self, x, random=None) method of random.Random instance x, random=random.random -> shuffle list x in place; return None. Optional arg random is a 0-argument function returning a random float in [0.0, 1.0); by default, the standard random.random.
-
re
OverviewThis module provides regular expression matching operations similar to those found in Perl. Both patterns and strings to be searched can be Unicode strings as well as 8-bit strings.
Regular expressions use the backslash character ('\') to indicate special forms or to allow special characters to be used without invoking their special meaning. This collides with Python’s usage of the same character for the same purpose in string literals; for example, to match a literal backslash, one might have to write '\\\\' as the pattern string, because the regular expression must be \\, and each backslash must be expressed as \\ inside a regular Python string literal.
The solution is to use Python’s raw string notation for regular expression patterns; backslashes are not handled in any special way in a string literal prefixed with 'r'. So r"\n" is a two-character string containing '\' and 'n', while "\n" is a one-character string containing a newline. Usually patterns will be expressed in Python code using this raw string notation.
It is important to note that most regular expression operations are available as module-level functions and RegexObject methods. The functions are shortcuts that don’t require you to compile a regex object first, but miss some fine-tuning parameters.
See https://docs.python.org/2/library/re.html and https://docs.python.org/2/howto/regex.html for detailed information about regular expressions.re.groupReturns one or more subgroups of the match. If there is a single argument, the result is a single string; if there are multiple arguments, the result is a tuple with one item per argument. Without arguments, group1 defaults to zero (the whole match is returned). If a groupN argument is zero, the corresponding return value is the entire matching string; if it is in the inclusive range [1..99], it is the string matching the corresponding parenthesized group. If a group number is negative or larger than the number of groups defined in the pattern, an IndexError exception is raised. If a group is contained in a part of the pattern that did not match, the corresponding result is None. If a group is contained in a part of the pattern that matched multiple times, the last match is returned.
re.groupsReturn a tuple containing all the subgroups of the match, from 1 up to however many groups are in the pattern. The default argument is used for groups that did not participate in the match; it defaults to None.
re.matchHelp on function match in re: re.match = match(pattern, string, flags=0) Try to apply the pattern at the start of the string, returning a match object, or None if no match was found.
re.searchHelp on function search in re: re.search = search(pattern, string, flags=0) Scan through string looking for a match to the pattern, returning a match object, or None if no match was found.
-
string
string.capitalize
Help on function capitalize in string: string.capitalize = capitalize(s) capitalize(s) -> string Return a copy of the string s with only its first character capitalized.
string.capwordsHelp on function capwords in string: string.capwords = capwords(s, sep=None) capwords(s [,sep]) -> string Split the argument into words using split, capitalize each word using capitalize, and join the capitalized words using join. If the optional second argument sep is absent or None, runs of whitespace characters are replaced by a single space and leading and trailing whitespace are removed, otherwise sep is used to split and join the words.
string.joinHelp on function join in string: string.join = join(words, sep=' ') join(list [,sep]) -> string Return a string composed of the words in list, with intervening occurrences of sep. The default separator is a single space. (joinfields and join are synonymous)
string.splitHelp on function split in string: string.split = split(s, sep=None, maxsplit=-1) split(s [,sep [,maxsplit]]) -> list of strings Return a list of the words in the string s, using sep as the delimiter string. If maxsplit is given, splits at no more than maxsplit places (resulting in at most maxsplit+1 words). If sep is not specified or is None, any whitespace string is a separator. (split and splitfields are synonymous)
-
time
time.time
Help on built-in function time in time: time.time = time(...) time() -> floating point number Return the current time in seconds since the Epoch. Fractions of a second may be present if the system clock provides them.
-
turtle
turtle.back
Help on function back in turtle: turtle.back = back(distance) Move the turtle backward by distance. Aliases: back | backward | bk Argument: distance -- a number Move the turtle backward by distance ,opposite to the direction the turtle is headed. Do not change the turtle's heading. Example: >>> position() (0.00, 0.00) >>> backward(30) >>> position() (-30.00, 0.00)
turtle.backwardHelp on function backward in turtle: turtle.backward = backward(distance) Move the turtle backward by distance. Aliases: back | backward | bk Argument: distance -- a number Move the turtle backward by distance ,opposite to the direction the turtle is headed. Do not change the turtle's heading. Example: >>> position() (0.00, 0.00) >>> backward(30) >>> position() (-30.00, 0.00)
turtle.begin_fillHelp on function begin_fill in turtle: turtle.begin_fill = begin_fill() Called just before drawing a shape to be filled. No argument. Example: >>> begin_fill() >>> forward(100) >>> left(90) >>> forward(100) >>> left(90) >>> forward(100) >>> left(90) >>> forward(100) >>> end_fill()
turtle.bgcolorHelp on function bgcolor in turtle: turtle.bgcolor = bgcolor(*args) Set or return backgroundcolor of the TurtleScreen. Arguments (if given): a color string or three numbers in the range 0..colormode or a 3-tuple of such numbers. Example: >>> bgcolor("orange") >>> bgcolor() 'orange' >>> bgcolor(0.5,0,0.5) >>> bgcolor() '#800080'
turtle.bkHelp on function bk in turtle: turtle.bk = bk(distance) Move the turtle backward by distance. Aliases: back | backward | bk Argument: distance -- a number Move the turtle backward by distance ,opposite to the direction the turtle is headed. Do not change the turtle's heading. Example: >>> position() (0.00, 0.00) >>> backward(30) >>> position() (-30.00, 0.00)
turtle.circleHelp on function circle in turtle: turtle.circle = circle(radius, extent=None, steps=None) Draw a circle with given radius. Arguments: radius -- a number extent (optional) -- a number steps (optional) -- an integer Draw a circle with given radius. The center is radius units left of the turtle; extent - an angle - determines which part of the circle is drawn. If extent is not given, draw the entire circle. If extent is not a full circle, one endpoint of the arc is the current pen position. Draw the arc in counterclockwise direction if radius is positive, otherwise in clockwise direction. Finally the direction of the turtle is changed by the amount of extent. As the circle is approximated by an inscribed regular polygon, steps determines the number of steps to use. If not given, it will be calculated automatically. Maybe used to draw regular polygons. call: circle(radius) # full circle --or: circle(radius, extent) # arc --or: circle(radius, extent, steps) --or: circle(radius, steps=6) # 6-sided polygon Example: >>> circle(50) >>> circle(120, 180) # semicircle
turtle.clearHelp on function clear in turtle: turtle.clear = clear() Delete the turtle's drawings from the screen. Do not move No arguments. Delete the turtle's drawings from the screen. Do not move State and position of the turtle as well as drawings of other turtles are not affected. Examples: >>> clear()
turtle.clearHelp on function clear in turtle: turtle.clear = clear() Delete the turtle's drawings from the screen. Do not move No arguments. Delete the turtle's drawings from the screen. Do not move State and position of the turtle as well as drawings of other turtles are not affected. Examples: >>> clear()
turtle.colorHelp on function color in turtle: turtle.color = color(*args) Return or set the pencolor and fillcolor. Arguments: Several input formats are allowed. They use 0, 1, 2, or 3 arguments as follows: color() Return the current pencolor and the current fillcolor as a pair of color specification strings as are returned by pencolor and fillcolor. color(colorstring), color((r,g,b)), color(r,g,b) inputs as in pencolor, set both, fillcolor and pencolor, to the given value. color(colorstring1, colorstring2), color((r1,g1,b1), (r2,g2,b2)) equivalent to pencolor(colorstring1) and fillcolor(colorstring2) and analogously, if the other input format is used. If turtleshape is a polygon, outline and interior of that polygon is drawn with the newly set colors. For mor info see: pencolor, fillcolor Example: >>> color('red', 'green') >>> color() ('red', 'green') >>> colormode(255) >>> color((40, 80, 120), (160, 200, 240)) >>> color() ('#285078', '#a0c8f0')
turtle.colormodeHelp on function colormode in turtle: turtle.colormode = colormode(cmode=None) Return the colormode or set it to 1.0 or 255. Optional argument: cmode -- one of the values 1.0 or 255 r, g, b values of colortriples have to be in range 0..cmode. Example: >>> colormode() 1.0 >>> colormode(255) >>> pencolor(240,160,80)
turtle.delayHelp on function delay in turtle: turtle.delay = delay(delay=None) Return or set the drawing delay in milliseconds. Optional argument: delay -- positive integer Example: >>> delay(15) >>> delay() 15
turtle.distanceHelp on function distance in turtle: turtle.distance = distance(x, y=None) Return the distance from the turtle to (x,y) in turtle step units. Arguments: x -- a number or a pair/vector of numbers or a turtle instance y -- a number None None call: distance(x, y) # two coordinates --or: distance((x, y)) # a pair (tuple) of coordinates --or: distance(vec) # e.g. as returned by pos() --or: distance(mypen) # where mypen is another turtle Example: >>> pos() (0.00, 0.00) >>> distance(30,40) 50.0 >>> pen = Turtle() >>> pen.forward(77) >>> distance(pen) 77.0
turtle.dotHelp on function dot in turtle: turtle.dot = dot(size=None, *color) Draw a dot with diameter size, using color. Optional arguments: size -- an integer >= 1 (if given) color -- a colorstring or a numeric color tuple Draw a circular dot with diameter size, using color. If size is not given, the maximum of pensize+4 and 2*pensize is used. Example: >>> dot() >>> fd(50); dot(20, "blue"); fd(50)
turtle.downHelp on function down in turtle: turtle.down = down() Pull the pen down -- drawing when moving. Aliases: pendown | pd | down No argument. Example: >>> pendown()
turtle.end_fillHelp on function end_fill in turtle: turtle.end_fill = end_fill() Fill the shape drawn after the call begin_fill(). No argument. Example: >>> begin_fill() >>> forward(100) >>> left(90) >>> forward(100) >>> left(90) >>> forward(100) >>> left(90) >>> forward(100) >>> end_fill()
turtle.exitonclickHelp on function exitonclick in turtle: turtle.exitonclick = exitonclick() Go into mainloop until the mouse is clicked. No arguments. Bind bye() method to mouseclick on TurtleScreen. If "using_IDLE" - value in configuration dictionary is False (default value), enter mainloop. If IDLE with -n switch (no subprocess) is used, this value should be set to True in turtle.cfg. In this case IDLE's mainloop is active also for the client script. This is a method of the Screen-class and not available for TurtleScreen instances. Example: >>> exitonclick()
turtle.fdHelp on function fd in turtle: turtle.fd = fd(distance) Move the turtle forward by the specified distance. Aliases: forward | fd Argument: distance -- a number (integer or float) Move the turtle forward by the specified distance, in the direction the turtle is headed. Example: >>> position() (0.00, 0.00) >>> forward(25) >>> position() (25.00,0.00) >>> forward(-75) >>> position() (-50.00,0.00)
turtle.fillHelp on function fill in turtle: turtle.fill = fill(flag=None) Call fill(True) before drawing a shape to fill, fill(False) when done. Optional argument: flag -- True/False (or 1/0 respectively) Call fill(True) before drawing the shape you want to fill, and fill(False) when done. When used without argument: return fillstate (True if filling, False else) Example: >>> fill(True) >>> forward(100) >>> left(90) >>> forward(100) >>> left(90) >>> forward(100) >>> left(90) >>> forward(100) >>> fill(False)
turtle.fillcolorHelp on function fillcolor in turtle: turtle.fillcolor = fillcolor(*args) Return or set the fillcolor. Arguments: Four input formats are allowed: - fillcolor() Return the current fillcolor as color specification string, possibly in hex-number format (see example). May be used as input to another color/pencolor/fillcolor call. - fillcolor(colorstring) s is a Tk color specification string, such as "red" or "yellow" - fillcolor((r, g, b)) *a tuple* of r, g, and b, which represent, an RGB color, and each of r, g, and b are in the range 0..colormode, where colormode is either 1.0 or 255 - fillcolor(r, g, b) r, g, and b represent an RGB color, and each of r, g, and b are in the range 0..colormode If turtleshape is a polygon, the interior of that polygon is drawn with the newly set fillcolor. Example: >>> fillcolor('violet') >>> col = pencolor() >>> fillcolor(col) >>> fillcolor(0, .5, 0)
turtle.forwardHelp on function forward in turtle: turtle.forward = forward(distance) Move the turtle forward by the specified distance. Aliases: forward | fd Argument: distance -- a number (integer or float) Move the turtle forward by the specified distance, in the direction the turtle is headed. Example: >>> position() (0.00, 0.00) >>> forward(25) >>> position() (25.00,0.00) >>> forward(-75) >>> position() (-50.00,0.00)
turtle.goto_$rw$no Python documentation found for 'turtle.goto_$'
turtle.headingHelp on function heading in turtle: turtle.heading = heading() Return the turtle's current heading. No arguments. Example: >>> left(67) >>> heading() 67.0
turtle.hideturtleHelp on function hideturtle in turtle: turtle.hideturtle = hideturtle() Makes the turtle invisible. Aliases: hideturtle | ht No argument. It's a good idea to do this while you're in the middle of a complicated drawing, because hiding the turtle speeds up the drawing observably. Example: >>> hideturtle()
turtle.homeHelp on function home in turtle: turtle.home = home() Move turtle to the origin - coordinates (0,0). No arguments. Move turtle to the origin - coordinates (0,0) and set its heading to its start-orientation (which depends on mode). Example: >>> home()
turtle.htHelp on function ht in turtle: turtle.ht = ht() Makes the turtle invisible. Aliases: hideturtle | ht No argument. It's a good idea to do this while you're in the middle of a complicated drawing, because hiding the turtle speeds up the drawing observably. Example: >>> hideturtle()
turtle.isdownHelp on function isdown in turtle: turtle.isdown = isdown() Return True if pen is down, False if it's up. No argument. Example: >>> penup() >>> isdown() False >>> pendown() >>> isdown() True
turtle.isvisibleHelp on function isvisible in turtle: turtle.isvisible = isvisible() Return True if the Turtle is shown, False if it's hidden. No argument. Example: >>> hideturtle() >>> print isvisible(): False
turtle.leftHelp on function left in turtle: turtle.left = left(angle) Turn turtle left by angle units. Aliases: left | lt Argument: angle -- a number (integer or float) Turn turtle left by angle units. (Units are by default degrees, but can be set via the degrees() and radians() functions.) Angle orientation depends on mode. (See this.) Example: >>> heading() 22.0 >>> left(45) >>> heading() 67.0
turtle.ltHelp on function lt in turtle: turtle.lt = lt(angle) Turn turtle left by angle units. Aliases: left | lt Argument: angle -- a number (integer or float) Turn turtle left by angle units. (Units are by default degrees, but can be set via the degrees() and radians() functions.) Angle orientation depends on mode. (See this.) Example: >>> heading() 22.0 >>> left(45) >>> heading() 67.0
turtle.pdHelp on function pd in turtle: turtle.pd = pd() Pull the pen down -- drawing when moving. Aliases: pendown | pd | down No argument. Example: >>> pendown()
turtle.pencolorHelp on function pencolor in turtle: turtle.pencolor = pencolor(*args) Return or set the pencolor. Arguments: Four input formats are allowed: - pencolor() Return the current pencolor as color specification string, possibly in hex-number format (see example). May be used as input to another color/pencolor/fillcolor call. - pencolor(colorstring) s is a Tk color specification string, such as "red" or "yellow" - pencolor((r, g, b)) *a tuple* of r, g, and b, which represent, an RGB color, and each of r, g, and b are in the range 0..colormode, where colormode is either 1.0 or 255 - pencolor(r, g, b) r, g, and b represent an RGB color, and each of r, g, and b are in the range 0..colormode If turtleshape is a polygon, the outline of that polygon is drawn with the newly set pencolor. Example: >>> pencolor('brown') >>> tup = (0.2, 0.8, 0.55) >>> pencolor(tup) >>> pencolor() '#33cc8c'
turtle.pendownHelp on function pendown in turtle: turtle.pendown = pendown() Pull the pen down -- drawing when moving. Aliases: pendown | pd | down No argument. Example: >>> pendown()
turtle.pensizeHelp on function pensize in turtle: turtle.pensize = pensize(width=None) Set or return the line thickness. Aliases: pensize | width Argument: width -- positive number Set the line thickness to width or return it. If resizemode is set to "auto" and turtleshape is a polygon, that polygon is drawn with the same line thickness. If no argument is given, current pensize is returned. Example: >>> pensize() 1 >>> pensize(10) # from here on lines of width 10 are drawn
turtle.penupHelp on function penup in turtle: turtle.penup = penup() Pull the pen up -- no drawing when moving. Aliases: penup | pu | up No argument Example: >>> penup()
turtle.posHelp on function pos in turtle: turtle.pos = pos() Return the turtle's current location (x,y), as a Vec2D-vector. Aliases: pos | position No arguments. Example: >>> pos() (0.00, 240.00)
turtle.positionHelp on function position in turtle: turtle.position = position() Return the turtle's current location (x,y), as a Vec2D-vector. Aliases: pos | position No arguments. Example: >>> pos() (0.00, 240.00)
turtle.puHelp on function pu in turtle: turtle.pu = pu() Pull the pen up -- no drawing when moving. Aliases: penup | pu | up No argument Example: >>> penup()
turtle.resetHelp on function reset in turtle: turtle.reset = reset() Delete the turtle's drawings and restore its default values. No argument. , Delete the turtle's drawings from the screen, re-center the turtle and set variables to the default values. Example: >>> position() (0.00,-22.00) >>> heading() 100.0 >>> reset() >>> position() (0.00,0.00) >>> heading() 0.0
turtle.rightHelp on function right in turtle: turtle.right = right(angle) Turn turtle right by angle units. Aliases: right | rt Argument: angle -- a number (integer or float) Turn turtle right by angle units. (Units are by default degrees, but can be set via the degrees() and radians() functions.) Angle orientation depends on mode. (See this.) Example: >>> heading() 22.0 >>> right(45) >>> heading() 337.0
turtle.rtHelp on function rt in turtle: turtle.rt = rt(angle) Turn turtle right by angle units. Aliases: right | rt Argument: angle -- a number (integer or float) Turn turtle right by angle units. (Units are by default degrees, but can be set via the degrees() and radians() functions.) Angle orientation depends on mode. (See this.) Example: >>> heading() 22.0 >>> right(45) >>> heading() 337.0
turtle.sethHelp on function seth in turtle: turtle.seth = seth(to_angle) Set the orientation of the turtle to to_angle. Aliases: setheading | seth Argument: to_angle -- a number (integer or float) Set the orientation of the turtle to to_angle. Here are some common directions in degrees: standard - mode: logo-mode: -------------------|-------------------- 0 - east 0 - north 90 - north 90 - east 180 - west 180 - south 270 - south 270 - west Example: >>> setheading(90) >>> heading() 90
turtle.setheadingHelp on function setheading in turtle: turtle.setheading = setheading(to_angle) Set the orientation of the turtle to to_angle. Aliases: setheading | seth Argument: to_angle -- a number (integer or float) Set the orientation of the turtle to to_angle. Here are some common directions in degrees: standard - mode: logo-mode: -------------------|-------------------- 0 - east 0 - north 90 - north 90 - east 180 - west 180 - south 270 - south 270 - west Example: >>> setheading(90) >>> heading() 90
turtle.setposHelp on function setpos in turtle: turtle.setpos = setpos(x, y=None) Move turtle to an absolute position. Aliases: setpos | setposition | goto: Arguments: x -- a number or a pair/vector of numbers y -- a number None call: goto(x, y) # two coordinates --or: goto((x, y)) # a pair (tuple) of coordinates --or: goto(vec) # e.g. as returned by pos() Move turtle to an absolute position. If the pen is down, a line will be drawn. The turtle's orientation does not change. Example: >>> tp = pos() >>> tp (0.00, 0.00) >>> setpos(60,30) >>> pos() (60.00,30.00) >>> setpos((20,80)) >>> pos() (20.00,80.00) >>> setpos(tp) >>> pos() (0.00,0.00)
turtle.setpositionHelp on function setposition in turtle: turtle.setposition = setposition(x, y=None) Move turtle to an absolute position. Aliases: setpos | setposition | goto: Arguments: x -- a number or a pair/vector of numbers y -- a number None call: goto(x, y) # two coordinates --or: goto((x, y)) # a pair (tuple) of coordinates --or: goto(vec) # e.g. as returned by pos() Move turtle to an absolute position. If the pen is down, a line will be drawn. The turtle's orientation does not change. Example: >>> tp = pos() >>> tp (0.00, 0.00) >>> setpos(60,30) >>> pos() (60.00,30.00) >>> setpos((20,80)) >>> pos() (20.00,80.00) >>> setpos(tp) >>> pos() (0.00,0.00)
turtle.setupHelp on function setup in turtle: turtle.setup = setup(width=0.5, height=0.75, startx=None, starty=None) Set the size and position of the main window. Arguments: width: as integer a size in pixels, as float a fraction of the Default is 50% of height: as integer the height in pixels, as float a fraction of the Default is 75% of startx: if positive, starting position in pixels from the left edge of the screen, if negative from the right edge Default, startx=None is to center window horizontally. starty: if positive, starting position in pixels from the top edge of the screen, if negative from the bottom edge Default, starty=None is to center window vertically. Examples: >>> setup (width=200, height=200, startx=0, starty=0) sets window to 200x200 pixels, in upper left of screen >>> setup(width=.75, height=0.5, startx=None, starty=None) sets window to 75% of screen by 50% of screen and centers
turtle.setworldcoordinatesHelp on function setworldcoordinates in turtle: turtle.setworldcoordinates = setworldcoordinates(llx, lly, urx, ury) Set up a user defined coordinate-system. Arguments: llx -- a number, x-coordinate of lower left corner of canvas lly -- a number, y-coordinate of lower left corner of canvas urx -- a number, x-coordinate of upper right corner of canvas ury -- a number, y-coordinate of upper right corner of canvas Set up user coodinat-system and switch to mode 'world' if necessary. This performs a reset. If mode 'world' is already active, all drawings are redrawn according to the new coordinates. But ATTENTION: in user-defined coordinatesystems angles may appear distorted. (see Screen.mode()) Example: >>> setworldcoordinates(-10,-0.5,50,1.5) >>> for _ in range(36): ... left(10) ... forward(0.5)
turtle.setworldcoordinatesHelp on function setworldcoordinates in turtle: turtle.setworldcoordinates = setworldcoordinates(llx, lly, urx, ury) Set up a user defined coordinate-system. Arguments: llx -- a number, x-coordinate of lower left corner of canvas lly -- a number, y-coordinate of lower left corner of canvas urx -- a number, x-coordinate of upper right corner of canvas ury -- a number, y-coordinate of upper right corner of canvas Set up user coodinat-system and switch to mode 'world' if necessary. This performs a reset. If mode 'world' is already active, all drawings are redrawn according to the new coordinates. But ATTENTION: in user-defined coordinatesystems angles may appear distorted. (see Screen.mode()) Example: >>> setworldcoordinates(-10,-0.5,50,1.5) >>> for _ in range(36): ... left(10) ... forward(0.5)
turtle.setxHelp on function setx in turtle: turtle.setx = setx(x) Set the turtle's first coordinate to x Argument: x -- a number (integer or float) Set the turtle's first coordinate to x, leave second coordinate unchanged. Example: >>> position() (0.00, 240.00) >>> setx(10) >>> position() (10.00, 240.00)
turtle.setyHelp on function sety in turtle: turtle.sety = sety(y) Set the turtle's second coordinate to y Argument: y -- a number (integer or float) Set the turtle's first coordinate to x, second coordinate remains unchanged. Example: >>> position() (0.00, 40.00) >>> sety(-10) >>> position() (0.00, -10.00)
turtle.shapeHelp on function shape in turtle: turtle.shape = shape(name=None) Set turtle shape to shape with given name / return current shapename. Optional argument: name -- a string, which is a valid shapename Set turtle shape to shape with given name or, if name is not given, return name of current shape. Shape with name must exist in the TurtleScreen's shape dictionary. Initially there are the following polygon shapes: 'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'. To learn about how to deal with shapes see Screen-method register_shape. Example: >>> shape() 'arrow' >>> shape("turtle") >>> shape() 'turtle'
turtle.showturtleHelp on function showturtle in turtle: turtle.showturtle = showturtle() Makes the turtle visible. Aliases: showturtle | st No argument. Example: >>> hideturtle() >>> showturtle()
turtle.speedHelp on function speed in turtle: turtle.speed = speed(speed=None) Return or set the turtle's speed. Optional argument: speed -- an integer in the range 0..10 or a speedstring (see below) Set the turtle's speed to an integer value in the range 0 .. 10. If no argument is given: return current speed. If input is a number greater than 10 or smaller than 0.5, speed is set to 0. Speedstrings are mapped to speedvalues in the following way: 'fastest' : 0 'fast' : 10 'normal' : 6 'slow' : 3 'slowest' : 1 speeds from 1 to 10 enforce increasingly faster animation of line drawing and turtle turning. Attention: speed = 0 : *no* animation takes place. forward/back makes turtle jump and likewise left/right make the turtle turn instantly. Example: >>> speed(3)
turtle.stHelp on function st in turtle: turtle.st = st() Makes the turtle visible. Aliases: showturtle | st No argument. Example: >>> hideturtle() >>> showturtle()
turtle.stampHelp on function stamp in turtle: turtle.stamp = stamp() Stamp a copy of the turtleshape onto the canvas and return its id. No argument. Stamp a copy of the turtle shape onto the canvas at the current turtle position. Return a stamp_id for that stamp, which can be used to delete it by calling clearstamp(stamp_id). Example: >>> color("blue") >>> stamp() 13 >>> fd(50)
turtle.titleHelp on function title in turtle: turtle.title = title(titlestring) Set title of turtle-window Argument: titlestring -- a string, to appear in the titlebar of the turtle graphics window. This is a method of Screen-class. Not available for TurtleScreen- objects. Example: >>> title("Welcome to the turtle-zoo!")
turtle.towardsHelp on function towards in turtle: turtle.towards = towards(x, y=None) Return the angle of the line from the turtle's position to (x, y). Arguments: x -- a number or a pair/vector of numbers or a turtle instance y -- a number None None call: distance(x, y) # two coordinates --or: distance((x, y)) # a pair (tuple) of coordinates --or: distance(vec) # e.g. as returned by pos() --or: distance(mypen) # where mypen is another turtle Return the angle, between the line from turtle-position to position specified by x, y and the turtle's start orientation. (Depends on modes - "standard" or "logo") Example: >>> pos() (10.00, 10.00) >>> towards(0,0) 225.0
turtle.tracerHelp on function tracer in turtle: turtle.tracer = tracer(flag=None, delay=None) Turns turtle animation on/off and set delay for update drawings. Optional arguments: n -- nonnegative integer delay -- nonnegative integer If n is given, only each n-th regular screen update is really performed. (Can be used to accelerate the drawing of complex graphics.) Second arguments sets delay value (see RawTurtle.delay()) Example: >>> tracer(8, 25) >>> dist = 2 >>> for i in range(200): ... fd(dist) ... rt(90) ... dist += 2
turtle.tracerHelp on function tracer in turtle: turtle.tracer = tracer(flag=None, delay=None) Turns turtle animation on/off and set delay for update drawings. Optional arguments: n -- nonnegative integer delay -- nonnegative integer If n is given, only each n-th regular screen update is really performed. (Can be used to accelerate the drawing of complex graphics.) Second arguments sets delay value (see RawTurtle.delay()) Example: >>> tracer(8, 25) >>> dist = 2 >>> for i in range(200): ... fd(dist) ... rt(90) ... dist += 2
turtle.turtlesHelp on function turtles in turtle: turtle.turtles = turtles() Return the list of turtles on the Example: >>> turtles() [<turtle.Turtle object at 0x00E11FB0>]
turtle.upHelp on function up in turtle: turtle.up = up() Pull the pen up -- no drawing when moving. Aliases: penup | pu | up No argument Example: >>> penup()
turtle.updateHelp on function update in turtle: turtle.update = update() Perform a TurtleScreen update.
turtle.updateHelp on function update in turtle: turtle.update = update() Perform a TurtleScreen update.
turtle.widthHelp on function width in turtle: turtle.width = width(width=None) Set or return the line thickness. Aliases: pensize | width Argument: width -- positive number Set the line thickness to width or return it. If resizemode is set to "auto" and turtleshape is a polygon, that polygon is drawn with the same line thickness. If no argument is given, current pensize is returned. Example: >>> pensize() 1 >>> pensize(10) # from here on lines of width 10 are drawn
turtle.window_heightHelp on function window_height in turtle: turtle.window_height = window_height() Return the height of the turtle window. No argument. Example (for a TurtleScreen instance named screen): >>> screen.window_height() 480
turtle.window_widthHelp on function window_width in turtle: turtle.window_width = window_width() Returns the width of the turtle window. No argument. Example (for a TurtleScreen instance named screen): >>> screen.window_width() 640
turtle.writeHelp on function write in turtle: turtle.write = write(arg, move=False, align='left', font=('Arial', 8, 'normal')) Write text at the current turtle position. Arguments: arg -- info, which is to be written to the TurtleScreen move (optional) -- True/False align (optional) -- one of the strings "left", "center" or right" font (optional) -- a triple (fontname, fontsize, fonttype) Write text - the string representation of arg - at the current turtle position according to align ("left", "center" or right") and with the given font. If move is True, the pen is moved to the bottom-right corner of the text. By default, move is False. Example: >>> write('Home = ', True, align="center") >>> write((0,0), True)
turtle.xcorHelp on function xcor in turtle: turtle.xcor = xcor() Return the turtle's x coordinate. No arguments. Example: >>> reset() >>> left(60) >>> forward(100) >>> print xcor() 50.0
turtle.ycorHelp on function ycor in turtle: turtle.ycor = ycor() Return the turtle's y coordinate --- No arguments. Example: >>> reset() >>> left(60) >>> forward(100) >>> print ycor() 86.6025403784
-
urllib.request
urllib.request.read
no Python documentation found for 'urllib.request.read'
urllib.request.readlineno Python documentation found for 'urllib.request.readline'
urllib.request.readlinesno Python documentation found for 'urllib.request.readlines'