就业寒冬，从拉勾招聘看Python就业前景
1.数据采集
事情的起源是这样的，某个风和日丽的下午... 习惯性的打开知乎准备划下水，看到一个问题刚好邀请回答
于是就萌生了采集下某招聘网站Python岗位招聘的信息，看一下目前的薪水和岗位分布，说干就干。
先说下数据采集过程中遇到的问题，首先请求头是一定要伪装的，否则第一步就会给你弹出你的请求太频繁，请稍后再试，其次网站具有多重反爬策略，解决方案是每次先获取session然后更新我们的session进行抓取，最后拿到了想要的数据。
Chrome浏览器右键检查查看network，找到链接https://www.lagou.com/jobs/positionAjax.json?needAddtionalResult=false
可以看到返回的数据正是页面的Python招聘详情，于是我直接打开发现直接提示{"status":false,"msg":"您操作太频繁,请稍后再访问","clientIp":"124.77.161.207","state":2402}，机智的我察觉到事情并没有那么简单
真正的较量才刚刚开始，我们先来分析下请求的报文，
可以看到请求是以post的方式传递的，同时传递了参数
datas = {
'first': 'false',
'pn': x,
'kd': 'python',
}同时不难发现每次点击下一页都会同时发送一条get请求
经过探索，发现这个get请求和我们post请求是一致的，那么问题就简单许多，整理一下思路
关键词：python 搜索范围：全国 数据时效：2019.05.05
#!/usr/bin/env python3.4
# encoding: utf-8
"""
Created on 19-5-05
@title: ''
@author: Xusl
"""
import json
import requests
import xlwt
import time
# 获取存储职位信息的json对象，遍历获得公司名、福利待遇、工作地点、学历要求、工作类型、发布时间、职位名称、薪资、工作年限
def get_json(url, datas):
my_headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36",
"Referer": "https://www.lagou.com/jobs/list_Python?city=%E5%85%A8%E5%9B%BD&cl=false&fromSearch=true&labelWords=&suginput=",
"Content-Type": "application/x-www-form-urlencoded;charset = UTF-8"
}
time.sleep(5)
ses = requests.session() # 获取session
ses.headers.update(my_headers) # 更新
ses.get("https://www.lagou.com/jobs/list_python?city=%E5%85%A8%E5%9B%BD&cl=false&fromSearch=true&labelWords=&suginput=")
content = ses.post(url=url, data=datas)
result = content.json()
info = result['content']['positionResult']['result']
info_list = []
for job in info:
information = []
information.append(job['positionId']) # 岗位对应ID
information.append(job['city']) # 岗位对应城市
information.append(job['companyFullName']) # 公司全名
information.append(job['companyLabelList']) # 福利待遇
information.append(job['district']) # 工作地点
information.append(job['education']) # 学历要求
information.append(job['firstType']) # 工作类型
information.append(job['formatCreateTime']) # 发布时间
information.append(job['positionName']) # 职位名称
information.append(job['salary']) # 薪资
information.append(job['workYear']) # 工作年限
info_list.append(information)
# 将列表对象进行json格式的编码转换,其中indent参数设置缩进值为2
# print(json.dumps(info_list, ensure_ascii=False, indent=2))
# print(info_list)
return info_list
def main():
page = int(input('请输入你要抓取的页码总数：'))
# kd = input('请输入你要抓取的职位关键字：')
# city = input('请输入你要抓取的城市：')
info_result = []
title = ['岗位id', '城市', '公司全名', '福利待遇', '工作地点', '学历要求', '工作类型', '发布时间', '职位名称', '薪资', '工作年限']
info_result.append(title)
for x in range(1, page+1):
url = 'https://www.lagou.com/jobs/positionAjax.json?needAddtionalResult=false'
datas = {
'first': 'false',
'pn': x,
'kd': 'python',
}
try:
info = get_json(url, datas)
info_result = info_result + info
print("第%s页正常采集" % x)
except Exception as msg:
print("第%s页出现问题" % x)
# 创建workbook,即excel
workbook = xlwt.Workbook(encoding='utf-8')
# 创建表,第二参数用于确认同一个cell单元是否可以重设值
worksheet = workbook.add_sheet('lagouzp', cell_overwrite_ok=True)
for i, row in enumerate(info_result):
# print(row)
for j, col in enumerate(row):
# print(col)
worksheet.write(i, j, col)
workbook.save('lagouzp.xls')
if __name__ == '__main__':
main()
当然存储于excel当然是不够的，之前一直用matplotlib做数据可视化，这次换个新东西pyecharts。
2.了解pyecharts
pyecharts是一款将python与echarts结合的强大的数据可视化工具，包含多种图表
Bar（柱状图/条形图）
Bar3D（3D 柱状图）
Boxplot（箱形图）
EffectScatter（带有涟漪特效动画的散点图）
Funnel（漏斗图）
Gauge（仪表盘）
Geo（地理坐标系）
Graph（关系图）
HeatMap（热力图）
Kline（K线图）
Line（折线/面积图）
Line3D（3D 折线图）
Liquid（水球图）
Map（地图）
Parallel（平行坐标系）
Pie（饼图）
Polar（极坐标系）
Radar（雷达图）
Sankey（桑基图）
Scatter（散点图）
Scatter3D（3D 散点图）
ThemeRiver（主题河流图）
WordCloud（词云图）
用户自定义
Grid 类：并行显示多张图
Overlap 类：结合不同类型图表叠加画在同张图上
Page 类：同一网页按顺序展示多图
Timeline 类：提供时间线轮播多张图
另外需要注意的是从版本0.3.2 开始，为了缩减项目本身的体积以及维持 pyecharts 项目的轻量化运行，pyecharts 将不再自带地图 js 文件。如用户需要用到地图图表（Geo、Map），可自行安装对应的地图文件包。
全球国家地图: echarts-countries-pypkg (1.9MB): 世界地图和 213 个国家，包括中国地图
中国省级地图: echarts-china-provinces-pypkg (730KB)：23 个省，5 个自治区
中国市级地图: echarts-china-cities-pypkg (3.8MB)：370 个中国城市
也可以使用命令进行安装
pip install echarts-countries-pypkg
pip install echarts-china-provinces-pypkg
pip install echarts-china-cities-pypkg3.数据可视化（代码+展示）
各城市招聘数量
from pyecharts import Bar
city_nms_top10 = ['北京', '上海', '深圳', '成都', '杭州', '广州', '武汉', '南京', '苏州', '郑州', '天津', '西安', '东莞', '珠海', '合肥', '厦门', '宁波','南宁', '重庆', '佛山', '大连', '哈尔滨', '长沙', '福州', '中山']
city_nums_top10 = [149, 95, 77, 22, 17, 17, 16, 13, 7, 5, 4, 4, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1]
bar = Bar("Python岗位", "各城市数量")
bar.add("数量", city_nms, city_nums, is_more_utils=True)
# bar.print_echarts_options() # 该行只为了打印配置项，方便调试时使用
bar.render('Python岗位各城市数量.html') # 生成本地 HTML 文件
地图分布展示（这个场景意义不大，不过多分析）
from pyecharts import Geo
city_datas = [('北京', 149), ('上海', 95), ('深圳', 77), ('成都', 22), ('杭州', 17), ('广州', 17), ('武汉', 16), ('南京', 13), ('苏州', 7), ('郑州', 5), ('天津', 4), ('西安', 4), ('东莞', 3), ('珠海', 2), ('合肥', 2), ('厦门', 2), ('宁波', 1), ('南宁', 1), ('重庆', 1), ('佛山', 1), ('大连', 1), ('哈尔滨', 1), ('长沙', 1), ('福州', 1), ('中山', 1)]
geo = Geo("Python岗位城市分布地图", "数据来源拉勾", title_color="#fff",
title_pos="center", width=1200,
height=600, background_color='#404a59')
attr, value = geo.cast(city_datas)
geo.add("", attr, value, visual_range=[0, 200], visual_text_color="#fff",symbol_size=15, is_visualmap=True)
geo.render("Python岗位城市分布地图_scatter.html")
geo = Geo("Python岗位城市分布地图", "数据来源拉勾", title_color="#fff",
title_pos="center", width=1200,
height=600, background_color='#404a59')
attr, value = geo.cast(city_datas)
geo.add("", attr, value, type="heatmap", visual_range=[0,10],visual_text_color="#fff",symbol_size=15,is_visualmap=True)
geo.render("Python岗位城市分布地图_heatmap.html")
各个城市招聘情况
from pyecharts import Pie
city_nms_top10 = ['北京', '上海', '深圳', '成都', '广州', '杭州', '武汉', '南京', '苏州', '郑州']
city_nums_top10 = [149, 95, 77, 22, 17, 17, 16, 13, 7, 5]
pie = Pie()
pie.add("", city_nms_top10, city_nums_top10, is_label_show=True)
# pie.show_config()
pie.render('Python岗位各城市分布饼图.html')
北上深的岗位明显碾压其它城市，这也反映出为什么越来越多的it从业人员毕业以后相继奔赴一线城市，除了一线城市的薪资高于二三线这个因素外，还有一个最重要的原因供需关系，因为一线岗位多，可选择性也就比较高，反观二三线的局面，很有可能你跳个几次槽，发现同行业能呆的公司都待过了...
薪资范围
由此可见，python的岗位薪资多数在10k~20k，想从事Python行业的可以把工作年限和薪资结合起来参考一下。
学历要求 + 工作年限
从工作年限来看，1-3年或者3-5年工作经验的招聘比较多，而应届生和一年以下的寥寥无几，对实习生实在不太友好，学历也普遍要求本科，多数公司都很重视入职人员学历这点毋容置疑，虽然学历不代表一切，但是对于一个企业来说，想要短时间内判断一个人的能力，最快速有效的方法无疑是从学历入手。学历第一关，面试第二关。
但是，这不代表学历不高的人就没有好的出路，现在的大学生越来越多，找工作也越来越难，竞争越来越激烈，即使具备高学历，也不能保证你一定可以找到满意的工作，天道酬勤，特别是it这个行业，知识的迭代，比其他行业来的更频密。不断学习，拓展自己学习的广度和深度，才是最正确的决定。
就业寒冬来临，我们需要的是理性客观的看待，而不是盲目地悲观或乐观。从以上数据分析，如果爱好Python，仍旧可以入坑，不过要注意一个标签有工作经验，就算没有工作经验，自己在学习Python的过程中一定要尝试独立去做一个完整的项目，爬虫也好，数据分析也好，亦或者是开发，都要尝试独立去做一套系统，在这个过程中培养自己思考和解决问题的能力。持续不断的学习，才是对自己未来最好的投资，也是度过寒冬最正确的姿势。
作者：一只写程序的猿
来源：https://juejin.cn/post/6844903837698883597
Fiddler抓取抖音视频数据
本文仅供参考学习,禁止用于任何形式的商业用途，违者自行承担责任。
准备工作：
手机（安卓、ios都可以）/安卓模拟器，今天主要以安卓模拟器为主，操作过程一致。
抓包工具：Fiddel 下载地址：（https://www.telerik.com/download/fiddler ）
编程工具：pycharm
安卓模拟器上安装抖音（逍遥安装模拟器）
一、fiddler配置
在tools中的options中，按照图中勾选后点击Actions
配置远程链接：
选择允许监控远程链接，端口可以随意设置，只要别重复就行，默认8888
然后：重启fiddler！！！这样配置才能生效。
二、安卓模拟器/手机配置
首先查看本机的IP：在cmd中输入ipconfig，记住这个IP
手机确保和电脑在同一局域网下。
手机配置：配置已连接的WiFi，代理选择手动，然后输入上图ip端口号为8888
模拟器配置：设置中长按已连接wifi，代理选择手动，然后输入上图ip端口号为8888
代理设置好后，在浏览器中输入你设置的ip：端口，例如10.10.16.194：8888，就会打开fiddler的页面。然后点击fiddlerRoot certificate安装证书，要不手机会认为环境不安全。
证书名称随便设，可能还需要设置一个锁屏密码。
接下来就可以在fiddler中抓到手机/模拟器软件的包了。
三、抖音抓包
打开抖音，然后观察fiddler中所有的包
其中有个包，包类型为json（json就是网页返回的数据，具体百度），主机地址如图，包大小一般不小，这个就是视频包。
点击这个json包，在fidder右侧，点击解码，我们将视频包的json解码
解码后：点击aweme_list,其中每个大括号代表一个视频，这个和bilibili弹幕或者快手一样，每次加载一点出来，等你看完预加载的，再重新加载一些。
Json是一个字典，我们的视频链接在：aweme_list中，每个视频下的video下的play_addr下的url_list中，一共有6个url，是完全一样的视频，可能是为了应付不同环境，但是一般第3或4个链接的视频不容易出问题，复制链接，浏览器中粘贴就能看到视频了。
接下来解决几个问题，
1、视频数量，每个包中只有这么几个视频，那如何抓取更多呢？
这时候需要借助模拟器的模拟鼠标翻页，让模拟器一直翻页，这样就不断会出现json包了。
2、如何json保存在本地使用
一种方法可以手动复制粘贴，但是这样很low。
所以我们使用fidder自带的脚本，在里面添加规则，当视频json包刷出来后自动保存json包。
自定义规则包：
链接：https://pan.baidu.com/s/1wmtUUMChzuSDZFYGSyUhCg
提取码：7z0l
点击规则脚本，然后将自定义规则放在如图所示位置：
这个脚本有两点需要修改的：
（1）第一行的网址：
这个是从视频包的url中摘出来的，抖音会时不时更新这个url，所以不能用了也要去更新：
比如现在的已经和昨天不同了，记着修改。
（2）路径，那个是我设置json包保存的地址，自己一定要去修改，并创建文件夹，修改完记着点保存。
打开设置好模拟器和脚本后，等待一会，就可以看到文件夹中保存的包了：
四、爬虫脚本
接下来在pycharm中写脚本获取json包里的视频链接：
导包：
import os,json,requests伪装头：
headers = {‘User-Agent’: ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36’}逻辑代码：
运行代码：
效果：
源码：
import os, json, requests# 伪装头
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36'
}
videos_list = os.listdir(
'C:/Users/HEXU/Desktop/抖音数据爬取/抖音爬取资料/raw_data/')# 获取文件夹内所有json包名
count = 1# 计数， 用来作为视频名字
for videos in videos_list: #循环json列表， 对每个json包进行操作
a = open('./抖音爬取资料/raw_data/{}'.format(videos), encoding = 'utf-8')# 打开json包
content = json.load(a)['aweme_list']# 取出json包中所有视频
for video in content: #循环视频列表， 选取每个视频
video_url = video['video']['play_addr']['url_list'][4]# 获取视频url， 每个视频有6个url， 我选的第5个
videoMp4 = requests.request('get', video_url, headers = headers).content# 获取视频二进制代码
with open('./抖音爬取资料/VIDEO/{}.mp4'.format(count), 'wb') as f: #
以二进制方式写入路径， 记住要先创建路径
f.write(videoMp4)# 写入
print('视频{}下载完成'.format(count))# 下载提示
count += 1# 计数 + 1
Python操作Redis
Part1前言
前面我们都是使用 Redis 客户端对 Redis 进行使用的，但是实际工作中，我们大多数情况下都是通过代码来使用 Redis 的，由于小编对 Python 比较熟悉，所以我们今天就一起来学习下如何使用 Python 来操作 Redis。
Part2环境准备
Redis首先需要安装好。Python安装好（建议使用Python3）。Redis的Python库安装好（pip install redis）。
Part3开始实践
1小试牛刀
例：我们计划通过 Python 连接到 Redis。然后写入一个 kv，最后将查询到的 v 打印出来。
直接连接
#!/usr/bin/python3
import redis # 导入redis模块
r = redis.Redis(host='localhost', port=6379, password="pwd@321", decode_responses=True) # host是redis主机，password为认证密码，redis默认端口是6379
r.set('name', 'phyger-from-python-redis') # key是"name" value是"phyger-from-python-redis" 将键值对存入redis缓存
print(r['name']) # 第一种：取出键name对应的值
print(r.get('name')) # 第二种：取出键name对应的值
print(type(r.get('name')))
其中的
get为连接池最后一个执行的命令。
连接池
通常情况下，需要连接 redis 时，会创建一个连接，基于这个连接进行 redis 操作，操作完成后去释放。正常情况下，这是没有问题的，但是并发量较高的情况下，频繁的连接创建和释放对性能会有较高的影响，于是连接池发挥作用。
连接池的原理：预先创建多个连接，当进行 redis 操作时，直接获取已经创建好的连接进行操作。完成后，不会释放这个连接，而是让其返回连接池，用于后续 redis 操作！这样避免连续创建和释放，从而提高了性能！
#!/usr/bin/python3
import redis,time # 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库
pool = redis.ConnectionPool(host='localhost', port=6379, password="pwd@321", decode_responses=True) # host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379
r = redis.Redis(connection_pool=pool)
r.set('name', 'phyger-from-python-redis')
print(r['name'])
print(r.get('name')) # 取出键name对应的值
print(type(r.get('name')))
你会发现，在实际使用中直连和使用连接池的效果是一样的，只是在高并发的时候会有明显的区别。
2基操实践
对于众多的 Redis 命令，我们在此以 SET 命令为例进行展示。
格式： set(name, value, ex=None, px=None, nx=False, xx=False)
在 redis-py 中 set 命令的参数：
| 参数名 | 释义 |
|---|---|
| ex | |
| px | |
| nx | |
| xx | |
ex
我们计划创建一个 kv 并且设置其 ex 为 3，期待 3 秒后此 k 的 v 会变为 None。
#!/usr/bin/python3
import redis,time # 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库
pool = redis.ConnectionPool(host='localhost', port=6379, password="pwd@321", decode_responses=True) # host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379
r = redis.Redis(connection_pool=pool)
r.set('name', 'phyger-from-python-redis',ex=3)
print(r['name']) # 应当有v
time.sleep(3)
print(r.get('name')) # 应当无v
print(type(r.get('name')))
nx
由于 px 的单位太短，我们就不做演示，效果和 ex 相同。
我们计划去重复 set 前面已经 set 过的 name，不出意外的话，在 nx 为真时，我们将会 set 失败。但是人如果 set 不存在的 name1，则会成功。
#!/usr/bin/python3
import redis,time # 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库
pool = redis.ConnectionPool(host='localhost', port=6379, password="pwd@321", decode_responses=True) # host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379
r = redis.Redis(connection_pool=pool)
r.set('name', 'phyger-0',nx=3) # set失败
print(r['name']) # 应当不生效
r.set('name1', 'phyger-1',nx=3) # set成功
print(r.get('name1')) # 应当生效
print(type(r.get('name')))
如上，你会发现
name的set未生效，因为name已经存在于数据库中。而name1的set已经生效，因为name1是之前在数据库中不存在的。
xx
我们计划去重复 set 前面已经 set 过的 name，不出意外的话，在 nx 为真时，我们将会 set 成功。但是人如果 set 不存在的 name2，则会失败。
#!/usr/bin/python3
import redis,time # 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库
pool = redis.ConnectionPool(host='localhost', port=6379, password="pwd@321", decode_responses=True) # host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379
r = redis.Redis(connection_pool=pool)
r.set('name', 'phyger-0',xx=3) # set失败
print(r['name']) # 应当变了
r.set('name2', 'phyger-1',xx=3) # set成功
print(r.get('name2')) # 应当没有set成功
print(type(r.get('name')))
以上，就是今天全部的内容，更多信息建议参考
redis官方文档。
作者：phyger
来源：https://mp.weixin.qq.com/s/bsv57OPKubD2dz0Wskn6eQ
Python列表和集合的查找原理
集合与列表查找对比
关于大量数据查找，效率差距到底有多大？
先看一组实例：
import time
import random
nums = [random.randint(0, 2000000) for i in range(1000)]
list_test = list(range(1000000))
set_test = set(list_test)
count_list, count_set = 0, 0
t1 = time.time() #测试在列表中进行查找
for num in nums:
if num in list_test:
count_list += 1
t2 = time.time()
for num in nums: #测试在集合中进行查找
if num in set_test:
count_set += 1
t3 = time.time() #测试在集合中进行查找
print('找到个数，列表：{}，集合：{}'.format(count_list, count_set))
print('使用时间，列表：{:.4f}s'.format(t2 - t1))
print('使用时间，集合：{:.4f}s'.format(t3 - t2))
输出结果为：
找到个数，列表：528，集合：528
使用时间，列表：7.9329s
使用时间，集合：0.0010s
对于大数据集量来说，我们清晰地看到，集合的查找效率远远的高于列表，那么本文接下来会从Python底层数据结构的角度分析为何出现如此情况。
list列表的原理
Python中的list作为一个常用数据结构，在很多程序中被用来当做数组使用，可能很多人都觉得list无非就是一个动态数组，就像C++中的vector或者Go中的slice一样。但事实真的是这样的吗？
我们来思考一个简单的问题，Python中的list允许我们存储不同类型的数据，既然类型不同，那内存占用空间就就不同，不同大小的数据对象又是如何存入数组中呢？
比如下面的代码中，我们分别在数组中存储了一个字符串，一个整形，以及一个字典对象，假如是数组实现，则需要将数据存储在相邻的内存空间中，而索引访问就变成一个相当困难的事情了，毕竟我们无法猜测每个元素的大小，从而无法定位想要的元素位置。
>>> test = ["hello world", 456, {}]
>>> test
['hello world', 456, {}]
是通过链表结构实现的吗？毕竟链表支持动态的调整，借助于指针可以引用不同类型的数据。但是这样的话使用下标索引数据的时候，需要依赖于遍历的方式查找，O(n)的时间复杂度访问效率实在是太低。
同时使用链表的开销也较大，每个数据项除了维护本地数据指针外，还要维护一个next指针，因此还要额外分配8字节数据，同时链表分散性使其无法像数组一样利用CPU的缓存来高效的执行数据读写。
实现的细节可以从其Python的源码中找到， 定义如下：
typedef struct {
PyObject_VAR_HEAD
PyObject **ob_item;
Py_ssize_t allocated;
} PyListObject;
内部list的实现的是一个C结构体，该结构体中的obitem是一个指针数组，存储了所有对象的指针数据，allocated是已分配内存的数量, PyObjectVAR_HEAD是一个宏扩展包含了更多扩展属性用于管理数组，比如引用计数以及数组大小等内容。
所以我们可以看出，用动态数组作为第一层数据结构，动态数组里存储的是指针，指向对应的数据。
既然是一个动态数组，则必然会面临一个问题，如何进行容量的管理，大部分的程序语言对于此类结构使用动态调整策略，也就是当存储容量达到一定阈值的时候，扩展容量，当存储容量低于一定的阈值的时候，缩减容量。
道理很简单，但实施起来可没那么容易，什么时候扩容，扩多少，什么时候执行回收，每次又要回收多少空闲容量，这些都是在实现过程中需要明确的问题。
假如我们使用一种最简单的策略：超出容量加倍，低于一半容量减倍。这种策略会有什么问题呢？设想一下当我们在容量已满的时候进行一次插入，随即删除该元素，交替执行多次，那数组数据岂不是会不断地被整体复制和回收，已经无性能可言了。
对于Python list的动态调整规则程序中定义如下, 当追加数据容量已满的时候，通过下面的方式计算再次分配的空间大小，创建新的数组，并将所有数据复制到新的数组中。这是一种相对数据增速较慢的策略，回收的时候则当容量空闲一半的时候执行策略，获取新的缩减后容量大小。
具体规则如下：
new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6)
new_allocated += newsize
动态数组扩容规则是：当出现数组存满时，扩充容量新加入的长度和额外3个，如果新加入元素大于9时，则扩6额外。
其实对于Python列表这种数据结构的动态调整，在其他语言中也都存在，只是大家可能在日常使用中并没有意识到，了解了动态调整规则，我们可以通过比如手动分配足够的空间，来减少其动态分配带来的迁移成本，使得程序运行的更高效。
另外如果事先知道存储在列表中的数据类型都相同，比如都是整形或者字符等类型，可以考虑使用arrays库，或者numpy库，两者都提供更直接的数组内存存储模型，而不是上面的指针引用模型，因此在访问和存储效率上面会更高效一些。
从上面的数据结构可以得出，Python list的查找时间复杂度为O（n），因为作为一个动态数组，需要遍历每一个元素去找到目标元素，故而是一种较为低效的查找方式。
set集合的原理
说到集合，就不得不提到Python中的另一种数据结构，就是字典。字典和集合有异曲同工之妙。
在Python中，字典是通过散列表或说哈希表实现的。字典也被称为关联数组，还称为哈希数组等。也就是说，字典也是一个数组，但数组的索引是键经过哈希函数处理后得到的散列值。
哈希函数的目的是使键均匀地分布在数组中，并且可以在内存中以O(1)的时间复杂度进行寻址，从而实现快速查找和修改。哈希表中哈希函数的设计困难在于将数据均匀分布在哈希表中，从而尽量减少哈希碰撞和冲突。由于不同的键可能具有相同的哈希值，即可能出现冲突，高级的哈希函数能够使冲突数目最小化。
Python中并不包含这样高级的哈希函数，几个重要（用于处理字符串和整数）的哈希函数是常见的几个类型。
通常情况下建立哈希表的具体过程如下：
数据添加：把key通过哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。
数据查询：再次使用哈希函数将key转换为对应的数组下标，并定位到数组的位置获取value。
哈希函数就是一个映射，因此哈希函数的设定很灵活，只要使得任何关键字由此所得的哈希函数值都落在表长允许的范围之内即可。本质上看哈希函数不可能做成一个一对一的映射关系，其本质是一个多对一的映射，这也就引出了下面一个概念——哈希冲突或者说哈希碰撞。哈希碰撞是不可避免的，但是一个好的哈希函数的设计需要尽量避免哈希碰撞。
Python中使用开放地址法解决冲突
CPython使用伪随机探测（pseudo-random probing）的散列表（hash table）作为字典的底层数据结构。由于这个实现细节，只有可哈希的对象才能作为字典的键。字典的三个基本操作（添加元素，获取元素和删除元素）的平均事件复杂度为O(1)。
Python中所有不可变的内置类型都是可哈希的。可变类型（如列表，字典和集合）就是不可哈希的，因此不能作为字典的键。
常见的哈希碰撞解决方法：
开放寻址法（open addressing） 开放寻址法中，所有的元素都存放在散列表里，当产生哈希冲突时，通过一个探测函数计算出下一个候选位置，如果下一个获选位置还是有冲突，那么不断通过探测函数往下找，直到找个一个空槽来存放待插入元素。开放地址的意思是除了哈希函数得出的地址可用，当出现冲突的时候其他的地址也一样可用，常见的开放地址思想的方法有线性探测再散列，二次探测再散列等，这些方法都是在第一选择被占用的情况下的解决方法。 再哈希法 这个方法是按顺序规定多个哈希函数，每次查询的时候按顺序调用哈希函数，调用到第一个为空的时候返回不存在，调用到此键的时候返回其值。 链地址法 将所有关键字哈希值相同的记录都存在同一线性链表中，这样不需要占用其他的哈希地址，相同的哈希值在一条链表上，按顺序遍历就可以找到。 公共溢出区 其基本思想是：所有关键字和基本表中关键字为相同哈希值的记录，不管他们由哈希函数得到的哈希地址是什么，一旦发生冲突，都填入溢出表。 装填因子α 一般情况下，处理冲突方法相同的哈希表，其平均查找长度依赖于哈希表的装填因子。哈希表的装填因子定义为表中填入的记录数和哈希表长度的比值，也就是标志着哈希表的装满程度。直观看来，α越小，发生冲突的可能性就越小，反之越大。一般0.75比较合适，涉及数学推导。
在Python中一个key-value是一个entry，entry有三种状态：
Unused：me_key == me_value == NULL
Unused是entry的初始状态，key和value都为NULL。插入元素时，Unused状态转换成Active状态。这是me_key为NULL的唯一情况。
Active：me_key != NULL and me_key != dummy 且 me_value != NULL
插入元素后，entry就成了Active状态，这是me_value唯一不为NULL的情况，删除元素时Active状态可转换成Dummy状态。
Dummy：me_key == dummy 且 me_value == NULL
此处的Dummy对象实际上一个PyStringObject对象，仅作为指示标志。Dummy状态的元素可以在插入元素的时候将它变成Active状态，但它不可能再变成Unused状态。
为什么entry有Dummy状态呢？
这是因为采用开放寻址法中，遇到哈希冲突时会找到下一个合适的位置，例如某元素经过哈希计算应该插入到A处，但是此时A处有元素的，通过探测函数计算得到下一个位置B，仍然有元素，直到找到位置C为止，此时ABC构成了探测链，查找元素时如果hash值相同，那么也是顺着这条探测链不断往后找，当删除探测链中的某个元素时，比如B，如果直接把B从哈希表中移除，即变成Unused状态，那么C就不可能再找到了，因为AC之间出现了断裂的现象，正是如此才出现了第三种状态-Dummy，Dummy是一种类似的伪删除方式，保证探测链的连续性。
set集合和dict一样也是基于散列表的，只是他的表元只包含键的引用，而没有对值的引用，其他的和dict基本上是一致的，所以在此就不再多说了。并且dict要求键必须是能被哈希的不可变对象，因此普通的set无法作为dict的键，必须选择被“冻结”的不可变集合类：frozenset。顾名思义，一旦初始化，集合内数据不可修改。
一般情况下普通的顺序表数组存储结构也可以认为是简单的哈希表，虽然没有采用哈希函数（取余），但同样可以在O(1)时间内进行查找和修改。但是这种方法存在两个问题：
扩展性不强 浪费空间
dict是用来存储键值对结构的数据的，set其实也是存储的键值对，只是默认键和值是相同的。Python中的dict和set都是通过散列表来实现的。下面来看与dict相关的几个比较重要的问题：
dict中的数据是无序存放的。操作的时间复杂度，插入、查找和删除都可以在O(1)的时间复杂度。这是因为查找相当于将查找值通过哈希函数运算之后，直接得到对应的桶位置（不考虑哈希冲突的理想情况下），故而复杂度为O（1）。
由于键的限制，只有可哈希的对象才能作为字典的键和set的值。可hash的对象即Python中的不可变对象和自定义的对象。可变对象（列表、字典、集合）是不能作为字典的键和set的值的。
与list相比：list的查找和删除的时间复杂度是O(n)，添加的时间复杂度是O(1)。但是dict使用hashtable内存的开销更大。为了保证较少的冲突，hashtable的装载因子，一般要小于0.75，在Python中当装载因子达到2/3的时候就会自动进行扩容。
参考资料：
Python dict和set的底层原理：https://blog.csdn.net/liuweiyuxiang/article/details/98943272
python 图解Python List数据结构：https://blog.csdn.net/u014029783/article/details/107992840
作者：严天宇
来源：https://mp.weixin.qq.com/s/wvgf7GpbCoeDsLOp1WAFPg
Python运算符优先级及结合性
当多个运算符出现在一起需要进行运算时，Python 会先比较各个运算符的优先级，按照优先级从高到低的顺序依次执行；
当遇到优先级相同的运算符时，再根据结合性决定先执行哪个运算符：如果是左结合性就先执行左边的运算符，如果是右结合性就先执行右边的运算符。
运算符的优先级
在数学运算2 + 4 * 3中，要先计算乘法，再计算加法，否则结果就是错误的。所谓优先级，就是当多个运算符出现在一起时，需要先执行哪个运算符，那么这个运算符的优先级就更高。
Python中运算符优先级如下表所示，括号的优先级是最高的，无论任何时候优先计算括号里面的内容，逻辑运算符的优先级最低，在表中处在同一行运算符的优先级一致，上一层级的优先级高于下一层级的。算术运算符可以分为四种，幂运算最高，其次是正负号，然后是 “* / // %”，最后才是加减“+ -”。
运算符 | 描述 |
() | 括号 |
** | 幂运算 |
~ | 按位取反 |
+、- | 正号、负号 |
* 、/、 %、 // | 乘、除、取模、取整除 |
+ 、- | 加、减 |
>> 、<< | 右移、左移 |
& | 按位“与” |
^ 、| | 按位“异或”，按位“或” |
<= 、< 、>、 >= | 比较运算符 |
==、!= | 等于、不等于 |
=、%=、/=、//=、-=、+=、*=、**= | 赋值运算符 |
is、is not | 身份运算符 |
in、not in | 成员运算符 |
and or not | 逻辑运算符 |
运算符的结合性
在多种运算符在一起进行运算时，除了要考虑优先级，有时候还需要考虑结合性。当同时出现多个优先级相同的运算符时，先执行左边的叫左结合性，先执行右边的叫右结合性。如：5 / 2 * 4，由于/和*的优先级相同，所以只能参考运算符的结合性了，/和*都是左结合性的，所以先计算除法，再计算乘法，结果是10.0。Python中大部分运算符都具有左结合性，其中，幂运算**、正负号、赋值运算符等具有右结合性。
>>> 5 / 2* 4# 左结合性运算符
10.0
>>> 2 ** 2 ** 3# 右结合性，等同于2 ** （2 **3）
256虽然Python运算符存在优先级的关系，但写程序时不建议写很长的表达式，过分依赖运算符的优先级，比如：2 ** -1 % 3 / 5 ** 3 *4，这样的表达式会大大降低程序的可读性。因此，建议写程序时，遵守以下两点原则，保证运算逻辑清晰明了。
尽量不要把一个表达式写的过长过于复杂，如果计算过程的确需要，可以尝试将它拆分几部分来写。 尽量多使用()来控制运算符的执行顺序，使用()可以让运算的先后顺序变得十分清楚。
作者：刘文飞
