Python学习笔记——常用函数的使用及面试考点（持续更新）

最新推荐文章于 2024-08-13 14:14:41 发布

置顶子季鹰才

最新推荐文章于 2024-08-13 14:14:41 发布

阅读量3.8k

点赞数 5

本文链接：https://blog.csdn.net/hitzijiyingcai/article/details/81944639

版权

记录一下自己在学习过程中遇到了知识点，及在面试中被问到的知识点。

5、xrange() 与range函数用法

13. 使用sys.stdin.readline()获得输入

14、装饰器（划重点！）

15、反射机制（划重点！）

16、几个内置函数：lambda()、filter() 、map( )

17、sorted

18、@classmethod与@staticmethod的区别（划重点！）

19、关于对象——python中b=a与b=a[:]的区别

26、collections.Counter()

27、collections.defaultdict()的使用

1、OS模块

（1）当前使用平台

os.name:指示你正在使用的工作平台。比如对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'。

（2）当前路径和文件

os.getcwd() :返回当前工作目录

os.listdir(): 返回指定目录下的所有文件和目录名

（3）os.path系列

（1. os.path.join(path,name)

该函数实现的功能为连接目录与文件名或目录，用于路径拼接文件路径，可以传入多个路径。

基本功能为：

要注意：

会从第一个以”/”开头的参数开始拼接，之前的参数全部丢弃。
以上一种情况为先。在上一种情况确保情况下，若出现”./”开头的参数，会从”./”开头的参数的上一个参数开始拼接。如图：

此外：

输出：

（2. os.path.exists(name)

判断是否存在文件或目录name，如果存在，返回True；如果不存在，返回False。

（3. os.path.isdir(name):判断name是不是目录，不是目录就返回false

os.path.isfile(name):判断name这个文件是否存在，不存在返回false

os.path.getsize(name):或得文件大小，如果name是目录返回0L

os.path.abspath(name):获得绝对路径

os.path.isabs():判断是否为绝对路径

os.path.normpath(path):规范path字符串形式

os.path.split(name):分割文件名与目录（事实上，如果你完全使用目录，它也会将最后一个目录作为文件名而分离，同时它不会判断文件或目录是否存在）

os.path.splitext():分离文件名和扩展名

os.path.basename(path):返回文件名

os.path.dirname(path):返回文件路径

os.path.getmtime(path)：返回文件或目录的最后修改时间，结果为秒数

os.path.getatime(path)：返回文件或目录的最后访问时间，结果为秒数

os.path.getctime(path)：返回文件或目录的创建时间，结果为秒数

os.path.getsize(path)：返回文件大小

os.path.isfile(path)：判断path是否为文件，是返回True，不是返回False

os.path.isdir(path)：判断path是否为目录，是返回True，不是返回False

(4) os.mkdir()与os.makedirs()

os.mkdir()创建路径中的最后一级目录，即：只创建path_03目录，而如果之前的目录不存在并且也需要创建的话，就会报错。os.makedirs()创建多层目录，即：Test,path_01,path_02,path_03如果都不存在的话，会自动创建。

结果为：

(5) os.remove(file):删除一个文件

os.stat（file）:获得文件属性

os.chmod(file):修改文件权限和时间戳

os.rmdir("dir")：只能删除空目录

`2、文件操作`

os.mknod("text.txt")：创建空文件

fp = open("text.txt",w):直接打开一个文件，如果文件不存在就创建文件

关于open的模式：

w 写方式
a 追加模式打开（从EOF开始，必要时创建新文件）
r+ 以读写模式打开
w+ 以读写模式打开
a+ 以读写模式打开
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )

fp.read([size]) #size为读取的长度，以byte为单位

fp.readline([size]) #读一行，如果定义了size，有可能返回的只是一行的一部分

fp.readlines([size]) #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。

fp.write(str) #把str写到文件中，write()并不会在str后加上一个换行符

fp.writelines(seq) #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。

fp.close() #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError

fp.flush() #把缓冲区的内容写入硬盘

fp.fileno() #返回一个长整型的”文件标签“

fp.isatty() #文件是否是一个终端设备文件（unix系统中的）

fp.tell() #返回文件操作标记的当前位置，以文件的开头为原点

fp.next() #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。

fp.seek(offset[,whence]) #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。

fp.truncate([size]) #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。

3、glob

glob包最常用的方法只有一个, glob.glob()。

函数功能：匹配所有的符合条件的文件，并将其以list的形式返回。跟使用windows下的文件搜索差不多。
”*”匹配0个或多个字符；
”?”匹配单个字符；
”[]”匹配指定范围内的字符，如：[0-9]匹配数字。

如：

import glob

#获取指定目录下的所有图片

print glob.glob(r"/home/Picture/*/*.jpg")

4、Matplotlib

# 导入绘图模块

import matplotlib.pyplot as plt

具体使用可参考：https://www.cnblogs.com/LHWorldBlog/p/7819331.html

5、xrange() 与range函数用法

函数语法:

range(stop)

range([start,] stop[, step])：根据start与stop指定的范围以及step设定的步长，生成一个序列。

参数说明：

start: 计数从 start 开始。默认是从 0 开始。例如 xrange(5) 等价于 xrange(0， 5)
stop: 计数到 stop 结束，但不包括 stop。例如：xrange(0， 5) 是 [0, 1, 2, 3, 4] 没有 5
step：步长，默认为1。例如：xrange(0， 5) 等价于 xrange(0, 5, 1)

xrange() 函数用法与range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。

由上面的示例可以知道：要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间，这两个基本上都是在循环的时候用：

所以xrange做循环的性能比range好，尤其是返回很大的时候，所以尽量用xrange，除非是要返回一个列表。

NB：以上xrange()函数是在Python2中的函数，在Python 3中，range()的实现方式与xrange()函数相同，所以就不存在专用的xrange( )。

在Python3中range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型，所以打印的时候不会打印列表。

list() 函数是对象迭代器，把对象转为一个列表。返回的变量类型为列表。

6、zip()函数

（1）考虑下面的股票名和价格映射字典：

prices = {'ACME': 45.23,'AAPL': 612.78,'IBM': 205.55,'HPQ': 37.20,'FB': 10.75}

          为了对字典值执行计算操作,通常需要使用zip()函数先将键和值反转过来.下面是查找最小和最大股票价格和股票值的代码：
　　　　　　　 min_price = min(zip(prices.values(), prices.keys()))
                          # min_price is (10.75, 'FB')
                          max_price = max(zip(prices.values(), prices.keys()))
                          # max_price is (612.78, 'AAPL')

执行这些计算的时候，需要注意的是zip() 函数创建的是一个只能访问一次的迭代器。比如，下面的代码就会产生错误：

                           prices_and_names = zip(prices.values(), prices.keys())
                           print(min(prices_and_names)) # OK
                           print(max(prices_and_names)) # ValueError: max() arg is an empty sequence

（2）使用zip函数, 把key和value的list组合在一起, 再转成字典(dict).

7、yield关键字

先介绍可迭代的对象的概念：当你使用一个列表生成式来建立一个列表的时候，就建立了一个可迭代的对象，如：

在这里，所有的值都存在内存当中，所以并不适合大量数据。

再介绍生成器的概念：

可迭代
只能读取一次
实时生成数据，不全存在内存中

这里将“[]"换成了“()"。

yield关键字：

yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器
当你调用这个函数的时候，函数内部的代码并不立马执行，这个函数只是返回一个生成器对象
当你使用for进行迭代的时候，函数中的代码才会执行

第一次迭代中你的函数会执行，从开始到达 yield 关键字，然后返回 yield 后的值作为第一次迭代的返回值. 然后，每次执行这个函数都会继续执行你在函数内部定义的那个循环的下一次，再返回那个值，直到没有可以返回的。

8、datetime模块计算时间差

python中通过datetime模块可以很方便的计算两个时间的差,datetime的时间差单位可以是天、小时、秒,甚至是微秒。

如下为此函数的使用示例：

    import datetime 

    di=datetime.datetime.now()
    for times in range(Max):
        PrintN2(A,x)
    d1=datetime.datetime.now()
    print(d1-di)

9、关于以is为开头的关键字的使用

最近做关于算法的题，遇到了几个有用的函数isdigit( ), islower( ), isupper( ), isalpha( ) , isspace( )。

isdigit( ) 检测字符串是否只由数字组成。和 isnumeric( )函数类似

islower( ) 检测字符串是否由小写字母组组成。

isupper( ) 检测字符串中所有的字母是否都为大写。

isalpha( ) 检测字符串是否只由字母组成。

isspace( ) 检测字符串是否只由空格组成。

isalnum() 检测字符串是否由字母和数字组成。

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

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

如果要判断两个类型是否相同推荐使用 isinstance()。

用法：isinstance(object, classinfo)

object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

注：在C++及C中也有这些函数，他们的相关用法类似，但是在C++及C中要加上头文件#include <ctype.h>。

他们在两种语言中使用的区别在于：在Python中是str.isdigit()而在C++中是直接使用。

10、enumerate（）函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

以下是 enumerate() 方法的语法:

enumerate(sequence, [start=0])

参数

sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

普通的 for 循环：

>>>i = 0
>>> seq = ['one', 'two', 'three']
>>> for element in seq:
...     print i, seq[i]
...     i +=1
... 
0 one
1 two
2 three

for 循环使用 enumerate：

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 
0 one
1 two
2 three

11、jion（）函数的使用

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
str = "-";
seq = ("a", "b", "c"); # 字符串序列
print str.join( seq );

输出：

a-b-c

12、字符串操作

（1）replace() 方法把字符串中的 old（旧字符串）替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

#!/usr/bin/python
 
str = "this is string example....wow!!! this is really string";
print str.replace("is", "was");
print str.replace("is", "was", 3);

输出：

thwas was string example....wow!!! thwas was really string
thwas was string example....wow!!! thwas is really string

（2）if xxx.strip()函数的使用

strip()函数可以去掉句子前后的空格,\n,\t等（换行，回车），保持句子整洁。

a = '            \n this is a test file  \t '  #句子有空格和换行以及回车
b = '   \t \n'                           #句子除了换行空格和回车外没有其他字符    
if a.strip():                           #如果a.strip()的值为真，打印a,否则为假不打印。          
    print(a)
if b.strip():                           #如果b.strip()的值为真打印b,为假不打印          
    print(b)

>>> this is a test file

因为a除了空格回车换行外还有字符，所以a.strip()是有值的，为真，而b.strip()已经将空格换行回车去掉，没有任何字符（也没看空格），所以空的序列是假，不打印b，可以通过布尔表达式下面查看b.strip()的真假。

     bool(b.strip())
Out: False

而如果写成

if not b.strip():
    xxx

则表示如果b.strip()是假（从而not b.strip()是真）则执行下面xxx程序。

好，明白了这一点，看看strip('a')

这个函数是去掉字符串中和a相同的字符，但是有一点，是从两边开始的。什么意思呢？

a='123abc123'
a.strip('12')
得到
a='3abc123'

右边一开始撞到了'3'，而3不是我们想要删除的元素，所以就停止右边的删除，同样的左边。类似的函数

lstrip() #删左边 rstrip()#删右边

括号没东西时，删除转义字符和空白字符。

13. 使用sys.stdin.readline()获得输入

关于input( )和sys.stdin.readline( )的区别

sys.stdin.readline( )会将标准输入全部获取，包括末尾的'\n'，

input()会把‘\n’忽略

import sys
a=sys.stdin.readline()
b=input()
print(len(a),len(b))
 
执行：
abc
abc
4 3

如果在平时使用sys.stdin.readline( )获取输入的话，不要忘了去掉末尾的换行符，可以用strip( )函数去掉（sys.stdin.readline( ).strip('\n')）

import sys
a=sys.stdin.readline().strip()
b=input()
print(len(a),len(b))
 
执行结果：
abc
abc
3 3

python3中使用sys.stdin.readline()可以实现标准输入，其中默认输入的格式是字符串，如果是int，float类型则需要强制转换:

import sys
try:
    while True:
        print('Please input a number:')
        n = int(sys.stdin.readline().strip('\n')) #strip('\n')表示以\n分隔，否则输出是“字符串+\n”的形式
        print('Please input some numbers:')
        sn = sys.stdin.readline().strip()#若是多输入，strip()默认是以空格分隔，返回一个包含多个字符串的list。
        if sn == '':
            break
        sn = list(map(int,sn.split())) #如果要强制转换成int等类型，可以调用map()函数。
        print(n)
        print(sn,'\n')
except:
    pass

14、装饰器（划重点！）

最近也是同学去参加面试被问到装饰器我才注意到这个知识点，多么重要的知识点！

安利几个博客，讲的真心不错，简单易懂：

https://blog.csdn.net/by_side_with_sun/article/details/80573228

https://blog.csdn.net/xiangxianghehe/article/details/77170585

https://blog.csdn.net/u010358168/article/details/77773199

15、反射机制（划重点！）

同“装饰器”，最近也是同学去面试被问到才注意到，important！

超级详细：https://www.cnblogs.com/Guido-admirers/p/6206212.html

16、几个内置函数：lambda()、filter() 、map( )

lambda()

在Python中，我们使用lambda关键字来声明一个匿名函数，这就是为什么我们将它们称为“lambda函数”。匿名函数是指没有声明函数名称的函数。尽管它们在语法上看起来不同，lambda函数的行为方式与使用def关键字声明的一般函数相同。以下是Python中 lambda函数的特点:

lambda函数可以接受任意数量的参数，但函数只能包含一个表达式。表达式是lambda函数执行的一段代码，它可以返回任何值，也可以不返回任何值。
lambda函数可以返回函数对象。
从语法上讲，lambda函数只能有一个表达式。

创建一个lambda函数

我们使用以下语法来声明lambda函数：

lambda arguments: expression

正如上面所述，我们可以有很多个参数，但是只能有一个表达式。lambda操作符不能有任何声明,它返回一个函数对象，我们可以将此函数对象赋值给任何变量。

例如：

remainder = lambda num : num % 2
print(remainder(5))

输出：

这段代码中，lambda num: num % 2是lambda函数。num是参数，num%2是表达式，用来计算后返回结果。该表达式获取输入参数除以2的模数并返回。将5作为参数传入，通过除以2进行计算，得到余数1.

你应该注意到，上面脚本中的lambda函数没有分配任何名称。它只是返回一个函数对象，该对象被分配给标识符remainder。然而，尽管函数是匿名的，我们还是可以像调用普通函数那样调用它。

filter() 函数

Python中的filter( )函数接受一个列表参数和一个lambda函数参数。它的语法如下：

filter(object,iterable)

这里的object必须是一个返回布尔值的lambda函数。对迭代器中的每一项都会调用该函数来计算其结果是True或False。请注意，本函数只能接受一个迭代器作为输入。

lambda函数，和需要被处理的列表，被一同传递给filter( )函数。filter（）函数将返回一个新的列表，新的列表中只包含旧列表中被lambda函数处理后返回值为True的那些元素。请参考下面给出的例子：

number_list = [2,6,8,10,11,4,12,7,13,17,0,3,21]
filterer_list = list[filter(lambda num : (num>7)), number_list]
print(filterer_list)

输出

[8, 10, 11, 12, 13, 17, 21]

在上面的例子中，我们先创建了一个包含一系列整数的列表number_list,接着我们创建了一个lambda函数来检查大于7的整数。此lambda函数作为参数传递给filter（）函数，过滤后的结果保存在一个名为filtered_list的新列表中。

map( ) 函数

map( )函数是另一个以一个函数对象和一个列表作为参数的内置函数。map函数的语法如下：

map(object,iterable_1,iterable_2,...)

传入map（）函数的迭代器可以是字典，列表等。map（）函数主要是根据lambda函数定义的逻辑来将输入迭代器中的每一项映射到输出迭代器中的相关项。请参考以下的例子：

number_list = [2,6,8,10,11,4,12,7,13,17,0,3,21]
mapped_list = list(filter(lambda num : (num % 7), number_list))
print(mapped_list)

输出：

[2, 6, 8, 10, 11, 4, 12, 13, 17, 3]

在上面的脚本中，我们先定义了一个由随机数组成的列表numbers_list,接着我们调用map（）函数，并传递一个lambda函数作为参数。此lambda函数计算每个数除以2之后的余数。映射的结果保存在一个名为mapped_list的列表中。最后，我们打印出列表的内容。

17、sorted

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>>

sorted返回一个有序的副本，并且类型总是列表，如下：（字符串变列表）

print (sorted('Python')) #['P', 'h', 'n', 'o', 't', 'y']

18、@classmethod与@staticmethod的区别（划重点！）

安利博客：https://blog.csdn.net/GeekLeee/article/details/52624742

19、关于对象——python中b=a与b=a[:]的区别

b=a与b=a[:]的区别
b=a将两者指向同一个对象
而b=a[:]会创建一个新的与a完全相同的对象，但是与a并不指向同一对象。
在计算机中，不同的对象即不同的内存地址。
可理解为：b=a将创建a与b两个快捷方式并指向同一文件；
而b=a[:]先将a指向的文件复制一份作为副本，然后创建一个指向该副本的快捷方式b。
二者不同表现为当两者指向同一对象时，改变其中任意一个，都会改变对象的值，也就是同时改变a，b的值。