异想家博采众长的客厅

异想家Python学习代码

2017.03.04

本文是自己学习廖雪峰Python教程的笔记,记录些常用用法,方便以后找代码片段。

JfzPylib.py文件:

#!/usr/bin/env python3
#coding=utf-8
'''
异想家Python函数库
'''
import math
# 求绝对值
def Fun_abs(x):
    if not isinstance(x, (int, float)): 
        raise TypeError('bad operand type') 
    if x>=0:
        return x
    else:
        return -x

# 解一元二次方程
def Fun_Solve2yuanEquation(a,b,c): 
    delta = b*b-4*a*c
    if delta < 0:
        return
    elif delta == 0:
        x1 = (-b + math.sqrt(b*b-4*a*c))/(2*a)
        return x1
    else:
        x1 = (-b + math.sqrt(b*b-4*a*c))/(2*a)
        x2 = (-b - math.sqrt(b*b-4*a*c))/(2*a)
        return x1,x2

JfzPyStudy.py文件:

#!/usr/bin/env python3
# coding=utf-8
' 异想家Python学习 '
__author__ = 'Sandeepin'

# 【1】输出
print('\n\033[1;31m【1】输出\033[0m\n')
print("异想家")  # 双引号
print('Fuck''Bitch','Shit')  # 单引号,逗号间隔,输出变空格
print('1234 - 5678 =',1234-5678)  # 输出数字计算

# 【2】输入
print('\n\033[1;31m【2】输入\033[0m\n')
#name = input()
#print(name)
#name2 = input('输入网名')
#print(name2)

# 【3】Python基础
print('\n\033[1;31m【3】Python基础\033[0m\n')
# 缩进强迫写出格式化代码,坚持使用【4个空格】的缩进
# Python程序【大小写敏感】

# 【4】数据类型、变量
print('\n\033[1;31m【4】数据类型、变量\033[0m\n')
print(1024)
print(0xff)
print(1.23e9)
print('abc')
print("xyz")
print("x\'y\'z\n")  # 转义字符\n换行
print(r'\\\t\\')  # r表示内部字符不转义
print('''123
456
789''')  # '''括起的内容可多行
# True False and or not  # 布尔运算
# None  # 空值

a = 123  # 变量数值
print(a)
a = 'jfz'  # 变量字符串,同一变量反复赋值
b = a
a = '666'
print(a)
print(b)
PI = 3.14159265359  # 常量用大写表示,实际上是变量,想改就改
print(PI)
print(10 / 3)
print(10 // 3)  # 地板除,整数部分
print(10 % 3)  # 余数部分
# Python整数无大小限制,浮点数也没限制,太大会变成inf(无限大)

# ASCII 1个字节,Unicode 通常2个字节, UTF-8 可变长编码(英语1个,中文3个,特殊4-6个)
print('中文str')  # python字符串以Unicode编码
print(ord('A'))  # ord获取字符整数表示
print(ord('蒋'))
print(chr(66))   # ord编码整数转字符
print(chr(26041))
print('\u4e2d\u6587')  # 用16进制写中文
print(b'ABC')# 编码为bytes
print('ABC'.encode('ascii'))
print('异想家123'.encode('utf-8'))
print(b'fuck'.decode('ascii'))# 解码为str
print(b'\xe8\x92\x8b\xe6\x96\xb9\xe6\xad\xa3'.decode('utf-8'))

print(len('ABC'))  # 计算str字符数
print(len('异想'))
print(len(b'ABCddd'))  # 计算bytes字节数

# 【5】格式化输出
print('\n\033[1;31m【5】格式化输出\033[0m\n')
# 和C语言类似,%d %f %s %x
print('Jfz %d poi %s' %(77, 'sandeepin') )  # 几个%号,在后面就用%(1,2)填几个
print('%02d %07.3f' %(7, 33.3333333333) )  # 补零,类似C语言
print('年龄: %s %% 男士: %s' %(23, True) )  # %s永远起作用,不知道用什么的时候用它, %%转义%
s1 = 72
s2 = 85
r = s1/s2
print('比率s1/s2 = %.2f' % r)
print('彩色显示:\033[1;31mSandeepin\033[0m')

# 【6】list列表
print('\n\033[1;31m【6】list列表\033[0m\n')
# list列表是可变有序集合,用xxx = ['1','2','3']表示
classmates = ['Sandeepin', 'Samothrace', 'Bitch']
print(classmates)
print(len(classmates))  # list元素个数
print(classmates[0])  # 类似数组下标的方式访问元素,从0开始
print(classmates[2])
print(classmates[-1])  # 倒数第一个,即classmates[2]
print(classmates[-2])  # 倒数第二个
classmates.append('Jfz')  # 追加元素
classmates.insert(1,'poi')  # 插入元素,插在第1个(下标从0开始)
print(classmates)
classmates.pop()  # 弹出,最后一个元素删除
print(classmates)
classmates.pop(2)  # 弹出下标为2的那个
print(classmates)
classmates[0] = 'jiangfangzheng'  # 替换用赋值方法
print(classmates)
mixlist = ['poi',123,3.5678,['www','jj']]  # list元素类型可混合,list套list
print(mixlist[3][1])  # 相当于二维数组
nonelist=[]
print(len(nonelist))  # 空list

# 【7】tuple元组
print('\n\033[1;31m【7】tuple元组\033[0m\n')
# tuple元组是有序列表,类似list,但是tuple初始化后不能改,用xxx = ('1','2','3')表示
classmates = ('Michael', 'Bob', 'Tracy')
print(classmates)
print(classmates[1])
t = (1,)  # 只有一个元素的tuple要加个逗号,避免歧义为赋值1
print(t)  # 显示时也会加逗号防止误解
t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
print(t)  # tuple元素不变,里面有list,list元素可变

# 【8】条件判断
print('\n\033[1;31m【8】条件判断\033[0m\n')
age = 19
if age >= 18:
    print('成年人')  # 从上往下判断,符合要求后剩下的判断忽略
elif age>=6:
    print('青少年')
else:
    print('小孩')
x =3
if x:
    print('True')   # 简写,x非0,非空就为True

#year = input()
##if year > 2000:         # 输入1999程序出错,因为输入的是字符串,要转成整数
#if int(year) > 2000:     # int()函数转整数
#    print('2000年之后')
#else:
#    print('2000年之前')

#print('体重判断程序')
#height = input('输入身高')
#weight = input('输入体重')
#bmi = int(weight)/(int(height)*int(height))
#if bmi>25:
#    pass  # pass跳过,不填报错
#else:
#    print('不胖')

# 【9】循坏
print('\n\033[1;31m【9】循坏\033[0m\n')
# 第1种 for...in循坏
names = ['异想家','sandeepin','jfz']
for aaa in names:  # 就是把每个元素带入aaa,执行下面语句一回
    print(aaa)
# 求和举例
qiuhe = 0
for x in [1,2,3,4,5,6,7,8,9,10]:
    qiuhe = qiuhe + x
print(qiuhe)

qiuhe = 0
for x in range(11):  # 生成从0开始的小于11的数的list
    qiuhe = qiuhe + x
print(qiuhe)

# 第2种 while循坏
n = 10
qiuhe = 0
while n > 0:
    qiuhe = qiuhe + n
    n = n -1
print(qiuhe)
# 【技巧】死循环时按Ctrl + C 强制退出

# 【10】字典
print('\n\033[1;31m【10】字典\033[0m\n')
# 字典dictionary类似其它语言中的map,键-值存储,快速查找,其内部存放顺序与放入顺序无关
# 字典以空间(内存)换时间,list以时间换空间,dictionary适合高速场合
# 字典的Key不能变,因此不能以list作为Key
jfzn = {'jfz':100,'sandeepin':96,'poi':88}
print(jfzn['poi'])  # 就像给数组的下标起别名,访问对应数值
jfzn['jfz'] = 99  # 字典内容赋值
print(jfzn['jfz'])
print('Thomas' in jfzn)  # 判断Key是否在字典中
print(jfzn.get('Thomas'))  # 不在返回None
print(jfzn.get('Thomas', 999))  # 不在返回自定义的999
print(jfzn.pop('poi'))  # 弹出Key
print(jfzn)

# set类似字典dict,是Key的集合,可作交并计算,不储存value
s = set([1, 2, 3])  # list作为输入
ss = set([1,1,2,2,3,3])  # 滤除重复元素
print(s)
s.add(4)  # 添加Key,重复无用
s.remove(1)  # 移除Key
print(s)
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1 & s2)  # 交运算
print(s1 | s2)

# 【11】可变与不可变学习
print('\n\033[1;31m【11】可变与不可变学习\033[0m\n')
# list可变
abc = ['b','a','c']
abc.sort()  # 排序
print(abc)
# str不可变
strabc = 'bac'
print(strabc.replace('b','B'))  # 替换只对当前有效,strabc本质没变
print(strabc)

# 【12】函数
print('\n\033[1;31m【12】函数\033[0m\n')
# 调用函数 help(abs) 查看abs函数信息,官网看文档 http://docs.python.org/3/library/functions.html#abs
print(abs(-5))
print(max(2, 3, 1, -5))
# 数据类型转换函数
print(int('123'))
print(int(12.3))
print(float(123.456))
print(bool(1))
# 函数名本身就是一个引用,完全可以给函数名取别名
ShiLiu = hex
print(ShiLiu(12))
# 自定义函数
def Fun_SanCiFang(x):
    return x*x*x
print(Fun_SanCiFang(3))  # 调用函数
from JfzPylib import Fun_abs  # 从JfzPylib.py文件中导入函数Fun_abs
print(Fun_abs(-93))
# 返回多个值
import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

print(move(10, 20, 50))  # 返回的本质是一个元组
x, y = move(10, 20, 50)  # 返回一个元组可省略括号
print(x, y)

def Fun_Solve2yuanEquation(a,b,c):  # 解二次方程函数
    delta = b*b-4*a*c
    if delta < 0:
        return
    elif delta == 0:
        x1 = (-b + math.sqrt(b*b-4*a*c))/(2*a)
        return x1
    else:
        x1 = (-b + math.sqrt(b*b-4*a*c))/(2*a)
        x2 = (-b - math.sqrt(b*b-4*a*c))/(2*a)
        return x1,x2
print(Fun_Solve2yuanEquation(1,4,7774))
# 函数参数——默认参数、可变参数、关键字参数
def CiFang(x):
    return x*x
print(CiFang(2))
def LiFang(x):
    return x*x*x
print(LiFang(2))
# 位置参数,顺序要定好,n=2是默认参数
def CiFangN(x, n=2):
    out = 1
    while n > 0:
        out = out * x
        n = n - 1
    return out
print(CiFangN(2,4))# 位置参数
print(CiFangN(2))  # 默认参数,必选参数在前,默认参数在后,否则有歧义
# 默认参数,变化大的放在前面,变化小的放在后面
def ZhuCe(name, gender , age=6, city = 'Guilin'):
    print('name=%s, gender=%d, age=%d, city=%s'%(name,gender,age,city))
    return 'OK'
print(ZhuCe('jfz', 2))
print(ZhuCe('poi', 1, 8))  # 按顺序补全
print(ZhuCe('poi', 1, city='wuhan'))  # 选择输入city,其它默认
# 一个坑
def add_end(L=[]):
    L.append('END')
    return L
poid=[3,2,1]
print(add_end(poid))
print(add_end())
print(add_end())  # 输出了['END', 'END'],默认参数L被记着了,不能这么用
# 正确写法:
def add_endfix(L=None):
    if L is None:
        L=[]
    else:
        L.append('END')
    return L
print(add_endfix())
print(add_end())
# 【技巧】能设计为不变对象时,就尽量设计成不变对象,防止意外修改

# 可变参数——传入的参数可变
# 传统方法:传list或tuple
def calcX2(shuru):
    sum = 0
    for fuck in shuru:
        sum = fuck*fuck +sum
    return sum
fuckk=[1,2,3]
print('calcX2 =',calcX2(fuckk))
# 可变参数法——仅在参数前加个*号
def calcX2B(*shuru):
    sum = 0
    for fuck in shuru:
        sum = fuck*fuck +sum
    return sum
print('calcX2B =',calcX2B(fuckk[0], fuckk[1], fuckk[2]))  # 输入参方法1
print('calcX2B =',calcX2B(*fuckk))  # 输入参方法2
print('calcX2B =',calcX2B(1, 2, 3))  # 输入参方法3

# 关键字参数——加两个**,扩展函数功能,获得额外信息
def ZhuCeKW(name, gender , **kw):
    print('name=%s, gender=%d other='%(name, gender), kw)
    return 'OK'
print(ZhuCeKW('duck', 3))
print(ZhuCeKW('duck', 3, city='wuhan'))
extra = {'age':12, 'city':'guilin'}  # 键值形式输入
print(ZhuCeKW('duck', 3, **extra))  # extra加**
# 限制关键字参数——命名关键字参数
# 例如只接受city和age
# 命名关键字参数以特殊的单个*表示,后面的为命名关键字参数
# 命名关键字参数必须传入参数名
def ZhuCeCheck(name, gender, *, age, city='guilin'):
     print(name, gender, age, city)
     return 'OK'
print(ZhuCeCheck('Jack', 24, city='Beijing', age = 11))
# print(ZhuCeCheck('Jack', 24, city='Beijing', job='Engineer'))  # 输出出错

# 参数组合举例——必选、默认、可变、关键字、命名关键字
# 顺序: 必选、默认、可变\关键字\命名关键字
# 可变和命名显然不能混在一起
def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
f1(1, 2)
f1(1, 2, c=3)
f1(1, 2, 3, 'a', 'b')  # a、b是可变
f1(1, 2, 3, 'a', 'b', x=99)  # x=99是关键字,用 = 表示键值配对
f2(1, 2, d=99, ext=None)   # d为命名关键字,只有写d=xx才对,**kw就换成关键字了,变成键值配对
args = (1, 2, 3, 4)  # 通过tuple和dict作为输入
kw = {'d': 99, 'x': '#'}
f1(*args, **kw)  # 任意函数都可以以形式f1(*args, **kw)调用
args = (1, 2, 3)
kw = {'d': 88, 'x': '#'}
f2(*args, **kw)
# 【小结】
# *args是可变参数,接收tuple元组
# **kw是关键字参数,接收dict字典
# func(1,2,3)可以装list、tuple通过*args传入func(*(1,2,3))
# func(a=1,b=2),可以装dict通过**kw传入func(**{'a':1,'b':2})

# 【13】递归函数——函数调用本身
print('\n\033[1;31m【13】递归函数\033[0m\n')
def JieCheng(n):
    if n == 1:
        return 1
    else:
        return n * JieCheng(n-1)
print('递归阶乘:', JieCheng(5))
# 递归太多层会栈溢出,解决方法:尾递归优化
# 常规递归过程如下:
# ===> fact(5)
# ===> 5 * fact(4)
# ===> 5 * (4 * fact(3))
# ===> 5 * (4 * (3 * fact(2)))
# ===> 5 * (4 * (3 * (2 * fact(1))))
# ===> 5 * (4 * (3 * (2 * 1)))
# ===> 5 * (4 * (3 * 2))
# ===> 5 * (4 * 6)
# ===> 5 * 24
# ===> 120
def fact(n):
  return fact_iter(n, 1)
def fact_iter(num, product):
  if num == 1:
    return product
  return fact_iter(num - 1, num * product)
print('优化阶乘:', fact(5))
# 优化递归过程如下:
# ===> fact_iter(5, 1)
# ===> fact_iter(4, 5)
# ===> fact_iter(3, 20)
# ===> fact_iter(2, 60)
# ===> fact_iter(1, 120)
# ===> 120
# 【遗憾的是】python没对尾递归优化,这样写照样爆栈

# 利用递归函数移动汉诺塔:
def move(n, a, b, c):
    if n == 1:
        print('move', a, '-->', c)
        return
    move(n-1, a, c, b)
    print('move', a, '-->', c)
    move(n-1, b, a, c)
move(3, 'A', 'B', 'C')  # n为A盘数量1

# 【14】高级特性
print('\n\033[1;31m【14】高级特性\033[0m\n')
# 传统的循坏实现 1 3 5 7 9
L = []
n = 1
while n <= 99:
    L.append(n)
    n = n + 2
print(L)

print('\n【1、切片Slice】')
# 切片Slice
L = ['Fuck','Bitch','Shit','Porn']
LL = [L[0],L[1],L[2]]  # 笨办法
print(LL)
LL = []
for n in range(2):   # 循环办法
    LL.append(L[n])
print(LL)
LLL = L[0:3]    # 切片办法,代表取0 1 2号元素
LLL = L[:3]     # 切片办法,0开始取可省略0
LLL = L[1:4]    # 切片办法,1 2 3
LLL = L[-2:-1]  # 切片办法,取倒数第二个2到倒数第1个(不包括倒数第1个)
LLL = L[-2:]    # 包括倒数第1个
print(LLL)
# 各种取法
L = list(range(100))
print(L)
LL = L[:10]
print(LL)
LL = L[-10:]
print(LL)
LL = L[0:10:2]  # 取0~10,隔2-1=1个取一个(第一个必取,从第一个开始,2个中取一个)
print(LL)
LL = L[::5]  # 全取,每5个取一个
print(LL)
LL = L[:]  # 全取,等于复制
print(LL)
T = (1,2,3,4,5)
TT = T[2:4]  # Tuple也可切片(1,2,3)[:3]类似形式
print(TT)
Str1 = 'abcdefg'
Str2 = Str1[0:3]  # 字符串也可切片
print(Str2)
# 【总结】切片可以节省循环,一句话实现

# 【迭代Iteration】
print('\n【2、迭代Iteration】')
# for循环遍历一遍就是迭代
# Python的for是高度抽象的循环
Fuck = {'Bitch':'Good','Porn':'OK','Shit':'No'}
for key in Fuck:  # 默认迭代key
    print(key)
for value in Fuck.values():  # 迭代value
    print(value)
for item in Fuck.items():  # 迭代key和value
    print(item)
for ch in 'Sandeepin':  # 字符串迭代
    print(ch)
# 判断一个对象是否能迭代
from collections import Iterable
print(isinstance('abc', Iterable))   # str可以
print(isinstance(123, Iterable))     # 整数不行
# 对list实现类似Java的下标循环
for i, value in enumerate(['A', 'B', 'C']):
    print(i,value)
for x, y in [(1, 1), (2, 4), (3, 9)]:  # 实现for循环引用两个变量
    print(x, y)

# 【列表生成式List Comprehensions】
print('\n【3、列表生成式List Comprehensions】')
# 用来创建list的生成式
# 生成 1 2 3 ... 10
print(list(range(1, 11)))
L = []
# 生成 1 4 9 ... 100
for x in range(1, 11):
    L.append(x * x)
print(L)
# 列表生成式的方法,生成 1 4 9 ... 100
LLL = [x * x for x in range(1, 11)]  # 生成结果 for 序号 in 序列
print(LLL)
# 后面能加 if 条件,例如只生成偶数的平方结果
LLL2 = [x * x for x in range(1, 11) if x%2 is 0]  # 生成结果 for 序号 in 序列
print(LLL2)
# 还可以两层、多层循环,实现全排列
LL = [m+n for m in 'ABC' for n in 'xyz']
print(LL)
# 字典键值同时迭代
for key,value in Fuck.items():  # 迭代key和value
    print(key,'=',value)
# 利用两个变量生成list
d = {'x': 'A', 'y': 'B', 'z': 'C' }
dd = [k + '=' + v for k, v in d.items()]
# list元素变小写
L = ['Hello', 'World', 'IBM', 'Apple']
L = [s.lower() for s in L]
print(L)
# 列出当前文件夹所有文件和目录
import os  # 导入OS模块
dirr = [d for d in os.listdir('.')]  # os.listdir列出当前文件夹所有文件和目录
print(dirr)
# 混合整型字符串的list转小写
L = ['Hello', 'World', 18, 'Apple', None]
S = [ss.lower() for ss in L if isinstance(ss, str)]  # 判断是否为字符串
print(S)

# 【生成器Generator】
print('\n【4、生成器Generator】')
# 列表生成式生成List受内存限制,很浪费空间。生成器在循环过程中不断推出后续元素,不必创建大量list,节省空间。
# 创建生成器Generator方法1:列表生成式[]改为()
g = (x * x for x in range(10))
print(next(g))
print(next(g))
print(next(g))  # 用next方法打印生成器

for n in g:    # 用for打印
    print(n)
# 复杂情况for循环实现不了的时候用函数实现,就需要生成器了
# Fibonacci数列 1, 1, 2, 3, 5, 8, 13, 21, 34
def FibonacciNum(num):
    n, a, b = 0, 0, 1
    while n < num:
        print(b)
        c = b
        b = a + b
        a = c
        # a, b = b, a + b  # 同时进行,可以省去一个变量
        n = n + 1
    return 'poi'
FibonacciNum(10)
# 递归实现Fibonacci数列
def FibonacciNumDigui(num):
    if num == 1:
        return 1
    elif num == 2:
        return 1
    else:
        out = FibonacciNumDigui(num - 1) + FibonacciNumDigui(num - 2)
        return out
print(FibonacciNumDigui(8))

# 变成生成器,只需要把print变成yield
def FibonacciGenerator(max):
  n, a, b = 0, 0, 1
  while n < max:
    yield b
    a, b = b, a + b
    n = n + 1
  return 'ppp'
# 变成generator的函数,在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行
fg = FibonacciGenerator(6)
print(next(fg))  # 在执行过程中,遇到yield就中断,下次又继续执行
print(next(fg))
print(next(fg))
print(next(fg))
print(next(fg))
print(next(fg))
for n in FibonacciGenerator(6):  # for循坏调用生成器,基本上不用next
    print(n)  # 但是拿不到return的值,要用StopIteration,以后再说

# 杨辉三角形生成[jfz写,不完善]
def YangTriangles(num):
    if num == 1:
        a = [1,]
        #print(a)
        return a
    if num == 2:
        a = [1,1]
        #print(a)
        return a
    if num >=3:
        c = list(range(num))
        c[0] = 1
        c[-1] = 1
        for i in range(1,num-1):
            c[i] = YangTriangles(num-1)[i-1] + YangTriangles(num-1)[i]
        return c
print(YangTriangles(6))

# 【迭代器Iterable】
print('\n【5、迭代器Iterable】')
# 可以直接作用于for循环的对象统称为可迭代对象:Iterable: list、tuple、dict、set、str、generator
# 用isinstance()判断
from collections import Iterable
print('迭代对象:',isinstance((x for x in range(10)), Iterable))
print('迭代对象:',isinstance('1232',Iterable))  # 字符串可以
print('迭代对象:',isinstance(1232,Iterable))  # 数字不可以
# 可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator
from collections import Iterator
print('迭代器:',isinstance((x for x in range(10)), Iterator))
print('迭代器:',isinstance('1232',Iterator))
# 可迭代对象变迭代器:iter()
print('变迭代器:',isinstance(iter([]), Iterator))
print('变迭代器:',isinstance(iter('1232'),Iterator))
# Iterator甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。


# 【15】函数式编程
print('\n\033[1;31m【15】函数式编程\033[0m\n')
# Functional  Programming,函数式编程就是一种抽象程度很高的编程范式
# 函数式编程的一个特点: 允许把函数本身作为参数传入另一个函数,还允许返回一个函数!
# 【高阶函数Higher-order function】

print('\n【1、高阶函数Higher-order function】')
absxxx = abs(-10)  # 变量指向函数返回值
print(absxxx)
absxx = abs  # 变量指向函数本身,函数名本身可看作一个变量,它指向具有某种作用的一个函数
print(absxx(-777))
# 一个函数接受另一个函数作为变量
def add(x, y, f):
    return f(x) + f(y)
print(add(-2, -3, abs))
# 把函数作为参数传入,这样的函数称为【高阶函数】

#【map/reduce】
# 有一个函数f(x)=x^2,要把这个函数作用在一个list[1, 2, 3, 4, 5, 6, 7, 8, 9]上,就可以用map()实现
fuck = [1,2,3,4,5,6]
def square2(x):
    return x * x
xxx = map(square2,fuck)  # 结果r是一个Iterator惰性序列
print(list(xxx))  # 用list算迭代器,计算出来
print(list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])))  # 将数字字符串化

# reduce把一个函数作用在一个序列[x1, x2, x3, ...]上, 把结果继续和序列的下一个元素做累积计算
# 效果就是:reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reduce
def add(x, y):
    return x + y
print(reduce(add, [1, 2, 3, 4, 5]))  # 等于是求和,还可用sum
# 把序列[1, 3, 5, 7, 9]变换成整数13579
def fn(x, y):
    return x * 10 + y
print(reduce(fn, [1, 3, 5, 7, 9]))

# map/reduce配合,整理成一个str2int的函数
def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    return reduce(fn, map(char2num, s))
print(str2int('123'))

# (jfz)实现输入:['adam', 'LISA', 'barT'],输出:['Adam', 'Lisa', 'Bart']
def normalize(name):
    namelow = name.lower()  # 转小写
    return namelow.capitalize()  # 转首字母大写
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

# (jfz)实现类似sum求和的求积函数prod()
def prod(L):
    def squareXxY(x, y):
        return x * y
    return reduce(squareXxY, L)
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))

# (jfz)实现str2float函数
def str2float(instr):
    def str2int(s):
        def fn(x, y):
            return x * 10 + y
        def char2num(s):
            return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
        return reduce(fn, map(char2num, s))
    [z, x]=instr.split('.')
    return str2int(z) + str2int(x)/(pow(10, len(x)))
print(str2float('123.456777'))

#【filter】
# filter()函数用于过滤序列
# 和map()类似,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。
# 例如删掉偶数
def is_odd(n):
    return n % 2 == 1
print(list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])))
# 例如删掉空字符串
def not_empty(s):
    return s and s.strip()
print(list(filter(not_empty, ['A', '', 'B', None, 'C', '  '])))
# 【注意】filter()函数返回的是Iterator,也要list化

# 埃氏筛法用filter求素数
# 先构造一个从3开始的奇数序列:
def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n
# 定义一个筛选函数:
def _not_divisible(n):
    return lambda x: x % n > 0
# 定义一个生成器,不断返回下一个素数:
def primes():
    yield 2
    it = _odd_iter()  # 初始序列
    while True:
        n = next(it)  # 返回序列的第一个数
        yield n
        it = filter(_not_divisible(n), it)  # 构造新序列
# 调用时需要设置一个退出循环的条件:
# 打印1000以内的素数:
for n in primes():
    if n < 1000:
        print(n)
    else:
        break
# (jfz)利用filter()滤掉非回文数:
print('回文数:')
def is_palindrome(n):
    strn = str(n)  # 转字符串
    i= len(strn)//2  # 半长度
    k = 0  # 回文计数
    for j in range(i):
        if strn[j] == strn[-(j+1)]:
            k = k + 1
    if k == i:# 回文次数=半长度说明回文
        return True
    else:
        return False
output = filter(is_palindrome, range(1, 1000))
print(list(output))

#【排序算法sorted】
# 排序的核心是比较两个元素的大小
# 数字直接比较,字符串或者两个dict呢?比较的过程必须通过函数抽象出来。
# 默认从小到大排list
print('从小到大排序:',sorted([36, 5, -12, 9, -21]))
# sorted()函数是高阶函数,可以接收一个key函数来实现自定义的排序
print('绝对值排序:',sorted([36, 5, -12, 9, -21],key=abs))
# 字符串排序,按ASCII的大小比较
print('字符串排序:',sorted(['bob', 'about', 'Zoo', 'Credit']))
# 按照字母序排序,忽略大小写
print('按字母排序(忽略大小写):',sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower))
# 反向排序,只需要传入第三个参数reverse=True
print('反向排序(从大到小):',sorted([36, 5, -12, 9, -21],reverse=True))
# 学生名字和成绩: 按名字排序
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
    tt = t[0]
    return tt
L2 = sorted(L, key=by_name)
print('按名字排序:',L2)
# 学生名字和成绩: 按成绩从高到低排序
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_score(t):
    tt = t[1]
    return tt
L2 = sorted(L, key=by_score, reverse=True)
print('按成绩排序:',L2)

# 返回函数
print('\n【2、返回函数】')
# 把函数作为结果值返回
# 通常求和的函数
def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return a
print('直接求和:',calc_sum(1, 3, 5, 7, 9))
# 如果不需要立刻求和,而是在后面的代码中,根据需要再计算怎么办?可以不返回求和的结果,而是返回求和的函数
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
# 定义的函数内部再定义一个函数,外函数返回内函数
print('延迟求和(返回求和函数):',lazy_sum(1, 3, 5, 7, 9))
# 当lazy_sum返回函数sum时,相关参数和变量都保存在返回的函数中,这种称为“闭包(Closure)”的程序结构拥有极大的威力
# 当我们调用lazy_sum()时,每次调用都会返回一个新的函数,即使传入相同的参数
f1 = lazy_sum(1, 3, 5, 7, 9)
f2 = lazy_sum(1, 3, 5, 7, 9)
print('闭包不等:',f1==f2)

# 【闭包】
# 返回的函数并没有立刻执行,而是直到调用了f()才执行
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs
f1, f2, f3 = count() # 将一个list中每个元素分别给f1, f2, f3
print('闭包调用才执行:', f1(), f2(), f3())  # 结果是9 9 9
# 原因就在于返回的函数引用了变量i,但它并非立刻执行。
# 等到3个函数都返回时,它们所引用的变量i已经变成了3,因此最终结果为9
# 【注意】返回闭包时牢记一点:返回函数不要引用任何循环变量,或者后续会发生变化的变量
# 如果一定要引用循环变量怎么办?方法是再创建一个函数,用该函数的参数绑定循环变量当前的值
def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行,因此i的当前值被传入f()
    return fs
f1, f2, f3 = count() # 将一个list中每个元素分别给f1, f2, f3
print('多一层函数:', f1(), f2(), f3())  # 结果是1 4 9

# 匿名函数
print('\n【3、匿名函数】')
# 就是没有名字的函数,关键字lambda表示匿名函数,冒号前面的x表示函数参数。
a = list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(a)
# 等于是:
def f(x):
    return x * x
a = list(map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(a)
# 匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果
f = lambda x: x * x
print(f(5))
# 把匿名函数作为返回值返回
def build(x, y):
    return lambda:x*x+y*y
aaa = build(3, 4)
print(aaa())

# 装饰器
print('\n【4、装饰器】')
# 通过变量也能调用该函数
def jfz():
    print('poi')
sa = jfz
sa()
# 函数对象有一个__name__属性,可以拿到函数的名字
print(sa.__name__)
print(jfz.__name__)
# 假设要增强jfz()的功能,如在函数调用前后自动打印日志,但又不希望修改函数
# 这种在代码运行期间动态增加功能的方式,称之为“装饰器”(Decorator)
# 本质上,decorator就是一个返回函数的高阶函数,定义如下函数:
def flog(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
kxy = flog(jfz)
kxy()
# 借助Python的@语法,把decorator置于函数的定义处:
@flog  # 调用now()函数,不仅会运行now()函数本身,还会在运行now()函数前打印一行日志
def now():  # 相当于执行了语句:now = flog(now)
    print('fuck')
# 由于flog()是一个decorator,返回一个函数,所以,原来的now()函数仍然存在,
# 只是现在同名的now变量指向了新的函数,于是调用now()将执行新函数,即在flog()函数中返回的wrapper()函数
# 如果decorator本身需要传入参数,那就需要编写一个返回decorator的高阶函数
# 比如,要自定义flog的文本:
def flog(text):
    def decorator(func):  # 原来def flog(func)放到了内层,外层传文本text
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator
# 这个3层嵌套的decorator用法如下:
@flog('异想家')
def now():
    print('fuck')
now()  # 显示结果为:异想家 now():\n fuck; now()相当于 now = log('execute')(now)
# 经过decorator装饰之后的函数,它们的__name__已经从原来的'now'变成了'wrapper':
print(now.__name__)
# 需要把原始函数的__name__等属性复制到wrapper()函数中,否则,有些依赖函数签名的代码执行就会出错
# Python内置的functools.wraps就是干这个事的,一个完整的decorator的写法如下:
import functools
def flog(func):
    @functools.wraps(func)  # 最后一层函数时用functools.wraps
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
# 针对带参数的decorator:
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

# (jfz)编写一个decorator,能在函数调用的前后打印出'begin call'和'end call'的日志
def belog(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('开始 %s()' % func.__name__)
        # f = func(*args, **kw)
        # print('结束 %s()' % func.__name__)
        # return f
        return [func(*args,**kw), print('结束 %s()' % func.__name__)][0]  # 网友的巧妙写法
    return wrapper
@belog
def now():
    print('fuck')
now()
print(now.__name__)

# (jfz)能否写出一个@log的decorator,使它既支持:
# @log
# def f():
#     pass
# 又支持:
# @log('execute')
# def f():
#     pass
def log(xxx):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    if isinstance(xxx,str):
        text = xxx
        return decorator
    else:
        text = '开始'
        return decorator(xxx)

@log
def lrz():
    print('路然真')
lrz()
print(lrz.__name__)

@log('姐姐')
def lrz():
    print('路然真')
lrz()
print(lrz.__name__)

# 偏函数Partial function
print('\n【5、偏函数Partial function】')
# 通过设定参数的默认值,可以降低函数调用的难度。而偏函数也可以做到这一点。
print('默认转十进制',int('12'))
print('自定义转八进制',int('12',base=8))
print('自定义转十六进制',int('12',16))
# 要转换大量的二进制字符串,定义一个int2()的函数,默认把base=2传进去:
def int2(x, base=2):
    return int(x, base)
# functools.partial就是帮助我们创建一个偏函数, 可以直接使用下面的代码创建一个新的函数int2:
import functools
intp2 = functools.partial(int, base=2)
print('偏函数转二进制',intp2('11111'))
# 【总结】functools.partial的作用就是把一个函数的某些参数给固定住,返回一个新的函数
# 也可以在函数调用时传入其他值:
print('偏函数转八进制',intp2('11', base=8))
# 创建偏函数时,实际上可以接收函数对象、*args和**kw这3个参数,当传入:
# int2 = functools.partial(int, base=2)相当于:
# kw = { 'base': 2 }
# int('10010', **kw)
max2 = functools.partial(max, 10)  # 把10作为*args的一部分自动加到左边
print('加了10的求最大',max2(5, 6, 7))  # 相当于:args = (10, 5, 6, 7);max(*args)

# 【16】模块Module
print('\n\033[1;31m【16】模块Module\033[0m\n')
# 为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,一个.py文件就称之为一个模块Module
# 最大的好处是大大提高了代码的可维护性。
# 其次,编写代码不必从零开始。
# 使用模块还可以避免函数名和变量名冲突。
# Python的所有内置函数:https://docs.python.org/3/library/functions.html
# 例如:一个abc.py的文件就是一个名字叫abc的模块

# 如果不同的人编写的模块名相同怎么办?
# 为了避免模块名冲突,Python又引入了按目录来组织模块的方法,称为包(Package)
# 方法是选择一个顶层包名,比如sandeepin,按照如下目录存放:
# -sandeepin
#    - abc.py
#    - jfz.py
# 现在,abc.py模块的名字就变成了sandeepin.abc
# 【注意】__init__.py文件必须存在,否则Python就把这个目录当成普通目录,而不是一个包。
# 类似的,可以有多级目录,组成多级层次的包结构。如fuck.bitch.shit
import sandeepin.poi.poilib
sandeepin.poi.poilib.poi()

# [使用模块]模板
# #!/usr/bin/env python3
# # -*- coding: utf-8 -*-
# ' a test module '
# __author__ = 'Sandeepin'
import sys
def test():
    # sys模块有一个argv变量,用list存储了命令行的所有参数。
    # argv至少有一个元素,因为第一个参数永远是该.py文件的名称
    # 运行python3 hello.py jfz获得的sys.argv就是['hello.py', 'jfz']
    args = sys.argv
    if len(args)==1:
        print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')
# 当我们在命令行运行hello模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 如果在其他地方导入该hello模块时,if判断将失败
# 因此,这种if测试可以让一个模块通过命令行运行时执行一些额外的代码
if __name__=='__main__':
    test()
# 启动Python交互环境,再导入hello模块, 没有打印Hello, word!,因为没有执行test()函数。

# [作用域]
# 在一个模块中,有的函数和变量我们希望给别人使用,有的函数和变量我们希望仅仅在模块内部使用
# 在Python中,是通过_前缀来实现,正常的函数和变量名是公开的(public),可以被直接引用
# 类似_xxx和__xxx这样的函数或变量就是非公开的(private),【不应该】被直接引用,比如_abc,__abc等
# private函数和变量不是【不能】被直接引用,是因为Python没有一种方法可以完全限制访问private函数或变量
def _private_1(name):
    return 'Hello, %s' % name
def _private_2(name):
    return 'Hi, %s' % name
def greeting(name):
    if len(name) > 3:
        return _private_1(name)
    else:
        return _private_2(name)
# 我们在模块里公开greeting()函数,而把内部逻辑用private函数隐藏起来
# 【技巧】外部不需要引用的函数全部定义成private,只有外部需要引用的函数才定义为public
print(greeting('jfz'))
print(greeting('Sandeepin'))
print(_private_1('San'))  # 并不限制用
print(_private_2('sss'))

# [安装第三方模块]
# 在Python中,安装第三方模块,是通过包管理工具pip完成的
# 比如安装Pillow的命令就是:pip install Pillow

# 图片生成缩略图
from PIL import Image
def JfzBlogImgThumb(ImgName):
    im = Image.open(ImgName)
    print(im.format, im.size, im.mode)
    if max(im.size[0], im.size[1]) > 1000:
        if im.size[0] > im.size[1]:
            im.thumbnail((1280, 1280))
        else:
            im.thumbnail((1000, 1000))
        im.save('thumb\\'+ImgName, 'JPEG')
    return 'OK'
JfzBlogImgThumb('1.jpg')


最后附上廖雪峰的教程地址:https://www.liaoxuefeng.com/wiki/1016959663602400

如果学习的话,更推荐直接阅读他的教程,讲得更详细。