Python学习心得.doc

(完整版)Python学习心得

0、命令行常用命令

命令行（ Windows 下叫 “命令提示符 "，Mac 下叫 “终端 ”）里的常用命令。打开命令行,我们

会看到每行前面都有诸如

C:\Documents and Settings\Crossin>

或者

MyMacBook：~ crossin＄

之类的.

这个提示符表示了当前命令行所在目录.

第一个常用的命令是：

dir （ windows 环境下）

ls （ mac 环境下）

dir 和 ls 的作用差不多，都是显示出当前目录下的文件和文件夹。

第二个常用命令是:

cd 目录名

通过 dir 或 ls 了解当前目录的结构之后，可以通过 “cd目录名 ”的方式,进入到当前目录下的子目录里.

如果要跳回到上级目录，可以用命令:

cd .。

另外， Windows 下如果要写换盘符,需要输入

盘符 ：

比如从 c 盘切换到 d 盘 C：\Documents and Settings\Crossin>d：

有了以上两个命令， 就可以在文件目录的迷宫里游荡了. 虽然没可视化的目录下的操作那么直观，但是会显得你更像个程序员。。。

于是乎，再说个高阶玩法：现在你可以不用 idle 那套东西了， 随便找个顺手的文本软件，把你的代码写好， 保存好,最好是保存成 py 文件。然后在命令行下进入到 py 文件保存的目录，使用命令： python 程序保存的文件名

就可以运行你写的程序了。

--

一、关于分号“； ”

在 C、Java 等语言的语法中规定， 必须以分号作为语句结束的标识。

样用于一条语句的结束标识。但在 Python 中分号的作用已经不像


Python 也支持分号， 同C、Java 中那么重要了,

Python 中的分号可以省略,主要通过换行来识别语句的结束。

例如，以下两行代码是等价的:

1. print ”hello world！”

2. print ”hello world!"；

第 1 行代码的输出结果:


hello world!

第 2 行代码的输出结果:


hello world！

如果要在一行中书写多条句，就必须使用分号分隔每个语句，否则


Python


无法识别语句之

间的间隔：

1. ＃ 使用分号分隔语句

2. x=1； y=1 ； z=1

第 2 行代码有 3 条赋值语句,语句之间需要用分号隔开。如果不隔开语句，

将不能正确解释，提示语法错误： SyntaxError: invalid syntax


Python


解释器

注意分号不是 Python 推荐使用的符号， Python 倾向于使用换行符作为每条语句的分隔,简单直白是 Python 语法的特点.通常一行只写一条语句，这样便于阅读和理解程序。一行写多条语句的方式是不好的习惯。

二、关于连行符 “ ”（双反斜杠好像不可以，已测试 ）

Python 同样支持多行写一条语句,
Python 使用 “”作为连行符.在实践中，一条语句写在多
行也是非常常见的。

【例】把 SQL 语句作为参数传递给函数，由于
SQL 的语句一般非常长,为了阅读方便，因
此需要换行书写。

1.
＃ 字符串的换行

2。
# 写法一

3.
sql = ”select id,name \

4。
from dept \

5.
where name = ’A’”

6.
print sql

7.
＃ 写法二

8.
sql = ”select id,name " \

9。
”from dept ” \

10.
"where name = 'A’"

11.
print sql

写法一只使用了一对双引号，把
SQL 语句分为 select、from 、 where 等 3 部分分别书写。

第 6 行代码输出结果： select id，name from dept where name = 'A'

写法二使用了 3 对双引号， select、from 、 where 分别对应一对双引号。

第 11 行代码输出结果: select id,name from dept where name = 'A'

第二种写法比第一种写法的可读性更强， 可以使用空格和制表符对齐语句, 使代码显得更工整.对于简短的语句不推荐换行的写法, 这种写法只会造成阅读的复杂性。 下面这段程序是不合理的换行写法：

1. # 一条语句写在多行

2. print \

3. "hello world！"

第 2 行～第 3 行代码是一个整体, 调用 print 输出 “hello world! ，这”种情况不适合分行书写.

三、关于单引号和双引号

双引号和单引号都是可以用的， 只不过用单引号的时候可以在字符串里面使用双引号。 同理，使用双引号时也可以在字符串里面使用单引号

先说 1 个双引号与 3 个双引号的区别，双引号所表示的字符串通常要写成一行如：

s1 = ”hello,world”

如果要写成多行，那么就要使用 ( “连行符 ”）,如

s2 = "hello,\

world”

s2 与 s1 是一样的.如果你用 3 个双引号的话，就可以直接写了,如下：

s3 = ”””hello,

world，

hahaha.”"” ，那么 s3 实际上就是 ”hello，\n world,\n hahaha。”， 注意 “n”，所以,

如果你的字符串里 \n 很多，你又不想在字符串中用 \n 的话，那么就可以使用

引号。而且使用 3 个双引号还可以在字符串中增加注释，如下：

s3 = ””"hello， #hoho， this is hello, 在 3 个双引号的字符串内可以有注释哦


3 个双

world,

＃hoho, this is world

hahaha。""”

这里我试过一下,确实可以加注释，不过在 print s3 的时候连注释内容会一起给打印出来这就是 3 个双引号和 1 个双引号表示字符串的区别了, 3 个双引号与 1 个单引号的区别也是和这个一样的，实际上 python 支持单引号是有原因的，下面我来比较 1 个单引号和

1 个双引号的区别.

当我用单引号来表示一个字符串时，如果要表示


Let's go


这个字符串，必须这样:

s4 = 'Let\’s go' ，注意没有,字符串中有一个 ',而字符串又是用 '来表示,所以

使用转义符 \, 如果你的字符串中有一大堆的转义符，看起来肯定不舒服，

解决了这个问题，如下：


这个时候就要

python 也很好的

s5 = "Let's go"

对于双引号，也是一样的，下面举个例子

s6 = ’I realy like ”python”!’

这就是单引号和双引号都可以表示字符串的原因了。

例子：

(1） print (”Stay hungry,\n” ＃这里换行符 \n 必须写在双引号里面

"stay foolish.\n”

”—— Steve Jobs”)

（2） print （’’’Stay hungry, ＃这里用了三个单引号，没用换行符

stay foolish.

-— Steve Jobs'’’）

（3） print （"”"Stay hungry， #这里用了三个双引号,没用换行符

stay foolish。

—- Steve Jobs”"")

这三个输出的结果都是三行：

Stay hungry,

stay foolish。

-— Steve Jobs

(4) print （”Stay hungry, \ stay foolish。 \

—— Steve Jobs”）

这个输出的结果是一行： Stay hungry， stay foolish。 -- Steve Jobs

四、关于注释符

用井号作为注释一行

＃此处为注释

一般用 "”” （三个英文引号）也可以注释多行，不过一般用来表示函数文档

”””

此处是注释

此函数功能为。.。.

""”

五、逻辑量 True 和 False 首字母必须大写

Python 中的 None ：

None 是一个特殊的常量。

None 和 False 不同.

None 不是 0。

None 不是空字符串。

None 和任何其他的数据类型比较永远返回 False 。

None 有自己的数据类型 NoneType 。

你可以将 None 复制给任何变量,但是你不能创建其他 NoneType 对象。

六、 if 语句, if ⋯elif ⋯else语句， while 循环, for 循环 ， break 和 continue

if 条件: ＃注意冒号必须有

选择执行的语句 #注意这里有四个空格的缩进

if, elif， else 可组成一个整体的条件语句：

if 是必须有的; elif 可以没有，也可以有很多个，每个 elif 条件不满足时会进入下一个 elif

判断； else 可以没有，如果有的话只能有一个，必须在条件语句的最后。

if a == 1：

print 'one’

elif a == 2:

print ’two'

else:

print ’too many’

while 条件： # 注意冒号必须有

选择执行的语句 ＃注意这里有四个空格的缩进

for i in range(1, 101): #i 从 1 取到 100

print i

注： range（x， y, c)表示一个 list : ［x， x+c， x+2c, ⋯ ， y -c］ 。如果没有第三个参数 c， 默认 c=1。

break

while 循环在条件不满足时 结束， for 循环遍历完序列后

或序列没有遍历完的时候，想要强行跳出循环,就需要用到


结束.如果在循环条件仍然满足

break 语句.

continue

break


是彻底地跳出循环，而


continue


只是略过本次循环的余下内容，直接进入下一次循

环。

七、 变量命名规则

python 在定义一个变量时 不需要给它限定类型 。变量会根据赋给它的值,自动决定它的类

型。你也可以在程序中，改变它的值,于是也就改变了它的类型.

变量命名时 第一个字符必须是字母或者下划线“ _”， 剩下的部分可以是字母、下划线“ _” 或数字（ 0—9)

变量名称是对大小写敏感的， myname 和 myName 不是同一个变量。

八、字符串的输出和运算

字符串之间可以通过加法连接起来：

str1 = ’good’

str2 = ’bye'

print （str1 + str2)

print (’very ’ + str1）

print (str1 + ' and ’ + str2)

print （'My age is ' + str（18）)

num = 18

print （'My age is %d’


％num)


#注意， ％num 可以直接用 ％18 代替,但是 ％num

间不能加逗号,只能是空格（没有空格也可以）


和字符串之

print （’Today is ％s。' print ( ， Price is ％.2f ?

％ 'Friday')

％ 4。99）

注意: ％d 表示整数， %s 表示字符串, %f 表示浮点数， %。4f 表示带 4 位小数的浮点数

print


( "％s’s score is ％d”


％ ('Mike’, 87）


)

无论你有多少个值需要代入字符串中进行格式化， 只需要在字符串中的合适位置用对应格式的% 表示，然后在后面的括号中按顺序提供代入的值就可以了。占位的 ％和括号中的值在数量上必须相等，类型也要匹配。

（’Mike’, 87)这种用


（)表示的一组数据在


python


中被称为元组（


tuple），是


python


的一种基本

数据结构，以后我们还会用到。

九、变量强制类型转换

int(x) # 把 x 转换成整数

float（x） # 把 x 转换成浮点数

str(x) ＃ 把 x 转换成字符串

bool(x） ＃ 把 x 转换成 bool 值

例如,以下等式的结果均为真： int（'123’) == 123

float（’3.3'） == 3.3

str(111） == '111’

bool(0） == False

bool（’abc'） == True

bool('False') == True

bool（'’) == False

并不是所有的值都能做类型转换， 比如 int（’abc'） 同样会报错， python 没办法把它转成一个数。

关于


bool


类型的转换,在 python 中,以下数值会被认为是 False：

为 0 的数字，包括 0, 0.0

空字符串,包括 ’’, "”

表示空值的 None （ None 是 python 中的一个特殊值，表示什么都没有，它和


0、空字符、

False、空集合都不一样）

空集合，包括 （） ， [］ ， {｝

其他的值都认为是 True.

十、函数

如果我们要写一个函数，就需要去定义它。


Python


里定义函数的关键字是


def，格式如下：

def sayHello（)：

print 'hello world!'

我们用 sayHello(） 来调用这个函数。 (注意括号必须带着）

return 是函数的结束语句，


return 后面的值被作为这个函数的返回值。

被执行到的时候，这个函数就会结束。


函数中任何地方的


return

十一、 list 列表

格式 :用中括号包围、逗号隔开的一组元素；列表中的元素可以是不同的类型。

例如， range（1，10)或者 ［1, 2, 3， 4， 5， 6, 7, 8， 9] ; I = ［365, ’everyday’， 0.618， True］ 。

操作 list :

1。 访问 list 中的元素

python 计数是从 0 开始，例如 I［0]=365， I［1]= ’everyday'

2. 修改 list 中的元素

修改 list 中的某一个元素，只需要直接给那个元素赋值就可以了： l[0］ = 123

注意如下例子： c=[1，2，3］

b=c

a=c

b［0]=2

print a 得到 a=[2，2,3]

特别注意： 如果用一个 list 赋值给另一个 list ,但是想要改变一个 list 的时候另一个不变， 这

时需用如下赋值方法: a=[1，2]

b=[]

b［0 : len(a)］=a［0 ： len（a）]

b.append（3)

print a 得到 [1，2］

print b 得到 [1,2,3]

3. 向 list 中添加元素

list 有一个 append 方法，可以增加元素。以 I 这个列表为例,调用的方法是：

I。append（1024） ＃注意这里是小括号

输出 I，你会看到 [123， ’everyday’, 0.618, True, 1024］ ，1024 被添加到了 I，成为最后一个元素。

（第一个元素在上一步被改成了 123。)然后同样可以用 I[4] 得到 1024。

4。 删除 list 中的元素

删除 list 中的某一个元素，要用到 del:

del I［0］ ,然后输出 I ,得到 [’everyday’， 0.618， True, 1024］ 。这时候再调用 I[0] ，会得到 ’everyday'，其他元素的序号也相应提前。

例子， #==== 点球小游戏 ====＃

from random import choice

print 'Choose one side to shoot:'

print 'left, center， right’

you = raw_input（）

print ’You kicked ' + you

direction = ['left’, 'center', ’right'］

com = choice（direction)

print ’Computer saved ’ + com

if you ！= com：

print ’Goal!'

else:

print 'Oops.。.’

5。 求和：例如 sum([1,2,3]）=6, sum(range（101))=5050

list 有两类常用操作: 索引 （index） 和切片 （slice）。

用 [] 加序号访问的方法就是 索引操作 。除了指定位置进行索引外, list 还可以处理负数的索引，例如 I[—1］ 表示 l 中的最后一个元素， l［-3] 表示倒数第 3 个元素。

切片操作 符是在 ［] 内提供一对可选数字， 用冒号分割。 冒号前的数表示切片的开始位置，

冒号后的数字表示切片到哪里结束。同样，计数从 0 开始.注意，开始位置包含在切片中，

而结束位置不包括。例如， I = [365， 'everyday'， 0.618, True］ ， I[1：3］ 得到的结果是 [’everyday’，

0.618]。

如果不指定第一个数，切片就从列表第一个元素开始。

如果不指定第二个数，就一直到最后一个元素结束。

都不指定，则返回整个列表的一个拷贝。

I[:3]


I［1:］


I［：]

同索引一样，切片中的数字也可以使用负数。比如：

I［1:-1]


得到

［'everyday', 0。618]

十二、字符串的索引和切片（类似

1. 遍历


list 的操作）

通过 for。..in 可以遍历字符串中的每一个字符。

word = 'helloworld’

for c in word:

print c

2. 索引访问

通过 ［］ 加索引的方式，访问字符串中的某个字符.

word[0］= 'h'

word[-2]= 'l'

与 list 不同的是，字符串不能通过索引访问去更改其中的字符。

word［1］ = ’a’ 这样的赋值是错误的。

3. 切片

通过两个参数,截取一段子串，具体规则和 list 相同。

print word[5:7］

print word［:—5]

print word［:］

4. 连接字符

join 方法也可以对字符串使用，与 list 的 join 用法类似.

'，’。join（word）= 'h，e,l,l,o，w,o,r,l，d'

十三、字符串的分割 —- list

假设需要把一个句子中的每一个单词拿出来单独处理.

sentence = 'I am an English sentence’

这时就需要对字符串进行分割 : sentence。split（)

字符串 .split（） 会把字符串按照其中的空格进行分割，分割后的每一段都是一个新的字符

串，最终返回这些字符串组成一个 list 。于是得到 ［'I', 'am’, 'an’， ’English'， 'sentence’］

除了空格外， split（） 同时也会按照换行符 \n，制表符 \t 进行分割.所以应该说， split 默认

是按照空白字符进行分割。

之所以说默认，是因为 split 还可以指定分割的符号。比如你有一个很长的字符串

section =’Hi。 I am the one。 Bye。'


通过指定分割符号为


'。’，可以把每句话分开：


section.split（’。')

得到 [’Hi’， ' I am the one’, ' Bye'， ’'] 。这时候， ’。'作为分割符被去掉了，而空格仍然保留在它的

位置上。注意 最后那个空字符串 。每个 ’.'都会被作为分割符，即使它的后面没有其他字符，

也会有一个空串被分割出来。 例如 ’aaa’。split（’a’) 将会得到 ［'’， '', '’， ''］ ,由四个空串组成的 list 。

十四、连接 list-- 字符串

join :和 split 正好相反 ，join 把一个 list 中的所有字符串连接成一个字符串 , 而 split

是把一个字符串分割成很多字符串组成的 list 。

join 的格式有些奇怪，它不是 list 的方法，而是字符串的方法.首先需要有一个字符

串作为 list 中所有元素的连接符，然后再调用这个连接符的 join 方法, join 的参数是被

连接的 list :

例如： s = '；'

li = ［'apple'， 'pear'， 'orange']

fruit = s.join（li）

print fruit

得到结果 ’apple；pear；orange’

又例如: '’。join(['hello', 'world’]）


。


得到 ’helloworld’


,字符串被无缝连接在一起。

十一 ** 、元组 （ tuple ）

元组（ tuple ）也是一种序列, 和我们用了很多次的

后就不能被修改。 例如 position = (1, 2）


list


类似，只是 元组中的元素在创建之

geeks = ('Sheldon’， ’Leonard’, ’Rajesh’， 'Howard')

都是元组的实例.它有和 list 同样的索引、切片、遍历等操作：

1. print postion［0]

2. for g in geeks:

3. print g

4. print geeks[1:3]

其实我们之前一直在用元组,就是在 print 语句中：

print '％s is ％d years old’ % （'Mike', 23）

('Mike', 23） 就是一个元组。这是元组最常见的用处.

再来看一下元组作为函数返回值的例子：

1. def get_pos(n）：

2. return （n/2, n＊2）

得到这个函数的返回值有两种形式，一种是根据返回值元组中元素的个数提供变量：

1. x, y = get_pos（50)

2. print x

3. print y

这就是我们在开头那句代码中使用的方式。

还有一种方法是用一个变量记录返回的元组：

1. pos = get_pos(50)

2. print pos[0］

3. print pos[1］

十五、读文件

新建个文件，就叫它 data.txt 。在里面随便写上一些话,保存。把这个文件放在接下来你打算保存代码的文件夹下,这么做是为了方便我们的程序找到它。

打开一个文件的命令很简单： file（' 文件名 '）

这里的文件名可以用文件的完整路径， 也可以是相对路径. 因为我们把要读取的文件和代码放在了同一个文件夹下，所以只需要写它的文件名就够了。

f = file（'data.txt')


#注意这里 f 不是字符串 ， 是文件对象

但这一步只是打开了一个文件， 并没有得到其中的内容。 变量 f 保存了这个文件， 还需

要去读取它的内容。你可以通过 read(） 函数把文件内所有内容读进一个字符串中。

data = f。read(） #这里 data 是字符串

做完对文件的操作之后，记得用


close（)


关闭文件，释放资源.

完整程序示例：

f = file(’data。txt')

data = f。read()

print data

f.close(）

读取文件内容的方法还有:

readline（) ＃ 读取一行内容

readlines() # 把内容按行读取至一个


list


中

去替换程序的第二行，看看它们的区别。

十六、写文件

打开文件的几种模式:

python 默认是以只读模式打开文件。如果想要写入内容，在打开文件的时候需要指定

打开模式为写入： f = file('output。txt’， 'w’）

’w' 就是 writing ，以这种模式打开文件，原来文件中的内容会被你新写入的内容覆盖掉，

如果文件不存在，会自动创建文件。不加参数时， file 为你默认为 ’r' ， reading ，只读模

式,文件必须存在，否则引发异常。

另外还有一种模式是 f = file（’output.txt', 'a') ,其中 ’a’ 是 appending 。它也是

打开文件还有一种方法,就是 open() ，用法和 file() 是一致的。

写文件:

写入内容的方法同样简单：

f.write('a string you want to write’)

write 的参数可以是一个字符串，或者一个字符串变量。

示例程序:

data = 'I will be in a file。\nSo cool！'

out = open(’output。txt’, ’w’)

out.write(data)

out.close(）

在你的程序保存目录下，打开类似的， writelines（list） #


output。txt

把 list


就会看到结果。

的每一个元素写成一行

没有 writeline（list) .

十七、处理文件中的数据

比如我现在拿到一份文档， 里面有某个班级里所有学生的平时作业成绩。 因为每个人交作业的次数不一样， 所以成绩的数目也不同， 没交作业的时候就没有分。 我现在需要统计每个学生的平时作业总得分.

看一下我们的文档里的数据：

#-— scores.txt

刘备 23 35 44 47 51

关羽 60 77 68

张飞 97 99 89 91

诸葛亮 100

1。
先把文件读进来：

f = file（’scores.txt’）

2。
取得文件中的数据。因为每一行都是一条学生成绩的记录,所以用
readlines ，把每一

行分开，便于之后的数据处理：

lines = f。readlines()

f.close()

提示：在程序中,经常使用 print
来查看数据的中间状态， 可以便于你理解程序的运行。

比如这里你可以 print lines ,看一下内容被存成了什么格式。

3. 对每一条数据进行处理。按照空格，把姓名、每次的成绩分割开： for line in lines：

data = line.split（)


# 这里


data


是


list

接下来的 4、 5 两个步骤都是针对一条数据的处理,所以都是在 for 循环的内部。

4. 整个程序最核心的部分到了。如何把一个学生的几次成绩合并，并保存起来呢？我的做法是:对于每一条数据，都新建一个字符串，把学生的名字和算好的总成绩保存进去。最后再把这些字符串一起保存到文件中：

sum = 0

for score in data[1:］：

sum += int（score）

result = '％s\t: ％d\n’ % （data［0］, sum）

这里几个要注意的点：

对于每一行分割的数据， data［0] 是姓名， data［1:］ 是所有成绩组成的列表。

每次循环中， sum 都要先清零。

score
是一个字符串，为了做计算,需要转成整数值int 。

result
中，我加了一个制表符 \t 和换行符 \n ，让输出的结果更好看些.

5.
得到一个学生的总成绩后，把它添加到一个
list
中。

results.append（result)
# 这里 results
是 list

results
需要在循环之前初始化
results = []

6。
最后，全部成绩处理完毕后，把
results 中的内容保存至文件。因为results
是一个字

符串组成的 list ，这里我们直接用 writelines
方法：

output = file('result。txt', ’w')

output.writelines(results）

outpus.close(）

十八、异常处理

在 python 中，可以使用 try。。。except语句来处理异常。 做法是， 把可能引发异常的语句放

在 try— 块中，把处理异常的语句放在except- 块中。例如:

try：

f = file('non-exist。txt’)

print 'File opened！'

f.close（)

except:

print ’File not exists。’

print 'Done'

十九、字典


dictionary

python


中的基本类型

-— 字典(

dictionary


）：

字典这种数据结构有点像我们平常用的通讯录, 有一个名字和这个名字对应的信息。字典中,名字叫做“键 （key) "，对应的内容信息叫做“值 (value） ”.字典就是一个键对的集合。键 / 值对用冒号分割,每个对之间用逗号分割，整个字典包括在花括号中。

在

/ 值

d = {key1 : value1, key2 ： value2 }

举个简单的字典例子： score = ｛’ 萧峰 ’: 95， ’ 段誉 ’： 97,' 虚竹 '： 89｝

关于字典的键要注意的是：

1. 键必须是唯一的；

2. 键只能是简单对象， 比如字符串、 整数、浮点数、 bool 值.list 就不能作为键, 但是


可

以作为值。

3。python 字典中的键 / 值对没有顺序， 我们无法用索引访问字典中的某一项， 而是要用键来

访问. 例如 print score［’ 段誉 ’] 或者 print score。get（' 段誉 ') 。如果你的键是字符串,

通过键访问的时候就需要加引号， 如果是数字作为键则不用。 注意,字典类的 get 方法是按

照给定 key 寻找对应项，如果不存在这样的 key ，就返回空值 None

4。 字典也可以通过 for。..in 遍历：

for name in score：

print score[name］


#这里要用中括号

或者 print score.get（name) #这里要用小括号

注意,遍历的变量中存储的是字典的键。

5。
如果要改变某一项的值，就直接给这一项赋值:
score［'
虚竹 '］ = 91
6.
增加一项字典项的方法是，给一个新键赋值：
score［’
慕容复 ’］ = 88
7。
删除一项字典项的方法是
del ： del score[’
萧峰 ’]

注意,这个键必须已存在于字典中.

8。
如果你想新建一个空的字典，只需要
： d = ｛}

二十、模块

python 自带了功能丰富的标准库，另外还有数量庞大的各种第三方库。使用这些功能