import os
#文件读写 不用自动关闭
with open('test.txt','r') as f:
#一次性读取所有
data = f.read()
#print(data)
print('---------循环打印------------')
with open('test.txt','r') as f:
for line in f:
if line=='':
print('遇到\n换行符')
else:
#为什么输出是换行？
print(line)
with open('test.txt','w') as f:
f.write('你好\n')
f.write('热烈欢迎\n')
#line1='我爱北京'
#line2='*'
#with open('test.txt','w') as f:
# print(line1,file f)
# print(line2,file f)
#nt表示是window
print(os.name)
#环境变量
print(os.environ)
#操作文件与目录
print(os.path.abspath('.'))
#在某个目录下面创建一个新的目录
print(os.path.join('batman\python\demo','pictures'))
#os.rmdir('E:\\batman\\python\\demo\\pictures')
#os.mkdir('E:\\batman\\python\\demo\\pictures')
#os.rename('学习目标.txt','learntarget.txt')
#os.remove('learntarget.txt')
#复制文件os没有提供 可以使用shutil
#import shutil 学习！！！
#shutil.copyfile('E:\\batman\\python\\demo\\learntarget.txt','E:\\batman\\python\\demo')
print('-------------序列化和反序列化------------------')
import pickle
d=dict(name='王晓春',age=30,adress='安徽')
#调用dumps函数进行序列化
str=pickle.dumps(d)
print(str)
f=open('dump.txt','wb')
#将序列化的内容写入到f文件中
pickle.dump(d,f)
f.close()
#使用json序列化
import json
d=dict(name='小四',age=28,adress='潮州')
str=json.dumps(d)
print(str)
#调用loads反序列化
d=json.loads(str)
print(d)
#求绝对值得函数 abs
print(abs(-100))
print(type(abs))
#abs 具有复制的能力
f=abs
print(f(-99))
def add(x,y,f):
return f(x)+f(y)
print(add(-4,4,abs))
print('----------匿名函数------------')
sum=lambda arg1,arg2:arg1+arg2
print(sum(1,2))
#reduce内建函数是一个二元操作函数，用来将一个数据集合(列表、元组)中的所有数据进行如下操作：传给reduce中的函数
#func()必须是一个二元操作函数先对集合中的第1,2个数据进行操作，得到的结果在与第三个数据用func()函数进行运算
from functools import reduce
l=[1,2,3,4,5,6,7,8]
print(reduce(lambda x,y:x+y,l))
#给一个初始值，放在list后面
print(reduce(lambda x,y:x+y,l,10))
#map函数
new_list=list(map(lambda i:i+1,l))
print(new_list)
l2=[2,3,4]
new_list=list(map(lambda x,y:x+y,l,l2))
print(new_list)
#filter()函数可以对序列做过滤处理，把序列的每一项传到自定义的过滤函数里面处理
f1=[33,44,55,666]
new_list=list(filter(lambda x:x<100,f1))
print(new_list)
print('----------装饰器------------')
def hello(fn):
def wrapper():
print('hello, %s' %fn.__name__)
#回调函数
fn()
print('goodbye, %s' %fn.__name__)
return wrapper()
#hello注解 hello函数中返回了一个inner函数wrapper,这个wrapper函数回调了传过来的fn
#并在回调前后加了两条语句
#可以理解为把一个函数传到另外一个函数中，在回调自己
@hello
def foo():
print('i am foo')
foo()
#斐波那契数列递归算法
from functools import wraps
def memo(fn):
cache={}
miss=object()
@wraps(fn)
def wrapper(*args):
result=cache.get(args,miss)
if result is miss:
result=fn(*args)
cache[args]=result
return result
return wrapper
@memo
def fib(n):
if n<2:
return n
return fib(n-1)+fib(n-2)
print('---------动态添加属性和方法-----------')
#动态给对象添加属性和方法
from types import MethodType
#__slots__限制添加属性和方法
class MyClass(object):
__slots__ = ['name','set_name']
def set_name(self,name):
self.name=name
mycls=MyClass()
mycls.name='jack'
mycls.set_name=MethodType(set_name,mycls)
mycls.set_name('tom')
print(mycls.name)
#限制对继承类不起作用
class YoursClass(MyClass):
pass
youcls=YoursClass()
youcls.age=30
print(youcls.age)
import traceback
class Student:
@property
def score(self):
return self._score
@score.setter
def score(self,value):
if not isinstance(value,int):
raise ValueError('not int')
elif value<0 or value>100:
raise ValueError('not between')
self._score=value
#只读属性
@property
def double_score(self):
return self._score * 2
s=Student()
s.score=75
print(s.score)
print(s.double_score)
try:
s.double_score=150
except AttributeError:
traceback.print_exc()
#自己实现描述器 __set__/__get__/__del__
class MyProperty:
def __init__(self, fget=None, fset=None, fdel=None):
print(fget)
self.fget=fget
self.fset=fset
self.fdel=fdel
def __get__(self,instance,cls):
if self.fget:
self.fget(instance)
def __set__(self, instance, value):
if self.fset:
self.fset(instance,value)
def __del__(self, instance):
if self.fdel:
self.fdel(instance)
def getter(self,fn):
self.fget=fn
def setter(self,fn):
self.fset=fn
def deler(self,fn):
self.fdel=fn
class Student2:
@MyProperty
def score(self):
return self._score
@score.setter
def set_score(self,value):
self._score=value
s=Student2()
s.score=95
print(s.score)