python语法进阶这一篇就够了

雨洁

前言

前面我们已经学习了Python的基础语法，了解了Python的分支结构，也就是选择结构、循环结构以及函数这些具体的框架，还学习了列表、元组、字典、字符串这些Python中特有的数据结构，还用这些语法完成了一个简单的名片管理系统。下面我就将介绍一下Python的一些进阶语法规则，为后面更复杂的编程打下基础。

• 闭包与装饰器
  什么是闭包、装饰器函数、yield关键字
  
  
• python高阶函数
  lambda匿名函数、reduce函数、map函数、filter过滤器函数
  
  
• 面向对象编程
  什么是面向对象、对象的封装、类的继承、类的多态
  
  
• 进程与线程编程
  python中的进程与线程、多线程编程
  
  

第一章. 闭包与装饰器

1. 什么是闭包

1. # coding=utf-8
2. # 闭包
3. # def func1():
4. #     print ("函数1运行")
5. #     return func2()
6. # #函数1的返回值是函数2的引用
7. # def func2():
8. #     print ("函数2运行")
9. #     return 2
10. # r =func1()
11. # print (r)
12. # r2= r()  # r = func2
13. # print (r2)
16. def func1():
17.     print ("函数1运行")
18.     def func2():
19.         print ("函数2运行")
20.     func2()
21.     return func2()
22. f2 = func1()
23. print(f2)
24. f2()
25.   
26. """
27. 在一个函数，比如func1中的内部定义了另外一个函数function2
28. 并且函数1（func1）的返回值是函数2（func2）的引用
29. 这种情况，我们称之为闭包
31. 简单来说就是外部函数返回内部函数的引用就叫做闭包
32. """

复制代码

print打印结果：

1. 函数1运行
2. 函数2运行
3. 函数2运行
4. None

复制代码

案例：龟兔赛跑

1. # coding=utf-8
2. import time
3. import random
5. # 定义跑道长度
6. track_length = 10
7. def runtime(func):
8.     def wrapper():
9.         start_time = time.time()
10.         func()
11.         end_time = time.time()
12.         print (func.__name__,"运行时间是",end_time-start_time,"秒")
13.     return wrapper
14.    
15. @runtime
16. def tortoise():
17.     # for i in [1,2,3,4,5,6,7,8,9,10]:
18.     for i in range(1,track_length+1):
19.         print ("乌龟跑的{}米".format(i))
20.         time.sleep(1)
21. @runtime
22. def rabbit():
23.     for i in range(1,track_length + 1):
24.         if i % 5 == 0:
25.             time.sleep(random.randint(1,10))
26.         print ("兔子跑了{}米".format(i))
27. tortoise()
28. rabbit()

复制代码

print打印结果：

1. 乌龟跑的1米
2. 乌龟跑的2米
3. 乌龟跑的3米
4. 乌龟跑的4米
5. 乌龟跑的5米
6. 乌龟跑的6米
7. 乌龟跑的7米
8. 乌龟跑的8米
9. 乌龟跑的9米
10. 乌龟跑的10米
11. tortoise 运动时间是 10.04876708984375 秒
12. 兔子跑了1米
13. 兔子跑了2米
14. 兔子跑了3米
15. 兔子跑了4米
16. 兔子跑了5米
17. 兔子跑了6米
18. 兔子跑了7米
19. 兔子跑了8米
20. 兔子跑了9米
21. 兔子跑了10米
22. rabbit 运动时间是 9.022485494613647 秒

复制代码

2. 什么是装饰器呢？

就是在特定条件下为某些函数再不改动函数体的时候为函数新添加一些功能，这就是装饰器
实现原理：
基于@语法和函数闭包，将原函数封装在闭包中，然后将函数赋值为一个新的函数（内置函数），执行函数时再在内层函数中执行闭包中的原函数
实现效果：
可以在你改变函数内部代码和调用的前提下，实现在函数执行和执行拓展功能
适用场景：
多个函数系统统一在执行前后定义一些功能
关于前言我们了解这么多就够了，然后小编带着大家推导出装饰器
装饰器：
装饰器的写法：
这里我们有一个需求，我们定义了5个函数，想在5个函数执行前和执行后都打印一句话：装饰器的学习。首先我们来写于一下没有装饰器的写法，话不多说直接上代码：

1. def a():
2.     pass
5. def b():
6.     pass
9. def c():
10.     pass
13. def d():
14.     pass
17. def e():
18.     pass

复制代码

先定义5个函数，再加上我们要打印的话：

1. def a():
2.     print("装饰器的学习")
3.     print("装饰器的学习")
6. def b():
7.     print("装饰器的学习")
8.     print("装饰器的学习")
11. def c():
12.     print("装饰器的学习")
13.     print("装饰器的学习")
16. def d():
17.     print("装饰器的学习")
18.     print("装饰器的学习")
21. def e():
22.     print("装饰器的学习")
23.     pass
24.     print("装饰器的学习")
27. a()
28. b()
29. c()
30. d()
31. e()

复制代码

运行一下：

发现运行成功，但我们想如果我要修改打印的话就要都修改一次，特别麻烦，而且，这是5个函数如果是500个，我们还要一个一个的去加吗？这就有我们的装饰器了，首先我用装饰器修改下，再给大家解释。

1. def outer(origin):
2.     def inner():
3.         print("装饰器的学习")
4.         res = origin()
5.         print("装饰器的学习")
6.         return res
8.     return inner
11. @outer
12. def a():
13.     pass
16. @outer
17. def b():
18.     pass
21. @outer
22. def c():
23.     pass
26. @outer
27. def d():
28.     pass
31. @outer
32. def e():
33.     pass
36. a()
37. b()
38. c()
39. d()
40. e()

复制代码

运行一下：

发现这样我们也成功了，接下来小编来个大家解释
首先：
我们要明白@的作用，那我们的函数a来举例子@的作用就是帮我们执行一次a=outer(a)，首先python将把我们的a变成参数传给outer函数，运行后再赋值给a，这就是@的作用。
其次给大家解释一下自定的outer函数
我自己称这个函数为@下函数的补丁函数，也就是装饰器函数还是拿a函数举例子，首先a函数变成参数传给了我们的outer函数，outer里又嵌套了一个inner函数 ，然后将函数a赋值给res，然后用return语句返回出结果，外层函数返回inner函数，也就是将inner函数运行一次，这就是工作流程。
最后分别在各函数前加上装饰，最后运行出结果

这就是装饰器的写法。
装饰器的参数
这时我遇到一个问题如果函数内有参数而且每个函数的参数数量不同，我们应该怎末办，先看下面代码

1. def outer(origin):
2.     def inner():
3.         print("装饰器的学习")
4.         res = origin()
5.         print("装饰器的学习")
6.         return res
8.     return inner
11. @outer
12. def a(g, e):
13.     pass
16. @outer
17. def b(w):
18.     pass
21. @outer
22. def c(u, y, t):
23.     pass
26. @outer
27. def d(c):
28.     pass
31. @outer
32. def e():
33.     pass
36. a()
37. b()
38. c()
39. d()
40. e()

复制代码

这时我们运行一下

发现报错，是因为我们的装饰器内没有这两个参数，那可以在装饰器内设置两个参数，但问题是，有的函数内有3个参数，而有的函数内没有参数，那我们应该怎么办？
针对这个问题我们可以给装饰器设置动态参数，先看代码：

1. def outer(origin):
2.     def inner(*args, **kwargs):
3.         print("装饰器的学习")
4.         res = origin(*args, **kwargs)
5.         print("装饰器的学习")
6.         return res
8.     return inner
11. @outer
12. def a(a1):
13.     print("我是一函数")
16. @outer
17. def b(a1, a2):
18.     print("我是二函数")
21. @outer
22. def c(a5, a6, a7):
23.     print("我是三函数")
26. a(1)
27. b(2, 3)
28. c(4, 5, 6)

复制代码

因为函数太多了，小编有点麻烦就剪了几个函数，但道理是相同的，这时我们再运行一下

这样我们就成功了，以上就是装饰器的写法，接下来给大家拓展一下
装饰器的拓展：（functools模块）
首先给大家引入一下这时教给大家几个魔法方法

接下来我们实战一下

1. def outer(origin):
2.     def inner(*args, **kwargs):
3.         # 我是一个装饰器函数
4.         print("装饰器的学习")
5.         res = origin(*args, **kwargs)
6.         print("装饰器的学习")
7.         return res
9.     return inner
12. @outer
13. def c(a5, a6, a7):
14.     # 我是个函数
15.     print("我是三函数")
18. c(4, 5, 6)
19. print(c.__name__)
20. print(c.__doc__)

复制代码

运行一下：

这时我们发现我要的是c函数，但给我反馈的是inner函数，这是为什么呢？
这就是工作原理，直接就把c函数装饰成了inner函数，那以后再工作中一定会要自己函数的名字，而不要我装饰后的函数，这样就可以让我们的函数装饰的更像，其实在以后中，都想装饰的更像，那我们应该怎末办？
这时就需要我们的第三方模块functools，直接上代码

1. import functools
4. def outer(origin):
5.     @functools.wraps(origin)
6.     def inner(*args, **kwargs):
7.         # 我是一个装饰器函数
8.         print("装饰器的学习")
9.         res = origin(*args, **kwargs)
10.         print("装饰器的学习")
11.         return res
13.     return inner
16. @outer
17. def c(a5, a6, a7):
18.     # 我是个函数
19.     print("我是三函数")
22. c(4, 5, 6)
23. print(c.__name__)
24. print(c.__doc__)

复制代码

这时再运行一下

这时我们发现，我们伪装成功了，这样就会让我们的装饰更像。
装饰器模板：
接下来送给大家装饰器的模板，以后需要随时ctrl+c和ctrl+v

1. import functools
4. def outer(origin):
5.     @functools.wraps(origin)
6.     def inner(*args, **kwargs):
7.         # 这里书写需要装饰的功能
8.         res = origin(*args, **kwargs)
9.         return res
11.     return inner
12.    

复制代码

第二章. Python高阶函数

1. lambda表达式（匿名函数）

1. # coding=utf-8
2. # lambda表达式（匿名函数）
3. # 计算圆形的面积
4. # pi * r * r
5. # 导入数学模块
6. import math
7. def circle_area(r):
8.     result = math.pi * r * r
9.     return result
10. r = circle_area(3)
11. print (r)
12. """
13. lambda是一个关键字
14. 冒号前边的r是这个函数的参数
15. 冒号后边的是这个函数的运算逻辑
16. """
17. result = lambda r:math.pi * r * r
18. r = result(3)
19. print (r)
21. def calc_function(o):
22.     if o == "+":
23.         return lambda a,b : a + b
24.     elif o == "-":
25.         return lambda a,b : a - b
26.     elif o == "*":
27.         return lambda a,b : a * b
28.     elif o == "/":
29.         return lambda a,b : a / b
30. f = calc_function("*")
31. print (f)
32. r = f(3,4)
33. print (r)

复制代码

print打印结果：

1. 28.2743338823
2. 28.2743338823
3. <function <lambda> at 0x03159B70>
4. 12

复制代码

2. map自动拆分的计算函数

1. # coding=utf-8
2. # map函数
3. my_list = [1,2,3,4,5]
4. # 1
5. result = []
6. for i in my_list:
7.     result.append(i + 1)
8. print (result)
10. # 2
11. def add_one(e):
12.     return e + 1
13. r = map(add_one,my_list)
14. print (list(r))
15. def add_two(e):
16.     if e == 1:
17.         return e + 3
18.     elif e == 2:
19.         return 2 - 1
20.     else:
21.         return e
22. r =map(add_two,my_list)
23. print (list(r))
24. # 3
25. print (list(map(lambda e:e+1,my_list)))

复制代码

print打印结果：

1. [2, 3, 4, 5, 6]
2. [2, 3, 4, 5, 6]
3. [4, 1, 3, 4, 5]
4. [2, 3, 4, 5, 6]

复制代码

3. reduce自动堆叠计算函数

1. # coding=utf-8
2. # reduce
3. # 导入reduce
4. from functools import reduce
5. a =[2,4,6,8,10]
6. def add(x,y):
7.     return x + y
8. result = reduce(add,a)
9. print (result)
11. print (reduce(lambda x,y : x+y,a))

复制代码

print打印结果：

1. 30
2. 30

复制代码

4. filter过滤器函数

1. # coding=utf-8
3. # filter函数
4. letter=['a',"B",'c',"D",'e',"F"]
5. upper_letter = filter(lambda x: x == x.upper(),letter)
6. print (upper_letter)
7. print (list(upper_letter))
9. student_name = ['李元芳','李建国','莫怀羽']
10. print (list(filter(lambda x:x.startwith("李"),
11.                    student_name)))

复制代码

print打印结果：

1. ['B', 'D', 'F']
2. ['B', 'D', 'F']
3. ['李元芳','李建国']

复制代码

第三章. 面向对象编程

1. 对象的封装

1. # coding=utf-8
2. # 对象的封装
3. # 类的概念
4. """
5. 类的名字：当名字由多个单词构成时，我们采用驼峰命名法
6. 就是说多个单词，每个单词的首字母需要大写
7. 这也是python的命名规则
8. """
9. class BeautifulGirl():
10.     # 类的属性
11.     eye = ""
12.     nose = ""
13.     mouth = ""
14.     hair = ""
15.     face = ""
17.     # 构造函数
18.     def __init__(self,eye,nose,mouth,hair,face):
19.         self.eye = eye
20.         self.nose = nose
21.         self.mouth = mouth
22.         self.hair = hair
23.         self.face = face
24.         print ("构造函数运行了")
25.     # 在这就叫做类的方法
26.     def dance(self):
27.         print ("美女在跳舞")
29.     def get_beautiful_girl(self):
30.         print ("这个美女的样貌是：")
31.         print (self.nose)
32.         print (self.mouth)
33.         print (self.hair)
34.         print (self.face)
35.         print (self.eye)
37. # 实例化就是获取具体对象的一个过程 new新的一个。
38. girl = BeautifulGirl("大大的眼睛"
39.                      ,"小巧的嘴唇"
40.                      ,"乌黑亮丽的头发"
41.                      ,"清秀的脸庞")
42. girl.dance()
43. girl.get_beautiful_girl()
45. girl2 = BeautifulGirl("小小的眼睛",'鼻子','嘴','头发','脸庞')
46. girl2.get_beautiful_girl()

复制代码

print打印结果：

1. 大大的眼睛
2. 小巧的嘴唇
3. 乌黑亮丽的头发
4. 清秀的脸庞
5. 小小的眼睛
6. 这个美女的样貌是：
7. 鼻子
8. 嘴
9. 头发
10. 脸庞

复制代码

2. 类的私有属性

1. # coding=utf-8
2. # 类的私有属性
3. class BeautifulGirl():
4.     # 类的属性
5.     eye = ""
6.     nose = ""
7.     mouth = ""
8.     hair = ""
9.     face = ""
10.     # 这就是私有属性，私有属性在类的外部是不可以访问的
11.     __name ="高圆圆"
12.     address = "河北省唐山市"
13.     # 构造函数
14.     def __init__(self,eye,nose,mouth,hair,face):
15.         self.eye = eye
16.         self.nose = nose
17.         self.mouth = mouth
18.         self.hair = hair
19.         self.face = face
20.         print ("构造函数运行了")
21.     # 在这就叫做类的方法
22.     def dance(self):
23.         print ("美女在跳舞")
24.     def __dd(self):
25.         print ("美女在跳舞")
27.     def get_beautiful_girl(self):
28.         print ("这个美女的样貌是：")
30.         print (self.__name)
31.         print (self.nose)
32.         print (self.mouth)
33.         print (self.hair)
34.         print (self.face)
35.         print (self.eye)
36. girl = BeautifulGirl("大大的眼睛"
37.                      ,"小巧的嘴唇"
38.                      ,"乌黑亮丽的头发"
39.                      ,"清秀的脸庞")
40. print (girl.mouth)
41. print (girl.address)
42. # print (girl.__name)
43. # # 类的私有属性可以访问吗？
44. # print (BeautifulGirl.__dict__)
45. # print (girl._beautiful__name)
46. girl.get_beautiful_girl()

复制代码

print打印结果：

1. 构造函数运行了
2. 这个美女的样貌是：
3. 高圆圆
4. 大大的眼睛
5. 小巧的鼻子
6. 薄薄的嘴唇
7. 乌黑亮丽的头发
8. 清秀的脸庞

复制代码

3. 类中的方法

1. # coding=utf-8
2. # 类的私有属性
3. class BeautifulGirl():
4.     # 类的属性
5.     eye = ""
6.     nose = ""
7.     mouth = ""
8.     hair = ""
9.     face = ""
10.     # 这就是私有属性，私有属性在类的外部是不可以访问的
11.     __name ="高圆圆"
12.     address = "河北省唐山市"
13.     # 构造函数，也叫构造方法
14.     def __init__(self,eye,nose,mouth,hair,face):
15.         self.eye = eye
16.         self.nose = nose
17.         self.mouth = mouth
18.         self.hair = hair
19.         self.face = face
20.         print ("构造函数运行了")
21.     # 在这就叫做类的方法
22.     def dance(self):
23.         print ("美女在跳舞")
24.     # 这个叫做私有方法
25.     def __dd(self):
26.         print ("美女在跳舞")
27.     # 这个叫做一般方法
28.     def get_beautiful_girl(self):
29.         print ("这个美女的样貌是：")
31.         print (self.__name)
32.         print (self.nose)
33.         print (self.mouth)
34.         print (self.hair)
35.         print (self.face)
36.         print (self.eye)
37.     # 静态方法
38.     # 静态方法不能够访问类中的属性
39.     @staticmethod
40.     def study():
41.         print ("美女在实习")
43.     # 类方法
44.     # 类方法是不可以访问实例变量的，它可以访问类变量（类的属性
45.     @classmethod
46.     def girl_friend(cls):
47.         print (cls.__name)
48.         print (cls.address)
49.         print (cls.face)
50. girl = BeautifulGirl("大大的眼睛"
51.                      ,"小巧的嘴唇"
52.                      ,"乌黑亮丽的头发"
53.                      ,"清秀的脸庞")
55. # print (BeautifulGirl.__dict__)
56. # 这就访问了类中的私有方法
57. # girl.beautifulGirl__dd()
59. girl.study()
60. BeautifulGirl.study()
62. # 类名，一般方法的名称调用是会报错的
63. # BeautifulGirl.dance(girl)
65. girl.girl_friend()
66. BeautifulGirl.girl_friend()
67. girl.get_beautiful_girl()

复制代码

print打印结果：

1. 构造函数运行了
2. 这个美女的样貌是：
3. 高圆圆
4. 河北省唐山市
5. 高圆圆
6. 河北省唐山市
7. 大大的眼睛
8. 小巧的鼻子
9. 薄薄的嘴唇
10. 乌黑亮丽的头发
11. 清秀的脸庞

复制代码

4. 类的继承

1. # coding=utf-8
2. # 类的继承
3. # 父类和子类
4. class Father(object):
5.     age = 38
7.     def __init__(self,name):
8.         self.name = name
9.         print ("父类的构造函数运行了")
11.     def father_money(self):
12.         print ("父亲有很多钱")
14.     def __father_knowleger(self):
15.         print ("父亲的知识体系")
17.     @staticmethod
18.     def study():
19.             print ("父亲在学习")
21.     @classmethod
22.     def father_friend(cls):
23.             print ("父亲有很多朋友")
25.     def face(self):
26.             print ("父亲非常帅")
27. # 意味着son这个类继承了father这个类
28. class Son(Father):
29.    def __init__(self):
30.        print ("子类的构造函数运行了")
31. # son = Son("小王")
32. son = Son()
33. # 在继承中，子类如果有构造函数，name就不会调用弗雷德构造函数
35. # 在继承中，一般的方法是可以被继承的
36. son.father_money()
38. # 私有方法可以被继承
39. # son.__father_knowleger()
40. son.study()
41. son.father_friend()
43. class Mother():
44.     def face(self):
45.         print ("妈妈长的很漂亮")
47. # 这就叫做多继承
48. class Son2(Mother,Father):
49.     def __init__(self):
50.         print("2儿子的构造函数运行了")
52. son2 = Son2()
53. son2.father_money()
54. son2.face()
55. # 当多继承的时候，多个父类拥有一个名称的变量或方法时
56. # 哪个父类写在继承列表的前边，子类就继承谁的

复制代码

print打印结果：

1. 子类的构造函数运行了
2. 父亲有很多钱
3. 父亲在学习
4. 父亲有很多朋友
5. 2儿子的构造函数运行了
6. 父亲有很多钱
7. 妈妈长的很漂亮

复制代码

5. 类的多态

1. # coding=utf-8
2. # 类的多态
3. # 指的是多种形态
5. class Animal():
6.     def run(self):
7.        print ("动物开始跑")
8. # 子类在继承父类的过程中，重写了父类中的方法
9. class Dog(Animal):
10.     def run(self):
11.         print ("狗狗跑")
13. class Cat(Animal):
14.     def run(self):
15.         print ("猫跑")
17. class Person(Animal):
18.     def run(self):
19.         print ("人类跑")
21. dog = Dog()
22. dog.run()
24. cat = Cat()
25. cat.run()
27. person = Person()
28. person.run()
30. # 多个类继承同一个类，都重写了父类的方法，呈现出了不同的形态
32. # 多态性
33. class A(Animal):
34.     pass
35. a = A()
37. def run(obj):
38.     obj.run()
40. run(dog)
41. run(cat)
42. run(person)
43. run(a)

复制代码

print打印结果：

1. 狗狗跑
2. 猫跑
3. 人类跑
4. 狗狗跑
5. 猫跑
6. 人类跑
7. 动物开始跑

复制代码

6. 多进程编程

1. # coding=utf-8
2. # 多进程编程代码演示
3. import time
4. from multiprocessing import Process
5. import os
7. def target_function():
8.     print ("子进程的ID:{}".format(os.getpid()))
9.     time.sleep(2)
10. if __name__== "__main__":
11.     print (__name__)
12.     print ("主进程ID:{}".format(os.getpid()))
13.     ps = []
14.     for i in range(10):
15.         p = Process(target_function())
16.         p.start()
17.         ps.append(p)
18.     # 让主进程等待子进程进行运行完成后在停止
19.     for p in ps:
20.         p.join()

复制代码

print打印结果：

1. __main__
2. 主进程ID:2692
3. 子进程的ID:2692
4. 子进程的ID:2692
5. 子进程的ID:2692
6. 子进程的ID:2692
7. 子进程的ID:2692
8. 子进程的ID:2692
9. 子进程的ID:2692
10. 子进程的ID:2692
11. 子进程的ID:2692
12. 子进程的ID:2692

复制代码

最后

访问量破千，一起加油！
写博客是为了记录和分享自己的学习历程，温故知新！做的不好的地方欢迎指正！！！

来源:https://www.cnblogs.com/kasia/p/17090278.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！