Python初学者学习案例之一

----------普通人：计划失败 -> 沮丧 -> 骂自己一顿 -> 制订新计划 -> 继续失败----------学霸：计划失败 -> 沮丧 -> 骂自己一顿 -> 深度思考计划为啥失败 -> 改善问题 -> 制订

案例:

一、定义变量及变量的类型范围、使用

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
print ('Hello,world!')
print (100+2)
100+2
name = input()
name
print (name)
print ("input 是 value:",name)


print ('''lin1
lin2,
lin3\'\\\n,''')


print (r'''lin1
lin2,
lin3\'\\\n,''')


age = input('input age:')
age = int(age)
if age >= 18:
    print ('adult,',age)
else:
    print ('teenager,',-age)


if age>=15:
print('you age is:',age)
print('adult')


sum=0
for x in range(101):
sum= sum + x
if sum>3000:
sum = sum - 200
continue
if sum>4000:
break
print(sum)



n = input('n is value:')
n= int(n)
while n>20:
    sum = sum + n
    n = n - 1
print(sum)
#List
s_lis=['b','a','c']
s_lis.sort()
print(s_lis)
a1='Abc'
b1=a1.replace('c','C')
print(b1)
#dict的使用
d={'张三':99,'李四':98}
print('value is:',d['张三'])


#查询key值是否存在
a = '张三' in d
print(a)


#set的使用
s=set([1,2,3,4,4])
print(s)
s.add(5)
s.remove(4)
print(s)


s1=set([2,5,6])
print(s&s1)
print(s|s1)

二、paython变量进阶

#內建函数

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#绝对值
print(abs(-23))

#函数指向
a=abs
print(a(-1))

#最大值
print('\n最大:',max(1,2,-0.12),'最小:',min(1,2,-0.12))

#类型转换
print('\n浮点转整数:',int(12.45),'字符型:',str(100),'浮点型:',float(21),'boolean:',bool(1))
print('\n十进制转化为十六进制:',hex(255),'|',hex(100))

#用def自定义函数(不传=默认参数值)
def my_abs(x=2):
if x>=0:
return x
else:
return -x
print('\n自定义绝对值函数:',my_abs(-3))


#x2平方函数
def power(x):
   return x*x
print('平方:',power(2))


#List作为参数
def add_endList(L=None):
if L is None:
L=[]
L.append('ok')
return L
print(add_endList([1,2,3]))


#可变参数设定：可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组


装为一个tuple
def calc(*number):
sum = 0
for n in number:
sum = sum +n*n
return sum


nums = [1,2,3,4]
print('\n可变参数乘积为:',calc(*nums))


#关键字参数允许你传入0个或任意个含参数名的参数,函数内部自动组装为一个dict
def personMes(name,age,**kw):
print('name:',name,'age:',age,'other:',kw)
print('不加可变字参数:',personMes('Michael',30))
print('加可变参数:',personMes('Michael',30,city='beijing'))


#如果要限制关键字参数的名字，就可以用命名关键字参数
def personMes1(name,age,*,city,addr):
print(name,age,city,addr)
print('*限制参数:',personMes1('Li','80',city='tongzhi',addr='LSG'))


#Such As：
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,3,'a','b')
f1(1,2,3,'a','b',e='aa')


f2(1,2,d='sd',ext=99)


args=(1,2,3,4)
kw={'d':99,'x':'%'}
f1(*args,**kw)


args=(1,2,3)
f2(*args,**kw)


#递归函数：极容易栈溢出
def backFun(n):
if n==1:
return 1
return n*backFun(n-1)
print(backFun(10))


#递归函数：修改后的代码
def backReFun(num,total):
if num==1:
return total
return backReFun(num-1,total*num)
print(backReFun(3,1))


#应用一下，构造1.3.5.7.....99
L1=[]
n=1
while n<100:
L1.append(n)
n=n+2


print('\n构造:',L1)


#提取前一半数据1.3..5.7.....49
H=[]
for x in range(0,int(len(L1)/2)):
H.append(L1[x])
print('\n循环去前一半:',H)


#可是这种循环方式还是太繁琐,运用切片
print('\n切片取前一半:',L1[0:int(len(L1)/2)])

print('\n切片取后一半:',L1[-int(len(L1)/2):])

print('\n切片取后一半,每两个取一个:',L1[-int(len(L1)/2)::2])

print('\ntuple取数据:','ABCDEFGHIJKLMN'[-10:-5:2])

三、paython之分片、迭代、列表生成式、生成器

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

#----分片-------
print('\ntuple取数据:','ABCDEFGHIJKLMN'[-10:-5:2])

#----迭代-------
#dict对象迭代：无序的
d={'a':1,'b':2,'c':3}
for key in d:
print(key)
for key in d.values():
print(key)
for ch in 'ABC':
print(ch)


#通过collections模块的Iterable类型判断：一个对象是否为可迭代对象
from collections import Iterable #导包
print(isinstance('abc',Iterable))#调用isinstance方法验证
print(isinstance(123,Iterable))


#实现下标及value值循环迭代
d1 = ['A','B','C']
for i,value in enumerate(d1):
print(i,value)


d2=[(3,5),(2,4),(7,8)]
for x,y in d2:
print(x,y)


#----列表生成式-------
#构造生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(range(0,10)))


#构造[1x1, 2x2, 3x3, ..., 10x10]
L=[]
for x in range(1,11):
L.append(x*x)
print(L)


#换一种方式(加个条件偶数的平方)
print([x*x for x in range(1,11) if x%2==0])


#两层循环
print([m+n for m in 'ABC' for n in 'def'])


#列出当前目录下的文件名
import os
print([d for d in os.listdir('D:/')])#os.listdir列出文件和目录


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


#转换为小写
print([s.lower() for s in d1])


#练习:只输出字符串
L1 = ['Hello', 'World', 18, 'Apple', None]
print([x for x in L1 if isinstance(x,Iterable)==True],'\n')


#----生成器-----
#只要把一个列表生成式的[]改成()，就创建了一个generator生成器：
for n in (x*x for x in range(10)):
print(n)


#著名的斐波拉契数列（Fibonacci）
#generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而#变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回
，再次执行时从上次返回的yie#ld语句处继续执行。
def fib(num):
n,a,b =0,0,1
while n<num:
yield b #print(b) 替换后就成为生成器就不再是一个函数了
a,b = b,a+b
n=n+1
return 'done over'


#因为是generator,所以取值不用next用for
for n in fib(6):
print(n)
#捕捉错误
g=fib(6)
while True:
try:
x=next(g)
print('g:',x)
except StopIteration as e:
print('Generator return exception message:',e.value)
break
#生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
#把list、dict、str等Iterable变成Iterator可以使用iter()函数
from collections import Iterator
print(isinstance(iter([]), Iterator))


#凡是可作用于for循环的对象都是Iterable类型；
#凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
#集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数


获得一个Iterat#or对象。

四、python之函数式编程

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


#函数式编程:
#函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一#个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有
副作用。

#而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因#此，这种函数是有副作用的。
#函数本身也可以赋值给变量，即：变量可以指向函数。
f=abs
print(f(-10))

#既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数#就称之为高阶函数。
#特点:函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回

一个函数
#试想下我们可以使用工厂模式根据不同的条件来更换函数来达到我们的目的
def abs_as(x,y,z):
return z(x)+z(y)

print('高阶绝对值函数传入函数:',abs_as(-2,-4,f))

#----map/reduce-----
#是一个Iterator，需要通过list()函数让它把整个序列都计算出来并返回一个list
#map()作为高阶函数，事实上它把运算规则抽象了，因此，我们可以计算简单的f(x)=x2
def f(x):
return x*x 
r = map(f,[1,2,3,4,5,6,7,8,9])
print('Iterator 转为List',list(r))#迭代结算

#字符串也可以
print('转化为字符串',list(map(str,[1,2,3,4,5,6,7,8,9])))

#再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, #...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
#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 用法:',reduce(add,[1,2,3,4,5,6,7,8,9]))
print('sum求和:',sum([1,2,3,4,5,6,7,8,9]))


#求和世界用sum就可以了,但是序列[1, 3, 5, 7, 9]变换成整数13579
from functools import reduce
def fn(x,y):
return x*10+y
print('合并',reduce(fn,[1,3,5,7,9]))


#练习1
L1 = ['adam', 'LISA', 'barT']
def normalize(x):
return(x[0].upper()+x[1:].lower())
#return x.capitalize()
print(list(map(normalize, L1)))


#练习2
from functools import reduce
def str2float(s):
def str_num(s):
return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]
def fn(x,y):
return x*10+y
n=s.find('.')
ss = s[:n]+s[n+1:]
return reduce(fn,map(str_num,ss))/(10**n)
print('字符串转化为浮点型:str2float(\'123.456\') =', str2float('123.456'))


#-----filter 过滤序列--------
#Python内建的filter()函数用于过滤序列
#List接收为对象，可以意识到filter()函数返回的是一个Iterator
#保留奇数
def is_odd(s):
return s%2==1
print('Filter保留奇数:',list(filter(is_odd,[1,2,3,4,5,6,7,8,9])))


#去掉空字符串
L2 = ['A','B','',None,'D']
def not_empty(s):
return s and s.strip()
print('Filter去掉空字符串:',list(filter(not_empty,L2)))


#换一种方式
from collections import Iterable #导包
print([x for x in L2 if isinstance(x,Iterable)==True])#去不掉为空的字符串


#练习:计算素数的一个方法是埃氏筛法，它的算法理解起来非常简单：把2的倍数帅选调,在


剩下额数中把3##的倍数帅选掉，以此类推得到所有素数

五、python之过滤

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

#---sorted排序算法-接收一个key函数-----
print('排序:',sorted([34,23,-4,-65,78]))
print('绝对值排序:',sorted([34,23,-4,-65,78],key=abs))
print('字符串排序按ASCII大小:',sorted(['bob', 'about', 'Zoo', 'Credit']))
print('字符串排序忽略大小写:',sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower))
print('反向忽略大小写:',sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower,reverse=True))


#练习：按姓名排序或按成绩
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def fn(n):
return n[0];
print('函数按姓名排序',sorted(L,key=fn))
print('按姓名排序',sorted(L,key=lambda x:x[0]))
print('按成绩排序',sorted(L,key=lambda x:x[1]))

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


#函数式编程:
#----返回函数----
#高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。


def lazy_sum(*args):
def sum():
ax=0
for n in args:
ax = ax + n
return ax
return sum
f = lazy_sum(1,2,3,4,5,6)
print(f())#当调用lazy_sum直返回了sum函数，此时里面的sum并没有执行，当f()时就执行sum函数了，并返回结果
#内部函数sum可以引用外部函数lazy_sum的参数和局部变量,相关参数和变量都保存在返回的函数中这种称##为“闭包（Closure）”的程序结构拥有极大的威力.

#牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。如果一定要引用循环变##量怎么办？方法是再创建一个函数
def count_sum():
def f(j):
def g():
return j*j
return g
L=[]
for x in range(1,4):
L.append(f(x))## f(i)立刻被执行，因此i的当前值被传入f()
return L

f1,f2,f3 = count_sum()
print(f1())
print(f2())
print(f3())

#---匿名函数----
#当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。
#计算f(x)=x2时，除了定义一个f(x)的函数外，还可以直接传入匿名函数:
print('\n匿名函数:',list(map(lambda x:x*x,[1,2,3,4,5,6,7,8,9])))


#n匿名函数也是一个函数对象
fu = lambda x:x*x
f =fu
print(f(2),'：匿名函数对象\n')


#也可以把匿名函数作为返回值返回,改上一个例子
def count_sum1():
def f(j):
return lambda:j*j
L=[]
for x in range(1,4):
L.append(f(x))## f(i)立刻被执行，因此i的当前值被传入f()
return L
f1,f2,f3 = count_sum()
print('改后:',f1())
print('改后:',f2())
print('改后:',f3())

#----装饰器----
#函数对象有一个__name__属性，可以拿到函数的名字：
#def now():
# print('2017-7-28')
#f = now
#print(f._name_)

#在函数调用前后自动打印日志，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）
#完整的decorator写法如下:

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator(func=text) if callable(text) else decorator # callable检测是否被调用

#是否带参数的两种情况
@log('call funcation:')
def now():
    print('2015-3-25')

@log
def now1():
    print('2015-3-26')

now()
now1()
print('函数对象:',now.__name__)

#-----偏函数----------
#字符串转化为整数
print(int('123456'))


#但实际上，这个int函数是有另外一个参数，用来进制转换，默认十进制，所以才可以转化为整形
print(int('123456',base=8))
print(int('123456',8))


def int_cover(x,base=8):
return print('封装后:',int(x,base))

int_cover('123456')


#Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）
#过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。
#functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int_cover()


import functools
int2 = functools.partial(int, base=8)
print('偏函数:',int2('123456'))
max2 = functools.partial(max, 10)
print('偏函数:',max2(5, 6, 7))

六、加群

有需要进行辅导帮助解决问题的同学，可以加群喔:不是推销，就是IT问题讨论