Python 学习笔记

本文主要包括 Python 遍历方法、公共方法、异常处理、模块、列表推导式等内容。

遍历

通过 for ... in ...: 的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构。

字符串、列表、元组遍历

>>> for i in 'abc':    
...     print(i)       
...                    
a                      
b                      
c                      
>>> for i in [1,2,3]:  
...     print(i)       
...                    
1                      
2                      
3                      
>>> for i in (1,2,3):  
...     print(i)       
...                    
1                      
2                      
3                      
>>>

字典遍历

>>> for key in dict.keys():
...     print(key)
...
name
age

>>> for value in dict.values():
...     print(value)
...
liuha
29

>>> for item in dict.items():
...     print(item)
...
('name', 'liuha')
('age', 29)

>>> for key,value in dict.items():
...     print('%s=%s' %(key,value))
...
name=liuha
age=29

enumerate()

enumerate(sequence, [start=0]) - 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

>>> l = ['a', 'b', 'c']
>>> list(enumerate(l))
[(0, 'a'), (1, 'b'), (2, 'c')]

>>> list(enumerate(l, start=1))
[(1, 'a'), (2, 'b'), (3, 'c')]

>>> list = ['a', 'b', 'c']

>>> for i,ele in enumerate(list):
...     print('%s=%s' %(i, ele))
...
0=a
1=b
2=c

# 下标位置从1开始
>>> for i,ele in enumerate(list, start=1):
...     print('%s=%s' %(i, ele))
...
1=a
2=b
3=c
>>>

---

公共方法

运算符

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	‘Hi!’ * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	复制	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典

---

Python函数相关

python内置函数

方法	描述
len(item)	计算容器中元素个数
max(item)	返回容器中元素最大值
min(item)	返回容器中元素最小值
del(item)	删除变量

函数参数

缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。

# 缺省参数
def printInfo(name, age=5):
    print('name is %s, age is %s' %(name, age))

printInfo('liuha', 20)
printInfo('liu2')

输出结果为：

name is liuha, age is 20
name is liu2, age is 5

注意：带有默认值的参数一定要位于参数列表的最后面。否则会报错：SyntaxError: non-default argument follows default argument

不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。

基本语法如下：

def functionname([formal_args,] *args, **kwargs):
   function_suite
   return [expression]

加了 * 的变量 args 会存放所有未命名的变量参数，args 为元组；而加 ** 的变量 kwargs 会存放命名参数，即形如 key=value 的参数， kwargs 为字典。

# 可变长参数
def func_test(a, b=2, *args, **kwargs):
    print('a = %s' %a)
    print('b = %s' %b)
    print('args = ' , args)
    print('kwargs = ' , kwargs)

func_test(1,2,3,4,k1=2,k2=3)
print('-'*5)

func_test(1,2,3,k1=2,k2=3)
print('-'*5)

func_test(1,k1=3)

输出：

1
2
[1, 2, 3]
[1, 2, 3]
----------
name is liuha, age is 20
name is liu2, age is 5
----------
a = 1
b = 2
args =  (3, 4)
kwargs =  {'k1': 2, 'k2': 3}
-----
a = 1
b = 2
args =  (3,)
kwargs =  {'k1': 2, 'k2': 3}
-----
a = 1
b = 2
args =  ()
kwargs =  {'k1': 3}

引用传参

可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？

Python中函数参数是引用传递（注意不是值传递）。对于不可变类型（string，integer，tuple），因变量不能修改，所以运算不会影响到变量自身；而对于可变类型（list，dict），函数体中的运算有可能会更改传入的参数变量。

# 引用传参
def add(a,b=33):
    a *= 2
    b = b * 2

a = 1
b = 1
add(a,b)
print('a = ', a)
print('b = ', b)
a_list = [2,3]
b_list = [2,3]
add(a_list, b_list)
print('a_list = ', a_list)
print('b_list = ', b_list)

输出为：

a = 1
b = 2
args =  ()
kwargs =  {'k1': 3}
a =  1
b =  1
a_list =  [2, 3, 2, 3]
b_list =  [2, 3]

注意 a *= 2 和 a = a*2 的不同，对于可变类型，a = a*2 会重新分配一个变量 a，而之前的 a 是不会变的。

匿名函数

用 lambda 关键词能创建小型匿名函数。这种函数得名于省略了用 def 声明函数的标准步骤。

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

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

• lambda 函数能接收任何数量的参数但只能返回一个表达式的值。
• 匿名函数不能直接调用 print，因为 lambda 需要一个表达式

>>> sum = lambda a,b : a+b
>>> sum(1,2)
3

应用场合

>>> stus
[{'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}]

# 对 dict 按 age 排序
>>> stus.sort(key = lambda x : x['age'])
>>> stus
[{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}]

---

Python 异常处理

import time
try:
    f = open('test.txt', 'r')
    try:
        while True:
            content = f.readline()
            if(len(content) == 0):
                break
            time.sleep(2)
            print(content)
    except:
        print('发生异常')
    finally:
        f.close()
        print('关闭文件')
except (IOError,NameError) as e:
    print(e)

• 当捕获多个异常时，可以把要捕获的异常的名字，放到 except 后，并使用元组的方式仅进行存储
• 在 try...except... 中也是如此，即如果没有捕获到异常，那么就执行else中的事情
• 在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用 finally。

异常传递

• 如果 try 嵌套，那么如果里面的 try 没有捕获到这个异常，那么外面的 try 会接收到这个异常，然后进行处理，如果外边的 try 依然没有捕获到，那么再进行传递。
• 如果一个异常是在一个函数中产生的，例如函数 A ---->函数 B ---->函数 C，而异常是在函数 C 中产生的，那么如果函数 C 中没有对这个异常进行处理，那么这个异常会传递到函数 B 中，如果函数 B 有异常处理那么就会按照函数 B 的处理方式进行执行；如果函数 B 也没有异常处理，那么这个异常会继续传递，以此类推。如果所有的函数都没有处理，那么此时就会进行异常的默认处理，即通常见到的那样。

# coding=utf-8

# 循环的传递

def test1():
    print("---test1-1---")
    print(num)
    print("---test1-2---")

    
def test2():
    print("---test2-1---")
    test1()
    print("---test2-2---")

def test3():
    try:
        print("---test3-1---")
        test1()
        print("---test3-2---")
    except Exception as e:
        print("出现异常： %s" %e)

    print("---test3-3---")

test3()
print("------华丽的分割线-----")
test2()

运行结果：

• 注意观察执行结果图中，当调用 test3 函数时，在 test1 函数内部产生了异常，此异常被传递到 test3 函数中完成了异常处理，而当异常处理完后，并没有返回到函数 test1 中进行执行，而是在函数 test3 中继续执行

---

模块

模块导入

模块就好比是工具包，要想使用这个工具包中的工具（就好比函数），就需要导入这个模块。

import

在 Python 中用关键字 import 来引入某个模块，形如：

import module1,mudule2...

• 通过这种方式引入的时候，调用函数时只能给出函数名，不能给出模块名，但是当两个模块中含有相同名称函数的时候，后面一次引入会覆盖前一次引入。也就是说假如模块 A 中有函数 function()，在模块 B 中也有函数 function()，如果引入 A 中的 function 在先、B 中的 function 在后，那么当调用 function 函数的时候，是去执行模块 B 中的 function 函数。

• 如果想一次性引入 math 中所有的东西，还可以通过 from math import * 来实现

from…import

有时候我们只需要用到模块中的某个函数，只需要引入该函数即可，此时可以用下面方法实现：

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

as

通过 as 可以赋予引入的包一个别名：

>>> import math as m
>>> m.sqrt(4)
2.0

模块引用顺序

当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

1. 当前目录
2. 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3. 如果都找不到，Python 会察看默认路径。UNIX 下，默认路径一般为 /usr/local/lib/python/
4. 模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH 和由安装过程决定的默认目录。

模块制作

自定义模块模块

在 Python 中，每个 Python 文件都可以作为一个模块，模块的名字就是文件的名字。

比如有这样一个文件 test.py，在 test.py 中定义了函数 add：

# coding=utf-8

def add(a, b):
    return a+b

调用自定义模块

那么在其他文件中就可以先 import test，然后通过 test.add(a,b) 来调用了，当然也可以通过 from test import add 来引入。

>>> import test
>>> test.add(2,3)
5

测试模块

在实际开中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在 py 文件中添加一些测试信息，例如：

# coding=utf-8

def add(a, b):
    return a+b

result = add(2, 3)
print('int test.py file, 2+3 = %d'%result)

test.py 中的测试代码，应该是单独执行 test.py 文件时才应该执行的，不应该是其他的文件中引用而执行。

可以根据 __name__ 变量的结果能够判断出，是直接执行的 python 脚本还是被引入执行的，从而能够有选择性的执行测试代码。

# coding=utf-8

def add(a, b):
    return a+b

print(__name__)

if __name__ == "__main__":
    result = add(2, 3)
    print('int test.py file, 2+3 = %d'%result)

__all__ 变量

python 模块中的 __all__ 属性，可用于模块导入时限制，如：from module import *。

此时被导入模块若定义了 __all__ 属性，则只有 __all__ 内指定的属性、方法、类可被导入。若没定义，则导入模块内的所有公有属性，方法和类。

因此，使用 __all__ 可以隐藏不想被 import 的默认值。

# coding=utf-8

__all__ = ["Test", "test1"]

class Test(object):
    def test(self):
        print('This is test.')

def test1():
        print('This is test1.')

def test2():
    print("This is test2.")

测试结果：

>>> from test import *
>>> test1()
This is test1.

>>> t = Test()
>>> t.test()
This is test.

# __all__ 变量中没有 test2 函数，因此无法通过 import * 引入
>>> test2()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'test2' is not defined

>>> from test import test2
>>> test2()
This is test2.

模块发布

1. mymodule 目录如下：

.
├── setup.py
├── suba
│   ├── aa.py
│   ├── bb.py
│   └── __init__.py
└── subb
    ├── cc.py
    ├── dd.py
    └── __init__.py

2 directories, 7 files

1. 编辑 setup.py 文件：

py_modules 需指明所需包含的 py 文件。

from distutils.core import setup

setup(name="liuhao", version="1.0", 
    description="liuhao's module", author="liuhao", 
    py_modules=['suba.aa', 'suba.bb', 'subb.cc', 'subb.dd'])

1. 构建模块

python setup.py build1

构建后的目录结构：

.
├── build
│   └── lib
│       ├── suba
│       │   ├── aa.py
│       │   ├── bb.py
│       │   └── __init__.py
│       └── subb
│           ├── cc.py
│           ├── dd.py
│           └── __init__.py
├── setup.py
├── suba
│   ├── aa.py
│   ├── bb.py
│   └── __init__.py
└── subb
    ├── cc.py
    ├── dd.py
    └── __init__.py

6 directories, 13 files

1. 生成发布包

python setup.py sdist

打包后，生成最终发布压缩包 liuhao-1.0.tar.gz，目录结构：

.
├── build
│   └── lib
│       ├── suba
│       │   ├── aa.py
│       │   ├── bb.py
│       │   └── __init__.py
│       └── subb
│           ├── cc.py
│           ├── dd.py
│           └── __init__.py
├── dist
│   └── liuhao-1.0.tar.gz
├── MANIFEST
├── setup.py
├── suba
│   ├── aa.py
│   ├── bb.py
│   └── __init__.py
└── subb
    ├── cc.py
    ├── dd.py
    └── __init__.py

7 directories, 15 files

模块安装和使用

1. 找到模块的压缩包
2. 解压
3. 进入文件夹
4. 执行命令 python setup.py install

如果在 install 的时候，执行目录安装，可以使用 python setup.py install --prefix=安装路径

在程序中，使用 from import 即可完成对安装的模块使用

from 模块名 import 模块名或者*

---

列表推导式

1. 基本方式

>>> [x for x in range(3)]
[0, 1, 2]
>>> [x for x in range(3,8)]
[3, 4, 5, 6, 7]
>>> [x for x in range(3,8,2)]
[3, 5, 7]

1. 结合 if

>>> [x for x in range(3,10) if x%2 == 0]
[4, 6, 8]
>>> [x for x in range(3,10) if x%3 == 0]
[3, 6, 9]

1. 多个 for 循环

>>> [(x,y) for x in range(3) for y in range(4) if x%2 ==0 if y%3 == 0]
[(0, 0), (0, 3), (2, 0), (2, 3)]