自学python

最新推荐文章于 2024-08-26 18:48:07 发布

yu4hao4

最新推荐文章于 2024-08-26 18:48:07 发布

阅读量183

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/weixin_42147992/article/details/80472878

版权

python 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

好久没更新了，这次来波大的

1.装饰器

装饰器：
定义; 本质是函数，（装饰其他函数）就是为其他函数添加附加功能
原则： 1.不能修改被装饰的函数的源代码
        2.不能修改被装饰的函数的调用方式

实现装饰器知识储备：
1.函数即“变量”
2.高阶函数

    a.把一个函数名当做实参传给另外一个函数
    (在不修改被装饰函数源代码的情况下为其添加功能）
    b.返回值中包含函数名
    (不修改函数的调用方式)
3.嵌套函数

高阶函数+嵌套函数 = 装饰器

import time
def timmer(func):
    def warpper(*args,**kwargs):
        start_time = time.time()
        func()
        stop_time = time.time()
        print("the func run time is %s"%(stop_time-start_time))
    return warpper


@timmer
def test1():
    time.sleep(3)
    print("in the test1")

def bar():
    print("in the bar")

def foo():
    print("in the foo")
    bar()
foo()

import time

def  bar():
    time.sleep(2)
    print("in the bar")

def test1(func):
    start_time = time.time()
    func()  #运行bar
    stop_time = time.time()
    print("the func run time is %s"%(stop_time-start_time))
test1(bar)

def test2(func):
    print(func)
    return func
bar = test2(bar)
bar()

import time
def timer(func):
    def deco():
        start_time = time.time()
        func()
        stop_time = time.time()
        print("%s"%(stop_time-start_time))
    return deco

@timer  #test1 = timer(test1)
def test1():
    time.sleep(1)
    print('adadada')

@timer   #test2 = timer(test2)
def test2():
    time.sleep(1)
    print("asdasdasdfgsd")


test2()
test1()

2.局部变量

school = "oldboy edu"
names = ["alex","jack","rain"]
def stable_name():
    names[0] = "但敬爱死了的骄傲"
    print("inside func",names)
stable_name()#局部变量在修改全局变量的时候除了字符串和整数以外，其他的都可以改
print(names)

def change_name(name):
    global school#声明school为全局变量，可以进行修改全局变量
    print("before change ",name)
    name = "alex li"#局部变量只在函数里起作用，这个函数就是这个变量的作用域
    print("after change",name)

name = 'alex'
change_name(name)
print(name)

3.递归

# def calc(n):
#     print(n)
#     return calc(n+1)
#
# calc(0)


def cac(n):
    print(n)
    if int(n/2) > 0:
        return cac(int(n/2))
    print("->",n)
cac(10)



'''
递归特性：
1.必须有一个明确的结束条件
2.每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈这种数据结构实现的，
每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是
无限的，所以，递归调用的次数过多，会导致栈溢出）

'''

4.高阶函数

def add(a,b,f):
    return f(a)+f(b)

res = add(3,-7,abs)
print(res)

5.yield伪并发

import time
def consumer(name):
    print("%s 准备吃包子啦"%name)
    while True:
        baozi = yield
        print("包子[%s]来了，被[%s]吃了"%(baozi,name))

def producer(name):
    c = consumer('a')
    c2 = consumer('b')
    c.__next__()
    c2.__next__()
    print("老子开始做包子啦")
    for i in range(10):
        time.sleep(1)
        print("做了两个包子")
        c.send(i)
        c2.send(i)


producer("alex")

6.时间模块

import time
# print(time.time())#显示时间戳
# print(time.clock())#cpu执行时间
# print(time.gmtime())#这是国际第一时区的时间UTC世界标准时间
# print(time.localtime())#本地时间
# struct_time = time.localtime()
# print(time.strftime('%Y--%m--%d  %H:%M:%S',struct_time))#字符串时间
# print(time.strptime('2017-08-23 18:23:12','%Y-%m-%d %H:%M:%S'))#结构化时间
# a = time.strptime('2017-08-23 18:26:12','%Y-%m-%d %H:%M:%S')
# print(a.tm_mday)

print(time.ctime(3600))
print(time.mktime(time.localtime()))#把时间转化成时间戳


import datetime
print(datetime.datetime.now())

7.生成器


# 生成器一共两种创建方式：
# 1.  （x*2 for x in range(5))
#2.yield

def foo():
    print('sdfsdfasd')
    yield 1
    print("asdffhnukhjksqw")
    yield 2

g = foo()
next(g)
next(g)

#
# for i in foo():
#     print(i)
#
#
#
# def fib(max):
#     n,before,after = 0,0,1
#     while n<max:
#         print(after)
#         before,after=after,before+after
#         n = n+1
# fib(10)#3min

8.迭代器

#生成器都是迭代器，迭代器不一定是生成器
#list，tuple，dict，string：iterable（可迭代对象）

l=[1,2,3,5]
d = iter(l)
print(d)

# 什么是迭代器？
# # 满足两个条件：1.有iter方法  2.有next方法

print(next(d))
print(next(d))
print(next(d))
print(next(d))

9.迭代器生成器回顾

列表生成式
[x*2 for x in range(10)]

生成器(generator object)
    创建生成器两种方式：
        1.  （x*2 for x in range(10))>>>>>>>>generator object
        2.  def f():
                yield 2

                f()>>>>>>generator object

    生成器的方法：
        1.  next(f())---------计算出一个值
            注意：生成器在创建的时候已经决定了能计算出值的个数，调用next的次数超过这个值
         就会报StopIteration
         遍历所有元素可以通过for循环：
                    for i in [1,2,3]
                        print i
             for循环内部做了三件事:
                    1.调用对象的iter()方法，返回一个迭代器对象
                    2.while:
                            try:
                                i = next(list_Iterator)

                            except StopIteration:
                                break
        2.send():
            f().send(None)#等价于next(f())



#迭代器

    满足迭代器协议：
            1.内部有next方法
            2.内部有iter（）方法



time模块:
    time.time()
    time.strftime()
    time.gmtime():utc时间
    time.localtime()
    time.ctime():

datetime
    datetime.datetime.now()


random
    char():随机转化成字母和数字（验证码）

10.随机数

import random
# print(random.random())# 0-1随机数
# print(random.randint(1,8))# 1-8随机数包括8
# print(random.choice('hello'))
# print(random.choice(['123',4,[1,2,3]]))
# print(random.sample(['123',4,[1,2,3]],2))#随机选两个数
# print(random.randrange(1,3))#不包括3


def v_code():
    code = ''
    for i in range(6):
        add = random.choice([random.randrange(10),chr(random.randrange(65,91))])
    # code = ''
    # for i in range(5):
    #     if random.choice():
    #         add = random.randrange(10)
    #
    #     else:
    #         add = chr(random.randrange(65,91))
        code+=str(add)
    print(code)

v_code()#生成6位数随机验证码