python中级中级阶段一
一. 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，
比如print()
定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
return 语句
return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None
。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：
函数调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
# 定义函数
def printme( str ): "打印任何传入的字符串" print str; return; # 调用函数 printme("我要调用用户自定义函数!"); printme("再次调用同一函数");
参数传递分为:
值传递:
string tuple number 是不可变
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个
int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：
#可写函数说明
def printinfo( name, age ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" );
#可写函数说明
def printme( str ): "打印任何传入的字符串" print str; return; #调用printme函数 printme( str = "My string");
默认参数
调用函数时 如果没有传递参数就是使用默认参数 如果传递了参数就不使用默认参数
def ChangeInt( a=1,b=2 ): c=a+b return c ChangeInt() print (c) # 3
def ChangeInt( a=1,b=2 ): c=a+b return c ChangeInt(12,10) print (c) # 22
要使用默认参数 最好将默认参数放到最后
def ChangeInt( a,b=2 ): c=a+b return c ChangeInt(12) print (c) # 14
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
#可写函数说明
def printinfo( name, age = 35 ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" ); printinfo( name="miki" ); 以上实例输出结果： Name: miki Age 50 Name: miki Age 35
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：# 可写函数说明
def printinfo( arg1, *vartuple ): "打印任何传入的参数" print "输出: " print arg1 for var in vartuple: print var return; # 调用printinfo 函数 printinfo( 10 ); printinfo( 70, 60, 50 );
# 可写函数说明
def printinfo( arg1, *vartuple ): "打印任何传入的参数" print "输出: " print arg1 for var in vartuple: print var return; # 调用printinfo 函数 printinfo( 10 ); printinfo( 70, 60, 50 );
加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：# 可写函数说明
def aa(name,*age):
print(name) #张三
for i in age:
print(i)#25 28 23 20
aa("张三",25,28,23,20)
**是代表键值对的传参方式 和*代表的意义一样
def aa(**name) print(name) #{"a":1,"b":2,"c":3S} print(type(name)) #{"class" dict} aa(a=1,b=2,c=3,d=4)
匿名函数
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，
后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2; # 调用sum函数 print "相加后的值为 : ", sum( 10, 20 ) print "相加后的值为 : ", sum( 20, 20 ) # 相加后的值为 : 30 # 相加后的值为 : 40
# 偏函数
import functools
# functools模块用于高阶函数：作用与或者返回其它函数的函数。
# 一般来说，对于该模块，任何可调用对象都可以视为一个函数。
def int2(str,base=2): return int(str,base) print(int2("11111"))
def int2(str,base=2): return int(str,base) print(int2("11111")) # 把一个参数固定住 形成一个新的函数 int3=functools.partial(int,base=2) print(int3("111")) # 进制的换算 # 31 # 7
变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
全局变量
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，
定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，
而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称
total = 0; # 这是一个全局变量 # 可写函数说明 def sum( arg1, arg2 ): #返回2个参数的和." total = arg1 + arg2; # total在这里是局部变量. print "函数内是局部变量 : ", total return total; #调用sum函数 sum( 10, 20 ); print "函数外是全局变量 : ", total # 把局部变量改成全局变量 name=111110000000000000000000 def AA(): global name # global 意思就是把局部变量改成全局变量 name=2220000 print(name) AA() print(name)
# 把局部变量改成全局变量
""" name=111110000000000000000000 def AA(): global name # global 将全局变量 变成局部变量 name=2220000 print(name) # 2220000 AA() print(name) # 2220000 """ """1、global---将变量定义为全局变量。可以通过定义为全局变量，实现在函数内部改变变量值。 2、一个global语句可以同时定义多个变量，如 global x, y, z""" # 注意： 如果函数的内容global 关键字 优先读取局部变量 只能读取全局变量 无法重新赋值 # #注意函数中有global 关键字 变量本质上就是全局的那个变量 可以赋值 a='张三' def aa(): global a print('您好',a) # 您好 张三 a='李四' print('lover',a) # lover 李四 def bb(): a=111111 print('这是',a) # 这是 111111 aa() bb()
二. 闭包装饰器
# 概念: 是一个闭包 把一个函数当做参数返回一个替代的函数 本质上就是一个返回函数的函数
# 简单的函数装饰器
def fun1(): print("哈哈哈哈哈哈name") def fun2(): print("啦啦啦啦啦啦啦") fun1() fun2()
# 概念: 是一个闭包 把一个函数当做参数返回一个替代的函数 本质上就是一个返回函数的函数
# 简单的函数装饰器
# def fun1(): # print("哈哈哈哈哈哈name") # def fun2(): # print("啦啦啦啦啦啦啦") # fun1() # fun2()
def fun1(): print("111111111111111111") def outer(func): def inner(): print("222222222222222222") func() return inner # f是函数func1的加强版本 f=outer(fun1) f() # 222222222222222222 # 111111111111111111
def fun1(): print("111111111111111111") def outer(func): def inner(): print("222222222222222222") func() return inner # f是函数func1的加强版本 f=outer(fun1) f() # 222222222222222222 # 111111111111111111
# 概念: 是一个闭包 把一个函数当做参数返回一个替代的函数 本质上就是一个返回函数的函数 # 简单的函数装饰器 def fun1(): print("哈哈哈哈哈哈name") def fun2(): print("啦啦啦啦啦啦啦") fun1() fun2() # def say(age): # print(age) # say(-10) #-10 # def outer(func): # def inner(age): # if age<0: # age=0 # func(age) # return inner # s=outer(say) # s(-10) #0 概念: 是一个闭包 把一个函数当做参数返回一个替代的函数 本质上就是一个返回函数的函数
一般装饰器
# 概念: 是一个闭包 把一个函数当做参数返回一个替代的函数 本质上就是一个返回函数的函数 # 简单的函数装饰器 # def fun1(): # print("哈哈哈哈哈哈name") # def fun2(): # print("啦啦啦啦啦啦啦") # fun1() # fun2() def outer(func): def inner(*args,**kwargs): #添加功能 print("***************") func(*args,**kwargs) return inner # @相当于say=outer(say) @outer def say(name,age): #函数参数最后不要超过7个 print(name ,age) say("张三",1000) # *************** # 张三 1000 # def say(name ,age): # 函数参数最后不要超过7个 print(name ,age) say("张三", 1000) def outer(func): def inner(*args ,**kwargs): # 添加功能 print("***************") func(*args ,**kwargs) return inner # @outer aa=outer(say) aa("扣扣",25) # 张三 1000 # *************** # 扣扣 25
# 概念: 是一个闭包 把一个函数当做参数返回一个替代的函数 本质上就是一个返回函数的函数 # 简单的函数装饰器 def fun1(): print("哈哈哈哈哈哈name") def fun2(): print("啦啦啦啦啦啦啦") fun1() fun2() # def say(age): # print(age) # say(-10) #-10 # def outer(func): # def inner(age): # if age<0: # age=0 # func(age) # return inner # s=outer(say) # s(-10) #0 概念: 是一个闭包 把一个函数当做参数返回一个替代的函数 本质上就是一个返回函数的函数 def outer(func): def inner(age): if age<0: age=0 func(age) return inner # @相当于say=outer(say) @outer def say(age): print(age) say(-10)
三. 异常处理
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生
格式:
try :
语句1
except 错误代码 as e:
语句2
except 错误代码 as e:
语句3
......
except 错误代码 as e:
语句n
else:
语句e
注意 else 可有可无
作用: 用来检测try 语句块的错误 从而让except语句捕获异常信息并处理
逻辑: 当程序执行到try ---except --else 语句时
1 如果try 语句1 执行出现错误 会匹配第一个错误码 如果匹配上就执行 语句
2 如果当try 语句1 执行出现错误 没有匹配的异常 错误将会 被提交到上一层的try 语句 或者到程序的最上一层
3 如果当try 语句1 执行没有出现错误 执行else 下的语句e
异常名称 描述
BaseException 所有异常的基类
SystemExit 解释器请求退出
KeyboardInterrupt 用户中断执行(通常是输入^C)
Exception 常规错误的基类
StopIteration 迭代器没有更多的值
GeneratorExit 生成器(generator)发生异常来通知退出
StandardError 所有的内建标准异常的基类
ArithmeticError 所有数值计算错误的基类
FloatingPointError 浮点计算错误
OverflowError 数值运算超出最大限制
ZeroDivisionError 除(或取模)零 (所有数据类型)
AssertionError 断言语句失败
AttributeError 对象没有这个属性
EOFError 没有内建输入,到达EOF 标记
EnvironmentError 操作系统错误的基类
IOError 输入/输出操作失败
OSError 操作系统错误
WindowsError 系统调用失败
ImportError 导入模块/对象失败
LookupError 无效数据查询的基类
IndexError 序列中没有此索引(index)
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于Python 解释器不是致命的)
NameError 未声明/初始化对象 (没有属性)
UnboundLocalError 访问未初始化的本地变量
ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError 一般的运行时错误
NotImplementedError 尚未实现的方法
SyntaxError Python 语法错误
IndentationError 缩进错误
TabError Tab 和空格混用
SystemError 一般的解释器系统错误
TypeError 对类型无效的操作
ValueError 传入无效的参数
UnicodeError Unicode 相关的错误
UnicodeDecodeError Unicode 解码时的错误
UnicodeEncodeError Unicode 编码时错误
UnicodeTranslateError Unicode 转换时错误
Warning 警告的基类
DeprecationWarning 关于被弃用的特征的警告
FutureWarning 关于构造将来语义会有改变的警告
OverflowWarning 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning 关于特性将会被废弃的警告
RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning 可疑的语法的警告
UserWarning 用户代码生成的警告
try: fh = open("testfile", "w") fh.write("这是一个测试文件，用于测试异常!!") except IOError: print "Error: 没有找到文件或读取文件失败" else: print "内容写入文件成功" fh.close() 以上程序输出结果： $ python test.py 内容写入文件成功 $ cat testfile # 查看写入的内容 这是一个测试文件，用于测试异常!!
try: print(3/1) except NameError as e: print("没有改变量") except ZeroDivisionError as e: print("除数为0") else: print("代码没有问题了") print(".....................................") # 使用except 而不使用 任何的错误类型 try: print(4/0) print(num) except: print("程序出现了异常") # 使用except带有多种异常 try: print(5/0) except(NameError,ZeroDivisionError)
格式: try : 语句1 except 错误代码 as e: 语句2 except 错误代码 as e: 语句3 ...... except 错误代码 as e: 语句n finally: 语句f 作用 :语句t无论是否有错误 都讲执行最后的语句 try: print(1/0) finally: print("必须执行我")
以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。
如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，
而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。
下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:
格式: try : 语句1 except 错误代码 as e: 语句2 except 错误代码 as e: 语句3 ...... except 错误代码 as e: 语句n finally: 语句f 作用 :语句t无论是否有错误 都讲执行最后的语句f try: print(1/0) finally: print("必须执行我")
四. 时间函数
协调世界时(英:Coordinated Universal Time ，法:Temps Universel Coordonné)，又称世界统一时间，世界标准时间，
国际协调时间。英文(CUT)和法文(TUC)的缩写不同，作为妥协，简称UTC。
在中国 来说是 UTC+8
DST
DST是Daylight Saving Time的缩写，称为阳光节约时，在我国称为夏时制，
又称夏令时，是一种为节约能源而人为调整地方时间的制度。
有些国家DST的使用时间较长，(如美国长达7个月)跨越了春夏秋等三个季节
时间表现的形势:
1 时间戳
以整型 或浮点型表示时间的一个以秒为单位的时间间隔
这个时间 时间间隔的基础值是1970年1月1号零点开始算起
2 元组
一种python 的数据结构表示 这个元组有9 个整型内容
year
month
day
hours
minutes
seconds
weekday
julia day
flag(1 或 -1 或0)
3 格式化字符串
%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; # 引入time模块 c=time.time() print(c) #1528132954.339143 # 将时间戳 转为utc时间元组 t=time.gmtime(c) print(t) #time.struct_time(tm_year=2018, tm_mon=6, tm_mday=4, tm_hour=17, tm_min=23, tm_sec=27, tm_wday=0, tm_yday=155, tm_isdst=0) # 将时间戳转为本地时间元组 b=time.localtime(c) #time.struct_time(tm_year=2018, tm_mon=6, tm_mday=5, tm_hour=1, tm_min=26, tm_sec=31, tm_wday=1, tm_yday=156, tm_isdst=0) print(b) # 将第时间元组 转成时间戳 m=time.mktime(b) print(m) #1528133464.0 # 将时间元组转换成字符串 s=time.asctime(b) print(s) #Tue Jun 5 01:33:34 2018 # 将时间戳转换为字符 p=time.ctime(c) print(p) # Tue Jun 5 01:35:49 2018 # 将时间元组转换成给定格式的字符串 如果没有参数2 默认转换为当前时间 q=time.strftime("%Y-%m-%d %H:%M:%S") print(q) #2018-06-05 01:40:38 # 将时间元组转换成给定格式的字符串 参数2为时间元组 如果没有参数2 默认转换为当前时间 h=time.strftime("%Y-%m-%d %H:%M:%S",b) print(h) #2018-06-05 01:42:48 l=time.strftime("%Y-%m-%d %X",b) print(l) #2018-06-05 01:46:40 print(type(l)) #<class 'str'> # 将时间字符串转换为时间元组 w=time.strptime(q,"%Y-%m-%d %X") print(w) #time.struct_time(tm_year=2018, tm_mon=6, tm_mday=5, tm_hour=1, tm_min=49, tm_sec=59, tm_wday=1, tm_yday=156, tm_isdst=-1) # 延迟一个时间 整型或者浮点型 # time.sleep(4) # 返回当前程序的cpu 执行时间 # Unix 系统同时返回全部时间 # windows从第二次开始 都是以第一个调用函数的开始时间戳作为基数 c1=time.clock() print(c1) #1.7104874547148446e-06
实例
import time time.clock() sum=0 for x in range(10000000): sum+=x print(time.clock()) #3.0864349222241354
# datetime 比time高级了不少 可以理解为datetime基于time进行封装
# 提供了各位使用的函数 date模块的接口更直观 更容易
# datetime 比time高级了不少 可以理解为datetime基于time进行封装 # 提供了各位使用的函数 date模块的接口更直观 更容易 # 模块中的类: # datetime 同时又时间日期 # timedelta 主要计算时间的跨度 # tzinfo 时区相关 # time 只关注时间 # date 只关注日期 import datetime # 引入time模块 # 获取当前时间 d1=datetime.datetime.now() print(d1) #2018-06-05 18:20:22.763177 print(type(d1)) # <class 'datetime.datetime'> # 获取指定的时间 d2=datetime.datetime(1999,10,1,10,28,25,123456) print(d2) #1999-10-01 10:28:25.123456 # 将时间转为字符串 d3=d1.strftime("%Y-%m-%d %X") print(d3) #18-06-05 18:26:02 2018-06-05 18:26:30 # 将格式字符串转为datetime对象 # 注意的格式要与字符串一致 d4=datetime.datetime.strptime(d3,"%Y-%m-%d %X") print(d4) #2018-06-05 18:28:44 # dtaetime 时间类型还可以加减 d5=datetime.datetime(1999,10,1,10,28,25,123456) d6=datetime.datetime.now() d7=d6-d5 print(d7) #6822 days, 8:03:35.068612 print(type(d7)) # <class 'datetime.timedelta'> # 能获取到间隔天数 print(d7.days) # 获取间隔天数以为的秒数 print(d7.seconds) #29133
# 日历模块
import calendar # 日历模块 # 使用 # 返回指定某年某月的日历 print(calendar.month(2017,7)) # July 2017 # 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 # 返回指定一年的日历 # print(calendar.calendar(2018)) # 2018 # January February March # Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su # 1 2 3 4 5 6 7 1 2 3 4 1 2 3 4 # 8 9 10 11 12 13 14 5 6 7 8 9 10 11 5 6 7 8 9 10 11 # 15 16 17 18 19 20 21 12 13 14 15 16 17 18 12 13 14 15 16 17 18 # 22 23 24 25 26 27 28 19 20 21 22 23 24 25 19 20 21 22 23 24 25 # 29 30 31 26 27 28 26 27 28 29 30 31 # April May June # Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su # 1 1 2 3 4 5 6 1 2 3 # 2 3 4 5 6 7 8 7 8 9 10 11 12 13 4 5 6 7 8 9 10 # 9 10 11 12 13 14 15 14 15 16 17 18 19 20 11 12 13 14 15 16 17 # 16 17 18 19 20 21 22 21 22 23 24 25 26 27 18 19 20 21 22 23 24 # 23 24 25 26 27 28 29 28 29 30 31 25 26 27 28 29 30 # 30 # July August September # Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su # 1 1 2 3 4 5 1 2 # 2 3 4 5 6 7 8 6 7 8 9 10 11 12 3 4 5 6 7 8 9 # 9 10 11 12 13 14 15 13 14 15 16 17 18 19 10 11 12 13 14 15 16 # 16 17 18 19 20 21 22 20 21 22 23 24 25 26 17 18 19 20 21 22 23 # 23 24 25 26 27 28 29 27 28 29 30 31 24 25 26 27 28 29 30 # 30 31 # October November December # Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su # 1 2 3 4 5 6 7 1 2 3 4 1 2 # 8 9 10 11 12 13 14 5 6 7 8 9 10 11 3 4 5 6 7 8 9 # 15 16 17 18 19 20 21 12 13 14 15 16 17 18 10 11 12 13 14 15 16 # 22 23 24 25 26 27 28 19 20 21 22 23 24 25 17 18 19 20 21 22 23 # 29 30 31 26 27 28 29 30 24 25 26 27 28 29 30 # 31 # 可以判断是否为闰年 这返回true 否则返回false print(calendar.isleap(2000)) #True # 返回某个月的weekday的第一天和这个月所有天数 print(calendar.monthrange(2017,7)) # (5, 31) 5表示某个月的weekday的第一天 31 表示是31天 # 返回某个月 以每一周为元素的列表 # print(calendar.monthcalender(2018,7))
