今日面试题:

今日考题:
1.列举字符串,列表，元组，字典每个常用的五个方法

1.按索引取值（只可取不可改变）

# str索引取值
msg = 'hello nick'
#      0123456789  # 索引序号

print(f'索引为6: {msg[6]}')
print(f'索引为-3: {msg[-3]}')
索引为6: n
索引为-3: i
2.切片（顾头不顾尾，步长）

# 索引切片
msg = 'hello nick'
#      0123456789  # 索引序号

print(f'切片3-最后: {msg[3:]}')
print(f'切片3-8: {msg[3:8]}')
print(f'切片3-8，步长为2: {msg[3:8:2]}')
print(f'切片3-最后，步长为2: {msg[3::2]}')

# 了解，步长为正从左到右；步长为负从右到左
print('
**了解知识点**')
print(f'切片所有: {msg[:]}')
print(f'反转所有: {msg[::-1]}')
print(f'切片-5--2: {msg[-5:-2:1]}')
print(f'切片-2--5: {msg[-2:-5:-1]}')
切片3-最后: lo nick
切片3-8: lo ni
切片3-8，步长为2: l i
切片3-最后，步长为2: l ik

**了解知识点**
切片所有: hello nick
反转所有: kcin olleh
切片-5--2:  ni
切片-2--5: cin
3.长度len

# str长度
msg = 'hello nick'

print(len(msg))
10
4.成员运算in和not in

# str成员运算
msg = 'my name is nick, nick handsome'

print(f"'nick' in msg: {'nick' in msg}")
print(f"'jason' not in msg: {'jason' not in msg}")
print(f"not 'jason' in msg: {not 'jason' in msg}")
'nick' in msg: True
'jason' not in msg: True
not 'jason' in msg: True
5.移除空白strip()

# str移除空白strip()
name = '&&&n ick'

print(f"name.strip('&'): {name.strip('&')}")  # strip()默认为‘ ’，并且不修改原值，新创建空间
print(f"name: {name}")

# strip()应用场景
pwd = input('password: ')  # 用户可能会手抖输入空格
if pwd.strip() == '123':
    print('密码输入成功')

print(f"'*-& nick+'.strip('*-& +'): {'*-& nick+'.strip('*-& +')}")
name.strip('&'): n ick
name: &&&n ick
password: 123   
密码输入成功
'*-& nick+'.strip('*-& +'): nick
6.切分split

# str切分split
info = 'nick:male:19'
info_list1 = info.split(':')
info_list2 = info.split(':', 1)

print(f'info_list1:{info_list1}')
print(f'info_list2:{info_list2}')
info_list1:['nick', 'male', '19']
info_list2:['nick', 'male:19']
7.循环

msg = 'hello nick'

for i in msg:
    print(i)
h
e
l
l
o
 
n
i
c
k

1.按索引取值（正向取值+反向取值），即可存也可以取

# list之索引取值
name_list = ['nick', 'jason', 'tank', 'sean']
name_list[0] = 'nick handsom'
# name_list[1000] = 'tank sb'  # 报错

print(f"name_list[0]: {name_list[0]}")
name_list[0]: nick handsom
2.切片

# list之切片
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list[0:3:2]: {name_list[0:3:2]}")
name_list[0:3:2]: ['nick', 'tank']
3.长度

# list之长度
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"len(name_list): {len(name_list)}")
len(name_list): 4
4.成员运算in和not in

# list之成员运算in和not in
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"'tank sb' in name_list: {'tank sb' in name_list}")
print(f"'nick handsome' not in name_list: {'nick handsome' not in name_list}")
'tank sb' in name_list: False
'nick handsome' not in name_list: True
5.追加值

# list之追加值
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.append('tank sb')

print(f"name_list: {name_list}")
name_list: ['nick', 'jason', 'tank', 'sean', 'tank sb']
6.删除

# list之删除
name_list = ['nick', 'jason', 'tank', 'sean']
del name_list[2]

print(f"name_list: {name_list}")
name_list: ['nick', 'jason', 'sean']
7.循环

# list之循环
name_list = ['nick', 'jason', 'tank', 'sean']

for name in name_list:
    print(name)
nick
jason
tank
sean

1.索引取值

# tuple之索引取值
name_tuple = ('nick', 'jason', 'tank', 'sean')
# name_tuple[0] = 'nick handsom'  # 报错

print(f"name_tuple[0]: {name_tuple[0]}")
name_tuple[0]: nick
2.切片（顾头不顾尾，步长）

# tuple之切片
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")
name_tuple[1:3:2]: ('jason',)
3.长度

# tuple之长度
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"len(name_tuple): {len(name_tuple)}")
len(name_tuple): 4
4.成员运算

# tuple之成员运算
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"'nick' in name_tuple: {'nick' in name_tuple}")
'nick' in name_tuple: True
5.循环

# tuple之循环
name_tuple = ('nick', 'jason', 'tank', 'sean')

for name in name_tuple:
    print(name)
nick
jason
tank
sean
6.count()

# tuple之count()
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.count('nick'): {name_tuple.count('nick')}")
name_tuple.count('nick'): 1
7.index()

# tuple之index()
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.index('nick'): {name_tuple.index('nick')}")
name_tuple.index('nick'): 0

1.按key存取值：可存可取

# dic之按key存取值
dic = {'a': 1, 'b': 2}

print(f"first dic['a']: {dic['a']}")

dic['a'] = 3

print(f"second dic['a']: {dic['a']}")
first dic['a']: 1
second dic['a']: 3
2.长度len

# dic之长度len
dic = {'a': 1, 'b': 2}

print(f"len(dic): {len(dic)}")
len(dic): 2
3.成员运算in和not in

# dic之成员运算in和not in
dic = {'a': 1, 'b': 2}

print(f"'a' in dic: {'a' in dic}")
print(f"1 in dic: {1 in dic}")
'a' in dic: True
1 in dic: False
4.删除

# dic之删除del
dic = {'a': 1, 'b': 2}
del dic['a']

print(f"dic.get('a'): {dic.get('a')}")
dic.get('a'): None
# dic之删除pop()
dic = {'a': 1, 'b': 2}
dic.pop('a')  # 指定元素删除

print(f"dic.pop('b'): {dic.pop('b')}")
print(f"dic.get('a'): {dic.get('a')}")
dic.pop('b'): 2
dic.get('a'): None
# dic之删除popitem()
dic = {'a': 1, 'b': 2}

print(f"dic.popitem(): {dic.popitem()}")  # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
dic.popitem(): ('b', 2)
5.键keys()、值values()、键值对items()

# dic之键keys()、值values()、键值对items()，python2中取出的是列表（鸡蛋）；python3中取出的是元组（鸡）
dic = {'a': 1, 'b': 2}

print(f"dic.keys(): {dic.keys()}")
print(f"dic.values(): {dic.values()}")
print(f"dic.items(): {dic.items()}")
dic.keys(): dict_keys(['a', 'b'])
dic.values(): dict_values([1, 2])
dic.items(): dict_items([('a', 1), ('b', 2)])
6.循环

# dic之循环
# dic是无序的，但是python3采用了底层优化算法，所以看起来是有序的，但是python2中的字典是无序
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

for k, v in dic.items():  # items可以换成keys()、values()
    print(k, v)
a 1
b 2
c 3
d 4

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

# map  --> 映射
def function1(item):
    return item + 2
res = map(function1, [1, 2, 3, ])
print(res)
print(list(res))



#zip --> 将两个个序列中的元素进行一对一的组合成元组
res = zip(["1", "2", "3"], [5, 6,7, 8])
print(res)
'''
{'1': 5, '2': 6, '3': 7}
多余的将会被丢弃
'''
#将字典中的kv颠倒
res = zip(dict0.values(), dict0.keys())
dict1 = dict(res)
print(dict1)
 

    
# fileter ---> 筛选
def function(item):  # 1/2/3/4
    if item < 5:
        return True
    else:
        return False
res = filter(lambda item: item > 2, [1, 2, 3, 4])
print(res)  
print(list(res))

# sorted --> 排序
def function2(item):
    return salary_dict[item]
salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000,
    'z': 1000
}
res = sorted(salary_dict, key=function2, reverse=True)
print(list(res))





#reduce --> 把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
'''
把序列[5, 4, 3, 2, 1]变成整数54321
'''
import functools
res = functools.reduce(lambda x,y:x * 10 +y,[5, 4, 3, 2, 1])
print(res) #54321

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

    __init__: 在调用类时触发。
    __str__: 会在打印对象时触发。
    __del__: 对象被销毁前执行该方法,该方法会在最后执行。
    __getattr__: 会在对象.属性时，“属性没有”的情况下才会触发。
    __setattr__: 会在 “对象.属性 = 属性值” 时触发。
    __call__: 会在对象被调用时触发。
    __new__: 会在__init__执行前触发。

4.写出form表单中所有的知识点

action  控制数据的提交路径			
method  控住数据提交的方式  默认是get请求			
enctype  控制前端朝后端提交数据的编码格式		
注册页面
下拉框 select标签
textarea 大段文本
			

5.列举你所知道的所有css选择器

基本选择器
			
			id选择器		#id值
			
			类选择器        .class值
			
			通用选择器      *
		
后代选择器
属性选择器
伪类选择器
伪元素选择器

6.简述解释性语言和编译性的区别

编译型
优点（解释型）：执行效率高
缺点（解释型）：开发效率低
解释型
优点（编译型）：开发效率高
缺点（编译型）：执行效率低

7.列举你所知道的python2与python3之间的区别

print
1/2的结果
编码
在使用super()的不同

8.什么是匿名函数。匿名函数一般结合什么一起使用

没有名字的函数
一般和 max/min/filter/map/sorted联用

9.三次握手四次挥手

10.什么是GIL全局解释器锁

1.GIL本质上是一个互斥锁.
2.GIL的为了阻止同一个进程内多个线程同时执行(并行)
3.这把锁主要是因为CPython的内存管理不是 "线程安全" 的.
GIL的存在就是为了保证线程安全的.

11.什么是python的垃圾回收机制

当一个变量值的引用计数为0的时候，会触发垃圾回收机制，改变量值会被回收

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

 # 单例模式1
    __instance = None   
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance
# 单例模式2
    __instance = None 
    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance = cls()
        return cls.__instance

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

# time模块：提供了三种不同类型的时间（时间戳）,三种不同类型的时间可以相互转换
# datetime模块：时间的加减
# random模块：随机数
# hashlib模块：对字符加密
# hmac模块：对字符加密，并且加上密钥
# typing模块：与函数联用，控制函数参数的数据类型,提供了基础数据类型之外的数据类型
# requests模块：爬虫--》爬数据，模拟浏览器对url发送请求，拿到数据
# re模块： 去字符串找 符合某种特点的字符串
# numpy模块：用来做数据分析，对numpy数组（既有行又有列）--矩阵进行科学运算

14.什么是浮动，浮动的效果是什么，有没有坏处，如何解决

在 CSS 中，任何元素都可以浮动。
浮动的元素 是脱离正常文档流的(原来的位置会让出来),浏览器会优先展示文本内容
浮动带来的影响,会造成父标签塌陷(口袋瘪了)	
如何解决父标签塌陷问题？？？
clear  清除浮动带来的影响,哪个父标签塌陷了 就给谁加clearfix这个类属性值

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

相对定位   relative
			相对于标签原来的位置 移动
绝对定位  absolute
			相对于已经定位过(只要不是static都可以 relative)的父标签 再做定位(******)
固定定位  fixed
			相对于浏览器窗口  固定在某个位置不动
1.不脱离文档流:相对定位;
2.脱离文档流:浮动的元素,绝对定位,固定定位

16.二进制转换成十进制：v = “0b1111011”
十进制转换成二进制：v = 18
八进制转换成十进制：v = “011”
十进制转换成八进制：v = 30
十六进制转换成十进制：v = “0x12”
十进制转换成十六进制：v = 87

print(int(v,2)
print(bin(v))
print(int(v,8))
print(oct(v))
print(int(v,16))
print(hex(v))

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

含有.__iter__方法的数据类型就叫做可迭代对象,除了数字类型，所有数据类型都是可迭代对象
含有__iter__和__next__方法的对象就是迭代器对象
含有yield关键字的函数叫做生成器
为什么要有迭代器对象：提供了不依赖索引取值的手段
可迭代对象不一定是迭代器对象; 迭代器对象一定是可迭代对象
yield的特性:
1. 暂停函数
2. 通过next取值

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

元类就是类的类，类的类是type，type是所有类的类，type就是一个元类。
元类可以帮我们控制类的创建。

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

主要MyISAM与InnoDB两个引擎，其主要区别如下：
一、InnoDB支持事务，MyISAM不支持，这一点是非常之重要。事务是一种高级的处理方式，如在一些列增删改中只要哪个出错还可以回滚还原，而MyISAM就不可以了;
二、MyISAM适合查询以及插入为主的应用，InnoDB适合频繁修改以及涉及到安全性较高的应用;
三、InnoDB支持外键，MyISAM不支持;
四、MyISAM是默认引擎，InnoDB需要指定;
五、InnoDB不支持FULLTEXT类型的索引;
六、InnoDB中不保存表的行数，如selectcount(*)fromtable时，InnoDB;需要扫描一遍整个表来计算有多少行，但是MyISAM只要简单的读出保存好的行数即可。注意的是，当count(*)语句包含where条件时MyISAM也需要扫描整个表;
七、对于自增长的字段，InnoDB中必须包含只有该字段的索引，但是在MyISAM表中可以和其他字段一起建立联合索引;
八、清空整个表时，InnoDB是一行一行的删除，效率非常慢。MyISAM则会重建表;
九、InnoDB支持行锁(某些情况下还是锁整表，如updatetableseta=1whereuserlike‘%lee%’

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

js是前端的一门编程语言
js中的数据类型
数值类型 Number,字符类型 string,对象  object,布尔值  Boolean