复习-基础

一、review-base

其他语言吗和python的对比

 

c   vs   Python
c语言是python的底层实现，解释器就是由python编写的。
c语言开发的程序执行效率高，开发现率低（内存的管理），python开发效率更高
java   vs  python
同一个级别，都需要解释器老解释代码。
python简洁方便，java繁琐。
python对于机器学习等强大的类库（模块）。

解释型语言和编译型语言

解释型：边解释边执行（即时翻译）。
代表：python，php，shell
编译型：将所有代码编译成指定文件。如：.dll，然后再去执行.dll文件。
代表：c，c++,Go,c#,java

 字节和位的关系

1Byte = 8bit 
1Kb = 1024Byte
1Mb = 1024Kb
1Gb = 1024Mb
1Tb = 1024Gb

Python中如何实现 二进制、八进制、十进制、十六进制 之间的转换？

# 其他转十进制
a1 = "010101010101111"
int(a1,base=2)

# 十进制转二进制
bin(8123)
# 十进制转八进制
oct(87234)
# 十进制转十六进制
hex(3453)

练习：

如 10.3.9.12 转换规则为：
            10            00001010
    
         3            00000011

             9            00001001
    
        12            00001100

    再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？

def ip_func():
    ip_num = input("请输入一个ip地址:")
    s = ""
    ip_list = ip_num.split(".")
    for i in ip_list:
        i = bin(int(i)).lstrip("0b")
        if len(i) != 8:
            i = i.zfill(8)
            s += i
    return int(s,2)
print(ip_func())

字节码和机器码

机器码：是汇编的结果，给操作系统直接读取使用。
字节码：字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。例如：xxx.pyc文件，这个就是python中的中间文件

执行脚本头文件 #!/usr/bin/env python

Linux下运行python文件：
方式一：
     a.py 
           print(123)
                
      python a.py 
方式二：
     a.py 
             #!/usr/bin/env python
             print(123)
            
     赋予可执行权限
      ./a.py     

执行脚本头文件 # --coding:utf-8 -*-

py2中：默认编码是asicc(切记！py2一定要用--coding:utf-8 -*-)
py3中：默认编码是utf-8

运算符

v1 = 1 or 2                  # 1
v2 = 6 and 1 or 2 and 9     # 1
v3 = 1 or 3                 # 1
v4 = 1 and 3                # 3
v5 = 0 and 2 and 1          # 0
v6 = 0 and 2 or 1           # 1
v7 = 0 and 2 or 1 or 4      # 1
v8 = 0 or False and 1      # False

三元表达式/三元运算/三目运算

v1 = 'x1' if 1==1 else 'x2'

常见数据类型

str: split、join、strip、upper
list: append、pop、insert、extend、reverse
tuple:
dict: ....

练习题：

示例1：
data = [
        {'id': 1, 'name': 'x1'},
        {'id': 2, 'name': 'x2'},
        {'id': 3, 'name': 'x3'},
        {'id': 4, 'name': 'x4'},
    ]
data_dict = {}
for item in data:
    data_dict[item["id"]] = item
print(data_dict)
while True:
    nid = int(input("请输入id"))
    if nid in data_dict:
        print("success")
    else:
        print("faile")

示例2：
data = [
        {'id': 1, 'name': 'x1'},
        {'id': 2, 'name': 'x2'},
        {'id': 3, 'name': 'x3'},
        {'id': 4, 'name': 'x4'},
    ]
data_dict = {}
for item in data:
    data_dict[item["id"]] = item
data_dict[2]["name"] = "鹿晗"
print(data)

示例3：
data = [
        {'id': 1, 'name': 'x1','pid':None},
        {'id': 2, 'name': 'x2','pid':1},
        {'id': 3, 'name': 'x3','pid':2},
        {'id': 4, 'name': 'x4','pid':1},
    ]
data_dict = {}
for item in data:
    item["children"] = []
    data_dict[item["id"]] = item
# print(data_dict)
for item in data:
    pid = item["pid"]
    if not pid:
        continue
    data_dict[pid]["children"].append(item)
print(data_dict)

练习题：
v = [11, 232, 122, 13, 122, 31, 123, 111]
获取列表中第二大的数字。
def second(ln):
    max = 0
    s = {}
    # 查看个数出现的次数然后与赋值给max，
    for i in range(len(ln)):
        flag = 0
        for j in range(len(ln)):
            if ln[i] >= ln[j] and i != j:
                flag = flag + 1
        s[i] = flag
        print(s)
        if flag > max:
            max = flag
    for i in s:
        if s[i] == max - 1:
            break
    print(ln[i])
second([11,232,122,13,122,31,123,111] )

函数的参数

def func(a1, a2=[]):
    a2.append(a1)
    return a2


v1 = [11, 22, 33]
result1 = func(55)
print(result1)     # [55]

result2 = func(44, v1) 
print(result2)     # [11, 22, 33, 44]

result3 = func(66)
print(result3)    # [55, 66]

闭包函数

SQLAlchemy源码
class Query(object):
    
        def get(self, a1):
            return 1
    
        def filter(self, a1, a2):
            return 2
    
    
    class NewFoo(object):
        pass
    
    
    def method(name):
        def inner(*args, **kwargs):
            return getattr(Query, name)(*args, **kwargs)
        return inner
    
    
    for name in ['get', 'filter']:
        setattr(NewFoo, name, method(name))
    
    obj = NewFoo()
    print(obj.get(1111))

Stark组件
class UserInfoConfig(ModelStark):
        
        def show_gender(...):
            if is_header:
                return "性别"
            
            return obj.get_gender_display()
        
        def show_level(...):
            if is_header:
                return "级别"
            
            return obj.get_level_display()
        
        def show_status(...):
            if is_header:
                return "状态"
            
            return obj.get_status_display()
            
        list_display = ['name','email',show_gender,show_level,show_status]
        
    
    
    def get_display(filed_name,title):
        def show(obj,is_header):
            if is_header:
                return title 
            tpl = "get_%s_display" %filed_name
            
            return getattr(obj,tpl)()
            
        return show
    
    class UserInfoConfig(ModelStark):
        
       
        list_display = ['name','email',get_display('gender','性别'),get_display('level','级别'),get_display('status','状态')]

装饰器

编写装饰器计算函数执行时间

import time
from functools import wraps


def time_this_function(func):
    # 作为装饰器使用，返回函数执行需要花费的时间
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        # 函数的名字
        print(func.__name__, end - start)
        return result

    return wrapper


if __name__ == '__main__':
    @time_this_function
    def count_number(n):
        while n>0:
            time.sleep(0.1)
            n+=-1
    count_number(10)

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import time

def deco_limit(s, foo= None):
    """
    这是个函数装饰器，可以控制访问频率
    :param s: 该参数为访问频率，每多少s一次
    :param foo: 可选参数，用户自定制装饰器逻辑（比如cookie或状态验证等，执行返回值为False则不执行函数)  #该参数实现了，我又删了，不好用，给你提供思路自己做
    :return:
    """
    def wrpper(func):
        """
        该函数接受被修饰函数作为参数，返回装饰器，变量func_identify为变量标识，
        存储被修饰函数的name为key，value为调用成功的时间戳。key-second存储为时间频率
        :param func: 参数为被修饰函数
        :return:
        """
        name = func.__name__
        func_identify ={name: 0,'foo': foo, 'second': s}
        def inner(*args, **kwargs):
            """
            执行函数
            :param args: 将接收的参数，打包
            :param kwargs:
            :return:
            """
            useable_time = func_identify[name] + func_identify['second']
            time_now = time.time()
            remain_time = useable_time-time_now
            # print(remain_time)
            if time_now > useable_time:
                func_identify[name] = time_now #设置调用时间
                res = func(*args,**kwargs)
            else:
                print('\033[32;1mFunction \033[31;1m{0} \033[0m'\
                      .format(name)+'\033[32;1mcan be used after {0:.2f} seconds later\033[0m'\
                      .format(remain_time))
                res = None
            return res

        return inner
    return wrpper




#以下为被装饰函数foo1
@deco_limit(5)     #在这儿参数为设置调用间隔时间
def foo1(*args, **kwargs):
    """ do something with args and kwargs"""
    print('执行foo1--everything is ok')
    return 'result'

#以下为被修饰函数func1
@deco_limit(3)     #间隔时间为3秒
def func1(*args, **kwargs):
    """ do something with args and kwargs"""
    print('执行func1---呱呱呱')
    return 'result'

print('测试混合执行：')
foo1(1,2,3)
func1(1,2,3)
foo1(2,3,4)
time.sleep(3)
foo1(5,6,7)
time.sleep(2)
foo1(7,9,0)

print('\n测试混合执行--：')
func1(1,2,3)
foo1(2,4,52)
func1(2,3,4)
time.sleep(3.2)
foo1(3,4,5)
func1(5,6,7)

#-----以下为运行结果------------
测试混合执行：
执行foo1--everything is ok
执行func1---呱呱呱
Function foo1 can be used after 5.00 seconds later
Function foo1 can be used after 2.00 seconds later
执行foo1--everything is ok

测试混合执行--：
执行func1---呱呱呱
Function foo1 can be used after 5.00 seconds later
Function func1 can be used after 3.00 seconds later
Function foo1 can be used after 1.80 seconds later
执行func1---呱呱呱

装饰器实现函数重复执行

def counter(num):
    def outer(func_name):
        def inner(*args,**kwargs):
            for i in range(num):
                func_name()
        return inner
    return outer
@counter(5)
def func():
    print(123)
func()

装饰器的应用场景？

- flask路由系统
- django用户登录 auth 
- django csrf token (from django.views.decorators.csrf import csrf_protect,csrf_exempt)

列表生成式 + lambda 表达式

示例1：
for i in range(10):
    pass
print(i)    # 9

示例2：
def func(a1):
    return a1 + 100
func_list = []
for i in range(10):
    func_list.append(func)
result = func_list[4](10)
print(result)    # 110

示例3：
def func():
    return i+100
func_list = []
for i in range(10):
    func_list.append(func)
result = func_list[2]()
print(result)    # 109

示例4：
func_list = []
for i in range(10):
    func_list.append(lambda : i+100)
result  = func_list[2]()
print(result)   # 109  lambda 是匿名函数，i+100是函数体。只是for循环并没有调用，等到调用的时候再执行

示例5：
func_list = [lambda :i+100 for i in range(10)]
result = func_list[7]()
print(result)   # 109   一样

示例6：
def num():
    return [lambda x:i*x for i in range(4)]
print([m(2) for m in num()])   # [6,6,6,6]

示例7：
def outer(value):
    def inner():
        print(value)

    return inner


func_list = []
for i in range(10):
    func_list.append(outer(i))

func_list[0]()
func_list[1]()
func_list[2]()
func_list[3]()
func_list[4]()
# 0
# 1
# 2
# 3
# 4

生成器

def func():
    yield 1
    yield 2
    yield 3
    yield 4
obj = func()

练习：

通过yield自己实现一个类似于py3 range的功能

def func():
    for i in range(10):
        yield i
print([i for i in func()])

补充：
py3中list(range(100))与py2中的range(100)相同，直接输出
py3中的range(100)和py2中xrange(100)相同，是生成器，for循环输出值

常见的内置函数

max、min、len、bin、oct、hex、zip
    
区别：map、filter、reduce（functools）

filter 过滤出符合条件的元素
        res = filter(lambda x:x>2 ,[1,2,3])
        for i in res:
            print (i)  # 3
    map对指定序列做映射
        res = map(lambda x:x**2 ,[1,2,3])
        for i in res:
            print (i)  # 1  4  9
    reduce 对参数序列中元素进行累积
        from functools import reduce
        def add(x,y):
            return x + y
        ret = reduce(add,[1,2,3,4,5])
        print(ret)   # 1+2+3+4+5=15
        # 使用lambda函数
        ret = reduce(lambda x,y:x+y,[1,2,3,4,5])
        print(ret)  # 1+2+3+4+5=15

列举常见的内置模块、第三方模块

内置：os、sys、json、time、random、uuid、logging、hashlib、re ...
第三方模块：pandas、numpy、bs4、xpath、requests、scrapy、pymysql、dbutils、gevent-websocket、redis

re模块

match/search区别？

match与search函数功能一样，match匹配字符串开始的第一个位置，search是在字符串全局匹配第一个符合规则的。
简单来说就是：
    re.match与re.search的区别：re.match只匹配字符串的开始，
    如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
    而re.search匹配整个字符串，直到找到一个匹配。

什么是正则的贪婪匹配？

举例说明：
    如：String str="abcaxc";
    　　Patter p="ab.*c";
    　　贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。如上面使用模式p匹配字符串str，结果就是匹配到：abcaxc(ab.*c)。
    　　非贪婪匹配：就是匹配到结果就好，就少的匹配字符。如上面使用模式p匹配字符串str，结果就是匹配到：abc(ab.*c)。

常见正则：手机、邮箱、IP

手机号：^1(3|4|5|6|7|8)[0-9]\d{8}$
邮箱：\w[-\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+.)+[A-Za-z]{2,14}
IP:(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d).(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d).(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d).(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)

面向对象

基础

- 基础：三大特性，封装、继承、多态
        - 封装，对象、类。  应用场景：分页组件；stark组件
        - 继承，多继承继承顺序mro；经典类和新式类；super;  应用场景：drf视图

　　　　　- 多态

继承：

class Base1(object):
    def func(self):
        print('base1.func')
        super(Base1, self).func()


class Base2(object):
    def func(self):
        print('base2.func')


class Foo(Base1, Base2):
    pass


obj = Foo()  # Foo > Base1 > Base2
obj.func()
# base1.func
# base2.func
# super是多继承顺序，所以会往base2找

# obj = Base1()  # Base1
# obj.func()
# 会报错，因为object是父类，没有这个方法

成员

 - 字段
        
            class Foo:
                COUNTRY = "中国" # 类变量；静态字段；静态属性
                def __init__(self,name):
                    self.name = name  # 实例变量；字段；对象属性
            
            obj = Foo('天珠')
        
        - 方法
            class Foo:
                def f1(self):  # 实例方法   Foo().f1()
                    pass
                    
                @classmethod
                def f2(cls):   # 类方法    Foo.f2()     Foo().f2()
                    pass

                @staticmethod  # 静态方法  Foo.f2()     Foo().f2()
                def f3():
                    pass
        - 属性
            class Foo:
            
                @property
                def start():
                    pass 
            
            obj = Foo()
            obj.start

特殊成员

 __init__ # 初始化方法
        __new__  # 构造方法
        __call__ # 对象后边加括号，触发执行
        __getattr__  # 在使用调用属性（方式，属性）不存在的时候触发
        __setattr__  # 添加/修改属性会触发它的执行
        __delattr__  # 删除属性的时候会触发
        __getitem__  
        ...
        __dict__
        __add__
        __str__
        __repr__
        __iter__
        __doc__
        __name__  # 输出函数名
        __enter__ # with中用
        __exit__
            class Foo(object): # 上下文管理
                def __enter__(self):
                    print('进入')
                    return '1'
            
                def __exit__(self, exc_type, exc_val, exc_tb):
                    print('出去')
            
            obj = Foo()
            
            
            with obj as num:
                print(123,num)
        __add__
            class Foo(object):
                def __init__(self,num):
                    self.num = num
            
                def __add__(self, other):
                    return self.num + other.num
            
            obj1 = Foo(11)
            obj2 = Foo(22)
            
            result = obj1 + obj2
            
            print(result)

反射

什么是反射：
    getattr/delattr.....
应用场景？
    django CBV，
        django、flask、scrapy等所有的配置文件： v = "django.contrib.sessions.middleware.SessionMiddleware"
        
            def import_string(dotted_path):
                try:
                    # 'django.contrib.sessions.middleware.    SessionMiddleware'
                    module_path, class_name = dotted_path.rsplit('.', 1)
                except ValueError:
                    msg = "%s doesn't look like a module path" % dotted_path
                    six.reraise(ImportError, ImportError(msg), sys.exc_info()[2])
                # from django.contrib.sessions import middleware
                module = import_module(module_path)
            
                try:
                    # middleware.SessionMiddleware
                    return getattr(module, class_name)
                except AttributeError:
                    msg = 'Module "%s" does not define a "%s" attribute/class' % (
                        module_path, class_name)
                    six.reraise(ImportError, ImportError(msg), sys.exc_info()[2])

py2和py3的区别？

1、字符串和字节
py2： unicode  -> encode utf-8 ->      str(字节串)  = bytes
py3： str      -> encode utf-8 ->      bytes 
意思是：py2中的unicode相当于py3中的str
       py2中的str相当于py3中的bytes
2、经典类和新式类
py2：经典类、新式类  
py3：新式类（默认继承object类）
3、yield       （配合for循环使用）
　 yield from  (用于一个函数跳到另一个函数，基本在py3.3以上版本都有)
4、默认解释器编码：py2：asicc码
　　　　　　　　　 py3：utf-8
5、range和xrange：py2中的xrange相当于py3中的range
6、readlines和xreadlines：py2中xreadlines相当于py3中的readlines
7、print py2中print（）或者print '内容'，但是py3是print("内容")
8、input、raw_input py2中的input相当于py3中的eval()函数，py2中的raw_input相当于py3中的input()

给你一个路径“D:\EVCapture” 找到目录下的所有文件（子目录中的文件）。

import os
path1=r'D:\EVCapture'
for root, dirs, files in os.walk(path1):
    print(root)
    print(dirs)
    for  file in files:
        if file.endswith('.pdf'):
            print(os.path.join(root,file))

一行代码实现两个值的互换 & 一行实现 9*9 乘法表

a,b=b,a

print('\n'.join(['\t'.join(["%s*%s=%s"%(j,i,i*j) for j in range(1,i+1)]) for i in range(1,10)]))

利用面向对象创建一个栈。

    # Stack()：创建一个新的空栈
    class Stack():
        def __init__(self):
            self.items = []

        # 判断栈是否为空
        def is_empty(self):
            return self.items == []

        # 添加一个新的元素，item到栈顶
        def push(self, item):
            self.items.append(item)

        # 弹出栈顶元素
        def pop(self):
            return self.items.pop()

        # 返回栈顶元素
        def peek(self):
            return self.items[len(self.items) - 1]

        # 返回栈的元素个数
        def size(self):
            return len(self.items)