Python 入门

os.fork() :子进程永远返回0, 父进程返回子进程ID

os.getpid()：返回当前进程ID

os.getppid()：返回父进程ID

Process(target=函数名，args=参数)

join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步

Pool(子进程数) ：创建子进程池，进程数默认为cpu核数

进程间通信

threading.Thread(target=线程执行方法名, name='线程名称') 创建子线程

threading.current_thread()函数，它永远返回当前线程的实例

threading.current_thread().name 获取当前线程名称，主线程默认是 MainThread，其他根据子线程参数传入确定

加锁

import threading
    
# 创建全局ThreadLocal对象:
local_school = threading.local()

def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()

t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()

test = '用户输入的字符串'
if re.match(r'正则表达式', test):
    print('ok')
else:
    print('failed')

Match 对象 分组

>>> 'a b   c'.split(' ')
['a', 'b', '', '', 'c']

>>> re.split(r'[\s\,]+', 'a,b, c  d')
['a', 'b', 'c', 'd']

>>> re.split(r'[\s\,\;]+', 'a,b;; c  d')
['a', 'b', 'c', 'd']

>>> re.match(r'^(\d+)(0*)$', '102300').groups()
('102300', '')

非贪婪匹配（也就是尽可能少匹配）

>>> import re
# 编译:
>>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
# 使用：
>>> re_telephone.match('010-12345').groups()
('010', '12345')
>>> re_telephone.match('010-8086').groups()
('010', '8086')

>>> from datetime import datetime
>>> now = datetime.now() # 获取当前datetime
>>> print(now)
2015-05-18 16:28:07.198690
>>> print(type(now))
<class 'datetime.datetime'>

>>> from datetime import datetime
>>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime
>>> print(dt)
2015-04-19 12:20:00

1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time，记为0（1970年以前的时间timestamp为负数），当前时间就是相对于epoch time的秒数，称为timestamp

>>> from datetime import datetime
>>> dt = datetime(2015, 4, 19, 12, 20) # 用指定日期时间创建datetime
>>> dt.timestamp() # 把datetime转换为timestamp
1429417200.0

整数位为秒

>>> from datetime import datetime
>>> t = 1429417200.0
>>> print(datetime.fromtimestamp(t)) # 本地时间
2015-04-19 12:20:00
>>> print(datetime.utcfromtimestamp(t)) # UTC时间
2015-04-19 04:20:00

>>> from datetime import datetime
>>> cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
>>> print(cday)
2015-06-01 18:19:59

注意转换后的datetime是没有时区信息的

>>> from datetime import datetime, timedelta
>>> now = datetime.now()
>>> now
datetime.datetime(2015, 5, 18, 16, 57, 3, 540997)
>>> now + timedelta(hours=10)
datetime.datetime(2015, 5, 19, 2, 57, 3, 540997)
>>> now - timedelta(days=1)
datetime.datetime(2015, 5, 17, 16, 57, 3, 540997)
>>> now + timedelta(days=2, hours=12)
datetime.datetime(2015, 5, 21, 4, 57, 3, 540997)

>>> from datetime import datetime, timedelta, timezone
>>> tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
>>> now = datetime.now()
>>> now
datetime.datetime(2015, 5, 18, 17, 2, 10, 871012)
>>> dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
>>> dt
datetime.datetime(2015, 5, 18, 17, 2, 10, 871012, tzinfo=datetime.timezone(datetime.timedelta(0, 28800)))

# 拿到UTC时间，并强制设置时区为UTC+0:00:
>>> utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
>>> print(utc_dt)
2015-05-18 09:05:12.377316+00:00
# astimezone()将转换时区为北京时间:
>>> bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
>>> print(bj_dt)
2015-05-18 17:05:12.377316+08:00
# astimezone()将转换时区为东京时间:
>>> tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
>>> print(tokyo_dt)
2015-05-18 18:05:12.377316+09:00
# astimezone()将bj_dt转换时区为东京时间:
>>> tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
>>> print(tokyo_dt2)
2015-05-18 18:05:12.377316+09:00

先通过utcnow()拿到当前的UTC时间，时区转换的关键在于，拿到一个datetime时，要获知其正确的时区，然后强制设置时区，作为基准时间

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'

注意默认值是调用函数返回的，而函数在创建defaultdict对象时传入

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

OrderedDict的Key会按照插入的顺序排列，不是Key本身排序

>>> from collections import Counter
>>> c = Counter()
>>> for ch in 'programming':
...     c[ch] = c[ch] + 1
...
>>> c
Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})
>>> c.update('hello') # 也可以一次性update
>>> c
Counter({'r': 2, 'o': 2, 'g': 2, 'm': 2, 'l': 2, 'p': 1, 'a': 1, 'i': 1, 'n': 1, 'h': 1, 'e': 1})

$ ./backup.py -u root -p hello --database testdb backup.sql
parsed args:
outfile = backup.sql
host = localhost
port = 3306
user = root
password = hello
database = testdb
gzcompress = False

import hashlib

md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?'.encode('utf-8'))
print(md5.hexdigest())

import hashlib

sha1 = hashlib.sha1()
sha1.update('how to use sha1 in '.encode('utf-8'))
sha1.update('python hashlib?'.encode('utf-8'))
print(sha1.hexdigest())

>>> import itertools
>>> natuals = itertools.count(1)
>>> for n in natuals:
...     print(n)
...
1
2
3
...

>>> import itertools
>>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种
>>> for c in cs:
...     print(c)
...
'A'
'B'
'C'
'A'
'B'
'C'
...

>>> ns = itertools.repeat('A', 3)
>>> for n in ns:
...     print(n)
...
A
A
A

>>> for c in itertools.chain('ABC', 'XYZ'):
...     print(c)
# 迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'

>>> for key, group in itertools.groupby('AAABBBCCAAA'):
...     print(key, list(group))
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']

这个decorator接受一个generator，用yield语句把with ... as var把变量输出出去，然后，with语句就可以正常地工作了

from contextlib import contextmanager

class Query(object):

    def __init__(self, name):
        self.name = name

    def query(self):
        print('Query info about %s...' % self.name)

@contextmanager
def create_query(name):
    print('Begin')
    q = Query(name)
    yield q
    print('End')

@contextmanager
def tag(name):
    print("<%s>" % name)
    yield
    print("</%s>" % name)

with tag("h1"):
    print("hello")
    print("world")

from contextlib import closing
from urllib.request import urlopen

with closing(urlopen('https://www.python.org')) as page:
    for line in page:
        print(line)

实际上是：

@contextmanager
def closing(thing):
    try:
        yield thing
    finally:
        thing.close()

from urllib import request

with request.urlopen('https://api.douban.com/v2/book/2129650') as f:
    data = f.read()
    print('Status:', f.status, f.reason)
    for k, v in f.getheaders():
        print('%s: %s' % (k, v))
    print('Data:', data.decode('utf-8'))

模拟浏览器发送GET请求

模拟微博登录

10000000000 == 10_000_000_000

0.000012 == 1.2e-5

1.23 乘 10 的 9次幂 == 1.23e9

ord() 获取字符整数表示

chr() 整数转换成对应字符

encode() 表示字符串 str 编码为 字节 bytes

decode() 和 encode() 相反

len() 

格式化

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

超越索引范围返回 IndexError 错误

索引值带上 - 符号可倒序获取列表元素

直接赋值某个索引上的值

len() 获取list 元素个数

append() 追加列表元素

insert() 指定位置插入元素

pop() 删除list末尾元素,返回最后一个元素值

list() 

classmates = ('python', 'php', 'go')

注意单个元素时的初始化 必须加一个逗号,，来消除歧义

初始化空tuple

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}

key必须是不可变对象

无序

通过 in  判断key 是否存在

get() 方法，不存在返回 None

pop(key)

查找和插入的速度极快，不会随着key的增加而变慢

需要占用大量的内存，内存浪费多

set(list) 初始化

add(key) 添加元素，可重复添加

remove(key) 删除元素

获取交集、并集

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

>>> f = abs
>>> f(-10)
10

可修改系统函数，但一般不建议这样操作

返回值是一个tuple

默认参数

可变参数

关键字参数

命名关键字参数

参数组合

由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出

接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

过滤序列

接收一个key函数来实现自定义的排序

反向排序，传入第三个参数 reverse=True

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

可再创建一个函数，用该函数的参数绑定当前循环变量当前的值

def inc():
    x = 0
    def fn():
        nonlocal x
        x = x + 1
        return x
    return fn

f = inc()
print(f()) # 1
print(f()) # 2

# 创建一个接受两个参数的 lambda 函数，并返回它们的和
add_func = lambda x, y: x + y

# 调用 lambda 函数计算 3 和 4 的和
result = add_func(3, 4)
print(result)  # 输出 7

无参数

有参数

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

函数用于创建一个整数序列，通常用于循环中指定范围

open() 打开文件，不存在则抛出 IOError 错误，存在则返回文件描述符对象 file-like Object

StirngIO() ，读写字符串

BytesIO() ，读写bytes

f.read() 一次性读取文件全部内容，可传入 size ，反复调用 read(size) 避免一次性读取大文件

f.readline() 每次读取一行内容

f.readlines() 一次读取所有内容并按行返回list

f.write() 写入文件

f.close() 文件使用完毕后必须关闭

f.seek() 移动文件指针

pickle模块

json 模块

age = 15

match age:
    case x if x < 10:
        print(f'< 10 years old: {x}')
    case 10:
        print('10 years old.')
    case 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18:
        print('11~18 years old.')
    case 19:
        print('19 years old.')
    case _:
        print('not sure.')

args = ['gcc', 'hello.c', 'world.c']
# args = ['clean']
# args = ['gcc']

match args:
    # 如果仅出现gcc，报错:
    case ['gcc']:
        print('gcc: missing source file(s).')
    # 出现gcc，且至少指定了一个文件:
    case ['gcc', file1, *files]:
        print('gcc compile: ' + file1 + ', ' + ', '.join(files))
    # 仅出现clean:
    case ['clean']:
        print('clean')
    case _:
        print('invalid command.')

sum = 0
for x in range(101):
    sum = sum + x
print(sum)

n = 1
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

>>> L[:10:2]
[0, 2, 4, 6, 8]

>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

>>> from collections.abc import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

>>> for ch in 'ABC':
...     print(ch)
...
A
B
C

使用 for 循环迭代

使用索引迭代

使用 enumerate() 迭代

使用 while 循环迭代

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

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

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

>>> [x if x % 2 == 0 else -x for x in range(1, 11)]
[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

for i in fib(3):
     print(i)

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

直接作用于for 循环的对象统称为可迭代对象：Iterable

isinstance()判断一个对象是否是Iterable对象

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的

class Student(object):
    pass

继承

多态

与实例绑定的函数

__init__(self, 其他属性字段) 方法

私有变量

类属性

实例属性

实例属性

实例方法

类方法

使用__slots__

通过属性形式调用方法

属性的方法名不要和实例变量重名

__init__(self, ...)

__str__(self)

__repr__(self)

__del__(self)

__call__(self, ...)

__getitem__(self, key)

__setitem__(self, key, value)

__len__(self)

__iter__(self) 和 __next__(self)

判断两个变量类型是否相同

动态创建类

一个对象是否是该类型本身，或者位于该类型的父继承链上

获得一个对象的所有属性和方法

通过包（Package）按目录组织模块，包目录下必须存在__init__.py 文件

不能和Python自带的模块名称冲突

检查是否存在，可在python交互环境执行 import 模块 ，成功即存在

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

' a test module '

__author__ = 'Michael Liao'

非公开（private）变量

pip install XXXX

常用工具

import xxx模块

try ... except ... finally ...

无论是否异常都会执行finally，可以不设置 finally

所有错误类型都继承自 BaseException

从上往下调用

logging 模块

raise 抛出错误实例

def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'
    return 10 / n

def main():
    foo('0')

assert语句本身就会抛出AssertionError

启动Python解释器时可以用-O参数来关闭assert

-m pdb 启动，例如 python -m pdb err.py

pdb.set_trace()

测试类需继承 unittest.TestCase

以 test 开头的方法才是测试方法

期待抛出指定类型的Error

assertEqual(a, b)：断言 a 和 b 相等

assertTrue(x)：断言 x 为 True

assertFalse(x)：断言 x 为 False

assertIn(a, b)：断言 a 存在于 b 中

assertIsInstance(a, b)：断言 a 是 b 的实例

assertRaises(exception, callable, *args, kwargs) 断言调用 callable 时会引发特定的异常

新增以下代码后直接运行 python mydict_test.py

命令行通过参数-m unittest直接运行单元测试