亿点简单的代码
最基本的入门知识
- Number（数值型）
- String（字符串型）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Number(数值型)
Python3 支持 int、float、bool（布尔值）、complex（复数）
一些简单的基础操作（必须掌握）
- 赋值
- 查看数据类型——type( )
- 删除一些对象引用——del( )
- 数值运算操作
- 除数和余数的结合——divod( )
#赋值
a=20
a
a,b=20,30
print(a,b)
a, b, c, d = 20, 5.5, True, 4+3j
print(a,b,c,d)
#内置的 type() 函数可以用来查询变量所指的对象类型
print(type(a), type(b), type(c), type(d))
#使用del语句删除一些对象引用
del a
#数值运算
5 + 4 # 加法
4.3 - 2 # 减法
3 * 7 # 乘法
数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
2 / 4 # 除法，得到一个浮点数
2 // 4 # 除法，得到一个整数
17 % 3 # 取余
2 ** 5 # 乘方
divmod() 函数——把除数和余数运算结果结合起来
#divmod() 函数把除数和余数运算结果结合起来
#函数语法：divmod(a, b)
divmod(7,2)
##Output[]:(3, 1)
在混合计算时，Python会把整型转换成为浮点数。
String（字符型）
Python中的字符串用单引号 ' ' 或双引号 " " 括起来
m="abc"
m
m,n="abc","def"
print(m,n)
#连接字符串，输出结果👉abcdef
m+n
同时使用反斜杠\n 转义特殊字符 ，
\n: 换行
#转义符号/n
string="Ru\noob"
print(string)
##Output
Ru
oob
如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串
print(r'Ru\noob')
##Output
Ru\noob
[亿点补充]转义字符
字符串截取
截取的语法格式（Python在各个数据类型的截取方法一致）如下：
| 字符串/列表元素/元组元素 | R | u | n | o | o | b |
|---|---|---|---|---|---|---|
| 反向截取 | -6 | -5 | -4 | -3 | -2 | -1 |
| 正向截取 | 0 | 1 | 2 | 3 | 4 | 5 |
截取字符串采取左闭右开原则，因此如果想要截取到第i个字符，则右端点应该是i+1，
如果选取最后一个，则右端点为:
左端点也可以输入:，表示从第一个开始截取。
str = 'Runoob'
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
##Output
Runoob
Runoo
R
noo
noob
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数
print (str * 2) # 输出字符串两次
print (str + "TEST") # 连接字符串
##Output
RunoobRunoob
RunoobTEST
Python中的字符串不能改变
List(列表)
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）
tinylist = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
列表的截取和连接
list[a:b:c]: list可以接受第3个参数，第三个参数的意义是步长
list = [123,'runoob']
print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
#从第一个元素到第四个元素，步长为2（就是一个隔一个取数字）
#list[a:b:c] list可以接受第三个参数，第三个参数的意义是步长
print(tinylist[0:4:2])
print (list[2:]) # 输出从第三个元素开始的所有元素
print (list * 2) # 输出两次列表
print (list + tinylist) # 连接列表
改变列表的元素
a = [1, 2, 3, 4, 5, 6]
a[0] = 9 #将列表a中的第一个元素 1 改为 9
a[2:5] = [13, 14, 15] #将列表a中第三个到第五个数据依次改为 13，14，15
a[2:6] = [] # 将对应的元素值设为空值，不是设为 0， 是直接删除掉这些个数据
[亿点补充] append()、pop()函数
List 内置了有很多方法，例如 append()、pop() 等等
- 连接元素
append()函数 - 删除删除
pop()函数
关于Python中[]和()的运用
[]: 提取dataframe中的变量时，
- 有变量名则
表格名称[" 变量名 "] - 无变量名则
[索引数字] - 待更新…
eg.
()：使用函数时
元组（tuple）
- 元组的元素不能修改
- 元组中的元素类型也可以不相同
- 元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取
- 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
元组的截取和连接
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组
构造只有一个元素或者没有元素
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
[亿点补充]元组的函数
| 编号 | 函数 | 描述 |
|---|---|---|
| 1 | cmp(tuple1, tuple2) | 比较两个元组的元素 |
| 2 | len(tuple) | 给出元组的总长度 |
| 3 | max(tuple) | 从元组返回最大值项 |
| 4 | min(tuple) | 从元组返回最大值项 |
| 5 | tuple(seq) | 将列表转换为元组 |
[亿点补充]元组的意义——namedtuple()函数
既然tuple和list比起来没差，为什么要有这个数据呢？
- 元组适合存放那些无需修改的数据（保护数据）
- 具名元组
namedtuple，也叫 带字段名的记录 - 实现多值返回
eg.
from collections import namedtuple
# 生成一个City类
City = namedtuple("City", "name country polulation coordinates")
# 实例化
tokyo = City("Tokyo", 'JP', '36.93', ('35.68','139,69'))
print(tokyo)
# City(name='Tokyo', country='JP', polulation='36.93', coordinates=('35.68', '139,69'))
print(tokyo.name)
# Tokyo
# 打印字段名
print(City._fields)
('name', 'country', 'polulation', 'coordinates')
# 生成新实例
LatLong = namedtuple('LatLong', 'lat long')
Xiamen_tuple = ('Xiemen', 'China', '40.54', LatLong(24.26,118.03))
Xiamen = City._make(Xiamen_tuple)
print(Xiamen)
# City(name='Xiemen', country='China', polulation='40.54', coordinates=(24.26, 118.03))
集合（Set）
- 基本功能是进行成员关系测试和删除重复元素
- 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 输出集合，重复的元素被自动去掉
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
#{'Jim', 'Mary', 'Tom', 'Rose', 'Jack'}
#{'r', 'a', 'b', 'd', 'c'}
#{'r', 'b', 'd'}
#{'r', 'l', 'a', 'b', 'm', 'd', 'c', 'z'}
#{'a', 'c'}
#{'r', 'l', 'd', 'b', 'm', 'z'}
字典（Dictionary）
- 字典是无序的对象集合
- 字典当中的元素通过键来存取
- 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
- 键(key)必须使用不可变类型
- 在同一个字典中，键(key)必须是唯一的
[亿点补充]字典到底是干嘛的？
- 字典是 Python 用于存放具有映射关系的数据。
比如有份成绩表数据，语文：79，数学：80，英语：92，这组数据看上去像两个列表，但这两个列表的元素之间有一定的关联关系。如果单纯使用两个列表来保存这组数据，则无法记录两组数据之间的关联关系。
字典相当于保存了两组数据，其中一组数据是关键数据，被称为 key；另一组数据可通过 key 来访问，被称为 value。
- 由于字典中的 key 是非常关键的数据，而且程序需要通过 key 来访问 value，因此字典中的 key 不允许重复。
- 元组可以作为 dict 的 key，但列表不能作为dict的 key，这是因为键(key)必须使用不可变类型
关于怎么创建一个字典
第一种创建方式
# 创建包含3组key-value对的字典
vegetables = [('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]
dict3 = dict(vegetables)
print(dict3)
# {'celery': 1.58, 'brocoli': 1.29, 'lettuce': 2.19}
cars = [['BMW', 8.5], ['BENS', 8.3], ['AUDI', 7.9]]
# 创建包含3组key-value对的字典
dict4 = dict(cars)
print(dict4)
# {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
第二种创建方式（此时key不需要加''单引号）
# 使用关键字参数来创建字典
dict6 = dict(spinach = 1.39, cabbage = 2.59)
print(dict6) # {'spinach': 1.39, 'cabbage': 2.59}
第三种创建方式(对不存在的key赋值，就是增加key-value对)
# 对不存在的key赋值，就是增加key-value对
dict3['potato'] = 2.22
print(dict3)
# {'celery': 1.58, 'brocoli': 1.29, 'lettuce': 2.19,'spinach': 1.39,'cabbage': 2.59, 'potato': 2.22}
创建一个空字典
# 创建空的字典
dict5 = dict()#或者dict5={}
print(dict5)
# {}
一些基本操作
# 通过key访问value
print(dict3['cabbage'])
#{'cabbage': 2.59}
#删除一个key-value对
del dict3['cabbage']
# 对存在的key-value对赋值，改变key-value对
dict3['potato']=3.33
#判断字典是否包含指定的 key
print('cabbage' in dict3) # False
print('potato' not in dict3) #False
print('lettuce' in dict3)#True
What’s more 👉 Python字典及基本操作(dict的自带函数)
Numpy
非常有用的Numpy官方网站👇
https://numpy.org/doc/stable/index.html
有一定英语基础的可以去看看
Numpy数组和列表很类似,
- 数组可以比较方便的进行一些数学运算，而列表则比较麻烦；
- 数组可以支持多维的数据，而列表通常只能储存一维的数据。
import numpy as np
a = [1, 2, 3, 4]
b = np.array([1, 2, 3, 4])
print(a)
print(b)
print(type(a))
print(type(b))
列表和数组有着相同的索引机制，唯一的区别就是数组里面是通过空格加粗样式分隔元素，而列表用的是逗号。
print(b[1])
print(b[0:2])
#[1 2]
c = a * 2 #列表*2，重复列表内容两次
d = b * 2#数组*2，数组内容数值*2
print(c)#[1, 2, 3, 4, 1, 2, 3, 4]
print(d)#[2 4 6 8]
创建列表多数是一维的数据，但是numpy可以有多维的数据
e = [[1,2], [3,4], [5,6]] # 列表里的元素为小列表
f = np.array([[1,2], [3,4], [5,6]]) # 创建二维数组的一种方式
print(e)
#[[1, 2], [3, 4], [5, 6]]
print(f)
#[[1 2]
[3 4]
[5 6]]
创建数组
a=np.array([1,2,3,4])#一维数据
b=np.array([1,2,3],[4,5,6],[7,8,9])#三行三列的数组
c=np.arange(1,10,2)#参数1是起点，参数2是终点，参数3是步长
d=np.random.randn(40)#创建服从标准正态分布的40个随机数字，形成一维数组
e=(np.random.randn(3,4)+5)*2#创建服从正态分布（5，4）的，3行4列的数组
f=np.random.arange(12).reshape(3,4)#创建三行四列的数组
g = np.random.randint(0, 10, (4, 4))#创建范围在[0,10]内的四行四列的随机整数数组
print(g)
# Out[]
[[3 9 9 2]
[3 0 4 6]
[0 2 1 9]
[8 0 8 5]]
**numpy.arange
numpy.arange([start, ]stop, [step, ]dtype=None, *, like=None)
返回一组给定间隔的均匀分布的值，返回的是numpy.ndarray(多维数组)
给定范围是左闭右开区间 [start, stop)
👉See also
- numpy.linspace
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)[source]
Return evenly spaced numbers over a specified interval.
Returns num evenly spaced samples, 计算的是闭区间 [start, stop].
但是右端点可以利用参数endpoint=False选择性打开.
返回的是numpy.ndarray
d=np.linspace(2,3,num=5)
d
#Out[] array([2. , 2.25, 2.5 , 2.75, 3. ])
dtype可以设置数值类型，但是系统自动筛选的数值类型不会是int，哪怕输出的是整数，用的还是float
If dtype is not given, the data type is inferred from start and stop.
The inferred dtype will never be an integer; float is chosen even if the arguments would produce an array of integers.
d=np.linspace(2,3,num=5,dtype=str)
d
#Out[1] array(['2.0', '2.25', '2.5', '2.75', '3.0'], dtype='<U32')
d=np.linspace(2,3,num=5,dtype=int)
d
#Out[2] array([2, 2, 2, 2, 3])
Pandas
Pandas官方网站👇
https://pandas.pydata.org/pandas-docs/stable/index.html
Pandas主要有两种数据结构：Series和DataFrame
Series
Series类似于通过Numpy产生的一维数组，不同的是Series对象不仅包含数值，还包含一组索引
创建Series
import pandas as pd
s=pd.Series([1,2,3])
s
#Out[]
0 1
1 2
2 3
dtype: int64
s1 = pd.Series(['丁一', '王二', '张三'])
print(s1)
#Out[]
0 丁一
1 王二
2 张三
dtype: object
print(s1[1])
#Out[] 王二
但是Series一般不单独使用，多数用的是DataFrame，从DataFrame里用变量名提取出来的往往是Series格式
DataFrame
创建DataFrame
#第一种创建
s=[[1, 2], [3, 4], [5, 6]]
a = pd.DataFrame(s)
a
#第二种创建
a = pd.DataFrame([[1, 2], [3, 4], [5, 6]])
a
#Out[]
0 1
0 1 2
1 3 4
2 5 6
#第三种创建
b = pd.DataFrame([[1, 2], [3, 4], [5, 6]], columns=['date', 'score'], index=['A', 'B', 'C'])
#Out[]
date score
A 1 2
B 3 4
C 5 6
#第四种创建
c = pd.DataFrame() # 创建一个空DataFrame
c["data"]=[1,2,3,4]
c["score"]=[5,6,7,8]
c
#Out[]
data score
0 1 5
1 2 6
2 3 7
3 4 8
#第五种创建
d = pd.DataFrame() # 创建一个空DataFrame
date = [1, 3, 5]
score = [2, 4, 6]
d['date'] = date
d['score'] = score
d
#Out[]
date score
0 1 2
1 3 4
2 5 6
通过字典创建DataFrame
course=pd.DataFrame({'class':['ShiJianXuLie','ChouYangDiaoCha','YingYongHuiGui'],'teacher':['GaoRui','FangMaoZhong','YuHaoDong']})
course
#Out[]
class teacher
0 ShiJianXuLie GaoRui
1 ChouYangDiaoCha FangMaoZhong
2 YingYongHuiGui YuHaoDong
这里也可以在函数里面加上index=['a','b','c']，那么行索引列的0，1，2就会变成a，b，c
course=pd.DataFrame({'class':['ShiJianXuLie','ChouYangDiaoCha','YingYongHuiGui'],'teacher':['GaoRui','FangMaoZhong','YuHaoDong']},index=['a','b','c'])
course
#Out[]
class teacher
a ShiJianXuLie GaoRui
b ChouYangDiaoCha FangMaoZhong
c YingYongHuiGui YuHaoDong
pandas.DataFrame.from_dict()
pd.DataFrame.from_dict(data, orient='columns', dtype=None, columns=None)[source]
把字典转换成dataframe：
Creates DataFrame object from dictionary by columns or by index allowing dtype specification.
通过orient='index或orient='columns来控制字典中的key是行索引还是列索引，不设置则默认是orient='columns
import pandas as pd
f={'class':['ShiJianXuLie','ChouYangDiaoCha','YingYongHuiGui'],'teacher':['GaoRui','FangMaoZhong','YuHaoDong']}
pd.DataFrame.from_dict(f,orient='columns')
#Out[]
class teacher
0 ShiJianXuLie GaoRui
1 ChouYangDiaoCha FangMaoZhong
2 YingYongHuiGui YuHaoDong
import pandas as pd
f={'class':['ShiJianXuLie','ChouYangDiaoCha','YingYongHuiGui'],'teacher':['GaoRui','FangMaoZhong','YuHaoDong']}
pd.DataFrame.from_dict(f,orient='index')
#Out[]
0 1 2
class ShiJianXuLie ChouYangDiaoCha YingYongHuiGui
teacher GaoRui FangMaoZhong YuHaoDong
转置
在数据框后用.T对数据框进行转置
print(c)#原数据框
print(c.T)#转置后的数据框
用numpy创建数据框
记得import numpy as np
import numpy as np
a=np.arange(12).reshape(3,4)
c=pd.DataFrame(a)
a
#Out[]
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
#或者👇
c1=pd.DataFrame(a,columns=['a','b','c','d'],index=[1,2,3])#加了个行索引和列索引
c1
#Out[]
A B C D
1 0 1 2 3
2 4 5 6 7
3 8 9 10 11
rename()
利用映射改变行索引，列索引，坐标轴
DataFrame.rename(mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False, level=None, errors='ignore')
[level:int, str, tuple, or list, default None]
f
#Out[]
class teacher
0 ShiJianXuLie GaoRui
1 ChouYangDiaoCha FangMaoZhong
2 YingYongHuiGui YuHaoDong
f.rename(columns={'class':'课程','teacher':'老师'},inplace=True)
#Out[]
课程 老师
0 ShiJianXuLie GaoRui
1 ChouYangDiaoCha FangMaoZhong
2 YingYongHuiGui YuHaoDong
#在函数中加上inplace=True，那么f在索引上的改变就被赋值给自己了，不需要再新建一个df进行赋值；如若不然，这个索引的改变并没有实际改变在f本身上，即并没有改变原表格结构。
set_index()/reset_index()
set_index()
DataFrame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)[source]
将数据框中的某一列数据作为索引
f
#Out[]
课程 老师
0 ShiJianXuLie GaoRui
1 ChouYangDiaoCha FangMaoZhong
2 YingYongHuiGui YuHaoDong
f.set_index('课程',inplace=False)#inplace的默认就是False，可以不写
#Out[]
老师
课程
ShiJianXuLie GaoRui
ChouYangDiaoCha FangMaoZhong
YingYongHuiGui YuHaoDong
f.index.name='序号'#直接给索引起名字
#Out[]
课程 老师
序号
0 ShiJianXuLie GaoRui
1 ChouYangDiaoCha FangMaoZhong
2 YingYongHuiGui YuHaoDong
reset_index()
DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')
level见👉rename
重置索引名称，并且还原成默认
Reset the index of the DataFrame, and use the default one instead
f.reset_index()
#Out[]
序号 课程 老师
0 0 ShiJianXuLie GaoRui
1 1 ChouYangDiaoCha FangMaoZhong
2 2 YingYongHuiGui YuHaoDong
f.reset_index(drop=True)#drop=True 可以删除掉序号那一列
#Out[]
课程 老师
0 ShiJianXuLie GaoRui
1 ChouYangDiaoCha FangMaoZhong
2 YingYongHuiGui YuHaoDong
数据读取、写入（报错解决）
pd.read_csv( )
这里仅仅展示常用的参数,完整的参数太长了
pd.read_csv(filepath_or_buffer,sep=NoDefault.no_default, header='infer', names=NoDefault.no_default, index_col=None,dtype=None,encoding=None)
- sep 默认值为
','因为csv文件里面的分隔符不是,而导致的乱码，需要手动设置这个参数 - header 默认值为
header=0等价于header='False'，当导入的文件第一行自带变量名，一定要改成header=1或者header='True' - names 当导入的文件需要第一行的变量名，则使用这个参数。如果已经有变量名，需要补上
header=0再添加新的变量名 - index_col 可以选择文件中的变量设置为索引，eg.
index_col=0即数据框第一列设置为索引 - dtype 以字典格式可以把不同列分别设置成不同的数据类型，eg.
dtype={'a':np.float64,'b':np.int32} - encoding 文字乱码，尤其是中文字，可以通过
encoding='gbk'或者encoding='UTF-8'解决
绝对路径写法👇
data.to_excel('E:\\大数据分析\\data.xlsx')
相对路径写法👇前提是先把文件导入了Python的Homepage
data1=pd.read_csv('附件.csv')
不同数据类型的导入代码,有少数参数不同
data=pd.read_csv()
data=pd.read_excel()
sheet_name=0导入excel的sheet1，默认值是导入所有sheet
sheet_name='Sheet1'导入sheet的名字是’Sheet1’的sheet
data=pd.read_table()#用这个可以导入文本文件
pandas.DataFrame.to_excel
DataFrame.to_excel(excel_writer, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, encoding=None, inf_rep='inf')
na_rep=''写入的数据的缺失值的表示方式float_format=" "设置小数格式 eg.float_format="%.2f"保留两位小数inf_rep='inf'设置无穷大的表示方式
DataFrame的提取数列
course
#Out[]
class teacher
a ShiJianXuLie GaoRui
b ChouYangDiaoCha FangMaoZhong
c YingYongHuiGui YuHaoDong
course['class']#这里返回的是一维的series，所以没有表头
#Out[]
a ShiJianXuLie
b ChouYangDiaoCha
c YingYongHuiGui
Name: class, dtype: object
course[['class']]#这里返回的是二维的表格数据
#Out[]
class
a ShiJianXuLie
b ChouYangDiaoCha
c YingYongHuiGui
提取多组列数据
course[['class','teacher']]
#Out[]
class teacher
a ShiJianXuLie GaoRui
b ChouYangDiaoCha FangMaoZhong
c YingYongHuiGui YuHaoDong
iloc
提取行数据
course[1:3]#提取第二到第三行，注意左闭右开原则
course[0，1]#提取第一，第二行
course.iloc[0:2]#提取第一到第二行
在这里插入代码片
df.iloc[1,1]#提起第二行第二列的数据
df.iloc[[1,2],[3,4]]#提取第二行，第三行以及第四列第五列的交点的数据
df.iloc[1:3,3:6]#提取第二到第三行，第三列到第六列的交点的数据
df.iloc[:,[True,False,True,False]]#这里假设只有四列数据，那么提取的就是第一列和第三列的所有行数据
loc
Note that contrary to usual python slices,both the start and the stop are included
loc可以通过行索引提取数据
df.loc[['viper', 'sidewinder']]#提取viper行和sidewinder行
df.loc['cobra', 'shield']#提取cobra行，shield列的数据
除了像iloc选取数列，loc函数更多还有一个筛选的功能
df.loc[df['shield'] > 35] = 0#筛选df数据框中shield>35的数据，并且赋值为0
df.loc[df['shield']=35]#筛选df数据框中shield值等于5的数据
df.loc[:,'max_speed'] = 30#让max_speed所有行都改为30
这里不需要inplace
dtype
DataFrame.dtypes
This returns a Series with the data type of each column. The result’s index is the original DataFrame’s columns. ==Columns with mixed types are stored with the object dtype. ==
drop
DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')
argument:
axis=1 代表drop labels from the ‘columns’,axis=0(默认值)代表drop labels from the 'index’
inplace=True代表改变原数据结构，覆盖原数据
eg.
#删除变量名为B和C的列
df.drop(['B', 'C'], axis=1)
df.drop(columns=['B', 'C'])
df.drop(['a','c'])#删除index为a和c的行
df.drop([0, 1])#删除第一，第二行
df.drop(index='a', columns='A',inplace=True)#删除index为a的行数据和变量名为A的列数据，覆盖原数据
DataFrame.dropna
DataFrame.drop_duplicates
Please turn to 案例分析.数据预处理
案例分析
数据预处理
缺失值
.isna()
DataFrame.isna()
Detect missing values
Series也可以用这个函数
❗ 类似于空的字符串‘’和无穷大值不被考虑为NA值
返回的数据是一个同样大小的bool型数值矩阵：
age born name toy
0 True False True False
1 True True True True
2 False True True True
那么怎么显示所有缺失值的行呢？
df.isna().sum()#显示所有变量的缺失值个数
df.info()#显示所有变量的数据个数和数据格式
df[df['A'].isna()]#这里假设，在第一步我查看出‘A’列有缺失值，那么可以显示‘A’列所有出现缺失值的行
注意**.info.()不适用于series**，所以如果要查看某一列的数据，要转换成dataframe的格式，即：
df['A'].info()#会报错×
df[['A']].info()#可以运行√
.dropna()
DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
Remove missing values.
argument:
how=‘any’ 默认值，如果该列（行）内有任何数据缺失，则删除
how='all'如果该列（行）所有数据都缺失，则删除
subset=''如果subset指定的变量在该行（列）有缺失，则删除
除了删掉缺失值列以外，如果遇到样本数据有限的情况，我们可以选择填补缺失值，那么就有
.fillna()
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
arguments:
method:{'backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}
method='ffill/pad'用缺失值上一个有效观测值填补
method='bfill/backfill'用缺失值下一个有效观测值填补
df.fillna(0)#用0填补所有缺失值
df.fillna(method='bfill'，implace=True)#用每个缺失值各自的后一项有效观测值填补
df['A'].fillna(0,inplace=True)#用0填补'A'列的缺失值
df['B'].fillna(method='ffill',inplace=True)#用前一个有效观测值填补'B'列
#分别用0，1，2，3填补'A','B','C','D'列的缺失值
values = {"A": 0, "B": 1, "C": 2, "D": 3}
df.fillna(value=values)
重复值
.duplicated()
DataFrame.duplicated(subset=None, keep='first')
返回一组bool数据的数据框,重复值处显示True，非重复值处显示False
df.duplicated(subset='style')#返回一组bool数列
df[df.duplicated(subset='style')]#显示在style列有重复的所有重复行
.drop_duplicates()
DataFrame.drop_duplicates(subset=None, keep='first', inplace=False, ignore_index=False)
==返回已经被去除重复数据的数据框，默认不改变原
时间格式的数值将会被忽略
arguments：
keep：{‘first’, ‘last’, False}, default ‘first’
默认保留第重复数据行中的第一行，也可以改变选择保留最后一个
subset与**.dropna（）**用法一致
eg.
#删除在'brand'和'style'中有重复的数据行，并保留重复行中的最后一行
df.drop_duplicates(subset=['brand', 'style'], keep='last')
数据改格式
.astype()
DataFrame.astype(dtype, copy=True, errors='raise')
arguments:
- dtypedata: type, or dict of column name -> data type
eg.
df.astype('int32')#把整个数据框所有数据格式都改成'int32'
df.astype({'col1': 'int32'})#只把col1这个变量下的数据格式改成'int32'
- errors:‘raise’, ‘ignore’,default ‘raise’
-
raise: 所有改格式出错的数据都会被报错 -
ignore: 所有改格式不成功的数据将会以object的形式显示，而非报错.
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
