python学习笔记(1)：python基础

python基础回顾

1.Ipython魔术命令　

%timeit //多次执行一条语句，并返回平均时间，%%time->多条语句，用于测试一条语句用了多少时间 %time //返回执行一条语句的时间 %rest //删除当前空间的全部变量 %run*.py //在IPython中执行python脚本 魔术命令+显示文档 如：%time?

2.变量不需要指定类型，但是仍然是"强类型语言"，只是不显示地表示

　　注意python中的变量是没有类型的，只有对象才有类型

　　如：x=5，变量x是没有类型的，而是指向整形对象5的一个变量

3.可变与不可变

　　大部分python对象是可变的(mutable)，e.g.列表、字典，自定义的类

　　字符串和元组是不可变的(immutable)

4.字符串

　　单引号('')，双引号("")均可

　　三引号()一般用于放置文档说明(docstring)或多行字符串

　　字符串格式化,(%)

　　类型转换str bool int float

5.时间和日期

　　datetime模块

　　strftime将datetime类型格式化为字符串

6.时间和日期

　　strptime将字符串解析为datetime类型

7.if  elif   else

8.for循环　　　　for item in collection

　　　　　　　　continue,break以及他们之间的区别：continue是跳出本次循环，break是跳出整个循环

9.while循环

10.没有++，--,可用+=1，-=1替代

11.pass用于占位：python不允许空代码块

12.异常处理：try    except

13.range和xrange

　　生成整数列表：

　　xrange比range效率高，但是xrange不会预先生成列表，而是一个迭代

14.关于python中的引用

　　变量赋值、传参是值传递

　　列表、字典的复制、传参是传引用

15.浅拷贝和深拷贝

　　浅拷贝的效果：[:]切片操作,copy()。只拷贝父对象，不拷贝对象内部的子对象

　　深拷贝：同时拷贝父对象以及子对象

 二、Python数据结构

-------------------------------------------------------------------

　　1.元组：

一维、定长、不可变的对象序列

　　　　创建元组

　　　　转换为元组,list->tuple，string->tuple

　　　　访问元组

　　　　合并元祖

　　拆包

　　　　函数同时返回多个值

　　　　元组列表迭代

　　常用方法  count

　　　　返回指定值的次数

创建元组：
    tuple = 1,2,3
    print tuple
    (1,2,3)
#嵌套元组
    tup2 =(1,2,3)(4,5)
    print tup2
    ((1,2,3),(4,5))
转换为元组：list->tuple,string->tuple
    
    l=[1,2,3]
    print tuple(l)
    (1,2,3)

    str="Hello ChinaHadoop"
    ('H','e','l','l','o',' ','C','h','i','n','a','H','a','d','o','o','o','p')
　　#访问元组
　　tup3= tuple(str)
　　print tup3[4]
　　o
　　#合并元组
　　tup1+tup2
　　((1,2,3),(1,2,3),(4,5))
　　#拆包
　　a,b,c= tup1
　　print b
　　2
　　#函数返回多个值
　　def return_mutiple():
　　　　t=(1,2,3)
　　　　return t
　　a,_,c = trturn_mutiple()　　//元组里面，如果不需要某个值的时候，可以用下划线代替，就是不需要这个值了
　　print c 
　　3
　　#元组的迭代
　　tuple_lst = [(1,2),(3,4),(5,6)]
　　for x, y  tuple_lst;
　　　　print x+ y 
  　3
    7
    11
　　#常用方法 count,返回指定值的次数
　　tup3= tuple(str)
　　print tup3[4]
　　o
 

　　　2.列表

　　变长，可变

　　创建列表　　[]

　　转换为列表,tuple->list

　　添加、移除元素，append，insert,pop,remove

　　合并列表+，extend

　　排序sort操作(注：就地排序，无需创建新的对象)　　结果不包含stop_idx的元素

#列表
  创建列表
lst_1=[1,2,3,'a','b',(4,5)]
print lst_1     //[1,2,3,'a','b',(4,5)]   

lst_2=range(1,9)
print lst_2    //[1,2,3,4,5,6,7,8,9]

#添加、移除元素
lst_4=range(10)
#末尾添加，在末尾添加元素
lst_4.append(11)
print lst_4        //[1,2,3,4,5,6,7,8,9，11]
#在指定位置插入元素
lst_4.insert(5,12)
print lst_4        //[1,2,3,4,5,6,7,8,9,11]

#删除指定位置的元素并返回
item=lst_4.pop(6)
print ite        //5
print lst_4    //[0,1,2,3,4,12,6,7,8,9,11]
#删除指定的值
lst_4.remove(12)
print lst_4    //[0,1,2,3,4,6,7,8,9,11]
#合并列表
lst_3=lst_1 + lst_2
print lst_3    //[1,2,3,'a','b',(4,5),1,2,3,4,5,6,7,8]

lst_1.extend(lst_2)
print lst_1    //[1,2,3,'a','b',(4,5),1,2,3,4,5,6,7,8]

#操作序列
import random
lst_5=range(10)
random.shuffle(lst_5)
print lst_5        //[7,8,5,3,2,0,4,6,9,1]
lst_5.sort()        //sort就地排序，没有创建新的对象
print lst_5        //[0,1,2,3,4,5,6,78,9]    

lst_6= ['welcome','to','Python','Data','Analysis','Course']    //按照字典顺序进行排序
print lst_6        //['Analysis','welcome','course','python','Data','to']

#按照字符串从长到短进行排序
lst_6.sort(key=len,reverse=True)
print lst_6    //['Analysis','Welcome','Course','Python','Date','to']

#切片操作
print lst_5    //[0,1,2,3,4,5,6,7,8,9]
print lst_5[1:5]    //[1,2,3,4]末尾的序列号是不包含在里面的，所以只是输出[1,2,3,4]
print lst_5[5:]    //[5,6,7,8,9],从5直接输出到末尾的

print lst_5[:5]    //[0,1,2,3,4]输出从第一个元素到最后一个元素，不包括最后一个元素

print lst_5[-5:]    //[5,6,7,8,9],从倒数第五个元素输出到最后一个元素
print lst_5[-5:-2]    //[5,6,7]从倒数第五个元素输出到倒数第二个元素，不包括倒数第二个元素
print lst_5[::2]    //[0,2,4,6,8],从0开始输出元素，步长为2
print lst_5[::-1]    //[9,8,7,6,5,4,3,2,1,0]倒序输出所有的元素

3.常用的序列函数

　　(1)enumerate，for循环时记录索引，逐个返回元组(i,item)

　　(2)sorted 返回新的有序列表，区别：list中的sort()是就地排序

　　(3)zip"压缩"将多个序列对应位置的元素组成元组

　　(4)zip(*元组列表)"解压缩",zip的逆操作

　　(5)reversed逆序迭代，可以配合list返回逆序列表

#enumerate
lst_6=['welcom','to','Python','Data','Analysis','Course'] //拆包操作，拿到i和值拿到
for i , item in enumerate(lst_6):
    print '%i-%s' %(i,item)
0-welcom
1-to
2-python
3-Data
4-Analysis
5-Course

#sorted
import random
lst_5=random(10)
random.shuffle(lst_5)
print lst_5　　//[6,2,5,7,0,1,4,3,9,8],得到的是乱序的

#sorted
lst_5_sorted = sorted(lst_5)
print lst_5　　//[6,2,5,7,0,1,4,3,9,8]

print lst_5_sorted　　//[0,1,2,3,4,5,6,7,8,9]

#zip压缩
lst_6=['welcom','to','Python','Data','Analysis','Course']
lst_7=range(5)
lst_8=['a','b','c']
zip_lst=zip(lst_6,lst_8,lst_7)　　　　//[('welcome','a','0'),('to','b',1),('python','c',2)]
#zip解压缩
zip(*(zip_lst))
[('welcom','to','python'),('a','b','c'),(0,1,2)]

#reversed逆序的迭代
list(reserved(lst_6))
['Course','Analysis','Data','pyhon','to','welcome']

4.字典dict

{key1:value1,key2:value2}

通过多个列表创建字典

哪些可以做"键"

　　整数、浮点数、字符串或者元组

　　可"哈希"的对象,hash 

#创建字典
empty_dict={}
dict1={'a':1.2:'b','3':[1,2,3]}    //初始化一个字典
print empty_dict    {}
print dict1    {'a:1',2:'b','3':[1,2,3]}
#插入元素
dict1[4]=(4,5)
print dict1    //{'a':1,2:'b',4:(4,5),'3':[1,2,3]}

#删除元素
del dict[2]
print dict1    //{'a':1,4:(4,5),'3':[1,2,3]}
#通过pop来删除元素
a_value  = dict1.pop('a')
print a_value    //a_value
print dict1        //{4:(4,5),'3':[1,2,3]}

#获取键、值列表
print dict1.keys()    //[4,'3']
print dict.values()    //[(4,5),[1,2,3]]

#合并字典
dict2={4:"new1",5:'new5'}
dict.update(dict2)
print dict1        //{'3':[1,2,3],4:'new1',5:'news'}

#通过多个列表创建字典
#普通方法
dict_3={}
l1=range(10)
l2=list(reversed(range(10)))
for i1,i2 in zip(i1,i2):
    dict_3[i1]=i2
print dict_3    
//{0:9,1:8,2:7,3:6,4:5,5:4,6:3,7:2,8:1,9:0}

dict_4=dict(zip(l1,l2))
print dict_4
//{0:9,1:8,2:7,3:6,4:5,5:4,6:3,7:2,8:1,9:0}

hash(12)    //12
hash('test hash')    //-520327859
hash((1,2,3))        //
hash([1,2,3])

5.集合set

创建集合{}

集合操作，交并差异或

a=set(range(10))
print a            //set([0,1,2,3,4,5,6,7,8,9])

b=set(range(5,15))
print b            //set([5,6,7,8,9,10,11,12,13,14])
#集合的并运算
a | b
{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14}

#集合的交运算
a & b
{5,6,7,8,9}

#a -b
{0,1,2,3,4}

#异或运算
a ^ b
{0,1,2,3,4,10,11,12,13,14}

#判断是否为子集、父集
a.issubset(b)    //a是b的子集吗
False
#
a.issuperset(b)    //a是b的父集吗
False    

6.Python高级特性

-------------------------------------------------------

　　(1)集合推导式

　　　　　　列表推导式：使用一句表达式构造一个新列表，可包含过滤、转换等操作

[exp for item in collection if contion]

%%timeit
#普通方法
result1 = []
for i in range(10000):
　　if i%2==0:
　　　　result1.append(i) 

#
%%timeit
#列表推导式的方法
result2 = [i for i in range(10000) if i%2 ==0 ]

#将集合中的字符串全部都大写或者全部都小写
str_lst=["welcome","to","python","data","analyse","course"]
result3=[x.upper() for x in str_lst if len(x)>4]
print result3　　　　//["WELCOME","PYTHON","ANALYSIS","COURSE"]

　　　　　　字典推导式：　

{key_exp :value_exp for item in collectiob if condition}
dict1={key:value for key,value in enumerate(reversed(range(10)))}
print dict1
{0:9,1:8,2:7,3:6,4:5,5:4,6:3,7:2,8:1,9:0}

　　　　　　集合推导式：

{exp for item in collection if condition}
set1={i for i in range(10)}
print set1　　　　//set([0,1,2,3,4,5,6,7,8,9])

　　　　　　嵌套列表推导式：按照嵌套顺序理解

lists=[range(10),range(10,20)]
print lists        //[[0,1,2,3,4,5,6,7,8,9],[10,11,12,13,14,15,16,17,18,19]]

　　(3)函数列表

python中皆是对象  ,函数也是对象， [func1,func2]

匿名函数lambda

f = lambda x:x**2
f(2)    //4

str_lst=["Welcome","to","python","Data","Analysis","courses"]
str_lst.sort(key=lambda x:len(x))    #sort by length
print str_lst

str_lst.sort(key=lambda x:x[-1])    #sort by last letter
print str_lst    #按照每个单词最后一个字母进行排序

　　(4)生成器

def gen_test():
    for i in range(3):
            yield i 
gen =gen_test() #这个时候不执行生成器
type(gen)            #generator

for i in gen : #直到迭代的时候才执行

0   1   2

(5)函数式编程

　　函数本身可以赋值给变量，赋值后变量为函数

　　允许将函数本身作为参数传入另一个函数

　　允许返回一个函数

(6)map/reducce

　　map(func,lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表返回

　　reduce(func(x,y),lst),其中func必须有两个参数，每次计算的结果继续和序列的下一个元素做累积计算。

　　lst=[a1,a2,a3,..........,an]

函数式编程
#函数本身也可以赋值给变量
import math
math.sqrt(25)        //5.0

math.sqrt
<function math.sqrt>

fun=math.sqrt
fun
<function math.sqrt>
fun(10)            //3.1666666

将函数作为参数
def func_add(x,y,f):
    
#map
x_2_lst = [x**3 for x in range(10)]　　//对于0-9中的所有元素全部来求3次方
print x_2        
[0,1,4,9,16,25,36,49,64,81]

x_sqrt_lst=map(MATH.SQRT,X_2)　　　　　　//对于x_2列表，全部用来求开平方的操作
PRINT X_2_FLOAT_LST
[0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]

X_2-float_lst=map(float,x_2)　　　　　　//对于x_2列表，全部将其转换为float的数据类型
print x_2_float_lst
[0.0,1.0.4.0,9.0,16.0,25.0,36.0,49.0,64.0,81.0]　　

x_2_str_lst=map(str,x_2)
print x_2_str_lst
['0','1','4','9','16','25','36','49','64','81']　　

//对于x_2类型的数据，全部将其转换为字符串类型

　　reduce(func(x,y),lst)，其中func必须有两个参数。每次dunc计算的结果继续和序列的下一个元素做累积计算

lst = [a1,a2,a3,.............,an]
reduce(func(x,y),lst)
<===>func(func(func(a1,a2),a3),.................,an)

str_lst=map(str,range(5))    #将数组转换成字符串类型
print str_lst

def make_num(str1,str2)
    return int(str1)*10 + int(str2)    //将字符串转化为整数
result = reduce(make_num,str_lst)
print result

['0','1','2','3','4']
1234

(7)filter筛选器

　　筛选序列

　　filter(func,lst),将func作用于lst的每个元素，然后根据返回值是True或者是False来判断是保留还是丢弃

　　map,reduce和filter中的函数变量均可以是匿名函数

number_lst=range(-10,10)

def is_negative(x):
    return x<0
filtered_lst=filter(is_negative,number_lst)

print number_lst
[-10.....................9]

[-10........................-1]