#set document(title: "11.6 Chapter summary", author: "OpenStax / XYZ Homework")
#set page(width: 8.5in, height: auto, margin: 1in)
#import "@preview/cetz:0.5.2"
#set text(font: ("STIX Two Text", "Libertinus Serif", "New Computer Modern"), size: 10.5pt, lang: "en")
#show math.equation: set text(font: ("STIX Two Math", "New Computer Modern Math"))
#set par(justify: true, leading: 0.62em, spacing: 0.9em)
#set enum(spacing: 1.1em)   // room between list items so tall inline fractions don't collide
#set list(spacing: 1.1em)
#set table(stroke: 0.5pt + rgb("#c7ccd3"))

#let BLUE = rgb("#183B6F")     // brand navy — section bars + example/solution labels (white on navy 11.09:1)
#let ORANGE = rgb("#A94509")   // brand primary-700 — AA-safe deep orange for TEXT (5.93:1 on white; raw brand #F37021 is 2.94:1 and must never carry text)
#let RED = rgb("#DC2626")      // brand error-600
#let GREEN = rgb("#059669")    // brand success-600 (decoration only; small green text uses green-text #007942)

#show heading.where(level: 1): it => block(width: 100%, above: 0pt, below: 16pt,
  fill: gradient.linear(BLUE, rgb("#2C5AA0")), inset: (x: 14pt, y: 12pt), radius: 3pt,
  text(fill: white, weight: "bold", size: 19pt, it.body))
#show heading.where(level: 2): it => block(width: 100%, above: 18pt, below: 10pt,
  fill: BLUE, inset: (x: 10pt, y: 6pt), radius: 2pt,
  text(fill: white, weight: "bold", size: 12pt, it.body))
#show heading.where(level: 3): it => text(fill: ORANGE, weight: "bold", size: 12.5pt, it.body)
#show heading.where(level: 4): it => text(fill: BLUE, weight: "bold", size: 10.5pt, it.body)

#let examplebox(label, title, body) = block(width: 100%, breakable: true,
  fill: rgb("#EFF1F5"), stroke: 0.5pt + rgb("#CFDDF0"), radius: 4pt, inset: 10pt,
  above: 12pt, below: 12pt)[
  #block(below: 6pt)[#box(fill: BLUE, inset: (x: 6pt, y: 2pt), radius: 2pt,
    text(fill: white, weight: "bold", size: 8.5pt, label)) #h(0.4em) #strong[#title]]
  #body]

// rail = decorative left rule (raw brand token); labelcolor = AA-safe label text shade
#let notebox(label, rail, labelcolor, tint, body) = block(width: 100%, breakable: true, fill: tint,
    stroke: (left: 3pt + rail), inset: (left: 10pt, rest: 8pt), radius: (right: 4pt),
    above: 11pt, below: 11pt)[
    #text(fill: labelcolor, weight: "bold", size: 7.5pt, tracking: 0.5pt)[#upper(label)]
    #linebreak() #body]

#let solutionbox(body) = block(above: 4pt, below: 8pt)[
  #text(fill: BLUE, weight: "bold", size: 8.5pt)[Solution] #linebreak() #body]

#let figph(msg) = block(width: 100%, height: 60pt, fill: rgb("#f6f7f9"),
  stroke: (paint: rgb("#c7ccd3"), dash: "dashed"), radius: 4pt, inset: 10pt)[
  #align(center + horizon, text(fill: rgb("#889"), style: "italic", size: 9pt, msg))]

// Standardize inlined figure sizes: measure the natural CeTZ canvas, then scale to a
// consistent envelope (aspect-aware; see build_typst.py FIG_* constants). Unlike the
// print preamble, dimensions are FLOORED: in an editor a user can trim a figure to a
// degenerate 1-D shape (a bare line), and w/h or tw/w would then divide by zero.
#let _STD_W = 3.5
#let _WIDE_W = 5.6
#let _MAX_H = 3.4
#let _ASPECT_WIDE = 2.2
#let _UPSCALE_MAX = 1.15
#let stdfig(body) = context {
  let m = measure(body)
  let w = calc.max(m.width / 1in, 0.01)
  let h = calc.max(m.height / 1in, 0.01)
  let tw = if w / h > _ASPECT_WIDE { _WIDE_W } else { _STD_W }
  let s = calc.min(tw / w, _MAX_H / h, _UPSCALE_MAX)
  align(center, box(scale(x: s * 100%, y: s * 100%, reflow: true, body)))
}

#show figure: set block(breakable: false)
#set figure(gap: 8pt)
#show figure.caption: set text(size: 8.5pt, fill: rgb("#555"))


  
== 11.6#h(0.6em)Chapter summary


  
    
=== 


    Highlights from this chapter include:


    - Object-oriented programming involves grouping related fields and procedures into objects using data abstraction and encapsulation.
- Classes define a type of object with attributes and methods.
- Instances of a class type represent objects and are created using \_\_init\_\_().
- Attributes may belong to the instance (unique for each instance) or the class (shared by all instances).
- Instance methods have the first parameter self to access the specific instance.
- Python uses magic methods to perform "under-the-hood" actions for users. Magic methods always start and end with double underscores.
- Python allows overloading of existing operators for user-defined classes.
- Classes can be imported from modules by name or can be renamed using aliases.


    At this point, you should be able to write classes that have instance attributes, class attributes, and methods, and import classes from modules. You should also be able to overload operators when defining a class.


    #figure(table(
  columns: 2, align: left, inset: 6pt,
  table.header([Construct], [Description]),
  [Class definition], [class ClassName:
  """Docstring"""],
  [\_\_init\_\_()], [class ClassName:
  def \_\_init\_\_(self):
    \# Initialize attributes],
  [Attributes], [class ClassName:
  class\_attr\_1 = \[value\]
  class\_attr\_2 = \[value\]

  def \_\_init\_\_(self):
    instance\_attr\_1 = \[value\]
    instance\_attr\_2 = \[value\]
    instance\_attr\_3 = \[value\]],
  [Methods (instance)], [class ClassName:

  def \_\_init\_\_(self):
    instance\_attr\_1 = \[value\]
    instance\_attr\_2 = \[value\]
    instance\_attr\_3 = \[value\]

  def method\_1(self, val1, val2):
    \# Access/change attributes

  def method\_2(self):
    \# Access/change attributes],
  [Instances], [instance\_1 = ClassName()
instance\_1.instance\_attr\_1 = \[new value\]
instance\_2 = ClassName()
instance\_2.method\_2()],
  [Overloaded multiplication operator], [class ClassName:
  \# Other methods

  def \_\_mul\_\_(self, other):
    return ClassName(self.instance\_attr\_3 \* other.instance\_attr\_3)],
  [Import class from module with alias], [from class\_module import ClassName as ClassAlias],
))