Python学习笔记1

-*- coding: utf-8 -*-
Python 学习笔记(thanks for Micheal liao)

# 1. 寻找素数
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)

for n in primes():
	if n <100:
		print(n)
	else:
		break

# 2. 排序
print(sorted(['Bob','alice','Zoo','yook'],key=str.lower,reverse=True))

# 3. 闭包
# 内部函数使用了外部函数的参数和局部变量
# 返回的函数中保存了外部函数的参数和局部变量
# 这种程序结构叫做闭包
def lazy_sum(*args):
	def sum():
		ax = 0
		for n in args:
			ax = ax + n
		return ax
	return sum
f=lazy_sum(1,3,5,7,9)
print(f)
print(f())

# 闭包需要注意的问题就是就不要用变化的作为参数
# 比如list等
def count():
	fs = []
	for i in range(1,4):
		def f():
			return i*i
		fs.append(f)
	return fs
f1,f2,f3 = count()
print(f1(),f2(),f3()) #结果不是1，4，9 而是9，9，9
# 因为返回的函数并不是立刻执行的，而是调用的时候才执行
# 就是当i=3的时候才返回的
# 怎样去避免这种情况，除了使用不可变参数外
# 就是再声明一个方法，用该方法的参数绑定变量当前的值

def count():
	fs = []
	def f(i):
		def g():
			return i*i
		return g
	for i in range(1,4):
		fs.append(f(i))
	return fs
f1,f2,f3=count()
print(f1(),f2(),f3()) #输出为1，4，9

# 4. 匿名函数
# 一个匿名函数的demo
print(list(map(lambda x:x*x,[1,2,3])))
# >>>[1,4,9]
# 其中的lambda x:x*x 等价于
def f(i):
	return i*i

# 使用匿名函数(lambda关键字)就是为了方便，匿名函数没有return
# 函数的表达式结果就是返回值


# 5. 装饰器
# 在代码运行期间动态增加功能的方式，称为装饰器(Decorator)

# 一个demo
def log(func):
	def wrapper(*args,**kw): # *args,**kw 表示可以接收所有参数
		print("call %s():" % func.__name__)
		return func(*args,**kw)
	return wrapper

@log
def now():
	print("2016-08-17")

now()

# >>> call now():
#     2016-08-17

# 分析：
# 1.该装饰器的目的是为了在打印日期的时候，打印出方法的名字的日志
# 2.@log 相当于执行了now = log(now)
# 3.now函数作为参数传入到装饰器函数中，装饰器本质就是一个高级函数
#   可以接收函数作为参数，并返回一个函数。
# 4.原来的now函数依然存在，只是执行的是同名的返回的wrapper函数，在wrapper
#   函数中先打印日志，然后调用原始函数。


# 6. 偏函数(Partial function)
# 当函数的参数个数太多，需要简化时，
# 使用functools.partial可以创建一个新的函数，
# 这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

# demo
import functools
int2=functools.partial(int,base=2)
print(int2('1000000'))
# >>>64

# 总结:其实就是类似于Python中默认参数的用法。


# 7. 作用域
# 正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等；
# 类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用
# 只是不应该，并不是不可以。

# demo
def __private1(name):
	return 'hello,%s' % name

def __private2(name):
	return 'hi,%s' % name

def greeting(name):
    if len(name) > 3:
        return __private1(name)
    else:
        return __private2(name)

# 总结:这个demo只是告诉我们，外部不需要引用的函数全部定义成private，
#      只有外部需要引用的函数才定义为public。



# 8. 面向对象编程(OOP)
# 经典的编程思想,一切皆对象。每个对象包含了数据和操作数据的函数
# 类是抽象的模板，实例是具体化的类

# demo 
class Student(object): # (object)表示继承自object类

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

    def print_score(self):
        print('%s: %s' % (self.name, self.score))
# 调用
bart = Student('bart simpson',59)
bart.name
>>>'bart simpson'
# 一点提示：self其实就是实例本身，还记得java中的this嘛
# 在类中定义的函数第一个参数永远是self,调用时，不用传递该参数。
# __init__方法类似于java中的构造函数

# 访问限制
# 如果不想属性被直接的访问到并可以修改，可以把属性改成私有的
# 就是在属性前加__

# demo
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))
# 如果要访问并修改就要添加get/set类似的方法
def get_name(self):
	return self.__name
def set_score(self, score):
        self.__score = score



# 9. 继承和多态
# 同样是OOP的特性之一，继承和多态与java中学的一样，并没什么特别的
# 只需要注意到Python是动态语言。对于继承，动态语言的鸭子特性需要注意
# java中必须传入的类型是需要的对象的父类或者子类，否则无法调用其方法
# Python则不需要，只要是像鸭子或者走起路来像鸭子就可以继承。


# 10. 面向对象高级编程
# 实例属性和类属性
class Student(object):
	name = 'Micheal' # 类属性
s = Student()
s.Name = 'Bob' # 实例属性，注意不要和类属性重名

待续.........