python进阶

函数式编程

　　高阶函数：一个函数可以接收另一个函数作为参数

　　　　map() : map(function, Iterrable)  :将传入的函数一次作用于序列的每个元素上，并将结果作为新的Iterator返回

# 实现,f(x) = x2, 作用于l = [1,2,3,4]
def func(x):
    return x*x
L = reduce(func, [1,2,3,4])
print(L)

　　　　reduce() ：reduce把一个函数作用在一个序列上，该函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

# 实现[1,2,3,4,5]Z转换为12345
def func(x,y):
    return x×10 + y

L = reduce(func, [1,2,3,4,5,6])
print(L)

　　　　

　　　　filter() ： filte把传入的函数作用于每个元素，根据返回值true/false 过滤元素

# 将序列中的空字符串删除

def not_empty(s):
    return s and s.strip()

# print(list(filter(not_empty, ['A', '', 'B', None, 'C', '  '])))

# 使用filter筛选出回数
def is_palindrome(n):
     return str(n) == str(n)[::-1]

output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))

　

　　　　sorted()：可接收一个key函数实现自定义的排序，将函数作用于每一个元素，按key函数返回的结果进行排序

print(sorted([36, -25, -68, 79], key=abs))
print(sorted(['bob', 'about','Zoo']))
print(sorted(['bob', 'about','Zoo'], key=str.lower))

>>>
[-25, 36, -68, 79]
['Zoo', 'about', 'bob']
['about', 'bob', 'Zoo']

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

def by_name(t):
    return t[0].lower()

def by_score(t):
    return t[1]

print(sorted(L, key=by_score, reverse=True))
print(sorted(L, key =by_name ))

　　返回函数：闭包，将函数作为结果值返回（返回函数名）

# 计数器，每次调用counterA()时，+1
def createCounter():
    f = [0]
    def counter():

        f[0] = f[0] + 1
        return f[0]
    return counter

counterA = createCounter()
print(counterA(),counterA())

　　

　　匿名函数：lambda  x：(x为函数参数）不需要显示定义函数，使用表达式的结果作为返回值

L = list(filter(lambda x: x %2 ==1 , range(1,20)))
print(L)

　　装饰器：调用函数时，不修改函数定义，但调用时动态增加功能的方式

# 装饰器函数
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print(func.__name__)
        return func(*args, **kw)
    return wrapper

@log  #将装饰器装饰在now函数上
def now():
    print('2015-3-25')

now()
print(now.__name__)

　　　　当装饰函数需要传入参数时

#  当装饰器函数需要传入参数时:
def log(text):
    def derectorA(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print(func.__name__)
            return func(*args, **kw)

        return wrapper
    return derectorA

@log('execute')
def now():
    print('2021-6-23')

now()
print(now.__name__)

　　

　　　　例：设计一个装饰器，打开多装饰函数的执行时间

# 设计decoratoe,打印函数的执行时间
import time
def metric(fn):
    @functools.wraps(fn)  # 作用是让所装饰的函数名称等属性复制到wrapper上，（保证依赖函数签名的代码执行正常）
    def wrapper(*args, **kw):
        t1 = time.time()
        print(t1)
        fn(*args, **kw)
        t2 = time.time()
        print(t2)
        print('%s executed in %s ms' % (fn.__name__, t2-t1))
        return fn(*args, **kw)

    return wrapper

# 测试
@metric
def fast(x, y):
    time.sleep(0.0012)
    return x + y

@metric
def slow(x, y, z):
    time.sleep(0.1234)
    return x * y * z

f = fast(11, 22)
s = slow(11, 22, 33)

　　偏函数：将函数的某些参数固定，返回一个新的函数（与默认参数的作用一致，降低函数调用的难度）

# 实现转换二进制字符串,int(x, base =2)[应用于批量转换二进制字符串]

int2 = functools.partial(int, base = 2)  #偏函数
print(int2('100011'))
print(map(int2, ['110', '100', '001']))

面向对象编程

"""
类属性实例属性实例方法类方法静态方法
"""

class ClassA():
    name = '类属性名称'  # 类属性，类访问，所有实例也均可访问

    # 构造函数，可写可不写，当需要给所有实例绑定必须的属性时，可编写加上必须绑定的属性
    def __init__(self, Test_name):
        self.test_name = Test_name  # 实例属性

    # 实例方法,由实例调用
    def instance_func(self):
        print("调用实例方法")

    # 类方法,由类调用也可由实例调用
    @classmethod
    def class_func(cls):
        print("调用类方法")

    # 静态方法,可被类和实例调用
    @staticmethod
    def satic_func():
        print("调用静态方法")


test = ClassA("测试名称")
print(test.test_name)  # 实例调用实例名称

print(ClassA.name)  # 类调用类属性
print(test.name)  # 实例调用类属性
test.instance_func()
test.class_func()
ClassA.class_func()
test.satic_func()
ClassA.satic_func()

　　访问限制：限制外部访问内部属性，可通过方法访问获取属性，修改属性时同样有一样的范围限制，不可随意修改　

# coding=utf-8
# 访问限制，不允许访问name属性，修改score属性时，限制修改范围为：60-100


class Student(object):
    def __init__(self, name, score):
        self.__name = name  # 私有属性,外部代码不可随意修改对象内部的状态
        self.__score = score

    # 允许外部代码获取属性及一定程度范围的修改
    def get__score(self):
        return self.__score

    def set__score(self, score):
        if 60 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('error score')


s1 = Student('byy', 110)
print(s1.get__score())  # 通过使用方法获取属性
print(s1.set__score(99))  # 通过调用方法修改属性
print(s1.__score)  # 属性名称前加__,变为私有变量,只有内部可以访问,外部不能访问

　　继承和多态

class Animal(object):
    def run(self):
        print('Animal is running')


class Dog(Animal): #继承Animal类
    def run(self):  # 子类的run覆盖父类run方法
        print('dog is running')

class Tortoise(object):
    def run(self):
        print("Tortoise is running")

dog = Dog()
dog.run()  # 调用子类的run方法,

def run_teice(am): # 传入实例,该实例有run方法
    am.run()
run_teice(Dog())
run_teice(Tortoise())

　　获取对象信息　　　　

　　　　判断对象的类型  isinstance(dog, Dog）

　　　　获取一个对象的所有属性和方法：dir（）  

　　　　通过后面的方法配合可操作对象的状态：getattr（）、setattr（）、hasattr（）

class Myobject():
    def __init__(self):
        self.x = 9
    def power(self):
        print('hh')


obj = Myobject()
m = 'abc'
print(dir(m)) # 获取对象的所有属性和方法
print(dir(obj))
print(hasattr(obj, 'x')) # 判断是否有属性x
print(setattr(obj, 'y', 16)) # 为对象设置属性y
print(getattr(obj, 'y'))  # 获取属性y

　　

# 每创建一个实例, count值加一
class Student(object):
    count = 0

    def __init__(self, name):
        self.name = name
        Student.count = Student.count+1

S1 = Student('S1')
S2 = Student('S2')
print(Student.count)
print(S1.count)

　　__slots__  : 限制实例属性的绑定

定义类并创建了类的实例后，可动态的给实例添加任何属性和方法，

class Student(object):
    pass

def set_age(self,age):
    self.age =age  # 可通过self来给实例绑定属性

S1 = Student()
S1.name = 'S1'  # 可任意给实例绑定属性

from types import MethodType  # 给S1实例单独绑定方法
S1.set_age = MethodType(set_age, S1)

S1.set_age(12)
print(S1.age)
print(S1.name)

限制实例可以绑定的属性，__slots__    (__slots只对当前类的实例起作用，对继承的子类不起作用）

# 限制实例属性的绑定
class Student(object):
    __slots__ = ('name', 'age') # 使用tuple定义允许绑定的属性名称

S1 = Student()
S1.name = 'S1'
S1.score = 99   # 不允许绑定该属性

　　@property  ： 装饰器负责将方法变成属性去调用

调用属性的方式不变的同时，增加对属性的检查（之前通过get_score, set_score实现对属性的检查，但调用的是方法，因此@property的作用为将方法变成属性去调用）

getter ： 只读属性   setter：赋值属性， 未调用setter则为一个只读属性

class Screen(object):   # 定义一个可修改值属性width和只读属性resolution
 
    @property
    def width(self):
        return self._width

    @property
    def resolution(self):  # 定义resolution]为只读属性
        return 'resolution'

    @width.setter  # width属性
    def width(self,wid_value):
        if not isinstance(wid_value, int):
            raise TypeError('width must be integer')
        if wid_value<0:
            raise ValueError('width must between 1~100')
        self._width = wid_value

sc = Screen()
sc.width = 99
print(sc.resolution )