python_learn Ⅰ

时间 2019-11-11

标签 python learn 栏目 Python 繁體版

原文原文链接

基于廖雪峰python3教程学习。html

目录：java

01_输入输出.py
02_list、tuple.py
03_条件判断.py
04_循环.py
05_利用循环排序.py
06_自定义3元2次方程的根求解函数.py
07_函数的参数.py
08_递归函数.py
09_切片.py
10_迭代、索引.py
11_列表生成式.py
12_元组循环迭代列表生成式输出天干地支.py
13_将列表大小写字符所有小写输出.py
14_生成器.py
15_生成器生成斐波拉契数列.py
16_生成器生成杨辉三角.py
17_迭代器.py
18_高阶函数_map、reduce.py
19_filter.py
20_sorted.py
21_返回函数.py
22_匿名函数.py
23_偏函数.py
24_类和实例.py
25_访问限制.py
26_继承和多态.py
27_获取对象信息.py
28_实例属性和类属性.py
29_限制实例属性__slots__.py
30_使用@property.py
31_多重继承.py
32_枚举类.py
33_文件读写.py
34_StringIO_BytesIO.py
35_操做文件和目录.py
36_代码实现dir -l功能.py
37_序列化_pickle模块.py
38_JSON.py
39_多进程.py
40_多线程.py
41_正则表达式.py
42_datetime模块.py
43_collections模块.py
44_base64模块.py
45_hashlib模块.py
46_hmac模块.py
47_itertools模块.py
48_contextlib模块.py
49_urllib模块.py
50_XML解析.py
51_HTMLParser模块.py
52_pillow模块.py
53_requests模块.py
54_chardet模块.py
55_psutil模块.py
56_TCP编程.py
57_UDP编程.py
58_SMTP发送邮件.py
59_POP3收取邮件.py
60_使用SQLite.py
61_使用MySQL.py
62_使用SQLAIchemy.py
63_WSGI接口.py

条件判断

#!/usr/bin/env python
# -*- coding: utf-8 -*-
h = float(input('请输入你的身高: '))
w = float(input('请输入你的体重: '))
bmi =float('%.1f' % (w//(h*h)))

if bmi<18.5:
    print('您的体重太轻')
elif bmi<25:
    print('您的处于正常范围')
elif bmi<28:
    print('您体重太重')
elif bmi<32:
    print('您处于肥胖状态')
else:
    print('您严重肥胖')

循环

#!/usr/bin/env python
# -*- coding: utf-8 -*-
L = ['Bart','Lisa','Adam']
for x in L:
    print('hello,',x)

利用循环排序

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

array = [1, 2, 5, 3, 6, 8, 4]
for i in range(len(array) - 1, 0, -1):
    print(i)
    for j in range(0, i):
        print(j)
        if array[j] > array[j + 1]:
            array[j], array[j + 1] = array[j + 1], array[j]
print(array)

三元二次方程求解

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import math
def quadratic(a,b,c):
    for s in (a,b,c):
        if not isinstance(s, (int, float)):
            raise TypeError('数字类型输入错误，请从新输入')
    d = float(b*b-4*a*c)
    if d < 0:
        print('方程无解')
    elif d == 0:
        x = (b + math.sqrt(d))/ (2*a)
        print('方程仅一个解: %.1f' % x)
    else:
        x1 = (b + math.sqrt(d))/(2*a)
        x2 = -(b + math.sqrt(d))/(2*a)
        print('方程有两个解: %.1f' % x1,x2)

quadratic(1,4,4)

函数的参数

#!/usr/bin/env python
#-*- coding: utf:8 -*-
# 阶乘函数
def power(x,n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

def power(x,n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

print(power(4,3))
print(power(5))

递归函数

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 利用递归函数计算阶乘
# N! = 1 * 2 * 3 * ... * N
def fact(n):
    if n == 1:
        return 1
    return n * fact(n-1)

print('fact(1) =', fact(1))
print('fact(5) =', fact(5))
print('fact(10) =', fact(10))
print('递归调用次数太多容易出现栈溢出')
print('--------------------------')

# 利用递归函数移动汉诺塔:
def move(n, a, b, c):  # n 为最初A柱子上的圆盘个数，将其从A移到C，B为缓冲区
    if n == 1:
        print('move', a, '-->', c)  # n=1 时，直接从A到C
    else:
        move(n-1, a, c, b)  # n 个时，先将 n-1 从A移到B
        move(1, a, b, c)  # 再将剩下最大的一个从A移到C
        move(n-1, b, a, c)  # 将刚才放在B上的 n-1 从B移到C
move(3, 'A', 'B', 'C')

切片

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

# 切片只能在list列表和tuple元组中，dict字典中不能进行切片输出

# list
L = list(range(20))
print(L)        #输出列表L
print(L[:])      #同上，输出全部列表数字，从起始到结束，起始结束位置可不写
print(L[:5])    #输出前5个数字，起始位置可省略
print(L[-3:])    #输出后3个数字，结尾位置可省略
print(L[::2])    #每隔一位输出L列表（输入偶数位）
print(L[1::2])  #从第一位起每隔两位输出L列表（输出奇数位）
print(L[::-1])  #倒序输出列表L
print(L[::-3])  #倒序每隔两位输出L
print('------------------------------------------------------------')

# tuple
s = (1,2,3,4,5)
print(s[:])
print(s[::-1])

迭代、索引

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

#使用for...in...输出就是一种迭代
d = {'a':5, 'b':6, 'c':7, 'd':8}

for key in d:
    print(key)    #迭代输出字典d的字符

print('-----------------分隔符----------------')

for value in d.values():
    print(value)  #迭代输出字典d的字符的值

print('-----------------分隔符-----------------')

#enumerate()函数能够索引列举 list、tuple、dict 里面的内容
for zifu in d:
    print('输出字典d的内容:',zifu)

for value in d.values():
    print('输出字典d的字符值:',value)

for suoyin in enumerate(d):
    print('索引列举出字典d的内容:', suoyin)  #索引单个参数输出的是元组，如 （1, 2）

for key,hey in enumerate(d):
    print('索引列举出 key,hey:', key,hey)  #索引多个参数输出的是 字符序号 和 字符内容自己。

for x,y in ((1,1),(2,4),(3,9)):
    print(x,y)

print('-----------------分隔符-----------------')

#迭代可输出 列表、元组、字典、字符串，但不能迭代整数
#判断是否可迭代, isinstance() 判断对象类型
from collections import Iterable
print('isinstance([1,2,3],Iterable):', isinstance([1,2,3],Iterable))
print('isinstance((1,2,3),Iterable):', isinstance((1,2,3),Iterable))
print("isinstance({'a':1, 'b':2, 'c':3},Iterable):", isinstance({'a':1, 'b':2, 'c':3},Iterable))
print("isinstance('ABC'),Iterable:", isinstance('ABC',Iterable))
print('isinstance(123,Iterable):', isinstance(123,Iterable))

列表生成式

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

#列表生成三种方法
print('法一：直接经过range()生成')
print(list(range(10)))

print('法二：经过循环在空列表末尾叠加')
L = []
for x in range(10):
    L.append(x*x)
print(L)

print('法三：列表生成式')
print([x*x for x in range(10)])              #直接列表生成式输出
print([x*x for x in range(10) if x%2==0])    #输出偶数的平方列表
print([x+y for x in 'ABCD' for y in 'EFGH'])  #二层循环输出列表

# *.values()、*.items()函数使用
d = {'A':'a', 'B':'b', 'C':'c', 'D':'d'}
for x in d.values():
    print(x)              #输出字符的值

for y,z in d.items():
    print(y,'=',z)        #将字符的值赋值给字符，即 A=a

元组循环迭代列表生成式输出天干地支

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

#天干地支
print('***** 法一：循环 *****')

a=('甲','乙','丙','丁','戊','己','庚','辛','壬','癸')
b=('子','丑','寅','卯','辰','巳','午','未','申','酉','戌','亥')
c=[]
for i in range(60):
    print(i)
    c.append(a[i%len(a)]+b[i%len(b)])
print(c)

print('------------------------------------------------------')

print('***** 法二：列表生成式 *****')
#列表生成式一句代替法一循环输出，代码更简洁
a = ['甲','乙','丙','丁','戊','己','庚','辛','壬','癸']
b = ['子','丑','寅','卯','辰','巳','午','未','申','酉','戌','亥']
c = [a[i%len(a)]+b[i%len(b)] for i in range(60)]
print (c)

将列表大小写字符所有小写输出

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

#将列表的内容所有小写输出

print('--------- 场景一 ---------')
L = ['Hello', 'World', 'Apple']
print([s.lower() for s in L])


print('--------- 场景二 ---------')
L1 = ['Hello', 'World', 18, 'Apple', None]
#print([s.lower() for s in L1])  在L列表中能这样，L1中不能这样输出，由于 *.lower()函数对象只针对于字符串，不能对整型，空值进行。
L2 = []
for s in L1:
    if isinstance(s, str):    # isinstance()函数 判断 变量类型
        L2.append(s.lower())
    else:
        L2.append(s)
print(L2)

生成器

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

#列表生成
L = [x*x for x in range(10)]
print(L)
print('----------- 分隔符 ----------')

#生成器，不一次生成，有效解决列表生成式循环次数过多带来的内存限制及空间浪费，生成器边循环边计算边输出
g = (x*x for x in range(10))
print('第一个:',next(g))
print('第二个:',next(g))
print('第三个:',next(g))
print('第四个:',next(g))
print('----------- 分隔符 ----------')

#生成器也可利用循环一次单行输出全部，不用向上面每次敲 next(g)
g = (x*x for x in range(10))
for s in g:
    print(s)
print('----------- 分隔符 ----------')

#生成器一次输出成一个列表，如最上面的列表生成同样
g = (x*x for x in range(10))
print([n for n in g])

生成器生成斐波拉契数列

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

#斐波拉契数列：从第三位起，每位数都等于前两位数字的和
# 1，1，2，3，5，8，13，21，34，...

#方法一：判断、循环自定义显示斐波拉契数列的数字个数
max = int(input('请输入列表显示的位数 max：'))
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
print(fib(max))
print('----------------- 分隔符 ----------------')

#方法二：生成器生成，使用了 yield ，而后循环列出，输出没有 None 字符
min = int(input('请输入列表显示的位数 min：'))
def fab(min):
    n, a, b = 0, 0, 1
    while n < min:
        yield b
        a, b = b, a+b
        n = n + 1

L = []
for i in fab(min):
    L.append(i)
print(L)
print('------------ 分隔符 -----------')

#方法三：递归、循环自定义显示斐波拉契数列的数字个数
def xh(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return xh(n-1)+xh(n-2)

L = []
a = int(input('请输入列表显示的位数 a：'))
for s in range(1,a+1):
    L.append(xh(s))
print(L)

# 以上第一种和第三种会因函数中的变量值的加大而损耗内存，第二种生成器生成的，使用 yield 每次执行一次循环就挂起，
# 下次再从挂起的地方调用，不会一次性生成完，从而不会占用系统资源。虽然在此输出结果是相同的，这是由于for...in...
# 循环调用输出的次数使其所有输出了。

生成器生成杨辉三角

迭代器

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

# 可直接做用于 for 循环的对象统称为 可迭代对象：Iterable
# list、tuple、dict、str、for循环，是可迭代对象，整数不是可迭代对象。ininstance()判断 变量类型。
from collections import Iterable
print('isinstance([],Iterable):',isinstance([],Iterable))
print('isinstance((),Iterable):',isinstance((),Iterable))
print('isinstance({},Iterable):',isinstance({},Iterable))
print("isinstance('abc',Iterable):",isinstance('abc',Iterable))
print('isinstance((x for x in range(10)),Iterable):',isinstance((x for x in range(10)),Iterable))
print('isinstance(100,Iterable):',isinstance(100,Iterable))
print('-------------------- 分隔符 ------------------')


# 不但能够做用于 for 循环，还能够被next()函数不断调用并返回下一个值的叫 迭代器：Iterator
# list、tuple、dict、str、int 不是 迭代器，for 循环的 为 迭代器
from collections import Iterator
print('isinstance([],Iterator):',isinstance([],Iterator))
print('isinstance((),Iterator):',isinstance((),Iterator))
print('isinstance({},Iterator):',isinstance({},Iterator))
print("isinstance('abc',Iterator):",isinstance('abc',Iterator))
print('isinstance((x for x in range(10)),Iterator):',isinstance((x for x in range(10)),Iterator))
print('isinstance(100,Iterator):',isinstance(100,Iterator))
print('-------------------- 分隔符 ------------------')


# 将 可迭代对象 变为 迭代器 可使用 iter() 函数
from collections import Iterator
print('isinstance(iter([]),Iterator):',isinstance(iter([]),Iterator))
print('isinstance(iter(()),Iterator):',isinstance(iter(()),Iterator))
print('isinstance(iter({}),Iterator):',isinstance(iter({}),Iterator))
print("isinstance(iter('abc'),Iterator):",isinstance(iter('abc'),Iterator))
print('isinstance((x for x in range(10)),Iterator):',isinstance((x for x in range(10)),Iterator))
print('isinstance(iter(100),Iterator):',isinstance(iter(100),Iterator))  # 注：整数不是 可迭代对象，因此加iter()也不能成为迭代器

# 小结：凡是可做用于for循环的对象都是Iterable类型；
# 凡是可做用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
# 迭代器都是可迭代对象，可迭代对象不必定是迭代器。

高阶函数map、reduce

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

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

# 示例一
def f(x):
    return x*x
r = map(f, [1, 2, 3, 4, 5])
print(list(r))

# 示例二
print(list(map(str, [1, 2, 3, 4, 5])))
print('------------------------------')


# reduce()：做用在序列上，函数必须接收两个参数。将结果继续和序列下一个元素作累积计算。
# 在python3 中使用reduce函数要先从库中加载

# 示例一：列表元素求和
from functools import reduce
def sum(x,y):
    return x+y
print(reduce(sum, [1, 2, 3, 4, 5]))

# 示例二：将 [1,3,5,7,9] 输出为 13579
from functools import reduce
def fn(m, n):
    return 10 * m + n
print(reduce(fn, [1, 3, 5, 7, 9]))
print('------------------------------')

# 练习一：
# 利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其余小写的规范名字。
# 输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']
# 大写字母转小写函数 lower(), 小写字母转大写函数 upper()
L1 = ['adam', 'LISA', 'barT']
def normalize(name):
    return name[0].upper()+name[1:].lower()
L2 = list(map(normalize, L1))
print(L2)
print('------------------------------')

# 练习二：
# sum()函数和上面reduce()函数代码都可求 list 的和，仿照定义 pord() 函数，求 list 的积
from functools import reduce
def s(x,y):
    return x * y
L = [3, 5, 7, 9]
def prod(L):
    return reduce(s, L)
print(prod(L))

print('------------------------------')

# 练习三：
# 利用 map 和 reduce 编写一个 str2float 函数，把字符串'123.456'转换成浮点数123.456
from functools import reduce
def str2float(s):
    s = s.split('.')    #以小数点为分隔符，把字符串分为两部分
    def f1(x,y):        #函数1，小数点以前的数用这个函数处理
        return x * 10 + y
    def f2(x,y):        #函数2，小数点以后的数用这个函数处理
        return x / 10 + y
    def str2num(str):    #函数3，用于把字符串'123'逐个变为数字
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[str]
    return reduce(f1,list(map(str2num,s[0]))) + reduce(f2,list(map(str2num,s[1]))[::-1])/10

print(str2float('123.456'))
# 最后一步是这个解法的精髓：
# 小数点前的数'123'，用 x * 10 + y 正常求和就能得出123，小数点以后的数'456'要怎样才能得出0.456呢？
# 首先把字符串'456'用list(map(str2num,s[1]))转成一个列表[4,5,6]
# 而后用[::-1]切片的方式从后往前取，列表变为[6,5,4]
# 而后把[6,5,4]利用reduce函数放到f2函数中计算，( 6 / 10 + 5) / 10 + 4 = 4.56，得出结果4.56
# 再除以一个10，得出0.456，到此成功把字符串'456'变成了浮点数0.456
# 把先后结果加起来，就获得了最终解，成功把字符串'123.456'变成了浮点数123.456

filter

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

# 与map()相似，filter()也接收一个函数和一个序列。
# 和map()不一样的是，filter()把传入的函数依次做用于每一个元素，而后根据返回值是True仍是False决定保留仍是丢弃该元素。
# 而map()仅返回 True or False
def is_odd(n):
    return n % 2 == 1
print(list(filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])))  # filter() 将自定义函数 is_odd() 为True的值返回
print(list(map(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])))      # map() 仅判断 True or False，不做筛选
print('----------------------------------------------------------')


# 练习一：计算素数
# 首先，列出从2开始的全部天然数，构造一个序列：
# 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
# 取序列的第一个数2，它必定是素数，而后用2把序列的2的倍数筛掉：
# 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
# 取新序列的第一个数3，它必定是素数，而后用3把序列的3的倍数筛掉：
# 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
# 取新序列的第一个数5，而后用5把序列的5的倍数筛掉：
# 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
# 不断筛下去，就能够获得全部的素数。

def _odd_iter():    # 选取从 2 以后，且不为2倍数的数
    n = 1
    while True:
        n = n + 2
        yield n

def _not_divisible(n):    # 筛选掉以上所选数的倍数
    return lambda x: x % n > 0

def primes():    # 迭代过滤出知足要求的数 n
    yield 2
    it = _odd_iter()
    while True:
        n = next(it)
        yield n
        it = filter(_not_divisible(n), it)

def main():        # 给 n 一个取值，输出这些数
    for n in primes():
        if n < 10:
            print(n)
        else:
            break

if __name__ == '__main__':
    main()

print('----------------------------------------------------------')

# 练习二：列出 1~1000 的回数(顺着倒着读都同样，如：12321，909)，使用filter()过滤掉非回数
def is_palindrome(n):
    return str(n) == str(n)[::-1]

output = filter(is_palindrome, range(1, 1000))
print(list(output))

sorted

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

# sorted() 函数能够对list元素按小到大排序
print(sorted([36, 5, -12, 9, -21]))

# 此外 sorted() 也是一个高阶函数
print(sorted([36, 5, -12, 9, -21], key=abs))

# 字符串也是能够排序的，按的首字母ASCII的大小
print(sorted(['bob', 'about', 'Zoo', 'Credit']))

# 若是要按字母顺序，就须要加参数排除首字母大小写 ASCII 大小不一的干扰
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower))

print('-----------------------------------')

# 练习：
# 一组学生名字和成绩tuple，分别按名字字母、成绩排序
# L = [('Bob', 75), ('adam', 92), ('bart', 66), ('Lisa', 88)]

L = [('Bob', 75), ('adam', 92), ('bart', 66), ('Lisa', 88)]
def by_name(name):
    return name[0].lower()

def by_score(score):
    return score[1]

print(sorted(L, key=by_name))
print(sorted(L, key=by_score))
# 对于单个元组，（名字，成绩）： name[0] 为名字，score[1] 为成绩

返回函数

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

# 函数做为返回值
# map reduce filter sorted 等高阶函数，它们将函数做为参数，除次以外，函数还可做为返回值。

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

f = lazy_sum(1, 2, 4, 5, 7, 8, 9)
print(f)    # 输出错误，由于输出f时，f = lazy_sum() ，输出的是 lazy_sum() 函数里面的 sum() 求和函数
print(f())  # 输出 f() 时，才是输出 求和函数 sum() 的计算结果

f2 = lazy_sum(1, 2, 4, 5, 7, 8, 9)
print( f==f2 )      # 调用lazy_sum()时，每次调用都会返回一个新的函数，即便传入相同的参数。 因此 False
print( f()==f2() )  # 函数的参数同样，返回的结果值也同样，因此 True

# *args 与 **args 的区别：
# *args和**args适用于函数的参数不肯定的时候。*args能够看作是多个变量组成的tuple，**args能够看作是个字典。

# def funarg1(arg):  #只容许传入一个参数
#    print(arg)
# funarg1(1)
# >>1          #输出执行结果

# def funarg(arg1,arg2,arg3): #必须传入3个参数
#    print(arg1,arg2,arg3)
# funarg(1,2,3)
# >>1,2,3      #输出执行结果

# def funargs(*args): #能够传入任意数量个参数（包括零个）
#    for i in args:
#        print(i)
# funargs(1,2,3,4,5)  #传入5个参数
# list2=(2,3,4,5,6)
# funargs(list2)      #传入列表
# funargs()
# >>1 2 3 4 5 (2,3,4,5,6)

print('----------------------------')

# 闭包
# why f1(), f2(), f3() returns 9, 9, 9 rather than 1, 4, 9?
def count():
    fs = []
    for i in range(1, 4):
        def f():
            return i * i
        fs.append(f)        # 此时函数f并无执行，只是返回了函数f
    return fs
f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())

print('----------------------------')

def count():
    fs = []
    for i in range(1, 4):
        def f():
            return i * i
        fs.append(f())        # 此时函数f执行了，返回了具体的结果数值。这就不属于 返回函数 了
    return fs

f1, f2, f3 = count()

print(f1)
print(f2)
print(f3)

print('----------------------------')

# fix:
def count():
    fs = []
    def f(n):
        def j():
            return n * n
        return j
    for i in range(1, 4):
        fs.append(f(i))  # f(i)马上被执行，所以i的当前值被传入f()
    return fs

f1, f2, f3 = count()

print(f1())
print(f2())
print(f3())

# 小结：
# 函数既能够的做为高阶函数的参数，又能够做为一个函数的返回函数。
# 返回一个函数时，该函数并未执行，返回函数中不要引用任何可能会变化的变量。

匿名函数

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

# 匿名函数 lambda x: x * x
# 匿名函数简介方便，不用事先定义，也不用担忧函数重名，但其只有有一个参数，一个表达式。

print(list(map(lambda x: x * x, [1, 2, 3, 4, 5])))

# 等同于：
def f(x):
    return x * x
print(list(f(x) for x in [1, 2, 3, 4, 5]))

偏函数

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

# int()函数能够把字符串转换成整数
print(int('12345'))

# int()还可提供额外的base参数
print(int('12345',base=8))  #转化成8进制

print('----------------')

# 若是常常转换，每次都加 base 参数，很麻烦，能够定义一个函数
def int2(x,base=2):
    return int(x, base)

print(int2('1011010'))

print('----------------')

# 其实不用自定义函数，python自带的 functools.partial()偏函数 就能实现这一功能
import functools
int2 = functools.partial(int,base=2)  # functools.partial 就建立了一个偏函数

print(int2('1011010'))

类和实例

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

# 面向对象编程
# 类和实例

# 类是一个抽象的模版，实例是根据类建立出来的具体对象，属性是这个实例所具备的能力
# 好比说猫类、狗类，而后狗类里面又有具体的实例(泰迪、金毛、二哈)，这些狗的实例都具备的属性(爱吃肉、骨头、会游泳)

# 定义 类 使用 class：
# class Student(object):
#    psss
# class 后面紧跟 类名(Student)， 类名通常首字母大写。(object)表示该类从哪一个类继承下来的。

# 定义 实例， 经过 类名+()实现
class Student(object):    # 建立Student类
    pass
bart = Student()      # 建立 bart 实例
bart.name = 'simpson'  # 给实例绑定属性，name，这个实例叫什么
print(bart.name)

# 建立实例的时候，把一些必须绑定的属性强制填写进去，经过 __init__ 方法 添加上相关属性。
# 以双下划线'__'开头和结尾的是特殊变量
class Student(object):
    def __init__(self, name, score):    # __init__ 方法的第一个参数永远是 self
        self.name = name
        self.score = score
bart = Student('simpson', 99)
print(bart.name)
print(bart.score)

print('------------------- ')


# 数据封装
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s: %s' % (self.name, self.score))
    def grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'
# 以上整个类能够封装起来，对于用户来讲，只要输入 名字、成绩 便可，不须要了解过程

# 输入
bart = Student('simpson', 99)
bart1 = Student('john', 67)
bart2 = Student('tom', 34)

# 输出
print('bart.name=', bart.name)
print('bart.score=', bart.score)
bart.print_score()
print('grade of bart:', bart.grade())
print('grade of bart1:', bart1.grade())
print('grade of bart2', bart2.grade())

访问限制

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

# 普通的类、实例、属性代码，可执行无报错
class Student():
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s: %s' % (self.name, self.score))

bart = Student('simpson', 99)
print(bart.name)

# 作了访问限制的属性，从外部访问该实例的属性，不能执行，回显错误
class Student():
    def __init__(self, name, score):
        self.__name = name        # 学生类的 __name__ 属性，是内部属性，外部不可访问
        self.__score = score      # 学生类的 __score__ 属性，是内部属性，外部不可访问
    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

bart = Student('simpson', 99)
# print(bart.__name)    # 不可访问，代码报错。由于python解释器把 __name 变成了 _Student__name
print(bart._Student__name)    # 若是要在外部访问，可使用 _Student__name

继承和多态

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

# 继承：能够把父类的功能直接拿过来，也可新增本身的方法，也可覆盖重写父类的方法，
# 这也造就了子类比父类有更多的可能，造成多态。

class Animal(object):    # 父类 动物类
    def run(self):
        print('Animal is running...')

class Dog(Animal):      # 子类 狗类
    pass
class Cat(Animal):      # 子类 猫类
    pass

dog = Dog()
cat = Cat()

dog.run()    # 无需再定义run(),直接调用父类的函数
cat.run()

print('---------------------')

# 多态
class Animal(object):
    def run(self):
        print('Animal is running...')

class Dog(Animal):
    def run(self):
        print('Dog is running...')    # 覆盖父类的方法
    def eat(self):
        print('Liking eat meat.')      # 新增本身的方法

dog = Dog()

dog.run()
dog.eat()

获取对象信息

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

# type() 判断对象类型
print(type(123))    # int型
print(type('abc'))  # str
print(type(None))    # NoneType
print(type(abs))    # 函数方法

print(type(123)==type(456))  # 判断是否为同种类型， True or False。
print(type(123)==int)

print('----------------')

# isinstance() 与 type() 做用相同， isinstance() 多用于 class 继承关系里
class Animal(object):
    pass
class Dog(Animal):
    pass
class Husky(Dog):
    pass

a = Animal()
d = Dog()
h = Husky()

print(isinstance(h, Husky))
print(isinstance(h, Dog))
print(isinstance(h, Animal))

# dir()：得到一个对象的全部属性和方法
print(dir('ABC'))

# 除了把对象的属性和方法列出来，还可以使用 getattr()、setattr()、hasattr() 直接操做一个对象的状态
# getattr() 获取对象属性， setattr() 设置对象属性， hasattr() 询问对象是否有某属性
class MyObject(object):
    def __init__(self):
        self.x = 9
    def power(self):
        return self.x * self.x
obj = MyObject()

print(hasattr(obj, 'x'))    # obj 有 x 属性吗？
print(getattr(obj, 'x'))    # 获取 x 属性的结果
print(obj.x)                # 等同于 getattr()
print(hasattr(obj, 'y'))    # 询问是否有 y 属性

setattr(obj, 'y', 10)        # 设置 y 属性及其具体值
print(getattr(obj, 'y'))    # 获取 y 属性结果

实例属性和类属性

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

# 实例属性 和 类属性 不要使用相同的名字，同名的 实例属性 将覆盖 类属性，当删除 实例属性 后，访问的是 类属性

class Student(object):        # Student类
    name = 'Student'          # 类的 name 属性

s = Student()                # 类的 实例s

print(s.name)                # 打印 实例s 的 name属性，s并无该属性，往上找到它的类的 name属性
print(Student.name)          # 打印 类的 name属性

s.name = 'Michael'            # 给实例s设置一个name属性 Michael
print(s.name)                # 因为 实例属性 优先级比 类属性 高，覆盖 类属性，打印出 实例属性
print(Student.name)          # 打印 类属性

del s.name                    # 删除 实例属性
print(s.name)                # 输出的就是 类属性

限制实例属性slots

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

# 动态语言能够随时给实例绑定任何属性和方法
class Student(object):      # 定义一个类
    pass

s = Student()              # 建立类的 实例s
s.name = 'Michael'          # 动态给 实例s 加一个 name属性
print(s.name)

def set_age(self, age):    # 定义一个函数做为实例方法
    self.age = age

from types import MethodType
s.set_age = MethodType(set_age, s)    # 给 实例s 绑定 set_age 方法
s.set_age(25)        # 调用 set_age 方法
print(s.age)


s2 = Student()      # 建立类的 实例s2
# s2.set_age(15)      # 调用 set_age 方法
# print(s2.age)      # 输出结果出错，由于 s2 并未绑定 set_age 方法，给一个实例绑定方法，对另外一个实例不起做用

# 为了给全部实例都添加可调用的方法，可对 class 绑定方法
# 方法一：动态绑定，可在程序运行过程当中动态给 class 加上功能，这在静态语言中很难实现
def set_score(self, score):        # 程序任意位置定义 set_score 方法
    self.score = score

Student.set_score = set_score      # 给 Student类 绑定 set_score 方法

s.set_score(100)        # 实例s 可直接调用 class 方法
print(s.score)
s2.set_score(99)        # 实例s2 也可直接调用 class 方法
print(s2.score)

# 方法二：直接在最初建立类的地方定义类的方法
class Student(object):
    def set_score(self, score):
        self.score = score

# 特殊变量 __slots__  (前面还学习到特殊变量__init__)
# 该变量可限制实例属性，只容许添加定义的属性，至关于属性白名单。
# __slots__ 仅对当前类的实例生效，对其继承的子类实例不生效
class Student(object):
    __slots__ = ('name', 'age')    # 只容许定义这两种属性

s = Student()      # 建立实例
s.name = 'Tom'      # 添加实例 name属性
s.age = '17'        # 添加实例 age属性
# s.score = '90'    # 添加实例 score属性：不被容许，报错
print(s.name)
print(s.age)
# print(s.score)

class Xiaoming(Student):    # 建立子类 Xiaoming
    pass

y = Xiaoming()        # 建立实例y
y.name = 'xm'
y.age = '18'
y.score = '99'        # 父类中 禁用的属性，不影响 子类 的使用
print(y.name)
print(y.age)
print(y.score)        # 正常打印 y.score

使用@property

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

#属性函数(property)：
#将类方法转换为只读属性
#从新实现一个属性的setter和getter方法

class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

s = Student()
s.score = 60
print('s.score =', s.score)
# ValueError: score must between 0 ~ 100!
s.score = 9999

多重继承

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

# MixIn
#“混入”：Mix in。
# 在设计类的继承关系时，一般，主线都是单一继承下来的。可是，若是须要“混入”额外的功能，
# 经过多重继承就能够实现。

# 动物类
class Animal(object):
    pass

# 又将动物分为哺乳动物和鸟类:
class Mammal(Animal):
    pass
class Bird(Animal):
    pass

# 上面两类又能够细分各类动物类:
class Dog(Mammal):
    pass
class Bat(Mammal):
    pass
class Parrot(Bird):
    pass
class Ostrich(Bird):
    pass

# 上面的各类动物也能够按 地上跑的 和 天上飞的分类：
class Runnable(object):
    def run(self):
        print('Running...')

class Flyable(object):
    def fly(self):
        print('Flying...')

# 细分的动物能够继承多个类：
class Dog(Mammal, Runnable):
    pass
class Bat(Mammal, Flyable):
    pass

枚举类

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

# Enum能够把一组相关常量定义在一个class中，且class不可变，并且成员能够直接比较。能够枚举出该类。

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)

print('--------------------------------------')

from enum import Enum, unique

@unique
class Weekday(Enum):
    Sun = 0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

day1 = Weekday.Mon

print('day1 =', day1)
print('Weekday.Tue =', Weekday.Tue)
print('Weekday[\'Tue\'] =', Weekday['Tue'])
print('Weekday.Tue.value =', Weekday.Tue.value)
print('day1 == Weekday.Mon ?', day1 == Weekday.Mon)
print('day1 == Weekday.Tue ?', day1 == Weekday.Tue)
print('day1 == Weekday(1) ?', day1 == Weekday(1))

print('--------------------------------------')

for name, member in Weekday.__members__.items():
    print(name, '=>', member, ',', member.value)

文件读写

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

# 文件读取

# 文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。
# 因此，为了保证不管是否出错都能正确地关闭文件，咱们可使用try ... finally来实现：
try:
    f = open('/Users/xxx/Desktop/sqltest.txt', 'r')  #r 为read
    print(f.read())
finally:
    if f:
        f.close()

# 这么写太繁琐，Python引入了with语句来自动帮咱们调用close()方法
with open('/Users/xxx/Desktop/sqltest.txt', 'r') as f:
    print(f.read())

# 若是文件很小，read()一次性读取最方便；若是不能肯定文件大小，反复调用read(size)比较保险，
# 但一次次调用繁琐，因而能够调用下面两种：
# readline()能够每次读取一行内容，readlines()一次读取全部内容并按行返回list。
with open('/Users/xxx/Desktop/sqltest.txt', 'r') as f:
    print(f.read())
    for line in f.readlines():
        print(line.strip()) # 把末尾的'\n'删掉

# 二进制文件读取
f = open('/Users/michael/test.jpg', 'rb') #读取二进制文件(read bytes)，好比图片、视频等，用 rb 模式打开
print(f.read())

# 字符编码
f = open('/Users/michael/gbk.txt', 'r', encoding='gbk') #gbk编码
print(f.read())

# 写文件
# case1:
f = open('/Users/michael/test.txt', 'w')
f.write('hello world!')
f.close
# case2:
with open('/Users/michael/test.txt', 'w') as f:
    f.write('hello world!')

StringIO_BytesIO

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

# StringIO 在内存中读写str。
from io import StringIO
f = StringIO()
f.write('hello')
f.write(' ')
f.write('world!')
print(f.getvalue())

print('----------------------')

from io import StringIO
f = StringIO('Hello!\nHi!\nGoodbye!')
while True:
    s = f.readline()
    if s == '':
        break
    print(s.strip())
print('----------------------')

# StringIO操做的只能是str，若是要操做二进制数据，就须要使用BytesIO。
from io import BytesIO
f = BytesIO()
f.write('中文'.encode('utf-8'))
print(f.getvalue())

from io import BytesIO
f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
print(f.read())

操做文件和目录

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

# 在操做系统中对文件的操做能够直接使用cp、dir等系统命令完成。
# Python中内置的 os 模块也能够直接调用操做系统提供的接口函数。

import os
print(os.name) # 输出系统结果， nt 表明windows系统， posix 表明linux/unix/macos
#print(os.uname())  # 输出详细的系统信息（只针对于 非 windows系统，windows会报错）

# 输出环境变量
import os
print(os.environ)  # 输出环境变量

# 输出指定环境变量的值
print(os.environ.get('PATH'))  # 输出环境变量的路径


# 查看当前目录的绝对路径
print(os.path.abspath('.'))

# 在某个目录下建立一个新目录，首先把新目录的完整路径表示出来
print(os.path.join('/Users/xxx', '111'))
# windows下会显示 /Users/xxx\111 ，但不影响生成目录
# linux下会显示  /Users/xxx/111

# 在某个路径下新建一个新目录
print(os.mkdir('/Users/xxx/111'))

# 删除该新增目录
print(os.rmdir('/Users/xxx/111'))

# 目录拆分
print(os.path.split('/Users/xxx/111'))
# 这样能够把一个路径拆分为两部分，后一部分老是最后级别的目录或文件名

# os.path.splitext() 能够获得文件的扩展名
print(os.path.splitext('/Users/xxx/111/test.txt'))

#### 注： os.path.join()、os.path.split()、os.path.splitext()，合并、拆分不须要这些文件、
#### 文件夹真是存在，他们只对字符串进行操做。


# 文件重命名
print(os.rename('/Users/xxx/111/test.txt', '/Users/xxx/111/te.py'))

# 删除文件
print(os.remove('/Users/xxx/111/123.txt'))

# 建立文件能够结合前面的文件读写
with open('/users/xxx/111/123.txt', 'w') as f:
    f.write('hello world')

# 复制文件
# 虽然 os 模块没有复制文件的函数，但 shutil模块中有，它能够看做是 os模块的补充模块


# 过滤文件
# 输出当前目录下的文件夹
import os
L = [x for x in os.listdir('.') if os.path.isdir(x)]
print(L)

# 输出当前目录下的py文件
M = [x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1] == '.py']
print(M)

代码实现dir-l功能

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from datetime import datetime
import os

pwd = os.path.abspath('.')

print('      Size    Last Modified  Name')
print('------------------------------------------------------------')

for f in os.listdir(pwd):
    fsize = os.path.getsize(f)
    mtime = datetime.fromtimestamp(os.path.getmtime(f)).strftime('%Y-%m-%d %H:%M')
    flag = '/' if os.path.isdir(f) else ''
    print('%10d  %s  %s%s' % (fsize, mtime, f, flag))

序列化_pickle模块

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

# 序列化：
# Python中叫pickling。把变量从内存中变成可存储或传输的过程称之为序列化，如把内存中的字符字符串以二进制格式存储在硬盘上。

# 反序列化：
# Python中叫unpickling。反过来，把变量存储起来的内容从序列化的对象从新读到内存里称之为反序列化。

# 将一个对象序列化并写入文件:
# 1.将对象序列化：
import pickle
d = dict(name='Bob', age=20, score=80)
print(pickle.dumps(d))  # pickle.dumps() 方法将任意对象序列化成一个bytes

print('---------------------------')

# 2.写入文件(新建文件dump.txt)
f = open('dump.txt', 'wb')
pickle.dump(d, f)
f.close()

print('---------------------------')

# 将对象反序列化，从磁盘读取到内存
f = open('dump.txt', 'rb')
d = pickle.load(f)
f.close()
print(d)

JSON

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

# 不一样的编程语言之间传递对象，就必须把对象序列化为标准格式，好比XML，
# 但更好的方法是序列化为JSON。
# JSON不只是标准格式，而且比XML更快，并且能够直接在Web页面中读取，很是方便。

# json标准规定编码为 utf-8

# dumps()方法返回一个str，内容是标准json。相似dump()方法能够直接把json写入一个file-likes Object
import json
import pickle
d = dict(name='Bob', age=20, score=88)
print(json.dumps(d))

# 把json反序列化为Python对象，用loads()或者load()
# 前者把json字符串反序列化，后者从file-like Object中读取字符串并反序列化
json_str = '{"age":20, "score":88, "name":"Bob"}'
print(json.loads(json_str))

多进程

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

# unix/linux操做系统提供了一个 fork() 函数，
# 经过系统调用建立一个与原来进程几乎彻底相同的进程，这个新产生的进程称为子进程。
# 只须要调用getppid()就能够拿到父进程的ID。
# 子进程用getpid()查看PID。

import os
print('Process (%s) start...' % os.getpid())

# 如下在linux/unix/macos下执行，由于windows没有fork调用
'''
if pid == 0:
    print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
    print('I (%s) just created a child process (%s).' % (os.getpid(), pid))
'''

# multiprocessing：python多进程模块
from multiprocessing import Process
import os

# 子进程执行的代码
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('child process will start.')
    p.start()
    p.join()
    print('child process end.')
# join()方法 用于将序列中的元素以指定的字符链接生成一个新的字符串。


# Pool:进程池。用于要启用大量子进程时，批量建立子进程。
from multiprocessing import Pool
import os, time, random

def long_time_task(name):
    print('Run task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random()*3)
    end = time.time()
    print('Task %s runs %0.2f seconds.' % (name, (end-start)))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Pool(4)
    for i in range(5):
        p.apply_async(long_time_task, args=(i, ))
    print('Waiting for all subprocesses done...')
    p.close()
    p.join()
    print('All subprocesses done.')


# 子进程
# subprocess模块可让咱们很是方便地启动一个子进程，而后控制其输入和输出。
import subprocess

print('$ nslookup www.python.org') # 打印出内容，为显示好看，无实际做用。
r = subprocess.call(['nslookup', 'www.python.org'])
print('Exit code:', r)


import subprocess

print('$ nslookup')
p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b'set q=mx\npython.org\nexit\n')
print(output.decode('gbk'))
print('Exit code:', p.returncode)


# 进程间通讯
# Process之间确定是须要通讯的，操做系统提供了不少机制来实现进程间的通讯。
# Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。
from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q):
    print('Process to write: %s' % os.getpid())
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):
    print('Process to read: %s' % os.getpid())
    while True:
        value = q.get(True)
        print('Get %s from queue.' % value)

if __name__=='__main__':
    # 父进程建立Queue，并传给各个子进程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()
    # 启动子进程pr，读取:
    pr.start()
    # 等待pw结束:
    pw.join()
    # pr进程里是死循环，没法等待其结束，只能强行终止:
    pr.terminate()

多线程

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

# 多任务能够由多进程完成，也可由一个进程的多个线程完成。
# Python标准库提供 _thread(低级模块) 和 threading(高级模块) 两个模块进行多线程处理。

import time, threading

# 新线程执行的代码：
def loop():
    print('thread %s is running...' % threading.current_thread().name)
    n = 0
    while n<5:
        n = n+1
        print('thread %s >>> %s' % (threading.current_thread().name, n))
        time.sleep(1)
    print('thread %s ended.' % threading.current_thread().name)

print('thread %s is running...' % threading.current_thread().name)
t = threading.Thread(target=loop, name='LoopThread')
t.start()
t.join()
print('thread %s ended.' % threading.current_thread().name)


# Lock
# 多线程和多进程最大的不一样在于，多进程中，同一个变量，各自有一份拷贝存在于每一个进程中，
# 互不影响，而多线程中，全部变量都由全部线程共享，因此，任何一个变量均可以被任何一个线程修改，
# 所以，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。
import time, threading

balance = 0
lock = threading.Lock()

def change_it(n):
    global balance
    balance = balance + n
    balance = balance - n

def run_thread(n):
    for i in range(100000):
        # 先获取锁
        lock.acquire()
        try:
            # 更改数据
            change_it(n)
        finally:
            # 改完释放锁
            lock.release()


t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

# 注：
# 进程(Process) 比 线程(thread) 更稳定，windows下建立进程开销巨大。

正则表达式

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

# 正则表达式
# 正则表达式（Regular Expression，通常简写为RegEx或者RegExp），
# 也译为正规表示法、常规表示法，在计算机科学中，是指一个用来描述
# 或者匹配一系列符合某个句法规则的字符串的单个字符串。

# 用法细节见笔记“正则表达式”

# re模块
import re
print(re.match(r'^\d{3}\-\d{3,8}$', '010-12345'))
print(re.match(r'^\d{3}\-\d{3,8}$', '010 12345'))
# match()方法判断是否匹配成功，成功返回Match对象，失败返回None

print(r'a b  c'.split(' '))
print(re.split(r'\s+', 'a b  c'))

datetime模块

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

from datetime import datetime  # 导入datetime模块中的datetime类
now = datetime.now()
print(now)

print(type(now))

# 获取指定日期和时间
from datetime import datetime
dt = datetime(2015, 4, 19, 12, 20, 00)
print(dt)

# 1970年1月1日 00:00:00 UTC+00:00时区的时刻称为 epoch time
# 当前时间就是相对于epoch time的秒数，称为timestamp
# 示例：
# epochtime = 1970-1-1 00:00:00 UTC+0:00
# timestamp = 1970-1-1 09:00:00 UTC+9:00

# datetime 转换为 timestamp
# 使用timestamp()函数
from datetime import datetime
dt = datetime(2015, 4, 19, 12, 20, 00)
print(dt.timestamp())

# timestamp 转换为 datetime
# 使用 datetime 提供的 fromtimestamp()方法
from datetime import datetime
t = 1429417200.0
print(datetime.fromtimestamp(t))

# str转换为datetime
# 不少时候用户输入的是字符串，得把str转换datetime。
# 经过datetime.strptime()实现，须要一个日期和时间的格式化字符串
from datetime import datetime
cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
print(cday)

# datetime转换为str
# 若是已经有了datetime对象，将它格式化为字符串现实给用户，就须要转换str
# 用 strftime() 实现。
from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M'))

# 小结
# datetime表示的时间须要时区信息才能肯定一个特定的时间，不然只能视为本地时间。
# 若是要存储datetime，最佳方法是将其转换为timestamp再存储，由于timestamp的值与时区彻底无关。

collections模块

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

# collections是Python内建的一个集合模块，提供了许多有用的集合类。

# namedtuple()函数用来建立自定义 tuple对象，且规定 tuple元素的个数。
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])  # 规定tuple元素为 x, y
p = Point(1, 2)
print(p.x)
print(p.y)


# deque
# 实现高效插入与删除操做的双向列表，适合于队列和栈。
# （list是线性存储，按索引访问元素很快，但插入和删除元素就很慢）
from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print(q)

# defaultdict
# 使用dict时，若是引用的Key不存在，就会抛出KeyError。
# 使用defaultdict若是Key不存在会返回一个默认值。
from collections import defaultdict
dd = defaultdict(lambda : 'N/A')
dd['key1'] = 'abc'
print(dd['key1'])  # key1存在，正常输出
print(dd['key2'])  # key2不存在，返回默认值 N/A

# OrderedDict
# 在对dict作迭代时，key是无序的。OrderedDict会保持按插入的顺序输出。
# 即 FIFO（先进先出），当容量超出限制时，先删除最先添加的Key。
from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)  # 无序输出
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)  # 顺序输出，先入先出

# Counter
# Counter是一个简单的计数器，统计字符出现的次数。
from collections import Counter
c = Counter()
for ch in 'programming':
    c[ch] = c[ch] + 1
print(c)

base64模块

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

import base64
print(base64.b64encode(b'testtest'))  # 编码
print(base64.b64decode(b'dGVzdHRlc3Q='))  # 解码

hashlib模块

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

# 摘要算法：
# 摘要算法又称哈希算法、散列算法。它经过一个函数，
# 把任意长度的数据转换为一个长度固定的数据串（一般用16进制的字符串表示）

# hashlib提供常见的摘要算法，如：md5，sha1.
# case1(md5):
import hashlib
md5 = hashlib.md5()
md5.update('just test'.encode('utf-8'))
print(md5.hexdigest())

# case2(sha1):
import hashlib
sha1 = hashlib.sha1()
sha1.update('just test'.encode('utf-8'))
print(sha1.hexdigest())

# 小结
# 摘要算法在不少地方都有普遍的应用。要注意 摘要算法 不是 加密算法，
# 不能用于加密（由于没法经过摘要反推明文），只能用于防篡改。
# 可是它的单向计算特性决定了能够在不存储明文口令的状况下验证用户口令。

hmac模块

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

# hmac模块实现标准的Hmac算法，将原始消息message加入随机的key，哈希算法生成加salt的密文。
import hmac
message = b'Hello world!'
key = b'secret'
h = hmac.new(key, message, digestmod='MD5')
print(h.hexdigest())  # 加盐的md5加密

import hashlib
message = hashlib.md5()
message.update('Hello world!'.encode('utf-8'))
print(message.hexdigest())  # 未加盐，密文结果不一样

# 小结
# Python内置的hmac模块实现了标准的Hmac算法，它利用一个key对message计算“杂凑”后
# 的hash，# 使用hmac算法比标准hash算法更安全，由于针对相同的message，不一样的key会
# 产生不一样的hash。

itertools模块

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

# itertools模块提供了用于操做迭代对象的函数。
# count()会建立一个无限的迭代器，将数据一直打印出来，必须按ctrl+c退出。
import itertools
natuals = itertools.count(1)
for n in natuals:
    print(n)


# cycle()会将一个序列无限重复下去，一样停不下来。
import itertools
cs = itertools.cycle('ABC')
for c in cs:
    print(c)


# repeat()能够将一个元素无限重复下去，不过其第二个参数能够控制重复次数
import itertools
ns = itertools.repeat('A', 5)
for n in ns:
    print(n)


# 无限序列虽然能够无限迭代下去，但能够用 takewhile()函数 经过条件判断来截取有限序列
import itertools
natuals = itertools.count(1)
ns = itertools.takewhile(lambda x: x<=10, natuals)  # 限定只取10及之内的数
print(list(ns))  # 输出取的数的列表


# chain()
# 把一组迭代对象串联起来，造成一个更大的迭代器
import itertools
for c in itertools.chain('ABC','XYZ'):
    print(c)  # 输出 A B C X Y Z


# groupby()
# 把迭代器中相邻的重复元素跳出来放在一块儿
import itertools
for key, group in itertools.groupby('AAABBBCCCAAA'):
    print(key, list(group))
# 输出：
# A ['A', 'A', 'A']
# B ['B', 'B', 'B']
# C ['C', 'C', 'C']
# A ['A', 'A', 'A']

# 上面字符必须大小写统一，若是大小写混杂，可使用upper()，
# 其会将小写字符转变为大写字符排列，与lower()功能相反。
import itertools
for key, group in itertools.groupby('AAaBbBcCCaAA', lambda x: x.upper()):
    print(key, list(group))

contextlib模块

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
class Query(object):

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

    def __enter__(self):
        print('Begin')
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type:
            print('Error')
        else:
            print('End')

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

with Query('Bob') as q:
    q.query()

urllib模块

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

# urllib提供了一系列用于操做url的功能

# get
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'))
# 能够获取到http相应头和json数据
'''
Status: 200 OK
Date: Wed, 06 Dec 2017 03:51:05 GMT
Content-Type: application/json; charset=utf-8
Content-Length: 2058
Connection: close
Vary: Accept-Encoding
X-Ratelimit-Remaining2: 98
X-Ratelimit-Limit2: 100
Expires: Sun, 1 Jan 2006 01:00:00 GMT
Pragma: no-cache
Cache-Control: must-revalidate, no-cache, private
Set-Cookie: bid=ernch-JwbnQ; Expires=Thu, 06-Dec-18 03:51:05 GMT; Domain=.douban.com; Path=/
X-DOUBAN-NEWBID: ernch-JwbnQ
X-DAE-Node: sindar1b
X-DAE-App: book
Server: dae
Data: {"rating":{"max":10,"numRaters":16,"average":"7.4","min":0},"subtitle":"","author":["廖雪峰"],"pubdate":"2007","tags":[{"count":21,"name":"spring","title":"spring"},{"count":13,"name":"Java","title":"Java"},{"count":6,"name":"javaee","title":"javaee"},{"count":5,"name":"j2ee","title":"j2ee"},{"count":4,"name":"计算机","title":"计算机"},{"count":4,"name":"编程","title":"编程"},{"count":3,"name":"藏书","title":"藏书"},{"count":3,"name":"POJO","title":"POJO"}],"origin_title":"","image":"https://img3.doubanio.com\/mpic\/s2552283.jpg","binding":"平装","translator":[],"catalog":"","pages":"509","images":{"small":"https://img3.doubanio.com\/spic\/s2552283.jpg","large":"https://img3.doubanio.com\/lpic\/s2552283.jpg","medium":"https://img3.doubanio.com\/mpic\/s2552283.jpg"},"alt":"https:\/\/book.douban.com\/subject\/2129650\/","id":"2129650","publisher":"电子工业出版社","isbn10":"7121042622","isbn13":"9787121042621","title":"Spring 2.0核心技术与最佳实践","url":"https:\/\/api.douban.com\/v2\/book\/2129650","alt_title":"","author_intro":"","summary":"本书注重实践而又深刻理论，由浅入深且详细介绍了Spring 2.0框架的几乎所有的内容，并重点突出2.0版本的新特性。本书将为读者展现如何应用Spring 2.0框架建立灵活高效的JavaEE应用，并提供了一个真正可直接部署的完整的Web应用程序——Live在线书店(http:\/\/www.livebookstore.net)。\n在介绍Spring框架的同时，本书还介绍了与Spring相关的大量第三方框架，涉及领域全面，实用性强。本书另外一大特点是实用性强，易于上手，以实际项目为出发点，介绍项目开发中应遵循的最佳开发模式。\n本书还介绍了大量实践性极强的例子，并给出了完整的配置步骤，几乎覆盖了Spring 2.0版本的新特性。\n本书适合有必定Java基础的读者，对JavaEE开发人员特别有帮助。本书既能够做为Spring 2.0的学习指南，也能够做为实际项目开发的参考手册。","price":"59.8"}
'''

# 模拟浏览器发送请求，须要往 Request对象 添加http头信息
from urllib import request

req = request.Request('http://www.douban.com/')
req.add_header('User-Agent','Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0')
with request.urlopen(req) as f:
    print('Status:', f.status, f.reason)
    for k, v in f.getheaders():
        print('%s: %s' % (k, v))
    print('Data:', f.read().decode('utf-8'))


# post
# 发送一个post请求，只需把data以bytes形式传入。
# 模拟微博登录
from urllib import request,parse

print('Login to weibo.cn...')
email = input('Email:')
passwd = input('Password:')
login_data = parse.urlencode([
    ('username', email),
    ('password', passwd),
    ('entry', 'mweibo'),
    ('client_id', ''),
    ('savestate', '1'),
    ('ec', ''),
    ('pagerefer', 'https://passport.weibo.cn/signin/welcome?entry=mweibo&r=http%3A%2F%2Fm.weibo.cn%2F')
])

req = request.Request('https://passport.weibo.cn/sso/login')
req.add_header('Origin', 'https://passport.weibo.cn')
req.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0')
req.add_header('Referer', 'https://passport.weibo.cn/signin/login?entry=mweibo&res=wel&wm=3349&r=http%3A%2F%2Fm.weibo.cn%2F')

with request.urlopen(req, data = login_data.encode('utf-8')) as f:
    print('Status:', f.status, f.reason)
    for k, v in f.getheaders():
        print('%s: %s' % (k, v))
    print('Data:', f.read().decode('utf-8'))


# handler
# 经过一个代理 proxy 去访问网站，须要用 ProxyHandler 来处理。
from urllib import request
proxy_handler = urllib.request.ProxyHandler(['http': 'http://www.example.com:1080/'])
proxy_auth_handler = urllib.request.ProxyBasicAuthHandler()
proxy_auth_handler.add_password('realm', 'host', 'username', 'password')
opener = urllib.request.build_opener(proxy_handler, proxy_auth_handler)
with opener.open('http://www.example.com/login.html') as f:
    pass


# 小结
# urllib提供的功能就是利用程序去执行各类HTTP请求。若是要模拟浏览器完成特定功能，
# 须要把请求假装成浏览器。假装的方法是先监控浏览器发出的请求，再根据浏览器的请求
# 头来假装，User-Agent头就是用来标识浏览器的。

XML解析

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

# python解析xml，准备好三个事件函数 start_element, end_element, char_data 就能够完成。
# 示例： <a href="/">python</a>
# 会产生3个事件：
# 1.start_element事件，读取：<a href="/">;
# 2.char_data事件，读取：python；
# 3.end_element事件，读取：</a>。

from xml.parsers.expat import ParserCreate

class DefaultSaxHandler(object):
    def start_element(self, name, attrs):
        print('sax:start_element: %s, attrs: %s' % (name, str(attrs)))

    def end_element(self, name):
        print('sax:end_element: %s' % name)

    def char_data(self, text):
        print('sax:char_data: %s' % text)

xml = r'''<?xml version="1.0"?>
<ol>
    <li><a href="/python">Python</a></li>
    <li><a href="/ruby">Ruby</a></li>
</ol>
'''

handler = DefaultSaxHandler()
parser = ParserCreate()
parser.StartElementHandler = handler.start_element
parser.EndElementHandler = handler.end_element
parser.CharacterDataHandler = handler.char_data
parser.Parse(xml)

HTMLParser模块

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from html.parser import HTMLParser
from html.entities import name2codepoint

class MyHTMLParser(HTMLParser):
    def handle_starttag(self, tag, attrs):
        print('<%s>' % tag)

    def handle_endtag(self, tag):
        print('</%s>' % tag)

    def handle_startendtag(self, tag, attrs):
        print('<%s/>' % tag)

    def handle_data(self, data):
        print(data)

    def handle_comment(self, data):
        print('<!--', data, '-->')

    def handle_entityref(self, name):
        print('&%s;' % name)

    def handle_charref(self, name):
        print('&#%s;' % name)

parser = MyHTMLParser()
parser.feed('''<html>
<head></head>
<body>
<!-- test html parser -->
    <p>Some <a href=\"#\">html</a> HTML&nbsp;tutorial...<br>END</p>
</body></html>''')

# feed()方法能够屡次调用，也就是不必定一次把整个HTML字符串都塞进去，
# 能够一部分一部分塞进去。

pillow模块

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from PIL import Image
im = Image.open('101010.jpg')
w, h = im.size
print('Original image size: %sx%s' % (w, h))  # 输出原始图像大小
im.thumbnail((w//2, h//2))
print('Resize image to: %sx%s' % (w//2, h//2))  # 输出的图片宽高缩小一半
im.save('thumbnail.jpg', 'jpeg')

requests模块

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

# requests
# python内置的urllib模块用于访问网络资源，但用起来麻烦，缺乏不少实用的高级功能。
# requests处理url更方便。

#get
import requests
r = requests.get('https://www.douban.com/')
print(r.status_code)  # 输出页面状态码 200
print(r.text)  # 输出内容

# 对于带参数的url，传入一个dict做为params参数
import requests
r = requests.get('https://www.douban.com/search', params={'q':'python', 'cat':'1001'})
print(r.url)
# 此代码实际请求的url是 https://www.douban.com/search?q=python&cat=1001


# requests自动检测编码，可使用 encoding属性查看：
print(r.encoding)

# content 获取响应内容（无论是文本仍是二进制内容均以二进制获取）
print(r.content)

# requests方便在于特定类型的响应，如 JSON，可直接获取
r = requests.get('https://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20weather.forecast%20where%20woeid%20%3D%202151330&format=json')
print(r.json())

# 传入 HTTP Header 时，可加入 dict 添加headers 参数
r = requests.get('https://www.douban.com/', headers={'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit'})
print(r.text)   # 以文本内容获取

# post
import requests
r = requests.post('https://accounts.douban.com/login',data={'form_email': 'abc@example.com', 'form_password': '123456'})
print(r.status_code)
print(r.text)

# requests 默认使用 application/x-www-form-urlencoded 对POST数据编码
# 若是要传递json数据，可直接传入json参数
params = {'key':'value'}
r = requests.post(url, json=params)  # 替换url和params数据

# requests 还可进行更复杂的编码格式(如：二进制)，文件上传
import requests
upload_files = {'file':open('test.xls', 'rb')}
r = requests.post(url, file=upload_files)

# 同理，把 requests.get()、requests.post() 替换为 put、delete，也可进行该方式请求。

# requests 获取响应信息
print(r.headers)  # 获取http头信息
print(r.status_code)  # 获取状态码
print(r.text)  # 获取页面内容

# cookie
# requests 对 cookie 作了特殊处理，是咱们没必要解析cookie就能够轻松获取cookie
print(r.cookies)
# 若是要在请求中传入cookie，和post同样，使用dict传入cookie参数
cookie_params = {'token':12345, 'status':'abc', 'session':'DWEHDWLLKSNDQ2SD2H4'}

# 指定超时时间
r = requests.get('url', timeout=2.5) # 2.5秒超时

chardet模块

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

# chardet 用于监测编码
import chardet
print(chardet.detect(b'hello world!'))
# 结果：{'encoding': 'ascii', 'confidence': 1.0, 'language': ''}
# confidence 表示几率，1.0 表明100%


# 检测GBK编码的中文：
data = '离离原上草，一岁一枯荣'.encode('gbk')
print(chardet.detect(data))
# 结果：{'encoding': 'GB2312', 'confidence': 0.7407407407407407, 'language': 'Chinese'}

# 监测utf-8编码的中文：
data = '离离原上草，一岁一枯荣'.encode('utf-8')
print(chardet.detect(data))
# 结果：{'encoding': 'utf-8', 'confidence': 0.99, 'language': ''}

# 检测日文
data = '最新の主要ニュース'.encode('euc-jp')
print(chardet.detect(data))
# 结果：{'encoding': 'EUC-JP', 'confidence': 0.99, 'language': 'Japanese'}

psutil模块

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

# psutil：process and system utilities, 进程和系统实用工具。
# 自动化运维使用广泛。

import psutil
print(psutil.cpu_count())  # 获取CPU逻辑数量
# 结果：4
print(psutil.cpu_count(logical=False))  # CPU物理核心
# 结果：2
# 由于个人电脑是双核四线程的。

# 统计cpu的用户/系统/空闲时间
print(psutil.cpu_times())


# 实现相似 top 命令的cpu使用率，每秒刷新一次，累计10次：
'''for x in range(10):
    print(psutil.cpu_percent(interval=1, percpu=True))
'''
print('------------------------------')

# 获取内存信息
print(psutil.virtual_memory())  # 获取物理内存信息
# svmem(total=8467226624, available=4421910528, percent=47.8, used=4045316096, free=4421910528)
# 总内存8G，可用4G多，已用占比47.8%，已使用4G少一点，空余4G多=前面的可用数额
print(psutil.swap_memory())  # 获取交换分区信息
# sswap(total=13087117312, used=5167869952, free=7919247360, percent=39.5, sin=0, sout=0)

print('------------------------------')

# 获取磁盘信息
print(psutil.disk_partitions())  # 获取磁盘分区信息
print(psutil.disk_usage('/'))  # 磁盘使用状况
print(psutil.disk_io_counters())  # 磁盘IO，输入输出吞吐量

print('------------------------------')

# 获取网络信息
print(psutil.net_io_counters())  # 获取网络读写 字节/包 的个数

print('------------------------------')

# 获取网络接口
print(psutil.net_if_addrs())

print('------------------------------')

# 获取接口状态
print(psutil.net_if_stats())

print('------------------------------')

# 获取当前网络链接信息
print(psutil.net_connections())

print('------------------------------')

# 获取进程信息
'''
>>> psutil.pids() # 全部进程ID
[3865, 3864, 3863, 3856, 3855, 3853, 3776, ..., 45, 44, 1, 0]
>>> p = psutil.Process(3776) # 获取指定进程ID=3776，其实就是当前Python交互环境
>>> p.name() # 进程名称
'python3.6'
>>> p.exe() # 进程exe路径
'/Users/michael/anaconda3/bin/python3.6'
>>> p.cwd() # 进程工做目录
'/Users/michael'
>>> p.cmdline() # 进程启动的命令行
['python3']
>>> p.ppid() # 父进程ID
3765
>>> p.parent() # 父进程
<psutil.Process(pid=3765, name='bash') at 4503144040>
>>> p.children() # 子进程列表
[]
>>> p.status() # 进程状态
'running'
>>> p.username() # 进程用户名
'michael'
>>> p.create_time() # 进程建立时间
1511052731.120333
>>> p.terminal() # 进程终端
'/dev/ttys002'
>>> p.cpu_times() # 进程使用的CPU时间
pcputimes(user=0.081150144, system=0.053269812, children_user=0.0, children_system=0.0)
>>> p.memory_info() # 进程使用的内存
pmem(rss=8310784, vms=2481725440, pfaults=3207, pageins=18)
>>> p.open_files() # 进程打开的文件
[]
>>> p.connections() # 进程相关网络链接
[]
>>> p.num_threads() # 进程的线程数量
1
>>> p.threads() # 全部线程信息
[pthread(id=1, user_time=0.090318, system_time=0.062736)]
>>> p.environ() # 进程环境变量
{'SHELL': '/bin/bash', 'PATH': '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:...', 'PWD': '/Users/michael', 'LANG': 'zh_CN.UTF-8', ...}
>>> p.terminate() # 结束进程
Terminated: 15 <-- 本身把本身结束了
'''

print('------------------------------')

# 模拟ps命令效果
print(psutil.test())

TCP编程

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

# TCP 是可靠的，面向链接的协议。

# Socket 是网络编程的一个抽象概念，意为“孔、插座”，用于两个客户端之间的网络链接，
# 打开一个socket须要指定目标机器的IP和端口。


### 客户端
import socket
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) # AF_INET指定使用ipv4，若是是ipv6使用AF_INET6
s.connect(('www.sina.com.cn', 80))  # socket连接 参数是一个 tuple，包含地址、端口号

# 向新浪服务器发送请求
s.send(b'GET / HTTP/1.1\r\nHost: www.sina.com.cn\r\nConnection: close\r\n\r\n')

# 接收服务器返回数据
buffer = []
while True:
    d = s.recv(1024)  # recv(max)方法，一次最多接收指定的字节数
    if d:
        buffer.append(d)
    else:
        break
data = b''.join(buffer)
s.close()  # close()方法关闭Socket，网络通讯结束。

# 输出http头信息
header, html = data.split(b'\r\n\r\n', 1)
print(header.decode('utf-8'))

# 把接收的内容数据写入文件
with open('sina.html', 'wb') as f:
    f.write(html)


### 服务器
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定监听端口
s.bind(('127.0.0.1', 9999))

# 调用listen()开始监听，并设置最大等待链接数量，不是链接的客户端数量
s.listen(5)
print('Waiting for connection...')

# 服务器经过永久循环来接受来自客户端的链接
while True:
    # 接受一个新链接:
    sock, addr = s.accept()
    # 建立新线程来处理TCP链接:
    t = threading.Thread(target=tcplink, args=(sock, addr))
    t.start()

# 每次链接都要建立新的线程或进程
def tcplink(sock, addr):
    print('Accept new connection from %s:%s...' % addr)
    sock.send(b'Welcome!')
    while True:
        data = sock.recv(1024)
        time.sleep(1)
        if not data or data.decode('utf-8') == 'exit':
            break
        sock.send(('Hello, %s!' % data.decode('utf-8')).encode('utf-8'))
    sock.close()
    print('Connection from %s:%s closed.' % addr)


# 客户端与上面服务器通讯
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 创建链接:
s.connect(('127.0.0.1', 9999))
# 接收欢迎消息:
print(s.recv(1024).decode('utf-8'))
for data in [b'Michael', b'Tracy', b'Sarah']:
    # 发送数据:
    s.send(data)
    print(s.recv(1024).decode('utf-8'))
s.send(b'exit')
s.close()

UDP编程

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

# UDP 是面向无链接的协议。

### 服务端
import socket
s = socket.socket(socket.AF_INET, sock.SOCK_DGRAM)  # SOCK_DGRAM 指定Socket类型为UDP
# 绑定端口
s.bind(('127.0.0.1'. 9999))

# UDP与TCP相比，不须要调用listen()，直接接收客户端数据
print('Bind UDP on 9999..')
while True:
    # 接收数据
    data, addr = s.recvfrom(1024)  # recvfrom()返回数据和客户端地址、端口
    print('Received from %s: %s.' % addr)
    s.sendto(b'Hello, %s!' % data, addr)
    # 服务器收到后经过 sendto() 把数据经过UDP发送给客户端

### 客户端
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
for data in [b'Michael', b'Tracy', b'Sarah']:
    # 发送数据
    s.sendto(data, ('127.0.0.1', 9999))
    # 接收数据
    print(s.recv(1024).decode('utf-8'))
s.close()

SMTP发送邮件

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

# Python的 smtplib 和 email 两个模块对邮件支持。
# email 负责构造邮件，smtplib 负责发送邮件

from email.mime.text import MIMEText
msg = MIMEText('hello, send by Python...', 'plain', 'utf-8')

# 输入邮箱地址和口令
from_addr = input('From:')
password = input('Password:')
# 输入收件人地址
to_addr = input('To:')
# 输入SMTP服务器地址
smtp_server = input('SMTP server:')

import smtplib
server = smtplib.SMTP(smtp_server, 25)
server.set_debuglevel(1)  # 打印出和SMTP服务器交互的全部信息
server.login(from_addr, password)
server.sendmail(from_addr, [to_addr], msg.as_string())
server.quit()

# 完整邮件：
from email import encoders
from email.header import Header
from email.mime.text import MIMEText
from email.utils import parseaddr, formataddr
import smtplib

def _format_addr(s):
    name, addr = parseaddr(s)
    return formataddr((Header(name, 'utf-8').encode(), addr))

from_addr = input('From:')
password = input('Password:')
to_addr = input('To:')
smtp_server = input('SMTP server:')

msg = MIMEText('hello, send by Python...', 'plain', 'utf-8')
msg['From'] = _format_addr('Python爱好者 <%s>' % from_addr)
msg['To'] = _format_addr('管理员 <%s>' % to_addr)
msg['Subject'] = Header('来自SMTP的问候。。。', 'utf-8').encode()

server = smtplib.SMTP(smtp_server, 25)
server.set_debuglevel(1)
server.login(from_addr, password)
server.sendmail(from_addr, [to_addr], msg.as_string())
server.quit()

POP3收取邮件

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

# Python内置的poplib模块，用于实现邮件接收。

# 收取邮件分为两步：
# 1.用 poplib 把邮件原始文本下载到本地；
# 2.用 email 解析原始文本，还原邮件对象。

from email.parser import Parser
from email.header import decode_header
from email.utils import parseaddr
import poplib

# 解析邮件
# 打印出 message 对象的层次结构
# indent用于缩进显示
def print_info(msg, indent=0):
    if indent == 0:
        for header in ['From', 'To', 'Subject']:
            value = msg.get(header, '')
            if value:
                if header=='Subject':
                    value = decode_str(value)
                else:
                    hdr, addr = parseaddr(value)
                    name = decode_str(hdr)
                    value = u'%s<%s>' % (name, addr)
            print('%s%s: %s' % (' ' * indent, header, value))
    if(msg.is_multipart()):
        parts = msg.get_payload()
        for n, part in enumerate(parts):
            print('%spart %s' % (' ' * indent, n))
            print('%s----------------' % (' ' * indent))
            print_info(part, indent + 1)
    else:
        content_type = msg.get_content_type()
        if content_type=='text/plain' or content_type=='text/html':
            content = msg.get_payload(decode=True)
            charset = guess_charset(msg)
            if charset:
                content = content.decode(charset)
            print('%sText: %s' % (' ' * indent, content + '...'))
        else:
            print('%sAttachment: %s' % (' ' * indent, content_type))
# 邮件中的名字都是编码后的str，要正常显示，必须解码decode
def decode_str(s):
    value, charset = decode_header(s)[0]
    if charset:
        value = value.decode(charset)
    return value
# 邮件内容也要检测编码
def guess_charset(msg):
    charset = msg.get_charset()
    if charset is None:
        content_type = msg.get('Content-Type', '').lower()
        pos = content_type.find('charset=')
        if pos >= 0:
            charset = content_type[pos + 8:].strip()
    return charset

# 输入邮件地址、口令和POP3服务器地址
email = input('Email:')
password = input('Password:')
pop3_server = input('POP3 server:')

#链接到POP3服务器
server = poplib.POP3(pop3_server)
# 打开调试信息
server.set_debuglevel(1)
# 打印POP3服务器的欢迎文字
print(server.getwelcome().decode('utf-8'))

# 身份认证
server.user(email)
server.pass_(password)

# stat()返回邮件数量和占用空间
print('Messages: %s. Size: %s' % server.stat())
# list()返回全部邮件编号
resp, mails, octets = server.list()
# 查看返回列表
print(mails)

# 获取最新一封邮件
index = len(mails)
resp, lines, octets = server.retr(index)

# lines存储了邮件的原始文本的每一行，能够得到整个邮件原始文本
msg_content = b'\r\n'.join(lines).decode('utf-8')
# 稍后解析出邮件
msg = Parser().parsestr(msg_content)
print_info(msg)
# 关闭链接
server.quit()

使用SQLite

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

# SQLite是一种嵌入式数据库，数据库就是一个文件

# 导入sqlite数据库
import sqlite3
# 链接test.db数据库，若是不存在会自动建立
conn = sqlite3.connect('test.db')
# 建立Cursor，操做数据库经过Cursor执行SQL语句
cursor = conn.cursor()
# 执行建立表的命令
cursor.execute('create table user (id varchar(20) primary key, name varchar(20))')
# 插入一条记录
cursor.execute('insert into user (id, name) values (\'1\', \'Michael\')')
# 经过rowcount得到插入的行数
print(cursor.rowcount)
# 关闭Cursor
cursor.close()
# 提交事务
conn.commit()
# 关闭链接
conn.close()

# 查询
conn = sqlite3.connect('test.db')
cursor = conn.cursor()
# 执行查询语句
cursor.execute('select * from user where id?', ('1',))
# 得到查询结果集
values = cursor.fetchall()
print(values)
cursor.close()
conn.close()

使用MySQL

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

# 安装mysql驱动
# pip3 install mysql-connector-python --allow-external mysql-connector-python
# pip3 install mysql-connector

import mysql.connector
# 链接数据库
conn = mysql.connector.connect(use='root', password='root', database='test')
cursor = conn.cursor()
# 建立user表
cursor.execute('create table user (id varchar(20) primary key, name varchar(20))')
# 插入一行记录，注意mysql的占位符是 %s
cursor.execute('insert into user (id, name) values (%s, %s)', ['1', 'Michael'])
print(cursor.rowcount)
# 提交事务
conn.commit()
cursor.close()
# 查询
cursor = conn.cursor()
cursor.execute('select * from user where id = %s', ('1',))
values = cursor.fetchall()
print(values)
# 关闭cursor和connection
cursor.close()
conn.close()

使用SQLAIchemy

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

# SQLAlchemy 是python 操做数据库的一个库。
# pip3 install sqlalchemy

from sqlalchemy import Column, String, create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# 建立对象的基类
Base = declarative_base()
# 定义user对象
class User(Base):
    # 表的名字
    __tablename__ = 'user'

    # 表的结构
    id = Column(String(20), primary_key=True)
    name = Column(String(20))

# 初始化数据库链接
engine = create_engine('mysql+mysqlconnector://root:password@localhost:3306/test')
# 建立DBSession类型
DBSession = sessionmaker(bind=engine)

# ORM（Object Relational Mapping，对象关系映射）框架的做用就是把数据库表的一行记录
# 与一个对象互相作自动转换。

WSGI接口

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

# WSGI：Web Server Gateway Interface, web服务网关接口（接口规范）
# 1.浏览器发送一个HTTP请求；
# 2.服务器收到请求，生成一个HTML文档；
# 3.服务器把HTML文档做为HTTP响应的Body发送给浏览器；
# 4.浏览器收到HTTP响应，从HTTP Body取出HTML文档并显示。


# hello.py
def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return [b'<h1>Hello, web!</h1>']

# server.py
from wsgiref.simple_server import make_server
from hello import application  # 导入 hello.py 定义的application()

httpd = make_server('', 8000, application)
print('Serving HTTP on port 8000...')
httpd.serve_forever()

# hello.py 与 server.py 在同一目录下，运行 server.py，
# 浏览器 输入 http://localhost:8000，就能显示处 hello.py 的内容。

1. python_learn 装饰器
2. Sort(Ⅰ）
3. PyQt5学习Ⅰ
4. Learning Spark（Ⅰ）
5. Linux Shell教程Ⅰ
6. Object-Oriented Programming Summary Ⅰ
7. Language C Debug Ⅰ(UPDATING)
8. [leetcode] 并查集（Ⅰ）
9. HTTP(Ⅰ）—— http报文形式
10. SAP HANA租户库Ⅰ
更多相关文章...

python_learn Ⅰ

条件判断

循环

利用循环排序

三元二次方程求解

函数的参数

递归函数

切片

迭代、索引

列表生成式

元组循环迭代列表生成式输出天干地支

将列表大小写字符所有小写输出

生成器

生成器生成斐波拉契数列

生成器生成杨辉三角

迭代器

高阶函数map、reduce

filter

sorted

返回函数

匿名函数

偏函数

类和实例

访问限制

继承和多态

获取对象信息

实例属性和类属性

限制实例属性__slots__

使用@property

多重继承

枚举类

文件读写

StringIO_BytesIO

操做文件和目录

代码实现dir-l功能

序列化_pickle模块

JSON

多进程

多线程

正则表达式

datetime模块

collections模块

base64模块

hashlib模块

hmac模块

itertools模块

contextlib模块

urllib模块

XML解析

HTMLParser模块

pillow模块

requests模块

chardet模块

psutil模块

TCP编程

UDP编程

SMTP发送邮件

POP3收取邮件

使用SQLite

使用MySQL

使用SQLAIchemy

WSGI接口

限制实例属性slots