Python详细介绍及使用(基础篇)
Posted 穆瑾轩
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python详细介绍及使用(基础篇)相关的知识，希望对你有一定的参考价值。
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 /../path1）使用[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 | as | assert | break | class |
| continue | def | del | elif | else |
| except | exec | finally | for | from |
| global | if | import | in | is |
| lambda | not | or | 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
1
>>> _
1
>>> b=3
>>> b
3
>>> _
3
>>> 1.4、运算符或操作符
| 运算符优先级 | 运算符 |
| 0、定义/操作符 | (...),[...],{...} 索引切片 点操作符 |
| 1、乘方 | ** 注：**表示乘方运算符 |
| 2、单目运算符 | +（正） -（负）~（取反） |
| 3、乘/除/取余 | *, /, //,% 注：//返回数字序列中比真正的商小的最接近的数值 |
| 4、加/减 | + , - |
| 5、按位移 | << , >> 向左，向右按位移 |
| 6、按位与 | & |
| 7、按位异或、或 | ^ , | |
| 8、关系比较 | <, <= ,>,>= ,== ,!=,<> |
| 9、身份成员操作 | is ,is not in,not in |
| 6、逻辑运算符 | 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)
<class 'str'>
>>> 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
True3、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中
<class 'type'>
>>> type(None)
<type 'NoneType'>
解释：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:
passobject是任何类的基类，任何类（如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。
第二章 基本数据类型
一、数值类型
1、数值类型概述
数值类型是不可变类型，包括以下几种：
1)整数类型：int(有符号整数) 例如：（正数）84 （负数）-237 （16进制）0x80
长整型： long(长整型) 例如：-8888888l 0xDCDCDCFDDFL
注：2.3版本后L可有可无，不会溢出,3.x中已经没有该类型了
2)布尔值：bool(布尔值) 例如：True = 1 False = 0 注：首字母是大写
3)浮点型：float(浮点值) 例如：3.14159 4.2E-10
注：4.2E-10 表示4.2*10的10次方（E也可小写）
4)复数： complex(复数) 例如：6.23+1.5j
注：6.23是复数的实部 1.5是复数的虚部 j是虚数单位
解释：不可变类型:Python中和javascript一样，一切皆对象。对于不可变类型，我们对其任何的修改都会重新创建一个新的对象。Python和java特性很接近，各种内存对象，在不被引用时，会自动的由垃圾收集器回收。[当一个内存对象的引用计数为0时，就会在适合的时机被回收]
扩展：python中的bool值
Python中的bool的值：True和False。目前来说True和False还不是关键字。python中真假的含义：
a)非零数为真，否则为假(0是假)
b)非空对象为真，否则为假(对象在本质上不是真就是假）
c)None始终为假。
例如：
>>> class C:pass
>>> c = C()
>>> bool(c)
Truepython中，and和or运算符返回真或假的对象，而不是True或False。
and 两者为真返回后者，两者为假返回前者，一真一假返回假
or 两者为假返回后者，两者为真返回前者，一真一假返回真
not: 返回 True或False
例如：
>>> d1={} #空对象，真假性-为假
>>> d2={'a':1} #非空对象，真假性-为真
>>> d3={'b':2}#非空对象，真假性-为真
>>> d4=d2 and d3#两者为真，返回后者d4={‘b’:2}，两者为假返回前者
>>> d4=d1 and d2 #一真一假，返回假d4={}
注：and和or本质是短路操作符,and遇到假短路,or遇到真短路后面不再判断2、数值类型的工厂函数
| 类（工厂函数） | 描述 |
| bool(obj) | 返回obj对象的布尔值 |
| int(obj [,base=10]) | 返回一个字符串/数值对象的整数表示 |
| float(obj) | 返回一个字符串或数值对象的浮点数表示 |
| Complex(str) /complex(real,image=0.0) | 返回一个字符串的复数表示或根据给定的实数生成一个复数对象 |
例如：
>>> int(4.22)
4
>>> long(4) #注：python3.x版本中已经去掉了该类型，统一使用int
4L
>>> float('4')
4.0
>>> complex(4)
(4+0j)
>>> complex(2,3)
(2+3j)
2.1、扩展-工厂函数和内置函数的区别
Python一切事物都是对象，对象基于类创建。Python 2.2 统一了类型和类，以前的内建转换函数，现在都成了工厂函数。类型工厂函数：看上去像函数，实质上他们是类。调用他们的时候，实际上生成了该类型的一个实例。他不是通过类而是通过函数来创建对象。
熟悉的工厂函数，（以前版本里的这些叫内建函数）：int(),long(),float(),complex(),str(),unicode(),basestring(),list(),tuple(),type()
后来添加的工厂函数：dict(),bool(),set(),frozenset(),object(),classmethod(),staticmethod(),super(),property()...等等
我们找到源码：bltinmodule.c
#源码：bltinmodule.c -- Python-2.0.1
static PyMethodDef builtin_methods[] = {
...
{"int", builtin_int, 1, int_doc},
{"isinstance", builtin_isinstance, 1, isinstance_doc},
{"issubclass", builtin_issubclass, 1, issubclass_doc},
{"len", builtin_len, 1, len_doc},
{"list", builtin_list, 1, list_doc},
{"locals", builtin_locals, 1, locals_doc},
{"long", builtin_long, 1, long_doc},
...
}
#源码：bltinmodule.c -- Python-3.8.5
PyObject *
_PyBuiltin_Init(void)
{
...
SETBUILTIN("None", Py_None);
SETBUILTIN("Ellipsis", Py_Ellipsis);
SETBUILTIN("NotImplemented", Py_NotImplemented);
SETBUILTIN("False", Py_False);
SETBUILTIN("True", Py_True);
SETBUILTIN("bool", &PyBool_Type);
SETBUILTIN("memoryview", &PyMemoryView_Type);
SETBUILTIN("bytearray", &PyByteArray_Type);
SETBUILTIN("bytes", &PyBytes_Type);
SETBUILTIN("classmethod", &PyClassMethod_Type);
SETBUILTIN("complex", &PyComplex_Type);
SETBUILTIN("dict", &PyDict_Type);
SETBUILTIN("enumerate", &PyEnum_Type);
SETBUILTIN("filter", &PyFilter_Type);
SETBUILTIN("float", &PyFloat_Type);
SETBUILTIN("frozenset", &PyFrozenSet_Type);
SETBUILTIN("property", &PyProperty_Type);
SETBUILTIN("int", &PyLong_Type);
SETBUILTIN("list", &PyList_Type);
SETBUILTIN("map", &PyMap_Type);
SETBUILTIN("object", &PyBaseObject_Type);
SETBUILTIN("range", &PyRange_Type);
SETBUILTIN("reversed", &PyReversed_Type);
SETBUILTIN("set", &PySet_Type);
SETBUILTIN("slice", &PySlice_Type);
SETBUILTIN("staticmethod", &PyStaticMethod_Type);
SETBUILTIN("str", &PyUnicode_Type);
SETBUILTIN("super", &PySuper_Type);
SETBUILTIN("tuple", &PyTuple_Type);
SETBUILTIN("type", &PyType_Type);
SETBUILTIN("zip", &PyZip_Type);
...
}
内建函数：内建函数也叫内置函数，不需要导入任何包/模块就能直接使用的函数。而工厂函数，简单的理解就是被重新封装的类型,通过工厂函数来创建类的实例化。例如：
>>> age = int(-19)
>>> age
-19
>>> age.__abs__()
19
>>> dir(age)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> 说明： 使用int()工厂函数创建一个数字对象age,这个对象拥有int对象的很多方法，我们用dir(age)将其方法输出，调用对象的__abs__()，输出19.这就是工厂函数。
3、其他常用内建函数
| 函数 | 功能 |
| abs(num) | 返回num的绝对值 |
| coerce(num1,num2) | 将num1和num2转换为同一类型，然后以元组的形式返回 |
| divmod(num1,num2) | 除法-取余运算的结合。返回一个元组（num1/num2,num1%num2） |
| pow(num1,num2[,mod=1]) | 取num1的num2次方，如果提供了mod参数，则计算结果再对mod进行取余运算 |
| Round(num [,ndig=0]) | 接受一个浮点数flt并对其四舍五入，保存ndig位小数。若不提供ndig参数，则默认小数点后0位 |
| 仅适用于整数的函数 | |
| hex(num) | 将数字转换成十六进制数，并以字符串形式返回 |
| oct(num) | 将数字转换成八进制数，并以字符串形式返回 |
| chr(num) | 将ASCII值得数字转换成ASCII字符，范围0<=num<=255 |
| ord(num) | 接受一个ASCII/Unicode字符，返回相应的ASCII/Unicode值 |
| unichr(num) | 接受Unicode码值，返回对应的Unicode字符 |
例如：
>>> hex(2)
'0x2'
>>> oct(10)
'0o12'
>>> chr(65)
'A'
>>> ord('A')
65
>>> ord(u'黄') #注：只能传长度为1的字符串
40644
>>> 二、序列类型--字符串
1、序列概述
程序的组成：指令+代码 或者 数据结构+算法，Python的最基本的数据结构是序列。
成员有序排列的，并且可以通过下标偏移量访问到它的一个或者几个成员，这类 Python 类型统称为序列，包括下面这些：字符串，列表，和元组类型。
序列特性：
a)序列类型中的每一个元素都可以通过指定一个偏移量的方式得到。从左自右下表偏移量从0开始，从右自左从-1开始。
b)所有的序列都支持迭代。
1.1、序列类型操作符
| 序列公共操作和方法 | 描述 |
| seq[i] | 返回一个索引为i的序列元素 |
| seq[i:j] | 返回一个切片 |
| seq[i:j:stride] | 返回一个扩展切片，起始:结束:步长 |
| seq1+seq2 | +号合并两个序列，返回新的序列，序列类型要一致 |
| seq*n/n*seq | 把序列重复n次，返回新的序列 |
| in/not in seq | 成员关系判断。用法：obj in /not in seq #序列中是否包含obj |
| for x in s: | 迭代 |
| v1,v2,v3=s | 变量序列解包，将序列中存储的值指派给各个标识符 |
1.2、序列的切片
序列的切片操作可分为：进步切片、多维切片及省略切片
进步切片语法：Sequence[起始索引：结束索引：步长值] 注：步长不能是0,步长不写默认为1,步长是正表示从左向右,步长是负数从右向左取
多维切片语法：Sequence[start1:end1,start2:end2] 多维：n=[[[0]*3 for x in range(3) ] for x in range(3)]
省略切片语法：Sequence[...,start1:end1]
例如：
>>> str1='012345678'
>>> str1[0:6:1]
'012345'
>>> str1[0:6:2]
'024'
>>> str2='abcdefg'
>>> str2[::-1]
'gfedcba'
>>> str2[-1:-2:-1]
'g'
>>> str3='abc'
>>> str3*2
'abcabc'
>>> t=(1,2,3)
>>> t1,t2,t3=t #变量序列解包
>>> print(t1,t2,t3)
1 2 31.3、序列类型常用内置函数
python中也有不少内置函数可以对序列进行操作，常用的如下：
| 函数 | 功能 |
| enumerate(iter) | 接受一个可迭代对象作为参数，返回一个enumerate对象（也是一个迭代器），该对象生成由iter每个元素的index值和item值组成的元组 |
| lens(s) | 返回s中元素的个数 |
| min(s [, key=func]) | s中的最小值 |
| max(s [, key=func]) | s中的最大值 |
| sum(s [,initial]) | s中的各项的和（适用于数字序列） |
| all(s) | 检查s中的所有项是否为True |
| any(s) | 检查s中的任意项是否为True |
| reversed(s) | 接受一个序列作为参数，返回一个以逆序访问的迭代器 |
| zip([it0,it1,...itN],[x1,...xn]...) | 返回一个列表，其第一个元素是it0,it1,...这些元素的第一个元素组成的元组 |
例如：
>>> str1='abcdef'
>>> len(str1)
6
>>> max(str1)
'f'
>>> list(zip([1,2,3],['a','b','c']))
[(1, 'a'), (2, 'b'), (3, 'c')]2、序列-字符串简介
Python 中字符串被定义为引号（单引号、双引号或三引号）之间的字符集合。字符串是不可变类型，改变一个字符串的元素需要创建一个新的字符串。Python 支持使用成对的单引号、双引号或三引号（三个连续的单引号或者双引号）来包含特殊字符。
在python2.x中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位Unicode编码字符串，这样能够表示更多的字符集，使用语法是在字符串前面加上前缀u。例如：
解释：
方式一声明：str字符串本质上是一个字节流。是原字符经过编码之后的一个个字节，但是并不存储真正的编码方式。[在python2.x中str1存放的你好是文件存储时的编码格式编码后的字节序列。因为在IDLE中默认的编码是GBK，所以你好经过编码之后就是'\\xc4\\xe3\\xba\\xc3’，而一般在.py文件中，就是我们存储的文件编码格式。]
方式二：声明Unicode字符串本质上是一个Unicode对象，内部使用了特定的编码。事实上python中并没有Unicode字符串，只是为了方便，才说Unicode字符串。实际上都是指Unicode对象。
str1的len表示这个字节流共有多少个字节。Str字节长度是11。[在没有设置系统编码时，默认的系统编码是GBK，GBK是双字节编码，一个中文占两个字节，所以你好字节长度为4，加上其他的就是11了]。而str2的len表示这个字符串真正的长度。
Python3.x中对文本和二进制数据做了更为清晰的区分。python3中改善了复杂的字符编码处理。Python3.x中有两种表示字符序列的类型：bytes和str。前者包含原始的8位值，后者实际包含unicode字符串。即：所有的字符串都是Unicode字符串，由str表示，二进制数据则由bytes表示。
Python数据可视化之散点图(基础篇---图文并茂详细版！！！)