cbear小站
large picture of the cover

3-5-1-Python基础语法-数据类型

Python 自带了一些内在数据类型(内在类型) , 主要内在数据类型包括数值(number)、字符串 (str)、列表(list)、元组(tuple)、集合(set)、字典(dict)。

1. 数值类型

数值类型不是一个单独的类型 , 而可分为 int(整型)、float(浮点型)、complex(复数类型)、bool(布尔类型)。 bool 型用于表示一个逻辑量 , 即一个命题的真和假 , 因此只有表示真和假的两个值 True、False。

>>> type(5)
<class 'int'>
>>> type(3.14)
<class 'float'>
>>> type(2+3j)
<class 'complex'>
>>> type(False)
<class 'bool'>

只要计算机内存足够 , Python 的整型的长度就可以任意长。但浮点型的值小数点后的精度不超 过 15 位 , 而复数型的值总是写成 x+yi 形式

>>> a = 1234567890123456789
>>> b = 0.1234567890123456789
>>> c = 1+2j
>>> print(a)
1234567890123456789
>>> print(b)
0.12345678901234568
>>> print(c)
(1+2j)

int有不同的进制转换: 二进制、八进制、十进制、十六进制。

  • 二进制

    二进制数只能由 0 和 1 组成。二进制数以 0b 或 0B 开头。

    >>> bin1 = 0b101
>>> print('bin1Value: ' , bin1)
bin1Value:  5
>>>
>>> bin2 = 0B110
>>> print('bin1Value: ' , bin2)
bin1Value:  6
>>>
>>> foo = 0b1000111
>>> print(foo)
71
>>> # 使用前缀 0B 定义二进制数
>>> bar = 0B010110110
>>> print(bar)  
>>>182

  • 八进制

    八进制整数只能由 0~7 组成。八进制数以 0o 或 0O 开头(第一个字母是零 , 第二个字母是大写或小写的 O）。需要注意的是 , 在 Python 2.x 中 , 八进制数值还可以直接以 0(零)开头。

    >>> # 八进制
>>> oct1 = 0o26
>>> print('oct1Value: ', oct1)  # oct1Value:  22
oct1Value:  22
>>> oct2 = 0O41
>>> print('oct2Value: ', oct2)  # oct2Value:  33
oct2Value:  33
>>>
>>> # 使用前缀 0o 定义八进制数
>>> foo = 0o1652701
>>> print(foo)  # 480705
480705
>>>
>>> # 使用前缀 0B 定义八进制数
>>> bar = 0O1657430
>>> print(bar)  # 483096
483096
>>>

  • 十进制

    Python最常见的整数就是十进制形式的整数。在使用十进制表示整数值时 , 不能以 0(零)作为十进制数的开头（数值是0除外）。

    >>> # 定义十进制正整数
>>> foo = 256
>>> print(foo)  
256
>>>
>>> # 定义十进制负整数
>>> bar = -128
>>> print(bar)  
-128

  • 十六进制

    十六进制数由 0~9 以及 A~F(或 a~f)组成。十六进制数以 0x 或 0X 开头。

    >>> # 使用前缀 0x 定义十六进制数
>>> foo = 0x16ADC9
>>> print(foo)  # 1486281
1486281
>>>
>>> # 使用前缀 0X 定义十六进制数
>>> bar = 0XDB80A
>>> print(bar)  # 899082
899082
>>>
>>> # 十六进制
>>> hex1 = 0x45
>>> hex2 = 0x4Af
>>> print("hex1Value: ", hex1)  # hex1Value:  69
hex1Value:  69
>>> print("hex2Value: ", hex2)  # hex2Value:  1199
hex2Value:  1199
>>>
​

整型进制转换

  • bin() : 十进制转换二进制

  • oct() : 十进制转换八进制

  • hex() : 十进制转换十六进制

  • int() : 其他进制转换为十进制 , 也可其他数据类型转换为整数类型

>>> a = 100  # 十进制
>>> b = 0b1100100  # 二进制的100
>>> c = 0o144  # 八进制的100
>>> d = 0x64  # 十六进制的100
>>>
>>> '''十进制转换为其他进制,转换后的数据类型为字符串类型'''
'十进制转换为其他进制,转换后的数据类型为字符串类型'
>>> print(bin(a))  # 十进制转二进制  0b1100100
0b1100100
>>> print(oct(a))  # 十进制转八进制  0o144
0o144
>>> print(hex(a))  # 十进制转十六进制  0x64
0x64
>>> print(type(bin(a)))  # 查看数据类型  <class 'str'>
<class 'str'>
>>>
>>> '''其他进制转换为十进制,int()中的第一个值必须为字符串'''
'其他进制转换为十进制,int()中的第一个值必须为字符串'
>>> print(int('0b1100100', 2))  # 二进制转换十进制 100
100
>>> print(int('0o144', 8))  # 八进制转换十进制 100
100
>>> print(int('0x64', 16))  # 十六进制转换十进制 100
100
>>> print(type(int('0b1100100', 2)))  # 查看数据类型 <class 'int'>
<class 'int'>
>>>
>>>

整型数字分割符

为了提高数字的的可读性 , Python 3.x 允许使用下划线_作为数字(包括整数和小数)的分隔符。通常每隔三个数字添加一个下划线 , 类似于英文数字中的逗号。下划线不会影响数字本身的值。

>>> '''【实例】使用下划线书写数字'''
'【实例】使用下划线书写数字'
>>> click = 1_301_547
>>> distance = 384_000_000
>>> print("Python教程阅读量 : ", click)  # Python教程阅读量 :  1301547
Python教程阅读量 :  1301547
>>> print("地球和月球的距离 : ", distance)  # 地球和月球的距离 :  384000000
地球和月球的距离 :  384000000

整型所占的内存大小

python中可以用sys.getsizeof(object)来获取对象所占内存的大小。

>>> import sys
>>>
>>> # 内存大小
>>> print(sys.getsizeof(0))  # 28个字节
24
>>> print(sys.getsizeof(1))  # 28个字节
28
>>> print(sys.getsizeof(999999999))  # 28个字节
28
>>> print(sys.getsizeof(1000000000))  # 28个字节
28
>>> print(sys.getsizeof(1210101010))  # 32个字节
32
>>>

2. 字符串

  1. 字符串

    字符串是 UniCode 字符的有序序列 , 可以用置于首尾的单引号或双引号包围一个字符序列来 表示字符串。如果字符串的内容写在多行 , 则首尾分别要用三个单引号或双引号包围多行的字符 序列。

    单引号表示的字符串中可以包含双引号字符 , 但不能直接包含单引号(否则无法知道字符串 的开始结尾在哪里)。同样 , 双引号表示的字符串中可以包含单引号 , 但不能直接包含双引号。 例如:

    >>> print(" hello 'world' ")
 hello 'world'
>>> print(' hello "world" ')
 hello "world"
>>> print(''' hello "world"
... 'hello' world
... "hello world"
... ''')
 hello "world"
'hello' world
"hello world"

>>>

    单引号表示的字符串中不能直接包含单引号 , 双引号的字符串中也不能直接包含双引号。例如:

    >>> print(' 'hello' world')
  File "<stdin>", line 1
    print(' 'hello' world')
          ^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

    和 tuple 一样 , str 类型的对象也是不可修改的(immutable)。例如:

    >>> s = 'hello world'
>>> s[1] = 'E'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

    产生“字符串对象不支持赋值”的 TypeError(类型错误)

  2. 转义字符

    如果要在单引号表示的字符串中包含单引号 , 则可以在其前面添加反斜杠符号\构成一个单独的 字符。例如 , 用\'表示单引号字符 , 这种前面加反斜杠字符表示字符'的 \'称为"转义字符"。转义字符表示的是一个字符而不是两个字符。

    >>> print('hello \'li ping1\' ')
hello 'li ping1'

    既然反斜杠字符的特殊作用是表示“转义字符” , 那么如何表示反斜杠字符呢？办法是在它前面同样加上反斜杠字符 , 即转义字符\\表示的是单个斜杠字符\。例如:

    >>> print('hello \\')
hello \

    转义字符通常可以表示各种不可见的字符 , 如控制字符。例如 , \t 表示"制表符" , \n 表示"换行符"。因为这些字符是不可见的 , 所以函数 print()在遇到这些字符时会执行特定的动作。例如 , 对于制表符\t , 就输出固定个数的空格 , 对于换行符\n就换到新的一行。例如:

    >>> print('hello\tworld\n')
hello   world

>>> print('ok')
ok

    上例在输出的 hello 和 world 之间输出了固定个数的空格 , 并在换行符处换了一行。 同样可以用下标运算符[]访问字符串的一个或多个连续字符。例如 :

    >>> s = 'python programming'
>>> print(s[3])
h
>>> print(s[1:9])
ython pr

3. 列表

list 是一个数据元素的有序序列 , 定义列表时用一对左右方括号[ ]包围 , 元素之间用逗号隔开。 list 中的元素可以是不同的类型。例如:

[2, 3.14, 'python']

list 中的元素的类型是任意的 , 当然可以包含其他的 list 对象。例如:

[2, 3.14, [3,6,9],'python']

因为 list 是一个有序序列 , 所以其中的每个元素都有唯一的下标 , 下标从 0 开始 , 即第 1、2、 3、…元素的下标依次是 0、1、2、…。因此 , 对于 list 对象可以用下标运算符[]访问它的一个元素或一系列连续的元素。

>>> my_list =[2, 3.14, 8, 'python',9,'hello']
>>> print(type(my_list)) #打印 my_list 的类型 , 即 list 类型
<class 'list'>
>>> print(my_list)
[2, 3.14, 8, 'python', 9, 'hello']
>>> print(my_list[0])
2
>>> print(my_list[3])
python

还可以通过向下标运算符[ ]传递起始位置和结束位置的两个下标 , 返回连续多个元素组成的子列表(不包含结束位置的元素)。格式如下:

list[start:end]

起始位置和结束位置下标之间用冒号:隔开。例如:

>>> my_list =[2, 3.14, 8, 'python',9,'hello']
>>> print(my_list[1:4]) #从第 2 个到第 5 个 , 不包含第 5 个
[3.14, 8, 'python']
>>> print(my_list[2:]) #起始位置下标为 2 , 没有结束位置下标 , 表示从起始位置下标之后的所有元素
[8, 'python', 9, 'hello']
>>> print(my_list[:4]) #没有起始位置下标 , 表示起始位置下标默认为 0
[2, 3.14, 8, 'python']
>>> print(my_list[:]) #没有起始位置和结束位置下标 , 表示所有元素
[2, 3.14, 8, 'python', 9, 'hello']

list 对象是可修改的(mutable)。例如:

>>> my_list =[2, 3.14, 8, 'python',9,'hello']
>>> my_list[2]='小白'
>>> print(my_list)
[2, 3.14, '小白', 'python', 9, 'hello']

为指定下标范围内的元素重新赋值 , 从而替换为另一个 list。例如:

>>> my_list =[2, 3.14, 8, 'python',9,'hello']
>>> my_list[2:5]=[10,25]
>>> print(my_list)
[2, 3.14, 10, 25, 'hello']
>>>

为指定下标范围内的元素赋值一个空的 list[ ] , 相当于删除这个范围内的元素。例如:

>>> my_list=[2,3.14,10,25,'hello']
>>> my_list[2:4]=[] #相当于删除了[2:4]之间的元素 , 不包括下标为 4 的元素
>>> print(my_list)
[2, 3.14, 'hello']

必须给下标范围内的元素赋值一个 list 对象 , 如果赋值非 list 对象则会出错。例如:

>>> my_list[1:3]= 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable

4. 元组

和 list 一样 , 元组(tuple)也是一个有序序列 , 也就是每个元素也有唯一的下标 , 但 tuple 是不可修改的(immutable) , 另外 , 定义 tuple 时用圆括号而不是方括号。例如:

>>> t = ('python',[2,5],37,3.14,"https://a.hwdong.com")
>>> print(type(t))
<class 'tuple'>

可以用下标运算符[]访问 tuple 的元素:

>>> print(t[2])
37
>>> print(t[0:3])
('python', [2, 5], 37)
>>> print(t[:4])
('python', [2, 5], 37, 3.14)

但不可以通过下标修改 tuple 对象 , 因为 tuple 是不可修改的。例如:

>>> t[1] = 'helo'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

产生下列类型错误(TypeError)

这里需要注意 ,只有一个元素的 tuple 的最后必须加一个逗号 , 如(25,)表示一个 tuple , 而(25)表示一个整数

5. 集合

set 是不包含重复元素的无序集合。set 是用左右花括号{} , 包围的 , 以逗号隔开的一组元素。 因为集合无序 , 所以不能用下标操作其中的元素。例如:

>>> s = {2,3,'python',8}
>>> print(type(s))
<class 'set'>
>>> print(s)
{8, 'python', 2, 3}

set 中不能有相同值的元素。例如:

>>> s = {1,2,2,3,3,3}
>>> print(s)
{1, 2, 3}

集合是根据其元素的哈希值存储元素的 , 所以无法计算哈希值的对象不能作为集合的元素。例 如 , list 对象是无法计算哈希值的 , 所以不能作为集合的元素。例如:

>>> s = {2,3,[5,8]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>>

产生“list 不是可哈希的类型”的TypeError(语法错误)

6. 字典

dict 是一个“键-值”对(key-value pairs)的无序集合。 dict 中的每个元素都以“键:值(key:value)”的形式存储。例如:

>>> d = {1:'value','key':2,'hello':[4,7]}
>>> print(type(d))
<class 'dict'>
>>> print(d)
{1: 'value', 'key': 2, 'hello': [4, 7]}

需要通过 key(键 , 也称关键字)才能访问 dict 中 key 对应的值(value)。例如:

>>> d['hello']
[4, 7]
>>> d[1]
'value'
>>>

总结 :

  • Python 的内在数据类型包括 int、float、complex、bool , str , list、tuple、set、dict 等。

  • list 对象是可以修改的 , 而 str 和 tuple 等对象是不可修改的。

  • 对于有序序列数据类型 , 如 str、list、tuple , 可以通过下标访问其中的一个或多个元素 , 而 无序的 set 则不能用下标访问其中的元素。


熊熊

site logo

Hi,Friend

© 2025 cbear小站