利用Python进行数据分析_读书笔记（不定期更新）

读书笔记_利用Python进行数据分析

第二章 Python语言基础

2.1 Python解释器

Python是一种解释型语言，Python解释器每次执行一条程序

2.2 IPython基础

2.2.1 jupyter notebook及快捷键

通过运行 ipython 或者 jupyter notebook 运行

快捷键记录

命令	操作
快速运行	shift-enter
运行本单元格	ctrl-enter
快速补全	Tab
单元转入代码状态	Y
单元格转入markdown状态	M
上方插入单元	A
下方插入单元	B
剪切选中的单元	X
复制选中的单元	C
粘贴选中的单元	V
连续两次D，删除选中的单元	DD

2.2.2 内省及其他技能

#通过?显示对象的关键信息
a=1
a?
Type:        int
String form: 1
Docstring:  
int([x]) -> integer
int(x, base=10) -> integer

#通过??显示源代码
def sum(a,b):
    return a + b
sum??

#通过%run运行代码
%run ipython_script_test.py

#通过%load运行代码
%load ipython_script_test.py

#代码中断
ctrl-c

#执行剪贴板中的程序
%paste
%cpaste

2.2.3 关于魔术命令

2.3 Python 语言基础

2.3.1 语言语义

1、Python通过缩进来组织代码（一般采用4个空格）

2、Python一切皆为对象

3、Python通过#进行注释

4、pyhton传递一个变量时，实际上指向的是同一个对象

a = [1,2,3]
b = a
a.append(4)
print(b)
#输出[1,2,3,4]

5、二元操作符

a//b #a整除b
a**b #a的b次方
a is b #a和b是同一个Python对象则未true
a is not b #a和不是同一个Python对象则未true

6、可变对象与不可变对象

可变对象：列表、字典、NumPy数组

不可变对象:字符串、元组

2.3.2 标量类型

None  #null值，存在一天个实例
str	#字符串
bytes #原生ASCII
float #双精度64位浮点型
bool 
int 

2.3.2.1日期和时间

from datetime import datetime,date,time
dt = datetime(2011,10,29,20,30,21)
dt.day#输出今天日期
dt.minute#输出分钟
dt.date
dt.time

#strftime方法将datetime转化为字符串
dt.strftime('%Y-%m-%d')
#strptime把字符串转化为datetiem对象
datetime.strptime('20091031',%Y%m%d)

datetime格式化详细说明

%Y #四位年份
%y #两位年份
%m #两位的月份
%d #两位的天数
%H #24小时
%I #12小时
%M #两位的分钟
%S #秒值
%w #星期值
%U #一年中第几个星期的值，星期天是每周第一天
%W #一年中第几个星期的值，星期一是每周第一天
%F #'2020-01-01'
%d #'04/18/12'

2.3.3 控制流

2.3.3.1 if else-if 和else

if x < 0 :
    print(1)

if x < 0 ：
	print(1)
elif x == 0 :
    print(2)
else :
    print(3)

2.3.3.2 for循环

#for循环用于遍历一个集合或一个迭代器
for value in collection：
    #用值做什么

#continue跳过循环
for value in collection:
    if value == 0:
        continue
#break跳出循环
for value in collection:
    if value == 0:
        break

2.3.3.3 while循环

#当不符合条件的时候 或者 break的时候，结束循环
x = 256
total = 0
while x > 0:
    if total > 500:
        break
    total += x
    x = x // 2

2.3.3.4 pass

#pass就是什么都不做的意思
if x < 0 :
    print(1)
else :
    pass

2.3.3.5 range

range(10)
#输出 range(0,10)
list(range(10))
#输出 [0,1,2````,9]
range(0,20,2)
#开始，结尾，步进

第三章 内建数据结构、函数及文件

3.1数据结构和序列

3.1.1元组(固定长度，不可变对象)

创建元组

tup = 4,5,6

tup = (4,5,6),(7,8)

tuple([4,0,2])

3.1.1.1 元组的拆包

1、遍历元组

2、返回多个值

#普通拆包
tup = (4,5,6)
a,b,c = tup

#遍历元组
seq = [(1,2,3),(4,5,6),(7,8,9)]
for a,b,c in seq:
    print('a{0},b={1},c={2}').format(a,b,c)
    
#元素的采集
values = 1,2,3,4,5
a,b,*_ = values
##一般使用 _ 来表示不想要的变量

3.1.1.2 元组的方法

#使用count来计量某个数值再元组中出现的次数
a = (1,2,2,2,2,2,3,3,4)
a.count(2)

3.1.2 列表

列表长度可变，内容可修改,使用list或者[]来定义

a_list= [2,3,7,None]

3.1.2.1 增加和移除元素

#使用append方法将元素添加到列表的尾部
b_list.append('dwarf')
#使用insert方法将元素添加到指定位置
b_list.insert(1,'red')
```
insert的计算代价更高,可以考虑使用collections.deque
```

#使用pop移除指定元素并返回
b_list.pop(2)
#使用remove方法移除,会定位到第一个符合要求的值并去除他
b_list.remove('foo')
```
如果不考虑性能,使用append和remove
```

#使用in关键字可以检查一个值是否在列表中
'dwarf' in b_list

3.1.2.2 连接和联合表

使用 + 连接

[4,None,'foo'] + [7,8,(2,3)]

使用extend连接(extend效率高于 +)

x = [4,None,'foo']
x.extend[7,8,(2,3)]

3.1.2.3 排序

a = [7,8,8,8,3]
a.sort()

#可以通过 key=len 来进行字符串的排序
b.sort(key = len)

3.1.2.4 二分搜索何以排序列表的维护

import bisect
```
bisect模块不会先判断是否排序，若列表本身未排序，会导致出现错误的结果
```
c = [1,2,2,2,3,4,7]
bisect.bisect(c,2) #输出下一个2应该出现的位置
bisect.insort(c,6) #在7前面插入6

3.1.2.5 切片

#选出第 2 ~5 的列表
seq = [7,2,3,7,5,6,0,1]
seq[1:5]
#out:[2,3,7,5]

#使用切片进行赋值
seq[3:4] = [6,3]
#out [7,2,3,6,3,5,6,0,1]

#如果省略起始位置，则默认从第一个出发
#负索引可以从序列的尾部进行索引
seq[-4:]
#[5, 6, 0, 1]

#使用 :: 设置步长
seq[::2]

#巧用::-1进行倒叙
seq[::-1]

3.1.3 内建序列函数

3.1.3.1 enumerate

使用enumerate构建一个字典

some_list = ['foo','bar','baz']
mapping = {}
for i,v in enumerate(some_list):
    mapping[v] = i
#out: {'foo': 0, 'bar': 1, 'baz': 2}

3.1.3.2 sorted

根据任意序列中的元素新建一个已排序的列表

sorted = ([7,1,2,6,0,3,2])
#[0, 1, 2, 2, 3, 6, 7]

list = sorted('hey man')
print(list)
#[' ', 'a', 'e', 'h', 'm', 'n', 'y']

3.1.3.3 zip

zip将列表、元组或其他序列的元素匹配，新建一个元组构成的列表

seq1 = ['foo','bar','baz']
seq2 = ['1','2','3']
zipped = zip(seq1,seq2)
#out:[('foo', '1'), ('bar', '2'), ('baz', '3')]

3.1.3.4 reversed

将元素倒叙排序

seq1 = ['foo','bar','baz']
zipped = list(reversed(seq1))
print(zipped)

#out:['baz', 'bar', 'foo']

3.1.4 字典

字典,更常用的名字是哈希表或者是关联数组

empty_dict = {}
d1 = {'a':'1','b':'2'}
d1[7] = 'an integer'
#out:{'a': '1', 'b': '2', 7: 'an integer'}

使用in来查看是否有一个键

'b' in d1
#out : TRUE

使用del 和 pop方法删除值,pop方法会在删除的同时返回被删的值

del d1['a']

ret = d1.pop['b']

使用update方法将两个字典合并,若传给相同的键则覆盖

d1 = {'a':'1','b':'2'}
d1.update({'k':1})

3.1.5 集合

集合就像没有值的字典，无序且唯一的容器

#创建集合的两种方式
set([1,2,3,4])
{1,2,3,44,44}

#将两个集合合并
a = {1,2,3,4,5}
b = {1,2,3,4,4,5,7,8,8}
a.union(b)
a|b
#使用intersection获取交集
a.instersection(b)

3.1.6 列表、集合和字典的推导式

3.2 函数

使用 def function(): 来构造一个函数

3.2.2 返回多个值

def f():
	a = 5
    b = 6
    c = 7
    return a,b,c
a,b,c = f()

def f():
	a = 5
    b = 6
    c = 7
    return {'a':a,'b':b,'c':c}

3.2.3 函数是对象

import re
#构造函数，去除指定字符串
def remove_punctuation(value):
    return re.sub('[!#?]','',value)
#第一个函数去空格，第二个函数去除指定内容，第三个函数标题化
clean_ops = [str.strip,remove_punctuation,str.title]

def clean_string(strings,ops):
    result = []
    for value in strings:
        for function in ops:
            value = function(value)
        result.append(value)
    return result

states = ['sdf','#####dfsdfsd']
print(clean_string(states,clean_ops))

3.2.4 匿名(lambda)函数

使用lambda声明一个匿名函数
def short_function(x):
	return x*2
#等同于
fun = lambda x:x*2

x = 2
fun = lambda x:x*2
print(fun(x))

3.2.7 错误和异常处理

#定义一个函数，返回float结果，若错误，则返回x的值
def fun(x):
    try:
        return float(x)
    except:
    	return '这是错误的' + x

x = 'sdfsd'
print(fun(x))

3.3 文件与操作系统

使用sys.getdefaultencoding()检查文件的默认编码

r 只读模式

w 只写模式，创建新文件（清楚路径下的同盟文件中的数据）

x 只写模式，若存在同名文件，则失效

a 添加已经存在的文件（不存在就创建）

r+ 读写模式

b 二进制文件的模式

t 文件的文本格式