精华内容
下载资源
问答
  • 一. 运算符的总类 先列举所有的运算符类型:算术...本节将讨论比较运算符和逻辑运算符,这些仍旧属于java语言基础。等到讲完语法,函数,和数组之后,才是真正进入java语言的研究。 二.  在探讨比较运算符之前,先将视

    一. 运算符的总类

    先列举所有的运算符类型:算术运算符,赋值运算符,比较运算符,逻辑运算符,位运算符,三元运算符。

    命名为什么叫运算符,英文叫operator, 难道说这是对操作的符号化表示?可以着一些英文的原版书籍来看。

    本节将讨论比较运算符和逻辑运算符,这些仍旧属于java语言基础。等到讲完语法,函数,和数组之后,才是真正进入java语言的研究。

    二. 

    在探讨比较运算符之前,先将视频中遇到的一个问题再重新学习一下。这里DOS报的错是没有找到主类,产生这样问题的原因只有两个:java运行的类名写错,类的路径不对。这里重点说明第二个错误。类的路径不对,java都是在当前路径下运行的class类文件,路径不对,说明我们对路径进行了更改。在DOS中,输入set classpath,控制台将直接显示类路径。这里还要明白一点,系统中本来是没有classpath的,我们为了能在任意目录下,启动某一些class类文件,从而将这些类文件集中放在一个文件夹中,这个文件夹叫classpath。

    对于classpath知识点,背后也有一些东西值得深思。首先就是设置这个classpath,有永久的,暂时的,借用的。


    注意:上面理解的classpath还是有一些,偏差。举例来说明,如果开始在DOS中展示定义了classpath的路径,且DOS窗口一直没关闭,set classpath=d:\source\1,然后在d:\source\01文件夹中编写Demo.java源程序,接着在DOS中编译,和运行,看DOS的检测结果。

    最终的结果显示,我们开始编写的源程序是在d:source\01文件夹中的Demo.java,接着DOS进行了编译,编译的Demo.class运行文件和Demo.java源文件是在一个文件夹中的。但是java命令工具在启动class运行文件时,是直接去d:source\1文件中去寻找Demo.class类文件的。这就意味着,set classpath=..... 是要求java工具直接去对应的文件中去搜寻某一类文件,如果没有,就会显示为找不到或无法加载主类。

    三. 比较运算符

    比较运算符运算完都会有结果。只要是运算符,运算结束后都会有结果。

    比较运算符得出的结果不是true,就是false。

    常见的大家都知道,大于,小于...这里介绍了一种特殊的比较运算符,等等于或者是相等于。

    看下面的两个语句: System.out.println(3=2); System.out.println(3==2); 经过DOS的验证,前一个是错误的,后一个是正确的。


    四. 逻辑运算符

    在这里我们又回归到如何学习的问题上来。什么是逻辑?为什么要有逻辑运算符?

    逻辑就是一种关系,有这么几种类型,与,或.....。

    逻辑运算符的出现是为java语言定制的。在日常生活中,我们可以直接写2<x<5; 但是在java语言中无法这么写,这是两个表达式。为什么不能这么写?因为是两个表达式就不行?视频中的说法就是java不支持这种两个表达式的,因此构建了逻辑运算符,来连接两个boolean类型的表达式。

    五. 逻辑运算符的分类

    上面谈论逻辑运算符是连接boolean类型的表达式的,boolean类型就是输出为true或false,这就是逻辑运算。

    逻辑运算有多种,先描述两种,&与,|或,符号比较独特。

    &与逻辑运算符的使用:int x=3; System.out.println(x>2&x<5); 在DOS中输出为true。由此可以看出,逻辑运算符连接的是逻辑表达式,输出的也是boolean类型的数据。

    这里直接在输出语句中进行逻辑运算,那么可不可以在输出语句的外面进行,然后由输出语句输出呢?结果如下:


    而视频中的做法是直接在输出语句中的,截图如下:


    这说明输出语句可以直接当成一个计算的场地来用。为什么java要这样设置呢?这么做的原理是什么

    我又补充了一种Java语句,显示如下,ture和false是关键字,逻辑运算符本质上对两个boolean类型的数据进行对比,通过与运算的法则(也就是and运算,判断得出结果是true还是false)。


    注意:我们分析上面三种情况,视频中,只讲解了System.out.println(x<5&x>2); 这种情况。在实际的分析中,我觉着这么长的式子,底层有三个步骤。先是对&左右两侧进行判断,得出左右两侧的逻辑运算的结果,ture还是false,然后再对这两个boolean数据进行&运算,最后得出一个结果。写在输出语句外面和里面是没什么区别的,但是如果写成true&true这种形式的话,相当于省去了两个运算,直接进行了第三步。

    注意:对于false&false,我按照上面的三种形式写了一下,结果如下,挺有意思:

    第一种,在输出语句外面定义好了,最后用输出语句直接输出,DOS显示运行正常。


    第二种,在输出语句内直接进行运算,DOS直接报错。这说明底层在第一种和第二种形式下,进行的运算是不一样的。为什么在这种情况下DOS会报错?我又换了一个输出语句,在int a=3; System.out.println(x<1&x>2);按道理来说这是true&false的形式,但是DOS依旧报错。但是,当我在输出语句中直接书写System.out.println(true&false);DOS结果显示能够正常运行。这就很奇怪,背后的机制是什么?难道说输出语句中如果直接进行计算的话,&运算的两边必须给定是正确的,不然就报错,那么就给定boolean数据,这就不会管。→上面的说法完全是错误的,说不通,仔细地观察下面的截图,我们发现,前后变量写错了,定义时写的是a,但是在输出语句中写的是x,这就导致DOS报错为找不到x。

    在这里,我突然理解了那句话,计算机是帮助人们运算的工具。我们通过学习这些高级计算机语言,来编写一些程序。这些程序完全就是将人们日常生活中的计算思路全部化为代码,利用这些程序代替人们来进行计算,乃至于超越人们的计算能力。


    五. |或运算符

    对于|运算符,按照上面&运算符的形式,不在做更多的讲解。

    这里再插一句话,计算机高级语言就是一种极端符号化的集合体,将所用到的各种东西各种符号化,比如这里所讲的各种逻辑运算,都要将其符号化,并且利用键盘上原有的符号,诸如:%,^,&....来代表。





    展开全文
  • JavaScript是一种属于网络脚本语言,已经被广泛用于Web应用开发,常用来为网页添 加各式各样动态功能,为用户提供更流畅美观浏览效果。通常JavaScript脚本是通 过嵌入在HTML中来实现自身功能。 特点: 1....

    JavaScript基础:(主要介绍三点:简介、特点和组成)

    简介:

    JavaScript是一种属于网络的脚本语言,已经被广泛用于Web应用开发,常用来为网页添 加各式各样的动态功能,为用户提供更流畅美观的浏览效果。通常JavaScript脚本是通 过嵌入在HTML中来实现自身的功能的。

    特点:

    1. 解释性脚本语言。 2. 主要用来向HTML页面添加交互行为。 3. 可直接嵌入HTML页面,但写成单独的js文件有利于结构和行为的分离。 4. 跨平台特性,绝大多数浏览器支持,可以在多种平台下运行(如Windows、 Linux、Mac、Android、iOS等)。

    组成:

    JavaScript由三部分组成:

    1. ECMAScript: (3/5/6/7/8)它是JavaScript语言的标准,规定JavaScript的编程语法和 基础核心知识

    2. DOM:(document object model)文档对象模型, 提供给JavaScript很多操作页面 中元素的属性和方法

    3. BOM:(browser object model)浏览器对象模型, 提供了很多操作浏览器的属性 方法,而这些方法都存放在window浏览器对象上

    ECMAScript版本  支持情况

    ES5             主流浏览器都支持

    ES6(ES2015)   主流浏览器都支持绝大多数功能

    ES7(ES2016)   主流浏览器的新版本部分支持

    ES8(ES2017)   主流浏览器的新版本部分支持          (摘抄于JavaScript基础)

     

    接下来就介绍一下它的运算符: (算数运算符、赋值运算符、比较运算符和逻辑运算符)

    //算术运算符

    var x = 5; var y = 2;

    console.log("x+y=" + (x + y));  console.log("x-y=" + (x - y));

    console.log("x*y=" + (x * y));  console.log("x/y=" + (x / y));

    console.log("x%y=" + (x % y));

    //JavaScript当除数为0是

    console.log(1/0);// Infinity 正无穷   console.log(0/0);//NaN 非数console.log(-1/0);//-Infinity 负无穷  console.log(1%0);// NaN

    console.log(0%0);// NaN               console.log(-1%0);// NaN

    当JavaScript除数为0时,JS中不会报错,但是得到的值有点特殊(当大于0的数除0时结果等于正无穷Infinity、0除0等于NaN非数、小于0的数除0时结果为负无穷-Infinity、之后凡是取余的情况下除数为0的通通都是NaN非数),

    对应输出值图如下: (没什么很难得问题点,易懂)

    //赋值运算符 (把加减乘除取余和等号组合)

      x = 5; y = 2;

      x += y;// x=x+y;      x -= y;// x=x-y;       x *= y;// x=x*y;

      x /= y;// x=x/y;      x %= y;// x=x%y;

      console.log(x);

    把后面那一个的值赋给前面那一个就叫赋值。

    当y等于0时x /= y和x %= y就要参考上面的除数为0的情况。

     

    //比较运算符 (举了4个比较难理解的例子)

      x = "123";  y = 123;

      console.log("x==y :" + (x == y));    ==只比较值,类型不管 (相等) true

      console.log("x===y :" + (x === y));  ===先比较类型,如果类型相同再比较值,值不同还是不等(绝对相等) false

      console.log("x!=y :" + (x != y));    !=直接比较值相不相等 false

    console.log("x!==y :" + (x !== y));  !==先比较类型,不同就是true了,类型不同再比较值,值也相同就是false了。 true

    注意:

    ===和!==  首先比较两边的变量数据类型是否相同,如果类型相同才会比较两边 的变量的数值是否相等; ==和!=  比较时,若两边的类型不同会偿试转换类型,然后比较两边变量的数值 是否相等;若两边的类型相同,直接比较两边的数值是否相同。

     

     

    //逻辑运算符 (&&、||、!)

      x=5;  y=6;  z=7;

      console.log((x<y)&&(x>z));   console.log((x<y)||(x>z));  console.log(!(x<y));

    简化版:

    console.log(true && false);  console.log(true || false); console.log(!false);//非

    定义:不是假就是真,不是真就是假,不用太过纠结。

    展开全文
  • 运算符

    2020-11-18 22:02:23
    如:2+3、4-2、23等等,其中像数字2、3和4等数字都属于操作数,而“+”、“-”、“”这些符号就是运算符,这些运算符的存在使我们可以进行程序的运作,完成我们所需要的功能。 二、分类 运算符根据功能的不同可以...

    运算符

    一、概念

    • 运算符是用于执行程序代码运算,会针对一个以上操作数项目来进行运算。如:2+3、4-2、23等等,其中像数字2、3和4等数字都属于操作数,而“+”、“-”、“”这些符号就是运算符,这些运算符的存在使我们可以进行程序的运作,完成我们所需要的功能。

    二、分类

    • 运算符根据功能的不同可以分为以下几类:
    • 1.算术运算符
    • 2.赋值运算符
    • 3.比较运算符(关系运算符)
    • 4.身份运算
    • 5.逻辑运算符
    • 6.条件运算符(三元运算符)

    2.1 算术运算符

    运算符 描述 示例代码
    + 加 两个对象相加 a+b 结果为30
    - 减 两个对象相减 a-b 结果为-10
    * 乘 两个对象相乘 a*b 结果为100
    / 除 两个对象相除 a/b 结果为0.5
    % 取模(取余)返回除法的余数 a%b 结果为10
    ** 幂 x**y 返回x的y次方 a**b 结果为b次方
    // 去整数 返回商的整数 5//3 结果为1
    • 其实通过上面的表格可以看出,运算符的作用像我们在小学时候学习数学的加减乘除一样, 数字型的数值(如整数型int、浮点型float)可以在运算符的作用下进行加减乘除,此外,字符串型的数据也可以运用运算符来执行程序,但是该类型数据的执行结果并不像前者一样进行数值的运算。

    2.1.1 加号“+”

    • 各类型数值之间的运算
    • 1.整数型(int)与整数型(int)
    # 1. 整数型与整数型
    >>>a = 1
    >>>b = 2
    >>>print(a + b)
    >>> 3 
    
    • 2.整数型(int)与浮点数型(float)
    >>>a = 1.0
    >>>b = 2.0
    >>>print(a + b)
    >>> 3.0
    
    • 字符串类型

    3.浮点数型(float)与浮点数型(float)

    >>>a = 1.0
    >>>b = 2.0
    >>>print(a + b)
    >>> 3.0
    
    • 4.字符串型(str)与字符串型(str)
    >>>a = '2'
    >>>b = '3'
    >>>print(a + b)
    >>>> 23
    
    • 5.字符串型(str)与整数型(int)
    >>>a = '1'
    >>>b = 2
    >>>print(a + b)
    >>>TypeError: must be str, not int
    
    • 6.字符串型(str)与浮点数型(float)
    >>>a = '1'
    >>>b = 2.0
    >>>print(a + b)
    >>>TypeError: must be str, not float
    
    • 通过上面程序可以看出,数字型的数据通过运算符“+”进行数值间的相加,类似于我们小学时候的加法运算,此外要注意的是,整数型与浮点数型数据间的运算,得出的数据类型一定为浮点型。
    • 为啥得出的数据为浮点数型,这是因为在运算的过程中,系统会将整数型的数值转换为浮点型再进行运算,为什么不将浮点数型的数据转为整数型,我觉得是浮点数型的数据比起整数型的数据要更加精准一些,系统比较偏向于精准度比较高的浮点数型,因此在运算过程中会将整数型的数据转换为浮点数型后再进行运算。
    • 而对于字符串型的数据,此时的“+”号并不是数值相加的作用,在这里是起到拼接的作用,是将两个字符串的数值进行合并形成新的字符串,且字符串类型与整数型、浮点数型的数据无法通过“+”号进行运算。

    2.1.2 除号“-”

    • 各类型数值之间的运算
    • 1.整数型(int)与整数型(int)
    >>>a = 1
    >>>b = 2
    >>>print(a - b)
    >>> -1 
    
    • 2.整数型(int)与浮点数型(float)
    >>>a = 1
    >>>b = 2.0
    >>>print(a - b)
    >>> -1.0
    
    • 3.浮点数型(float)与与浮点数型(float)
    >>>a = 1.0
    >>>b = 2.0
    >>>print(a - b)
    >>> -1.0
    
    • 4.字符串型(str)与字符串型(str)
    >>>a = '2'
    >>>b = '3'
    >>>print(a - b)
    >>>TypeError: unsupported operand type(s) for -: 'str' and 'str'
    
    • 5.字符串型(str)与整数型(int)
    >>>a = '2'
    >>>b = 3
    >>>print(a - b)
    >>>TypeError: unsupported operand type(s) for -: 'str' and 'int'
    
    • 6.字符串型(str)与与浮点数型(float)
    >>>a = '1'
    >>>b = 2.0
    >>>print(a - b)
    >>>TypeError: unsupported operand type(s) for -: 'str' and 'float'
    

    通过上述例子,可以看出,对于数字型的数值来说。减号“-”的作用跟加号“+”的作用一样,是进行数值的减法运算,但是对于字符串类型的数据,减号“-”并没有像加号“+”的作用,无法通过减号“-”进行运算。

    2.1.3 乘号“*”

    • 各类型数值之间的运算
    • 1.整数型(int)与整数型(int)
    # 1. 整数型与整数型
    >>>a = 1
    >>>b = 2
    >>>print(a * b)
    >>> 2
    
    • 3.浮点数型(float)与浮点数型(float)
    >>>a = 1.0
    >>>b = 2.0
    >>>print(a * b)
    >>> 2.0
    
    • 4.字符串型(str)与字符串型(str)
    >>>a = '2'
    >>>b = '3'
    >>>print(a * b)
    >>>> TypeError: can't multiply sequence by non-int of type 'str'
    
    • 5.字符串型(str)与整数型(int)
    >>>a = '2'
    >>>b = 3
    >>>print(a * b)
    >>> 222
    
    >>>a = 3
    >>>b = '2'
    >>>print(a * b)
    >>> 222
    
    • 6.字符串型(str)与浮点数型(float)
    >>>a = '2'
    >>>b = 3.0
    >>>print(a * b)
    >>> TypeError: can't multiply sequence by non-int of type 'float'
    
    >>>a = 3.0
    >>>b = '2'
    >>>print(a * b)
    >>>TypeError: can't multiply sequence by non-int of type 'float'
    
    • 通过上述例子可以看出,对于数字型的数值来说。乘号“*”的作用就是让两个数值相乘,而字符串型的数据,通过上面的例子可以看出,在使用乘号运算符时,字符串型的数据只能与整数型的数据搭配使用,且乘号起到的作用是让字符串重复,重复的次数由整数型的数值决定。

    2.1.4 除号“/”

    • 各类型数值之间的运算
    • 1.整数型(int)与整数型(int)
    >>>a = 1
    >>>b = 2
    >>>print(a / b)
    >>> 0.5
    
    • 2.整数型(int)与浮点数型(float)
    >>>a = 1
    >>>b = 2.0
    >>>print(a / b)
    >>>0.5
    
    • 3.浮点数型(float)与与浮点数型(float)
    >>>a = 1.0
    >>>b = 2.0
    >>>print(a / b)
    >>> 0.5
    
    • 4.字符串型(str)与字符串型(str)
    >>>a = '2'
    >>>b = '3'
    >>>print(a / b)
    >>>TypeError: unsupported operand type(s) for /: 'str' and 'str'
    
    • 5.字符串型(str)与整数型(int)
    >>>a = '2'
    >>>b = 3
    >>>print(a / b)
    >>>TypeError: unsupported operand type(s) for /: 'str' and 'int'
    
    • 6.字符串型(str)与与浮点数型(float)
    >>>a = '1'
    >>>b = 2.0
    >>>print(a / b)
    >>>TypeError: unsupported operand type(s) for /: 'str' and 'float'
    
    • 除号“/”可以运用于浮点数型与整数型的数据,作用是数值的相除,此外,需要注意的是,整数之间相除,一旦除数的值大于被除数时候,计算得出的结果会变成浮点数型的数据。
    • 而字符串型的数据无法运用除号进行运算。

    2.1.5 除号“%”

    • 各类型数值之间的运算
    • 1.整数型(int)与整数型(int)
    >>>a = 5
    >>>b = 2
    >>>print(a % b)
    >>> 1
    
    • 2.整数型(int)与浮点数型(float)
    >>>a = 5
    >>>b = 2.0
    >>>print(a % b)
    >>> 1.0
    
    • 3.浮点数型(float)与与浮点数型(float)
    >>>a = 5.0
    >>>b = 2.0
    >>>print(a % b)
    >>> 1.0
    
    • 4.字符串型(str)与字符串型(str)
    >>>a = '5'
    >>>b = '2'
    >>>print(a % b)
    >>>TypeError: not all arguments converted during string formatting
    
    • 5.字符串型(str)与整数型(int)
    >>>a = '5'
    >>>b = 2
    >>>print(a % b)
    >>>TypeError: not all arguments converted during string formatting
    
    • 6.字符串型(str)与与浮点数型(float)
    >>>a = '5
    >>>b = 2.0
    >>>print(a % b)
    >>>TypeError: not all arguments converted during string formatting
    
    • 通过上述例子可以看出,取余“%”可以运用于整数型与浮点数型的数据,作用是数值相除后取余。但字符串型的数值无法运用 取余“%”进行运算。

    2.1.6 幂“**”

    • 各类型数值之间的运算
    • 1.整数型(int)与整数型(int)
    >>>a = 5
    >>>b = 2
    >>>print(a ** b)
    >>> 25
    
    • 2.整数型(int)与浮点数型(float)
    >>>a = 5
    >>>b = 1.2
    >>>print(a ** b)
    >>> 6.898648307306074
    
    • 3.浮点数型(float)与与浮点数型(float)
    >>>a = 5.1
    >>>b = 1.2
    >>>print(a ** b)
    >>> 7.064545251464895
    
    • 4.字符串型(str)与字符串型(str)
    >>>a = '5'
    >>>b = '2'
    >>>print(a ** b)
    >>>TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
    
    • 5.字符串型(str)与整数型(int)
    >>>a = '5'
    >>>b = 2
    >>>print(a ** b)
    >>>TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
    
    • 6.字符串型(str)与与浮点数型(float)
    >>>a = '5'
    >>>b = 2.0
    >>>print(a ** b)
    >>>TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'float'
    
    • 通过上述例子可以看出,幂“** ”可以运用于整数型与浮点数型的数据,作用是a的b次方, 但同样的 ,字符串型的数值无法运用幂“** ”进行运算。

    2.1.7 取整“//”

    • 各类型数值之间的运算
    • 1.整数型(int)与整数型(int)
    >>>a = 5
    >>>b = 2
    >>>print(a // b)
    >>> 2
    
    • 2.整数型(int)与浮点数型(float)
    >>>a = 5
    >>>b = 2.0
    >>>print(a // b)
    >>> 2.0
    
    • 3.浮点数型(float)与与浮点数型(float)
    >>>a = 5.0
    >>>b = 2.0
    >>>print(a // b)
    >>>2.0
    
    • 4.字符串型(str)与字符串型(str)
    >>>a = '5'
    >>>b = '2'
    >>>print(a // b)
    >>>TypeError: unsupported operand type(s) for //: 'str' and 'str'
    
    • 5.字符串型(str)与整数型(int)
    >>>a = '5'
    >>>b = 2
    >>>print(a // b)
    >>>TypeError: unsupported operand type(s) for //: 'str' and 'int'
    
    • 6.字符串型(str)与与浮点数型(float)
    >>>a = '5'
    >>>b = 2.0
    >>>print(a // b)
    >>>TypeError: unsupported operand type(s) for //: 'str' and 'float'
    
    • 通过上述例子可以看出,整数型和浮点数型的数据可以通过取整“//”进行运算,得出商的整数。
    • 字符串型的数字无法通过取整“//”与其他数值进行运算。

    2.2 赋值运算符

    运算符 描述
    = 赋值运算符,不是比较运算符
    += 加法赋值运算符
    -= 减法赋值运算符
    *= 乘法赋值运算符
    /= 除法赋值运算符
    %= 取模(取余)赋值运算符
    **= 幂赋值运算符
    //= 取整数赋值运算符

    2.2.1 赋值运算符“=”

    • 虽计算机的“=”与数学上的等于符号相同,但是它们的作用却完全不同。
    • “=”在我们学习的数学是等于符号,是判断两者的值是否相同,如a=2,b=2,因此我们可以判断出a=b,,但是如果b=1的话,就不能使用“=”。
    • 但在计算机的认知中,“=”起到的是赋值的作用,就是将数值赋予变量,如a=2,b=a,b=2,在这个过程中,计算机是将2这个值赋予了a,然后又将a的值赋予了b,使得b的值也等于2。
    • 在计算机里,与数学的“=”符号相同作用的是“==”,都是起到判断两者的值是否相同。
    >>>a = 2
    >>>b = a
    >>>print(b,a)
    >>>2 2
    
    >>>a = 2
    >>>b = 1
    >>>b = a
    >>>print(b,a)
    >>>2 2
    
    >>>a = 2
    >>>b = 1
    >>>c = 2
    >>>print(a == b)
    >>>print(a == c)
    >>>False
       True
    
    • 通过上述例子可以看出:
    • 从第1、2个例子可以看出,“=”在计算机中起到的是赋值的作用,都是将值赋予变量(a,b为变量,1和2为值),在例子2中,a和b一开始的值不相同,但是通过“=”将a的值赋予b,使b的值从1变成了2。
    • 例子3中,“==”符号起到的作用类似于数学中的等于符号的作用,用于判断两变量的值是否相同。如例子所示,a和c的值都为2,b的值为1,因此通过该符号让三者之间进行比较,相同的话显示True,不同的话显示False。

    2.2.2 加法赋值运算符“+=”

    >>>a = 1
    >>>b = 2
    >>>a = a + b
    >>>print(a)
    >>> 3
    
    >>>a = 1 
    >>>b = 2 
    >>>a += b
    >>>print(a)
    >>> 3
    
    • 通过上述的例子可以看出,a += b 等效于 a = a + b ,“+=”的作用就是先将a的值与b的值相加后得出新的值,然后再将这个新值赋予变量a,a的值就由原来的2变成为了3。

    2.2.3 减法赋值运算符“-=”

    >>>a = 2
    >>>b = 1
    >>>a = a - b
    >>>print(a)
    >>> 1
    
    >>>a = 2 
    >>>b = 1 
    >>>a -= b
    >>>print(a)
    >>> 1
    
    
    • 通过上述的例子可以看出,a -= b 等效于 a = a - b ,“-=”的作用与“+=”相同,就是先将a的值与b的值相减后得出新的值,然后再将这个新值赋予变量a。

    2.2.4 乘法赋值运算符“*=”

    >>>a = 2
    >>>b = 5
    >>>a = a * b
    >>>print(a)
    >>> 10
    
    >>>a = 2 
    >>>b = 5 
    >>>a *= b
    >>>print(a)
    >>> 10
    
    • 不用多说,=”的作用于上述的运算符一样,a *= b 等效于 a = a * b

    2.2.5 除法赋值运算符“/=”

    >>>a = 10
    >>>b = 5
    >>>a = a / b
    >>>print(a)
    >>> 2
    
    >>>a = 10 
    >>>b = 5 
    >>>a /= b
    >>>print(a)
    >>> 2
    
    • a /= b 等效于 a = a /b

    2.2.6 取模(取余)法赋值运算符“%=”

    >>>a = 6
    >>>b = 5
    >>>a = a % b
    >>>print(a)
    >>> 1
    
    >>>a = 6 
    >>>b = 5 
    >>>a %= b
    >>>print(a)
    >>> 1
    
    • a %= b 等效于 a = a % b

    2.2.7 幂赋值运算符“**=”

    >>>a = 6
    >>>b = 5
    >>>a = a ** b
    >>>print(a)
    >>> 7776
    
    >>>a = 6 
    >>>b = 5 
    >>>a **= b
    >>>print(a)
    >>> 7776
    
    • a **= b 等效于 a = a ** b

    2.2.8 取整数赋值运算符“//=”

    >>>a = 6
    >>>b = 5
    >>>a = a // b
    >>>print(a)
    >>> 1
    
    >>>a = 6 
    >>>b = 5 
    >>>a //= b
    >>>print(a)
    >>> 1
    
    • a //= b 等效于 a = a // b
    • 像“+=”、“-=”、“/=”、“%=”、“//=”等赋值运算符,都是先进行“+”、“-”、“*”、“/”等算术运算符的运算,然后再得出的新值赋值于变量。
    • 赋值运算符除了可以用于数字型的数值运算外,部分赋值运算符如“+=”、“*=”可以用于字符串型的运算符的运算。
    # 加法赋值运算符“+=”
    >>> a = 'hello'
    >>> b = 'world'
    >>> a = a + b
    >>> print(a)
    >>> helloworld
    
    >>> a = 'hello'
    >>> b = 'world'
    >>> a += b
    >>> print(a)
    >>> helloworld
    
    # 加法赋值运算符“*=”
    >>> a = 'c'
    >>> b = 2 
    >>> a = a * b
    >>> print(a)
    >>> cc
    
    >>> a = 'c'
    >>> b = 2 
    >>> a *= b 
    >>> print(a)
    >>> cc
    

    2.3 比较运算符

    运算符 描述
    == 恒等,表示对象是否相同
    != 不等于
    > 大于号
    < 小于号
    >= 大于等于
    <= 小于等于

    2.3.1 等于号“==”

    >>>a = 20
    >>>b = 10
    >>>c = 20
    print(a == b)
    print(a == c)
    >>>False
       True
    
    • 在前面介绍赋值符号“=”时,有介绍过,“==”等于数学中等于号“=”一样,是判断两个变量的值是否相同,相同时返回值为True,不同是为False。

    2.3.2 不等于号“!=”

    >>>a = 20
    >>>b = 10
    >>>c = 20
    >>>print(a != b)
    print(a != c)
    >>>True
       False
    
    • 不等于号“!=”的作用跟“==”相反,是用于判断两个变量之间的值是否不同。相同是返回值为False,不同时返回值为True。

    2.3.2 大于号“>”

    >>>a = 20
    >>>b = 10
    >>>c = 20
    >>>print(a > b)
    >>>print(b > c)
    >>>True
       False
    
    • 大于号“>”的作用是比较两个变量之间的值的大小。当左边的值大于右边时返回值为True,小于时返回值为False。

    2.3.4 小于号“<”

    >>>a = 20
    >>>b = 10
    >>>c = 20
    >>>print(a < b)
    >>>print(a < c)
    >>>True
       False
    
    • 小于号“<”的作用也是比较两个变量之间的值的大小。当左边的值小于右边时返回值为True,大于时返回值为False。

    2.3.5 大于等于号“>=”

    >>>a = 20
    >>>b = 10
    >>>c = 20
    >>>print(a >= b)
    >>>print(a >= c)
    >>>print(b >= c)
    >>>True
       True
       False
    
    • 大于等于号“>=”的作用是比较两个变量之间的值的大小,但是跟“>”号有所区别,不同的是,大于等于号“>=”是当左边的值大于或者等于右边时返回值为True,否则就为False。

    2.3.5 大于等于号“<=”

    >>>a = 20
    >>>b = 10
    >>>c = 20
    >>>print(a <= b)
    >>>print(a <= c)
    >>>print(b <= c)
    >>>False
       True
       True
    
    • 小于等于号“<=”的作用与上述比较运算符相同,当左边的值小于或者等于右边时返回值为True,否则就为False。

    - 注: 比较运算符的结果全部都是布尔值

    2.3.6 字符串能够用比较运算符进行运算?

    • 之前的例子都是数字型数据之间的比较,那字符串类型的数值能否使用 比较运算符进行比较?
    >>>a = '1'
    >>>b = '2'
    >>>print(a,b)
    >>>print(a > b)
    >>>print(a < b)
    >>>1 2
       False
       True
    
    • 从上面的例子看出,虽然a和b的值分别为1 和2,但是它们都是属于字符串类型,而不是整数型,因此它们不能向数字型数据一样通过看表面值的大小来进行比较。
    • 但是每一个字符串都对应了一个值,我们可以通过ord( )函数找出它对应的值。
    >>>a = '1'
    >>>b = '2'
    >>>print(ord(a))
    >>>print(ord(b))
    >>>49
       50
    
    >>>a = 'x'
    >>>b = 'y'
    >>>print(ord(a))
    >>>print(ord(b))
    >>>120
       121
     
    
    • 通过上面可以看出每个字符串都有其对应的数值,不能像数字型的数据那样直接通过值来判断。需要通过ord()函数来判断他们值的大小,因此比较运算符不单单适用于数字型的数据,也可用于字符串型的数据。

    2.4 身份运算符

    运算符 描述
    is is表示是否为引用同一个对象(同一个id)
    is not i表示是否不为引用同一个对象

    2.4.1 “is”

    >>>a = [1,2,3]
    >>>b = [1,2,3]
    >>>print(a is b)
    >>>print(a == b)
    >>>print(id(a))
    >>>print(id(b))
    >>>False
       True
       1942942238984
       1942942239048
    
    • 通过上述例子可以看出,is 不同于 “==”,“前者比较的是两个变量是否引用同一个对象,即⽐较两个对象是否是同⼀个对象,而后者比较的是两个变量的值是否相同。

    2.4.2 “is not”

    >>>a = [1,2,3]
    >>>b = [1,2,3]
    >>>print(a is not b)
    >>>print(id(a))
    >>>print(id(b))
    >>>True
       2684160821512
       2684160821576
    
    • is not 的作用与is相反, ⽐较两个对象是否不是同⼀个对象,即id不相同。

    - 注:身份运算符的结果全为布尔值。

    2.5 逻辑运算符

    运算符 描述
    and 同真则真:and两边同时为真结果就为真
    or 一真则真:or两边有一个为真的结果为真
    not 不真则假:不假则真

    2.5.1 逻辑与“and”

    1. 布尔值的与运算
    >>>a = 3 > 4 and 1 < 2 #假与真
    >>>b = 5 < 6 and 8 > 9 #真与真
    >>>c = 3 > 5 and 6 > 9 #假与假
    >>>d = 8 > 1 and 9 < 1 #真与假
    >>>print(a)
    >>>print(b)
    >>>False
       True
       False
       False
    
    • 通过以上例子可以得出, and可以对符号两侧的值进⾏与运算。 只有在符号两侧的值都为True时,才 会返回True,只要有⼀个False就返回False。
    1. 非布尔值的与运算
    >>>a = 0 and 1
    >>>b = 1 and 0
    >>>c = '' and 1
    >>>d = 'hello' and 1
    >>>e = 'hello' and []
    >>>f = 1 and {}
    >>>print('a=',a)
    >>>print('b=',b)
    >>>print('c=',c)
    >>>print('d=',d)
    >>>print('e=',e)
    >>>print('f=',f)
    >>>a= 0
    >>>b= 0
    >>>c=
    >>>d= 1
    >>>e= []
    >>>f= {}
    
    • 通过上述例子可以看出,进行非布尔值的与运算的要求:
    • 1.在对非布尔值进行与运算时,Python会将其当做布尔值运算,最终会返回原值。像例子中的空格,0,{}、[]等代表空性的值都是属于False,其他为True。
    • 与运算是找False的,如果第⼀个值是False,则不看第⼆个值,直接返回第一个值。如果第一个值是True,第二个值为False时,则返回第二个值。当两个值都为True,则直接返回第二个值。

    2.5.1 逻辑或“or”

    1. 布尔值的或运算
    >>>a = 3 > 4 or 1 < 2 #假或真
    >>>b = 5 < 6 or 8 > 9 #真或真
    >>>c = 3 > 5 or 6 > 9 #假或假
    >>>d = 8 > 1 or 9 < 1 #真或假
    >>>print(a)
    >>>print(b)
    >>>print(c)
    >>>print(d)
    >>>True
       True
       False
       True
    
    • 通过上述例子可以看出,或运算两个值中只要有⼀个True,就会返回True
    1. 非布尔值的与运算
    >>>a = 0 or 1
    >>>b = 1 or 0
    >>>c = '' or 1
    >>>d = 'hello' or 1
    >>>e = 'hello' or []
    >>>f = 1 or {}
    >>>g = 0 or []
    >>>print('a=',a)
    >>>print('b=',b)
    >>>print('c=',c)
    >>>print('d=',d)
    >>>print('e=',e)
    >>>print('f=',f)
    >>>print('g=',g)
    >>>a= 1
    >>>b= 1
    >>>c= 1
    >>>d= hello
    >>>e= hello
    >>>f= 1
    >>>g= []
    
    • 通过上述例子可以看出,非布尔值的或运算要求:
    • 1.或运算是找True的,如果第⼀个值是True,则不看第⼆个值,直接返回第二个值。
    • 2.当第一个值为False而第二个值为Ture时,则返回第二个值;
    • 3.当两个值都为False时,则返回第二个值;

    2.5.2 逻辑非“not”

    • not可以对符号右侧的值进⾏⾮运算对于布尔值,⾮运算会对其进⾏取反操 作,True变False,False变True
    1. 布尔值的逻辑非运算:
    >>>a =  True
    >>>b =  not a 
    >>>print(a,b)
    >>>True False
    
    >>>a = 3>4
    >>>b = not a 
    >>>print(a,b)
    >>>False True
    
    >>>a = 5<6
    >>>b = not a 
    >>>print(a,b)
    >>>True False
    
    • 通过上述例子可以看出,通过逻辑非“not”的运算,可将True变False,False变True。
    1. 非布尔值的逻辑非运算:
    >>>a = 'hello'
    >>>b = not a 
    >>>print(b)
    >>>False
    
    >>>a = 1
    >>>b = not a 
    >>>print(b)
    >>>False
    
    >>>a = []
    >>>b = not a 
    >>>print(b)
    >>>True
    
    • 通过上述例子,非布尔值的逻辑非运算时候,先将非布尔值转换为布尔值,然后在进行逻辑非的运算,最后输出的结果即为布尔值(True或False)。
    • 无论是布尔值还是非布尔值,通过逻辑非的运算输出的结果都为布尔值(True或False)。

    2.6 运算符的优先级

    • 各种类型的运算符之间存在着优先级。
    运算符等级 描述
    **
    +,- 正负号
    * ,/ ,%, // 乘、除、取模、取整
    >,>=,<, <=, !=, == 比较运算符
    =, +=, -=, *=, /=,%= ,**=, //= 赋值运算符
    and, or , not 逻辑运算符
    • 优先级高的先执行,低的后执行
    • 相同优先级,从左到右执行
    • 四则运算:先乘除后加减,有括号先算括号里面的
    >>>a = (1<5) or (1==3)
    >>>b = 3 + 2 * (3==5)/2
    >>>c = (1 + 2) * (3 == 4/5)
    >>>d = (True == 1)*(3 == 4/5)
    >>>print(a)
    >>>print(b)
    >>>print(c)
    >>>print(d)
    >>>True
    >>>3.0
    >>>0
    >>>0
    

    2.7 条件运算符(三元运算符)

    • 条件运算符在执⾏时,会先对条件表达式进⾏求值判断 如果判断结果为True,则执⾏语句1,并返回执⾏结果 如果判断结果为False,则执⾏语句2,并返回执⾏结果。
    • 语法: 语句1 if 条件表达式 else 语句2
    >>>a = 1
    >>>b = 2
    >>>c = a if a > b else b
    >>>print(c)
    >>>2
    
    • 通过上述例子得知,语句1为a,语句2为b,a>b为条件表达式,当满足表示式的条件是则执行语句1,否则就执行语句2.
    展开全文
  • 成员运算符Python里有成员运算符,可以判断一个元素是否在某一个序列中。比如可以判断一个字符是否属于这个...看个代码实例吧:身份运算符Python支持对象本身的比较比较的语法是:obj1is[not]obj2身份运算符是用...

    成员运算符

    Python里有成员运算符,可以判断一个元素是否在某一个序列中。比如可以判断一个字符是否属于这个字符串,可以判断某个对象是否在这个列表中等等。

    Python中的成员操作符的使用语法是:obj [not] in sequence

    这个操作符返回值是True或者False。

    看个代码实例吧:

    989d01ec3ae260a4a56663d513fd40b8.png

    身份运算符

    Python支持对象本身的比较,比较的语法是:obj1 is [not]  obj2

    身份运算符是用来比较2个对象是否是同一个对象,而之前比较运算符中的 == 则是用来比较2个对象的值是否相等。

    这里需要讲下身份运算符是怎么判断的。

    Python中的变量有3个属性:name、id、value。

    name可以理解为变量名,id可以联合内存地址来理解,value就是变量的值。is运算符则是通过这个id来进行判断的,id一样就返回true,否则返回false。

    比如:a = [1, 2, 3]

    b = [1, 2, 3]

    print( a == b )

    print( a is b )

    这段代码输出的结果是true和false,因为变量a和变量b的value是一样的,所以用==运算符比较的变量的value,所以返回true。但是用is的时候,比较的是id,a和b的id不一样(可以使用id(a)来查看a的id),所以返回false。

    但是并不是所有的情况都是这样的,对于小的整数,Python缓存了-5到257之间的所有整数,共262个。所以下面的代码:a = 100b = 100print( a is b )

    c = 500d = 500print( c is d )

    返回结果一个是true,一个是false,false的情况和上面一样,true的结果是因为Python对小的整数做了处理,还有字符串的情况也是一样的,使用is都会返回相等。

    更多学习内容,就在码芽网http://www.mayacoder.com/lesson/index

    850cd9b62761a0e15b09bd0698589dea.png

    展开全文
  • 变量:变量是内存中装载数据小盒,你只能用它来存数据和取数据计算机存储单元:硬盘属于永久存储,内存属于临时存储1.定义出所有数据类型变量/* 定义Java中变量 定义出所有数据类型变量 四类八种 */ ...
  • 移位运算符和按位运算符一样,同属于位运算符,因此移位运算符的位指的也是二进制位。它包括以下几种:1. 左移位(&lt;&lt;):将操作符左侧的操作数向左移动操作符右侧指定的位数。移动的规则是在二进制的...
  • R语言一些比较神奇的运算符

    千次阅读 2018-08-05 22:26:10
    取余、相除、相除求商(相除可以看做是C语言里面浮点数相除,相除求商可以看做是C语言里面整数相除) ... %in%用来标识一个元素是否位于某个向量之中,或者说,是否属于某个集合。但它不能判断一个集...
  • javascript中有一个叫恒等运算符,那么这个运算符是什么意思呢?...由此可以看出,如果同样一个值,属于同一属于不同类型时使用恒等和等于结果是完全不同下面有一段代码能很好反应这个现象: ...
  • java三元运算符

    2017-05-13 16:50:00
    但它确实属于运算符的一种,因为它最终也会生成一个值。这与本章后一节要讲述的普通if-else语句是不同的。表达式采取下述形式: 布尔表达式 ? 值0:值1 若“布尔表达式”的结果为true,就计算“值0”,而且它的结果...
  • 运算符是可以操纵操作数值结构。如下一个表达式:10 + 20 = 30。这里,10和20称为操作数,+则被称为运算符运算符类型Python语言支持以下类型的运算符 -1.算术运算符2.比较(关系)运算符3.赋值运算符4.逻辑运算符5...
  • Java三元运算符与if...else...的比较

    千次阅读 2012-10-31 16:58:30
    但它确实属于运算符的一种,因为它最终也会生成一个值。这与本章后一节要讲述的普通if-else语句是不同的。表达式采取下述形式:  布尔表达式 ? 值0:值1  若“布尔表达式”的结果为true,就计算“值0”,而且它的...
  • C++运算符重载

    2015-10-30 00:11:30
    这个比较简单,运算符左侧对象表示调用对象,运算符右侧对象是作为参数对象。 例如myComplex c; c*3.2表示c.operator*(3.2)二、非成员运算符重载函数 同上例,如果遇到输入3.2*c时候,由于3.2属于double...
  • C++规定有四个运算符 =, -&...不能重载为类静态成员应该比较容易理解,因为静态成员函数是属于整个类,不是属于某个对象,它只能去操作类静态数据成员。而赋值运算符“=”是基于对象操作。...
  • 如果要进行赋值操作,则需要运算符,在java当中,运算符一共分为5类:算术运算符、比较运算符、赋值运算符、条件运算符、逻辑运算符。 0.1算术运算符 算术运算符如下图: 算术运算符一共有7种,知识范围属于...
  • python 运算符(上)

    2020-04-23 09:56:35
    python中运算符包括算术运算符、赋值运算符、复合赋值运算符、比较运算符、逻辑运算符、成员运算符,在本博客中介绍前三种,下一篇博客将介绍后三种。 1、算术运算符 算术运算符主要是指用于数值之间计算,如...
  • 不能重载为类静态成员应该比较容易理解,因为静态成员函数是属于整个类,不是属于某个对象,它只能去操作类静态数据成员。而赋值运算符“=”是基于对象操作。那么为什么赋值运算符不可以重载为类友元函数...
  • 比较运算符(关系运算符) 逻辑运算符 条件运算符(三元运算符) 算术运算符 + 加法运算符(如果是两个字符串之间进行加法运算,则会进行拼串操作) - 减法运算符 * 乘法运算符(如果将字符串和数字相乘...
  • 因此,此运算符可以用于可以确定对象是否属于一个特定类。 注意: 1.instanceof左边显式声明类型与右边操作元必须是同种类或存在继承关系,也就是说需要位于同一个继承树,否则会编译错误。 2.左边对象实例不...
  • C++中友元函数不能重载四个运算符 C++规定有四个运算符 =, ->...不能重载为类静态成员应该比较容易理解,因为静态成员函数是属于整个类,不是属于某个对象,它只能去操作类静态数据成员。而...
  • 隐式转换属于类型转换一部分,类型转换是一个简单而又繁杂话题。这篇文章旨在理清楚其中一个相关操作 相等运算符。 相等运算其中包括抽象相等(==)和严格相等(===),它们之间区别仅在与,严格相等会直接...
  • 为了书写方便,es6中提出了很多比较友好书写方式,其中最为常见的属于以下几个: 字符串模板 `abcdef${test}` 解构赋值 let [a, b, c] = [1, 2, 3] 扩展运算符 rest参数 … 本文希望能够学习其中主要用法...
  • 每种语言都有其特定的运算符,大多是属于想通,部分是特有。本次参考网上资料,按自己理解整理一番。 Python有以下几种运算符: 算术运算符 比较(关系)运算符 赋值运算符 逻辑运算符运算符 成员...
  • 运算符和表达式

    2013-11-24 14:55:00
    关于这一章节东西,也是学编程一个很基础东西,每个语言也都会有,这里记录一些比较重要知识点,好了进入正题: 运算符可以有如下几种分法: 下面对其一一进行学习: 算术运算符: ①++和--运算符前置...
  • 接上篇:java学习——6运算符与表达式(一)(2)关系运算符关系运算,即为比较大小运算。有:>(大于)、=(大于等于)、 <=(小于等于)!=(不等于)。关系运算都属于双目运算,即需要两个操作数。关系运算结果为...
  • 比较运算符>赋值运算符>逻辑运算符 在 Python 中,字符串属于不可变对象,不支持原地修改,如果需要修改其中值,智能创建新字符串对象。但是,经常我们确实需要原地修改字符串,可以使用 io.StringIO对象...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 231
精华内容 92
关键字:

属于比较运算符的是