首页  思维导图  详情

Python

2019-12-31 09:48:38   2  举报





AI智能生成

Python

作者其他创作

大纲/内容

单词

打印

Defined(define)

定义

synataxError

语法错误

NameErrror

名字错误

Invalid

无效的

Character

字符

python安装的目录

DLLs

库文件

Doc

文档

include

包含所对应的一些依赖

Lib

(图书馆)库,内置库,系统自带的

libs

本身解释器运行需要的一些东西

Scripts

pip

包管理器

tcl

Tools

解释器python.exe+Lib(内置库)+pip(包管理器:pip.exe)

转义符

换行符:linux:"\n" windows:"\r\n" mac:"\r" python:"\n"

制表符:python:"\t"

转义符:python:"\"

原义符"python:r" " #raw原始字符串

反斜杠转义字符表:

\(在行尾时) 续行符

\\ 反斜杠符号

\' 单引号

\" 双引号

\a 响铃

\b 退格(Backspace)

\e 转义

\000 空

\0 空字符,字符值为零

\n 换行

\v 纵向制表符

\t 横向制表符

\r 返回光标至行首

\f 换页

\oyy 八进制数，yy代表的字符，例如：\o12代表换行

\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行

\xXX XX为两个十六进制表示的字符

\uXXXX XXXX为四个十六进制表示的Unicode16字符

\UXXXXXXXX 8个十六进制表示的Unicode32字符

\other 其它的字符以普通格式输出

其他

pass 语句

填充语法空白

系统位数取值范围

32位 2**31-1

64位 2**63-1

缩进区分代码块官方规定四个空格

python基础初识。

1. 运行python代码。

在d盘下创建一个t1.py文件内容是：
print('hello world')
打开windows命令行输入cmd，确定后写入代码python d:t1.py
您已经运行了第一个python程序，即：终端---->cmd-----> python 文件路径。回车搞定~

2. 解释器

上一步中执行 python d:t1.py 时，明确的指出 t1.py 脚本由 python 解释器来执行。
如果想要类似于执行shell脚本一样执行python脚本，例： ./t1.py ，那么就需要在 hello.py 文件的头部指定解释器，如下：
#!/usr/bin/env python
print "hello,world"
如此一来，执行： ./t1.py 即可。
ps：执行前需给予t1.py 执行权限，chmod 755 t1.py

3. 注释。

当行注释：# 被注释内容
多行注释：'''被注释内容'''，或者"""被注释内容"""

4. 变量

变量是什么？变量：把程序运行的中间结果临时的存在内存里，以便后续的代码调用。
4.1、声明变量
lux = '鲁迅本人'
上述代码声明了一个变量，变量名为： lux，变量name的值为："鲁迅本人"
变量的作用：昵称，其代指内存里某个地址中保存的内容
4.2、变量定义的规则：
变量名只能是字母、数字或下划线的任意组合
变量名的第一个字符不能是数字
以下关键字不能声明为变量名
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
变量的定义要具有可描述性。
4.3、推荐定义方式
#驼峰体
AgeOfOldboy = 56
NumberOfStudents = 80
#下划线
age_of_oldboy = 56
number_of_students = 80
你觉得哪种更清晰，哪种就是官方推荐的，我想你肯定会先第2种,第一种AgeOfOldboy咋一看以为是AngelaBaby
4.4、变量的赋值
lux = '鲁迅本人'、
name = '太白金星'
name1 = '太白金星'
name2 = name1
name3 = name2
4.5、定义变量不好的方式举例
变量名为中文、拼音
变量名过长
变量名词不达意

5. 常量

常量即指不变的量，如pai 3.141592653..., 或在程序运行过程中不会改变的量

举例，假如老男孩老师的年龄会变，那这就是个变量，但在一些情况下，他的年龄不会变了，那就是常量。在Python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写代表常量

AGE_OF_OLDBOY = 56

在c语言中有专门的常量定义语法，const int count = 60;一旦定义为常量，更改即会报错

6. 基础数据类型（初始）。

什么是数据类型？
　　我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，今天我们暂只讲3种，数字、字符串、布尔类型

6.1、整数类型（int）。

int（整型）

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

6.2、字符串类型（str）。

在Python中,加了引号的字符都被认为是字符串！
>>> name = "Alex Li" #双引号

>>> age = "22" #只要加引号就是字符串

>>> age2 = 22 #int

>>>

>>> msg = '''My name is taibai, I am 22 years old!''' #我擦，3个引号也可以

>>>

>>> hometown = 'ShanDong' #单引号也可以

那单引号、双引号、多引号有什么区别呢？让我大声告诉你，单双引号木有任何区别，只有下面这种情况你需要考虑单双的配合

msg = "My name is Alex , I'm 22 years old!"

多引号什么作用呢？作用就是多行字符串必须用多引号

msg = '''

今天我想写首小诗，

歌颂我的同桌，

你看他那乌黑的短发，

好像一只炸毛鸡。

'''

print(msg)

字符串拼接

数字可以进行加减乘除等运算，字符串呢？让我大声告诉你，也能？what ?是的，但只能进行"相加"和"相乘"运算。

>>> name

'Alex Li'

>>> age

'22'

>>>

>>> name + age #相加其实就是简单拼接

'Alex Li22'

>>>

>>> name * 10 #相乘其实就是复制自己多少次，再拼接在一起

'Alex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex Li'

注意，字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接

>>> type(name),type(age2)

(<type 'str'>, <type 'int'>)

>>>

>>> name

'Alex Li'

>>> age2

22

>>> name + age2

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: cannot concatenate 'str' and 'int' objects #错误提示数字和字符不能拼接

6.3、布尔值（True，False）。

布尔类型很简单，就两个值，一个True(真)，一个False(假), 主要用记逻辑判断

但其实你们并不明白对么？ let me explain, 我现在有2个值， a=3, b=5 , 我说a>b你说成立么? 我们当然知道不成立，但问题是计算机怎么去描述这成不成立呢？或者说a< b是成立，计算机怎么描述这是成立呢？

没错，答案就是，用布尔类型

>>> a=3

>>> b=5

>>>

>>> a > b #不成立就是False,即假

False

>>>

>>> a < b #成立就是True, 即真

True

7. 程序交互

#!/usr/bin/env python

# -*- coding: utf-8 -*-

# 将用户输入的内容赋值给 name 变量

name = input("请输入用户名：")

# 打印输入的内容

print(name)

执行脚本就会发现，程序会等待你输入姓名后再往下继续走。

可以让用户输入多个信息，如下

#!/usr/bin/env python

# -*- coding: utf-8 -*-

name = input("What is your name?")

age = input("How old are you?")

hometown = input("Where is your hometown?")

print("Hello ",name , "your are ", age , "years old, you came from",hometown)

8. 流程控制之--if。

　　假如把写程序比做走路，那我们到现在为止，一直走的都是直路，还没遇到过分叉口，想象现实中，你遇到了分叉口，然后你决定往哪拐必然是有所动机的。你要判断那条岔路是你真正要走的路，如果我们想让程序也能处理这样的判断怎么办？很简单，只需要在程序里预设一些条件判断语句，满足哪个条件，就走哪条岔路。这个过程就叫流程控制。
if...else 语句
单分支
if 条件:
满足条件后要执行的代码
双分支
"""
if 条件:
满足条件执行代码
else:
if条件不满足就走这段
"""
AgeOfOldboy = 48
if AgeOfOldboy > 50 :
print("Too old, time to retire..")
else:
print("还能折腾几年!")
缩进
这里必须要插入这个缩进的知识点

你会发现，上面的if代码里，每个条件的下一行都缩进了4个空格，这是为什么呢？这就是Python的一大特色，强制缩进，目的是为了让程序知道，每段代码依赖哪个条件，如果不通过缩进来区分，程序怎么会知道，当你的条件成立后，去执行哪些代码呢？

在其它的语言里，大多通过{}来确定代码块，比如C,C++,Java,Javascript都是这样，看一个JavaScript代码的例子
var age = 56
if ( age < 50){
console.log("还能折腾")
console.log('可以执行多行代码')
}else{
console.log('太老了')
}
在有{}来区分代码块的情况下，缩进的作用就只剩下让代码变的整洁了。

Python是门超级简洁的语言，发明者定是觉得用{}太丑了，所以索性直接不用它，那怎么能区分代码块呢？答案就是强制缩进。

Python的缩进有以下几个原则:
顶级代码必须顶行写，即如果一行代码本身不依赖于任何条件，那它必须不能进行任何缩进
同一级别的代码，缩进必须一致
官方建议缩进用4个空格，当然你也可以用2个，如果你想被人笑话的话。
多分支
回到流程控制上来，if...else ...可以有多个分支条件
if 条件:
满足条件执行代码
elif 条件:
上面的条件不满足就走这个
elif 条件:
上面的条件不满足就走这个
elif 条件:
上面的条件不满足就走这个
else:
上面所有的条件不满足就走这段

写个猜年龄的游戏吧
age_of_oldboy = 48
guess = int(input(">>:"))
if guess > age_of_oldboy :
print("猜的太大了，往小里试试...")
elif guess < age_of_oldboy :
print("猜的太小了，往大里试试...")
else:
print("恭喜你，猜对了...")
上面的例子，根据你输入的值不同，会最多得到3种不同的结果

再来个匹配成绩的小程序吧，成绩有ABCDE5个等级，与分数的对应关系如下
A 90-100
B 80-89
C 60-79
D 40-59
E 0-39
要求用户输入0-100的数字后，你能正确打印他的对应成绩
score = int(input("输入分数:"))
if score > 100:
print("我擦，最高分才100...")
elif score >= 90:
print("A")
elif score >= 80:
print("B")
elif score >= 60:
print("C")
elif score >= 40:
print("D")
else:
print("太笨了...E")
这里有个问题，就是当我输入95的时候，它打印的结果是A,但是95 明明也大于第二个条件elif score >=80:呀, 为什么不打印B呢？这是因为代码是从上到下依次判断，只要满足一个，就不会再往下走啦，这一点一定要清楚呀！

什么是表达式？

1+2*3 就是一个表达式，这里的加号和乘号叫做运算符，1、2、3叫做操作数。1+2*3 经过计算

后得到的结果是7，就1+2*3 = 7。我们可以将计算结果保存在一个变量里，ret = 1-2*3 。所

以表达式就是由操作数和运算符组成的一句代码或语句，表达式可以求值，可以放在“=”的右边，

用来给变量赋值。

a = 1+2*3 # 这是语句,其中1+2*3是表达式

python环境

windows下安装Python（自动添加环境变量）以3,.5版本的举例：
1. 官网下载：https://www.python.org/downloads/windows/
2. 选择版本。
3. 自动添加环境变量。
4. 更改完成。
5. 点击安装即可。
linux：
无需安装，原装Python环境
ps：如果自带2.6，请更新至2.7

Python介绍

1. python的出生与应用

python的创始人为吉多·范罗苏姆（Guido van Rossum）。1989年的圣诞节期间，吉多·范罗苏姆（中文名字：龟叔）为了在阿姆斯特丹打发时间，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。
（龟叔：2005年加入谷歌至2012年，2013年加入Dropbox直到现在，依然掌握着Python发展的核心方向，被称为仁慈的独裁者）。
2017年7月的TIOBE排行榜，Python已经占据第四的位置， Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。
由上图可见，Python整体呈上升趋势，反映出Python应用越来越广泛并且也逐渐得到业内的认可！！！
Python可以应用于众多领域，如：数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等众多领域。目前业内几乎所有大中型互联网企业都在使用Python，如：Youtube、Dropbox、BT、Quora（中国知乎）、豆瓣、知乎、Google、Yahoo!、Facebook、NASA、百度、腾讯、汽车之家、美团等。

目前Python主要应用领域：

云计算: 云计算最火的语言，典型应用OpenStack

WEB开发: 众多优秀的WEB框架，众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣。。。，典型WEB框架有Django

科学运算、人工智能: 典型库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发展史

1989年，为了打发圣诞节假期，Guido开始写Python语言的编译器。Python这个名字，来自Guido所挚爱的电视剧Monty Python’s Flying Circus。他希望这个新的叫做Python的语言，能符合他的理想：创造一种C和shell之间，功能全面，易学易用，可拓展的语言。

1991年，第一个Python编译器诞生。它是用C语言实现的，并能够调用C语言的库文件。从一出生，Python已经具有了：类，函数，异常处理，包含表和词典在内的核心数据类型，以及模块为基础的拓展系统。

Granddaddy of Python web frameworks, Zope 1 was released in 1999

Python 1.0 - January 1994 增加了 lambda, map, filter and reduce.

Python 2.0 - October 16, 2000，加入了内存回收机制，构成了现在Python语言框架的基础

Python 2.4 - November 30, 2004, 同年目前最流行的WEB框架Django 诞生

Python 2.5 - September 19, 2006

Python 2.6 - October 1, 2008

Python 2.7 - July 3, 2010

In November 2014, it was announced that Python 2.7 would be supported until 2020, and reaffirmed that there would be no 2.8 release as users were expected to move to Python 3.4+ as soon as possible

Python 3.0 - December 3, 2008

Python 3.1 - June 27, 2009

Python 3.2 - February 20, 2011

Python 3.3 - September 29, 2012

Python 3.4 - March 16, 2014

Python 3.5 - September 13, 2015

Python 3.6 - December 16,2016

2. python是什么编程语言。

编程语言主要从以下几个角度为进行分类，编译型和解释型、静态语言和动态语言、强类型定义语言和弱类型定义语言，每个分类代表什么意思呢，我们一起来看一下。

2.1 编译型与解释型。

编译器是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快;

而解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的.

这是因为计算机不能直接认识并执行我们写的语句,它只能认识机器语言(是二进制的形式)

编译型

优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。

缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。

解释型

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

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

2.2动态语言和静态语言

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

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

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

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

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

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

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

例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。

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

3. python的优缺点。

先看优点

Python的定位是“优雅”、“明确”、“简单”，所以Python程序看上去总是简单易懂，初学者学Python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程序。

开发效率非常高，Python有非常强大的第三方库，基本上你想通过计算机实现任何功能，Python官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上再进行开发，大大降低开发周期，避免重复造轮子。

高级语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节

可移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所有Python程序无需修改就几乎可以在市场上所有的系统平台上运行

可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。

可嵌入性————你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。

再看缺点：

速度慢，Python 的运行速度相比C语言确实慢很多，跟JAVA相比也要慢一些，因此这也是很多所谓的大牛不屑于使用Python的主要原因，但其实这里所指的运行速度慢在大多数情况下用户是无法直接感知到的，必须借助测试工具才能体现出来，比如你用C运一个程序花了0.01s,用Python是0.1s,这样C语言直接比Python快了10倍,算是非常夸张了，但是你是无法直接通过肉眼感知的，因为一个正常人所能感知的时间最小单位是0.15-0.4s左右，哈哈。其实在大多数情况下Python已经完全可以满足你对程序速度的要求，除非你要写对速度要求极高的搜索引擎等，这种情况下，当然还是建议你用C去实现的。

代码不能加密，因为PYTHON是解释性语言，它的源码都是以名文形式存放的，不过我不认为这算是一个缺点，如果你的项目要求源代码必须是加密的，那你一开始就不应该用Python来去实现。

线程不能利用多CPU问题，这是Python被人诟病最多的一个缺点，GIL即全局解释器锁（Global Interpreter Lock），是计算机程序设计语言解释器用于同步线程的工具，使得任何时刻仅有一个线程在执行，Python的线程是操作系统的原生线程。在Linux上为pthread，在Windows上为Win thread，完全由操作系统调度线程的执行。一个python解释器进程内有一条主线程，以及多条用户程序的执行线程。即使在多核CPU平台上，由于GIL的存在，所以禁止多线程的并行执行。关于这个问题的折衷解决方法，我们在以后线程和进程章节里再进行详细探讨。

当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。

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

4. 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，而是通过网络调用来交互，确保各程序之间的独立性。

变量

变量是为了存储程序运行中的一些结果,方便日后调用

变量的命名规则

见明知义

1. 要具有描述性

2. 变量名只能_,数字，字母组成，不可以是空格或特殊字符(#?<.，￥$*!~)

3. 不能以中文为变量名

4. 不能以数字开头

5. 保留字符是不能被使用,列如(import keyword；print(keyword.kwlist))

6. 驼峰式命名,下划线连接单词

7. 严格区分大小写

变量：声明变量实际上就是给内存空间

变量能存放类型：字符串，整型，浮点数，布尔类型，列表list，字典dict set列表

常量

在py里面所有的量都是可变的 ,所以用全部大写的变量名来代表此变量为常量

常量：不变的量命名时，名字是大写的例如:NAME="JACK" pie=3.141592653....

格式化输出

%s 输出字符串

'%s' %('hello')

%d 输出数字

'%d' %(10)

浮点数

原形毕露

流程控制之--if

if....else

if... elif..else

条件表达式:

a = -n if n<0 else n #如果n小于0,a=-n,否则a=n

流程控制之--while循环

break。终止循环

continue（终止本次循环）。

quit(),exit()
也是终止循环,但是调用的是系统的命令,不建议使用

while...else

while 后面的else 作用是指，当while 循环正常执行完，中间没有被break 中止的话，就会执行else后面的语句

运算符

算数运算符:+加,-减,*乘,/除,//整除(地板除),%取余,**幂运算

赋值运算符:=,+=,-=,*=,/=,//=,**=,%=

比较运算符:<,>,<=,>=,!=不等,==等于

逻辑运算符:not,and,or

成员运算符： not in 、in （判断某个单词里是不是有某个字母）

身份运算符： is、is not

优先级:

运算符描述

** 指数 (最高优先级)

~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

* / % // 乘，除，取模和取整除

+ - 加法减法

>> << 右移，左移运算符

& 位 'AND'

^ | 位运算符

<= < > >= 比较运算符

<> == != 等于运算符

= %= /= //= -= += *= **= 赋值运算符

is is not 身份运算符

in not in 成员运算符

not and or 逻辑运算符

一元(一目)运算符: 只有一个条件的例如: not a<b, not True, not False

二元(二目)运算符: 有两个操作数(条件)的例如:1+2, A and B, A or B

三元(三目)运算: 只针对简单的if..else这样的结果才可以使用.

x if x > y else y 条件成立返回x,不成立返回y

x or y if x is Ture ,return x

x and y if x is Ture and y is Ture,return y

Python的学习交流QQ群:1003571914

编码

ASCII码：包含英文字母，数字，特殊字符与01010101对应关系。

在计算机中，所有的数据在存储和运算时都要使用二进制数表示（因为计算机用高电平和低电平分别表示1和0），例如，像a、b、c、d这样的52个字母（包括大写）以及0、1等数字还有一些常用的符号（例如*、#、@等）在计算机中存储时也要使用二进制数来表示，而具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码），而大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，于是美国有关的标准化组织就出台了ASCII编码，统一规定了上述常用符号用哪些二进制数来表示。 [2]

美国标准信息交换代码是由美国国家标准学会(American National Standard Institute , ANSI )制定的，标准的单字节字符编码方案，用于基于文本的数据。起始于50年代后期，在1967年定案。它最初是美国国家标准，供不同计算机在相互通信时用作共同遵守的西文字符编码标准，它已被国际标准化组织（International Organization for Standardization, ISO）定为国际标准，称为ISO 646标准。适用于所有拉丁文字字母。

Bin(二进制)

Oct(八进制)

Dec(十进制)

Hex(十六进制)

缩写/字符

解释

0000 0000

0

0

00

NUL(null)

空字符

0000 0001

1

1

01

SOH(start of headline)

标题开始

0000 0010

2

2

02

STX (start of text)

正文开始

0000 0011

3

3

03

ETX (end of text)

正文结束

0000 0100

4

4

04

EOT (end of transmission)

传输结束

0000 0101

5

5

05

ENQ (enquiry)

请求

0000 0110

6

6

06

ACK (acknowledge)

收到通知

0000 0111

7

7

07

BEL (bell)

响铃

0000 1000

10

8

08

BS (backspace)

退格

0000 1001

11

9

09

HT (horizontal tab)

水平制表符

0000 1010

12

10

0A

LF (NL line feed, new line)

换行键

0000 1011

13

11

0B

VT (vertical tab)

垂直制表符

0000 1100

14

12

0C

FF (NP form feed, new page)

换页键

0000 1101

15

13

0D

CR (carriage return)

回车键

0000 1110

16

14

0E

SO (shift out)

不用切换

0000 1111

17

15

0F

SI (shift in)

启用切换

0001 0000

20

16

10

DLE (data link escape)

数据链路转义

0001 0001

21

17

11

DC1 (device control 1)

设备控制1

0001 0010

22

18

12

DC2 (device control 2)

设备控制2

0001 0011

23

19

13

DC3 (device control 3)

设备控制3

0001 0100

24

20

14

DC4 (device control 4)

设备控制4

0001 0101

25

21

15

NAK (negative acknowledge)

拒绝接收

0001 0110

26

22

16

SYN (synchronous idle)

同步空闲

0001 0111

27

23

17

ETB (end of trans. block)

结束传输块

0001 1000

30

24

18

CAN (cancel)

取消

0001 1001

31

25

19

EM (end of medium)

媒介结束

0001 1010

32

26

1A

SUB (substitute)

代替

0001 1011

33

27

1B

ESC (escape)

换码(溢出)

0001 1100

34

28

1C

FS (file separator)

文件分隔符

0001 1101

35

29

1D

GS (group separator)

分组符

0001 1110

36

30

1E

RS (record separator)

记录分隔符

0001 1111

37

31

1F

US (unit separator)

单元分隔符

0010 0000

40

32

20

(space)

空格

0010 0001

41

33

21

!

叹号

0010 0010

42

34

22

"

双引号

0010 0011

43

35

23

#

井号

0010 0100

44

36

24

$

美元符

0010 0101

45

37

25

%

百分号

0010 0110

46

38

26

&

和号

0010 0111

47

39

27

'

闭单引号

0010 1000

50

40

28

(

开括号

0010 1001

51

41

29

)

闭括号

0010 1010

52

42

2A

*

星号

0010 1011

53

43

2B

+

加号

0010 1100

54

44

2C

,

逗号

0010 1101

55

45

2D

-

减号/破折号

0010 1110

56

46

2E

.

句号

00101111

57

47

2F

/

斜杠

00110000

60

48

30

0

数字0

00110001

61

49

31

1

数字1

00110010

62

50

32

2

数字2

00110011

63

51

33

3

数字3

00110100

64

52

34

4

数字4

00110101

65

53

35

5

数字5

00110110

66

54

36

6

数字6

00110111

67

55

37

7

数字7

00111000

70

56

38

8

数字8

00111001

71

57

39

9

数字9

00111010

72

58

3A

:

冒号

00111011

73

59

3B

;

分号

00111100

74

60

3C

<

小于

00111101

75

61

3D

=

等号

00111110

76

62

3E

>

大于

00111111

77

63

3F

?

问号

01000000

100

64

40

@

电子邮件符号

01000001

101

65

41

A

大写字母A　

01000010

102

66

42

B

大写字母B

01000011

103

67

43

C

大写字母C

01000100

104

68

44

D

大写字母D

01000101

105

69

45

E

大写字母E

01000110

106

70

46

F

大写字母F

01000111

107

71

47

G

大写字母G

01001000

110

72

48

H

大写字母H

01001001

111

73

49

I

大写字母I

01001010

112

74

4A

J

大写字母J

01001011

113

75

4B

K

大写字母K

01001100

114

76

4C

L

大写字母L

01001101

115

77

4D

M

大写字母M

01001110

116

78

4E

N

大写字母N

01001111

117

79

4F

O

大写字母O

01010000

120

80

50

P

大写字母P

01010001

121

81

51

Q

大写字母Q

01010010

122

82

52

R

大写字母R

01010011

123

83

53

S

大写字母S

01010100

124

84

54

T

大写字母T

01010101

125

85

55

U

大写字母U

01010110

126

86

56

V

大写字母V

01010111

127

87

57

W

大写字母W

01011000

130

88

58

X

大写字母X

01011001

131

89

59

Y

大写字母Y

01011010

132

90

5A

Z

大写字母Z

01011011

133

91

5B

[

开方括号

01011100

134

92

5C

\

反斜杠

01011101

135

93

5D

]

闭方括号

01011110

136

94

5E

^

脱字符

01011111

137

95

5F

_

下划线

01100000

140

96

60

`

开单引号

01100001

141

97

61

a

小写字母a　

01100010

142

98

62

b

小写字母b

01100011

143

99

63

c

小写字母c

01100100

144

100

64

d

小写字母d

01100101

145

101

65

e

小写字母e

01100110

146

102

66

f

小写字母f

01100111

147

103

67

g

小写字母g

01101000

150

104

68

h

小写字母h

01101001

151

105

69

i

小写字母i

01101010

152

106

6A

j

小写字母j

01101011

153

107

6B

k

小写字母k

01101100

154

108

6C

l

小写字母l

01101101

155

109

6D

m

小写字母m

01101110

156

110

6E

n

小写字母n

01101111

157

111

6F

o

小写字母o

01110000

160

112

70

p

小写字母p

01110001

161

113

71

q

小写字母q

01110010

162

114

72

r

小写字母r

01110011

163

115

73

s

小写字母s

01110100

164

116

74

t

小写字母t

01110101

165

117

75

u

小写字母u

01110110

166

118

76

v

小写字母v

01110111

167

119

77

w

小写字母w

01111000

170

120

78

x

小写字母x

01111001

171

121

79

y

小写字母y

01111010

172

122

7A

z

小写字母z

01111011

173

123

7B

{

开花括号

01111100

174

124

7C

|

垂线

01111101

175

125

7D

}

闭花括号

01111110

176

126

7E

~

波浪号

01111111

177

127

7F

DEL (delete)

GBK：只包含本国文字（以及英文字母，数字，特殊字符）与0101010对应关系。

GBK全称《汉字内码扩展规范》（GBK即“国标”、“扩展”汉语拼音的第一个字母，英文名称：Chinese Internal Code Specification），中华人民共和国全国信息技术标准化技术委员会1995年12月1日制订，国家技术监督局标准化司、电子工业部科技与质量监督司1995年12月15日联合以技监标函1995 229号文件的形式，将它确定为技术规范指导性文件。这一版的GBK规范为1.0版。

GBK 向下与 GB 2312 编码兼容，向上支持 ISO 10646.1国际标准，是前者向后者过渡过程中的一个承上启下的产物。ISO 10646 是国际标准化组织 ISO 公布的一个编码标准，即 Universal Multilpe-Octet Coded Character Set（简称UCS），大陆译为《通用多八位编码字符集》，台湾译为《广用多八位元编码字元集》，它与 Unicode 组织的 Unicode 编码完全兼容。ISO 10646.1 是该标准的第一部分《体系结构与基本多文种平面》。我国 1993 年以 GB 13000.1 国家标准的形式予以认可（即 GB 13000.1 等同于 ISO 10646.1）。

GBK编码，是在GB2312-80标准基础上的内码扩展规范，使用了双字节编码方案，其编码范围从8140至FEFE（剔除xx7F），共23940个码位，共收录了21003个汉字，完全兼容GB2312-80标准，支持国际标准ISO/IEC10646-1和国家标准GB13000-1中的全部中日韩汉字，并包含了BIG5编码中的所有汉字。GBK编码方案于1995年10月制定， 1995年12月正式发布，目前中文版的WIN95、WIN98、WINDOWS NT以及WINDOWS 2000、WINDOWS XP、WIN 7等都支持GBK编码方案。

知识链接：

我们经常使用各种编码标准的汉字，编码到底是什么呢？所谓编码，是以固定的顺序排列字符，并以此做为记录、存贮、传递、交换的统一内部特征，这个字符排列顺序被称为“编码”。和中文字库有关的编码标准有：国标GB码、GBK码、港台BIG-5码等，不同编码的汉字字库都与汉字的应用有密切关系。

很多人在使用过程中，发现字不够用，因为目前大家使用的主要是GB编码字库，此编码标准只收录了6763个常用汉字，而GB字库以外大量汉字，只能通过方正女娲补字软件拼字或其它造字程序补字。尽管补出的汉字在字形上满足需要，但在字体风格、大小、结构方面难以协调统一，而采用手工贴图的方式补字，更不雅观。进而言之，如果用户建立信息系统，或需要查询新闻、出版内容时，靠补字是无法实现的。方正开发的GBK字库，将极大地缓解缺字现象。

从GB字库扩充到GBK字库，增加了1万4千多字。北大方正从1996年投入大量人力，开始做黑、宋、仿、楷GBK字库，并于1998年4月成为第一家通过国家权威部门组织的GBK字库鉴定的专业厂商。到现在为止，北大方正已将全部字体转换成GBK字库，共46款，其中18款字数达21003个，是拥有GBK字库款数最多的厂商。

ISO 10646 是一个包括世界上各种语言的书面形式以及附加符号的编码体系。其中的汉字部分称为“CJK 统一汉字”（C 指中国，J 指日本，K 指朝鲜）。而其中的中国部分，包括了源自中国大陆的 GB 2312、GB 12345、《现代汉语通用字表》等法定标准的汉字和符号，以及源自台湾的 CNS 11643 标准中第 1、2 字面（基本等同于 BIG-5 编码）、第 14 字面的汉字和符号。

经实际测试和查阅文档，GBK是采用单双字节变长编码，英文使用单字节编码，完全兼容ASCII字符编码，中文部分采用双字节编码。

Unicode：包含全世界所有的文字与二进制0101001的对应关系。

Unicode（统一码、万国码、单一码）是计算机科学领域里的一项业界标准，包括字符集、编码方案等。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。1990年开始研发，1994年正式公布。

因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），0 - 255被用来表示大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码，比如大写字母A的编码是65，小写字母z的编码是122。

如果要表示中文，显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。

类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。

Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为0就可以。

因为Python的诞生比Unicode标准发布的时间还要早，所以最早的Python只支持ASCII编码，普通的字符串'ABC'在Python内部都是ASCII编码的。

Unicode 是为了解决传统的字符编码方案的局限而产生的，例如ISO 8859所定义的字符虽然在不同的国家中广泛地使用，可是在不同国家间却经常出现不兼容的情况。很多传统的编码方式都有一个共同的问题，即容许电脑处理双语环境（通常使用拉丁字母以及其本地语言），但却无法同时支持多语言环境（指可同时处理多种语言混合的情况）。

Unicode 编码包含了不同写法的字，如“ɑ/a”、“户/户/戸”。然而在汉字方面引起了一字多形的认定争议。

在文字处理方面，统一码为每一个字符而非字形定义唯一的代码（即一个整数）。换句话说，统一码以一种抽象的方式（即数字）来处理字符，并将视觉上的演绎工作（例如字体大小、外观形状、字体形态、文体等）留给其他软件来处理，例如网页浏览器或是文字处理器。

几乎所有电脑系统都支持基本拉丁字母，并各自支持不同的其他编码方式。Unicode为了和它们相互兼容，其首256字符保留给ISO 8859-1所定义的字符，使既有的西欧语系文字的转换不需特别考量；并且把大量相同的字符重复编到不同的字符码中去，使得旧有纷杂的编码方式得以和Unicode编码间互相直接转换，而不会丢失任何信息。举例来说，全角格式区段包含了主要的拉丁字母的全角格式，在中文、日文、以及韩文字形当中，这些字符以全角的方式来呈现，而不以常见的半角形式显示，这对竖排文字和等宽排列文字有重要作用。

在表示一个Unicode的字符时，通常会用“U+”然后紧接着一组十六进制的数字来表示这一个字符。在基本多文种平面（英文为 Basic Multilingual Plane，简写 BMP。它又简称为“零号平面”, plane 0）里的所有字符，要用四位十六进制数（例如U+4AE0，共支持六万多个字符）；在零号平面以外的字符则需要使用五位或六位十六进制数了。旧版的Unicode标准使用相近的标记方法，但却有些微的差异：在Unicode 3.0里使用“U-”然后紧接着八位数，而“U+”则必须随后紧接着四位数。

起初：Unicode规定一个字符用两个字节表示：

　　英文: a b c 六个字节一个英文2个字节

　　中文中国四个字节一个中文用2个字节

UTF-8:包含全世界所有的文字与二进制0101001的对应关系（最少用8位一个字节表示一个字符）。

UTF-8（8-bit Unicode Transformation Format）是一种针对Unicode的可变长度字符编码，又称万国码，由Ken Thompson于1992年创建。现在已经标准化为RFC 3629。UTF-8用1到6个字节编码Unicode字符。用在网页上可以统一页面显示中文简体繁体及其它语言（如英文，日文，韩文）。

UTF-8：是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存...

UTF-16: 每个字符最少占16位.

GBK: 每个字符占2个字节, 16位.　

UTF-8 ：最少用8位数,去表示一个字符.

　　　　　　英文: 8位,1个字节表示.

　　　　欧洲文字: 16位,两个字节表示一个字符.

　　中文,亚洲文字: 24位,三个字节表示.

单位之间的转换

8bit = 1byte

1024byte = 1KB

1024KB = 1MB

1024MB = 1GB

1024GB = 1TB

1024TB = 1PB

1024TB = 1EB

1024EB = 1ZB

1024ZB = 1YB

1024YB = 1NB

1024NB = 1DB

常⽤到TB就够了　

笔记

ASCII占8bit,一个字节 2**8=256

ASCII最初设计一个字符是七位

优化为八位,最左一位为0,是预留的

八位又称为一个字节 8位==1字节

字符编码

支持中文的第一张表就叫 GB2312

1980 gb2312 6700+

1995 gbk1.0 20000

2000 gb18030 27000

big5 台湾

unicode 万国码支持所有国家和地区的编码 32位 2**32

起初,一个字符16位,2个字节 2**16 = 65535 = 存一个字符统一占用2个字节

改版,一个字符32位,4个字节 2**32

浪费资源

UTF-8 = unicode 的扩展集，可变长的字符编码集,原ASCII占1个字节,欧洲占2个字节,东亚占3个字节

最少1个字节=8位，最多4字节=32位，中文3字节=24位表示

最少用8位表示一个字符

英文:8位

欧洲文字:2个字节16位表示

中文:3个字节24位表示

gbk = gb2312(国标):只包含字母,数字,特殊字符和中文

英文:8位

中文:16位

1.编码之间不能识别

2.网路传输或者硬盘存储,必须是非Unicode的编码方式

大环境Python3x:

str(字符串):内存(内部)编码方式是Unicode

bytes:Python的基础数据类型之一,它和str相当于双胞胎,str拥有的所有方法,bytes都适用

区别:

英文字母:

str:

表现形式 s1 = 'alex'

内部编码方式:Unicode

bytes:

表现形式 b1 = b'alex'

内部编码方式:非Unicode

中文:

str:

表现形式 s1 = '太白'

内部编码方式:Unicode

bytes:

表现形式 b1 = b'\xe5\xa4\xaa\xe7\x99\xbd' # utf-8

b1 = b'\xcc\xab\xb0\xd7' # gbk

内部编码方式:非Unicode

如何使用:

你想将一部分内容(字符串)写入文件,或者通过网络 socket传输,这样这部分内容(字符串)必须转化成 bytes才可以进行

平时你代码中,使用字符串

gbk <--> utf-8 可以互相转化ASCII(字母,数字,特殊字符)

中国发展:

Assic -->Gb2312 ->gbk1.0-->gb18030

gbk:国标,只包含中文,英文(英文字母,数字,特殊字符)

英文字母用一个字节表示

中文用两个字节表示

国际发展:

Assic -->unicode -->utf-8 /utf-16

常用的ASCII字符编码:

字符十进制十六进制

'0' 48 0x30

'A' 65 0x41

'a' 97 0x61

Python2.x == Assic 默认编码 ascii

#-*- coding:utf-8 -*-

#coding:utf-8

python3.x == unicode默认编码 utf-8

unicode 是向下兼容gb2312 , gbk(中文2个字节)

基础数据类型

一.什么是数据类型？

　　我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，如下：

　整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).

int。数字：主要用于运算。1 ，2,3...

bool。判断真假：True, False.

str。简单少量的储存数据，并进行相应的操作。name = 'alex',

tuple。只读，不能更改。(1,'alex')

list：大量有序数据，[1,'ses',True,[1,2,3],{'name':'jinxin'}]

dict：大量数据，且是关联性比较强的数据 {'name':'jinxin','age':18,'name_list':['张三'，'李四']}

二.基础数据类型。

2.1数字int。

2.2布尔值bool

真 1 True。

假 0 False。

2.3字符串str。

*** string.capitalize()

把字符串的第一个字符大写

** string.center(width[, fillchar])

返回一个原字符串居中,并使用fillchar填充字符,默认空格填充至长度 width 的新字符串

string.count(str, beg=0, end=len(string))

返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

string.casefold()

返回适合无大小写比较的字符串版本

string.decode(encoding='UTF-8', errors='strict')

以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 'ignore' 或者'replace'

string.encode(encoding='UTF-8', errors='strict')

以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'

*****string.endswith(obj, beg=0, end=len(string))

检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

string.expandtabs(tabsize=8)

把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。

*****string.find(str, beg=0, end=len(string))

检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

* string.format()

格式化字符串

msg = "姓名{},年龄{},性别{}".format("str","str","str")

msg = "姓名{0},年龄{1},性别{2},姓名{0}".format("str","str","str")

msg = "姓名{name},年龄{age},性别{sex}".format(age="str",name="str",sex="str")

*****string.index(str, beg=0, end=len(string))

跟find()方法一样，只不过如果str不在 string中会报一个异常.

*****string.isalnum()

如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

*****string.isalpha()

如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

string.isdecimal()

如果 string 只包含十进制数字则返回 True 否则返回 False.

*****string.isdigit()

如果 string 只包含数字则返回 True 否则返回 False.

string.islower()

如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

string.isnumeric()

如果 string 中只包含数字字符，则返回 True，否则返回 False

string.isspace()

如果 string 中只包含空格，则返回 True，否则返回 False.

string.istitle()

如果 string 是标题化的(见 title())则返回 True，否则返回 False

string.isupper()

如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

!****string.join(seq)

自定义连接符,将可迭代对象中的元素链接起来,以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

string.ljust(width)

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

*****string.lower()

转换 string 中所有大写字符为小写.

string.lstrip()

截掉 string 左边的空格

string.maketrans(intab, outtab])

maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

max(str)

返回字符串 str 中最大的字母。

min(str)

返回字符串 str 中最小的字母。

string.partition(str)

有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字符串 string 分成一个 3 元素的元组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.

*****string.replace(str1, str2, num=string.count(str1))

把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

string.rfind(str, beg=0,end=len(string) )

类似于 find()函数，不过是从右边开始查找.

string.rindex( str, beg=0,end=len(string))

类似于 index()，不过是从右边开始.

string.rjust(width)

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

string.rpartition(str)

类似于 partition()函数,不过是从右边开始查找

*****string.rstrip()

删除 string 字符串末尾的空格.

*****string.split(str="", num=string.count(str))

将字符串分割为列表,默认以空格分割,*字符串前如果有空格,再以默认分割的话,最前的数据没有输出,如果指定以空格分隔的话,最前面的数据会输出*,以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串

string.splitlines([keepends])

按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

*****string.startswith(obj, beg=0,end=len(string))

检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.

*****string.strip([obj])

默认去除前后的空格,制表符和换行,可以多字符指定,在 string 上执行 lstrip()和 rstrip()

** string.swapcase()

翻转 string 中的大小写

** string.title()

非字母隔开的单词首字母大写,返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

string.translate(str, del="")

根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中

*****string.upper()

转换 string 中的小写字母为大写

string.zfill(width)

返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

字符串的索引操作:

Python的字符串是不可以改变的序列

索引 index

语法: 字符串[整数表达式]

说明:

Python序列都可以用索引来访问序列中的对象

Python序列的正向索引是从0开始的,第二个索引为1,最后一个索引为len(s)-1

Python序列的反向索引是从-1开始的,-1代表最后一个,-2代表倒数第二个,以此类

推,第一个是-len(s)

示例:

s = 'ABCDE'

print(s[0]) #输出:A

print(s[4]) #输出:E

print(s[len(s)-1]) #输出:E

print(s[-1]) #输出:E

print(s[-5]) #输出:A

print(s[-len(s)]) #输出:A

切片 slice

从一个字符串序列中取出相应的元素重新组成一个字符串序列

语法:

字符串序列[(开始索引b):(结束索引e)(:(步长s))]

注:

小括号()括起来的部分代表可省略

说明:

1.开始索引是切片开始切下的位置,0代表第一个元素,1代表第二个元素,-1代表最

后一个元素

2.结束索引是切片的终止索引(但不包含终止点)

3.步长是切片每次获取完当前元素后移动的方向和偏移量

1)没有步长,相当于取值完成后向右移动一个索引的位置(默认为1)

2)当步长为整数时,取正向切片:

步长默认为1,开始索引默认为0,结束索引默认为len(s)

步长代表下次索引的取值的增长值

3)当步长为负整数时,取反向切片

默认的起始位置是最后一个元素,终止位置是第一个元素的前一个位置

2.4列表list

列表的索引切片

lis[起始值:结束值:步长]

增

append 追加，给列表的最后面追加一个元素

insert 插入在列表的任意位置插入元素

extend 迭代着追加，在列表的最后面迭代着追加一组数据

删

pop 通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素

remove 通过元素删除列表中该元素

clear 清空列表

del

按照索引删除该元素

切片删除该元素

切片(步长)删除该元素

改

按照索引改值

按照切片改值(迭代着增加)

按照切片(步长)改值(必须一一对应)

查

切片去查，或者循环去查

其他操作

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

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

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

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

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

列表:
索引,切片加步长
与字符串使用相仿
list[num] 索引
list[num:num:num] 切片加步长
增删改查
增
append 追加
list.append(value)
insert 插入
list.insert(index, value)
extend 迭代追加
list.extend(iterable(可迭代的对象))
删
pop 按照索引删除(唯一有返回值的)
list.pop(index)
remove 按照元素删除
list.remove(value)
clear 清空
list.clear()
del
可以按照索引删除
del list[index]
可以按照切片删除(可以加步长)
del list[index:index:step]
可以在内存级别删除整个列表
del list
改
按照索引
list[index] = 'value'
按照切片加步长
按照切片
list[index:index] = [value,value] # 先清空切片的元素,再迭代的添加元素
加步长
list[index:index:step] = [value] # 删除几个,添加几个,一一对应
查
按照索引,切片,切片加步长
for循环
for i in list
其他方法
len(list) 查询个数
list.count('value') 查询某个元素出现的个数
list.index('value') 通过元素找索引
list.sort() 从小到大排序
list.sort(reverse=Ture) 从大到小排序
list.reverse() 列表的反转
列表嵌套
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

2.5元组tuple

2.5.1 元组的索引切片

2.5.2 元组其他操作方法

因为元组的特性，直接从属于元组的元素不能更改，所以元组只能查看

index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错

`count: 获取某元素在列表中出现的次数

2.5.3 len

元组:只读列表,只允许查询,不允许增删改

查

索引,切片,切片加步长

for循环查

index,len(),count

应用:不允许修改的重要的数据

儿子不能改,孙子可以改

tuple = (value,[list])

tuple[1].append(value) # tuple = (value,[list,value])

range:可控(自定制)的数字范围的可迭代,可以类比成列表

for i in range(1,101) 顾头不顾尾

range() 一般和for循环结合使用

in 方法: 判断元素是否在里面

not in 方法: 判断元素是否不在里面

2.6字典dict。

2.6.1 字典的初识

Why:咱们目前已经学习到的容器型数据类型只有list，那么list够用？他有什么缺点呢？

1. 列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。

2. 列表只能按照顺序存储，数据与数据之间关联性不强。

所以针对于上的缺点，说咱们需要引入另一种容器型的数据类型，解决上面的问题，这就需要dict字典。

what：

数据类型可以按照多种角度进行分类，就跟咱们人一样，人按照地域可以划分分为亚洲人，欧洲人，美洲人等，但是按照肤色又可以分为白种人，黄种人，黑种人，等等，数据类型可以按照不同的角度进行分类，先给大家按照可变与不可变的数据类型的分类：

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

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

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

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

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

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

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

　当然，字典也有缺点：他的缺点就是内存消耗巨大。

字典查询之所以快的解释

字典的查询速度非常快，简单解释一下原因：字典的键值对会存在一个散列表（稀疏数组）这样的空间中，每一个单位称作一个表元，表元里面记录着key：value,如果你想要找到这个key对应的值，先要对这个key进行hash获取一串数字咱们简称为门牌号（非内存地址），然后通过门牌号，确定表元，对比查询的key与被锁定的key是否相同，如果相同，将值返回，如果不同，报错。（这里只是简单的说一下过程，其实还是比较复杂的。）

详细解释

# 此段解释来源于《流畅的python》.

这一节笼统地描述了 Python 如何用散列表来实现 dict 类型，有些细节只是一笔带过，像

CPython 里的一些优化技巧就没有提到。但是总体来说描述是准确的。

Python 源码 dictobject.c 模块（http://hg.python.org/cpython/file/tip/Objects/dictobject.c）里有丰富的注释，另外延伸阅

读中有对《代码之美》一书的引用。

为了简单起见，这里先集中讨论 dict 的内部结构，然后再延伸到集合上面。

散列表其实是一个稀疏数组（总是有空白元素的数组称为稀疏数组）。在一般的数据结构

教材中，散列表里的单元通常叫作表元（bucket）。在 dict 的散列表当中，每个键值对

都占用一个表元，每个表元都有两个部分，一个是对键的引用，另一个是对值的引用。因

为所有表元的大小一致，所以可以通过偏移量来读取某个表元。

因为 Python 会设法保证大概还有三分之一的表元是空的，所以在快要达到这个阈值的时

候，原有的散列表会被复制到一个更大的空间里面。

如果要把一个对象放入散列表，那么首先要计算这个元素键的散列值。Python 中可以用

hash() 方法来做这件事情，接下来会介绍这一点。

01. 散列值和相等性

内置的 hash() 方法可以用于所有的内置类型对象。如果是自定义对象调用 hash()

的话，实际上运行的是自定义的 __hash__。如果两个对象在比较的时候是相等的，

那它们的散列值必须相等，否则散列表就不能正常运行了。例如，如果 1 == 1.0 为

8

8

真，那么 hash(1) == hash(1.0) 也必须为真，但其实这两个数字（整型和浮点）

的内部结构是完全不一样的。

为了让散列值能够胜任散列表索引这一角色，它们必须在索引空间中尽量分散开来。

这意味着在最理想的状况下，越是相似但不相等的对象，它们散列值的差别应该越

大。示例 3-16 是一段代码输出，这段代码被用来比较散列值的二进制表达的不同。

注意其中 1 和 1.0 的散列值是相同的，而 1.0001、1.0002 和 1.0003 的散列值则非常不

同。

示例 3-16 在32 位的 Python 中，1、1.0001、1.0002 和 1.0003 这几个数的散列

值的二进制表达对比（上下两个二进制间不同的位被 ! 高亮出来，表格的最右

列显示了有多少位不相同）

32-bit Python build

1 00000000000000000000000000000001

!= 0

1.0 00000000000000000000000000000001

------------------------------------------------

1.0 00000000000000000000000000000001

! !!! ! !! ! ! ! ! !! !!! != 16

1.0001 00101110101101010000101011011101

------------------------------------------------

1.0001 00101110101101010000101011011101

!!! !!!! !!!!! !!!!! !! ! != 20

1.0002 01011101011010100001010110111001

------------------------------------------------

1.0002 01011101011010100001010110111001

! ! ! !!! ! ! !! ! ! ! !!!! != 17

1.0003 00001100000111110010000010010110

------------------------------------------------

用来计算示例 3-16 的程序见于附录 A。尽管程序里大部分代码都是用来整理输出格

式的，考虑到完整性，我还是把全部的代码放在示例 A-3 中了。

从 Python 3.3 开始，str、bytes 和 datetime 对象的散列值计算过程中多

了随机的“加盐”这一步。所加盐值是 Python 进程内的一个常量，但是每次启动

Python 解释器都会生成一个不同的盐值。随机盐值的加入是为了防止 DOS 攻击

而采取的一种安全措施。在 __hash__ 特殊方法的文档

（https://docs.python.org/3/reference/datamodel.html#object.__hash__) 里有相关的详

细信息。

了解对象散列值相关的基本概念之后，我们可以深入到散列表工作原理背后的算法

了。

02. 散列表算法

为了获取 my_dict[search_key] 背后的值，Python 首先会调用 hash(search_key)来计算 search_key 的散列值，把这个值最低的几位数字当作偏移量，在散列表里查找表元（具体取几位，得看当前散列表的大小）。若找到的表元是空的，则抛出KeyError 异常。若不是空的，则表元里会有一对 found_key:found_value。这时候 Python 会检验 search_key == found_key 是否为真，如果它们相等的话，就会返回 found_value。如果 search_key 和 found_key 不匹配的话，这种情况称为散列冲突。发生这种情况是因为，散列表所做的其实是把随机的元素映射到只有几位的数字上，而散列表本身的索引又只依赖于这个数字的一部分。为了解决散列冲突，算法会在散列值中另外再取几位，然后用特殊的方法处理一下，把新得到的数字再当作索引来寻找表元。若这次找到的表元是空的，则同样抛出 KeyError；若非空，或者键匹配，则返回这个值；或者又发现了散列冲突，则重复以上的步骤。图 3-3 展示了这个算法的示意

图。图 3-3：从字典中取值的算法流程图；给定一个键，这个算法要么返回一个值，要么抛出 KeyError 异常添加新元素和更新现有键值的操作几乎跟上面一样。只不过对于前者，在发现空表元的时候会放入一个新元素；对于后者，在找到相对应的表元后，原表里的值对象会被替换成新值。

另外在插入新值时，Python 可能会按照散列表的拥挤程度来决定是否要重新分配内存为它扩容。如果增加了散列表的大小，那散列值所占的位数和用作索引的位数都会随之增加，这样做的目的是为了减少发生散列冲突的概率。表面上看，这个算法似乎很费事，而实际上就算 dict 里有数百万个元素，多数的搜索过程中并不会有冲突发生，平均下来每次搜索可能会有一到两次冲突。在正常情况下，就算是最不走运的键所遇到的冲突的次数用一只手也能数过来。了解 dict 的工作原理能让我们知道它的所长和所短，以及从它衍生而来的数据类型

解释：字典内存开销巨大(了解)

由于字典使用了散列表，而散列表又必须是稀疏的，这导致它在空间上的效率低下。举例而言，如果你需要存放数量巨大的记录，那么放在由元组或是具名元组构成的列表中会是比较好的选择；最好不要根据 JSON 的风格，用由字典组成的列表来存放这些记录。用元组取代字典就能节省空间的原因有两个：其一是避免了散列表所耗费的空间，其二是无需把记录中字段的名字在每个元素里都存一遍。记住我们现在讨论的是空间优化。如果你手头有几百万个对象，而你的机器有几个GB 的内存，那么空间的优化工作可以等到真正需要的时候再开始计划，因为优化往往是可维护性的对立面。

2.6.2 创建字典的几种方式

方式1:

dic = dict((('one', 1),('two', 2),('three', 3)))

方式2:

dic = dict(one=1,two=2,three=3)

方式3:

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

方式5:

dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))

方式6: 字典推导式

# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}

方式7:利用fromkeys

# dic = dict.fromkeys('abcd','Leif')

2.6.4 字典的常用操作方法

增

通过键值对直接增加

setdefault

没有的键添加,有的不变,有返回值

删

pop 通过key删除字典的键值对，有返回值，可设置返回值。

popitem 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值

clear 清空字典

del

通过键删除键值对

删除整个字典

改

通过键值对直接改

update

查

通过键查询

# 直接dic[key](没有此键会报错)

get

keys()

返回字典中所有的键

values()

返回字典中所有的值

items()

返回字典中所有的键值对

字典

key:value 形式存储的

key 不可变(可哈希)的数据类型

value 任意数据,对象

可以存储大量的数据,关系数据,字典的查询速度非常的额快,是基于数据库的原理做的

Python3.5(包含3.5)字典是无序的

Python3.6 以后字典是有序的

dic = {'name':'taibai'}

增

dic['age'] = 18 # 有则改之,无则添加

dic.setdefault(key[, value]) # 有则不变,无则添加; value 可以不加,不加字典将自动的添加None

删

pop 按照键去删除有返回值

dic.pop('name2', None) # 为了防止报错,在后面加上None参数

clear 清空

del

按照键删除键值对

del dic['name']

删除整个字典

del dic

popitem() 有返回值

Python3.5(包含3.5)字典是无序的,随即删除

Python3.6 以后字典是有序的,默认删除最后一个

改

dic['name'] = 'alex'

update(字典)

update(sex='男') # 添加键值对

查

按照键查询

dic['name']

dic['name1'] # 字典中没有会报错

dic,get('name') # 后面的参数可写可不写,如果字典没有这个键就返回None

dic.keys() dic.values() dic.items() # 都可以遍历,都可以转化为列表

a = 10

b = 20

a,b = b,a # a,b值一行互换

for k,v in dic.item()

print(k,v) # 分别打印键值对的键和值

其他操作

字典嵌套

2.7集合set

1，集合的创建

set1 = set({1,2,'barry'})

set2 = {1,2,'barry'}

2，集合的增

set1.add('hello')

update：迭代着增加

3，集合的删

set1.remove('hello') # 删除一个元素

set1.pop() # 随机删除一个元素

set1.clear() # 清空集合

del set1 # 删除集合

4，集合的其他操作

4.1 交集。（& 或者 intersection）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 & set2) # {4, 5}

print(set1.intersection(set2)) # {4, 5}

4.2 并集。（| 或者 union）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8}

print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7,8}

4.3 差集。（- 或者 difference）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 - set2) # {1, 2, 3}

print(set1.difference(set2)) # {1, 2, 3}

4.4反交集。（^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}

set2 = {4,5,6,7,8}

print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}

print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}

4.5子集与超集

set1 = {1,2,3}

set2 = {1,2,3,4,5,6}

print(set1 < set2)

print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)

print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。

5，frozenset不可变集合，让集合变成不可变类型。

s = frozenset('barry')

print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

数据类型转换

int(x [,base])

将x转换为一个整数

long(x [,base] )

将x转换为一个长整数

float(x)

将x转换到一个浮点数

complex(real [,imag])

创建一个复数

str(x)

将对象 x 转换为字符串

repr(x)

将对象 x 转换为表达式字符串

eval(str)

用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s)

将序列 s 转换为一个元组

list(s)

将序列 s 转换为一个列表

set(s)

转换为可变集合

dict(d)

创建一个字典。d 必须是一个序列 (key,value)元组。

frozenset(s)

转换为不可变集合

chr(x)

将一个整数转换为一个字符

unichr(x)

将一个整数转换为Unicode字符

ord(x)

将一个字符转换为它的整数值

hex(x)

将一个整数转换为一个十六进制字符串

oct(x)

将一个整数转换为一个八进制字符串

数据类型的转换:

int str bool

str <-> bytes

str <-> list # 要将list里的元素用join拼接为字符串,list里的元素必须全是str类型

dict.keys() dict.values() dict.items() -> list()

list(dict.keys()) list(dict.values()) list(dict.items())

tuple <-> list

dict --> list # 只是将键添加到列表中

0 "" [] {} () set() --> bool # False

for循环

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

range：指定范围，生成指定数字。

小数据池，代码块的最详细、深入剖析

一，id，is，==

在Python中，id是什么？id是内存地址，那就有人问了，什么是内存地址呢？你只要创建一个数据（对象）那么都会在内存中开辟一个空间，将这个数据临时加在到内存中，那么这个空间是有一个唯一标识的，就好比是身份证号，标识这个空间的叫做内存地址，也就是这个数据（对象）的id，那么你可以利用id（）去获取这个数据的内存地址：

那么 is 是什么？ == 又是什么？
== 是比较的两边的数值是否相等，而 is 是比较的两边的内存地址是否相等。如果内存地址相等，那么这两边其实是指向同一个内存地址。

二，代码块。

根据提示我们从官方文档找到了这样的说法：

A Python program is constructed from code blocks. A block is a piece of Python program text that is executed as a unit. The following are blocks: a module, a function body, and a class definition. Each command typed interactively is a block. A script file (a file given as standard input to the interpreter or specified as a command line argument to the interpreter) is a code block. A script command (a command specified on the interpreter command line with the ‘-c‘ option) is a code block. The string argument passed to the built-in functions eval() and exec() is a code block.

A code block is executed in an execution frame. A frame contains some administrative information (used for debugging) and determines where and how execution continues after the code block’s execution has completed.

上面的主要意思是：

Python程序是由代码块构造的。块是一个python程序的文本，他是作为一个单元执行的。

代码块：一个模块，一个函数，一个类，一个文件等都是一个代码块。

而作为交互方式输入的每个命令都是一个代码块。

什么叫交互方式？就是咱们在cmd中进入Python解释器里面，每一行代码都是一个代码块，例如：

而对于一个文件中的两个函数，也分别是两个不同的代码块：

　　那么，可能有的同学还有一些不理解代码块，可以这样解释：我们都上过学对吧，你们在初中的时候，有没有过值周？就以一个班的学生用一星期的时间打扫整个学校，再比如有没有运动会，无论是值周，还是运动会，还是组织什么活动，都是以什么为单位呢？对，都是以班级为单位，那么咱们学生就好比是代码，班级就好比是代码块，我们想让代码运行起来，必须依靠班级去执行，也就是代码块。

代码块的缓存机制

前提条件：在同一个代码块内。

机制内容：Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在你给出的例子中，文件执行时（同一个代码块）会把i1、i2两个变量指向同一个对象，满足缓存机制则他们在内存中只存在一个，即：id相同。

适用对象： int（float），str，bool。

对象的具体细则：（了解）

　　int(float):任何数字在同一代码块下都会复用。

　　bool:True和False在字典中会以1，0方式存在，并且复用。

　　str：几乎所有的字符串都会符合缓存机制，具体规定如下（了解即可！）：

1，非乘法得到的字符串都满足代码块的缓存机制：

s1 = 'Leif@！#*ewq'

s2 = 'Leif@！#*ewq'

print(s1 is s2) # True

2,乘法得到的字符串分两种情况：

　　2.1 乘数为1时，任何字符串满足代码块的缓存机制：

b1 = 'Leif@5847395QQ0743895*&^%$#((&_+(())' *1

a1 = 'Leif@5847395QQ0743895*&^%$#((&_+(())' *1

print(a1 is b1) # True

　　2.2 乘数>=2时：仅含大小写字母，数字，下划线，总长度<=20，满足代码块的缓存机制：

s1 = 'old_' * 5

s2 = 'old_' * 5

print(s1 is s2) # True

优点：能够提高一些字符串，整数处理人物在时间和空间上的性能；需要值相同的字符串，整数的时候，直接从‘字典’中取出复用，避免频繁的创建和销毁，提升效率，节约内存。

三，小数据池

小数据池，不同代码块的缓存机制，也称为小整数缓存机制，或者称为驻留机制等等，博主认为，只要你在网上查到的这些名字其实说的都是一个意思，叫什么因人而异。

那么到底什么是小数据池？他有什么作用呢？

前提条件：在不同一个代码块内。

机制内容：官方对于整数，字符串的小数据池是这么说的:

对于整数，Python官方文档中这么说：
The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you actually just get back a reference to the existing object. So it should be possible to change the value of 1. I suspect the behaviour of Python in this case is undefined.

对于字符串：
Incomputer science, string interning is a method of storing only onecopy of each distinct string value, which must be immutable. Interning strings makes some stringprocessing tasks more time- or space-efficient at the cost of requiring moretime when the string is created or interned. The distinct values are stored ina string intern pool. –引自维基百科

来，我给你们翻译并汇总一下，这个表达的意思就是：

Python自动将-5~256的整数进行了缓存，当你将这些整数赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。

python会将一定规则的字符串在字符串驻留池中，创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象，而是使用在字符串驻留池中创建好的对象。

　　其实，无论是缓存还是字符串驻留池，都是python做的一个优化，就是将~5-256的整数，和一定规则的字符串，放在一个‘池’（容器，或者字典）中，无论程序中那些变量指向这些范围内的整数或者字符串，那么他直接在这个‘池’中引用，言外之意，就是内存中之创建一个。

适用对象： int（float），str，bool

对象的具体细则：（了解即可）

int：那么大家都知道对于整数来说，小数据池的范围是-5~256 ，如果多个变量都是指向同一个（在这个范围内的）数字，他们在内存中指向的都是一个内存地址。

那么对于字符串的规定呢？

str:字符串要从下面这几个大方向讨论（了解即可！）：

1,字符串的长度为0或者1，默认都采用了驻留机制（小数据池）。

2,字符串的长度>1,且只含有大小写字母，数字，下划线时，才会默认驻留。

3,用乘法得到的字符串，分两种情况。

　　3.1 乘数为1时：

仅含大小写字母，数字，下划线，默认驻留。

含其他字符，长度<=1,默认驻留。

含其他字符，长度>1,默认驻留。

　　3.2 乘数>=2时：

仅含大小写字母，数字，下划线，总长度<=20,默认驻留。

4，指定驻留。

from sys import intern

a = intern('hello!@'*20)

b = intern('hello!@'*20)

print(a is b)

#指定驻留是你可以指定任意的字符串加入到小数据池中，让其只在内存中创建一个对象，多个变量都是指向这一个字符串。

满足以上字符串的规则时，就符合小数据池的概念。

bool值就是True，False，无论你创建多少个变量指向True，False，那么他在内存中只存在一个。

看一下用了小数据池（驻留机制）的效率有多高：

显而易见，节省大量内存在字符串比较时，非驻留比较效率o(n)，驻留时比较效率o(1)。

优点：能够提高一些字符串，整数处理人物在时间和空间上的性能；需要值相同的字符串，整数的时候，直接从‘池’里拿来用，避免频繁的创建和销毁，提升效率，节约内存

四，小结。

　　如果在同一代码块下，则采用同一代码块下的换缓存机制。

　　如果是不同代码块，则采用小数据池的驻留机制。

# pycharm 通过运行文件的方式执行下列代码：这是在同一个文件下也就是同一代码块下，采用同一代码块下的缓存机制。

i1 = 1000

i2 = 1000

print(i1 is i2) # 结果为True 因为代码块下的缓存机制适用于所有数字

通过交互方式中执行下面代码： # 这是不同代码块下，则采用小数据池的驻留机制。

>>> i1 = 1000

>>> i2 = 1000

>>> print(i1 is i2)

False # 不同代码块下的小数据池驻留机制数字的范围只是-5~256.

更多验证：

# 虽然在同一个文件中，但是函数本身就是代码块，所以这是在两个不同的代码块下，不满足小数据池（驻存机制），则指向两个不同的地址。

def func():

i1 = 1000

print(id(i1)) # 2288555806672

def func2():

i1 = 1000

print(id(i1)) # 2288557317392

func()

func2()

小数据池 is id == 等

虽然if,while,for缩进的内容都叫代码块,但是它不是Python中严格定义的代码块

Python程序是由代码块构造的。块是一个python程序的文本，他是作为一个单元执行的。

代码块：一个模块，一个函数，一个类，一个文件等都是一个代码块。

而作为交互方式输入的每个命令都是一个代码块。

什么叫交互方式？就是咱们在cmd中进入Python解释器里面，每一行代码都是一个代码块

id(元素) 打印的是元素在内存中的地址

在内存中id的值都是唯一的,如果两个变量指向的值得id相同,就证明它们在内存中是同一个

is 判断的是两个元素的,在内存中的id值是否相同

如果is是True,那么==一定是True

== 判断的是两个元素的值是否相等

小数据池(缓存机制,驻留机制)

小数据池的应用类型:只有整数,字符串,bool值

小数据池是Python对内存做的一个优化:

它将 -5~256 的整数,以及一定规则的字符串,提前在内存中创建了一个池(容器),容器里固定的放了这些数

目的:

1.节省内存

2.提高性能与效率

一定规则的字符串:

1,字符串的长度为0或者1，默认都采用了驻留机制（小数据池）。

2,字符串的长度>1,且只含有大小写字母，数字，下划线时，才会默认驻留。

3,用乘法得到的字符串，分两种情况。

3.1 乘数为1时：

仅含大小写字母，数字，下划线，默认驻留。

含其他字符，长度<=1,默认驻留。

含其他字符，长度>1,默认驻留。

3.2 乘数>=2时：

仅含大小写字母，数字，下划线，总长度<=20,默认驻留。

4,指定驻留。

from sys import intern

a = intern('hello!@'*20)

b = intern('hello!@'*20)

print(a is b)

#指定驻留是你可以指定任意的字符串加入到小数据池中，让其只在内存中创建一个对象，多个变量都是指向这一个字符串

代码块:

Python在同一个代码块中的变量,初始化对象的命令时,它会将变量与值得对应关系放到一个字典中,如果下面的代码遇到初始化对象的命令时,它会从字典中寻找,

如果存在相同的值,它会复用,指向的都是同一个能存地址

dic = {'name': alex@的内存地址}

Python对于不同的代码块,初始化对象的命令时,它会从小数据池中寻找

name = 'alex@'

name1 = 'alex@'

深浅copy

深浅拷贝

浅copy

.copy()

第一层(第一层的元素的id是一样的)在内存中是独立的,从第二层开始以及更深的层,都是公用的一个内存地址,一变都变

对于浅copy来说，只是在内存中重新创建了开辟了一个空间存放一个新列表，但是新列表中的元素与原列表中的元素是公用的。

深copy

import copy

l2 = copy.deepcopy(l1)

对于深copy来说，列表是在内存中重新创建的，列表中可变的数据类型是重新创建的，列表中的不可变的数据类型是公用的。

切片属于浅copy l1 = l2[:]

文件操作

小结

文件操作

初识

文件路径

编码方式：utf-8，gbk，gb2312....

操作模式：只读，只写，追加，写读，读写....

1.绝对路径:从磁盘根目录开始一直到文件名

2.相对路径:用一个文件夹下的文件,相对于当前这个程序所在的文件而言.如果在同一个文件中,则相对路劲就是这个文件名.如果再上一层文件夹则要使用../相对路径下，你就可以直接写文件名即可。

读

r

1,全部读取

f = open('d:\文件.txt',mode='r',encoding='utf-8')

content = f.read()

print(content)

f.close()

2,read(n) n的单位是字符

f = open('d:\文件.txt',mode='r',encoding='utf-8')

content = f.read(10) # 读取前10个字符

print(content)

f.close()

3,按行读取

f = open('d:\文件.txt',mode='r',encoding='utf-8')

content = f.readline()

print(content) # 一行的读取,写几个print(content)或print(f.readline())读取几行

print(content)

print(content)

f.close()

4,按行读取,返回list

f = open('d:\文件.txt',mode='r',encoding='utf-8')

content = f.readlines()

print(content)

f.close()

5,for 循环 (文件句柄是可迭代对象)

f = open('../path1/弟子规',mode='r',encoding='utf-8')

for line in f:

print(line) #这种方式就是在一行一行的进行读取,它就执行了下边的功能

print(f.readline())

print(f.readline())

print(f.readline())

print(f.readline())

f.close()

rb

文件操作中凡是带b字母的,都是与非文字类文件相关的

f = open('d:\图片.jpg',mode='rb')

content = f.read()

print(content)

f.close()

rb模式下,read(n) n的单位是字节

f = open('d:\文件.txt',mode='r',encoding='utf-8')

content = f.read(10) # 读取前10个字节

print(content)

f.close()

r+ 读写:先读,后追加

r+b

写

w

如果文件不存在，利用w模式操作文件，那么它会先创建文件，然后写入内容.

如果文件存在，利用w模式操作文件，先清空原文件内容，在写入新内容。

wb

第一步,将图片以rb模式读取出来

f = open('d:\图片.jpg',mode='rb')

content = f.read()

print(content)

第二步,将读取出来的数据以wb的模式写入新的文件

f1 = open('d:\图片1.jpg',mode='wb')

content = f1.write(content)

f.close()

f1.close()

w+

w+b

追加

a

如果文件不存在，利用a模式操作文件，那么它会先创建文件，然后写入内容。

如果文件存在，利用a模式操作文件，那么它会在文件的最后面追加内容。

ab

a+

a+b

常用方法:

readable() 判断是否可读,返回的是bool值

writeable() 判断是否可读,返回的是bool值

tell() 使用tell()可以帮我们获取当前光标在什么位置

seek() :

seek(n)光标移动到n位置,注意: 移动单位是byte,所有如果是utf-8的中文部分要是3的倍数通常我们使用seek都是移动到开头或者结尾

移动到开头:seek(0)

移动到结尾:seek(0,2) seek的第二个参数表示的是从哪个位置进行偏移,默认是0,表示开头,1表示当前位置,2表示结尾

truncate(): 截取,对原文件截取

如果想做截断操作. 记住了. 要先挪动光标. 挪动到你想要截断的位置. 然后再进行截断关于truncate(n), 如果给出了n. 则从开头进行截断,

如果不给n, 则从当前位置截断. 后面的内容将会被删除

with open('文件', encoding='utf-8', mode = 'w') as f1:

pass

改

函数

"*"号

聚合

打散

函数初识

函数: 封装一个功能

函数初识:

格式:

def 函数名():

函数主体

函数的优点:

减少代码的重复率

增强代码的阅读性

所数到底是什么?数最主要的目的:封装一个功能

函数的返回值 return

1.遇到return,函数结束,return下面的（函数内）的代码不会执行。

2.return 会给函数的执行者返回值。

如果return后面什么都不写，或者函数中没有return,则返回的结果是None

如果return后面写了一个值,返回给调用者这个值

如果return后面写了多个结果,,返回给调用者一个tuple(元组),调用者可以直接使用元组的解构获取多个变量。

函数的传参:

1.形参

写在函数声明的位置的变量叫形参,形式上的一个完整.表示这个函数需要xxx

1.位置参数

2.默认值参数大多数传进来的参数都是一样的, 一般用默认参数

默认参数的陷阱

默认参数若是可变的数据类型,他始终使用的是一个内存地址

3.动态参数

2.实参

在函数调用的时候给函数传递的值.加实参,实际执行的时候给函数传递的信息.表示给函数xxx

1.位置参数

位置参数就是从左至右，实参与形参一一对应。

2.关键字参数

3.混合参数

可以把上面两种参数混合着使用. 也就是说在调用函数的时候即可以给出位置参数, 也可以指定关键字参数.

混合参数一定要记住：关键字参数一定在位置参数后面。

位置参数必须在关键字参数前面

函数的传参就是函数将实际参数交给形式参数的过程.

函数的动态参数*args,**kwargs,形参的顺序

为了拓展,传入的参数不固定

在函数定义时,在位置参数上前面加*,聚合

*args 将所有实参的位置参数聚合到一个元组,并将这个元组赋值给args

**kwargs 将所有实参的关键字参数聚合到一个字典,并将这个元组赋值给kwargs

*的魔性用法:

在函数定义时,在位置参数和关键字参数上前面加*和**,聚合

在函数调用(执行)时,在可迭代对象前面加*或**,打散

形参的顺序

位置参数,*args,默认参数,**kwargs

名称空间,临时名称空间,作用域,取值顺序,加载顺序等

名称空间

\1. 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间

\2. 局部(临时)命名空间--> 在函数中声明的变量会放在局部命名空间

\3. 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间

作用域

1. 全局作用域: 全局命名空间 + 内置命名空间

2. 局部作⽤域: 局部(临时)命名空间

取值顺序

LEGB:

built-in(内置) <-- g1oba1(全局) <-- enclose(父级) <-- local(子级)(本地)

# 如果你在全局名称空间引用一个变量，先从全局名称空间引用，全局名称空间如果没有，才会向内置名称空间引用。

# 如果你在局部名称空间引用一个变量，先从局部名称空间引用，局部名称空间如果没有，才会向全局名称空间引用，全局名称空间在没有，就会向内置名称空间引用。

加载顺序

内置命名空间(程序运行伊始加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)

取值顺序与加载顺序是相反的，取值顺序满足的就近原则，从小范围到大范围一层一层的逐步引用。

global, nonlocal

global关键字有两个作用：

1，声明一个全局变量。

2，在局部作用域想要对全局作用域的全局变量进行修改时，需要用到 global(限于字符串，数字)。

nonlocal的总结：

1，不能更改全局变量。

2，在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，并且引用的哪层，从那层及以下此变量全部发生改变。

函数名的应用

1.函数名(不加()的)就是函数的内存地址

2.函数名可以赋值给其他变量函数名可以作为变量

3.函数名可以当做容器类类型的元素

4.函数名可以当做函数的参数

5.函数名可以作为函数的返回值

函数名是一个特殊的变量，他除了具有变量的功能，还有最主要一个特点就是加上() 就执行，其实他还有一个学名叫第一类对象。

闭包

闭包的定义：

1. 闭包是嵌套在函数中的函数。

2. 闭包必须是内层函数对外层函数的变量（非全局变量）的引用。

闭包的作用：保存局部信息不被销毁，保证数据的安全性。

闭包的应用：

可以保存一些非全局变量但是不易被销毁、改变的数据。

装饰器。

迭代器

小结

可迭代对象

从字面意思来说：可迭代对象就是一个可以重复取值的实实在在的东西。

从专业角度来说：但凡内部含有__iter__方法的对象，都是可迭代对象。

可迭代对象可以通过判断该对象是否有’__iter__’方法来判断。

可迭代对象的优点：

可以直观的查看里面的数据。

可迭代对象的缺点：

1. 占用内存。

2. 可迭代对象不能迭代取值（除去索引，key以外）。

迭代器

在python中，内部含有'__Iter__'方法并且含有'__next__'方法的对象就是迭代器。

从字面意思来说：迭代器就是可以迭代取值的工具。

从专业角度来说：在python中，内部含有'__Iter__'方法并且含有'__next__'方法的对象就是迭代器。

迭代器的优点：

节省内存。

迭代器在内存中相当于只占一个数据的空间：因为每次取值都上一条数据会在内存释放，加载当前的此条数据。

惰性机制。

next一次，取一个值，绝不过多取值。

有一个迭代器模式可以很好的解释上面这两条：迭代是数据处理的基石。扫描内存中放不下的数据集时，我们要找到一种惰性获取数据项的方式，即按需一次获取一个数据项。这就是迭代器模式。

迭代器的缺点：

不能直观的查看里面的数据。

取值时不走回头路，只能一直向下取值。

判断可迭代对象和迭代器

第二种方法

from collections import Iterable

from collections import Iterator

print(isinstance('alex', Iterable)) True

print(isinstance('alex', Iterator)) False

print(isinstance('alex', str)) 这个不光可以检测是不迭代器,也可以检测是不会是字符串....

while循环模拟for循环机制

for 循环:

1,将可送代对象转化成送代器

2,调用next方法取值

3,利用异常处理停止报错。

for循环的循环对象一定要是可迭代对象，但是这不意味着可迭代对象就可以取值，因为for循环的内部机制是：将可迭代对象转换成迭代器，然后利用next进行取值，最后利用异常处理处理StopIteration抛出的异常。

l1 = [1, 2, 3, 4, 5, 6]

# 1 将可迭代对象转化成迭代器

obj = iter(l1)

# 2,利用while循环，next进行取值

while 1:

# 3,利用异常处理终止循环

try:

print(next(obj))

except StopIteration:

break

可迭代对象与迭代器对比

可迭代对象：

不能取值

是一个私有的方法比较多，操作灵活（比如列表，字典的增删改查，字符串的常用操作方法等）,比较直观，但是占用内存，而且不能直接通过循环迭代取值的这么一个数据集。

应用：当你侧重于对于数据可以灵活处理，并且内存空间足够，将数据集设置为可迭代对象是明确的选择。

迭代器：

可以取值

每次只会取一个值

单项的,不反复,一条路走到头

是一个非常节省内存，可以记录取值位置，可以直接通过循环+next方法取值，但是不直观，操作方法比较单一的数据集。

应用：当你的数据量过大，大到足以撑爆你的内存或者你以节省内存为首选因素时，将数据集设置为迭代器是一个不错的选择。（可参考为什么python把文件句柄设置成迭代器）。

生成器vs列表推导式

小结

生成器
#生成器:就是自己用python代码写的迭代器,生成器的本质就是迭代器
在python中有三种方式来创建生成器：
1. 通过生成器函数
2. 通过生成器推导式
3. python内置函数或者模块提供（其实1,3两种本质上差不多，都是通过函数的形式生成，只不过1是自己写的生成器函数，3是python提供的生成器函数而已）
一个next 对应一个 yield
yield将值返回给上个生成器对象__next__()
yield vs return
return结束函数,给函数的执行者返回值
yield不会结束函数,一个next对应一个yield,给生成器对象__next()__返回值
生成器函数vs迭代器
区别1:自定制的区别
区别2:内存级别的区别。(生成器更省内存,迭代器还需要可迭代对象的转化)
迭代器是需要可迭代对象进行转化。可迭代对象非常占内存。
生成器直接创建,不需要转化,从本质就节省内存。
send和next()区别:
相同点：
send 和 next()都可以让生成器对应的yield向下执行一次。
都可以获取到yield生成的值。
不同点：
第一次获取yield值只能用next不能用send（可以用send(None)）。
send可以给上一个yield置传递值。
最后一个yie1d远也得不到send传的值。
def cloth1(n):
for i in range(n+1):
print('衣服%号' % i)
c1oth1(100000)
def cloth2(n):
for i in range(1, n+1):
yield '衣服%s号' % i
g = cloth2(10000)
for i in range (50):
print(g.__next__())
for i in range(50):
print(g.__next__())
列表推导式,生成器的表达方式:
l1 = []
for num in range(1, 101):
11.append(num)
print(11)
#列表推导式工一行代码几乎搞定你需要的任何的列表。
#循环模式:变量(加工后的变量)for变量 in iterable
1=[i for i in range(1, 101)]
print(1)
12=['python%s期' % i for i in range(1,16)]
print(12)
print([i*i for i in range(1, 11)])
#筛选模式:[变量(加工后的变量) for 变量 in iterable if条件]
l3= [i for i in range(1, 31) if i % 2 == 0]
print(13)
列表推导式vs生成器表达式
1把列表解析的换成()得到的就是生成器表达式
2列表解析与生成器表达式都是一种便利的编程方式,只不过生成器表达式更节省内存
3 Python不但使用迭代器协议,让for循环变得更加通用。大部分内置函数,也是使用迭代器协议访问对象的。例如,Sum函数是 Python的内置函数,该函数使选代器协议访问对象,而生成器实现了迭代器协议,所以,我们可以直接这样计算一系列值的和
sum(x ** 2 for x in range(4))
更多精彩请见一一迭代器生成器专题:http://www.cnblogs.com/jin-xin/articles/8423802.html

列表推导式

优点: 一行解决,方便
缺点: 容易着迷,不易排错,不能超过三次循环
列表推导式不能解决所有列表的问题,所有不要太刻意使用

列表推导式

两种模式

1,循环模式。[变量(加工后的变量)for变量 in iterable ]
2,筛选模式。[变量(加工后的变量)for变量 in iterable if 条件]
生成器表达式

生成器表达式

将列表推导式的[]换成()即可

g =(i for i in range(150))
print(g)
print(g.__next__())

生成器:自己用 python代码写的,本质上迭代器

生成器函数

yield与 return区别

return结束函数,返回给函数的执行者返回值

yield不会结束函数,会将值返回给生成器对象

next与send区别

共同点:都可以从生成器(迭代器)里取值

不同点 :send给上一个 yield发送一个值

生成器表达式

列表推导式与生成器表达式的不同

1,形式上不同 [ ] ( )
2,内存级别不同。生成器表达式非常节省内存。

内置函数

变量名加()

执行时输入的是: 变量(变量)

作用域相关*****

globals()

返回一个字典:包含全部的全局变量

locals()

返回一个字典:包含的是当前作用域所有的变量。

其他相关,不建议使用***

eval()

执行字符串类型的代码，并返回最终结果。

eval('2 + 2') # 4

n=81

eval("n + 4") # 85

eval('print(666)') # 666

exec()

执行字符串类型的代码,不返回结果代码流

s = '''

for i in [1,2,3]:

print(i)

'''

exec(s)

complie()

输入输出相关*****

input()

函数接受一个标准输入数据,返回为string类型

print()

打印输出

sep

打印多个内容分隔符默认是空格

end

默认换行

print(value,sep="默认分隔符",end="默认换行\n")

内存相关****

hash

只能哈希不可变的数据类型

获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

获取int类型的哈希值的时候,数字是多好,哈希值就是多少(例如:100的哈希值就是100)

print(hash(12322))

print(hash('123'))

print(hash('arg'))

print(hash('alex'))

print(hash(True))

print(hash(False))

print(hash((1,2,3)))

'''

-2996001552409009098

-4637515981888139739

1

2528502973977326415

'''

id()

获取该对象的内存地址

字典:会将你的所有的key在内存中转化成id

文件操作相关

open() *****

函数用于打开一个文件,创建一个file对象,相关的方法才可以调用它进行读写

模块相关

__import__ ***

函数用于动态加载类和函数

type(变量名)

变量是什么类型

序列常用函数

len(x)

返回字符个数

max(x)

返回序列最大值元素

min(x)

返回序列最小值元素

字符串编码转换函数

ord('x')

返回字符的Unicode值

ord('张') #24352

chr(i)

返回x(整型数)这个数值所对应的字符

chr(24352) #'张'

整数转进制字符串

bin(i)

将整数转换为二进制字符串

oct(i)

将整数转换为八进制字符串

hex(i)

将整数转换为十六进制字符串

字符串构造函数

str(obj='')

将对象转换为字符串

帮助

help( ) **

函数用于查看函数或模块用途的详细说明。

print(help(list))

print(help(str.split))

调用相关

callable( ) ***

函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

name = 'alex'

def func():

pass

print(callable(name)) # False

print(callable(func)) # True

查看内置属性 ***

dir( )

d1r:函数不带参数的,返回当前范固内的变量、方法和定义的类型列表;带参数的,返回参数的属性、方法列表.
如果参数包含方法__dir__( ),该方法将被调用。如果参数不包含__dir__( ),该方法将最大限度地收集参数信息。

name = 'alex'
print(dir(name))

range( )

函数可创建一个整数对象,一般用在for循环中。

# python2x: range(3)-->[0,1,2] 列表

xrange(3)--->送代器。

# python3x: range(3)--->range(0,3)可送代对象

next( )

内部实际使用了__nert__方法,返回送代器的下一个项目

iter( )

函数用来生成送代器(将一个可送代对象,生成送代器)。

数据类型

bool( ) ***

用于将给定参数转换为布尔类型,如果没有参数,返回 False。

int( ) ***

函数用于将一个字符串或数字转换为整型。

fioat( ) ***

函数用于将整数和字符串转换成浮点数。

complex( )

函数用创建一个值为 real+img*j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数

数学运算

abs() ****

函数返回数字的绝对值

divmod ****

计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

round(x) ***

保留浮点数的小数位数，默认保留整数。数字四舍五入

pow **

求x**y次幂。（三个参数为x**y的结果对z取余）

sum() *****

对可迭代对象进行求和计算(可设置初始值)

min() *****

返回可送代对象的最小值(可加key,key为函数名,通过函数的规则,返回最小值)

#1,他会将 iterahle里面的每个元素自动提取出来

#2,他会将你的返回值作为比较大小的具体条件。

#3,他会将遍历的元素返回回来。

max() *****

返回可送代对象的最大值(可加key,key为函数名,通过函数的规则,返回最大值)

和数据结构相关

list

将一个可迭代对象转换成列表(如果是字典,默认将key作为列表的元素)

tuple

将一个可迭代对象转换成元祖(如果是字典,默认将key作为元祖的元素)

reversed() *****

将一个序列翻转, 返回翻转序列的迭代器

slice ***

构造一个切片对象,用于列表切片

format **

与具体数据相关,用于计算各种小数,精算等

# print( format('test','<20'))

# print( format('test','>20'))

# print(format('test','^20'))

bytes() ****

把字符串转换成bytes类型

s = '你好太白'
bs = s.encode('utf-8')
print(bs)
结果:b'\xe4\xbd\xa0\xe5\xa5\xbd\xe6\xad\xa6\xe5\xa4\xa7'

s1 = bs.decode('utf-8')
print(s1)
结果: 你好太白

s = '你好'
bs = bytes(s,encoding='utf-8')
print(bs)
# 将字符串转换成字节

bs1 = str(bs,encoding='utf-8')
print(bs1)
# 将字节转换成字符串

bytearry

返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围:0<=x<256

ret = bytearray ('alex', encoding='utf-8')
print(id(ret))
print(ret)# bytearray(b'alex')
print (ret[0])#97
ret[0]=65
print(ret) # bytearray(b'Alex')
print(id(ret))

memoryview

ret= memoryview( bytes('你好', encoding='utf-8')
print(len (ret))
print (ret)
print(bytes(ret[: 3]). decode('utf-8'))
print(bytes(ret[3: ]). decode('utf-8'))

ord **

输入字符找该字符编码 unicode的位置

print(ord('a'))

print(ord('中'))

chx **

输入位置数字找出其对应的字符 unicode

print(chr(97))

print(chr(20013))

ascii **

是asci码中的返回该值,不是则返回他在 unicode的位置(16进制。)

print( ascii('a'))

print(ascii('中')) # '\u4e2d'

repr *****

返回一个对象的 string形式(原形毕露)。

repr( ) json pickle序列化模块特殊字符串, python字符串的区别

sorted *****

对所有可迭代的对象进行排序操作。

形成新的列表,原列表不变

enumerate

枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

all ***

可迭代对象中，全都是True才是True 多做条件判断

any ***

可迭代对象中，有一个True 就是True 多做条件判断

zip() *****

拉链方法。将多个iter 纵向组成一个个元祖

函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回

filter *****

筛选过滤

语法: filter(function,iterable)
function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据
iterable:可迭代对象
lst = [{'id':1,'name':'alex','age':18},
{'id':1,'name':'wusir','age':17},
{'id':1,'name':'taibai','age':16},]
ls = filter(lambda e:e['age'] > 16,lst)
print(list(ls))
结果:
[{'id': 1, 'name': 'alex', 'age': 18},
{'id': 1, 'name': 'wusir', 'age': 17}]

map

会根据提供的函数对指定序列做映射。循环模式

l1=[1,2,3,4]

print([i**2 for i in l1])

def func(x):
return x**2

print(list(map(func, l1))

重点

print sum reversed

含key: min max map sorted filter zip

匿名函数

语法:
　　函数名 = lambda 参数:返回值
1）此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func.
2）lambda 是定义匿名函数的关键字，相当于函数的def.
3）lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。
func = lambda a,b,*args,sex= 'alex',c,**kwargs: kwargs
print(func(3, 4,c=666,name='alex')) # {'name': 'alex'}
# 所有类型的形参都可以加，但是一般使用匿名函数只是加位置参数，其他的用不到。
4）返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型。
5）匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据

func = lambda a,b: a+b

print(func(3, 4)) # 7

匿名函数不单独使用,多于内置函数结合

可以放三元运算

lambda x: x if x>2 else x * 2

递归函数

人理解函数,神理解递归

所有递归能解决的,函数都能解决

Python3.8

经测试最大递归深度是996

i = 0
def fun():
global i
i += 1
print(i)
if i == 996: return
fun()
fun()

默认递归深度:998

可修改递归深度