标签：
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)
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‘)
连接池
待续
Python面试基础
标签：
原文地址：http://www.cnblogs.com/liqxd/p/5667562.html
