Python基础教程

Python基础语法

来自Python菜鸟教程

标识符

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

python保留字

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

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注释

• 单行注释以 # 开头
• 多行注释可以用 ‘’’ 和 “”"
  ''' 第三注释 第四注释 '''

行与缩进

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。
程序由于缩进不一致会导致运行出错，出现类似以下错误：

File "test.py", line 6
    print ("False")    # 缩进不一致，会导致运行错误
                                      ^
IndentationError: unindent does not match any outer indentation level

缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。

多行语句

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

total = item_one + \
        item_two + \
        item_three

*在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 *

空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分。

import 与 from…import

-在 python 用 import 或者 from…import 来导入相应的模块。

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

基本数据类型

• Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
• 在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
• 等号（=）用来给变量赋值。=左边是一个变量名,右边是存储在变量中的值。
• 多个变量赋值
  Python允许同时为多个变量赋值

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

标准数据类型

• Number（数字）

• String（字符串）

• List（列表）

• Tuple（元组）

• Set（集合）

• Dictionary（字典）

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

数字(Number)类型

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

• int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
• bool (布尔), 如 True。
• float (浮点数), 如 1.23、3E-2
• complex (复数), 如 1 + 2j、 1.1 + 2.2j
  用函数type()和 isinstance()可以用来判断数据类型

>>> 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'>

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。
  注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加

函数

随机函数

字符串(String)

• Python 中字符串用单引号 ’ 和双引号 " 括起来。
• 使用三引号(‘’’ 或 “”")可以指定一个多行字符串。
• 转义符 \。
• 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n 会显示，并不是换行。
• 按字面意义级联字符串，如 "this " "is " “string” 会被自动转换为 this is string。
  - 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python 中的字符串不能改变。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

str='123456789' 
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始后的所有字符
print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)             # 输出字符串两次
print(str + '你好')         # 连接字符串 
print('------------------------------') 
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

字符串操作

字符串的格式化

将一个值插入到一个有字符串格式符 %s 的字符串中

>>> print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
    我叫 小明 今年 10 岁!

数值运算

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

List（列表）

• 列表 是 Python 中使用最频繁的数据类型。
• 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
• 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
• 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
• 索引值以 0 为开始值，-1 为从末尾的开始位置。
• 加号 + 是列表连接运算符，星号 * 是重复操作。
• 列表截取的语法格式如下：

变量[头下标:尾下标]

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

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

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 []
>>> a
[9, 2, 6]

注意：

• List写在方括号之间，元素用逗号隔开。
• 和字符串一样，list可以被索引和切片。
• List可以使用+操作符进行拼接。
• List中的元素是可以改变的。

列表操作

• 使用 append() 方法来添加列表项
• 使用 del 语句来删除列表的的元素
• +和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

>>>list1 = ['Google', 'Runoob', 'Taobao']
>>>list1.append('Baidu')
>>>print ("更新后的列表 : ", list1)
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']
>>>del list[2]
>>>print (list)
>['Google', 'Runoob', 2000]

列表函数

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：

>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)

列表函数和方法

tuple（元组）

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。
其实，可以把字符串看作一种特殊的元组。
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

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

元组的修改

• 元组中的元素值是不允许修改的，但可以对元组进行连接组合，+和*进行操作
• 元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组
• 已经定义好的元素值不能被修改
• 元组函数和列表函数类似

Set（集合）

• 一个无序的不重复元素序列。 - 由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
  - 基本功能是进行成员关系测试和删除重复元素。
• 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
  创建格式：

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)     # a 和 b 的差集，a-a&b
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集 
print(a ^ b)     # a 和 b 中不同时存在的元素,a+b-a&b

集合的修改

• 添加元素：s.add( x )或者s.update( x )，后者方法参数x可以是列表，元组，字典,并且x可以有多个值（用,隔开）
• 移除元素：s.remove( x )或者s.discard( x )，如果元素不存在，前者则会发生错误，后者不会
• 随机删除集合中的一个元素，s.pop()
• 情况集合：s.clear()
• 判断元素是否在集合中存在，x in s

Dictionary（字典）

• 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
• 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
• 键(key)必须使用不可变类型。
• 在同一个字典中，键(key)必须是唯一的。

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

构造函数 dict() 可以直接从键值对序列中构建字典如下：

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，所以可以用数字，字符串或元组充当，而用列表就不行，且且不能重复，
3、创建空字典使用 { }，不允许同一个键出现两次

字典的修改

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息
del tinydict['Name'] # 删除键 'Name'

• 通过新增键值对增加添加新内容
• 删除一个字典用del命令

数据类型转换

据类型的转换，一般情况下你只需要将数据类型作为函数名即可。 数据类型转换可以分为两种：

• 隐式类型转换 - 自动完成，整型和浮点型进行运算时，自动转为浮点型
• 显式类型转换 - 需要使用类型函数来转换，如：
  int(x [,base]) 将x转换为一个整数
  float(x) 将x转换到一个浮点数
  complex(real [,imag]) 创建一个复数
  str(x) 将对象 x 转换为字符串
  repr(x) 将对象 x 转换为表达式字符串
  eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
  tuple(s) 将序列 s 转换为一个元组
  list(s) 将序列 s 转换为一个列表
  set(s) 转换为可变集合
  dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。

Python 推导式

从一个数据序列构建另一个新的数据序列的结构体。Python 支持各种数据结构的推导式：

• 列表(list)推导式
• 字典(dict)推导式
• 集合(set)推导式
• 元组(tuple)推导式

列表推导格式

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]
或者
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

• out_exp_res：列表生成元素表达式，可以是有返回值的函数。
• for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
• if condition：条件语句，可以过滤列表中不符合条件的值

例子：
（1）过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：

>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']

（2）30以内能够被3整除的数：

>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

字典推导格式

{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }

比如：

>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

集合推导式

{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

判断不是 abc 的字母并输出：

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

元组推导式

利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

运算符

算术运算符

+ - * / %(取余） **(幂) //(向下取整)

比较运算符

==   !=  >    <    >=   <=

赋值运算符

项目	Value
+=	c += a 等效于 c = c + a
-=（*=）（/=）(**=)(//=)	含义与上类似

逻辑运算符

项目	Value
and	x and y 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。
or	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
not 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

>>>a= 10
>>>b = 20
>>>print(a and b)
20
>>>print(a or b)
10
>>>a= 0
>>>print(a and b)
0
>>>print(a or b)
20

成员运算符

项目	Value
in	如果在指定的序列中找到值返回 True，否则返回 False。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。

条件控制（if 语句）

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

• 如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
• 如果 “condition_1” 为False，将判断 “condition_2”
• 如果"condition_2" 为 True 将执行 “statement_block_2” 块语句
• 如果 “condition_2” 为False，将执行"statement_block_3"块语句
  嵌套 if 语句中，可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中

if 表达式1:
    语句1
    if 表达式2:
        语句2
    elif 表达式3:
        语句3
    else:
        语句4
elif 表达式4:
    语句5
else:
    语句6

• 如果式1为 True执行语句1，并判断式2是否为True，否则判断式3是否为True，否则执行else 语句4
• 如果式1为False，判断式4是否为True，否则执行语句6

循环

while 循环

while 判断条件(condition)：
    执行语句(statements)……

while 循环使用 else 语句：如果 while 后面的条件语句为 false 时，则执行 else 的语句块。

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")
输出结果：
0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

for语句

for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

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

例子

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")
输出：
循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!

如果需要遍历数字序列，可以使用内置range()函数
也可以结合range()和len()函数来遍历一个序列的索引

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
...     print(i, a[i])
... 
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ

还可以使用range()函数来创建一个列表：

break 和 continue 语句及循环中的 else 子句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
例子

 
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
        print(n, ' 是质数')
输出：2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3

pass 语句

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

 
for letter in 'Runoob': 
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter) 
print ("Good bye!")
输出：
当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!

迭代器与生成器

• 可迭代的（Iterable）：就是可以for循环取数据的，比如字典、列表、元组、字符串等，不可使用next()方法
• 迭代器对象（Iterator）：可以使用next()方法依次取数据

迭代器

• 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
• 是一个可以记住遍历的位置的对象。
• 从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
• 迭代器有两个基本的方法：iter() 和 next()
  例如：迭代器对象可以使用常规for语句进行遍历，也可以使用next()：

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")
输出
1 2 3 4

生成器

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

函数

• 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数定义

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

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

参数类型

• 必需参数：以正确的顺序传入函数。调用时的数量必须和声明时的一样，def(m,n)
• 关键字参数：和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
• 默认参数：调用函数时，如果没有传递参数，则会使用默认参数
• 不定长参数

#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return 
#调用printinfo函数
printinfo( age=50, name="runoob" )  关键参数

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )   默认参数
print ("------------------------")
printinfo( name="runoob" )

不定长参数

• 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
• 两个星号 ** 的参数会以字典的形式导入、
• 如果单独出现星号 *，则星号 * 后的参数必须用关键字传入：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

# *，输出元组
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )
输出: 
70
(60, 50)

# **输出字典
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)
输出: 
1
{'a': 2, 'b': 3}

匿名函数

不再使用 def 语句的形式定义一个函数， 使用 lambda 来创建匿名函数。

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

y=lambda a1,a2:a1*a2
print(y(2,3))
输出：
6

也可以将匿名函数封装在 myfunc 函数中，通过传入不同的参数来创建不同的匿名函数：

def g(n):
    return lambda a:a*n
f=g(4)
print(f(5))
输出：20

遍历技巧

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

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

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

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

同时遍历两个或更多的序列，可以使用 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.

模块

__name__属性

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

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

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

dir() 函数

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

错误和异常

语法错误

语法错误或者称之为解析错误

>>> while True print('Hello world')
  File "<stdin>", line 1, in ?
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。函数 print() 被检查到有错误，是它前面缺少了一个冒号 :

异常

异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError，NameError 和 TypeError。

错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。

异常处理

try/except

异常捕捉可以使用 try/except 语句。

try 语句按照如下方式工作；

• 首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）
• 如果没有异常发生，忽略 except 子句，try 子句执行后结束。
• 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
• 如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。
  一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。 处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

try/except…else

try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。
else 子句将在 try 子句没有发生任何异常的时候执行。

try-finally 语句

抛出异常raise 语句

语法格式：

raise [Exception [, args [, traceback]]]

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

面向对象

Python是一门面向对象的语言

面向对象技术

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
  - 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

类定义

语法格式：

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

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

类对象

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

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

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

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

类的方法

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

#类定义
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('runoob',10,30)
p.speak()
输出：runoob 说: 我 10 岁。

继承

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

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

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))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade)) 
 
s = student('ken',10,60,3)
s.speak()
输出：ken 说: 我 10 岁了，我在读 3 年级

多继承

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

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

方法重写

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

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
输出:
调用子类方法
调用父类方法

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

类属性与方法

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

类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。

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

标准库概览

操作系统接口

os模块提供了不少与操作系统相关联的函数。

>>> import os
>>> os.getcwd()      # 返回当前的工作目录
'C:\\Python34'
>>> os.chdir('/server/accesslogs')   # 修改当前的工作目录
>>> os.system('mkdir today')   # 执行系统命令 mkdir 
0

针对日常的文件和目录管理任务，:mod:shutil 模块提供了一个易于使用的高级接口:

>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
>>> shutil.move('/build/executables', 'installdir')

文件通配符

glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

命令行参数

通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys 模块的 argv 变量

>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three']

sys 还有 stdin，stdout 和 stderr 属性，即使在 stdout 被重定向时，后者也可以用于显示警告和错误信息，大多脚本的定向终止都使用 “sys.exit()”。

字符串正则匹配

re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案:

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

日期和时间

datetime模块为日期和时间处理同时提供了简单和复杂的方法。
支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出。

>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'

>>> # dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368

数学

math模块为浮点运算提供了对底层C函数库的访问

访问互联网

有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request 以及用于发送电子邮件的 smtplib:

数据压缩

直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile

测试模块

开发高质量软件的方法之一是为每一个函数开发测试代码，并且在开发过程中经常进行测试。doctest模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试。