Python学习日志04-基础语法学习03

Python学习日志04-基础语法学习03

亓翎_Re-TikaRa Lv4
  2024-11-25 15:20:58 2024-11-25 15:20:58 创建   2024-11-26 23:53:36 2024-11-26 23:53:36 更新      3.4k 字  13 分钟  

数字类型

  python支持如下四种数字类型：

  • 整数（int）
      整数就是整数，包括正整数，负整数和零，不带小数点。在Python中，整数的取值范围是很大的。Python中的整数还可以以几种不同的进制进行书写。0+“进制标志”+数字代表不同进制的数。现实中有如下四种常用的进制标志。
    • 0o [0O] 数字：表示八进制整数，例如0o24、0o24。
    • 0x [0X] 数字：表示十六进制整数，例如：0x2A、0X2A。
    • 0b [0B] 数字：表示二进制整数，例如：0b101010、0B101010。
    • 不带进制标志：表示十进制整数
  • 浮点型
      浮点数（float）数据由整数部分与小数部分组成，浮点型数据也可以用科学技术法表示（2.5e2=2.5×102=250）。当按照科学计数法表示时，一个浮点数的小数点的位置是可以变的，比如，1.23×109和12.3×108是等价的。浮点数可以采用数学写法，如：1.23、3.14、-55.369等。但是对于很大或者很小的浮点数，就必须使用科学计数法来表示，把10用e代替，如：1.23e-5、3.14e5等。
  • 布尔型
      布尔型是一种表示逻辑值的简单类型，它的值只能是“真”或“假”这两个中的其中一个。布尔型是所有逻辑关系运算的返回类型，经常用excel的同学应该很熟悉，他就是IF函数判断条件的返回值。在Python中，布尔型的取值只有“True”和“False”两个，注意大小写。
  • 复数型
      在Python中，复数型即complex型，由实数部分和虚数部分构成，可以用a+bj或者complex(a,b)来表示，复数的实部a和虚部b都是浮点型。

  我们可以用type()函数来判断一个变量的类型，例如我现在有text1~4四个变量，分别存储了字符串、整数、浮点数和布尔值，我们可以用type()函数来判断它们的类型，如下：

1
2
3
4
5
text1 = "hello world"
text2 = 30
text3 = 3.14
text4 = True
print(type(text1),type(text2),type(text3),type(text4))

  上面那段代码就会输出如下结果

1
<class 'str'> <class 'int'> <class 'float'> <class 'bool'>

image.png

类型转换函数

  python中，我们时常要将某个类型的值转换为另一个类型，通过下表中的函数，我们就可以将一个类型转换成另一个类型。

函数 功能
int(x[,base]) 将x转换为整数类型（并不是四舍五入，而是直接取整）
float(xx) 将x转换为浮点数类型
str() 将一个数值类型转换为字符串类型
cpmplex(real[,imag]) 创建一个复数
repr(x) 将对象转换为表达式字符串
eval(str) 计算在字符串中有效的Python表达式，并且返回一个对象
tuple(s) 将序列s转换为元组
list(s) 将序列s转换为一个列表
set(s) 转换为可变集合
dict(s) 创建一个字典。必须是序列(key,value)元组
forzenset(s) 转换为一个不可变集合
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为一个Unicode字符，在Python3中已弃用
ord(x) 将一个字符转换为一个整数值
hex(x) 将一个整数转换为十六进制字符串
oct(x) 将一个整数转换为八进制字符串

  分别举例如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# int(x[,base]) - 将x转换为整数类型
print(int('123'))  # 输出: 123
print(int('101', base=2))  # 输出: 5

# float(x) - 将x转换为浮点数类型
print(float('3.14'))  # 输出: 3.14

# str() - 将一个数值类型转换为字符串类型
print(str(123))  # 输出: '123'

# complex(real[,imag]) - 创建一个复数
print(complex(3, 4))  # 输出: (3+4j)

# repr(x) - 将对象转换为表达式字符串
print(repr(123))  # 输出: '123'

# eval(str) - 计算在字符串中有效的Python表达式，并且返回一个对象
print(eval('2 + 3 * 4'))  # 输出: 14

# tuple(s) - 将序列s转换为元组
print(tuple([1, 2, 3]))  # 输出: (1, 2, 3)

# list(s) - 将序列s转换为一个列表
print(list('abc'))  # 输出: ['a', 'b', 'c']

# set(s) - 转换为可变集合
print(set([1, 2, 3, 2, 1]))  # 输出: {1, 2, 3}

# dict(s) - 创建一个字典。必须是序列(key,value)元组
print(dict([('a', 1), ('b', 2)]))  # 输出: {'a': 1, 'b': 2}

# frozenset(s) - 转换为一个不可变集合
print(frozenset([1, 2, 3, 2, 1]))  # 输出: frozenset({1, 2, 3})

# chr(x) - 将一个整数转换为一个字符
print(chr(65))  # 输出: 'A'

# ord(x) - 将一个字符转换为一个整数值
print(ord('A'))  # 输出: 65

# hex(x) - 将一个整数转换为十六进制字符串
print(hex(255))  # 输出: '0xff'

# oct(x) - 将一个整数转换为八进制字符串
print(oct(8))  # 输出: '0o10'

运算符和表达式

  在Python中，有了变量，字符串等，还必须使用某种方式将变量和字符串的关系表示出来，只有这样才能用程序解决现实中的问题，此时运算符和表达式便应运而生。运算符和表达式的作用是为变量建立一种组合联系，实现对变量的处理。

算术运算符

  算术运算符用于对数值变量进行运算，如加减乘除等，运算符的优先级和结合律与数学一致。具体符号见下表：

运算符 功能
+ 两对象相加
- 两对象相减，得到负数或表示用一个减一个
* 两数相乘或者返回一个被重复若干次的字符串
/ 两数相除
% 取模运算符，也就是取除法的余数
** 幂运算符，实现a的b次方
// 取整除，返回商的整数部分，不包含余数

  若a=3065，b=20，则上面的表中举例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
a = 3065
b = 20

# + 加法
print(a + b)  # 输出: 3085

# - 减法
print(a - b)  # 输出: 3045

# * 乘法
print(a * b)  # 输出: 61300

# / 除法
print(a / b)  # 输出: 153.25

# % 取模（取余数）
print(a % b)  # 输出: 5

# ** 幂运算
print(a ** b)  # 输出: 3065 的 20 次方, 结果非常大

# // 整除
print(a // b)  # 输出: 153

比较运算符

  比较运算符用于比较两个数值变量的关系，返回一个布尔值，即True或False。常用于比较大小关系等。其具体符号见下表：

运算符 功能
== 判断两个对象是否相等
!= 判断两个对象是否不相等
> 判断一个对象是否大于另一个对象
>= 判断一个对象是否大于等于另一个对象
< 判断一个对象是否小于另一个对象
<= 判断一个对象是否小于等于另一个对象
  例如，现在有两个数值变量a和b，a=5，b=10，则比较运算符举例如下： 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
a = 5
b = 10
# == 判断两个对象是否相等
print(a == b)  # 输出: False
print(a == 5)  # 输出: True
# != 判断两个对象是否不相等
print(a != b)  # 输出: True
print(a != 5)  # 输出: False
# > 判断一个对象是否大于另一个对象
print(a > b)  # 输出: False
print(b > a)  # 输出: True
# >= 判断一个对象是否大于等于另一个对象
print(a >= b)  # 输出: False
print(b >= a)  # 输出: True
# < 判断一个对象是否小于另一个对象
print(a < b)  # 输出: True
print(b < a)  # 输出: False
# <= 判断一个对象是否小于等于另一个对象
print(a <= b)  # 输出: True
print(b <= a)  # 输出: False

  需要注意的是，有时会返回0或者1，而不是True和False，其中0表示False，1表示True。

赋值运算符

  赋值运算符的含义是给某变量或表达式设置一个值，例如a=3065，表示将值3065赋给变量a。这样一见到a就知道他是3065， （像是数学中的换元？） 。Python为我们提供了7中复合赋值运算符，就是在原始赋值运算符之上加了算数运算符，详见下表：

运算符 功能
= 赋值运算符
+= 加法赋值运算符
-= 减法赋值运算符
*= 乘法赋值运算符
/= 除法赋值运算符
%= 取模赋值运算符
**= 幂赋值运算符
//= 取整除赋值运算符
  例如，现在有两个数值变量a和b，a=100，b=10，则赋值运算符举例如下： 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# 初始值
a = 3065
b = 50

# 加法赋值
a += b  # a 现在是 3115 (3065 + 50)
print(f"加法赋值后 a 的值: {a}")
加法赋值后 a 的值: 3115

# 减法赋值
a -= b  # a 现在回到 3065 (3115 - 50)
print(f"减法赋值后 a 的值: {a}")
减法赋值后 a 的值: 3065

# 乘法赋值
a *= b  # a 变成 153250 (3065 * 50)
print(f"乘法赋值后 a 的值: {a}")
乘法赋值后 a 的值: 153250

# 浮点除法赋值
a /= b  # a 回到 3065.0 (153250 / 50)，注意这里结果是浮点数
print(f"除法赋值后 a 的值: {a}")
除法赋值后 a 的值: 3065.0

# 取模赋值
a %= b  # a 变成 15 (3065 % 50)
print(f"取模赋值后 a 的值: {a}")
取模赋值后 a 的值: 15.0

# 幂赋值
a **= b  # a 变成 15 的 50 次方
print(f"幂赋值后 a 的值: {a:.2e}")  # 使用科学记数法显示以避免非常大的数字
幂赋值后 a 的值: 6.38e+58

# 整数除法赋值
a //= b  # a 变成 15 的 50 次方除以 50 后向下取整的结果
print(f"整数除法赋值后 a 的值: {a}")
整数除法赋值后 a 的值: 1.2752430004280992e+57

  此处每一个举例的a都是复用上一个举例的结果，而不是最开始的3065。

位运算符和位表达式

  在Python中，使用位运算符可以操作二进制数据，位运算可以直接操作整数类型的位，也就是说，按位运算是把数字看作二进制数来计算。具体如下：

运算符 功能
& 按位与运算符，如果两个相应位都为1，则该位结果为1
| 按位或运算符，只要两个二进制位有一个为1，结果位就是1
^ 按位异或运算符，如果两个二进制位相异或时，结果为1
~ 按位取反运算符，对数据的每个二进制位取反，即0变1，1变0
<< 左移动运算符，运算数的各二进制位全部左移若干位，由<<右边的数指定移动位数，高位丢弃，低位补0
>> 右移动运算符，把>>左边的运算数的各二进制位全部右移若干位，由>>右边的数指定移动的位数

  假设变量a=3065，则a的二进制数是：101111111001，变量b=50，则b的二进制数是：110010，为了进行位运算，我们首先需要确保两个数有相同的位数。b 比 a 少几位，所以我们在 b 的前面补零，使其与 a 有相同的位数，即 b 变为 000000110010。

  1. 按位与(&):

    • 运算: a & b 即 101111111001 & 000000110010
    • 结果: 000000110000 （十进制 48）

  2. 按位或(|):

    • 运算: a | b 即 101111111001 | 000000110010
    • 结果: 101111111011 （十进制 3071）

  3. 按位异或(^):

    • 运算: a ^ b 即 101111111001 ^ 000000110010
    • 结果: 101111001011 （十进制 3023）

  4. 按位取反(~):

    • 对于 a: ~a 即 ~101111111001
      • 在大多数计算机系统中，整数是以补码形式存储的，因此对于一个正整数执行按位取反后，通常会得到一个负数。这里直接取反得到的是 010000000110，但实际结果会依赖于具体的机器和数据类型大小。
    • 对于 b: ~b 即 ~000000110010
      • 同样地，直接取反得到 111111001101，但考虑补码表示，这实际上代表了一个负数。

  5. 左移(<<):

    • 假设我们将 a 左移 2 位: a << 2 即 101111111001 << 2
    • 结果: 111111100100 （十进制 12260）

  6. 右移(>>):

    • 假设我们将 a 右移 2 位: a >> 2 即 101111111001 >> 2
    • 结果: 001011111110 （十进制 766）

逻辑运算符

  在Python中，逻辑运算就是将变量用逻辑关系连接起来，并对其进行求值的一个过程。在Python中，逻辑运算符包括：and、or、not。其具体如下：

运算符 功能
and 逻辑与运算符，如果两个表达式都为真，则返回True，否则返回False
or 逻辑或运算符，如果两个表达式有一个为真，则返回True，否则返回False
not 逻辑非运算符，返回表达式的反值，即如果表达式为真，则返回False，否则返回True

  

1
2
3
4
5
6
7
8
9
10
11
a = True
b = False
# and 运算符
print(a and b)  # 输出: False
print(a and a)  # 输出: True
# or 运算符
print(a or b)  # 输出: True
print(b or b)  # 输出: False
# not 运算符
print(not a)  # 输出: False
print(not False)  # 输出: True

后记

  Python中运算符具有优先级，从高到低依次是：算术运算符>比较运算符>位运算符和位表达式>逻辑运算符>赋值运算符。若有同级运算符，则从左向右依次计算。在实际使用中，要注意优先级的问题，避免出现错误。

  • 标题: Python学习日志04-基础语法学习03
  • 作者: 亓翎_Re-TikaRa
  • 创建于 : 2024-11-25 15:20:58
  • 更新于 : 2024-11-26 23:53:36
  • 链接: https://re-tikara.fun/posts/e067adc7/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
推荐阅读
Python学习日志02-基础语法学习01 Python学习日志02-基础语法学习01 python学习日志03-基础语法学习02 python学习日志03-基础语法学习02 Python学习日志05-基础语法学习04 Python学习日志05-基础语法学习04
推荐阅读
Python学习日志02-基础语法学习01 Python学习日志02-基础语法学习01 python学习日志03-基础语法学习02 python学习日志03-基础语法学习02
目录
Python学习日志04-基础语法学习03
  1. 数字类型
  2. 类型转换函数
  3. 运算符和表达式
    1. 算术运算符
    2. 比较运算符
    3. 赋值运算符
    4. 位运算符和位表达式
    5. 逻辑运算符
  4. 后记