Python3 数据类型

变量只是保留内存位置来存储值。 这意味着当你创建一个变量时，你在内存中保留了一些空间。

根据变量的数据类型，解释程序分配内存并决定可以在保留内存中存储的内容。 因此，通过为变量分配不同的数据类型，可以在这些变量中存储整数，小数或字符。

赋值给变量

Python变量不需要显式声明来保留内存空间。 当您为变量赋值时，声明会自动发生。 等号（=）用于赋值给变量。

=运算符左侧的操作数是变量的名称，=运算符右侧的操作数是存储在变量中的值。 例如 -

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
  • 07
  • 08
  • 09
#!/usr/bin/python3

counter = 100          # An integer assignment
miles   = 1000.0       # A floating point
name    = "John"       # A string

print (counter)
print (miles)
print (name)

这里，100,1000.0和“John”分别是分配给计数器，英里和名称变量的值。 这会产生以下结果 −

  • 01
  • 02
  • 03
100
1000.0
John

多重分配

Python允许您同时为多个变量分配单个值。例如 -

  • 01
a = b = c = 1

在这里，用值1创建一个整型对象，并将所有这三个变量分配给相同的内存位置。 您也可以将多个对象分配给多个变量。 例如 -

  • 01
a, b, c = 1, 2, "john"

这里，将两个值分别为1和2的整数对象分别分配给变量a和b，并将一个值为“john”的字符串对象分配给变量c。

标准数据类型

存储在内存中的数据可以有多种类型。 例如，一个人的年龄被存储为一个数值，他或她的地址被存储为字母数字字符。 Python有各种标准数据类型，用于定义可能的操作以及每种操作的存储方法。

Python有五种标准数据类型 -

  • Number（数字）
  • String（字符串）
  • List（列表）
  • Tuple（元组）
  • Dictionary（字典）

Number（数字）

Number数据类型存储数字值。 数字对象在您为其分配值时创建。 例如 -

  • 01
  • 02
var1 = 1
var2 = 10

您也可以使用del语句删除对数字对象的引用。 del语句的语法是 -

  • 01
del var1[,var2[,var3[....,varN]]]]

您可以使用del语句删除单个对象或多个对象。例如 -

  • 01
  • 02
del var
del var_a, var_b

Python支持三种不同的数字类型 -

  • int（有符号整数）
  • float（浮点数实数值）
  • complex（复数）

Python3中的所有整数都表示为长整数。 因此，没有单独的数字类型。

以下是一些数字的例子 -

int float complex
10 0.0 3.14j
100 15.20 45.j
-786 -21.9 9.322e-36j
080 32.3+e18 .876j
-0490 -90. -.6545+0J
-0x260 -32.54e100 3e+26J
0x69 70.2-E12 4.53e-7j

一个复数由一个由x + yj表示的有序实浮点数组成，其中x和y是实数，j是虚数单位。

String（字符串）

Python中的字符串被标识为用引号表示的一组连续的字符。 Python允许使用一对单引号或双引号。 可以使用slice操作符（[]和[：]）来获取字符串的子集，索引从字符串开头的0开始，从-1到结束。

加号（+）是字符串连接运算符，星号（*）是重复运算符。 例如 -

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
  • 07
  • 08
  • 09
  • 10
#!/usr/bin/python3

str = 'Hello World!'

print (str)          # Prints complete string
print (str[0])       # Prints first character of the string
print (str[2:5])     # Prints characters starting from 3rd to 5th
print (str[2:])      # Prints string starting from 3rd character
print (str * 2)      # Prints string two times
print (str + "TEST") # Prints concatenated string

这将产生以下结果 −

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

List（列表）

列表是Python的复合数据类型中功能最多的。 列表包含用逗号分隔的项目，并用方括号（[]）括起来。 在某种程度上，列表与C中的数组类似。它们之间的差异之一是属于列表的所有项目可以具有不同的数据类型。

存储在列表中的值可以使用slice操作符（[]和[：]）进行访问，索引从列表开始的0开始，并以结束-1的方式工作。 加号（+）是列表级联运算符，星号（*）是重复运算符。 例如 -

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
  • 07
  • 08
  • 09
  • 10
  • 11
#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print (list)          # Prints complete list
print (list[0])       # Prints first element of the list
print (list[1:3])     # Prints elements starting from 2nd till 3rd 
print (list[2:])      # Prints elements starting from 3rd element
print (tinylist * 2)  # Prints list two times
print (list + tinylist) # Prints concatenated lists

这产生了以下结果 -

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
['abcd', 786, 2.23, 'john', 70.200000000000003]
abcd
[786, 2.23]
[2.23, 'john', 70.200000000000003]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']

Tuple（元组）

元组是另一种与列表相似的序列数据类型。 一个元组由多个用逗号分隔的值组成。 然而，与列表不同，元组被括在括号内。

列表和元组的主要区别是 - 列表括在括号（[]）中，它们的元素和大小可以更改，而元组括在括号（）中并且不能更新。 元组可以被认为是只读列表。 例如 -

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
  • 07
  • 08
  • 09
  • 10
  • 11
#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
tinytuple = (123, 'john')

print (tuple)           # Prints complete tuple
print (tuple[0])        # Prints first element of the tuple
print (tuple[1:3])      # Prints elements starting from 2nd till 3rd 
print (tuple[2:])       # Prints elements starting from 3rd element
print (tinytuple * 2)   # Prints tuple two times
print (tuple + tinytuple) # Prints concatenated tuple

这会产生以下结果 −

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
('abcd', 786, 2.23, 'john', 70.200000000000003)
abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

下面的代码对元组无效，因为我们试图更新一个不允许的元组。 类似的情况是可能的列表 −

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
list = [ 'abcd', 786 , 2.23, 'john', 70.2  ]
tuple[2] = 1000    # Invalid syntax with tuple
list[2] = 1000     # Valid syntax with list

Dictionary（字典）

Python的字典是一种散列表类型。 它们像Perl中的关联数组或哈希函数一样工作，并由键值对组成。 字典键可以是几乎任何Python类型，但通常是数字或字符串。 另一方面，值可以是任意的Python对象。

字典由大括号（{}）括起来，并且可以使用方括号（[]）分配和访问值。 例如 -

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
  • 07
  • 08
  • 09
  • 10
  • 11
  • 12
  • 13
#!/usr/bin/python3

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print (dict['one'])       # Prints value for 'one' key
print (dict[2])           # Prints value for 2 key
print (tinydict)          # Prints complete dictionary
print (tinydict.keys())   # Prints all the keys
print (tinydict.values()) # Prints all the values

这会产生以下结果 −

  • 01
  • 02
  • 03
  • 04
  • 05
This is one
This is two
{'name': 'john', 'dept': 'sales', 'code': 6734}
dict_keys(['name', 'dept', 'code'])
dict_values(['john', 'sales', 6734])

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数 描述
int(x [,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) >转换为可变集合
dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串