面试题（基础知识）

目录

• 解释型和编译型
• 数据类型
  • python中一切皆对象
  • 深浅copy
  • 可变类型与不可变类型
  • 字符编码
• 闭包函数
• python中的魔法方法
  • setattr，getattr，setitem，getitem演示
  • with 上下文管理器
  • __eq__
• cookie，session，token
• django中的session底层原理
• 异常处理
• pymysql的使用

解释型和编译型

主流开发环境:windows ,sanic ,fastapi 
    针对linux,可以远程连接linux内的docker开发

c：c代码写完，编译（不同平台），跨平台运行，linux上源码安装软件，自行编译，运行
java:一处编码，处处运行，java是编译型还是解释型？编译型，编译过程---把java源代码编译成字节码文件 .class
    ---不能直接运行在操作系统之上----》jvm（java虚拟机），jvm运行至少要300m内存
    jdk
    jre
    jvm
    javase javame javaee
go:编译型，跨平台编译（windows平台可以编译出mac平台的可执行文件），所有go代码打成一个可执行文件
    
python: 强类型动态语言
js：只能在浏览器中运行，nodejs
php：web开发

数据类型

python中一切皆对象

# type和object的关系
1 type 是object的类 print(type(object))#<class 'type'>
2 type继承了object  #class type(object):
3 type是type自己的类  type(type)#<class 'type'>
4 object也是由type实例化得到 print(type(object))#<class 'type'>


def a():
    pass

print(type(a)) #<class 'function'>
print(type(type(a))) #type
print(type(int))  #type
print(type(object))  #type
print(type(type))  #type

# 所有类，除了object都继承自object，包括type

深浅copy

 #一切皆对象的好处
不同类型之间的变量直接可以相关赋值
a=100
a='xxx'
其实本质，变量都是指向了一个内存地址
出现了深浅copy问题
# 深浅copy问题

# l=[1,2,3,[4,5,6]]
# l2=l  #赋值
#
# print(l2 is l)
# from copy import copy
# from copy import deepcopy
# # l3=copy(l)
# # print(l)
# # print(l3)
# # print(l is l3)
# # l3[3][1]=999
# # print(l)
# # print(l3)
#
# l4=deepcopy(l)
# l4[3][1]=999
# print(l)
# print(l4)

可变类型与不可变类型

#字典，列表，集合   可变类型
#数字，字符串，元组  不可变类型
# 字典的key必须用不可变类型，可以hash    
# 看一下这篇博客
https://www.cnblogs.com/xiaoyuanqujing/articles/12008689.html
# python中的参数传递是值传递还是引用传递？
python中参数传递都是copy一份传递过去，由于一切皆对象，传过去，都是地址，python中区分可变和不可变类型，可变类型在函数中修改会影响原来的，不可变类型，不会影响原来的

字符编码

# 计算机的计量单位：
bit比特位：0或者1的一个小格
8个bit位是一个byte，一个字节
1024个字节---》1kb
1024kb---》1mb
1024mb---》1gb

1个字节---》2的8次方中变化，就可以表示出所有的字符（数字，字母，标点符号）

计算机到了中国---》中国汉字--》gbk编码
但是到了不同国家，不同国家有不同国家编码方式，就会出现乱码问题

Unicode编码统一了，字符和数字的对应关系

utf-8：目前主流的编码方式
utf-16

utf8mb4 :在utf-8的基础上增加了表情等特殊符号

闭包函数

1 定义在函数内部
2 对外部作用域有引用

python中函数是一等公民：函数可以赋值给一个变量,也就意味着可以直接传递函数的地址

# 装饰器是闭包函数的典型应用
#在不改变源代码的情况下,新增功能
# python中有装饰器语法糖  @
def wrapper(func):
    def inner(*args,**kwargs):
        # 代码
        res=func(*args,**kwargs)
        # 代码
        return res
    return inner
   
# 没有语法糖 
# a=wrapper(a)
# a()

# 有语法糖
# @wrapper
def a():
    print("xxx")

python中的魔法方法

# __init__：类实例化会触发(对对象进行初始化)
# __str__:打印对象会触发
# __call__:对象()触发，类也是对象  类(),类的实例化过程调用元类的__call__
# __new__:在类实例化会触发，它比__init__早(造出一个空对象)
# __del__:del 对象，对象回收的时候触发
# __setattr__,__getattr__:(.拦截方法)，当对象.属性--》赋值会调用setattr，如果是取值会调用getattr
# __getitem__,__setitem__:([]拦截),当对象[属性]-->赋值和取值时会触发
# __enter__和__exit__ 上下文管理器

setattr，getattr，setitem，getitem演示

# class Person:
#     def __init__(self,name):
#         self.name=name
#     def __setitem__(self, key, value):
#         setattr(self,key,value)  #反射
#     def __getitem__(self, item):
#         return getattr(self,item) # 反射取值
#
# p=Person('lqz')
# # p.name='ppp'
# p['name']=10 # 如何变行 重写__setitem__魔法方法
# # print(p.name)
#
# print(p['name'])


# dic={'name':'lqz','age':19}

class Mydic(dict):
    def __setattr__(self, key, value):
        print("对象加点赋值，会触发我")
        self[key]=value
    def __getattr__(self, item):
        print("对象加点取值，会触发我")
        return self[item] # 不要加引号

mydic=Mydic(name='lqz',age=18)
# print(mydic['name'])
print(mydic.name)
# mydic.name=99
# print(mydic.name)

with 上下文管理器

class Person:
    def __enter__(self):
        print("我在with管理的时候，会触发")
        print('进入with语句块时执行此方法，此方法如果有返回值会赋值给as声明的变量')
        return 'oo'

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('退出with代码块时执行此方法')
        print('1', exc_type)
        print('2', exc_val)
        print('3', exc_tb)


with Person() as p:   # 这句话执行，会触发类的__enter__
    print(p)

__eq__

class A:
    def __init__(self,x,y):
        self.x = x
        self.y = y
	def __eq__(self,obj):
    	# 打印出比较的第二个对象的x值
    	print(obj.x)
    	if self.x +self.y == obj.x+obj.y:
        	return True
    	else:
       		return False
a=A(1,2)
b=A(99,3)
print(a=='ddd')   # 当执行==s时，会触发__eq__的执行，并且把b传进去，就是object
# ==后只要是对象，就可以传进去，就是object

cookie，session，token

# HTTP协议：无状态，无连接，基于请求响应，基于tcp/ip,应用层协议

# mysql：c/s架构：底层基于socket，自己封装的协议，mysql的客户端：navcate（c++图形化界面，实现了请求和响应协议）,pymysql(用python语言实现了请求和响应协议)
# redis：c/s架构：底层基于socket，自己封装的协议
# docker：c/s架构，基于http协议，使用restful规范
# elasticsearch：c/s架构，基于http协议，使用restful规范

# cookie：是存在于浏览器的键值对，向服务端发送请求，携带它过去（不安全）
# session：存在于服务端的键值对（存放的位置可以是多种:内存中，文件，mysql，redis）
#  缺陷：如果用户量很大，存储需要耗费服务器资源
# token：就是个字符串（既安全，又存个人信息），加密字符串，会有个人信息
# token现在应用非常广泛，契合了前后端分离
# JWT：json web token

django中的session底层原理

# 在中间件中，请求走的时候，process_response，取出request.session的modify属性，判断是否是true，如果是true，表示在视图函数中修改过session，数据库同步修改，如果是false，就不修改，返回给前端sessionid：随机字符串
# 请求来了，通过sessionid，取出随机字符串--》去数据库中查--》把表的数据转成字典，赋值给request.session,后面视图函数中就可以操作它了

异常处理

try:
    print("xxx")
    # print(1/0)
except Exception as e:
    print(e)
else:  # 基本上不会用到,只要没有触发异常,就执行else
    print("正常执行，没有出异常，会走")
finally:
    print("我是finally")   # 永远都执行，无论是否有异常

pymysql的使用

import pymysql

#连接数据库
conn=pymysql.connect(host='101.133.225.166', user='root', password="123456",database='test', port=3306) #
# 获取游标
cursor=conn.cursor(cursor=pymysql.cursors.DictCursor) # 查出来数据是字典格式
# 查询操作 定义一个sql
# sql='select id,name from book'
# cursor.execute(sql)
# ret=cursor.fetchall()
# print(ret)
# 插入
# sql='insert into book(id,name) values (%s,%s)'
# cursor.execute(sql,[3,'lqz'])
# conn.commit()

# 删除
# sql='delete from book where name=%s'
# cursor.execute(sql,['lqz'])
# conn.commit()

# 更新
# sql='update book set name=%s where id=%s'
# cursor.execute(sql,['xxx',1])
# conn.commit()