目录

第一章：变量和数据类型

1.1输出：

1.2 变量：

1.3字符串：

      1.3.1定义字符串：

      1.3.2字符串的修改：

         1.3.4删除空白：

         1.4数：

                   1.4.1整数：

                   1.4.2浮点数：

      1.4.3整数和浮点数：

           1.4.4 数中的下划线：

             1.4.5 同时给多个变量赋值：

            1.4.6 常量: 

    1.5注释

           1.5.1 如何编写注释：

第二章：列表

     2.1列表定义：

          2.1.1访问列表元素：

          2.1.2索引从0而不是1开始:

           2.1.3 使用列表中的各个值

2.2修改、添加和删除元素：

   2.2.1修改列表元素：

    2.2.2 在列表中添加元素：

              2.2.3 从列表中删除元素：

2.3组织列表

             2.3.1 使用方法sort() 对列表永久排序

            2.3.2 使用函数sorted() 对列表临时排序

2.3.3 倒着打印列表

   2.3.4 确定列表的长度

第三章 列表操作

    3.1 遍历整个列表：

                       如此将会把列表中的每一个元素打印一遍     3.1.1 深入研究循环：

          3.1.2 在for 循环中执行更多操作：

3.2 创建数值列表

       3.2.1 使用函数range()

         3.3.2 使用range() 创建数字列表

  3.3.3对数字列表执行

      3.3.4 列表解析：

3.4 使用列表的一部分：

    3.4.1 切片

    3.4.2 遍历切片

                                    3.4.3 复制列表

3.5元组

      3.5.1 定义元组

       3.5.3 修改元组变量

第四章 if 语句

    4.1 if语句的作用：

  4.2 复杂的if语句

  4.3如何判断列表是否为空？

第七章：函数

  7.1 定义函数

      7.1.1 向函数传递信息

    7.1.2 实参和形参

     7.2 传递实参

      7.2.1 位置实参

          7.2.2 关键字实参

      7.2.3 默认值

   7.3 返回值

         7.3.1 返回简单值

       7.3.2 让实参变成可选的

        7.3.3 返回字典

   7.5 传递任意数量的实参

     7.5.1 结合使用位置实参和任意数量实参

  7.5.2 使用任意数量的关键字实参

   7.6.1 导入整个模块

      7.6.3 使用as 给函数指定别名

      7.6.4 使用as 给模块指定别名

          7.6.5 导入模块中的所有函数

           7.7 函数编写指南

第八章 类

    8.1 创建和使用类

        8.1.1 创建Dog 类

8.1.2 根据类创建实例

8.2 使用类和实例

8.2.1 Car 类

8.2.2 给属性指定默认值

8.2.3 修改属性的值

9.3 继承：

9.3.1 子类的方法__init__()

9.3.2 给子类定义属性和方法

9.3.3 重写父类的方法

9.3.4 将实例用作属性

第一章：变量和数据类型

1.1输出：

      在python中的”输出语句“为” print（）“

1.2 变量：

            变量的命名规则：

                                变量名只能包含字母、数字和下划线。
                                变量名不能包含空格，但能使用下划线来分隔其中的单词。
                                变量名应既简短又具有描述性。

1.3字符串：

      1.3.1定义字符串：

                   就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号。
                   eg：'HELLO' 或者 "HELLO" 
                    
                   备注：二者不可混合使用，使用”单引号“开头时必须使用”单引号“结尾。
                             并且引号必须成对存在。
                             这种灵活性让你能够在字符串中包含引号和撇号：
                   eg：
                        'I told my friends "It is easy for me to learn python".'

      1.3.2字符串的修改：

                    python中有专门针对字符串修改的语句：

                      方法title（）：即将每个单词的首字母。都改为大写。
                         upper（）：将所有单词全部大写。
                          lower（）：将所有单词全部小写。
          
                     

name = "Ada Lovelace"
print(name.title())
print(name.upper())
print(name.lower())

  
      1.3.3在字符串中使用变量：

                      在这里要使用到“f字符串”格式为 f'{变量} {变量} Hello'

                               

 name='咸蛋超人'
 print(f"{name),hello!")

                      同时在使用f字符串是同样可以在{}中对变量进行修改：

                             

  name='jiamianqishi'
  print(f"{name.upper(),hello!")

                       f字符串也可以在变量中使用：

                                                                   

 first_name = "ada"
 last_name = "lovelace"
 full_name = f"{first_name} {last_name}"
 print(f"Hello, {full_name.title()}!")

                   
                       制表符（t)和换行符（n）：
                                                          t ：   >>> print("Python")
                                                                    Python
                                                                   >>> print("tPython")
                                                                        Python
    
                                                                  制表符使得打印的字符串空出四个空格（一个制表符tab相当于四个空格）
 
                                                         n:        print("Languages:nPythonnCnJavaScript")
                                                                     Languages:
                                                                     Python
                                                                     C
                                                                     JavaScript

         1.3.4删除空白：

                                删除字符串末尾的空白可使用方法 变量.rstrip()
                                删除字符串开头的空白可使用方法 变量.lstrip()
                                删除字符串两端的空白可使用发放 变量.strip()

         1.4数：

                   1.4.1整数：

                                在Python中，可对整数执行加（+ ）减（- ）乘（* ）除（/ ）运算。
                                     eg：>>> 2 + 3
                                             5
                                             >>> 3 - 2
                                             1
                                             >>> 2 * 3
                                             6
                                             >>> 3 / 2
                                             1.5   

                                 python使用两个乘号表示乘方运算：

                                              A**B A是底数 B是幂次    

                                      eg：>>> 3 ** 2
                                             9
                                             >>> 3 ** 3
                                             27
                                             >>> 10 ** 6
                                             1000000

                   1.4.2浮点数：

                                   浮点数的定义：Python将所有带小数点的数称为浮点数。
    
                                   对浮点数的计算中需要注意的是，结果包含的小数位数可能是不确定的。
                  
                                   eg：>>> 0.2 + 0.1
                                           0.30000000000000004
                                          >>> 3 * 0.1
                                          0.30000000000000004

      1.4.3整数和浮点数：

                                  将任意两个数相除时，结果总是浮点数，即便这两个数都是整数且能整除：
                                     eg  >>> 4/2
                                           2.0
                                  在其他任何运算中，如果一个操作数是整数，另一个操作数是浮点数，结果也总是浮点数：
                                    >>> 1 + 2.0
                                    3.0
                                    >>> 2 * 3.0
                                    6.0
                                    >>> 3.0 ** 2
                                    9.0
                                   无论是哪种运算，只要有操作数是浮点数，Python默认得到的总是浮点数，即便结果原本为整数也是如此。

           1.4.4 数中的下划线：

                                         书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读：
                                          >>> universe_age = 14_000_000_000
                                         当你打印这种使用下划线定义的数时，Python不会打印其中的下划线：
                                          >>> print(universe_age)
                                          14000000000
                                         这是因为存储这种数时，Python会忽略其中的下划线。将数字分组时，即便不是将每三位分成一组，也不会影响最终的值。在Python看来，1000 与1_000 没什么不同，
                                         1_000 与10_00 也没什么不同。这种表示法适用于整数和浮点数。

 
            1.4.5 同时给多个变量赋值：

                                         可在一行代码中给多个变量赋值，这有助于缩短程序并提高其可读性。这种做法最常用于将一系列数赋给一组变量。

                                          eg >>> x, y, z = 0,0,0

            1.4.6 常量: 

                            常量 类似于变量，但其值在程序的整个生命周期内保持不变。Python没有内置的常量类
                             型，但Python程序员会使用全大写来指出应将某个变量视为常量，其值应始终不变：MAX_CONNECTIONS = 5000
                             在代码中，要指出应将特定的变量视为常量，可将其字母全部大写。

 
   1.5注释

           1.5.1 如何编写注释：

                           在Python中，注释用井号（# ）标识。井号后面的内容都会被Python解释器忽略。

第二章：列表

  

     2.1列表定义：

                   列表由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0～9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。
                   在Python中，用方括号（[] ）表示列表，并用逗号分隔其中的元素。       

                     names=['ju','ma','pao']                                                  

                直接对列表打印时 会将其[]一并打印

          2.1.1访问列表元素：

 
                  要访问列表元素，可指出列表的名称，再指出元素的索引，并将后者放在方括号内。
                   

 names=['ju','ma','pao']
 print(names[0])
      

          2.1.2索引从0而不是1开始:

                         
                     在Python中，第一个列表元素的索引为0，而不是1。多数编程语言是如此规定的，这与列表操作的底层实现相关。    

                        names=['ju','ma','pao']
                        print(names[0])

                        结果:  ju

                      Python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1 ，可让Python返回最后一个列表元素，这种约定也适用于其他负数索引。例如，索引-2 返回倒数第
                       二个列表元素，索引-3 返回倒数第三个列表元素，依此类推。

           2.1.3 使用列表中的各个值

                              你可以像使用其他变量一样使用列表中的各个值。例如，可以使用f字符串根据列表中值来创建消息。

                              下面尝试从列表中提取第一款自行车，并使用这个值创建一条消息：

                                     

 bicycles = ['trek', 'cannondale', 'redline', 'specialized']
 message = f"My first bicycle was a {bicycles[0].title()}."
 print(message)

2.2修改、添加和删除元素：

                                        列表中的元素在被创建后可以进行修改，添加和删除。

   2.2.1修改列表元素：

    直接修改法：
                                         

 bicycles = ['trek', 'cannondale', 'redline', 'specialized']
 bicycles[0]='yongjiu'

                                             进行如上操作则列表中第零个元素会被替换。

    2.2.2 在列表中添加元素：

                            在列表末尾添加元素  列表.append(元素)
                             在任意位置添加元素  列表.insert(索引,元素）                                           

motorcycles.append('ducati')
print(motorcycles)
motorcycles = ['honda', 'yamaha', 'suzuki']

motorcycles.insert(0, 'ducati')
print(motorcycles）

              2.2.3 从列表中删除元素：

                  1使用del 语句删除元素   如果知道要删除的元素在列表中的位置，可使用del 语句。

    删除任意位置元素  del 列表[索引]  注意：del方法比较特殊 （无需添加"."去连接方法和函数）
                                
                                             

del motorcycles[0]
print(motorcycles)

                     2使用pop()删除元素（有时候，你要将元素从列表中删除，并接着使用它的值）

                                            方法pop() 删除列表末尾的元素，并让你能够接着使用它。术语弹出 （pop）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。

                                             

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles）
popped_motorcycle = motorcycles.pop()    

     在程序中 pop(索引)  每出现一次则对应的列表中的元素就会被删除

print(motorcycles)
print(popped_motorcycle)

 若要引用pop(索引) 则直接令  变量=列表.pop(索引)   则在这个过程中索引对应的元素既会被引用也会1从列表删除。
     

 而为了顶出任意位置的索引可以在pop后面的括号里加上索引，那么就可以删除任意位置的元素。
              
  3根据元素删除元素运用 方法remove
             

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
motorcycles.remove('ducati'）

      
     
   注意 ：方法remove() 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要                 使用循环来确保将每个值都删除。

2.3组织列表

             在创建的列表中，列表的排序通常无法预测，Python提供了很多组织列表的方式，可根据具体情况选用。

 
            2.3.1 使用方法sort() 对列表永久排序

                    Python方法sort() 让你能够较为轻松地按照字母顺序对列表进行排序。

  cars = ['bmw', 'audi', 'toyota', 'subaru']
  cars.sort()
  print(cars)      

                  注意：这一方法直接修改了元素顺序，且不可逆。

                 若是想要字母表的逆序排列，那么需要在输出sort(reverse=True)

            2.3.2 使用函数sorted() 对列表临时排序

                  运用函数sorted()可以临时改变列表顺序 让其按照你需要的显示，同时不影响它们在列表中的原始排列顺序。
                  这一函数多用于打印中 sorted(列表）
                                     
                      

 print("nHere is the sorted list:")
 print(sorted(cars))

当需要临时对列表按照字母表反序排列时   sorted(列表,reverse = True) --- 倒叙排列

2.3.3 倒着打印列表

 要反转列表元素的排列顺序，可使用方法reverse() 。注意，reverse() 不是按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序    列表.reverse()

                                           

cars = ['bmw', 'audi', 'toyota', 'subaru']            
print(cars)                                                           
cars.reverse()
print(cars)

     注意：方法reverse() 永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，只需对列表再次调用reverse() 即可。

   2.3.4 确定列表的长度

                           使用函数len() 可快速获悉列表的长度。在下面的示例中，列表包含四个元素，因此其长度为4 ：

                                eg      >>> cars = ['bmw', 'audi', 'toyota', 'subaru']
                                          >>> len(cars)
 

第三章 列表操作

                             学习如何遍历列表                   

    3.1 遍历整个列表：

             遍历整个列表可以使用for循环
                                              B=[.............]
                                              for A in B:      

          利用for循环打印列表中每一个元素， 原理类似于: 每次循环 将取出B中的一个元素和A相关联。

                                            

 magicians = ['alice', 'david', 'carolina']
 for magician in magicians:
     print(magician)

                       如此将会把列表中的每一个元素打印一遍
 
    3.1.1 深入研究循环：

           循环这种概念很重要，因为它是让计算机自动完成重复工作的常见方式之一。

           例如，在前面magicians.py中使用的简单循环里，Python将首先读取其中的第一行代码：

                          for magician in magicians:

                          这行代码让Python获取列表magicians 中的第一个值'alice' ，并将其与变量
                          magician 相关联。接下来，Python读取下一行代码：

                           print(magician)

                            它让Python打印magician 的值，依然是'alice' 。鉴于该列表还包含其他值，
                            Python返回到循环的第一行：

                           for magician in magicians:

                          python获取列表中的下一个名字'david'，并将其与变量magician相关联，再执行下面这行代码：

                                print(magician)

                                Python再次打印变量magician 的值，当前为'david' 。接下来，Python再次执行整个循环，对列表中的最后一个值'carolina' 进行处理。至此，列表中没有其他的值了，因此Python接着执行程序的下一行代码。在这个示例中，for 循环后面没有其他代码，因此程序就此结束。

          3.1.2 在for 循环中执行更多操作：

               在for 循环中，想包含多少行代码都可以。在代码行for magician inmagicians 后面，每个缩进的代码行都是循环的一部分，将针对列表中的每个值都执行一次。因此，可对列表中的每个值执行任意次数的操作。

                注意：for循环后若不缩减则不会加入到循环中，只会在循环结束后运行。
                           且注意不要遗漏for循环后的 : 这个符号

3.2 创建数值列表

                  列表的元素千变万化，可以是字符也可以是数字，本节将学习如何创建数字列表。

 
      3.2.1 使用函数range()

        函数range(A，B)包含了从A到B-1的所有数 也相当于列表[A,..........,B-1]， 但需要注意这里只是相当并不是真正的列表。

               Python中函数range() 让你能够生成一系列数。可以像下面这样使用函数range() 来打印一系列数：
                                       

   for value in range(1, 5):
       print(value）

 
        3.3.2 使用range() 创建数字列表

                                      要创建数字列表，可使用函数list() 将range() 的结果直接转换为列表。如果将range() 作为list() 的参数，输出将是一个数字列表。

                                        

 numbers = list(range(1, 6))
 print(numbers)

                                       结果 [0,1,2,3,4,5]

        使用函数range() 时，还可指定步长。为此，可给这个函数指定第三个参数，Python将根据这个步长来生成数。

                                             

number=list(range(0,10,2)
print(number)

                                              结果 [0,2,4,6,8]

          利用range()几乎可以创建所有数集，。例如，如何创建一个列表，其中包含前10个整数（1～10）的平方呢？

                                     

 number=[]
for X in range(1,10):
    Y=X**2
    number.append(Y)
print(number)

  3.3.3对数字列表执行

    简单的统计计算有几个专门用于处理数字列表的Python函数。例如，你可以轻松地找出数字列表的最大值、最小值和总和：
                                        >>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
                                        >>> min(digits)
                                        0
                                        >>> max(digits)
                                        9
                                        >>> sum(digits)
                                        45                                          

      3.3.4 列表解析：

             
                列表解析 将for 循环和创建新元素的代码合并成一行，并自动附加新元素。

                         

 squares = [value**2 for value in range(1, 11)]                
 print(squares)

3.4 使用列表的一部分：

                           在访问列表单个元素和全体元素的基础上，我们还能访问部分元素。

    3.4.1 切片

 
       要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range()一样，Python在到达第二个索引之前的元素后停止。要输出列表中的前三个元素，需要指定索引0和3，
这将返回索引为0、1和2的元素。           
         
                           

 players = ['charles', 'martina', 'michael', 'florence', 'eli']
 print(players[0:3])

                            结果： ['charles', 'martina', 'michael']

                           注意  如果没有开头索引则默认从第一个元素开始。
                                    如果没有最后一个索引则默认到最后一个元素结束。

    3.4.2 遍历切片

                             如果要遍历列表的部分元素，可在for 循环中使用切片。下面的示例遍历前三名队员，并打印他们的名字：

                                

 players = ['charles', 'martina', 'michael', 'florence', 'eli']
 print("Here are the first three players on my team:")
 for player in players[:3]：
        print(player)

                             
       3.4.3 复制列表

                              要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:] ）。这让Python创建一个始于第一个元素、终止于最后一个元素的切片，
                               即整个列表的副本。
     
                                

players = ['charles', 'martina', 'michael', 'florence', 'eli']
players1=playser[:]
                        

                           如此就将列表players复制了
 
  注意列表复制不能直接将 新列表=原列表 这相当于给原列表起了一个新名字 而本质上两个列表表示的是一个地址的列表。对于这两个列表任意一个的改动都是关联的。
          
                                   

friend_foods = my_foods
my_foods.append('cannoli')
friend_foods.append('ice cream')
print("My favorite foods are:")
print(my_foods)
print("nMy friend's favorite foods are:")
print(friend_foods)

                           结果：
                                    My favorite foods are:
                                    ['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
                                    My friend's favorite foods are:
                                    ['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

3.5元组

          定义：Python将不能修改的值称为不可变 的 ，而不可变的列表被称为元组。

 
     3.5.1 定义元组

          元组看起来很像列表，但使用圆括号而非中括号来标识。定义元组后，就可使用索引来访问其元素，就像访问列表元素一样。
                  
                       

 dimensions = (200, 50)
 print(dimensions[0])
 print(dimensions[1])

               结果:200
                       50

              元组除了其中的元素不可改动和为圆括号之外，其余的同列表并无区别，遍历元组也同样可以使用for循环。

       3.5.3 修改元组变量

              虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改前述矩形的尺寸，可重新定义整个元组：

                 

dimensions = (200, 50)
print("Original dimensions:")
for dimension in dimensions:
    print(dimension)
dimensions = (400, 100)
print("nModified dimensions:")
for dimension in dimensions:
    print(dimension)

                   结果：Original dimensions:
                             200
                             50
                             Modified dimensions:
                             400
                             100

第四章 if 语句

    编程时经常需要检查一系列条件，并据此决定采取什么措施。在Python中，if 语句让你能够检查程序的当前状态，并采取相应的措施。

    4.1 if语句的作用：

    
               if可以用来判断变量是否满足条件。
               输出格式为：if     判断语句：
                                       后续执行语句
               if 判断为真则执行后续语句，若判断为假则跳过后续执行语句。

               判断变量是否相等使用  ==
               判断变量是否不相等用  !=
               python中且用 and    （当and连接两个判断语句时 同真为真 一假都假）
               python中或用or         (当or连接两个判断语句时 一真为真 一假都假）

               python也可以判断某一个元素是否在列表中 需使用关键字 in
               
               eg  requested_toppings = ['mushrooms', 'onions', 'pineapple']
                     >>> 'mushrooms' in requested_toppings
                     True
                     >>> 'pepperoni' in requested_toppings
                     False

                若是检查某一元素不在列表中则使用关键字 not in 用法同上面相同。

  4.2 复杂的if语句
 

          通常我们在判断时有多个条件需要进行判断这个时候我们就可以使用 elif else 两个语句

               

age = 12
if age < 4:
    price = 0
elif age < 18:
    price = 25
elif age < 65:
    price = 40
else:
    price = 20
print(f"Your admission cost is ${price}.")

            当运行到某一条件判断为真时，则会执行此判断语句的后续语句，并跳过余下的判断语句。

             Python并不要求if-elif 结构后面必须有else 代码块。

             if判断语句的后面可以跟不限次数的 elif。

  4.3如何判断列表是否为空？

    
         if 列表:在输入判断语句的后面直接 输入列表 若列表不为空则会返回 True 若为空则会返回 false

第七章：函数

  7.1 定义函数

                 

 def greet_user():
      """显示简单的问候语。"""
       print("Hello!")
       greet_user()

    函数定义格式：开头处的代码行使用关键字def 来告诉Python,你需要定义一个函数，向 Python  指出了函数名 在圆括号内指出函数为完成任务需要什么样的信息。在这里，函数名为greet_user()，紧跟在def greet_user(): 后面的所有缩进行构成了函数体。
                              
    函数调用：调用这个函数，可依次指定函数名以及用圆括号括起的必要信息。

 
     7.1.1 向函数传递信息

              可在函数定义def greet_user() 的括号内添加username 。通过在这里添加username ，可让函数接受你给username 指定的任何值。现在，这个函数要求你调用它时给username 指定一个值。调用greet_user() 时，可将一个名字传递给它，如下所示：

                       

 def greet_user(username):
     """显示简单的问候语。"""
     print(f"Hello, {username.title()}!")
     greet_user('jesse')       

                             -

    7.1.2 实参和形参

                在函数greet_user() 的定义中，变量username 是一个形参 （parameter），即函数完成工作所需的信息。在代码greet_user('jesse') 中，值'jesse' 是一个实参 （argument）。

            注意：大家有时候会形参、实参不分，因此如果你看到有人将函数定义中的变量称为实参或将函数调用中的变量称为形参，不要大惊小怪。

     7.2 传递实参

                    向函数传递实参的方法有很多，有位置实参，也可以使用关键字实参。

      7.2.1 位置实参

                       调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。
                       最简单的关联方式是基于实参的顺序。这种关联方式称为位置实参 。
                        
                           

def describe_pet(animal_type, pet_name):
    """显示宠物的信息。"""
     print(f"nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")
describe_pet('hamster', 'harry')

                      结果：        I have a hamster.
                                        My hamster's name is Harry.

          7.2.2 关键字实参

                                关键字实参 是传递给函数的名称值对。因为直接在实参中将名称和值关联起来，以向函数传递实参时不会混淆（不会得到名为Hamster的harry这样的结果）。关键字实参让你无须考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

                    d

def describe_pet(animal_type, pet_name):
   """显示宠物的信息。"""
   print(f"nI have a {animal_type}.")
   print(f"My {animal_type}'s name is {pet_name.title()}.")
describe_pet(animal_type='hamster', pet_name='harry')

               这样传递实参使得每个值都精确的传递给函数，不收到位置影响。

      7.2.3 默认值

                    编写函数时，可给每个形参指定默认值 。在调用函数中给形参提供了实参时，Python将使用指定的实参值；否则，将使用形参的默认值。
                    因此，给形参指定默认值后，可在函数调用中省略相应的实参。使用默认值可简化函数调用，还可清楚地指出函数的典型用法。

                       

def describe_pet(pet_name, animal_type='dog'):
    """显示宠物的信息。"""
    print(f"nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")
describe_pet(pet_name='willie')

              如此一来，当未给默认值参数赋值时，将会自动默认为默认值。
            注意：指定了默认值的形参必须在最后的位置。
                         其余的参数位置随意。

   7.3 返回值

                      函数并非总是直接显示输出，它还可以处理一些数据，并返回一个或一组值。函数返回的值称为返回值 。

         7.3.1 返回简单值

                           这里是重点，任何引用此函数的程序，会返回方程值。

def get_formatted_name(first_name, last_name):
       """返回整洁的姓名。"""
       full_name = f"{first_name} {last_name}"
       return full_name.title()            #这里是重点，任何引用此函数的程序，会返回方程值。
musician = get_formatted_name('jimi', 'hendrix')
print(musician)

                        结果 :  Jimi Hendrix

       7.3.2 让实参变成可选的

             

 def get_formatted_name(first_name, last_name, middle_name=''):
      """返回整洁的姓名。"""
      if middle_name:
              full_name = f"{first_name} {middle_name} {last_name}"
      else:
              full_name = f"{first_name} {last_name}"
              return full_name.title()
  musician = get_formatted_name('jimi', 'hendrix')
  print(musician)
  musician = get_formatted_name('john', 'hooker', 'lee')
  print(musician)

       令某一形参为空字符，则在输入实参时如果不指定实参，则届时此形参就行未输入一般。

        7.3.3 返回字典

             函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。例如，下面的函 数接受姓名的组成部分，并返回一个表示人的字典：
               

def build_person(first_name, last_name):
     """返回一个字典，其中包含有关一个人的信息。"""
     person = {'first': first_name, 'last': last_name}
     return person
musician = build_person('jimi', 'hendrix')
print(musician)

def build_person(first_name, last_name, age=None):
    """返回一个字典，其中包含有关一个人的信息。"""
    person = {'first': first_name, 'last': last_name}
       if age:
         person['age'] = age
            return person
musician = build_person('jimi', 'hendrix', age=27)
print(musician)

       在函数定义中，新增了一个可选形参age ，并将其默认值设置为特殊值None （表示变量没有值）。可将None 视为占位值。在条件测试中，None 相当于False 。
     如果函数调用中包含形参age 的值，

   7.5 传递任意数量的实参

     有时候，预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参。

     来看一个制作比萨的函数，它需要接受很多配料，但无法预先确定顾客要多少种配料。下面的函数只有一个形参*toppings ，但不管调用语句提供了多
      少实参，这个形参会将它们统统收入囊中：

             

def make_pizza(*toppings):
    """打印顾客点的所有配料。"""
      print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

         形参名*toppings 中的星号让Python创建一个名为toppings 的空元组，

     7.5.1 结合使用位置实参和任意数量实参

    如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。

        

 def make_pizza(size, *toppings):
    """概述要制作的比萨。"""
    print(f"nMaking a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")
 make_pizza(16, 'pepperoni')
 make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

  7.5.2 使用任意数量的关键字实参

       

 def build_profile(first, last, **user_info):
    """创建一个字典，其中包含我们知道的有关用户的一切。"""
      user_info['first_name'] = first
      user_info['last_name'] = last
      return user_info
user_profile = build_profile('albert', 'einstein',
                            location='princeton',
                            field='physics')
print(user_profile)

    形参**user_info 中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称值对都放到这个字典中。

   7.6.1 导入整个模块

    要让函数是可导入的，得先创建模块。模块 是扩展名为.py的文件，然后再此文件下新建一个文件，包含要导入到程序中的代码。

              在pizza.py文件夹下的

             def make_pizza(size, *toppings):
                   """概述要制作的比萨。"""
                  print(f"nMaking a {size}-inch pizza with the following toppings:")
                  for topping in toppings:
                  print(f"- {topping}")

             调用
                        import pizza
                        pizza.make_pizza(16, 'pepperoni')
                        pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

                    Python读取这个文件时，代码行import pizza 让Python打开文件pizza.py

    7.6.2 导入特定的函数

       如果只想导入要使用的函数，代码将类似于下
面这样：                                                                                    只导入特定文件。
                 from pizza import make_pizza                                
                 make_pizza(16, 'pepperoni')
                 make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

         使用这种语法时，调用函数时无须使用句点。由于在import 语句中显式地导入了函数make_pizza() ，调用时只需指定其名称即可。

      7.6.3 使用as 给函数指定别名

    如果要导入函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名 ：函数的另一个名称，类似于外号。
   要给函数取这种特殊外号，需要在导入它时指定。

                  from pizza import make_pizza as mp
                  mp(16, 'pepperoni')
                  mp(12, 'mushrooms', 'green peppers', 'extra cheese')

      7.6.4 使用as 给模块指定别名

              还可以给模块指定别名。通过给模块指定简短的别名（如给模块pizza 指定别名p），让你能够更轻松地调用模块中的函数。相比于
              pizza.make_pizza() ，p.make_pizza() 更为简洁：

              import pizza as p
              p.make_pizza(16, 'pepperoni')
              p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

              以上二者可以混合使用。

          7.6.5 导入模块中的所有函数

               使用星号（* ）运算符可让Python导入模块中的所有函数：

                         from pizza import *
                         make_pizza(16, 'pepperoni')
                         make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

                      import 语句中的星号让Python将模块pizza 中的每个函数都复制到这个程序文件 中。
                      由于导入了每个函数，可通过名称来调用每个函数，而无须使用句点表示法。

           7.7 函数编写指南

                          给形参指定默认值时，等号两边不要有空格：
                          对于函数调用中的关键字实参，也应遵循这种约定
 

第八章 类

             面向对象编程 是最有效的软件编写方法之一。在面向对象编程 中，你编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。编 写类时，你定义一大类对象都有的通用行为。基于类创建对象 时，每个对象都 自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。

    8.1 创建和使用类

                             使用类几乎可以模拟任何东西。

        8.1.1 创建Dog 类

 类格式上的定义：

      class    类名():

                 默认属性

                方法 

  

根据 Dog 类创建的每个实例都将存储名字和年龄，我们赋予了每条小狗蹲下 （ sit() ）和打滚（ roll_over() ）的能力：

 class Dog:
    """一次模拟小狗的简单尝试。"""
    def __init__(self, name, age):
        """初始化属性name和age。"""
         self.name = name
         self.age = age
   def sit(self):
       """模拟小狗收到命令时蹲下。"""
         print(f"{self.name} is now sitting.")
   def roll_over(self):
       """模拟小狗收到命令时打滚。"""
         print(f"{self.name} rolled over!")

方法__init__()：

      类中的函数称为方法 。你在前面学到的有关函数的一切都适用于方法，就目前而 言，唯一重要的差别是调用方法的方式。方法__init__() 是一个特殊方法，每当你根据Dog 类创建新实例时，Python都会自动运行它。

      我们将方法__init__() 定义成包含三个形参：self 、name 和age 。在这个方 法的定义中，形参self 必不可少，而且必须位于其他形参的前面。

    在Python中创建实例时，每个与实例相关联的方法调用都自动传递实参self ，它是一个指 向实例本身的引用，让实例能够访问类中的属性和方法。

8.1.2 根据类创建实例

class Dog:
 --snip--
 my_dog = Dog('Willie', 6)
 print(f"My dog's name is {my_dog.name}.")
 print(f"My dog is {my_dog.age} years old.")

    这这里使用的是前一个示例中编写的 Dog 类。 让Python创建一条名字 为'Willie' 、年龄为 6 的小狗。遇到这行代码时，Python使用实参 'Willie' 和 6 调用 Dog 类的方法 __init__() 。方法 __init__() 创建一个表示特定小狗的 实例，并使用提供的值来设置属性name 和 age 。接下来，Python返回一个表示这 条小狗的实例，而我们将这个实例赋给了变量my_dog 。在这里，命名约定很有 用：通常可认为首字母大写的名称（如Dog ）指的是类，而小写的名称（如 my_dog ）指的是根据类创建的实例。 a. 访问属性   要访问实例的属性，可使用句点表示法。 如下代码来访问 my_dog 的属性name 的值：

my_dog.name

b. 调用方法 根据 Dog 类创建实例后，就能使用句点表示法来调用 Dog 类中定义的任何方法 了。下面来让小狗蹲下和打滚：

class Dog:
 --snip--
my_dog = Dog('Willie', 6)
my_dog.sit()
my_dog.roll_over()

要调用方法，可指定实例的名称（这里是 my_dog ）和要调用的方法，并用句 点分隔。遇到代码my_dog.sit() 时，Python在类 Dog 中查找方法 sit() 并 运行其代码。Python以同样的方式解读代码my_dog.roll_over() 。

8.2 使用类和实例               可使用类来模拟现实世界中的很多情景。  

8.2.1 Car 类

 class Car:
     """一次模拟汽车的简单尝试。"""
     def __init__(self, make, model, year):
         """初始化描述汽车的属性。"""
         self.make = make
         self.model = model
         self.year = year
     def get_descriptive_name(self):
     """返回整洁的描述性信息。"""
         long_name = f"{self.year} {self.make} {self.model}"
         return long_name.title()
 my_new_car = Car('audi', 'a4', 2019)
 print(my_new_car.get_descriptive_name())

8.2.2 给属性指定默认值           下面来添加一个名为 odometer_reading 的属性，其初始值总是为0。我们还添加 了一个名为 read_odometer() 的方法，用于读取汽车的里程表：    

class Car:
   def __init__(self, make, model, year):
     """初始化描述汽车的属性。"""
     self.make = make
     self.model = model
     self.year = year
     self.odometer_reading = 0
   def get_descriptive_name(self):
            --snip--
   def read_odometer(self):
     """打印一条指出汽车里程的消息。"""
     print(f"This car has {self.odometer_reading} miles on it.")
my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()

         现在，当Python调用方法 __init__() 来创建新实例时，将像前一个示例一样以属 性的方式存储制造商、型号和生产年份。接下来，Python将创建一个名为 odometer_reading 的属性，并将其初始值设置为0.

8.2.3 修改属性的值   我们能以三种方式修改属性的值：直接通过实例进行修改，通过方法进行设置，以 及通过方法进行递增（增加特定的值）。下面依次介绍这些方式: a. 直接修改属性的值

class Car:
 --snip--
my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

       这种方法属于直接在对象也就是实例中，对属性进行引用后直接修改的。有时候需要像这样直接访问属性，但其他时候需要编写对属性进行更新的方法。

b. 通过方法修改属性的值 如果有方法能替你更新属性，将大有裨益。这样就无须直接访问属性，而可将 值传递给方法，由它在内部进行更新。（虽然是内部更新，但对象不同则数据还是会同最初始的类）

class Car:
   --snip--
   def update_odometer(self, mileage):
     """将里程表读数设置为指定的值。"""
      self.odometer_reading = mileage
 my_new_car = Car('audi', 'a4', 2019)
 print(my_new_car.get_descriptive_name())
 my_new_car.update_odometer(23)
 my_new_car.read_odometer()

c. 通过方法对属性的值进行递增：        有时候需要将属性值递增特定的量，而不是将其设置为全新的值。假设我们购 买了一辆二手车，且从购买到登记期间增加了100英里的里程。下面的方法让我 们能够传递这个增量，并相应地增大里程表读数：

 class Car:
                        --snip--
         def update_odometer(self, mileage):
                        --snip--
         def increment_odometer(self, miles):
                """将里程表读数增加指定的量。"""
                self.odometer_reading += miles
 my_used_car = Car('subaru', 'outback', 2015)
 print(my_used_car.get_descriptive_name())
 my_used_car.update_odometer(23_500)
 my_used_car.read_odometer()

9.3 继承：      编写类时，并非总是要从空白开始。如果要编写的类是另一个现成类的特殊版本，可使用继承 。一个类 继承 另一个类时，将自动获得另一个类的所有属性和方法。 原有的类称为父类 ，而新类称为 子类 。

9.3.1 子类的方法__init__()

    在既有类的基础上编写新类时，通常要调用父类的方法__init__() 。这将初始化 在父类__init__() 方法中定义的所有属性，从而让子类包含这些属性。  

   下面来模拟电动汽车。电动汽车是一种特殊的汽车，因此可在前面创建的 Car 类的基础上创建新类 ElectricCar 。这样就只需为电动汽车特有的属性和行为编 写代码：

 class Car:
     """一次模拟汽车的简单尝试。"""
     def __init__(self, make, model, year):
         self.make = make
         self.model = model
         self.year = year
         self.odometer_reading = 0
     def get_descriptive_name(self):
         long_name = f"{self.year} {self.make} {self.model}"
         return long_name.title()
     def read_odometer(self):
         print(f"This car has {self.odometer_reading} miles on it.")
     def update_odometer(self, mileage):
         if mileage >= self.odometer_reading:
             self.odometer_reading = mileage
         else:
             print("You can't roll back an odometer!")
     def increment_odometer(self, miles):
         self.odometer_reading += miles
 class ElectricCar(Car):
         """电动汽车的独特之处。"""
        def __init__(self, make, model, year):
             """初始化父类的属性。"""
         super().__init__(make, model, year)
 my_tesla = ElectricCar('tesla', 'model s', 2019)
 print(my_tesla.get_descriptive_name())

super() 是一个特殊函数，让你能够调用父类的方法。这行代码让Python调 用Car 类的方法__init__()，，让ElectricCar 实例包含这个方法中定义的所 有属性。父类也称为超类 （superclass），名称super 由此而来。

        创建ElectricCar 类的一个实例，并将其赋给变量 my_tesla 。这行代码调用ElectricCar 类中定义的方法__init__() ，后者 让Python调用父类Car 中定义的方法__init__() 。

9.3.2 给子类定义属性和方法

        让一个类继承另一个类后，就可以添加区分子类和父类所需的新属性和新方法了。

       下面来添加一个电动汽车特有的属性（电瓶），以及一个描述该属性的方法。我们 将存储电瓶容量，并编写一个打印电瓶描述的方法：   

 class Car:
     --snip--
 class ElectricCar(Car):
     """电动汽车的独特之处。"""
     def __init__(self, make, model, year):
             """
          初始化父类的属性。
          再初始化电动汽车特有的属性。
           """
          super().__init__(make, model, year)
          self.battery_size = 75
    def describe_battery(self):
         """打印一条描述电瓶容量的消息。"""
         print(f"This car has a {self.battery_size}-kWh battery.")
 my_tesla = ElectricCar('tesla', 'model s', 2019)
 print(my_tesla.get_descriptive_name())
 my_tesla.describe_battery()

9.3.3 重写父类的方法

       对于父类的方法，只要它不符合子类模拟的实物的行为，都可以进行重写。为此，可在子类中定义一个与要重写的父类方法同名的方法。这样，Python将不会考虑这 个父类方法，而只关注你在子类中定义的相应方法。 ​​​​​​​      假设 Car 类有一个名为 fill_gas_tank() 的方法，它对全电动汽车来说毫无意 义，因此你可能想重写它。下面演示了一种重写方式：

class ElectricCar(Car):
        --snip--
   def fill_gas_tank(self):
      """电动汽车没有油箱。"""
      print("This car doesn't need a gas tank!")

  现在，如果有人对电动汽车调用方法 fill_gas_tank() ，Python将忽略 Car 类中 的方fill_gas_tank() ，转而运行上述代码。使用继承时，可让子类保留从父 类那里继承而来的精华，并剔除不需要的糟粕。

​​​​​​​9.3.4 将实例用作属性

        使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清 单以及文件都越来越长。在这种情况下，可能需要将类的一部分提取出来，作为一个独立的类。可以将大型类拆分成多个协同工作的小类。

 class Car:
 --snip--
 class Battery:
        """一次模拟电动汽车电瓶的简单尝试。"""
     def __init__(self, battery_size=75):
        """初始化电瓶的属性。"""
      self.battery_size = battery_size
     def describe_battery(self):
       """打印一条描述电瓶容量的消息。"""
        print(f"This car has a {self.battery_size}-kWh battery.")
 class ElectricCar(Car):
       """电动汽车的独特之处。"""
     def __init__(self, make, model, year):
       """
      初始化父类的属性。
      再初始化电动汽车特有的属性。
       """
       super().__init__(make, model, year)
       self.battery = Battery()
 my_tesla = ElectricCar('tesla', 'model s', 2019)
 print(my_tesla.get_descriptive_name())
 my_tesla.battery.describe_battery()

在 ElectricCar 类中，添加了一个名为 self.battery 的属性（见 ❹ ）。这行代 码让Python创建一个新的Battery 实例（因为没有指定容量，所以为默认值75）， 并将该实例赋给属性self.battery 。每当方法 __init__() 被调用时，都将执 行该操作，因此现在每个ElectricCar 实例都包含一个自动创建的 Battery 实 例。