《Python 3》--三引号、math模块、cmath模块、日期和时间、转义字符、字符串运算符、字符串格式化、函数、全局变量和局部变量、匿名函数（lambda））
■Python三引号（triple quotes）
python中三引号可以将复杂的字符串进行复制:
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
var = '''hello
world'''
print var
运行结果:
hello
world
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，
自始至终保持一小块字符串的格式是所谓的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)
''')
■Python math 模块、cmath 模块
Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。
Python math 模块提供了许多对浮点数的数学运算函数。
Python cmath 模块包含了一些用于复数运算的函数。
cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。
要使用 math 或 cmath 函数必须先导入：
import math
import cmath
#ceil(x) 返回数字的上入整数，如math.ceil(1.5) 返回 2
import math
print math.ceil(1.5)
#floor(x) 返回数字的下舍整数，如math.floor(1.5)返回 1
print math.floor(1.5)
import math
print math.pi
■Python 日期和时间
Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。
Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:
■时间类
import time
print time.time()
print time.localtime()
print time.localtime()[0]
print time.localtime()[1]
print time.localtime()[2]运行结果:
1534329188.39
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=15, tm_hour=18, tm_min=33, tm_sec=8, tm_wday=2, tm_yday=227, tm_isdst=0)
2018
8
15
python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身例：格式化时间
import time
# 格式化成2016-03-20 11:45:39形式
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
输出结果:
2018-09-09 15:20:16
■日期类
import calendar
month = calendar.month(2018,8)
print month
运行结果:
August 2018
Mo Tu We Th Fr Sa Su
1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31
例：字符<-->日期
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time
import datetime
#时间转字符串
str=time.strftime("%Y-%m-%d", time.localtime())
print str
#字符串转时间,返回类型是元组
t = time.strptime("2019 - 03 - 19", "%Y - %m - %d")
#获得的是时间元组
print t
#获得元组的年 月 日
print t[0]
print t[1]
y,m,d = t[0:3]
#转datetime类型
#ymd=datetime.datetime(2018,11,12)
ymd=datetime.datetime(y,m,d)
print ymd
■Python转义字符
转义字符 描述
\(在行尾时) 续行符
\\ 反斜杠符号
\' 单引号
\" 双引号
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出
■Python字符串运算符
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
操作符 描述 实例
+ 字符串连接 >>>a + b 输出:'HelloPython'
* 重复输出字符串 >>>a * 2 输出:'HelloHello'
[] 通过索引获取字符串中字符 >>>a[1] 输出:'e'
[ : ] 截取字符串中的一部分 >>>a[1:4] 输出:'ell'
in 成员运算符 - 如果字符串中包含给定的字符返回 True >>>"H" in a 输出:True
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True >>>"M" not in a 输出:True
r/R 原始字符串：所有的字符串都是直接按照 >>> print r'\n' \n
字面的意思来使用，没有转义特殊或不能打印的字符。 >>> print R'\n' \n
原始字符串除在字符串的第一个引号前加上字母"r"
（可以大小写）以外，与普通字符串有着几乎完全相同的语法
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = "Hello"
b = "Python"
print "a + b 输出结果：", a + b
print "a * 2 输出结果：", a * 2
print "a[1] 输出结果：", a[1]
print "a[1:4] 输出结果：", a[1:4]
if( "H" in a) :
print "H 在变量 a 中"
else :
print "H 不在变量 a 中"
if( "M" not in a) :
print "M 不在变量 a 中"
else :
print "M 在变量 a 中"
print r'\n'
print R'\n'
以上程序执行结果为：
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n
#将两个变量值交换
a = 100
b = 200
print '分别输出两个变量的值__________'
print a
print b
# print '传统方法实现两数交换__________'
# c=a
# a=b
# b=c
# print a
# print b
# print '元组方法实现两数交换__________'
# a,b = (b,a)
# print a
# print b
print '省略元组小括号两数交换__________'
a,b = b,a
print a
print b■Python 字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，
但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
■python字符串格式化符号:
符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址
格式化操作符辅助指令:
符号 功能
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
<sp> 在正数前面显示空格
# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0 显示的数字前面填充'0'而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
实例1：
#!/usr/bin/python
print "My name is %s and weight is %d kg!" % ('Zara', 21)
以上实例输出结果：
My name is Zara and weight is 21 kg!实例2：
name = 'xiaoming'
position = '讲师'
address = '北京市昌平区建材城西路金燕龙办公楼1层'
print('--------------------------------------------------')
print("姓名：%s"%name)
print("职位：%s"%position)
print("公司地址：%s"%address)
实例3：
userName = raw_input('请输入用户名:')
print("用户名为：%s"%userName)
password = raw_input('请输入密码:')
print("密码为：%s"%password)
实例4：
字符串格式化操作
<1>格式化操作的目的
比如有以下代码:
pirnt("我今年10岁")
pirnt("我今年11岁")
pirnt("我今年12岁")
...
想一想:
在输出年龄的时候，用了多次"我今年xx岁"，能否简化一下程序呢？？？怎样用一个print来循环完成呢？
答:
字符串格式化
<2>什么是格式化
看如下代码:
age = 10
print("我今年%d岁"%age)
age += 1
print("我今年%d岁"%age)
age += 1
print("我今年%d岁"%age)
...
在程序中，看到了%这样的操作符，这就是Python中格式化时用运算符
修改以上的程序，如下：
age = 10
while i<=13:
print("我今年%d岁"%age)
age += 1
实例5：%d 格式化整数
i = 0
while i<5:
print "当前是第%d次执行循环"%(i+1)
print "i=%d"%i
i+=1
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
◆format()
这一种格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次
替换字符串内的占位符{0}、{1}……，
不过这种方式写起来比%要麻烦得多：
实例6：:九九乘法表
for i in range(1, 10):
for j in range(1, i + 1):
print'{}x{}={}\t'.format(i, j, i * j),
print
1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
4x1=4 4x2=8 4x3=12 4x4=16
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
■ Python 函数
如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，
所以把具有独立功能的代码块组织为一个小模块，这就是函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
1.函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
2.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4.函数内容以冒号起始，并且缩进。
5.return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]实例 :以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。
# 自定义函数
def printme(str):
print str
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");
#可写函数说明
def printme( str ):
#"打印任何传入的字符串"
print str;
return;
#调用printme函数
printme( str = "My string");
#定义一个函数
def hello():
'''打印函数信息'''
print ("hello")
def hello2(message):
print("hello"+message)
#调用函数
hello()
hello2("张三")
#有返回值的方法调用:
def hello2(n1,n2):
sum = n1 + n2
return sum
#调用函数
result = hello2(1,3)
print result
#函数调用 例子:
#打印一条横线
def printOneLine():
print("-"*30)
# 打印多条横线
def printNumLine(num):
i=0
# 因为printOneLine函数已经完成了打印横线的功能，
# 只需要多次调用此函数即可
while i<num:
printOneLine()
i+=1
printOneLine()
#printNumLine(3)
■ 嵌套函数调用， 断点调试
# 求3个数的和
def sum3Number(a,b,c):
return a+b+c # return 的后面可以是数值，也可是一个表达式
# 完成对3个数求平均值
def average3Number(a,b,c):
# 因为sum3Number函数已经完成了3个数的就和，所以只需调用即可
# 即把接收到的3个数，当做实参传递即可
sumResult = sum3Number(a,b,c)
aveResult = sumResult/3.0
return aveResult
# 调用函数，完成对3个数求平均值
result = average3Number(11,2,55)
print("average is %d"%result)
■参数传递
在 python 中，类型属于对象，变量是没有类型的：
a=[1,2,3]
a="Hello"
以上代码中，[1,2,3] 是 List 类型，
"Hello" 是 String 类型，
而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），
可以是 List 类型对象，也可以指向 String 类型对象。
■在python 中，string, tuples, numbers 是不可更改的对象，
而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，
再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，
本身la没有动，只是其内部的一部分值被修改了。
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，
我们应该说传不可变对象和传可变对象。
■python 传不可变对象实例:
def ChangeInt(a):
a = 10
b = 2
ChangeInt(b)
print b # 结果是 2解析:
实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，
按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，
在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它,原a=2，因为不在指向而丢弃
■传可变对象实例
def changeme( mylist ):
#"修改传入的列表"
mylist.append([1,2,3,4]);
print "函数内取值: ", mylist
return
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print "函数外取值: ", mylist解析:
实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]
■下例能将关键字参数顺序不重要，展示得更清楚
def printinfo( name, age ):
"打印任何传入的字符串"
print "Name: ", name;
print "Age ", age;
return;
#调用printinfo函数
printinfo( age=50, name="miki" );■缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。
def printinfo(name, age=35):
"打印任何传入的字符串"
print "Name: ", name;
print "Age ", age;
return;
# 调用printinfo函数
printinfo(age=50, name="miki"); #如果age没有被传入
printinfo(name="miki1"); #打印默认的age
■全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2; # total在这里是局部变量.
print "函数内是局部变量 : ", total
return total;
#调用sum函数
sum( 10, 20 );
print "函数外是全局变量 : ", total
以上实例输出结果：
函数内是局部变量 : 30
函数外是全局变量 : 0
■局部变量不能给全局变量赋值
var_1 = 5
def fun():
var_1=10
print "局部变量",var_1
fun()
print "全局变量", var_1
■如果在函数中修改全局变量，那么就需要使用global进行声明
global关键字，告诉python解释器这是一个全局变量
var_1 = 5
def fun():
global var_1
var_1=10
print "局部变量",var_1
fun()
print "全局变量", var_1
全局变量定义位置：
def fun():
global var_1
var_1=10
print "局部变量",var_1
#var_1 = 5 在调用函数之前定义
fun()
var_1 = 5 #在调用函数之后定义
print "全局变量", var_1■函数传列表:
def display(list):
for i in list:
print i
list1 = [1,2,3]
display(list1)运行结果:
1
2
3
■列表改变:
arrays =[3,5]
def swap(args):
arrays[0],arrays[1]=arrays[1],arrays[0]
print(arrays)
swap(arrays)
print(arrays)
■匿名函数
用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
sum = lambda arg1, arg2: arg1 + arg2
#调用sum函数
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )以上实例输出结果：
Value of total : 30
Value of total : 40
#lambda并不是python独有的，它相当于不去调用方法，而是一次性执行表达式
# lambda替换调用函数
result = lambda n1,n2:n1+n2
print result(2,3)Lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数不能直接调用print，因为lambda需要一个表达式
#!/usr/bin/python
# -*- coding: UTF-8 -*-r
def test(a,b,fun):
result=fun(a,b)
return result
ret=test(1,5,lambda x,y:x+y)
print ret