Python高阶学习

最新推荐文章于 2023-12-19 11:15:29 发布

「已注销」

最新推荐文章于 2023-12-19 11:15:29 发布

阅读量223

点赞数

本文链接：https://blog.csdn.net/Chile_Wang/article/details/104548911

版权

点击上方蓝字关注我们吧

前情回顾

Python基础

Python进阶学习

3.4 Python高阶学习

3.4.1 面向过程编程

定义方法指令：def

面向过程编程是通过定义一个又一个的方法去确定的，在数学上我们更倾向于将方法称作函数。这么做的目的是为了将一个大的任务拆成一个又一个小任务去实现，然后用搭积木似的操作去组装，从而完成任务。我们可以将积木看做方法，这些方法都是我们实现的，将一个又一个的积木组装成自己想要的形状，就是完成任务的过程。

1. 有返回值,无参数

1.  # /chapter3/3_4_Basis_high_ranking.ipynb
2.  def print_value():  
3.      return 1  
4.  print_value()  # 调用函数

2．无返回值,无参数

1.  def print_value():  
2.      print('Chile')  
3.  print_value()  # 调用函数

Chile

3. 无返回值,有参数

1.  def print_value(a, b):  
2.      if a > b:  
3.          print('a > b')  
4.      elif a < b:  
5.          print('a < b')  
6.      else:  
7.          print('a == b')  
8.            
9.  # 三种调用方式          
10.  print_value(1, 2)  # 调用函数    
11.    
12.  a = 1  
13.  b = 2  
14.  print_value(a, b)  # 调用函数    
15.    
16.  print_value(a=1, b=2)  # 调用函数

a < b

4．有返回值,有参数

1.  def print_value(a_test, b_test):  
2.      if a > b:  
3.          return 'a > b'  
4.      elif a < b:  
5.          return 'a < b'  
6.      else:  
7.          return 'a == b'  
8.            
9.  # 三种调用方式          
10.  print(print_value(1, 2))  # 调用函数    
11.    
12.  a = 1  
13.  b = 2  
14.  print(print_value(a, b))  # 调用函数    
15.    
16.  print(print_value(a_test=1, b_test=2))  # 调用函数

a < b

3.4.2 面向对象编程

面向对象有两个概念:类（Class）和实例（Instance），类是抽象的模板，例如Phone类，而实例是根据类创建出来的一个个具体的“对象”例如huawei和iphone等，每个实例的对象都拥有相同的方法，但各自的数据可能不同。

每一个方法第一个参数永远是self。

类的三大特性：封装、继承与多态。

1．封装

将属性和方法封装进类，每一个对象的属性和方法是一样的，类似模板，但数据不一样，类似我们将自己的内容输入模板。

1.  class Phone(object):  
2.      # 内置的方法，用来绑定类的属性  
3.      def __init__(self, name, price):  
4.          # 属性  
5.          self.name = name    
6.          self.price = price  
7.        
8.      # 方法  
9.      def print_price(self):  
10.          print(self.price)  
11.      def assistant(self):  
12.          print('I have an assistant!')

2. 实例化对象

1.  iphone = Phone('iphone', 5200)


2.  huawei = Phone(name='huawei', price=8888)  
3.  print(iphone.price)  # 查看实例属性  
4.  huawei.print_price()  # 调用实例函数

5200

8888

3. 继承

就是传统意义上的意思，继承父辈已有的东西，然后在自己身上开发父辈没有的东西。

1.  class Iphone(Phone):  
2.      def operation_system(self):  
3.          return 'ios'  
4.  iphone = Iphone('iphone', '5200')  
5.  print(iphone.operation_system())

ios

4. 多态

如果从父辈继承的方法不适合，子类会重写一个适合自己的同名方法，覆盖从父辈那继承的已有的方法。即在运行子类的实例时，总是优先运行子类的代码。所以多态也叫多样性。

1.  class Iphone(Phone):  
2.      def assistant(self):  
3.          print('I have siri assistant!')  
4.    
5.  class Huawei(Phone):  
6.      def assistant(self):  
7.          print('I have hormony assistant!')  
8.  iphone = Iphone('iphone', 5200)  
9.  huawei = Huawei(name='huawei', price=8888)  
10.  iphone.assistant()  
11.  huawei.assistant()

I have siri assistant!

I have hormony assistant!

1.  def get_assistant(Phone):  
2.      Phone.assistant()  
3.  get_assistant(Phone('phone', 500))  
4.  get_assistant(Iphone('iphone', 5200))  
5.  get_assistant(Huawei('huawei', 8888))

I have an assistant!

I have siri assistant!

I have hormony assistant!

3.4.3 面向过程与面向对象的区别

面向过程的程序设计是以过程为中心，将问题分解成一个个小问题，然后用一个个函数将这些小问题按照步骤去解决，即把大函数切成小函数，从而降低问题的复杂度。而面向对象的程序设计是以对象为中心，将事物高度抽象化成模型，然后使用模型实例化出一个个对象，通过对象之间的通信来解决问题。

当然，不管是面向过程还是面向对象编程，本质上都是为了简化代码，提高代码复用率，只不过面向对象更加抽象罢了。越抽象的东西，通用性越高，当然也就意味着复用性越好。