'''
统计如下list单词及其出现的次数。
'''
a=['apple', 'banana', 'apple', 'tomato', 'orange', 'apple', 'banana', 'watermeton']

dic={}
for key in a:
    dic[key]=dic.get(key,0) +1
print(dic)

#等同于

for key in a:
    if key in dic.keys():
        dic[key]=dic[key]+1
    else:
        dic[key]=1
print(dic)

'''
给列表中的字典排序(例如有如下list对象,将alist中的元素按照age从小到大排序)
'''
alist=[{"name":"a", "age":20}, {"name":"b", "age":30}, {"name":"c", "age":25}]
# 法一
for i in range(1,len(alist)):
    for j in range(0,len(alist)-i):
        if alist[j].get('age')>alist[j+1].get('age'):
            alist[j],alist[j+1]=alist[j+1],alist[j]
print(alist)
#法二
alist.sort(key=lambda x: x['age'])
print(alist)

转载于：https://blog.csdn.net/weixin_45044554/article/details/125547411
'''
                                    numpy
'''
import numpy as np
array001=np.array([1,2,3,4,5,6,7,8,9,10,11,12])
array002=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

array003=array001.reshape(3,-1)     #转换成3行，列需要计算
# array003=array001.reshape(-1,4)     转换成4列，行需要计算
# print(array003)

# array004=np.append(array001,[-1,-2,-3,-4])
array004=np.append(array002,[[-1],[-2],[-3]],axis=1)      #增加一列
# print(array004)

array005=array002.T
# print(array005)
array006=np.delete(array005,1,axis=0)       #axis=0 删除行，axis=1 删除列
# print(array006)

array002[1:2,1:2]=0
# print(array002)

arr1 = np.array([1,2,3])
arr2 = np.array([4,5,6])
# print('纵向堆叠后：\n',np.vstack((arr1,arr2)),
#       '\n横向堆叠后：\n',np.hstack((arr1,arr2)))


# mat()方法可以把其他数据结构的对象转换为矩阵类型
array1 = [1,2,3]
array2 = [6,7,8]
array3 = [11,12,17]
matrix = np.mat([array1,array2,array3])
# print('显示该数据结构类型：',type(matrix))
# print(matrix)


# 矩阵合并。c_() 方法进行连接，根据参数顺序也将决定生产矩阵的结果；r_() 方法用于列连接
mat1 = np.mat([[1,2],[3,4]])
mat2 = np.mat([4,5])
matrix_r = np.c_[mat1,mat2.T]
# print('将mat2矩阵添加在原矩阵右侧\n',matrix_r)
matrix_l = np.c_[mat2.T,mat1]
# print('将mat2矩阵添加在原矩阵左侧\n',matrix_l)
matrix_u = np.r_[np.mat([array1]),matrix]
# print('在原矩阵上方连接矩阵\n',matrix_u)


# 矩阵常常与列表和数组进行数据类型转换
# print('矩阵列表转换：\n',matrix.tolist(),
#       '\n矩阵转数组：\n',np.array(matrix))



'''
                                    pandas
'''
import pandas as pd

sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
s0 = pd.Series(sdata)
# print('利用字典生成的序列对象\n',s0)
# print('显示该数据结构类型：',type(s0))
s1 = pd.Series([6,1,2,9])
# print('利用列表生成的序列对象\n',s1)


s1=pd.Series([6,1,2,9],index=['a','b','c','d'])
# print(s1)

# 查询
# print('序列的值\n',s0.values)
# print('序列的索引\n',s0.index)
# print('按照下标查找序列',s0[2])
# print('按照索引值查找元素',s0['Utah'])
# print('按照下标批量查找序列\n',s0[:2])
# print('按照索引值批量查找元素\n',s0[['Ohio','Oregon']])


# 增加
s2=s1.append(pd.Series([12],index=['e']))
# print(s2)

# 删除
s3=s1.drop('a')
# print(s3)

# 修改
s1['a']=4
# print(s1)


# Series特殊操作

    # 排序
# print(s1.sort_values())     #升序排序

    #序列求中位数
# print(s1)
# print('中位数为：'+str(s1.median()))
# print('大于序列中位数的数\n',s1[s1>s1.median()])

    # 序列的运算
s2 = pd.Series([4,3,5,8],index=['a','b','c','d'])
# print(s2+s1)

    #时间序列
s3 = pd.Series([100,150,200])
# print('产生的序列是：\n',s3)
idx = pd.date_range(start='2019-9',freq='M',periods=3)  #freq 是频率,“M”表示一个月的最后一天
# print('\n生成的时间序列是：\n',idx)
s3.index = idx
# print('\n产生的时间序列是：\n',s3)

'''pd.date_range(
    start=None,#开始时间
    end=None,#截止时间
    periods=None,#总长度
    freq=None,#时间间隔/频率，默认天，pd.date_range()默认频率为日历日，pd.bdate_range()默认频率为工作日
    tz=None,#时区
    normalize=False,#是否标准化到midnight
    name=None,#date名称
    closed=None,#首尾是否在内
)'''

            #数据框（DataFrame）
# pd.DataFrame(data,columns,index)
dic1 = {'name':['Tom','Lily','Cindy','Petter'],'no':['001','002','003','004'],'age':[16,16,15,16],'gender':['m','f','f','m']}
df1 = pd.DataFrame(dic1)
# print('显示该数据结构类型',type(df1))
df1.index.name = 'id'     #index.name给索引命名
# print(df1)

    #查询
'''
获取列索引：df.cloums 
获取行索引：df.index
获取值：df.value
'''
column = df1.no
row = df1.loc[3]
# print(df1)
# print('\n列数据索引\n',column,'\n行数据索引\n',row)


    # 增加
# print('修改前：\n',df1)
df2 = df1.append([{'name':'Stark','no':'005','age':15,'gender':'m'}],ignore_index=True) #接着索引号为4，不写的话就是0
# print('增加行：\n',df2)
df2['new_Col'] = [1,2,3,4,5]
# print('增加列：\n',df2)

    #删除
df3 = df1.copy()
# print('处理前的数据\n',df3)
df3b = df3.drop(['name'],axis=1)
# print('删除列后的数据框\n',df3b)
df3c = df3.drop([2])
# print('删除行后的数据框\n',df3c)

    #合并修改
#按列合并
df4 = pd.DataFrame({'address':['school','home','school','school','home']})
df5 = pd.concat([df2,df4],axis=1)
# print('合并前的df2\n',df2)
# print('合并前的df4\n',df4)
# print('合并后的df5\n',df5)

#按行合并
df6 = pd.DataFrame({'name':['Tony'],'no':['005'],'age':[16],'gender':['m']})
df7 = pd.concat([df1,df6],axis=0,ignore_index=True)
# print('合并前的df1\n',df1)
# print('合并前的df6\n',df6)
# print('合并后的df7\n',df7)

表连接的几种类型：自连接、内连接、左外连接、右外连接。

1、自连接

       自连接：即表本身和自己连接。

准备两个表：

一个学生表stu，字段有：stu_id，stu_name，stu_cls
一个课程表class，字段有：cls_id，cls_name，cls_stu_id（选课学生id）

2、内连接

语法：

select 查找字段..
from 左表
inner join 右表
on 查找条件;

查找出所有选了课的学生的名字，和所选课程名称

select stu_name,cls_name
from stu
inner join class
on stu_id= clas_stu_id;

3、左外连接

select 查找字段..
from 左表
left join右表
on 左表字段  = 右表字段 ;

select 查找字段..
from 左表,右表
where 左表字段 = 右表字段(+);

通用语法：
select stu_name,cls_name
from stu
left join class
on stu_id = cls_stu_id；

oracle特有语法实现：
select stu_name,cls_name
from stu,class
where stu_id = cls_stu_id(+)；

通用语法：
select 左表字段，右表字段
from 左表
right join 右表
on 左表字段 = 右表字段;

特有语法：
select 左表字段，右表字段
from 左表，右表
where 左表字段（+） = 右表字段;

通用语法
select cls_name,stu_name
from class
right join stu
on cls_stu_id = stu_id;

特有语法;
select cls_name,stu_name
from class,stu
where cls_stu_id(+) = stu_id;

1、索引有哪些类型？

       普通索引：普通索引是最基本的索引，没有任何限制，值可以为空；仅加速查询；

        唯一索引：与普通索引类似，不同的是：索引的列必须唯一，但可以为空值，如果是组合索引，则列值的组合必须唯一；

        主键索引：主键索引是特殊的唯一索引，一个表只能有一个主键，不许有空值；

        组合索引：组合索引指在多个字段上创建的索引，只有在查询条件中使用了创建索引时的第一个字段，索引才会被使用。使用组合索引时遵循最左前缀集合；

        全文索引：全文索引主要用来查找文本中的关键字，而不是直接与索引中的值相比较。

2、union和union all的区别

        union和union all 都是对于多个查询结果的并集进行操作，但：union会去重并排序，而union all会将所有结果显示出来，不去重也不排序。

3、索引的作用，和他的优缺点是什么？

        索引就一种特殊的查询表，数据库的搜索可以利用它加速对数据的检索。它很类似与现实生活中书的目录，不需要查询整本书内容就可以找到想要的数据。索引可以是唯一的，创建索引允许指定单个列或者是多个列。缺点是它减慢了数据录入的速度，同时也增加了数据库的尺寸大小。一般唯一、不为空、经常被查询的字段适合建索引。

4、MySQL哪些字段适合建立索引？

       数量超过300的表应该有索引；

        表的主键、外键必须有索引；

        经常与其他表进行连接的表，在连接字段上应该建立索引；

        经常出现在where语句中的字段，特别是大表的字段，应该建立索引；

        频繁进行数据操作的表，不要建立太多索引；

5、主键和外键的区别？

       主键是能确定一条记录的唯一标识，比如，一条记录包括身份证号、姓名、年龄。其中，身份证号是唯一能确定你这个人的，其他的都有可能重复，但身份证号不会，所以，身份证号是主键。

        外键用于与另一张表的关联。是能确定另一张表记录的字段，用于保持数据的一致性。比如，A表中的一个字段，是B表的主键，那他就可以是A表的外键。

6、order by 和 group by 的区别是什么？

       order by：order by的作用就是排序。asc：升序，desc：降序。order by后面跟多个字段时，排序按照就近原则；

        group by：聚合分组，值相等即为一组。聚合的意思就是聚合函数，例如sum()、avg()、count()、max()等；

注意：having只能用在group by之后，对分组后的结果进行筛选(即：要使用having，你必须先用group by分组)；如果还要使用where，那么where要放在group by 之前；where后的条件表达式里不允许使用聚合函数，但having可以。

MySQL通常通过 delete、truncate、drop 关键字进行删除；这三种都可以用来删除数据，但场景不同。

一、从执行速度上来说

drop>truncate>delete

二、从原理上讲

1、delete

        delete属于数据库DML操作语言，只删除数据不删除表的结构；

        在InnoDB中，delete其实不会真的把数据删除，mysql实际上只是给删除的数据打上了一个不可视的标签，标记为已删除，因此delete删除数据时，表文件在磁盘上所占空间大小不会变，存储空间不会释放。虽然未释放磁盘空间，但下次插入数据时仍然可以重用这一部分（重用  -->  覆盖）；

        delete执行时，会先将删除数据缓存到rollback segement中，事务提交后生效；

        delete from table_name删除表的全部数据，对于MYISAM会释放磁盘空间，InnoDB不会释放磁盘空间；

        对于delete from table_name where ...带条件的删除，MYISAM和InnoDB都不会释放磁盘空间；

        delete操作后使用optimize table table_name（空间优化）会立刻释放磁盘空间，无论是MYISAM还是InnoDB；

        delete操作是一行一行执行删除的，且同时将该行的操作日志记录在表空间中方便回滚和重做操作，生成的大量日志会占用磁盘空间。

2、truncate

       truncate属于数据库DDL定义语言，不走事务；

        truncate from table table_name立刻释放磁盘空间，无论是MYISAM还是InnoDB。truncate table类似于drop table然后create；

        truncate能够快速清空一个表，并且重置auto_increme（自增索引）的值；

3、drop

       drop属于数据库DDL定义语言，同truncate；

        drop table table_name立刻释放磁盘空间；

可以这么理解，一本书，delete是把目录撕了，truncate是把书的内容撕下来烧了，drop是把书烧了！！！

聚簇索引和辅助索引

聚簇索引：数据是存放在叶子节点上。

辅助索引：叶子节点上是不存放真实数据的，而是存放聚簇索引的索引值。

        聚簇索引和辅助索引都是B+树的结构，区别就是叶子节点上是否存放真实的数据。那么为什么有这个区分呢。其实也很好理解，我们都知道，Mysql中的每一个索引都是一颗B+树来存储的，如果我每一颗B+树的叶子节点上面都存储数据的话，这个空间的要求是不是很大呢？当然，也可以所有的索引都不存储真实的数据，都存储指向真实数据的索引，这是MyISAM存储引擎的做法。

        在Innodb存储引擎中，DBA一般都会要求我们建立一个自增长的，为整数型的值为主键索引。如果没有唯一索引的话，Mysql会自己帮我们维护一个索引，就是会帮我们这张表建立一个隐藏列，用作聚簇索引的建立。而每一张表只有这一个聚簇索引，并且存储真实的数据。

        对比的来看，MyISAM存储引擎使用的都是辅助索引，即没有一棵B+树上存储了真实数据，都是指向真实数据的索引，这也是为什么当Mysql的表使用了MyISAM存储引擎的时候，会产生三个文件。一个表结构、一个就是真实数据、一个索引文件。而使用Innodb存储引擎的表，只有两个，一个表结构，另外一个包含了索引和真实数据。

MYISAM和InnoDB的区别

         1、InnoDB支持事务，MyISAM不支持，对于InnoDB每一条SQL语言都默认封装成事务，自动提交，这样会影响速度，所以最好把多条SQL语言放在begin和commit之间，组成一个事务；

        2、InnoDB支持外键，而MyISAM不支持。对一个包含外键的InnoDB表转为MYISAM会失败；

         3、InnoDB是聚集索引，使用B+Tree作为索引结构，数据文件是和（主键）索引绑在一起的（表数据文件本身就是按B+Tree组织的一个索引结构），必须要有主键，通过主键索引效率很高。但是辅助索引需要两次查询，先查询到主键，然后再通过主键查询到数据。因此，主键不应该过大，因为主键太大，其他索引也都会很大。MyISAM是非聚集索引，也是使用B+Tree作为索引结构，索引和数据文件是分离的，索引保存的是数据文件的指针。主键索引和辅助索引是独立的。

        也就是说：InnoDB的B+树主键索引的叶子节点就是数据文件，辅助索引的叶子节点是主键的值；而MyISAM的B+树主键索引和辅助索引的叶子节点都是数据文件的地址指针。

        4、InnoDB不保存表的具体行数，执行select count(*) from table时需要全表扫描。而MyISAM用一个变量保存了整个表的行数，执行上述语句时只需要读出该变量即可，速度很快。

        5、InnoDB表必须有唯一索引（如主键）（用户没有指定的话会自己找/生产一个隐藏列Row_id来充当默认主键），而Myisam可以没有。

        6、Innodb存储文件有frm、ibd，而Myisam是frm、MYD、MYI

        Innodb：frm是表定义文件，ibd是数据文件

        Myisam：frm是表定义文件，myd是数据文件，myi是索引文件