《Python基础教程》阅读笔记(1-2章)

这几天开始阅读《Python基础教程》,老规矩,还是边看边写笔记,不过因为之前已经看了《Head_First_Python》,因此,在看《Python基础教程》时,与《Head_First_Python》重复的知识点就不记了。

第一章:基础知识

基础运算

1
2
3
4
5
6
7
8
9
10
>>> 1//2		##整除
0
>>> 1/2
0.5
>>> 1+2
3
>>> 2**3 ##幂运算(乘方),2**3等价于pow(2,3)

8
>>>

一些函数运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
>>> math.floor(3.9)	##返回数的下舍整数
3
>>> math.ceil(2.1) ##返回数的上入证书
3
>>> abs(-5) ##返回数字的绝对值
5
>>> math.sqrt(4) ##返回数字的平方根
2.0
>>> math.sqrt(-1) ##普通sqrt只能处理浮点数
Traceback (most recent call last):
File "<pyshell#27>", line 1, in <module>
math.sqrt(-1)
ValueError: math domain error
>>> import cmath ##导入复数模块
>>> cmath.sqrt(-1) ##复数模块可以处理虚数
1j

>>> pow(2,3) ##求幂运算
8
>>> round(2.555555,3) ##根据给定的精度对数字进行四舍五入
2.556
>>> round(2.444444,4)
2.4444
>>> round(2.500000000) ##不指定精度的情况
2
>>> round(2.5000000001)
3

str:把值转换为合理形式的字符串
repr:创建一个字符串,以合法的Python表达式的形式来表示值

1
2
3
4
>>> print(repr("hello world"))
'hello world'
>>> print(str("hello world"))
hello world

原始字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> print('c:\nowhere') ##普通字符串碰到’\n’会换行
c:
owhere
>>> print(r'c:\nowhere')##原始字符串以r开头,不会把反斜线当作特殊字符,
c:\nowhere
>>> print(r'c:\nowhere\') ##原始字符串的最后一个字符(引号前面的那个)不能是反斜线

SyntaxError: EOL while scanning string literal
>>> print(r'c:\nowhere\\')##2个反斜线没问题
c:\nowhere\\
>>> print(r'c:\nowhere' '\\')##想在末尾输出1个反斜线,可以使用这种方法
c:\nowhere\
>>> u'hello world!' ##unicode字符串,在Python3.0中,所有字符串都是unicode字符串
'hello world!'

第二章:列表和元组

分片:包含第一个索引,不包含第二个索引,无论在左边还是右边开始取都遵循这个规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
>>> n = [1,2,3,4,5,6,7,8,9,10]
>>> n[-3:-1]
[8, 9]
>>> n[-3:0]
[]
>>> n[-3:] ##第二个索引为空,默认输出到末尾
[8, 9, 10]
>>> n[0:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> n[:3] ##第一个索引为空,默认从头开始输出
[1, 2, 3]
>>> n[:] ##两个索引都为空,输出整个序列
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> n[::2] ##设置步长为2,则每次跳过1个元素
[1, 3, 5, 7, 9]
>>> n[0:10:3] ##设置步长为3,则每次跳过2个元素
[1, 4, 7, 10]
>>> n[0:10:-1] ##步长可以为负数,此时从右向左提取元素,但此时索引也要进行对换(大的在前,小的在后)
[]
>>> n[10:0:-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2]
>>> n[10:0:-3]
[10, 7, 4]
>>> n[5:0:-1] ##此时取索引为5的,不取索引为0的(第一个索引为5)
[6, 5, 4, 3, 2]
>>> n[0:5:1] ##此时取索引为0的,不取索引为5的(第一个索引为0)
[1, 2, 3, 4, 5]
>>> n[5::-2] ##步长为负数,此处相当于n[5:0:-2],
[6, 4, 2]
>>> n[:5:-2] ##步长为负数,此处相当于n[10:5:-2],
[10, 8]

对于一个正数步长,Python会从序列的头部开始向右提取元素,直到最后一个元素;对于负数步长,则是从序列的尾部开始向左提取元素,直到第一个元素。

列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
>>> a = list('hello')	##根据字符串创建列表
>>> a
['h', 'e', 'l', 'l', 'o']
>>> ''.join(a) ##将由字符串组成的列表转换为字符串
'hello'

>>> name = ['aa','bb','cc','dd','ee','ff']
>>> del name[1] ##删除元素
>>> name
['aa', 'cc', 'dd', 'ee', 'ff']

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[1:] = list('ython') ##分片赋值,替换掉原来的元素
>>> name
['P', 'y', 't', 'h', 'o', 'n']

>>> number = [1,5]
>>> number[1:1] = [2,3,4] ##分片赋值,不替换原来元素的情况下插入新的元素
>>> number
[1, 2, 3, 4, 5]

>>> number[5:]=[6,7,8,9,10]
>>> number
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> number[0:10:2] = [11,12,13] #将步长改为2后,如果要进行替换必须替换范围内的所有数
Traceback (most recent call last):
File "<pyshell#129>", line 1, in <module>
number[0:10:2] = [11,12,13]
ValueError: attempt to assign sequence of size 3 to extended slice of size 5
>>> number[0:10:2] = [11,12,13,14,15]
>>> number
[11, 2, 12, 4, 13, 6, 14, 8, 15, 10]
>>> number[0:10:4] = [21,22,23] ##步长为4
>>> number
[21, 2, 12, 4, 22, 6, 14, 8, 23, 10]

列表方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
>>> test = ['aa','bb','vv','cc','bb']
>>> test.count('bb') ##计数
2
>>> test.index('bb') ##查找第一个匹配项的索引位置
1

>>> x = [1,2,3]
>>> x.reverse() ##反转
>>> x
[3, 2, 1]

>>> x = [1,3,5,2,4]
>>> y = x ##这样写,x和y会指向同一个列表
>>> y.sort()
>>> y
[1, 2, 3, 4, 5]
>>> x
[1, 2, 3, 4, 5]

>>> x = [1,3,5,2,4]
>>> y = x[:] ##这样写,y得到的是包含了x所有元素的分片
>>> y.sort()
>>> y
[1, 2, 3, 4, 5]
>>> x
[1, 3, 5, 2, 4]

>>> x = ['aaa','aa','aaaa','aaaaa','a']
>>> x.sort(key = len) ##指定排序方法为:按字符串长度排序
>>> x
['a', 'aa', 'aaa', 'aaaa', 'aaaaa']

>>> x = [4,3,6,5,1]
>>> x.sort(reverse = True) ##指定排序方式为:降序
>>> x
[6, 5, 4, 3, 1]

元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
>>> 1,2,3	##这样也算创建了一个元组,元组大多情况都是通过圆括号括起来
(1, 2, 3)
>>> 32
32
>>> 32,
(32,)
>>> 3*(40+2) ##普通运算
126
>>> 3*(40+2,) ##元组
(42, 42, 42)

>>> tuple([1,2,3]) ##tuple函数:以一个序列作为参数并把它转换为元组,如果参数就是元组,则返回原样
(1, 2, 3)
>>> tuple('abc') ##参数是字符串
('a', 'b', 'c')
>>> tuple((1,2,3)) ##参数是元组的情况
(1, 2, 3)

>>> x = 1,2,3 ##元组的分片跟列表的分片一样
>>> x[0:2]
(1, 2)
>>> x[0:3]
(1, 2, 3)
>>> x[1]
2

元组存在的意义:
1.元组可以在映射(和集合的成员)中当作键使用——而列表则不行
2.元组作为很多内建函数和方法的返回值存在,也就是说你必须对元组进行处理。只要不尝试修改元组,那么,“处理”元组在绝大多数情况下就是把它们当作列表来进行操作(除非需要使用一些元组没有的方法,例如index和count)

小结:
1.序列。序列是一种数据结构,它包含的元素都进行了编号(从0开始)。典型的序列包括列表、字符串和元组。其中,列表是可变的(可以进行修改),而元组和字符串是不可变的(一旦创建了就是固定的)。通过分片操作可以访问序列的一部分,其中分片需要两个索引号来指出分片的起始和结束位置。想要改变列表,则要对相应的位置进行赋值,或者使用赋值语句重写整个分片。
2.成员资格。in操作符可以检查一个值是否存在于序列(或者其他容器)中。对字符串使用in操作符是一个特例——它可以查找子字符串。
3.方法。一些内建类型(例如列表和字符串,元组则不在其中)具有很多有用的方法。这些方法有些像函数——不过它们与特定值联系得更密切。方法是面向对象编程的一个重要概念,稍后的第7章中会对其进行讨论。