Gazebo学习笔记（2）--传感器和执行器的使用

运算符

运算符介绍

1. 运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

2. 算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符 [需要二进制基础]。

算术运算符

基本介绍

• 算符运算符是对数值类型的变量进行运算的，在程序中使用的非常多。

算术运算符一览

使用细节

1. 对于除号 /，返回结果是小数。
2. 对于取整除 //，返回商的整数部分（并且是向下取整）。
3. 当对一个数取模时，对应的运算公式：a % b = a - a // b * b。

# 演示算术运算符的使用
# /, //, %, **
# 对于除号 /，返回结果是小数
print(10 / 3)

# 对于取整数 //，返回商的整数部分（并且是向下取整）
print(10 // 3)
print(-10 // 3)

# 当对一个数取模时，对应的运算公式： a % b = a - a // b * b
print(10 % 3)
# 分析：-10 - (-10) // 3 * 3 = -10 - (-4) * 3 = -10 - (-12) = 2
print(-10 % 3)
# 分析： 10 - 10 // (-3) * (-3) = 10 - (-4) * (-3) = 10 - 12 = -2
print(10 % -3)
# 分析： -10 - (-10) // (-3) * (-3) = -10 - 3 * (-3)= -10 + 9 = -1
print(-10 % -3)

print(2 ** 5)

# 练习
# 假如还有97天放假，问：合xx个星期 零xx天
days = 97
week = days // 7
left_day = days % 7
print(f"假如还有{days}天放假，则：合{week}个星期 零{left_day}天")

# 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100)，请求出华氏温度对应的摄氏温度
hua_shi = 234.5
she_shi = 5 / 9 * (hua_shi - 100)
print(f"华氏温度 {hua_shi} 对应的摄氏温度 {she_shi}")
print("华氏温度 %.2f 对应的摄氏温度 %.2f" % (hua_shi, she_shi))

比较运算符

基本介绍

1. 比较运算符的结果要么是 True，要么是 False。
2. 比较表达式 经常用在 if 结构的条件，为 True 就执行相应的语句，为 False 就不执行。

n1 = 1
if n1 > -10:
    print("hi...")

比较运算符一览

使用细节

1. 比较运算符组成的表达式，我们称为比较表达式，比如：a > b。
2. 比较运算符 == 不能误写成 = 。

# 比较运算符的使用
a = 9
b = 8
print(a > b)
print(a >= b)
print(a <= b)
print(a < b)
print(a == b)
print(a != b)
flag = a > b
print("flag =", flag)
print(a is b)
print(a is not b)

str1 = "abc#"
str2 = "abc#"
print(str1 == str2)
print(str1 is str2)  # 交互模式下为False

逻辑/布尔运算符

基本介绍

• 逻辑运算也被称为布尔运算。

逻辑/布尔运算符一览

• 以下假设变量 a = 10，b = 20。

a = 10
b = 20

print(a and b)
print(a or b)
print(not (a and b))

使用细节

1. and 是“短路运算符”，只有当第一个为 True 时，才去验证第二个。
2. or 是“短路运算符”，只有当第一个为 False 时才去验证第二个（换言之，如果第一个为 True，就直接返回第一个的值）。

# and 使用细节
score = 70
if (score >= 60 and score <= 80):
    print("成绩还不错~")

a = 1
b = 99
print(a and b)
print((a > b) and b)
print((a < b) and b)

# or 使用细节
score = 70
if score <= 60 or score >= 80:
    print("hi~")

a = 1
b = 99
print(a or b)
print((a > b) or b)
print((a < b) or b)

# not 使用细节
a = 3
b = not (a > 3)
print(b)
print(not False)
print(not True)
print(not 0)
print(not "jack")
print(not 1.88)
print(not a)

赋值运算符

基本介绍

• 赋值运算符就是将某个运算后的值，赋给指定的变量。

赋值运算符一览

使用细节

1. 运算顺序从右往左，num = a + b +c
2. 赋值运算符的左边是变量，右边可以是变量、表达式、字面量。
   • 如：num1 = 20、num2 = 78 * 34 - 10、num3 = a、num4 = a * b。

# 赋值运算符
num1 = 10
i = 100
i += 100  # => i = i + 100
print("i =", i)
i -= 100  # => i = i - 100
print("i =", i)
i *= 3  # i = i * 3
print("i =", i)

# 有两个变量，a 和 b，要求将其进行交换，最终打印结果
# 方法1
a = 30
b = 40
print(f"没有交换前 a={a} b={b}")
temp = a
a = b
b = temp
print(f"交换后 a={a} b={b}")

# 方法2
a = 30
b = 40
print(f"没有交换前 a={a} b={b}")
a, b = b, a
print(f"交换后 a={a} b={b}")

# 方法3
a = 30
b = 40
print(f"没有交换前 a={a} b={b}")
a = a + b
b = a - b
a = a - b
print(f"交换后 a={a} b={b}")

三元运算符

基本语法

1. Python 是一种极简主义的编程语言，它没有引入 ?: 这个运算符，而是使用 if else 关键字来实现相同的功能。
2. 语法： max = a if a > b else b。
   • 如果 a > b 成立，就把 a 作为整个表达式的值，并赋给变量 max。
   • 如果 a > b 不成立，就把 b 作为整个表达式的值，并赋给变量 max。

代码演示

# 三元运算符
# 获取两个数的最大值
a = 10
b = 80
max = a if a > b else b
print(f"max={max}")

# 获取三个数的最大值
a = 10
b = 30
c = 20
max1 = a if a > b else b
max2 = max1 if max1 > c else c
print(f"max2={max2}")

# 可以支持嵌套使用，但是可读性差，不推荐
max = (a if a > b else b) if (a if a > b else b) > c else c
print(f"max={max}")

运算符优先级

基本语法

• 运算符有不同的优先级，所谓优先级就是表达式的运算顺序。

标识符的命名规则和规范

标识符概念

1. Python 对各种变量、函数、和类等命名时使用的字符序列称为标识符。
2. 凡是自己可以起名字的地方都叫标识符，num1 = 90。

# 代码演示
def sum(seq):
    total = 0
    for x in seq:
        if x is not None:
            total += x
    return total

标识符的命名规则

1. 由 26 个英文字母大小写，0-9，_组成。
2. 数字不可以开头。
3. 不可以使用关键字，但能包含关键字。
4. Python 区分大小写。
5. 标识符不能包含空格。

# 1. 由26个英文字母大小写，0-9，_组成。
num9_N = 100
# 2. 数字不可以开头。
# 1num = 100
# 3. 不可以使用关键字，但能包含关键字。
# if = 100
my_if = 100
# 4. Python区分大小写。
n = 100
N = 200
print("n =", n, "N =", N)
# 5. 标识符不能包含空格。
my_name = "hi"
# my name = "hi"

# 练习：判断变量名是否正确
hello = 1
hello12 = 2
# 1hello = 1  # 不能以数字开头
# h-b = 1  # 不能包含-
# x h = 1  # 不能包含空格
# h$4 = 1  # 不能包含$
# class = 1  # 不能以关键字作为变量
int = 1
# or = 1  # 不能以关键字作为变量
# and = 1  # 不能以关键字作为变量
# if = 1  # 不能以关键字作为变量
_if = 600
stu_name = 1

标识符命名规范

1. 变量名：变量要小写，若有多个单词，使用下划线分开。常亮全部大写。

num = 20
my_friend_age = 21
PI = 3.1415926

2. 函数名：函数名一律小写，如果有多个单词，用下划线隔开。另外，私有函数以双下划线开头。

def my_func(var1, var2):
    pass
def __private_func(var1, var2):
    pass

3. 类名：使用大驼峰命名。

class SheetParser:
    pass
class Foo:
    pass

关键字

关键字的定义和特点

• 定义：被 Python 语言赋予了特殊含义，用做专门用途的字符串（单词）。

如何查看关键字

1. 官方文档—语言参考—2.3 标识符和关键字—2.3.1 关键字。

2. Python 的交互模式中输入 help()，再输入 keywords 即可。

键盘输入语句

基本介绍

1. 在编程中，需要接收用户输入的数据，就可以使用键盘语句来获取。
2. input() 介绍：

应用实例演示

# 可以从控制台接收用户信息，【姓名，年龄，薪水】
name = input("请输入姓名：")
age = input("请输入年龄：")
score = input("请输入成绩：")

print("\n输入的信息如下：")
print("name:", name)
print("age:", age)
print("score:", score)

# 注意：接收到的数据类型是str。
# print(10 + score)  # TypeError: unsupported operand type(s) for +: 'int' and 'str'
# 如果我们希望对接收到的数据进行算术运算，则需要进行类型转换。
print(10 + float(score))

# 当然，我们也可以在接收数据的时候，直接转成需要的类型
age = int(input("请输入年龄："))
print("age的类型是：", type(age))

扩展知识：进制

进制

进制介绍

1. 对于整数，有如下表示方式
   • 2 进制：0,1，满 2 进 1，以 0b 或 0B 开头。
   • 8 进制：0-7，满 8 进 1，以数字 0o 或 0O 开头。
   • 10 进制，0-9，满 10 进 1。
   • 16 进制，0-9 以及 A(10)-F(15)，满 16 进 1，以 0x 或 0X 开头。此处的 A-F 不区分大小写。

# 2进制
print(0b111)  # 7
print(0B111)

# 8进制
print(0o111)  # 73
print(0O111)

# 10进制
print(111)  # 111

print(0x111)  # 273
print(0X111)

进制的图示

进制的转换

其它进制转十进制

1. 二进制转成十进制（加权法/按权展开法）

• 规则：从最低位（右边）开始，将每个位上的数提取出来，乘以 2 的（位数-1）次方，然后求和。

• 案例：将 0b1011 转成十进制的数。

0b1011 = 
1 * 2的（1-1）次方 + 1 * 2的（2-1）次方 + 0 * 2的（3-1）次方 + 1 * 2的（4-1）次方 = 
1 + 2 + 0 + 8 = 11

print(0b1011)  # 11

2. 八进制转成十进制

• 规则：从最低位（右边）开始，将每个位上的数提取出来，乘以 8 的（位数-1）次方，然后求和。
• 案例：请将 0o234 转成十进制的数。

0o234 = 
4 * 8的（1-1）次方 + 3 * 8的（2-1）次方 + 2 * 8的(3-1)次方 = 
4 + 24 + 128 = 156

print(0o234)  # 156

3. 十六进制转成十进制

• 规则：从最低位（右边）开始，将每个位上的数提取出来，乘以 16 的（位数-1）次方，然后求和。
• 案例：请将 0x23A 转成十进制的数。

0x23A = 
10 * 16的（1-1）次方 + 3 * 16的（2-1）次方 + 2 * 16的（3-1）次方 = 
10 + 48 + 512 = 570

print(0x23A)  # 570

4. 练习

1、0b110001100 转成 十进制
= 0 + 0 + 1 * 2**2 + 1 * 2**3 + 0 + 0 + 0 + 1 * 2**7 + 1 * 2**8
= 4 + 8 + 128 + 256
= 396
print(0b110001100)  # 396
2、0o2356 转成 十进制
= 6 * 8^0 + 5 * 8**1 + 3 * 8**2 + 2 * 8**3
= 6 + 40 + 192 + 1024
= 1262
print(0o2356)  # 1262
3、0xA45 转成 十进制
= 5 * 16**0 + 4 * 16**1 + 10 * 16**2
= 5 + 64 + 2560
= 2629
print(0xA45)  # 2629

十进制转其它进制

1. 十进制转成二进制（短除法）

• 规则：将该数不断除以 2，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二进制。
• 案例：请将 34 转成二进制的数。

34 = 0b100010
34
17	0
8	1
4	0
2	0
1	0
	1
print(bin(34))  # 0b100010

2. 十进制转成八进制

• 规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。
• 案例：请将 131 转成八进制的数。

131 = 0o203
16	3
2	0
	2
print(oct(131))  # 0o203

3. 十进制转成十六进制

• 规则：将该数不断除以 16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。
• 案例：请将 237 转成十六进制的数。

237 = 0xED
14	13
	14
print(hex(237))  # 0xed

4. 练习

1、123 转成 二进制
123 = 0b1111011
61	1
30	1
15	0
7	1
3	1
1	1
	1
print(bin(123))  # 0b1111011
2、678 转成 八进制
678 = 0o1246
84	6
10	4
1	2
	1
print(oct(678))  # 0o1246
3、8912 转成 十六进制
8912 = 0x22D0
557	0
34	13
2	2
	2
print(hex(8912))  # 0x22d0

二进制转成八进制、十六进制

1. 二进制转换成八进制

• 规则：从低位开始，将二进制数每三位一组，转成对应的八进制数。
• 案例：请将 0b11010101 转成八进制。

0b11010101 = 0o325
101 = 1 * 2**0 + 0 + 1 * 2**2 = 5
010 = 0 + 1 * 2**1 + 0 = 2
11 = 1 * 2**0 + 1 * 2**1 = 3
print(oct(0b11010101))  # 0o325

2. 二进制转换成十六进制

• 规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数。

• 案例：请将 0b11010101 转成十六进制。

0b11010101 = 0xD5
0101 = 1 * 2**0 + 0 + 1 * 2**2 + 0 = 5
1101 = 1 * 2**0 + 0 + 1 * 2**2 + 1 * 2**3 = 13
print(hex(0b11010101))  # 0xd5

3. 练习

1、0b11100101 转成 八进制
0b11100101 = 0o345
101 = 1 + 0 + 1 * 2**2 = 5
100 = 1 * 2**2 = 4
11 = 1 + 1 * 2**1 = 3
print(oct(0b11100101))  # 0o345
2、0b1110010110 转成 十六进制
0b1110010110 = 0x396
0110 = 0 + 1 * 2**1 + 1 * 2**2 + 0 = 6
1001 = 1 + 0 + 0 + 1 * 2**3 = 9
11 = 1 + 1 * 2**1 = 3
print(hex(0b1110010110))  # 0x396

八进制、十六进制转成二进制

1. 八进制转成二进制

• 规则：将八进制数每 1 位，转成对应的 3 位的二进制数。
• 案例：请将 0o237 转成二进制。

0o237 = 0b10011111
7 = 111
3 = 011
2 = 010
print(bin(0o237))  # 0b10011111

2. 十六进制转成二进制

• 规则：将十六进制数每 1 位，转成对应的 4 位的二进制。
• 案例：请将 0x23B 转成二进制。

0x23B = 0b1000111011
B = 1011
3 = 0011
2 = 0010
print(bin(0x23B))  # 0b1000111011

3. 练习

1、0o1230 转成 二进制
0o1230 = 0b1010011000
0 = 000
3 = 011
2 = 010
1 = 001
print(bin(0o1230))  # 0b1010011000
2、0xAB29 转成 二进制
0xAB29 = 0b1010101100101001
9 = 1001
2 = 0010
B = 1011
A = 1010
print(bin(0xAB29))  # 0b1010101100101001

二进制在运算中的说明

基本介绍

1. 二进制是逢 2 进位的进位制，0、1 是基本数字符号。
2. 现代的电子计算机技术全部采用的是二进制，因为它只使用 0、1 两个数字符号，非常简单方便，易于电子方式实现。
3. 计算机内部处理的信息，都是采用二进制数来表示的。二进制（Binary）数用 0 和 1 两个数字及其组合来表示任何数。进位规则是“逢 2 进 1”，数字 1 在不同的位上代表不同的值。

原码、反码、补码

基本介绍

1. 二进制的最高位是符号位：0 表示整数，1 表示负数。

print(sys.getsizeof(3))  # 3用28个字节表示
# 我们假定用一个字节来表示
3  => 	0000 0011
-3 => 	1000 0011

2. 正数的原码、反码、补码都一样（三码合一）。

3 => 	原码：0000 0011
		反码：0000 0011
    	补码：0000 0011

3. 负数的反码 = 它的原码符号位不变，其它位取反（0-> 1，1-> 0）。

   负数的补码 = 它的反码 + 1，负数的反码 = 负数的补码 - 1。

-3 =>	原码：1000 0011
		反码：1111 1100
  		补码：1111 1101  

4. 0 的反码，补码都是 0

5. 在计算机运算的时候，都是以补码的方式来运算的；当我们看运算结果的时候，要看它的原码。

1 + 3 => 
1 =>	补码：0000 0001
3 =>	补码：0000 0011
1 + 3 =>补码：0000 0100 => 原码 0000 0100 => 4

1 - 3 => 1 + (-3)
1 =>	补码：0000 0001
-3 =>	原码：1000 0011 => 反码 1111 1100 => 补码 1111 1101
	  1的补码：0000 0001
     -3的补码：1111 1101
  1 - 3的补码：1111 1110 => 反码 1111 1101 => 原码 1000 0010 => -2

位运算符

&、|、^、~

1. ~ 按位与反

• 规则：对数据的每个二进制位取反，即把 1 变成 0，把 0 变成 1。

~-2 = 1
-2的补码：?	=> -2的原码 1000 0010 => 反码 1111 1101 => 补码 1111 1110
~-2 = 0000 0001(补码) => 原码 0000 0001 => 1
print(~-2)  # 1

~2 = -3
2的补码：	0000 0010
~2 => 1111 1101(补码) => 反码 1111 1100 => 原码 1000 0011 => -3
print(~2)  # -3

2. & 按位与

• 规则：参与运算的两个值，如果两个相应位都为 1，则该为的结果为 1，否则为 0。

2 & 3 = 2
2的补码：0000 0010
3的补码：0000 0011
2 & 3 => 0000 0010(补码) => 原码 0000 0010 => 2
print(2 & 3)  # 2

3. ^ 按位异或

• 规则：当两个对应的二进制位相异时，结果为 1。

2 ^ -3 = -1
2的补码：	0000 0010
-3的补码：? => 原码 1000 0011 => 反码 1111 1100 => 补码 1111 1101
2 ^ -3 => 1111 1111(补码) => 反码 1111 1110 => 原码 1000 0001 => -1
print(2 ^ -3)  # -1

4. | 按位或

• 规则：只要对应的两个二进制位有一个为 1 时，结果位就位 1。

2 | 3 = 3
2的补码：	0000 0010
3的补码：	0000 0011
2 | 3 =>   0000 0011(补码) => 原码 0000 0011 => 3
print(2 | 3)  # 3

>>、<<

1. << 左移

• 规则：运算数的各二进制位全部左移若干位，由“<<”右边的数指定移动的位数，符号位不变，高位丢弃，低位补 0。
• 左移一位相当于 * 2 一次。

5 << 1 = 10
5的补码：	0000 0101
5 << 1 =>  0000 1010(补码) => 原码 0000 1010 => 10
print(5 << 1)  # 10

-5 << 1 = -10
-5的补码：? => 原码 1000 0101 => 反码 1111 1010 => 补码 1111 1011
-5 << 1 => 1111 0110(补码) => 反码 1111 0101 => 原码 1000 1010 => -10
print(-5 << 1)  # -10

2. >> 右移

• 规则：把 >> 左边的运算数的各二进制位全部右移若干位，>> 右边的数指定移动的位数，低位溢出，符号位不变，并用符号位补溢出的高位。
• 右移一位相当于 // 2 一次。

5 >> 1 = 2
5的补码：	0000 0101
5 >> 1 =>  0000 0010(补码) => 原码 0000 0010 => 2
print(5 >> 1)  # 2

-5 >> 1 = -3
-5的补码：1111 1011
-5 >> 1 => 1111 1101(补码) => 反码 1111 1100 => 原码 1000 0011 => -3
print(-5 >> 1)  # -3