基础教程
Python快速教程
列表推导式
c = a if a>b else b //如果a>b返回a，否则返回b
>>> a = 1
>>> b = 2
>>> c = a if a>b else b
>>> c
2
c = [b,a][a>b] //如果a>b返回a，否则返回b
>>> a = 1
>>> b = 2
>>> c = [b,a][a>b]
>>> c
2
c = [ i for i in a if i%2==0 ] //遍历a，在i为偶数时返回
>>> a = [1,2,3]
>>> c = [i for i in a if i%2==0]
>>> c
[2]
注意当你用上述方式生成列表，但又不引用而只是作为临时参数时，为减少内存开销，应将sum( [ i for i in a if i%2==0 ] )改成sum( i for i in a if i%2==0 )，
生成集合：c = { i for i in a if i%2==0 } //遍历a，在i为偶数时返回
生成字典：c = { i:i**i for i in a if i%2==0 } //遍历a，在i为偶数时返回
c = [i+j for i in a for j in b if i%2==0 and j%2==0] //同时嵌套遍历列表a和b，返回i和j同时为偶数时的和。其中for in a属于外层嵌套，for in b属于内层
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [i+j for i in a for j in b if i%2==0 and j%2==0]
>>> c
[6, 8]
# 嵌套推导式
[ [item for item in tupe] for tupe in tup_list ]
c = [i if i%2==0 else 1 for i in a] //遍历a，如果i为偶数直接返回，否则直接返回1。此处if写在for前面要求必须有else项
>>> a = [1,2,3]
>>> c = [i if i%2==0 else 1 for i in a]
>>> c
[1, 2, 1]
数据交换
a,b=b,a //交换数据
>>> a=1
>>> b=2
>>> a,b=b,a
>>> a
2
>>> b
1
数组转字符串
''.join['1','2'] //字符list的连接
>>> c = ''.join(['1','2'])
>>> c
'12'
上下文管理器
# 自建可以with的类
class Sample:
def __enter__(self):
return self
def __exit__(self, type, value, trace):
print "type:", type
print "value:", value
print "trace:", trace
def do_something(self):
bar = 1/0
return bar + 10
#1、类Sample被实例化后，调用__enter__()方法，将返回值赋给as后的变量sample
#2、with语句下的语句sample.do_something()被执行
#3、语句执行完或者是出现异常时调用__exit__()方法
with Sample() as sample:
sample.do_something()
# 使用contextmanager实现上下文管理
from contextlib import contextmanager
from random import random
DEFAULT_EXPIRES = 15
DEFAULT_RETRIES = 5
@contextmanager
def dist_lock(key, client):
key = 'lock_%s' % key
try:
_acquire_lock(key, client)
yield
finally:
_release_lock(key, client)
def _acquire_lock(key, client):
for i in xrange(0, DEFAULT_RETRIES):
get_stored = client.get(key)
if get_stored:
sleep_time = (((i+1)*random()) + 2**i) / 2.5
print 'Sleeipng for %s' % (sleep_time)
time.sleep(sleep_time)
else:
stored = client.set(key, 1)
client.expire(key,DEFAULT_EXPIRES)
return
raise Exception('Could not acquire lock for %s' % key)
def _release_lock(key, client):
client.delete(key)
数组切片
#切片
a = [1,2,3,4]
a[:-1] #取0到倒数第二位之间的list，其中-1指的是4所在位置，根据索引左闭右开
[1, 2, 3]
a[::-1] # 将list反向，可以理解为第一个:表示开始位置0，第二个:表示最后位置，多出的-1表示反向
[4, 3, 2, 1]
a[::]
[1, 2, 3, 4]
a[:]
[1, 2, 3, 4]
a[:2] #选取[0,2)index的元素
[1, 2]
a[::2] # 隔一个数选取
[1, 3]
import numpy as np
a = np.arange(25).reshape((5,5))
print(a)
print(a[:,::-1])
print(a[...,::-1])
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]]
[[ 4 3 2 1 0]
[ 9 8 7 6 5]
[14 13 12 11 10]
[19 18 17 16 15]
[24 23 22 21 20]]
[[ 4 3 2 1 0]
[ 9 8 7 6 5]
[14 13 12 11 10]
[19 18 17 16 15]
[24 23 22 21 20]]
*与**区别
调用函数时使用*和** ：
test(*args)：* 把序列 args 中的每个元素，当作位置参数传进去。
如果 args 等于 (1,2,3) ，就等价于 test(1, 2, 3) 。
test(**kwargs)：** 把字典 kwargs 变成关键字参数传递。
如果 kwargs 等于 {‘a’:1,’b’:2,’c’:3} ，就等价于 test(a=1,b=2,c=3) 。
定义函数参数时使用*和**：
def test(*args):
定义函数参数时 *args 表示把传进来的参数都装在元组 args 里面。
如果调用 test(1, 2, 3) ， 那 args = (1, 2, 3) 。
def test(**kwargs):
定义函数参数时 **args 表示把传进来的参数都装在元组 args 里面。
如果调用 test(a=1,b=2,c=3) ， kwargs = {‘a’:1,’b’:2,’c’:3} 。
zip打包dict
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，可理解为解压
[(1, 2, 3), (4, 5, 6)]
# 制作字典
vocabs, _ = list(zip(*dicts))
dict(zip(vocabs, range(1, len(vocabs) + 1)))
类型判断
Python中的对象包含三要素：id、type、value
其中id用来唯一标识一个对象，type标识对象的类型，value是对象的值
is判断的是a对象是否就是b对象，是通过id来判断的
==判断的是a对象的值是否和b对象的值相等，是通过value来判断的
a = 1
b = 1.0
a is b #false
a == b # true
判断类型
isinstance(cfg.pos_weight, (int, float))
使用*号初始化字符串，数组
字符串可以做*运算，但并不是数学运算，而是重复
'a'*3 = 'aaa'
a = [[]] * 2
print(a) # [[], []]
a[0] == a[1] # True 注意这种初始化的子数组是同一个对象
命名方式
python中主要存在四种命名方式：
1、object #公用方法
2、_object #半保护，被看作是“protect”，意思是只有类对象和子类对象自己能访问到这些变量，在模块或类外不可以使用，不能用’from module import *’导入。
3、_ _ object #全私有私有成员“private”，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据，不能用’from module import *’导入。
#__object 是为了避免与子类的方法名称冲突， 对于该标识符描述的方法，父类的方法不能轻易地被子类的方法覆盖，他们的名字实际上是_classname__methodname。
4、_ _ object_ _ #内建方法，用户不要这样定义
深浅复制
[python对象的引用与复制](https://www.cnblogs.com/linxiyue/p/7970287.html?utm_source=tuicool&utm_medium=referral)：
在python中像b = a这样的赋值时，只会创建一个对a的新引用，使a的引用计数加1，而不会创建新的对象。
当引用的对象是可变对象的时候(列表，字典，可变集合等），修改后会改变原始对象：
>>> a = [1, 2, 3, 4]
>>> b = a
>>> b.append(5)
>>> a
[1, 2, 3, 4, 5]
浅复制：
>>> a = [1, 2, 3, 4]
>>> import copy
>>> b = copy.copy(a)
>>> b.append(5)
>>> b
[1, 2, 3, 4, 5]
>>> a
[1, 2, 3, 4]
浅复制的新对象中包含的是对原始对象中的项的引用，如果对象的项为可变对象，仍然会改变原始对象：
>>> a = [1, [1, 2]]
>>> b = copy.copy(a)
>>> b[1].append(3)
>>> b
[1, [1, 2, 3]]
>>> a
[1, [1, 2, 3]]
深复制将创建一个新对象，并递归地复制它所包含的所有对象：：
>>> a = [1, [1, 2]]
>>> b = copy.deepcopy(a)
>>> b[1].append(3)
>>> b
[1, [1, 2, 3]]
>>> a
[1, [1, 2]]
对于不可改变的对象而言(字符串，数字，元组)等，没有必要拷贝，因为它们是不可改变的。
bisect数组插入位置
api
#获取函数插入位置
from bisect import bisect
bisect(["20190220","20190225","20190229"],"20190230")
bisect_left bisect_right
类的含义
Python __dict__属性详解
Python 中__new__()和__init__()的区别
python 魔法方法补充（setattr,getattr,getattribute）
函数分两步传参：
def func(a, b):
print(a, b)
from functools import partial
s = partial(func, b=2)
s(1) # 1 2
getattr, __getattr__, __getattribute__和__get__区别
getattr, __getattr__, __getattribute__和__get__区别
getattr()：相当于调用对象属性
__getattribute__：访问对象属性时调用
__getattr__：__getattribute__拿不到属性时，调用
__get__：将访问该对象改成访问该对象的get方法
class TitleInfo(object):
__slots__ = ["id", "title"]
def __getitem__(self, key):
if hasattr(self, key):
return self.__getattribute__(key)
else:
return None
def __setitem__(self, key, val):
return self.__setattr__(key, val)
def __repr__(self):
assert len(__slots__) == len(set(__slots__)), "repeated field."
dict_data = {}
for slot in self.__slots__:
dict_data[slot] = self[slot]
return repr(dict_data)
263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
