您的位置:新葡亰496net > 电脑系统 > 新葡亰496net:幼功语法相比,Shell分别支付二个

新葡亰496net:幼功语法相比,Shell分别支付二个

发布时间:2019-11-16 11:30编辑:电脑系统浏览(123)

    汇总系列:

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

    汇总系列:

    Jupyter最新排版:

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

    Python3 与 C# 基础语法对比:

    汇总系列:

    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现在也有这个预览版的插件了)

    在线演示: 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部分说)然后就说说面向对象吧。

    先吐槽一下:Python面向对象真心需要规范,不然太容易走火入魔了 -_-!!! 汗,下次再说。。。

    对比写作真的比单写累很多,希望大家多捧捧场 ^_^

    *新葡亰496net:幼功语法相比,Shell分别支付二个Ubuntu版的准期提示。*新增直接运行py文件的补充:请在py前面加上:** style="color: #ff0000;">#!/usr/bin/env python3 然后再执行 sudo chmod x ./task.py 下次运行直接 ./task.py


    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

    平时经常用定时提醒来提高工作效率,到了Linux。。。。蒙圈了,以前C#写的不能跨平台啊,于是就有了这篇文章~(有些人喜欢用番茄工作法,这个算是个福利了)

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

    事先声明一下,避免让新手进入误区:不是说Python比NetCore要好,而Python设计的目的就是==》让程序员解放出来,不要过于关注代码本身,那么性能、规范等等各方面隐患就存在了,后面编写一个稍微大点的项目就看出来了。而且不要太受语言约束,之前我也说过,用各自语言的优势来为项目服务~ 这才是开发王道。比如Python用来数据分析,Go用来并发处理等等,不多说了,记住一句话即可: style="color: #ff6600;">“Net是性价比最高的”

    style="color: #ff6600;">新葡亰496net 1

    先从函数定义说起吧:

    步入正题:

    跳转到Python:

    欢迎提出更简单的语法~(文章中案例有两个福利哦,一个是养生,一个是人工智能[ 密码:fqif])

    步入正题:欢迎提出更简单或者效率更高的方法

    # style="color: #ff6600;">定义一个空函数:(不写pass就报错了)

    新葡亰496net 2


    #  style="color: #ff6600;">定义一个无参函数注意缩进

    新葡亰496net 3


    定义一个含参函数

    新葡亰496net 4

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

    新葡亰496net 5


    #  style="color: #ff6600;">定义一个含默认参数(缺省参数)的函数

    新葡亰496net 6

    # 定义有返回值的函数

    新葡亰496net 7


    # style="color: #ff6600;">定义含有多个返回值的函数(利用了元组)

    新葡亰496net 8

    来个案例解释一下:(多返回值只是一种假象,Python函数返回的仍然是单一值~元组)

    新葡亰496net 9


    style="color: #ff00ff;">传多个参数系列:(上面那个多返回参数也可以返回一个list来实现类似效果)

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

    新葡亰496net 10


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

    新葡亰496net 11

    如果你需要传一个元组或者列表进去的话,可以参数前面加 style="color: #ff6600;">*

    新葡亰496net 12

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

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

    新葡亰496net 13

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

    新葡亰496net 14

    需要注意py里面的书写格式==》 style="color: #ff6600;">先定义再调用(Code参考)

    新葡亰496net 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
    


    // # 定义含有多个返回值的函数(利用了元组) 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
        }
    }
    

    先NetCore吧:(old code:me)

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

    基础系列:(这边重点说说Python,上次讲过的东西我就一笔带过了)

    函数相关扩展

     1.列表相关:

    核心代码:Process.Start("notify-send", "友情提醒 10分钟过去了");

    原理说明:调用了ubuntu的notify-send的弹窗提醒,自己控制循环和定时

    补充知识: style="color: #008000;">RuntimeInformation.IsOSPlatform(OSPlatform.xxx) 这个来判断是什么系统,OSPlatform是一个结构体

    定时提醒:Thread.Sleep(new TimeSpan(0, 10, 0));

    代码比较简单就不详说了,主要讲讲环境部署 发布

    using System;
    using System.Threading;
    using System.Diagnostics;
    using System.Runtime.InteropServices;
    


    //Old: namespace netcore { class Program { static void Main(string[] args) { while (true) { try { Console.WriteLine(DateTime.Now.ToString()); Thread.Sleep(new TimeSpan(0, 10, 0)); MyBeep(); } catch { //异常还不结束? break; } } } private static void MyBeep() { if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Console.WriteLine("当前系统为Linux"); Process.Start("notify-send", "友情提醒 10分钟过去了"); //用shell启动指定程序 命令 //Process.Start(new ProcessStartInfo("notify-send", "友情提醒 10分钟过去了") { RedirectStandardOutput = true }); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { Console.WriteLine("当前系统为Windows"); // frequency:提示音的频率,介于 37 到 32767 赫兹之间。// duration:提示音的持续时间,以毫秒为单位。 Console.Beep(500, 1500); } else { Console.WriteLine("精力有限,暂不支持"); } } } }

    来走一个流程:(基本上跟官网走一遍,我贴几个链接和图)

    我以前写的文章:

    官方文档(多看看官方文档):

    新葡亰496net 16

    2.创建一个netcore的console应用:dotnet new console

    新葡亰496net 17

    3.安装VSCode(直接下载安装deb包即可):

    4.安装VSCode的C#扩展

    新葡亰496net 18

    5.打开刚才那个文件夹,F5试运行一下,新版的貌似不用自己配置运行路径什么的了

    新葡亰496net 19

    6.刚才代码贴了,coding一下。调试运行什么的和win下没什么大区别

    新葡亰496net 20

    style="color: #ff6600;">7.1发布吧,讲一下官方推荐的发布方式(适合开发人员),到项目目录下,Ctrl ALT T调出终端==》  style="color: #ff6600;">dotnet publish –c release

    参考:

    这种轻量级方式发布,把这两个文件弄出去就ok了

    新葡亰496net 21

    运行效果:dotnet xxx.dll,如果你改了程序名字,对应配置名字也记得改哦~

    新葡亰496net 22

    7.2发布第二种方式【 style="color: #ff6600;">很多人不是开发人员也不想装runtime】(指定应用程序运行时(自宿主应用),这种方式将会把指定平台的Core CLR打包进去):

    发布前先做一件事情,添加你需要支持的哪些系统,我这边win10和Ubuntu18就好了(别忘了)

    style="background-color: #ffff00;">在<PropertyGroup>标签里面添加 style="color: #ff6600;"><RuntimeIdentifiers>win10-x64;ubuntu.18.04-x64; style="color: #ff6600;"></RuntimeIdentifiers>

    新葡亰496net 23*

    style="background-color: initial;">系统命名以及系统支持参考:(貌似Android也是支持的)


    新葡亰496net 24

    修复依赖 发布指定系统的runtime: style="color: #ff6600;">dotnet publish -c Release -r ubuntu.18.04-x64

    新葡亰496net 25

    其实netcore2.x系列不用再输入restore了,它会自动执行restore

    新葡亰496net 26

    自托管的包挺大的

    新葡亰496net 27*

    发现自动生成了个netcore无后缀文件,而且是可执行文件【为基础薄弱的同志普及下:1.看颜色 2.ll 查看有没有执行权限】,直接运行就OK了

    新葡亰496net 28

    来试着发布一个win10的:dotnet publish -c Release -r win10-x64

    新葡亰496net 29

    拖到win10来测试~ok,可以跨平台(其他平台一样,发布的时候换下操作系统即可)

    新葡亰496net 30

    先说下感觉,python的编程有点JavaScript的感觉(比如:'和“有时候不区别),又感觉像外国版的易语言,整个过程像读书一样,比如一个元素不在列表之中==> for item not in lists。使用它做个大点的项目一定要先规定好编程风格,不然能让人崩溃的。先不深究,后面会继续深究。。。(Python2我就不讲了,官方推荐使用Python3

    1.输出 类型转换

    Python写法:

    新葡亰496net 31

    NetCore:

    新葡亰496net 32

    2.字符串拼接 style="background-color: initial;">拼接输出方式

    python:

    新葡亰496net 33

    NetCore

    新葡亰496net 34

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

    重点说下python的 style="color: #ff0000;">下标,有点意思,最后一个元素,我们一般都是len(str)-1,他可以直接用-1,倒2自然就是新葡亰496net:幼功语法相比,Shell分别支付二个Ubuntu版的准期提示。-2

    #最后一个元素:user_str[-1]

    user_str[-1]

    user_str[len(user_str)-1] #其他编程语言写法

    #倒数第二个元素: style="color: #ff0000;">user_str[-2]

    新葡亰496net 35

    这次为了更加形象对比,一句一句翻译成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在这方面简化了

    新葡亰496net 36

    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的

    新葡亰496net 37

    NetCore,其实你用Python跟其他语言对比反差更大,net真的很强大了。补充(对比看就清楚Python的step为什么是2了,i =2==》2)

     新葡亰496net 38

    style="color: #ff0000;">1.递归函数:函数递归调用其实就是自己调用自己,关键点只要考虑什么时候跳出即可(没有跳出就是死循环)

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

    新葡亰496net 39

    来个案例(实际工作中并不会自己定义,用系统自带 style="color: #ff6600;">strip方法即可)

    新葡亰496net 40

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

    新葡亰496net 41


    2.匿名函数系列: style="color: #008000;">lambda 参数: 表达式

    新葡亰496net 42

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

    新葡亰496net 43

    还有一个比较常用的地方:(当参数传递

    新葡亰496net 44

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


    3.全局变量和局部变量 

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

    新葡亰496net 45

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

    新葡亰496net 46

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

    新葡亰496net 47

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

    新葡亰496net 48

    总结:

    # 在函数中不使用 style="color: #ff0000;">global声明全局变量不能修改全局变量==>本质是不能修改全局变量的指向,即不能将全局变量指向新的数据

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

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


    style="color: #008000;">下面就进入验证扩展系列,看看一些概念

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

    新葡亰496net 49


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

    # 感到疑惑可以看之前的运算符扩展()

    新葡亰496net 50

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


    # 函数名能不能重复的问题(能不能 style="color: #008000;">重载:具有不同的参数的类型或参数的个数【跟返回值没关系】

    新葡亰496net 51

    结论:函数名不能重名


    来两个有趣的扩展

    style="color: #ff6600;">1.交换两个数熟悉吧,编程第一课,除了用第三变量 或者 两数相加减 实现外,Python还有一种新方式 style="color: #ff0000;">a,b=b,a

    新葡亰496net 52

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

    新葡亰496net 53


     2. style="color: #ff6600;">eval(和js里面的eval差不多): style="color: #008000;">不太建议使用

     新葡亰496net 54

    style="color: #ff6600;">Python定义一个列表(列表虽然可以存不同类型,一般我们把相同类型的值存列表里面,不同类型存字典里(key,value))

    info_list=[] #空列表

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

    遍历和之前一样,for 或者 while 都可以(for扩展:)

    新葡亰496net 55

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

    遍历可以用foreach,for,while

    新葡亰496net 56


    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]

    新葡亰496net 57

    style="color: #ff6600;">Python在指定位置插入列表是真的插入一个列表进去,C#是把里面的元素挨个插入进去

    新葡亰496net 58

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

    新葡亰496net 59


    Python列表删除系列

    infos_list.pop() #删除最后一个

    infos_list.pop(0) #删除指定索引,不存在就报错

    infos_list. style="color: #ff6600;">remove("张三")  style="background-color: initial;"># remove("")删除指定元素 style="background-color: initial;">,不存在就报错

    新葡亰496net 60

    style="color: #ff6600;">del infos_list[1] #删除指定下标元素,不存在就报错

    del infos_list #删除集合(集合再访问就不存在了)不同于C#给集合赋null

    新葡亰496net 61

    再过一遍新葡亰496net 62

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

    新葡亰496net 63


    style="color: #ff6600;">Python修改:(只能通过索引修改)

    infos_list2[1]="PHP" #只有下标修改一种方式, style="background-color: initial;">不存在则异常

    # 想按值修改需要先查下标再修改 eg:

    infos_list2.index("张三")

    infos_list2[0]="GO"

    # infos_list2.index("dnt")#不存在则异常

    style="color: #000000;">新葡亰496net 64

    # 知识面拓展:

    # 为什么python中不建议在for循环中修改列表?

    # 由于在遍历的过程中,删除了其中一个元素,导致后面的元素整体前移,导致有个元素成了漏网之鱼。

    # 同样的,在遍历过程中,使用插入操作,也会导致类似的错误。这也就是问题里说的无法“跟踪”元素。

    # 如果使用while,则可以在面对这样情况的时候灵活应对。

    NetCore:基本上和Python一样

    新葡亰496net 65


    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;">新葡亰496net 66

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

    新葡亰496net 67

    查找用 style="color: #008000;">Contains,其他的先看看,后面会讲

    新葡亰496net 68


    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;"># 从大到小

    新葡亰496net 69

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

    新葡亰496net 70

    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)

    新葡亰496net 71

     

    0.命名规则

    方法系列:

     

    2.Tuple 元组

    这次轮到Python了

    Python官方是推荐使用_来间隔单词,但一般开发人员都是以各自主语言的命名来定义的,这个就各人爱好了,不过团队一定要统一。

    style="color: #ff6600;">标示符字母、下划线和数字组成,且数字不能开头(这个基本上都一样) style="color: #ff0000;">注意: style="background-color: #ffff00; color: #000000;">标识符是区分大小写的

    新葡亰496net 72新葡亰496net 73

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

     扩充:Python的 style="color: #ff6600;">关键词可以自己打印一下:

    新葡亰496net 74

    ['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

    新葡亰496net 75

    netcore:index0f就相当于python里面的find

    新葡亰496net 76


    # 计数:count

    python:str.count()

    新葡亰496net 77

    netcore:这个真用基础来解决的话,两种方法:

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

    新葡亰496net 78

     

    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)

    新葡亰496net 79

    index查找不到会有异常

    新葡亰496net 80


    # 替换:replace

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

    新葡亰496net 81

    replace可以指定替换几次

    新葡亰496net 82

    NetCore:替换指定次数的功能有点业余,就不说了,你可以自行思考哦~

    新葡亰496net 83


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

    style="color: #ff6600;">新葡亰496net 84

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

    新葡亰496net 85 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)) #在第三个空格处切片,后面的不切了

    新葡亰496net 86

    新葡亰496net 87

    继续说说 style="color: #ff6600;">splitlines(按行分割),和split("n")的区别我图中给了案例

    扩展: style="background-color: initial; color: #ff6600;">split(),默认按空字符切割(空格、t、n等等,不用担心返回'')

    新葡亰496net 88

    最后说一下 style="color: #ff6600;">partition style="background-color: initial;">和 style="color: #ff6600;">r style="background-color: initial;"> style="color: #ff6600;">partition 返回是元祖类型(后面会说的),方式和find一样,找到第一个匹配的就罢工了【注意一下没找到的情况】

    新葡亰496net 89

     

    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的命名空间哦】

    新葡亰496net 90


    # 头尾判断:startswith(以。。。开头),endswith(以。。。结尾)

    新葡亰496net 91

    netcore:

    新葡亰496net 92


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

    新葡亰496net 93

    netcore:

    新葡亰496net 94


    # 格式系列: 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;">新葡亰496net 95 style="background-color: initial;"> 

    新葡亰496net 96

     

    netcore:Tirm很强大,除了去空格还可以去除你想去除的任意字符

    新葡亰496net 97

    ljust,rjust,center这些就不说了,python经常在linux终端中输出,所以这几个用的比较多。net里面string.Format各种格式化输出,可以参考

     


    # 验证系列: style="color: #ff6600;">isalpha(是否是纯字母), 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

    新葡亰496net 98

     

    netcore: style="background-color: initial;">string.IsNullOrEmpty 和 string.IsNullOrWhiteSpace 是系统自带的,其他的你需要自己封装一个扩展类(eg:简单封装)【附录有】

    新葡亰496net 99

    先到这吧,有什么扩充的下面再贴吧~

    这次先说 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监视信息)

    新葡亰496net 100

    需要说下的是,取值只能通过itemxxx来取了,然后就是 style="color: #ff6600;">valueTuple的值是可以修改的

    新葡亰496net 101

    忽略上面说的(一般不会用的),直接进应用场景:

    新葡亰496net 102

    就说到这了,代码部分附录是有的

     

    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)

    新葡亰496net 103

    来说说拆包相关的,C#的上面说了,这边来个案例即可:

    a=(1,2)

    b=a #把a的引用给b

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

    新葡亰496net 104

    来个扩展吧(多维元组)

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

    some_tuples[0]

    some_tuples[0][1]

    新葡亰496net 105

     其实核心代码都差不多,几句话解决

    import os
    import time
    


    while True: print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())) time.sleep(600) os.system("notify-send 友情提醒 10分钟过去了")

    新葡亰496net 106

    新葡亰496net 107

    运行(其实你可以自己把他设置为可执行程序【 style="color: #ff6600;">chmod x ./task.py】,这样在终端中直接./task.py就运行了)

    style="color: #ff0000;">新增补充:记得py文件前面加上: style="color: #ff0000;">#!/usr/bin/env python3 

    新葡亰496net 108

    1.注释

    附录:

    3.Dict系列

    Shell:(有些人在微信公众号问我,shell怎么获取时间,我这边改了下shell代码)【其实shell方便之处在于直接执行系统命令,系统获取时间:date,那shell加一行即可】

    python: style="color: #ff6600;">#注释一行三个单引号或者三个双引号注释多行: style="color: #008000;">'''XXX style="color: #008000;">'''或者 style="color: #008000;">"""XXXX style="color: #008000;">"""(一般用#就够了,有点像shell脚本的感觉)

    python输出就直接print即可,C是printf(不要搞混哦)

    新葡亰496net 109

    C、Java、Net都是 style="color: #ff6600;">//注释一行,/**/注释多行

    新葡亰496net 110

    Python3:

    新葡亰496net 111新葡亰496net 112

    # #输出 类型转换
    # 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

    新葡亰496net 113新葡亰496net 114

    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:

    新葡亰496net 115新葡亰496net 116

    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:一个隔一个跳着取("我编,程它它程,序谁") 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不写默认是取到最后一个,是正取(从左往右)还是逆取(从右往左),就看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(去除右边空格),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)) //# # ------------------------------------------------------------- // // //# 验证系列:isalpha(是否是纯字母),isalnum(是否是数字|字母),isdigit(是否是纯数字),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

    简单封装:

    新葡亰496net 117新葡亰496net 118

    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))

    新葡亰496net 119 

    NetCore:方式和Python差不多

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

    {

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

    }

    新葡亰496net 120 


    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

    新葡亰496net 121

    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;">列表内容清空

    新葡亰496net 122 


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

    新葡亰496net 123


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

    新葡亰496net 124

    while :
    do
     date
     sleep 600
      echo -e 'a'
     notify-send 友情提醒 已经过了10分钟了
    done
    

    2.变量

      说这么多基本上差不多完了,下次列表 字典 元组就一起讲了啊~ 

    扩展:

    知识点补充:

     python定义变量比较牛逼,直接写变量名即可,句子后面不用加分号,eg: style="color: #ff6600;">name="小明"

    新葡亰496net 125

    netcore,可以用var来进行类型推断,eg: style="color: #ff6600;">var name="小明";

    新葡亰496net 126

    1.多维元组:

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

    some_tuples[0]

    some_tuples[0][1]

    style="background-color: initial;">新葡亰496net 127


    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)

    新葡亰496net 128

    # 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

    新葡亰496net 129


    style="background-color: initial;">3.内置函数扩展:(len,max,min,del)

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

    新葡亰496net 130

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

    新葡亰496net 131

    这个注意一种情况(当然了,你按照之前说的规范,list里面放同一种类型就不会出错了)

    新葡亰496net 132

    min(),这个和max一样用

    新葡亰496net 133

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

    新葡亰496net 134

     

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

    直接输入python进入交互模式,相当于启动了Python解释器,但是等待你一行一行地输入源代码,每输入一行就执行一行。

    直接运行.py文件相当于启动了Python解释器,然后一次性把.py文件的源代码给执行了,你是没有机会以交互的方式输入源代码的。

    3.输入输出:r''表示''内部的字符串默认不转义

    知识扩展

    我稍微说下Linux日常使用的体验,可以略过这段:(这段放最后吧,不然认为我是打广告的就不太好了o((>ω< ))o)

    换行输出,不换行输出:( style="background-color: #ffff00;">n使用这个就不说了,它们和C都是一样的)

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

    新葡亰496net 135

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

    新葡亰496net 136


    python输出多个重复字符,不需要自己手打N个*或者for循环输出多个重复字符,eg: style="color: #ff6600;">print("x"*10)

    新葡亰496net 137

    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))【注意引号后面没有,哦】

    新葡亰496net 138

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

    新葡亰496net 139

      style="color: #ff0000;">可变的元组(元组在定义的时候就不能变了,但是可以通过类似这种方式来改变)

    新葡亰496net 140

    List切片

    新葡亰496net 141

    新葡亰496net 142


    Set集合扩展:

    新葡亰496net 143新葡亰496net 144新葡亰496net 145


    更新:(漏了一个删除的方法):

    新葡亰496net 146

    概念再补充下

    # dict内部存放的顺序和key放入的顺序是没有关系的
    # dict的key必须是不可变对象(dict根据key进行hash算法,来计算value的存储位置
    # 如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了)

    用一张图理解一下:(测试结果: style="color: #ff6600;">元组是可以作为Key的 -_-!

    新葡亰496net 147

    以前开发环境都是Win10或者Win系列,后来Net跨平台了,慢慢的开发专用笔记本也换成了Ubuntu,关于Linux基础和环境等就不说了,可以看我以前写的文章()

    Linux基本上还用的惯,之前开发工具突然间从VS变成了JetBrains Rider (Netcore的Console程序在linux下有时候有些莫名错误,所以才搭上了Rider)和 VSCode,陡然间稍有不适,用了几天就熟悉了。所以开发相关的Linux基本上和Win差不多

    关键是日常比较蛋疼,贴个常用deb安装包, 这个就不细说了可以参考我以前在Ubuntu16.04上发的文章(),截图自带的勉强能用Alt PrtScr,用不惯可以用国产deepin-screenshot或者用hotshots也行。 style="background-color: initial;">播放器可以自己安装一下:sudo apt-get  install  smplayer

    其他的其实也没啥了,文档有WPS,音乐有网易云,输入法有搜狗,词典可以选择有道,浏览器反正谷歌嘛。暂时不需要Linux版的录屏软件(有好的可以推荐哦~)【记得我前面讲dock的时候提过一款()】

    回头可能考虑再开发一个水印工具,以前开发的用惯了:

    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()

    新葡亰496net 148

    netcore:该案例推荐使用 int.TryParse,我这边就用常用的Convert系列了【支持类型比较多】

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

    新葡亰496net 149

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

    新葡亰496net 150

    netcore(C#常用数学方法都在Match类中)

    新葡亰496net 151

    = -= *= /= %= **= //= 这些就不用详说了吧?(举个例子: style="background-color: initial;">c = a 等效于 c = c a

    Python:

    Python List:

    新葡亰496net 152新葡亰496net 153

    # 定义一个列表,列表虽然可以存不同类型,一般我们把相同类型的值存列表里面,不同类型存字典里(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:

    新葡亰496net 154新葡亰496net 155

    # 只能查询,其他操作和列表差不多(不可变)
    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:

    新葡亰496net 156新葡亰496net 157

    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:

    新葡亰496net 158新葡亰496net 159

    // 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:

    新葡亰496net 160新葡亰496net 161

    // 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:

    新葡亰496net 162新葡亰496net 163

    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;">>= <=),就一点不一样:也可以用<>

    来个if else基础语法:括号可加可不加,但是记得加:。不用大括号,但是if里面的代码注意缩进

    新葡亰496net 164

    netcore:if或者else下面是单行代码可以不用写括号

    新葡亰496net 165

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

    新葡亰496net 166

    netcore:单行代码可以不用写括号

    新葡亰496net 167

    6.while

     直接来个案例:

    python里面没有 和 --,这点的确用的有点小不方便,扩展部分有相关说明

    新葡亰496net 168

    netcore

    新葡亰496net 169

     

    7.for

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

    新葡亰496net 170

    netcore: foreach (var i in name)

    新葡亰496net 171


    老规矩,来个扩展:switch(这个目前不用掌握,看看就好,后面会继续探讨的)

    Python没有 /--  参考文章(点我)

    python 中,变量是以内容为基准而不是像 c 中以变量名为基准,所以只要你的数字内容是5,不管你起什么名字,这个变量的 ID 是相同的,同时也就说明了 python 中一个变量可以以多个名称访问

    新葡亰496net 172

    如上例,a 和 b 都是 5,当你 改变了 a 时,b 也会跟着变,这当然不是我们希望的。so,正确的自增操作应该  a = 1,通过 id() 观察可知,id 值变化了,即 a 已经是新值的名称


     for的扩展(一般不太用)官方参考:

    新葡亰496net 173

    图片出处:


    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发布于电脑系统,转载请注明出处:新葡亰496net:幼功语法相比,Shell分别支付二个

    关键词: