python基础

——《利用Python进行数据分析》附录a：Python语言精要读书笔记

语言语义

1、缩进，而不是大括号，冒号表示一段缩进代码的开始，其后的所有代码都必须缩进相同的量，直到代码块结束为止。
2、分号只能用在一行里不同语句之间
3、万物皆对象
4、#后面的都为注释
5、函数或方法调用
函数：result=f(x,y,z)或g()
对象的方法调用：obj.some_method(x,y,z)
参数可以接受位置参数，也可以接受关键字参数：result=f(a,b,c,d=5,e=’foo’)
6、变量和按引用传递
对变量赋值时，是创建等号右侧对象的一个引用
a = [1,2,3]
b = a
b不会是副本，而是跟a同样指向一个对象
当将对象以参数形式传入函数时，传递的是引用
7、动态引用，强类型
a = 5
type(a)
a = ‘foo’
type(a)
变量的类型信息保存在自己内部。类型之间不会轻易隐式转换（比如字符与数字），隐式转换只在很明显的情况下发生（比如float与int相除）。可以用isinstance函数检查对象是否是某个类型的实例：
a=5
isinstance(a,int)
isinstance(a,(int,float)) #检查a是否是元组（int,float）中的一个
8、鸭子类型
首先Python不支持多态，也不用支持多态，python是一种多态语言，崇尚鸭子类型。以下是维基百科中对鸭子类型得论述：
在程序设计中，鸭子类型（英语：duck typing）是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试，“鸭子测试”可以这样表述：
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为鸭的对象，并调用它的走和叫方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的走和叫方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的走和叫方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。
鸭子类型通常得益于不测试方法和函数中参数的类型，而是依赖文档、清晰的代码和测试来确保正确使用。从静态类型语言转向动态类型语言的用户通常试图添加一些静态的（在运行之前的）类型检查，从而影响了鸭子类型的益处和可伸缩性，并约束了语言的动态特性。

在参数引用时，经常出现下面参数说明：

就是说，像array类型的都可以

9、import从其他py文件的模块中引入变量和函数
import pandas as pd
from pandas import DataFrame,Series

10、二元运算符

11、比较运算符，判断两个变量是否指向同一个对象：is，isnot
12、python所有计算立即执行
13、可变与不可变变量：大部分对象是可变的（可以在原内存块中修改变量内容，比如List，nparray等）；有些是不可变的（Tuple、string等只能通过产生副本来修改变量内容）

标量类型

15、数值类型：int和float。
float保存为一个双精度（64位）值，可以用科学计数法表示：f=6.78e-5
复数的虚部是用j表示的。
16、字符串：
可以单引号也可双引号，多行可用三重引号（”’ 或”“”）包围。
字符串是不可变的，要修改就只能创建新的。
可以用下标访问字符串中的单个字符，可以用.replace()替换生成新字符串
可以用str函数转换为字符串：a=5.6;s=str(a)
可以当做序列进行处理：s=’python’; s[:3]
反斜杠（\）是转义字符。如果字符串中有多个需要转义的字符，可在前面加r：
s=r’this\has\no\special\characters’
将两个字符串+起来会产生一个新字符串
字符串格式化： label=u’%s，AUC=%.3f’ % (name, auc)
17、类型转换
str、bool、int、float等类型可用作将值转换成该类型的函数
18、空值类型None：a=None;a is None
None不是一个保留关键字，只是NoneType的一个实例
19、日期和时间
from datatime import datetime,date,time
dt = datetime(2011,10,29,20,30,21)
dt.day
dt.minute
dt.date()
dt.time()
dt.strftime(‘%m/%d/%Y %H:%M’)
datetime.strptime(‘20091031’,’%Y%m%d’) #将字符串转换为datetime
dt.replace(minute=0,second=0) #在对时间序列数据进行聚合或分组时可能需要
dt2 = datetime(2011,11,15,22,30)
delta = dt2-dt #两个datetime对象的差会产生一个datetime.timedelta类型

控制流

20、if、elif和else

if x<0:    print 'Tt's negative'elif x==0:    print 'Equal to zero'elif 0<x<5:    print 'Positive but smaller than 5'else:    print 'Positive and larger than or equal to 5'

组合条件用and或or连接，各条件按从左到右顺序求值，短路型
21、for循环
for value in collection:
print value #对value做相应处理
continue关键字使for循环提前进入下一次迭代
break关键字使for循环完全退出
另可以如下：
for a,b,c in iterator:
#对a、b、c分别处理
22、while循环

x=256total = 0while x > 0:    if total > 500        break;    total += x    x = x //2

23、pass：空操作，可用于占位符
24、异常处理

def attempt_float(x)    try:        return float(x)    except(TypeError, ValueError):        return x    finally:        pass

当将x转换为float时发生异常，则会返回x本身
25、range和xrange
range函数用于产生一组间隔平均的整数：range(10);range(0,20,2)。不包括末端值
在Python2中，对于非常长的范围，建议使用xrange
26、三元表达式
value = true-expr if condition else false-expr

数据结构和序列

元组
27、元组（tuple）：一种一维的、定长的、不可变的python对象序列
tup=4,5,6
nested_tup = (4,5,6),(7,8) #由元组组成的元组
tuple([4,0,2]) #可以将任何序列或迭代器转换为元组
tup = tuple(‘string’) #可以用下标[i]进行访问
tup = tuple([‘foo’,[1,2],True])
tup[2] = False #出错。tuple创建完后不能被修改
tup[1].append(3) #但是可以添加（好晕！）
(4,None,’foo’) + (6,0) + (‘bar’,) #可用+ 运算符连接元组产生更长的元组。元组中如果只有一个元素，需在末尾加’,’以明确类型
(‘foo’,’bar’)*4 #扩展4个该元组的副本为一个元组
28、元组拆包，常用于对由元组或列表组成的序列进行迭代，或从函数中返回多个值
tup = (4,5,6)
a,b,c = tup
tup = 4,5,(6,7)
a,b,(c,d) = tup
b,a = a,b #交换变量名
29、元组方法：count用于计算指定值在元组中出现的次数
列表(list)
30、跟元组相比，列表是变长的，且内容是可以修改的。
a_list = [2,3,7,None]
tup = (‘foo’,’bar’,’baz’)
b_list = list(tup)
b_list[1] = ‘peekaboo’
31、添加和移除元素
b_list.append(‘dwarf’) #在列表尾添加元素
b_list.insert(1,’red’) #在列表指定位置插入元素
b_list.pop(2) #insert的逆运算，移除并返回指定位置的元素
b_list.remove(‘foo’) #找到第一个符合要求的值删除
‘dwarf’ in b_list #元素是否在列表中
32、合并列表
[4,None,’foo’] + [7,8,(2,3)]
x = [4,None,’foo’]
x.extend([7,8,(2,3)]) #extend要比+节约资源
33、排序
a = [7,2,5,1,3]
a.sort()
b = [‘saw’,’small’,’He’,’foxes’,’six’]
b.sort(key=len) #用key参数指定用于产生排序的值的函数
34、二分搜索及维护有序列表
import bisect #不检查原列表是否有序
c = [1,2,2,2,3,4,7]
bisect.bisect(c,2) #为保持列表有序性找出新元素应被插入的位置
bisect.insort(c,6) #保持列表有序性插入新元素
35、切片：可以选取序列类型（数组、元组、Numpy数组、列表等）的子集
seq = [7,2,3,7,5,6,0,1]
seq[1:5] #包括start索引的元素，不包括stop索引的元素
seq[3:4] = [6,3] #批量赋值
seq[-4:] #从末尾开始切片
seq[-6:-2]
seq[::2] #第二个冒号后的数字表示步长
seq[::-1] #可以实现反序
内置的序列函数
36、enumerate返回序列的(i,value)元组
for i,value in enumerate(collection):
#处理i和value
some_list = [‘foo’,’bar’,’baz’]
mapping = dict((v,i) for I,v in enumerate(some_list)) #将序列值映射到其所在位置的字典
37、sorted：可以将任何序列返回为一个有序列表
38、zip：将多个序列（列表、元组）中的元素“配对”，产生一个新的元组列表
seq1= [‘foo’,’bar’,’baz’]
seq2=[‘one’,’two’,’three’]
zip(seq1,seq2)
seq3 = [False,True]
zip(seq1,seq2,seq3) #zip接受任意数量的序列，得到的元组数量由最短的序列决定
for i,(a,b) in enumerate(zip(seq1,seq2)):
print(‘%d:%s,%s’ %(i,a,b))
pitchers = [(‘Nolan’,’Ryan’),(‘Roger’,’Clements’),(‘Schilling’,’Curt’)] #已压缩的序列
first_names,last_names = zip(*pitchers) #解压缩成两个元组
39、reversed：按逆序迭代序列中的元素
list(reversed(range(10)))
字典
就是哈希映射，是一种大小可变的键值对集
empty_dict = {}
d1 = {‘a’:’some value’,’b’:[1,2,3,4]}
d1[7] = ‘an integer’ #访问（插入、设置）元素的语法与列表和元组是一样的
‘b’ in d1 #判断字典中是否有某个键
del d1[7] #删除元素
ret = d1.pop(‘a’) #删除指定值并返回
d1.keys() #取出所有键列表
d1.values() #取出所有值列表
d1.update({‘b’:’foo’,’c’:12}) #合并字典
40、从序列类型创建字典
mapping = dict(zip(rang(5),reversed(range(5))))
41、默认值
value = some_dict.get(key,default_value) #如果key不存在，默认返回None
words = [‘apple’,’bat’,’bar’,’atom’,’book’]
by_letter = {}
for word in words:
letter = word[0]
by_letter.setdefault(letter,[]).append(word) #将列表转成以首字母为键的字典
from collections import defaultdict
by_letter = defaultdict(list)
for word in words
by_letter[word[0]].append(word)
42、字典键的有效类型
键必须是不可变对象，如标量类型（整数、浮点数、字符串）或元组（元组中的所有对象也必须是不可变的），即可哈希的。
hash(‘string’)
hash((1,2,(2,3))
集合
是由唯一元素组成的无序集
set([2,3,2,1,3,2])
a = {2,3,2,3}
集合支持各种数学集合运算，如并、交、差及对称差（异或）等
a = {1,2,3,4,5}
b={3,4,5,6,7,8}
a|b
a&b
a-b
a^b
a.issubset(b) #a是否是b的子集
a.issupperset(b) #a是否是b的超集

列表、集合以及字典的推导式
列表推导式基本形式：[expr for val in collection if condition]
例：
strings = [‘a’,’as’,’bat’,’car’,’dove’,’python’]
[x.upper() for x in strings if len(x) > 2]
字典推导式基本形式：dict_comp = {key-expr:value-expr for value in collection if condition}
例：loc_mappint = {val:index for index,val in enumerate(strings)}
集合推导式基本形式：set_comp = {expr for value in collection if condition}

44、嵌套列表推导式：就是多个for循环嵌套的简化写法
some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
flattend = [x for tup in some_tuples for x in tup] #将元组列表展平为元素列表

函数

函数越多越好！！！
def my_function(x,y,z=1.5):
if z>1:
return z*(x+y)
else:
return z/(x+y)
可以同时有多条return语句。如果没有return语句，返回None
可以有位置参数（如上面的x,y），也可以有关键字参数（如上面的z），关键字参数通常用于指定默认值或可选参数。关键字参数必须位于位置参数之后。关键字参数无顺序。
命名空间、作用域及局部函数
全局和局部命名空间（作用域）
返回多个值

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

函数亦为对象
可以将函数组成列表，作为参数传递给函数，然后依次执行列表中的函数进行处理
匿名（lambda）函数
equiv_anon = lambda x:x*2
很多数据转换函数都是以函数作为参数的，直接传入lambda函数比编写完整函数再传参要简洁

def apply_to_list(some_list,f)    return [f(x) for x in some_list]ints = [4,0,1,5,6]apply_to_list(ints,lambda x:x*2)

闭包：返回函数的函数
闭包就是由其他函数动态生成并返回的函数，其关键性质是，被返回的函数可以访问其创建者的局部命名空间中的变量。

扩展调用语法和*args、**kwargs
位置参数打包成元组args
关键字参数打包成字典kwargs