Python知识点整理

时间 2019-11-29

标签 python 知识整理栏目 Python 繁體版

原文原文链接

Python

1、python概述：

一、面向对象、解释型计算机程序设计语言，目前最流行的10种编程语言之一html

二、荷兰 Guido Van Rossum 1989发明。第一个公开发行版：1991 年python

三、语言特色：正则表达式

—编程范式：支持命令式编程、函数式编程、面向切面编程、泛型编程、面向对象程序设计算法

—与Ruby、Perl、TCL等动态语言同样，具有垃圾回收功能，自动管理内存使用shell

—Python虚拟机自己和Python程序能够在几乎全部操做系统（Windows、Linux、Unix、MacOS）上运行。数据库

—可使用py2exe、PyPy、PyInstaller工具，将Python源码转换成能够脱离Python解释器执行的程序编程

—做为脚本语言，处理系统管理任务和Web编程。api

2、实验部分：

一、python安装：数组

—方法一：官方Python（https://www.python.org/）+第三方库安全

—方法二：第三方集成版—Anaconda（https://www.continuum.io/downloads）

二、环境 = python解释器（负责Python程序的解释执行）+一个命令行交互环境（python shell）+经过网页进行交互式编程的环境（jupyter notebook）+集成开发环境

3、python语法：

一、变量：程序执行过程当中能够改变的量。任意数据类型，无需事先定义数据类型，赋值时肯定数据类型。变量名：英文/下划线开头，后续字符为英文/数字/下划线

二、常量：程序执行过程当中不能改变的量。包括整数（ex:33）、小数、字符串

三、注释：#开头到一行末尾。Python解释器忽略注释，不执行。

四、数据类型

4.1 布尔值bool：True/False。能够用True/False表示布尔值，也能够经过关系运算/逻辑运算计算出来

4.2 整数int：表示精度不限的整数

4.3 浮点数float：标准写法（3.23）/科学计数法（3.23e3）

4.4 复数complex：包括实部和虚部，虚部带一个字符j（ex: c1 = 3+2.7j）

4.5 字符串str：单引号/双引号括起来，三个双引号首尾括起来的字符串能够换行。字符串包括换行和空格。下标从0开始

ex: s3 = """This

    is

    apple.””"

    str=‘Hello’

    print(str[2:])#打印2号下标字符，以及后续字符

    print(str[2:5])#打印二、3、4号下标字符

    print(str*2)#打印str两遍

    print(str+”Test”)#HelloTest

4.6 列表list：[]括起元素，中间逗号隔开，元素能够同类型也能够不一样类型。

ex: list = [‘abcd’,789]

print(list*2)#[‘abcd’,789,’abcd’,789]

—追加元素x：append（x）

—x插入指定位置i：insert（i，x）

—删除末尾元素：pop（）

—删除指定位置i元素：pop（i）

—替换元素：直接赋值给索引值。

使用列表对矩阵进行转置

#way1

a=[[3,4,5,6],[13,14,15,16],[23,24,25,26]]

b=[]

i=0

for row in range(len(a[0])):

b.append([])

for col in range(len(a)):

b[row].append(a[col][row])

print(a)

print(b)

#way2

import pandas as pd

df=pd.DataFrame(b)

print(df.transpose())

4.7 元组tuple：()括起元素。一旦初始化不能修改（read-only）。代码更加安全。

4.8 字典dict：Hash Table。键值对key-value pairs。key和value能够是整数、小数、字符串、布尔值。

—查找元素：dict[key] / dict.get(key)

—删除key：pop(key)

—判断key是否在dict中：key in dict

4.9 集合与冻结集合set/frozenset：概念同数学，元素无序且惟一。可作交&并|集操做。用{}括起，元素用逗号隔开。

—添加元素：add（key）

—删除元素：remove（key）

—判断元素是否在set中：key in set

frozenset：一旦建立不可更改

五、运算符、优先级、表达式：

5.1 运算符：包括算数运算符、关系运算符、逻辑运算符、集合运算符、对象运算符

5.2 优先级：书

5.3 表达式：利用运算符，把兼容的常量、变量拼接起来的式子。

ex: 关系运算表达式（a>b）、逻辑表达式（a>b and c>d）

六、顺序、分支、循环：

6.1 顺序程序结构：顺序执行

6.2 分支程序结构：条件判断（关系表达式、逻辑表达式）。if/ else/ elif。能够嵌套

6.3 循环程序结构：while/ do-while/ for

6.4 程序=数据结构+算法。

算法特色：肯定性（每步肯定）；有穷性（操做步骤有限）；0/多个输入；1/多个输出；有效性（肯定结果）

#冒泡排序python代码

list_name = ['A','B','C','D']

list_socre = [1,2,3,4]

count = len(list_name)

for i in range(0,count):

for j in range(i+1,count):

if(list_score[i]>list_score[j]):

list_score[i],list_score[j] = list_score[j],list_score[i]

list_name[i],list_name[j] = list_name[j],list_name[i]

for i in range(0,count):

print(list_name[i]+”:”+list_score[i])

七、函数：具备必定功能的一段代码，有利于程序模块化设计风格实现。能够递归调用。

二分搜索：

def bin_search(a,target):

　　low=0

　　high=len(a)-1

　　while(low<=high):

　　　　mid=(low+high)/2

　　　　mid_value=a[mid]

　　　　if(mid_value<target):

　　　　　　high=mid-1

　　　　elif(mid_value>target):

　　　　　　low=mid+1

　　　　else:

　　　　　　return mid

　　return -1

 

a = [1,2,3,4,5,6,7,8]

target = 6

ret_result = bin_search(a,target)

if(ret_result==-1):

　　print("Not Found")

else:

　　print(ret_result)

Hanoi 问题：

def hanoi(n,x,y,z):

    if(n==1):

        print(n,':',x,'-->',z)

    else:

        hanoi(n-1,x,z,y)

    　　print(n,':',x,'-->',z)

　　　　hanoi(n-1,y,x,z)

n=int(input(u'please input the number of disks:')

print(n)

hanoi(n,'x','y','z')

Python内置函数（https://docs.python.org/2/library/functions.html）

八、类和对象、对象的构造、对象摧毁、封装和继承、重写：

class Employee(object):

　　def __init__(self,_name):

　　　　self.name = _name

　　def setName(self,_name):

　　　　self.name = _name

　　def setSex(self,_sex):

　　　　self.sex = _sex

　　def show(self)

　　　　print 'name:',self.name,',sex:',self.sex

emp1 = Employee('John')

emp1.setName('John')

emp1.setSex('Male')

emp1.show()

print Employee.__name__#显示类名

8.1 构造函数：负责对象的构造、初始化，名称是__init__，带一个self参数（指向要构造的对象，即对象的引用）和其余参数。

8.2 对象摧毁和垃圾回收：周期性执行，自动删除对象，释放内存

8.3 重写（Override）：对父类的方法从新定义的机制

九、异常处理：发生除零等异常，捕捉异常，打印提示信息，采起补救措施。

通常把可能引起异常的代码放在try: 语句块里，以后except: 语句块对错误状况做出处理

try:

    a = 10

    b = 0

    print(a/b)

except ZeroDibisionError:

    print('Error')

class Networkerror(RuntionError):

    def __init__(self,_args):

    　　self.args = _args

try:

　　host_not_found = True

　　if(host_not_found):

　　　　raise Networkerror("host not found")

　　　　#若是没有异常，继续执行后续代码

except Networkerror, e:

print(e.args)

十、正则表达式：特殊的字符序列。用于匹配/查找其余字符串里面的子串。

import re

#正则表达式匹配电话号码

pattern_phone = re.compile('^(\d{3})-(\d{3})-(\d{4})$')

 

phone = '800-555-1212'

#phone = '800-555-1212-1216'

phonematch = pattern_phone.match(phone)

if(phonematch):

　　print(phonematch.group())

else:

　　print('error')

4、Pandas：

一、介绍：开源（BSD-licensed）python库。基于NumPy库开发，和其余第三方库无缝集成，支持时间序列分析。

能够处理：

—表格数据：表格各列可有不一样类型

—时间序列数据：有序/无序，时间序列数据无需固定频率数据

—矩阵：支持异构数据类型矩阵，能够设定行列标签

提供基本模块（Fundamental Building Block），即基本数据结构：

—Series：一维数组，相似Numpy中array和list。区别是list中元素能够是不一样数据类型，array和series中只容许存储相同数据类型的元素。

—Time Series：以时间为索引的series

—DataFrame：二维表格型数据结构。series的容器

—Panel：三维数组。DataFrame的容器

二、Pandas的功能：

(1) 处理数据的缺失值(Missing Data)，包括浮点数和非浮点数的缺失值。
(2) 动态扩展性，用户能够插入或者删除DataFrame数据结构的列。
(3)数据对齐(Data Alignment)：用户能够把数据对象对齐到标签(Label)，或者由Series、DataFrame等数据结构自行对齐。
(3) 分组汇集功能(Group by and Aggregation)。
(4) 把其它NumPy等第三方库的数据结构转换成DataFrame的功能。
(5) 数据转换(Transformation)。
(6) 数据集的合并(Merging)和链接(Joining)。
(7) 从CSV文件、Excel文件、数据库进行装载数据，把数据保存到HDF5格式的文件，以及从HDF5格式的文件装载数据。
(8) 坐标轴的层次标签(Hierarchical Labeling)。
(9) 数据透视表的旋转(Pivoting)、改变形状 (Reshaping)。
(10) 对大数据集进行基于标签的(Label based)数据切片(Slicing)、提取子集(Sub Setting)、创建和使用索引(Fancy Indexing)。
(11) Pandas还提供面向时间序列数据处理的一些特殊功能，好比时间频率转换、移动窗口上的统计值计算、移动窗口上的线性回归、序列的前移和后移(Shifting and Lagging)、生成数据范围好比生成时间范围(Date Range Generation)等。

三、建立Series：

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

s = pd.Series([1,3,5,np.nan,6,8])

print(s)

四、建立DataFrame：DataFrame的每一列的数据都相同，不一样的列数据类型不一样。每一行是一个记录，每一列是一个字段。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
dates = pd.date_range('20130101',periods=6)
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['A','B','C','D'])
df2 = pd.DataFrame({'A':1.,'B':pd.Timestamp('20130102'),'C':pd.Series(1,index=range(4),dtype='float32'),'D':np.array([3]*4,dtype='int32'),'E':pd.Categorical(['test','train','test','train']),'F':'foo'})
print(df)
print(df2)

print(df.head())#前5行,head和tail能够显示前N条和后N条记录，N默认为5
print(df.tail())#后5行
df.describe()#描述信息，包括计数、平均数、标准差、最大值、最小值、4分位差
print(df.index)#行标签
print(df.columns)#列标签
print(df.dtypes)#各列的数据类型
print(df.values)#DataFrame的值

print(df.T)#数据转置

df = df.sort_index(axis=1,ascending=False)
#按照第1个坐标轴进行排序，即沿着列方向对col name排序。按照第0个坐标轴排序，即对行标签排序
print(df)

df = df.sort_values(by='B')#对B列进行排序
print(df)

print(df['A'])#只打印列A
print(df[0:3])#提取下标为0、一、2的行，行下标有头无尾
print(df['20130102':'20130104'])#提取‘20130102’‘20130103’‘20130104’三行，行标签有头有尾
print(df.loc['20130102':'20130104',['A','B']])

print(df.iloc[3:5,0:2])#row=3&4,clo=0&1
print(df.iloc[[1,2,4],[0,2]])#row=1&2&4,col=0&2
print(df.iloc[1,1])#提取一个单元cell的值
print(df.iat[1,1])#提取一个单元cell的值,第一行第一列为0,0

print(df[df.A>0])#提取A>0的行
print(df2[df2['E'].isin(['train'])])#提取df2的E列值为‘train’的行

df.at[dates[0],'A'] = -99#经过行标签和列标签，设定单元格的值
print(df.head())

df.iat[0,1] = 3#经过行下标和列下标，设定单元格的值
print(df.head())

df.loc[:,'D'] = np.array([5]*len(df))#对整列进行设置
print(df)

df.iat[0,2] = np.nan
df = df.dropna(how = 'any')#把包含缺失值的行删除
print(df)

print(pd.isnull(df))
df.fillna(value=5)#用5替代缺失值

print(df.mean())#计算DataFrame每一个数据列的均值

df.apply(lambda x:x.max() - x.min())#计算极差=最大值-最小值

s = pd.Series(np.random.randint(0,7,size=10))#计算每一个值的频率
print(s.value_counts())
s.plot.hist(grid=True,rwidth=0.9,color='#607c8e')
plt.title('test histogram')
plt.xlabel('counts')
plt.ylabel('value')
plt.grid(axis='y',alpha=0.75)

s = pd.Series(['A','B','C','Aaba','Baca',np.nan,'CABA','dog','cat'])#向量化的处理方式（一次处理若干元素），如：将全部字符串都变成小写形式
s = s.str.lower()
print(s)

df = pd.DataFrame(np.random.randn(10,4))
print(df)
pieces = [df[:3], df[3:7], df[7:]]
print(pd.concat(pieces))#DataFrame的合并，将若干模式相同的DataFrame合并构成一个大的DataFrame。

left = pd.DataFrame({'key':['foo','bar'],'lval':[1,2]})
right = pd.DataFrame({'key':['foo','bar'],'rval':[4,5]})
print(left)
print(right)
pd.merge(left,right,on='key')#DataFrame的链接：将两个DataFrame各行合起来构成目标DataFrame的一行

df = pd.DataFrame(np.random.randn(8,4),columns=['A','B','C','D'])
print(df)
s = df.iloc[3]
print(s)
df = df.append(s,ignore_index=True)#添加新的数据行
print(df)

df = pd.DataFrame({'A':['foo','bar','foo','bar','foo','bar','foo','foo'],'B':['one','one','two','three','two','two','one','three'],'C':np.random.randn(8),'D':np.random.randn(8)})
#分组：根据每一个列的值把全部的行分红一组一组的。汇集：进行求和、最小值、最大值、平均值计算
print(df)
print(df.groupby('A').sum())
print(df.groupby(['A','B']).sum())

df = pd.DataFrame({'A':['one','one','two','three'] * 3,'B':['A','B','C'] * 4,'C':['foo','foo','foo','bar','bar','bar'] * 2,'D':np.random.randn(12),'E':np.random.randn(12)})
print(df)
pd.pivot_table(df,values='D',index=['A','B'],columns=['C'])#建立以A，B列为行变量，C列为列变量，D列为单元格值的数据透视表

import pandas as pd
import numpy as np
rng = pd.date_range('1/1/2012',periods=10,freq='S')#频率为秒
ts = pd.Series(np.random.randint(0,500,len(rng)),index=rng)
print(ts)

ts = ts.resample('5Min').sum()#pandas提供resample函数，对时间序列进行频率转化和从新采样。本例将秒级采样的数据，进行每5分钟从新采样，求和汇总
print(ts)

rng = pd.date_range('3/6/2012 00:00',periods=5,freq='D')#频率为天
ts = pd.Series(np.random.randn(len(rng)),index=rng)
print(ts)
#时间序列数据的时间戳，能够改变时区设定
ts_utc = ts.tz_localize('UTC')#世界标准时间
print(ts_utc)
ts_new = ts_utc.tz_convert('US/Eastern')#转换成美国东部时间
print(ts_new)

#Converting between time span representations
#时间序列数据分为时期序列（period）和时点序列（point）
rng = pd.date_range('1/1/2012',periods=5,freq='M')#频率为月
ts = pd.Series(np.random.randn(len(rng)),index=rng)
print(ts)
ps = ts.to_period()#将时点序列转成时期序列
print(ps)
print(ps.to_timestamp())#再转成时点序列

#将频率为季度的时间序列数据，转换成季度最末尾一个月第一天上午9点的时点序列数据
prng = pd.period_range('1990Q1','2000Q4',freq='Q-NOV')
ts = pd.Series(np.random.randn(len(prng)),index=prng)
print(ts.head())
ts.index = (prng.asfreq('M','e')+1).asfreq('H','s')+9

#画图
#可视化Series：序列从2000年1月1日开始1000天的随机数序列
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
ts = pd.Series(np.random.randn(1000),index=pd.date_range('1/1/2000',periods=1000))
plt.figure();
ts = ts.cumsum()#cumulative sum
ts.plot()
plt.legend(loc='best')
plt.show()

#可视化DataFrame：行标签和Series行标签同样
df = pd.DataFrame(np.random.randn(1000,4),index=ts.index,columns=['A','B','C','D'])
df = df.cumsum()#cumulative sum
plt.figure();
df.plot();
plt.legend(loc='best')
plt.show()

#读写文件:将数据保存到文件/写到文件，支持csv，HDF5，excel
#Writing to & read from a csv file
df.to_csv('foo.csv')
df = pd.read_csv('foo.csv')
print(df.head())

#Writing to & read from HDF5 Store
df.to_hdf('foo.h5','df')
df = pd.read_hdf('foo.h5','df')
print(df.head)

#Writing to & read from an excel file
df.to_excel('foo.xlsx',sheet_name='Sheet1')
df = pd.read_excel('foo.xlsx','Sheet1',index_col=None,na_values=['NA'])
print(df.head())