python3 -基础知识

参照：Python3

Python3 基础语法

编码

UTF-8

标识符

第一个字符必须是字母表中字母或下划线’_’。
标识符的其他的部分有字母、数字和下划线组成。
标识符对大小写敏感。

注释

1. 单行注释以#开头
2. 多行注释用三个单引号（’’’）或者三个双引号（"""）将注释括起来。

行与缩进

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

数据类型

python中数有四种类型：整数、长整数、浮点数和复数。

1. 整数， 如 1
2. 长整数 是比较大的整数
3. 浮点数 如 1.23、3E-2
4. 复数 如 1 + 2j、 1.1 + 2.2j

字符串

1. python中单引号和双引号使用完全相同。
2. 使用三引号(’’'或""")可以指定一个多行字符串。
3. 转义符 ‘\’
4. 自然字符串， 通过在字符串前加r或R。 如 r"this is a line with \n" 则\n会显示，并不是换行。
5. python允许处理unicode字符串，加前缀u或U， 如 u"this is an unicode string"。
6. 字符串是不可变的。
7. 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。

Python3 基本数据类型

1. Python中的变量不需要声明。
2. 每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在Python中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

Python 3中有六个标准的数据类型：

Numbers（数字）

Python 3支持 int、float、bool、complex（复数）。内置的type()函数可以用来查询变量所指的对象类型。
注意：

1. Python可以同时为多个变量赋值，如a, b = 1, 2。
2. 一个变量可以通过赋值指向不同类型的对象。
3. 数值的除法（/）总是返回一个浮点数，要获取整数使用（//）操作符。
4. 在混合计算时，Pyhton会把整型转换成为浮点数。
5. 乘方 2 ** 5

String（字符串）

字符串str用单引号(’ ')或双引号(" ")括起来，同时使用反斜杠()转义特殊字符。
s = ‘Yes,he doesn’t’
注意：

1. 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。

   print(‘C:\some\name’)
   C:\some
   ame
   print(r’C:\some\name’)
   C:\some\name

2. 字符串可以用+运算符连接在一起，用*运算符重复。

   print(‘str’+‘ing’, ‘my’*3)
   string mymymy

3. Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。注意，没有单独的字符类型，一个字符就是长度为1的字符串。

   word = ‘Python’
   print(word[0], word[5]) ⇒P n
   print(word[-1], word[-6]) ⇒ n P

   还可以对字符串进行切片，获取子串。用冒号分隔两个索引，形式为变量[头下标:尾下标]。
   截取的范围是前闭后开的，并且两个索引都可以省略：

   word = ‘ilovepython’
   word[1:5] ⇒ ‘love’
   word[:]　⇒’ilovepython’
   word[5:]　⇒’python’
   word[-10:-6]　⇒’love’

4. Python中的字符串不能改变。
   向一个索引位置赋值，比如word[0] = 'm’会导致错误。

List（列表）

1. 列表是写在方括号之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同：a = [‘him’, 25, 100, ‘her’]

2. 列表同样可以被索引和切片，列表被切片后返回一个包含所需元素的新列表。

3. 列表还支持串联操作，使用+操作符

   a = [1, 2, 3, 4, 5]
   a + [6, 7, 8]
   [1, 2, 3, 4, 5, 6, 7, 8]

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

Tuple（元组）

1. 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里，元素之间用逗号隔开。

2. 元组与字符串类似，可以被索引且下标索引从0开始，也可以进行截取/切片

3. 构造包含0个或1个元素的tuple是个特殊的问题，所以有一些额外的语法规则：

   tup1 = () # 空元组
   tup2 = (20,) # 一个元素，需要在元素后添加逗号

4. 元组也可以使用+操作符进行拼接。
   `

Sets（集合）

集合（set）是一个无序不重复元素的集。基本功能是进行成员关系测试和消除重复元素。
可以使用大括号 或者 set()函数创建set集合，注意：创建一个空集合必须用 set() 而不是 { }，因为{ }是用来创建一个空字典。

>>> student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
>>> print(student)   # 重复的元素被自动去掉
{'Jim', 'Jack', 'Mary', 'Tom', 'Rose'}
>>> 'Rose' in student  # membership testing（成员测试）
True
>>> # set可以进行集合运算
... 
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'b', 'c', 'd', 'r'}
>>> a - b     # a和b的差集
{'b', 'd', 'r'}
>>> a | b     # a和b的并集
{'l', 'm', 'a', 'b', 'c', 'd', 'z', 'r'}
>>> a & b     # a和b的交集
{'a', 'c'}
>>> a ^ b     # a和b中不同时存在的元素
{'l', 'm', 'b', 'd', 'z', 'r'}

Dictionaries（字典）

字典是一种映射类型（mapping type），它是一个无序的键 : 值对集合。
关键字必须使用不可变类型，也就是说list和包含可变类型的tuple不能做关键字。
在同一个字典中，关键字还必须互不相同。

>>> dic = {}  # 创建空字典
>>> tel = {'Jack':1557, 'Tom':1320, 'Rose':1886}
>>> tel
{'Tom': 1320, 'Jack': 1557, 'Rose': 1886}
>>> tel['Jack']   # 主要的操作：通过key查询
1557
>>> del tel['Rose']  # 删除一个键值对
>>> tel['Mary'] = 4127  # 添加一个键值对
>>> tel
{'Tom': 1320, 'Jack': 1557, 'Mary': 4127}
>>> list(tel.keys())  # 返回所有key组成的list
['Tom', 'Jack', 'Mary']
>>> sorted(tel.keys()) # 按key排序
['Jack', 'Mary', 'Tom']
>>> 'Tom' in tel       # 成员测试
True
>>> 'Mary' not in tel  # 成员测试
False

Python3 解释器

交互式编程

命令提示符中输入"Python"命令来启动Python解释器
在交互模式中，最后被输出的表达式结果被赋值给变量 _ .
_ 变量应被用户视为只读变量。不要显式地给它赋值——这样您将会创建一个具有相同名称的独立的本地变量，并且屏蔽了这个内置变量的功能。

脚本式编程

通过以下命令执行该脚本文件

python hello.py

SHELL编程

#! /usr/bin/env python3.4

$ chmod +x hello.py

./hello.py

Python3 条件控制

if 语句

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

注意：

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

Python3 循环

while 循环

while 判断条件：
    statements

for语句

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

Python3 迭代器与生成器

迭代器

迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。迭代器有两个基本的方法：iter() 和 next()。

#!/usr/bin/python3

import sys         # 引入 sys 模块

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象

while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

1
2
3
4

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next()方法时从当前位置继续运行。

#!/usr/bin/python3

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

0 1 1 2 3 5 8 13 21 34 55

Python3 函数

定义函数

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

函数变量作用域

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

关键字参数

函数也可以使用 kwarg=value 的关键字参数形式被调用.例如,以下函数:

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print("-- This parrot wouldn't", action, end=' ')
    print("if you put", voltage, "volts through it.")
    print("-- Lovely plumage, the", type)
    print("-- It's", state, "!")

返回值

Python的函数的返回值使用return语句，可以将函数作为一个值赋值给指定变量：

可变参数列表

def arithmetic_mean(*args):
    sum = 0
    for x in args:
        sum += x
    return sum

print(arithmetic_mean(45,32,89,78))
print(arithmetic_mean(8989.8,78787.78,3453,78778.73))
print(arithmetic_mean(45,32))
print(arithmetic_mean(45))
print(arithmetic_mean())

Python3 数据结构

列表

Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。

1. list.append(x)
2. list.extend(L)
3. list.insert(i, x)
4. list.remove(x)
5. list.pop([i])
6. list.clear()
7. list.index(x)
8. list.count(x)
9. list.sort()
10. list.reverse()
11. list.copy()

将列表当做堆栈使用

stack.append(6)
stack.pop()

将列表当作队列使用

拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

列表推导式

通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

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

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

>>> [3*x for x in vec if x > 3]
[12, 18]

>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]

嵌套列表解析

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]

以下实例将3X4的矩阵列表转换为4X3列表：

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

del 语句

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表

元组和序列

元组由若干逗号分隔的值组成，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的例如：

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

集合

集合也支持推导式：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

字典

序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。

1. 理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。

2. 构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：

   >>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
   {'sape': 4139, 'jack': 4098, 'guido': 4127}
   

3. 字典推导可以用来创建任意键和值的表达式词典：

   >>> {x: x**2 for x in (2, 4, 6)}
   {2: 4, 4: 16, 6: 36}
   

遍历技巧

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

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

2. 在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

   >>> for i, v in enumerate(['tic', 'tac', 'toe']):
   ...     print(i, v)
   ...
   0 tic
   1 tac
   2 toe
   

3. 同时遍历两个或更多的序列，可以使用 zip() 组合：

   >>> questions = ['name', 'quest', 'favorite color']
   >>> answers = ['lancelot', 'the holy grail', 'blue']
   >>> for q, a in zip(questions, answers):
   ...     print('What is your {0}?  It is {1}.'.format(q, a))
   ...
   What is your name?  It is lancelot.
   What is your quest?  It is the holy grail.
   What is your favorite color?  It is blue.
   

4. 要反向遍历一个序列，首先指定这个序列，然后调用 reversesd() 函数：

   >>> for i in reversed(range(1, 10, 2)):
   ...     print(i)
   ...
   9
   7
   5
   3
   1
   

5. 要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

   >>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
   >>> for f in sorted(set(basket)):
   ...     print(f)
   ...
   apple
   banana
   orange
   pear
   

Python3 模块

import语句

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

import module1[,module2[, ... moduleN]

原理

1. 一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
2. 搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。
3. 搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

from … import语句

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中，例如导入指定的函数
语法如下：

from modname import name1[, name2[, ... nameN]

这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面，fibo 这个名称是没有定义的）。

from … import*语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

__name__属性

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

#!/usr/bin/python3
# Filename: using_name.py

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

1. 每个模块都有一个__name__属性，当其值是’main’时，表明该模块自身在运行，否则是被引入。
2. name 与 main 底下是双下划线，是“_ _”去掉中间的空格。

dir() 函数

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

标准模块

Python 本身带着一些标准的模块库，有些模块直接被构建在解析器里，比如 winreg 这个模块就只会提供给 Windows 系统。
应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>

包

1. 包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
   比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。
2. 在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
3. 目录只有包含一个叫做 init.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。
4. 注意当使用from package import item这种形式的时候，对应的item既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。import语法会首先把item当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，恭喜，一个:exc:ImportError 异常被抛出了。
5. 如果使用形如import item.subitem.subsubitem这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

从一个包中导入*

导入语句遵循如下规则：如果包定义文件__init__.py 存在一个叫做__all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。作为包的作者，可别忘了在更新包之后保证__all__ 也更新了啊。

推荐导入方式

使用from Package import specific_submodule这种方法永远不会有错。事实上，这也是推荐的方法。除非是你要导入的子模块有可能和其他包的子模块重名。

Python3 输入和输出

输出格式美化

Python两种输出值的方式: 表达式语句和 print() 函数。
如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

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

str() 函数返回一个用户易读的表达形式。

repr() 产生一个解释器易读的表达形式。

>>> #  repr() 函数可以转义字符串中的特殊字符
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"

读和写文件

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

open(filename, mode) # mode 参数是可选的; 'r' 将是默认值。

文件对象的方法

f.read()

为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

f.readline()

f.readline() 会从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

f.readlines()

f.readlines() 将返回该文件中包含的所有行。

如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

f.write()

f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

f.tell()

f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

f.seek()

如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ： 表示从当前位置往后移动x个字符
seek(-x,2)：表示从文件的结尾往前移动x个字符
from_what 值为默认为0，即文件开头。下面给出一个完整的例子：

f.close()

在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。
当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源

当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:

with open(’/tmp/workfile’, ‘r’) as f:
… read_data = f.read()
f.closed
True

文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用。

pickle 模块

python的pickle模块实现了基本的数据序列和反序列化。
通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象
基本接口：

pickle.dump(obj, file, [,protocol])

有了 pickle 这个对象, 就能对 file 以读取的形式打开:

x = pickle.load(file)

#使用pickle模块将数据对象保存到文件

import pickle

data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}

selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)

output.close()

Python3 OS 文件/目录方法

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

Python3 错误和异常

捕获异常

try:
except (RuntimeError, TypeError, NameError):

try:
except IOError:
else:  # 这个子句将在try子句没有发生任何异常的时候执行

抛出异常

Python 使用 raise 语句抛出一个指定的异常。例如:

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: HiThere

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

用户自定义异常

你可以通过创建一个新的exception类来拥有自己的异常。异常应该继承自 Exception 类，或者直接继承，或者间接继承，例如:

>>> class MyError(Exception):
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)
   
>>> try:
        raise MyError(2*2)
    except MyError as e:
        print('My exception occurred, value:', e.value)
   
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'

定义清理行为(finally)

try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:

>>> try:
        raise KeyboardInterrupt
    finally:
        print('Goodbye, world!')

预定义的清理行为

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

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

Python3 面向对象

类定义

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

类对象

类对象支持两种操作：属性引用和实例化。
属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

#!/usr/bin/python3

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 = []

当然__init__() 方法可以有参数，参数通过 init() 传递到类的实例化操作上。

类的方法

在类内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数:

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

# 实例化类
p = people('W3Cschool',10,30)
p.speak()

继承

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

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法。

多继承

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

方法重写

覆盖父类的方法。

类属性与方法

类的私有属性

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

类的方法

在类的内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数

类的私有方法

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

类的专有方法：
1__init__: 构造函数，在生成对象时调用
2__del__ : 析构函数，释放对象时使用
3__repr__ : 打印，转换
4__setitem__ : 按照索引赋值
5__getitem__: 按照索引获取值
6__len__: 获得长度
7__cmp__: 比较运算
8__call__: 函数调用
9__add__: 加运算
10__sub__: 减运算
11__mul__: 乘运算
12__div__: 除运算
13__mod__: 求余运算
14__pow__: 乘方

Python3 正则表达式

re 模块使 Python 语言拥有全部的正则表达式功能。

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

re.match(pattern, string, flags=0)

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

re.search(pattern, string, flags=0)

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

re.sub

Python 的re模块提供了re.sub用于替换字符串中的匹配项。

re.sub(pattern, repl, string, max=0)

Python3 JSON 数据解析

Python3 中可以使用 json 模块来对 JSON 数据进行编解码，它包含了两个函数：

1. json.dumps(): 对数据进行编码。
2. json.loads(): 对数据进行解码。

Python3 日期和时间

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。

时间戳

#!/usr/bin/python3
import time;  # 引入time模块

ticks = time.time()
print ("当前时间戳为:", ticks)

获取当前时间

#!/usr/bin/python3
import time

localtime = time.localtime(time.time())
print ("本地时间为 :", localtime)

本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=28, tm_sec=49, tm_wday=3, tm_yday=98, tm_isdst=0)

获取格式化的时间

#!/usr/bin/python3
import time

localtime = time.asctime( time.localtime(time.time()) )
print ("本地时间为 :", localtime)

本地时间为 : Thu Apr  7 10:29:13 2016

格式化日期

#!/usr/bin/python3
import time

# 格式化成2016-03-20 11:45:39形式
print
    (time.strftime("%Y-%m-%d %H:%M:%S", time
        .localtime()))

# 格式化成Sat Mar 28 22:24:24 2016形式
print 
            (time.strftime("%a %b %d %H:%M:%S %Y", time.
                localtime()))  

# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"

                    print (time.mktime(time.
                        strptime(a,"%a %b %d %H:%M:%S %Y")))
                            

2016-04-07 10:29:46
Thu Apr 07 10:29:46 
20161459175064.0

获取某月日历

#!/usr/bin/python3

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

以下输出2016年1月份的日历:    
    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

Python3网络爬虫

在Python3中，可以使用urllib.request和requests进行网页爬取。

1. urllib库是python内置的，无需我们额外安装，只要安装了Python就可以使用这个库。
2. requests库是第三方库，需要我们自己安装。