Python入门

Python诞生

python的创始人为吉多·范罗苏姆（Guido van Rossum）。1989年，为了打发圣诞节假期，Guido开始在阿姆斯特丹写Python语言的编译器。Python这个名字，来自Guido所挚爱的电视剧Monty Python’s Flying Circus。他希望这个新的叫做Python的语言，能符合他的理想：创造一种C和shell之间，功能全面，易学易用，可拓展的语言。

TIOBE 近日公布了2019年5月编程语言排行榜，总体排名变化不大，排名前十的依旧是：Java, C, C++, Python, Visual Basic .NET, C#, JavaScript, SQL, PHP 和汇编语言。（TIOBE编程语言排行榜是编程语言流行趋势的一个指标，每月更新，这份排行榜排名基于互联网有经验的程序员、课程和第三方厂商的数量。排名使用著名的搜索引擎（诸如Google、MSN、Yahoo!、Wikipedia、YouTube以及Baidu等）进行计算。请注意这个排行榜只是反映某个编程语言的热门程度，并不能说明一门编程语言好不好，或者一门语言所编写的代码数量多少。--百度百科）

Python可以应用于众多领域，如：数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等众多领域。目前业内几乎所有大中型互联网企业都在使用Python，如：Youtube、Dropbox、BT、Quora（中国知乎）、豆瓣、知乎、Google、Yahoo!、Facebook、NASA、百度、腾讯、汽车之家、美团等。

Python2与Python3区别

参考：

https://www.cnblogs.com/yyyyyyyyyy/p/8580824.html

https://www.cnblogs.com/meng-wei-zhi/articles/8194849.html

Python应用

目前Python主要应用领域：

• 云计算: 云计算最火的语言， 典型应用OpenStack；
• WEB开发: 众多优秀的WEB框架，众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣，知乎...， 典型WEB框架有Django，Flask；
• 科学运算、人工智能: 典型库NumPy, SciPy, Matplotlib, Enthought librarys,pandas；
• 系统运维: 运维人员必备语言；
• 金融：量化交易，金融分析，在金融工程领域，Python不但在用，且用的最多，而且重要性逐年提高。原因：作为动态语言的Python，语言结构清晰简单，库丰富，成熟稳定，科学计算和统计分析都很牛逼，生产效率远远高于c,c++,java,尤其擅长策略回测；
• 图形GUI: PyQT, WxPython,TkInter；

Python在一些公司的应用： 

• 谷歌：Google App Engine 、code.google.com 、Google earth 、谷歌爬虫、Google广告等项目都在大量使用Python开发；
• CIA: 美国中情局网站就是用Python开发的；
• NASA: 美国航天局(NASA)大量使用Python进行数据分析和运算；
• YouTube:世界上最大的视频网站YouTube就是用Python开发的；
• Dropbox:美国最大的在线云存储网站，全部用Python实现，每天网站处理10亿个文件的上传和下载；
• Instagram:美国最大的图片分享社交网站，每天超过3千万张照片被分享，全部用python开发；
• Facebook:大量的基础库均通过Python实现的；
• Redhat: 世界上最流行的Linux发行版本中的yum包管理工具就是用python开发的；
• 豆瓣: 公司几乎所有的业务均是通过Python开发的；
• 知乎: 国内最大的问答社区，通过Python开发(国外Quora)；
• 春雨医生：国内知名的在线医疗网站是用Python开发的；
• 除上面之外，还有搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝 、土豆、新浪、果壳等公司都在使用Python完成各种各样的任务；

Python语言类型

编程语言主要可分为以下几类：编译型和解释型、静态语言和动态语言、强类型定义语言和弱类型定义语言：

编译型与解释型。

编译器是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快; 而解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的. 这是因为计算机不能直接认识并执行我们写的语句,它只能认识机器语言(是二进制的形式)。大多数语言都是仅编译（C++:预编译、编译、汇编、链接）或仅解释，JAVA则是先编译成.class文件再进行解释。

编译型
优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。
缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。

解释型
优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。

缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。

动态语言和静态语言
通常我们所说的动态语言、静态语言是指动态类型语言和静态类型语言。

（1）动态类型语言：动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如VBScript也多少属于动态类型语言。

（2）静态类型语言：静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。

强类型定义语言和弱类型定义语言

（1）强类型定义语言：强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。

（2）弱类型定义语言：数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。

强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。另外，“这门语言是不是动态语言”与“这门语言是否类型安全”之间是完全没有联系的！
例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。

通过上面这些介绍，我们可以得出，python是一门动态解释性的强类型定义语言。

Python优缺点

优点：

1. Python的定位是“优雅”、“明确”、“简单”，所以Python程序看上去总是简单易懂，初学者学Python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程序。
2. 开发效率非常高，Python有非常强大的第三方库，基本上你想通过计算机实现任何功能，Python官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上再进行开发，大大降低开发周期，避免重复造轮子。
3. 高级语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节
4. 可移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工 作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所有Python程序无需修改就几乎可以在市场上所有的系统平台上运行
5. 可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。
6. 可嵌入性————你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。

缺点：

1. 速度慢，Python 的运行速度相比C语言确实慢很多，跟JAVA相比也要慢一些，因此这也是很多所谓的大牛不屑于使用Python的主要原因，但其实这里所指的运行速度慢在大多数情况下用户是无法直接感知到的，必须借助测试工具才能体现出来，比如你用C运一个程序花了0.01s,用Python是0.1s,这样C语言直接比Python快了10倍,算是非常夸张了，但是你是无法直接通过肉眼感知的，因为一个正常人所能感知的时间最小单位是0.15-0.4s左右，哈哈。其实在大多数情况下Python已经完全可以满足你对程序速度的要求，除非你要写对速度要求极高的搜索引擎等，这种情况下，当然还是建议你用C去实现的。
2. 代码不能加密，因为PYTHON是解释性语言，它的源码都是以名文形式存放的，不过我不认为这算是一个缺点，如果你的项目要求源代码必须是加密的，那你一开始就不应该用Python来去实现。
3. 线程不能利用多CPU问题，这是Python被人诟病最多的一个缺点，GIL即全局解释器锁（Global Interpreter Lock），是计算机程序设计语言解释器用于同步线程的工具，使得任何时刻仅有一个线程在执行，Python的线程是操作系统的原生线程。在Linux上为pthread，在Windows上为Win thread，完全由操作系统调度线程的执行。一个python解释器进程内有一条主线程，以及多条用户程序的执行线程。即使在多核CPU平台上，由于GIL的存在，所以禁止多线程的并行执行。关于这个问题的折中解决方法，我们在以后线程和进程章节里再进行详细探讨。

由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以编写Python解释器来执行Python代码（当然难度很大）。事实上，确实存在多种Python解释器。

Python解释器种类

CPython

当我们从Python官方网站下载并安装好Python 3.6后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行Python就是启动CPython解释器。

CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。

IPython

IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。

CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。

PyPy

PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。

绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。

Jython

Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

IronPython

IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

小结：

　　Python的解释器很多，但使用最广泛的还是CPython。如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。

Python开发

Python环境搭建

可参看《Python编程：从入门到实践》第一章节；

*注意

在Linux下可使用Ctrl+Alt+T开启一个终端；

Linux下退出Python环境可使用Ctrl+D或者exit()；

在Windows下可使用Win+r开启一个终端或者Shift+右键；

Windows下退出Python环境可使用Ctrl+Z、Ctrl+D或者exit()；

cmd运行python代码

在d盘下创建一个test.py文件内容是：

print('hello world')

打开windows cmd，写入python d:test.py （或者python d: est.py）

回车，您已经运行了第一个python程序， 即：终端---->cmd-----> python  文件路径。

添加Python解释器，运行Python脚本

如果想要类似于执行shell脚本一样执行python脚本，那么就需要在 test.py 文件的头部指定解释器，如下：

#!D:ProgramDataAnaconda3python
# -*- coding:utf-8 -*-
print('hello world')

但是该方式似乎在Windows下行不通，原因是无法修改.py文件为可执行文件，必须先选择执行方式，即：python d:test.py （或者python d: est.py）。

但在Linux下该方式可行，此时需在文件头部添加#!/usr/bin/env python，其中/usr/bin/env 为python解释器所在目录。同时修改py文件为可执行文件chmod 755 test.py，执行方式为./test.py。

Python数据类型

可参看《Python编程：从入门到实践》第二章节或菜鸟教程；

*注意

查看变量类型

type(a)

查看变量内存地址

id(a)

查看变量所占字节大小

import sys

print(sys.getsizeof(a))

数字

十进制整数转换为二进制整数采用"除2取余，逆序排列"法

十进制小数转换成二进制小数采用"乘2取整，顺序排列"法

在定义数字后可发现sys.getsizeof(0)为24，而sys.getsizeof(1)为28，Python数字类型所占字节并不是“4个字节”，其原因为数字在Python中是用C语言指针数组定义的（int 类型在python中是动态长度的。因为python3中int类型是长整型，理论支持无限大的数字，它的结构其实也很简单, 在 longintepr.h 中定义），具体如下：

https://blog.csdn.net/mjl960108/article/details/80191308

bit_length()帮助你快速计算整数在内存中占用的二进制码的长度

num = 10
print(num.bit_length())  # 当十进制用二进制表示时，最少使用的位数
# 运行结果: 4

字符串

字符串切片：

索引切片规则：（索引：索引：步长），切片规则“左闭右开”

字符串常用方法：

#数字符串中的元素出现的个数
a="abcdefghiabc"
r = a.count("a",0,4) # o:索引头 4：索引尾
print(r)
#运行结果为1

a = "dkfjdkfasf54"
#startswith 判断是否以...开头
#endswith 判断是否以...结尾
r = a.endswith('jdk',3,6)  # 顾头不顾腚
print(r)  # 返回的是布尔值
r = a.startswith("kfj",1,4)
print(r)
#运行结果
#True
#True

#split()从左向右寻找，以某个元素为中心将左右分割成两个元素并放入列表中
#rsplit()从右向左寻找，以某个元素为中心将左右分割成两个元素并放入列表中
#splitlines()根据换行符（
）分割并将元素放入列表中

a = "dlrblist"
a1 = a.split("l", 1)
print(a1)
#输出结果：
['d', 'rblist']
#从左向右寻找，以寻找到的第一个"l"为中心将左右分割成两个元素并放入列表中

b = "dlrblist"
b1 = b.rsplit("l", 1)
print(b1)
#输出结果：
['dlrb', 'ist']
#从右向左寻找，以寻找到的第一个"l"为中心将左右分割成两个元素并放入列表中

c = "hello
world
dlrb"
c1 = c.splitlines()
print(c1)
#输出结果：
['hello', 'world', 'dlrb']
#根据换行符切割成了三个元素并放入列表中

字符串格式化有两种方式：百分号方式、format方式。

其中，百分号方式比较老，而format方式是比较先进的，企图替代古老的方式，目前两者共存。

百分号方式：

格式：%[(name)][flags][width].[precision]typecode

• (name)    可选，用于选择指定的key
• flags        可选，可供选择的值有：
  • +　右对齐：正数的加正号，负数的加负号
  • -　左对齐：正数前没有负号，负数前加负号
• width    可选，占有宽度
• .precision    可选，小数点后保留的位数
• typecode     必选
  • s，获取传入的对象__str__方法的返回值，并将其格式化到指定位置
  • r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
  • c，整数：将数字转换成其unicode对应的值，10进制范围为0 <= i <=1114111
  • o，将整数转换成八进制表示，并将其格式化到指定位置
  • x，将整数转换成16进制，并将其格式化到指定位置
  • d，将整数，浮点数转化为十进制表示，并将其格式化到指定位置

>>> s = 'hello, %s!' % 'python'
>>> s
'hello, python!'

>>> s = 'hello, %s, %d!' % ('python', 2018)
>>> s
'hello, python, 2018!'

>>> s = 'hello, %(name)s, %(year)d!' % {'name': 'python', 'year': 2018}
>>> s
'hello, python, 2018!'

>>> s = 'hello, %(name)+10s, %(year)-10d!' % {'name': 'python', 'year': 2018}
>>> s
'hello, python, 2018!'

>>> s = 'hello, %(name)s, %(year).3f!' % {'name': 'python', 'year': 2018}
>>> s
'hello, python, 2018.000!'

%r 与 %s 区别：

%r 用来做 debug 比较好，因为它会显示变量的原始数据（raw data），而其它的符号则是用来向用户显示输出的。

>>> a = 'sunday'
>>> print("Today is %s" % a)
Today is sunday
>>> print("Today is %r" % a)
Today is 'sunday'  # 格式化部分用单引号输出

>>> from datetime import datetime
>>> d = datetime.now()
>>> print('%s' % d)
2018-09-10 08:52:00.769949
>>> print('%r' % d)
datetime.datetime(2018, 9, 10, 8, 52, 0, 769949)  # 可以看见与上面输出存在明显的区别

format方式：

>>> s = 'hello, {}, {}'.format('python', 2018)
>>> s
'hello, python, 2018'

>>> s = 'hello, {0}, {1}, hi, {0}'.format('python', 2018)
>>> s
'hello, python, 2018, hi, python'

>>> s = 'hello, {name}, {year}, hi, {name}'.format(name='python', year=2018)
>>> s
'hello, python, 2018, hi, python'

>>> s = 'hello, {:s}, {:d}, hi, {:f}'.format('python', 2018, 9.7)
>>> s
'hello, python, 2018, hi, 9.700000'

#is系列
name='taibai123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdecimal()) #字符串只由十进制组成

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

*其他常用函数可自行百度

列表

增：

# append 追加，给列表的最后面追加一个元素
l = [1, 2, 'a']
l.append(666)
print(l) # [1, 2, 'a', 666]

# insert  插入在列表的任意位置插入元素
l = [1, 2, 'a']
l.insert(1,'太白')
print(l) # [1, '太白', 2, 'a']

# extend  迭代着追加，在列表的最后面迭代着追加一组数据
l = [1, 2, 'a']
l.extend('太白a')
print(l)

删：

# pop  通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
l = ['太白', 'alex', 'WuSir', '女神']
ret = l.pop(1)
print(ret,l) # alex ['太白', 'WuSir', '女神']

# remove  通过元素删除列表中该元素
l = ['太白', 'alex', 'WuSir', '女神']
l.remove('alex')
print(l) # ['太白', 'WuSir', '女神']

# clear 清空列表
l = ['太白', 'alex', 'WuSir', '女神']
l.clear()
print(l) # []  

# del
#按照索引删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[2]
print(l) # ['太白', 'alex', '女神']

# 切片删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[1:]
print(l) # ['太白']

# 切片(步长)删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[::2]
print(l) # ['alex', '女神']

改：

# 按照索引改值
l = ['太白', 'alex', 'WuSir', '女神']
l[0] = '男神'
print(l) # ['男神', 'alex', 'WuSir', '女神']

# 按照切片改值(迭代着增加)
l = ['太白', 'alex', 'WuSir', '女神']
l[1:3] = 'abcdefg'
print(l) # ['太白', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神'] 

# 按照切片(步长)改值(必须一一对应)
l = ['太白', 'alex', 'WuSir', '女神']
l[::2] = '对应'
print(l) # ['对', 'alex', '应', '女神']

查：

切片查，或循环查

其他操作：

count（数）（方法统计某个元素在列表中出现的次数）。

1 a = ["q","w","q","r","t","y"]
2 print(a.count("q"))

index（方法用于从列表中找出某个值第一个匹配项的索引位置）

1 a = ["q","w","r","t","y"]
2 print(a.index("r"))

sort （方法用于在原位置对列表进行排序）。

 reverse （方法将列表中的元素反向存放）。

1 a = [2,1,3,4,5]
2 a.sort()# 他没有返回值，所以只能打印a
3 print(a)
4 a.reverse()#他也没有返回值，所以只能打印a
5 print(a)

列表也可以相加与整数相乘

l1 = [1, 2, 3]
l2 = [4, 5, 6]
# print(l1+l2)  # [1, 2, 3, 4, 5, 6]
print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

l1 = [1, 2, 3]
l2 = [4, 5, 6]
# print(l1+l2)  # [1, 2, 3, 4, 5, 6]
print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

Python直接赋值、切片、浅拷贝、深拷贝区别

import copy
names1=['Amir','Barry','Cgakes','Dao',[11,22,33]]
names2=names1#直接赋值，指向同一个对象
names3=names1[:]#切片生成一个新的对象
names4=copy.copy(names1)#浅拷贝，拷贝父对象，和切片效果一样
names5=copy.deepcopy(names1)#深拷贝，拷贝父对象和子对象
print(names1)
print(names2)
print(names3)
print(names4)
print(names5)
names1[0]='fuck'
names1[-1][0]=44
print(names1)
print(names2)
print(names3)
print(names4)
print(names5)

['Amir', 'Barry', 'Cgakes', 'Dao', [11, 22, 33]]
['Amir', 'Barry', 'Cgakes', 'Dao', [11, 22, 33]]
['Amir', 'Barry', 'Cgakes', 'Dao', [11, 22, 33]]
['Amir', 'Barry', 'Cgakes', 'Dao', [11, 22, 33]]
['Amir', 'Barry', 'Cgakes', 'Dao', [11, 22, 33]]
['fuck', 'Barry', 'Cgakes', 'Dao', [44, 22, 33]]
['fuck', 'Barry', 'Cgakes', 'Dao', [44, 22, 33]]#父对象和子对象都是指向同一个内存地址
['Amir', 'Barry', 'Cgakes', 'Dao', [44, 22, 33]]#父对象是独立的，子对象还是指向同一个内存地址
['Amir', 'Barry', 'Cgakes', 'Dao', [44, 22, 33]]#父对象是独立的，子对象还是指向同一个内存地址
['Amir', 'Barry', 'Cgakes', 'Dao', [11, 22, 33]]#父对象和子对象都是独立的

字典

数据类型可以按照不同的角度进行分类，先给大家按照可变与不可变的数据类型的分类：

    不可变（可哈希）的数据类型：int，str，bool，tuple。

    可变（不可哈希）的数据类型：list，dict，set。

字典是Python语言中的映射类型，他是以{}括起来，里面的内容是以键值对的形式储存的：

    Key: 不可变（可哈希）的数据类型.并且键是唯一的，不重复的。

    Value:任意数据(int，str，bool，tuple，list，dict，set)，包括后面要学的实例对象等。

　在Python3.5版本（包括此版本）之前，字典是无序的。

　在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。

创建字典的几种方式

# 创建字典的几种方式：

# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic)  # {'one': 1, 'two': 2, 'three': 3}


# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic)  # {'one': 1, 'two': 2, 'three': 3}


# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式5: 
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)

# 方式6: 字典推导式
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)

# 方式7:利用fromkey
# dic = dict.fromkeys('abcd','太白')
# print(dic)  # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}

增：

# 通过键值对直接增加
dic = {'name': '太白', 'age': 18}
dic['weight'] = 75 # 没有weight这个键，就增加键值对
print(dic) # {'name': '太白', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name这个键，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}

# setdefault
dic = {'name': '太白', 'age': 18}
dic.setdefault('height',175) # 没有height此键，则添加
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
dic.setdefault('name','barry') # 有此键则不变
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
#setdefault有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.setdefault('name')
print(ret)  # 太白

删：

# pop 通过key删除字典的键值对，有返回值，可设置返回值。
dic = {'name': '太白', 'age': 18}
# ret = dic.pop('name')
# print(ret,dic) # 太白 {'age': 18}
ret1 = dic.pop('n',None)
print(ret1,dic) # None {'name': '太白', 'age': 18}

#popitem 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.popitem()
print(ret,dic) # ('age', 18) {'name': '太白'}

#clear 清空字典
dic = {'name': '太白', 'age': 18}
dic.clear()
print(dic) # {}

# del
# 通过键删除键值对
dic = {'name': '太白', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
#删除整个字典
del dic

改：

# 通过键值对直接改
dic = {'name': '太白', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}

# update
dic = {'name': '太白', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}

dic = {'name': '太白', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}

dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75} 

查：

# 通过键查询
# 直接dic[key](没有此键会报错)
dic = {'name': '太白', 'age': 18}
print(dic['name']) # 太白

# get
dic = {'name': '太白', 'age': 18}
v = dic.get('name')
print(v) # '太白'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','没有此键')
print(v) # 没有此键 


keys()
dic = {'name': '太白', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age']) 

values()
dic = {'name': '太白', 'age': 18}
print(dic.values()) # dict_values(['太白', 18])

items()
dic = {'name': '太白', 'age': 18}
print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])

本博客主要引用文章如下：

作者：太白金星
链接：https://www.cnblogs.com/jin-xin/articles/7459977.html
来源：博客园

作者：呵呵python
链接：https://www.cnblogs.com/yyyyyyyyyy/p/8580824.html
来源：博客园

作者：快乐糖果屋
链接：https://www.cnblogs.com/meng-wei-zhi/articles/8194849.html
来源：博客园

作者：shawnMMM
链接：https://blog.csdn.net/mjl960108/article/details/80191308
来源：CSDN

作者：寒爵
链接：https://www.cnblogs.com/Jimc/p/9606112.html
来源：博客园

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。