python学习笔记

高级编程语言的分类：

编译型（C，C++等）：

source code ——compiler——object code——executor——output

解释型（basic，Python等）：

source code——interpreter——output

Python是现代编程语言：

面向对象；

支持泛型设计；

支持函数式编程；

?对象和对象类型

?Python中所有类型都是以对象的形式存在

五种基本对象类型：

字符串 str

整数 int

浮点数 float

布尔数 bool

复数 complex

type函数查看对象类型；

Python中除了十进制数，其他进制的数只有字符串类型；

浮点数有精度损失，因此要区分整数和浮点数；

?Python内置了类型转换函数：

int() 函数可将二进制、八进制、十六进制转换成十进制的整型；int('1111',2) chr() 函数将整型转换为字符；#Python没有char类型

ord() 将字符转换为整型；

hex() 将十进制转换为十六进制；

oct() 将十进制转换为八进制；

bin() 将十进制转换为二进制；

?运算符与表达式

算术运算符

% 求余

** 指数运算

/ 向下取整数；如有一个数为浮点数，则结果为浮点数；若是两个整数相除，则结果还是取整数；

自动类型转换

若参与运算的两对象类型相同，则结果类型不变；

若类型不同，按以下规则进行自动类型转换：

bool ——> int ——> float ——> complex

math模块

import math #引入模块

dir(math) #查看模块函数

help(math.sin) #查看模块中函数的帮助

关系运算符

== 表示等于

!= 或 <> 表示不等于

【关系运算符返回True or False】

逻辑运算符

and, or, not

【逻辑运算符返回满足条件的结果】12 and 45返回12，12 or 45返回45

运算符优先级

括号（）

一元运算（正负） + -

幂次 **

算术运算 * / % //

算术运算（加减） + -

比较运算 == != <> <= >=

逻辑非 not

逻辑与 and

逻辑或 or

赋值运算 = *= /= += -= %= //=

变量

标识符（Identifier）：变量、函数、模块等的名字

变量的赋值：赋值运算符、增量赋值运算符如+=

标准（键盘）输入：

raw_input([prompt]) 读取键盘输入，将所有输入作为字符串看待；

示例：radius = float(raw_input('Radius:'))

标准（控制台）输出：

print object or variable

将多个对象输出到一行示例：print 'The area for the circle of radius', radius, 'is', area

将一个字符串输出到多行：print 'Hello\nWorld!'

常用转义字符

\n 回车

\t 制表符tab

\\ 一个\

\a 响铃bell

\' 单引号’

?程序控制结构1 - 选择结构

if 条件1:

if 条件2:

缩进的执行语句1

else:

缩进的执行语句2

else:

执行语句3

?多分支结构

if 条件1:

语句1

elif 条件2:

语句2

else:

语句3

?程序控制结构2 - while循环结构

初始条件

while 循环条件:

缩进的循环体（包括条件改变语句）

else:

可选的循环体

其他程序语句

break 结束当前循环体；

continue 结束当次循环；

?程序控制结构3 - for循环结构

for anElement in object:

缩进的循环体

range函数

range(start,stop[,step])

format函数

?函数

def 函数名(形参1，形参2=缺省值):

"""

说明文档，即注释

"""

语句，和说明文档一起称为函数体

return 返回值（可选）

?

o return将终止当前函数的执行，之后的语句将被忽略！

o global和local变量，以global关键字声明

?递归函数

程序调用自身：初始条件、递归部分

嵌套层次深，函数调用开销大，重复计算比较多；但是程序比较简洁。

?字符串

字符串运算

len()获得字符串长度；

+字符串拼接

*字符串重复

in成员运算符，返回True或False

for枚举字符串的每个字符，如for var in 'hello'

字符串索引[ ]

从0（前向）开始或-1（后向）开始

切片 [start : finish]，其中finish是索引结束位置的下一个字符的索引值；计数参数 [start : finish : countBy]

字符串是不可变的！

字符串方法（对象的函数）：

如my_str.replace(old,new)函数可将字符串my_str中的old字符串替换为new 字符串；替换后需要通过重新赋值才能将原字符串修改为新的字符串。

find('var' ) 查找字符出现的位置；

split(',') 切分字符串；

文件操作：

f = open(filename,mode)

for line in f:

line = line.strip()#去除字符串前后的空格、回车等字符

print line.title()#首字母大写，其余字母小写

f.close()

f.write(str)

字符串比较：

ASCII编码：任何一个字符对应一个数字；

故字符串的比较就是直接比较字符串对应的数字的大小；

字符串格式化：

str.format(para1,para2)，在str用 {} 表示对应的位置

如：print "Hello {} good {}.".format(5,'DAY')

{fieldname:align width.precision type}

"%s=%s" %(k, params[k])

正则表达式：

.表示任意字符

\d+表示一系列数字

[a-z]表示一个小写字母

如：re.search('C.A','ABCDEDF')

列表

列表：内建的数据结构，用来存储一系列元素。

支持索引[ ]、切片、拼接+、重复*、成员in、长度len、循环for

使用[ ]生成，元素间用逗号分隔；可以包含多种类型；

列表的内容是可变的。

列表的方法：

mylist.append(元素) ：追加元素，区别于拼接（拼接不改变列表）；mylist.extend(列表) ：追加新的列表；

mylist.insert(位置，内容) ：插入元素；

mylist.pop(下标，默认为最后) ：删除元素并返回该元素,

mylist.remove(元素内容) ：删除元素

sum(lst); max(lst); min(lst) ...

list.index( 元素 )：查找，返回位置

列表赋值

a = [1,2,3,]

b = a #b和a指向同一个列表；

c = a[:] #生成了一个新的列表c；

列表作为参数；

列表的查找：list.index( )

线性查找：最坏运行时间为 k0n+k1

二分查找：（有序列表）

时间复杂度

O(n)、O(n^2)等

列表的排序：内建函数sorted(lst)， list.sort()，使用quicksort算法，比选择排序和冒泡排序要快。

选择排序：

def selection_sort_v1(lst):

for i in range(len(lst)):

min_index = i

for j = range(i+1,len(lst))):

if lst(j) < lst(min_index):

min_index = j

lst.insert(i, lst.pop(min_index))

def selection_sort_v2(lst):

for i in range(len(lst)):

min_index = i

for j = range(i+1,len(lst))):

if lst(j) < lst(min_index):

min_index = j

swap(lst,i,min_index)

冒泡排序：

def buble_sort(lst):

top = len(lst)-1

is_exchanged = True

while is_exchanged：

is_changed = False

for i in range(top):

if lst[i] > lst[i+1]:

is_changed = True

swap(lst,i,i+1)

top -= 1

嵌套列表：

列表的解析（推导）：[表达式 for 变量 in 列表 if 条件]

eg. [i for i in range(1,x+1) if x%i==0]

eg. students.sort(key = lamda x: x[1], reverse = True)

匿名函数，列表嵌套，列表解析的应用

?元组Tuple

即不可变的列表，故除了改变列表内容的方法外，其他方法均使用与元组；用逗号（也可加小括号）创建元组：如 a = 1, 'abc', 3, 4

元组的赋值：a, b = b, a

DSU模式（装饰、排序、反装饰）：eg. 对单词按长度重新排列；

?字典

key-value，对应着c++的map或Java的HashTable

创建字典：使用{ }，冒号指明键值对，逗号隔开不同元素：

eg. my_dict = {'John':655879, 'Bob':266742}

访问字典：用[ key ] 进行访问；

字典运算符和方法：

len(dict)返回键值对数目；

key in my_dict判断key是否是字典中的键；

for key in my_dict枚举字典的键

my_dict.items()全部的键值对，以列表和元组的形式

my_dict.keys()全部的键

my_dict.values()全部的值

my_dict.clear()清空字典

示例：字母计数

方案二：生成具有26个元素的列表，将每个字母利用ASCM转化为相应的索引值

count = [0] * 26

for i in 'abeopd':

count[ord(i) - 97] += 1 # ord()返回字符的ASCM码

方案三：生成一个字典，字母做键，对应出现的次数做值

s = 'aoofgeoj'

d = { }

for i in s:

if i in d:

d[i] += 1

else:

d[i] = 1

print d

示例：统计文本中单词出现的频率

f = open('test.txt')

word_freq = {｝#字典

for line in f:

words = line.strip( ).split( )

for word in words:

if word in word_freq:

word.freq[word] += 1

else:

word.freq[word] = 1

freq_word = [ ] #列表

for word, freq in word_freq.items():

freq_word.append(freq, word))

freq_word.sort(reverse = True)

for freq, word in freq_word[:10]:

print word

f.close()

集合

无序不重复元素（键）集

创建集合：

x = set()

x = {key1,key2,...}

x.add()

x.remove()

列表元素的查找时间复杂度太高，所以用集合的形式；