python基础学习第六天

Posted 2021-02-06 愤怒中的小草

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(‘遇到
换行符‘)
        else:
            #为什么输出是换行？
            print(line)
with open(‘test.txt‘,‘w‘) as f:
    f.write(‘你好
‘)
    f.write(‘热烈欢迎
‘)
#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(‘batmanpythondemo‘,‘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)