Python学习笔记(2)——函数与面向对象编程

函数

• input()函数：input(参数) //参数为提示信息

• 接收到的对象默认会被传递为string类型

• 函数：带名字的代码块，用于完成具体的任务，是对某一功能的抽象

• 格式：

  • 声明：

  def 函数名(形式参数列表):
      """函数体"""
      语句1
      语句2
      ...
      return None
  

  • 调用：函数名(实际参数列表)
  • 注意：
    • 参数即需要从函数外部传入的对象
    • 实参列表对应形参列表，声明函数时，形式参数可省略，也可以有多个
    • 函数名下一行的三个双引号注释中，在python代表该函数的说明文档
    • 任何函数都有返回值，即便写return语句也会自动返回一个None

• 示例：

  def get_point(point_x1, point_y1, point_x2, point_y2):
      """传入点坐标，计算两点间距离"""
      delta_x = (point_x1 - point_x2) ** 2
      delta_y = (point_x2 - point_y2) ** 2
      distns = (delta_x + delta_y) ** 0.5
      print('the distance of two point is : '+ str(distns))
      point_x1+=1
      return distns
  
  x1 = 2.0
  y1 = 1.0
  x2 = 3.0
  y2 = 2.0
  get_point(x1, y1, x2, y2)
  print()
  print(get_point(x1, y1, x2, y2))
  print(x1)
  ==================Run=====================
  the distance of two point is : 1.4142135623730951
  
  the distance of two point is : 1.4142135623730951
  1.4142135623730951
  2.0
  

  • 注意：
    • 变量作为实参直接传入函数不会被改变

参数

函数是对某一个功能的抽象，对于一个需要重复执行的操作，每次仅有某几个值不同，这时就使用到了参数

形参

• 形参：函数完成其工作所需要的一项信息

实参

• 实参：调用函数时传递给函数的信息

• 参数的传递：

  • 位置实参：默认的参数关联方式

    • 按照形式参数的位置，将实参按顺序一一传递给对应位置的形参

    • 示例：

      def eg_func(param_1, param_2, param_3):
          print('%s %s %s' % (param_1, param_2, param_3))
          return None
      argum_1 = 'LiLei'
      argum_2 = 'ai'
      argum_3 = 'HanMeiMei'
      eg_func(argum_1, argum_2, argum_3)
      print()
      eg_func(argum_1, argum_3, argum_2)
      ==================Run=====================
      LiLei ai HanMeiMei
      
      LiLei HanMeiMei ai
      

    • 注意：

      • 按位置传递实参好处是简单方便，但必须严格按照位置顺序逐个传递
      • 坏处就是当形式参数比较复杂的时候，参数的传递可能会出现混乱

  • 关键字实参：

    • 将实参的值与形参的名称对应

    • 示例：

      def eg_func(param_1, param_2, param_3):
          print('%s %s %s' % (param_1, param_2, param_3))
          return None
      argum_1 = 'LiLei'
      #argum_2 = 'ai'
      argum_3 = 'HanMeiMei'
      
      eg_func(param_1=argum_1, param_2='ai', param_3= argum_3)
      ==================Run=====================
      LiLei ai HanMeiMei
      

    • 分析：

      • 实际上是在调用函数时，直接指定某一形参的值
      • 该传递方式发生在函数调用过程中

  • 默认参数

    • 在声明函数时，直接给形式参数指定默认的值，用于实参缺省时

    • 示例：

      def eg_func(param_1, param_2, param_3='LiLei'):
          print('%s %s %s' % (param_1, param_2, param_3))
          return None
      argum_1 = 'LiLei'
      argum_2 = 'ai'
      
      eg_func(argum_1, argum_2)
      eg_func(argum_1, argum_2, argum_3)
      ==================Run=====================
      LiLei ai LiLei
      LiLei ai HanMeiMei
      

    • 注意：

      • 默认参数的指定发生在函数声明时
      • 一个形参指定了默认值后，如果没有参数值传递进来，则调用默认值
      • 默认参数的指定必须从形参列表的最右侧开始

  • 传递列表

    • 直接传入列表可能会导致原有数据被改变，为防止此问题可传入切片

返回值

函数可以只执行某些操作，也可以同时返回某些对象

在python中，任何函数都有返回值，如果缺省会返回None

• 返回简单值

  • 示例：

    PI = 3.14159
    def get_circle_area(radius):
        area = radius ** 2 * PI
        return area
    print(get_circle_area(2))
    ==================Run=====================
    12.56636
    

• 返回字典

  • 示例：

    def city_country(citys, countrys):
        dict_city_country = {}
        for tmp in citys:
            i = 1
            dict_city_country[tmp] = countrys[i]
            i+=1
        return dict_city_country
    
    citys = ['Roma', 'Washington', 'Beijing', 'Tokyo']
    countrys = ['Itally', 'America', 'China', 'Japan']
    print(city_country(citys, countrys))
    ==================Run=====================
    {'Roma': 'America', 'Washington': 'America', 'Beijing': 'America', 'Tokyo': 'America'}
    

• 返回列表

  • 示例：

    def get_name_list():
        names = []
        while(1):
            name = input("Input Student Name: ")
            if name == 'q':
                break
            else:
                names.append(name)
        return names
    
    print(get_name_list())
    ==================Run=====================
    Input Student Name: maria
    Input Student Name: david
    Input Student Name: seven
    Input Student Name: q
    ['maria', 'david', 'seven']
    

可变参数

• 传递任意数量的实参

• 格式：def 函数名(*形参名)

• 示例：

  def print_time(*dates):
      print(dates)
  
  print_time(2020, 7, 17)
  ==================Run=====================
  (2020, 7, 17)
  

• 注意：

  • 通过可变参数传入的实参，在函数内部会被封装为一个元组(不可修改的列表)
  • 可以将可变参数当做一个序列来处理

模块与函数

使用函数，可以将代码块与主程序分离，而函数可以被存储在单独的文件中，某一程序在需要时可以将其导入，这样的文件就是模块

模块可以让编程的重点放到高层逻辑中，而不是程序代码的细节，并且可以让代码的重用性更高

导入

• 导入模块

  • 前提：主程序所在的目录中，模块(文件)已存在

  • 格式：import module_name

  • 示例：

    • 当前目录下：pizza.py making_pizzas.py

    # ./pizza.py
    def make_pizza(size, *toppings):
        """概述要制作的披萨"""
        print("\nMaking a " + str(size) +
              "-inch pizza with the following toppings: ")
        for topping in toppings:
            print("-" + topping)
    

    # ./making_pizzas.py
    import pizza
    
    pizza.make_pizza(16, 'pepperoni')
    pizza.make_pizza(12, 'mushrooms', 'green peppers',
                     'extra cheese')
    ==================Run=====================
    Making a 16-inch pizza with the following toppings: 
    -pepperoni
    
    Making a 12-inch pizza with the following toppings: 
    -mushrooms
    -green peppers
    -extra cheese
    

  • 注意：

    • 该方式导入是直接将整个模块导入了进来
    • 使用import也可以导入模块中的特定函数

• 导入特定函数

  • 格式：from module_name import function_name

  • 示例：

    from pizza import make_pizza
    
    make_pizza(16, 'pepperoni')
    make_pizza(12, 'mushrooms', 'green peppers',
                     'extra cheese')
    ==================Run=====================
    Making a 16-inch pizza with the following toppings: 
    -pepperoni
    
    Making a 12-inch pizza with the following toppings: 
    -mushrooms
    -green peppers
    -extra cheese
    

  • 注意：

    • 导入特定函数后，调用时直接用该函数名即可，不再使用.+函数名()的方式来调用

• 导入模块中所有函数

  • 格式：from module_name import *

  • 示例：

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

指定别名

Python中，可以使用as来给要导入的模块或函数来指定别名，作用范围是当前主程序

• 指定模块别名

  • 格式：import module_name as alias_name

  • 示例：

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

• 指定函数别名

  • 格式：from module_name import function_name as alias_name

  • 示例：

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

函数编写规范

• 函数名应符合命名规范，且有意义
• 每个函数都应该有注释文档，对其功能、形参、返回值等进行简单阐述
• 为函数的某一参数指定值时，该参数等号两边不应有空格
• 一行代码不应超过79个字符，若超过应在下一行接续
• 程序或函数中若包含多个函数，应使用不超过三个(通常为两个)的空行将他们相互分隔
• 所有的import语句都应该写在文件开头，除非文件开头使用了对整个程序进行说明的注释

面向对象

面向对象编程思想：万物皆对象

面向对象编程三大特征：封装，继承，多态

类

• 将对象抽象后的代码叫类，将这段代码实例化的具体对象称为对象

• 一般的，类包含两部分：

  • 存储数据的属性
  • 执行操作的方法

• 格式：

  • 声明类：

    class 类名(父类名):
        语句1
        语句2
        ...
    

  • 创建实例：

    实例名1 = 类名(实参列表)
    实例名2 = 类名(实参列表)
    

• 示例：

  class Dog():
      """模拟一只狗"""
      def __init__(self, name, age):
          """对狗的name和age两个属性初始化"""
          self.name = name
          self.age = age
          
      def sit(self):
          """命令狗坐下"""
          print(self.name.title() + " is now sitting")
      
      def roll_over(self):
          print(self.name.tittle() + " rolled over!")
          
  my_dog = Dog('Buddy', 8)
  my_dog.sit()
  my_dog.roll_over()
  print(my_dog.name)
  ==================Run=====================
  Buddy is now sitting
  Buddy rolled over!
  Buddy
  

• 注意：

  • 在声明类时，类名后的括号中书写需要继承的父类名，缺省则不继承
  • 类中的函数叫方法，类中的变量叫属性
  • __init__类似构造函数，一般用来初始化类内的属性，产生新的实例时自动调用
  • self是每个类方法都不可缺少的形参，且必须在第一位
  • 在__init__方法中的两个以self.为前缀的变量，表示其是属于类的属性，可供类内所有方法使用，可以通过实例名.变量名的方式直接访问

属性与方法

• 属性：

  • 类中存储数据的对象，可以是变量、列表、字典等
  • 模拟现实对象的一些详细特征或数据
  • 类的每个属性都必须有初始值

• 方法：

  • 类的函数叫方法
  • self是每个类方法都不可缺少的形参，且必须在第一位

• 指定属性默认值

  • 示例：

    class Car():
        def __init__(self, make, model, year=2000):
            self.make = make
            self.model = model
            self.year = year
            self.odometer = 0
            
        def print_information(self):
            print(self.make + ' ' + self.model +
              ' made in ' + str(self.year) + 's' +
              '\nOdometer is: ' + str(self.odometer))
        
        def print_odometer(self):
            print(self.model + ' has run ' +
                  str(self.odometer) + 'km')
    
    my_car = Car('kia', 'k3')
    my_car.print_information()
    print('odemeter is: ' + str(my_car.odometer))
    ==================Run=====================
    kia k3 made in 2000s
    Odometer is: 0
    

  • 说明：指定属性值有两种方法

    • 在形参列表中指定
    • 在声明属性时直接初始化

• 修改属性值

  • 直接修改：使用实例对属性进行访问并修改

    class Car():
        --类内语句同上--
    
    my_new_car = Car('BYD', 'e3', 2019)
    my_new_car.print_odometer()
    my_new_car.odometer = 128  # 通过实例直接修改属性
    print('\nupdated:')
    my_new_car.print_odometer()
    ==================Run=====================
    e3 has run 0km
    
    updated:
    e3 has run 128km
    

  • 使用方法修改：

    class Car():
        --语句同上--
        
        def update_odometer(self, odmtr): # 使用方法修改属性
            self.odometer += odmtr
            
    my_new_car.print_odometer()
    my_new_car.update_odometer(10)
    print('\nupdated:')
    my_new_car.print_odometer()
    my_new_car.update_odometer(50)
    print('\nupdated:')
    my_new_car.print_odometer()
    ==================Run=====================
    e3 has run 0km
    
    updated:
    e3 has run 10km
    
    updated:
    e3 has run 60km
    

继承

• 继承：

  • 如果在声明类名时，括号内写上了另一个类的类名，则该类自动获得另一个类的所有属性和方法
  • 原有的类叫父类，新的类叫子类
  • 子类可以增加自己的属性和方法

• 示例：

  # 新建一个Electric子类，继承自Car类
  class Car():
    --类中语句同上--
  
  class Electric(Car):
      def __init__(self, make, model, year):
          # 使用super()函数调用父类__init__方法，初始化父类属性并继承
          super().__init__(make, model, year)
          # 定义子类的属性
          self.battery_size = 100
      
      # 子类的方法
      def get_battery(self):
          return self.battery_size
      
      def print_battery(self, batry_siz):
          print('the battery of this electric car is: ' 
                + str(batry_siz) + 'kWh')
      
      # 在子类中重写父类的update_odometer()方法
      def update_odometer(self, odmtr, batry_siz):
          self.odometer = odmtr
          self.battery_size = batry_siz
  
  my_elec = Electric('Tesla', 'Model X', 2019)
  my_elec.print_information()
  # 使用get_battery返回的值作为实参，传入print_battery方法
  my_elec.print_battery(my_elec.get_battery())
  print()
  # 调用重写后的update_odometer()方法
  my_elec.update_odometer(21, 90)
  my_elec.print_information()
  my_elec.print_battery(my_elec.get_battery())
  
  ==================Run=====================
  Tesla Model X made in 2019s
  Odometer is: 0
  the battery of this electric car is: 100kWh
  
  Tesla Model X made in 2019s
  Odometer is: 21
  the battery of this electric car is: 90kWh
  

• 说明：

  • 子类的__init__方法中，super()是将子类与父类关联的特殊函数，让子类能够调用父类的__init方法，以初始化父类的属性

  • 使用子类创建的实例可以使用子类和父类的所有属性和方法

  • 子类中可以对父类的方法重新定义，只要重写一个同名方法即可

  • 类中可以使用其他类作为属性，示例如下：

    class Car():
        --语句同上--
    
    class Battery():
        """模拟电动汽车电瓶"""
        def __init__(self, battery_size):
            """初始化电瓶属性"""
            self.battery_size = battery_size
        
        def describe_battery(self):
            """将电瓶容量输出到屏幕"""
            print("This cas has a " + str(self.battery_size)
                  + "kWh battery.")
    
    class ElectricCar(Car):
        """电动汽车的独特之处"""
        def __init__(self, make, model, year, btsiz):
            """
            先初始化父类Car的属性
            然后初始化子类ElectricCar的属性
            """
            super().__init__(make, model, year)
            # battery属性为Battery类的实例
            self.battery = Battery(btsiz)
            
    my_tesla = ElectricCar('tesla', 'model s', 2016, 70)
    my_tesla.print_information()
    my_tesla.battery.describe_battery()
    ==================Run=====================
    tesla model s made in 2016s
    Odometer is: 0
    This cas has a 70kWh battery.
    

模块与类

• 与导入函数模块相同，善加利用模块文件可以让代码变得简洁
• 类的导入主要以下几种方式：
  • 导入单个类
    • 格式：
      • from 模块文件名 import 类名
  • 导入一个模块中的多个类
    • 格式：
      • from 模块文件名 import 类名1, 类名2, ....
    • 类名之间用逗号分隔，并可以在逗号后加上一个空格
  • 导入整个模块
    • 格式：
      • import 模块文件名
    • 这时需要用模块文件名.类名的方式调用类，不能像前两种方式一样直接使用类名
  • 导入模块中的所有类（不推荐）
    • 该方式并不推荐，易造成类的调用追溯混乱，且可能会引发同名冲突
    • 格式：
      • from 模块文件名 import *

python标准库

• 标准库：
  • python安装完成后都包含的一组模块，其内写好了多种使用函数和类
  • 多加使用已有的库可以极大提高开发效率

类编程规范

• 命名：
  • 类名应采用大驼峰命名法，类名中不使用下划线区分每个单词，而是将每个单词首字母大写
  • 类的实例，以及模块名都应该采用小写格式，并在单词之间加上下划线
• 文档：
  • 每个类名后都应该紧跟一个对类进行简单说明的文档字符串
  • 每个模块也应该包含一个文档字符串，对其内的类的功能进行简单描述
• 代码分隔：
  • 在类中，使用一个空行来分隔方法
  • 在模块中，使用两个空行分隔类
• 模块导入：
  • 同时导入标准库的模块和自定义模块时，将标准库的import语句写完后空一行，然后再导入自定义模块