X

曜彤.手记

随手写写,关于互联网技术、产品与创业

Python 小记


最近在工作中一直在从事 Python 相关的工作,因为以前 Python 用的比较少,特地趁此机会好好学习和复习一下,将一些基础性的知识点整理在这里。同时也方便以后的回顾和查找。关于 Python 的编码规范,有两种常用规范可以选择。一个是 PEP8,另一个是 Google Python 规范。

# 控制台输入;
s = input("Please input:")

# 类型转换(Python 不允许类型的隐式转换);
s = int(s)
s = str(s)

# 可迭代对象;
from collections import Iterable
isinstance([], Iterable) # True

# Python 的 for 循环本质上是通过不断调用 next() 函数实现的;
for x in [1, 2, 3, 4, 5]:
    pass

# 首先获得 Iterator 对象;
it = iter([1, 2, 3, 4, 5])
# 循环;
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到 StopIteration 就退出循环;
        break


# 多行模式,续行模式;
print('''line1
line2 
line2''');

# 编码转换;
ord('A') # 65
chr(66) # 'B'

# 字符串模版;
'Hi, %s, you have $%d.' % ('Michael', 1000000);
# 'Hi, Michael, you have $1000000.'

# 判断某一个键值对是否在一个 dict 中;
'Name' in {'Name': 'Jason', 'Age': 18}

# Set 相关;
s = set([1, 1, 3, 4])
s.add(4)
s.remove(1)

# 交集;
s & set([1, 3])

# 偏函数;
import functools
def log(level, message, stack):
    print(level + ": " + message)
    print(stack)

log_unknown_error = functools.partial(functools.partial(log, "Error"), "Unknown")

# 使用不变类型做默认参数;
def add_end(L = None):
    if L is None:
        L = []
    L.append('END')
    return L

# 可变参数和关键字参数;
def f1(a, b, c = 0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

args = (1, 2, 3, 4);
kw = {'d': 99, 'x': '#'}
f1(args, kw);
# a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}

# 列表生成式;
[x * x for x in range(1, 11) if x % 2 == 0]

d = {'x': 'A', 'y': 'B', 'z': 'C' }
[k + '=' + v for k, v in d.items()]

L = ['Hello', 'World', 'IBM', 'Apple']
[s.lower() for s in L]

# 切片;
l = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack'];
l[:3]
l[-2:]
l[:]
l[::2]
'ABCDEFG'[:3]
'ABCDEFG'[::2]

# 生成器(从列表生成式演化过来);
g = (x * x for x in range(10));
next(g);

for n in g:
    print(n);

# 断言(不成立会抛出 Assertion Error);
assert 1 == 1

# 无参数装饰器;
import functools

def log(func):
    @functools.wraps(func) # 修正函数的 __name__ 属性;
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
# 带参数装饰器;
import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

# 匿名函数;
func = lambda:1 + 1     # 无参;
func = lambda x:x + 1   # 有参;

# 字符串格式化:
print('{},{}'.format('Hongten','Welcome to my space!'))
print('Hi,{name},{message}'.format(name = 'Tom',message = 'How old are you?'))

table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
    for name, phone in table.items():
        print('{0:10} ==> {1:10d}'.format(name, phone))

# 字符串格式化,填充与宽度限制(^居中、<左对齐、>右对齐);
'{:>8}'.format('189')
'{:0>8}'.format('189')
'{:a>8}'.format('189')

# 字符串格式化,精度限制;
'{:.2f}'.format(321.33345)

# 字符串格式化,进制限制(d/b/o/x);
'{:d}'.format(17)

# 字符串格式化,千分位分隔符;
'{:,}'.format(1234567890)

闭包和 LEGB 法则:

闭包最重要的使用价值在于封存函数执行的上下文环境;闭包在其捕捉的执行环境(def 语句块所在上下文)中,遵循 LEGB 规则逐层查找,直至找到符合要求的变量,或者抛出异常。可以看如下的 Python 闭包和 Javscript 闭包的示例代码。会产生闭包的根本原因是因为语言的灵活性,可以将函数作为参数或者返回值,这样某层函数的作用域环境会在特定情况下被“保存”下来。

# Python Version;
def func1():
    i = 0
    def func2():
        nonlocal i
        print(++i)
    return func2

ref = func1() # 保存最外层函数的环境和引用;
ref() # 1
ref() # 2
ref() # 3
// Javascript;
function func1() {
  var i = 0;
  function func2() {
    console.log(++i);
  }
  return func2;
}
var ref = func1();
ref();
ref();
ref();


这是文章底线,下面是评论
  暂无评论,欢迎勾搭 :)