您的位置:新葡亰496net > 电脑系统 > 基础语法对比

基础语法对比

发布时间:2019-11-24 07:14编辑:电脑系统浏览(55)

    Jupyter排版:https://www.cnblogs.com/dotnetcrazy/p/9102030.html

    聚集类别:

    Jupyter最新制版:

    Jupyter最新版:https://www.cnblogs.com/dotnetcrazy/p/9155310.html

    集聚类别:

    Jupyter排版:https://www.cnblogs.com/dunitian/p/9119986.html

    style="color: #3366ff;">昨夜开始写大纲做demo,今天捐躯中午休憩时间码文大器晚成篇,希望大家点点赞O(∩_∩)O

    NetCore: style="color: #008000;">https://github.com/lotapp/BaseCode/tree/master/netcore/1_POP/6func

    Python: style="color: #008000;">https://github.com/lotapp/BaseCode/tree/master/python/1.POP/4.func_IO

    在线演示: style="color: #008000;">http://nbviewer.jupyter.org/github/lotapp/BaseCode/tree/master/python/notebook/1.POP/4.func

    style="color: #008000;">在线编制程序

    注重是推广一下Python根基语法,相比较着Net,新手更易于上手。相比较学习很有趣的,越发是有个别底层和思路

    无可争辩觉得函数要说的地点没有多少,细细生机勃勃企划,开掘~依旧单独拉出后生可畏篇说说吧,之后就进去面向对象了,函数仍有不可贫乏精晓一下的,不然届期候Class里面包车型地铁方法概念又要说了。

    亲自去做的方式平素在变,刚初步让大家耳闻则诵一下 style="color: #ff6600;">VSCode,后来引进了 style="color: #008000;">ipython人机联作式编制程序的概念,今后就用明天讲的 style="color: #ff0000;">Notebook来演示了(VSCode以往也可以有那么些预览版的插件了卡塔 尔(英语:State of Qatar)

    在线演示: style="color: #008000;">http://nbviewer.jupyter.org/github/lotapp/BaseCode/blob/master/python/notebook/1.POP/3.list_tuple_dict

    更新: style="color: #ff0000;">新增Python可变Tuple、List切片、Set的扩展:https://www.cnblogs.com/dotnetcrazy/p/9155310.html#extend 

    几日前说说List和Tuple以至Dict。POP部分还会有局地如Func、IO(也得以放OOP部分说卡塔 尔(英语:State of Qatar)然后就说说面向对象吧。

    先调侃一下:Python面向对象真心供给专门的职业,不然太轻巧走火入魔了 -_-!!! 汗,后一次再说。。。

    相比较写作真的比单写累相当多,希望大家多捧捧场 ^_^

    VSCode设置python3的支出条件(linux下默许是python2卡塔 尔(阿拉伯语:قطر‎

    在线浏览:http://nbviewer.jupyter.org/github/lotapp/BaseCode/tree/master/python/notebook/1.POP/2.str

    直白跳到扩张连串:https://www.cnblogs.com/dotnetcrazy/p/9175950.html#ext

    跻身增添:https://www.cnblogs.com/dotnetcrazy/p/9155310.html#ext

    在线演示:http://nbviewer.jupyter.org/github/lotapp/BaseCode/blob/master/python/notebook/1.POP/1.base/01.helloworld.ipynb

    刚开始阶段声澳优(Ausnutria Hyproca卡塔尔国下,幸免让新手步向误区:不是说Python比NetCore要好,而Python设计的目标正是==》让程序猿解放出来,不要过分关心代码本人,那么质量、标准等等各地方隐患就存在了,前面编写三个不怎么大点的等级次序就看出来了。並且不用太受语言限定,早前自个儿也说过,用各自语言的优势来为品种劳务~ 那才是付出王道。比如Python用来多少解析,Go用来现身管理等等,十分少说了,记住一句话就能够: style="color: #ff6600;">“Net是性能价格比最高的”

    style="color: #ff6600;">图片 1

    先从函数定义说起吧:

    步向正题:

    招待提议更简明的语法~(小说中案例有多个福利哦,贰个是调护治疗,三个是人为智能[ 密码:fqif])

    步入正题:应接建议更简约可能效用越来越高的主意

    # style="color: #ff6600;">定义一个空函数:(不写pass就报错了卡塔 尔(英语:State of Qatar)

    图片 2


    #  style="color: #ff6600;">概念一个无参函数只顾缩进

    图片 3


    概念一个含参函数

    图片 4

    扩:文书档案表达用""" 只怕'''来定义,便是之类效果

    图片 5


    #  style="color: #ff6600;">概念多个含暗许参数(缺省参数)的函数

    图片 6

    # 定义有再次来到值的函数

    图片 7


    # style="color: #ff6600;">定义含有多个重临值的函数(利用了元组卡塔尔

    图片 8

    来个案例解释一下:(多再次回到值只是风流浪漫种假象,Python函数再次来到的仍为单纯值~元组卡塔尔

    图片 9


    style="color: #ff00ff;">传八个参数体系:(上边相当多重临参数也得以回来二个list来得以达成相符作用)

    style="color: #ff6600;">援用传递(通过元组、列表落成)**扩展有可变类型和不可变类型作为形参的相比较

    图片 10


    # style="color: #ff6600;">定义一个可变参数的函数(参数名字平日都是 style="color: #ff6600;">*args)

    图片 11

    假若你供给传几个元组或许列表进去的话,能够参数前边加 style="color: #ff6600;">*

    图片 12

    # style="color: #ff6600;">定义含关键字参数的函数:def default_kv_params(name,age=23, style="color: #ff6600;">**kv):

    # 可变参数允许你传入0个或私行个参数,那么些可变参数在函数调用时自动组装为叁个tuple
    # 关键字参数允许你传入0个或私下个含key-value的参数,自动组装为四个dict

    图片 13

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

    图片 14

    供给注意py里面包车型地铁书写格式==》 style="color: #ff6600;">先定义再调用(Code参考)

    图片 15


    style="color: #008000;">NetCore:(C#底子语法我们都很熟了,笔者贴三个评释的Code就可以卡塔 尔(阿拉伯语:قطر‎

    style="color: #ff6600;">VSCode里面如若也想像VS雷同,///就生成注释==》问安装函数文书档案注释: style="color: #ff0000;">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
    


    // # 定义含有五个重回值的函数(利用了元组卡塔 尔(英语:State of Qatar) var (sum, dvalue) = DivHaveReturns(1, 2); Console.WriteLine($"sum:{sum},D-value:{dvalue}");
    // 传几个参数种类: // 引用传递(通过元组、列表达成卡塔 尔(阿拉伯语:قطر‎:扩大有可变类型和不得变类型作为形参的对照 var list = new List() { 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()
            {
    


    } ///

    /// 定义一个无参函数 /// // private static void GetName() // { // Console.WriteLine("你好"); // } //简写 private static void GetName() => Console.WriteLine("你好");
    /// /// 定义一个含参数的函数 /// /// 名字 /// 年龄 // private static void ShowInfos(string name, int age) // { // Console.WriteLine($"作者叫{name} 笔者的年龄是{age}"); // } //简写 private static void ShowInfos(string name, int age) => Console.WriteLine($"小编叫{name} 笔者的年龄是{age}");
    /// /// 定义一个含缺省参数的函数 /// /// 名字 /// 年龄默认23 // 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}");
    /// /// 定义一个有返回值的函数(计算a b,返回计算结果) /// /// num1 /// num2 // private static int DivHaveReturn(int a, int b) // { // return a b; // } //简写 private static int DivHaveReturn(int a, int b) => a b;

            #endregion
    


    ///

    /// 定义含有多个返回值的函数(利用了元组) /// 计算a b的和,计算a-b,并返回两个结果 /// /// /// /// // 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
        }
    }
    

    复习C#功底请看附录2:https://www.cnblogs.com/dotnetcrazy/p/9102030.html#csharp

    底蕴体系:(这边珍视说说Python,上次讲过的事物本人就单笔带过了卡塔尔

    函数相关扩张

     1.列表有关:

    先说下感觉,python的编制程序有一点点JavaScript的感到(比方:'和“临时候不区分),又感到像国外版的易语言,整个进程像读书相仿,举例三个成分不在列表之中==> for item not in lists。使用它做个大点的类别不得不承认要先分明好编制程序风格,否则能让人崩溃的。先不追究,后边会三回九转深究。。。(Python2自家就不讲了,官方推荐应用Python3

    1.出口 类型转变

    Python写法:

    图片 16

    NetCore:

    图片 17

    2.字符串拼接 style="background-color: initial;">拼接出口情势

    python:

    图片 18

    NetCore

    图片 19

    3.字符串遍历、下标、切丝

    重大说下python的 style="color: #ff0000;">下标,有一点意思,最终三个元素,大家经常都是len(str)-1,他能够一贯用-1,倒2自然就是-2

    #末尾三个要素:user_str[-1]

    user_str[-1]

    user_str[len(user_str)-1] #任何编制程序语言写法

    #尾数第一个成分: style="color: #ff0000;">user_str[-2]

    图片 20

    本次为了进一层形象比较,一句一句翻译成NetCore(有未有觉察规律,user_str[ style="color: #ff6600;">user_str.Length-1]==》 style="color: #ff6600;">-1是最终三个,user_str[ style="color: #ff6600;">user_str.Length-2]==》 style="color: #ff6600;">-2是最后三个。python在此上边简化了

    图片 21

    3.2 python切开语法: style="color: #ff0000;">[start_index:end_index:step] (end_index取不到)

    # 切片:[start_index:end_index:step] (end_index取不到)
    # eg:str[1:4] 取str[1]、str[2]、str[3]
    # eg:str[2:] 取下标为2开始到最后的元素
    # eg:str[2:-1] 取下标为2~到倒数第二个元素(end_index取不到)
    # eg:str[1:6:2] 隔着取~str[1]、str[3]、str[5](案例会详细说)
    # eg:str[::-1] 逆向输出(案例会详细说,)
    

    来个案例:小编注释部分说的很详细了,附录会贴democode的

    图片 22

    NetCore,其实你用Python跟其它语言相比反差越来越大,net真的很强盛了。补充(比较看就清楚Python的step为何是2了,i =2==》2卡塔尔国

     图片 23

    style="color: #ff0000;">1.递归函数:函数递归调用其实就是齐心协力调用自身,关键点只要构思怎么样时候跳出即可(未有跳出就是死循环)

    先来个大致的案例熟练一下:

    图片 24

    来个案例(实际专门的事业中并不会自身定义,用系统自带 style="color: #ff6600;">strip方法就能够)

    图片 25

    C#的递归笔者就引述一下在先的Code:https://github.com/dunitian/LoTCodeBase/blob/master/NetCode/1.面向进程/01.底子/10.递归案例/Program.cs

    图片 26


    2.佚名函数多元: style="color: #008000;">lambda 参数: 表达式

    图片 27

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

    图片 28

    还应该有一个相比较常用的地点:(当参数字传送递

    图片 29

    NetCore:下面Code中的简写都是用佚名函数的主意,能够参见


    3.全局变量和朝气蓬勃部分变量 

    有人也许会说,那些就太简单了,没啥好说的,(⊙o⊙)… Python还真需求说说,来个案例给您猜结果:

    图片 30

    直白看结果吗:开采全局变量a木有被更正,而b改良了

    图片 31

    抑或来个简单案例表达下吧~

    图片 32

    # 那是因为,python定义三个变量的写法不用加类型引致的(⊙﹏⊙) 所以 style="color: #008000;">函数里面a=200,python解释器就认为你定义了一个和a这么些全局变量名字同样的局地变量,那怎么用吧? style="color: #ff0000;">global来声称一下全局变量即可:

    图片 33

    总结:

    # 在函数中不使用 style="color: #ff0000;">global证明全局变量无法改改全局变量==>本质是不能改改全局变量的针对,即不能够将全局变量指向新的多寡

    # 对于不可变类型的全局变量来讲,因其指向的数额不能够改改,所以不应用global时不恐怕改革全局变量

    # 对于可变类型的全局变量来讲,因其指向的数目能够改良,所以不应用global时也可校勘全局变量


    style="color: #008000;">下边就进来验证扩张种类,看看一些概念

    # 以前非常多材质说py3佚名函数里无法调用print函数,本人测量检验下

    图片 34


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

    # 以为郁结可以看前边的运算符扩充()

    图片 35

    # Python中函数参数都以援引传递
    # 对于不可变类型,因变量不能够改改,所以运算不会潜濡默化到变量本人
    # 而对于可变类型来讲,函数体中的运算有希望会退换传入的参数变量


    # 函数名能否再一次的主题素材(能不能 style="color: #008000;">重载:具备区别的参数的种类或参数的个数【跟再次来到值不妨】

    图片 36

    敲定:函数名不能重名


    来四个有意思的恢宏

    style="color: #ff6600;">1.换到八个数熟练吧,编制程序第大器晚成课,除了用其三变量 或者 两数相加减 达成外,Python还会有生龙活虎种新方式 style="color: #ff0000;">a,b=b,a

    图片 37

    NetCore:这么些作者也是刚知道,O(∩_∩)O哈哈~还得多谢争辨区的男子^_^

    图片 38


     2. style="color: #ff6600;">eval(和js里面包车型客车eval大约卡塔 尔(英语:State of Qatar): style="color: #008000;">不太提议接纳

     图片 39

    style="color: #ff6600;">Python定义四个列表(列表尽管可以存差别品种,常常大家把相符类别的值存列表里面,不一样系列存字典里(key,value卡塔尔国卡塔 尔(阿拉伯语:قطر‎

    info_list=[] #空列表

    style="color: #ff6600;">infos_list=["C#","JavaScript"]

    遍历和事先同生龙活虎,for 大概 while 都得以(for扩张:)

    图片 40

    NetCore style="color: #ff6600;">var infos_list = new List<object>() { "C#", "JavaScript" };

    遍历能够用foreach,for,while

    图片 41


    Python列表的丰盛

    # 最后追加 infos_list. style="color: #ff6600;">append("Java")

    #  style="color: #ff6600;">累计四个列表 infos_list. style="color: #ff6600;">extend(infos_list2)

    # style="color: #ff6600;">钦命地方插入 infos_list. style="color: #ff6600;">insert(0,"Python") 

    # 布置列表:infos_list style="color: #ff6600;">.insert(0,temp_list) 

     看后边的 style="color: #339966;">列表嵌套,是透过下标格局获取,eg: infos_list[0][1]

    图片 42

    style="color: #ff6600;">Python在钦赐地点插入列表是实在插入三个列表进去,C#是把内部的因素挨个插入进去

    图片 43

    style="color: #ff6600;">NetCore:Add,AddRange,Insert,InsertRange (和Python插入列表有个别分裂)

    图片 44


    Python列表删除种类

    infos_list.pop() #去除最终二个

    infos_list.pop(0) #删去钦定索引,海市蜃楼就报错

    infos_list. style="color: #ff6600;">remove("张三")  style="background-color: initial;"># remove("")删除钦点成分 style="background-color: initial;">,一纸空文就报错

    图片 45

    style="color: #ff6600;">del infos_list[1] #剔除内定下标成分,不设有就报错

    del infos_list #删去集结(会集再拜望就子虚乌有了卡塔尔差别于C#给集合赋null

    图片 46

    再过叁回图片 47

    style="color: #ff6600;">NetCore移除钦赐索引:infos_list. style="color: #ff6600;">RemoveAt(1); 移除钦命值: infos_list. style="color: #ff6600;">Remove(item); 清空列表: infos_list. style="color: #ff6600;">Clear();

    图片 48


    style="color: #ff6600;">Python改进:(只可以通过索引校正卡塔 尔(英语:State of Qatar)

    infos_list2[1]="PHP" #唯有下标校正意气风发种方法, style="background-color: initial;">不设有则十二分

    # 想按值修改要求先查下标再校勘 eg:

    infos_list2.index("张三")

    infos_list2[0]="GO"

    # infos_list2.index("dnt")#空头支票则十三分

    style="color: #000000;">图片 49

    # 知识面扩充:

    # 为何python中不建议在for循环中期维修改列表?

    # 由于在遍历的进程中,删除了内部四个因素,招致后边的因素全体前移,招致有个要素成了漏网游鱼。

    # 相符的,在遍历进程中,使用插入操作,也会促成相似的荒唐。那也便是难题里说的无能为力“跟踪”成分。

    # 要是选择while,则足以在面对那样情形的时候灵活应对。

    NetCore:基本上和Python同样

    图片 50


    style="color: #ff6600;">Python查询种类:in, not in, index, count

    if "张三" in names_list:

      names_list.remove("张三")

    if "大舅子" not in names_list:

      names_list.append("大舅子")

    names_list.index("王二麻子")

    names_list.count("逆天")

    style="color: #000000;">图片 51

    NetCore: style="color: #008000;">IndexOf , style="color: #008000;">Count

    图片 52

    查找用 style="color: #008000;">Contains基础语法对比。,别的的先看看,前面会讲

    图片 53


    Python排序 style="background-color: initial;"> 

    num_list.reverse()  style="background-color: initial;"># 倒序

    num_list.sort()  style="background-color: initial;"># 从小到大排序

    num_list. style="color: #ff6600;">sort(reverse=True)  style="background-color: initial;"># 从大到小

    图片 54

    style="color: #ff6600;">列表嵌套,获取用下标的措施: style="color: #ff6600;">num_list[5][1]

    图片 55

    NetCorevar num_list2 = new List<object>() { 33, 44, 22, style="color: #008000;">new List<object>(){11,55,77} };

    无法像python那样下标操作,能够定义多维数组来扶植 num_list2[i][j] (PS,其实那些嵌套不太用,今后都是列表里面套Dict,相同与Json卡塔尔国

    图片 56

    0.命名法规

    主意层层:

     

    2.Tuple 元组

    Python官方是援用使用_来间距单词,但经常开采人士都是以各自己作主语言的命名来定义的,那几个就各人欢欣了,可是团队自然要统风姿浪漫。

    style="color: #ff6600;">标示符字母、下划线和数字组成,且数字不能够开始(这么些大致都相似卡塔 尔(英语:State of Qatar) style="color: #ff0000;">注意: style="background-color: #ffff00; color: #000000;">标志符是分别抑扬顿挫写的

    图片 57图片 58

    style="color: #ff6600;">取名法则,总的原则就是见名知意,平常都以驼峰命名法,纯Python的话推荐用_接二连三单词

     扩充:Python的 style="color: #ff6600;">关键词能够友善打字与印刷一下:

    图片 59

    ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

    # 查找:find,rfind,index,rindex

    Python查找推荐您用find和rfind

    图片 60

    netcore:index0f就一定于python里面包车型地铁find

    图片 61


    # 计数:count

    python:str.count()

    图片 62

    netcore:那些真用底工来缓和的话,二种办法:

    先是种和煦变形一下: style="background-color: initial;">(原字符串长度 - 替换后的长度) / 字符串长度

    图片 63

     

    style="color: #ff6600;">字符串总括另风度翩翩种方法(就用index)【点我】

     

                int count = 0;
                int index = input.IndexOf("abc");
    


    while (index != -1) { count ; index = input.IndexOf("abc", index 3);//index指向abc的后一位 }

     

    Python补充表达:像这么些艺术演练用ipython3就好了(sudo apt-get install ipython3卡塔尔,code的话须要二个个的print,相比费心(笔者那边因为急需写文章,所以只可以二个个code卡塔 尔(英语:State of Qatar)

    图片 64

    index查找不到会有特别

    图片 65


    # 替换:replace

    Python:xxx.replace(str1, str2, 替换次数)

    图片 66

    replace能够钦定替换几遍

    图片 67

    NetCore:替换内定次数的功用有一点点业余,就蒙蔽了,你能够自动考虑哦~

    图片 68


    style="color: #ff6600;">#连接:join:eg:print("-".join(test_list))

    style="color: #ff6600;">图片 69

     netcore:string.Join(分隔符,数组)

    图片 70 style="background-color: initial;"> 

    style="color: #ff6600;">#细分:split(按钦命字符分割卡塔尔国,splitlines(按行分割),partition(以str分割成三某个,str前,str和str后),rpartition

    说下split的切成块用法 :print( style="background-color: #ffff99;">test_input.split(" ",3)) #在第四个空格处切成片,前边的不切了

    图片 71

    图片 72

    一连说说 style="color: #ff6600;">splitlines(按行分割),和split("n")的界别小编图中给了案例

    扩展: style="background-color: initial; color: #ff6600;">split(),私下认可按空字符切割(空格、t、n等等,不用顾虑重返'')

    图片 73

    最终说一下 style="color: #ff6600;">partition style="background-color: initial;">和 style="color: #ff6600;">r style="background-color: initial;"> style="color: #ff6600;">partition 回来是元祖类型(后边会说的卡塔尔,方式和find相符,找到第二个门道相当的就罢工了【注意一下没找到的情景】

    图片 74

     

    netcore: style="background-color: initial;"> split里面比较多种载方法,能够自身去查看下,eg: style="color: #ff6600;">Split("n",StringSplitOptions.RemoveEmptyEntries)**

    再说一下以此: style="background-color: initial;">test_str.Split('a');//重回数组。 style="color: #ff6600;">万大器晚成要和Python相像 style="background-color: #ffff99;">重返列表==》test_str. style="background-color: #ffff99;">Split('a').ToList(); 【要求援引linq的命名空间啊】

    图片 75


    # 头尾决断:startswith(以。。。领头卡塔 尔(英语:State of Qatar),endswith(以。。。结尾卡塔 尔(阿拉伯语:قطر‎

    图片 76

    netcore:

    图片 77


    # 大小写系: style="color: #ff6600;">lower(字符串转变为题写), style="color: #ff6600;">upper(字符串转换为题写),title(单词首字母大写), style="color: #ff6600;">capitalize( style="background-color: #ffff99;">第叁个字符大写,其余变小写)

    图片 78

    netcore:

    图片 79


    # 格式连串: style="color: #ff6600;">lstrip(去除左边空格卡塔 尔(阿拉伯语:قطر‎, style="color: #ff6600;">rstrip(去除左边空格卡塔尔, style="color: #ff6600;">strip(去除两边空格卡塔 尔(阿拉伯语:قطر‎美化输出体系: style="color: #ff6600;">ljust, style="color: #ff6600;">rjust, style="color: #ff6600;">center

    style="background-color: initial;">图片 80 style="background-color: initial;"> 

    图片 81

     

    netcore:Tirm很强盛,除了去空格还足以去除你想去除的自由字符

    图片 82

    ljust,rjust,center这几个就不说了,python平时在linux终端中输出,所以那多少个用的超级多。net里面string.Format各个格式化输出,能够参照

     


    # 验证体系: style="color: #ff6600;">is阿尔法(是不是是纯字母卡塔 尔(英语:State of Qatar), style="color: #ff6600;">isalnum(是或不是是数字|字母卡塔尔, style="color: #ff6600;">isdigit(是还是不是是纯数字卡塔尔国, style="color: #ff6600;">isspace(是或不是是纯空格卡塔 尔(阿拉伯语:قطر‎

    一张图解决,别的的自身去试风流倜傥试吧,注意哦~ style="color: #ff0000;"> style="background-color: initial;"> test_str5=" t n " # style="background-color: #ffff99;">isspace() ==>true

    图片 83

     

    netcore: style="background-color: initial;">string.IsNullOrEmpty 和 string.IsNullOrWhiteSpace 是系统自带的,别的的你需求团结包装一个扩大类(eg:粗略包装)【附录有】

    图片 84

    先到那吗,有如何扩展的下边再贴吧~

    这一次先说 style="color: #008000;">NetCore吧:(逆天ValueTuple用的超级多,上面案例正是用的那么些卡塔尔

    元组系:

    值元组:

     

    style="font-size: 15px;">C#瓜时组重要是便利程序员,不用自然能够。 style="background-color: initial;">比方:当您回去七个值是不是还用ref out 或然重返四个list之类的? style="background-color: initial;"> 这几个都亟需先定义,比较麻烦.元祖在这几个处境用的可比多。 style="background-color: initial;">先说说基本使用:

     

    style="background-color: initial;">初始化: style="background-color: initial;">var test_tuple = ("萌萌哒", 1, 3, 5, "加息", "加息"); //这种方法就是valueTuple了(看vscode监视音讯卡塔尔

    图片 85

    亟待说下的是,取值只可以通过itemxxx来取了,然后就是 style="color: #ff6600;">valueTuple的值是足以修正的

    图片 86

    概略上面说的(平日不会用的卡塔尔,直接进应用处景:

    图片 87

    就提及那了,代码部分附录是大器晚成对

     

    style="color: #ff6600;">Python:用法基本上和列表大约( style="color: #ff0000;">下标和眼下说的用法同样,比方test_tuples[-1] 最终三个成分卡塔尔

    概念:四个要素:test_tuple1= style="color: #ff6600;">(1,)

     

    test_tuple=("萌萌哒",1,3,5,"加息","加息")

    test_tuple. style="color: #ff6600;">count("加息")

    test_tuple. style="color: #ff6600;">index("萌萌哒")  style="background-color: initial;">#没有find方法

    test_tuple.index("加息", 1, 4) #从一定岗位查找, style="background-color: initial;">左闭右开区间==>[1,4)

    图片 88

    来讲说拆包相关的,C#的地点说了,那边来个案例就能够:

    a=(1,2)

    b=a #把a的援用给b

    c,d=a #不是把a分别赋值给c和d,等价于: style="color: #ff6600;">c=a[0] d=a[1]

    图片 89

    来个扩充吧(多维元组卡塔 尔(英语:State of Qatar)

    some_tuples=[(2,"萌萌哒"),(4,3)]

    some_tuples[0]

    some_tuples[0][1]

    图片 90

    1.注释

    附录:

    3.Dict系列

    python: style="color: #ff6600;">#表明生机勃勃行四个单引号可能多个双引号注释多行: style="color: #008000;">'''XXX style="color: #008000;">'''或者 style="color: #008000;">"""XXXX style="color: #008000;">"""(一般用#就够了,有点像shell脚本的以为卡塔 尔(英语:State of Qatar)

    python输出就径直print即可,C是printf(不要搞混哦卡塔尔

    图片 91

    C、Java、Net都以 style="color: #ff6600;">//注释后生可畏行,/**/注释多行

    图片 92

    Python3:

    图片 93图片 94

    # #输出 类型转换
    # user_num1=input("输入第一个数:")
    # user_num2=input("输入第二个数:")
    

    # print("两数之和:%d"%(int(user_num1) int(user_num2)))
    

    # # ------------------------------------------------------------
    

    # #字符串拼接
    # user_name=input("输入昵称:")
    # user_pass=input("输入密码:")
    # user_url="192.168.1.121"
    

    # #拼接输出方式一:
    # print("ftp://" user_name ":" user_pass "@" user_url)
    

    # #拼接输出方式二:
    # print("ftp://%s:%s@%s"%(user_name,user_pass,user_url))
    

    # # -------------------------------------------------------------
    

    # # 字符串遍历、下标、切片
    # user_str="七大姑曰:工作了吗?八大姨问:买房了吗?异性说:结婚了吗?"
    

    # #遍历
    # for item in user_str:
    #     print(item,end=" ")
    

    # #长度:len(user_str)
    # print(len(user_str))
    

    # #第一个元素:user_str[0]
    # print(user_str[0])
    

    # #最后一个元素:user_str[-1]
    # print(user_str[-1])
    # print(user_str[len(user_str)-1])#其他编程语言写法
    

    # #倒数第二个元素:user_str[-2]
    # print(user_str[-2])
    

    # # -------------------------------------------------------------
    

    # 切片:[start_index:end_index:step] (end_index取不到)
    # eg:str[1:4] 取str[1]、str[2]、str[3]
    # eg:str[2:] 取下标为2开始到最后的元素
    # eg:str[2:-1] 取下标为2~到倒数第二个元素(end_index取不到)
    # eg:str[1:6:2] 隔着取~str[1]、str[3]、str[5](案例会详细说)
    # eg:str[::-1] 逆向输出(案例会详细说,)
    


    it_str="小编爱编制程序,编制程序爱它,它是前后相继,程序是谁?"

    #eg:取“编程爱它” it_str[5:9]
    print(it_str[5:9])
    print(it_str[5:-11]) #end_index用-xx也一样
    print(it_str[-15:-11])#start_index用-xx也可以
    

    #eg:取“编程爱它,它是程序,程序是谁?” it_str[5:]
    print(it_str[5:])#不写默认取到最后一个
    

    #eg:一个隔一个跳着取("我编,程它它程,序谁") it_str[0::2]
    print(it_str[0::2])#step=△index(eg:0,1,2,3。这里的step=> 2-0 => 间隔1)
    

    #eg:倒序输出 it_str[::-1]
    # end_index不写默认是取到最后一个,是正取(从左往右)还是逆取(从右往左),就看step是正是负
    print(it_str[::-1])
    print(it_str[-1::-1])#等价于上一个
    

    # # -------------------------------------------------------------
    

    View Code

    图片 95图片 96

    test_str="ABCDabcdefacddbdf"
    

    # -------------------------------------------------------------
    

    # # 查找:find,rfind,index,rindex
    # # xxx.find(str, start, end)
    # print(test_str.find("cd"))#从左往右
    # print(test_str.rfind("cd"))#从右往左
    # print(test_str.find("dnt"))#find和rfind找不到就返回-1
    

    # # index和rindex用法和find一样,只是找不到会报错(以后用find系即可)
    # # print(test_str.index("dnt"))
    

    # # -------------------------------------------------------------
    

    # # 计数:count
    # # xxx.count(str, start, end)
    # print(test_str.count("a"))
    

    # # -------------------------------------------------------------
    

    # # 替换:replace
    # # xxx.replace(str1, str2, count_num)
    # print(test_str)
    # print(test_str.replace("b","B"))#并没有改变原字符串,只是生成了一个新的字符串
    # print(test_str)
    

    # # replace可以指定替换几次
    # print(test_str.replace("b","B",1))#ABCDaBcdefacddbdf
    

    # # -------------------------------------------------------------
    

    # 分割:split(按指定字符分割),splitlines(按行分割),,partition(以str分割成三部分,str前,str和str后),rpartition
    # test_list=test_str.split("a")#a有两个,按照a分割,那么会分成三段,返回类型是列表(List),并且返回结果中没有a
    # print(test_list)
    

    # test_input="hi my name is dnt"
    # print(test_input.split(" ")) #返回列表格式(后面会说)['hi', 'my', 'name', 'is', 'dnt']
    # print(test_input.split(" ",3))#在第三个空格处切片,后面的不管了
    

    # # 按行分割,返回类型为List
    # test_line_str="abcnbcancabn"
    # print(test_line_str.splitlines())#['abc', 'bca', 'cab']
    # print(test_line_str.split("n"))#看出区别了吧:['abc', 'bca', 'cab', '']
    

    # # 没看出来就再来个案例
    # test_line_str2="abcnbcancabnLLL"
    # print(test_line_str2.splitlines())#['abc', 'bca', 'cab', 'LLL']
    # print(test_line_str2.split("n"))#再提示一下,最后不是n就和上面一样效果
    

    # 扩展:
    # print("hi my name is dnttn  mntn".split())#split(),默认按空字符切割(空格、t、n等等,不用担心返回'')
    

    # #partition,返回是元祖类型(后面会说的),方式和find一样,找到第一个匹配的就罢工了
    # print(test_str.partition("cd"))#('ABCDab', 'cd', 'efacddbdf')
    # print(test_str.rpartition("cd"))#('ABCDabcdefa', 'cd', 'dbdf')
    # print(test_str.partition("感觉自己萌萌哒"))#没找到:('ABCDabcdefacddbdf', '', '')
    

    # # -------------------------------------------------------------
    

    # # 连接:join
    # # separat.join(xxx)
    # # 错误用法:xxx.join("-")
    # print("-".join(test_list))
    

    # # -------------------------------------------------------------
    

    # # 头尾判断:startswith(以。。。开头),endswith(以。。。结尾)
    # # test_str.startswith(以。。。开头)
    # start_end_str="http://www.baidu.net"
    # print(start_end_str.startswith("https://") or start_end_str.startswith("http://"))
    # print(start_end_str.endswith(".com"))
    # # -------------------------------------------------------------
    

    # # 大小写系:lower(字符串转换为小写),upper(字符串转换为大写),title(单词首字母大写),capitalize(第一个字符大写,其他变小写)
    # print(test_str)
    # print(test_str.upper())#ABCDABCDEFACDDBDF
    # print(test_str.lower())#abcdabcdefacddbdf
    # print(test_str.capitalize())#第一个字符大写,其他变小写
    

    # # -------------------------------------------------------------
    

    # # 格式系列:lstrip(去除左边空格),rstrip(去除右边空格),strip(去除两边空格),ljust,rjust,center
    # strip_str=" I Have a Dream "
    # print(strip_str.strip() "|")#我加 | 是为了看清后面空格,没有别的用处
    # print(strip_str.lstrip() "|")
    # print(strip_str.rstrip() "|")
    

    # #这个就是格式化输出,就不讲了
    # print(test_str.ljust(50))
    # print(test_str.rjust(50))
    # print(test_str.center(50))
    # # -------------------------------------------------------------
    

    # 验证系列:isalpha(是否是纯字母),isalnum(是否是数字|字母),isdigit(是否是纯数字),isspace(是否是纯空格)
    

    # test_str2="Abcd123"
    # test_str3="123456"
    # test_str4="  t"
    # test_str5="  t n " #isspace() ==>true
    # 一张图搞定,其他的自己去试一试吧
    # test_str.isalpha()
    # test_str.isalnum()
    # test_str.isdigit()
    # test_str.isspace()
    

    View Code

    NetCore:

    图片 97图片 98

    using System;
    using System.Linq;
    


    namespace aibaseConsole { public static class Program { private static void Main() {

                #region BaseCode
    


    //var test="123";//定义二个变量 // Console.WriteLine(test);//输出那个变量 // // Console.WriteLine("请输入顾客名:"); // var name = Console.ReadLine(); //
    // Console.WriteLine("请输入性别:"); // var gender = Console.ReadLine(); //
    // Console.WriteLine($"Name:{name},Gender:{gender}"); //推荐用法 // Console.WriteLine("Name:{0},Gender:{1}", name, gender); //Old 输出 // //// 类型调换 // Console.WriteLine("输入第多个数字:");
    // var num1 = Console.ReadLine();
    // Console.WriteLine("输入第三个数字:");
    // var num2 = Console.ReadLine(); // Console.WriteLine($"num1 num2={Convert.ToInt32(num1) Convert.ToInt32(num2)}"); //
    //// Convert.ToInt64(),Convert.ToDouble(),Convert.ToString() // Console.Write("dnt.dkill.net/now"); // Console.WriteLine("带您走进中医经络"); // // var temp = "xxx"; // var tEmp = "==="; // Console.WriteLine(temp tEmp); // var num = 9; // Console.WriteLine("num=9,下边结果是对2的除,取余,取商操作:"); // Console.WriteLine(num/2.0); // Console.WriteLine(num%2.0); // Console.WriteLine(num/2); // //指数 // Console.WriteLine(Math.Pow(2,3));
    // int age = 24; // // if (age >= 23) // Console.WriteLine("七大妈曰:职业了啊?八小姑问:买房了啊?异性说:成婚了吗?"); // else if (age >= 18) // { // Console.WriteLine(age); // Console.WriteLine("成年了哇"); // } // else // Console.WriteLine("好学不倦每四日向上");
    // int i = 1; // int sum = 0; // while (i <= 100) // { // sum = i; // i ; // } // Console.WriteLine(sum);
    // var name = ""; // foreach (var i in name) // { // if(i=='#') // break; // Console.Write(i); // } // Console.WriteLine("n end ...");

                #endregion
    

                #region String
                //            //# # 字符串遍历、下标、切片
                //            //# user_str="七大姑曰:工作了吗?八大姨问:买房了吗?异性说:结婚了吗?"
                //            var user_str = "七大姑曰:工作了吗?八大姨问:买房了吗?异性说:结婚了吗?";
                //
                //            //# #遍历
                //            //# for item in user_str:
                //            //#     print(item,end=" ")
                //            foreach (var item in user_str)
                //            {
                //                Console.Write(item);
                //            }
                //            
                //            //# #长度:len(user_str)
                //            //# print(len(user_str))
                //            Console.WriteLine(user_str.Length);
                //
                //            //# #第一个元素:user_str[0]
                //            //# print(user_str[0])
                //            Console.WriteLine(user_str[0]);
                //            
                //            //# #最后一个元素:user_str[-1]
                //            //# print(user_str[-1])
                //            //# print(user_str[len(user_str)-1])#其他编程语言写法
                //            Console.WriteLine(user_str[user_str.Length-1]);
                //            //
                //            //# #倒数第二个元素:user_str[-2]
                //            //# print(user_str[-2])
                //            Console.WriteLine(user_str[user_str.Length-2]);
    


    // //# # ------------------------------------------------------------- // // // //# 切片:[start_index:end_index:step] (end_index取不到) // //# eg:str[1:4] 取str[1]、str[2]、str[3] // //# eg:str[2:] 取下标为2起来到最后的因素 // //# eg:str[2:-1] 取下标为2~到尾数第贰个成分(end_index取不到) // //# eg:str[1:6:2] 隔着取~str[1]、str[3]、str[5](案例会详细说) // //# eg:str[::-1] 逆向输出(案例会详细说,卡塔 尔(阿拉伯语:قطر‎ // // // var it_str = "笔者爱编制程序,编制程序爱它,它是前后相继,程序是何人?"; // // // //#eg:取“编制程序爱它” it_str[5:9] // // print(it_str[5:9]) // // print(it_str[5:-11]) #end_index用-xx也一样 // // print(it_str[-15:-11])#start_index用-xx也可以 //
    // //Substring(int startIndex, int length) // Console.WriteLine(it_str.Substring(5, 4));//首个参数是长度 //
    // // // //#eg:取“编制程序爱它,它是程序,程序是哪个人?” it_str[5:] // // print(it_str[5:])#不写暗中认可取到结尾叁个 // Console.WriteLine(it_str.Substring(5));//不写暗许取到最后二个 //
    // //#eg:一个隔二个跳着取("我编,程它它程,序哪个人"卡塔 尔(英语:State of Qatar) it_str[0::2] // // print(itstr[0::2])#step=△index(eg:0,1,2,3。这里的step=> 2-0 => 间隔1) //
    // //那么些自家先是反馈是用linq ^
    ^ // for (int i = 0; i < it_str.Length; i =2)//相比看就免去Python的step为啥是2了,i =2==》2 // { // Console.Write(it_str[i]); // } //
    // Console.WriteLine("n倒序:"); // //#eg:倒序输出 it_str[::-1] // //# end_index不写暗中认可是取到最终三个,是正取(从左往右卡塔 尔(阿拉伯语:قطر‎依然逆取(从右往左卡塔 尔(英语:State of Qatar),就看step是多亏负 // // print(it_str[::-1]) // // print(it_str[-1::-1])#等价于上二个 // for (int i = it_str.Length-1; i>=0; i--) // { // Console.Write(it_str[i]); // } // //其实能够用Linq:Console.WriteLine(new string(it_str.ToCharArray().Reverse().ToArray()));

                #endregion
    

                #region StringMethod
                // var test_str = "ABCDabcdefacddbdf";
    


    // //# # 查找:find,rfind,index,rindex // //# # xxx.find(str, start, end) // //# print(test_str.find("cd"))#从左往右 // Console.WriteLine(test_str.IndexOf('a'));//4 // Console.WriteLine(test_str.IndexOf("cd"));//6
    // //# print(test_str.rfind("cd"))#从右往左 // Console.WriteLine(test_str.LastIndexOf("cd"));//11
    // //# print(test_str.find("dnt"))#find和rfind找不到就回到-1 // Console.WriteLine(test_str.IndexOf("dnt"));//-1 // //# # index和rindex用法和find相似,只是找不加入报错(现在用find系就能够卡塔尔 // //# print(test_str.index("dnt"))
    // //# # ------------------------------------------------------------- // //# # 计数:count // //# # xxx.count(str, start, end) // // print(test_str.count("d"))#4 // // print(test_str.count("cd"))#2 // // 第风度翩翩影响,字典、正则、linq,后来想怎么用底工知识化解,于是有了那么些~(原字符串长度-替换后的长短)/字符串长度
    // System.Console.WriteLine(test_str.Length-test_str.Replace("d","").Length);//总结单个字符就轻巧了 // System.Console.WriteLine((test_str.Length-test_str.Replace("cd","").Length)/"cd".Length); // System.Console.WriteLine(test_str);//不用忧虑原字符串改正(python和C#都以有字符串不可变性的卡塔尔
    // //# # ------------------------------------------------------------- // // // //# # 替换:replace // //# # xxx.replace(str1, str2, count_num) // //# print(test_str) // //# print(test_str.replace("b","B"))#并不曾改动原字符串,只是生成了贰个新的字符串 // //# print(test_str) // System.Console.WriteLine(test_str.Replace("b","B")); // //# # replace可以钦赐替换五次 // //# print(test_str.replace("b","B",1))#ABCDaBcdefacddbdf // // 替换钦命次数的效率有一些业余,就不说了
    // //# # -------------------------------------------------------------
    // //# 分割:split(按钦赐字符分割卡塔尔,splitlines(按行分割),partition(以str分割成三片段,str前,str和str后),rpartition // //# test_list=test_str.split("a")#a有八个,遵照a分割,那么会分为三段,重回类型是列表(List卡塔尔,并且重回结果中从未a // //# print(test_list) // var test_array = test_str.Split('a');//再次回到数组(即便要回去列表==》test_str.Split('a').ToList();) // var test_input = "hi my name is dnt"; // //# print(test_input.split(" ")) #重临列表格式(前边会说卡塔尔国['hi', 'my', 'name', 'is', 'dnt'] // test_input.Split(" "); // //# print(test_input.split(" ",3))#在第多少个空格处切块,后边的无论了 // //# # 按行分割,重返类型为List // var test_line_str = "abcnbcancabn"; // //# print(test_line_str.splitlines())#['abc', 'bca', 'cab'] // test_line_str.Split("n", StringSplitOptions.RemoveEmptyEntries); // //# print(test_line_str.split("n"))#看出差异了吗:['abc', 'bca', 'cab', ''] // // // //# # # 没看出来就再来个案例 // //# test_line_str2="abcnbcancabnLLL" // //# print(test_line_str2.splitlines())#['abc', 'bca', 'cab', 'LLL'] // //# print(test_line_str2.split("n"))#再唤醒一下,最后不是n就和下面雷同效果 // // // //# # 扩展: // //# print("hi my name is dnttn mntn".split())#split(),私下认可按空字符切割(空格、t、n等等,不用顾忌重回'') // // // //# #partition,再次来到是元祖类型(后边会说的卡塔尔国,情势和find同样,找到第三个门当户对的就罢工了 // //# print(test_str.partition("cd"))#('ABCDab', 'cd', 'efacddbdf') // //# print(test_str.rpartition("cd"))#('ABCDabcdefa', 'cd', 'dbdf') // //# print(test_str.partition("认为本身萌萌哒"))#没找到:('ABCDabcdefacddbdf', '', '') // // // //# # ------------------------------------------------------------- // //# 连接:join // //# separat.join(xxx) // //# 错误用法:xxx.join("-") // //# print("-".join(test_list)) // System.Console.WriteLine(string.Join("-",test_array));//test_array是数组 ABCD-bcdef-cddbdf //# # ------------------------------------------------------------- // // //# # 头尾判定:startswith(以。。。初阶卡塔尔国,endswith(以。。。结尾卡塔 尔(阿拉伯语:قطر‎ // //# # test_str.startswith(以。。。开头) // var start_end_str=""; // //# print(start_end_str.startswith("https://") or start_end_str.startswith("http://")) // System.Console.WriteLine(start_end_str.StartsWith("")); // //# print(start_end_str.endswith(".com")) // System.Console.WriteLine(start_end_str.EndsWith(".com")); // //# # ------------------------------------------------------------- // // // //# # 大小写系:lower(字符串转变为题写),upper(字符串调换为题写),title(单词首字母大写),capitalize(第贰个字符大写,别的变小写) // //# print(test_str) // //# print(test_str.upper())#ABCDABCDEFACDDBDF // System.Console.WriteLine(test_str.ToUpper()); // //# print(test_str.lower())#abcdabcdefacddbdf // System.Console.WriteLine(test_str.ToLower()); // //# print(test_str.capitalize())#第多个字符大写,别的变小写 // // // //# # ------------------------------------------------------------- // // // //# # 格式体系:lstrip(去除左边空格卡塔 尔(阿拉伯语:قطر‎,rstrip(去除侧面空格卡塔 尔(英语:State of Qatar),strip(去除两侧空格卡塔尔,ljust,rjust,center // var strip_str=" I Have a Dream "; // //# print(strip_str.strip() "|")#作者加 | 是为着看清前边空格,未有其余用项 // System.Console.WriteLine(strip_str.Trim() "|"); // //# print(strip_str.lstrip() "|") // System.Console.WriteLine(strip_str.TrimStart() "|"); // //# print(strip_str.rstrip() "|") // System.Console.WriteLine(strip_str.TrimEnd() "|");
    //# #那一个就是格式化输出,就不讲了 //# print(test_str.ljust(50)) //# print(test_str.rjust(50)) //# print(test_str.center(50)) //# # ------------------------------------------------------------- // // //# 验证连串:is阿尔法(是否是纯字母卡塔尔,isalnum(是或不是是数字|字母),isdigit(是或不是是纯数字卡塔 尔(英语:State of Qatar),isspace(是还是不是是纯空格卡塔 尔(阿拉伯语:قطر‎ // // // //# test_str2="Abcd123" // //# test_str3="123456" // var test_str4=" t"; // var test_str5=" t n "; //#isspace() ==>true // // string.IsNullOrEmpty 和 string.IsNullOrWhiteSpace 是系统自带的,其余的你要求自个儿包裹三个恢弘类 // System.Console.WriteLine(string.IsNullOrEmpty(test_str4)); //false // System.Console.WriteLine(string.IsNullOrWhiteSpace(test_str4));//true // System.Console.WriteLine(string.IsNullOrEmpty(test_str5));//false // System.Console.WriteLine(string.IsNullOrWhiteSpace(test_str5));//true // //# 一张图化解,其余的投机去试风流倜傥试吧 // //# test_str.isalpha() // //# test_str.isalnum() // //# test_str.isdigit() // //# test_str.isspace()

                #endregion
                // Console.Read();
            }
        }
    }
    

    View Code

    简短包装:

    图片 99图片 100

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text.RegularExpressions;
    


    public static partial class ValidationHelper {

        #region 常用验证
    

        #region 集合系列
        /// <summary>
        /// 判断集合是否有数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <returns></returns>
        public static bool ExistsData<T>(this IEnumerable<T> list)
        {
            bool b = false;
            if (list != null && list.Count() > 0)
            {
                b = true;
            }
            return b;
        } 
        #endregion
    

        #region Null判断系列
        /// <summary>
        /// 判断是否为空或Null
        /// </summary>
        /// <param name="objStr"></param>
        /// <returns></returns>
        public static bool IsNullOrWhiteSpace(this string objStr)
        {
            if (string.IsNullOrWhiteSpace(objStr))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    


    ///

    /// 判断类型是否为可空类型 /// /// /// public static bool IsNullableType(Type theType) { return (theType.IsGenericType && theType.GetGenericTypeDefinition().Equals(typeof(Nullable<>))); }

        #endregion
    

        #region 数字字符串检查
        /// <summary>
        /// 是否数字字符串(包括小数)
        /// </summary>
        /// <param name="objStr">输入字符串</param>
        /// <returns></returns>
        public static bool IsNumber(this string objStr)
        {
            try
            {
                return Regex.IsMatch(objStr, @"^d (.d )?$");
            }
            catch
            {
                return false;
            }
        }
    


    ///

    /// 是否是浮点数 /// /// 输入字符串 /// public static bool IsDecimal(this string objStr) { try { return Regex.IsMatch(objStr, @"^(-?d )(.d )?$"); } catch { return false; } }

        #endregion
    

        #endregion
    

        #region 业务常用
    

        #region 中文检测
        /// <summary>
        /// 检测是否有中文字符
        /// </summary>
        /// <param name="objStr"></param>
        /// <returns></returns>
        public static bool IsZhCN(this string objStr)
        {
            try
            {
                return Regex.IsMatch(objStr, "[u4e00-u9fa5]");
            }
            catch
            {
                return false;
            }
        }
        #endregion
    

        #region 邮箱验证
        /// <summary>
        /// 判断邮箱地址是否正确
        /// </summary>
        /// <param name="objStr"></param>
        /// <returns></returns>
        public static bool IsEmail(this string objStr)
        {
            try
            {
                return Regex.IsMatch(objStr, @"^([w-.] )@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-] .) ))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$");
            }
            catch
            {
                return false;
            }
        }
        #endregion
    

        #region IP系列验证
        /// <summary>
        /// 是否为ip
        /// </summary>
        /// <param name="objStr"></param>
        /// <returns></returns>
        public static bool IsIP(this string objStr)
        {
            return Regex.IsMatch(objStr, @"^((2[0-4]d|25[0-5]|[01]?dd?).){3}(2[0-4]d|25[0-5]|[01]?dd?)$");
        }
    


    ///

    /// 判断输入的字符串是否是表示一个IP地址 ///
    /// 被比较的字符串
    /// 是IP地址则为True
    public static bool IsIPv4(this string objStr) { string[] IPs = objStr.Split('.'); for (int i = 0; i < IPs.Length; i ) { if (!Regex.IsMatch(IPs[i], @"^d $")) { return false; } if (Convert.ToUInt16(IPs[i]) > 255) { return false; } } return true; }
    /// /// 判断输入的字符串是否是合法的IPV6 地址 /// /// /// public static bool IsIPV6(string input) { string temp = input; string[] strs = temp.Split(':'); if (strs.Length > 8) { return false; } int count = input.GetStrCount("::"); if (count > 1) { return false; } else if (count == 0) { return Regex.IsMatch(input, @"^([da-f]{1,4}:){7}[da-f]{1,4}$"); } else { return Regex.IsMatch(input, @"^([da-f]{1,4}:){0,5}::([da-f]{1,4}:){0,5}[da-f]{1,4}$"); } }

        #endregion
    

        #region 网址系列验证
        /// <summary>
        /// 验证网址是否正确(http:或者https:)【后期添加 // 的情况】
        /// </summary>
        /// <param name="objStr">地址</param>
        /// <returns></returns>
        public static bool IsWebUrl(this string objStr)
        {
            try
            {
                return Regex.IsMatch(objStr, @"http://([w-] .) [w-] (/[w- ./?%&=]*)?|https://([w-] .) [w-] (/[w- ./?%&=]*)?");
            }
            catch
            {
                return false;
            }
        }
    


    ///

    /// 判断输入的字符串是否是一个超链接 /// /// /// public static bool IsURL(this string objStr) { string pattern = @"^[a-zA-Z] ://(w (-w ))(.(w (-w )))(?S)?$"; return Regex.IsMatch(objStr, pattern); }

        #endregion
    

        #region 邮政编码验证
        /// <summary>
        /// 验证邮政编码是否正确
        /// </summary>
        /// <param name="objStr">输入字符串</param>
        /// <returns></returns>
        public static bool IsZipCode(this string objStr)
        {
            try
            {
                return Regex.IsMatch(objStr, @"d{6}");
            }
            catch
            {
                return false;
            }
        }
        #endregion
    

        #region 电话 手机验证
        /// <summary>
        /// 验证手机号是否正确
        /// </summary>
        /// <param name="objStr">手机号</param>
        /// <returns></returns>
        public static bool IsMobile(this string objStr)
        {
            try
            {
                return Regex.IsMatch(objStr, @"^13[0-9]{9}|15[012356789][0-9]{8}|18[0123456789][0-9]{8}|147[0-9]{8}$");
            }
            catch
            {
                return false;
            }
        }
    


    ///

    /// 匹配3位或4位区号的电话号码,其中区号可以用小括号括起来,也可以不用,区号与本地号间可以用连字号或空格间隔,也可以没有间隔 /// /// /// public static bool IsPhone(this string objStr) { try { return Regex.IsMatch(objStr, "^(0d{2})[- ]?d{8}$|^0d{2}[- ]?d{8}$|^(0d{3})[- ]?d{7}$|^0d{3}[- ]?d{7}$"); } catch { return false; } }

        #endregion
    

        #region 字母或数字验证
        /// <summary>
        /// 是否只是字母或数字
        /// </summary>
        /// <param name="objStr"></param>
        /// <returns></returns>
        public static bool IsAbcOr123(this string objStr)
        {
            try
            {
                return Regex.IsMatch(objStr, @"^[0-9a-zA-Z$] $");
            }
            catch
            {
                return false;
            }
        }
        #endregion
    

        #endregion
    }
    

    View Code

    Python遍历相关

    #每一回也便是取三个元组,那能够用事先讲的例证来简化了:c,d=a #等价于:c=a[0] d=a[1]

    for k,v in infos_dict.items():

      print("Key:%s,Value:%s"%(k,v))

    图片 101 

    NetCore:方式和Python差不多

    foreach (KeyValuePair<string, object> kv in infos_dict)

    {

      Console.WriteLine($"Key:{ style="color: #ff6600;">kv.Key},Value:{ style="color: #ff6600;">kv.Value}");

    }

    图片 102 


    Python style="background-color: initial;">增加和删除改种类:

    增加、修改 style="color: #ff6600;">infos_dict["wechat"]="dotnetcrazy style="background-color: initial;"> style="color: #ff6600;">" #有就修改,没就加多

    删除种类

    # 删除

    del infos_dict["name"] #不设有就报错

    #清空字典内容

    infos_dict.clear()

    # 删除字典

    del infos_dict

    图片 103

    NetCore

    添加:infos_dict.Add("wechat", "lll");  infos_dict["wechat1"] = "lll";

    修改

    infos_dict["wechat"] = "dotnetcrazy";

     

    删除

    style="background-color: initial;">infos_dict.Remove("dog"); // style="color: #ff6600;">不设有不报错   style="background-color: initial;">infos_dict.Clear(); // style="color: #ff6600;">列表内容清空

    图片 104 


    Python查询体系 style="background-color: initial;">: style="background-color: #ffff00;">推荐 style="background-color: initial;">:infos_dict. style="color: #ff6600;">get("mmd")  style="background-color: initial;">#查不到不会这二个

    图片 105


      style="color: #339966;">NetCoreinfos_dict["name"] 可以通过  style="color: #ff6600;">ContainsKey(key) 幸免相当。看值就 ContainsValue(value)

    图片 106

    2.变量

      说那样多基本上大约完了,下一次列表 字典 元组就联手讲了呀~ 

    扩展:

     python定义变量比较牛逼,间接写变量名就能够,句子后边毫无加分号,eg: style="color: #ff6600;">name="小明"

    图片 107

    netcore,能够用var来张开项目推测,eg: style="color: #ff6600;">var name="小明";

    图片 108

    1.多维元组:

    some_tuples=[(2,"萌萌哒"),(4,3)]

    some_tuples[0]

    some_tuples[0][1]

    style="background-color: initial;">图片 109


    2.运算符扩大:( ,*,in,not in)

    # 运算符扩展:

    test_str="www.baidu.com"

    test_list=[1,"d",5]

    test_dict={"name":"dnt","wechat":"xxx"}

    test_list1=[2,4,"n","t",3]

    # 合并 (不扶助字典)

    print(test_str test_str)

    print(test_list test_list1)

    # * 复制 (不帮助字典)

    print(test_str*2)

    print(test_list*2)

    图片 110

    # in 是还是不是留存(字典是查key卡塔 尔(阿拉伯语:قطر‎

    print("d" in test_str) #True

    print("d" in test_list) #True

    print("d" in test_dict) #False

    print("name" in test_dict) #True

     

    # not in 是还是不是一纸空文(字典是查key卡塔尔国

    print("z" not in test_str) #True

    print("z" not in test_list) #True

    print("z" not in test_dict) #True

    print("name" not in test_dict) #False

    图片 111


    style="background-color: initial;">3.内置函数扩大:(len,max,min,del卡塔 尔(阿拉伯语:قطر‎

    len(),那个就不说了,用的太多了

    图片 112

    max(),求最大值,dict的最大值是比较的key

    图片 113

    以此注意生龙活虎种情景(当然了,你依据事先说的职业,list里面放同风姿浪漫连串型就不会出错了卡塔尔

    图片 114

    min(),这个和max一样用

    图片 115

    del() or del xxx 删完就木有了

    图片 116

     

    #可以先忽视cmp(item1, item2)   相比较八个值 # style="color: #ff6600;">是Python2里面有个别 cmp(1,2) ==> -1 #cmp在可比字典数据时,先比较键,再相比值

    3.输入输出:r''表示''里面的字符串暗中认可不转义

    知识扩大

    换行输出,不换行输出:( style="background-color: #ffff00;">n接受那一个就不说了,它们和C都以相仿的)

    python: style="color: #ff6600;">print("dnt.dkill.net/now",end='') style="color: #008000;">#默认end='n' (' 和 " 随意)

    图片 117

    netcore: Console. style="color: #ff6600;">Write Console. style="color: #ff6600;">WriteLine

    图片 118


    python输出多个双重字符,没有必要协和手打N个*只怕for循环输出八个再也字符,eg: style="color: #ff6600;">print("x"*10)

    图片 119

    style="color: #ff0000;">假如你不太鲜明相应用什么,%s千古起效果,它会把其余数据类型调换为字符串

    # %c    字符
    # %s    通过str() 字符串转换来格式化
    # %o    八进制整数
    # %x    十六进制整数(小写字母)
    # %X    十六进制整数(大写字母)
    # %e    指数(小写'e')
    # %E    指数(大写“E”)
    # %f    浮点实数
    # %g    %f和%e 的简写
    # %G    %f和%E的简写
    

    上边来个输入输出的简短的案例吧:打字与印刷一张片子,Name:毒逆天,Gender:男

    Python: style="color: #008000;">print("Name:%s,Gender:%s"%(name,gender))【注意引号前边未有,哦】

    图片 120

    NetCore: style="color: #008000;">Console.WriteLine($"Name:{name},Gender:{gender}");

    图片 121

      style="color: #ff0000;">可变的元组(元组在概念的时候就无法变了,可是能够通过相似这种艺术来改造卡塔 尔(英语:State of Qatar)

    图片 122

    List切片

    图片 123

    图片 124


    Set集结扩张:

    图片 125图片 126图片 127


    更新:(漏了八个去除的情势卡塔尔:

    图片 128

    概念再补偿下

    # dict内部存放的次第和key放入的次第是不曾涉及的
    # dict的key必需是不可变对象(dict根据key进行hash算法,来计量value的蕴藏地方
    # 纵然每一趟总计同后生可畏的key得出的结果不相同,这dict内部就全盘混乱了卡塔尔

    用一张图掌握一下:(测验结果: style="color: #ff6600;">元组是能够看作Key的 -_-!

    图片 129

    4.类型调换 算术运算符

    附录Code

    python:类型(值),eg: style="color: #ff6600;">int(),long(),float(), style="color: #ff0000;">str()...等等(Python没有double类型哦~)【:转换成16进制: style="color: #ff6600;">hex()、转换为8进制: style="color: #ff6600;">oct()

    图片 130

    netcore:该案例推荐应用 int.TryParse,作者那边就用常用的Convert数不胜数了【帮助项目很多】

    style="color: #ff6600;">Convert.ToInt64(),Convert.ToDouble(),Convert.ToString()

    图片 131

    算术运算符编制程序语言基本上差不离,Python多了个 style="color: #ff6600;">// 取商( style="color: #ff6600;">%是取余)和 幂 style="color: #ff6600;">**,来个案例:

    图片 132

    netcore(C#常用数学方法都在Match类中卡塔尔国

    图片 133

    = -= *= /= %= **= //= 那些就无须详说了啊?(比方: style="background-color: initial;">c = a 等效于 c = c a

    Python:

    Python List:

    图片 134图片 135

    # 定义一个列表,列表虽然可以存不同类型,一般我们把相同类型的值存列表里面,不同类型存字典里(key,value)
    infos_list=["C#","JavaScript"]#[]
    

    # ###########################################################
    # # 遍历 for while
    # for item in infos_list:
    #     print(item)
    

    # i=0
    # while i<len(infos_list):
    #     print(infos_list[i])
    #     i =1
    # ###########################################################
    # # 增加
    # # 末尾追加
    # infos_list.append("Java")
    # print(infos_list)
    

    # # 指定位置插入
    # infos_list.insert(0,"Python")
    # print(infos_list)
    

    # temp_list=["test1","test2"]
    # infos_list.insert(0,temp_list)
    # print(infos_list)
    

    # # 添加一个列表
    # infos_list2=["张三",21]#python里面的列表类似于List<object>
    # infos_list.extend(infos_list2)
    # print(infos_list)
    

    # # help(infos_list.extend)#可以查看etend方法描述
    # ###########################################################
    # # 删除
    # # pop()删除最后一个元素,返回删掉的元素
    # # pop(index) 删除指定下标元素
    # print(infos_list.pop())
    # print(infos_list)
    # print(infos_list.pop(0))
    # # print(infos_list.pop(10)) #不存在就报错
    # print(infos_list)
    

    # # remove("")删除指定元素
    # infos_list.remove("张三")
    # # infos_list.remove("dnt") #不存在就报错
    # print(infos_list)
    

    # # del xxx[index] 删除指定下标元素
    # del infos_list[1]
    # print(infos_list)
    # # del infos_list[10] #不存在就报错
    

    # # del infos_list #删除集合(集合再访问就不存在了)
    # ###########################################################
    # # 修改 xxx[index]=xx
    # # 注意:一般不推荐在for循环里面修改
    # print(infos_list2)
    # infos_list2[1]="PHP" #只有下标修改一种方式
    # # infos_list2[3]="GO" #不存在则异常
    # print(infos_list2)
    

    # # 想按值修改需要先查下标再修改
    # infos_list2.index("张三")
    # infos_list2[0]="GO"
    # print(infos_list2)
    # # infos_list2.index("dnt")#不存在则异常
    

    # # 知识面拓展: https://www.zhihu.com/question/49098374
    # # 为什么python中不建议在for循环中修改列表?
    # # 由于在遍历的过程中,删除了其中一个元素,导致后面的元素整体前移,导致有个元素成了漏网之鱼。
    # # 同样的,在遍历过程中,使用插入操作,也会导致类似的错误。这也就是问题里说的无法“跟踪”元素。
    # # 如果使用while,则可以在面对这样情况的时候灵活应对。
    

    ###########################################################
    # # 查询 in, not in, index, count
    # # # for扩展:https://www.cnblogs.com/dotnetcrazy/p/9102030.html#forelse
    

    # names_list=["张三","李四","王二麻子"]
    

    # # #张三在列表中执行操作
    # if "张三" in names_list:
    #     names_list.remove("张三")
    # print(names_list)
    

    # # #查看"大舅子"不在列表中执行操作
    # if "大舅子" not in names_list:
    #     names_list.append("大舅子")
    # print(names_list)
    

    # # #查询王二麻子的索引
    # print(names_list.index("王二麻子"))
    

    # print(names_list.count("大舅子")) 
    # print(names_list.count("逆天")) 
    ###########################################################
    # # 排序(sort, reverse 逆置)
    # num_list=[1,3,5,88,7]
    

    # #倒序
    # num_list.reverse()
    # print(num_list)
    

    # # 从小到大排序
    # num_list.sort()
    # print(num_list)
    

    # # 从大到小
    # num_list.sort(reverse=True)
    # print(num_list)
    # # ###########################################################
    

    # # #列表嵌套(列表也是可以嵌套的)
    # num_list2=[33,44,22]
    # num_list.append(num_list2)
    # print(num_list)
    # # for item in num_list:
    # #     print(item,end="")
    

    # print(num_list[5])
    # print(num_list[5][1])
    # # ###########################################################
    

    # # # 引入Null==>None
    # # a=[1,2,3,4]
    # # b=[5,6]
    # # a=a.append(b)#a.append(b)没有返回值
    # # print(a)#None
    

    View Code

    Python Tuple:

    图片 136图片 137

    # 只能查询,其他操作和列表差不多(不可变)
    test_tuple=("萌萌哒",1,3,5,"加息","加息")
    

    # count index
    print(test_tuple.count("加息"))
    print(test_tuple.index("萌萌哒"))#没有find方法
    # 注意是左闭右开区间==>[1,4)
    # print(test_tuple.index("加息", 1, 4))#查不到报错:ValueError: tuple.index(x): x not in tuple
    

    #下标取
    print(test_tuple[0])
    

    # 遍历
    for item in test_tuple:
        print(item)
    


    i=0 while i

    # 扩展:
    test_tuple1=(1,) #(1)就不是元祖了
    test_tuple2=(2)
    print(type(test_tuple1))
    print(type(test_tuple2))
    

    # # ==============================================
    # 扩展:(后面讲字典遍历的时候会再提一下的)
    a=(1,2)
    b=a#把a的引用给b
    #a里面两个值,直接给左边两个变量赋值了(有点像拆包了)
    c,d=a #不是把a分别赋值给c和d,等价于:c=a[0] d=a[1]
    


    print(a) print(b) print(c) print(d)

    View Code

    Python Dict:

    图片 138图片 139

    infos_dict={"name":"dnt","web":"dkill.net"}
    

    # # 遍历
    # for item in infos_dict.keys():
    #     print(item)
    

    # #注意,如果你直接对infos遍历,其实只是遍历keys
    # for item in infos_dict:
    #     print(item)
    

    # for item in infos_dict.values():
    #     print(item)
    

    # for item in infos_dict.items():
    #     print("Key:%s,Value:%s"%(item[0],item[1]))
    # #每一次相当于取一个元组,那可以用之前讲的例子来简化了:c,d=a #等价于:c=a[0] d=a[1]
    # for k,v in infos_dict.items():
    #     print("Key:%s,Value:%s"%(k,v))
    

    # # 增加 修改 (有就修改,没就添加)
    # # 添加
    # infos_dict["wechat"]="lll"
    # print(infos_dict)
    

    # # 修改
    # infos_dict["wechat"]="dotnetcrazy"
    # print(infos_dict)
    

    # # 删除
    # del infos_dict["name"]
    # del infos_dict["dog"] #不存在就报错
    # print(infos_dict)
    

    # #清空字典内容
    # infos_dict.clear()
    # print(infos_dict)
    

    # # 删除字典
    # del infos_dict
    

    # 查询
    infos_dict["name"]
    # infos_dict["mmd"] #查不到就异常
    



    infos_dict.get("name") infos_dict.get("mmd")#查不到不会格外

    # 查看帮助
    # help(infos_dict)
    len(infos_dict) #有几对key,value 
    # infos_dict.has_key("name") #这个是python2里面的
    

    View Code


    NetCore:

    NetCore List:

    图片 140图片 141

    // using System;
    // using System.Collections.Generic;
    // using System.Linq;
    


    // namespace aibaseConsole // { // public static class Program // { // private static void Main() // { // #region List // //# 定义一个列表 // // # infos_list=["C#","JavaScript"]#[] // var infos_list = new List() { "C#", "JavaScript" }; // // var infos_list2 = new List() { "张三", 21 }; // // // # ########################################################### // // // # # 遍历 for while // // // # for item in infos_list: // // // # print(item) // // foreach (var item in infos_list) // // { // // System.Console.WriteLine(item); // // } // // for (int i = 0; i < infos_list.Count; i ) // // { // // System.Console.WriteLine(infos_list[i]); // // } // // // # i=0 // // // # while i // // infos_list.Add("Java"); // // DivPrintList(infos_list); // // // # # 钦赐地方插入 // // // # infos_list.insert(0,"Python") // // // # print(infos_list) // // infos_list.Insert(0,"Python"); // // DivPrintList(infos_list); // // // # # 增添多少个列表 // // // # infos_list2=["张三",21]#python里面包车型客车列表相像于List
    // // // # infos_list.extend(infos_list2) // // // # print(infos_list) // // infos_list.AddRange(infos_list2); // // DivPrintList(infos_list); // // /C#有insertRange方法 / // // DivPrintList(infos_list2,"List2原来的列表:"); // // infos_list2.InsertRange(0,infos_list); // // DivPrintList(infos_list2,"List2变化后列表:"); // // // # # help(infos_list.extend)#能够查看etend方法描述 // // // # ########################################################### // // // # # 删除 // // // # # pop()删除最终三个成分,再次回到删掉的元素 // // // # # pop(index) 删除内定下标成分 // // // # print(infos_list.pop()) // // // # print(infos_list) // // // # print(infos_list.pop(1)) // // // # # print(infos_list.pop(10)) #不设有就报错 // // // # print(infos_list)
    // // // # # remove("")删除钦赐成分 // // // # infos_list.remove("张三") // // // # # infos_list.remove("dnt") #空头支票就报错 // // // # print(infos_list)
    // // // # # del xxx[index] 删除内定下标元素 // // // # del infos_list[1] // // // # print(infos_list) // // // # # del infos_list[10] #空中楼阁就报错
    // // // # del infos_list #删除会集(集结再拜谒就一纸空文了卡塔尔
    // // DivPrintList(infos_list); // // infos_list.RemoveAt(1); // // // infos_list.RemoveAt(10);//不设有则报错 // // // infos_list.RemoveRange(0,1); //能够移除多个 // // DivPrintList(infos_list); // // infos_list.Remove("作者家在西南吗?"); //移除内定item,荒诞不经不会报错 // // DivPrintList(infos_list,"清空前:"); // // infos_list.Clear();//清空驶列车表 // // DivPrintList(infos_list,"清空后:");
    // // // # ########################################################### // // // # # 修改 xxx[index]=xx // // // # # 注意:经常不引入在for循环里边纠正 // // // # print(infos_list2) // // // # infos_list2[1]="PHP" #只有下标修正黄金年代种艺术 // // // # # infos_list2[3]="GO" #官样文章则不行 // // // # print(infos_list2) // // DivPrintList(infos_list2); // // infos_list2[1] = "PHP"; // // // infos_list2[3]="GO"; //不设有则特别 // // DivPrintList(infos_list2); // // // # # 想按值改进须求先查下标再改进 // // // # infos_list2.index("张三") // // // # infos_list2[0]="GO" // // // # print(infos_list2) // // // # # infos_list2.index("dnt")#海市蜃楼则非常 // // int index = infos_list2.IndexOf("张三"); // // infos_list2[index] = "GO"; // // DivPrintList(infos_list2); // // infos_list2.IndexOf("dnt");//荒诞不经再次来到-1
    // // // ########################################################### // // // # 查询 in, not in, index, count // // // # # for扩展: // // // # names_list=["张三","李四","王二麻子"] // // var names_list=new List(){"张三","李四","王二麻子"}; // // // Console.WriteLine(names_list.Find(i=>i=="张三")); // // // Console.WriteLine(names_list.FirstOrDefault(i=>i=="张三")); // // Console.WriteLine(names_list.Exists(i=>i=="张三")); // // System.Console.WriteLine(names_list.Contains("张三")); // // // # #张三在列表中实施操作 // // // # if "张三" in names_list: // // // # names_list.remove("张三") // // // # else: // // // # print(names_list)
    // // // # #查看"大舅子"不在列表中试行操作 // // // # if "大舅子" not in names_list: // // // # names_list.append("大舅子") // // // # else: // // // # print(names_list)
    // // // # #查询王二麻子的索引 // // // # print(names_list.index("王二麻子")) // // // names_list.IndexOf("王二麻子");
    // // // # print(names_list.count("大舅子")) // // // # print(names_list.count("逆天")) // // // Console.WriteLine(names_list.Count);
    // // // ########################################################### // // // # # 排序(sort, reverse 逆置) // // // # num_list=[1,3,5,88,7] // // var num_list = new List() { 1, 3, 5, 88, 7 };
    // // // # #倒序 // // // # num_list.reverse() // // // # print(num_list) // // num_list.Reverse(); // // DivPrintList(num_list); // // // # # 从小到大排序 // // // # num_list.sort() // // // # print(num_list) // // num_list.Sort(); // // DivPrintList(num_list);
    // // // # # 从大到小 // // // # num_list.sort(reverse=True) // // // # print(num_list) // // num_list.Sort(); // // num_list.Reverse(); // // DivPrintList(num_list);
    // // // # ###########################################################
    // // // # #列表嵌套(列表也是足以嵌套的) // // // # num_list2=[33,44,22] // // // # num_list.append(num_list2) // // // # print(num_list) // // var num_list2 = new List() { 33, 44, 22,new List(){11,55,77} }; // // DivPrintList(num_list2);//能够定义多维数组来支撑 num_list2[i][j] // // // # for item in num_list: // // // # print(item) // // // # ###########################################################
    // // // # # 引入Null==>None // // // # a=[1,2,3,4] // // // # b=[5,6] // // // # a=a.append(b)#a.append(b)未有重返值 // // // # print(a)#None // #endregion
    // // Console.Read(); // }
    // private static void DivPrintList(List list, string say = "") // { // Console.WriteLine($"n{say}"); // foreach (var item in list) // { // System.Console.Write($"{item} "); // } // } // } // }

    View Code

    NetCore Tuple:

    图片 142图片 143

    // using System;
    


    // namespace aibaseConsole // { // public static class Program // { // private static void Main() // { // #region Tuple // // C#中元组首假如利于程序猿,不用自然能够. // // 元祖系: // // 值元组: // // 比方:当您回到多个值是或不是还用ref out 恐怕重临贰个list之类的? // // 那么些都急需先定义,比较麻烦.元祖在后生可畏都部队分气象用的可比多 eg:

    // // 初始化 // // var test_tuple = ("萌萌哒", 1, 3, 5, "加息", "加息"); //这种方式正是valueTuple了
    // // test_tuple.Item1 = "ddd";//能够改正值
    // // test_tuple.GetType(); // // test_tuple.itemxxx //获取值只好通过itemxxx
    // var result = GetCityAndTel(); //支持async/await模式 // var city = result.city; // var tel = result.tel; // // 拆包格局: // var (city1, tel1) = GetCityAndTel();
    // #endregion // // Console.Read(); // } // // public static (string city, string tel) GetCityAndTel() // // { // // return ("东方之珠", "110"); // // } // // 简化写法 // public static (string city, string tel) GetCityAndTel() => ("法国首都", "110"); // } // }

    View Code

    NetCore Dict:

    图片 144图片 145

    using System;
    using System.Collections.Generic;
    


    namespace aibaseConsole { public static class Program { private static void Main() {

                #region Dict
                // infos_dict={"name":"dnt","web":"dkill.net"}
                // # # 遍历
                // # for item in infos_dict.keys():
                // #     print(item)
                // # for item in infos_dict.values():
                // #     print(item)
                // # for item in infos_dict.items():
                // #     print("Key:%s,Value:%s"%(item[0],item[1]))
                // # #每一次相当于取一个元组,那可以用之前讲的例子来简化了:c,d=a #等价于:c=a[0] d=a[1]
                // # for k,v in infos_dict.items():
                // #     print("Key:%s,Value:%s"%(k,v))
                var infos_dict = new Dictionary<string, object>{
                    {"name","dnt"},
                    {"web","dkill.net"}
                };
                // foreach (var item in infos_dict.Keys)
                // {
                //     System.Console.WriteLine(item);
                // }
                // foreach (var item in infos_dict.Values)
                // {
                //     System.Console.WriteLine(item);
                // }
                // foreach (KeyValuePair<string, object> kv in infos_dict)
                // {
                //     //    System.Console.WriteLine("Key:%s,Value:%s",(kv.Key,kv.Value));
                //     System.Console.WriteLine($"Key:{kv.Key},Value:{kv.Value}");
                // }
    


    // // # # 扩张 改正 (有就改正,没就增加) // // # # 添加 // // # infos_dict["wechat"]="lll" // // # print(infos_dict) // infos_dict.Add("wechat", "lll"); // infos_dict["wechat1"] = "lll"; // // # # 修改 // // # infos_dict["wechat"]="dotnetcrazy" // // # print(infos_dict) // infos_dict["wechat"] = "dotnetcrazy";
    // // # # 删除 // // # del infos_dict["name"] // // # del infos_dict["dog"] #不设有就报错 // // # print(infos_dict) // infos_dict.Remove("name"); // infos_dict.Remove("dog"); // // # #清空驶列车表内容 // // # infos_dict.clear() // // # print(infos_dict) // infos_dict.Clear(); // // # # 删除列表 // // # del infos_dict
    // # 查询 // infos_dict["name"] // infos_dict["mmd"] #查不到就可怜

    // infos_dict.get("name") // infos_dict.get("mmd")#查不到不会那二个 Console.WriteLine(infos_dict["name"]); // Console.WriteLine(infos_dict["mmd"]); //#查不到就那贰个 // 先看看有未有 ContainsKey(key),看值就 ContainsValue(value) if (infos_dict.ContainsKey("mmd")) Console.WriteLine(infos_dict["mmd"]);
    // # 查看帮忙 // help(infos_dict) // len(infos_dict) #有几对key,value Console.WriteLine(infos_dict.Count);

                #endregion
    


    // Console.Read(); } } }

    View Code

    5.if else

     说Python像国外版的易语言,那边就能够看出来一点了,先说说Python的逻辑运算符==》与 style="color: #ff6600;">and 或 style="color: #ff6600;">or 非 style="color: #ff6600;">not,那些倒是跟C、C#、Java等大大分裂,假设再结合Python命名准绳就感到在阅读小说相像

     关系运算符和此外语言基本上大约( style="color: #ff6600;">== != <> > < style="color: #ff6600;">>= <=卡塔 尔(英语:State of Qatar),就一些不等同:也足以用<>

    来个if else底子语法:括号可加可不加,可是记得加:。不用大括号,然则if里面包车型地铁代码注意缩进

    图片 146

    netcore:if恐怕else下边是单行代码能够绝不写括号

    图片 147

    再来个嵌套的:注意哦~else if 在python里面简写成了: style="color: #ff0000;">elif

    图片 148

    netcore:单行代码能够毫不写括号

    图片 149

    6.while

     直接来个案例:

    python里面未有 和 --,那一点的确用的有一点小不便利,扩超过57%有连锁表达

    图片 150

    netcore

    图片 151

     

    7.for

     python的for循环,类似于js里面的for in 以及C#里面的foreach

    图片 152

    netcore: foreach (var i in name)

    图片 153


    常规,来个扩展:switch(这一个近日毫无掌握,看看就好,前边会继续查究的卡塔 尔(英语:State of Qatar)

    Python没有 /--  参照随笔(点小编卡塔 尔(阿拉伯语:قطر‎

    python 中,变量是以内容为条件并非像 c 中以变量名称叫原则,所以如果您的数字内容是5,不管你起什么名字,这几个变量的 ID 是均等的,同有时间也就证实了 python 中贰个变量能够以多个称呼访谈

    图片 154

    如上例,a 和 b 都以 5,当您 改动了 a 时,b 也会随之变,那本来不是大家期望的。so,正确的自增操作应该  a = 1,通过 id() 观望可以知道,id 值变化了,即 a 已是新值的名称


     for的扩展(平时不太用卡塔尔官方参谋:

    图片 155

    图表出处:


    Python 未有 switch / case 语句。为了兑现它,大家能够行使字典映射:

    # style="color: #008000;">官方的演说讲,“用if... elif... elif... else系列超级轻巧来落到实处 switch / case 语句”。并且可以选择函数字典映射和类的调节方式。

    def numbers_to_strings(argument):
        switcher = {
            0: "zero",
            1: "one",
            2: "two",
        }
        return switcher.get(argument, "nothing")
    

    这段代码相通于:

    function(argument){
        switch(argument) {
            case 0:
                return "zero";
            case 1:
                return "one";
            case 2:
                return "two";
            default:
                return "nothing";
        };
    };
    

    在 Python 中字典映射也能够包含函数恐怕 lambda 说明式

    def zero():
        return "zero"
     
    def one():
        return "one"
     
    def numbers_to_functions_to_strings(argument):
        switcher = {
            0: zero,
            1: one,
            2: lambda: "two",
        }
        func = switcher.get(argument, lambda: "nothing")
        return func()
    

    类的调节措施:

    style="background-color: initial;">假如在三个类中,不分明要动用哪一种方法,能够用二个调治格局在运作的时候来明显。

        class Switcher(object):
        def numbers_to_methods_to_strings(self, argument):
            method_name = 'number_'   str(argument)
            method = getattr(self, method_name, lambda: "nothing")
            return method()
     
        def number_0(self):
            return "zero"
     
        def number_1(self):
            return "one"
     
        def number_2(self):
            return "two"
    

     Python设计算利唇齿相依的为何,可以参见官方文书档案:

    附录2:C#底工(逆天上学那会做的笔记卡塔 尔(阿拉伯语:قطر‎

    易忘知识点(点卡塔尔

    C#底蕴汇总(点卡塔 尔(阿拉伯语:قطر‎

    特别概况系(点卡塔尔国

    CodeBase ~ POP

    CodeBase ~ OOP

    本文由新葡亰496net发布于电脑系统,转载请注明出处:基础语法对比

    关键词: