python介绍

跨平台，面向对象，解释型语言

编译相关

1. pyc文件： .pyc 是一种二进制文件，是由 .py 文件经过编译后，生成一种byte code文件。 .py 文件变成 .pyc 文件后，加载的速度有所提高，而且 .pyc 是一种跨平台的字节码，是由python的虚拟机来执行的，这个类似于JAVA或者.NET的虚拟机的概念。 .pyc 的内容是跟python的版本相关的，不同版本编译后的 .pyc 文件是不同的，2.5编译的 .pyc 文件对于2.4版本的python是无法执行的。可用于隐藏Python源代码和提高运行速度
2. pyw文件: Python源文件，常用于图形界面程序文件
3. pyo文件： .pyo 是优化编译后的字节码文件 python -O 源文件 即可将源程序编译为 .pyo 文件。
4. pyd文件： 由其他语言编写并编译的二进制文件, 常用于实现接口插件或Python动态链接库

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 编译成pyc文件
# ------------------------------------------------------
python -m py_compile $filename    # 其中，$filename是要编译的python源码文件名


2. 编译成pyo文件
# -------------------------------------------------------
python -O -m py_compile $filename
# 或者
python -OO -m py_compile $filename

# 其中， + -O选项表示优化产生的字节码，优化程度由PYTHONOPTIMIZE(environment)的值来决定。 + -OO选项表示在-O优化的基础上移除所有的doc-strings(文档文本)。

对于模块文件，第一次被导入时将被编译成字节码的形式，并在以后再次导入时优先使用“.pyc”文件，以提高模块的加载和运行速度 对于非模块文件，直接执行时并不生成“.pyc”文件，可以选择手动编译

pip命令

对象

1. python中一切都是对象

• 内置对象可直接使用，数字，字符串，列表
• 非内置对象需要导入模块

IDLE交互模式

1. 在 IDLE 交互模式中浏览上一条语句的快捷键是 ALT + P
2. IDLE下一条 Alt + n
3. 在 IDLE 交互模式中，复合语句(例如for循环等需要按两次回车)

强弱类型&动态静态

• 强类型：某一个变量被定义类型，如果不经强制转换，那么它永远是该数据类型
• 弱类型：某一个变量被定义类型，该变量可以根据环境变化自动进行转换，不需要经过现行强制转换
• 动态类型：在运行期间才去做数据类型检查的语言，，即写程序时不需要指明变量类型，到程序运行为变量赋值时变量的类型才得以确认
• 静态类型：数据类型在编译期间检查，也就是说在写程序时要声明所有变量的数据类型

python运算符

算术运算符

$3<5>2 \Leftrightarrow 3<5 \ and \ 5>2$

python不支持++和--自增自减运算符，起到的作用仅是改变正负

1
2

+-2
>> -2

逻辑运算符

具有惰性求值特点，只计算必须计算的表达式

1
2
3
4
5
6

# 由于是 or 运算，只要有一者为真，那么结果为真，因此到3时就可以确定最终结果了(python认为非0值均为True)
>>> 3 or 5
3
## 由于是and运算，只要一者为假，那么最终结果为假
>>> 0 and 2
0

位运算符

成员运算符

身份成员运算符

同一个对象：具有相同的id

集合操作符

python 6种数据类型

map、filter、enumerate、zip具有的特点：1. 惰性求值 2. 访问过的元素不可再次访问，简单理解就是迭代器已经到了end()的位置

1
2
3
4
5
6
7
8
9

x = [1, 2, 3]

y = filter(lambda x : x + 1, x)

print(list(y))
print(list(y))
结果：
[1, 2, 3]
[]

Number（数字）

复数

1
2
3
4
5

>>> c = 3 + 4j
>>> c.real # 实部
3.0
>>> c.imag # 虚部
4.0

在数字中间位置使用单个下划线作为分隔来提高数字的可读性，不影响数字的值，仅是方便读

1
2

>>> 1_2_3.4_5
123.45

String（字符串)

1、反斜杠可以用来转义，使用r意思是将那些特殊的转义字符看为普通字符，例如’\n’代表换行，但是r’\n’仅代表两个字符，一个’'，一个’n’，当我们希望字符串中的’'仅是一个’'字符而非转义符号时，一种方法是’\’，另一种就是字符串前面加上’r' 2、字符串可以用+运算符连接在一起，用*运算符重复。 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。 4、Python中的字符串不能改变，因此切片不支持字符串修改

常用转义字符

List（列表）[]

1、List写在方括号之间，元素用逗号隔开。 2、和字符串一样，list可以被索引和切片。 3、List可以使用+操作符进行拼接。 4、List中的元素是可以改变的。 5、列表支持双向索引(最后一个元素索引值为-1) 6、一个列表中的数据类型可以各不相同

remove(x)：If the element doesn’t exist, it throws ValueError: list.remove(x): x not in list exception.

+在进行列表拼接时，并非把一个列表中的元素加入到另一个列表中，而是重新开辟一个列表，将两部分列表中的元素复制过去，较为耗时 append()和extend()都是原地操作，前者是增加一个元素，后者可以将可迭代对象逐个放入 +=类似extend()，是原地操作，但是+并不是原地操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

x = [1, 2, 3]
print(x, id(x))

x += [4]
print(x, id(x))

x = x + [5]
print(x, id(x))
结果：
[1, 2, 3] 2918749822344
[1, 2, 3, 4] 2918749822344
[1, 2, 3, 4, 5] 2918749822216

insert()虽然会移动元素，但是仍是原地操作

1
2
3
4
5
6
7
8

x = [1, 2, 3]
print(x, id(x))

x.insert(1, 2)
print(x, id(x))
结果：
[1, 2, 3] 2785177427336
[1, 2, 2, 3] 2785177427336

乘法增加列表元素对象,对原列表内容的重复，且复制出来的不是值，而是引用，修改任何一个其它的也会改变

1
2
3
4
5
6
7

>>> x = [[1]]
>>> x *= 3
>>> x
[[1], [1], [1]]
>>> x[0][0] = 2
>>> x
[[2], [2], [2]]

列表推导式得到的重复内容，仅是值，而非引用，改变其中一个，其它的并不会改变

1
2
3
4

>>> x = [[] for i in range(3)]
>>> x[0].append(1)
>>> x
[[1], [], []]

Tuple（元组）()

1、与字符串一样，元组的元素不能修改。 2、元组也可以被索引和切片，方法一样。 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。

1 2	tup1 = () # 空元组 tup2 = (20,) # 一个元素，需要在元素后添加逗号

4、元组也可以使用+操作符进行拼接。 5.元组支持双向索引(最后一个元素索引值为-1)

连续赋值可以得到一个元组

1
2
3

>>> x = 3, 4
>>> x
(3, 4)

del 不能删除元组中单个元素，但是可以直接删除整个元组

元组虽然为不可变序列，但是其中确可以放入可变序列。并且其中的可变序列还可以进行修改。但放入可变序列的元组就不能再放进set或者作为dist的键了 元组其实就是一种特殊的列表，什么都可以放，只是不能修改

1
2
3
4

>>> a = [1, 2]
>>> b = (1, a)
>>> b
(1, [1, 2])

Set（集合）{}

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }

集合中只能保存不可变序列，例如字符串，元组，原因与Why Lists Can’t Be Dictionary Keys类似

当两个集合中存储的数据相同时，两个集合相等 注：

1. 是两个集合相等，不是两个对象相同，是两个对象，但是它们的内容相等
2. 集合是无序容器，所以判断是否相等时不考虑数据顺序，仅考虑含有的数字是不是一样的

集合的大小关系 <=> 包含关系

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

x = {1, 2, 3}
y = {1, 2, 5}
z = {1, 2, 3, 4, 5}

print(x < y) # x不是y的真子集
print(y < z) # y是z的真子集
print(x < z) # x是z的真子集

结果：
False
True
True

无法删除集合中指定位置的元素，只能删除特定值的元素 del不能删除集合中的元素，但是可以删除整个集合

Dictionary（字典）{}

1、字典是一种映射类型，它的元素是键值对。 2、字典的关键字必须为不可变类型，且不能重复，即数字，字符串，元组 3、创建空字典使用 { }

sorted()直接对字典排序，实际是对字典的键进行排序，因为字典属于无序容器，顺序对它来说并没有意义

Why Lists Can’t Be Dictionary Keys

如果需要一个可以记住元素插入顺序的字典，可以使用 collections.OrderedDict

输出字典，默认输出键

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

x = {
    "name":"ghy", 
    "age": 20,
    "sex":"male"
}

for i in x:
    print(i)

结果：
name
age
sex

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）； 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合） 有序序列：列表，字符串，元组 无序序列：字典，集合

python类型转换

print语句

print(*objects, sep=' ', end='\n', file=sys.stdout)

objects –表示输出的对象。输出多个对象时，需要用 , （逗号）分隔 sep – 指定输出对象之间的间隔符 end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符 file – 要写入的文件对象

格式化输出：

1
2

>>> print("the length of (%s) is %d" %('runoob',len('runoob')))
the length of (runoob) is 6

$abs(a + bj) = \sqrt{a^2 + b^2}$

内存管理机制

Python 采用的是基于值的自动内存管理方式，相同的值在内存中只有一份

这个问题比较复杂，因为运行结果要分为在交互模式下和在程序中两种情况，上面的说法也没错，但是说的非常笼统 首先，Python启动时，会对[-5, 256]区间的整数进行缓存

交互模式下

1. 浮点数的id不同，不过连续赋值有点奇怪

1
2
3
4
5
6
7
8

>>> x = 3.4
>>> y = 3.4
>>> id(x) == id(y)
False

>>> x, y = 3.4, 3.4
>>> id(x) == id(y)
True

2. 列表内部，缓存区以内相同数的id相等，在缓存区间以外，相同大整数的id相等，小数(例如负数)的id不等

1
2
3
4
5
6
7
8

>>> x = [30000, 30000]
>>> id(x[0]) == id(x[1])
True

>>> x = [-111, -11]
>>> x = [-111, -111]
>>> id(x[0]) == id(x[1])
False

3. 不同列表之间，缓存区以内相同数值id相等， 在缓存区间以外相同数值的id不等

1
2
3
4

>>> x = [300, 300]
>>> y = [300, 300]
>>> id(x[0]) == id(y[0])
False

4. 相同列表，相同短字符串的id相等，相同长字符串的id不等

1
2
3
4
5
6
7

>>> x = ['abc', 'abc']
>>> id(x[0]) == id(x[1])
True

>>> x = ['abc' * 50, 'abc' * 50]
>>> id(x[0]) == id(x[1])
False

程序中

1. 浮点数的id相等

1
2
3
4
5
6
7
8

x = 3.4
y = 3.4
print(id(x) == id(y))
True

x, y = 3.4, 3.4
print(id(x) == id(y))
True

2. 列表内部执行结果与交互模式相同
3. 不同列表之间，缓存区以外相同大整数id相等，小数(例如负数)id不等

1
2
3
4
5
6
7
8
9

x = [300, 300]
y = [300, 300]
print(id(x[0]) == id(y[0]))
True

x = [-111, -111]
y = [-111, -111]
print(id(x[0]) == id(y[0]))
False

4. 字符串同交互模式

这句话并不严密

对象存储的是值的内存地址或者引用，为对象修改值时，并不是真的直接修改变量的值，而是使变量指向新的值

库

python标准库

无论时标准库还是第三方库使用时都需要import 但是在使用标准库中那68个内置函数时是不需要导入库的

注释

1. 单行注释 ：#
2. 多行注释：三个单引号 ''' 或者三个双引号 """

注：这并不代表着三个单引号或双引号中的内容就是注释，它们也可用来定义字符串(单行字符串或多行字符串)

python关键字

id不是关键字，可以作为变量名，但不建议 python变量名是区分大小写的

del

1. 删除整个列表 del list
2. 删除列表中某个元素 del list[0]

切片

浅复制是指复制出的为原内容的引用，存储在同一内存区域，copy()是指对列表中的每一个元素执行浅拷贝，例如列表中嵌套列表，copy出的新列表中的嵌套列表为原来的拷贝 深复制是指复制出的为原内容的拷贝，存储在不同内存区域，deepcopy()是指对列表中的每一个元素执行深拷贝

切片返回的为浅复制，因此可以通过切片直接修改原有序列中那些容器，改变切片中的数值原有容器对应数值并不会改变 但是切片得到和原列表并不是一个对象，两者的id并不相等

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

>>> x = [1, [2, 3]]
>>> y = x[:]
>>> id(x)
2491381320136
>>> id(y)
2491381319048
>>> x
[1, [2, 3]]
>>> y
[1, [2, 3]]

>>> y[0] = 4
>>> x
[1, [2, 3]]
>>> y
[4, [2, 3]]

>>> y[1][0] = 5
>>> x
[1, [5, 3]]
>>> y
[4, [5, 3]]

但是直接赋值得到的和原列表是一个对象，修改其中一个中的任何元素，另一个对应元素也会改变(相当于一个引用)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

>>> x = [1, [2, 3]]
>>> y = x

>>> id(x)
2491381319240
>>> id(y)
2491381319240

>>> y[0] = 2
>>> x
[2, [2, 3]]
>>> y
[2, [2, 3]]

切片非常神奇的地方在于，切片的结果和原对象不是同一个对象，但是却可以直接采用切片对原对象进行修改

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

x = [1,2,1,1,2]

print(x, id(x));
print(x[:], id(x[:]))

x[len(x):] = [3]
print(x)
结果：
[1, 2, 1, 1, 2] 2168963063176
[1, 2, 1, 1, 2] 2168963063048
[1, 2, 1, 1, 2, 3]

+=

python对[-5, 256]内的数字在内存中进行了缓存，所以当多个对象(例如下面的x和y)都等于范围内一个数字时，实际代表的对象就只是一个

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> x = 3
>>> id(x)
1382786208
>>> id(3)
1382786208

>>> x += 3
>>> id(x)
1382786304
>>> id(6)
1382786304

序列解包

解包：把容器内的元素一个个抽离出来的过程

在定义函数时，某个参数名字前面带有2个*符号表示可变长度参数，可以接收任意多个关键参数并将其存放于一个字典之中

排序

x.sort():原地排序，默认升序，```reverse = True````表示降序

sorted():非原地排序，返回排序后的列表，默认升序

reversed()：对列表元素逆序排列返回迭代对象，通过list()可生成列表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def size(x):
    return x + 5
    
x = [3, 4, 1, 2]

y = sorted(x, key = lambda x : x, reverse = False)
print(y)

y = sorted(x, key = size, reverse = True)
print(y)

random模块中常用方法

列表推导式和生成器推导式

列表推导式使用[]生成, 生成器推导式使用()生成 列表推导式的返回值是一个列表，生成器推导式的返回值是一个生成器对象，只能一次遍历 生成器推导式使用()生成，用一个生成一个，在我们不对它进行操作之前，它什么都不会做

x 如果是生成器推导式生成的，list(x)一次使得迭代器遍历结束，因此后一次list(x)的结果就为空了 准确的的理解是，生成器推导式并不会把结果计算出来放入到内存中，而是用一个生成一个，因此只能遍历一次

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

>>> x = (3 for i in range(3))
>>> x
<generator object <genexpr> at 0x0000025F8A7B3A40>

>>> list(x)
[3, 3, 3]

>>> list(x)
[]

g = (i for i in range(3))

print(g.__next__()) # 0
print(next(g)) # 1
结果：
0
1

while和for循环的else

只要循环不是由break结束的，就会执行else中的语句

1
2
3
4

while xxx:
    xxx
else:
    xxx

1
2
3
4

for xxx:
    xxx
else:
    xxx

条件表达式

在条件表达式中不允许使用赋值运算符“=”，会提示语法错误

1
2
3

>>> if a = 3:
	
SyntaxError: invalid syntax

global关键字

内部函数有引用外部函数的同名变量或者全局变量，并且对这个变量有修改时，Python 会认为它是一个局部变量，如果函数中并没有 x 的定义，则会报错local variable 'xxx' referenced before assignment

pass语句

pass 不做任何事情，一般用做占位语句

函数

如果函数中没有 return 语句，则默认返回空值 None

python内置函数

内置函数不需要导入对应模块即可使用

callable()

callable() 函数用于检查一个对象是否是可调用的 对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True

isinstance()

判断一个对象是否是一个已知的类型

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

map()

map() 函数会根据提供的函数对指定序列做映射 map(function, iterable, ...) 可迭代对象iterable中的每一个元素调用 function 函数，对iterable进行映射，返回映射结果map的迭代器

filter()

filter(function, iterable) filter() 函数会把iterable中那些使function()返回值为True的元素留下，返回filter迭代器

map() 和 filter()区别：

1
2
3
4
5
6
7
8
9

a = [1, 2]

b = filter(lambda x : x > 1, a)
print(list(b))
>>> [2]

c = map(lambda x : x > 1, a)
print(list(c))
>>> [False, True]

zip()

将可迭代的对象作为参数，将对象中对应位置的元素按照下标打包成一个个元组，返回一个zip迭代器，通过list()等转化为其它容器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = zip(a, b)
>>> list(c)
[(1, 4), (2, 5), (3, 6)]

# 不是对应位置的结果
a = [1, 2, 3]
b = ['a', 'b']
c = zip(a, b)
print(list(c))
结果：[(1, 'a'), (2, 'b')]

enumerate()

enumerate(iterable, start=0) Parameters: Iterable: any object that supports iteration Start: the index value from which the counter is to be started, by default it is 0

1
2
3
4
5
6

>>> s = "abc"
>>> o = enumerate(s, 2)
>>> o
<enumerate object at 0x0000024411E5A240>
>>> list(o)
[(2, 'a'), (3, 'b'), (4, 'c')]

eval()

函数功能更：执行一个字符串表达式，并返回表达式的值

1
2

>>> eval('2 + 2')
4

join()

用于将序列中的元素以指定的字符连接生成一个新的字符串

1
2
3
4

>>> str = '-'
>>> seq = ['a', 'b', 'c']
>>> str.join(seq)
'a-b-c'

len()

python 3.x 在统计字符串长度时，无论是数字，英文字母还是汉字，计数均按照一个字符处理

reduce()

该函数不是内置函数 代码实现出处 Geeksforgeeks讲解

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# reduce()代码实现
def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        value = next(it) # 返回第一个值，详细说明查一下next()，使用一次next，迭代器本身会自增
    else:
        value = initializer
    for element in it:
        value = function(value, element)
    return value

# 当缺省initializer时，next(it)会使迭代器会后移一位，因此for循环时会从第2个元素开始

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# python code to demonstrate working of reduce()

# importing functools for reduce()
import functools

# initializing list
lis = [1, 3, 5, 6, 2, ]

# using reduce to compute sum of list
print("The sum of the list elements is : ", end="")
print(functools.reduce(lambda a, b: a+b, lis))

# using reduce to compute maximum element from list
print("The maximum element of the list is : ", end="")
print(functools.reduce(lambda a, b: a if a > b else b, lis))

input()

input()函数的返回结果都是字符串,需要将其转换为相应的类型再处理

all() 和 any()

all()函数检查序列对象中是否所有元素均等价于True any()函数检查序列对象中是否存在元素等价于True

1
2
3
4
5
6
7

x = [1, 1, 0]

print(all(x))
print(any(x))
结果：
False
True

sum()

sum(iterable, start) 求和，如果计算的不是数值，需要指定start。这并不难理解，数值类型不指定可以认定为0，其他类型很难说

globals() 和 locals()

globals()：返回当前作用域内所有全局变量和值的字典 locals()：返回当前作用域内所有局部变量和值的字典

字符串

ASCII码：1个字节 GB2312、GBK和CP936：2个字节表示中文 UTF-8：3个字节表示常见汉字 Python 3.x默认使用UTF-8编码，数字、英文字母，汉字，在统计字符串长度时都按一个字符对待和处理

1
2
3
4
5
6

x = "高"
y = 'a'
print(len(x), len(y))

结果：
1 1

字符串使用r意思是将那些特殊的转义字符看为普通字符，例如’\n’代表换行，但是r’\n’仅代表两个字符，一个’'，一个’n’，当我们希望字符串中的’'仅是一个’'字符而非转义符号时，一种方法是’\’，另一种就是字符串前面加上’r’

1
2
3
4
5
6
7

>>> s = '\n'
>>> print(s)


>>> s = r'\n'
>>> print(s)
\n

string中定义的相关常量

1
2
3
4
5
6
7
8
9

whitespace = ' \t\n\r\v\f'
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_letters = ascii_lowercase + ascii_uppercase
digits = '0123456789'
hexdigits = digits + 'abcdef' + 'ABCDEF'
octdigits = '01234567'
punctuation = r"""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""
printable = digits + ascii_letters + punctuation + whitespace

字符串格式化

• %操作符：

1
2
3

>>> str = '0x7f'
>>> print('I am %s'%str)
I am 0x7f

• format()方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

>>> print("I am {}".format("0x7f"))
I am 0x7f

>>> print("{} {} {}".format("I", "am", "0x7F"))
I am 0x7F

>>> print("{2} {1} {0}".format('c', 'b', 'a'))
a b c

# 与使用%操作符等价的format格式，例如%s <=> {参数位置:s}，同样可以进行宽度，精度控制
>>> print("I am {0:s}".format("0x7F"))
I am 0x7F

# 使用‘#’可以添加上不同进制数前面的标志
>>> print('{0:d}, {0:b}, {0:x}, {0:o}'.format(65))
65, 1000001, 41, 101
>>> print('{0:#d}, {0:#b}, {0:#x}, {0:#o}'.format(65))
65, 0b1000001, 0x41, 0o101

# 控制精度
>>> print("{0:.2f}".format(11.12345))
11.12

• f-strings方式

1
2
3
4
5

weight = 8
height = 8
print(f"weight:{weight}, height:{height}, weight*height:{weight*height}")
结果：
weight:8, height:8, weight*height:64

find() 和 rfind()

str.find(str, beg=0, end=len(string))

• str：待查询字符串
• beg：规定开始位置下标
• end: 规定结束位置下标的后一位(即左闭右开区间)

find()返回待查询字符串作为子串在当前字符串中第一次出现的位置，如果没有匹配项则返回 -1 rfind()返回待查询字符串作为子串在当前字符串中最后一次出现的位置，如果没有匹配项则返回 -1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

>>> n = 6
>>> x = bin(n)
>>> x
'0b110'
>>> x.rfind('1')
3

>>> str = "abc"
>>> str.find('b', 0, 1)
-1
>>> str.find('b', 0, 2)
1

startswith()

检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False str.startswith(str, beg=0,end=len(string))

• str：待查询字符串
• beg：规定开始位置下标
• end: 规定结束位置下标的后一位(即左闭右开区间)

1
2
3
4
5
6
7
8

>>> 'abc'.startswith('a', 1)
False
>>> 'abc'.startswith('a', 0)
True
>>> 'abcd'.startswith('bc', 1, 2)
False
>>> 'abcd'.startswith('bc', 1, 3)
True

index() 和 rindex()

index()：返回一个字符串在另一个字符串中作为子串第一次出现的位置，不存在则抛出异常 rindex()：返回一个字符串在另一个字符串中作为子串最后一次出现的位置，不存在则抛出异常

1
2
3
4
5

>>> str = "abb,a,s"
>>> str.index('a')
0
>>> str.rindex('a')
4

count()

返回一个字符串作为子串在当前字符串中出现的次数

split()

str.split(str="", num=string.count(str)).

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num – 分割次数。分割num次生成num+1个子串。默认为 -1, 即分隔所有。

当不指定分隔符时，采取默认的空白字符(上方提到的)，切分结果中的空字符会被自动删除 指定分隔符时，空字符不会被删除

partition()

根据指定的分隔符将字符串进行分割，返回一个3元的元组

• 如果分割符在待分割字符串中，那么第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
• 如果分隔符不在待分割字符串中，那么第一个为原字符串，第二个和第三个为空字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

str = 'abc'

>>> str.partition('a')
('', 'a', 'bc')

>>> str.partition('b')
('a', 'b', 'c')

>>> str.partition('c')
('ab', 'c', '')

>>> str.partition('d')
('abc', '', '')

upper()， lower()， swapcase()

upper(): 小写字母转大写字母 lower(): 大写字母转小写字母 swapcase(): 将大小写字母进行颠倒，小写->大写，大写->小写

1
2
3

>>> str = "i AM 0x7f"
>>> str.swapcase()
'I am 0X7F'

ljust() 和 rjust()

ljust(): 返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串 rjust():返回一个原字符串右对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串

1
2
3
4
5
6

>>> str = '!abc'
>>> str.ljust(6, '*')
'!abc**'

>>> str.rjust(6, '*')
'**!abc'

maketrans() 和 translate()

maketrans(): 创建字符映射的转换表。第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同，为一一对应的关系 translate(): 根据maketrans()生成的转换表，将字符串中的响应字符进行转换

1
2
3
4

# 这里如果不通过字符串调用maketrans，就需要导入相应模块，哪个字符串调用都无所谓
>>> table = ''.maketrans('abcw', 'xyzc')
>>> 'Hellow world'.translate(table)
'Helloc corld'

replace()

string.replace(old, new, count) 不要求全字匹配，子串即可

strip(), lstrip() 和 rstrip()

3种方法提供的字符串可以是一个字符，或者多个字符，匹配时不是按照整个字符串匹配的，而是一个个匹配的

strip():移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。方法只能删除开头或是结尾的字符，不能删除中间部分的字符

1
2

>>> 'aaasdfaaas'.strip("as")
'df'

lstrip(): 截掉字符串左边的空格或指定字符

1
2

>>> 'aaasdfaaas'.lstrip('as')
'dfaaas'

rstrip(): 删除 string 字符串末尾的指定字符（默认为空格）

1
2

>>> 'aaasdfaaas'.rstrip("as")
'aaasdf'

isalnum(), isalpha() 和 isdigit()

isalnum(): 检测字符串是否由字母和数字组成 返回值：

• True：如果所有的字符均是字母或数字
• False：如果一个或多个字符不是字母和数字 isalpha(): 检测字符串是否只由字母组成 isdigit(): 检测字符串是否只由数字组成

encode() 和 decode()

默认均为utf-8编码 编码：str.encode(encoding='UTF-8',errors='strict') 解码：str.decode(encoding='UTF-8',errors='strict')

compress() 和 decompress()

zlib.compress(): 字符串压缩 zlib.decompress(): 字符串解压缩

正则表达式re

re.match()

从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none re.match(pattern, string, flags=0)

1
2
3
4
5
6

# 在起始位置匹配
>>> print(re.match('www', 'www.runoob.com').span())
(0, 3)
# 不在起始位置匹配
>>> print(re.match('com', 'www.runoob.com'))
None

re.search()

扫描整个字符串并返回第一个成功的匹配，未找到则返回None re.search(pattern, string, flags=0)

1
2
3
4
5
6

# 在起始位置匹配
>>> print(re.search('www', 'www.runoob.com').span())
(0, 3)
# 不在起始位置匹配
print(re.search('com', 'www.runoob.com').span())
(11, 14)

re.findall() 与 re.search()的差异

1
2
3
4
5
6
7

>>> re.search(r'\w*?(?P<f>\b\w+\b)\s+(?P=f)\w*?', 'Beautiful is is better than ugly.').group(0)
'is is'
>>> re.search(r'\w*?(?P<f>\b\w+\b)\s+(?P=f)\w*?', 'Beautiful is is better than ugly.').group(1)
'is'

>>> re.findall(r'\w*?(?P<f>\b\w+\b)\s+(?P=f)\w*?', 'Beautiful is is better than ugly.')
['is']

search任何时候都将整个正则视为一个分组，group(0)，这也是search的默认返回结果，其他括号也都算一个分组可通过group(index)方法来获取对应分组的匹配结果；

findall在没有括号时将整个正则视为一个分组，有括号时只认括号内的分组，仅仅匹配分组里面的内容，然后返回这个组的列表; 如果有多个分组，那就把每一个分组看成一个单位，组合为一个元组，然后返回一个含有多个元组的列表。如果想要在使用findall()时将整个正则表达式视为分组，把小括号仅作为一个整体来匹配，可以采用非捕获分组

参考资料

re.sub()

re.sub(pattern, repl, string, count=0, flags=0) 替换字符串中的匹配项，如果匹配项没有找到，则不加改变地返回 string

pattern : 正则中的模式字符串。 repl : 替换的字符串，也可为一个函数。 string : 要被查找替换的原始字符串。 count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

1
2
3
4
5
6

>>> re.sub('\d', '1', 'a12345bbbb67c890d0e')
'a11111bbbb11c111d1e'

# 注意默认采用的是贪婪模式，因此会尽可能多的进行匹配，所以连着的数字就被匹配为1个元素了
>>> re.sub('\d+', '1', 'a12345bbbb67c890d0e')
'a1bbbb1c1d1e'

re.compile()

re.compile(pattern, flags=0) 编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

• pattern : 一个字符串形式的正则表达式
• flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：

1. re.I(IGNORECASE) 忽略大小写
2. re.L(LOCALE) 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
3. re.M(MULTILINE) 多行模式
4. re.S(DOTALL) 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
5. re.U(UNICODE) 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
6. re.X(VERBOSE) 为了增加可读性，忽略空格和 # 后面的注释

1
2
3
4

>>> pattern = re.compile('\d+')
>>> m = pattern.match('123abc')
>>> m
<_sre.SRE_Match object; span=(0, 3), match='123'>

模块

模块的作用

1. 提高代码可维护性
2. 提高代码可重用性

重新导入一个模块，使用imp模块的reload函数 在导入模块时，会优先导入相应的pyc文件,如果相应的pyc文件与py文件时间不相符，则导入py文件并重新编译该模块

导入模块时的文件搜索顺序

在 import 导入 module 时，会遵循以下的优先级进行搜索

1. 当前文件夹
2. sys.path变量指定的文件夹
3. 优先导入pyc文件

我们可以通过如下的方式来查看目前的 module 的搜索路径以及某个具体的 module 所在的路径

1
2
3
4
5
6
7
8

>>> from sys import path

>>> path
['', '/home/user', '/home/user/miniconda3/lib/python39.zip', '/home/user/miniconda3/lib/python3.9', '/home/user/miniconda3/lib/python3.9/lib-dynload', '/home/user/miniconda3/lib/python3.9/site-packages']

>>> import pip
>>> pip
<module 'pip' from '/home/user/miniconda3/lib/python3.9/site-packages/pip/__init__.py'>

有两种方式修改导入 module 的搜索路径 ¹

1. 通过 sys.path.append()
2. 通过 PYTHONPATH environment variable

在使用这两种方式指定搜索路径后，即可直接通过 import 引入指定目录下的 module

代码规范性

检查工具：pep8工具，flake8，pylint

包

包是一个包含__init__.py文件的文件夹 打包工具：py2exe，pyinstaller，cx_Freeze

函数的设计与使用

1. 参数传递传的是引用而非值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def add(x):
    a = x
    print(id(a))
    a += 1
    print(id(a))

y = 5
print(id(y))
add(y)

结果：
1409066208
1409066208
1409066240

如果实参为序列对象，在函数内部采用序列对象原地操作的方法就可以实现通过形参修改实参了 2. 参数类型：普通参数，默认值参数，关键参数，可变长度参数

• 默认值参数必须出现在函数参数列表的最右端，任何一个默认值参数右边不能有非默认值参数
• 可变长度参数 *parameter用来接收多个位置实参并将其放在元组中 parameter接收多个关键参数**并存放到字典中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def fun1(*x):
    print(x)

def fun2(**x):
    print(x)

fun1(1, 2, 3)
fun2(a = 1, b = 2, c = 3)

结果：
(1, 2, 3)
{'a': 1, 'b': 2, 'c': 3}

3. 对字典进行两次解包后参数传递 <=> 关键参数传递

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def fun(a, b):
    print(a, b)

dic = {'a':1, 'b':2}
fun(**dic)

fun(a = 1, b = 2)

结果：
1 2
1 2

4.当函数执行结束后，局部变量自动删除 5.nonlocal：闭包作用域变量，nonlocal声明的变量会引用距离最近的非全局作用域的变量，用于内部函数中使用外部函数的局部变量 7. 如何理解yield创建生成器对象 6. 修饰器（decorator，包装器），本质上也是一个函数，只不过这个函数接收其他函数作为参数并对其进行一定的改造之后返回新函数。(函数即对象)

面向对象程序设计

1. OOP支持代码复用 和 设计复用
2. 基本原则：计算机程序由多个能够起到子程序作用的单元或对象组合而成
3. 基本功能：封装，继承，多态，对基类方法的重写
4. 类包含：数据成员(用变量表示的对象属性)，成员方法(用函数表示的对象行为)
5. 类名的首字母一般要大写
6. Python 类中属性和方法所在的位置是任意的
7. 类的所有实例方法都必须至少有一个名为self的参数，且必须是方法的第一个形参
8. 混入机制(mixin)：可以动态地为自定义类和对象增加或删除成员
9. 实例对象仅可以访问类变量，无法修改，修改实际是在定义新的实例变量; 实例变量和类变量重名时， 实例对象会首选实例变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class T :
    val = 5

t = T()
print(t.val)

t.val = 3
print(t.val)

t2 = T()
T.val = 4
print(t.val)
print(t2.val)

结果：
5
3
3
4

11.如果数据成员为容器类对象，则通过实例修改和通过类修改，所有实例均会发生改变

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class T :
    val = [0]

t = T()
t2 = T()
print(t.val)
print(t2.val)

t.val[0] = 1
print(t.val)
print(t2.val)

T.val[0] = 2
print(t.val)
print(t2.val)

结果：
[0]
[0]
[1]
[1]
[2]
[2]

12.函数和方法的区别在于方法具有第一个隐式参数self 13. _xxx：受保护成员，不能用’from module import *‘导入； __xxx__：系统定义的特殊成员； __xxx：私有成员(>=2个‘_’开头的数据成员)，只有类对象自己能访问，子类对象不能直接访问到这个成员，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。 14.类中方法：公有方法，私有方法，静态方法(@staticmethod)，类方法(@classmethod) 静态方法和类方法只能访问类的成员 15.@property，保护类的封装特性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class T :
    def __init__(self, val):
        self.__val = val

    @property
    def getVal(self) :
        return self.__val

t = T(5)
print(t.getVal) # @property修饰，不需要加()

结果：5

16.特殊方法 17. 多态的定义：基类的同一个方法在不同派生类对象中具有不同的表现和行为 多态的前提条件：1.继承：发生在子类和父类之间 2.重写：子类重写父类方法

简答题

简单解释 Python 基于值的自动内存管理方式

在 Python 中可以为不同变量赋值为相同值，这个值在内存中只有一份，多个变量指向同一个内存地址； Python 具有自动内存管理功能，会自动跟踪内存中所有的值，对于没有任何变量指向的值，Python 自动将其删除。

Python 运算符&的两种功能

1. 数字位运算
2. 集合交集运算

Python 中导入模块中的对象的几种方式

1. import 模块名 [as 别名]
2. from 模块名 import 对象名 [as 别名]
3. from 模块名 import *

1与3的区别在于，对于模块内的方法名，1需要以模块名为前导，3则可以直接使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

>>> sqrt(4.0)
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    sqrt(4.0)
NameError: name 'sqrt' is not defined

>>> import math
>>> sqrt(4.0)
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    sqrt(4.0)
NameError: name 'sqrt' is not defined
>>> math.sqrt(4.0)
2.0

>>> from math import *
>>> sqrt(4.0)
2.0

解释 Python 脚本程序的“name”变量及其作用

每个 Python 脚本在运行时都有一个“name”属性。 如果脚本作为模块被导入，则其“name”属性的值被自动设置为模块名； 如果脚本独立运行，则其“name”属性值被自动设置为“main”。 利用“name”属性即可控制 Python 程序的运行方式。

为什么应尽量从列表的尾部进行元素的增加与删除操作

当列表增加或删除元素时，列表对象自动进行内存扩展或收缩，从而保证元素之间没有缝隙， 但这涉及到列表元素的移动，效率较低，应尽量从列表尾部进行元素的增加与删除操作以提高处理速度。

析逻辑运算符“or”的短路求值特性

假设有表达式“表达式 1 or 表达式 2”， 如果表达式 1 的值等价于 True，那么无论表达式 2 的值是什么，整个表达式的值总是等价于 True。 因此，不需要再计算表达式 2 的值。

简单解释 Python 中短字符串驻留机制

对于短字符串，将其赋值给多个不同的对象时，内存中只有一个副本，多个对象共享改副本。

异常和错误有什么区别

异常是指因为程序执行过程中出错而在正常控制流以外采取的行为。 严格来说，语法错误和逻辑错误不属于异常，但有些语法错误往往会导致异常， 例如由于大小写拼写错误而访问不存在的对象，或者试图访问不存在的文件，等等。

使用 pdb 模块进行 Python 程序调试主要有哪几种用法

1. 在交互模式下使用 pdb 模块提供的功能可以直接调试语句块、表达式、函数等多种脚本。
2. 在程序中嵌入断点 来实现调试功能。在程序中首先导入 pdb 模块，然后使用 **pdb.set_trace()**在需要的位置设置断点。 如果程序中存在通过该方法调用显式插入的断点，那么在命令提示符环境下执行该程序或双击执行程序时将自动打开 pdb 调试环境，即使该程序当前不处于调试状态。
3. 使用命令行调试程序。在命令行提示符下执行“python –m pdb 脚本文件名”，则直接进入调试环境；当调试结束或程序正常结束以后，pdb 将重启该程序。

文件操作

1. 文件对象常用方法

2.序列化：把内存中的数据在不丢失其类型信息的情况下转成对象的二进制形式的过程 常用的序列化模块有struct、pickle、marshal和shelve

3. os模块 和 os.path模块 常用方法

• os模块
• os.path模块

魔术方法（Magic methods）

Python 魔术方法指南 第三方拓展魔术命令

IPython-Magic functions

Magic functions介绍

Reference

• [1] How to uninstall python3 from Ubuntu