Python3 与 NetCore 基础语法对比（Function专栏）

Jupyter最新排版：https://www.cnblogs.com/dotnetcrazy/p/9175950.html

昨晚开始写大纲做demo，今天牺牲中午休息时间码文一篇，希望大家点点赞 O(∩_∩)O

NetCore：https://github.com/lotapp/BaseCode/tree/master/netcore/1_POP/6func

Python：https://github.com/lotapp/BaseCode/tree/master/python/1.POP/4.func_IO

在线演示：http://nbviewer.jupyter.org/github/lotapp/BaseCode/tree/master/python/notebook/1.POP/4.func

在线编程：https://mybinder.org/v2/gh/lotapp/BaseCode/master

主要是普及一下Python基础语法，对比着Net，新手更容易上手。对比学习很有意思的，尤其是一些底层和思路

本来感觉函数要说的地方没多少，细细一规划，发现～还是单独拉出一篇说说吧，之后就进入面向对象了，函数还是有必要了解一下的，不然到时候Class里面的方法定义又要说了。

演示的模式一直在变，刚开始让大家熟悉一下VSCode，后来引入了ipython交互式编程的概念，现在就用前几天讲的Notebook来演示了（VSCode现在也有这个预览版的插件了）

直接跳到扩展系列：https://www.cnblogs.com/dotnetcrazy/p/9175950.html#ext

先从函数定义说起吧：

# 定义一个空函数：（不写pass就报错了）

# 定义一个无参函数（注意缩进）

# 定义一个含参函数

扩：文档说明用""" 或者'''来定义，就是如下效果

# 定义一个含默认参数(缺省参数)的函数

# 定义有返回值的函数

# 定义含有多个返回值的函数（利用了元组）

来个案例解释一下：（多返回值只是一种假象，Python函数返回的仍然是单一值～元组）

传多个参数系列：(上面那个多返回参数也可以返回一个list来实现类似效果)

引用传递（通过元组、列表实现）：扩展有可变类型和不可变类型作为形参的对比

# 定义一个可变参数的函数(参数名字一般都是*args)

如果你需要传一个元组或者列表进去的话，可以参数前面加*

# 定义含关键字参数的函数：def default_kv_params(name,age=23,**kv):

# 可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
# 关键字参数允许你传入0个或任意个含key-value的参数，自动组装为一个dict

来个综合案例：def default_god_params(name,age=23,*args,**kv):

需要注意py里面的书写格式==》先定义再调用（Code参考）

NetCore：（C#基础语法大家都很熟了，我贴一个注释的Code即可）

VSCode里面如果也想像VS一样，///就生成注释==》请安装函数文档注释：XML Documentation Comments

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
using System;
using System.Collections.Generic;

namespace _6func
{
    class Program
    {
        static void Main(string[] args)
        {
            #region Base
            // # 定义一个空函数：
            Method();
            // # 定义一个无参函数
            GetName();
            // # 定义一个含参函数
            ShowInfos("李四", 22);
            // # 定义一个含默认参数(缺省参数)的函数
            DefaultParam("张三");
            // # 定义有返回值的函数
            int result = DivHaveReturn(1, 2);
            Console.WriteLine($"计算结果为{result}");
            #endregion

            // # 定义含有多个返回值的函数（利用了元组）
            var (sum, dvalue) = DivHaveReturns(1, 2);
            Console.WriteLine($"sum:{sum},D-value:{dvalue}");

            // 传多个参数系列：
            // 引用传递（通过元组、列表实现）：扩展有可变类型和不可变类型作为形参的对比
            var list = new List<int>() { 1, 2, 3, 4, 5 };
            Console.WriteLine(DefaultSomeParams(list));
            Console.WriteLine(list.Count);//这就是引用传递的证明

            // # 定义一个可变参数的函数(参数名字一般都是*args)
            Console.WriteLine(DefaultParams(1, 2, 3, 4, 5));

            // # 定义含关键字参数的函数直接传Dict
        }

        #region base
        /// <summary>
        /// 定义一个空函数
        /// </summary>
        private static void Method()
        {

        }
        /// <summary>
        /// 定义一个无参函数
        /// </summary>
        // private static void GetName()
        // {
        //     Console.WriteLine("你好");
        // }
        //简写
        private static void GetName() => Console.WriteLine("你好");

        /// <summary>
        /// 定义一个含参数的函数
        /// </summary>
        /// <param name="name">名字</param>
        /// <param name="age">年龄</param>
        // private static void ShowInfos(string name, int age)
        // {
        //     Console.WriteLine($"我叫{name} 我的年龄是{age}");
        // }
        //简写
        private static void ShowInfos(string name, int age) => Console.WriteLine($"我叫{name} 我的年龄是{age}");

        /// <summary>
        /// 定义一个含缺省参数的函数
        /// </summary>
        /// <param name="name">名字</param>
        /// <param name="age">年龄默认23</param>
        // private static void DefaultParam(string name, int age = 23)
        // {
        //     Console.WriteLine($"我叫{name} 我的年龄是{age}");
        // }
        //简写
        private static void DefaultParam(string name, int age = 23) => Console.WriteLine($"我叫{name} 我的年龄是{age}");

        /// <summary>
        /// 定义一个有返回值的函数（计算a+b，返回计算结果）
        /// </summary>
        /// <param name="a">num1</param>
        /// <param name="b">num2</param>
        // private static int DivHaveReturn(int a, int b)
        // {
        //     return a + b;
        // }
        //简写
        private static int DivHaveReturn(int a, int b) => a + b;
        #endregion

        /// <summary>
        /// 定义含有多个返回值的函数（利用了元组）
        /// 计算a+b的和，计算a-b，并返回两个结果
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        // private static (int sum,int dValue) DivHaveReturns(int a, int b)
        // {
        //     return ((a+b),(a-b));
        // }
        //简写
        private static (int sum, int dValue) DivHaveReturns(int a, int b) => ((a + b), (a - b));

        #region 传入多个参数系列
        /// <summary>
        /// 利用列表实现,引用传递之类的C#还有ref和out，这边就不说了
        /// </summary>
        /// <param name="nums"></param>
        /// <returns></returns>
        private static int DefaultSomeParams(List<int> numList)
        {
            int sum = 0;
            foreach (var item in numList)
            {
                sum += item;
            }
            numList.Clear();
            return sum;
        }
        /// <summary>
        /// 定义一个可变参数的函数
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        private static int DefaultParams(params int[] args)
        {
            int sum = 0;
            foreach (var item in args)
            {
                sum += item;
            }
            return sum;
        }
        #endregion
    }
}

函数相关扩展：

1.递归函数:函数递归调用其实就是自己调用自己，关键点只要考虑什么时候跳出即可(没有跳出就是死循环)

先来个简单的案例熟悉一下:

来个案例(实际工作中并不会自己定义,用系统自带strip方法即可)

C#的递归我就引用一下以前的Code：https://github.com/dunitian/LoTCodeBase/blob/master/NetCode/1.面向过程/01.基础/10.递归案例/Program.cs

2.匿名函数系列：lambda 参数: 表达式

来个经常用的案例：data_list.sort(key=lambda x:x["key"])

还有一个比较常用的地方：（当参数传递）

NetCore：上面Code中的简写都是用匿名函数的方式，可以参考

3.全局变量和局部变量

有人可能会说，这个就太简单了，没啥好说的，(⊙o⊙)… Python还真需要说说，来个案例给你猜结果：

直接看结果吧：发现全局变量a木有被修改，而b修改了

还是来个简单案例说明下吧～

# 这是因为，python定义一个变量的写法不用加类型导致的(⊙﹏⊙) 所以函数里面a=200，python解释器就认为你定义了一个和a这个全局变量名字相同的局部变量，那怎么用呢？global来声明一下全局变量即可：

总结：

# 在函数中不使用global声明全局变量不能修改全局变量==>本质是不能修改全局变量的指向，即不能将全局变量指向新的数据

# 对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量

# 对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量

下面就进入验证扩展系列，看看一些概念：

# 之前很多资料说py3匿名函数里不能调用print函数,自己测试下

# 可变类型与不可变类型的变量分别作为函数参数的区别

# 感到疑惑可以看之前的运算符扩展（https://www.cnblogs.com/dotnetcrazy/p/9155310.html#ext）

# Python中函数参数都是引用传递
# 对于不可变类型，因变量不能修改，所以运算不会影响到变量自身
# 而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量

# 函数名能不能重复的问题（能不能重载：具有不同的参数的类型或参数的个数【跟返回值没关系】）

结论：函数名不能重名

来两个有趣的扩展：

1.交换两个数熟悉吧，编程第一课，除了用第三变量 或者 两数相加减 实现外，Python还有一种新方式：a,b=b,a

NetCore:这个我也是刚知道，O(∩_∩)O哈哈~还得谢谢评论区的兄弟^_^

2.eval（和js里面的eval差不多）：不太建议使用