我的Python学习之路-数据类型/运算符

　　(1)Cpython(官方推荐)
　　　　把python转化成c语言能识别的二进制码
　　(2)Jpython
　　　　把python转化成java语言能识别的二进制码
　　(3)其他语言解释器
　　　　把python转化成其他语言能识别的二进制码
　　(4)PyPy
　　　将所有代码一次性编译成二进制码,加快执行效率(模仿编译型语言的一款python解释器)

二、注释的用法

　　注释的含义：就是对代码的解释，方便阅读代码；

1.注释的分类

1 #print("hello world")

单行注释

 1 '''
 2 print("这个小伙看起来相貌堂堂,一表人才")
 3 print("这个小伙看起来文质彬彬,谈吐非凡")
 4 '''
 5 
 6 """
 7 print("这个小伙看起来相貌堂堂,一表人才")
 8 print("这个小伙看起来文质彬彬,谈吐非凡")
 9 
10 """

多行注释

2.注释的注意点

　　如果外面使用三个单引号，里面使用三个双引号，反之亦然。

 1 '''
 2 print("耿泽世这个小伙看起来相貌堂堂,一表人才")
 3 print("贾这个小伙看起来文质彬彬,谈吐非凡")
 4 
 5 """
 6 print("这个帅哥看起来浓眉大眼,樱桃小嘴")
 7 """
 8 print("何这个帅哥气质美如兰,才华腹如仙")
 9 print("李这个家伙衣冠禽兽,斯文败类")
10 '''

View Code

3.注释的排错性

　　运行程序时代码发生错误，可以根据报错提示行数，先注释一部分代码，然后执行另外一部分，看看是否报错，逐层缩小报错范围，找到最终错误点；

三、变量

1、变量概念

　　定义：可以改变的的量，实际上是指内存上的一块存储空间；

2、变量声明

1 # 方法一
2 a = 1
3 b = 2
4 # 方法二
5 a,b = 5,6
6 # 方法三
7 a = b = 90

View Code

3.变量的命名　

　　#字母数字下划线，首字符不能为数字
　　#严格区分大小写，且不能使用关键字
　　#变量命名有意义，且不能使用中文哦

4、变量的交换　　

 1 # 方法一
 2 a = 100
 3 b = 200
 4 a,b = b,a
 5 print(a,b)
 6 
 7 # 方法二
 8 a = 100
 9 b = 200
10 tmp = a 
11 a = b   
12 b = tmp 
13 print(a,b)

View Code

5、常量

　　常量就是不可改变的量，由于pyton没有常量的关键字，约定俗称的把变量名大写就当做常量使用；

四、python的六大数据类型初识

python中有六大数据类型：

　　　　(1)Number 数字类型 (int float bool complex)

　　　　(2)str 字符串类型

　　　　(3)list 列表类型
　　　　(4)tuple 元组类型
　　　　(5)set 集合类型
　　　　(6)dict 字典类型

1、数字 Number

　　（1）整型

　　　　十进制整型：intvar=13；

　　　　二进制整型：0b10；

　　　　八进制整型：0o17;

　　　　十六进制整型：0xff；

　　（2）浮点型 float（小数）

　　　　表示方法分为两类：1、小数 2 、科学计数法　　　

1 # 方法一
2 floatvar = 3.13
3 print( floatvar , type(floatvar) )
4 
5 # 方法二 科学计数法
6 floatvar = 3.66e3
7 floatvar =  4.32e-4
8 print(floatvar , type(floatvar))

View Code

　　（3）bool 布尔型

　　　　True（1）真；False（0），假；

　　（4）复数型

　　　　形如a+bj的数字就叫做复数，其中a叫做实数，b叫做虚数；

　　　　表示方法有两种：

 1 # 方法一
 2 complexvar = 3 + 4j
 3 print(complexvar , type(complexvar))
 4 
 5 # 方法二
 6 # 用法: complex(实数,虚数)
 7 res = complex(3,4)
 8 res = complex(3,-4)
 9 res = complex(0,5)
10 print(res , type(res));

View Code

2、字符串类型 str

　　特征:可获取,不可修改,有序

#1.单引号
strvar1='今天是周四,学习python第二课'
#2.双引号
strvar2="今天是周四,学习python第二课"
#3.三引号（支持跨行）
strvar3 = """
当学习不好的时候,就"照镜"子激励自己.
不然别人会说,这个人除了'好看'之后一无所有
"""

字符串格式化输出

# %d  整型占位符
strvar = "张三买了%d个苹果" % (5)
# %2d 整型占位符 (占两位)
"""占两位 , 不够两位拿空格来补位,原字符串局右"""
strvar = "张三买了%2d个苹果" % (5)
print(strvar)

# %-2d 整型占位符 (占两位)，原字符串局左
strvar = "张三买了%-2d个苹果" % (5)
print(strvar)

# %f 浮点型占位符 (默认小数位保留6位)
strvar = "每个月开%f元工资" % (3.8887)
# %.2f 浮点型占位符 (默认小数位保留2位) 存在四舍五入
strvar = "每个月开%.2f元工资" % (3.8887)
print(strvar)

# %s 字符串占位符
strvar = "%s" % ("方金顺真帅")
print(strvar)

转义字符： + 符号

、	换行
	缩进（水平制表符）
	把后面的字符串拉到本行行首

元字符串不产生转义,原型化输出字符串

pathvar = r"D:python33视频课件
otepad++"
#输出：D:python33视频课件
otepad++

3、列表 list

　　特征：可获取、可修改、有序

　　1、列表的定义　　

# 1.定义空列表
listvar = []

# 2.定义普通列表
listvar = [19,6.89,"你好",5-90j]

　　2、获取列表中的元素

# 正向索引   0    1       2    3
listvar = [19, 6.89,"你好",5-90j]
# 逆向索引 -4    -3    -2    -1
res = listvar[2] 
print(res)
#输出：你好

　　3.获取列表中最后一个元素

#1. 通过逆向索引下标
res = listvar[-1]
#2.获获取列表的长度-1
res = listvar[ len(listvar) - 1  ]

　　4.修改列表中的元素

listvar = [19,6.89,"你好",5-90j]
listvar[1] = "刘灵镇"
print(listvar)
#输出[19,6.89,"刘灵镇",5-90j]

4、元组类型 tuple

特点：可获取、不可修改、有序

　　1、元组的定义　

# 1.定义一个空元组
tuplevar = ()
print(tuplevar , type(tuplevar))

# 2 定义一个普通元组
# 正向索引    0       1        2       3        4
tuplevar = ("李琦","朱培峰","方金顺","黄昌建","刘文博")
# 逆向索引    -5      -4      -3      -2       -1

　　2.获取元组当中数据

res = tuplevar[3]
print(res)#输出:"黄昌建"

3.注意点

　　区分是否是元组,由逗号这个标识符来决定；

tuplevar = ("你好",)
tuplevar = (345,)
tuplevar = 1,2
tuplevar = 5,
#以上都是表示一个元组

5、集合 set

　　特征：无序、自动去重

　　1、定义一个集合　

#1.定义一个空集合
setvar1 = set()
# 2.定义一个普通集合
setvar2 = {"周杰伦","易烊千玺","王源","王俊凯"}

　　2.集合特征: 无序

# 是否可获取集合中的元素? 不行
# print(setvar[0]) error

# 是否可修改集合中的元素? 不行
# setvar[0] = "周润发"

　　3.集合特征: 自动去重

setvar = {"周杰伦","易烊千玺","王源","王俊凯","王文","王文","王文"}
print(setvar) 
#输出：{'王俊凯', '王文', '周杰伦', '易烊千玺', '王源'}

6、字典 dict

　字典里的数据以键值对的方式进行存储,表面上有序,实际上无序;　在python3.6版本之后,底层做了优化,存储时,记录了字典的定义顺序，在获取字典时,把无序存储的数据拿出来,按照定义字典的字面顺序重新排序;语法: {键1:值1,键2:值2 , .... }

　　1、字典的定义

#1、定义一个空字典
dictvar1={}
#2、定义一个普通的字典
dictvar = {"haq":"胡安庆","llz":"刘灵镇","wsf":"王生福","xhr":"熊海瑞"}

　　2.获取字典中的元素

res = dictvar["llz"]
print(res)
#输出：刘灵镇

　　3.修改字典中的元素

dictvar["xhr"] = "小黄人"
print（dictvar）
#{'haq': '胡安庆', 'llz': '刘灵镇', 'wsf': '王生福', 'xhr': '小黄人'}

集合和字典之间的注意事项

集合的值和字典的键有数据类型上的要求:
　　允许的数据类型 (可哈希的数据类型,不可变的数据类型): Number(int , float , bool ,complex) , str , tuple
　　不允许的数据类型(不可哈希的数据类型,可变的数据类型): list , set , dict

　　(了解)
　　字典的键和集合的值在底层内存存储时,使用了哈希算法，哈希算法的要求是该数据类型为不可变得数据类型才能够存储
　　哈希算法特点: 无序的散列;
　　为什么要提出哈希算法?

　　为了把数据均匀的存储在内存之后,减少哈希碰撞，让数据更快的存储在内存中.

知识扩展

isinstance:判断类型

语法一

isinstance( 要判断的数据,要判断的类型 ) ,如果该数据是这个类型,返回True,反之返回False

语法二

isinstance( 要判断的数据,(类型1,类型2,类型3 .... ) ), 如果该数据在后面的类型元组中,返回True,反之返回False

1 # 语法一
2 res = isinstance(111,int)
3 res = isinstance([] , tuple )
4 print(res)
5 
6 # 语法二
7 res = isinstance("你好",(int ,float,list,tuple ,str) )
8 res = isinstance({'a','b','c'},(int ,float,list,tuple ,str) )
9 print(res)

View Code

五、变量的缓存机制

1、在同一文件(模块)里,变量存储的缓存机制 (仅对python3.6版本负责)

　　1、Number 部分

　　1、对于整型而言，-5~正无穷范围内的相同值 id一致

　　2、对于浮点数而言，非负数范围内的相同值 id一致

　　3、3.布尔值而言,值相同情况下，id一致

　　4、复数在实数+虚数这样的结构中id永不相同(只有纯正虚数的情况例外)

　　2、容器类型部分

　　1、.字符串和空元组相同的情况下，地址相同

　　2、列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]

2、不同文件(模块)里,部分数据驻留小数据池中 (仅对python3.6版本负责了解)

　　用cmd运行python就是不同文件的条件下，验证不同文件下的变量缓存；

　　python在内存中创建了-5 ~ 256 范围的整数,提前驻留在了内存的一块区域.如果是不同文件(模块)的两个变量,声明同一个值，在-5~256这个范围里，那么id一致.让两个变量的值都同时指向一个值的地址，节省空间。

3、总结

　　无论是同一文件的缓存机制,还是不同文件的小数据池,都是为了提升执行的效率,减小空间损耗;

六、数据的类型转换

1、Number的强制类型转化

　　1、int的强制转换：

　　　　　init()　可以转换的类型为：整型、浮点数、布尔值、纯数字字符串

　　2、float的强制转换

　　　　　float() 可以转换的类型为：整型、浮点数、布尔值、纯数字字符串

　　3、complex的强制转换

　　　　　complex() 可以转换的类型为：整型、浮点数、布尔值、纯数字字符串、复数

　　4、bool 的强制转换

　　　　 bool() 没有数据类型的限制,可以转换一切数据类型

　　　　　布尔型为假的十种情况：0、0.0、0j、False、""、()、{}、set()、[]、None

　　　　　ps:None用于变量的初始化

2、Number 的自动类型转换

　　精度从高到底是：bool->int->float->complex

　　自动转化的原则是从低精度数据的向高精度的转化　

 1 # bool + int
 2 res = True + 100 # 1 + 100 => 101
 3 print(res , type(res))
 4 
 5 # bool + float
 6 res = True + 4.5 # 1.0 + 4.5 => 5.5
 7 print(res , type(res))
 8 
 9 # bool + complex
10 res = True + 6+3j # 1+0j  +  6+3j => 7 + 3j
11 print(res , type(res))
12 
13 # int + float
14 res = 120 + 3.14 # 120.0 + 3.14
15 print(res , type(res))
16 
17 # int + complex
18 res  =100 + 4-3j # 100 + 0j +4-3j
19 print(res , type(res))
20 
21 # float + complex
22 res = 5.67 + 3+3j # 5.67 + 0j + 3 + 3j
23 print(res , type(res)

View Code

　　知识扩展：精度损耗 (写程序时,不要用小数做比较的条件,会导致结果不准确,一般系统会把小数位截取15~18位而产生数据的误差)　

res = 0.1+0.2 == 0.3
print(res)#输出 False

3、容器类型的强制转化

　　str 强制转换成字符串：在原数据的两边套上引号,表达字符串的类型;可以强转一切数据；

　　list 强制转换成列表：　如果是字符串,把里面的字符一个个拿出来,作为列表的新元素

　　　　　　　　　　　　如果是字典,只保留字典的键,不要值
　　　　　　　　　　　　　如果是其他容器,就是单纯的把两边的符号换成[];

　　tuple 强制转换成元组：

　　　　　　　　　　　　如果是字符串,把里面的字符一个个拿出来,作为元组的新元素

　　　　　　　　　　　　如果是字典,只保留字典的键,不要值
　　　　　　　　　　　　如果是其他容器,就是单纯的把两边的符号换成();

　set 强制转换成集合:

　　　　　　　　　　如果是字符串,把里面的字符一个个拿出来,作为集合的新元素(无序,去重)
　　　　　　　　　　如果是字典,只保留字典的键,不要值(无序,去重)
　　　　　　　　　　如果是其他容器,就是单纯的把两边的符号换成{};

# ### 容器类型的强制转换 (str list tuple set dict)

var1 = "我爱你,就像老鼠爱大米"
var2 = [1,2,3]
var3 = ("景旭阳","孙翔宇","家营和","耿择世")
var4 = {"郝建康","白金鸽","杨特"}
var5 = {"hjk":"英明神武,瞳孔有力","bjg":"白面小生","yt":"兰陵王特质"}

# str 强制转换成字符串
"""特点: 在原数据的两边套上引号,表达字符串的类型;可以强转一切数据"""
res = str(var2)
res = str(var3)
res = str(var4)
print(res ,type(res))
# 原型化输出字符串 等价于r"" 元字符传
print(repr(res))

# list 强制转换成列表
"""
特点:如果是字符串,把里面的字符一个个拿出来,作为列表的新元素
     如果是字典,只保留字典的键,不要值
     如果是其他容器,就是单纯的把两边的符号换成[];
"""
res = list(var1)
res = list(var3)
res = list(var5)
print(res , type(res))

# tuple 强制转换成元组
"""
特点:如果是字符串,把里面的字符一个个拿出来,作为元组的新元素
     如果是字典,只保留字典的键,不要值
     如果是其他容器,就是单纯的把两边的符号换成();
"""
res = tuple(var1)
res = tuple(var4)
res = tuple(var5)
print(res , type(res))

# set 强制转换成集合
"""
特点:如果是字符串,把里面的字符一个个拿出来,作为集合的新元素(无序,去重)
     如果是字典,只保留字典的键,不要值(无序,去重)
     如果是其他容器,就是单纯的把两边的符号换成{};
"""
res = set(var1)
res = set(var3)
res = set(var5)
print(res , type(res))

View Code

　　dict()字典的强制转换：必须是等长的二级容器(里面的元素都是容器,且每个元素包含的元素个数相等),且元素个数是2个

　二级容器：　

# 二级列表
listvar = [1,2,3,4,[5,6,7]]

# 二级元组
tuplevar = (1,2,3,(4,5,6))

# 二级集合
setvar = {"a","b","c",(1,2,3)}
print(setvar)

# 二级字典
dictvar = {    "a":1,      "b" : {"c":3,"d":4}    }

字典强制转换的例子：

# 1.外面是列表,里面是列表或者元组
container = [ ["a",1],("b",2) ]
res = dict(container)
print(res , type(res)) # {'a': 1, 'b': 2} <class 'dict'>

# 2.外面是元组,里面是列表或者元组
container = ( ["a",1],("b",2) )
res = dict(container)
print(res , type(res)) # {'a': 1, 'b': 2} <class 'dict'>

# 3.外面是集合,里面是元组
container = { ("a",1) , ("b",2) }
res = dict(container)
print(res , type(res)) # {'a': 1, 'b': 2} <class 'dict'>

扩展：

# 情况一:额外扩展
"""语法ok , 但是由于集合是无需，导致键值不明确不符合本意,不推荐"""
container = [ ["a",1],("b",2),{"c",3} ]
res = dict(container)
print(res)

# 情况二:额外扩展
"""语法有很大局限性,字符串的个数必须是2个,不推荐"""
container = [["a",1],("b",2),"c3"]
res = dict(container)
print(res)

七、数据运算

1、算数运算符

运算符	描述 a=10 b=20	实例
+	加-两个对象相加	a+b=30
-	减-两个对象相减	a-b=-10
*	乘-两个对象相乘	a*b=200
/	除-两个对象相除（结果一定是小数）	b/a=2.0
%	返回余数	b%a=0
//	取整数-返回商的的整数部分(如果被除数或者除数身上有小数,在得到正常结果之后,加上.0)	9//2=4 9.0//4.0=2.0
**	幂运算	2**3=8

取余的具体使用方法：

先正常算出余数,如果被除数身上有负号,那么该余数身上补负号和除数相加，如果被除数或者除数身上都有符号,直接算出余数,然后前面套上负号即可　　　　

res = 7 % 4
res = -7 % 4  # -3 + 4 = 1
res = 7 % -4  # 3 + (-4) = -1
res = -7 % -4 # -3
res = -91 % 8 # -3 + 8 = 5
res = 91 % -8 # 3 + (-8) = -5
res = -91 % -8# -3

2.比较运算符

比较运算符只能得到2个结果,要么是True 真的 ,要么是False 假的（> < >= <= == !=）

res  = 5 > 3 # True
res = 6 <= 6 # True
res = 6 == 7 # False
res = 6 != 7 # True

3、赋值运算

运算符	描述	实例
=	简单赋值运算符	c=a+b
+=	加法赋值运算符	c+=a 等效于c=a+c
-=	减法赋值运算符	c-=a 等效于c=c-a
*=	乘法赋值运算符	c=a 等效于c=ac
/=	除法赋值运算符	c/=a 等效于c=c/a
%=	取模赋值运算符	c%=a 等效于c=c%a
**=	幂法赋值运算符	c=a 等效于c=ca
//=	取整除数法赋值运算符	c//=a 等效于c=c//a

4、成员运算符

　　 in 和 not in 针对于容器型数据，数据在容器内返回 True ，否则返False;在字典中只能判断“键”是否存在，不能判断“值”；

5、身份运算符

　　is 和 is not 检测两个数据在内存当中是否是同一地址

6、逻辑运算符

　　and：与全真则真,一假则假

　　or ：或一真则真,全假则假

　　not ：非真变假,假变真

逻辑短路:后面的代码不执行了

短路两种形式:

(1) True or 表达式

(2) False and 表达式

无论后面的表达式是什么,都无法改变最后的结果,会出现逻辑短路

# 逻辑运算符的优先级:  () > not > and > or
res = 5 or 6 and 7  # 5
res = 5 and 6 or 7  # 6
res = (5 or 6) and 7  #7
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => 短路返回前者

7、位运算符 (针对于二进制操作)

  1 var1 = 19
  2 var2 = 15
  3 
  4 # & 按位与
  5 res = var1 & var2
  6 print(res)
  7 """
  8 19:  00010011
  9 15:  00001111
 10 
 11 00010011
 12 00001111
 13 00000011  => 3
 14 """
 15 
 16 # | 按位或
 17 res = var1 | var2
 18 print(res)
 19 """
 20 19:  00010011
 21 15:  00001111
 22 
 23 00010011
 24 00001111
 25 00011111  => 31
 26 """
 27 
 28 # ^ 按位异或
 29 """两个值不一样时为真,反之为假"""
 30 res = var1 ^ var2
 31 print(res) # 28
 32 """
 33 19:  00010011
 34 15:  00001111
 35 
 36 00010011
 37 00001111
 38 00011100 => 28
 39 """
 40 
 41 # << 左移
 42 """公式: 5 乘以 2的n次幂 """
 43 res = 5 << 1 # 10
 44 res = 5 << 2 # 20
 45 res = 5 << 3 # 40
 46 res = 5 << 4 # 80
 47 print(res)
 48 """
 49 5 : 00000101  => 5
 50 向左移动一位
 51   : 00001010  => 10
 52 向左移动二位
 53   : 00010100  => 20
 54 向左移动三位
 55   : 00101000  => 40
 56 """
 57 
 58 # >> 右移
 59 """公式: 5 地板除 2的n次幂"""
 60 res = 5 >> 1 # 2
 61 res = 5 >> 2 # 1
 62 res = 5 >> 3 # 0
 63 print(res)
 64 """
 65 5 : 00000101  => 5
 66 向右移动一位
 67   : 00000010  => 2
 68 向右移动二位
 69   : 00000001  => 1
 70 向右移动三位
 71   : 00000000  => 0
 72 """
 73 
 74 # ~ 按位非
 75 """公式: -(n+1)"""
 76 # (按位非是让二进制的每一位都取反,包含符号位)
 77 res = ~19
 78 print(res)
 79 """
 80 19
 81 原码: 0 000 ... 10011
 82 反码: 0 000 ... 10011
 83 补码: 0 000 ... 10011
 84  
 85 0 000 ... 10011
 86 按位非: 
 87 1 111 ... 01100
 88 
 89 给你补码 -> 求原码
 90 补码: 1 111 ... 01100
 91 反码: 1 000 ... 10011
 92 原码: 1 000 ... 10100 => -20
 93 """
 94 
 95 res = ~(-19)
 96 print(res)
 97 """
 98 -19
 99 原码: 1 000 ... 10011
100 反码: 1 111 ... 01100
101 补码: 1 111 ... 01101
102 
103 按位非: 
104 1 111 ... 01101
105 0 000 ... 10010
106 
107 给你补码 -> 求原码
108 0 000 ... 10010 (正值 : 原码 = 反码 = 补码) => `18
109 """

View Code

总结：

个别运算符:

优先级最高的: **

优先级最低的: =

整体运算符:

一元运算符 : 同一时间操作一个数值 (- , ~)

二元运算符 : 同一时间操作二个数值 (+,-,* , / ....)

一元运算符 > 二元运算符:

同一种类运算符:

算术运算符: 先算乘除,再算加减

逻辑运算符: () > not > and > or

位运算符 : ( << >> ) > & > ^ > |

所有大类运算符:

算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符

赋值运算符做收尾;

相关阅读:
软考-高项
 Env Navigator项目设计
 传统Winform系统的转小程序化设想
 .net 混淆和反混淆工具
 ObjectListView 使用技巧
 Dapr资料汇总
 Keycloak保护Spring Boot Restful API接口
 将B站英语教学视频转成mp3和课件
 Java: 如何将XML格式化
 Java: 非泛型类如何设计List<T>这样的属性
原文地址：https://www.cnblogs.com/yj0405/p/14008111.html

我的Python学习之路-数据类型/运算符

一、python认知

1、python 简介

2、python 版本

3、编译性语言和解释性语言的区别

4、python解释器

二、注释的用法

1.注释的分类

2.注释的注意点

3.注释的排错性

三、变量

1、变量概念

2、变量声明

3.变量的命名

4、变量的交换

5、常量

四、python的六大数据类型初识

1、数字 Number

（1）整型

（2）浮点型 float（小数）

2、字符串类型 str

3、列表 list

1、列表的定义

2、获取列表中的元素

3.获取列表中最后一个元素

4.修改列表中的元素

4、元组类型 tuple

1、元组的定义

2.获取元组当中数据

3.注意点

5、集合 set

1、定义一个集合

2.集合特征: 无序

3.集合特征: 自动去重

6、字典 dict

1、字典的定义

2.获取字典中的元素

3.修改字典中的元素

集合和字典之间的注意事项

知识扩展

五、变量的缓存机制

1、在同一文件(模块)里,变量存储的缓存机制 (仅对python3.6版本负责)

1、Number 部分

2、容器类型部分

2、不同文件(模块)里,部分数据驻留小数据池中 (仅对python3.6版本负责 了解)

3、总结

六、数据的类型转换

1、Number的强制类型转化

1、int的强制转换：

2、float的强制转换

3、complex的强制转换

4、bool 的强制转换

2、Number 的自动类型转换

3、容器类型的强制转化

七、 数据运算

1、算数运算符

取余的具体使用方法：

2.比较运算符

3、赋值运算

4、成员运算符

5、身份运算符

6、逻辑运算符

7、位运算符 (针对于二进制操作)

总结：

3.变量的命名　

4、变量的交换　　

　　（1）整型

　　（2）浮点型 float（小数）

　　1、列表的定义　　

　　2、获取列表中的元素

　　3.获取列表中最后一个元素

　　4.修改列表中的元素

　　1、元组的定义　

　　2.获取元组当中数据

　　1、定义一个集合　

　　2.集合特征: 无序

　　3.集合特征: 自动去重

　　1、字典的定义

　　2.获取字典中的元素

　　3.修改字典中的元素

　　1、Number 部分

　　2、容器类型部分

2、不同文件(模块)里,部分数据驻留小数据池中 (仅对python3.6版本负责了解)

　　1、int的强制转换：

　　2、float的强制转换

　　3、complex的强制转换

　　4、bool 的强制转换

七、数据运算