python基础语法

一年没碰Python3.x，基本语法又忘得差不多了，回头整理一下我容易忘记的点。
参考 菜鸟教程

运算符

算数运算

%表示取余， 5%2=1；
// 表示取整，5//2=2。
数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。

比较运算

3<4<5 True
3<4==4 True

字符运算

\ 反斜杠在多行语句中用于换行，如
total = item_one +
item_two +
item_three
但在{} [] ()中无需使用。

也可以使用 “”"…""" 或者 ‘’’…’’’ 跨越多行。

反斜杠用于转义，如\n 表示换行，加r则不希望转义字符起作用，注意区分，demo:


加号 + 用于连接字符串，demo:

复制字符串可使用*，demo:

赋值运算

+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a| |

位运算

是对二进制表示进行的运算。
（分别使用 bin，oct，hex 可输出数字的二进制，八进制，十六进制形式）
使用格式化字符串进行进制转换，demo:

>>> num=10
>>> print('十六进制：%#x' % num)    #使用%x将十进制num格式化为十六进制
十六进制：0xa
>>> print('二进制:', bin(num))      #使用bin将十进制num格式化为二进制
二进制: 0b1010
>>> print('八进制：%#o' % num)      #使用%o将十进制num格式化为八进制
八进制：0o12

& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1
^ 按位异或运算符：当两对应的二进位相异时，结果为1
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1
<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<“右边的数指定移动的位数，高位丢弃，低位补0
>> 右移动运算符：把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数

子网掩码换算demo：

b = '1'
bs_len = len(b)
while bs_len < 9:
    b_b=b.ljust(8,'0')
    d=int(b_b,2)
    print('二进制 %s 相当于十进制 %s' %(b_b,d))
    b = b +"1"
    bs_len=len(b)

身份&成员运算

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

is is 是判断两个标识符是不是引用自一个对象 , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象

代码组

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组，demo:

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

在 while … else 在条件语句为 false 时执行 else 的语句块：

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")
   

for循环可以遍历任何序列的项目，如一个列表或者一个字符串，for循环的一般格式如下：

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

break 语句可以跳出 for 和 while 的循环体。如果从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

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

输出

print

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

x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

注意print和不加print结果会稍有区别。
输出也可以使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。
如果希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值；
希望将输出的值转成字符串，可以使用 解释器易读的repr()或 用户易读的str() 函数来实现。

格式化

格式化输出可使用format，demo：

for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...

输出结果：

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换，在括号中的数字用于指向传入对象在 format() 中的位置

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

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数，位置及关键字参数可以任意的结合：

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

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

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

% 操作符也可以实现字符串格式化，demo：

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

整数的格式化

print('%o' % 20) # 八进制24
print('%d' % 20) # 十进制20
print('%x' % 24) # 十六进制18

浮点数的格式化

print('%f' % 1.11)         # 默认保留6位小数1.110000
print('%.1f' % 1.11)       # 取1位小数1.1
print('%e' % 1.11)         # 默认6位小数，用科学计数法1.110000e+00
print('%.3e' % 1.11)       # 取3位小数，用科学计数法1.110e+00
print('%g' % 1111.1111)    # 默认6位有效数字1111.11
print('%.7g' % 1111.1111)  # 取7位有效数字1111.111
print('%.2g' % 1111.1111)  # 取2位有效数字，自动转换为科学计数法1.1e+03

字符串的格式化

print('%s' % 'hello world')       # 字符串输出hello world
print('%20s' % 'hello world')     # 右对齐，取20位，不够则补位         hello world
print('%-20s' % 'hello world')    # 左对齐，取20位，不够则补位hello world         
print('%.2s' % 'hello world')     # 取2位he
print('%10.2s' % 'hello world')   # 右对齐，取2位        he
print('%-10.2s' % 'hello world')  # 左对齐，取2位he

import

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

输入

键盘输入

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

读写文件

open() 将会返回一个 file 对象，open(filename, mode)
mode：决定了打开文件的模式：只读，写入，追加等。

• r 只读 （指针默认在开头）
• rb 二进制格式只读
• r+ 读写（文件必须存在）
• rb+ 二进制格式打开进行读写
• w 只写入，若文件已存在则从开头重新编辑，不存在则新建
• wb 二进制打开写入
• w+ 读写
• wb+ 二进制格式打开读写
• a 打开文件追加（指针放在文件末尾）
• ab 二进制打开追加
• a+ 读写
• ab+ 二进制打开进行追加
  即：r对于读，w对应写（两者区别在于文件是否必须存在），a对应追加，+表示读写，b表示二进制格式。
  

文件的方法

• f.read()
  为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。
  size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。
• f.readline()
  从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
• f.readlines()
  返回该文件中包含的所有行。
• f.write()
  f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
• f.close()
  在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。
  处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

获取文件后缀，demo：

def getfile_fix(filename):
     return filename[filename.rfind('.')+1:]
print(getfile_fix('runoob.txt'))

用户输入"xxx.txt"类文档文件名，输入被替换的"待替换字"，输入替换目标"新的字"，判断是否全部替换 yes/no：

def file_replace(file_name, rep_word, new_word):
    f_read = open(file_name)
    content = []
    count = 0
    for eachline in f_read:
        if rep_word in eachline:
            count = count+eachline.count(rep_word)
            eachline = eachline.replace(rep_word, new_word)
        content.append(eachline)    

    decide = input('\n文件 %s 中共有%s个【%s】\n您确定要把所有的【%s】替换为【%s】吗？\n【YES/NO】：' \
                   % (file_name, count, rep_word, rep_word, new_word))
                   
    if decide in ['YES', 'Yes', 'yes']:
        f_write = open(file_name, 'w')
        f_write.writelines(content)
        f_write.close()

    f_read.close()


file_name = input('请输入文件名：')
rep_word = input('请输入需要替换的单词或字符：')
new_word = input('请输入新的单词或字符：')
file_replace(file_name, rep_word, new_word)

数据类型

可变

List（列表）、Dictionary（字典）、Set（集合）

不可变

Number（数字）、String（字符串）、Tuple（元组）

判断类型

isinstance 和 type 的区别在于：

type()不会认为子类是一种父类类型；isinstance()会认为子类是一种父类类型。

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

删除数据用del，与matlab的clear类似。
Python可以同时为多个变量赋值，如 a, b = 1, 2

List 列表

列表是写在方括号 [ ] 之间、用逗号分隔开的元素列表。
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

listname[头下标:尾下标]

列表内部还可以嵌套列表，demo：

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]

列表推导式书写形式：

[表达式 for 变量 in 列表]
或者
[表达式 for 变量 in 列表 if 条件]
Python 列表是链式存储结构，并非顺序存储，通过查id可以看出。

Tuple 元组

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

tup[0] = 11  # 修改元组元素的操作是非法的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

·虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
·元组也可以使用+操作符进行拼接，可以把字符串看作一种特殊的元组。
·元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。
·元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：

>>>tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>
 
>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

Set 集合

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
parame = {value01,value02,...} 或 set(value)

输出集合时，重复元素会被自动去掉，集合可用于检测成员，demo:

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'} 
print(student)   # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
    

集合有对应的运算，差、并、交、补，demo：

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

输出结果:
{‘Mary’, ‘Jim’, ‘Rose’, ‘Jack’, ‘Tom’}
Rose 在集合中
{‘b’, ‘a’, ‘c’, ‘r’, ‘d’}
{‘b’, ‘d’, ‘r’}
{‘l’, ‘r’, ‘a’, ‘c’, ‘z’, ‘m’, ‘b’, ‘d’}
{‘a’, ‘c’}
{‘l’, ‘r’, ‘z’, ‘m’, ‘b’, ‘d’}

Dictionary 字典

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

dict = {}
dict['key1'] = "1 -value1"
dict[2] = "2 - value2"
print (dict['key1'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值

删除字典中某一对，用del dict[keyname]。
字典的键值是"只读"的，所以不能对键和值分别进行初始化.。

字典支持多级嵌套，demo：

cities={
    '北京':{
        '朝阳':['国贸','CBD','天阶','我爱我家','链接地产'],
        '海淀':['圆明园','苏州街','中关村','北京大学'],
        '昌平':['沙河','南口','小汤山',],
        '怀柔':['桃花','梅花','大山'],
        '密云':['密云A','密云B','密云C']
    },
    '河北':{
        '石家庄':['石家庄A','石家庄B','石家庄C','石家庄D','石家庄E'],
        '张家口':['张家口A','张家口B','张家口C'],
        '承德':['承德A','承德B','承德C','承德D']
    }
}
for i in cities['北京']:
    print(i)
    
for i in cities['北京']['海淀']:
    print(i)
    

注释

单行注释以 # 开头，多行注释用三个单引号 ‘’’ 或者三个双引号 “”" 将注释括起来，demo：

#!/usr/bin/python3 
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
'''
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号 
这是多行注释，用三个双引号
"""
#这是单行注释

迭代器与生成器

迭代

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

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

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

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

生成

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

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

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

函数

格式

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

参数传递

在 python 中，类型属于对象，变量是没有类型的。
a=[1,2,3] a="Runoob"
以上代码中，[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

可更改与不可更改对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象；
集合有两种类型：set为可变集合，frozenset为不可变集合。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

取不可变的数值demo:

传可变的list demo：

必需参数

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

关键字参数

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值；
若未指定关键字，则按传递顺序匹配。

默认参数

调用函数时，如果没有传递参数，则会使用默认参数，默认参数必须放在最后面。

不定长参数

• 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数，demo：

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

输出:
70
(60, 50)
如果在函数调用时没有指定参数，它就是一个空元组。也可以不向函数传递未命名的变量。

• 加了两个星号 ** 的参数会以字典的形式导入，demo：

def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(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 来创建匿名函数，即不再使用 def 语句这样标准的形式定义一个函数。

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

sum = lambda arg1, arg2: arg1 + arg2

lambda 匿名函数也是可以使用"关键字参数"进行参数传递，也可以设定默认值。

return语句

用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

变量作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

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

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

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域
        

内置作用域是通过一个名为 builtin 的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。

全局和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字，demo：

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

以上实例输出结果：
1
123
123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字，demo：

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

以上实例输出结果：
100
100

数据结构

列表

Python中列表是可变的，列表的方法使用格式 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()返回最后一个元素
• list.clear() 移除列表中的所有项，等于del a[:]
• list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误
• list.count(x) 返回 x 在列表中出现的次数
• list.sort() 对列表中的元素进行排序
• list.reverse() 倒排列表中的元素
  类似 insert, remove 或 sort 等修改列表的方法没有返回值。

list当做堆栈使用

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

list当做队列使用

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。
在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

列表推导式

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。
返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。
如果希望表达式推导出一个元组，就必须使用括号。
demo：

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

列表推导式可以使用复杂表达式或嵌套函数，demo：

>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

嵌套列表

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

matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]
>>> [[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 语句从列表中删除一个切割，或清空整个列表。

集合

集合也支持推导式，demo：

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

字典

序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。
理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。
一对大括号创建一个空的字典：{}。
构造函数 dict() 直接从键值对元组列表中构建字典，也可用推导式，demo：

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

遍历

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

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

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

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

按顺序或反向遍历List，用sorted和reversed

模块

如果从 Python 解释器退出再进入，那么定义的所有的方法和变量就都消失了。
为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。

语句

模块是一个包含所有你定义的函数和变量的文件，其后缀名是py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法，使用import语句引入。
from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中，只有name1 name2…

from modname import * 表示导入一个模块中所有项目，不建议过多使用。

name属性

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

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

>>>python using_name.py
   程序自身在运行
>>>import using_name
   我来自另一模块

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

dir() 函数

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

包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。
目录只有包含一个叫做 init.py 的文件才会被认作是一个包。
from Package import specific_submodule

错误和异常

try语句

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

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

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

except (RuntimeError, TypeError, NameError):
        pass

最后一个except子句可以忽略异常的名称，它将被当作通配符使用。可以使用这种方法打印错误信息，然后把异常抛出。

try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。
这个子句将在try子句没有发生任何异常的时候执行。
使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。

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

自定义异常

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

清理行为

try 语句还有另外一个可选的子句finnaly，它定义了无论在任何情况下都会执行的清理行为。
如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。
关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法。

面向对象

类Class

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

定义

demo：

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

操作

类对象支持两种操作：属性引用和实例化。
类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。
属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类定义了 init() 方法，类的实例化操作会自动调用它，可以有参数，参数通过 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 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。
在类的内部，使用 def 关键字来定义一个方法，定义私有属性 __weight = 0 ，在类外部无法直接访问。

单继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义demo：

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

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

多继承

Python同样有限的支持多继承形式。多继承的类定义形demo：

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

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

#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python.")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

执行以上程序输出结果为：

我叫 Tim，我是一个演说家，我演讲的主题是 Python.

方法重写

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

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

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

执行以上程序输出结果为：

调用子类方法
调用父类方法

私有方法

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

常用库

os

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

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

文件通配符

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

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

字符串正则匹配

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'

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，re.match(pattern, string, flags=0)
匹配成功re.match方法返回一个匹配的对象，否则返回None。

数学

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

>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757
>>> math.log(1024, 2)
10.0

时间

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

示例

参考菜鸟教程实例