python高阶_Python高阶学习

学习目录阿力阿哩哩：深度学习 | 学习目录​zhuanlan.zhihu.com

上一期我们讲到阿力阿哩哩：Python进阶学习​zhuanlan.zhihu.com

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() # 调用函数

1

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

a < b

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

a < b

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 面向过程与面向对象的区别

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

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

下一期，我们将介绍

正则表达式

敬请期待~

关注我的微信公众号【阿力阿哩哩的炼丹日常】~不定期更新相关专业知识~

喜欢就点个赞吧~