docs_Python

Python-01基础-00菜鸟教程

2020-02-01  本文已影响0人  SuperScfan

Python-菜鸟驿站

tags: Python 菜鸟驿站 2018年 12月

简介说明

以下全文来自于菜鸟驿站官网，如需跳转请点击。

各类程序员学习路线图

学习资料站点地图：学习资料站点地图

Python简介

Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。
Python由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。
像Perl语言一样, Python 源代码同样遵循 GPL(GNU General Public License)协议。

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。

Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。

Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

Python 发展历史

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。
Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。
像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。
现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。

Python 特点

  1. 易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
  2. 易于阅读：Python代码定义的更清晰。
  3. 易于维护：Python的成功在于它的源代码是相当容易维护的。
  4. 一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
  5. 互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
  6. 可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
  7. 可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
  8. 数据库：Python提供所有主要的商业数据库的接口。
  9. GUI编程：Python支持GUI可以创建和移植到许多系统调用。
  10. 可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

Python环境变量

PYTHONPATH
是Python搜索路径，默认我们import的模块都会从PYTHONPATH里面寻找。

PYTHONSTARTUP
Python启动后，先寻找PYTHONSTARTUP环境变量，然后执行此变量指定的文件中的代码。

PYTHONCASEOK
加入PYTHONCASEOK的环境变量, 就会使python导入模块的时候不区分大小写.

PYTHONHOME
另一种模块搜索路径。它通常内嵌于的PYTHONSTARTUP或PYTHONPATH目录中，使得两个模块库更容易切换。

**#!/usr/bin/python **:
是告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器；

#!/usr/bin/env python(推荐）:
这种用法是为了防止操作系统用户没有将 python 装在默认的 /usr/bin 路径里。
当系统看到这一行的时候，首先会到 env 设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。

!/usr/bin/python 相当于写死了python路径;

!/usr/bin/env python 会去环境设置寻找 python 目录,推荐这种写法

Python运行参数

Python启动交互式界面参数。

$ python # Unix/Linux

Python保留字符

Python 保留字符下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。
所有 Python 的关键字只包含小写字母。

and exec not assert finally or

break for pass class from print

continue global raise def if

return del import try elif in

while else is with except lambda yield

Python函数

Python数学函数

数学函数需要导入 math或cmath包

improt math
函数 返回值 ( 描述 )
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。
min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。
modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) x**y 运算后的值。
round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x) 返回数字x的平方根

Python随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

函数 返回值 ( 描述 )
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数
randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random() 随机生成下一个实数，它在[0,1)范围内。
seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst) 将序列的所有元素随机排序
uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

Python三角函数

常量 返回值 ( 描述 )
cos(x) 返回x的反余弦弧度值。
asin(x) 返回x的反正弦弧度值。
atan(x) 返回x的反正切弧度值。
atan2(y, x) 返回给定的X及Y坐标值的反正切值。
cos(x) 返回x的弧度的余弦值。
hypot(x, y) 返回欧几里德范数sqrt(x*x + y*y)。
sin(x) 返回的x弧度的正弦值。
tan(x) 返回x弧度的正切值。
degrees(x) 将弧度转换为角度,如degrees(math.pi/2),返回90.0
radians(x) 将角度转换为弧度

Python数学常量

常量 返回值 ( 描述 )
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）。

匿名函数

python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )

Python 异常

异常说明

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
一般情况下，在Python无法正常处理程序时就会发生一个异常。
异常是Python对象，表示一个错误。
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。
语法：
以下为简单的try....except...else的语法：

try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生

异常处理

指定标准异

对指定标准异常进行解释。只能识别之地指定标准异常。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()

使用except不带异常类型

可以捕获所有异常，但是无法识别出具体异常信息。

使用except带多种异常类型

捕获多个标准异常

try:
    正常的操作
except(Exception1[, Exception2[,...ExceptionN]]]):
    发生以上多个异常中的一个，执行这块代码
else:
    如果没有异常执行这块代码

Try-finally语句

try-finally 语句无论是否发生异常都将执行最后的代码。
退出try时总会执行finally中语句。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print "Error: 没有找到文件或读取文件失败"

异常的参数

一个异常可以带上参数，可作为输出的异常信息参数。
你可以通过except语句来捕获异常的参数，如下所示

try:
    正常的操作
except ExceptionType, Argument:
    你可以在这输出 Argument 的值...
    变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。
    元组通常包含错误字符串，错误数字，错误位置。实例
    以下为单个异常的实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 定义函数
def temp_convert(var):
    try:
        return int(var)
    except ValueError, Argument:
        print "参数没有包含数字\n", Argument

# 调用函数
temp_convert("xyz");
以上程序执行结果如下：
$ python test.py
参数没有包含数字
invalid literal for int() with base 10: 'xyz'触发异常

raise触发异常

我们可以使用raise语句自己触发异常
raise语法格式如下：
raise [Exception [, args [, traceback]]]
语句中 Exception 是异常的类型（例如，NameError）参数标准异常中任一种，args 是自已提供的异常参数。
最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。实例
一个异常可以是一个字符串，类或对象。 Python的内核提供的异常，大多数都是实例化的类，这是一个类的实例的参数。
定义一个异常非常简单，如下所示：

def functionName( level ):
if level < 1:
raise Exception("Invalid level!", level)
# 触发异常后，后面的代码就不会再执行
注意：为了能够捕获异常，"except"语句必须有用相同的异常来抛出类对象或者字符串。
例如我们捕获以上异常，"except"语句如下所示：

try:
正常逻辑
except Exception,err:
触发自定义异常
else:
其余代码实例

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 定义函数
def mye( level ):
if level < 1:
raise Exception,"Invalid level!"
# 触发异常后，后面的代码就不会再执行
try:
mye(0) # 触发异常
except Exception,err:
print 1,err
else:
print 2
执行以上代码，输出结果为：

$ python test.py
1 Invalid level!

用户自定义异常

通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。
以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。
在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。

class Networkerror(RuntimeError):
def __init__(self, arg):
self.args = arg
在你定义以上类后，你可以触发该异常，如下所示：

try:
raise Networkerror("Bad hostname")
except Networkerror,e:
print e.args

标准异常说明

菜鸟驿站异常处理: http://www.runoob.com/python/python-exceptions.html

Python常见标准异常说明

异常代码 异常说明
BaseException 所有异常的基类
SystemExit 解释器请求退出
KeyboardInterrupt 用户中断执行(通常是输入^C)
Exception 常规错误的基类
StopIteration 迭代器没有更多的值
GeneratorExit 生成器(generator)发生异常来通知退出
StandardError 所有的内建标准异常的基类
ArithmeticError 所有数值计算错误的基类
FloatingPointError 浮点计算错误
OverflowError 数值运算超出最大限制
ZeroDivisionError 除(或取模)零 (所有数据类型)
AssertionError 断言语句失败
AttributeError 对象没有这个属性
EOFError 没有内建输入,到达
EOF 标记
EnvironmentError 操作系统错误的基类
IOError 输入/输出操作失败
OSError 操作系统错误
WindowsError 系统调用失败
ImportError 导入模块/对象失败
LookupError 无效数据查询的基类
IndexError 序列中没有此索引(index)
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于 Python解释器不是致命的)
NameError 未声明/初始化对象 (没有属性)
UnboundLocalError 访问未初始化的本地变量
ReferenceError 弱引用( Weak reference)试图访问已经垃圾回收了的对象
RuntimeError 一般的运行时错误
NotImplementedError 尚未实现的方法
SyntaxErrorPython 语法错误
IndentationError 缩进错误
TabErrorTab 和空格混用
SystemError 一般的解释器系统错误
TypeError 对类型无效的操作
ValueError 传入无效的参数
UnicodeErrorUnicode 相关的错误
UnicodeDecodeErrorUnicode 解码时的错误
UnicodeEncodeErrorUnicode 编码时错误
UnicodeTranslateErrorUnicode 转换时错误
Warning 警告的基类
DeprecationWarning 关于被弃用的特征的警告
FutureWarning 关于构造将来语义会有>改变的警告
OverflowWarning 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning 关于特性将会被废弃的警告
RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning 可疑的语法的警告
UserWarning 用户代码生成的警告

Python内置函数

菜鸟驿站参考链接： http://www.runoob.com/python/python-built-in-functions.html

重要内置函数

open()或file()
打开文件，创建file对象。 注意点： file对象的方法 + 打开模式

staticmethod
返回函数的静态方法

In [16]: class C():
    ...:     @staticmethod
    ...:     def a():
    ...:         pass
    ...:     def b():
    ...:         pass
In [18]: C.a()
In [20]: # 以上实例声明了静态方法 f，类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 C().f()。vvvvv

classmethod
修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

getattr()
用于返回一个对象属性值。

>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1

eval()
函数用来执行一个字符串表达式，并返回表达式的值

isinstance()
函数来判断一个对象是否是一个已知的类型，类似 type()

In [42]: a=2;print isinstance (a,int); print isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True
True
In [43]: # 推荐使用 isinstance ，isinstance和type()区别，type（）不会考虑继承问题
In [44]: # int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple

# basestring() 方法是 str 和 unicode 的超类（父类），也是抽象类basestring() 函数。
# basestring() 可以被用来判断一个对象是否为 str 或者 unicode 的实例
>>>isinstance("Hello world", str)
True
>>> isinstance("Hello world", basestring)
True
>>> isinstance(u"Hello world", basestring)
True

issubclass()
用于判断参数 class 是否是类型参数 classinfo 的子类。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class A:
    pass
class B(A):
    pass
    
print(issubclass(B,A))    # 返回 True

super() TODO
super() 函数是用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

基础内置函数

abs
返回函数绝对值。

divmod(a,b)
取余。

>>> divmod(7,2)
(3,1)

input()
接收一个合法的python表达式

raw_input()
接收任何字符，输出为 字符串

all()
判断 列表或元组中是否都为 True

In [22]: all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
Out[22]: True
In [23]: all(['a', '', 0, 'c', 'd'])  # 列表list，存在为空或0的元素
Out[23]: False
# 注意点 空列表或空元组 返回True
In [24]: all([])
Out[24]: True

enumerate()
函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
同时列出数据和数据下标，一般用在 for 循环当中

In [29]:  list(enumerate(seasons, start=1))       # 下标从 1 开始
Out[29]: [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

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

ord()
返回对应十进制

str()
函数将对象转化为适于人阅读的形式。

any()
判断 元组或列表 是否全部为False. 与all()相反

pow()
方法返回 xy（x的y次方） 的值。

improt math
math.power(2,4): 16.0

sum()
对系列进行求和计算。

**bin() **
返回一个整数 int 或者长整数 long int 的二进制表示。

In [47]: bin(10)
Out[47]: '0b1010'

iter()
生成迭代器

property()
函数的作用是在新式类中返回属性值。

filter()
函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

range()
函数可创建一个整数列表，一般用在 for 循环中。

函数语法
range(start, stop[, step])
参数说明：

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

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

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

list()
方法用于将元组转换为列表。

unichr()
函数 和 chr()函数功能基本一样， 只不过是返回 unicode 的字符。

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

对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。

str.format()
它增强了字符串格式化的功能。 TODO

locals()
函数会以字典类型返回当前位置的全部局部变量

reduce()
函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
reduce(function, iterable[, initializer])
参数
function -- 函数，有两个参数
iterable -- 可迭代对象
initializer -- 可选，初始参数

chr()
用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

frozenset()
返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

long()
函数将数字或字符串转换为一个长整型。

reload()
用于重新载入之前载入的模块。

vars()
函数返回对象object的属性和属性值的字典对象。

map()
会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]

repr()
函数将对象转化为供解释器读取的形式。

xrange()
函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。

cmp(x,y)
函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

globals()
函数会以字典类型返回当前位置的全部全局变量。

max()
方法返回给定参数的最大值，参数可以为序列。

reverse()
函数用于反向列表中元素。

zip()
函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

compile()
函数将一个字符串编译为字节代码。

hasattr()
函数用于判断对象是否包含对应的属性。

memoryview()
函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

round()
方法返回浮点数x的四舍五入值。

import()
函数用于动态加载类和函数 。
如果一个模块经常变化就可以使用 import() 来动态载入。

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

hash()
用于获取取一个对象（字符串或者数值等）的哈希值。

min()
方法返回给定参数的最小值，参数可以为序列。

set()
函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

delattr
函数用于删除属性。 delattr（x，'foobar'）相等于del x.foobar。

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

next()
返回迭代器的下一个项目.

setattr()
函数对应函数 getattr()，用于设置属性值，该属性必须存在。

dict()
函数用于创建一个字典

hex()
函数用于将10进制整数转换成16进制，以字符串形式表示

slice()
函数实现切片对象，主要用在切片操作函数里的参数传递。

dir()
函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法dir()，该方法将被调用。如果参数不包含dir()，该方法将最大限度地收集参数信息。

id()
函数用于获取对象的内存地址。

oct()
函数将一个整数转换成8进制字符串。

sorted(list) 有返回值
list.sort() 无返回值，直接修改原list
函数对所有可迭代的对象进行排序操作

exec()
执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码

Python模块

模块搜索顺序

搜索路径当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

  1. 当前目录
  2. 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
  3. 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
    模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。命名空间和作用域
    变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。
    一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。

dir()
函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。

globals() 和 locals() 函数
根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

reload() 函数
当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。
因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。

sys模块

系统相关的信息模块: import sys

os模块

操作系统相关的调用和操作: import os

OS模块-文件目录

os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：

类型转换

类型转换

Python转义符

在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：

Python字符串格式化符号

格式化操作符辅助指令:

字符串内建函数

方法 描述
string.capitalize(): 把字符串的第一个字符大写
string.center(width): 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string)): 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
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(): 格式化字符串
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
string.isdecimal(): isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

日期和时间

时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

# 获取当前时间戳
In [3]: print time.time()
1542250660.2

时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。

struct_time元组

struct_time元组

属性 值
tm_year 2008
tm_mon 1-12
tm_mday 1-31
tm_hour 0-23
tm_min 0-59
tm_sec 0-61(60/61闰秒)
tm_wday 0-6周一到周日
tm_yday 0-366(儒略历)
tm_isdst -1, 0, 1, -1是决定是否为夏令时的旗帜

获取当前时间

获取当前时间 struct_time格式

In [7]: print time.localtime(time.time())
time.struct_time(tm_year=2018, tm_mon=11, tm_mday=15, tm_hour=17, tm_min=52, tm_sec=23, tm_wday=3, tm_yday=319, tm_isdst=0)

获取当前时间 asctime格式

In [8]: print  time.asctime( time.localtime(time.time()) )
Thu Nov 15 17:53:21 2018

格式化日期

使用 time.strftime() 方法来格式化日期

time.strftime(format[, t])

实例演示

# 格式化成2016-03-20 11:45:39形式
In [9]: print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) 
2018-11-15 17:55:43
# 格式化成Sat Mar 28 22:24:24 2016形式
In [10]: print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) 
Thu Nov 15 17:55:54 2018
# 将格式字符串转换为时间戳
In [11]: a = "Sat Mar 28 22:24:24 2016"
In [12]: print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))
1459175064.0

python中时间日期格式化符号：

日历模块 Calendar

Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：

cal = calendar.month(2016, 1)
print "以下输出2016年1月份的日历:"
print cal;

January 2016
Mo Tu We Th Fr Sa Su
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

Time模块函数

Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：

模块函数 描述
time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
time.asctime([tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
time.clock( ) 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
time.ctime([secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime()
time.gmtime([secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
time.localtime([secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
time.mktime(tupletime) 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。
time.sleep(secs) 推迟调用线程的运行，secs指秒数。
time.strftime(fmt[,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根据fmt的格式把一个时间字符串解析为时间元组。
time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
time.tzset() 根据环境变量TZ重新初始化时间相关设置。

Time模块包含了以下2个非常重要的属性：
time.timezone
属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）

time.tzname
属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。

Calendar函数

星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：

calendar.calendar(year,w=2,l=1,c=6)
返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。

calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。

calendar.isleap(year)
是闰年返回 True，否则为 False。

calendar.leapdays(y1,y2)
返回在Y1，Y2两年之间的闰年总数。

calendar.month(year,month,w=2,l=1)
返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。

calendar.monthcalendar(year,month)
返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。

calendar.monthrange(year,month)
返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。

calendar.prcal(year,w=2,l=1,c=6)
相当于 print calendar.calendar(year,w,l,c).

calendar.prmonth(year,month,w=2,l=1)
相当于 print calendar.calendar（year，w，l，c）。

calendar.setfirstweekday(weekday)
设置每周的起始日期码。0（星期一）到6（星期日）。

calendar.timegm(tupletime)
和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。

calendar.weekday(year,month,day)
返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）

datetime函数

pass

Some Tips

循环控制语句

break语句： 语句块中终止循环，并跳出。
continue语句： 语句块中终止循环，继续下次循环。
pass语句： 空语句，用于保持程序完整性。

使用内置 enumerate 函数进行遍历

In [24]: sequence = [1,2,3]
In [26]: for index, item in enumerate(sequence):
    ...:         print(index, item) 
(0, 1)
(1, 2)
(2, 3)

In [27]: sequence = {'a':1,'b':2,'c':3}
In [28]: for index, item in enumerate(sequence):
    ...:         print(index, item)
(0, 'a')
(1, 'c')
(2, 'b')

return func和return func()区别

In [27]: def funx(x):
    ...:     def funy(y=1):
    ...:         return x*y
    ...:     return funy

In [28]: funx(12)(2)
Out[28]: 24

函数参数类型

函数参数的类型：

列表与字典函数

Python列表 内置方法

序号 方法
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj) 将对象插入列表
list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素
list.sort([func]) 对原列表进行排序

Python字典 内置方法

序号 函数及描述
dict.clear() 删除字典内所有元素
dict.copy() 返回一个字典的浅复制
dict.fromkeys(seq[, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
dict.has_key(key) 如果键在字典dict里返回true，否则返回false
dict.items() 以列表返回可遍历的(键, 值) 元组数组
dict.keys() 以列表返回一个字典所有的键
dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2) 把字典dict2的键/值对更新到dict里
dict.values() 以列表返回字典中的所有值
pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem() 随机返回并删除字典中的一对键和值。

读取键盘输入

In [33]: input('输入内容为:')
输入内容为:test
NameError: name 'test' is not defined
In [32]: raw_input('输入内容为:')
输入内容为:test
Out[32]: 'test'

In [35]: input('输入内容为:')
输入内容为:[i for i in range(1,3)]
Out[35]: [1, 2]
In [36]: raw_input('输入内容为:')
输入内容为:[i for i in range(1,3)]
Out[36]: '[i for i in range(1,3)]'
上一篇下一篇

猜你喜欢

热点阅读