柠栀

python的整型

2025/9/10 python

# 1.整型的基本概念

整型(int)表示整数，包括正整数、负整数和零。

# 基本整型定义
positive = 42
negative = -15
zero = 0

print(f"positive: {positive}, 类型: {type(positive)}")  # <class 'int'>
print(f"negative: {negative}, 类型: {type(negative)}")  # <class 'int'>
print(f"zero: {zero}, 类型: {type(zero)}")              # <class 'int'>
1
2
3
4
5
6
7
8

# 2.不同进制的整型表示

Python支持多种进制表示整数：

# 十进制 (默认)
decimal = 10
print(f"十进制 10: {decimal}")

# 二进制 (以 0b 或 0B 开头)
binary = 0b1010  # 二进制 1010 = 十进制 10
print(f"二进制 0b1010: {binary}")

# 八进制 (以 0o 或 0O 开头)
octal = 0o12  # 八进制 12 = 十进制 10
print(f"八进制 0o12: {octal}")

# 十六进制 (以 0x 或 0X 开头)
hexadecimal = 0xA  # 十六进制 A = 十进制 10
print(f"十六进制 0xA: {hexadecimal}")

# 使用下划线提高可读性 (Python 3.6+)
large_number = 1_000_000
print(f"大数字: {large_number}")

credit_card = 1234_5678_9012_3456
print(f"信用卡号: {credit_card}")

bytes_value = 0b1100_1010_1111_0101
print(f"字节值: {bytes_value}")
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

# 3.整型转换函数

# 其他类型转整型
print("类型转换:")
print(f"int(3.14) = {int(3.14)}")          # 浮点数转整型 (截断小数)
print(f"int(-2.99) = {int(-2.99)}")        # -2
print(f"int('100') = {int('100')}")        # 字符串转整型
print(f"int('1010', 2) = {int('1010', 2)}") # 二进制字符串转十进制
print(f"int('FF', 16) = {int('FF', 16)}")  # 十六进制字符串转十进制
print(f"int(True) = {int(True)}")          # 布尔值转整型 (True=1)
print(f"int(False) = {int(False)}")        # 布尔值转整型 (False=0)

# 进制转换函数
number = 10
print(f"n数字 {number} 的不同进制表示:")
print(f"二进制: {bin(number)}")      # 0b1010
print(f"八进制: {oct(number)}")      # 0o12
print(f"十六进制: {hex(number)}")    # 0xa
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 4.整型运算

# 4.1.基本算术运算

a, b = 10, 3

print("基本算术运算:")
print(f"{a} + {b} = {a + b}")      # 加法: 13
print(f"{a} - {b} = {a - b}")      # 减法: 7
print(f"{a} * {b} = {a * b}")      # 乘法: 30
print(f"{a} / {b} = {a / b}")      # 除法: 3.333... (返回浮点数)
print(f"{a} // {b} = {a // b}")    # 整除: 3
print(f"{a} % {b} = {a % b}")      # 取余: 1
print(f"{a} ** {b} = {a ** b}")    # 幂运算: 1000
print(f"-{a} = {-a}")              # 取负: -10
print(f"+{a} = {+a}")              # 取正: 10
1
2
3
4
5
6
7
8
9
10
11
12

# 4.2.位运算

x, y = 5, 3  # 5 = 0b101, 3 = 0b011

print("位运算:")
print(f"{x} & {y} = {x & y}")      # 按位与: 0b101 & 0b011 = 0b001 = 1
print(f"{x} | {y} = {x | y}")      # 按位或: 0b101 | 0b011 = 0b111 = 7
print(f"{x} ^ {y} = {x ^ y}")      # 按位异或: 0b101 ^ 0b011 = 0b110 = 6 异或是指两个位不同则返回1，相同则返回0
print(f"~{x} = {~x}")              # 按位取反: ~0b101 = -6 (补码表示)  −x−1 00000101→11111010-1→11111001→ 00000110
print(f"{x} << 1 = {x << 1}")      # 左移: 0b101 << 1 = 0b1010 = 10 左移是乘以2
print(f"{x} >> 1 = {x >> 1}")      # 右移: 0b101 >> 1 = 0b10 = 2 右移是除以2
1
2
3
4
5
6
7
8
9
READ_PERMISSION = 0b001  # 1
# 定义写权限，二进制010，十进制2
WRITE_PERMISSION = 0b010 # 2  
# 定义执行权限，二进制100，十进制4
EXECUTE_PERMISSION = 0b100 # 4

# 用户权限：拥有读和写权限，使用按位或运算
user_permissions = READ_PERMISSION | WRITE_PERMISSION  # 0b011

# 打印权限控制标题
print(f"n权限控制:")
# 打印用户当前的权限（二进制表示）
print(f"用户权限: {bin(user_permissions)}")
# 判断用户是否有读权限
print(f"可读权限: {(user_permissions & READ_PERMISSION) != 0}")
# 判断用户是否有写权限
print(f"可写权限: {(user_permissions & WRITE_PERMISSION) != 0}")
# 判断用户是否有执行权限
print(f"可执行权限: {(user_permissions & EXECUTE_PERMISSION) != 0}")

# 给用户添加执行权限，使用按位或运算
user_permissions |= EXECUTE_PERMISSION
# 打印添加执行权限后的用户权限（二进制表示）
print(f"添加执行权限后: {bin(user_permissions)}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 4.3.比较运算

a, b = 10, 5

print("比较运算:")
print(f"{a} == {b}: {a == b}")    # 等于: False
print(f"{a} != {b}: {a != b}")    # 不等于: True
print(f"{a} > {b}: {a > b}")      # 大于: True
print(f"{a} < {b}: {a < b}")      # 小于: False
print(f"{a} >= {b}: {a >= b}")    # 大于等于: True
print(f"{a} <= {b}: {a <= b}")    # 小于等于: False

# 链式比较
c = 7
print(f"n链式比较:")
print(f"{b} < {c} < {a}: {b < c < a}")  # True
print(f"{a} > {c} > {b}: {a > c > b}")  # True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 5.整型的特性

# 5.1.无限精度

# Python整型没有大小限制 (仅受内存限制)
very_large = 10 ** 100  # 10的100次方
very_small = -10 ** 100

print(f"非常大的数: {very_large}")
print(f"非常小的数: {very_small}")
print(f"类型仍然是int: {type(very_large)}")

# 可以计算超大数的阶乘
def factorial(n):
    """计算阶乘"""
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

print(f"n阶乘演示:")
print(f"10! = {factorial(10)}")
print(f"50! = {factorial(50)}")  # 可以计算非常大的阶乘
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 5.2.内存占用

import sys

"""显示整型的内存占用"""
numbers = [0, 1, 10, 100, 1000, 10**10, 10**100]

print("整型内存占用:")
for num in numbers:
    size = sys.getsizeof(num)
    print(f"数字 {num}: {size} 字节")
1
2
3
4
5
6
7
8
9

sys模块提供了与 Python 解释器 和 系统环境 交互的变量和函数。
sys.getsizeof 用于返回对象占用的内存字节数

# 6.内置数学函数

import math

numbers = [-5, 0, 5, 10, 15]

print("内置数学函数:")
for num in numbers:
    print(f"abs({num}) = {abs(num)}")          # 绝对值

print(f"n最大值: {max(1, 5, 2, 8, 3)}")      # 8
print(f"最小值: {min(1, 5, 2, 8, 3)}")        # 1
print(f"求和: {sum([1, 2, 3, 4, 5])}")        # 15

# 更多数学函数
print(f"n高级数学函数:")
print(f"2的3次方: {pow(2, 3)}")               # 8
print(f"四舍五入: {round(3.14159, 2)}")       # 3.14
print(f"向上取整: {math.ceil(3.14)}")         # 4
print(f"向下取整: {math.floor(3.14)}")         # 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 7.实际应用

# 7.1.示例1：数值计算

# 质数判断 
# 质数：大于1的自然数，且只能被1和它本身整除的数。
def is_prime(n):
    # 如果n小于2，则不是质数
    if n < 2:
        return False
    # 从2到sqrt(n)遍历，判断是否有因数
    # 如果 n 是合数，那么它一定有一个因子 ≤ sqrt(n)，假设 n = a × b，如果 a > sqrt(n) 且 b > sqrt(n)，那么 a × b > n，矛盾
    for i in range(2, int(n ** 0.5) + 1):
        # 如果n能被i整除，则不是质数
        if n % i == 0:
            return False
    # 如果没有因数，则是质数
    return True

# 打印提示信息
print("质数判断:")    

# 遍历2到19，判断每个数是否为质数
for i in range(2, 20):
    # 如果是质数，则打印出来
    if is_prime(i):
        print(f"{i} 是质数")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 定义斐波那契数列生成器函数
def fibonacci(n):
    # 初始化前两个斐波那契数
    a, b = 0, 1
    # 循环n次，生成前n项
    for _ in range(n):
        # 使用yield返回当前的a
        yield a
        # 更新a和b的值，a变为b，b变为a+b
        a, b = b, a + b

print("n斐波那契数列前10项:")
# 生成前10项斐波那契数列，并转换为列表
fib_list = list(fibonacci(10))
# 打印斐波那契数列
print(fib_list)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 7.2.示例2：位运算应用

# 7.2.1.判断奇偶性

# 定义一个函数，判断一个数是否为偶数
def is_even(n):
    # 使用位运算判断最低位是否为0，若为0则为偶数
    # 偶数的二进制表示：最低位（最右边）是 0
    # 奇数的二进制表示：最低位（最右边）是 1
    return (n & 1) == 0

# 打印15是否为偶数
print(f"15是偶数吗? {is_even(15)}")
# 打印16是否为偶数
print(f"16是偶数吗? {is_even(16)}")
1
2
3
4
5
6
7
8
9
10
11

# 7.2.2.交换两个数 (不使用临时变量)

# 定义一个函数，使用异或运算交换两个数的值
# 异或运算：相同为0，不同为1
def swap(a, b):
    # 第一步：a变为a^b
    a = a ^ b
    # 第二步：b变为a^b^b，即a
    b = a ^ b
    # 第三步：a变为a^b^a，即b
    a = a ^ b
    # 返回交换后的a和b
    return a, b

# 初始化x和y的值
x, y = 5, 3
# 调用swap函数交换x和y
x, y = swap(x, y)
# 打印交换后的x和y
print(f"交换后: x={x}, y={y}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 7.2.3.计算过程

  1. 二进制表示
a = 5 = 0101 (二进制)
b = 3 = 0011 (二进制)
1
2
  1. 第一步：a = a ^ b
a = 5 ^ 3
  0101 (5)
^ 0011 (3)
--------
  0110 (6)

现在：a = 6, b = 3
1
2
3
4
5
6
7
  1. 第二步：b = a ^ b
b = 6 ^ 3
  0110 (6)
^ 0011 (3)
--------
  0101 (5)

现在：a = 6, b = 5
1
2
3
4
5
6
7
  1. 第三步：a = a ^ b
a = 6 ^ 5
  0110 (6)
^ 0101 (5)
--------
  0011 (3)

现在：a = 3, b = 5
1
2
3
4
5
6
7

最终结果：a = 3, b = 5，交换成功！

# 7.2.4.异或运算

# 7.2.4.1.异或运算规则
  • 0 ^ 0 = 0
  • 0 ^ 1 = 1
  • 1 ^ 0 = 1
  • 1 ^ 1 = 0

记忆口诀：相同为0，不同为1

# 7.2.4.2.异或的重要性质
  1. 交换律: a ^ b = b ^ a结合律: (a ^ b) ^ c = a ^ (b ^ c)自反性: a ^ a = 0与0异或: a ^ 0 = a可逆性: 如果 a ^ b = c，那么 a ^ c = b 且 b ^ c = a
# 7.2.4.3.代数推导

设初始值：a = A, b = B

# 第一步后：a = A^B, b = B
# 第二步后：a = A^B, b = (A^B)^B = A^(B^B) = A^0 = A
# 第三步后：a = (A^B)^A = (A^A)^B = 0^B = B, b = A
1
2
3

# 7.2.5.判断是否是2的幂

# 定义一个函数，判断一个数是否是2的幂
def is_power_of_two(n):
    # n大于0且n按位与n-1等于0时，n是2的幂
    return n > 0 and (n & (n - 1)) == 0

# 打印8是否是2的幂
print(f"8是2的幂吗? {is_power_of_two(8)}")
# 打印6是否是2的幂
print(f"6是2的幂吗? {is_power_of_two(6)}")
1
2
3
4
5
6
7
8
9

2的幂次方在二进制表示中有一个重要特点：只有一个1，其余都是0

按位与运算：

# 1  100...000  (n)
# 2& 011...111  (n-1)
# 3------------
# 4  000...000  = 0
1
2
3
4

# 7.3.示例3：进制转换工具

# 定义一个通用进制转换函数
def convert_base(number, from_base, to_base):
    """通用进制转换"""
    # 如果输入是字符串，则先将其从原进制转换为十进制整数
    if isinstance(number, str):
        decimal = int(number, from_base)
    # 如果输入已经是整数，则直接赋值
    else:
        decimal = number
    
    # 如果目标进制是2，返回二进制字符串
    if to_base == 2:
        return bin(decimal)
    # 如果目标进制是8，返回八进制字符串
    elif to_base == 8:
        return oct(decimal)
    # 如果目标进制是16，返回十六进制字符串
    elif to_base == 16:
        return hex(decimal)
    # 如果目标进制是10，返回十进制字符串
    elif to_base == 10:
        return str(decimal)
    # 其他自定义进制的转换
    else:
        # 定义可用的数字和字母作为进制字符
        digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        # 如果十进制数为0，直接返回"0"
        if decimal == 0:
            return "0"
        # 初始化结果字符串
        result = ""
        # 通过取余和整除不断获取每一位
        while decimal > 0:
            result = digits[decimal % to_base] + result
            decimal //= to_base
        # 返回最终结果
        return result

# 打印进制转换提示
print("进制转换:")
# 定义测试用例，每个元素为(数字, 原进制, 目标进制)
test_cases = [
    ("1010", 2, 10),   # 二进制转十进制
    ("255", 10, 16),   # 十进制转十六进制
    ("377", 8, 2),     # 八进制转二进制
    (100, 10, 36)      # 十进制转36进制
]

# 遍历每个测试用例，进行进制转换并输出结果
for number, from_base, to_base in test_cases:
    result = convert_base(number, from_base, to_base)
    print(f"{number} (基{from_base}) -> {result} (基{to_base})")
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
46
47
48
49
50
51
52
53

# 8.整型的特殊方法

# 定义一个自定义整型类
class CustomInt:
    """自定义整型类演示"""
    # 构造方法，初始化对象时赋值
    def __init__(self, value):
        self.value = value
    
    # 重载加法运算符，实现自定义加法
    def __add__(self, other):
        return CustomInt(self.value + other.value)
    
    # 重载字符串表示方法，便于打印对象
    def __str__(self):
        return f"CustomInt({self.value})"
    
    # 重载int()函数的行为，使对象可转换为int类型
    def __int__(self):
        return self.value

# 创建自定义整型对象a，值为5
a = CustomInt(5)
# 创建自定义整型对象b，值为3
b = CustomInt(3)
# 对a和b进行加法运算，结果赋值给c
c = a + b
# 打印自定义整型的加法运算结果
print(f"自定义整型运算: {a} + {b} = {c}")
# 打印将c转换为int类型的结果
print(f"转换为int: {int(c)}")
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

# 9.总结

Python整型的特点：

  1. 无限精度：不受固定位数限制
  2. 多进制支持：二进制、八进制、十进制、十六进制
  3. 丰富的运算：算术运算、位运算、比较运算
  4. 类型转换灵活：支持各种类型到整型的转换
  5. 内存效率：自动优化小整数的存储
  6. 广泛应用：数值计算、位操作、算法实现等

python的迭代器