学习笔记--＞Python\Java\C#基本语法对比使用

Mr DaYang

已于 2023-02-24 16:48:08 修改

阅读量377

点赞数 1

分类专栏： Java 文章标签： python java 爬虫

于 2021-08-12 09:02:06 首次发布

本文链接：https://blog.csdn.net/m0_46204224/article/details/119618288

版权

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Python基础语句

#说明
#python中单引号和双引号没有区别，一样使用
#
message="AaD"
message1="i love 3"
#1.使用“+”连接时无空格，使用“,”连接是有空格的
print(message.lower()+message.upper()+message.title())#aadAADAad
print(message.lower(),message.upper(),message.title())#aad AAD Aad
print(message1.title())#I Love 只要是空格前都要大写
print(len(message))
print(message.index("a"))#3
print(message[0:2])#Aa 都是左闭右开
#2.\n\t换行符制表符号+交换
print("languages:\n\tpython")
a=10
b=20
a,b=b,a

#3.删除空格
message = " python "
print(message.rstrip()+"----"+message.lstrip()+"----")

#4.字符强转int() str() float()
print(chr(1))#a
age=3
print("happy"+" "+str(age)+"rd birthday!")

#5.列表相关函数的调用，注意大多数方法是没有返回值的=None，没有返回值的，说明修改了原来的列表
message=["a","b","a","c"]
print(message[0])
message.append(22)
message.remove("a")
message.insert(1,"qq")
print(message.insert(1,"11"))#无返回值None
print(message)#['b', '11', 'qq', 'a', 'c', 22]
del message[3]
print(message.pop(-1))#22

print(message)#['b', '11', 'qq', 'c']
message.sort(reverse=False)
print(message)#['11', 'b', 'c', 'qq']
print(sorted(message))#有返回值-对原本函数不构成影响(已证)
print(message)
print(set(message))#返回不重复的无序数组


#6.列表的操作
#6.1 min()  max()  sum()有返回值
pizzas=["a","b","d","c"]
for i in pizzas:
    print(i,end="\n")#abdc
list1=[1,3,5]
print(min(list1),max(list1),sum(list1))#1 5 9

#6.2表的建立
#6.2.1
list1=[]
for i in range(1,10):#左开右闭
    list1.append(i)
print(list1)#[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list1[1:3])#[2, 3]左开右闭
print(list1[-2])#8
print(list1[:2])#[1, 2]左开右闭
list1[2]="33333333"

#6.2.2列表生成器
list1 = [i for i in range(1,10,2)]

#6.2.3可迭代对象生成list
list1 = list(range(1,10))#[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list1)

#6.3列表复制
food=[1,2,3,"a","b"]
food1= food#直接相等，导致a变，b也变
food1.append("ccc")
print("food:{}".format(food),"food1:{}".format(food1))

food1= food[:]#a,b单独操作
food1.append("ddd")
print("food:{}".format(food),"food1:{}".format(food1))

#7.元祖(与list对应，只不过元祖里信息不能修改)
dimension=(100,200,3,"sss")#元素不可修改，但可附新值
dimension=(100,400)
print(dimension)

#8.字典
#8.1
dic={'name':'lin','age':'20'}
print(dic['name'])
print(dic.keys(),dic.values())
print(sorted(dic.keys()),set(dic.keys()))#['age', 'name'] {'age', 'name'}

dic['age']=30#增，改
print(dic)#{'name': 'lin', 'age': 30}
del dic['name']#删，只能删除键，对应的值也会被删除
print(dic)

#8.2遍历
for k,v in dic.items():
    print(k,v)

for k in dic.keys():
    print(k)

#8.3
# 键-值(字符串)
# 键-值(列表)
# 键-值(字典)
dic1={'name':'lin','food':['mushroom','chess'],'address':{'country':'nanjing','population':500}}


#9.程序流程控制
#9.1  if语句
car="bmw"
print(car=="bmw")#返回boolean
print("b" in car)#True

#9.1.2
# if-elif-elif-else#只执行一段代码块
a=10
if a>4:#上下两个if无关联，都会执行
    print("yes")
if a>6:
    print("yes")

#9.1.3判断是否为空
b=[]
if b:
    print("b中是有数字的")

#10 while 语句
#10.1 while+input()
# isFlag=True
# while isFlag:
#     m=input()
#     if m=="y" or m=="y".upper():
#         isFlag=False
#     else:
#         print("你输入的数据是{}".format(m))
#
# name=input("first name:")
# print(name)
#10.1.1,使用！=作为条件，也就是说一直循环，直到条件=5，退出循环
count=0
while count !=5:
	cur=+=1

#10.2
pets=[1,2,2,3,4,3,2]
while 2 in pets:
    pets.remove(2)
print("去除所有的2")
print(pets)


l=[1,2,3,3,3]
for item in l:
    # print(item)
    if item==3:
        l.remove(item)
        print(l)
print(l)#[1, 2, 3]

   # #idex是从0一直往下走，每次要检查idex<=len(l),idex是一直累加的，l是看新生成的
   # index     item    目标=3   l
   # 0         1               [1,2,3,3,3]
   # 1         2               [1,2,3,3,3]
   # 2         3       ok      [1,2,3,3]
   # 3         3       ok      [1,2,3]


#11函数
def get_user(pet,username='niming'):#要求默认值放到末尾,函数可以有返回值，
    print("hello,{} 我的朋友,你喜欢{}吗".format(username,pet))
    return "作者你好"
m1=get_user('dog','lin')
print(m1)

#11.1函数接收多个参数
def make_pizza(size,*addings):
    print('the pizza is {} inch'.format(size))
    for i in addings:
        print(i,end='')
make_pizza(16,"a","b","c")
print()

#12.类（可以有多个父类）
#12.1
class Cat:#self表示当前对象

    def __init__(self,name):#初始化方法，定义一个类的具体属性
        self.name=name
        self.__age='我是私有的，你看不见'#在属性或方法前加__表示私有，1.是不能被对象调用，2.不可被子类继承 3.但可以通过内部方法使用，如eat()

    def eat(self,food):#self就是对象本身
        print(self.name+"猫爱吃{}".format(food),self.__age)

    ##内置方法，带有  __方法名__的方法，在对象被建立时，这种函数会自动执行
    def __str__(self):
        return self.name+"是一只猫"

tom = Cat('tom')
tom.eat('fish')
print(tom)#<__main__.Cat object at 0x0000000001DC39B0>
#重写str内置方法后print(tom)->tom是一只猫

#12.2类的多继承时，先入为主，C(A,B)，先查c有没，再查A(要是A中有这方法，就不再看B了)，最后查B
class A:
    def p(self):
        print("a")
class B:
    def p(self):
        print("b")

class C(A,B):
    pass
    # def p(self):#重写父类方法
    #     print("c")
o=C()
o.p()
print()

#12.3类的方法
#从生命周期来看，是现有类，再有对象
# 还没有生成对象之前就有了(类属性，静态方法,类方法)，因此他们内部不能调用对象的方法
#生成对象后，可以调用类的方法
class Game:
    #1.类属性
    top_score=0#只能被类方法调用，不能被对象方法调用
    #2. self，对象属性
    def __init__(self,name):
        self.name =name
    #3.静态方法
    @staticmethod
    def show_help():
        print("帮助信息")

    #4.类方法
    @classmethod
    def show_top_score(cls):
        print("历史记录{}".format(cls.top_score))
    #5.对象方法
    def show(self):
        print('开始游戏！')
        self.show_help()
        self.show_top_score()

game=Game('lin')
game.show()

Java基础语句

请添加图片描述
附上一个思维导图：链接
在这里插入图片描述

package lin;
import java.util.*;

/**
 * @author lin
 * @create 2021-08-11-19:13
 */
public class basic {
    public static void main(String[] args){
  /*说明
  1.java规范比较严格,单双引号不一样，定义变量前，要声明类型,每个代码后加封号
  2.变量的命名方式遵循一定原则，好记。
  3.代码要编译，再运行，有时明显的错误，编译都过不了
    1.整型：byte(1字节=8bit)\ short(2字节)\ int(4字节) \long(8字节)
    2.浮点型float(4字节) \double(8字节)
    3.字符型char(1字符=2字节)
    4.布尔型 false ture
    */
        int a=0; char a1='c'; double a2=12.3; boolean a3=false; String a4="sss";
        //1.只能使用“,”连接
        String str="ilovechina";
        int[] arr=new int[]{12,3};
        System.out.println(str.toUpperCase()+" "+str.toLowerCase());
        System.out.println(str.length()+" "+arr.length);//8 2
        System.out.println(str.indexOf("i"));//0
        System.out.println(str.substring(0,3));//ilo 都是左闭右开

        //2.\n\t换行符制表符号+交换
        System.out.println("languages:\n\tpython");
        int a=10;
        int b =20;
        int temp;
        temp=a;
        a=b;
        b=temp;
        

        //3.删除空格
        String s1 = "  java  ";
        System.out.println(s1.trim());

        //4.字符强转,调用Arrays类来查看数组
        String s2="2";
        char [] b =new char[]{'a','b'};
        byte [] b1 =new byte[]{'a','b'};
        System.out.println(String.valueOf(3)+" "+Integer.parseInt(s2));
        System.out.println(new String(b)+" "+s2.toCharArray());
        System.out.println(new String(b1)+" "+s2.getBytes());
        System.out.println(Arrays.toString(s2.toCharArray()));

        //5.数组+Arrays工具类的使用,指定什么样的数据类型里边就只填什么，
        // 由于是基本数据类型而不是引用数据类型(ArrayList)，因为Array中没有什么方法
        int [] b2=new int[]{1,2,3};//静态初始化
        int [][]b4 = new int[3][5];//动态初始化
        b2[0]=3;
        int [][] b3 =new int [][]{{1,2},{2,4,5}};
        System.out.println(Arrays.toString(b2));
        //Object [] b4= new Object []{1,'a',"a",new duixiang()};//所有类都继承object，所以object的数组可以任意方
        System.out.println(b3[0][1]);//2

        //5.1Arrays工具类
        int [] b5=new int[4];
        System.out.println(Arrays.equals(b2,b5));//必须保证前后是同一种类型才能比较，b2,b4一个是1维，一个是2维，编译不通过
        System.out.println(Arrays.toString(b2));//[3, 2, 3]
//        Arrays.fill(b2,10);//[10, 10, 10]
        Arrays.sort(b2);
        System.out.println(Arrays.toString(b2));//[2, 3, 3]
        System.out.println(Arrays.binarySearch(b2, 2));//以二分法查找2所在的index

        //6/集合---只能存对象引用数据类型，基本类型不行
        /*6.java几个分为Coolection结构(单列数据)和Map(双列数据)两种体系
         |----Collection接口：单列集合，用来存储一个一个的对象
*          |----List接口：存储有序的、可重复的数据。  -->“动态”数组
*              |----ArrayList、LinkedList、Vector//底层数据存储的方式不同
*
*          |----Set接口：存储无序的、不可重复的数据   -->高中讲的“集合”
*              |----HashSet、LinkedHashSet、TreeSet
*
*      |----Map接口：双列集合，用来存储一对(key - value)一对的数据   -->高中函数：y = f(x)
*              |----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties*/
        //ArrayList
       //6.1 数组转ArrayList集合的多种方法，见url：https://blog.csdn.net/m0_46204224/article/details/119539504?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162872965816780261968890%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=162872965816780261968890&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_v29-1-119539504.pc_v2_rank_blog_default&utm_term=java&spm=1018.2226.3001.4450

       //6.2方法
        /*增：add(Object obj)
        删：remove(int index) / remove(Object obj)
        对于string是正常list.remove("a"); list.remove(new Integer(15));
        改：set(int index, Object ele)
        查：get(int index)
        插：add(int index, Object ele)
        长度：size()返回存储元素的个数，而不是底层new（10）的10个空的数组!
        遍历：① Iterator迭代器方式
                Iterator iterator = list.iterator();
                while(iterator.hasNext()){
                    System.out.println(iterator.next());
                }
                //方式二：增强for循环
                for(Object obj : list){
                    System.out.println(obj);
                }

                System.out.println("***************");

                //方式三：普通for循环
                for(int i = 0;i < list.size();i++){
                    System.out.println(list.get(i));
                }
        */
        ArrayList <Integer>arrayList = new ArrayList<Integer>();//<Integer,String>尖括号表示泛型，表示此表只能存放什么类型的信息，注意只能存对象引用数据类型，基本类型不行
        arrayList.add(1);
        arrayList.add(2);
        System.out.println(arrayList.toString());//[1, 2]
        arrayList.add(0,45);//[45, 1, 2]
        System.out.println(arrayList);
        System.out.println(arrayList.get(0));//45

        //6.3collections接口方法
        /*
        reverse(List)：反转 List 中元素的顺序
        shuffle(List)：对 List 集合元素进行随机排序
        sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

        Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
        Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
        Object min(Collection)
        Object min(Collection，Comparator)
        int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
        void copy(List dest,List src)：将src中的内容复制到dest中
        boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

        */

        //8.Map
        /*总结：常用方法：
        * 添加：put(Object key,Object value)
        * 删除：remove(Object key)
        * 修改：put(Object key,Object value)
        * 查询：get(Object key)
        * 长度：size()
        * 遍历：keySet() / values() / entrySet()*/

        Map map =new HashMap();
        map.put("aa",123);
        map.put(45,123);
        map.put("bb",56);
        ArrayList arrayList1 =new ArrayList();
        arrayList1.add(3);
        map.put("cc",arrayList1);//{aa=123, bb=56, cc=[3], 45=123}

        Set a7 = map.keySet();
        System.out.println(a7.toString());//[aa, bb, cc, 45]无序的

        //9程序流程控制
        //9.1 if-else if -else if -else
        int x=4;
        int y =5;
        if(x>y){
            System.out.println("x大于y");
        }else if(x==y){
            System.out.println("x等于y");
        }else
            System.out.println("x小于y");

        //9.2switch-case
        int number=1;
        switch(number){
            case 0:
                System.out.println("case 0 状态");
                break;
            case 1:
                System.out.println("case 1 状态");
                break;
        }

        //9.3循环（三种，每种都包含以下4个部分）
        /*a.开发中常使用for，while
        b.do{}while ();至少执行一次循环体
        1.初始化条件
        2.循环条件
        3.循环体
        4.迭代部分*/

        //9.3.1-3
        for(int i=0;i<10;i++){
            System.out.println("yes");
        }
        /*
        for (1;2;4){
            3
        }
        //
        1
        while(2){
            3
            4 }

        //
        1
        do{
            3
            4 }
        while(2)
        */

        //12.类只能但继承，但为了弥补缺点，增加了一个类调用多个接口的方法
        /*
        class Person{

        //属性（也叫成员变量）
        boolean isMarried;
        String name;
        //构造器（使用类时，对类属性进行初始化操作）--对应init初始化方法
        public Person(String n,boolean m){
            this.name =n
            this.isMarried =m}

        //方法，函数
        public void walk(){
            System.out.println("人走路")
            }

        //代码块,用的少（用来初始化类，对象，只能用static修饰）
        {   age =17;
            System.out.println("hello,static block-2");
        }

        //内部类
        class pet{
             String name;
             float weight;
            }

        }

        * */
    }
    //13接口,类的继承,用关键词来修饰变量，方法
    interface Flyable{
        void attack();
    }

    class pet{
        void attacrt(){
        };
    }

    //1
    class Person extends pet{
    }
    //class person1 implements Flyable{}
    Person tom =new Person();
}

C#基础语句

5.数组、集合
1.数组是连续的不能add,delete(new int[3])
2.集合(arraylist支持add,delete但是装箱拆箱耗时-由于存储变量类型不一致情况导致,2.list泛型 list约束了只支持一种类型)

//每次new就会开辟一个新地址，尽管内容一次，但不是同一个
```csharp
 //关键字 int，int[] 声明变量类型，new 创建数组
  int q = 2;
  int[] a = new int[6];
  int[] b = new int[3] { 1,2,3};
  int[] c = new int[] { 'a',2,3};
  MessageBox.Show(c[0].ToString()); //输出97

在这里插入图片描述
6.数组、集合

 List<int> a = new List<int>( );
 List<int> b = new List<int> { 1,2,2};
 List<Person> p = new List<Person>();
 a.Add(112);
 a[0] = 4;
 a.Insert(0, 3);
 a.RemoveAt(0);
 a.Remove(4);
 a.Clear();
 p.Add(new Person() { });
 
 Dictionary<int, string> c = new Dictionary<int, string>();
 Dictionary<int, string> d = new Dictionary<int, string> {  //对象初始化器
     { 2,"333"},{4,"555"}
 };
 c.Add(1, "111");
 c.Add(2, "222");
 c.Add(3, "333");

 string value = c[2];//通过键索引到值； “222”
 bool f=c.Remove(1);//通过键删除那个值

9程序流程控制
9.1 条件分支
IF要一个个判断才能选择某个分支，switch直接进入那个分支

if (i>10){
}
else if(i>0){
}
else{
}

private void InitializeComponent()
        {
            MessageBox.Show("lin");
            int a = 2;  
            switch (a)  //a可以为数字也可为string
            {
                case 1:
                    MessageBox.Show("1");
                    break;
                case 2:
                    MessageBox.Show("2");
                    break;//必须要break
                default:
                    MessageBox.Show("3");
                    break;//必须要break
            }

9.3 循环-三种

//for 循环直接循环    while 预设一个条件，当条件满足时进入循环，    do {}while  先执行，达到条件退出
 for (int a =2; a<4; a++)
            {
                MessageBox.Show(a.ToString());
            };

int i = 1;
while (i <=3) {
    MessageBox.Show((i++).ToString());
}

int b = 1;
do {
    MessageBox.Show((b).ToString()); 
    b++;
}
while (b < 4);

10.类与方法
在这里插入图片描述
10.1函数-参数修饰符

   /*1。无修饰时函数内部处理的是副本不影响原来的值
    string want = "2222";   //want = "2222"
    Sellhouse(want);        //box显示1111
    MessageBox.Show(want.ToString());  //box显示2222
    */

    /*2。out修饰时,引用传递， 函数内部处理的是原地址，影响原来的值
    string want = "2222";   //want = "2222"
    Sellhouse1(out want);        //box显示1111
    MessageBox.Show(want.ToString());  //box显示1111
    */

    /*3。ref修饰时,引用传递， 函数内部处理的是原地址，影响原来的值,与out不同，out使用函数中（Sellhouse1）必须要赋值否则报错
    string want = "2222";   //want = "2222"
    Sellhouse2(ref want);        //box显示1111
    MessageBox.Show(want.ToString());  //box显示1111
    */
}
public void Sellhouse(string want)
{
    want = "1111";
    MessageBox.Show(want.ToString());
}
public void Sellhouse1(out string want)  
{
    want = "1111";   //有out时必须要赋值，否则报错
    MessageBox.Show(want.ToString());
}

public void Sellhouse2(ref string want)
{
    want = "1111";   //有ref时，谁调用它必须赋初值，否则报错
    MessageBox.Show(want.ToString());
}

12.遍历

  int[] a = new int[] { 3,4,5};
  foreach (int i in a)
  {
      MessageBox.Show(i.ToString());
  }

  List<int> b = new List<int> { 2,3,4};
  foreach(int i in b)
  {
      MessageBox.Show(i.ToString());
  }

  Dictionary<string, string> c = new Dictionary<string, string>() { {"aa","aaaaa" },{"bb","bbbb" } };
  foreach (KeyValuePair<string,string> i in c)
  {
      string key = i.Key;
      string value = i.Value;
  }

13.枚举

enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };

static void Main()
 {
     int x = (int)Day.Sun;//0
     int y = (int)Day.Fri;//5
  

     //1GetName方法：在指定枚举中检索具有指定值的常数的名称
     string strToday = Enum.GetName(typeof(Day), 3);//Wed

     //2GetNames方法： 检索指定枚举中常数名称的数组
     string[] array1 = Enum.GetNames(typeof(Day));//[Sun, Mon, Tue, Wed, Thu, Fri, Sat]

     Array array3 = Enum.GetValues(typeof(Day));
     Debug.WriteLine(array3.GetType().ToString());

     foreach (var i in array3) { Debug.WriteLine(i); }
     Debug.WriteLine(array1);//5

 }

类型转换

int number = 10;
//int ---> double
//目标类型 = 源类型
double d = number; //自动类型转换 隐式类型转换

double d1 = 303.6;
//double ---> int
//目标类型 = (目标类型)原类型
int n = (int)d1;//强制类型转换，显示类型转换
Console.WriteLine(n); //303

int n1 = 111111;
string s = n1.ToString();
Console.WriteLine(s);

占位符

string a = "aaa";
string b = "bbb";
string c = String.Format("我" + "{0}" +"{1}",a,b);//我aaabbb
string d = String.Format("我" + "{1}" + "{0}", a, b);//我bbbaaa
Console.WriteLine(c);
Console.WriteLine(d);

关键字
const（声明常量比如数学中的PI,e都是固定不变的值）、

//1.必须初始化等号后必须有值   2.PI不能被修改
const double PI = 3.1415;

Mr DaYang

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录