PyEphem

https://rhodesmill.org/pyephem/
Admin
PyEphem is an astronomy library for Python that computes positions of planets, comets, asteroids,...
Tokens:66,192
Snippets:403
Trust Score:9.3
Update:1 day ago
Show doc for...
Tokens:
Raw
### Using start parameter to continue rising search

Source: https://rhodesmill.org/pyephem/CHANGELOG.html

Shows how to use the new start= parameter to make a second next_rising call begin where the first left off.

```python
r1 = boston.next_rising(mars)
r2 = boston.next_rising(mars, start=r1)
```

--------------------------------

### Install PyEphem with pip

Source: https://rhodesmill.org/pyephem/

Command to install PyEphem from the Python Package Index using pip.

```bash
$ pip install pyephem
```

--------------------------------

### Get city observer with ephem.city()

Source: https://rhodesmill.org/pyephem/quick.html

Returns an Observer for a known city, with longitude and latitude set. The example shows Stuttgart's coordinates.

```python
>>> stuttgart = ephem.city('Stuttgart')
>>> print(stuttgart.lon)
9:10:50.8
>>> print(stuttgart.lat)
48:46:37.6
```

--------------------------------

### Find transit, rising, and setting times with PyEphem Observer

Source: https://rhodesmill.org/pyephem/quick.html

Shows how to create an Observer, set its location and date, and use next_transit() and next_rising() to find event times. The body's altitude and azimuth are printed after each event. The rising example uses the start= argument to begin the search from a later date.

```python
>>> sitka = ephem.Observer()
>>> sitka.date = '1999/6/27'
>>> sitka.lat = '57:10'
>>> sitka.lon = '-135:15'
>>> m = ephem.Mars()
>>> print(sitka.next_transit(m))
1999/6/27 04:22:45
>>> print('%s %s' % (m.alt, m.az))
21:18:33.6 180:00:00.0
>>> print(sitka.next_rising(m, start='1999/6/28'))
1999/6/28 23:28:25
>>> print('%s %s' % (m.alt, m.az))
-0:00:05.8 111:10:41.6
```

--------------------------------

### Load the ISS with ephem.readtle() and compute rise/transit/set times

Source: https://rhodesmill.org/pyephem/tutorial.html

Use ephem.readtle() with NORAD Two-Line Element data to create a satellite object. The example sets an Observer's date, computes the satellite, and prints rise, transit, and set times. Note that transit_time is the moment of highest altitude, not meridian crossing.

```python
>>> iss = ephem.readtle("ISS (ZARYA)",
...  "1 25544U 98067A   03097.78853147  .00021906  00000-0  28403-3 0  8652",
...  "2 25544  51.6361  13.7980 0004256  35.6671  59.2566 15.58778559250029")
>>> gatech.date = '2003/3/23'
>>> iss.compute(gatech)
>>> print("%s %s %s" % (iss.rise_time, iss.transit_time, iss.set_time))
2003/3/23 00:00:50 2003/3/23 00:03:26 2003/3/23 00:06:01
```

--------------------------------

### Import PyEphem with wildcard import

Source: https://rhodesmill.org/pyephem/quick.html

Shows an alternative import style using 'from ephem import *' to avoid typing the module name. The same Mars constellation example is repeated.

```python
>>> from ephem import *
>>> m = Mars('1970')
>>> print(constellation(m))
('Aqr', 'Aquarius')
```

--------------------------------

### Set observer.horizon for sunrise calculation

Source: https://rhodesmill.org/pyephem/quick.html

Demonstrates setting the horizon attribute to account for refraction. The horizon defaults to zero degrees; setting it to '-0:34' with pressure=0 mimics the Naval Observatory's constant 34' refraction estimate. The example shows the difference in sunrise times between visual and Naval Observatory calculations.

```python
>>> sun = ephem.Sun()
>>> greenwich = ephem.Observer()
>>> greenwich.lat = '51:28:38'
>>> print(greenwich.horizon)
0:00:00.0
>>> greenwich.date = '2007/10/1'
>>> r1 = greenwich.next_rising(sun)
>>> greenwich.pressure = 0
>>> greenwich.horizon = '-0:34'
>>> greenwich.date = '2007/10/1'
>>> r2 = greenwich.next_rising(sun)
>>> print('Visual sunrise: %s' % r1)
Visual sunrise: 2007/10/1 05:59:30
>>> print('Naval Observatory sunrise: %s' % r2)
Naval Observatory sunrise: 2007/10/1 05:59:50
```

--------------------------------

### ephem.constellation() example

Source: https://rhodesmill.org/pyephem/quick.html

Returns a tuple with the abbreviated and full constellation name for a Body or an (ra, dec) tuple. If a tuple is passed, epoch 2000 is assumed unless an epoch= keyword argument is supplied.

```python
>>> m = ephem.Moon('1980/6/1')
>>> print(ephem.constellation(m))
('Sgr', 'Sagittarius')
```

--------------------------------

### Find Martian seasons using newton

Source: https://rhodesmill.org/pyephem/newton.html

Real-world example: defines functions to compute Martian solar longitude and uses `newton` to find the dates of spring equinox and summer solstice. Outputs the computed dates and longitudes.

```python
# The angle that we call "the longitude of the Sun, as
# seen from Mars" should grow at the same rate as the
# "longitude of Mars as seen from the Sun" (since the
# two are the same line but viewed in opposite
# directions).
#
# The only problem is knowing what point to name "zero",
# so we have to learn what .hlon was when the first
# Martian year started:

from ephem import Mars, Date, degrees, newton
m = Mars()
m.compute('1955/4/11 23:00')
Ls0 = m.hlon

def Ls(date):
    m.compute(date)
    return degrees(m.hlon - Ls0).norm

# There!  Ls() should give Martian solar latitude.
# So the first round of seasons listed at the page
# http://www.planetary.org/explore/space-topics/mars/mars-calendar.html
# should give 90 degrees, 180 degrees, and 270 degrees:

for date in '1955/10/27', '1956/4/27', '1956/9/21':
    print Ls(date)

# The output is close to what we would expect:
#
# 90:11:58.3
# 179:57:32.2
# 270:13:22.6
#
# Great!  So what if we want to know, say, the date
# of the upcoming Spring Equinox or Summer Solstice?
# We need functions that are smooth, well-behaved,
# and cross zero at those two times, so that we can
# unleash Newton's Method upon them:

def spring_equinox(date):
    return Ls(date).znorm

def summer_solstice(date):
    return Ls(date) - degrees('90:00:00')

def find_spring_equinox(start_date):
    start_date = Date(start_date)
    y0 = Ls(start_date)
    y1 = Ls(start_date + 1)
    rate = y1 - y0
    angle_to_go = degrees(0.0 - y0).norm
    closer_date = start_date + angle_to_go / rate
    d = newton(spring_equinox, closer_date, closer_date + 1)
    return Date(d)

def find_summer_solstice(start_date):
    start_date = Date(start_date)
    y0 = Ls(start_date)
    y1 = Ls(start_date + 1)
    rate = y1 - y0
    angle_to_go = degrees(degrees('90:00:00') - y0).norm
    closer_date = start_date + angle_to_go / rate
    d = newton(summer_solstice, closer_date, closer_date + 1)
    return Date(d)

d = find_spring_equinox('2015/1/22')
print d, Ls(d)

d = find_summer_solstice('2015/1/22')
print d, Ls(d)

# Output:
# 2015/6/16 15:03:15 0:00:00.0
# 2015/12/31 21:12:07 90:00:00.0
```

--------------------------------

### Compute Sun and Moon positions for an observer

Source: https://rhodesmill.org/pyephem/tutorial.html

Sets the observer's date and epoch (epoch defaults to 2000), creates Sun and Moon objects, computes their positions using the observer, and prints altitude and azimuth. The example uses the 1984 solar eclipse from Atlanta.

```python
>>> gatech.date = '1984/5/30 16:22:56'   # 12:22:56 EDT
>>> sun, moon = ephem.Sun(), ephem.Moon()
>>> sun.compute(gatech)
>>> moon.compute(gatech)
>>> print("%s %s" % (sun.alt, sun.az))
70:08:39.2 122:11:26.4
>>> print("%s %s" % (moon.alt, moon.az))
70:08:39.5 122:11:26.0
```

--------------------------------

### Star atlas lookup examples: uranometria, uranometria2000, millennium_atlas

Source: https://rhodesmill.org/pyephem/quick.html

Each function takes an ra and dec and returns the volume and page in the corresponding star atlas: Uranometria by Johannes Bayer, Uranometria 2000.0 edited by Wil Tirion, and Millennium Star Atlas by Roger W. Sinnott and Michael A. C. Perryman.

```python
>>> ra, dec = '7:16:00', '-6:17:00'
>>> print(ephem.uranometria(ra, dec))
V2 - P274
>>> print(ephem.uranometria2000(ra, dec))
V2 - P135
>>> print(ephem.millennium_atlas(ra, dec))
V1 - P273
```

--------------------------------

### Get an Observer for a city with ephem.city()

Source: https://rhodesmill.org/pyephem/CHANGELOG.html

The city() function returns a new Observer object for the named city. This example shows how to obtain an Observer for 'Boston'.

```python
observer = ephem.city('Boston')
```

--------------------------------

### Create a Body and Access Name

Source: https://rhodesmill.org/pyephem/quick.html

Demonstrates creating a Mars body and a star from the catalog, and accessing their name attributes.

```APIDOC
## Create a Body and Access Name

### Description
Create a Mars body and a star from the catalog, then access their `name` attributes.

### Method
N/A (Python module usage)

### Endpoint
N/A

### Parameters
#### Constructor Arguments
- **None** for `ephem.Mars()`
- **name** (string) - Required - Star name for `ephem.star()`

### Request Example
```python
m = ephem.Mars()
a = ephem.star('Arcturus')
print(m.name)
print(a.name)
```

### Response
#### Success Response
- **name** (string) - Name of the body

#### Response Example
```python
'Mars'
'Arcturus'
```
```

--------------------------------

### Import PyEphem and Create a Mars Body

Source: https://rhodesmill.org/pyephem/quick.html

Demonstrates importing the ephem module and creating a Mars body with a date string, then printing its constellation.

```APIDOC
## Import PyEphem and Create a Mars Body

### Description
Import the ephem module and create a Mars body for a given date, then print its constellation.

### Method
N/A (Python module usage)

### Endpoint
N/A

### Parameters
#### Constructor Arguments
- **date** (string) - Optional - Date string for initial computation (e.g., '1970')

### Request Example
```python
import ephem
m = ephem.Mars('1970')
print(ephem.constellation(m))
```

### Response
#### Success Response
- **constellation** (tuple) - Tuple of (abbreviation, full name) of the constellation

#### Response Example
```python
('Aqr', 'Aquarius')
```
```

--------------------------------

### Find Mars position in galactic coordinates

Source: https://rhodesmill.org/pyephem/coordinates.html

Shows how to get galactic coordinates of a body by passing it to ephem.Galactic. The example uses the same Mars object and prints the galactic longitude and latitude.

```python
>>> gal = ephem.Galactic(m)
>>> print('%s %s' % (gal.lon, gal.lat))
168:47:15.2 -24:14:01.8
```

--------------------------------

### Find Mars position in ecliptic coordinates

Source: https://rhodesmill.org/pyephem/coordinates.html

Shows how to get ecliptic coordinates of a body by passing it to ephem.Ecliptic. The example uses Mars at a specific date and prints the ecliptic longitude and latitude.

```python
>>> import ephem
>>> m = ephem.Mars('1990/12/13')
>>> print('%s %s' % (m.a_ra, m.a_dec))
3:51:20.54 22:12:49.4
```

```python
>>> ecl = ephem.Ecliptic(m)
>>> print('%s %s' % (ecl.lon, ecl.lat))
60:27:09.2 2:00:47.5
```

--------------------------------

### Get ecliptic and galactic coordinates of Mars

Source: https://rhodesmill.org/pyephem/coordinates

Shows how to obtain ecliptic and galactic coordinates for a body by passing it to ephem.Ecliptic and ephem.Galactic. The example uses Mars at a specific date and prints the resulting longitude and latitude.

```python
>>> import ephem
>>> m = ephem.Mars('1990/12/13')
>>> print('%s %s' % (m.a_ra, m.a_dec))
3:51:20.54 22:12:49.4
```

```python
>>> ecl = ephem.Ecliptic(m)
>>> print('%s %s' % (ecl.lon, ecl.lat))
60:27:09.2 2:00:47.5
```

```python
>>> gal = ephem.Galactic(m)
>>> print('%s %s' % (gal.lon, gal.lat))
168:47:15.2 -24:14:01.8
```

```python
>>> print(ecl.epoch)
2000/1/1 12:00:00
```

--------------------------------

### Specify a date in multiple equivalent formats

Source: https://rhodesmill.org/pyephem/tutorial.html

Shows five equivalent ways to create the same PyEphem date: as a floating-point day count, as a string with fractional day, as a string with time, and as tuples with varying detail.

```python
>>> d = ephem.Date(34530.34375)
>>> d = ephem.Date('1994/7/16.84375')
>>> d = ephem.Date('1994/7/16 20:15')
>>> d = ephem.Date((1994, 7, 16.84375))
>>> d = ephem.Date((1994, 7, 16, 20, 15, 0))
```

--------------------------------

### Create PyEphem date from string and print it

Source: https://rhodesmill.org/pyephem/date

Initialize an ephem.Date with a string and print it. The string output omits fractional seconds.

```python
>>> d = ephem.Date('1984/05/30 16:23:45.12')
>>> print(d)
1984/5/30 16:23:45
```

--------------------------------

### Compute next setting time and altitude/azimuth with PyEphem

Source: https://rhodesmill.org/pyephem/tutorial.html

Use the observer's next_setting method to find the next setting time of a body, then print its altitude and azimuth at that moment. The output shows the setting time and the altitude/azimuth values.

```python
>>> print(gatech.next_setting(sun))
1984/5/31 00:42:22
>>> print("%s %s" % (sun.alt, sun.az))
-0:15:45.8 297:20:43.7
```

--------------------------------

### Repeated next_rising calls without start parameter

Source: https://rhodesmill.org/pyephem/CHANGELOG.html

Shows that after the incompatible change, calling next_rising twice without a start parameter returns the same value twice.

```python
r1 = boston.next_rising(mars)
r2 = boston.next_rising(mars)
```

--------------------------------

### Use hour, minute, and second constants in date math

Source: https://rhodesmill.org/pyephem/date

Illustrates the hour, minute, and second constants that represent fractions of a day, and how to combine them for custom time increments.

```python
>>> print(ephem.Date(n + ephem.hour))
1900/1/8 01:00:00
>>> print(ephem.Date(n + ephem.minute))
1900/1/8 00:01:00
>>> print(ephem.Date(n + ephem.second))
1900/1/8 00:00:01
>>> print(ephem.Date(n + 12 * ephem.hour + 36 * ephem.minute))
1900/1/8 12:36:00
```

--------------------------------

### get() Method

Source: https://rhodesmill.org/pyephem/coordinates

The get() method of any coordinate returns the value of its two angles in a tuple, with the 'big angle' (longitude or right ascension) first and then the 'small angle' (latitude or declination) second.

```APIDOC
## get() Method

### Description
Returns the two angles of the coordinate as a tuple, with the 'big angle' (longitude or right ascension) first and the 'small angle' (latitude or declination) second.

### Usage
```python
coord = Equatorial('23:19:01.27', '-17:14:22.1')
ra, dec = coord.get()
```
```

--------------------------------

### Import PyEphem module

Source: https://rhodesmill.org/pyephem/tutorial.html

Use this statement to import the PyEphem library in Python. It is the first step after installing the module.

```python
>>> import ephem
```

--------------------------------

### Observer-based computation: az and alt

Source: https://rhodesmill.org/pyephem/

Shows how to set up an Observer with latitude, longitude, and date, then compute a Mars position relative to that observer, printing azimuth and altitude.

```python
>>> boston = ephem.Observer()
>>> boston.lat = '42.37'
>>> boston.lon = '-71.03'
>>> boston.date = '2007/10/02 00:50:22'
>>> mars.compute(boston)
>>> print mars.az, mars.alt
37:55:48.9 -14:23:11.8
```

--------------------------------

### Convert PyEphem date to triple with triple() method

Source: https://rhodesmill.org/pyephem/date

Call d.triple() to get a three-item tuple with fractional day.

```python
>>> d = ephem.Date('1996/4/17 22:37:11.5')
>>> print(d.triple())
(1996, 4, 17.94249421296263)
```

--------------------------------

### Compute Jupiter's position with body.compute()

Source: https://rhodesmill.org/pyephem/quick.html

Shows how to create a Jupiter body, compute its position for a specific date, and print its right ascension and declination. Also demonstrates using a custom epoch ('1950') and accessing astrometric coordinates (a_ra, a_dec). The date defaults to now() and the epoch defaults to '2000' if omitted.

```python
>>> j = ephem.Jupiter()
>>> j.compute('1986/2/8')
>>> print('%s %s' % (j.ra, j.dec))
21:57:50.47 -13:17:37.2
>>> j.compute('1986/2/9', epoch='1950')
>>> print('%s %s' % (j.a_ra, j.a_dec))
21:56:50.83 -13:22:54.3
```

--------------------------------

### Convert PyEphem date to tuple with tuple() method

Source: https://rhodesmill.org/pyephem/date

Call d.tuple() to get a six-element tuple with fractional seconds.

```python
>>> d = ephem.Date('2001/12/14 16:07:57')
>>> print(d.tuple())
(2001, 12, 14, 16, 7, 57.0)
```

--------------------------------

### Instantiate from Manual Parts

Source: https://rhodesmill.org/pyephem/coordinates

You can instantiate a coordinate by providing its parts manually in the order listed for the class. If no epoch is specified, J2000 is assumed.

```APIDOC
## Instantiate from Manual Parts

### Description
Creates a coordinate object by providing its parts manually. The order is: for Equatorial: ra, dec; for Ecliptic and Galactic: lon, lat. An optional epoch can be provided; default is J2000.

### Usage
```python
Equatorial('23:19:01.27', '-17:14:22.1')
Equatorial('23:19:01.27', '-17:14:22.1', epoch='1950')
```
```

--------------------------------

### Coordinate get() Method

Source: https://rhodesmill.org/pyephem/coordinates.html

Retrieve the two angles of a coordinate as a tuple, with the big angle first and the small angle second.

```APIDOC
## Coordinate get() Method

### Description
Returns the value of the coordinate's two angles in a tuple, with the 'big angle' (longitude or right ascension) first and the 'small angle' (latitude or declination) second.

### Method
`get()`

### Return Value
- **tuple** - A tuple containing two angle values.

### Example
```python
coord = Equatorial('23:19:01.27', '-17:14:22.1')
ra, dec = coord.get()
```
```

--------------------------------

### ephem.julian_date() example

Source: https://rhodesmill.org/pyephem/quick.html

Returns the official Julian Date for the given day and time. Accepts a Date or Observer argument; without an argument, uses now().

```python
>>> ephem.julian_date('2000/1/1')
2451544.5
```

--------------------------------

### Coordinate Class Instantiation

Source: https://rhodesmill.org/pyephem/coordinates.html

How to instantiate coordinate objects from a body, from another coordinate, or manually, with optional epoch specification.

```APIDOC
## Coordinate Class Instantiation

### Description
Instantiate Equatorial, Ecliptic, or Galactic coordinate objects from a body, another coordinate, or manual parts.

### Usage

#### From a body
```python
Ecliptic(mars)
Ecliptic(mars, epoch='1950')
```

#### From another coordinate
```python
Galactic(north_pole)
Galactic(north_pole, epoch='1900')
```

#### Manual parts
```python
Equatorial('23:19:01.27', '-17:14:22.1')
Equatorial('23:19:01.27', '-17:14:22.1', epoch='1950')
```

### Parameters
- **body** (Body) - Required - A PyEphem body object.
- **coord** (Coordinate) - Required - Another coordinate object.
- **ra** (string) - Required - Right ascension string.
- **dec** (string) - Required - Declination string.
- **epoch** (string) - Optional - Epoch string (e.g., '1950', '1900'). Defaults to J2000 if omitted.

### Notes
- Coordinate classes have attributes: Equatorial (ra, dec, epoch), Ecliptic (lon, lat, epoch), Galactic (lon, lat, epoch).
```

--------------------------------

### Get star coordinates with ephem.star()

Source: https://rhodesmill.org/pyephem/quick.html

Retrieves a FixedBody for a named bright star and prints its right ascension and declination. The output shows the coordinates for Rigel.

```python
>>> rigel = ephem.star('Rigel')
>>> print('%s %s' % (rigel._ra, rigel._dec))
5:14:32.27 -8:12:05.9
```

--------------------------------

### Compute equinoxes and solstices with ephem.next_equinox and ephem.next_solstice

Source: https://rhodesmill.org/pyephem/quick.html

Shows how to compute the next equinox and solstice from a date, and calculate the duration of spring. Functions take a Date argument and return a Date.

```python
>>> d1 = ephem.next_equinox('2000')
>>> print(d1)
2000/3/20 07:35:17
>>> d2 = ephem.next_solstice(d1)
>>> print(d2)
2000/6/21 01:47:51
>>> t = d2 - d1
>>> print("Spring lasted %.1f days" % t)
Spring lasted 92.8 days
```

--------------------------------

### USNO Almanac Example Output

Source: https://rhodesmill.org/pyephem/rise-set.html

Sample output from the USNO web site for Atlanta on 6 September 2009, showing sunrise/sunset and moonrise/moonset times.

```text
Sunday
6 September 2009      Eastern Daylight Time

                 SUN
Begin civil twilight       6:50 a.m.
Sunrise                    7:15 a.m.
Sun transit                1:36 p.m.
Sunset                     7:56 p.m.
End civil twilight         8:21 p.m.

                 MOON
Moonrise                   8:17 p.m. on preceding day
Moon transit               2:37 a.m.
Moonset                    9:05 a.m.
Moonrise                   8:44 p.m.
Moonset                   10:05 a.m. on following day
```

--------------------------------

### Compute Venus position with Observer

Source: https://rhodesmill.org/pyephem/quick.html

Sets up an observer with location, elevation, and date, then computes Venus's altitude and azimuth. The output shows alt and az in sexagesimal format.

```python
>>> gatech = ephem.Observer()
>>> gatech.lon = '-84.39733'
>>> gatech.lat = '33.775867'
>>> gatech.elevation = 320
>>> gatech.date = '1984/5/30 16:22:56'
>>> v = ephem.Venus(gatech)
>>> print('%s %s' % (v.alt, v.az))
72:19:45.1 134:14:25.4
```

--------------------------------

### ephem.separation() example

Source: https://rhodesmill.org/pyephem/quick.html

Returns the angle separating two positions on a sphere. Each argument can be a Body (using its ra and dec) or a tuple (lon, lat) of spherical coordinates.

```python
>>> m1 = ephem.Moon('1970/1/16')
>>> m2 = ephem.Moon('1970/1/17')
>>> s = ephem.separation(m1, m2)
>>> print("In one day the Moon moved %s" % s)
In one day the Moon moved 12:33:28.5
```

--------------------------------

### Julian to Gregorian calendar transition

Source: https://rhodesmill.org/pyephem/date

Demonstrates the ten-day jump when the Gregorian calendar was introduced. Dates before the transition use the Julian calendar.

```python
>>> print(ephem.Date(-115860.0))
1582/10/4 12:00:00
>>> print(ephem.Date(-115859.0))
1582/10/15 12:00:00
```

--------------------------------

### Extract date components with triple() and tuple()

Source: https://rhodesmill.org/pyephem/tutorial.html

Shows how to display a PyEphem date as a float, a string, and as tuples using `triple()` (year, month, fractional day) and `tuple()` (down to fractional seconds).

```python
>>> print('as a float: %f\nas a string: "%s"' % (d, d))
as a float: 34530.343750
as a string: "1994/7/16 20:15:00"
>>> print(d.triple())
(1994, 7, 16.84375)
>>> print(d.tuple())
(1994, 7, 16, 20, 15, 0.0)
```

--------------------------------

### ephem.delta_t() example

Source: https://rhodesmill.org/pyephem/quick.html

Returns the difference in seconds between Terrestrial Time and Universal Time for the given date. Accepts a Date or Observer argument; without an argument, uses now().

```python
>>> print(ephem.delta_t('1980'))
50.54
```

--------------------------------

### Get City Observer from XEphem Database

Source: https://rhodesmill.org/pyephem/quick.html

Uses ephem.city() to retrieve an Observer for a named city from XEphem's built-in database. Only latitude, longitude, and elevation are set.

```python
>>> boston = ephem.city('Boston')
>>> print('%s %s' % (boston.lat, boston.lon))
42:21:30.4 -71:03:35.2
```

--------------------------------

### Create and manipulate Angle objects with ephem.degrees and ephem.hours

Source: https://rhodesmill.org/pyephem/quick.html

Shows how to create Angle objects from radians or strings, how they behave like floats, and how they display as degrees or hours. Also demonstrates converting between hours and degrees.

```python
>>> a = ephem.degrees(3.141593)  # float: radians
>>> print(a)
180:00:00.1
>>> a = ephem.degrees('180:00:00')  # str: degrees
>>> print(a)
180:00:00.0
>>> a
3.141592653589793
>>> print("180 degrees is %f radians" % a)
180 degrees is 3.141593 radians
>>> h = ephem.hours('1:00:00')
>>> deg = ephem.degrees(h)
>>> print("1h right ascension = %s degrees" % deg)
1h right ascension = 15:00:00.0 degrees
```

--------------------------------

### Instantiate Galactic from another coordinate with optional epoch

Source: https://rhodesmill.org/pyephem/coordinates

Shows how to create a Galactic coordinate from another coordinate (north_pole) and optionally specify an alternate epoch.

```python
Galactic(north_pole)
Galactic(north_pole, epoch='1900')
```

--------------------------------

### Print epoch of ecliptic coordinates

Source: https://rhodesmill.org/pyephem/coordinates.html

Shows that the epoch of the resulting ecliptic coordinates matches the body's astrometric epoch. The example prints the epoch of the ecliptic object.

```python
>>> print(ecl.epoch)
2000/1/1 12:00:00
```

--------------------------------

### Normalize angles with norm and znorm

Source: https://rhodesmill.org/pyephem/angle.html

The norm attribute returns the angle in [0, 2π) and znorm returns it in (-π, π]. The examples show various inputs and their normalized outputs.

```python
>>> circle = 2 * math.pi
```

```python
>>> a = + fifteen_degrees
>>> print('%s %s %s' % (a, a.norm, a.znorm))
15:00:00.0 15:00:00.0 15:00:00.0
```

```python
>>> a = - fifteen_degrees
>>> print('%s %s %s' % (a, a.norm, a.znorm))
-15:00:00.0 345:00:00.0 -15:00:00.0
```

```python
>>> a = ephem.degrees(circle - fifteen_degrees)
>>> print('%s %s %s' % (a, a.norm, a.znorm))
345:00:00.0 345:00:00.0 -15:00:00.0
```

```python
>>> a = ephem.degrees(circle + fifteen_degrees)
>>> print('%s %s %s' % (a, a.norm, a.znorm))
375:00:00.0 15:00:00.0 15:00:00.0
```

```python
>>> a = ephem.degrees(- circle + fifteen_degrees)
>>> print('%s %s %s' % (a, a.norm, a.znorm))
-345:00:00.0 15:00:00.0 15:00:00.0
```

```python
>>> a = ephem.degrees(- circle - fifteen_degrees)
>>> print('%s %s %s' % (a, a.norm, a.znorm))
-375:00:00.0 345:00:00.0 -15:00:00.0
```

--------------------------------

### Create Mars with date and print elongation and size

Source: https://rhodesmill.org/pyephem/quick.html

Creates a Mars body with a specific date, which triggers an initial compute. Prints the name, elongation, and size.

```python
>>> m = ephem.Mars('2003/8/27')
>>> print('%s %s %.10f' % (m.name, m.elong, m.size))
Mars -173:00:34.2 25.1121063232
```

--------------------------------

### Print Jupiter's declination as degrees

Source: https://rhodesmill.org/pyephem/angle.html

Shows that an ephem.Angle prints as degrees, minutes, and seconds of arc. The example creates a Jupiter object for a specific date and prints its declination.

```python
>>> import ephem
>>> j = ephem.Jupiter('1994/7/16 20:13:16')
>>> print(j.dec)
-12:09:28.2
```

--------------------------------

### Find next satellite pass with next_pass()

Source: https://rhodesmill.org/pyephem/quick.html

Demonstrates using ephem.readtle() to create an EarthSatellite from TLE lines and then boston.next_pass() to find the next pass. The output shows the rise time and azimuth.

```python
>>> line1 = "IRIDIUM 80 [+]"
>>> line2 = "1 25469U 98051C   09119.61415140 -.00000218  00000-0 -84793-4 0  4781"
>>> line3 = "2 25469  86.4029 183.4052 0002522  86.7221 273.4294 14.34215064557061"
>>> iridium_80 = ephem.readtle(line1, line2, line3)
>>> boston.date = '2009/5/1'
>>> info = boston.next_pass(iridium_80)
>>> print("Rise time: %s azimuth: %s" % (info[0], info[1]))
Rise time: 2009/5/1 00:22:15 azimuth: 104:36:16.0
```

--------------------------------

### List of Observer methods for transit, rising, and setting

Source: https://rhodesmill.org/pyephem/quick.html

Lists the eight Observer methods available for finding when an object rises, transits, or sets. Each takes a Body argument (except EarthSatellite) and returns a Date if successful.

```python
previous_transit()
next_transit()

previous_antitransit()
next_antitransit()

previous_rising()
next_rising()

previous_setting()
next_setting()
```
Tokens:
Raw