【语言学习】python3 - hippowc/hippowc.github.io GitHub Wiki

去python官网下载最新安装包，大概20多M，安装完100多一点，不得不感慨这么小的东西，有这么大的作用。Mac默认安装的是python2.7，安装完3.7以后，会保留两个命令，python--python2.7，python3--python3.7。同时会安全pip3，python的包管理器，非常的方便。

之前写过一次python的学习笔记，不过是2.7的，这次为了写一个爬虫应用，使用python3，也顺便在复习一遍python语法。

Linux/Unix的系统上，一般默认的 python 版本为 2.x，我们可以将 python3.x 安装在 /usr/local/python3 目录中。

$ PATH=$PATH:/usr/local/python3/bin/python3    # 设置环境变量
$ python3 --version
Python 3.4.0

你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样可直接执行：

#! /usr/bin/env python3

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

# -*- coding: cp-1252 -*-

• 第一个字符必须是字母表中字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字，并不多：

>>> import keyword
>>> keyword.kwlist

• 单行注释以 # 开头
• 多行注释可以用多个 # 号，还有 ''' 和 """

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}；缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

print( x, end=" " )
print( y, end=" " )

将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

#!/usr/bin/python3

counter = 100
a = b = c = 1
a, b, c = 1, 2, "runoob"

有六种变量类型

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Python3 支持 int、float、bool、complex（复数）

a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

一些数值运算与java不同

>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 2 ** 5 # 乘方
32

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次
print (str + "TEST") # 连接字符串

如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print(r'Ru\noob')
Ru\noob

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。加号 + 是列表连接运算符，星号 * 是重复操作。

print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

与Python字符串不一样的是，列表中的元素是可以改变的

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型也可以不相同,其实，可以把字符串看作一种特殊的元组。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

string、list 和 tuple 都属于 sequence（序列）。

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

parame = {value01,value02,...}
或者
set(value)

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。

dict = {}
dict['one'] = "xxx"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

字典类型也有一些内置的函数，例如clear()、keys()、values()等。

数据类型的转换，你只需要将数据类型作为函数名即可。这些函数返回一个新的对象，表示转换的值。

只有两个和java不同

**	幂 - 返回x的y次幂	
//	取整除 - 向下取接近除数的整数

和java相同

and or not

in not in

if ( a in list ):

is is not

is 是判断两个标识符是不是引用自一个对象

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

• 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
• 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 在Python中没有switch – case语句。

Python中的循环语句有 for 和 while

while 判断条件：
    语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

for <variable> in <sequence>:
    <statements>
else:
    <statements>

range()函数: 如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列

>>>for i in range(5):
...     print(i)
...
0 1 2 3 4

>>>for i in range(5,9) :
    print(i)
     
5 6 7 8

break和continue语句及循环中的else子句;循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。

Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句

迭代是Python最强大的功能之一，是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。迭代器有两个基本的方法：iter() 和 next()。字符串，列表或元组对象都可用于创建迭代器:

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1

Python 中，使用了 yield 的函数被称为生成器（generator）。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

与普通函数不同，生成器函数被调用后，其函数体内的代码并不会立即执行，而是返回一个生成器（generator-iterator）。当返回的生成器调用成员方法时，相应的生成器函数中的代码才会执行。

def square():
    for x in range(4):
        yield x ** 2
square_gen = square()
for x in square_gen:
    print(x)

生成器方法

• generator.next()：从上一次在 yield 表达式暂停的状态恢复，继续执行到下一次遇见 yield 表达式。
• generator.send(value)：和 generator.next() 类似，差别仅在与它会将当前 yield 表达式的值设置为 value。

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

def 函数名（参数列表）:
    函数体

• 必需参数: 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
• 关键字参数: 函数调用使用关键字参数来确定传入的参数值。
• 默认参数: 调用函数时，如果没有传递参数，则会使用默认参数。
• 不定长参数: 你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。

def printinfo( name, age ):
...

#调用printinfo函数
printinfo( age=50, name="runoob" )

def printinfo( name, age = 35 ):

def printinfo( arg1, *vartuple ):
   print (vartuple)

printinfo( 70, 60, 50 )
(60, 50)
如果在函数调用时没有指定参数，它就是一个空元组。

加了两个星号 ** 的参数会以字典的形式导入。
def printinfo( arg1, **vardict ):

printinfo(1, a=2,b=3)
{'a': 2, 'b': 3}

python 使用 lambda 来创建匿名函数。所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

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

lambda [arg1 [,arg2,.....argn]]:expression

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

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内置作用域（内置函数所在模块的范围）

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

>>> [weapon.strip() for weapon in freshfruit]

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：

import module1[, module2[,... moduleN]
from modname import name1[, name2[, ... nameN]]
from modname import *

一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

>>> import sys
>>> sys.path

模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。

每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞花。

from fibo import * 这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

每个模块都有一个__name__属性，当其值是'main'时，表明该模块自身在运行，否则是被引入。

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。目录只有包含一个叫做 init.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...

import sound.effects.echo
必须使用全名去访问:
sound.effects.echo.echofilter

from sound.effects import echo
这同样会导入子模块: echo，并且他不需要那些冗长的前缀

导入语句遵循如下规则：如果包定义文件 init.py 存在一个叫做 all 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。

__all__ = ["echo", "surround", "reverse"]

两种输出值的方式: 表达式语句和 print() 函数；第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

>>> print('{}网址： "{}!"'.format('菜鸟教程', 'www.runoob.com'))
菜鸟教程网址： "www.runoob.com!"

>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。

Python提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。input 可以接收一个Python表达式作为输入，并将运算结果返回。

str = input("请输入：");
print ("你输入的内容是: ", str)

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode)

• filename：包含了你要访问的文件名称的字符串值。
• mode：决定了打开文件的模式：只读，写入，追加等。

# 打开一个文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()

python的pickle模块实现了基本的数据序列和反序列化。

pickle.dump(obj, file, [,protocol])
x = pickle.load(file)

open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

open(file, mode='r')

file 对象使用 open 函数来创建

os 模块提供了非常丰富的方法用来处理文件和目录。

• 首先，执行try子句（在关键字try和关键字except之间的语句）
• 如果没有异常发生，忽略except子句，try子句执行后结束。
• 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
• 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

try:
        this_fails()
    except ZeroDivisionError as err:
        print('Handling run-time error:', err)
    finally:
...     print('Goodbye, world!')

raise NameError('HiThere')

些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

class ClassName:
    <statement-1>
    <statement-N>

类对象支持两种操作：属性引用和实例化。

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

def __init__(self):
    self.data = []

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

class DerivedClassName(BaseClassName1):
    <statement-1>
    <statement-N>

Python同样有限的支持多继承形式。

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    <statement-N>

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法

类的私有属性: __private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法:在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法:__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

• os模块提供了不少与操作系统相关联的函数。
• glob模块提供了一个函数用于从目录通配符搜索中生成文件列表
• 通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys 模块的 argv 变量。
• re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案
• math模块为浮点运算提供了对底层C函数库的访问
• 有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request 以及用于发送电子邮件的 smtplib
• datetime模块为日期和时间处理同时提供了简单和复杂的方法
• 性能度量: Timer
• pickle数据持久化
• 使用pydoc3 module可以查看方法使用