12、concatenate

numpy提供了numpy.concatenate((a1,a2,…), axis=0)函数。能够一次完成多个数组的拼接。其中a1,a2,…是数组类型的参数

>>> a=np.array([1,2,3])
>>> b=np.array([11,22,33])
>>> c=np.array([44,55,66])
>>> np.concatenate((a,b,c),axis=0)  # 默认情况下，axis=0可以不写
array([ 1,  2,  3, 11, 22, 33, 44, 55, 66]) #对于一维数组拼接，axis的值不影响最后的结果
>>> a=np.array([[1,2,3],[4,5,6]])
>>> b=np.array([[11,21,31],[7,8,9]])
>>> np.concatenate((a,b),axis=0)
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [11, 21, 31],
       [ 7,  8,  9]])
>>> np.concatenate((a,b),axis=1)  #axis=1表示对应行的数组进行拼接
array([[ 1,  2,  3, 11, 21, 31],
       [ 4,  5,  6,  7,  8,  9]])

numpy.append()和numpy.concatenate()相比，concatenate()效率更高，适合大规模的数据拼接

13、concat

如果要合并的DataFrame之间没有连接键，就无法使用merge方法，此时可以使用concat方法，把两个完全无关的数据拼起来。

concat方法相当于数据库中的全连接(UNION ALL),可以指定按某个轴进行连接,也可以指定连接的方式join(outer,inner 只有这两种)。

与数据库不同的是concat不会去重，要达到去重的效果可以使用drop_duplicates方法

concat(
    objs, axis=0, join='outer', join_axes=None, 
    ignore_index=False, keys=None, levels=None, names=None,
    verify_integrity=False, copy=True
)

df1 = DataFrame({'a1': ['Chicago', 'San Francisco', 'New York City'], 'rank': range(1, 4)})
df2 = DataFrame({'a2': ['Chicago', 'Boston', 'Los Angeles'], 'rank': [1, 4, 5]})
pd.concat([df1,df2])

从上面的结果可以看出，concat的连接方式是外连接（并集），通过传入join=‘inner’可以实现内连接。

winedf=pd.concat([pd.DataFrame(wine.data),pd.DataFrame(wine.target)],axis=1)

14、groupby

groupby：可以根据索引或字段对数据进行分组。

DataFrame.groupby(by=None,axis=0,level=None,as_index=True,sort=True,group_keys=True,squeeze=False)

对于by，如果传入的是一个函数，则对索引进行计算并分组；如果传入的是字典或者Series,则用字典或者Series的值作为分组的依据；如果传入的是numpy数组，则用数据元素作为分组依据‘如果传入的是字符串或者字符串列表，则用这些字符串所代表的字段作为分组依据。

15、values()与itervalues()

1、values()：

python内置的values()函数返回一个字典中所有的值。

即只返回{key0:value0,key1:value1}中的value0、value1……

并且重复值都会返回

values() 方法把一个 dict 转换成了包含 value 的list。

itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

打印 itervalues() 发现它返回一个对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

16、value_counts

pandas 的value_counts()函数可以对Series里面的每个值进行计数并且排序。

如果我们想知道，每个区域出现了多少次，可以简单如下：

每个区域都被计数，并且默认从最高到最低做降序排列。

如果想用升序排列，可以加参数ascending=True：

如果想得出的计数占比，可以加参数normalize=True：

空值是默认剔除掉的。value_counts()返回的结果是一个Series数组，可以跟别的数组进行运算。

例子二：结合分桶函数cut

ages = [20,22,25,27,21,23,37,31,61,45,41,32]
#将所有的ages进行分组
bins = [18,25,35,60,100]
#使用pandas中的cut对年龄数据进行分组
cats = pd.cut(ages,bins)
print(cats)

#调用pd.value_counts方法统计每个区间的个数
number=pd.value_counts(cats)
print(pd.value_counts(cats))

17、sort 与sort_values

sorted(iterable[, cmp[, key[, reverse]]])
iterable.sort(cmp[, key[, reverse]])

参数解释：

（1）iterable指定要排序的list或者iterable，不用多说；

（2）cmp为函数，指定排序时进行比较的函数，可以指定一个函数或者lambda函数，如：

students为类对象的list，每个成员有三个域，用sorted进行比较时可以自己定cmp函数，例如这里要通过比较第三个数据成员来排序，代码可以这样写：

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda student : student[2])

（3）key为函数，指定取待排序元素的哪一项进行排序，函数用上面的例子来说明，代码如下：

sorted(students, key=lambda student : student[2])

key指定的lambda函数功能是去元素student的第三个域（即：student[2]），因此sorted排序时，会以students所有元素的第三个域来进行排序。

18、open

open(file, mode='r')
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型

19、read_cav与to_csv

read_csv
to_csv

【1】获取当前工作路径

import os
os.getcwd() # 获取当前工作路径

【2】to_csv()是DataFrame类的方法，read_csv()是pandas的方法

dt.to_csv() #默认dt是DataFrame的一个实例，参数解释如下

【3】路径 path_or_buf: A string path to the file to write or a StringIO

dt.to_csv('Result.csv') #相对位置，保存在getwcd()获得的路径下  
dt.to_csv('C:/Users/think/Desktop/Result.csv') #绝对位置

【4】分隔符 sep : Field delimiter for the output file (default ”,”)

dt.to_csv('C:/Users/think/Desktop/Result.csv',sep='?')#使用?分隔需要保存的数据，如果不写，默认是,

【5】替换空值 na_rep: A string representation of a missing value (default ‘’)

dt.to_csv('C:/Users/think/Desktop/Result1.csv',na_rep='NA') #缺失值保存为NA，如果不写，默认是空

【6】格式 float_format: Format string for floating point numbers

dt.to_csv('C:/Users/think/Desktop/Result1.csv',float_format='%.2f') #保留两位小数

【7】保存某列数据 cols: Columns to write (default None)

dt.to_csv('C:/Users/think/Desktop/Result.csv',columns=['name']) #保存索引列和name列

【8】是否保留列名 header: Whether to write out the column names (default True)

dt.to_csv('C:/Users/think/Desktop/Result.csv',header=0) #不保存列名

【9】是否保留行索引 index: whether to write row (index) names (default True)

dt.to_csv('C:/Users/think/Desktop/Result1.csv',index=0) #不保存行索引

20、remove

remove() 函数可以删除列表中的指定元素。

语法：

list.remove(obj)

【1】obj – 列表中要移除的对象。

【2】返回值：该方法没有返回值但是会移除列表中的某个值的第一个匹配项。

分析一下结果为什么是【2,4】

remove方法用于移除列表中某个值的第一个匹配，这个没错。但是在上述例子中，第一次循环时，i=1，因此移除1，此时list为：[2,3,4,5]

此时索引为0的元素已经变成了2，而不再是1，而循环会从索引为1的元素开始，此时 i=3，然后根据 if 的判断，3会被remove掉，元素 4 的索引位置再往前变为2，循环再次开启，从索引为 3 的地方开始，即 5，再remove掉，故此最后遗留下来的list是：[2, 4]

21、series

import numpy as np
import pandas as pd
l1 = [1,2,"中国",4.5]
display(type(l1)) #list
display(l1) # [1, 2, '中国', 4.5]
display(l1[2]) #  '中国'
=================================================================
a1 = np.array([1,2,5,6,8])
display(a1) # array([1, 2, 5, 6, 8])
display(type(a1)) #numpy.ndarray
display(a1[4]) # 8
=================================================================
s1 = pd.Series([1,3,5,7,9])
display(s1)
'''
0    1
1    3
2    5
3    7
4    9
dtype: int64
'''
display(s1[4]) # 9
=================================================================
s2 = pd.Series([1,3,5,7,9],index=["a","b","c","d","e"])
display(s2)
'''
a    1
b    3
c    5
d    7
e    9
dtype: int64
'''
display(s2["d"]) # 7
display(s2[3]) # 7
=================================================================
s3 = pd.Series([1,3,5,7,9],index=[3,4,5,6,6]) #index是可以重复的
display(s3)
'''
3    1
4    3
5    5
6    7
6    9
dtype: int64
'''
display(s3[6])
# 括号里面指的都是索引index ，由于有两个index都是6，因此两个都输出
'''
6    7
6    9
dtype: int64
'''

创建Series序列时，当不指定索引的时候，默认使用的从0开始的整数索引；当自己指定了字符串索引，既可以通过这个字符串索引访问元素，也可以通过默认的整数索引访问元素；当自己指定一个整数索引，那么该索引会覆盖掉原有的默认的整数索引，只能通过这个新的整数索引访问元素，默认的整数索引会失效。

【1】创建Series的语法：pd.Series()；

【2】常用的几个参数：index，用于指定新的索引；dtype，用于指定元素的数据类型；

【3】大前提：要记住Series是一个一维的结构

1、通过一维列表创建Series

x = [1,3,5,7,9]
y = pd.Series(x,index=["a","b","c","d","e"],dtype=np.float32)
display(y)
'''
a    1.0
b    3.0
c    5.0
d    7.0
e    9.0
dtype: float32
'''

2、通过可迭代对象创建Series

x = range(2,7)
y = pd.Series(x)
display(y)
'''
0    2
1    3
2    4
3    5
4    6
dtype: int64
'''

3、通过字典创建Series

x = dict(a=22,b=18,c=35)
y = pd.Series(x)
display(y)
'''
a    22
b    18
c    35
dtype: int64
'''

4、通过一维数组创建Series

x = np.arange(1,6)
y = pd.Series(x)
display(y)
'''
0    1
1    2
2    3
3    4
4    5
dtype: int32
'''

5、通过标量(常数)创建Series

x = 22
y1 = pd.Series(x)
display(y1)
y2 = pd.Series(x,index=list(range(5)))
display(y2)
'''
0    22
dtype: int64
0    22
1    22
2    22
3    22
4    22
dtype: int64
'''

6、list、ndarray、Series的简单比较

【1】list列表，列表中的元素可以是不同的数据类型，使用从0开始的整数值作为默认索引；

【2】ndarray数组，数组中的元素必须是同种数据类型，也是使用从0开始的整数值作为默认索引；

【3】Series序列，是一种一维的结构，类似于一维列表和ndarray中的一维数组，但是功能比他们要更为强大，Series由两部分组成：索引index和数值values；

一维列表和一维数组中都是采用从0开始的整数值作为默认索引，索引值一般不显示的给出，但是我们可以通过索引去获取其中的元素。对于Series来说，默认索引也是从0开始的整数值作为默认索引，但是是显示地给出，更为强大的是，Series中的索引可以随意设置，方便我们取数。

22、DF的表头columns和index

对于DataFrame表格来说，dataframe.columns返回的是横向的表头，dataframe.index返回的是纵向的表头

import numpy as np 
df1= pd.DataFrame([('bird', 389.0),('bird', 24.0),
                   ('mammal', 80.5),('mammal', np.nan)],
                  index=['falcon', 'parrot', 'lion', 'monkey'],
                  columns=('class', 'max_speed'))
df2= pd.DataFrame([('bird', 389.0),('bird', 24.0),
                   ('mammal', 80.5),('mammal', np.nan)],)
display(df1,df2)

用columns修改列名:

import pandas as pd
df = pd.DataFrame({'$a': [1], '$b': [1], '$c': [1], '$d': [1], '$e': [1]})
df.columns = ['a', 'b', 'c', 'd', 'e']

改变Dataframe一列当中的列名：

# （作业：分类型数据类型转换成int型）
lidf23=lidf23.astype({'评价':'int'})

Series和ndarray中常用属性对比：

s = pd.Series([1,3,5,7,9])
display(s)
display(s.ndim) # 1：表示一维
display(s.shape) # （5，）:表示一维，并且有5个元素
display(s.dtype) # dtype('int64') 类型
display(s.size) # 5 元素个数
display(s.nbytes)# 40：所有元素所占空间的大小
display(s.T)# 转置，由于是一维的所以没有变化

23、字典

Python字典是另一种可变容器模型,可存储任意类型对象。如字符串、数字、元组等其他容器模型

因为字典是无序的所以不支持索引和切片。

元素以键值对存在》》》key(键值):value(实值)

空字典：字典名={} 或者字典名=dict()

dict = {"nane": "张三", "age": 20, "sex": "男"}
dict1={}
print(dict) # {'nane': '张三', 'age': 20, 'sex': '男'}
print(dict1) # {}

【1】key不可以重复,否则只会保留第一个;

【2】value值可以重复;

【3】key可以是任意的数据类型,但不能出现可变的数据类型,保证key唯一;

【4】key一般形式为字符串。

字典的增删改查

格式: 字典名[new key]=new value

# 定义一个字典
dict = {"nane": "张三", "age": 20, "sex": "男"}
# 增加元素
dict["score"] = 100
print(dict) # {'nane': '张三', 'age': 20, 'sex': '男', 'score': 100}

格式:del 字典名[key]

# 定义一个字典
dict = {"name": "张三", "age": 20, "sex": "男"}
#删除元素
del dict["name"]
print(dict) # {'age': 20, 'sex': '男'}

格式: 字典名[key]=new value

# 定义一个字典
dict = {"name": "张三", "age": 20, "sex": "男"}
#修改元素
dict["name"]="李四"
print(dict) # {'name': '李四', 'age': 20, 'sex': '男'}

格式: value=字典名[key]

# 定义一个字典
dict = {"name": "张三", "age": 20, "sex": "男"}
#查找元素
value=dict["sex"]
print(value) #  男

清空字典

#清空字典
dict.clear()
print(dict)

名称	解释
len()	测量字典中键值对个数
keys()	返回字典中所有的key
values()	返回包含value的列表
items()	返回包含(键值,实值)元组的列表
in \ not in	判断key是否存在字典中

# 定义一个字典
dict = {"name": "张三", "age": 20, "sex": "男"}
#常见操作
#len():测量字典中的键值对
print(len(dict)) # 3
#keys():返回所有的key
print(dict.keys()) #dict_keys(['name', 'age', 'sex']) 
#values():返回包含value的列表
print(dict.values()) # dict_values(['张三', 20, '男'])
#items():返回包含(键值,实值)元组的列表
print(dict.items()) # dict_values(['张三', 20, '男'])
#in  not in
if 20 in dict.values():
    print("我是年龄")
if "李四" not in dict.values():
    print("李四不存在")

字典函数values(),keys(),items()

values()函数：返回一个字典中所有的值。即只返回{key0:value0,key1:value1}中的value0、value1。
keys()函数：以列表形式（并非直接的列表，若要返回列表值还需调用list函数）返回字典中的所有的键。
items()函数：是可以将字典中的所有项，以列表方式返回。因为字典是无序的，所以用items方法返回字典的所有项，也是没有顺序的。

字典三种取值方式

1.value=字典名[key]:

这种是比较简单的方式,通过key值进行取值

#字典的定义
my_dict={"name":"小红","age":20,"sex":"女"}
#1.value=字典名[key]
print(my_dict["age"]) # 20

2.setdefault:

格式:字典名.setdefault(k,value)

如果key值存在,那么返回对应字典的value,不会用到自己设置的value;

如果key值不存在.返回None,并且把新设置的key和value保存在字典中;

如果key值不存在,但设置了value,则返回设置的value;

#字典的定义
my_dict={"name":"小红","age":20,"sex":"女"}
#2.setdefault:  格式:字典名.setdefault(k,default)
#如果key存在返回对应的value
print(my_dict.setdefault("name")) # 小红
print(my_dict.setdefault("name","111")) # 小红
print(my_dict) #{'name': '小红', 'age': 20, 'sex': '女'}
#如果key不存在,返回None,并且将设置的加入字典中
print(my_dict.setdefault("name1")) # None
print(my_dict.setdefault("name1","555")) # None
print(my_dict) # {'name': '小红', 'age': 20, 'sex': '女', 'name1': None}

3.get:

格式:字典名.get(k,value)

如果key值存在,那么返回对应字典的value,不会用到自己设置的value;

如果key值不存在.返回None,但是不会把新设置的key和value保存在字典中;

如果key值不存在,但设置了value,则返回设置的value;

#字典的定义
my_dict={"name":"小红","age":20,"sex":"女"}
#3.get:   格式:字典名.get(k,default)
#如果key存在返回对应的value
print(my_dict.get("name")) #小红
print(my_dict.get("name","李四")) # 小红
#如果key不存在,返回None,设置的不加入字典中
print(my_dict.get("name2")) # None
print(my_dict.get("name2","王五")) # 王五
print(my_dict) # {'name': '小红', 'age': 20, 'sex': '女'}

字典的遍历

#字典的定义
my_dict={"name":"小红","age":20,"sex":"女"}
#1.key
for i in my_dict.keys():
    print(i)
'''
name
age
sex
'''
#2.value
for i in my_dict.values():
    print(i)
'''
小红
20
女
'''
#3.所有项(元素)  item
for i in my_dict.items():
    print(i)
'''
('name', '小红')
('age', 20)
('sex', '女')
'''
#4.依次打印key和value,通过索引
for key,value in my_dict.items():
    print(key,value)
'''
name 小红
age 20
sex 女
'''
#5.元素值和对应的下标索引  enumerate(列表名)
for i in enumerate(my_dict):
    print(i)
'''
(0, 'name')
(1, 'age')
(2, 'sex')
'''

python 期末复习笔记（持续更新）（中）

12、concatenate

13、concat

14、groupby

15、values()与itervalues()

16、value_counts

17、sort 与sort_values

18、open

19、read_cav与to_csv

20、remove

21、series

1、通过一维列表创建Series

2、通过可迭代对象创建Series

3、通过字典创建Series

4、通过一维数组创建Series

5、通过标量(常数)创建Series

6、list、ndarray、Series的简单比较

22、DF的表头columns和index

23、字典

字典的增删改查

字典函数values(),keys(),items()

字典三种取值方式

字典的遍历

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

python 期末复习笔记（持续更新）（中）

12、concatenate

13、concat

14、groupby

15、values()与itervalues()

16、value_counts

17、sort 与sort_values

18、open

19、read_cav与to_csv

20、remove

21、series

1、通过一维列表创建Series

2、通过可迭代对象创建Series

3、通过字典创建Series

4、通过一维数组创建Series

5、通过标量(常数)创建Series

6、list、ndarray、Series的简单比较

22、DF的表头columns和index

23、字典

字典的增删改查

字典函数values(),keys(),items()

字典三种取值方式

字典的遍历

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像