Python学习笔记

------------------从2014-8-1号开始重新学习Python的笔记------------------

 

是学习vamei的Python快速教程的笔记。

 

1、关于变量

在Python中，变量不需要声明，可以直接使用。

 

2、序列(Squence)是一种有序元素的组合

有：tuple(定值表，或称为元组，用圆括号表示)、list(表，用方括号表示)。tuple的值不可以变，list的值可以变。

 

 3、一个新的函数，range()可以用来帮助建立表list，实现循环的时候会经常用到。

 for循环使用的格式是：

for 元素 in 序列:
    statement

序列可以是tuple，也可以是list，而且list可以用range()来创建。

while就比较简单了：

while 条件:
    statement

 

4、Python下面也有值传递(不会影响传递变量的值，他会在函数内部重新产生一个变量)&指针传递(会改变传递变量的值)

值传递发生在传递的是基本数据类型的变量，像是整形啊什么的。

指针传递发生在将一个表list传递给一个函数，对于表来说，表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作将在原有内存中进行，从而影响原有变量。

 附加，定义一个函数的格式为

def functionname(参数)：
    statement
    return something    #return is not necessary

记住：一个函数是一个对象 

 

5、Python中的面向对象

Python的类有属性(attribute)&方法(method)。方法的第一个参数是self，因为我们需要用self来调用这个类的属性。

特殊方法：特殊方法名字前后都有两个下划线。如__init__(),在初始化的时候都会调用这个函数，在建立对象时自动执行。

class Human(object):
    def __init__(self, input_gender):
        self.gender = input_gender
    def printGender(self):
        print self.gender

li_lei = Human('male') # 这里，'male'作为参数传递给__init__()方法的input_gender变量。
print li_lei.gender
li_lei.printGender()

__init__()把属性Human.gender的不确定表现的很好，让我们自己来设定。NOTE:跟构造有同样的作用。

 

6、自学Python很重要的两个命令

dir()用来查询一个类或者对象的属性。help()用来查询说明文档。

注意：要明确Everything is Object!像我们用到的list、int都是一个类。

 

7、一个新的类：dictionary字典，它分为键和值，注意，词典的元素没有顺序，不能通过下标引用元素，而是用键来引用。。ex：   dic={'tom':11,'sam':57,'lily':34}

容器(Container),可以存储多个元素的对象叫做容器。圆括号是tuple，中括号是list，大括号是dictionary。

 注意，字典的常用方法：dictionary.keys(),获取所有键；dictionary.values(),获取所有值；dictionary.items(),所有元素，也就是键值对；dictionary.clear(),清空。     dic是一个对象，dic(键)就是代表相应的值。

 

8、文件操作

打开文件：

f=open(文件名,模式)   #模式有“r”，只读；“w”，写入

操作：

content=f.read(N)           #读取N bytes的数据
content=f.readline()        #读取一行
content=f.readlines()       #读取所有行，存储在列表中，每个元素是一行

f.write('I love U')

关闭文件：

f.close()

我们用print dir(file) 可以打印出更多的属性和方法。像是writelines()啊什么的都可以看见了。

 

9、模块(module)：一个.py文件就是一个模块。

在一个模块中引入另一个模块a，这样写    import a

引入模块后，可以通过模块.对象的方式来调用引入模块中的某个对象(也可以用这种格式调用其中的函数，因为函数就是一个对象)。

其他的引入方式：

　　import a as b　　将名字a重命名为b

　　from a import function1　　引用a.function1，但是不用前面那么男写了，直接写function1就ok啦

　　from a import *　　　　　　你懂的，跟上面的很像嘛

import搜索包的路径有：文件所在文件夹，标准库安装路径，操作系统环境变量PYTHONPATH所包涵的路径。

模块包,将功能相似的模块房子啊同一个文件夹(比如说this_dir)中,构成一个模块包，通过 import this_dir.module   引入文件夹中的module模块。文件夹中必须要包含一个__init__.py，提醒Python，该文件为一个模块包，__init__.py可以是一个空文件。

 

10、函数的参数

默认参数的设置

def f(a,b,c=10):
    return a+b+c

print(f(3,2))
print(f(3,2,5))    #这样就对了，这样的话c就不是默认的10，c的值是5

包裹传递

在定义函数的时候，我们不知道要调用的时候会传递多少个参数。这时候，包裹(Packing)位置参数，或者包裹关键字参数，来进行参数传递，it works。 

def func(*name):

在func参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)。为了提醒Python参数，name是包裹位置传递所用的元组名，在定义func时，在name前加*号。

def func(**dict):

合并成一个字典(dictionary)。要在前面加**

*和**，也可以在调用的时候使用，即解包裹(unpacking)。

 

11、几个可以使循环更加灵活的函数

first one：      range()

second one:　　enumerate(),每次循环可以同时得到下标和元素。

third one:　　zip(),有多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，用它。每次循环，在list从左至右取出一个数组成一个tuple，所有的tuple合并成一个list：

ta=[1,2,3]
tb=[7,8,9]

#cluster   聚合
zipped=zip(ta,tb)
print(zipped)

#decompose    解聚合
na,nb=zip(*zipped)
print(na.nb)

上面这个例子就很吊啦。注意decompose之后是几个tuple，而不是list。

 

12、循环对象

iteration [计算机]循环，迭代

一、迭代器iter()

生成器(generator)的主要目的就是构成一个用户自定义的循环对象。generator的编写方法和函数定义类似，只是在return的地方改为yield。它可以有多个yield，当生成器遇到一个yield的时候会暂停运行生成器，返回yield后面的值，当再次调用生成器的时候会从刚才暂停的地方继续运行，知道下一个yield。

二、生成器表达式(generator expression)。generator expression是生成器的一种简便的编写方式。

一个生成器：

def gen():
    for i in range(4):
        yield i

可以写成generator expression：

G=(x for x in range(4))

三、表推导(list comprehension)是快速生成表的方法。语法简单，很有实用价值。

L=[]
for x in range(10):
    L.append(x**2)

生成一个表。也可以用表推导的方式：

L=[x**2 for x in range(10)]

表推导与生成器表达式类似，只不过generator expression用的是小括号，表推导list comperhension用的是中括号。

 

13、函数对象

函数也可以作为一个对象进行参数传递，当然函数也可以作为一个对象作为return的结果。函数一个简写的方法，lambda表达式。

def func(x,y):
    return x+y

#which can be express as follows
func=lambda x,y:x+y

map()函数

re=map((lambda x:x+3),[1,2,4,6])

map()的功能是将后面list中数值依次带入前面的函数中，得到的结果依次放在re表中。

filter()函数

filter()第一个参数为一个函数，第二个对象是一个列表list，将list中的数依次放入到函数中运算，返回的是True则将这儿数放到结果的list中，要是返回的是False，则这个数就被过滤掉了。

reduce()函数 

print reduce((lambda x,y:x+y),[1,3,4,5,7,9])

上面的例子相当于((((1+3)+4)+5)+7)+9

reduce()函数在3.0里面不能直接用的，它被定义在了functools包里面，需要引入包。

 

14、上下文管理器(Context Manager)

 规定某个对象的使用范围。一旦进入或者离开该使用范围，会有特殊操作被调用 (比如为对象分配或者释放内存，只是比如，并不是所有的离开了context就是释放了内存空间对象回收了)。它的语法形式是with   ..EXPRESS..   as  ..VAR..

任何定义了__enter__()和__exit__()方法的对象都可以用于上下文管理器。

实际上，任何一个有__call__()特殊方法的对象都被当作是函数。

 

15、属性attribute

有类属性(class attribute)和对象属性(object attribute)。对象属性存储在对象的__dict__属性中，__dict__是一个词典，键为属性名，值为属性本身。

在不知道一个对象用的是什么类的时候，用__class__属性可以找到对象的类，用类的__base__属性来查询父类。

特性(porperty)。一个对象的属性可能依赖另一个属性，当一个属性修改的时依赖他的属性也会相应改变。这是Python就需要一种特殊的机制来即时生成属性，这就是特性。特性使用内置函数property()来创建。前三个参数为函数，分别用于处理查询特性、修改特性、删除特性。最后一个参数为特性的文档，可以为一个字符串，起说明作用。

__getattr__(),他是一个特殊的方法，用来获得即时的生成的属性。我们用__dict__无法找到即时的属性，通过__getattr__()就可以获得该属性。

Python中还有一个__getattribute__特殊方法，用于查询任意属性。__getattr__只能用来查询不在__dict__系统中的属性

 

16、闭包(closure)

closure之于函数式编程，就像函数之于面向过程编程，class之于面向对象编程。

闭包(closure)：一个函数和它的环境变量一起组成了一个闭包。环境变量取值被保存在函数对象的__closure__属性中。

def line_conf(a, b):
    def line(x):
        return ax + b
    return line

line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5), line2(5))

上面就是闭包的一个很好的例子。利用line1和line2创建了两个函数x+1,4x+5，并将它们返回，在print中有可以利用它们。这样就利用闭包创建了泛函。有效的减少了要定义函数的数目，减少了函数所需要定义的参数的数目。

 

17、装饰器(decorator)

def decorator(F):
    def new_F(a, b):
        print("input", a, b)
        return F(a, b)
    return new_F

# get square sum
@decorator
def square_sum(a, b):
    return a**2 + b**2

# get square diff
@decorator
def square_diff(a, b):
    return a**2 - b**2

print(square_sum(3, 4))
print(square_diff(3, 4))

看上面的例子，我们可以很明显的发现，decorator就是将函数当做一个对象传递进来再将处理好的函数输出出去。被@了的函数就换掉了。

装饰器接受一个函数，并返回一个函数，从而起到加工函数的效果。

扩展一下：接受一个类，处理之后返回一个类，就达到了加工类的效果。这就是装饰类。

 

18、标准库(standard library)

forgive me,我已经迫不及待要进行标准库以及网络和服务器的搭建学习，基于Python。

Python的强大得益于它丰富的模块。

标准库：标准库会随着Python解释器，一起安装在你的电脑中的。它是Python的一个组成部分。这些标准库是Python为你准备好的利器，可以让编程事半功倍。

　　正则表达式(re,regular expression)注意之前混淆的     .任意一个字符　　*重复>=0次　　+重复>=1次　　?重复0次或1次

　　时间包有time包和datetime包

　　os.path包主要是处理路径字符串(这个包一部分类似于Linux中的ls命令)。

　　文件管理有(os部分，shutil包)

　　存储对象管理。我们在将内存中的数据转化成文本流(这个过程叫做serialize)，然后将文本流存到文件中。由于有些对象的类使我们自己定义的，所以serialize的时候我们需要知道类的格式才是存储。所以我们需要用Python中的pickle包。还有就是cPickle，用法与pickle一样。可以用 import cPickle as pickle  然后就将cPickle当做pickle一样用就好了。

　　pickle.dumps() #serialize object　　pickle.dump()#serialize and save object　　

　　pickle.load()#read file and build object

　　执行外部命令和程序用subprocess包，从这个意义上来说，subprocess的功能与shell类似。这个简直是太棒了！　

在Python下利用subprocess调用shell命令

　　　　除了subprocess.call()之外还有subprocess.check_call()、subprocess.check_output(),他们的用法几乎相同。实际上他们的用法都是基于Popen()的封装(wrapped)。 

import subprocess
child = subprocess.Popen(["ping","-c","5","www.google.com"])
child.wait()
print("parent process")

　　要是没有child.wait()的话，就不一定先执行ping了，他会先执行print。

　　另外还有：

child.poll()           # 检查子进程状态

child.kill()           # 终止子进程

child.send_signal()    # 向子进程发送信号

child.terminate()      # 终止子进程

　　subprocess.PIPE的用法 

import subprocess
child1 = subprocess.Popen(["ls","-l"], stdout=subprocess.PIPE)
child2 = subprocess.Popen(["wc"], stdin=child1.stdout,stdout=subprocess.PIPE)
out = child2.communicate()
print(out)

　　subprocess.PIPE实际上为文本流提供一个缓存区。child1的stdout将文本输出到缓存区，随后child2的stdin从该PIPE中将文本读取走。child2的输出文本也被存放在PIPE中，直到communicate()方法从PIPE中读取出PIPE中的文本。

　　Popen.wait(), Popen.communicate()

　　信号包signal。用signal.signal(signalnum, handler)来预设信号处理函数。一个有用的函数是signal.alarm()，它被用于在一定时间之后，向进程自身发送SIGALRM信号。

　　补充几个信号：

　　SIGINT   当键盘按下CTRL+C从shell中发出信号，信号被传递给shell中前台运行的进程，对应该信号的默认操作是中断(INTERRUPT) 该进程。

　　SIGQUIT  当键盘按下CTRL+\从shell中发出信号，信号被传递给shell中前台运行的进程，对应该信号的默认操作是退出 (QUIT) 该进程。

　　SIGTSTP  当键盘按下CTRL+Z从shell中发出信号，信号被传递给shell中前台运行的进程，对应该信号的默认操作是暂停 (STOP) 该进程。

　　SIGCONT  用于通知暂停的进程继续。

　　SIGALRM  起到定时器的作用，通常是程序在一定的时间之后才生成该信号。

　　实现多线程用threading包。

 

19、网络编程

 在Python中，我们利用socket包来进行网络编程。然而，socket传输自由度太高，从而带来很多安全和兼容的问题。我们往往利用高一些应用层协议来规定socket使用规则。以及所传输信息的格式。

我们还可以用SocketServer包来方便的架设服务器。

 

20.Django网络架构

 要完成一个完美的服务器，需要学习MySQL。我能不能继续学习MySQL！

 

 

 

 

 

 

 

------------------以下全是2014-8-1号之前的笔记----------------

1.变量是指向内存的地址，改变数据值的大小，是改变他的指向。所以我们不能通过给变量赋值改变内存中的值。

 

2.变量不需要指定变量的类型：因为他们都是指向某一块数据类型单元，他们的类型是一样的，不要指定什么类型

 

3.在linux中安装第三方函数库很简单：easy_install httplib2

 

4.python的函数库主要包括：系统函数库、网上的第三方函数库、自己写的函数

 

5.Type(a) 输出变量a的类型

 

6.序列(Sequence)有两种：tuple（定值表； 也有翻译为元组） 和 list (表)。

一旦建立，tuple的各个元素不可再变更，而list的各个元素可以再变更。

 

7.字符串是一种特殊的元组！！！！

 

×8.乘方运算，比如3的2次方写成： 3**2

 

9.if elif else

 

10.range()可以用来建立表

 

11.函数的定义以def作为标记

 

12.None是Python中特殊的字符，表示什么也没有

 

13.基本数据类型的参数：值传递； 表作为参数：指针传递

 

14.在class中定义一个方法用def（跟函数的定义是一样的），方法的第一个参数必须是self，不管是不是用得到。

 

15.Python中的继承，是直接卸载类名后面的括号中的，要是没有父类就写object

 

16.在第14条中说到，方法的第一个参数必须是self,为什么？通过self，调用类的其他属性。

 

17.__init__()是一个特殊方法(special method)。Python有一些特殊方法。Python会特殊的对待它们。特殊方法的特点是名字前后有两个下划线。
如果你在类中定义了__init__()这个方法，创建对象时，Python会自动调用这个方法。这个过程也叫初始化。

 

18.__init__()是初始化，不是什么构造函数。__init__(): 在建立对象时自动执行.

 

19.dir()用来查询一个类或者对象所有属性; help()用来查询说明文档。

 

20.词典(dictionary)与列表相似，可以存储多个元素。这种存储多个元素的对象成为容器(container)。

 

21.在Python中，一个.py文件就构成一个模块。通过模块，你可以调用其它文件中的程序。引入模块用import

 

22.可以将功能相似的模块放在同一个文件夹（比如说this_dir）中，构成一个模块包。该文件夹中必须包含一个__init__.py的文件，提醒Python，该文件夹为一个模块包。__init__.py可以是一个空文件。

 

23.函数的参数传递可以有关键字传递。

 

24.关键字(keyword)传递是根据每个参数的名字传递参数。

 

25.包裹传递(Packing).在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递.
包裹传递的关键在于定义函数时，在相应元组(tuple)或字典(dict)前加*或**。

 

26.*和**，也可以在调用的时候使用，即解包裹(unpacking).

 

27.用range()来控制for循环

 

28.利用enumerate()函数，可以在每次循环中同时得到下标和元素。

 

29.如果有多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现。zip()函数的功能，就是从多个列表中，依次各取出一个元素。每次取出的(来自不同列表的)元素合成一个元组，合并成的元组放入zip()返回的列表中。zip()函数起到了聚合列表的功能。

 

30.当一个循环结构（比如for）调用循环对象时，它就会每次循环的时候调用next()方法，直到StopIteration出现，for循环接收到，就知道循环已经结束，停止调用next()。

 

31.生成器(generator)的主要目的是构成一个用户自定义的循环对象。
生成器的编写方法和函数定义类似，只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个循环器，每次循环使用一个yield返回的值。

 

32.生成器表达式 (GeneratorExpression)

 

33.表推导(list comprehension)是快速生成表的方法.
Ex:L = [x**2 for x in range(10)]

 

34.Python中函数也是一个对象

 

35.lambda函数

 

36.函数可以作为一个对象，进行参数传递。

 

37.map()是Python的内置函数。map()的功能是将函数对象依次作用于表的每一个元素，他返回的是一个表（list）。

 

38.filter().filter函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是True，则该次的元素被储存于返回的表中(NOTE:说明在函数中要是返回的是True或者False，但是filter返回的是list中的数，而不是True或者False)。filter通过读入的函数来筛选数据。同样，在Python 3.X中，filter返回的不是表，而是循环对象。

 

39.reduce函数的第一个参数也是函数，但有一个要求，就是这个函数自身能接收两个参数。reduce可以累进地将函数作用于各个参数。reduce()函数在3.0里面不能直接用的，它被定义在了functools包里面，需要引入包。

 

40.在我们接触的对象中，有一类特殊的对象，是用于存储数据的。常见的该类对象包括各种数字，字符串，表，词典。在C语言中，我们称这样一些数据结构为变量。而在Python中，这些是对象。

 

41.对象是储存在内存中的实体。但我们并不能直接接触到该对象。我们在程序中写的对象名，只是指向这一对象的引用(reference)。

 

42.引用和对象分离，是动态类型的核心。

 

43.关于对象动态类型的讨论→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→ mutable object & immutable object
列表可以通过引用其元素，改变对象自身(in-place change)。这种对象类型，称为可变数据对象(mutable object)，词典也是这样的数据类型。
而像之前的数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象(immutable object)。
我们之前学的元组(tuple)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是immutable object.

 

44.函数的参数传递，本质上传递的是引用。

 

45.immutable对象和mutable对象在传递时的不同
如果参数是不可变(immutable)的对象，a和x引用之间相互独立。对参数x的操作不会影响引用a。这样的传递类似于C语言中的值传递。
如果传递的是可变(mutable)的对象，那么改变函数参数，有可能改变原对象。

 

46.但是Python也提供更加简洁的语法，让你使用不同的编程形态，从而在必要时隐藏一些面向对象的接口。
EX：在连接字符串的时候'abc'+'def',实际上是利用了字符串'abc'对象的方法.__add__() 所以实际执行的操作是'abc'.__add__('def')

 

47.上下文管理器(context manager)是Python2.5开始支持的一种语法，用于规定某个对象的使用范围。一旦进入或者离开该使用范围，会有特殊操作被调用 (比如为对象分配或者释放内存)。它的语法形式是with...as...
NOTE:很像C#中的using语句

 

48.Python中变量名和对象是分离的。变量名可以指向任何一个对象。

 

49.装饰器(decorator)接收一个函数/类，返回一个函数/类。
从本质上，装饰器起到的就是一个重新指向变量名的作用(name binding)，让同一个变量名指向一个新返回的可调用对象，从而达到修改可调用对象的目的。

 

50.为了探索对象在内存的存储，我们可以求助于Python的内置函数id()。它用于返回对象的身份(identity)。其实，这里所谓的身份，就是该对象的内存地址。

 

51.is用于判断两个引用所指的对象是否相同。

 

52.Python的一个容器对象(container)，比如表、词典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。

 

53.Python中内置的对字符串进行格式化的操作%

 

54.IndentationError: unexpected indent错误
提示格式不对，检查缩进等等可能出现的错误

 

55.程序包(Package)

 

56.pip
A tool for installing and managing Python packages.
在https://pypi.python.org/pypi/pip中可下载

 

57.在Python里面任何非0的数也会被解释为'True'

 

58.pass
pass表示什么也不做，pass

 

59.在Python3中，即使是整数相除，除法也会进行浮点数除法。

 

60.Python可是一个文件管理的利器

 

61.关于文本流与serialize
计算机的内存中存储的是二进制的序列 (当然，在Linux眼中，是文本流)。我们可以直接将某个对象所对应位置的数据抓取下来，转换成文本流 (这个过程叫做serialize)，然后将文本流存入到文件中。

 

-------------------------------语法(Syntax)------------------------------------------

1.import re
添加正则表达式的包

 

2.用from导入模块
如 from math import pi，现在就可以直接用pi了。要是没有前面的from，直接写import math，在用pi的时候须写成 math.pi

 

3.Python2提供了一个内置函数raw_input来从键盘获取输入。在Python3里，这个函数是input

 

4.time包

 

5.datetime包是基于time包的一个高级包， 为我们提供了多一层的便利。datetime可以理解为date和time两个组成部分。date是指年月日构成的日期(相当于日历)，time是指时分秒微秒构成的一天24小时中的具体时间(相当于手表)

 

6.os.path 包主要是处理路径字符串。os.path还可以查询文件的相关信息(metadata)。实际上，这一部分，类似于Linux中的ls命令的某些功能。

 

7.glob包最常用的方法只有一个, glob.glob()。该方法的功能与Linux中的ls相似

 

8.os包包括各种各样的函数，以实现操作系统的许多功能。这个包非常庞杂。os包的一些命令就是用于文件管理。

 

9.cwd(current working directory,当前工作路径)

 

10.pickele和cPickle可以将：内存中的对象转换成文本流；重建对象

 

11.subprocess包主要功能是执行外部的命令和程序，从这个意义上来说，subprocess的功能与shell类似。subprocess可以创建子进程，另外它还提供了一些管理标准流(standard stream)和管道(pipe)的工具，从而在进程间使用文本通信。

 

12.用subprocess.Popen()创建子进程，主程序不会自动等待子进程完成。我们必须调用对象的wait()方法，父进程才会等待(也就是阻塞block)

 

13.可以利用subprocess.PIPE将多个子进程的输入和输出连接在一起，构成管道(pipe).subprocess.PIPE实际上为文本流提供一个缓存区。

 

14.通过使用subprocess包，我们可以运行外部程序。这极大的拓展了Python的功能。

 

15.signal信号
要注意，signal包主要是针对UNIX平台(比如Linux, MAC OS)，而Windows内核中由于对信号机制的支持不充分，所以在Windows上的Python不能发挥信号系统的功能。

 

16.signal包的核心是使用signal.signal()函数来预设(register)信号处理函数

 

17.socket包，用来进行底层的socket的编程