معرفی شرکت ها
FractalArtMaker-0.1.0
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشتر
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشتر
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشتر
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشتر
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشترتوضیحات
A module for creating fractal art in Python's turtle module.
| ویژگی | مقدار |
|---|---|
| سیستم عامل | - |
| نام فایل | FractalArtMaker-0.1.0 |
| نام | FractalArtMaker |
| نسخه کتابخانه | 0.1.0 |
| نگهدارنده | [] |
| ایمیل نگهدارنده | [] |
| نویسنده | Al Sweigart |
| ایمیل نویسنده | al@inventwithpython.com |
| آدرس صفحه اصلی | https://github.com/asweigart/fractalartmaker |
| آدرس اینترنتی | https://pypi.org/project/FractalArtMaker/ |
| مجوز | MIT |
# fractalartmaker
A module for creating fractal art in Python's `turtle` module.
This module is explored in the book "The Recursive Book of Recursion" by Al Sweigart from No Starch Press.
You can purchase this book directly from the publisher at https://nostarch.com/recursive-book-recursion or read it online at https://inventwithpython.com/recursion/
Quickstart
==========
To view some example fractals, run the following from the interactive shell:
>>> import fractalartmaker
>>> fractalartmaker.fast() # draw the fractals quickly
>>> fractalartmaker.example(1) # pass 1 to 9
Making Fractals
===============
The Fractal Art Maker's algorithm has two major components: a shape-drawing function and the recursive `drawFractal()` function.
The shape-drawing function draws a basic shape. The Fractal Art Maker program comes with the two shape-drawing functions, `fractalartmaker.drawFilledSquare()` and `fractalartmaker.drawTriangleOutline()`, but you can also create your own. We pass a shape-drawing function to the `fractalartmaker.drawFractal()` function as an argument.
The `fractalartmaker.drawFractal()` function also has a parameter indicating changes to the size, position, and angle of the shapes between recursive calls to `fractalartmaker.drawFractal()`.
The `fractalartmaker.drawFractal()` function uses a shape-drawing function passed to it to draw the individual parts of the fractal. This is usually a simple shape, such as a square or triangle. The beautiful complexity of the fractals emerges from `fractalartmaker.drawFractal()` recursively calling this function for each individual component of the whole fractal.
Here's the two shape-drawing functions that come in the `fractalartmaker` module:
def drawFilledSquare(size, depth):
size = int(size)
# Move to the top-right corner before drawing:
turtle.penup()
turtle.forward(size // 2)
turtle.left(90)
turtle.forward(size // 2)
turtle.left(180)
turtle.pendown()
# Alternate between white and gray (with black border):
if depth % 2 == 0:
turtle.pencolor('black')
turtle.fillcolor('white')
else:
turtle.pencolor('black')
turtle.fillcolor('gray')
# Draw a square:
turtle.begin_fill()
for i in range(4): # Draw four lines.
turtle.forward(size)
turtle.right(90)
turtle.end_fill()
def drawTriangleOutline(size, depth):
size = int(size)
# Move the turtle to the top of the equilateral triangle:
height = size * math.sqrt(3) / 2
turtle.penup()
turtle.left(90) # Turn to face upwards.
turtle.forward(height * (2/3)) # Move to the top corner.
turtle.right(150) # Turn to face the bottom-right corner.
turtle.pendown()
# Draw the three sides of the triangle:
for i in range(3):
turtle.forward(size)
turtle.right(120)
The shape-drawing functions for the Fractal Art Maker have two parameters: `size` and `depth`. The size parameter is the length of the sides of the square or triangle it draws. The shape-drawing functions should always use arguments to `turtle.forward()` that are based on `size` so that the lengths will be proportionate to size at each level of recursion. Avoid code like `turtle.forward(100)` or `turtle.forward(200)`; instead, use code that is based on the `size` parameter, like `turtle.forward(size)` or `turtle.forward(size * 2)`. In Python's `turtle` module, `turtle.forward(1)` moves the turtle by one unit, which is not necessarily the same as one pixel.
The shape-drawing functions' second parameter is the recursive depth of `fractalartmaker.drawFractal()`. Your shape-drawing function can ignore this argument, but using it can cause interesting variations to the basic shape. For example, the `fractalartmaker.drawFilledSquare()` shape-drawing function uses depth to alternate between drawing white squares and gray squares. Keep this in mind if you'd like to create your own shape-drawing functions for the Fractal Art Maker program, as they must accept a `size` and `depth` argument.
The `fractalartmaker.drawFractal()` function has three required parameters and one optional one: `shapeDrawFunction`, `size`, `specs`, and optionally `maxDepth`. The `shapeDrawFunction` parameter expects a function, like `fractalartmaker.drawFilledSquare` or `fractalartmaker.drawTriangleOutline`. The `size` parameter expects the starting size passed to the drawing function. Often, a value between `100` and `500` is a good starting size, though this depends on the code in your shape-drawing function, and finding the right value may require experimentation.
The `specs` parameter expects a list of dictionaries that specify how the recursive shapes should change their size, position, and angle as `drawFractal()` recursively calls itself. These specifications are described later in this section. To prevent `drawFractal()` from recursing until it causes a stack overflow, the `maxDepth` parameter holds the number of times `drawFractal()` should recursively call itself. By default, `maxDepth` has a value of `8`, but you can provide a different value if you want more recursive shapes or fewer.
The recursive calls to `drawFractal()` are based on the specification in the `specs` list’s dictionaries. For each dictionary, `drawFractal()` makes one recursive call to `drawFractal()`. If specs is a list with one dictionary, every call to `drawFractal()` results in only one recursive call to `drawFractal()`. If specs is a list with three dictionaries, every call to `drawFractal()` results in three recursive calls to `drawFractal()`.
The dictionaries in the specs parameter provide specifications for each recursive call. Each of these dictionaries has the keys `sizeChange`, `xChange`, `yChange`, and `angleChange`. These dictate how the size of the fractal, the position of the turtle, and the heading of the turtle change for a recursive `drawFractal()` call.
* `sizeChange` (default is `1.0`) - The next recursive shape’s size value is the current size multiplied by this value.
* `xChange` (default is `0.0`) - The next recursive shape’s x-coordinate is the current x-coordinate plus the current size multiplied by this value.
* `yChange` (default is `0.0`) - The next recursive shape’s y-coordinate is the current y-coordinate plus the current size multiplied by this value.
* `angleChange` (default is `0.0`) - The next recursive shape’s starting angle is the current starting angle plus this value.
Let’s take a look at the specification dictionary for the Four Corners fractal, which is drawn when you call `fractalartmaker.example(1)`. The call to `drawFractal()` for the Four Corners fractal passes the following list of dictionaries for the `specs` parameter:
fractalartmaker.drawFractal(fractalartmaker.drawFilledSquare, 350,
[{'sizeChange': 0.5, 'xChange': -0.5, 'yChange': 0.5},
{'sizeChange': 0.5, 'xChange': 0.5, 'yChange': 0.5},
{'sizeChange': 0.5, 'xChange': -0.5, 'yChange': -0.5},
{'sizeChange': 0.5, 'xChange': 0.5, 'yChange': -0.5}], 5)
The `specs` list has four dictionaries, so each call to `drawFractal()` that draws a square will, in turn, recursively call `drawFractal()` four more times to draw four more squares.
To determine the size of the next square to be drawn, the value for the `sizeChange` key is multiplied by the current size parameter. The first dictionary in the specs list has a `sizeChange` value of `0.5`, which makes the next recursive call have a size argument of `350 * 0.5`, or `175` units. This makes the next square half the size of the previous square. A `sizeChange` value of `2.0` would, for example, double the size of the next square. If the dictionary has no `sizeChange` key, the value defaults to `1.0` for no change to the size.
If you look at the three other dictionaries in the `specs` list, you’ll notice they all have a `sizeChange` value of `0.5`. The difference between them is that their `xChange` and `yChange` values place them in the other three corners of the current square. As a result, the next four squares are drawn centered on the four corners of the current square.
The dictionaries in the `specs` list for this example don’t have an `angleChange` value, so this value defaults to `0.0` degrees. A positive `angleChange` value indicates a counterclockwise rotation, while a negative value indicates a clockwise rotation.
Take a look at the code in the module's `example()` function for more examples.
The `fractalartmaker` module also has a `fractalartmaker.fast()` function you can call to make the fractals draw quickly, and a `fractalartmaker.clear()` to clear the turtle drawing window.
نحوه نصب
نصب پکیج whl FractalArtMaker-0.1.0:
pip install FractalArtMaker-0.1.0.whl
نصب پکیج tar.gz FractalArtMaker-0.1.0:
pip install FractalArtMaker-0.1.0.tar.gz