python基础

python

• python概述

• 基础语法

• 流程控制

• 字符串

• 组合数据类型

• 函数

• 文件操作

• 异常

• 模块

• 面向对象

• python概述

  • 第一个python程序

    print("hello python")
    print("hello world")
    

  • 认识python

  • 起源

    • 1989 年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的解释程序，作为 ABC 语言的一种继承（感觉下什么叫牛人）

    • ABC 是由吉多参加设计的一种教学语言，就吉多本人看来，ABC 这种语言非常优美和强大，是专门为非专业程序员设计的。但是 ABC 语言并没有成功，究其原因，吉多认为是非开放造成的。吉多决心在 Python 中避免这一错误，并获取了非常好的效果

    • 之所以选中 Python（蟒蛇） 作为程序的名字，是因为他是 BBC 电视剧——蒙提·派森的飞行马戏团（Monty Python’s Flying Circus）的爱好者

    • 1991 年，第一个 Python 解释器 诞生，它是用 C 语言实现的，并能够调用 C 语言的库文件

  • 特点

    • Python 是完全面向对象的语言
      • 函数、模块、数字、字符串都是对象，在 Python 中一切皆对象
      • 完全支持继承、重载、多重继承
      • 支持重载运算符，也支持泛型设计
    • Python 拥有一个强大的标准库，Python 语言的核心只包含 数字、字符串、列表、字典、文件 等常见类型和函数，而由 Python 标准库提供了 系统管理、网络通信、文本处理、数据库接口、图形系统、XML 处理 等额外的功能
    • Python 社区提供了大量的第三方模块，使用方式与标准库类似。它们的功能覆盖 科学计算、人工智能、机器学习、Web 开发、数据库接口、图形系统 多个领域

    面向对象的思维方式

    • 面向对象 是一种 思维方式，也是一门 程序设计技术
    • 要解决一个问题前，首先考虑 由谁 来做，怎么做事情是 谁 的职责，最后把事情做好就行！
    • 要解决复杂的问题，就可以找多个不同的对象，各司其职，共同实现，最终完成需求

• 基础语法

  • 代码格式

    • 注释

    # 第一个注释
    print('hello word')
    
    '''
    这是由三对单三引号括起的注释
    这是由三对单三引号括起的注释
    '''
    """
    这是由三对双引号括起的注释
    这是由三对双引号括起的注释
    """
    

    • 缩进

      Python最具特色的就是使用缩进来表示代码块，使用4个空格进行悬挂式缩进，并且同一个代码块的语句，必须含有相同的缩进空格数，示例代码如下：

      if True:
        print ("True")  
      else:
        print ("False") 
      

  • 变量和数据类型

    • 变量和赋值

      在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）

      # 定义 qq 号码变量
      qq_number = "1234567"
      
      # 定义 qq 密码变量
      qq_password = "123"
      
      # 在程序中，如果要输出变量的内容，需要使用 print 函数
      print(qq_number)
      print(qq_password)
      

      # 定义苹果价格变量
      price = 8.5
      
      # 定义购买重量
      weight = 7.5
      
      # 计算金额
      money = price * weight
      
      print(money)
      

    • 数据类型

      • 数据类型可以分为 数字型 和 非数字型

      • 数字型

        • 整型 (int)
        • 浮点型（float）
        • 布尔型（bool）
          • 真 True 非 0 数 —— 非零即真
          • 假 False 0
        • 复数型 (complex)
          • 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题

      • 非数字型

        • 字符串

          name = 'abcdef'
          print (name[3])
          

          • 使用切片截取字符串

            切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。这里，我们以字符串为例进行讲解切片的使用。切片选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身）

            # [起始:结束:步长]
            
            name="abcdef"
            print(name[0:3])  # 取下标为0~2 的字符
            print(name[3:5])  # 取下标为3、4 的字符
            print(name[1:-1]) # 取下标为1开始 到 最后第2个之间的字符
            print(name[2:])   # 取下标从2开始到最后的字符
            print(name[::-2]) # 倒序从后往前，取步长为2的字符
            
            '''
            abc
            de
            bcde
            cdef
            fdb
            '''
            
            

        • 列表

          Python列表是一个可变的序列，它没有长度的限制，可以包含任意个元素。列表的长度和元素都是可变的，开发人员可以自由地对列表中的数据进行各种操作，包括添加、删除、修改元素。Python列表的表现形式类似于其它语言中的数组，列表中的元素使用“[]”包含，各元素之间使用英文逗号分隔

          list_two = [1, 10, 55, 20, 6]
          

          常见操作	说明
          len(s)	计算序列s的长度（元素个数）
          min(s)	返回序列s中的最小元素
          max(s)	返回序列s中的最大元素
          list.append()	在列表list的末尾添加元素x
          list.extend()	在列表list中添加列表lx的元素，与+=功能相同
          list.insert()	在列表list索引为i的元素之前插入元素x
          listpop()	取出并删除列表list中索引为i的元素x
          List.remove()	删除列表list中第一次出现的元素x
          list.reverse()	将列表list的元素反转
          list.clear()	删除列表list中的所有元素
          list.copy()	生成新列表，并拷贝列表list中的所有元素
          list.sort()	将列表list中的元素排序

        • 元组

          Python构建元组的方式非常简单，可以直接用圆括号包含元素，多个元素之间使用逗号隔开。非空元组的括号可以省略，但空元组是不能省略的

          >>> ()        # 创建一个空数组
          () 
          >>> 1,        # 由逗号结尾表示元组
          (1,) 
          >>> (1, )     # 单个元素的元组
          (1,) 
          >>> 1, 2, 3   # 包含多个元素的元组
          (1, 2, 3) 
          >>> (1, 2, 3) # 包含多个元素的元组
          (1, 2, 3)
          

        • 字典

          在编程中，通过“键”查找“值”的过程称为映射。字典是典型的映射类型，其中存放的是多个键值对。Python中使用“{}”包含键值对以创建字典，字典中各个元素之间通过逗号分隔，语法格式如下：

          >>> users = {'A': '123', 'B': '135', 'C': '680'}
          >>> users
          {'A': '123', 'B': '135', 'C': '680'}
          

          常见操作	说明
          d.keys()	返回字典d中所有的键信息
          d.values()	返回字典d中所有的值信息
          d.items()	返回字典d中所有的键值对信息
          d.get(key[, default])	若键存在于字典d中返回其对应的值，否则返回默认值
          d.clear()	清空字典
          d.pop(key[, default])	若键存在于字典d中返回其对应的值，同时删除键值对，否则返回默认值
          d.popitem()	随机删除字典d中的一个键值对
          del d[key]	删除字典d中的某键值对
          len(d)	返回字典d中元素的个数
          min(d)	返回字典d中最小键所对应的值
          max(d)	返回字典d中最大键所对应的值

  • 标识符和关键字

    • 标识符

      现实生活中，人们常用一些名称来标记事物，同理，若希望在程序中表示一些事物，需要开发人员自定义一些符号和名称，这些符号和名称叫作标识符。例如，变量名、函数名等都是标识符。Python中的标识符由字母、数字和下划线“_”组成，其命名方式需要遵守一定的规则，具体如下。

      （1）标识符由字母、下划线和数字组成，且不能以数字开头。示例代码如下：

      fromNo12   # 合法的标识符
      from#12    # 不合法的标识符，标识符不能包含#符号
      2ndObj    # 不合法的标识符，标识符不能以数字开头
      

      （2）Python中的标识符是区分大小写的。例如，leo和Leo是不同的标识符。

      （3）Python中的标识符不能使用关键字。例如，if不能作为标识符。

      除此之外，为了规范命名标识符，关于标识符的命名提以下几点建议。

      （1）见名知意：起一个有意义的名字，尽量做到看一眼就可以知道标识符是什么意思，从而提高代码的可读性。例如，定义名字使用name来表示，定义学生使用student来表示。

      （2）根据Python之父Guido推荐的规范，在为Python中的变量命名时, 建议对类名使用大写字母开头的单词（如CapWorld），模块名应该用小写加下划线的方式（如low_with_ under）。

    • 关键字

      在Python中，具有特殊功能的标识符称为关键字。关键字是Python语言自己已经使用的了，不允许开发者自己定义和关键字相同名字的标识符。Python中的关键字如下所示：

      
      # 获得所有关键字
      import keyword;
      keyword.kwlist;
      
      ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
      
      

  • 运算符

    运算符	描述
    **	指数（最高优先级）
    ～ + -	按位翻转，一元加号和减号（最后两个的方法名为+@和-@）
    * / % //	乘，除，取模和取整除
    + -	加法，减法
    >> <<	右移，左移运算符
    &	按位与
    ^ |	位运算符
    <= < > >=	比较运算符
    == !=	等于运算符
    = %= /= //= -= += = =	赋值运算符
    is is not	成员运算符
    or and	逻辑运算符

• 流程控制

  • if

    '''
    if条件表达式：
        代码块
    '''
    age = 5
    if age >= 3:    # 如果大于或等于3岁即可上幼儿园
       print("可以上幼儿园了")
    
    

    '''
    if 条件表达式：
        代码块1
    else:
        代码块2
    '''
    
    u_name = input("请输入用户名：")
    pwd = input("请输入密码：")
    if u_name == "admin" and pwd == "123":
        print("登录成功！即将进入主界面。")
    else:
        print("您输入的用户名或密码错误，请重新输入。")
    
    

    '''
    if 条件表达式1：
       代码块1
    elif 条件表达式2:
      代码块2
    elif 条件表达式3:
      代码块3
    elif 条件表达式n-1:
    代码块n-1
    else:
      代码块n
    '''
    
    score = int(input("请输入您的会员积分："))
    if score == 0:
      print("注册会员")
    elif 0 < score <= 2000:
      print("铜牌会员")
    elif 2000 < score <= 10000:
      print("银牌会员")
    elif 10000 < score <= 30000: 
      print("金牌会员")
    else:
      print('钻石会员')
    

  • 循环语句

    • for循环

      for循环可以对可迭代对象进行遍历，for语句的格式如下：

      '''
      for 临时变量 in 可迭代对象:
          执行语句1
          执行语句2
          ......
      '''
      company = "hello world"
      for c in company:
          print(c)
      
      

    • while循环

      while循环是一个条件循环语句，当条件满足时重复执行代码块，直到条件不满足为止

      '''
      while 条件表达式：
          代码块
      '''
      
      i = 1
      result = 1
      while i <= 10:
        result *= i
        i += 1
      print(result)
      

• 函数

  函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段，通过函数的名称表示和调用。函数也可以看作是一段有名字的子程序，可以在需要的地方使用函数名调用执行。在学习本章内容之前，其实我们已经接触过一些函数，比如输出信息到命令行窗口的print()函数、接收键盘输入信息的input()函数等。函数是一种功能抽象，它可以完成特定的功能，与黑箱模型的原理一样。黑箱模型是指所建立的模型只考虑输入与输出，而与过程机理无关。现实生活中，应用黑箱原理的实物有很多，比如洗衣机，对于使用者来说，大家只需要了解洗衣机的使用方法，将洗衣粉、水放入，最终得到洗干净的衣服，这个过程是完全封闭的。对于函数，外界不需要了解其内部的实现原理，只需要了解函数的输入输出方式即可使用，换言之，调用函数时以不同的参数作为输入，执行函数后以函数的返回值作为输出。

  使用函数的好处主要体现在以下几方面：

  （1） 将程序分解成更小的块（模块化）；

  （2） 降低理解难度，提高程序质量；

  （3） 减小程序体积，提高代码可重用性；

  （4） 降低了软件开发和维护的成本。

  • 函数的定义和调用

    在Python中，使用关键字def定义函数，其语法格式如下：

    def 函数名([参数列表]): 
        ["函数文档字符串"]
        函数体 
        [return语句]
    

    关于上述语法格式的介绍如下：

    • def关键字：函数以def关键字开头，其后跟函数名和圆括号()。
    • 函数名：用于标识函数的名称，遵循标识符的命名规则。
    • 参数列表：用于接收传入函数中的数据，可以为空。
    • 冒号：用于标识函数体的开始。
    • 函数文档字符串：一对由三引号包含的字符串，是函数的说明信息，可以省略。
    • 函数体：实现函数功能的具体代码。
    • return语句：用于将函数的处理结果返回给函数调用者，若函数没有返回值，return语句可以省略。

    若函数的参数列表为空，这个函数称为无参函数。定义一个显示4月8日天气状况的无参函数，具体代码如下：

    def weather():
        print("*" * 13)
        print("日期：4月8日")
        print("温度：14~28℃")
        print("空气状况：良")
        print("*" * 13)
    

    函数定义之时可以设置参数列表，以实现更灵活的功能。例如定义一个可以显示任意日期天气状况的函数，具体代码如下：

    def modify_weather(today, temp, air_quality):
        print("*"*13)
        print(f"日期：{today}")
        print(f"温度：{temp}")
        print(f"空气状况：{air_quality}")
        print("*" * 13)
    

    函数的调用格式如下：

    函数名([参数列表])
    

    定义好的函数直到被程序调用时才会执行。例如，调用weather()函数，示例代码如下：

    weather()
    
    '''
    ***********
    日期：4月8日
    温度：14~28℃
    空气状况：良
    *************
    '''
    
    modify_weather('4月6日', '15~30℃', '优')
    
    '''
    *************
    日期：4月6日
    温度：15~30℃
    空气状况：优
    *************
    '''
    

• 文件操作

  • 文件的打开和关闭

  Python内置的open()函数用于打开文件，该函数调用成功会返回一个文件对象，其语法格式如下：

  open(file, mode='r', encoding=None)
  

  open()函数中的参数file接收待打开文件的文件名；参数encoding表示文件的编码格式；参数mode设置文件的打开模式，其常用模式有r、w、a、b、+，这些模式的含义分别如下：

  • r：以只读的方式打开文件，默认值。
  • w：以只写的方式打开文件。
  • a：以追加的方式打开文件。
  • b：以二进制方式打开文件。
  • +：以更新的方式打开文件。

​

txt_data = open('txt_file.txt', 'r') # 使用open()函数以只读方式打开文件

文件打开模式可搭配使用，如表1所示为常用的搭配：

打开模式	名称	描述
r/rb	只读模式	以只读的形式打开文本文件/二进制文件，若文件不存在或无法找到，open()函数将调用失败
w/wb	只写模式	以只写的形式打开文本文件/二进制文件，若文件已存在，则重写文件，否则创建文件
a/ab	追加模式	以只写的形式打开文本文件/二进制文件，只允许在该文件末尾追加数据，若文件不存在，则创建新文件
r+/rb+	读取（更新）模式	以读/写的形式打开文本文件/二进制文件，如果文件不存在，open()函数调用失败
w+/wb+	写入（更新）模式	以读/写的形式创建文本文件/二进制文件，若文件已存在，则重写文件
a+/ab+	追加（更新）模式	以读/写的形式打开文本/二进制文件，但只允许在文件末尾添加数据，若文件不存在，则创建新文件

Python内置的close()方法用于关闭文件，该方法没有参数，直接调用即可。

txt_data.close()  

• 文件的读取

  Python中与文件读取相关的方法有3种，分别为read()、readline()、readlines()。

  • read()方法可以从指定文件中读取指定数据，其语法格式如下：

    txt_data.read([size]) 
    

​ 在上述格式中，txt_data表示文件对象，参数size用于设置读取数据的字节数，若参数size缺省，则一次读取指定文件中的所有数据。

txt_data = open('txt_file.txt', mode='r', encoding='utf-8')
print("读取两个字节数据：")
print(txt_data.read(2))  # 读取两个字节的数据
txt_data.close()
txt_data = open('txt_file.txt', mode='r', encoding='utf-8')
print("读取全部数据：")
print(txt_data.read())  # 读取全部数据
txt_data.close()

• 数据写入

  使用write()方法向文件中写入数据，其语法格式如下。

  txt_data = open('txt_file.txt',encoding='utf-8',mode='a+')
  print(txt_data.write('Hello world'))
  

• 异常

  Python程序中最常见的错误为语法错误。语法错误又称为解析错误，它是指开发人员编写了不符合Python语法格式的代码所引起的错误。含有语法错误的程序会抛出异常，无法运行。一段语法格式正确的Python代码在运行时产生的错误称为异常。如果这些异常不被处理，程序默认的处理方式是直接崩溃。在Python中所有的异常均由类实现，所有的异常类又继承自BaseException类，程序运行时出现的异常大多继承自Exception类。

  ​ Exception中常见的子类

  类名	描述
  SyntaxError	发生语法错误时引发
  FileNotFoundError	未找到指定文件或目录时引发
  NameError	找不到指定名称的变量时引发
  ZeroDivisionError	除数为0时的异常
  IndexError	当使用超出列表范围的索引时引发
  KeyError	当使用映射不存在的键时引发
  AttributeError	当尝试访问未知对象属性时引发
  TypeError	当试图在使用a类型的场合使用b类型时引发

• 捕获异常

  • try-except语句

    Python程序在运行时出现的异常会导致程序崩溃，这种异常处理方式并不友好，开发人员需要一种友好的方式处理程序运行时的异常。在Python中可使用try-except语句捕获异常，try-except还可以与else、finally组合使用实现更强大的异常处理功能。

    try-except语句用于捕获程序运行时的异常，其语法格式如下：

    try:
        可能出错的代码
        ......
    except [错误类型]:
        错误处理语句
        ......
    

    上述格式中，try子句后面是可能出错的代码，except子句后面是捕获的异常类型，及捕获到异常后的处理语句。

    try-except语句的执行过程如下：

    （1）先执行try子句，即try与except之间的代码；

    （2）若try子句中没有产生异常，忽略except子句代码；

    （3）若try子句产生异常，则忽略try子句的剩余代码，执行except子句代码。

    '''
    try-except语句
    '''
    
    try:
        for i in 2:
            print(i)
    except:
        print('int类型不支持迭代操作')
    

  • else子句

  异常处理的主要目的是防止因外部环境的变化导致程序产生无法控制的错误，而不是处理程序的设计错误。因此，将所有的代码都用try语句包含起来的做法是不推荐的，try语句应尽量只包含可能产生异常的代码。Python中try-except语句还可以与else子句联合使用，该子句放在except语句之后，表示当try子句没有出现错误时应执行的代码。其格式如下：

  try:
      可能出错的语句
      ......
  except:
      出错后的执行语句
  else:
      未出错时的执行语句
  

  '''
  某程序的分页显示数据功能可以根据用户输入控制每页显示多少条数据，但要求用户输入的数据为整数类型数据，如果输入的数据符合输入要求，每页显示用户指定的条数；如果输入的数据不不符合要求，则使用默认显示条数
  
  '''
  num =input("请输入每页显示多少条数据:") # 用户输入为字符串
  try:
      page_size = int(num)        # 将字符串转化为数字
  except Exception as e:
      page_size = 20           # 若转化出错，则使用预设的数据量
      print("当前页显示%d条数据"%page_size)
  else:
      print("当前页显示%s条数据"%num)   # 加载数据
  

  • finally子句

    finally子句与try-except语句连用时，无论try-except是否捕获到异常，finally子句后的代码都要执行，其语法格式如下：

    try:
        可能出错的语句
        ......
    except:
        出错后的执行语句
    finally:
        无论是否出错都会执行的语句
    

    try:
        file = open('异常.txt', 'r')
        file.write("人生苦短，我用Python")
    except Exception as error:
        print("写入文件失败", error)
    finally:
        file.close()
        print('文件已关闭')
    

• 抛出异常

  • 使用raise语句抛出异常

    在Python程序中的异常不仅可以自动触发异常，而且还可以由开发人员使用关键字raise抛出异常，如果程序中异常没有被处理，那么产生的异常会一层一层向上传递，直至程序无法处理。

    raise语句用于引发特定的异常，其使用方式大致可分为3种：

    1、由异常类名引发异常；

    2、由异常对象引发异常；

    3、由程序中出现过的异常引发异常。

    raise NameError
    

• 面向对象

  面向对象（Object Oriented）是程序开发领域中的重要思想，这种思想模拟了人类认识客观世界的逻辑，是当前计算机软件工程学的主流方法；类是面向对象的实现手段。Python在设计之初就已经是一门面向对象语言，了解面向对象编程思想对于学习Python开发至关重要。

  提到面向对象，自然会想到面向过程。面向过程编程的基本思想是：分析解决问题的步骤，使用函数实现步骤相应的功能，按照步骤的先后顺序依次调用函数。前面章节中所展示的程序都以面向过程的方式实现，面向过程只考虑如何解决当前问题，它着眼于问题本身。

  面向对象编程的着眼之处在于角色以及角色之间的联系。使用面向对象编程思想解决问题时，开发人员首先会从问题之中提炼出问题涉及的角色，将不同角色各自的特征和关系进行封装，以角色为主体，通过描述角色的行为去描述解决问题的过程。面向对象包括3大特征

  1.封装（encapsulation）

  封装是面向对象程序设计最重要的特征之一。封装就是隐藏。它将数据和数据处理过程封装成一个整体，以实现独立性很强的模块，避免了外界直接访问对象属性而造成耦合度过高及过度依赖，同时也阻止了外界对对象内部数据的修改而可能引发的不可预知错误。

  封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。例如，人们对计算机进行封装，用户只需知道通过鼠标和键盘可以使用计算机，但无需知道计算机内部如何工作。

  2.继承（inheritance）

  继承描述的是类与类之间的关系，通过继承，新生类可以在无需赘写原有类的情况下，对原有类的功能进行扩展。例如，已有一个汽车类，该类描述了汽车的普通特性和功能，现要定义一个拥有汽车类属性，但还具有其它特性和功能的轿车类，可以直接先让轿车类继承汽车类，再为轿车类单独添加轿车的特性即可。

  继承不仅增强了代码复用性，提高了开发效率，也为程序的扩充提供了便利。在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是数据组织和分类行之有效的方法，它减低了创建对象、类的工作量。

  3.多态（ polymorphism）

  多态指同一个属性或行为在父类及其各派生类中具有不同的语义，面向对象的多态特性使得开发更科学、更符合人类的思维习惯，能有效地提高软件开发效率，缩短开发周期，提高软件可靠性。

  以一个交通概念为例来进行讲解，假如在一个十字路口红灯亮起，那么汽车、飞机这两个对象看到红灯会做出不同的反应，汽车停车，飞机继续飞行，这就是多态性。不同的对象对同一个消息产生不同的行为。

  • 类与对象

    • 类和对象的关系

      面向对象编程思想力求在程序中对事物的描述与该事物在现实中的形态保持一致。为此，面向对象的思想中提出了两个概念：类和对象。类是对多个对象共同特征的抽象描述，是对象的模板；对象用于描述现实中的个体，它是类的实例。

    • 类的定义与访问

      在程序中创建对象之前需先定义类。类是对象的抽象，是一种自定义数据类型，它用于描述一组对象的共同特征和行为。类中可以定义数据成员和成员函数，数据成员用于描述对象特征，成员函数用于描述对象行为，其中数据成员也被称为属性，成员函数也被称为方法。下面介绍如何定义类，以及如何访问类的成员。

      类的定义格式如下：

      class 类名:                # 使用class定义类
          属性名 = 属性值         # 定义属性
          def 方法名(self):      # 定义方法
              方法体
      

      以上格式中的class是定义类的关键字，其后的类名是类的标识符，类名首字母一般为大写。类名后的冒号（:）必不可少，之后的属性和方法都是类的成员，其中属性类似于前面章节中学习的变量，方法类似于前面章节中学习的函数，但需注意，方法中有一个指向对象的默认参数self。

      # 定义汽车类Car，该类包含一个描述车轮数量的属性wheels、一个描述开车方式的方法drive()和一个描述停车方式的方法stop()。
      
      class Car:
          wheels = 4              # 属性
          def drive(self):        # 方法
              print('开车方式')
          def stop(self):         # 方法
              print('停车方式')
      
      

    • 对象的创建与使用

      my_car = Car() # 创建对象
      
      print(my_car.wheels)   # 访问并打印my_car的属性wheels
      my_car.drive()         # 访问my_car的方法drive()
      

  • 构造方法与析构方法

    • 构造方法

      每个类都有一个默认的__init__()方法，如果在定义类时显式地定义了__init__()方法，则创建对象时Python解释器会调用显式定义的__init__()方法；如果定义类时没有显式定义__init__()方法，那么Python解释器会调用默认的__init__()方法。

      __init__()方法按照参数的有无（self除外）可分为有参构造方法和无参构造方法，无参构造方法中可以为属性设置初始值，此时使用该方法创建的所有对象都具有相同的初始值。若希望每次创建的对象都有不同的初始值，则可以使用有参构造方法实现。

      class Inforamtion(object):
          def __init__(self, name, sex):     # 有参构造方法
              self.name = name               # 添加属性name
              self.sex = sex                 # 添加属性sex
          def info(self):
              print(f'姓名：{self.name}')
              print(f'性别：{self.sex}')
              
      infomation = Inforamtion('李婉', '女')
      infomation.info()
      
      '''
      姓名：李婉
      性别：女
      '''
      

  • 继承

    在Python中，类与类之间也具有继承关系，其中被继承的类称为父类或基类，继承的类称为子类或派生类。子类在继承父类时，会自动拥有父类中的方法和属性。

    • 单继承/多继承

      单继承指的是子类只继承一个父类，其语法格式为：class 子类(父类):

      # 定义一个表示两栖动物的父类Amphibian和一个表示青蛙的子类Frog
      
      class Amphibian:
          name = "两栖动物"    
          def features(self):
              print("幼年用鳃呼吸")
              print("成年用肺兼皮肤呼吸")
      class Frog(Amphibian):  # Frog类继承自Amphibian类
          def attr(self):
              print(f"青蛙是{self.name}")
              print("我会呱呱叫")
              
      frog = Frog()                # 创建类的实例化对象
      print(frog.name)             # 访问父类的属性
      frog.features()              # 使用父类的方法
      frog.attr()                  # 使用自身的方法
      
      
      '''
      两栖动物
      幼年用鳃呼吸。
      成年用肺兼皮肤呼吸。
      青蛙是两栖动物。
      我会呱呱叫。
      
      '''
      

      多继承指的是一个子类继承多个父类，其语法格式为：class 子类（父类A, 父类B）:

      '''
      一个学生接收多个老师传授的知识。定义English类、Math类与Student类，使Student类继承English类与Math类
      '''
      
      class English:
          def eng_know(self):
              print('具备英语知识。')
      class Math:
          def math_know(self):
              print('具备数学知识。')
      class Student(English, Math):
          def study(self):
              print('学生的任务是学习。')
              
              
      s = Student()
      s.eng_know()
      s.math_know()
      s.study()
      
      '''
      具备英语知识。
      具备语文知识。
      学生的任务是学习。
      '''
      

    • 方法的重写

      子类可以继承父类的属性和方法，若父类的方法不能满足子类的要求，子类可以重写父类的方法，以实现理想的功能。

      ''''
      定义Felines类与Cat类，使Cat类继承自Felines类，并重写自父类继承的方法speciality()
      '''
      
      class Felines:
          def speciality(self):
              print("猫科动物特长是爬树")
      class Cat(Felines):
          name = "猫"
          def speciality(self):
              print(f'{self.name}会抓老鼠')
              print(f'{self.name}会爬树')
              
      cat = Cat()
      cat.speciality()
      
      '''
      猫会抓老鼠
      猫会爬树
      '''
      

    • super()函数

      如果子类重写了父类的方法，但仍希望调用父类中的方法，该如何实现呢？Python提供了一个super()函数，该函数可以调用父类中的方法。

      class Cat(Felines):
          name = "猫"
          def speciality(self):
              print(f'{self.name}会抓老鼠')
              print(f'{self.name}会爬树')
              print('-' * 20)
              super().speciality()
              
              
      cat = Cat()
      cat.speciality() 
      
      '''
      猫会抓老鼠
      猫会爬树
      --------------------
      猫科动物特长是爬树
      '''
      

  • 多态

    在Python中，多态指在不考虑对象类型的情况下使用对象。相比于强类型，Python更推崇“鸭子类型”。“鸭子类型”是这样推断的：如果一只生物走起路来像鸭子，游起泳来像鸭子，叫起来也像鸭子，那么它就可以被当做鸭子。也就是说，“鸭子类型”不关注对象的类型，而是关注对象具有的行为。

    class Animal(object):           # 定义父类Animal
        def move(self):
            pass
    class Rabbit(Animal):           # 定义子类Rabbit
        def move(self):
            print("兔子蹦蹦跳跳")
    class Snail(Animal):           # 定义子类Snail
        def move(self):
            print("蜗牛缓慢爬行")
    def test(obj):                 # 在函数test()中调用了对象的move()方法
        obj.move()
    
        
    rabbit = Rabbit()           
    test(rabbit)            # 接收Rabbit类的对象
    snail = Snail()            
    test(snail)             # 接收Snail类的对象
    
    
    '''
    兔子蹦蹦跳跳
    蜗牛缓慢爬行
    '''