Python学习笔记--表达式

1. 赋值表达式

赋值表达式有如下几个特点：

• * 复制表达式创建一个引用；在Python中，变量中存储的只是对象的引用，赋值其实就是创建一个变量名到实际对象的一个引用
• * 变量名在第一次赋值的时候将会自动创建，无须声明和定义
• * 变量使用前必须被赋值

由于变量名中没有任何数据类型信息（记住，只是对象的引用），所以可以灵活对变量赋值任何类型的数据：eg：

x = 2 x = 'abc' x = [1,2,3] 在python中，有一种特殊的赋值--upacking assignment解包赋值，eg：

X, Y = 'abc', 'cde'        # tuple

[X, Y] = ['abc', 'abc]    # list

X, Y = 'ab'                  # string 可见，对于Sequence类型对象，都可以使用解包赋值，要求左边的变量数和右边的元素一致。  

Python学习笔记--引用vs复制

Python中，变量的都是默认存储对象的引用，而不是对象本身。例如：

>>> X = [1, 2, 3]

>>> L = ['a', X, 'b'] # Embed references to X's object.

>>> D = {'x':X, 'y':2}

这里X,L,D三个变量中的引用都指向了同一个对象[1,2,3]，在其中任意一个修改，都会影响其他的变量。
有时候我们可能并不希望出现这样的情况，我们可能需要每个变量中都有一个对象的单独拷贝。实现方法如下：

• * 使用无限制的slice来拷贝sequence对象，eg：A = L[:]


• * 对于Dictionary，使用copy函数来实现对象拷贝 eg：B = D.copy()


• * 一些函数也会产生对象的拷贝，例如list


• * 标准库copy可以用来完成完全的拷贝, eg：import copy，然后调用X=copy.deepcopy(Y);
  

值得注意的是，前面的第一二种方法得到的拷贝，都是最高层的拷贝，而并部拷贝嵌套的数据结构，如果要彻底的拷贝，就可以使用最后一种方法，他是递归的拷贝所有的嵌套的对象。

Python学习笔记--TUples,Files

1. Tuples 元组

Tuples其实和List基本一致，都是有序的对象集合，与List不同的是，tuples是immutable的。
Tuples在使用小括号()包围起来的一系列对象。Tuples不支持任何函数
Tuples有如下一些特点：

• * 任意对象的有序集合


• * 通过下表offset存取


• * Immutable


• * 定长，异质，任意嵌套</li
  
• * 对象索引的数组，而不是对象本色

Tuples的一些操作:

T = () #空元组

T = (1, ) # 一个元素的元组，后面要加一个逗号

T = (0, 'Hi', 1.2, 3) # 异质

T = ('ab', ('cd', 'ef')) #嵌套

T[i:j] #slicing

for t in T #迭代

T1 + T2 #连接

由于Tuple不支持任何函数，如果想对Tuple排序，应该怎么做呢？方法如下：

>>> T = ('cc', 'aa', 'dd', 'bb')

>>> tmp = list(T)

>>> tmp.sort( )

>>> tmp

['aa', 'bb', 'cc', 'dd']

>>> T = tuple(tmp)

>>> T

('aa', 'bb', 'cc', 'dd')

这里可以看到使用list()和tuple()函数进行相互转换，值得注意的是，这两个函数都是产生新的对象。

另外，tuple的immutable只是适用于tuple的最上层，如下例子可以说明：

>>> T = (1, [2, 3], 4)

>>> T[1][0] = 'spam' # Works

>>> T

(1, ['spam', 3], 4)

>>> T[1] = 'spam' # Fails

TypeError: object doesn't support item assignment

这里T[1]是一个List，list是mutable的。

2. Files 文件

文件是Python中的特殊的数据对象，此对象关联外部文件，相关函数可以直接对文件进行操作。
File的相关操作如下：

output = open('/dir/filename', 'w')

input = open('data','r') # file may be open as 'w' for write
# 'r' for read or 'a' for append

S = input.read() # 读取文件全部数据到一个字符串中

S = input.read(N) #读取N字节

S = input.readline() #读取下一行，以行结束符号=为标志

L = input.readlines() #读取整个文件到一个字符串的行的列表中

output.write(s) #向文件中写字符串s

output.wirtelines(L) #把列表中L中的所有行写入文件中

output.close() #关闭文件

在Python中，一个对象不再被引用的时候会自动回收内存，在回收file对象的时候，会首先关闭文件。手动close一个文件，虽然不是必须的，但是是一个好的习惯.

Python学习笔记--List和Dictionary

1. List列表 概述

List是Python中最灵活的有序集合类型。List中的元素可以是任何类型：number, string甚至list。List有一下特点：

• * List是任意对象的有序集合


• * 使用下标索引其中的元素


• * 可变长度，异质（list中元素可以是不同类型），内嵌（list of list）


• * mutable，序列的操作都适用（index，slice...）


• * list是引用的集合，而不是对象本身

L = [ ] #空list

L = [1, 2, ‘text’ ] #异质

L = [1, 3, [1, 2] ] #嵌套

L[1], L[1:3], L[i][j], len[L] # index, slice

L1+L2, L * 3 # 链接和复制

for x in L   2 in L

L2.append(4) L2.extend([5,6,7]) L2.sort( ) L2.index(1) L2.reverse( ) # 方法

del L2[k]  del L2[i:j] L2.pop( ) L2[i:j] = [ ] # 删除

L2[i] = 1  L2[i:j] = [4,5,6] # 赋值， mutable

range(4)  range(0, 4) # 产生整数列表

L4 = [x**2 for x in range(5)]  #列表推导式，（现在还不知道是什么意思） 

2. Dictionay字典 概述

如果说列表List是有序对象集合的话，字典就是无序对象集合，他们之间最主要的差别就是，字典通过关键字（key）存取值，而不是offset。

字典有如下特点：

• * 通过Key读取，而不是offset


• * 任意对象的无序集合


• * 可变长度，异质，可任意嵌套


• * Mutable映射表


• * 字典是对象引用的hash表，而不是对象本身

可见Dictionary和List基本是一直，除了全面所说的存取方式。

D = {} #空字典，注意是大括号

D1 = {'spam':2, 'egg':'None'} # 字典元素的定义方法

D2 = {'food':{'ham':1,'egg':2}} # 嵌套定义

D1['spam'] D2['food']['ham'] # 存取方法

D1.has_key('egg'), 'egg' in D1, D2.values(), ... # Dictionary相关的方法

D3 = dict(zip(keyslist, valuslist)) #Dictionary的构建（我现在还不清除这种用法）

由于Dictionary不是一个序列，所以不能直接使用迭代，要使用迭代的话，可以如下：
for item in D.keys():

Dictionary使用注意：

• * Dictionary是Mapping，而不是Sequence,在Dictonary中的各元素没有先后的顺序关系，所以对于Sequence的操作对Dictonary都不使用。如：连接，分片索引（slicing）


• * 对Dictionary的新的key赋值，就是增加一个新的元素。对已有的key赋值就是修改此元素


• * Dictionary的key不一定要是字符串string，其实任意不可变（immutable）的对象都可以，例如整数等

Python学习笔记--string 字符串

1. 字符串的定义

可以使用单引号（' '），双引号（" "）：这两个表示的方式完全等价。

还可以使用三引号（单双引号都可以），可以进行多行的字符串的定义。

Raw字符串，即完全原样字符串，不经心转义，eg：r'c:\py\text'

Unicode字符串，多字节字符串， eg：u'text'，u'ab\u0020cd'

Unicode --> normal：str(u"text")

normal --> Unicode：unicode("text")

2. 字符串操作

加法+：字符串的连接，'abc'+'def'

乘法*：字符串重复，'Hi!' * 3

求字符串的长度len()

字符串循环索引：

            ss = 'Hello'

            for c in ss: print c,  # H e l l o

            "H" in ss  # 1 or true

            "z" in ss   # 0 or false

字符串索引和分块：

           ss[0]  # 'H'

           ss[-2] # 'l'

           ss[1:3] #'el'

           ss[:-1]  #'Hell'

           ss[m:n], m和n可以缺省，m缺省为0, n缺省为ss的长度

           ss[start: end: step], eg, ss[1:5:2], ss[ : :-1]

字符串转换工具：

           不能直接把数值和字符串（即使这个字符串很像一个数字）使用加号“+”连接，因为加号“+”可能是表示字符串连接，也可能表示数值加法，所以Python就把这种情况视为语法错误。

           string--> number: eg. int("42"), float("1.23E-10"), string.atoi("42")

           number-->string:  eg. str(42), `42`, 这里的运算符backquotes(`object`),把之间的对象object转换成字符串。

           eval 函数用来执行Python代码。

改变字符串：

          首先要注意，字符串是不可改变的--immutale: can't chang in-place。所以要改变字符串，其实就是要使用相应的上述操作创造一个新的字符串。

          eg. ss='spam' ;  ss[0]='A' 将触发错误。

3. 字符串格式化

Python在string中重载了%运算符，这里类似了C语言中的sprintf函数中%的作用，占位符，eg：

>>> exclamation = "Ni" 

>>> "The knights who say %s!" % exclamation 

'The knights who say Ni!' 

这里使用exclamation变量替换了左边字符串中的%s

 >>> "%d %s %d you" % (1, 'spam', 4) 

'1 spam 4 you' 

如果是多个变量的时候，要使用小括号包围起来，形成一个元组tuple

 >>> "%s -- %s -- %s" % (42, 3.14159, [1, 2, 3]) 

'42 -- 3.14159 -- [1, 2, 3]'

这里把int，float，array类型的数据自动转换成string类型