Python练习1

1.反向迭代一个序列

lst= [1,2,3,4,5,6,4,3]
lst.reverse()
for x in lst:
    print(x)


非list手动重排
lst = (2,3,4,5,6)
for i in range(len(lst)-1,-1,-1):
    # print(i)
    print(lst[i])

2.查询并替换一个文本中的字符串

str = 'hello python, my name is liuxin,nice to neet you '
print(str.replace('liuxin', 'LIUXIN'))

import re
pattern = r'(hello|python)'
print(re.sub(pattern,'bye',str))

3.使用Python实现单例模式

1. 使用__new__方法,把类实例绑定到类变量上,通过内部代码实现
class SingleInstance(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = object.__new__(cls, *args, **kwargs)
        return cls._instance
class TestClass(SingleInstance):
    a = 1

test1 = TestClass()
test2 = TestClass()

print(test2 is test1)
print(id(test1), id(test2))


2. 使用装饰器
def SingleInstance(cls, *args, **kwargs):
    isinstance = {}
    def _singleinstance():
        if cls not in isinstance:
            isinstance[cls] = cls(*args,**kwargs)
        return isinstance[cls]
    return _singleinstance

@SingleInstance
class TestClass(object):
    a = 1

test1 = TestClass()
test2 = TestClass()

print(id(test2), id(test1))

3. 使用__metaclass__(元类)
class Single(type):
    def __init__(cls, name, bases, dict):
        super(Single, cls).__init__(name, bases, dict)
        cls._instance = None

    def __call__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super(Single, cls).__call__(*args, **kwargs)
        return cls._instance

class TestClass(metaclass=Single):
    pass

test1 = TestClass()
test2 = TestClass()
print(id(test1), id(test2))

4.重新实现str.strip()

def rightstrip(temStr, splitStr):
    endindex = temStr.rfind(splitStr)
    while endindex != -1 and endindex == len(temStr) - 1:
        temStr = temStr[:endindex]
        endindex = temStr.rfind(splitStr)
    return temStr

def leftstrip(temStr, splitStr):
    startindex = temStr.find(splitStr)
    while startindex == 0:
        temStr = temStr[:startindex]
        startindex = temStr.find(splitStr)
    return temStr

5.super的原理

class A(object):
    def __init__(self):
        print('enter A')
        super(A, self).__init__()
        print('leave A')

class B(object):
    def __init__(self):
        print("enter B")
        super(B, self).__init__()
        print("leave B")

class C(A):
    def __init__(self):
        print("enter C")
        super(C, self).__init__()
        print("leave C")

class D(A):
    def __init__(self):
        print("enter D")
        super(D, self).__init__()
        print("leave D")

class E(B, C):
    # def __init__(self):
    #     print("enter E")
    #     super(E, self).__init__()  # change
    #     print("leave E")
    pass
    # 继承顺序F->E->B

class F(E, D):
    def __init__(self):
        print("enter F")
        super(F, self).__init__()  # change
        print("leave F")

test = F()

6.闭包

装饰器是闭包的一种
自由变量:未在本地作用域定义的变量,例如定义在外层函数的作用域中的变量
闭包:出现在嵌套函数中,内层函数用到了外层函数的自由变量,就形成了闭包
内层函数就是闭包,内层函数中引用的外层函数的变量可以通过外层函数传入参数而改变,

闭包理解为一种特殊的函数，这种函数由两个函数的嵌套组成，且称之为外函数和内函数，外函数返回值是内函数的引用，此时就构成了闭包。

python中的使用@语法实现的单例模式就是利用闭包实现的，只不过用了@作为语法糖，使写法更简洁，闭包函数将函数的唯一实例保存在它内部的__closure__属性中，在再次创建函数实例时，闭包检查该函数实例已存在自己的属性中，不会再让他创建新的实例，而是将现有的实例返给它。

def 外层函数(参数):
    def 内层函数():
        print("内层函数执行", 参数)

    return 内层函数


内层函数的引用 = 外层函数("传入参数")
内层函数的引用()

def func(a, b):
    def line(x):
        return a * x - b

    return line


line = func(2, 3)
print(line(5))

7.给列表中的字典排序

alist = [{"name": "a", "age": 20}, {"name": "b", "age": 30}, {"name": "c", "age": 25}]
alist.sort(key=lambda x:x.get("age"))
print(alist)

8.合并两个列表排除重复元素

alist = ['a','b','c']
blist = ['x','b', 'q']

def merge_list(*args):
    s = set()
    for i in args:
        print(i)
        s = s.union(i)
    print(s)
    return s

merge_list(alist, blist)

9.打乱一个有序列表

from random import shuffle
list = [x for x in range(10)]
print(list)
shuffle(list)
print(list)

10.实现简单的栈结构stack

class Stack():
    def __init__(self):
        self.value = []

    def push(self, x):
        self.value.append(x)

    def pop(self):
        self.value.pop()

stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.value)
stack.pop()
print(stack.value)

11.输入一个日期,判断是一年中的哪一天

from datetime import datetime
def which_day(year, month, day):
    return (datetime(year, month, day) - datetime(year-1, 12, 31))

print(which_day(2017,1,1))

12.把字符串”k1:1|k2:2|k3:3”处理成 python 字典的形式:{k1:1,k2:2,k3:3}

def string_to_dict(string):
    d = {}
    for kv in string.split('|'):
        k,v = kv.split(':')
        if v.isdigit():
            v = int(v)
        d[k] = v
    return d

print(string_to_dict('k1:1|k2:2|k3:3'))

13.杨氏矩阵

杨氏矩阵:杨氏矩阵，是对组合表示理论和舒伯特演算很有用的工具。它提供了一种方便的方式来描述对称和一般线性群的群表示，并研究它们的性质。有一个二维数组. 数组的每行从左到右是递增的，每列从上到下是递增的. 在这样的数组中查找一个数字是否存在。 时间复杂度小于O(N);

14 获取最大公约数(欧几里得算法)

整数 m、n的最大公约数 等于 n和m除以n的余数的最大公约数。
a = 25
b = 15

def max_common(a,b):
    while b:
        a,b=b,a%b
    return a

print(max_common(a,b))

15.求两个数的最小公倍数(公式法)

两个数的乘积 等于 这两个数的 最大公约数 和 最小公倍数的 乘积

a = 25
b = 15

def min_commin(a,b):
    c = a * b
    while b:
        a, b = b, a % b
    return c // a

16.获取中位数

如果总数的个数是奇数,则去中间的那个数;反之,取中间两个数的平均数

num = [2,3,41,2,6,7,8]
def median_number(num):
    listnum = [num[i] for i in range(len(num))]
    listnum.sort()
    lnum = len(listnum)
    if lnum % 2 == 1:
        i = int((lnum + 1) / 2) - 1
        return listnum[i]
    else:
        i = int(lnum / 2) - 1
        return (listnum[i] + listnum[i + 1]) / 2

print(median_number(num))# 可以用整除 // 优化


num = [2,3,41,6,7,8,9]
print(sorted(num))
def medin(data):
    data.sort()
    half = len(data) // 2
    return (data[half] + data[~half]) / 2
print(medin(num))