python寒假入门[0]

一、类以下的基础语法

1、字符串

print(type("123"))
print(type(u"123"))
print(type(r"123"))
print(type(b"123"))

输出结果:

<class ‘str’>

<class ‘str’>

<class ‘str’>

<class ‘bytes’> (字节序列)

python中字符串是不可改变的,然而bytearray可以改变

2、字符串拼接

a= ','.join(['fuck','shit','meow'])
print(a)

输出结果 fuck,shit,meow(可以用join来拼接字符串,中间可以加分隔符)


2、集合类型

列表(list ) (Cpython里为数组)(采取了指数过分配(exponential over-allocation)(不懂))

list.insertlist.delete在任意一个位置插入或删除元素的复杂度为 O(n)

even=[]
for i in range(0,11):
    if(i%2==0):
        even.append(i)
print(even)
>>>[0,2,4,6,8,10]

这样的写法计算比较慢,应该使用以下的方法(列表推导)

even=[i for i in range(11) if i%2==0]
print(even)
>>>[0,2,4,6,8,10]

元组(tuple)

枚举(enumerate)

for i,element in enumerate(['one','two','three']):
    print(i,element)

zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。

序列解包 

a,b,*c=1,2,3,4,5
print(a)
print(b)
print(c) 
1
2
[3, 4, 5]

字典(dictionary)将一组唯一键映射到对应的值

{
    1: 'a',
    2: 'two',
    3: 'fuck',
}
squares={num:num**2 for num in range(11)}
print(squares.values())
print(squares.keys())
print(squares.items())


dict_values([0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100])
dict_keys([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
dict_items([(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64), (9, 81), (10, 100)])

集合 (set)  值为空的字典

3、进阶语法

1)迭代器

i=iter('123')
print(next(i))
print(next(i))
print(next(i))
============================
1
2
3
Traceback (most recent call last):
  File ".\iter.py", line 5, in <module>
    print(next(i))
StopIteration
=====================================
class CountDown:
    def __init__(self,step):
        self.step=step
    def __next__(self):
        if self.step <=0:
            raise StopIteration
        self.step-=1
        return self.step
    def __iter__(self):
        return self

for element in CountDown(4):
    print(element)
================================
3
2
1
0

2)生成器

def fib():
    a,b=0,1
    while True:
        yield b
        a,b=b,a+b
f=fib()
print([next(f) for i in range(10)])
print(type(f))
====================================
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
<class 'generator'>

使用yield语句(我感觉大概跟return差不多 但是不会退出函数,然后会返回一个生成器)

3)装饰器

import time
def now(func):
    def wrapper(*args,**kw):
        print("call %s at " % (func.__name__) + time.strftime('%Y_%m_%d') )
        return func(*args,**kw)
    return wrapper
@now
def fuck():
    print('fuck!')
fuck()
================================
call fuck at 20190201
fuck!
"""一个可以打印运行日期的装饰器"""

本质上,装饰器是一个返回函数的函数,要想自定义每次装饰器输出的内容,可以3层嵌套

import time
def now(text):
    def decorator(func):
        def wrapper(*args,**kw):
            print("%s %s at " % (text,func.__name__) + time.strftime('%Y_%m_%d') )
            return func(*args,**kw)
        return wrapper
    return decorator
@now("say")
def fuck():
    print('fuck!')
fuck()
=======================
say fuck at 2019_02_01
fuck!

使用 fuck() 首先调用 now(“say”)然后返回 decorator() 函数,在调用 decorator( fuck() )返回wrapper() 在调用wrapper() 先打印print语句,在返回 fuck() ———————————————-(大概)

然而经过decorator装饰之后的函数,它们的__name__已经从原来的'now'变成了'wrapper'

在第14行加上

print(fuck.__name__)
===============
wrapper

不需要编写wrapper.__name__ = func.__name__这样的代码,Python内置的functools.wraps就是干这个事的

import time
import functools
def now(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args,**kw):
            print("%s %s() at " % (text,func.__name__) + time.strftime('%Y_%m_%d') )
            return func(*args,**kw)
        return wrapper
    return decorator
@now("say")
def fuck():
    print('fuck!')
fuck()

print(fuck.__name__)
======================
say fuck() at 2019_02_01
fuck!
fuck

装饰器也可以写成一个类

class DecoratorClass:
    def __init__(self,function):
        self.function=function
    def __call__(self,*args,**kwargs):
        # 调用函数前做些什么
        result=self.function(*args,**kwargs)
        # 调用函数后做些什么
        return result

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注