Python面试基础

Python培训结束后忙于找工作，特整理了基础知识以应对面试。

基础篇

1.三元/幕运算

result = 值1 if 条件1 else 值2

2.进制

二进制：01

八进制：0-7

十进制：0-9

十六进制：0-F

3.str对象的方法

capitalize()

首字母大写

center(width,fillchar=None)

内容居中，width总长度，fillchar填充字符

如：*********************123************************

count()

decode(encoding=utf8)

解码

encode(encoding=utf-8)

编码，针对unicode

expandtabs(tabsize)

将tab转换成空格，默认一个tab转换成8个空格

find(sub)

找到自序的位置，如果没找到返回-1

format()

格式化字符串

index()

找位置，没找到报错

isalnum()

是否是字母或数字

isalpha()

是否是字母

isdiget()

是否是数字

islower()

是否是小写

join(str)

‘*‘.join(a)

1*2*3,注意join并不会改变原字符串

ljust(width,fillchar)

左对齐

lower()

小写

partition(sep)

(head,sep,tail)

replace(old,new)

替换

split()

分割成列表

strip()

移除两端空白

4.list的方法

append()

count(x)

x存在的个数

extend(li)

直接合并两个列表，包括重复值

index(x)

获取x的索引，如果不存在则报错

insert(idx,value)

在指定位置添加值

pop(idx)

删除指定索引的值

remove(v)

删除第一个出现的值

reverse()

反转

sort()

5.tuple

不可修改元素的值

6.dict的方法：

clear():

清除内容

get(k):

根据k取值

items():

将所有的k,v用元组的形式存储在列表中

如：[(a,b),(c,d)]

iteritems():

返回一个生成器，需要迭代获取元组

keys():

pop(k):

setdefault(k):

如果不存在，创建。如果存在返回值

update(dic):

合并两个字典，去重

7.set的方法：

集合是无序且不重复的元素的集合

intersection(*args,**kwargs)

取交集

8.collection系列

Counter

追踪值出现的次数

c = Counter(‘abcdeabcdabcaba‘)

print c

输出：Counter({‘a‘: 5, ‘b‘: 4, ‘c‘: 3, ‘d‘: 2, ‘e‘: 1})

有序字典orderedDict

双向队列deque

单向队列Queue

###先进先出，FIFO

9.生成器

xrange,xreadlines

生成器内部基于yield创建， 生成器只有使用时才被创建， 避免不必要的内存浪费

yield会返回并记录其当前位置

10.深浅copy

在修改数据时：

数字或字符串 ：在内存中新建一份数字

集合：修改内存中的同一份数据

浅copy复制外层元素，里层元素只是引用

深copy复制所有元素

11.文件操作

f = file(‘路径‘,‘模式‘)

f = open(..,..)

模式，rb,wb,ab

默认是只读模式r

f.flush()

刷新

f.next()

获取下一行数据，不存在则报错

readline()

读取一行

readlines()

保留到列表中

seek()

指定文件中指针的位置

write()

with open

可避免文件打开后忘记关闭

with open(‘log‘,‘r‘) as f:

with还可以同时对多个文件进行操作

with open(‘log‘) as f1,open(‘log1‘) as f2:

获取文件的每一行

with open(‘a‘) as f:

for line in f:

###循环文件的句柄，可以得到每一行的句柄

12.函数的三种不同的参数

默认参数

def func(name,age=18):

func(‘a‘,11)

###指定参数

func(‘a‘)

###使用默认参数

动态参数1

def func(*args):
func(1,2,3)

###传递多个参数

li = [1,2,3]

func(li)

###将列表整体作为一个参数

func(*li)

###传递列表中的每一个值

动态参数2

def func(**kwargs):

func(name=‘‘,age=)

###指定键值对参数

di = {‘name‘:‘‘,‘age‘=0}

func(**di)

###传入整个字典，必须加**

动态参数3

func(*args,**kwargs)

###字典列表都可以传

13.内置函数

map(func,li)

遍历序列，对序列中的每个元素执行func并最终获取新的序列。

每个元素加100：

new_list = map(lambda a: a + 100, li)

可以操作多个序列

两个序列对应值相加：

li = [11, 22, 33] sl = [1, 2, 3]

new_list = map(lambda a, b: a + b, li, sl)

filter(func,li)

对序列中的元素进行筛选，最终获取符合条件的序列

获取列表中大于12的所有元素的集合：

li = [11, 22, 33]

new_list = filter(lambda arg: arg > 22, li)

reduce(func,li)

对序列内所有元素进行累计操作

获取所有元素的和：

li = [11, 22, 33]

result = reduce(lambda arg1, arg2: arg1 + arg2, li)

14.yield

分批return，每次返回记录当前位置，下次从这个位置继续执行函数

自制xrange：

def myrange(num):

temp = -1

while True:

temp = temp + 1

if temp >= num:

return

else:

yield temp

15.递归实现斐波那契数列

前两项的和是第三项,递归

def func(a1,a2):
if a1 == 0:
    print a1,a2
    a3 = a1 + a2
    print a3
    func(a2,a3)
func(0,1)

16.socket

socket就是网络套接字，用来描述IP地址和端口，通过socket进行网络请求

C/S的socket请求原理：

S：socket() - bind() - listen() - accept()#阻塞等待客户端连接 - read() - write() - read() - close()

import socket
ip_port = (‘127.0.0.1‘,9999)
sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)
while True:
    print‘server waiting...‘
    conn,addr = sk.accept()
    client_data = conn.recv(1024)
    print client_data
    conn.sendall(‘不要回答,不要回答,不要回答‘)
    conn.close()

####accept()返回一个conn对象，conn.recv(1024)接收数据，conn.sendall()发送数据

C：socket() - connect()#连接服务器 - wirte() - read() - write() - close()

ip_port = (‘127.0.0.1‘,9999)
sk = socket.socket()
sk.connect(ip_port)
sk.sendall(‘请求占领地球‘)
server_reply = sk.recv(1024)
print server_reply
sk.close()

###客户端则都通过socket实例进行连接，resv和sendall

应用实例：

import socket
def handle_request(client):
    buf = client.recv(1024)
    client.send("HTTP/1.1 200 OK\r\n\r\n")
    client.send("Hello, World")

def main():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind((‘localhost‘,8080))
    sock.listen(5)
    while True:
        connection, address = sock.accept()
        handle_request(connection)
        connection.close()

if __name__ == ‘__main__‘:
    main()

socket的方法：

bind((‘localhost‘,8080))

连接地址

listen(backlog)

监听传入连接，backlog为可以挂起的连接数

setblocking(bool)

默认为True。是否阻塞,如果设置False, 那么accept和recv一旦没数据就会报错。

accept()

接收并返回(conn,addr)

其中conn是新的套接字对象，addr为发送数据的地址

send()一次发干净

send()发多次发干净

sendto()指定地址，UDP使用

fileno()

套接字的文件描述符

I/O多路复用

同时监控多个描述符，一旦某个描述符就绪就进行读写操作

如linux中的

select：能够监控的文件有限制（1024）

,poll：没有限制，开销大

epoll：最好的

python中有一个select模块，可以调用系统的select,poll,epoll实现多路复用。mac和windows只有select方法

select用来监视文件句柄，如果句柄发生变化，获取该句柄。从而可以同时处理多个socket的请求

socketServer模块

内部使用I/O多路复用，加上多线程和多进程，实现并发处理多个客户端请求的socket服务器端。每个请求会出创建一个线程或进程专门处理

ThreadingTCPServer

实现为每个请求创建线程

实现步骤：

1.创建一个类，继承SocketServer.BaseRequestHandler

2.类中定义一个handle方法

3.启动ThreadingTCPServer

import SocketServer
class MyServer(SocketServer.BaseRequestHandler):
    def handle(self):
        # print self.request,self.client_address,self.server
        conn = self.request
        conn.sendall(‘欢迎致电 10086，请输入1xxx,0转人工服务.‘)
        Flag = True
        while Flag:
            data = conn.recv(1024)
            if data == ‘exit‘:
                Flag = False
            elif data == ‘0‘:
                conn.sendall(‘通过可能会被录音.balabala一大推‘)
            else:
                conn.sendall(‘请重新输入.‘)
if __name__ == ‘__main__‘:
    server = SocketServer.ThreadingTCPServer((‘127.0.0.1‘,8009),MyServer)
    server.serve_forever()

###创建一个ThreadingTCPServer实例，调用serve_forever()方法，在handle()中通过self.request获得conn连接

ForkingTCPServer

与ThreadingTCPServer类似，但还可以为请求创建进程。

twisted

基于事件驱动的网络框架

实现异步I/O等等

17.线程、进程、携程

线程

生成线程：

for i in range():

t = threading.Thread(target=func,args=(,))

t.start()

线程的方法

start()启动线程

setName、getName设置线程名

setDaemon：设置为后台进程，如果主线程停止，它也会停止。

join：逐个执行每个线程，使得多线程无意义

run()：线程被调用后自动执行run方法

线程锁

Lock,RLock

###互斥锁，同一时刻只允许一个线程执行操作，用在处理共享数据时

lock = Threading.RLock() #全局变量

def Foo():

lock.acquire()

...

lock.release()

###在方法中加锁

信号量semaphore

同时允许一定数量的线程修改数据

semaphore= threading.BounedSemaphore(5)#全局变量，最多允许5个线程同时运行。

事件event

用于主线程控制其他线程的执行

包括set,wait,clear方法，主要是针对wait操作

设置一个全局变量，clear将其设置成False，wait（）会阻塞，set将其设置成True，wait()将不会阻塞

需要传递一个event对象，evobj = threading.Event()

条件condition

使得线程等待，只有满足某个条件时才释放n个线程

con = Threading.Condition()

con.acquire()

con.notify()

con.release()

定时器timer

指定n秒后的执行

from threading import Timer

t = Timer(1,func)

t.start()

进程

生成进程：

from multiprocessing import Process

for i in range(10)：

p = Process(target=,args=(i,))

p.start()

###跟创建线程类似，由于进程之间的数据是独立的，所以创建线程要更大的开销

进程数据共享

进程默认无法共享数据

方法1：

Array

from multiprocessing import Process,Array
temp = Array(‘i‘, [11,22,33,44])

def Foo(i):
    temp[i] = 100+i
    for item in temp:
        print i,‘----->‘,item

for i in range(2):
    p = Process(target=Foo,args=(i,))
    p.start()

###Array（‘i‘,[11,22,33,44]）操作的是一个Array实例，名称是i，值是后面的列表

方法2：

Manager

from multiprocessing import Process,Manager

manage = Manger()

dic = manage.dict()

###之后就可以像正常字典使用了

###进程锁用法同线程锁

进程池

进程池内部维护一个进程序列，使用时去取，没有时等待。

进程池中有两个方法：

apply和apply_async

pool = Pool()

pool.apply_async(func=Foo,args=().callback=Bar)

协程

线程和进程的操作是由操作系统执行的，协程则是程序员

当程序中大量不需要CPU的操作，如I/O操作

使用greenlet，gevent

from greenlet import greenlet

def test1():

print 12

gr2.switch()

print 34

gr2.switch()

def test2():

print 56

gr1.switch()

print 78

gr1 = greenlet(test1)

gr2 = greenlet(test2)

gr1.switch()

18.模块

自定义模块

导入模块的路径

sys.path

###如果没有你的模块路径，使用sys.path.append(‘路径‘)

os模块可以获取各种路径

path = os.path.abspath(‘../‘)

第三方模块

paramiko

远程控制的模块，可以执行命令或批量操作

内置模块

OS

提供系统级别的操作

os.getcwd

获得当前文件的路径

os.mkdir()

os.rename

os.system(‘ls -l‘)

运行shell命令

os.path.abspath(‘../‘)

sys

提供解释器的相关操作

sys.argv

命令行参数列表，第一个元素是程序的路径

sys.path

模块导入路径

sys.platform

获取系统平台

hashlib

用于加密操作，取代了MD5

import hmac

h = hmac.new(‘liqixuan‘)

h.update(‘hello‘)

json& pickle

用于序列化的模块

json:字符串和Python数据类型的转换

pickle:转换成只有python认识的类型

4种方法

dump

with open(‘a‘) as f:

json.dump(‘123‘,f)

将‘123‘写入文件

dumps

load

loads

subprocess

执行系统命令，shell

import subprocess

ret1 = subprocess.Popen(["mkdir","t1"])

ret2 = subprocess.Popen("mkdir t2", shell=True)

obj = subprocess.Popen("mkdir t3", shell=True, cwd=‘/home/dev‘,)

stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄

import subprocess

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

#进入pyton环境

obj.stdin.write(‘print 1 \n ‘)

obj.stdin.close()

cmd_out = obj.stdout.read()

obj.stdout.close()

cmd_error = obj.stderr.read()

obj.stderr.close()

print cmd_out

print cmd_error

shutil

高级的文件，文件夹压缩处理模块

configParser

用于对特定的配置文件进行操作

logging

记录日志且线程安全的模块

time

时间戳

time.time()

字符串化

time.strftime(‘%Y-%m-%d‘)

结构化时间

time.localtime()

时间日期

print time.strftime(‘%Y-%m-%d %H:%M:%S‘)

datetime

表示日期的类

print datetime.datetime.now()

2016-07-11 13:51:55.279000

print datetime.datetime.now() - datetime.timedelta(days=1)

时间操作计算

re

正则表达式

.匹配任意字符

\w匹配字母数字下划线或汉字

\s匹配空白符

\d匹配数字

\^匹配字符串的开始

\$匹配字符串的结束

重复次数

* 若干次

+至少一次

？至多一次

{n}重复n次

{n,m}重复n-m次

match()

从起始位置开始匹配，匹配1次

import re

obj = re.match(‘\d‘,‘123uuasf‘)

if obj:

print obj.group()

###结果需要调用group()

search()

根据内容去字符串中匹配内容，1次

obj = re.search(‘‘,‘‘)

print obj.group()

group,goups

group(0)不分组，默认为0

一个()对应一个分组，

groups()返回一个所有分组的元组

###match和group结果需要调用group()

findall()

找遍所有，返回一个列表，并且不用使用group()

sub()

替换字符串

content = "123abc456"

new_content = re.sub(‘\d+‘, ‘sb‘, content)

###会替换所有

split()

根据指定匹配进行分组

content = "‘1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )‘"

new_content = re.split(‘[\+\-\*\/]+‘, content)

###会返回列表，(+-*/)都是关键字需要加\转意

random

生成随机数

print random.random()

print random.randint(1,2)

print random.randrange(1,10)

###random.random()是0-1

randint(1,2)包括上下标

19.面向对象

判断obj是否是cls的对象

isinstance(obj,Foo)

判断sub是否是super的派生类

issubclass(sub,super)

异常处理

try:

except Exception,e:

try:
# 主代码块
    pass
except KeyError,e:
# 异常时，执行该块
    pass
else:
# 主代码块执行完，执行该块
    pass
finally:
# 无论异常与否，最终执行该块
pass 

主动触发异常

raise Exception(‘错误了。。。‘)

自定义异常类

继承Exception

断言

assert 1==1

assert 1==2

反射

检查是否有成员，获取成员

hasattr,getattr,setattr,delattr

#### 检查是否含有成员 ####

hasattr(obj, ‘name‘)

hasattr(obj, ‘func‘)

# #### 获取成员 ####

getattr(obj, ‘name‘)

getattr(obj, ‘func‘)

# #### 设置成员 ####

setattr(obj, ‘age‘, 18)

setattr(obj, ‘show‘, lambda num: num + 1)

# #### 删除成员 ####

delattr(obj, ‘name‘)

delattr(obj, ‘func‘)

###如果是字段获取值，如果是方法获取函数名

结论，反射是通过字符串操作对象中成员的方法

类、模块、对象中皆可以使用反射

类的属性

变种方法，在方法前加上@property

类成员的修饰符

公用成员，任何地方都能访问

私有成员，只有在类的内部才能

私有成员命名 __a

类的特殊成员

__doc__

注释

__module__

当前类在哪个模块

__class__

当前操作对象的类

__init__

构造方法

__call__

对象加()调用，或者类()()调用

__dict__

类或对象中的所有成员

__str__

打印对象时，输出该方法的返回值

__getitem__,setitem__

用于索引操作，如字典

__new__,__metaclass__

__mataclass__表示该类由谁实例化创建

20.缓存数据库

memcached

key-value的缓存库，支持集群

redis

基于key-value相比memcached，value可存储的数据类型更多，分别是

字符串str

list链表

set集合

zset有序集合

hash值。且他们都支持push/pop/add/remove及交集并集差集的操作

启动服务端

redis-server

启动客户端
redis-cli

Redis实例来实现Redis命令

import redis

r = redis.Redis(host =,port = )

r.set(‘foo‘,‘Bar‘)

print r.get(‘Foo‘)

连接池

　　待续