python的学习

python的学习，我这次条理不会非常清晰，只是记录一些自己感兴趣的部分。

1. name =input() python等待你的输入。
2. 当语句以冒号：结尾时，缩进的语句视为代码块
3. print()会一次打印每个字符串，遇到逗号“，”会输出空格，因此，输出的字符串是这样拼起来的：
   print(’The quick brown fox’,’jumps over’,’the lazy doy’)

python基础

数据类型和变量

整数

浮点数

字符串

字符串是以单引号’或双引号”括起来的任意文本。
如果字符串内部既包含’有包含”怎么办？可以用转义字符\来标识，比如
‘i\’m \”OK\”!’ ==>I’m “OK”!
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，
Python还允许用r‘’表示‘’内部的字符串默认不转义。
Python允许用’’’…’’’的格式表示多行内容。

布尔值

True False 布尔值可以用and、or和not运算

if age>=18:      print(‘adult’)else:    print(‘teenager’)   

空值

None

变量

变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头

常量

所谓常量就是不能变的变量，在Python中，通常用全部大写的变量名表示常量
python中，有两种出发，一种除法/
/除法计算结构是浮点数，即使是两个整数恰好整除，结果也是浮点数：
还有一种除法//，称为地板除，两个整数的除法仍然是整数：

字符串和编码

对于耽搁字符的编码，Python提供了ord()的函数获取字符的整数表示，chr()函数把编码转换为对应的字符。
由于python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保持在磁盘上，就需要把str变为以字节为单位的bytes。
python对bytes类型的数据用带b前缀的单引号或双引号表示。
要计算str包含多少个字符，可以用len()函数
当操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题,应对始终坚持使用utf-8编码对str和bytes进行转换。

#!/usr/bin/python# -*- coding: utf-8 -*-

格式化

print ('hello, %s' % 'world')print ('Hi,%s,you have %d.' % ('Michael', 10000))

常见的占位符：

%d 整数 %f 浮点数 %s 字符串 %x 十六进制整数

使用list和tuple

当索引超出了范围是，python会报一个indexError错误，所以，要确保索引不要越界，记得最后一个元素的所有-1，还可以用-1做索引，直接获得最后一个元素。
可以获得倒数第二个、倒数第三个：
classmates[-2]，calssmate[-3].
list是一个可变的有序表，所以，可以往list中追加元素到末尾：

classmates.append(‘Adam’)  classmates.insert(1,’jack’)

要删除指定位置的元素，用pop(i)方法。删除最后一个直接用pop方法。
要把某个元素替换别的元素，可以直接赋值对应的索引位置。
list里面的元素的数据类型也可以不同。

tuple

tuple一旦初始化就不能修改。

classmates=(’tony’,’lvy’,’homer’)

现在，这个tuple不能变了，它也没有append(),insert()这样的方法。其它获取元素的方法和list是一样的，你可以正常使用classmate.
所以，只有1个元素的tuple定义时必须加一个逗号，，来消除歧义：

t=(1,)

添加判断

ifelifelse

再议input

a=input(‘birth:s’)s=int(a)

循环

classmates = ['tony', 'homer', 'ivy']for name in classmates:    print name

如果要计算1-100的整数之和，从1写到100有点困难，幸好python提供一个range()函数，可以生产一个整数序列，再通过list()函数可以转化。

sum1 = 0for x in range(101):    sum1 = sum1 + xprint sum1

第二种循环

sum1=0n=99while n>0:    sum1=sum1+n    n=n-2print (sum1)    

break
contine

使用dict和set

python内置了字典：dict的支持，dict全程dictionary，其它言语中也称为map，使用key-value存储，具有极快的查找速度。

d = {'homer': 25, 'ivy': 21, 'tony': 18}print (d['homer'])

把数据放入dict的方法。

d['biwu'] = 32print(d)

避免key不存在的错误，有两种方法，一是通过in判断key是否存在：

print ('Thomas' in d)print (d.get('Thomas', -1))

删除一个key，用pop(key）方法。
要保证hash的正确性，作为key的对象就不能变。在python中，字符串、整数灯都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

set

s = set([1, 2, 3, 4, 1, 3, 4])print (s)s.add(5)print (s)s.remove(1)print s

再议不可变对象

函数

调用函数

定义函数

在python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号：,然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def my_abs(x):      if x>=0 :        return x    else:        return -x   

如果你已经把my_abs()的函数定义保存为abstest.py文件了,那么，可以在该文件的当前目录下启动python解释器，用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名。
pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没有想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

参数检查

让我们修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类检查可以用内置函数isinstance()实现：

def my_abs(x):    if not isinstance(x,(int,float)):        raise TypeEroor(‘bad operand type’)    if x>0:        return x    else：        return -x 

返回多个值

import mathdef move(x,y,step,angle=0):    nx=x+step*math.cos(angle)    ny=y-step*math.sin(angle)    return nx,ny

原来返回值是一个tuple，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接受一个tuple，按位置赋给对应的值。

函数的参数

默认参数

新的power(x,n)函数定义没有问题，但是，就的调用代码失败了，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。
设置默认参数是，有几点要注意：

1. 是必选参数在前面，默认参数在后，否则pyton的解释器会报错。
2. 如何是指默认参数

当函数有多个参数时，把变化大的参数放亲们，变化小额参数放后面。变化晓得额参数就可以作为默认参数。
原因解释如下：
python函数在定义的时候，默认参数L的值就被计算出来了，即[],因为默认参数L也是一个变量，它指向对象[],每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

def add_end(L=None)    if L is None:        L=[]    L.append(‘END’)    return L    

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同事读取对象不需要加锁，同事读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，就尽量设计成不变对象。

可变参数

1. 由于参数个数不确定，我们首先想到可以把a,b,c…作为一个list或tuple传进来，这样，函数可以定义如下：
2. 我们就把函数的参数改为可变参数：

def calc(*numbers):    sum=0    for n in numbers:        sum=sum+n*n    return sum  

这种写法当然是可行的，问题是太繁琐，所以python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变元素变成可变参数传入

关键字参数

和可变参数类似，也可以先组装一个dict，然后，把该dict转换为关键字参数传进入
**extra表示吧extra这个dict的所有key-value用关键字参数传入函数的**kw参数，kw将获得一个dict，注意kw获得dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

命令关键字参数

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*,*后面的参数被视为命令关键字参数。

def person(name,age,*,city,job)      print(name,age,city,job)

如何关键字参数必须传入参数名，者和位置参数不同。如果没有传入参数名，调用将报错。

def person (name,age,*args,city,job)    print(name,age,args,city,job)

参数组合

在python中定义函数，可以用必选参数、默认参数、可变参数、和命名关键字参数，这5中参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键参数和关键字参数。

def f1(a,b,c=0,*args,**kw)print(“a=”,a,”b=”,b,”c=”,c,”args=”,args,”kw”,kw)  def f2(a,b,c=0,*,d,**kw)print(“a=”,a,”b=”,b,”c=”,c,”d=”,d,”kw=”,kw)

所以,对于任何函数，都可以通过类似func(*args,**kw)的形式调用它，无论它的参数是如何定义的。

递归函数

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看出一种特殊的尾递归函数也是可以的。
尾递归的是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器可以把尾递归做优化，使递归本事无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

高级特性

切片

取一个list或tuple的部分元素是非常常见的操作。

L[0:3]

前10个数，每两个取一个

L[:10:2]

tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple。

(0,1,2,3,4,5)[:3]

迭代

可以看出，python的for循环抽象程度要高于java的for循环，只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代。
默认情况下，dict迭代的是key。如果要迭代value，可以用

for value in d.values()

如果要同时迭代key和value,可以用

for k,v in d.items()

如何判断一个对象是可迭代对象？方法是通过collections模块的iterable类型判断：

from collections import Iterableisinstance(‘abc’,Iterable)

最后一个小问题，如果要对list实现类似java那样的下边循环？python内置了enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身。

上面的for循环里，同时引用了两个变量，在python里很常用的。

列表生成式

但是循环太繁琐，则列表生产式则可以用一行语句代替循环生成上面的list：

[x*x for x in range(1,11) if x%2==0]

还可以使用两层循环，可以生成全排列

[m+n for m in ‘ABC’ for n in ‘XYZ’]

因此，列表生产式也可以使用两个变量来生成list

d={‘X’:’A’,’Y’:’B’,’Z’:’C’}[k+’=’+v for k,v in d.items()]

生成器

通过列表生产式，我们可以直接创建一个列表。但是，受内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在python中，这种以便循环一边计算的机制，称为生成器:generator.

要创建一个generator，有很多方法。第一种方法很简单，只要把一个列表生产式的[]改成（），就创建了一个generator：

g=(x*x for x in range(10))

当然，上面这种不断调用next(g)实在太变态了，正确的方法是使用for循环，因为generator也是可迭代对象。
python的赋值语句

a,b=b,a+b

上面的函数和generator仅一步之遥。要把flb函数变成generator，只需要把print(b)改为yield b就可以了。
者就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：
这里，最难理解的就是generator和函数的执行流程不一样。函数的是顺序执行，遇到return语句或最后一行函数语句就返回。而变成generator的函数，在每次调用next（）的时候，遇到yield语句返回，在执行时从上次返回的yield语句处继续执行。
但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须铺货stopIeration错误，返回值包含在StopIteration