Python详细介绍及使用(基础篇)

当前位置:

首页 > temp > python入门教程 >

Python详细介绍及使用(基础篇)

Python的由来：1989年，为了打发圣诞节假期，Guido开始写Python语言的编译/解释器。Python来自Guido所挚爱的电视剧Monty Python's Flying Circus (BBC1960-1970年代播放的室内情景幽默剧，以当时的英国生活为素材)。他希望这个新的叫做Python的语言，能实现他的理念(一种C和shell之间，功能全面，易学易用，可拓展的语言)。

1991年，第一个Python编译器(同时也是解释器)诞生。它是用C语言实现的，并能够调用C库(.so文件)。从一出生，Python已经具有了：类(class)，函数(function)，异常处理(exception)，包括表(list)和词典(dictionary)在内的核心数据类型，以及模块(module)为基础的拓展系统。

Python语法很多来自C，但又受到ABC语言的强烈影响。（ABC语言旨在替代BASIC，Pascal等语言-Python创始人Guido van Rossum于20世纪80年代曾在ABC系统开发中工作了数年）今天Python已经进入到3.0的时代。由于Python 3.0向后不兼容，所以从2.0到3.0的过渡并不容易。另一方面，有人说Python的运算性能低于C++和Java，Python的性能依然值得改进。

一、Python基本概念及环境配置

1、基本概念

Python是一种解释型语言，边执行边编译。但是这样会影响执行效率，通常编译型语言的效率比解释型语言高。不过解释型语言对平台的依赖性更低。

Python优势：代码量少、可移植性、有丰富的库。胶水语言，可以将python和非python所编写出来的库，让python进行调用。

python诞生于1989年。Python开发的网站：知乎，拉钩，果壳，豆瓣，youtobe......

Python语言设计的哲学：优雅、明确（尽量使用一种方式做一件事）、简单

Python可设计的领域:系统编程、GUI、网络编程(爬虫...)、Web编程、数据库编程...

Python运行时都需要生产字节码文件，交由虚拟机来处理。当我们在运行python文件程序的时候，python解释器将源码转换为字节码，然后由解释器来执行这些字节码，以求重复执行时更快更高效。不像java那样要先编译才能再执行，python可以边执行边编译。[java比较特殊，java这个编译过程并不是直接编译成机器语言，而是将其编译成字节码文件，由JVM将字节码文件翻译成机器语言，由此很好的实现了跨平台的特性]

注：解释性语言是指他们都有自己的解释器，也可以通俗的理解为翻译器（计算机本身是不能直接理解高级语言的，只能直接理解机器语言，所以必须把高级语言翻译成机器语言），解释性语言对平台的依赖相对较小，但是在执行过程中要比编译性语言的效率低。

编译型语言：在程序执行前，有一个单独的编译过程，将程序直接翻译成机器语言。以后执行这个程序的时候就不需要再进行翻译了。

Python 2.7 是 2.x 系列中的最后一个主版本，于2010年7月3日发布。因为Python 维护人员已将新功能开发工作的重点转移到了 Python 3.x 系列中。这意味着，尽管 Python 2 会继续修复bug并更新，以便在新的硬件和支持操作系统版本上正确构建，但不会有新的功能发布。Python 3.0实现了很多非常有用的功能，并打破了向后兼容性。

2、环境变量配置

安装完成后(如果安装时未添加环境变量)，要进行环境变量配置[是为了在任何目录下都可以执行python命令]

a)进入计算机-属性-高级系统设置-高级-环境变量

b)找到Path变量，再最后面加入Python的安装路径。

c)win+R 输入cmd，在DOS下输入python,回车出现如图所示，则说明环境变量配置好了

二、运行python

1、命令行上的交互式解释器

1.1、交互式解释器

a)直接启动python(command line)

b)可以使用DOS启动（运行cmd，使用python启用）

但是这种交互式模式下，执行完成后很难再次运行。因此保存为.py程序。

1.2、python 命令运行脚本

使用命令运行【xxx.py】程序。python xxx.py

1.3、在编写成.py文件时要注意的问题

在python3.x中的默认编码为【utf-8】，而在Python2.x中，默认编码为ASCII，如果没有声明，文件中又包含非ASCII编码的字符（如:中文），解析文件的时候就会报错（Non-ASCII character）

如果是python2.x我们需要运行.py命令，在创建文件时，我们需要在头部文件中声明编码格式。为什么要声明字符编码格式?如果没有此文件的字符编码类型的声明，则按照默认编码去处理。

在头部声明编码格式（一般在第一行或第二行，#coding = utf-8告诉python解释器按照utf-8读取源代码）：

方式一:

#coding=<encoding name> 例如：#coding = utf-8 只能放在首行

方式二：

#！/user/bin/python

#-*-coding<encoding name>-*- 例如：# -*- coding: utf-8 -*-

方式三:

#！/user/bin/python

#vim:set fileencoding=<encoding name> 例如：#vim:set fileencoding=utf-8

说明：#！/user/bin/python（#解释:这句话是表明在unix/linux下执行脚本时，要启动的解释器，是/usr/bin下面的python解释器）具体的后面说明。

2、如何生成.pyc/.pyo字节码文件

前面说到python是解释型语言，但是我们再执行的时候并没有看到有生成字节码文件呀？

python虚拟机执行过程：

a)完成模块的加载和链接

b)由编译器（Complier）将源代码翻译为PyCodeObject对象（也就是字节码.pyc/.pyo）,并将其写入内存当中

c)从上诉内存当中（方便CPU的读取）读取指令，并执行

d)程序结束后，根据命令行调用情况（取决于程序的方式），决定是否将PyCodeObject写会硬盘当中

e)后续再执行此脚本的时候，会先检查本地是否有上诉字节码文件，若有则执行，否则重复上述步骤。

为什么不直接生产这些文件？其实虚拟机也是讲究效率的，对于较大的项目如果要将PyCodeObject写会硬盘中，不可避免的要花些时间，而且我们也不知道这个程序是不是只执行一次。

Python虚拟机（PVM）种类：

a)CPython:原始、标准的实现。平时用的就是Cpython。可以调用C实现的类库，虽然Jpython，IronPython也可以。但是Cpython调用java实现的类库就会麻烦一些

b)Jython：用于与java语言集成的实现。可以直接调用外部的java类库

c)IronPython：用于与.NET框架集成的实现。

直接执行py文件不会自动生成字节码文件，需要手动编译一下：

python [options] [args]

python 命令选项说明

-d 提供调试输出

-O 生产优化的字节码（.pyo文件）

-S 不导入site模块以在启动时查找Python路径

-v 冗余输出（导入语句详细追踪）

-m mod 将一个模块以脚本形式运行（相当于脚本中的import）

-Q opt 除法选项

-c cmd 运行以命令字符串形式提交的Python脚本

file 从给定的文件运行Python脚本

2.1、方式一：命令方式

#语法：

# 单个文件

python -m py_compile xxx.py

# 批量（目录）

python -m compileall /../path

1）使用[py_compile模块]生成.pyc字节码文件

2）生成优化的字节码文件[.opt-1.pyc/.opt-2.pyc/.pyo]

3）也可以整个目录一起生成字节码文件[compileall模块]

注：__pycache__目录下不同版本的模块可以共存。python的编译可以有两层优化，-O和-OO，都是编译出.pyo文件，但从文件后缀上，看不出使用的是哪一层优化。这会导致一些使用上的问题。

因此，从python3.5开始，__pycache__目录下，就不会再有.pyo文件了。PEP 488提出的新的方案，还是回到.pyc文件，使用opt-1和opt-2来区分优化层级。

2.2、方式二：脚本方式

# 语法

import py_compile

>>> if __name__=='__main__':

py_compile.compile('c:\hello.py')

>>> import compileall

>>> if __name__=='__main__':

compileall.compile_dir('C:\\hello\\')

在交互式解释器上运行(安装好Python后，会有一个IDLE)

python的集成开发环境有很多，比如： PythonWin、PyCharm、Komodo Edit等等

三、Python基础知识

1、基础知识概述

Python程序可以分解成包、模块、语句、表达式以及对象。

a)程序由包/模块/函数组成（包是由一系列模块组成）

b)模块包含语句

c)语句包含表达式

d)表达式建立并处理对象

Python中的内置对象包括：数值类、字符串、列表、字典、元组、文件、集合、编程单元类型（函数、模块、类）等。

注：包必须包含至少一个__init__.py该文件的内容可以为空。__init__.py用于标识当前文件夹是一个包。例如：lib目录中的xml包。

1.1、Python语句中的基本规则和特殊字符

在Python中，代码块通过缩进对齐表达式，而不是使用{}来对齐，因为已经没有额外的字符来对齐表达式了，一般缩进4个字符。

特殊符号

说明

#（井号）

注释。可以从一行的任何地方开始。

\（反斜杠）

表示续行。

；（分号）

同一行放多个语句，用分号隔开。

：（冒号）

将代码块的头和体分开。

续行

>>> x=0

>>> if \ #注：续行

x<3:

print'True'

>>> x=0

>>> if x<3: #注：等效方式

print 'True'

1.2、Python中的标识符

注：常量通常定义于模块级别并且所有的字母都是大写，单词用下划线分开。例如MAX_OVERFLOW和TOTAL。

1.3、关键字

Python KeyWords

and

assert

break

class

continue

def

del

elif

else

except

exec

finally

for

from

global

import

lambda

not

pass

raise

return

try

while

with

yield

None

1.4、变量赋值

Python是动态类型语言，也就是说不需要预先声明变量的类型。变量的类型在赋值那一刻被初始化。Java是静态类型语言，适用前需声明变量类型。[变量名没有类型，对象才有，即类型是属于对象的，而不是变量]

>>> aInt = 1 #注：不需要预先声明变量的类型

>>> name = '字符串'

>>> del aInt

>>> aInt #注：删除数值类型对象，删除后无法使用，再次输出会报错

Traceback (most recent call last):

File "<pyshell#15>", line 1, in <module>

aInt

NameError: name 'aInt' is not defined

注：在交互式模式下，变量名“_”用于保存最后输出的表达式的结果

>>> a=1

>>> a

>>> _

>>> b=3

>>> b

>>> _

>>>

1.4、运算符或操作符

运算符优先级

运算符

0、定义/操作符

(...),[...],{...} 索引切片点操作符

1、乘方

** 注：**表示乘方运算符

2、单目运算符

+（正） -（负）~（取反）

3、乘/除/取余

*, /, //,% 注：//返回数字序列中比真正的商小的最接近的数值

4、加/减

+ , -

5、按位移

<< , >> 向左，向右按位移

6、按位与

7、按位异或、或

^ , |

8、关系比较

<, <= ,>,>= ,== ,!=,<>

9、身份成员操作

is ,is not in,not in

6、逻辑运算符

and , or , not

操作符说明

身份操作符：is :判定左端对象引用是否等同于右端对象的引用。

比较操作符：< , >,<=,>=,!=,==

成员操作符：in , not in (测试成员关系)

逻辑运算符：and ,or ,not

type:用于返回对象的类型，对象的类型本身也是一个对象，称为对象的类。

==：比较值是否相同。与java中有区别。

其他操作符

索引：x[i] 切片：x[i:j],x[i:j:stride]

元组：(...) 序列：[...] 字典：{...}

注：运算符 / 和 // 的区别

>>> print(3.2/1)

3.2

>>> print(3.2//1) #注：返回真正的比商小的最接近的数值

3.0

>>> print(3.8//1) #注：返回真正的比商小的最接近的数值

3.0

>>>

1.5、输入/输出

Python 的 print 语句，与字符串格式运算符( % )结合使用，可实现字符串替换功能，这点和 C 语言中的 printf()函数非常相似。在python3.x中print语句变更为print(...)函数

>>> print "%s is number %d!" % ("Python", 1) #2.7版本

Python is number 1!

>>> print("%s is number %d" %("Python",1)) #3.8版本

Python is number 1

注：%s 表示由一个字符串来替换，而%d 表示由一个整数来替换，另外一个很常用的就是%f，它表示由一个浮点数来替换。

Python解释器提供了3种标准的文件对象，分别是标准输入、标准输出和标准错误，他们分别在sys模块中分别以sys.stdin、sys.stdout和sys.stderr形式提供。

注：在2.x版本中实质上print语句只是sys.stdout.write()的简单接口，再加上了一些默认的格式设置。

1.5.1、使用内建函数输入：input()

在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了python2.x中的raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。

>>> user = input('Enter login name:') #注：所有的输入都被当做字符串返回

Enter login name:username

>>> print(user)

username

>>>

我们可以使用：help(input) --- 查看input使用说明：

>>> help(input)

Help on built-in function input in module builtins:

input(prompt=None, /)

Read a string from standard input. The trailing newline is stripped.

The prompt string, if given, is printed to standard output without a

trailing newline before reading input.

If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.

On *nix systems, readline is used if available.

大致翻译意思：从标准输入读取字符串。后面的换行符被剥离，以换行作为输入结束的标志的。

2、Python对象

2.1、基本概念

在Python中，可以说一切皆对象。所有的python对象都拥有三个特性：身份、类型和值。

1）身份：每一个对象都有一个唯一的身份标识自己，可以使用内建函数id()来得到，这个值可以被认为是内存地址。

2）类型：每个对象的类型决定了该对象可以保持什么类型的值，可以进行什么样的操作，可以使用内建函数type()查看对象的类型。任何对象都是由类实例化而来的，所以type()返回的是对象，而不是简单的字符串。

3）值：对象表示的数据项。

例如：

>>> name='jerry'

>>> id(name)

49245552

>>> type(name)

>>> name

'jerry'

解释：49245552是对象的身份（内存中的地址）<class 'str'>是对象的类型 'jerry'是对象的值

2.2、对象比较

a）身份比较：使用is操作符

b)类型比较：使用type()函数

c)值比较：使用==操作符

>>> a=123

>>> b=123

>>> a is b #注：等价于等价于id(a)=id(b)

True

>>> print(id(a),id(b))

8791550600672 8791550600672

>>> type(a) is type(b)

True

>>> a==b

True

3、python中的数据类型

3.1、基本数据类型

注：python3.x中整型是没有限制大小的，可以当作 long 类型使用，所以 Python3.x 没有 Python2.x 的 long 类型。[列表，字典是可变类型] [数值类型,字符串，元组是不可变类型]

3.2、其他内建类型

类型分类类型名称描述

可调用 types.BuiltinFunctionType 内置函数或方法

可调用 type 内置类型和类的类型

可调用 object 所有类型和类的祖先

可调用 types.FunctionType 用户定义的函数

可调用 types.MethodType 类方法

模块 types.ModuleType 模块

类 object 所有类型和类的祖先

类型 type

内置类型和类的类型

None Type(None) 空对象None

。。。。。。。。。

注：什么是Null对象，什么是（type）类型

>>> type(42)

<type 'int'> #注：42是一个int型对象

>>> type(type(42))

<type 'type'> #注：2.x中类型的对象就是type

>>> type(type(42)) #注：3.x中

>>> type(None)

解释：None 是Python 特殊的数据类型NoneType,它是一个空值可将None 赋值给任何数据类型，但不能创建其他NoneType对象。

python2.x中所有类型对象的类型都是type。它也是所有python类型的根和所有python标准类的默认元类。就像java中所有对象的根对象是Object一样。而在python3.x中统一了类（class）和类型(type)，使得整体结构更为清晰，更容易理解，更接近于class的面相对象的思想。

# 在 Python 2.x，你得显式写出自定义的类继承于object:

class C(object):

pass

# 在 Python 3.x,不用显式写出object,如果你不写，则自动继承于object:

class C:

pass

object是任何类的基类，任何类（如str,list,tuple,dict等内置数据结构以及自定义的类）在创建时都继承自object类，在Python3.x以后的版本中，可以不用手写继承object，会有系统自动添加继承自object类。object同时也是type的实例，type的基类是object。

Python3.x除了在object中新增了一些方法，还有一个区别就是：Python 3.x中默认都是新式类,经典类被移除，没必要显式的继承object，Python 2.x中默认都是经典类，只有显式继承了object才是新式类

新式类：采用算法是广度优先搜索，经典类：采用算法是深度优先搜索。

广度优先（D-B-C-A），是先找距离D最近的从左到右没找到则会继续往上一层找，而深度优先（D-B-A-C），是先找完B在找C。

————————————————

原文链接：https://blog.csdn.net/xiaoxianer321/article/details/116723566

栏目列表