Python3 與 NetCore 基礎語法對比（Function專欄）

本文轉載自查看原文 2018-06-15 11:28 914 python/ netcore/ AI

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

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差不多）：不太建議使用