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)    # 变量
输出结果：3

print括号中的内容，需要给文字或者字符串加上单引号或者双引号，其他如数字，计算式以及稍后会提到的变量不用加引号。

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.67

2、数值（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)


输出结果：True

5.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  输出：对应人类的年龄27

006 循环

# 为了解决重复性的工作，比如：
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)

输出结果：2500

007 函数

如何自定义函数？

在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_b

008 模块

▽ 内置模块

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

---

好了，先介绍到这里，未完待续... ....