import time
#61、简述同源策略
'''
同源策略需要同时满足以下三点要求：
1）协议相同
2）域名相同
3）端口相同
http:www.test.com与https:www.test.com 不同源——协议不同
http:www.test.com与http:www.admin.com 不同源——域名不同
http:www.test.com与http:www.test.com:8081 不同源——端口不同
只要不满足其中任意一个要求，就不符合同源策略，就会出现“跨域”
'''
#62、简述cookie和session的区别
'''
1，session 在服务器端，cookie 在客户端（浏览器）
2、session 的运行依赖 session id，而 session id 是存在 cookie 中的
也就是说，如果浏览器禁用了 cookie ，同时 session 也会失效
3、cookie安全性比session差
'''
#63、简述多线程、多进程
'''
进程：
1、操作系统进行资源分配和调度的基本单位，多个进程之间相互独立
2、稳定性好，如果一个进程崩溃，不影响其他进程
3、进程消耗资源大，开启的进程数量有限制
线程：
1、CPU进行资源分配和调度的基本单位
2、线程是进程的一部分，是比进程更小的能独立运行的基本单位
3、一个进程下的多个线程可以共享该进程的所有资源
4、如果IO操作密集，则可以多线程运行效率高
5、缺点是如果一个线程崩溃，都会造成进程的崩溃
应用：
1、IO密集的用多线程，在用户输入，sleep 时候，
可以切换到其他线程执行，减少等待的时间
2、CPU密集的用多进程，因为假如IO操作少，用多线程的话，
因为线程共享一个全局解释器锁，
当前运行的线程会霸占GIL，其他线程没有GIL，
就不能充分利用多核CPU的优势
'''
#64、简述any()和all()方法
'''
any():只要迭代器中有一个元素为真就为真
all():迭代器中所有的判断项返回都是真，结果才为真
python中什么元素为假？
0，空字符串，空列表、空字典、空元组、None, False
'''
#65
'''
IOError、AttributeError、ImportError、IndentationError、
IndexError、KeyError、SyntaxError、NameError分别代表什么异常?
答：
IOError：输入输出异常
AttributeError：试图访问一个对象没有的属性
ImportError：无法引入模块或包，基本是路径问题
IndentationError：语法错误，代码没有正确的对齐
IndexError：下标索引超出序列边界
KeyError:试图访问你字典里不存在的键
SyntaxError:Python代码逻辑语法出错，不能执行
NameError:使用一个还未赋予对象的变量
'''
#66、python中copy和deepcopy区别
'''
1、复制不可变数据类型，不管copy还是deepcopy,都是同一个地址
2、复制的值是可变对象（列表和字典）:
浅拷贝copy有两种情况：
1.复制的对象中无 复杂 子对象, 原来值的改变并不会影响浅复制的值
同时浅复制的值改变也并不会影响原来的值(也就是互不影响)
2.复制的对象中有 复杂 子对象，（例如列表中的一个子元素是一个列表），
改变原来的值 中的复杂子对象的值 ，会影响浅复制的值。
深拷贝deepcopy：完全复制独立，包括内层列表和字典
'''
#67、列出几种魔法方法并简要介绍用途
'''
__init__:对象初始化方法
__new__:创建对象时候执行的方法，单列模式会用到
__str__:当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
__del__:删除对象执行的方法
class f:
def __str__(self):
return 'ok'
f = f()
print(f.__str__())
'''
#68、C:Users y-wu.junyaDesktop>python 1.py 22 33命令行启动程序并传参，
# print(sys.argv)会输出什么数据？
'''
输出文件名和参数构成的列表
['1.py','22','33']
'''
#69、请将[i for i in range(3)]改成生成器
'''
a = (i for i in range(3))
print(list(a))
print(type(a))
'''
#70、a = " hehheh ",去除收尾空格
'''
a = " hehheh "
a = a.strip()
print(a)
'''
#71、举例sort和sorted对列表排序，list=[0,-1,3,-10,5,9]
'''
list=[0,-1,3,-10,5,9]
list.sort(reverse=False)
print('从小到大的顺序：',list)
ret = sorted(list,reverse=False)
print(ret)
总结：
1.sort是在原基础上修改，没有返回值
2.sorted有返回值，是个新的列表
'''
#72、对list排序
# foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4],使用lambda函数从小到大排序
'''
foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
fo = sorted(foo,key=lambda x:x,reverse=False)
print(fo) #[-20, -5, -4, -4, -2, 0, 2, 4, 8, 8, 9]
'''
#73、使用lambda函数对list排序
# foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]，输出结果为
#[0,2,4,8,8,9,-2,-4,-4,-5,-20]，正数从小到大，负数从大到小
'''
传两个条件，x<0和abs(x)
当i<0的时候，按照绝对值大小进行排序，i>0的时候，正常排序
foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
fo = sorted(foo,key=lambda i:(i<0,abs(i)))
print(fo)
'''
#74、列表嵌套字典的排序，分别根据年龄和姓名排序
'''
foo = [
{"name":"zs","age":19},
{"name":"ll","age":54},
{"name":"wa","age":17},
{"name":"df","age":23}
]
#年龄
f1 = sorted(foo,key=lambda x:x["age"])
print('按照年龄排序',f1)
#姓名
f2 = sorted(foo,key=lambda x:x["name"])
print('按照姓名排序',f2)
'''
#75、列表嵌套元组，分别按字母和数字排序
'''
foo = [
("zs",19),
("ls",54),
("wa",17),
("df",23),
]
#按字母
f1 = sorted(foo,key=lambda i:i[0])
print(f1)
#按数字
f2 = sorted(foo,key=lambda i:i[1])
print(f2)
'''
#76、列表嵌套列表排序，年龄数字相同怎么办？
'''
foo = [
["zs",19],
["ls",54],
["wa",17],
["df",19],
]
f = sorted(foo,key=lambda x:(x[1],x[0]))
print(f) #[['wa', 17], ['df', 19], ['zs', 19], ['ls', 54]]
注意：lambda函数中，如果发生了相同的条件，则根据后面的条件进行排序
'''
#77、根据键对字典排序（方法一，zip函数）
'''
dic = {"name":"zs","sex":"man","city":"bj"}
#字典转化为列表，并且嵌套元祖
foo = zip(dic.keys(),dic.values())
f = [i for i in foo ]
#print(f) #[('name', 'zs'), ('sex', 'man'), ('city', 'bj')]
#按照键排序
f_sort = sorted(f,key=lambda i:i[0])
new_dic = {i[0]:i[1] for i in f_sort}
print('new_dic:',new_dic) #{'city': 'bj', 'name': 'zs', 'sex': 'man'}
--------------
78.题（方法二）
dic_sort = sorted(dic.items(),key=lambda i:i[0])
# print(dic_sort) #[('city', 'bj'), ('name', 'zs'), ('sex', 'man')]
new_dic_sort = {i[0]:i[1] for i in dic_sort}
print(new_dic_sort)
这两种方法效果相同！
'''
#79、列表推导式、字典推导式、生成器
'''
import random
list1 = [i for i in range(6)]
print(list) #[0, 1, 2, 3, 4, 5]
dic = {i:random.randint(1,6) for i in ["a","b","c"]}
print(dic)
a = (i for i in range(6))
print(list(a)) #[0, 1, 2, 3, 4, 5]
print(a) #<generator object <genexpr> at 0x000001696375C408>
'''
#80、最后出一道检验题目，根据字符串长度排序，看排序是否灵活运用
'''
s = ["ab","abc","a","dgdf"]
#第一种方法
s_sort = sorted(s,key=lambda i:len(i))
print(s_sort)
#第二种方法
s.sort(key=len,reverse=True)
print(s)
'''
import time
#81、举例说明SQL注入和解决办法
'''
当以字符串格式化书写方式的时候，如果用户输入的有;+SQL语句，后面的SQL语句会执行，
比如例子中的SQL注入会删除数据库demo
input_name = "zs;drop database demo"
sql = "select * from demo where name='%s" %input_name
print(sql)
解决方式：通过传参数方式解决SQL注入
params = [input_name]
count = cs1.execute('select * from demo where name="%s",params)
'''
#82、s="info:xiaoZhang 33 shandong",
# 用正则切分字符串输出
# ['info', 'xiaoZhang', '33', 'shandong']
'''
import re
s="info:xiaoZhang 33 shandong"
s_ret = re.split(r'[:| ]',s)
print(s_ret)
'''
#83、正则匹配以163.com结尾的邮箱
'''
email_list = ["[email protected]","[email protected]","[email protected]"]
import re
for email in email_list:
email_list_ret = re.findall(r'[\w]{4,20}@163\.com$',email)
if email_list_ret:
print(email_list_ret)
else:
pass
'''
#84、递归求和,递归完成 1+2+3+4，，，，+10的和
'''
def get_sum(num):
if num >= 1:
res = num + get_sum(num-1)
else:
res = 0
return res
res = get_sum(5)
print(res)
# res = 5 + get_sum(4)
# res = 5 + 4 + get_sum(3)
# res = 5 + 4 + 3 + get_sum(2)
# res = 5 + 4 + 3 + 2 + get_sum(1)
# res = 5 + 4 + 3 + 2 + 1 + get_sum(0)
'''
#85、python字典和json字符串相互转化方法
'''
import json
dic = {"name":"zs"}
ret1 = json.dumps(dic)
print(type(ret1)) #<class 'str'>
ret2 = json.loads(ret1)
print(type(ret2)) #<class 'dict'>
'''
#86、MyISAM 与 InnoDB 区别：
'''
1、InnoDB 支持事务，MyISAM 不支持，这一点是非常之重要。事务是一种高
级的处理方式，如在一些列增删改中只要哪个出错还可以回滚还原，而 MyISAM
就不可以了；
2、MyISAM 适合查询以及插入为主的应用，InnoDB 适合频繁修改以及涉及到
安全性较高的应用；
3、InnoDB 支持外键，MyISAM 不支持；
4、对于自增长的字段，InnoDB 中必须包含只有该字段的索引，但是在 MyISAM
表中可以和其他字段一起建立联合索引；
5、清空整个表时，InnoDB 是一行一行的删除，效率非常慢。MyISAM 则会重
建表
'''
#87、统计字符串中某字符出现次数
"""
str = "张三 美国 小日本 哈哈 呵呵 张 三"
str_count = str.count("张三")
print(str_count) # 1
"""
#88、字符串转化大小写
'''
str1 = "allen"
str1 = str1.upper()
print(str1) #ALLEN
str2 = str1.lower()
print(str2) #allen
'''
#89、用两种方法去空格
"""
str1 = "hello world haha hehe"
str1 = str1.split(" ")
str1 = "".join(str1)
print(str1) #helloworldhahahehe
str2 = "hello world haha hehe"
str2 = str2.replace(' ','')
print(str2) #helloworldhahahehe
"""
#90、正则匹配不是以4和7结尾的手机号
"""
import re
tels = ["332814","332817","332817","332816"]
for tel in tels:
ret = re.match('1[\d]{9}[0-3,5-6,8-9]',tel)
if ret:
print('正确的手机号码',ret.group())
else:
print('错误的手机号码',tel)
"""
#91、简述python引用计数机制
"""
python垃圾回收主要以引用计数为主，
标记-清除和分代清除为辅的机制，
其中标记-清除和分代回收主要是为了处理循环引用的难题。
引用计数算法
当有1个变量保存了对象的引用时，此对象的引用计数就会加1
当使用del删除变量指向的对象时，
如果对象的引用计数不为1，比如3，
那么此时只会让这个引用计数减1，即变为2，
当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除
"""
#92、int("1.4"),int(1.4)输出结果？
"""
print(int("1.4")) #ValueError
print(int(1.4)) #1
"""
#93、列举3条以上PEP8编码规范
"""
1、顶级定义之间空两行，比如函数或者类定义。
2、方法定义、类定义与第一个方法之间，都应该空一行
3、三引号进行注释
4、使用Pycharm、Eclipse一般使用4个空格来缩进代码
"""
#94、正则表达式匹配第一个URL
"""
s = "https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&wd=python&rsv_pq=f912242f00000db7&rsv_t=7303ZsYPgxjNvPXiFYC4sw6XnA%2FoEv%2B4FEmxpbfwyXcd9fZ6YFUaAP8XdJc&rqlang=cn&rsv_enter=1&rsv_sug3=3&rsv_sug1=2&rhttps://www.baidu.comsv_sug7=101&rsv_sug2=0&ihttps://www.baidu.comnputT=2342&rsv_sug4=4060&rsv_sug=2"
import re
ret = re.findall(r'https://.*?\.com',s)
print(ret) #['https://www.baidu.com', 'https://www.baidu.com', 'https://www.baidu.com']
"""
#95、正则匹配中文
"""
import re
title = "你好 ，世界，aaa，我爱北京天安门"
t_obj = re.compile(r'[\u4e00-\u9fa5]+')
ret = re.findall(t_obj,title)
print(ret)
"""
#96、简述乐观锁和悲观锁
"""
悲观锁, 就是很悲观，每次去拿数据的时候都认为别人会修改，
所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。
传统的关系型数据库里边就用到了很多这种锁机制，
比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。
乐观锁，就是很乐观，每次去拿数据的时候都认为别人不会修改，
所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，
可以使用版本号等机制，乐观锁适用于多读的应用类型，这样可以提高吞吐量
"""
#97 r、r+、rb、rb+文件打开模式区别
#98、Linux命令重定向 > 和 >>
"""
Linux 允许将命令执行结果 重定向到一个 文件
将本应显示在终端上的内容 输出／追加 到指定文件中
> 表示输出，会覆盖文件原有的内容
>> 表示追加，会将内容追加到已有文件的末尾
将 echo 输出的信息保存到 1.txt 里echo Hello Python > 1.txt
将 tree 输出的信息追加到 1.txt 文件的末尾tree >> 1.txt
"""
#99、正则表达式匹配出<html><h1>www.itcast.cn</h1></html>
#前面的<>和后面的<>是对应的，可以用此方法
"""
labels = [
"<html><h1>www.itcast.cn</h1></html>",
"<html><h1>www.itcast.cn</h2></html>"
]
import re
for label in labels:
ret = re.match(r'<(\w*)><(\w*)>.*?</\2></\1>',label)
if ret:
print(ret.group())
else:
print('错误的是',label)
<html><h1>www.itcast.cn</h1></html>
错误的是 <html><h1>www.itcast.cn</h2></html>
"""
#100、python传参数是传值还是传址？
"""
Python中函数参数是引用传递（注意不是值传递）。
对于不可变类型（数值型、字符串、元组），因变量不能修改，
所以运算不会影响到变量自身；而对于可变类型（列表字典）来说，
函数体运算可能会更改传入的参数变量。
"""
import time
# 101、求两个列表的交集、差集、并集
'''
a = [1,2,3,4]
b = [4,3,5,6]
x = set(a) & set(b)
print('这是交集',list(x))
y = set(a) | set(b)
print('这是并集',list(y))
z = set(a) - set(b)
print('这是差集',list(z))
'''
#102、生成0-100的随机数
'''
import random
#0-1之间随机小鼠
ret = random.random() * 100
print(ret)
#0-101之间随机整数
ret2 = random.randint(0,101)
print(ret2)
'''
#103、lambda匿名函数好处
'''
精简代码，lambda省去了定义函数，map省去了写for循环过程
list1 = [2,4]
ret = map(lambda x:x**2,list1)
print(ret) #<map object at 0x000001A4FD741208>
print(list(ret)) #[4, 16]
'''
#104、常见的网络传输协议
'''
http,https,ftp,tcp,udp
'''
#105、单引号、双引号、三引号用法
"""
1 表示字符串的时候，单引号里面可以用双引号，而不用转义字符,反之亦然。
2 但是如果直接用单引号扩住单引号，则需要转义，像这样：
' She said:'Yes.' '
3 三引号可以直接书写多行，通常用于大段，大篇幅的字符串
"""
#106、python垃圾回收机制
"""
python垃圾回收主要以引用计数为主，
标记-清除和分代清除为辅的机制，
其中标记-清除和分代回收主要是为了处理循环引用的难题。
引用计数算法
当有1个变量保存了对象的引用时，此对象的引用计数就会加1
当使用del删除变量指向的对象时，
如果对象的引用计数不为1，比如3，
那么此时只会让这个引用计数减1，即变为2，
当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除
"""
#107、HTTP请求中get和post区别
"""
1、GET请求是通过URL直接请求数据，数据信息可以在URL中直接看到，
比如浏览器访问；而POST请求是放在请求头中的，我们是无法直接看到的；
2、GET提交有数据大小的限制，一般是不超过1024个字节，
而这种说法也不完全准确，HTTP协议并没有设定URL字节长度的上限，
而是浏览器做了些处理，所以长度依据浏览器的不同有所不同；
POST请求在HTTP协议中也没有做说明，
一般来说是没有设置限制的，但是实际上浏览器也有默认值。
总体来说，少量的数据使用GET，大量的数据使用POST。
3、GET请求因为数据参数是暴露在URL中的，
所以安全性比较低，比如密码是不能暴露的，就不能使用GET请求；
POST请求中，请求参数信息是放在请求头的，所以安全性较高，可以使用。
在实际中，涉及到登录操作的时候，尽量使用HTTPS请求，安全性更好。
"""
#108、python中读取Excel文件的方法
"""
应用数据分析库pandas
"""
#109、简述多线程、多进程
"""
进程：
1、操作系统进行资源分配和调度的基本单位，多个进程之间相互独立
2、稳定性好，如果一个进程崩溃，不影响其他进程，
但是进程消耗资源大，开启的进程数量有限制
线程：
1、CPU进行资源分配和调度的基本单位，
线程是进程的一部分，是比进程更小的能独立运行的基本单位，
一个进程下的多个线程可以共享该进程的所有资源
2、如果IO操作密集，则可以多线程运行效率高，缺点是如果一个线程崩溃，
都会造成进程的崩溃
应用：
IO密集的用多线程，在用户输入，sleep 时候，可以切换到其他线程执行，
减少等待的时间
CPU密集的用多进程，因为假如IO操作少，用多线程的话，因为线程共享一个全局解释器锁，
当前运行的线程会霸占GIL，其他线程没有GIL，就不能充分利用多核CPU的优势
"""
#110、python正则中search和match
"""
search 匹配的第一个匹配到的数据，加group()
findall 满足正则的都匹配
match 从开头进行匹配，匹配不到会报错，加group()
"""