文章中有小白没有叙述明白的欢迎大家给小白留言哟。 Python的基本数据类型主要分为两种，数值数据类型、字符串数据类型。除了这两种之外还有元组类型、集合类型、列表类型、字典类型等。
Ⅰ.数值数据类型(number)
表示数字或是数值的数据类型成为数字类型数据类型分为四种：
整数(int)：可用十进制(d)、十六进制(x)、八进制(o)、二进制(d)等不同进制形式。 浮点数(float)：可以表示带有小数点的一般形式，也可以用科学计数 法表示。 复数(complex)：复数类型与数学中的复数相一致，采用a+bj的形式表示，存在实部和虚部。 布尔型(bool)：判断表达式的真假，若为真则为1，若为假，则为0。
以上只是一些基础概念对于数据的操作可与数学中有一些区别！
(print()为Python中的输出函数，后续文章中详细解释)
Ⅱ.字符串数据类型(str)
字符串是一个有序字符的集合，用于存储和表示基本的文本信息，但是只能存放一个值，一经定义，不可改变。 是用两个双引号""或者两个单引号''括起来，同时使用反斜杠\转义特殊字符的一个或多个字符。 字符串的截取：变量[头下标:尾下标] 咚咚咚 敲黑板了，中括号里面的取值范围可是“左闭右开”的。既包含头下标的字符，不包含尾下标的字符。
索引值以0为开始值，-1为从末尾的开始位置，如下所示
加号+是字符串的连接符，星号*表示复制当前字符串，紧跟的数字为复制的次数。 Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串。 我们通过下面的列子一起来学习一下对字符串的操作，小白认为很有趣哦。
Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串
Ⅲ.元组类型
元组的创建：元组的定义通常是由逗号分隔,或由圆括号括住的一个序列
元组的访问和切片：通过单个索引可以获得该索引位置的元素，但是只能读，不能修改。通过切片可以获得由若干个元素构成的子元组。
元组操作符：+ 用于合并元组，* 用于重复元组
删除整个元组：用del 元组名来删除整个元组
元组的函数与方法：在列表的函数和方法中，除append,extend和insert这三个方法之外，其他的函数和方法都可以用于元组
元组的创建
元组的创建语法 定义由逗号分隔，或用圆括号括起来一个序列，元组内的数据类型可以不一致。圆括号也可以省略，示例如下
需要注意的是，当元组只有一个元素时，需要在元素后面添加逗号，否则括号会被当做运算符使用，如下示例
元组的访问
元组的访问和字符串的访问一样，都是通过下标索引来进行访问，如下所示
元组的修改
元组为不可变类型，即一经定义，不可修改。但是我们可以换一种思路，通过元组的截取、元组与元组之间的连接来形成新的元组，示例如下
元组的删除
由于元组为不可变类型，我们不能删除元组内的值，但我们可以通过del语句来删除整个元组。我们删除上文中的tup4元组，若显示tup4元组不存在即删除成功，示例如下
元组的相关运算
“+”号为字符串连接符，如下所示连接tup1和tup2形成新的元组tup3,在元组的修改中已有相关实验，这里不再详述。 使用*号实现对元组的复制，*后面的数字是几就是复制几次，示例如下
判断元素，如下示例，我们判断某个元素是否存在于元组的内部，用in关键字，若存在返回真(Ture)，不存在返回假(False)。
元组的函数
求元组的长度，求元组的长度使用运算函数len(),求最大值用max()函数，最小值min()函数。示例如下
Ⅳ.列表类型
List(列表) 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓嵌套)。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。(元组的圆括号可以省略，列表的方括号不可以省略。
列表和字符串一样，是可变数据类型，俗称Python的苦力。列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表的创建
列表创建的语法
列表名=[列表元素]
同一列表中的数据元素不一定相同，字符串需要用单引号或双引号引起的，如下示例
列表的简单操作
列表同字符串和元组一样，可以通过索引被截取。如下第一个示例。
列表的元素判断与元组不同，元组用的是关键字in,而列表用的是index()函数。如下第二个示例。
列表开始干苦力的地方来了，如下示例第三个和第四个分别是列表元素的追加(使用的是append()函数)，列表元素的移除(使用的是remove()函数)。
访问列表元素的值，通过切片访问，注意方括号的范围可是左闭右开的集合(即包含左边数据为下标的值，不办含右边数据为下标的值。 更新列表内元素值可以通过下标值直接赋给新的值 删除列表内元素值使用del语句实现
列表的遍历
列表遍历需要借助for循环，语法为：
for 变量名 in 列表名：
print(变量名)
需要提醒大家的是，for循环语句后的冒号不可省略，否则会出编译错误。Python是一门缩进严格的语言，print()语句为Python的子句，必须缩进，缩进几个字符无要求(若代码多，同一级的语句缩进必须一致)。
列表的嵌套
列表的嵌套也就是列表中包含列表，如下示例
列表的函数
len(列表名)返回列表元素个数
max(列表名)返回列表元素中的最大值
min(列表名)返回列表元素中的最小值
list( 元组名 )用于将元组转换为列表
前三个函数在上述实验中已有涉及，不再详述，将元组转换为列表的函数如下所示
列表的方法
list.append(obj)使用于在列表末尾添加新的对象
list.count(obj)使用于统计某个元素在列表中出现的次数
list.extend(seq)使用于在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj)使用于从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)使用于将指定对象插入列表的指定位置
list.pop([index=-1])使用于移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
list.remove(obj)使用于移除列表中某个值的第一个匹配项
list.reverse()使用于反向列表中元素
list.sort(cmp=None, key=None, reverse=False)
使用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序
reverse -- 排序规则，reverse = True 降序， reverse = False 升序(默认)
sort 方法不适合 int 和 str 类型的比较
list.clear()使用于清空列表，类似于 del a[:]
list.copy()使用于复制列表，类似于 a[:]
copy()和直接=赋值的区别：使用=直接赋值，是引用赋值，更改一个，另一个同样会变, copy() 则复制一个副本，原值和新复制的变量互不影响
Ⅴ.集合类型(Set)
集合：由不重复元素组成的无序的集。特殊的字典(下文中有涉及)，相当于字典中的key。基本用法：成员的检测和重复元素的消除。集合对象也支持像并集、交集、差 集、对称差等数学运算。集合(set)是一个无序不重复元素的序列，使用{}或者set()函数创建集合，需要注意的是：创建一个空集合必须用set()而不用{}，{}的用法是创建一个空字典。集合除了可以做集合运算之外，也可以被添加和删除集合元素。但是集合不能使用切片更不能使用索引。我们一起看一下下面的实验：
在这里我们扩展一下，我们除了利用集合去重，也可以使用流程控制去重，不过要比利用集合多几行代码，跟小白来一起看一下下面的实验。
集合的创建可以使用大括号{}或set()函数创建集合，创建语法：SetName={value1, value2, value3, value4} 或 set(value1,value2,value3,value4) 注意：创建一个空集合必须用set()而不用{}，{}的用法是创建一个空字典。
集合的基本操作
1、添加元素
语法格式
setname.add(n)
将元素n添加到集合setname中，若元素n已经存在，则不进行任何操作。如下实例。
继续对set1集合添加元素python,结果如下所示。
除了上述的方法以外，我们还可以用update()来添加元素，并且参数可以是列表，元组 ， 字典等，语法如下setname.update(n)参数n可以是一个也可以是多个，多个参数需要用逗号间隔。如下示例
2、移除元素方法1语法格式： setname.remove(n)将元素n从集合setname里面移除，若元素不存在，则会发生错误，如下示例。
方法2 语法 setname.discard(n)此种方法在元素不存在时，不会发生错误，如下所示
方法3语法setname.pop()此种方法设置随机删除其中的一个元素，如下所示。
3、计算集合元素个数语法len(setname)计算集合setname元素个数
4、清空集合语法setname.clear()清空集合setname,示例如下。
5、判断元素是否存在语法x in setname判断元素x是否在集合setname中，存在返回Ture,不存在返回False.
6、集合运算集合之间的运算符分别是‘-’、‘|’、‘&’、‘^’；作用如下： ‘ - ’：代表前者中包含后者中不包含的元素 ‘ | ’：取并集，两者中全部元素聚在一起去重后的结果 ‘&’：取交集，两者中都包含的元素 ‘^’：异或运算(可以理解为补集)，不同时包含于两个集合中的元素 集合的内置方法difference() 返回集合的差集，返回的集合元素包含在第一个集合中，不包含在第二个集合中，得到一个新的集合。 difference_update() 移除两个集合中都存在的元素。在原始集合上移除。intersection() 返回两个或更多集合中都包含的元素(交集)，得到一个新集合。 intersection_update() 返回两个或更多集合中都包含的元素(交集)，在原始集合上移除。 union() 返回两个集合的并集，即两者中全部元素聚在一起去重后的结果。 isdisjoint() 判断两个集合是否包含相同的元素，若没有返回Ture,否则返回False。 issubset() 判断集合的所有元素是否包含在指定集合中，若是返回Ture,否则返回False。 issuperset() 判断指定集合的所有元素是否都包含在原始的集合中，若是返回Ture,否则返回False。 symmetric_difference() 返回两个集合中不重复的元素集合，即移除两个集合中都存在的元素，结果返回一个新的集合。 symmetric_difference_update() 移除两个集合中都存在的的元素，并将另一个集合中不同的元素插入到当前集合。 Ⅵ、字典类型(dict) 字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
字典的创建 语法 d = {key1 : value1, key2 : value2 } 键必须是唯一的，但值则不必。
值可以取任何数据类型，键也可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
dict = {'a': '97', 'b': '98', 'c': '99'}dict1 = { 'abc': 979899};dict2 = { 'abc': 999, 98.6: 37 };
字典的访问
#访问字典里的值#!/usr/bin/python3dict = {'a': '97', 'b': '98', 'c': '99'}print ("dict['a']: ", dict['a'])#输出结果 dict['a']: 97print ("dict['c']: ", dict['c'])
字典的修改
dict = {'a': '97', 'b': '98', 'c': '99'}dict['a']=9797print ("dict['a']: ", dict['a'])#输出的结果 dict['a']: 9797
删除字典元素
dict = {'a': '97', 'b': '98', 'c': '99'}del dict['a'] # 删除键 'a'print(dict)#输出{'b': '98', 'c': '99'}dict.clear()# 清空字典print(dict)#输出{}del dict # 删除字典print(dict)#输出
字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。 1、不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住,如下所示。
dict = {'a': '97', 'b': '98', 'c': '99','a':'9090'}print("dict['a']:",dict['a'])#输出结果 dict['a']: 9090
2、键必须不可变，所以可以用数字，字符串或元组充当，而不能用列表和集合
#!/usr/bin/python3dict = {('Name'): 'xiaobai','9':'aaa', 'Age': 1 }print ("dict['Name']: ", dict['Name'])#输出结果 dict['Name']: xiaobaidict = {('Name'): 'xiaobai','9':'aaa', ['Age']: 1 }print ("dict['Name']: ", dict['Name'])#输出结果---------------------------------------------------------------------------TypeError Traceback (most recent call last)in ----> 1 dict = {('Name'): 'xiaobai','9':'aaa', ['Age']: 1 } 2 print ("dict['Name']: ", dict['Name'])TypeError: unhashable type: 'list'#提示错误不能使用列表类型dict = {('Name'): 'xiaobai','9':'aaa', {'Age'}: 1 }print ("dict['Name']: ", dict['Name'])#输出结果---------------------------------------------------------------------------TypeError Traceback (most recent call last)in ----> 1 dict = {('Name'): 'xiaobai','9':'aaa', {'Age'}: 1 } 2 print ("dict['Name']: ", dict['Name'])TypeError: unhashable type: 'set'#提示错误不能使用集合类型
字典的函数
len(dict)计算字典元素个数，即键的总数 str(dict)输出字典，以可打印的字符串表示 type(variable)返回输入的变量类型，如果变量是字典就返回字典类型
dict = {('Name'): 'xiaobai','9':'aaa', 'Age': 1 }len(dict)#输出结果：3str(dict)#输出结果："{'Name': 'xiaobai', '9': 'aaa', 'Age': 1}"type(dict)#输出结果：dict#注意这里输出的是dict的类型而不是字典名
字典的方法
dict.clear() 用于删除字典内所有元素
#!/usr/bin/python3dict = {'Name': 'xiaobai', 'Age': 0, 'Sex':1}print ("字典长度 : %d" % len(dict))#输出结果 字典长度 : 3dict.clear()print ("字典删除后长度 : %d" % len(dict))#输出结果 字典删除后长度 : 0
dict.copy() 返回一个字典的浅复制
#!/usr/bin/python# -*- coding: UTF-8 -*-dict1 = {'Name': 'xiaobai', 'Age': 0, 'Number':[1,2,3]}dict2 = dict1 # 浅拷贝: 引用对象dict3 = dict1.copy() # 浅拷贝：深拷贝父对象(一级目录)如[1,2,3]，子对象(二级目录)如1,2,3不拷贝，还是引用# 修改 data 数据dict1['Name']='XIAOBAI'dict1['Number'].remove(1)# 输出结果print(dict1)print(dict2)print(dict3)# 输出结果为{'Name': 'XIAOBAI', 'Age': 0, 'Number': [2, 3]}{'Name': 'XIAOBAI', 'Age': 0, 'Number': [2, 3]}{'Name': 'xiaobai', 'Age': 0, 'Number': [2, 3]}
dict.fromkeys(seq[, value])用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值
#!/usr/bin/python3seq = ('Name', 'Age', 'Sex')dict1 = dict.fromkeys(seq)print ("新的字典为 : %s" % str(dict1))dict2 = dict.fromkeys(seq,1)print ("新的字典为 : %s" % str(dict2))#输出结果为新的字典为 : {'Name': None, 'Age': None, 'Sex': None}新的字典为 : {'Name': 1, 'Age': 1, 'Sex': 1}
dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值
#!/usr/bin/python3 dict = {'Name': 'xiaobai', 'Age': 0}print ("Age 值为 : %s" % dict.get('Age'))print ("Sex 值为 : %s" % dict.get('Sex', "2"))#输出结果为Age 值为 : 0Sex 值为 : 2
dict.items() 以列表返回可遍历的(键, 值) 元组数组
#!/usr/bin/python3 dict = {'Name': 'xiaobai', 'Age': 0}print ("Value : %s" % dict.items())#输出结果为 Value : dict_items([('Name', 'xiaobai'), ('Age', 0)])d={1:"a",2:"b",3:"c"}result=[]#规定类型for k,v in d.items(): result.append(k) result.append(v)print(result)#输出结果为：[1, 'a', 2, 'b', 3, 'c']dict = {'Name': 'xiaobai', 'Age': 65}for i,j in dict.items(): print(i, ":\t", j)#输出结果为：Name : 'xiaobai'Age : 65
dict.keys() 返回一个迭代器，可以使用 list() 来转换为列表
dict = {'Name': 'xiaobai', 'Age': 65}dict.keys()list(dict.keys()) # 转换为列表#输出结果为：['Name', 'Age']
dict.setdefault(key, default=None) 和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值
#!/usr/bin/python3dict = {'Name': 'xiaobai', 'Age': 0}print ("Age 键的值为 : %s" % dict.setdefault('Age', None))print ("Sex 键的值为 : %s" % dict.setdefault('Sex', None))print ("新字典为：", dict)#输出结果为：Age 键的值为 : 0Sex 键的值为 : None新字典为： {'Name': 'xiaobai', 'Age': 0, 'Sex': None}
dict.update(dict2) 把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里
dict = {'Name': 'xiaobai', 'Age': 0}dict2 = {'Sex': 'female' }dict.update(dict2)print ("更新字典 dict : ", dict)#输出结果为：更新字典 dict : {'Name': 'xiaobai', 'Age': 0, 'Sex': 'female'}
dict.values() 返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值
#!/usr/bin/python3dict = {'Sex': 'female', 'Age': 7, 'Name': 'xiaobai'}print ("字典所有值为 : ", list(dict.values()))#输出结果为： 字典所有值为 : ['female', 7, 'xiaobai']
pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
dict = {'Sex': 'female', 'Age': 7, 'Name': 'xiaobai'}pop_obj=dict.pop('Name')print(pop_obj)#输出结果为：xiaobai
popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。
如果字典已经为空，却调用了此方法，就报出KeyError异常。
如下示例，若连续调用四次就会报错
#!/usr/bin/python3dict = {'Sex': 'female', 'Age': 7, 'Name': 'xiaobai'}pop_obj=dict.popitem()print(pop_obj) print(dict)#输出结果为：('Name', 'xiaobai'){'Sex': 'female', 'Age': 7}