python入门必备知识总结

人生苦短，我用python。看图说话

一.python简介与发展：

python 是一种面向对象的解释性计算机程序设计语言。

python由荷兰人Guido van Rossum 于1989年发明。

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

1994年1月 python 1.0诞生，增加lambda，map，filter and reduce

1999年，python web的鼻祖 Zope 1 发布

2000年10月16号 ，python2.0诞生，加入内存回收机制，构成现在Python语言框架

2004年11月30号，python 2.4诞生，同年web框架django诞生。

2006年11月19号，python 2.5诞生

2008年10月1号，  python2.6诞生

2008年12月3号，  python3.0诞生

2009年6月27号，  python3.1诞生

2010年7月3号，    python 2.7诞生

提示：由于python2.6与3.0差距较大，于是推出过渡版本，并于2014年十一月，宣布将支持Python 2.7至2020，并重申，将不会有2.8版本，用户将移动到Python 3.4

2011年2月20号， python3.2诞生

2012年11月29号，python3.3诞生

2014年3月16号，  python3.4诞生

2015年11月13号，python3.5诞生

二.目前python的主要应用领域：

　　云计算：云计算最火的语言，如：openstack

　　web开发：很多大型的网站均有python开发，如：Youtube，Dropbox，豆瓣等等，python的web框架：Django，flask

科学运算，人工智能：典型NumPy，SciPy, Matplotlib, Enthought librarys,pandas

　　运维：不会开发的运维，不是好运维，不会开发的运维，必将被淘汰

　　金融：量化交易，金融分析等等。。。

　　图形GUI：PyQT, WxPython,TkInter

三.python主要应用的公司：

　　YouTube、Instagram、豆瓣、Google、Yahoo等，NASA（美国航空航天局）等等。。。

四.python的优缺点：

　　优点：

　　1.Python的定位是“优雅”、“明确”、“简单”，"易学"，“免费”，“简单”。

　　2.开发效率非常高，Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、 CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。记住，只要 安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、 Twisted和Python图像库等等。 　

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

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

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

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

　　7.Python确实是一种十分精彩又强大的语言。它合理地结合了高性能与使得编写程序简单有趣的特色。

　　8.规范的代码。Python采用强制缩进的方式使得代码具有极佳的可读性。

五.python的种类：

　　1.Cpython:python的官网版本，使用C语言实现，使用最为广泛，Cpython实现会将源文件（py文件）转换成字节码（pyc文件），然后运行在python虚拟机上。

　　2.Jython：python的java实现，Jython会将python代码动态编译成Java字节码，然后在JVM上运行。

　　3.IronPython：python的C#实现，IronPython将Python代码编译成C#字节码，然后在CLR上运行。（与Jython类似）

　　4.PyPy（特殊） Python实现的Python，将Python的字节码字节码再编译成机器码

　　5.RubyPython、Brython ...

六.python与其他语言对比：

python与C对比：

　　python易学，易用，易懂。并且是一种脚本语言；python的类库齐全并且简单。

　　C语言：代码编译得到机器码，机器码在处理器上直接执行，每一条指令控制CPU工作，与底层硬件打交道

　　Python 和 C  Python这门语言是由C开发而来

　　对于使用：由于Python的类库齐全并且简洁，如果要实现同样的功能，Python 10行代码可以解决，C可能就需要100行甚至更多.
　　对于速度：Python的运行速度相较与C，很慢。

Python 和 C#对比：

　　python可以跨平台，可运行在linux、windows，osx等平台。

　　python开源，c#则相反

　　对于使用：Linux原装Python，其他语言没有；以上几门语言都有非常丰富的类库支持
　　对于速度：Python是解释性语言，C#需要编译，所以python运行要慢点

python与java对比：

　　开源方向来说，Python更有优势，Java（虽然最近Java已经开源了，但有一些开源协议上面的版权受限）；

　　对于使用：Python更简洁，Java过于庞大复杂（如Web服务器）

　　对于速度：于速度：Python是解释性语言，java需要编译，所以python运行要慢点

python与php对比：

　　Python的OO更加完善

　　Python可以开发桌面应用程序

python与ruby perl对比：

　　与ruby不同，OOP对于Python是可选的，所以Python不会强制用户选择OOP开发

七：python安装：

　　windows环境：

1、下载安装包
    https://www.python.org/downloads/
2、安装
    默认安装路径：C:\python27
3、配置环境变量
    【右键计算机】--》【属性】--》【高级系统设置】--》【高级】--》【环境变量】--》【在第二个内容框中找到 变量名为Path 的一行，双击】 --> 【Python安装目录追加到变值值中，用 ； 分割】
    如：原来的值;C:\python27，切记前面有分号

　　linux环境：

　　linux中自带python环境，如果想安装自己想要的版本（原本是2.6升级为2.7的版本），如下：

查看默认Python版本
python -V
1、安装gcc，用于编译Python源码
    yum install gcc
2、下载源码包，https://www.python.org/ftp/python/
3、解压并进入源码文件
4、编译安装
    ./configure
    make all
    make install
5、查看版本
    /usr/local/bin/python2.7 -V
6、修改默认Python版本
    mv /usr/bin/python /usr/bin/python2.6
    ln -s /usr/local/bin/python2.7 /usr/bin/python
7、防止yum执行异常，修改yum使用的Python版本
    vi /usr/bin/yum
    将头部 #!/usr/bin/python 修改为 #!/usr/bin/python2.6

到此为止，一下内容纯干货：

########################################################################################

第一个程序从hello world开始，并且这是2.7与3.6的打印区别：

title：python基础之数据类型与变量：

一 变量

变量：是用来存储值的所在处（保存状态），它们有名字和数据类型。变量的数据类型决定了如何将代表这些值的位存储到计算机的内存中。在声明变量时也可指定它的数据类型。所有变量都具有数据类型，以决定能够存储哪种数据

声明变量:

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

name = 'cyy'

　　上述代码声明了一个变量，变量名为： name，变量name的值为："cyy"　

　　定义：允许作为名字的有效字符串集合

• 名字必须有实际意义，可读性好
• 首字母必须是字母或下划线(_)
• 剩下的字符可以是字母和数字或者下划线
• 大小写敏感
• 两种风格：conn_obj或ConnObj
• 不能使用关键字，不能使用内建
• 变量名的第一个字符不能是数字
• 以下关键字不能声明为变量名
  ['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']

变量的赋值：

　　链式赋值：y＝x＝z＝1

　　

　　多元赋值：x,y=1,2 x,y=y,x

　

　　

　　增量/减量/乘量/除量 赋值：

　　

变量解压赋值：

　　

数据类型：数据类型是在数据结构中的定义是一个值的集合以及定义在这个值集上的一组操作。数据类型分类：

1、数字

int（整型）

python2.*与python3.*关于整型的区别

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

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
python3.*整形长度无限制

long（长整型）
　python2.*：

跟C语言不同，Python的长整型没有指定位宽，也就是说Python没有限制长整型数值的大小，
但是实际上由于机器内存有限，所以我们使用的长整型数值不可能无限大。
在使用过程中，我们如何区分长整型和整型数值呢？
通常的做法是在数字尾部加上一个大写字母L或小写字母l以表示该整数是长整型的，例如：
a = 9223372036854775808L
注意，自从Python2起，如果发生溢出，Python会自动将整型数据转换为长整型，
所以如今在长整型数据后面不加字母L也不会导致严重后果了。

python3.*
长整型，整型统一归为整型

eg：

　　
float（浮点型）

　　　浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

　　  整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差

 2、布尔值

　　真（True）或假（False）

　　0和空，None都是False，其他的全部为True

3、字符串

　　　特别声明：字符串是不可以修改的

创建字符串

　　a='hello word'

　　注：单引号和双引号没有任何区别

字符串常见方法：

name="zzl"
print(name.capitalize())#首字母变成大写
print(name.center(30)) # 居中
print(name.center(30,'*'))#居中加填充

msg='hello world'
print(msg.count('l'))#统计出现l在msg中出现的次数
print(msg.count('l',0,3))#统计l在msg中0到3之间l出现的次数
print(msg.count('l',-1))#统计l在msg中最后一个字符中出现l的次数
print(msg.endswith('s'))#判断msg是不是以s结尾，不是则为False，是为True
print(msg.startswith('h'))#判断msg是不是以h开头，不是则为False，是为True
print(msg.find('l'))#统计l出现的位置，如果不存在，则返回-1，存在返回位置，存在多个，只返回第一个出现的位置
print(msg.find('l',3,9))#统计l在msg的3到9之间，l出现的位置
print(msg.index('e'))#index与find本质区别是：index已经知道msg中存在e，然后进行查找，如果不存在会报错。
print(msg.isdigit())#判断字符串中是否包含数字,包含数字为False，不包含为True

msg='hello world'#多用于字符串拼接
msg_new='*'.join(msg)
print(msg_new)

msg='root:x:0:0:root:/bin/bash'
print(msg.split(':')) #split分割
print(msg.split(':',maxsplit=1))#以：为分割符，最大分割一次

msg_list=msg.split(':')
print(':'.join(msg_list))#按照：拼接字符串

msg='helLo world'
print(msg.upper())#小写转化为大写
print(msg.swapcase())#大小写转换

msg='*****zzl*****'
print(msg.strip('*'))#去掉首尾的指定字符
print(msg.lstrip('*'))#去除左边指定字符
print(msg.rstrip('*'))#去除右边指定字符

print(msg.replace('z','y')) #替换字符，不指定个数全部替换，指定几个就替换几个
print(msg.replace('z','y',1))

不常用的方法：

#不常用的方法
msg='hello world'
print(msg.isalpha())#msg是纯字母返回True，不是则返回False
print(msg.isidentifier())#msg是内置标识符，返回True，否则返回False
print(msg.isspace())#msg是空格，返回True，反之，返回False
print(msg.istitle())#msg是标题，也就是首字母大写，返回True
print(msg.ljust(10))#10个字符左对齐
print(msg.ljust(10,'*'))#10个字符左对齐,10个字符*填充
print(msg.rjust(10))#10个字符右对齐
print(msg.rjust(10,'*'))#10个字符右对齐,10个字符*填充
print(msg.zfill(20))#总长度20个，不足则在右边添加0

message='''aaa
bbb
ccc
ddd
'''
print(message.splitlines()) #按照行数切分

字符串索引，再看解压

msg='hello'
#字符串索引操作
print(msg[4])
print(msg[-2])
#字符串的切分操作
print(msg[0:3]) #切分原则：顾头不顾尾
print(msg[0:])
print(msg[:3])
print(msg[0:2000:2])#按两个字符切分
print(msg[::-1])#hello倒过来

#再看变量解压操作
msg='hello'
x,y,z,*_=msg
print(x)
print(y)
print(z)
x,y,z='abc','aaa','xxx'
print(x)
print(y)
print(z)

4、列表

列表的内置方法：

　　

name_list=['zzl','cyy','zl','cy']
#列表的索引操作
print(name_list[-1])
print(name_list[0:2])
print(name_list[::-1])
#列表的内置方法
#append增加到末尾
name_list=['zzl','cyy','zl','cy']
name_list.append('yy')
print(name_list)

#insert插入到指定位置
name_list=['zzl','cyy','zl','cy']
name_list.insert(0,'ylqh')
print(name_list)

#pop删除
name_list.pop()#默认从右边删除
name_list.pop(2)#指定删除第二个
print(name_list)
#清空列表
name_list=['zzl','cyy','zl','cy']
name_list.clear()
print(name_list)

#复制一份copy
name_list=['zzl','cyy','zl','cy']
i=name_list.copy()
print(i)

#计数
name_list=['zzl','cyy','zl','yy','cy','yy']
print(name_list.count('yy'))#yy出现了几次

#两个列表合并
name_list=['zzl','cyy','zl','cy']
nlist=['ylqi','lift']
name_list.extend(nlist)
print(name_list)
#单独加入列表
every_lis='xxx'
name_list.extend(every_lis)
print(name_list)

#remove移除
name_list=['zzl','cyy','zl','cy']
name_list.remove('zl')#按照元素名移除，有多个重复的元素值时，移除第一个
print(name_list)

#reverse反序排列
name_list=['zzl','cyy','zl','cy']
name_list.reverse()#反序
print(name_list)

#sort排列
name_list=['d','c','A','1','@','*']
name_list.sort()#按照字符编码表排列
print(name_list)

#统计列表有几个元素或说成列表的长度
name_list=['zzl','cyy','zl','cy']
print(len(name_list))#统计长度

#判断是否在列表里面
# name_list=['zzl','cyy','zl','cy']
print ('zl' in name_list)
print ('l' in name_list)

队列（先进先出）

队列
方法一：
lis=[]
lis.append(1)
lis.append(2)
lis.append(3)
lis.append(4)
print(lis)
print(lis.pop(0))
print(lis)
print(lis.pop(0))
print(lis)
print(lis.pop(0))
print(lis)
print(lis.pop(0))
print(lis)

方法二：
l=[]
l.insert(0,1)
l.insert(0,2)
l.insert(0,3)
l.insert(0,4)
print(l)
print(l.pop())
print(l)
print(l.pop())
print(l)
print(l.pop())
print(l)
print(l.pop())
print(l)

方法一 and 二 输出结果：

[4, 3, 2, 1]
1
[4, 3, 2]
2
[4, 3]
3
[4]
4
[]

堆栈：（先进后出）

#堆栈：(先进后出)

lis=[]
lis.append(1)
lis.append(2)
lis.append(3)
lis.append(4)
print(lis)
print(lis.pop())
print(lis)
print(lis.pop())
print(lis)
print(lis.pop())
print(lis)
print(lis.pop())
print(lis)

输出结果：
[1, 2, 3, 4]
4
[1, 2, 3]
3
[1, 2]
2
[1]
1
[]

5、元组(不可变列表)

 

6、字典（无序）

常用操作：

• 索引
• 新增
• 删除
• 键、值、键值对
• 循环
• 长度

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　座右铭：没有最好，只有更好