《Python核心编程》读书笔记（一）

谨以此博文记录自己初次学习Python的知识点，以下笔记均来自于学习《Python核心编程（第二版）》的读书笔记。

Python基础：

1. 字符串：myString = ‘Hello world’

2. print : 语句调用str() 函数显示对象，交互式解释器调用repr()函数显示对象

   print：“%s is number %d” % (“Python”, 1) # “” 与”均可以
   支持将输出重定向到文件：

   重定向到标准错误输出：
       import sys
       print >> sys.stderr, 'Fatal error...'
   重定向到日志文件：
       logfile = open('/tmp/mylog.txt', 'a')
       print >> logfile, 'Fatal error:...'
       logfile.close()
   

默认给每一行加一换行符。在最后加一逗号，可以不换行，只是自动加一空格

3._ 下划线，表示最后一个表达式的值

4.raw_input()：读取标准输入，将读到的数据赋给指定的变量：

>>> user = raw_input('Enter login name:')
Enter login name:   #等待用户输入

可以使用int()函数将用户输入的字符串转换为整型 —>才可以对它进行数学运算

5.注释：从 # 开始，直到一行结束的内容都是注释
6. 逻辑操作符： and or not
7. 变量：

Python是动态类型语言，无需预先声明变量的类型。
变量的类型、值在赋值那刻被初始化。
变量不支持自增1 和自减1操作符（++、--）

8. 布尔值：True、False

是特殊的整型，与数值运算的话，True为1 False为0

9.if 语句：

if expression:
    ...
elif expression2:
    ...
else:
    ...

10 for循环：

for item in ['e-mail', 'homework']:
    ...

in后边也可以是range():

 1. 与len() 一起用于字符串索引：

for i in range(len(foo)):
    print foo[i]

 2. 接受一数值范围，生成一列表：
         eg: range(3): [0, 1, 2]
 3. range(start, end, step): 起始值start，结束值stop-1

range(end)  #start:默认为0，step: 默认为1
range(start, end)   #step:1

列表解析：squared = [ x ** 2 for x in range(4) ]

11 文件函数：

fobj = open(filename, 'r')  #r:access_mode: 还可以是w, a(添加), +（读写）, b（二进制访问）
for eachLine in fobj:
    print eachLine,
fobj.close()

12 错误和异常：

try:
    ...
except IOError, e:  #EOFError:^D产生EOF错误，KeyboardInterrupt：^C产生中断退出error
    ... #  str(e)
else:
    ...

13 函数：

def addMe2Me(x):
    "..."     #备注
    ...
    return ...

可以有一个默认值：

def foo(debug = True):
    ... #在函数体内，如果以foo()调用，则认为debug为True
        #          如果以foo(False)调用，则认为为False

14 模块：

import module_name

#   eg:
import sys
sys.stdout.write('Hello world:\n')

int(obj)    将对象转换为整型
str(obj)    将以对象转换为字符串
repr(obj)   返回一对象的字符串表示
type(obj)   返回对象的类型（返回值本身是一个type对象，而不是简单的字符串）
反斜线 \ 继续上一行
cmp(obj1, obj2)  比较obj1，obj2，根据比较结果返回整型i（i < 0:obj1 < obj2）

变量赋值

复制并不是直接将一个值赋给一变量，而是：对象通过引用传递的，将该对象的引用（并不是值）赋值给变量。

• 无需中间变量，即可交换两个变量的值：

x, y = y, x

引用计数：
当对象被创建时，创建一个引用计数（置为1）；当这个对象不再需要，引用计数为0时，被垃圾回收。

x = 3.14        # x ——> 3.14
y = x           #3.14这个对象，引用计数+1（=2），  y   --> 3.14

#或作为参数传递给函数（新的本地引用）：
foobar(x)       #引用计数+1

#当变量被赋值给另一对象时，原对象的引用计数-1：
x = 4       #则3.14的引用计数-1

#但列表的值不论怎么改变，列表的ID始终不变：eg
aList[2] = ...
aList.append('abc')

del：删除一变量

注：任何追踪或调试程序会给一对象增加一额外的引用，推迟该对象被回收的时间。
垃圾收集器：

负责释放内存，一块独立代码，用来寻找引用计数器为0的对象

Python对象

Python对象三个特性：

身份：可用内建函数id()得到，该值可被认为是该对象的内存地址
类型：可用内建函数type()查看对象的类型
值：对象表示的数据项

NULL对象：值为None，布尔值总是False

代码对象：被编译过的Python源代码片段，可执行对象
通过内建函数compile()可得到代码对象—>可被exec命令或eval()内建函数来执行

帧对象：包含Python解释器在运行时所需的all信息
用到帧对象的—>跟踪记录对象

切片对象：

多维切片：sequence[start1:end1, start2:end2] 
        /省略号：sequence[..., start1:end1]
步进切片：sequence[起始索引：结束索引：步进值]

对象身份比较：

foo1 = 4.3
foo2 = 1.3 + 3.0  #foo1,foo2指向不同的对象

用 is 和 is not 来测试两个变量是否指向同一对象：

a is b
等价于  id(a) == id(b)

整型对象，字符串对象是不可变对象 so Python可很高效地缓存它们
Python**仅**缓存简单整型， 默认缓存的整型范围：（-1，100）

数字

Python标准整型等价于C的（有符号）长整型，整型一般以十进制表示（八进制以O开始，十六进制以0x开始）
复数：

aComplex.real
aComplex.imag
aComplex.conjugate() #返回该复数的共轭复数

地板除： // 舍去小数部分
位操作符（只适用于整型） 按位与 & 或 | 异或 ^ 取反 ~ 左移<< 右移>>

abs(num)                    #返回num的绝对值
coerce(num1, num2)          #将num1、num2转换为同一类型，以一个元组的形式返回
divmod(num1, num2)          #返回一元祖（num1/num2, num1%num2）
pow(num1, num2, mod = 1)    #取num1的num2次方，若提供mod，取余计算
round(flt, ndig = 1)        #接收一浮点数flt， 并对其四舍五入，保存ndig位小数

hex(num)    #将数字转换为十六进制数，并以字符串形式返回
oct(num)    #.......... 八 ....................
chr(num)    #接收一单字节整型值（0<= num <= 255），转换成ACSII 字符
ord(num)    #接受一字符，返回对应的整型值

序列：字符串、列表和元祖

序列：可以通过下标偏移量访问到它的一个/几个成员

序列（通用的）

关系操作符： in 、 not in
判断一元素是否属于一个序列

连接操作符：+
推荐列表用extend() 把两个列表对象合并

重复操作符：*

sequence * copies_int   #copies_int:整型。返回一新的包含多份原对象拷贝的对象

切片操作符： [ ], [ : ], [ : : ]
负索引：范围-1（以序列的结束为起点）到序列的负长度（-len(sequence)）

类型转换：

list(iter)           把可迭代对象转换为列表
str(obj)             把obj对象转换为字符串
tuple(iter)          把一可迭代对象转换为一元组对象

内建函数：

len(seq)
max(iter)
min(iter)
reversed(seq)
sorted(iter)
enumerate(iter) 返回由iter每个元素的index值和item值组成的元组：

for i,t in enumerate(s):
    print i, t

#输出：
0 f
1 ...
2 ...

字符串

单引号 ’ ’ 双引号” ” 作用相同（因为Python里没有字符这个类型）

单引号内双引号套的内容，不转义，志杰认为字符串输出：
eg：' ''str[2:4]'' ' 反之亦然
但！！！单引号内不可再套单引号！双引号一样

不可变类型：改变一字符串的元素需新建一新的字符串

aString = 'abcd'
len(aString)       # =4

#用aString[2:4]无错，但不可aString[4]访问

raw_input():
Python没有C语言的结束字符NULL，输入多少字符，len()就返回多少

三引号：”’ ”’
允许以字符串跨多行，字符串中可包含换行符，制表符以及其他特殊字符。eg：

>>> hi = '''hi      #所见即所得 WYSIWYG
...there'''
>>>hi               #repr()
'hi\nthere'
>>>print hi         #str()
hi
there

不变性：

>>>s[2] = 'C'   #非法，可用下边方法来修改字符串中的一个字符：
>>> s = '%sC%s' % (s[0:2],s[3:])   

列表

能保留任意数目的Python对象的灵活的容器
列表可包含不同类型的对象

>>>aList = [123, 'abc', ['inner', 'list'], 4.56]     #数字无''，其他的带''

>>>aList[3][1]
'list'

>>>list('foo')
['f', 'o', 'o']

更新列表：

>>>aList.append("hi, world")

删除：

>>>del aList[1]
>>>aList.remove(123)

+:
将两个列表合并在一起（新建一列表） —> extend方法：把新列表添加到原列表里

List.index(obj) 返回 list[k] == obj 的k值

在用index()之前，最好先用in、not in检查一下在不在，否则的话无obj的话index报错

list.insert(index, obj) 在索引量为index的位置插入对象obj

可变对象值得可变对象的方法：没有返回值！ <-> 字符串：不可变的，so必返回一新的对象

aList.pop()将列表最后一个元素弹出来 .pop(0)：弹出来列表第一个元素

元组

元组：圆括号( ) 列表：方括号[ ]
元组（不可变类型）可以用作一字典的key！通过Hash算法得到的值总是一个值

注：只有一个元素的元组：需在元组分割符里加一逗号（,） ->防止跟普通的元组操作符混淆
eg：

>>>['abc']            >>>('xyz')          >>>('xyz',)
['abc']               'xyz'               ('xyz',)

>>>type(['abc'])      >>>type(...)        >>>type(...)
<type 'list'>         <type 'str'>        <type 'tuple'>

可通过list() 把它转换为一列表

元组的“不可变“：

>>>t = (['xyz', 123], 23, -103.4)
>>>t[0][1] = ['abc','def']
>>>t
(['xyz', ['abc','def']], 23, -103.4)

映射类型：字典

字典（可变的）：Python语言中唯一的映射类型。
映射类型对象：哈希值（键，key）、指向的对象（值，value）

序列类型：可用数字类型的键（从序列的开始起按数值顺序索引）
映射类型：可以用其他对象类型做键（最常见：字符串）

>>>dict2 = {'name':'earth', 'port':80}

或可用dict( )创建字典：

>>> fdict = dict((['x',1], ['y', 2]))
>>> fdict
{'y':2, 'x':1}

访问字典中的值：

>>>for key in dict2.keys():
#          or: in dict2
...     print 'key = %s, value = %s' % (key, dict2[key])
>>>dict2['name']
'earth'

检查一字典中是否有某个键：in、 not in

键： 不允许被改变！——>可哈希的——>数字、字符串可以，列表、字典不行

更新字典：

>>>dict2['name'] = 'venus'       #若有该键则更新该键对应的值
                                 #若无该键则增加新条目
>>>print 'host %(name)s is running on port %(port)d' %dict2
host venus is running on port 80                            

删除字典元素：
del dict2[‘name’]

len() 返回所有元素（键-值对）的数目

内建方法：

>>>dict2.keys()        #返回一列表，包含字典中all的键
['port', 'name']

>>>dict2.values()      #返回一列表，包含字典中all的值
[80, 'earth']

>>>dict2.items()      #返回一列表，包含字典中（键，值）元组的列表
[('port',80), ('name','earth')]

dict.update(dict2) :将字典dict2的键-值对 添加到字典dict
dict.get(key, default = None) 返回字典中key对应的值，若不存在键key，返回default的值（默认为None）

值：必须是可哈希的

值相等的数字表示相同的键。eg：1.0与1的哈希值相同 ——>相同的键