第一篇：Python入门
一、编程语言分类
编程语言主要从以下几个角度来进行分类
- 编译型和解释型
- 静态语言和动态语言
- 强类型定义语言和弱类型定义语言
编译型和汇编语言一样，有一个负责翻译的程序来对源代码进行转换，生成相对应的可执行代码。这个过程称为编译，而负责编译的程序称为编译器。如果我们写的程序都包含在一个源文件中，那么通常编译之后就会直接生成一个可执行的文件，我们就可以直接运行了。但对于一个比较复杂的项目，为了方便管理，通常会把代码分散在各个源文件中，作为不同的模块来组织。这时编译各个文件就会生成目标文件而不是前面说的可执行文件。一般一个源文件的编译都会对应一个目标文件。这些目标文件里的内容基本上已经是可执行代码了，但由于只是整个项目的一部分，所以还不能直接运行。待所有的源文件的编译都大功告成，我们就可以最后把这些半成品的目标文件“打包”成一个可执行文件了，这个工作由另一个程序负责完成，由于此过程好像是把包含可执行代码的目标文件连接装配起来，所以又称为链接，而负责链接的程序就叫链接程序。链接程序除了链接目标文件外，可能还有各种资源，像图标文件啊、声音文件啊什么的，还要负责去除目标文件之间的冗余重复代码等等。
编译型
优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。
缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。
解释型
优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。
缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。
动态语言和静态语言
通常我们所说的动态语言、静态语言是指动态类型语言和静态类型语言。
（1）动态类型语言：动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如VBScript也多少属于动态类型语言。
（2）静态类型语言：静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。
1、运行的过程中给对象绑定(添加)属性
2、运行的过程中给类绑定(添加)属性
3、运行的过程中给类绑定(添加)方法
4、运行的过程中删除属性、方法
强类型定义语言和弱类型定义语言
（1）强类型定义语言：强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。
（2）弱类型定义语言：数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。
强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。另外，“这门语言是不是动态语言”与“这门语言是否类型安全”之间是完全没有联系的！
例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。
二、Python应用领域
- WEB开发——最火的Python web框架Django, 支持异步高并发的Tornado框架，短小精悍的flask,bottle, Django官方的标语把Django定义为the framework for perfectionist with deadlines(大意是一个为完全主义者开发的高效率web框架)
- 网络编程——支持高并发的Twisted网络框架， py3引入的asyncio使异步编程变的非常简单
- 爬虫——爬虫领域，Python几乎是霸主地位，Scrapy\Request\BeautifuSoap\urllib等，想爬啥就爬啥
- 云计算——目前最火最知名的云计算框架就是OpenStack,Python现在的火，很大一部分就是因为云计算
- 人工智能——谁会成为AI 和大数据时代的第一开发语言？这本已是一个不需要争论的问题。如果说三年前，Matlab、Scala、R、Java 和 Python还各有机会，局面尚且不清楚，那么三年之后，趋势已经非常明确了，特别是前两天 Facebook 开源了 PyTorch 之后，Python 作为 AI 时代头牌语言的位置基本确立，未来的悬念仅仅是谁能坐稳第二把交椅。
- 自动化运维——问问中国的每个运维人员，运维人员必须会的语言是什么？10个人相信会给你一个相同的答案，它的名字叫Python
- 金融分析——我个人之前在金融行业，10年的时候，我们公司写的好多分析程序、高频交易软件就是用的Python,到目前,Python是金融分析、量化交易领域里用的最多的语言
- 科学运算—— 你知道么,97年开始，NASA就在大量使用Python在进行各种复杂的科学运算，随着NumPy, SciPy, Matplotlib, Enthought librarys等众多程序库的开发，使的Python越来越适合于做科学计算、绘制高质量的2D和3D图像。和科学计算领域最流行的商业软件Matlab相比，Python是一门通用的程序设计语言，比Matlab所采用的脚本语言的应用范围更广泛
- 游戏开发——在网络游戏开发中Python也有很多应用。相比Lua or C++,Python 比 Lua 有更高阶的抽象能力，可以用更少的代码描述游戏业务逻辑，与 Lua 相比，Python 更适合作为一种 Host 语言，即程序的入口点是在 Python 那一端会比较好，然后用 C/C++ 在非常必要的时候写一些扩展。Python 非常适合编写 1 万行以上的项目，而且能够很好地把网游项目的规模控制在 10 万行代码以内。另外据我所知，知名的游戏<文明> 就是用Python写的
三、Python解释器分类
CPython
当我们从Python官方网站下载并安装好Python 3.5后，我们就直接获得了一个官方版本的解释器：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代码在两种解释器下执行可能会有不同的结果。
Jython
Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。
IronPython
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
四、安装Python解释器
在Windows上安装Python
首先，根据你的Windows版本（64位还是32位）从Python的官方网站下载Python 3.5对应的64位安装程序或32位安装程序（网速慢的同学请移步国内镜像），然后，运行下载的EXE安装包：
注意勾上Add Python 3.5 to PATH，然后点“Install Now”即可完成安装。
使用命令安装ipython:
C:\Users\lee>pip install ipython
运行Python
安装成功后，打开命令提示符窗口，敲入python后，会出现两种情况：
情况一：
看到上面的画面，就说明Python安装成功！
你看到提示符>>>就表示我们已经在Python交互式环境中了，可以输入任何Python代码，回车后会立刻得到执行结果。现在，输入exit()并回车，就可以退出Python交互式环境（直接关掉命令行窗口也可以）。
情况二：得到一个错误：
‘python’ 不是内部或外部命令，也不是可运行的程序或批处理文件。
这是因为Windows会根据一个Path的环境变量设定的路径去查找python.exe，如果没找到，就会报错。如果在安装时漏掉了勾选Add Python 3.5 to PATH，那就要手动把python.exe所在的路径添加到Path中。
鼠标右键点击“计算机”---->属性---->高级系统设置---->高级---->环境变量---->双击系统变量下Path---->在变量值后面添加“;”以及Python安装路径，如：“;C:\Python34”
五、第一个Python程序
进入解释器的交互式模式：调试方便，无法永久保存代码
脚本文件的方式：永久保存代码
当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。（后缀名可是是任意的，但导入模块时只能是py后缀）
六、Python的运行过程
当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。
所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。
先检测有没有pyc这个文件，如果有再判断更新时间，pyc更新时间跟源文件更新时间对比
七、变量与常量
定义变量
变量名必须是大小写英文、数字和_的组合，且不能用数字开头
a = 123 # a是整数 print(a) a = \'ABC\' # a变为字符串 print(a) 这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错 变量在计算机内存中的表示： a = \'ABC\' Python解释器干了两件事情： 1、在内存中创建了一个\'ABC\'的字符串； 2、在内存中创建了一个名为a的变量，并把它指向\'ABC\'。
变量名不能是python关键字
>>> import keyword >>> keyword.kwlist [\'False\', \'None\', \'True\', \'and\', \'as\', \'assert\', \'break\', \'class\', \'continue\', \' def\', \'del\', \'elif\', \'else\', \'except\', \'finally\', \'for\', \'from\', \'global\', \'if\', \'import\', \'in\', \'is\', \'lambda\', \'nonlocal\', \'not\', \'or\', \'pass\', \'raise\', \'retu rn\', \'try\', \'while\', \'with\', \'yield\'] >>>
定义变量会有：id，type，value
#1 等号比较的是value， #2 is比较的是id #强调： #1. id相同，意味着type和value必定相同 #2. value相同type肯定相同，但id可能不同,如下 >>> x=\'Info Egon:18\' >>> y=\'Info Egon:18\' >>> id(x) 4376607152 >>> id(y) 4376607408 >>> >>> x == y True >>> x is y False
常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：
PI = 3.14159265359
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
八、用户与程序交互
输入与输出
#在py2中: print "My", print "name", print "is", print "lee" #My name is lee 使用逗号将多个print 语句合并到同一行时，Python 会增加一个空格。 #在py3中: 通过在行尾添加逗号使得打印的内容都在同一行的方法不再有效 print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出： >>> print(\'The quick brown fox\', \'jumps over\', \'the lazy dog\',end=\'\') end取消换行 The quick brown fox jumps over the lazy dog #参数sep默认值为空格
print(\'root\',\'x\',\'x\',\'0\',sep=":")
#root:x:x:0
#在python3中 input：用户输入任何值，都存成字符串类型 #在python2中 input：用户输入什么类型，就存成什么类型(当输入3+2时，会当作加法作运算其结果是5) raw_input：等于python3的input
注释
代码注释分单行和多行注释， 单行注释用#，多行注释可以用三对双引号""" """
代码注释的原则：
#1. 不用全部加注释，只需要在自己觉得重要或不好理解的部分加注释即可 #2. 注释可以用中文或英文，但不要用拼音
文件头
#!/usr/bin/env python # -*- coding: utf-8 -*- <==>#coding:utf-8 是通过正则去匹配的
第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，可以./xx.py 直接运行，Windows系统会忽略这个注释；
第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。python3中加不加都行
九、基本数据类型
数字
#int整型 定义：age=10 #age=int(10) 有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示 >>> 0xff00 65280 int类型在2.7中长度：32位 取值范围为-2**31～2**31-1,64位 取值范围为-2**63～2**63-1,type出来的超过长度则是long类型
在py3系列中 没有长度限制，由内存决定 type出来的都是int类型
在py3中没有long类型
#float浮点型 定义：salary=3.1 #salary=float(3.1)
对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9 <===>1230000000.0
>>> 0.1+0.2 0.30000000000000004 >>> print 0.1+0.2 0.3 对于0.1和0.2 之和Python 会用足够多的二进制位（比特）创建一个浮点数（小数）来保证15 个小数位。不过这个二进制数并不完全等于0.3，它只是相当相当接近。（在这里，误差是0.000000000000004。）这个差称为舍入误差（roundoff error）。 在交互模式中键入0.1+0.2 这个表达式时，Python 会显示它存储的原始数值，包括所有的小数位。使用print 时，你会得到期望的结果，因为print 更聪明一点，它很清楚要四舍五入显示0.3。
布尔True or False
1、None，0，空（空字符串，空列表，空字典等）三种情况下布尔值为False 2、其余均为真
字符串
#在python中，以单引号\'或双引号"括起来的任意文本就是字符串类型 定义：name=\'lee\' #name=str(\'lee\')
多引号作用就是多行字符串必须用多引号
msg = \'\'\'
今天我想写首小诗，
歌颂我的同桌，
你看他那乌黑的短发，
好像一只炸毛鸡。
\'\'\'
#字符串拼接 >>> name=\'lee\' >>> age=\'18\' >>> name+age #相加其实就是简单拼接 \'lee18\' >>> name*5 \'leeleeleeleelee\' #注意1：字符串相加的效率不高 字符串1+字符串2，并不会在字符串1的基础上加字符串2，而是申请一个全新的内存空间存入字符串1和字符串2，相当字符串1与字符串2的空间被复制了一次， #注意2：只能字符串加字符串，不能字符串加其他类型
不要用+号进行拼接,+号会开辟好几块内存空间 效率低
字符串转义
#\'I\\'m \"OK\"!\' 转义字符\ >>> print(\'\\\t\\\') \ \ >>> print(r\'\\\t\\\') r\'\'表示\'\'内部的字符串默认不转义 raw_string原生字符串 \\\t\\
字符串方法
1 1、expandtabs(self,tabsize=8) 设置tab键的长度 可以制作类似表格的排版 2 >>> s="abcdefg\t09090\tkkk" 3 >>> s.expandtabs(6) 6个字符一组\t空格长度由组长度减去占用字符长度 4 \'abcdefg 09090 kkk\' 5 2、center(20,fillchar=None) fillchar可填一个字符 中文 可有可无 6 >>> \'adb\'.center(20,\'中\') 7 \'中中中中中中中中adb中中中中中中中中中\' 8 3、find(self, sub, start=None, end=None) 找到了返回其所在索引位置，没找到返回-1 rfind从右往左找 9 >>> \'hello world\'.find(\'w\',2,8) 10 6 11 >>> \'hello world\'.find(\'w\',2,3) 12 -1 13 >>> \'hello world\'.find(\'w\') 14 6 15 4、index 没找到报错 rindex 16 >>> \'hello world\'.index(\'r\') 17 8 18 >>> \'hello world\'.index(\'z\') 19 Traceback (most recent call last): 20 File "<stdin>", line 1, in <module> 21 ValueError: substring not found 22 5、capitalize（整个字符串首字母大写） 23 >>> \'hello world\'.capitalize() 24 \'Hello world\' 25 6、title（每个单词首字母大写）、istitle 26 >>> \'hello world\'.title() 27 \'Hello World\' 28 7、count(\'xxx\',起始位置，结束位置) 位置可忽略 29 >>> \'hello world\'.count(\'o\') 30 2 31 8、encode、decode 32 python2 默认编码是\'ascii\' 33 #coding:utf-8 34 temp=\'李白\' 35 temp_unicode=temp.decode(\'utf-8\') 36 temp_gbk=temp_unicode.encode(\'gbk\') 37 注：SyntaxError: Non-ASCII character 原因是Python默认是以ASCII作为编码方式的，如果在自己的Python源码中包含了中文，此时即使你把自己编写的Python源文件以UTF-8格式保存了；但实际上，这依然是不行的 38 39 python3 默认编码是\'utf-8\' 40 移除了Python的unicode类型 字符串编码成unicode类型会报错 41 temp=\'李白\' 42 temp_gbk=temp.encode(\'gbk\') 43 44 unicode、gbk、utf-8 相互转换 45 对于py2:utf-8--->gbk 46 utf-8解码unicode编码gbk 47 py3.5: 48 utf-8编码成gbk 49 windows上输出 50 utf-8--->unicode 终端上gbk格式进行自动转换 51 9、endswith、startswith 52 >>> \'hello\'.endswith(\'lo\') 53 True 54 10、isalnum(字母数字)、isalpha(字母)、 55 >>> \'12hello\'.isalnum() 56 True 57 >>> 58 >>> \'sf\'.isalpha() 59 True 60 11、isdigit、isdecimal(是否是数字 不能是小数) isdigit比isdecimal更强 能识别"②"这个数字 61 isdecimal:十进制数 62 >>> \'234\'.isdecimal() 63 True 64 isdigit:支持特殊数字符号，不支持中文数字 65 >>> \'②\'.isdigit() 66 True 67 >>> \'二\'.isdigit() 68 False 69 isnumeric:即支持特殊数字符号，又支持中文数字 70 >>> \'二\'.isnumeric() 71 True 72 >>> \'②\'.isnumeric() 73 True 74 12、isprintable() 是否可打印，字符串包含\t \n这种不可见字符时为false 75 >>> \'abc\'.isprintable() 76 True 77 >>> \'abc\t\'.isprintable() 78 False 79 13、isidentifier() 判断是否是一个合法的标识符，即变量名 80 >>> \'as\'.isidentifier() 81 True 82 >>> \'$as\'.isidentifier() 83 False 84 14、lower、casefold（功能比lower更强，同样也可以转换大小写，如果其它语言中也有大小写关系，则可以用此方法，lower只适用于英文大小写转换）、islower 85 >>> \'ABC\'.lower() 86 \'abc\' 87 15、isspace 是否全部是空格 88 >>> \' \'.isspace() 89 True 90 16、upper、isupper 转换成大写 91 >>> \'abc\'.upper() 92 \'ABC\' 93 17、partition、rpartition 分割 94 >>> \'hello world\'.partition(\'l\') 95 (\'he\', \'l\', \'lo world\') 96 18、join 连接 97 >>> \'%%\'.join([\'1\',\'2\',\'3\']) #列表里面元素必须全是字符串 否则报错 98 \'1%%2%%3\' 99 19、ljust(width,fillchar)、rjust 100 >>> \'aa\'.ljust(5) 101 \'aa \' 102 20、strip、lstrip、rstrip 103 s.strip() 不仅可以去除两端的空格，还可以去除换行符，甚至可以传参数去除指定两端的字符s.rstrip(\'abc\') 只要字符串右边包含abc这三个字符中的某个则会删除该字符 104 >>> \' abc \'.strip() 105 \'abc\' 106 >>> \'ssabdcdd\'.strip(\'ss\') 107 \'abdcdd\' 108 21、replace 替换 109 >>> \'abc\'.replace(\'ab\',\'ef\') 110 \'efc\' 111 >>> \'abcabcabc\'.replace(\'ab\',\'ef\',2) 112 \'efcefcabc\' 113 22、split()（切除字符串中的空格和\t）、rsplit、splitlines（切除\n,\r\n）（返回一个列表） 114 >>> \'abc\tefg\'.split() 115 [\'abc\', \'efg\'] 116 >>> \'hello world\'.split() 117 [\'hello\', \'world\'] 118 >>> \'abcabcabc\'.split(\'a\',2) #切除a 切2个 119 [\'\', \'bc\', \'bcabc\'] 120 >>> \'abc\r\nefg\'.splitlines() 121 [\'abc\', \'efg\'] 122 >>> \'abc\r\nefg\'.splitlines(True) #splitlines(True) 切出来的内容保留\n 为False则不保留 123 [\'abc\r\n\', \'efg\'] 124 23、swapcase 小写转大写，大写转小写 125 >>> \'abc\'.swapcase() 126 \'ABC\' 127 >>> \'ABC\'.swapcase() 128 \'abc\' 129 24、zfill(50) 字符串长度不及50就用0填充 130 >>> \'abc\'.zfill(10) 131 \'0000000abc\' 132 >>> \'abc\'.zfill(2) 133 \'abc\' 134 25、format 135 >>> temp=\'my name is {0},age is {1}\' 136 >>> temp.format(\'lee\',30) 137 \'my name is lee,age is 30\' 138 >>> temp=\'my name is {name},age is {age}\' 139 >>> temp.format(name=\'lee\',age=30) 140 \'my name is lee,age is 30\' 141 >>> temp.format(**{\'name\':\'lee\',\'age\':30}) #参数中有**kwargs 都可以以字典的方式传值 142 \'my name is lee,age is 30\' 143 26、s.format_map({\'name\':\'lee\'}) 里面参数传键值对 144 27、maketrans: 145 >>> p=str.maketrans(\'abcdef\',\'123456\') #把abcdef转换成123456 要一一对应 否则报错 146 >>> \'leebai\'.translate(p) 147 \'l5521i\'
字符串切片
从左往右数 a[-1:-3] 取出来的则是空值 a = "abcdef" >>> a[::-2] \'fdb\' >>> a[5:1:-2] 如果是a[5:1]则取不到值，如果是a[5:1:-1]则取到的是fedc \'fd\' l=[1,2,3,4,5,6] #正向步长 l[0:3:1] #[1, 2, 3] #反向步长 l[2::-1] #[3, 2, 1] 将一个字符串进行反转 name[-1::-1] 或 name[::-1] 逆序 [起始位置:终止位置:步长] 步长控制着方向
字符串格式化
1 >>> "percent %.2f" % 99.97623444444 #保留2位小数，会自舍五入 默认小数点后面保存6位 2 \'percent 99.98\' 3 4 >>> "percent %.3s" % 99.97623444444 ##截取3位字符 5 \'percent 99.\' 6 7 打印百分比 8 >>> "percent %.2f %%" % 99.97623444444 9 #percent 99.98% 10 11 s=\'i am %(n1)s,age %(n2)d\'%{\'n1\':\'alex\',\'n2\':19} 12 s=\'i am %(n1)s,age %(n1)d\'%{\'n1\':\'alex\'} 13 14 s=\'i am %(n1)+10s,age %(n2)d\'%{\'n1\':\'alex\',\'n2\':20} 15 #i am alex,age 20 16 17 s=\'i am {:#b}asdf\'.format(12) 18 print(s) #i am 0b1100asdf 19 20 s=\'i am {:.2%} df\'.format(0.2) 21 print(s) #i am 20.00% df 22 23 tpl = "i am {}, age {}, {}".format("seven", 18, \'alex\') 24 #i am seven, age 18, alex 25 26 tpl = "i am {}, age {}, {}".format(*["seven", 18, \'alex\']) 27 #i am seven, age 18, alex 28 29 tpl = "i am {0}, age {1}, really {0}".format("seven", 18) 30 #i am seven, age 18, really seven 31 32 tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18]) 33 #i am seven, age 18, really seven 34 35 tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18) 36 #i am seven, age 18, really seven 37 38 tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18}) 39 #i am seven, age 18, really seven 40 41 tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33]) 42 #i am 1, age 2, really 3 43 44 tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1) 45 #i am seven, age 18, money 88888.100000 46 tpl = "i am {:s}, age {:d}".format(*["seven", 18]) 47 #i am seven, age 18 48 49 tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18) 50 #i am seven, age 18 51 52 tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18}) 53 #i am seven, age 18 54 55 tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2) #numbers: 1111,17,15,f,F, 1587.623000% 56 57 tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15) 58 #numbers: 1111,17,15,f,F, 1500.000000% 59 60 tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15) 61 #numbers: 1111,17,15,f,F, 1500.000000%
列表list
list是一种有序的集合，可以随时添加和删除其中的元素
定义：students=[\'lee\',\'jack\',\'chen\',] #students=list([\'lee\',\'jack\',\'chen\',]])
用于标识：存储多个值的情况
列表方法
1 #增加 append、insert、extend 2 >>> li=[11,22,33] 3 >>> li.append(\'李白\') 4 >>> li 5 [11, 22, 33, \'李白\'] 6 >>> li.insert(1,\'dd\') 7 >>> li 8 [11, \'dd\', 22, 33, \'李白\'] 9 >>> li.extend(\'abc\') #extend参数必须是可迭代对象 10 >>> li 11 [11, \'dd\', 22, 33, \'李白\', \'a\', \'b\', \'c\'] 12 13 #删除 pop、remove、del 14 >>> li.pop() #从末尾开始删除 15 \'c\' 16 >>> li 17 [11, \'dd\', 22, 33, \'李白\', \'a\', \'b\'] 18 >>> li.pop(2) #指定索引，则删除索引对应的值 19 33 20 >>> li 21 [11, \'dd\',33, \'李白\', \'a\', \'b\'] 22 >>> li.remove(\'dd\') #删除指定的值 23 >>> li 24 [11, 33, \'李白\', \'a\', \'b\'] 25 >>> del li[3] #指定索引，则删除索引对应的值 del li[3]==li.pop(3) 26 >>> li 27 [11, 33, \'a\', \'b\'] 28 >>> del li[2:4] #删除指定区间的值 左闭右开 29 >>> li 30 [11, 33] 31 32 #修改 33 >>> li[0]=22 34 >>> li 35 [22, 33] 36 >>> li[0:2]=[\'aa\',\'bb\'] 37 >>> li 38 [\'aa\', \'bb\'] 39 40 #查找 in、not in、index、count 41 >>> \'aa\' in li 42 True 43 >>> \'aa\' not in li 44 False 45 >>> li=[\'a\',\'b\',\'c\',\'d\',\'a\',\'b\'] 46 >>> li.index(\'a\') 47 0 48 >>> li.index(\'a\',1,5) #左闭右开区间 49 4 50 >>> li.count(\'a\') 51 2 52 53 #reverse 反转 54 >>> li 55 [\'a\', \'b\', \'c\', \'d\', \'a\', \'b\'] 56 >>> li.reverse() 57 >>> li 58 [\'b\', \'a\', \'d\', \'c\', \'b\', \'a\'] 59 60 #sort 排序 不同数据类型不能放在一起排序,否则报错 61 >>> li.sort() 62 >>> li 63 [\'a\', \'a\', \'b\', \'b\', \'c\', \'d\'] 64 65 #copy 浅拷贝 66 >>> aa=li.copy() 67 >>> id(li) 68 4930616 69 >>> aa 70 [\'a\', \'a\', \'b\', \'b\', \'c\', \'d\'] 71 >>> id(aa) 72 6016256 73 74 #clear 清空 75 >>> aa.clear() 76 >>> aa 77 []
字符串可以通过list()直接转换成列表 内部使用for循环
>>> list(\'abcdefg\') [\'a\', \'b\', \'c\', \'d\', \'e\', \'f\', \'g\']
列表转换成字符串
1、即有数字又有字符串 需要通过for循环一个一个处理 #a = [1, 2, 3, 4, 5, \'a\', \'b\'] #print(str(a)) #“[1, 2, 3, 4, 5, \'a\', \'b\']” 2、列表里只有字符串 使用字符串的join方法 "".join(li)
字符串存储时是一个连续的空间 不能修改 而列表存储是多个空间通过链表的形式串在一起 当进行修改时其本质就是对原有内容删除添加新的内容
快速获取列表头尾数据
>>> li=[1,2,3,4,5,6,7,8] >>> a,*_,c=li >>> a 1 >>> c 8 >>> a,*d,c=li >>> a 1 >>> d [2, 3, 4, 5, 6, 7] >>> c 8
sort与sorted区别？
li.sort()会改变原始序列li
sorted(li) 返回一个排好序的序列，不改变原始序列 li中有不同的类型数据 则排序会报错
为什么索引从0 而不是从1 开始？
二进制计数从0 开始。所以，为了最高效地使用比特位而没有任何浪费，内存位置和列表索引也都从0 开始。
append是把一个要添加的列表当作一个整体进行添加
extend是把一个要添加的列表里面的元素拆开来一个个进行添加
元组tuple
元组的元素一旦初始化就不能修改 有序的集合
tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向\'a\'，就不能改成指向\'b\'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的
>>> a=[11,22] >>> a=(11,22,[33,44]) >>> a[2].append(55) >>> a (11, 22, [33, 44, 55])
内置方法count、index
>>> a=(11,22,11,33,11)
>>> a.count(11) 3 >>> a.index(22) 1
只有1个元素的tuple定义时必须加一个逗号,来消除歧义 以免误解成数学计算意义上的括号
>>> t = (1,)
字符串、列表及元组之间相互转换
>>> s=\'abcdef\' >>> tuple(s) (\'a\', \'b\', \'c\', \'d\', \'e\', \'f\') >>> li=[11,22] >>> tuple(li) (11, 22) >>> tu=(11,22) >>> list(tu) [11, 22]
字典dict
使用键-值（key-value）存储，具有极快的查找速度
字典方法
1 #增加及修改 2 >>> dic={\'k1\':\'v1\'} 3 >>> dic.update({\'k2\':\'v2\'}) 4 >>> dic 5 {\'k2\': \'v2\', \'k1\': \'v1\'} 6 >>> dic.update(k1=123,k3=\'asdf\') #有相同的键则更新原字典，无相同的则创建 7 >>> dic 8 {\'k2\': \'v2\', \'k1\': 123, \'k3\': \'asdf\'} 9 >>> dic[\'k3\']=\'v3\' #有k3则修改值，无则创建 10 >>> dic 11 {\'k2\': \'v2\', \'k1\': 123, \'k3\': \'v3\'} 12 13 #删除 pop、popitem 14 >>> dic.pop(\'k1\') #需传入要删除的键 15 123 16 >>> dic 17 {\'k2\': \'v2\', \'k3\': \'v3\'} 18 >>> dic.popitem() #随机删除 19 (\'k2\', \'v2\') 20 >>> dic 21 {\'k3\': \'v3\'} 22 23 #查找 in、get 24 >>> \'k3\' in dic 25 True 26 27 #在不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值 28 >>> dic.get(\'k3\') 29 \'v3\' 30 >>> dic.get(\'k4\') #未找到返回None 31 >>> dic.get(\'k4\',123) #未找到返回一个默认值 32 123
其它方法
1 #sort方法 2 >>> s=[{\'name\':\'lee\',\'age\':18},{\'name\':\'lexxe\',\'age\':28},{\'name\':\'ylee\',\'age\':8}] 3 >>> s.sort(key=lambda x:x[\'age\']) 4 5 #formkeys方法 6 >>> n=dict.fromkeys([\'k1\',\'k2\',\'k3\'],\'alex\') 初始化一个新的字典 fromkeys静态方法 7 >>> n 8 {\'k1\': \'alex\', \'k2\': \'alex\', \'k3\': \'alex\'} 9 10 n={\'k1\':[],\'k2\':[],\'k3\':[]) 11 n=dict.fromkeys([\'k1\',\'k2\',\'k3\'],[]) 12 区别：下者k1,k2,k3共用同一个列表 13 14 #keys方法 15 >>> aa={\'k1\': \'alex\', \'k2\': \'alex\', \'k3\': \'alex\'} 16 >>> aa.keys() 17 [\'k3\', \'k2\', \'k1\'] # py2得到的是一个列表 18 19 >>> aa={\'k1\': \'alex\', \'k2\': \'alex\', \'k3\': \'alex\'} 20 >>> aa.keys() 21 dict_keys([\'k2\', \'k1\', \'k3\']) #py3得到的是一个对象 生成器 可进行迭代 22 23 >>> aa.setdefault(\'k5\',\'zzzzz\') 24 \'zzzzz\' 25 >>> aa 26 {\'k5\': \'zzzzz\', \'k2\': \'alex\', \'k1\': \'alex\', \'k3\': \'alex\'} 27 n.setdefault("k5",‘zzzzz’]) key存在则返回当前key对应的值，key不存则返回设置的值 28 29 for i in info: 30 print(i,info[i]) 31 32 for k,v in info.items(): 33 print(k,v) 34 上面的比下面的高效，上面的是通过索查找，items要先把字典变成列表 35 36 #copy 浅拷贝 37 >>> bb=aa.copy() 38 >>> bb 39 {\'k5\': \'zzzzz\', \'k2\': \'alex\', \'k1\': \'alex\', \'k3\': \'alex\'} 40 >>> id(aa) 41 5620440 42 >>> id(bb) 43 5620920 44 45 #items方法 46 >>> bb.items() 47 dict_items([(\'k5\', \'zzzzz\'), (\'k2\', \'alex\'), (\'k1\', \'alex\'), (\'k3\', \'alex\')]) 48 49 #values方法 50 >>> bb.values() 51 dict_values([\'zzzzz\', \'alex\', \'alex\', \'alex\']) 52 53 #clear方法 54 >>> bb.clear() 55 >>> bb 56 {}
和list比较，dict有以下几个特点：
1、查找和插入的速度极快，不会随着key的增加而变慢；
2、需要占用大量的内存，内存浪费多。
而list相反：
1、查找和插入的时间随着元素的增加而增加；
2、占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法
字符串、元组、字典====》列表 都可以转换成列表
字典转换成列表时，列表中保存的只是字典中的key
>>> aa {\'k5\': \'zzzzz\', \'k2\': \'alex\', \'k1\': \'alex\', \'k3\': \'alex\'} >>> list(aa) [\'k5\', \'k2\', \'k1\', \'k3\']
集合set
无序的 key不能重复
要创建一个set >>> s = set([1, 2, 3])
>>> s=set((1,2,3) #{1, 2, 3}
>>> s=set({\'name\':\'lee\',\'age\':30}) #{\'age\', \'name\'}
>>>set(\'hello\') #{\'l\',\'o\',\'h\',\'e\'}
list_1=[1,4,4,5,7,8]
list_1=set(list_1) 快速去重
se={11,22,33} be={22,55} se.difference(be) #{11,33} #找se中存在，be中不存在的集合，返回结果变量接收 差集 x-y se.difference_update(be) #找se中存在，be中不存在的集合，并将结果更新自己 se.intersection(be) 交集 并返回结果 x&y se.intersection_update(be) 取交集 并更新自己 se.isdisjoint(be) 有交集是False,无交集是True se.issubset(be) be是否包含se se.issuperset(be) be的父序列是se se.pop() 移除元素并返回结果 不一定是最后一个元素 ， 元素是无序的 se={11,22,33,44} be={11,22,77,88} ret=se.symmetric_difference(be) #{33,44,77,88} 对称差集 x^y se.symmetric_difference_update(be) 同上，会更新se集合 se.union(be) 并集，返回一个新的集合给变量 x|y se.update(be) 并集，改变原se集合 可传入可迭代类型数据 se.add() 添加元素 se.discard(11) 移除元素 不存在的不报错 se.remove(11) 移除元素 不存在的报错 update([]) 添加多项 copy 浅复制 set()有pop clear add等方法 frozenset() 不可变集合 没有了增删改等方法 set((1,[2,3]))是错误的,key中包含列表 传入的参数必须是可hash的
十、基本运算符
算数运算符（+、-、*、/、%、**、//)
#Python中，有两种除法，一种除法是/： >>> 10 / 3 3.3333333333333335 #除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数： >>> 9 / 3 3.0 #还有一种除法是//，称为地板除，两个整数的除法仍然是整数： >>> 10 // 3 3 py2: 9/2=4 9/2=4.5 (导入模块 from __future__ import division)
比较运算符（==、!=、<>、>、<、>=、<=）
赋值运算符（=、+=、-=、*=、/=、%=、**=、//=）
逻辑运算符（and、or、not）
身份运算
#is比较的是id #而==比较的是值
十一、流程控制
条件判断 if.....else if...elif...else
age_of_girl=18 if age_of_girl > 30: print(\'阿姨好\') else: print(\'小姐好\')
for循环
for temp in card_infors: if temp["name"]==find_name: print("找到了。。。") break else: #只有在for循环结束之后才会执行，但循环中有break时不会执行 print("没有找到")
for i in range(0,10,2): 打印偶数
print(i)
for i in range(1,10): for j in range(1,i+1): print(\'%s*%s=%s\' %(i,j,i*j),end=\' \') print()
#分析 \'\'\' #max_level=5 * #current_level=1，空格数=4，*号数=1 *** #current_level=2,空格数=3,*号数=3 ***** #current_level=3,空格数=2,*号数=5 ******* #current_level=4,空格数=1,*号数=7 ********* #current_level=5,空格数=0,*号数=9 #数学表达式 空格数=max_level-current_level *号数=2*current_level-1 \'\'\' #实现 max_level=5 for current_level in range(1,max_level+1): for i in range(max_level-current_level): print(\' \',end=\'\') #在一行中连续打印多个空格 for j in range(2*current_level-1): print(\'*\',end=\'\') #在一行中连续打印多个空格 print()
while循环
while 条件: # 循环体 # 如果条件为真，那么循环体则执行，执行完毕后再次循环，重新判断条件。。。 # 如果条件为假，那么循环体不执行,循环终止 while....else...语句 else只有在while不成立时执行 循环中有break时不会执行
break和continue
break语句可以在循环过程中直接退出循环
continue语句可以提前结束本轮循环，并直接开始下一轮循环。
这两个语句通常都必须配合if语句使用。
三元运算
name=值1 if 条件 else 值2 #为真则返回值1，否则返回值2
十二、开发工具
1 为何要用IDE
到现在为止，我们也是写过代码的人啦，但你有没有发现，每次写代码要新建文件、写完保存时还要选择存放地点，执行时还要切换到命令行调用python解释器，好麻烦呀，能否一气呵成，让我简单的写代码？此时开发工具IDE上场啦，一个好的IDE能帮你大大提升开发效率。
很多语言都有比较流行的开发工具，比如JAVA 的Eclipse, C#,C++的VisualStudio, Python的是啥呢？ Pycharm，最好的Python 开发IDE
2 安装
下载地址:https://www.jetbrains.com/pycharm/download 选择Professional 专业版
Comunnity社区版是免费的，但支持的功能不多，比如以后我们会学的Django就不支持，所以还是用专业版，但专业版是收费的，一年一千多，不便宜。唉，万能的淘宝。。。不宜再多说啦。
注册完成后启动，会让你先创建一个项目，其实就是一个文件夹，我们以后的代码都存在这里面
3 创建目录
你以后写的项目可能有成百上千个代码文件 ，全放在一起可不好，所以一般把同样功能的代码放在一个目录，我们现在以天为单位，为每天的学习创建一个目录day1,day2,day3...这样
4 创建代码文件
5 执行代码