python基础教程

参考：Python基础教程

assert

1. 使用assert断言是学习python一个非常好的习惯，python assert 断言句语格式及用法很简单。在没完善一个程序之前，我们不知道程序在哪里会出错，与其让它在运行最崩溃，不如在出现错误条件时就崩溃，这时候就需要assert断言的帮助。

2. python assert断言是声明其布尔值必须为真的判定，如果发生异常就说明表达示为假。可以理解assert断言语句为raise-if-not，用来测试表示式，其返回值为假，就会触发异常。

3. 下面做一些assert用法的语句供参考：
   assert 1==1
   assert 2+2==2*2
   assert len([‘my boy’,12])<10
   assert range(4)==[0,1,2,3]

4. 如何为assert断言语句添加异常参数
   assert的异常参数，其实就是在断言表达式后添加字符串信息，用来解释断言并更好的知道是哪里出了问题。格式如下：
   assert expression [, arguments]
   assert 表达式 [, 参数]

python lambda

例子1. ： g = lambda x : x+1
看一下执行的结果：

    g(1)
    >>>2
    g(2)
    >>>3

可以这样理解lambda作为一个表达式，定义了一个匿名函数，上例的代码x为入口参数，x+1为函数体，相当于：

def g(x)
    return x + 1

• map(): 将序列中的元素通过处理函数处理后返回一个新的列表
• filter(): 将序列中的元素通过函数过滤后返回一个新的列表
• reduce()：将序列中的元素通过一个二元函数处理返回一个结果

将上面三个函数和lambda结合使用

    li = [1, 2, 3, 4, 5]
    # 序列中的每个元素加1
    map(lambda x: x+1, li) # [2,3,4,5,6]
     
    # 返回序列中的偶数
    filter(lambda x: x % 2 == 0, li) # [2, 4]
     
    # 返回所有元素相乘的结果
    reduce(lambda x, y: x * y, li) # 1*2*3*4*5 = 120

import

import语句作用就是用来导入模块的，它可以出现在程序中的任何位置。

import语句语法如下：

import module
关键字 模块名

from-import语句语法:

from module import name
关键字 模块名 关键字 方法名

import…as

import A as B,给予A库一个B的别称

import module 和 from module import，区别是前者所有导入的东西使用时需加上模块名的限定，而后者不需要。

python导入其他目录下的模块

参考网页

1. 主程序与模块程序在同一目录下:直接使用

2. 主程序所在目录是模块所在目录的父(或祖辈)目录

   `-- src
       |-- mod1.py
       |-- mod2
       |     |-- mod2.py
       |-- test1.py
   若在程序test1.py中导入模块mod2, 需要在mod2文件夹中建立空文件__init__.py文件(也可以在该文件中自定义输出模块接口); 然后使用from mod2.mod2 import * 或import mod2.mod2.
   

3. 主程序导入上层目录中模块或其他目录(平级)下的模块

   `-- src
   |-- mod1.py
   |-- mod2
   |     |-- mod2.py
   |-- sub
   |     |-- test2.py
   |-- test1.py
   若在程序test2.py中导入模块mod1和mod2。
   首先需要在mod2下建立__init__.py文件(同(2))，src下不必建立该文件。
   

变量作用域

Python是静态作用域语言，尽管它自身是一个动态语言。也就是说，在Python中变量的作用域是由它在源代码中的位置决定的，这与C有些相似，但是Python与C在作用域方面的差异还是非常明显的。

Python的作用域一共有4中，分别是：

    L （Local） 局部作用域
    E （Enclosing） 闭包函数外的函数中
    G （Global） 全局作用域
    B （Built-in） 内建作用域
    以 L --> E --> G -->B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

1. 一般在函数体外定义的变量成为全局变量，在函数内部定义的变量称为局部变量。
2. 函数内部可以使用global关键字定义全局变量。

变量类型

Python 中的变量赋值不需要类型声明。

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

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

1.数字类型

python支持4中数字类型：int ，bool, float, complex(复数)。

bool值使用True和False表示。

2.Python字符串

s = ‘ilovepython’ 或s = “ilovepython”

3. Python列表

list = [ ‘runoob’, 786 , 2.23, ‘john’, 70.2 ]

4. Python元组

元组不能二次赋值，相当于只读列表。
tuple = ( ‘runoob’, 786 , 2.23, ‘john’, 70.2 )

5. 字典

tinydict = {‘name’: ‘john’,’code’:6734, ‘dept’: ‘sales’}
dict[‘one’] = “This is one”

print

1. 输出字符串和数字类型

直接输出

print(1）
print("Hello world")

2.变量

无论什么类型的变量都可以直接输出例如：数值，布尔，列表，字典。。。

L = [1, 2, 'a']
print(L)
t = (1 ,2 ,'a')
print(t)

3.格式化输出类似于printf

1. %字符：标记转换说明符的开始
2. 转换标志：-表示左对齐；+表示在转换值之前要加上正负号；“”（空白字符）表示正数之前保留空格；0表示转换值若位数不够则用0填充.
3. 最小字段宽度：转换后的字符串至少应该具有该值指定的宽度。如果是*，则宽度会从值元组中读出。
4. 点(.)后跟精度值：如果转换的是实数，精度值就表示出现在小数点后的位数。如果转换的是字符串，那么该数字就表示最大字段宽度。如果是*，那么精度将从元组中读出

字符串格式化转换类型

转换类型          含义
d,i                 带符号的十进制整数
o                   不带符号的八进制
u                   不带符号的十进制
x                    不带符号的十六进制（小写）
X                   不带符号的十六进制（大写）
e                   科学计数法表示的浮点数（小写）
E                   科学计数法表示的浮点数（大写）
f,F                 十进制浮点数
g                   如果指数大于-4或者小于精度值则和e相同，其他情况和f相同
G                  如果指数大于-4或者小于精度值则和E相同，其他情况和F相同
C                  单字符（接受整数或者单字符字符串）
r                    字符串（使用repr转换任意python对象)
s                   字符串（使用str转换任意python对象）


>>> pi = 3.141592653  
>>> print('%10.3f' % pi) #字段宽10，精度3  
     3.142  
>>> print("pi = %.*f" % (3,pi)) #用*从后面的元组中读取字段宽度或精度  
pi = 3.142  
>>> print('%010.3f' % pi) #用0填充空白  
000003.142  
>>> print('%-10.3f' % pi) #左对齐  
3.142       
>>> print('%+f' % pi) #显示正负号  
+3.141593  

with

有一些任务，可能事先需要设置，事后做清理工作。对于这种场景，Python的with语句提供了一种非常方便的处理方式。

例如：

file = open("/tmp/foo.txt")
data = file.read()
file.close()

这里有两个问题:
一是可能忘记关闭文件句柄；
二是文件读取数据发生异常，没有进行任何处理，使用异常处理有比较冗长。

下面是with版本的代码：

with open("/tmp/foo.txt") as file:
    data = file.read()

紧跟with后面的语句被求值后，返回对象的 __enter__() 方法被调用，这个方法的返回值将被赋值给as后面的变量。 当with后面的代码块全部被执行完之后，将调用前面返回对象的 exit()方法。Python的with语句是提供一个有效的机制，让代码更简练，同时在异常产生时，清理工作更简单

异常处理

try….except…else的语法：

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

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

try:
<语句>
finally:
<语句>    #退出try时总会执行

例子：

try:
    1 / 0
except Exception as e:
    '''异常的父类，可以捕获所有的异常'''
    print "0不能被除"
else:
    '''保护不抛出异常的代码'''
    print "没有异常"
finally:
    print "最后总是要执行我"

操作符

1. ！在Python里面是非法的用not取代
2. Python的逻辑操作有三种：and、or、not。分别对应与、或、非。