简述使用python函数有哪些优势_python复习

2020-05-11

一、简述解释性语言和编译性的区别

计算机不能直接理解高级语言，只能直接理解机器语言，所以必须要把高级语言翻译成机器语言，计算机才能执行高级语言编写的程序。

翻译的方式有两种，一个是编译，一个是解释。两种方式只是翻译的时间不同。

解释性语言的定义：

解释性语言的程序不需要编译，在运行程序的时候才翻译，每个语句都是执行的时候才翻译。这样解释性语言每执行一次就需要逐行翻译一次，执行效率比较低。(一边翻译一边执行)

现代解释性语言通常把源程序编译成中间代码，然后用解释器把中间代码一条条翻译成目标机器代码，一条条执行。

(1)源代码不能直接翻译成机器语言，而是先翻译成中间代码，再由解释器对中间代码进行解释运行；(源代码—>中间代码—>机器语言)

(2)程序不需要编译，程序在运行时才翻译成机器语言，每执行一次都要翻译一次；

(3)解释性语言代表：Python、JavaScript、Shell、Ruby、MATLAB等；

(4)运行效率一般相对比较低，依赖解释器，跨平台性好；

编译性语言的定义：

编译性语言写的程序在被执行之前，需要一个专门的编译过程，把程序编译成为机器语言的文件，比如exe文件，以后要运行的话就不用重新翻译了，直接使用编译的结果就行了(exe文件)，因为翻译只做了一次，运行时不需要翻译，所以编译型语言的程序执行效率高。

(1)只须编译一次就可以把源代码编译成机器语言，后面的执行无须重新编译，直接使用之前的编译结果就可以；因此其执行的效率比较高；

(2)编译性语言代表：C、C++、Pascal/Object Pascal(Delphi)；

(3)程序执行效率比较高，但比较依赖编译器，因此跨平台性差一些；

二、列举你所知道的python2与python3之间的区别

python2的默认编码是ASCII,python3的默认编码是Unicode

python2中range返回的是列表，xrange返回的是可迭代对象，而Python3中range返回的是可迭代对象

python2中整数分为int 和 long，python3中统一归为int

python2不等于可以用！= 或者<>表示，在python3中只能用！=

python2 使用print语句，python3中使用print()函数

python2 用户输入用row_input() ,python3用input()

python2 super(类名)，python3 super()

三、什么是匿名函数。匿名函数一般结合什么一起使用，请列举几个常用的

匿名函数指一类无须定义标识符的函数。Python用lambda语法定义匿名函数，只需用表达式而无需申明。匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。 但通常都是在定义lambda函数的同时将其应用作为参数传递给另一个函数，该函数在其处理过程中对lambda定义的函数进行调用。结合max、min、sorted、map、reduce、filter使用

四、什么是TCP三次握手四次挥手

五、什么是GIL全局解释器锁

在CPython解释器中GIL是一把互斥锁，用来阻止同一个进程下的多个线程的同时执行

同一个进程下的多个线程无法利用多核优势！！！

因为cpython中的内存管理不是线程安全的

内存管理(垃圾回收机制)

1.应用计数

2.标记清楚

3.分代回收

重点:

1.GIL不是python的特点而是CPython解释器的特点

2.GIL是保证解释器级别的数据的安全

3.GIL会导致同一个进程下的多个线程的无法同时执行即无法利用多核优势(******)

4.针对不同的数据还是需要加不同的锁处理

5.解释型语言的通病:同一个进程下多个线程无法利用多核优势

2020-05-12

一、ascii,gbk,utf-8的区别

ascii：只支持英文字符；用8个二进制位对应一个英文字符

gbk：支持英文，中文字符；用8个二进制位对应一个英文字符，16个对应一个中文字符

utf-8：支持所有字符；用8个二进制位对应一个英文字符，24个对应一个中文字符

注：

utf-8只和Unicode做映射，其他编码必须先转成unicode,才可以转成utf-8

目前，计算机内存中均是Unicode，硬盘中均是utf-8

字节byte，一个字节由8个bit组成

编码的过程，由字符转为字节流 encode

解码的过程，由字节流转为字符 decode

用什么格式编码，就要用什么格式解码

unicode(内存) ---> 编码encode---> utf-8(硬盘)

utf-8(硬盘)---> 解码decode---> unicode (内存)

二、请用至少两种方式实现m与n值交换m=10,n=5

# 方式一：

m,n=n,m

# 方式二

t = m

m = n

n = t

三 、什么是深浅拷贝

对于不可变类型而言，深拷贝和浅拷贝最终的效果是一样的。

对于可变类型：

浅拷贝：是对一个对象的顶层拷贝，只拷贝了引用，没有拷贝内容，可变类型的变化会同时影响新旧两个对象。

list1.copy()

深拷贝：重新拷贝了一份内容，重建了引用。彼此相互独立。

import copy

copy.deepcopy(list1)

四、 什么是HTTP协议

超文本传输协议HyperText Transfer Protocol

四大特性：基于请求响应；

基于TCP/IP协议，作用于应用层之上；

无状态，HTTP是一种无状态协议，即服务器不保留与客户交易时的任何状态；

无/短链接；客户与服务器之间的HTTP连接是一种一次性连接，它限制每次连接只处理一个请求，当服务器返回本次请求的应答后便立即关闭连接，下次请求再重新建立连接。

五、列举你所知道的HTML标签

  空格

> >

< <

¥ ¥

© ©

® ®

&&

div 块儿级标签

span 行内标签

我是h1

标题标签 1～6级标题

加粗

斜体

下划线

删除线

段落

换行

---

水平分割线

2020-05-13

一、列举字符串,列表，元组，字典每个常用的五个方法基本数据类型及内置方法_Python_wg14747421417的博客-CSDN博客​blog.csdn.net

二、描述下列常见内置函数的作用可用代码说明map,zip,filter,sorted,reduce

# 拉链函数zip #拼接成小元组

v1 = 'helloy'

v2 = [111, 222, 333, 444, 5555, 6666]

res = zip(v1, v2)

print(dict(res)) # {'h': 111, 'e': 222, 'l': 444, 'o': 5555, 'y': 6666}

print(list(res)) # [('h', 111), ('e', 222), ('l', 333), ('l', 444), ('o', 5555), ('y', 6666)]面向过程与函数式_wg14747421417的博客-CSDN博客​blog.csdn.net

三、列举你所知道的面相对象中的__开头__结尾的方法及作用，越多越好

四、写出form标签几个关键性的属性及作用前端篇begin---HTML_前端_wg14747421417的博客-CSDN博客​blog.csdn.net

五、列举你所知道的css选择器前端篇之css_前端_wg14747421417的博客-CSDN博客​blog.csdn.net

2020-05-14

1、什么是python的垃圾回收机制

1、引用计数机制

在 Python 中用到的一切变量，本质上都是类对象。当这个对象的引用计数值为 0 时，

说明这个对象永不再用，自然它就变成了垃圾，需要被回收。

2、标记清除

当引用计数出现循环引用的时候，事实上，Python 使用标记清除(mark-sweep)算法

和分代收集(generation al)，来启用针对循环引用的自动垃圾回收。

3、分代回收

分为三代，新创建的对象放在新生代，若干轮清除之后如果没被回收，可以移到中年代，

最后移到老年代，老年代不易被回收。

2.你所知道的能够实现单例模式的方式有哪些，尝试着手写几个

'''

单例模式:

单例模式是一个软件的设计模式，为了保证一个类，无论调用多少次产生的实例对象，

都是指向同一个内存地址，仅仅只有一个实例(对象)!

五种单例:

- 模块

- 装饰器

- 元类

- __new__

- 类方法: classmethod

'''

class People:

def __init__(self, name, age, sex):

self.name = name

self.age = age

self.sex = sex

# 调用三次相同的类，传递相同的参数，产生不同的三个实例

p1 = People('tank', 17, 'male')

p2 = People('tank', 17, 'male')

p3 = People('tank', 17, 'male')

# print(p1 is p2 is p3)

# 打开同一个文件的时候，链接MySQL数据库

''' 伪代码

mysql_obj1 = MySQL(ip, port)

mysql_obj2 = MySQL(ip, port)

mysql_obj3 = MySQL(ip, port)

'''

'''

方式一: @classmethod ---> 通过类方法来实现单例

'''

class Foo(object):

# 定义了一个类的数据属性,

# 用于接收对象的实例，判断对象的实例是否只有一个

_instance = None # obj1

def __init__(self, name, age):

self.name = name

self.age = age

@classmethod

def singleton(cls, *args, **kwargs):

# 判断类属性_instance是否有值，有代表已经有实例对象

# 没有则代表没有实例对象，则调用object的__init__获取实例对象

if not cls._instance:

# object.__new__(cls): 创造对象

# 没有参数情况下

# cls._instance = object.__new__(cls, *args, **kwargs)

# 有参数的情况下

cls._instance = cls(*args, **kwargs) # Foo()

# 将已经产生的实例对象 直接返回

return cls._instance

obj1 = Foo.singleton('tank', '123')

obj2 = Foo.singleton('tank', '123')

# print(obj1 is obj2)

'''

方式二: 元类

'''

class MyMeta(type):

# 1、先触发元类里面的__init__

def __init__(self, name, base, attrs): # self --> Goo

# *** 造空的对象, 然后赋值给了Goo类中的_instance类属性

self._instance = object.__new__(self)

# 将类名、基类、类的名称空间，传给type里面的__init__

super().__init__(name, base, attrs)

# type.__init__(self, name, base, attrs)

# 2、当调用Goo类时，等同于调用了由元类实例化的到的对象

def __call__(self, *args, **kwargs):

# 判断调用Goo时是否传参

if args or kwargs:

init_args = args

init_kwargs = kwargs

# 1)通过判断限制了用于传入的参数必须一致，然后返回同一个对象实例

if init_args == args and init_kwargs == kwargs:

return self._instance

# 2) 若不是同一个实例，则新建一个对象，产生新的内存地址

obj = object.__new__(self)

self.__init__(obj, *args, **kwargs)

return obj

return self._instance

class Goo(metaclass=MyMeta): # Goo = MyMeta(Goo)

# _instance = obj

def __init__(self, x):

self.x = x

g1 = Goo('1')

g2 = Goo('1')

# print(g1 is g2) # True

'''

方式三: __new__实现 ---> 通过调用类方法实例化对象时，自动触发的__new__来实现单例

'''

class Aoo(object):

_instance = None

def __new__(cls, *args, **kwargs):

if not cls._instance:

cls._instance = object.__new__(cls)

return cls._instance

a1 = Aoo()

a2 = Aoo()

# print(a1 is a2) # True

'''

方式四: 装饰器实现 ---> 通过调用类方法实例化对象时，自动触发的__new__来实现单例

'''

# 单例装饰器

def singleton_wrapper(cls): # cls ---> Too

# 因为装饰器可以给多个类使用，所以这里采用字典

# 以类作为key, 实例对象作为value值

_instance = {

# 伪代码: 'Too': Too的示例对象

}

def inner(*args, **kwargs):

# 若当前装饰的类不在字典中，则实例化新类

# 判断当前装饰的Too类是否在字典中

if cls not in _instance:

# obj = cls(*args, **kwargs)

# return obj

# 不在，则给字典添加 key为Too， value为Too()---> 实例对象

# {Too: Too(*args, **kwargs)}

_instance[cls] = cls(*args, **kwargs)

# return 对应的实例对象cls(*args, **kwargs)

return _instance[cls]

return inner

@singleton_wrapper # singleton_wrapper(Too)

class Too(object):

pass

t1 = Too()

t2 = Too()

# print(t1 is t2) # True

'''

方式五: 模块导入实现

'''

import cls_singleton

s1 = cls_singleton.instance

s2 = cls_singleton.instance

print(s1 is s2) # True

3.列举python中常用模块及主要功能，越多越好！

time datatime 时间模块

random 随机数模块

os 系统相关的

sys 解释器与系统交互

shutil 高级的文件、文件夹、压缩包处理模块

json pickle 序列化模块

configparser 配置文件

hashlib 加密模块

suprocess 应用程序与操作系统交互

logging 日志模块

re 正则

scoket

from multiprocess import Queue,Process

from threading import Thread

import struct

4.简述盒子模型

1 外边距(标签与标签之间的距离) margin

2 边框 border

3 内边距/内填充 padding

4 内容 content

就以快递盒为例

快递盒与快递盒之间的距离(标签与标签之间的距离 margin外边距)

盒子的厚度(标签的边框 border)

盒子里面的物体到盒子的距离(内容到边框的距离 padding内边距)

物体的大小(内容 content)

5.什么是浮动，浮动的作用

浮动float

能够让标签脱离正常的文档流漂浮到空中(距离用户更近)

浮动的元素 没有块儿级一说 本身多大浮起来之后就只能占多大

2020-05-15

一、进制转化

二进制转换成十进制：v = “0b1111011”

十进制转换成二进制：v = 18

八进制转换成十进制：v = “011”

十进制转换成八进制：v = 30

十六进制转换成十进制：v = “0x12”

十进制转换成十六进制：v = 87

二进制转换成十进制：v = “0b1111011”

2**0*1 + 2**1*1 + 2**2*0... # 123

十进制转换成二进制：v = 18

# 10010

八进制转换成十进制：v = “011”

8**0*1 + 8**1*1 =9 # 9

十进制转换成八进制：v = 30

# 36

十六进制转换成十进制：v = “0x12”

# 18

十进制转换成十六进制：v = 87

# 57

2.简述可迭代对象，迭代器对象，生成器对象及应用场景

可迭代对象("可以转换成迭代器的对象")：内置有__iter__方法对象

可迭代对象.__iter__(): 得到迭代器对象

迭代器对象：内置有__next__方法并且内置有__iter__方法的对象

迭代器对象.__next__()：得到迭代器的下一个值

迭代器对象.__iter__()：得到迭代器的本身，说白了调了跟没调一个样子

若函数体包含yield关键字，再调用函数，并不会执行函数体代码，会返回一个生成器对象，返回值即生成器对象

生成器即——自定义迭代器

可迭代对象：字符串、列表、元组、字典、集合、文件对象

迭代器对象：文件对象

3.什么是元类?元类的应用场景有哪些，能具体说说吗？

元类就是实例化产生类的类

控制类的产生

__new__ 控制定义类时创建过程

__init__

控制类的调用

__call__ 控制调用类创建对象初始化的过程

有了元类我们就可以自定义自己的类

4.你用的MySQL是哪个引擎，各个引擎之间有什么区别

Innodb

是MySQL5.5版本及之后默认的存储引擎

存储数据更加的安全

myisam

是MySQL5.5版本之前默认的存储引擎

速度要比Innodb更快 但是我们更加注重的是数据的安全

memory

内存引擎(数据全部存放在内存中) 断电数据丢失

blackhole

无论存什么，都立刻消失(黑洞)

5.你所知道的定位有哪些，每个定位各有什么特点，列举哪些是不脱离文档流的哪些是脱离文档流的

静态

所有的标签默认都是静态的static，无法改变位置

相对定位(了解)

相对于标签原来的位置做移动relative

标签由static变为relative它的性质就从原来没有定位的标签变成了已经定位过的标签

虽然你哪怕没有动 但是你的性质也已经改变了

绝对定位(常用)

相对于已经定位过的父标签做移动(如果没有父标签那么就以body为参照)absolute

eg:小米网站购物车

当你不知道页面其他标签的位置和参数，只给了你一个父标签的参数，让你基于该标签左定位

固定定位(常用)

相对于浏览器窗口固定在某个位置fixed

eg:右侧小广告

不脱离文档流

1.相对定位

脱离文档流

1.浮动

2.绝对定位

3.固定定位

2020-05-18

1.什么是Js，Js的数据类型有哪些,Js序列化反序列化用的是什么方法

js也是一门编程语言

2.现有三个普通函数a,b,c都需要用户登陆之后才能访问。现需要你写一个装饰器校验用户是否登陆，并且用户只要登陆一次其他函数在调用时也无需再校验(提示:全局标志位)

3.什么是进程，线程，协程，程序中如何依次创建/实现它们

2020-05-19

1.列举你所知道的PEP8 Python编码规范

2.求结果(易错题)

v1 = 1 or 3 # 1

v2 = 1 and 3 # 3

v3 = 0 and 2 and 1 # 0

v4 = 0 and 2 or 1 # 1

v5 = 0 and 2 or 1 or 4 # 1

v6 = 0 or Flase and 1 # Flase

3.简述字符编码发展史，以及你所知道的字符编码，每个字符编码表的在表示字符内部位数区别

4.js代码书写位置有几种，什么是事件，js如何绑定事件

2020-05-20

1.有一个列表[3,4,1,2,5,6,6,5,4,3,3]请写出一个函数，找出该列表中没有重复的数的总和

l=[3,4,1,2,5,6,6,5,4,3,3]

new_l=[]

for i in l:

if not l.count(i)>1:

new_l.append(i)

2.简述数据库表设计中一对一、一对多、多对多的应用场景,char与varchar的区别

3.js代码书写位置有几种，什么是事件，js如何绑定事件，常见的事件有哪些

4.什么是jQuery，它的基本语法是什么，jQuery导入方式有哪些分别有什么区别，

列举你所知道的jQuery选择器(针对表单筛选器是否有注意事项)

2020-05-21

1.下面这段代码的输出结果是什么，并给出你的解释

def index():

return [lambda x : i * x for i in range(4)]

print([m(2) for m in index()])

2.什么是函数的递归调用?书写递归函数需要注意什么？你能否利用递归函数打印出下面列表中每一个元素(只能打印数字),l = [1,[2,[3,[4,[5,[6,[7,[8,[9]]]]]]]]]

3.jQuery的链式操作有什么特点，如何做到？

4.jQuery绑定事件的方式有哪些，列举出你所知道的事件

2020-05-22

1.你所知道的前端框架和实用插件有哪些，他们各有什么特点

2.使用bootstrap需要注意什么，常用的bootstrap样式有哪些