Python基础

Python3简介

Pyhton是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

• Python是一个解释性语言（开发过程中没有了编译环节）
• Python是一个交互式语言（可以在提示符>>>后直接执行代码）
• Python是面向对象语言
• Python是初学者的语言

特点

1. 易于学习
2. 易于阅读
3. 易于维护
4. 一个广泛的标准库
5. 互动模式
6. 可移植
7. 可扩展
8. 数据库
9. GUI编程
10. 可嵌入：可以将Pyhon嵌入到C/C++程序，让程序获得“脚本化”的能力。

Python3的基础用法

编码

默认情况下，Python3源码文件以UTF-8编码，所有字符串都是unicode字符串。

标识符

• 第一个字符必须是字母或下划线
• 标识符的其他部分由字母、数字、下划线组成
• 标识符对大小写敏感
• Pyhon3中，可以用中文作为变量名，非ASCⅡ标识符也是允许的了。

保留字（关键字）

注意 assert、raise、yield、nonlocal、with

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

• assert(断言)

  Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。
  断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况。

>>> assert True     # 条件为 true 正常执行
>>> assert False    # 条件为 false 触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError
>>> assert 1==1    # 条件为 true 正常执行
>>> assert 1==2    # 条件为 false 触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

>>> assert 1==2, '1 不等于 2'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: 1 不等于 2
>>>

• nonlocal

nonlocal关键字用来在函数或其他作用域中使用并修改外层(非全局)变量（逐层到外面作用域找，直到全局作用域之前的局部作用域）。

对于global，只能使用全局变量，对于嵌套函数中的内层函数而言，无法通过global使用外层函数，通过nonlocal就可以，当然直接读取也可以（闭包）。
对于闭包，内层函数可以读取外层函数的变量，但是如果在内部函数中尝试进行修改外部变量，且外部变量为不可变类型，则需要在变量前加nonlocal，如果变量为可变类型，则不需要添加nonlocal。

意义：nonlocal使用能够弥补global和**闭包**的两个问题。

​ global（全局变量）

​ 闭包（闭包= 函数+环境变量）

'''
nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量。
'''
def work():
    x = 0
    def new_work():
        nonlocal x
        x=x+3
        return x
    return new_work
         
f=work()
print(f())
print(f())
print(f())
'''打印结果

3

6

9'''

• raise

当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。

Python中的raise 关键字用于引发一个异常，基本上和C#和Java中的throw关键字相同，如下所示。

def ThorwErr():
    raise Exception("抛出一个异常") 
# Exception: 抛出一个异常 
ThorwErr()

• yield

yield可以理解为一个return操作，但是和return又有很大的区别，执行完return，当前函数就终止了，函数内部的所有数据，所占的内存空间，全部都没有了。而yield在返回数据的同时，还保存了当前的执行内容，当你再一次调用这个函数时，他会找到你在此函数中的yield关键字，然后从yield的下一句开始执行。

而有yield的函数则返回一个可迭代的 **generator（生成器）**对象，你可以使用for循环或者调用next()方法遍历生成器对象来提取结果。

def example():
    x=1
    y=10
    while x<y:
       yield x
       x+=1
a = example()
print(a)
//生成一个迭代器
<generator object example at 0x00000266B45C0CC8>

for i in a:
    print(i)
1
2
3
4
5
6
7
8
9

yield的作用：它的作用是返回一个可以用来迭代(for循环)的生成器，它的应用场景通常为一个需要返回一系列值的，含有循环的函数中。

• with（主要处理文件开启关闭等问题）

  Python 中的 with 语句用于异常处理，封装了 try…except…finally 编码范式，提高了易用性。

  with 语句使代码更清晰、更具可读性， 它简化了文件流等公共资源的管理。

  在处理文件对象时使用 with 关键字是一种很好的做法。

  with open('./test_runoob.txt', 'w') as my_file:
      my_file.write('hello world!')
  

注释

# 单行注释

'''
多行注释
'''

同一行显示多条语句

Python可以在同一行中使用多条语句，语句之间使用分号(;)分割，以下是一个简单的实例：

x = 'abc'; print(x+'\n')
#输出
#abc

Python命令行参数学习

Python的命令行参数，提供了很多有用的功能，可以方便调试和运行。（2、3、4、5较为重要）

1. -B，在import时候，不产生 pyc 或者 pyo 文件。

2. -c，直接运行python语句(可以用于测试安装包是否可以成功引用)

   python -c "print ('abc')"
   

3. -i，运行完python脚本文件以后打开一个python环境，方便查看运行结果。

   

   

4. -m 参数，将模块按照脚本执行，最常见的用法是:

   

   在打开浏览器的8081端口，可以用于局域网的简单文件下载服务。

5. -V 参数，输出Python的版本

6. -O 参数，产生一个优化的pyo文件（和-B 参数一起使用无效）:

   

7. -v 参数，会输出每一个模块引用信息，包括从何处引用的，以及何时被清除的

8. -u 参数，在print记录时候很有用，使用这个参数 会强制 stdin, stdout 和 stderr变为无缓冲的，会立刻输出出来，而不是等缓冲区满了才会打印数据。

Python变量类型

变量是存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。

基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。

因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

标准数据类型

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）

Python数字类型

Python支持四种不同的数字类型：

• int（有符号整型）
• long（长整型，也可以代表八进制和十六进制）
• float（浮点型）
• complex（复数）

#复数实现
#1、
a = complex(5,4)
#5+4j
#2、
b = 5+4j

Python字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。

如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

Python列表

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

列表用 [ ] 标识，是 python 最通用的复合数据类型。

列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

Python元组（不可更改）

元组是另一个数据类型，类似于 List（列表）。

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

#以下对元组的操作是无效的，因为元组不允许更新，而列表是允许更新的：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000    # 元组中是非法应用
list[2] = 1000     # 列表中是合法应用
元组是不允许更新的，所以以上代码执行错误，结果如下：

Traceback (most recent call last):
  File "test.py", line 6, in <module>
    tuple[2] = 1000    # 元组中是非法应用
TypeError: 'tuple' object does not support item assignment

Python 字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数	描述
[int(x [,base])]	将x转换为一个整数
[long(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)元组。
[frozenset(s)]	转换为不可变集合
[chr(x)]	将一个整数转换为一个字符
[unichr(x)]	将一个整数转换为Unicode字符
[ord(x)]	将一个字符转换为它的整数值
[hex(x)]	将一个整数转换为一个十六进制字符串
[oct(x)]	将一个整数转换为一个八进制字符串

用的相对较多的方法：int(x) ; float(x) ; complex(a,b) ; str(x) ; list(x) ; tuple(x) ; set(x) ;

可变集合为set；不可变集合为fronzenset。他们有一定的区别。

Python推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 支持各种数据结构的推导式：

• 列表(list)推导式

  [表达式 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：条件语句，可以过滤列表中不符合条件的值
  

  例子：

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

• 字典(dict)推导式

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

  例子：

  listdemo = ['Google','Runoob', 'Taobao']
  # 将列表中各字符串值为键，各字符串的长度为值，组成键值对
  >>> newdict = {key:len(key) for key in listdemo}
  >>> newdict
  {'Google': 6, 'Runoob': 6, 'Taobao': 6}
  

• 集合(set)推导式

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

  例子

  >>> setnew = {i**2 for i in (1,2,3)}
  >>> setnew
  {1, 4, 9}
  

• 元组(tuple)推导式

  (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)
  

Python 运算符

Python语言支持以下类型的运算符:

• 算术运算符（+，-，*，/，%【取模-返回除法的余数】，**【幂】，//【取除整-向下取整】）

• 比较（关系）运算符（==，！=，> , < , >= , <= ）

• 赋值运算符（=，+=，-=，=，/=，%=，*=，//=，:=）

  ：= 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。

  例子：

  在这个示例中，赋值表达式可以避免调用 len() 两次:

  if (n := len(a)) > 10:
      print(f"List is too long ({n} elements, expected <= 10)")
  

• 逻辑运算符(and 与 , or 或 , not 非 )

• 位运算符（暂时感觉用的相对较少 ）

  符	描述	实例
  & 与	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
  |或	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
  ^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
  ~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
  <<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
  >>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

• 成员运算符（in ； not in）

• 身份运算符（is ； not is） 用于比较两个对象的储存单元

• 运算符优先级

  运算符	描述
  **	指数 (最高优先级)
  ~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
  * / % //	乘，除，取模和取整除
  + -	加法减法
  >> <<	右移，左移运算符
  &	位 ‘AND’
  ^ |	位运算符
  <= < > >=	比较运算符
  <> == !=	等于运算符
  = %= /= //= -= += *= **=	赋值运算符
  is is not	身份运算符
  in not in	成员运算符
  not and or	逻辑运算符

Python 条件语句

1. if
2. if …else…
3. if …elif…elif…else…
4. Python没有三元表达式

Python 循环语句

（在 Python 中没有 do…while 循环）

Python 提供了 for 循环和 while 循环

1. for循环
2. while 循环
3. while …else循环
4. 嵌套循环（多个循环嵌套在一起）

循环控制语句

控制语句	描述
break	在语句块执行过程中终止循环，并且跳出整个循环
continue	在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass	pass是空语句，是为了保持程序结构的完整性。

Python数字

• 整型
• 长整型long
• 浮点型float
• 复数 complex

number类型转换

int(x [,base ])         将x转换为一个整数  
long(x [,base ])        将x转换为一个长整数  
float(x )               将x转换到一个浮点数  
complex(real [,imag ])  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串  

math与cmath库

Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。

Python math 模块提供了许多对浮点数的数学运算函数。

Python cmath 模块包含了一些用于复数运算的函数。

>>> import math
>>> dir(math)
['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
>>>

>>> import cmath
>>> dir(cmath)
['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
>>>

math模块常量与方法

常用常量：math.e ; math.inf ; math.nan ; math.pi ; math.tau

常量	描述
math.e	返回欧拉数 (2.7182…)
math.inf	返回正无穷大浮点数
math.nan	返回一个浮点值 NaN (not a number)
math.pi	π 一般指圆周率。 圆周率 PI (3.1415…)
math.tau	数学常数 τ = 6.283185…，精确到可用精度。Tau 是一个圆周常数，等于 2π，圆的周长与半径之比。

方法	描述
math.acos(x)	返回 x 的反余弦，结果范围在 0 到 pi 之间。
math.acosh(x)	返回 x 的反双曲余弦值。
math.asin(x)	返回 x 的反正弦值，结果范围在 -pi/2 到 pi/2 之间。
math.asinh(x)	返回 x 的反双曲正弦值。
math.atan(x)	返回 x 的反正切值，结果范围在 -pi/2 到 pi/2 之间。
math.atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值，结果是在 -pi 和 pi 之间。
math.atanh(x)	返回 x 的反双曲正切值。
math.ceil(x)	将 x 向上舍入到最接近的整数
math.comb(n, k)	返回不重复且无顺序地从 n 项中选择 k 项的方式总数。
math.copysign(x, y)	返回一个基于 x 的绝对值和 y 的符号的浮点数。
math.cos()	返回 x 弧度的余弦值。
math.cosh(x)	返回 x 的双曲余弦值。
math.degrees(x)	将角度 x 从弧度转换为度数。
math.dist(p,q)	返回 p 与 q 两点之间的欧几里得距离，以一个坐标序列（或可迭代对象）的形式给出。 两个点必须具有相同的维度。
math.erf(x)	返回一个数的误差函数
math.erfc(x)	返回 x 处的互补误差函数
math.exp(x)	返回 e 的 x 次幂，Ex， 其中 e = 2.718281… 是自然对数的基数。
math.expm1()	返回 Ex - 1， e 的 x 次幂，Ex，其中 e = 2.718281… 是自然对数的基数。这通常比 math.e ** x 或 pow(math.e, x) 更精确。
math.fabs(x)	返回 x 的绝对值。
math.factorial(x)	返回 x 的阶乘。 如果 x 不是整数或为负数时则将引发 ValueError。
math.floor()	将数字向下舍入到最接近的整数
math.fmod(x, y)	返回 x/y 的余数
math.frexp(x)	以 (m, e) 对的形式返回 x 的尾数和指数。 m 是一个浮点数， e 是一个整数，正好是 x == m * 2**e 。 如果 x 为零，则返回 (0.0, 0) ，否则返回 0.5 <= abs(m) < 1 。
math.fsum(iterable)	返回可迭代对象 (元组, 数组, 列表, 等)中的元素总和，是浮点值。
math.gamma(x)	返回 x 处的伽马函数值。
math.gcd()	返回给定的整数参数的最大公约数。
math.hypot()	返回欧几里得范数，sqrt(sum(x^2 for x in coordinates))。 这是从原点到坐标给定点的向量长度。
math.isclose(a,b)	检查两个值是否彼此接近，若 a 和 b 的值比较接近则返回 True，否则返回 False。。
math.isfinite(x)	判断 x 是否有限，如果 x 既不是无穷大也不是 NaN，则返回 True ，否则返回 False 。
math.isinf(x)	判断 x 是否是无穷大，如果 x 是正或负无穷大，则返回 True ，否则返回 False 。
math.isnan()	判断数字是否为 NaN，如果 x 是 NaN（不是数字），则返回 True ，否则返回 False 。
math.isqrt()	将平方根数向下舍入到最接近的整数
math.ldexp(x, i)	返回 x * (2**i) 。 这基本上是函数 math.frexp() 的反函数。
math.lgamma()	返回伽玛函数在 x 绝对值的自然对数。
math.log(x[, base])	使用一个参数，返回 x 的自然对数（底为 e ）。
math.log10(x)	返回 x 底为 10 的对数。
math.log1p(x)	返回 1+x 的自然对数（以 e 为底）。
math.log2(x)	返回 x 以 2 为底的对数
math.perm(n, k=None)	返回不重复且有顺序地从 n 项中选择 k 项的方式总数。
math.pow(x, y)	将返回 x 的 y 次幂。
math.prod(iterable)	计算可迭代对象中所有元素的积。
math.radians(x)	将角度 x 从度数转换为弧度。
math.remainder(x, y)	返回 IEEE 754 风格的 x 除于 y 的余数。
math.sin(x)	返回 x 弧度的正弦值。
math.sinh(x)	返回 x 的双曲正弦值。
math.sqrt(x)	返回 x 的平方根。
math.tan(x)	返回 x 弧度的正切值。
math.tanh(x)	返回 x 的双曲正切值。
math.trunc(x)	返回 x 截断整数的部分，即返回整数部分，删除小数部分

math相对重要的数据函数

• abs(x) 绝对值
• ceil(x) 向上取整
• cmp(x,y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
• exp(x) ex**
• fabs(x) 绝对值（浮点数）
• floor(x) 向下取整
• log(x)
• log10(x)
• max(x1,x2…)
• min(x1,x2…)
• modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
• pow(x,y) xy**
• round(x,[n]) 四舍五入
• sqrt(x) 平方根

math相对重要的三角函数

• acos(x) 反余弦弧度制
• asin(x)
• atan(x)
• atan2(y,x) 返回给定的x，y 坐标的反正切值
• cos(x)
• sin(x)
• hypot(x,y) 返回欧几里德范数 sqrt(xx + yy)。
• tan(x)
• degrees(x) 弧度转角度
• radians(x) 将角度转换为弧度

random库

• choice （seq）从序列里随机挑选一个元素
• randrange（[start],stop[,step]）从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为1
• random（） 随机生成一个实数[0，1）范围内
• seed（[x]） 改变随机数生成器的种子seed
• shuffle（lst） 将序列的所有元素随机排序
• uniform（x,y） 随机生成一个实数，在[x,y]范围内

Python字符串

访问字符串的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：

变量[头下标:尾下标]

注意：尾下标的字符是不会被截取到的

例子：

#!/usr/bin/python3
 
var1 = 'Hello World!'
var2 = "Runoob"
 
print ("var1[0]: ", var1[0])  #H
print ("var2[1:5]: ", var2[1:5]) #unoo

转义字符

转义字符	描述	实例
\(在行尾时)	续行符	>>> print("line1 \ ... line2 \ ... line3") line1 line2 line3 >>>
\	反斜杠符号	>>> print("\\") \
’	单引号	>>> print('\'') '
"	双引号	>>> print("\"") "
\a	响铃	>>> print("\a")执行后电脑有响声。
\b	退格(Backspace)	>>> print("Hello \b World!") Hello World!
\000	空	>>> print("\000") >>>
\n	换行	>>> print("\n") >>>
\v	纵向制表符	>>> print("Hello \v World!") Hello World! >>>
\t	横向制表符	>>> print("Hello \t World!") Hello World! >>>
\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。	>>> print("Hello\rWorld!") World! >>> print('google runoob taobao\r123456') 123456 runoob taobao
\f	换页	>>> print("Hello \f World!") Hello World! >>>
\yyy	八进制数，y 代表 0~7 的字符，例如：\012 代表换行。	>>> print("\110\145\154\154\157\40\127\157\162\154\144\41") Hello World!
\xyy	十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行	>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") Hello World!
\other	其它的字符以普通格式输出

字符串运算符

• [] 截取单字符

• [:] 截取字符串

• in

• not in

• r/R

  原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。

  例子：

  >>> print(r'\n')
  \n
  >>> print(R'\n')
  \n
  

• % 格式字符串

字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

例子：

#!/usr/bin/python

print "My name is %s and weight is %d kg!" % ('Zara', 21) 

My name is Zara and weight is 21 kg!

字符串格式化符号

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%F 和 %E 的简写
%p	用十六进制数格式化变量的地址

Python三引号

Python 中三引号可以将复杂的字符串进行赋值。

Python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。

例子：

 >>> hi = '''hi 
there'''
>>> hi   # repr()
'hi\nthere'
>>> print hi  # str()
hi 
there  

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

总结：三引号主要用于配置文件，即所写及所得，不用考虑转义字符等事情

一个典型的用例是，当你需要一块HTML或者SQL时，这时当用三引号标记，使用传统的转义字符体系将十分费神。

 errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (  
login VARCHAR(8), 
uid INTEGER,
prid INTEGER)
''')

字符串内建函数

方法	描述
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() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
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+1 个子字符串
[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.capitalize()

• 转换大小写

  string.upper()

  string.lower()

  string.swapcase() 翻转 string 中的大小写

• 转换位置

  string.center(width)

  string.ljust(width)

  string.rjust(width)

  string.zfill(width) 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

• 截掉空字符

  string.strip()

  string.rstrip()

  string.lstrip()

• 替换

  string.replace(str1,str2)

• 查找

  string.find(str)

  string.rfind(str)

  string.lfind(str)

  注意：index方法与find一样，但是如果找不到就会报异常

  string.index(str)

  string.lindex(str)

  string.rindex(str)

• 检验

  string.endswith(obj, beg=0, end=len(string))

  string.startswith(obj, beg=0, end=len(string))

• 格式化

  string.format()

• 判断

  string.isalnum()

  string.isalpha()

  string.isdecimal()

  string.isdigit()

  string.islower()

  string.isnumeric()

  string.isspace()

  string.istitle()

  string.isupper()

Python 列表

python列表函数与方法

1. Python包含以下函数
   • cmp（list1，list2） 比较两个列表元素
   • len（list）
   • max(list)
   • min(list)
   • list(seq)
2. list的方法
   • list.append(obj)
   • list.count(obj)
   • list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
   • list.index(obj)
   • list.pop([index=-1]) 移除列表中的一个元素
   • list.remove(obj)
   • list.reverse()
   • list.sort() 对列表进行排序

Python元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

删除元组

del tuple

元组内置函数

Python元组包含了以下内置函数

序号	方法及描述
1	cmp(tuple1, tuple2) 比较两个元组元素。
2	len(tuple) 计算元组元素个数。
3	max(tuple) 返回元组中元素最大值。
4	min(tuple) 返回元组中元素最小值。
5	tuple(seq) 将列表转换为元组。

Python字典

字典的实现（面试考试）

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中。

字典键的特性

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述
1	cmp(dict1, dict2) 比较两个字典元素。
2	len(dict) 计算字典元素个数，即键的总数。
3	str(dict) 输出字典可打印的字符串表示。
4	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：

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

Python集合

集合（set）是一个无序的不重复元素序列。

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

集合的基本操作

1. 添加元素
   • s.add(x)
   • s.update(x) 可以添加元素，且参数可以是列表，元组，字典等
2. 移除元素
   • s.remove(x) 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
   • s.discard(x) 移除集合中的元素，且如果元素不存在，不会发生错误
   • s.pop() 设置随机删除集合中的一个元素
3. 计算集合元素个数
   • len(s)
4. 清空集合
   • s.clear()
5. 判断元素是否在集合中存在
   • x in s

集合内置方法完整列表

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

Python3的迭代器与生成器

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器。

实例：

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

#迭代器对象可以使用常规for语句进行遍历：
#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")
1 2 3 4


#也可以使用 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()

创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 _iter_() 与 _next_() 。

如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 _init_(), 它会在对象初始化的时候执行。

_iter_() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 _next_() 方法并通过 StopIteration 异常标识迭代的完成。

_next_() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

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

调用一个生成器函数，返回的是一个迭代器对象。

Python3 函数

函数的作用：函数能提高应用的模块性，和代码的重复利用率。

定义函数的方法：

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

注意事项：

1、参数传递

在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的：

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,set,dict 等则是可以修改的对象。

不可变对象与可变对象的区别：

​ 不可变对象中，变量名只是传递的是该不可变对象的地址，并不会改变对象的值。（如果变量名所显示的值变了，也是将变量名所指的对象发生了变化）

​ 可变对象中，对象发生改变，变量名所指引的地址未发生变化。

例子：

>>> a= 1
>>> id(a)
140723117138320
>>> a = 2
>>> id(a)
140723117138352
>>> b =set()
>>> id(b)
2337014922152
>>> b.add('a')
>>> id(b)
2337014922152

参数类型

• 必须参数

  必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

  总结：必须参数 为 函数调用时所展现的参数。

  #!/usr/bin/python3
   
  #可写函数说明
  #str 是必须参数
  def printme( str ):
     "打印任何传入的字符串"
     print (str)
     return
   
  # 调用 printme 函数，不加参数会报错
  printme()
  

• 关键字参数

  关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

  使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

  以下实例在函数 printme() 调用时使用参数名：

  #!/usr/bin/python3
   
  #可写函数说明
  #str为关键字参数，我认为也可以叫必须参数
  def printme( str ):
     "打印任何传入的字符串"
     print (str)
     return
   
  #调用printme函数
  printme( str = "菜鸟教程")
  

  总结：关键字参数与必须参数即在函数调用时，有没有确定传入的参数值。

• 默认参数

  调用函数时，如果没有传递参数，则会使用默认参数。

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

• 不定长参数（即参数的元组，字典等）

  你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下

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

  1. 加了星号 ***** 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
  2. 加了两个星号 ** 的参数会以字典的形式导入。
  3. *声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 ，则星号 * 后的参数必须用关键字传入

  #第一种情况
  #!/usr/bin/python3
    
  # 可写函数说明
  def printinfo( arg1, *vartuple ):
     "打印任何传入的参数"
     print ("输出: ")
     print (arg1)
     print (vartuple)
   
  # 调用printinfo 函数
  printinfo( 70, 60, 50 )
  
  
  #第二种情况
  #!/usr/bin/python3
    
  # 可写函数说明
  def printinfo( arg1, **vardict ):
     "打印任何传入的参数"
     print ("输出: ")
     print (arg1)
     print (vardict)
   
  # 调用printinfo 函数
  printinfo(1, a=2,b=3)
  输出: 
  1
  {'a': 2, 'b': 3}
  
  
  
  #第三种情况
  >>> def f(a,b,*,c):
  ...     return a+b+c
  ... 
  >>> f(1,2,3)   # 报错
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: f() takes 2 positional arguments but 3 were given
  >>> f(1,2,c=3) # 正常
  6
  >>>
  

匿名函数（lambda函数）

Python 使用 lambda 来创建匿名函数。

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

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

语法

lambda 函数的语法只包含一个语句，如下：

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

设置参数 a 加上 10:

实例

x = lambda a : a + 10 print(x(5))

以上实例输出结果：15

以下实例匿名函数设置两个参数：

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

以上实例输出结果：

相加后的值为 :  30
相加后的值为 :  40

重要：

我们可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。

以下实例将匿名函数封装在 myfunc 函数中，通过传入不同的参数来创建不同的匿名函数：（重要）

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(mydoubler(11))
print(mytripler(11))

以上实例输出结果：

22
33

Python3 数据结构（主要回顾list、set、tuple、dict等常用方法）

该章节主要是应用list、字典等方法实现数据结构中常用的栈、队列等结构

list

方法	描述
list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i])	从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x)	返回 x 在列表中出现的次数。
list.sort()	对列表中的元素进行排序。
list.reverse()	倒排列表中的元素。
list.copy()	返回列表的浅复制，等于a[:]。

利用列表实现堆栈的使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

利用list实现队列（先进先出）

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

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

tuple

元组由若干逗号分隔的值组成

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

如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。

set

dict

遍历技巧

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

   注：dict.items() 返回的是items类型

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

2. 使用枚举进行遍历

   >>> 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. 进行翻转遍历（利用reserver（）方法）

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

5. 进行排序遍历（利用sort（）方法）

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

Python3模块

模块引用

• import 模块名
• from 模块名 import 方法名
• from 模块名 import *

__name__属性

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

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

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

$ python using_name.py
程序自身在运行

$ python
>>> import using_name
我来自另一模块
>>>

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

说明：name 与 main 底下是双下划线， _ _ 是这样去掉中间的那个空格。

dir() 函数

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

如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称。

包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。

比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

包的结构

目录只有包含一个叫做 _init_.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。

最简单的情况，放一个空的 :file:_init_.py就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的）__all__变量赋值。

包的引用

from package import item

from sound.effects import *

包的__init.py__内置方法（属性）

1. _all_

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

2. _path_

   包还提供一个额外的属性__path__。这是一个目录列表，里面每一个包含的目录都有为这个包服务的__init__.py，你得在其他__init__.py被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。

Python输入与输出

读取键盘输入（input函数）

Python 提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。

#!/usr/bin/python3

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

Python输出（主要为字符串的格式化方法）

【重要】str.format() 方法用法

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

• 括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

• 在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：

>>> **print**('{0} 和 {1}'.format('Google', 'Runoob'))
Google 和 Runoob
>>> **print**('{1} 和 {0}'.format('Google', 'Runoob'))
Runoob 和 Google

• 如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

>>> **print**('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
菜鸟教程网址： www.runoob.com

• 位置及关键字参数可以任意的结合:

>>> **print**('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
站点列表 Google, Runoob, 和 Taobao。

• !a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化:

  >>> import math
  >>> print('常量 PI 的值近似为： {}。'.format(math.pi))
  常量 PI 的值近似为： 3.141592653589793。
  >>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
  常量 PI 的值近似为： 3.141592653589793。
  

• 可选项 : 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位。

  >>> import math
  >>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
  常量 PI 的值近似为 3.142。
  

• 在 : 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。

  >>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
  >>> for name, number in table.items():
  ...     print('{0:10} ==> {1:10d}'.format(name, number))
  ...
  Google     ==>          1
  Runoob     ==>          2
  Taobao     ==>          3
  

• 如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。最简单的就是传入一个字典, 然后使用方括号 [] 来访问键值 :

  >>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
  >>> **print**('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
  Runoob: 2; Google: 1; Taobao: 3
  

  也可以通过在 table 变量前使用 ** 来实现相同的功能：

  >>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
  >>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
  Runoob: 2; Google: 1; Taobao: 3
  

文件（File）

文件的打开与读 file.open()、file.read()

open(filename, mode)
#完整语法
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

文件的读

• f.read()

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

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

• f.readline()

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

• f.readlines()

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

文件的写file.write()

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

文件所用方法

f.tell()

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

f.seek()

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

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

from_what 值为默认为0，即文件开头。

• seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
• seek(x,1) ： 表示从当前位置往后移动x个字符
• seek(-x,2)：表示从文件的结尾往前移动x个字符

f.close()

在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

总结

序号	方法及描述
1	file.close()关闭文件。关闭后文件不能再进行读写操作。
2	file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4	file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next()Python 3 中的 File 对象不支持 next() 方法。返回文件下一行。
6	[file.read(size])从文件读取指定的字节数，如果未给定或为负则读取所有。
7	[file.readline(size])读取整行，包括 “\n” 字符。
8	[file.readlines(sizeint])读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9	[file.seek(offset, whence])移动文件读取指针到指定位置
10	file.tell()返回文件当前位置。
11	[file.truncate(size])从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
12	file.write(str)将字符串写入文件，返回的是写入的字符长度。
13	file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

OS文件/目录方法

序号	方法及描述
1	os.access(path, mode) 检验权限模式
2	os.chdir(path) 改变当前工作目录
3	os.chflags(path, flags) 设置路径的标记为数字标记。
4	os.chmod(path, mode) 更改权限
5	os.chown(path, uid, gid) 更改文件所有者
6	os.chroot(path) 改变当前进程的根目录
7	os.close(fd) 关闭文件描述符 fd
8	os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9	os.dup(fd) 复制文件描述符 fd
10	os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
11	os.fchdir(fd) 通过文件描述符改变当前工作目录
12	os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13	os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14	os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15	os.fdopen(fd[, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16	os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17	os.fstat(fd) 返回文件描述符fd的状态，像stat()。
18	os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19	os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。
20	os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21	os.getcwd() 返回当前工作目录
22	os.getcwdb() 返回一个当前工作目录的Unicode对象
23	os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24	os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25	os.lchmod(path, mode) 修改连接文件权限
26	os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
27	os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
28	os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
29	os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30	os.lstat(path) 像stat(),但是没有软链接
31	os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32	os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
33	[os.makedirs(path, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34	os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35	[os.mkdir(path, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36	[os.mkfifo(path, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制)
37	[os.mknod(filename, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38	[os.open(file, flags, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
39	os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40	os.pathconf(path, name) 返回相关文件的系统配置信息。
41	os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42	os.popen(command[, mode[, bufsize]]) 从一个 command 打开一个管道
43	os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44	os.readlink(path) 返回软链接所指向的文件
45	os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46	os.removedirs(path) 递归删除目录。
47	os.rename(src, dst) 重命名文件或目录，从 src 到 dst
48	os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
49	os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50	os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51	[os.stat_float_times(newvalue]) 决定stat_result是否以float对象显示时间戳
52	os.statvfs(path) 获取指定路径的文件系统统计信息
53	os.symlink(src, dst) 创建一个软链接
54	os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55	os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56	os.tempnam([dir[, prefix]]) Python3 中已删除。返回唯一的路径名用于创建临时文件。
57	os.tmpfile() Python3 中已删除。返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58	os.tmpnam() Python3 中已删除。为创建一个临时文件返回一个唯一的路径
59	os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
60	os.unlink(path) 删除文件路径
61	os.utime(path, times) 返回指定的path文件的访问和修改的时间。
62	os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。
63	os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
64	os.path 模块 获取文件的属性信息。
65	os.pardir() 获取当前目录的父目录，以字符串形式显示目录名。
66	os.replace() 重命名文件或目录

python 错误和异常

异常判断处理（try/except）

try/except

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

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

一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

try/except…else

try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。

else 子句将在 try 子句没有发生任何异常的时候执行。

try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码。

抛出异常

raise

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

raise语法格式如下：

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

以下实例如果 x 大于 5 就触发异常:

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

执行以上代码会触发异常：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
Exception: x 不能大于 5。x 的值为: 10

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

如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

>>> **try**:
    **raise** NameError('HiThere') # 模拟一个异常。
  **except** NameError:
    **print**('An exception flew by!')
    **raise**
  
An exception flew by!
Traceback (most recent call last):
 File "<stdin>", line 2, **in** ?
NameError: HiThere

---

用户自定义异常

你可以通过创建一个新的异常类来拥有自己的异常。**异常类继承自 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!'

在这个例子中，类 Exception 默认的 _init_() 被覆盖。

当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:

class Error(Exception):
    """Base class for exceptions in this module."""
    pass

class InputError(Error):
    """Exception raised for errors in the input.

    Attributes:
        expression -- input expression in which the error occurred
        message -- explanation of the error
    """

    def __init__(self, expression, message):
        self.expression = expression
        self.message = message

class TransitionError(Error):
    """Raised when an operation attempts a state transition that's not
    allowed.

    Attributes:
        previous -- state at beginning of transition
        next -- attempted new state
        message -- explanation of why the specific transition is not allowed
    """

    def __init__(self, previous, next, message):
        self.previous = previous
        self.next = next
        self.message = message

大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。

---

定义清理行为

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

>>> try:
...     raise KeyboardInterrupt
... finally:
...     print('Goodbye, world!')
...
Goodbye, world!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyboardInterrupt

以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出。

下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:

>>> def divide(x, y):
        try:
            result = x / y
        except ZeroDivisionError:
            print("division by zero!")
        else:
            print("result is", result)
        finally:
            print("executing finally clause")
   
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

预定义的清理行为

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

下面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

**for** line **in** open("myfile.txt"):
  **print**(line, end="")

以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。

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

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

以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭

Python 面向对象

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

• **方法：**类中定义的函数。

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

• **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

• **数据成员：**类变量或者实例变量用于处理类及其实例对象的相关的数据。

• **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

• **局部变量：**定义在方法中的变量，只作用于当前实例的类。

• **实例变量：**在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

• **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

  python中可以单继承也可以多继承

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

• **实例化：**创建一个类的实例，类的具体对象。

• **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

注意：python没有重载。

类的专有方法

• init : 构造函数，在生成对象时调用

  __init__方法负责对象的初始化，系统执行该方法前，其实该对象已经存在了，

• del : 析构函数，释放对象时使用

• repr : 打印，转换

• setitem : 按照索引赋值

• getitem: 按照索引获取值

• len: 获得长度

• cmp: 比较运算

• call: 函数调用

• add: 加运算

• sub: 减运算

• mul: 乘运算

• truediv: 除运算

• mod: 求余运算

• pow: 乘方

• new:是在新式类中新出现的方法，它作用在构造方法init()建造实例之前，可以这么理解，在Python 中存在于类里面的构造方法init()负责将类的实例化。