python 去除列表空值_零基础如何快速入门python

1、为什么学习python

随着人工智能和大数据的兴起，Python 这门语言也越来越多人使用。以下是IEEE Spectrum年度编程语言排行榜，2018年，Python在总排行、发展趋势、就业市场需求、开源领域均排第一。

IEEE Spectrum年度编程语言排行榜

为什么python这么火爆呢，一方面是由于其语言的核心设计思想，具备简洁、易读、高效等诸多优点，另一方面是其广泛的应用场景，分别在人工智能、大数据、数据挖掘、数据分析、爬虫、web开发等非常多的领域。

对于初入行业、想从事数据分析的初学者，python在数据分析和交互、科学计算以及数据可视化等方面都有非常成熟的，如numpy、pandas、matplotlib、scikit-learn等库和工具，可以学习使用python快速上手。

2、python安装与环境配置

对于数据分析而言，Anaconda 和 Jupyter Notebook 已经成为Python数据分析的标准环境：

• Anaconda：包管理器和环境管理器
• Jupyter Notebook：可以将数据分析需要的代码、图片、文字组合到一个web文档中，形成数据分析报告，也是学习python非常好用的笔记工具

初学 Python 者自学 Anaconda 的正确姿势是什么？​www.zhihu.com

jupyter notebook 可以做哪些事情？​www.zhihu.com

首先，我们可以参照上面链接中的操作文档，在自己的电脑上安装Anaconda（如果需要A naconda的安装包，可以私信），再安装Jupyter Notebook（安装Anaconda后会自动附带Jupyter notebook）。当你安装好这两个软件后，便可以在Jupyter Notebook中输出你人生中第一行代码：print('Hello World')

3、零基础快速入门python

零基础入门python7个知识点

1⃣️知识点1：变量

1、什么是变量，变量赋值

我们用变量来存放数据，并用等号=为变量赋值，“=”左边的即为变量，变量可以存放任意的数据类型

2、变量命名规则

• ① 一般命名是会采取“数据意义+数据类型”的格式来命名
• ② 变量第一关字符必须是字母或者下划线（“_”），不能用数字作为变量名称的开头
• ③ Python是大小写敏感的，不要有空格

3、注释，用#表示，或三引号（''''''）

nameStr='张三'  # 等号左边为变量名，等号右边为变量值
ageInt=18
a=b=1  # 多变量赋值
c,d=1,'马云'
print(nameStr,ageInt,a,b,c,d)
张三 18 1 1 1 马云

2⃣️知识点2：数据类型及操作

内容框架，红色图标部分为不可变数据类型：字符串、数值、元祖

数据类型1：字符串String

字符串是由数字、字母、下划线组成的一串字，用于表示文本的数据类型，用英文标点符号，单引号(' ')，双引号(" ")表示

# 定义字符串
nameStr='张三'
dadStr='李四'
# 字符串合并
print('用+将字符串合并：',nameStr+dadStr)

# 用%s格式化字符串
str1='我叫%s ,今年%s ' % ('土豆', '18岁')
print(str1)

用+将字符串合并： 张三李四
我叫土豆 ,今年18岁

数据类型2：数值Number（整型int、长整型long、浮点型float、复数complex）

# 定义数值
x1 = 10
x2 = 10.0
print(type(x1),type(x2)) # type()函数，用于查看数据类型
 

数据类型3：容器:列表List、元祖Tuple、集合Sets、字典Dictionary① 如何定义② 容器的4种操作：增加、删除、修改、查询

'''
3.1列表list
'''

# 定义列表，用[]标识，有序对象
ls = [1,'马云',2.4,502.2,['土豆',2,3]]
print(ls)

# 列表长度： len()函数
print('ls长度为',len(ls))

# 1）增加元素： .append
ls.append('刘强东')
print('增加1个元素：',ls)

# 2）删除元素： del
del ls[1]
print('删除第2个元素：',ls)

# 3）查询元素：使用下标索引来访问列表中的值，注意下标从0开始
ls1=ls[0]
print('查询列表的第1个元素：',ls1)

# 4）修改元素：直接指定下标的值
print('修改之前第1个元素是：',ls[0])
ls[0]='孙悟空'
print('修改之后第1个元素是：',ls[0])
[1, '马云', 2.4, 502.2, ['土豆', 2, 3]]
ls长度为 5
增加1个元素： [1, '马云', 2.4, 502.2, ['土豆', 2, 3], '刘强东']
删除第2个元素： [1, 2.4, 502.2, ['土豆', 2, 3], '刘强东']
查询列表的第1个元素： 1
修改之前第1个元素是： 1
修改之后第1个元素是： 孙悟空

'''
3.2元祖Tuple
'''

# 定义元祖，用()标识，有序对象
tp = (1,'马云',2.4,502.2,['土豆',2,3])
print(ls)

# 元祖长度： len()函数
print('tp长度为',len(tp))

# 查询元素：使用下标索引来访问列表中的值，注意下标从0开始
tp1=tp[0]
print('查询元祖的第1个元素：',tp1)

# 元组的元素不能修改（增、删、改），只能查询
(1, '马云', 2.4, 502.2, ['土豆', 2, 3])
tp长度为 5
查询元祖的第1个元素： 1

'''
3.3集合Sets，集合（Sets）是一个没有重复元素的容器
'''

# 定义集合：用{}标识，定义6家公司的股票
gupiaoSets={'腾讯','阿里巴巴','苹果','谷歌','Facebook','亚马逊','亚马逊'}
print('股票集合为',gupiaoSets)

# 1）增加元素：使用update()增加元素
gupiaoSets.update(['网易','华为'])
print('增加结果',gupiaoSets)

# 2）删除元素：discard()
gupiaoSets.discard('亚马逊')
print('删除结果',gupiaoSets)

# 3）修改元素：
#第1步：先删除
gupiaoSets.discard('腾讯')
#第2步：再添加
gupiaoSets.update(['腾讯'])
print('修改结果',gupiaoSets)

# 4）查找元素
txBool='腾讯' in gupiaoSets
print('查找结果',txBool)
股票集合为 {'阿里巴巴', 'Facebook', '腾讯', '苹果', '谷歌', '亚马逊'}
增加结果 {'华为', '阿里巴巴', 'Facebook', '腾讯', '苹果', '网易', '谷歌', '亚马逊'}
删除结果 {'华为', '阿里巴巴', 'Facebook', '腾讯', '苹果', '网易', '谷歌'}
修改结果 {'华为', '阿里巴巴', 'Facebook', '腾讯', '苹果', '网易', '谷歌'}
查找结果 True

'''
3.4字典Dictionary
'''

# 定义字典方式1：函数映射，人员编号和姓名的映射关系
peopleDic={'001':'土豆','002':'马云','003':'王健林','004':'马化腾'}
print('定义字典1',peopleDic,'n---')

# 定义字典方式2：excel格式，人员数据存储
peopleDic2={'001':['猴子',29,'较差'],
            '002':['马云',34,'好转'],
            '003':['王健林',28,'显著好转'],
            '004':['马化腾',52,'好转']}
print('定义字典2',peopleDic2,'n----')

# 1)增加元素
peopleDic2['005']=['王思聪',30,'好转']
print('增加结果',peopleDic2,'n----')

# 2)删除元素，删除key值即可
del peopleDic2['005']
print('删除结果',peopleDic2,'n----')

# 3)查询，根据编号key值查询信息
valueList1=peopleDic2['001']
print('查询结果',valueList1,'n----')

# 4)修改元素
print('修改之前，病人信息：',peopleDic2['001'])
peopleDic2['001']=['猴子', 29, '好转']
print('修改之后，病人信息：',peopleDic2['001'])
定义字典1 {'003': '王健林', '001': '土豆', '004': '马化腾', '002': '马云'} 
---
定义字典2 {'003': ['王健林', 28, '显著好转'], '001': ['猴子', 29, '较差'], '004': ['马化腾', 52, '好转'], '002': ['马云', 34, '好转']} 
----
增加结果 {'003': ['王健林', 28, '显著好转'], '005': ['王思聪', 30, '好转'], '001': ['猴子', 29, '较差'], '004': ['马化腾', 52, '好转'], '002': ['马云', 34, '好转']} 
----
删除结果 {'003': ['王健林', 28, '显著好转'], '001': ['猴子', 29, '较差'], '004': ['马化腾', 52, '好转'], '002': ['马云', 34, '好转']} 
----
查询结果 ['猴子', 29, '较差'] 
----
修改之前，病人信息： ['猴子', 29, '较差']
修改之后，病人信息： ['猴子', 29, '好转']

数据类型4：布尔类型，True，实际值为1，False，实际值为0

age=10
if age==10:
    print('判断条件是True')
else:
    print('判断条件是False')
判断条件是True

数据类型5：空值None

age=None
if age==None:
    print('年龄是空值')
else:
    print('年龄不是空值')
年龄是空值

数据操作：①数据类型转换② 运算符

①数据类型转换：int，float，str

a1 = 10.8
a2 = int(a1)  # int(x)函数：将x转为整数，如果是四舍五入则是round(x)函数
print(a2,type(a2))
print('----------')

b1 = 10
b2 = float(b1)  # float(x)函数：将x转为浮点数
print(b2,type(b2))
print('----------')


c1 = 10.0
c2 = str(c1)  # str(x)函数：将x转为字符串
c3 = float(c2)
print(c1,type(c1))
print(c2,type(c2))
print(c3,type(c3))
print('----------')
10.8 
10 
----------
10 
10.0 
----------
10.0 
10.0 
10.0 
----------

② 运算符

# 算数运算符：加减乘除，幂，取余数，取整除数
a, b, c = 21, 2, 0
c = a % b  # 取模，返回除法的余数
print( "a取b的模为：", c)

c = a**b   # 幂
print( "21的2次方的值为：", c)

c = a//b  # 取整除数 
print( "21除2的整除数为：", c)
a取b的模为： 1
21的2次方的值为： 441
21除2的整除数为： 10

# 比较运算符：等于，不等于，大于，小于，大于等于，小于等于
a, b = 21, 2
print(a == b)  # 等于
print(a != b)  # 不等于
print(a > b)  # 大于
print(a < b)  # 小于
print(a >= 21)  # 大于等于
print(a <= 2)  # 小于等于
False
True
True
False
True
False

# 逻辑运算符
print(True and False)  # and：且
print(True or False)  # or：或
print(not True)  # not：非
print('-----')

# 成员运算符
lst = [1,2,3,4,5,6]
a,b = 1,10
print(a in lst)  # a 在 lst 序列中 , 如果 x 在 y 序列中返回 True。
print(b not in lst)  # b 不在 lst 序列中 , 如果 x 不在 y 序列中返回 True。
True
True

3⃣️知识点3：函数

内容框架

如何创建及使用函数：def 语句

# 定义函数，调用函数

def f(x):
    if x < 5:
        print('输入值小于5')
    else:
        print('输入值大于等于5')  # 定义函数，其中x是参数（局部变量）
f(10)  # 运行函数
输入值大于等于5

# 关于retuen

def f1(x):
    y = 2**x  # 没有return

def f2(x):
    y = 2**x
    return y # 含有return

print(f1(2),f2(2))
# return语句退出函数，并返回一个表达式。不带参数值的return语句返回None
None 4

# 可变参数

def f(*x):   # 通过*来定义可变参数，默认会把可变参数传入一个元祖！
    print(x)
    return x
f(1)
f('a','b')
f(1,2,3,[44,33])
print(type(f('a','b')))
(1,)
('a', 'b')
(1, 2, 3, [44, 33])
('a', 'b')

局部变量与全部变量

def f(m):
    m = '做自己' 
    print("函数内为局部变量：%s" % m)    

a = input('请输入一个数字：')   # input输入函数
f(a)
print("函数外为全局变量：%s" % a)
f(m)
请输入一个数字：23
函数内为局部变量：做自己
函数外为全局变量：23
---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

 in ()
      8 f(a)
      9 print("函数外为全局变量：%s" % a)
---> 10 f(m)


NameError: name 'm' is not defined

# global语句 → 把局部变量变为全局变量

def f():
    global a
    a = '做自己'  
    print("函数内转为全局变量：%s" % a)    

a = input('请输入一个数字：')
print("输入变量值：%s" % a)
f()
请输入一个数字：23
输入变量值：23
函数内转为全局变量：做自己

匿名函数：lambda语句创建匿名函数

def f(a,b):
    return a+b
print(f(1,2))
# def创建自定义函数，求和

f = lambda a,b:a+b
print(f(1,2))
# lambda作为匿名函数，是不需要函数名的 → 需要一个函数，又不想动脑筋去想名字，这就是匿名函数
# lambda的主体是一个表达式，而不是一个代码块。
# lambda只有一行，仅仅能在lambda表达式中封装有限的逻辑进去。
3
3

4⃣️知识点4：条件判断if语句

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块

'''
条件判断的一般格式：

if 边界条件：
    要做的事情1……
else：
    要做的事情2……

边界条件判断有两类：
①值比较：大于、小于、等于、不等于、大于等于、小于等于
②逻辑比较：and、or、not
'''

#边界条件为值比较
scoreNum=9.1
if scoreNum >=8 :   # if语句后面必须有冒号：
    print('我要去看这部电影')   # 自动缩进
else:              # if语句写完后，要退回原有缩进继续写
    print('电影太烂，不去看了')

#值比较为逻辑比较
nameList=['土豆','马云','王健林']
if '土豆' not in nameList:
    print('列表中没有叫土豆的人')
else:
    print('列表中有个叫土豆的人')
我要去看这部电影
列表中有个叫土豆的人

'''
多个条件判断
'''
age=int(input('输出狗狗的年龄：'))
if age < 0 :
    print('狗狗年龄不能小于0')
elif age == 1:
    print('相当于14岁的人')
elif age == 2 :
    print('相当于22岁的人')
else:
    human=22+(age-2)*5
    print('对应人类年龄',human)
输出狗狗的年龄：23
对应人类年龄 127

5⃣️循环语句：for循环、while循环（用的不多，不做阐述），循环控制语句

内容框架，while循环在python中用的比较少，在此不多阐述

for循环：循环批量处理数据，可以循环遍历任何序列、映射

# 想输出"hello world"5次怎么办？
for i in range(5):
    print('hello world')
hello world
hello world
hello world
hello world
hello world

#将股票代码全部大写
gafataDict={'谷歌':'Goog','亚马逊':'aMZN','Facebook':'FB'}

for key,value in gafataDict.items(): 
    newValue=value.upper()    #对股票代码转换成大写
    gafataDict[key]=newValue  #将转换后新的股票代码赋值给对应的key

print(gafataDict)
{'Facebook': 'FB', '谷歌': 'GOOG', '亚马逊': 'AMZN'}

# 可以嵌套循环，尽量不要多于3个
for i in range(2):
    for j in range(3):
        print(i,j)
0 0
0 1
0 2
1 0
1 1
1 2

循环控制语句：break、continue、pass（空语句，不中断也不跳过，用的不多，不过多阐述）

# continue用于跳出当前循环，执行下一次循环
for key,value in gafataDict.items():
    if(key=='谷歌'):
        continue
    print('当前公司：',key,',当前股票代码：',value)
当前公司： Facebook ,当前股票代码： FB
当前公司： 亚马逊 ,当前股票代码： AMZN

# break用于退出整个循环
# 如查找谷歌公司的股票代码
number=0
for key,value in gafataDict.items():
    number=number+1
    if(key=='谷歌'):
        print('查找',key,'公司的股票代码是',value)
        break
    print('当前公司：',key,',当前股票代码：',value)
当前公司： Facebook ,当前股票代码： FB
查找 谷歌 公司的股票代码是 GOOG

6⃣️模块与包

模块(Module)即分类，每个模块都有特定的功能，使用模块就不需要从零自己编写相关函数，可以提高写代码和维护代码的效率。Python 中有内置的模块，也有许多第三方的库，引入模块就可以使用模块中的函数和属性。

为了避免模块名的冲突，Python 又引入了按目录来组织模块的方法，称为包

''''
Python内置模块
'''
#第1步：引入模块
import sys
#第2步：使用模块中的函数，属性
pathList=sys.path

'''
使用conda命令安装包：conda install pandas
使用第三方模块：pandas
pandas是数据分析工具
'''
#引入模块
import pandas as pd  # 简化模块名

#文件路径（在本地运行时替换成你自己的实际数据路径）
# mac用户如何查看文件路径：可以将文件拖入终端，即可查看
fileNameStr='/Users/elieen/Downloads/数据/病历数据.xlsx'

#读取excel文件里的数据
xl = pd.ExcelFile(fileNameStr)

#获取指定工作表（Sheet）名称的数据
patientDf = xl.parse('Sheet1')

print(patientDf)
病人编号   姓名  年龄  糖尿病类型    病情
0     1   猴子  29  1型糖尿病    较差
1     2   马云  34  2型糖尿病    好转
2     3  王健林  28  1型糖尿病  显著好转
3     4  马化腾  52  2型糖尿病    较差

# 调用部分模块语句：From…import 语句
from collections import deque

7⃣️常用python内置模块collections

collections是Python内建的一个集合模块，提供了许多有用的集合类。

Python拥有一些内置的数据类型，比如str, int, list, tuple, dict等， collections模块在这些内置数据类型的基础上，提供了几个额外的数据类型：（这里重点介绍前3个）

collections提供给的额外的数据类型

1、deque，其实是 double-ended queue 的缩写，翻译过来就是双端队列。

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。deque是为了高效实现插入和删除操作的双向列表，适合用于队列（queue）和栈（stack）。

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

队列（queue）：队列就像我们去餐厅吃饭排队，新取票的人在队列尾部加入，叫做入队。到号进场的人从队列首部离开队列，叫做出队

#导入collections包中的deque函数
from collections import deque

#定义队列：排队吃饭人的编号
queue=deque(['001','002','003'])

#入队：在队列尾部插入元素
queue.append('004')
print(queue)
deque(['001', '002', '003', '004'])

#出队：在队列头部删除元素
queue.popleft()
print(queue)   # 此行代码运行了3次，将头部3个元素都删除了，只剩最后一个元素
deque(['004'])

栈（stack）：栈这种数据结构有点像像生活中的木桶。你往栈中加入新的元素，就是入栈，新的元素总是放在木桶的最上面。

#定义栈：浏览我个人知乎主页的顺序
stack=deque(['知乎动态','知乎回答','知乎文章'])
print(stack)
deque(['知乎动态', '知乎回答', '知乎文章'])

#入栈：在栈顶加入元素
stack.append('知乎专栏')
print(stack)
deque(['知乎动态', '知乎回答', '知乎文章', '知乎专栏'])

#出栈：将栈顶元素移除
stack.pop()
print(stack)
deque(['知乎动态', '知乎回答', '知乎文章'])

排序字典OrderedDict：字典Dict是无序的，OrderedDict可以按照插入key的顺序，对字典排序

from collections import OrderedDict
# 普通字典
gupiaoDict1={'谷歌':'GOOG','亚马逊':'AMZN','Facebook':'FB',
            '苹果':'AAPL','阿里巴巴':'BABA','腾讯':'0700'}
gupiaoDict1
{'Facebook': 'FB',
 '亚马逊': 'AMZN',
 '腾讯': '0700',
 '苹果': 'AAPL',
 '谷歌': 'GOOG',
 '阿里巴巴': 'BABA'}

#定义有序字典
gupiaoDict2=OrderedDict({'谷歌':'GOOG','亚马逊':'AMZN','Facebook':'FB',
            '苹果':'AAPL','阿里巴巴':'BABA','腾讯':'0700'})
gupiaoDict2
OrderedDict([('腾讯', '0700'),
             ('苹果', 'AAPL'),
             ('亚马逊', 'AMZN'),
             ('阿里巴巴', 'BABA'),
             ('谷歌', 'GOOG'),
             ('Facebook', 'FB')])

计数器Counter

from collections import Counter
cDict = Counter('大家好，我是土豆爱数学，一名数据分析师，专注于大数据与人工智能领域')
cDict['数']
3
#出现次数最多的3个词
cDict.most_common(3)
[('数', 3), ('，', 3), ('大', 2)]

4、如何快速掌握编程

多敲代码多练习～多总结内化～

学会使用搜索引擎，掌握自学的能力，自己解决问题的能力～

以上是自己的学习笔记，与君共勉～附学习框架

学习框架笔记

over～有任何问题可以私信联系我～