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)