《think Python》学习笔记

l 初识python：

Python：解释性语言，是由解释器运行的（使用解释器的两种方法：交互模式&脚本模式）

l 解释器：

每转译一行程序叙述就立刻运行，然后再转译下一行，再运行

l 脚本：

将代码存储在文件中，用解释器运行文件内容

Python脚本用.py结尾

l 交互模式VS脚本模式：

交互模式：键入表达式则可以获得运算结果

脚本模式：若无打印指令，不会显示结果（实际上计算了表达式，但只是在没有指令时不会输出）

l 程序基本元素：

变量&表达式&语句

l 模块：一个包含一批相关函数的文件（相当于C++中的头文件）

在使用模块前需要导入

e.g.

>>>importmath

即生成一个名为math的模块对象（包含定义在模块内的函数和变量），若对模块对象进行打印可以获得它的信息。

若要访问其中一个函数，需要指出模块名以及函数名，以点分割（不能直接访问模块对象中的函数和变量）：

>>>radians =0.7

>>>height =math.sin(radians)

l 导入的三种形式：

1.   直接导入一个模块：

>>>importmath

2.   从模块中导入一个对象：

>>>from mathimport pi

从math模块中导入pi这个变量，如此则可以直接访问pi变量

3.   从模块中导入所有的东西：（使用*运算符）

>>>from mathimport *

从模块中导入的内容要小心重定义现象。                        

l 泛化：

给函数增加一个形参，让函数更一般化

l 基本语法：

1.   赋值语句：

e.g.>>>message= ‘I am happy.’

>>>n = 7

>>>pi= 3.1415926’

2.   定义函数：使用def关键字

e.g.

def print_lyrics():

print (“I am a lumberjack, and I’mokay.”)

       函数头必须以：结尾，函数体必须是缩进的，

       在交互模式中，为了结束函数，必须输入一个空行（脚本中不需要）

3.   三引号字符串：”””……………………………………

                    ……………………………………”””

即多行字符串（三引号允许字符串超过一行）

4.   Space：

空格字符的字符串，用来控制输出的缩进

5.   break:

若循环条件为True，则它总是真的，所以直到遇到break语句才会停止循环

l 运算符：

**：指数运算

^：ＸＯＲ运算

／：除法运算（向下取整数：当两个整数相除时，结果也是整数，向下取整数砍掉小数部分，如：０．９８则取０。但如果是浮点数相除，结果就是浮点数。什么类型的数据进行运算，则结果就是什么类型的）

%：求余运算（可以查看一个数是否能被另一个数整除，若x%y=0则x可被y整除）

in：布尔运算符，可以接收两个字符串，如果第一个作为子串出现在第二个中，则返回True

e.g.

>>> 'a' in 'banana'

True

>>> 'seed' in 'banana'

False

+=：增量赋值语句。total += x 等价于 total = total + x

is：布尔运算符，查看两个变量是否引用同一个对象

   e.g.

   >>> a = 'hello'

>>> b = 'hello'

>>> a is b

True

但生成两个列表时，是生成了两个对象， 两个列表的元素相同，只能说两个列表相等，但不可以说他们是相同的两个对象：

e.g.

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

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

>>> a is b

False

l 运算符优先级：

用PEMDAS助记规则：

Parentheses括号>Exponentiation指数运算>Multiplication乘法&Division除法>Addition加法&Subtraction减法

具有相同优先级的运算符是从左到右进行运算

l 字符串运算：

1.   +运算符：进行级联运算：把字符串连接起来

e.g.

>>>first = ’what’

>>>second = ’ever’

>>>print(first + second)

whatever

2.   *运算符：执行重复运算

e.g.

>>>A = ‘Ha’

>>>print(A*3)

HaHaHa

l 数据类型转换：

1.   int能将浮点数转换为整数（截掉小数部分）

int函数能接受任意值，在其能做到的前提下，将任意值转换为整数，否则会报错

e.g.>>>int(‘32’)

   32

   >>>int(‘Hello’)

   ValueError: invalid literal for int():Hello

2.   float将整数和字符串转化为浮点数

e.g.>>>float(‘3.1415926’)

3.1415926

3.  str将实参转化为字符串

e.g.>>>str(32)

   ‘32’

l 浮点数：

浮点数值只是估计正确的，大多数分数、无理数不能够用浮点数精确表示。

l 迭代的应用：

循环常被用于计算数值结果的程序中，其开始于一个估计答案并迭代地改进它。

e.g.用牛顿法计算平方根：y = (x + a/x)/2

l 函数返回值：

在交互模式下，调用一个有返回值的函数，Python会显示其返回值，但如果是在脚本模式下，若不将函数返回值赋值给一个变量，函数返回值就会丢失。

无返回值函数可能在屏幕上打印内容或是有其他用途，但他们没有返回值，若将这个结果赋给一个变量，会得到一个被称为None的值。

值None  VS   字符串’None ’：

值None的数据类型是NoneType

‘None’的数据类型是str

l 使用函数的作用：

1.   增强代码可读性

2.   避免代码重复调用，使程序所占的存储空间更小

3.   方便Debug，可逐过程调试

4.   方便修改代码

l 布尔函数：

布尔函数的函数名通常是一个“是否问题”，如“is_divisible”返回True或Flase来测试是否能整除。

判断一个函数是否为布尔函数可以看它的返回值是否为布尔值。

但==运算符的结果也是布尔值，如果返回值的表达式有==运算符，则也为布尔函数。

布尔函数通常用于条件语句。

l 函数不工作的三个思考方面：

1.   传递的实参违反先决条件

2.   函数体有错误，违反后置条件

3.   函数返回值或函数的调用方式有错

解决：在函数开始的时候，增加一条ｐｒｉｎｔ语句将形参的值／类型打印出来，或者显示先决条件。若形参的值／类型无误，则在每个ｒｅｔｕｒｎ语句之前加一个ｐｒｉｎｔ语句显示返回值。若函数看起来能工作，则考虑返回值是否被正确调用。

l 遍历的方法：

1.   使用while循环：

e.g.

>>>fruit = ‘banana’

>>>index = 0

>>>whileindex < len(fruit):

          letter = fruit[index]

          print (letter)

          index = index + 1

2.   使用for循环：

e.g.

>>>fruit = ‘banana’

>>>for charin fruit:

        print (char)

每次通过循环，字符串中的下一个字符赋值给char，循环继续，直到没有剩余的字符。

语法：

For + 变量名 +in + 字符串：

l 字符串切片：（书P100的图！！！）

一段字符串成为切片，选择一个切片类似于选择一个字符

e.g.

>>> s = 'Monty Python'

>>> print (s[0:5])

Monty

[n : m]操作符返回从第n个字符到第m个字符的部分字符串（n和m不是下标），包括第一个但不包括最后一个。

若省略输入n，则表示切片起始于字符串的开始，若省略输入m，则表示切片一直到字符串的结尾。

l 字符串不可变：

不能改变一个已存在的字符串。只能够生成一个新的字符串！

e.g.

>>>greeting =‘Hello, word!’

>>>new_greeting= ‘J’+ greeting[1:]

>>>print(new_greeting)

Jello, world!

l 列表：

列表是值的序列。在列表中，它可以是任意值。列表中的值被称为元素或项。

生成列表的方法：

把元素放在[]中

e.g.

[‘spam’, 4.0 , 5, [5,6] ]

列表中的元素不一定是同一类型的，甚至列表中的元素可以是另一张列表（嵌套列表）

[]：空列表

l 访问列表元素：

与访问字符串的字符一样，均用括号运算符。括号内的表达式是索引，索引从0开始。

l 列表是可变的：

e.g.

>>> numbers = [12, 123]

>>> numbers[0] = 5

>>> print(numbers)

[5, 123]

直接赋值给对应元素即可

l 列表方法：

1.   append：在列表的结尾中加一个新元素

e.g．

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

>>> t.append(4)

>>> print(t)

[1, 2, 3, 4]

2.   extend：作为实参在列表中追加所有元素（相当于第二张列表作为实参传进来，与表一合并）

e.g.

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

>>> t2 = [4, 5]

>>> t1.extend(t2)

>>> print(t1)

[1, 2, 3, 4, 5]

3.   sort：升序排列列表元素（无实参）

e.g.

>>> t = ['a', 'e', 'c']

>>> t.sort()

>>> print(t)

['a', 'c', 'e']

列表的方法均无返回值，他们只改变列表但没有返回值

l 删除列表元素的方法：

1.   pop：改变列列表并返回被删除的元素。若不提供索引，则删除列表中最后一个元素。

e.g.

>>> t = [1, 2, 3, 4]

>>> x = t.pop(1)

>>> print(t)

[1, 3, 4]

>>> print (x)

2

>>> x = t.pop()

>>> print(t)

[1, 3]

2.   remove：想删除元素但不知索引

e.g.

>>> t = [1, 2, 3, 4]

>>> x = t.remove(4)

>>> print(t)

[1, 2, 3]

>>> print(x)

None

remove函数没有返回值

3.   del+切片：删除多余一个的元素

e.g.

>>> t = [1, 2, 3, 4, 5]

>>> del t[1:3] #t[1:3]不作为实参

>>> print (t)

[1, 4, 5]

l 列表VS字符串：

1.   in运算符不仅能用于字符串中，还能用于列表中

2.   索引作用相同：

任何整数表达式都能被用作索引

如果indexout of range,则会获得IndexError

如果index为复数，则他从列表的结尾往回数

3.   列表可变，字符串不可变

4.   +运算符在列表中是合并两张列表，在字符串中是将两个字符串连起来

5.   *运算符在列表中时重复列表给定次数，如：

>>> [0]*4

[0, 0, 0, 0]

>>> [1, 2, 3, 4]*3

[1, 2, 3, 4, 1, 2, 3,4, 1, 2, 3, 4]

6.   列表切片与字符串切片一样：

e.g.：

>>> t = ['a', 'b', 'c', 'd', 'e','f']

>>> t[1:3]

['b', 'c']

>>> t[1:3] = [1,2]

>>> t[:]

['a', 1, 2, 'd', 'e','f']

l 字符串转化为字符列表：

1. 使用内建函数list（）（将字符串分成字母）

e.g.

>>> s = 'spam'

>>> t = list(s)

>>> print (t)

['s', 'p', 'a', 'm']

2.使用列表方法split（）（将字符串转化为单词列表）

e.g.

>>> s = 'I am happy today'

>>> t = s.split()

>>> print(t)

['I', 'am', 'happy','today']

使用delimiter这一可选实参指明哪一个字符被用于单词边界

e.g.（以-连字符作为例子）

>>> s = 'spam-spam-spam'

>>> delimiter = '-'

>>> s.split(delimiter)

['spam', 'spam', 'spam']

 

join和split相反，它是接受一个字符串的列表并把它连起来。join是一个字符串方法，你必须在分隔符上调用它并传递列表作为实参：

e.g.

>>> t = ['I', 'am', 'happy', 'today']

>>> delimiter = ' '

>>> delimiter.join(t)

'I am happy today'

l 字典：

字典是一般化的列表，列表的索引必须是int型，而字典的索引可以是任意类型

dict（）用于生成一个新的没有任何项的字典，它是内建函数，变量名要避免用它来命名

{}花括号表示一个空字典，向字典内增加项，使用[]方括号

[]方括号中的写的是键

字典中项的顺序不可预知

e.g.

>>> eng2sp = dict()

>>> eng2sp['one'] = 'uno'

>>> print(eng2sp)

{'one': 'uno'}   # {键：值}

>>> print(eng2sp['one'])  #打印指定的键对应的值

uno

>>> len(eng2sp)  #输出键的个数

1

>>> 'one' in eng2sp   #判断键是否在字典中

True

>>> 'uno' in eng2sp

False

>>> vals = eng2sp.values()   #使用values方法，让作为一个列表返回值

>>> 'uno' in vals

True

l 在Python解释器中读入文件：

e.g.

>>>fin open(‘words.txt)

>>>print(fin)

l 与C++对比：

1.   表示字符串：Python——用’’单引号

            C++——用“”双引号

Python中 “”双引号用于打印指令中

2.   赋值语句：Python——直接写出变量名并赋值即可

              C++——要先定义变量并声明其类型后才能赋值

3.   引入头文件（模块、库）的方式：

Python——import导入

C++——#include包含

4.   定义函数：

函数头的写法都是一样的，但函数体中的写法则有不同：

Python——从函数头的冒号开始，并且是缩进的

C++——包含在花括号内，函数头后面不需要冒号

5.   注释：

Python：只能单行注释，不能多行注释，采用#标记

C++：单行注释//和多行注释/**/均可

6.   要求同时满足两个条件时符号不一样：

Python——if0 < x and x < 10

C++——if(0< x && x < 10)

7.   输入输出流：

Python——print‘a is’, a

输出结果：a is (a的值)

C++——cout<<”ais ”<<a<<endl;

输出结果：a is (a的值)

8.   链式条件：

Python——用elif

C++——用elseif

9.   条件为假的情况：

Python——ifnot isinstance(n, int):

C++——if(isinstance(n,int) != true)

10. 表示句子结束：

Python—— ，

C++—— ；

11. 负索引：

Python——可以使用负索引，让其从字符串的结尾往后数。

           e.g.

           >>>fruit = ‘banana’

           >>>print (fruit[-1])

           a

           -1表示查找最后一个字符，-2表示查找倒数第二个

C++——无此查找方法

12. 变量自增：i++

Python——不合语法

C++——i++用于下标自增或变量自增等

13. 别名化：具有超过一个引用的对象有超过一个的名字则对象被别名化

Python——>>> a = [1,2,3]

>>>b = a

       C++—— int a = 2;

                  typedef a b;

   （如果别名化的对象是可变的，那么用一个别名引起的变化影响另一个别名：

e.g.

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

>>> b = a

>>> b is a

True

>>> b[0] = 5

>>> print (a)

[5, 2, 3]

）

l Python自带函数：

1.   Type函数：输出所输入值的类型

e.g.>>>type(‘Hello,World!’)

   <type’str’>

2.   raw_input函数：从键盘获得输入（Python2）

在Python3中被称为input

e.g.

>>>input =raw_input()

What are you waitingfor?

>>>print(input)

What are you waitingfor?

Raw_input()能够接收一个提示作为实参，提示用户输入

e.g.

>>>name =raw_input(‘What … is your name?\n’)

What … is your name?\n

King

>>>print(name)

King

3.   len(‘……’)：返回字符串中的字符数

e.g.

>>>fruit = ‘banana’

>>>len(fruit)

6

4.   .upper（）：接受一个字符串并返回一个新的，都是大写字母的字符串

e.g.

>>> word = 'banana'

>>> new_word = word.upper()

>>> print(new_word)

BANANA

点号的形式指出方法的名字upper以及应用该方法的字符串的名字word

5.   .find（）：查找的字符串方法

e.g.

>>> word = 'banana'

>>> index = word.find('a')

>>> print(index)

1

>>> index = word.find('na')

>>> print(index)

2

#还可以查找到子串

>>> word.find('na', 3)

4

#还可以接受从何处开始的索引作为第二个实参

>>> name = 'bob'

>>> name.find('b', 1 ,2)

-1

#表示从1和2的索引之间搜索