python的一些学习笔记

#demo.py

from __future__ import division

print 'inpuit you number '
a = raw_input('input you string:')
print("you input the number :",a)

def power(x):
return x*x

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

def pw(s,n):

while n>1:
n = n-1
s= s*n
print s
print n
return s

def nop():
pass
def enroll(name,grad):
print 'name:',name
print 'grad:',grad

def add_end(l=[]):
l.append('end')
return  l

def add_args(*number):
sum=0
for n  in  number:
sum = sum+n*n

return sum
summ =[1,2,3]

# Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
#
# 默认参数一定要用不可变对象，如果是可变对象，运行会有逻辑错误！
#
# 要注意定义可变参数和关键字参数的语法：
#
# *args是可变参数，args接收的是一个tuple；
#
# **kw是关键字参数，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})。
#
# 使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

def fact(n):
if n==1:
return 1
return  n*fact(n-1)
#但是以上情况,容易出现栈的益处 ,所以需要优化

def fact1(n):
return  fact1_iter(n,1)

def fact1_iter(number,pro):
if number ==1:
return pro
return fact1_iter(number-1,number*pro)

l=[]
m=1
while m<99:
l.append(m)
m =m+2
print  m

#切片功能
k=['3,','4','5']
print k[0:3]     #输出从0开始到3的数值
print k[1:3]      #输出从索引1开始，取出2个元素出来：
print k[-1]       #输出倒数最后一个元素
print k[-2]       #输出倒数第二个元素

#列表生成器
#要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用range(1, 11)：
range(1,11)
print range(1,11)

#使用内建的isinstance函数可以判断一个变量是不是字符串：
x = 'abc'
y=18
print "isinstance 是不是字符串",isinstance(x,str)
print "isinstance 是不是字符串",isinstance(7,str)

#。在Python中，这种一边循环一边计算的机制，称为生成器（Generator）。
# 要创建一个generator，
# 有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

#Python内建了map()和reduce()函数
#map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回

def fun(x):            # fun(x) =x*x
return  x*x

print map(fun,[1,2,3,4,5])

# 还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串
print map(str,[1,2,3,4,5])      #result ['1', '2', '3', '4', '5', '6', '7', '8', '9']

#关键字lambda表示匿名函数，
def build(x, y):
return lambda: x * x + y * y

# 由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数

def now():
print  '2016年12月24日12:37:19'
# 类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量
#类似_xxx和__xxx这样的函数或变量就是非公开的（private,不应该被直接引用

def _pritvate_1(name):
return  'hello,%s' %name

def _private_2(name):
return  'hi,%s' %name
def greeting(name):
if len(name)>3:
return _pritvate_1(name)
else:
return _private_2(name)

# Python提供了__future__模块，把下一个新版本的特性导入到当前版本，于是我们就可以在当前版本中测试一些新版本的特性
# Python为了确保你能顺利过渡到新版本，特别提供了__future__模块，让你在旧的版本中试验新版本的一些特性。
# 如果你想在Python 2.7的代码中直接使用Python 3.x的除法，可以通过__future__模块的division实现：
#导入的函数

print '10 / 3 =', 10 / 3

# -*- coding: utf-8 -*-

from multiprocessing import Process
from multiprocessing import Pool
import  os
class Student(object):
pass                 #预制空的  ,起到一个占位的作用

# 可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候
#注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，
# 因为self就指向创建的实例本身
# 有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去
class Stu(object):
def __init__(self,name,score):
self.name = name
self.score = score

def print_scroe(std):
print  '%s,%s' %(std.name,std.score)

def get_grade(self):
if self.score>=90:
return  'A'
elif self.score>=70:
return 'B'
else:
return 'C'
# 访问限制
# 如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），
# 只有内部可以访问，外部不能访问，所以，我们把Student类改一改：

class Stu1(object):
def __init__(self,name,score):
self.__name = name
self.__score = score

# 对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__score

# 但是如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：

class Student(object):

def get_name(self):
return self.__name

def get_score(self):
return self.__score

#在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。
#
# 有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
#
# 双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，
# 所以，仍然可以通过_Student__name来访问__name变量：

# 在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。

class Animal(object):
def run(self):
print 'dog is running '
class Dog(Animal):
def run(self):
print 'dog is running '
class Cat(Animal):
def  run(self):
print  'cat is running'
#对于Dog来说，Animal就是它的父类，对于Animal来说
# 由于Animial实现了run()方法，因此，Dog和Cat作为它的子类，什么事也没干，就自动拥有了run()方法

# dog = Dog()
# dog.run()
#
# cat = Cat()
# cat.run()

# 当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()

# 判断一个变量是否是某个类型可以用isinstance()判断：
#
# >>> isinstance(a, list)
# True
# >>> isinstance(b, Animal)
# True
# >>> isinstance(c, Dog)
# True

# 我们来判断对象类型，使用type()函数
# type(123)
# <type 'int'>

# 我们要判断class的类型，可以使用isinstance()函数。

try:
print 'try  '
except ZeroDivisionError ,e :
print 'except' ,e
finally:
print  'finally'
print 'END'
# 使用Python内置的open()函数，传入文件名和标示符
# try:
#     f= open('C:\Python27\NEWS.txt','r')
#     print f.read()
# finally:
#     if f:
#         f.close()
#在这里是一次性的读入 ,文件小的话还能接受 ,文件大的就有点不能接受了.会卡死的现象
# 但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：

# with open('C:\Python27\NEWS.txt', 'r') as f:
#     print f.read()

f= open('C:\Python27\NEWS.txt','r')
for line in f.readlines():
print(line.strip())

#写文件

# 写文件和读文件是一样的，唯一区别是调用open()函数时，传入标识符'w'或者'wb'表示写文本文件或写二进制文件：

# f= open('C:\Python27\NEWS.txt','w')
# f.write('hello this is write file')
# f.close()

with open('C:\Python27\NEWS.txt', 'w') as  f:
f.write('hjsdfsdfsdfsdfsdfsdfssdfsdfsdfsdf')

with open('C:\Python27\NEWS.txt', 'r') as f:
print f.read()

# 在Python中，文件读写是通过open()函数打开的文件对象完成的。使用with语句操作文件IO是个好习惯。

# 操作文件和目录
# 如果我们要操作文件、目录，可以在命令行下面输入操作系统提供的各种命令来完成。比如dir、cp等命令
# Python内置的os模块也可以直接调用操作系统提供的接口函数。
#
# 打开Python交互式命令行，我们来看看如何使用os模块的基本功能：   这里需要导入import os模块 ,在最上边
print  os.name
# os.uname()
print  os.environ
print  os.path.abspath('.')

# 然后创建一个目录:
filetest  ='C:\Python27\mestdir'
if os.path.isdir(filetest):
print   filetest,'is exist and  is a file'
else:
os.mkdir('C:\Python27\mestdir')     #创建一个文件夹
print   filetest,' new   mkdir '
# 删掉一个目录:
os.rmdir('C:\Python27\mestdir')

# print  os.path.splitext('/path/to/file.txt')

#一个路径拆分为两部分，后一部分总是最后级别的目录或文件名
print  os.path.split('/Users/michael/testdir/file.txt')
# os.path.splitext()可以直接让你得到文件扩展名
print  os.path.splitext('/Users/michael/testdir/file.txt')

# 对文件重命名:
# os.rename('/Users/michael/testdir/file.txt', 'test.py')
# 删掉文件:
# os.remove('test.py')

print [x for x in os.listdir('.') if os.path.isdir(x)]

#线程 ,进程
#线程是最小的执行单元，而进程由至少一个线程组成。如何调度进程和线程，完全由操作系统决定，程序自己不能决定什么时候执行，执行多长时间。

# 由于Python是跨平台的，自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。
#
# multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了启动一个子进程并等待其结束：
#导入的模块在顶部

def run_proc(name):
print 'Run child proces %s (%s)' %(name,os.getpid())
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 'process will start'
p.start()

p.join()
print 'process end '
# 子进程要执行的代码
# 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 'Process will start.'
#     p.start()
#     p.join()
#     print 'Process end.'
#
# import  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()
#     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.'

# from time import ctime,sleep
#
# def music():
#     for i in range(2):
#         print "I was listening to music. %s" %ctime()
#         sleep(1)
#
# def move():
#     for i in range(2):
#         print "I was at the movies! %s" %ctime()
#         sleep(5)
#
# if __name__ == '__main__':
#     music()
#     move()
#     print "all over %s" %ctime()

# 多任务可以由多进程完成，也可以由一个进程内的多线程完成。
# Python的标准库提供了两个模块：thread和threading，thread是低级模块，threading是高级模块，
# 对thread进行了封装。绝大多数情况下，我们只需要使用threading这个高级模块。
# 启动一个线程就是把一个函数传入并创建Thread实例，然后调用start()开始执行：

import threading,time
def loop():
print 'threading %s is running ' %threading.current_thread().name
n=0
while n<6:
n = n+1
print 'thread %s,name>>>%s' %(threading.current_thread().name,n)
time.sleep(1)
print 'thread %s,end' %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.currentThread().name

# 分布式进程
# 由于任何进程默认就会启动一个线程，我们把该线程称为主线程，主线程又可以启动新的线程，Python的threading模块有个current_thread()函数，
# 它永远返回当前线程的实例。主线程实例的名字叫MainThread，

# 正则表达式
# Python提供re模块，包含所有正则表达式的功能。由于Python的字符串本身也用\转义

#
# PIL
# PIL：Python Imaging Library，已经是Python平台事实上的图像处理标准库了。PIL功能非常强大，但API却非常简单易用