对于想了解C#null结合运算符的读者，本文将是一篇不可错过的文章，我们将详细介绍??，并且为您提供关于24.Python比较运算符（关系运算符、7大运算符：（算数运算符，比较运算符，赋值运算符，成员
对于想了解C# null结合运算符的读者，本文将是一篇不可错过的文章，我们将详细介绍??，并且为您提供关于24.Python比较运算符（关系运算符、7大运算符：（算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符）与其优先级关系、Android数据绑定空结合运算符、C++中类中范围解析运算符：：和点运算符（.）的有价值信息。
本文目录一览：- C# null结合运算符（??）（c#null值处理）
- 24.Python比较运算符（关系运算符
- 7大运算符：（算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符）与其优先级关系
- Android数据绑定空结合运算符
- C++中类中范围解析运算符：：和点运算符（.）
C# null结合运算符（??）（c#null值处理）
using System;
namespace CalculatorApplication {
class NullablesAtShow {
static void Main(string[] args) {
double? num1 = null;
double? num2 = 3.14157;
double num3;
num3 = num1 ?? 5.34;
Console.WriteLine( Value of num3: {0}, num3);
num3 = num2 ?? 5.34;
Console.WriteLine( Value of num3: {0}, num3);
Console.ReadLine();
}
}
}
24.Python比较运算符（关系运算符
比较运算符，也成关系运算符，用于对常量、变量或表达式的结果进行大小、真假等比较，如果比较结果为真，则返回 True；反之，则返回 False。
Python 支持的比较运算符如表 1 所示。
| 比较运算符 | 功能 |
|---|---|
| > | 大于，如果运算符前面的值大于后面的值，则返回 True；否则返回 False |
| >= | 大于或等于，如果运算符前面的值大于或等于后面的值，则返回 True；否则返回 False |
| < | 小于，如果运算符前面的值小于后面的值，则返回 True；否则返回 False |
| <= | 小于或等于，如果运算符前面的值小于或等于后面的值，则返回 True；否则返回 False |
| == | 等于，如果运算符前面的值等于后面的值，则返回 True；否则返回 False |
| != | 不等于，如果运算符前面的值不等于后面的值，则返回 True；否则返回 False |
| is | 判断两个变量所引用的对象是否相同，如果相同则返回 True |
| is not | 判断两个变量所引用的对象是否不相同，如果不相同则返回 True |
下面程序示范了比较运算符的基本用法：
>>> print("5是否大于 4：", 5 > 4)
5是否大于 4： True
>>> print("3的4次方是否大于等于90.0：", 3 ** 4 >= 90)
3的4次方是否大于等于90.0： False
>>> print("20是否大于等于20.0：", 20 >= 20.0)
20是否大于等于20.0： True
>>> print("5和5.0是否相等：", 5 == 5.0)
5和5.0是否相等： True
>>> print("True和False是否相等：", True == False)
True和False是否相等： False
>>>
比较运算符 == 和 is 的区别
初学 Python，大家可能对 is 比较陌生，很多人会误将它和 == 的功能混为一谈，但其实 is 与 == 有本质上的区别，完全不是一码事儿。
== 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象，例如：
- import time
- # 获取当前时间
- a = time.gmtime()
- b = time.gmtime()
- print(a == b) # a和b两个时间相等，输出True
- print(a is b) # a和b不是同一个对象，输出False
上面代码中 a、b 两个变量都代表当前系统时间，因此 a、b 两个变量的时间值是相等的（代码运行速度很快，能保证是同一时间），故程序使用“==”判断返回 True。但由于 a、b 两个变量分别引用不同的对象（每次调用 gmtime() 函数都返回不同的对象），因此a is b返回 False。
那么，如何判断两个变量是否属于一个对象呢？Python 提供了一个全局的 id() 函数，它可以用来判断变量所引用的对象的内存地址（相当于对象在计算机内存中存储位置的门牌号），如果两个对象所在的内存地址相同（相当于它们住在同一个房间内，计算机同一块内存在任一时刻只能存放一个对象），则说明这两个对象其实是同一个对象。
由此可见，is 判断其实就是要求通过 id() 函数计算两个对象时返回相同的地址。例如，使用 id() 函数判断上面的 a、b 两个变量：
print(id(a))
print(id(b))
从运行结果中将会看到 a、b 两个变量所引用的对象的内存地址是不同的，这样通过 is 来判断 a、b 两个变量自然也就输出 False 了。
再举一个例子：
>>> a = ''cheesezh''
>>> b = ''cheesezh''
>>> id(a)
2680257978480
>>> id(b)
2680257978480
>>> a is b
True
7大运算符：（算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符）与其优先级关系
一，运算符(7种算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符)
优先级：
(1) 个别运算符:
优先级最高 ** 幂运算
优先级最低 = 赋值运算符
() 括号可以提升运算优先级
(2) 整体 一元运算符 > 二元运算符
一元运算符: 同一时间,只操作一个值 - ~
二元运算符: 同一时间,操作两个值 + - * / ...
(3) 同一层级
逻辑: () > not > and > or
算数: 乘除 > 加减
位运算符: ( << >> ) > & > ^ > |
(4) 其他运算符
算数运算符 > 位运算符 > 比较运算符 > 身份运算符> 成员运算符 > 逻辑运算符
赋值运算符是最后算完进行赋值,做收尾工作的.
"""
res = 5+5 << 6//3 is 40 and True
print(res)
"""
res = 10 << 2 is 40 and True
res = 40 is 40 and True
res = True and True
res = True
"""
# 加上括号包起来,让别人能看懂代码;
res = (5+5) << (6//3) is 40 and True
（1）算术运算符 + - * / // % **
var2 = 4
# +
res = var1 + var2
print(res)
# -
res = var1 - var2
print(res)
# *
res = var1 * var2
print(res)
# / 除法 (结果为小数)
res = var1 / var2
res = 10 / 5
print(res)
# // 地板除 (返回整数)
res = 10 // 5
res = 11 // 4
print(res)
# 如果被除数或者除数是一个小数,结果加上.0
res = 11.0 // 4
print(res)
# % 取余
res = 11 % 4
res = -11 % 4 # -3 + 4 = 1
res = 11 % -4 # 3 + (-4) = -1
res = -11 % -4 # -3(如果被除数和除数都是负数,在正常得到的结果前面填上负号即可.)
print(res)
res = -17 % 7 # -3 + 7 = 4
res = 17 % -7 # 3 + (-7) = -4
res = -17 % -7 #-3
print(res)
# ** 幂运算
res = 3 ** 2
res = 3 ** 4
print(res)
（2）比较运算符> < >= <= == !=
比较运算符只会差生两种结果: True 真的 ,False 假的
var1 = 100
var2 = 100
res = var1 > var2
res = var1 < var2
res = var1 >= var2
res = var1 <= var2
print(res)
# 注意点
res = var1 == var2
print(res)
（3）赋值运算符
= += -= *= /= //= %= **=
# = 从右向左,将右侧的值赋值给左侧变量
var1 = 9
var2 = 2
# +=
"""var1 = var1 + var2"""
# var1 += var2
# print(var1)
# -=
"""var1 = var1 - var2"""
# var1 -= var2
# print(var1)
# *=
"""var1 = var1 * var2"""
# var1 *= var2
# print(var1)
# /=
"""var1 = var1 / var2"""
# var1 /= var2
# print(var1)
# //=
"""var1 = var1 // var2"""
# var1 //= var2
# print(var1)
# %=
"""var1 = var1 % var2"""
# var1 %= var2
# print(var1)
# **=
"""var1 = var1 ** var2"""
var1 **= var2
print(var1)
(4)成员运算符：in 和 not in （针对于容器类型数据）
strvar = "雷霆嘎巴,无情哈拉少"
res = "雷" in strvar
res = "文" not in strvar
res = "无情" in strvar
res = "霆哈少" in strvar
res = '','' not in strvar
print(res)
# list tuple set
lst = ["余锐","高学峰","治理追","温子月","草神光"]
res = "高学峰" in lst
print(res)
tup = ("余锐","高学峰","治理追","温子月","草神光")
res = "李博伦" not in tup
print(res)
setvar = {"金角大王","银角大王","神秘男孩"}
res = "神秘男孩" in setvar
print(res)
# dict
""" in 和 not in 在字典中只判断键,不判断值 """
dic = {"yr":"英俊帅气","bx":"抠脚大汉","mcp":"高大威猛"}
res = "英俊帅气" in dic # False
res = "yr" in dic
res = "mcp" not in dic
print(res)
(5)身份运算符： is和 is not（检测两个数据在内存当中是否是同一个值）
""" 字符串必须是一个连续的片段 """
strvar = "雷霆嘎巴,无情哈拉少"
res = "雷" in strvar
res = "文" not in strvar
res = "无情" in strvar
res = "霆哈少" in strvar
res = '','' not in strvar
print(res)
# list tuple set
lst = ["余锐","高学峰","治理追","温子月","草神光"]
res = "高学峰" in lst
print(res)
tup = ("余锐","高学峰","治理追","温子月","草神光")
res = "李博伦" not in tup
print(res)
setvar = {"金角大王","银角大王","神秘男孩"}
res = "神秘男孩" in setvar
print(res)
# dict
""" in 和 not in 在字典中只判断键,不判断值 """
dic = {"yr":"英俊帅气","bx":"抠脚大汉","mcp":"高大威猛"}
res = "英俊帅气" in dic # False
res = "yr" in dic
res = "mcp" not in dic
print(res)
(6)逻辑运算符: and or not
# and 逻辑与
"""全真则真,一假则假"""
res = True and True # True
res = True and False # False
res = False and True # False
res = False and False # False
print(res)
# or 逻辑或
"""全假则假,一真则真"""
res = True or True # True
res = True or False # True
res = False or True # True
res = False or False # False
print(res)
# not 逻辑非
"""真变假,假变真"""
res = not True
res = not False
print(res)
# 逻辑短路: 如果出现了短路效果,后面的代码不执行
"""
短路:
(1) True or 表达式
(2) False and 表达式
"""
"""
True or print("紫月真胖呀")
True or True => True
True or False => True
False and print("紫月真猛呀")
False and False => False
False and True => False
"""
"""
bool 类型为假的十种情况
0 0.0 0j False '''' [] () {} set() None
先用大脑算一下布尔值真假,是否出现短路情况
如果出现了直接返回当前值,没出现,继续向右执行;
"""
res = 5 or 6
res = 0 or 6
res = 0 and 9
print(res)
逻辑运算符的优先级
() > not > and > or
eg:
res = 5 or 6 and 7 # 5 or 7 => 5
res = (5 or 6) and 7 # 5 and 7 => 7
res = not(5 or 6) and 7 # not 5 and 7 => False and 7 =>False
print(res)
res = 1>2 or 3<4 and 5>10 or 11<12 and 13>15 or 100<1000 and 1<2
# res = False or True and False or True and False or True and True
# res = False or False or False or True
# res = False or False or True
# res = False or True
# res = True
print(res)
(7)位运算符 & | ^ << >> ~
# 按位与 &
var1 = 19
var2 = 15
print(var1 & var2)
"""
19的二进制
0000 ... 10011
15的二进制
0000 ... 01111
0000 ... 10011
0000 ... 01111
0000 ... 00011 => 3
"""
# 按位或 |
var1 = 19
var2 = 15
print(var1 | var2)
"""
19的二进制
0000 ... 10011
15的二进制
0000 ... 01111
0000 ... 10011
0000 ... 01111
0000 ... 11111 => 31
"""
# 按位异或 ^ 两个值不一样,返回真,否则返回假
"""
1 0 => 1
1 1 => 0
0 0 => 0
0 1 => 1
"""
var1 = 19
var2 = 15
print(var1 ^ var2)
"""
19的二进制
0000 ... 10011
15的二进制
0000 ... 01111
0000 ... 10011
0000 ... 01111
0000 ... 11100 => 28
"""
# << 左移
""" 左移相当于做乘法 : 5 * 2的n次幂 """
res = 5 << 1 # 10
res = 5 << 2 # 20
res = 5 << 3 # 40
print(res)
"""
0000 ... 101
0000 ... 1010 移动一位 10
0000 10100 移动二位 20
"""
# >> 右移
""" 右移相当于做除法 : 5 // 2的n次幂 """
res = 5 >> 1 # 2
res = 5 >> 2 # 1
res = 5 >> 3 # 0
print(res)
"""
0000 ... 101
0000 ... 010 移动一位 2
0000 ... 001 移动二位 1
0000 ... 000 移动三位 0
"""
# ~ 按位非 (针对于补码进行操作,按位取反,包括符号位)
"""公式: -(n+1)"""
var1 = ~19
print(var1)
"""
~ 按位非每一位都取反,包括符号位,求反码每一位除了符号位,都取反.
原码:0000 ... 10011
反码:0000 ... 10011
补码:0000 ... 10011
补码: 0000 ... 10011
按位非: 1111 ... 01100
给你补码求原码:
补码: 1111 ... 01100
反码: 1000 ... 10011
原码: 1000 ... 10100 => -20
"""
var1 = ~(-22)
print(var1)
"""
原码: 1000 ... 10011
反码: 1111 ... 01100
补码: 1111 ... 01101
补码: 1111 ... 01101
按位非: 0000 ... 10010
给你补码求原码:
正数 : 补码 = 反码 = 原码
原码: 0000 ... 10010 => 18
"""
Android数据绑定空结合运算符
XML
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
<data>
<import type="android.view.View" />
<variable
name="dataModel"
type="com.my.app.MyDataModel" />
</data>
<TextView
android:id="@id/mCompoundDrawable"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:drawableRight="@{(dataModel.isSelected ? @drawable/selected : @drawable/not_selected) ?? @drawable/not_specified }"
android:focusable="true"
android:gravity="center_vertical"
android:scrollHorizontally="false"
android:text="@{dataModel.text}" />
</layout>
数据模型
public class MyDataModel
{
public String text;
public Boolean isSelected;
public MyDataModel(String text,Boolean isSelected)
{
this.text = text;
this.isSelected = isSelected;
}
}
我通过调用来调用它：
MyDataModel dataModel = new MyDataModel(text,null);
binding.setDataModel(dataModel);
我以为
android:drawableRight="@{(dataModel.isSelected ? @drawable/selected : @drawable/not_selected) ?? @drawable/not_specified }
实际上与以下内容相同：
android:drawableRight="@{dataModel.isSelected != null? (dataModel.isSelected ? @drawable/selected : @drawable/not_selected) : @drawable/not_specified }
但是,我在运行时遇到以下异常：
java.lang.NullPointerException：尝试在空对象引用上调用虚方法’boolean java.lang.Boolean.booleanValue()’
我想知道如何克服这个错误.谢谢！
解决方法
是不一样的
(2)dataModel.isSelected！= null？ (dataModel.isSelected？@ drawable / selected：@ drawable / not_selected)：@ drawable / not_specified
在第一个表达式中,您得到错误,因为运算符？：在空指针上隐式调用dataModel.isSelected.booleanValue().
无论如何,我相信在这种情况下你无法使用空合并运算符,所以我只想使用第二个表达式.
C++中类中范围解析运算符：：和点运算符（.）
C++ 类成员函数
类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。
让我们看看定义的类 Box，现在我们要使用成员函数来访问类的成员，而不是直接访问这些类的成员：
成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。
所以您可以按照如下方式定义 Volume() 函数：
您也可以在类的外部使用范围解析运算符 :: 定义该函数，如下所示：
在这里，需要强调一点，在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据，如下所示：
今天关于C# null结合运算符和??的介绍到此结束，谢谢您的阅读，有关24.Python比较运算符（关系运算符、7大运算符：（算数运算符，比较运算符，赋值运算符，成员运算符，身份运算符，逻辑运算符，位运算符）与其优先级关系、Android数据绑定空结合运算符、C++中类中范围解析运算符：：和点运算符（.）等更多相关知识的信息可以在本站进行查询。
本文标签：
