变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。
标准数据类型
在内存中存储的数据可以有多种类型。
例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。
Python 定义了一些标准类型，用于存储各种类型的数据。
Python有五个标准的数据类型：
- List item
- Numbers（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Dictionary（字典）
import dataType
if __name__ == '__main__':
try:
print('数据类型开始：')
Number1 = 3;
Number2 = 5;
dataTypeObj = dataType(Number1,Number2);
dataTypeObj.dataTypemethord()
print('数据类型结束：')
except BaseException as Argument:
print(Argument)
except ValueError as Argument:
print(Argument)class dataType:
def __init__(self, Number1, Number2):
self.Number1 = Number1
self.Number2 = Number2
# 数据类型
# 数字
def dataTypemethord(self):
print('这是一个数字Number1：', self.Number1);
print('这是一个数字Number2：', self.Number2);
print('这是一个数字Number1和Number2：',self.Number1, self.Number2);
del self.Number2;
print('删除一个数字Number2，name \'Number2\' is not defined,name \'Number1\'的值为：', self.Number1);
a = 21
b = 10
c = 0
print ("a的值为：", a)
print ("b的值为：", b)
print ("c的值为：", c)
c = a + b
print ("c = a + b的值为：", c)
c = a - b
print ("c = a - b的值为：", c )
c = a * b
print ("c = a * b 的值为：", c)
c = a / b
print ("c = a / b的值为：", c )
c = a % b
print ("c = a % b 的值为：", c)
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print ("a的值为：", a)
print ("b的值为：", b)
print ("c = a**b的值为：", c)
a = 10
b = 5
c = a//b
print ("a的值为：", a)
print ("b的值为：", b)
print ("c = a//b的值为：", c)
Int = 123;
print('int数据类型：',Int);
float = 12.3;
print('float数据类型：',float);
complex = 3.14j;
print('float数据类型：',complex);
# 字符串
NXD = 'nxd';
String = '字符串';
print('NXD的数据类型是：' + String);
print('NXD字符为：' + NXD);
print('NXD第一个字符为：' + NXD[0]);
print('NXD第二个字符为：' + NXD[1]);
print('NXD第三个字符为：' + NXD[2]);
print('NXD[0:2]包含第一个，不包含最后一个：' + NXD[0:2]);
letters = ['a','b','c','d','e','f'];
print('列表截取一步一跳letters[0:letters.__len__():1],列表长度:' , letters.__len__() , letters[0:letters.__len__():1]);
print('列表截取二步一跳letters[0:letters.__len__():2],列表长度：' , letters.__len__() , letters[0:letters.__len__():2]);
print('列表截取三步一跳letters[0:letters.__len__():3],列表长度：' , letters.__len__() , letters[0:letters.__len__():3]);
print('列表截取一步一跳letters[0:4:1],列表长度:' , letters.__len__()-1 , letters[0:4:1]);
print('列表截取二步一跳letters[0:4:2],列表长度：' , letters.__len__()-1 , letters[0:4:2]);
print('列表截取三步一跳letters[0:4:3],列表长度：' , letters.__len__()-1 , letters[0:4:3]);
print('列表截取letters[1:3],列表长度：' , letters.__len__() , letters[1:3]);
print('列表截取letters[:6],列表长度：' , letters.__len__() , letters[:6]);
print('列表截取letters[3:],列表长度：' , letters.__len__() , letters[3:]);
print('列表截取letters[:],列表长度：' , letters.__len__() , letters[:]);
# !/usr/bin/python
# -*- coding: UTF-8 -*-
list = ['runoob', 786, 2.23, 'john', 70.2];
tinylist = [123, 'john'];
print ('输出完整列表list：',list); # 输出完整列表
print ('输出完整列表tinylist：',tinylist); # 输出完整列表
print ('打印组合的列表list + tinylist：',list + tinylist); # 打印组合的列表
print ('输出列表两次list * 2：',list * 2); # 输出列表两次
print ('输出列表两次tinylist * 2：',tinylist * 2); # 输出列表两次
print ('输出列表的第一个元素list[0]：',list[0]); # 输出列表的第一个元素
print ('输出第二个至第三个元素list[1:3]：',list[1:3]); # 输出第二个至第三个元素
print ('输出从第三个开始至列表末尾的所有元素list[2:]：',list[2:]); # 输出从第三个开始至列表末尾的所有元素
tuple = ('runoob', 786, 2.23, 'john', 70.2)
tinytuple = (123, 'john')
print ('输出完整元组tuple：',tuple) # 输出完整元组
print ('输出完整元组tuple：',tinytuple) # 输出完整元组
print ('打印组合的元组tuple + tinytuple：',tuple + tinytuple) # 打印组合的元组
print ('输出元组两次tuple * 2：',tuple * 2) # 输出元组两次
print ('输出元组两次tinytuple * 2：',tinytuple * 2) # 输出元组两次
print ('输出元组的第一个元素tuple[0]：',tuple[0]) # 输出元组的第一个元素
print ('输出第二个至第四个（不包含）的元素tuple[1:3]：',tuple[1:3]) # 输出第二个至第四个（不包含）的元素
print ('输出从第三个开始至列表末尾的所有元素tuple[2:]：',tuple[2:]) # 输出从第三个开始至列表末尾的所有元素元组(tuple)和列表（list）区别
list 是可变的对象，元组 tuple 是不可变的对象！
由于 tuple 不可变，所以使用 tuple 可以使代码更安全！等等 ...- 函数返回（return）多个值
从打印结果可以看出，这里返回值就是一个tuple！由于在语法上，返回一个tuple是可以省略括号的，而多个变量可以同时接收一个tuple，按位置赋给对应的值。
所以，Python的函数返回多值时，其实就是返回一个tuple。
2. tuple 不可变的好处
相对于 list 而言，tuple 是不可变的
可变的list>>> name=['cong','rick','long']
>>> name[-2] #等同于name[1]
'rick'
>>> name.append('tony')
>>> name.insert(0,'bob') #在第一个位置即索引0处插入bob
>>> name.insert(2,'Jam')
>>> name
['bob', 'cong', 'Jam', 'rick', 'long', 'tony']
>>> name.pop() #删除最后的元素
'tony'
>>> name.pop(0) #删除第一个元素
'bob'
>>> name
['cong', 'Jam', 'rick', 'long']不可变的tuple>>> month=('Jan','Feb','Mar')
>>> len(month)
3
>>> month
('Jan', 'Feb', 'Mar')
>>> month[0]
'Jan'
>>> month[-1]
'Mar'
>>> month.appnd('Apr') #编辑元素内容会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'appnd'若要编辑通过tuple定义的元素，可先转换为list再编辑：>>> month_1=list(month) #转换为list
>>> month_1
['Jan', 'Feb', 'Mar']
>>> month_1.append('Apr') #可追加
>>> month_1
['Jan', 'Feb', 'Mar', 'Apr']
>>> month
('Jan', 'Feb', 'Mar')
>>> month=tuple(month_1) #转回tuple
>>> month
('Jan', 'Feb', 'Mar', 'Apr')tuple 放弃了对元素的增删（内存结构设计上变的更精简），换取的是性能上的提升：创建 tuple 比 list 要快，存储空间比 list 占用更小。所以就出现了“能用 tuple 的地方就不用 list”的说法。
多线程并发的时候，tuple 是不需要加锁的，不用担心安全问题，编写也简单多了。
二、元组到底可不可以被修改
1、创建和访问一个元组如果创建一个空元组，直接使用小括号即可；
如果要创建的元组中只有一个元素，要在它的后面加上一个逗号‘，’。
>>> temp = ()
>>> type(temp)
<class 'tuple'>
>>> temp = (1,)
>>> type(temp)
<class 'tuple'>
>>> temp = (1)
>>> type(temp)
<class 'int'>
>>> 8 * (8)
64
>>> 8 * (8,)
(8, 8, 8, 8, 8, 8, 8, 8)元组里只有一个元素的时候，逗号（，）非常重要
2、更新和删除元组
直接在同一个元组上更新是不可行的，可以通过拷贝现有的元组片段构造一个新的元组的方式解决。
通过分片的方法让元组拆分成两部分，然后再使用连接操作符（+）合并成一个新元组，最后将原来的变量名（temp）指向连接好的新元组。在这里就要注意了，逗号是必须的，小括号也是必须的！
创建实例后调用def __init__(self) 实例化属性
定义初始化方法的格式是def __init__(self)，是由init加左右两边的【双】下划线组成（ initialize “初始化”的缩写）
初始化方法的作用在于：当每个实例对象创建时，该方法内的代码无须调用就会自动运行。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
