python mysql插入时判断变量为none插入空值_给数据分析学习者的Python入门秘籍
以简短直白的语言，讲清楚新手入门python应该学会的知识点。
一、 摆正心态
准备以饱满的精神投入至少20小时到python学习上，认真写下每一行代码，反复练习。
二、 配置环境
不同于其他语言，python2.0和python3.0并不兼容，建议学习python3.0，为啥呢，我就不赘述了，可以参考这篇文章 应该学习最新版本的 Python 3 还是旧版本的 Python 2？ 。
目前Anaconda和Jupyter已经成为python数据分析的标准配置环境了，简单来说，Anaconda就是包管理器和环境管理器，而Jupyter可以将数据分析过程中的代码，图片和文字组合到一个web文档中。
三、 python基础
001 输出命令
print(‘你要输出的东西’） 在括号中加上字符串，就可以向屏幕上输出指定的文字
print('hello world') # 字符串
输出结果：hello world
print('hello world','weather','sunday') # 多个字符串
输出结果：hello world,weather,sunday
print(5) # 数字
输出结果：5
print(1+3) # 计算式
输出结果：4
s=3
print(s) # 变量
输出结果：3print括号中的内容，需要给文字或者字符串加上单引号或者双引号，其他如数字，计算式以及稍后会提到的变量不用加引号。
ps：print() 也可以接受多个字符串，输出时，遇到逗号，就用空格隔开。
002 变量
为了操作方便，我们需要引入变量。变量，顾名思义：“可变化的量”。这个和我们从小学习的方程式中的变量是一样。
计算机中用变量存放数据，用等号‘=’给变量赋值。
NameStr = ‘马化腾’等号左边就是变量名，右边是变量值。（需要注意的是，变量本身没有类型，它是和右边的变量值同类型，这里就是字符串类型。）
变量名是可以随意起的，但是为了代码的美观和可读性，编程人员都会有一些约定俗成的习惯，比如 变量命名时，一般会由两部分组成，前半部分代表数据的意义，后半部分代表数据的类型，比如NameStr中的Name表明这个数据某个人的名字，而Str则表明这个这个数据是字符串类型。
注：在python中，变量命名不能以数字开头，注意区分大小写
003 注释
有时候是为了说明用途和其他详细信息，有时候是把暂时不需要用到的代码先暂时注释，以备后用。注释掉的内容是不会被程序执行的。
(1)方法1： # 需要解释的内容
#中国首富马云
nameStr = '马云'(2) 方法2：''' 需要解释的内容 '''
'''
中国首富马云，真有钱啊
'''
nameStr = '马云'004 数据
数据包括数据类型和数据结构
##数据类型
数据类型通常包括以下五种：
- 字符串String
- 数值Number
- 布尔Bool
- 空值None
- 容器：列表，元祖，集合，字典
1、字符串（String）
（1）定义：
以单引号（‘abc’；“abc”）或者双引号（“123”）括起来的任意文本。字符串是不可变数据类型。
print('I love python') 输出：I love python注意：如果文本中本身就存在单引号或者双引号，为了让计算机明白我们需要输出什么，就需要用到转义字符 来标识。
print(' I 'm ok ') 输出：I'm ok补充其他转义符知识：
- n : 换行
- t ：制表（相当于按一下tab键的效果）
- ：
- ' ：'（单引号）
- '' ：''（双引号）
但是如果一行代码中转义符号太多，则不利于阅读，因此还有一个简易方法： r ' '表示 ' ' 内不进行转义。
print(' t ') 结果是：
print(r't ') 结果是：t（2）字符串运算：
第一种：使用加号（+）进行字符串拼接
print('马云' + '有钱') 输出：马云有钱第二种：利用join函数
a='马云'
b='有钱'
print(''.join([a,b]) 输出：马云有钱（3）格式化字符串
我们经常会输出类似'亲爱的xxx你好！你xx月的话费是xx，余额是xx'之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的方式。
print('%s的年龄是%d岁' %('小明', 18)) 输出：小明的年龄是18岁原始字符串中的%s 被小明代替，%d 被18所替代。
在字符串内部，%s表示用字符串替换，%d表示用整数替换，%f表示用浮点数替换。
有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。此外，格式化浮点数还可以指定输出几位小数。
pirnt('price is %.2f' % 4.6669 输出：price is 4.672、数值（Number）
（1）类型
1）整型int：写法和数学上一样，例：a=50；b=2
2）浮点型float：即小数，例：s=5.67
3）复数complex：实部+虚部
3、布尔类型
（1）内容：
只有True 和 False两种值（注意大小写），此外也可以用1和0分别表示True 和 False，在python里面可以用这两个数输出表达运算结果。
print(3>2) 输出：True
print(10<1) 输出：False（2）应用
布尔类型经常在条件判断中运用：
age=20
if age>=18:
print('判断条件为真')
else:
print('判断条件为假')
输出结果：判断条件为真4、空值（None）
空值是Python里一个特殊的值，用None表示。
注意：None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
5、容器
将不同的数据放在一起，方便查找处理。比如，钱包就可以看做一个容器，里面有各个不同银行的银行卡，可以做不同的事情。
生活中有很多不同的容器，比如钱包，书包，化妆包，他们的功能各不相同。同样，python中为了存放不同的数据，也有不同的容器，接下来介绍4中数据容器。
5.1 列表（list）
（1）定义：有序的数据集合，可变
生成列表的方法： nameList=[ '马化腾' , '王健林' , '马云' , '小娟儿' ]
查询列表长度的方法：nameLen = len(nameList)
用索引来访问列表中的元素：
索引除了用正数，也可以用 -1 直接获取最后一个元素：
nameList=[ '马化腾' , '王健林' , '马云' , '小娟儿' ]
print(nameList[-1]
#输出结果：
小娟儿以此类推：
nameList=[ '马化腾' , '王健林' , '马云' , '小娟儿' ]
print(nameList[-2]
#输出结果：
马云
print(nameList[-3]
#输出结果：
王健林
print(nameList[-4]
#输出结果：
马化腾（2）使用方法：
增删改查
- 增 列表是个可变容器，因此可以追加元素
~方法1：追加元素至末尾
nameList=[ '马化腾' , '王健林' , '马云' , '小娟儿' ]am
nameList.append('刘强东')
print(nameList)
#输出结果：
[ '马化腾' , '王健林' , '马云' , '小娟儿','刘强东' ]~方法2：追加元素至指定位置，比如插入至索引为1 的位置
nameList=[ '马化腾' , '王健林' , '马云' , '小娟儿' ]
nameList.insert(1，'李彦宏')
print(nameList)
#输出结果：
[ '马化腾' , '李彦宏'，'王健林' , '马云' , '小娟儿' ]- 删
~方法1：删除末尾元素，用pop()弹出
nameList=[ '马化腾' , '王健林' , '马云' , '小娟儿'，'刘强东' ]
nameList.pop()
print(nameList)
#输出结果：
[ '马化腾' , '王健林' , '马云' , '小娟儿'， ]~方法2：指定位置元素删除，，pop(i) i指的是索引位置，或者del list[i]
nameList=[ '马化腾' , '王健林' , '马云' , '小娟儿'，'刘强东' ]
nameList.pop(1)
print(nameList)
#输出结果：
[ '马化腾' , '马云' , '小娟儿' , '刘强东' ]
del nameList[2]
print(nameList)
#输出结果：
[ '马化腾' , '马云' ,'刘强东' ]- 改
直接赋值对应索引位置即可
- 查
利用列表元素下表索引访问列表中的元素，索引从0开始
5.2 元组（tuple）
（1）定义：有序数据集合，一旦生成，不可变
生成元组的方式：nameTuple=（ '马化腾' , '王健林' , '马云' , '小娟儿'）
（2）使用方法
# 定义空元组
s=() 输出： ()
# 定义只有一个元素的元组
s=(1,) 输出：(1,) #注意，一定要加逗号
5.3 集合（sets）
（1）定义：无序的，没有重复元素的容器(常用语删除重复元素)
生成集合的方式：gafataSets={'腾讯','阿里巴巴','苹果','谷歌','Facebook','亚马逊','亚马逊'}
'''
容器：集合（sets）是一个没有重复元素的容器
'''
#定义集合：6家公司的股票
gafataSets={'腾讯','阿里巴巴','苹果','谷歌','Facebook','亚马逊','亚马逊'}
print(gafataSets)
结果输出：{'腾讯', '亚马逊', '苹果', '谷歌', 'Facebook', '阿里巴巴'}（2）使用方法：
增删改查
- 增
#1）容器操作：增加
# 定义一个空的集合
stockSets=set()
#方法一：使用update()增加元素
stockSets.update(['腾讯','阿里巴巴','京东'])
print(stockSets)
输出结果：{'腾讯' , '阿里巴巴' , '京东'}
#方法二：使用add()增加元素方法
stockSets.add('字节')
print(stockSets)
输出结果：{'腾讯' , '阿里巴巴' , '京东' , '字节'}
- 删
#2）容器操作：删除
#方法一：使用discard()删去元素
stockSets.discard('京东')
print(stockSets)
输出结果：{'腾讯' , '阿里巴巴'}
#方法二：使用remove()删去元素
stockSets.remove('腾讯')
print(stockSets)
输出结果：{'阿里巴巴'}- 改
#4）容器操作：修改
#第1步：先删除
stockSets.discard('京东')
#第2步：再添加
stockSets.update(['字节'])
print(stockSets)
输出结果：{'腾讯', '阿里巴巴', '字节'}- 查
#3）容器操作：查找
txBool='腾讯' in stockSets
print(txBool)
输出结果：True5.4 字典（dictionary）
（1）定义：将键和值一一对应放到容器中，方便查找，节省时间（键是唯一的）
生成字典的方式：
'''
容器：字典（Dictionary）
'''
#定义字典：病人编号和姓名的映射关系
patientDic={'001':'猴子','002':'马云','003':'王健林','004':'马化腾'}如果病人信息较多，有姓名，年龄，疾病等，还可以通过传入列表，代表病人信息
#定义字典：excel病人数据存储
patientDic2={
'001':['猴子',29,'1型糖尿病','较差'],
'002':['马云',34,'2型糖尿病','好转'],
'003':['王健林',28,'1型糖尿病','显著好转'],
'004':['马化腾',52,'2型糖尿病','好转']}（2）使用方法
增删改查
- 增
# 1） 容器增加元素，通过key放入
patientDic['005']='小明'
print(patientDic)
输出结果：{'001': '猴子', '002': '马云', '003': '王健林', '004': '马化腾', '005': '小明'}- 删
#2)容器操作：删除
del patientDic['005']
print(patientDic)
输出结果：{'001': '猴子', '002': '马云', '003': '王健林', '004': '马化腾'}- 改
#2)容器操作：修改
# 方法同增加操作， 如果键存在，就对原值修改，如果不存在，就在容器中增加一对 key-value
print('修改前patientDic是：' , patientDic)
patientDic['002'] ='小明'
print('修改后patientDic是：' , patientDic)
输出结果：
修改前patientDic是：{'001': '猴子', '002': '马云', '003': '王健林', '004': '马化腾'}
修改后patientDic是：{'001': '猴子', '002': '小明', '003': '王健林', '004': '马化腾'}- 查
#3)容器操作：查询，根据病人编号查询病人信息
print(patientDic['001'])
输出结果：'猴子'## 数据结构
定义：数据元素与数据元素之间的相互关系或者组织数据的形式
【线性表】
- 线性表的顺序存储
1、定义
若将线性表L=(a0,a1, ……,an-1)中的各元素依次存储于计算机一片连续的存储空间，这种机制表，视为线性表的顺序存储结构。
2、特点
逻辑上相邻的元素 ai, ai+1，其存储位置也是相邻的； 存储密度高，方便对数据的遍历查找。 对表的插入和删除等运算的效率较差
3. 程序实现
在Python中，list存放于一片单一连续的内存块，故可借助于 列表 类型来描述线性表的顺序存储结构，而且列表本身就提供了丰富的接口满足这种数据结构的运算。
>>>L = [1,2,3,4]
>>>L.append(10) #尾部增加元素
L
[1, 2, 3, 4, 10]
>>>L.insert(1,20) #插入元素
L
[1, 20, 2, 3, 4, 10]
>>>L.remove(3) #删除元素
L
[1, 20, 2, 4, 10]
>>>L[4] = 30 #修改
L
[1, 20, 2, 4, 30]
>>>L.index(2) #查找
2- 线性表的链式存储
1、定义
将线性表L=(a0,a1,……,an-1)中各元素分布在存储器的不同存储块，称为结点，每个结点（尾节点除外）中都持有一个指向下一个节点的引用，这样所得到的存储结构为链表结构。
2、特点
逻辑上相邻的元素 ai, ai+1，其存储位置也不一定相邻； 存储稀疏，不必开辟整块存储空间。 对表的插入和删除等运算的效率较高。 逻辑结构复杂，不利于遍历。
【栈】
1、定义
栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”，另一固定端称为“栈底”，当栈中没有元素时称为“空栈”。
2、特点
栈只能在一端进行数据操作 栈模型具有先进后出或者叫做后进先出的规律
3、代码的实现
栈的操作有入栈（压栈），出栈（弹栈），判断栈的空满等操作。
#定义栈：浏览我个人知乎主页的顺序
stack = deque(['知乎动态','知乎文章','知乎回答'])
print(stack)
输出结果：deque(['知乎动态', '知乎回答', '知乎文章'])
# 在栈顶加元素——入栈
stack.append('知乎专栏')
print(stack)
输出结果：deque(['知乎动态', '知乎回答', '知乎文章','知乎专栏'])
# 在栈顶加元素——出栈
stack.pop() #将栈顶元素'知乎专栏'弹出
print(stack)
输出结果：deque(['知乎动态', '知乎回答', '知乎文章'])【队列】
1、定义
队列是限制在两端进行插入操作和删除操作的线性表，允许进行存入操作的一端称为“队尾”，允许进行删除操作的一端称为“队头”。
2、特点
队列只能在队头和队尾进行数据操作
队列模型具有先进先出或者叫做后进后出的规律
3、队列的代码实现
队列的操作有入队，出队，判断队列的空满等操作
#导入collections包
from collections import deque
#定义队列：排队吃饭人的编号
queue=deque(['001','002','003','004','005'])
#入队：在队列尾部插入元素
queue.append('006')
print(queue)
输出结果：deque(['001','002','003','004','005','006'])
#出队：在队列头部删除元素
queue.popleft()
print(queue)
输出结果：deque(['002','003','004','005'])
【排序字典OrderedDict】
1、定义
dict字典里面的（key—value）pairs是没有顺序的，而OrderDict可以创建有顺序的字典
2、代码实现
'''
OrderedDict：按照插入key的顺序，对字典排序
'''
from collections import OrderedDict
gafataodDict=OrderDict( {'谷歌':'GOOG','亚马逊':'AMZN','Facebook':'FB', '苹果':'AAPL','阿里巴巴':'BABA','腾讯':'0700'} )
print(gafataodDict)
OrderedDict([('谷歌', 'GOOG'),
('亚马逊', 'AMZN'),
('Facebook', 'FB'),
('苹果', 'AAPL'),
('阿里巴巴', 'BABA'),
('腾讯', '0700')])
#输出结果和我们导入的顺序一致【计数器Counter】
1、定义
计数器是一个无序容器，用于记录各种值出现的次数。它采用键值对的形式存储，要记录的值作为key，这个值出现的次数作为value，value值可正可负。
2、代码实现
- 创建计数器：利用无参构造函数
from collections import Counter
c = Counter()也可以从list，tuple，dict，字符串等可迭代对象(iterable)创建：
c = Counter( ['a','a','b','b','c'] ) #从list创建
c = Counter( 'a','a','b','b','c') #从tuple创建
c = Counter( {'a':2,'b':2,'c':1} ) #从dict创建
c = Counter( "aabbc" ) #从字符串创建
# 这四个方式创建计数器都是相通的，结果：Counter({ 'a': 2, 'b':2, 'c':1 })- 访问元素
计数器是dict的子类，因此可以像使用dict那样访问计数器元素：
print(c['a'])
输出： 2
print(c['d'])
输出： 0 #访问计数器中没有的元素，不会报错，而是返回0查看其中出现次数最后的几个元素
from collections import Counter
c = Counter( 'aabbbccdeeefggghhhw' )
print(c.most_common(3))
输出：[('b', 3), ('e', 3), ('g', 3)] #出现次数最多的三个字符005 条件判断
程序顺序往下执行遇到if 语句的时候，会去判断它所带条件的真假，“如果”条件为True，就会去执行接下来的内容。“如果”条件为False，就跳过。
# 根据豆瓣评分，判断是否看《摔跤吧，爸爸》这部电影！
scoreNum = 9.1
if scoreNum >= 8.0:
print('我要去看这部电影')
else:
print('电影太烂了，我才不去看呢! ')
输出结果：我要去看这部电影- 边界条件判断
'''
边界条件：逻辑判断
'''
#定义列表：病人姓名
nameList=['猴子','马云','王健林','马化腾']
if '猴子' not in nameList:
print('列表中没有叫猴子的病人')
else:
print('列表中有个叫猴子的病人')
输出结果：列表中有个叫猴子的病人- 多个条件判断，用到elif
'''
多个条件判断
'''
age=int(input('输出狗狗的年龄，按enter键获取对应人类的年龄：'))
if age < 0 :
print('狗狗年龄不能小于0')
elif age == 1:
print('相当于14岁的人')
elif age == 2 :
print('相当于22岁的人')
else:
human=22+(age-2)*5
print('对应人类年龄',human)
输入：3 输出：对应人类的年龄27006 循环
# 为了解决重复性的工作，比如：
print('第一次吃饭')
print('第二次吃饭')
print('第二次吃饭')
#为了让计算机能计算成千上万次的重复运算，我们就需要循环语句。Python的循环有两种，一种是for...in循环，依次把list或tuple中的每个元素迭代出来，看栗子
# 容器：1天中吃第几次饭
eatList=['吃第1次饭','吃第2次饭','吃第3次饭']
#循环
for i in eatList:
print(i)
执行这段代码，会依次打印eatList 的每一个元素：
吃第1次饭
吃第2次饭
吃第3次饭所以for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句。
'''
定义字典：6家公司（GAFATA）的股票
key是公司名称，value是股票代码
'''
gafataDict={
'谷歌':'Goog','亚马逊':'aMZN','Facebook':'FB',
'苹果':'aapl','阿里巴巴':'BABA','腾讯':'0700'}
#将股票代码全部大写
for key,value in gafataDict.items():
newValue=value.upper() #对股票代码转换成大写
gafataDict[key]=newValue #将转换后新的股票代码赋值给对应的key
print(gafataDict)
输出结果：
{
'谷歌': 'GOOG', '亚马逊': 'AMZN', 'Facebook': 'FB', '苹果': 'AAPL', '阿里巴巴': 'BABA', '腾讯': '0700'}- 跳出循环
# continue用于跳出当前循环
for key,value in gafataDict.items():
if(key=='苹果'):
continue
print('当前公司：',key,',当前股票代码：',value) #执行到continue，本轮循环结束，进行下一轮循环
输出结果：
当前公司： 谷歌 ,当前股票代码： GOOG
当前公司： 亚马逊 ,当前股票代码： AMZN
当前公司： Facebook ,当前股票代码： FB
当前公司： 阿里巴巴 ,当前股票代码： BABA
当前公司： 腾讯 ,当前股票代码： 0700
# break用于退出整个循环
#查找苹果公司的股票代码
number=0
for key,value in gafataDict.items():
number=number+1
if(key=='苹果'):
print('查找',key,'公司的股票代码是',value)
break
print('当前公司：',key,',当前股票代码：',value)
输出结果：
当前公司： 谷歌 ,当前股票代码： GOOG
当前公司： 亚马逊 ,当前股票代码： AMZN
当前公司： Facebook ,当前股票代码： FB
查找 苹果 公司的股票代码是 AAPL另一种是while循环
只要条件满足，就不断循环，条件不满足时退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现：
# 计算100以内所有奇数之和，可以用while循环实现：
sum = 0
i= 1
while i<100:
sum += i
i += 2
print(sum)
输出结果：2500007 函数
如何自定义函数？
在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回
'''
定义函数
函数功能：两个数相加
输入：x，y是要相加的两个数
输出：两个数相加的和
'''
def add(x,y):
z=x+y
return z如何调用函数？
#使用函数
a=1
b=2
c=add(x=a,y=b)
print('1和2相加等于',c)
输出结果：3函数参数！
...不可变数据类型
#定义函：改变数据的值
def changeInt(a):
a=a+1
'''
使用函数
参数是不可变数据类型（字符串，元祖，数值）：
传递的只是该数据类型的值（相当于复制一份）
'''
b=1
print('调用函数之前b的值=',b)
changeInt(a=b)
print('调用函数之后b的值=',b)
输出：
调用函数之前b的值=1
调用函数之后b的值=1...可变数据类型
#定义函：改变列表的值
def changeList(inputList):
inputList.append('奶茶妹妹')
'''
使用函数
参数是可变数据类型：
传递的是该变量的引用地址
'''
nameList=['马云','刘强东']
print('调用函数之前的值：',nameList)
changeList(inputList=nameList)
print('调用函数之后的值：',nameList)
输出结果：
调用函数之前的值：['马云','刘强东']
调用函数之后的值：['马云','刘强东','奶茶妹妹']变量作用域
Python的变量作用域一共有2种：全局作用域，局部作用域。
- 全局变量：定义在一个函数体内部的变量，只有局部作用域，能在其被声明的函数内部访问
- 全局变量：定义在外面的变量，拥有全局作用域，可以在整个程序范围内访问
比如
a = 1
def f():
b = 2其中a就是全局变量，而b是局部变量。局部变量只在函数体内部有效，出了函数体，外面是访问不到的，而全局变量则对下面的代码都有效。
# 变量作用域
def test():
aStr='别理会他人闲言闲语，今日随他们，让他们说吧，你的机会将会到来，再来证明自己。'
#在函数外面，访问函数内的局部变量aStr
print(aStr)
输出结果：报错，外面无法访问局部变量aStr- global关键字
有时候我们想把函数体内部定义的变量，强制定义为全局变量，也是有可能的。
global关键字可以帮助我们实现。使用方法如下：
# 没有使用global之前：
g_b = 3
def t1():
global g_b 定义全局变量：g_b
g_b = 2
t1()
print(g_b)
输出结果：3
# 函数体内部也定义了一个变量g_b，这是个局部变量，并不能改变外面的g_b，所有结果仍是3。
# 使用global之后：
g_b = 3
def t1():
global g_b 定义全局变量：g_b
g_b = 2
t1()
print(g_b)
输出结果：2 #全局变量g_b被重新赋值，因为函数体内部也定义了一个重名变量g_b008 模块
▽ 内置模块
Python本身就内置了很多非常有用的模块，只要安装完毕，这些模块就可以立刻使用。
例如sys模块
''''
Python内置模块
'''
#第1步：导入模块
import sys
#第2步：使用模块中的函数，属性
pathList=sys.path
print('Python 路径为：n', pathList)▽ 第三方模块
在Python中，安装第三方模块，是通过包管理工具pip完成的。
一般来说，第三方库都会在Python官方的pypi.python.org网站注册，要安装一个第三方库，必须先知道该库的名称，可以在官网或者pypi上搜索，比如Pillow的名称叫Pillow，因此，安装Pillow的命令就是：
pip install Pillow在使用Python时，我们经常需要用到很多第三方库，例如，上面提到的Pillow，还有MySQL驱动程序，Web框架Flask，科学计算Numpy等。用pip一个一个安装费时费力，还需要考虑兼容性。
因此推荐直接使用Anaconda，这是一个基于Python的数据处理和科学计算平台，它已经内置了许多非常有用的第三方库，我们装上Anaconda，就相当于把数十个第三方模块自动安装好了，非常简单易用。
'''
使用conda命令安装包：conda install pandas
使用第三方模块：pandas
pandas是数据分析工具
'''
#引入模块
import pandas as pd 一般数据分析需要导入excel或者csv等外部文件，通常直接
#文件路径（在本地运行时替换成你自己的实际数据路径）
fileNameStr='C:houzi第2关零基础掌握人工智能核心语言Python数据病历数据.xlsx'
'''
运行后会报错，报错信息是：ImportError: Install xlrd>=0.90 for Excel support
这时候要学会看报错信息，
上面的报错信息意思是说：缺少读取Excel文件的包xlrd
这时候用conda命令安装就可以了，在conda中输入以下安装包的命令即可：
conda install xlrd
'''
#读取excel文件里的数据
xl = pd.ExcelFile(fileNameStr)
或者
x1=pd.read_excel(fileNameStr)
'''
Excel里面可以有多个工作表（Sheet）
这里参入的参数值“Sheet1”，就是某个工作表的名称，而不是Excel的文件名。
我们可以打开Excel文件，会看到工作表（Sheet）对应的名称，默认的工作表名称是“Sheet1”（注意大小写）
你也可以修改这个工作表的名称，然后传入对应的名称，就会根据名称读取这个工作表里的数据了
注意这个名称如果是英文，注意大小写，我一般喜欢从Excel中复制这个名称过来，以防错误
'''
#获取指定工作表（Sheet）名称的数据
patientDf = xl.parse('Sheet1')
print(patientDf)
输出结果：
病人编号 姓名 年龄 糖尿病类型 病情
0 1 猴子 29 1型糖尿病 较差
1 2 马云 34 2型糖尿病 好转
2 3 王健林 28 1型糖尿病 显著好转
3 4 马化腾 52 2型糖尿病 较差▽ 理解python中的模块、库、包有什么区别
模块，库，包对应的英文名分别是：module、lib 和 package
模块（module）：一个 .py 文件就是个 module
自我包含并且有组织的 代码片段为模块。
表现形式为：写的代码保存为文件。这个文件就是一个模块。sample.py 其中文件名sample为模块名字。
包（package）：一个有层次的文件目录结构，它定义了由n个模块或n个子包组成的python应用程序执行环境。
通俗一点：包是一个包含__init__.py 文件的目录，该目录下一定得有这个__init__.py文件和其它模块或子包。
库（lib）：是一个抽象的概念，只要你喜欢，什么都是 lib。也可以理解为各种模块的组成。
补充：
notebook保存文件的默认格式是：.ipynb 格式，但是python导包只能导入.py格式的包，所以要另存为.py格式
- 模块使用方式：
import 包名称
import 包名称 as 别名
from 包名称 import 函数名
举个栗子：
from collections import deque
import pandas as pd好了，先介绍到这里，未完待续... ....