python基础

PYTHON

//感谢 自强学堂//link
以下内容搬家自 自强学堂 ，边学边敲的感觉有助于自己的记忆吧。。。再次感谢！

---

---

---

基本语法

1. 区分大小写
2. 等待用户输入raw_input("\n\nPress the key to exit.") "\n\n"在结果输出前会输出两个新的空行。一旦用户按下键，程序退出。
3. 多个语句构成代码组。缩进相同的一组语句构成一个代码块，我们称之为代码组。（clause）

if expression:
	suite
elif expression:
	suite
else :
	suite

变量类型

1.允许同时给多个变量赋值a=b=c=d=1创建一个整形对象，值为1，三个变量被分配到相同的内存空间中
为多个对象指定多个变量，例如：a,b,c=1,2,"john"

标准数据类型

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

Python 数字

不可改变的数字类型，改变数字数据类型会分配一个新的对象

操作	代码
创建：	var = 2
删除del：	del var1[,var2[,var3[....,varN]]]] del vardel del var_a,var_b

python支持的四种数字类型

• int（有符号整型）
• long （长整型【也可以代表八进制和十六进制】）
• complex（复数）

int	long	float	complex
10	51924361L	0.0	2+1.14j

python字符串

2种取值顺序

• 从左到右索引默认0开始，最大范围字符串长度少1
• 从右到左索引默认==-1==开始，最大范围时字符串开头

str="hello world"
print str[-4:-1]
print str[-1]
print str[-4:-1]+str[-1]

python列表

列表可以完成大多数集合类的数据结构的实现。支持字符，数字，字符串，甚至可以包含列表（嵌套）
列表用[ ]标识
列表中的值的分割也可以用 [头下标：尾下标] 截取相应列表（同字符串）

List = ["abcd", 789 , 2.23 , "john" ,70.2 ]
tinylist = [123, "john"]
print list #输出完整列表
print list[0] #输出列表的第一个元素
print list[1:3] #输出第二至第三个元素
print list[2:0] #输出第三个开始到结束的所有元素
print tinylist *2 #输出列表两次
print list+tinylist #打印组合列表

#输出结果
['abcd', 789, 2.23, 'john', 70.2]
abcd
[789, 2.23]
[]
[123, 'john', 123, 'john']
['abcd', 789, 2.23, 'john', 70.2, 123, 'john']

python元组

元组用“（）”标识。内部元素用逗号隔开。元素不能二次赋值，相当于只读列表。

tuple = ("abcd",786,2.23,"john",70.2)
tinytuple = (123,"john")
print tuple #输出完整元组
print tuple[0] #输出列表第一个元素
print tuple[1:3] #输出第二至第三个元素
print tuple[2:] #输出元组第三个开始至列表末尾所有元素
print tinytuple*2 #输出元组两次
print tuple+tinytuple #打印组合元组

#输出结果
("abcd", 786, 2.23, "john", 70.2)
abcd
(786, 2.23)
(2.23, "john", 70.2)
(123, "john", 123, "john")
("abcd", 786, 2.23, "john", 70.2, 123, "john")

元组不允许更新，列表可以更新

tuple = ( "abcd", 786 , 2.23, "john", 70.2 )
list = [ "abcd", 786 , 2.23, "john", 70.2 ]
tuple[2] = 1000 # 错误!元组中是非法应用
list[2] = 1000 # 正确！列表中是合法应用

python字典

dictionary是python之中最灵活的的内置数据结构类型。
列表是有序的，字典是无序的。字典当中的元素是通过键来存取的而不是通过偏移存取
字典用==“{ }”标识由索引键（key）和它对应的值value==组成

dict = {}
dict["one"] = "this is one"
dict[2]="this is two"
tinydict= {"name":"john","code":1234,"dept":"student"}

print dict["one"] #输出键为“one”的值
print dict[2] #输出键为2 的值
print tinydict #输出完整的字典
print tinydict.keys() #输出字典所有键
print tinydict.values() #输出字典所有值

#输出结果
this is one
this is two
{'dept': 'student', 'code': 1234, 'name': 'john'}
['dept', 'code', 'name']
['student', 1234, 'john']

python数据类型转换

函数	描述
int(x[,base])	将x转换为一个整数
long(x[,base])	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real[,imag])	创建一个复数
str(x)	将对象x转换为字符串
repr(x)	将对象x转换为表达式字符串
eval(str)	用来计算在字符串中的有效python表达式，并返回一个对象
tuple(s)	将序列s转换为一个元组
list(s)	将序列s转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d必须是一个序列(key，value)元组
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符串
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为他的整数值
hex(x)	将一个整数转换为十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

算数运算符

假设a=10,b=2

运算符	描述	实例
**	幂 返回x的y次幂	a**b输出结果为100
//	取整除-返回商的整数部分	9//2输出结果为4，9.0//2.0输出结果为4.0

/ 与 // 的区别

>>> print 9.0 / 2.0
4.5   #输出结果
>>> print 9.0 // 2.0
4.0   #输出结果

比较运算符

1表示真，0表示假
假设a=10，b=20

运算符	描述	实例
<>	不等于-比较两个对象是否不相等	（a<>b)返回true。 类似 !=

赋值运算符

运算符	=、+=、-=、*=、/=、%=、**=、//=

位运算符

把数字看作二进制来进行按位计算

运算符	描述
&	按位与
	按位或
~	按位取反
^	异或
<<	左移
>>	右移

逻辑运算符

运算符	描述
and	布尔“与”
or	布尔“或”
not	布尔“非”

成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回true，否则返回false	如果x在y序列中，返回true
not in	如果在指定序列没找到值返回true，否则返回false	如果x不在序列y中返回true

a=10
b=20
list=[1,2,3,4,5]
if (a in list):
	print "line-1-a is available in the given list"
else:
	print "line-1-a is not available in the given list"
if (b not in list):
	print "line-2-b is not available in the given list"
else:
	print "line-2-b is available in the given list"
a=2
if(a in list):
	print "line-3-a is available in the given list"
else:
	print "line-3-a is not available in the given list"

输出结果：

line-1-a is not available in the given list
line-2-b is not available in the given list
line-3-a is available in the given list

身份运算符

运算符	描述
is	is是判断两个标识符是不是引用自一个对象
is not	is not 判断两个标识符是不是引自不同对象

a=20
b=20
if(a is b):
	print "line1 - a and b hanve same identity"
else:
	print "line 1 - a and b do not have same identity"

if(id(a) == id(b)):
	print "line 2 - -a and b have same identity"
else:
	print "line 2 -a and b do not have same identity"

b=30
if(a is b ):
	print "line 3 - a and b have same identity"
else:
	print "line 3 - a and b do not have same identity"
if(a is not b):
	print "line 4 - a and b do not have same identity"
else:
	print "line 4 - a and b have same identity"

运行结果：

line1 - a and b hanve same identity
line 2 - -a and b have same identity
line 3 - a and b do not have same identity
line 4 - a and b do not have same identity

条件语句

python程序语言指任何非0和非空（null）值为true，0或null为false
** if语句**

if 判断条件1：
	执行语句1……
elif 判断条件2：
	执行语句2……
elif 判断条件3：
	执行语句3……
else：
	执行语句4……

判断条件，需要多个条件同时判断时用 or 或者 and

循环语句

while循环

while

while 判断条件：
	执行语句……

continue用于跳过该次循环
break 用于退出循环

while…else

正常执行完while语句后执行else
如果非正常执行完，即通过break退出或return退出循环，则不执行else

for循环

语法

for iterating_var in sequence:
	statements(s)

examples:

for letter in 'python':
	print 'current letter:',letter
fruits=['banana','apple','mango']
for fruit in fruits:
	print 'current fruit:',fruit
print "the end. good bye!"

运行结果：

current letter: p
current letter: y
current letter: t
current letter: h
current letter: o
current letter: n
current fruit: banana
current fruit: apple
current fruit: mango
the end. good bye!

通过索引执行循环遍历

fruits = ['banana','apple','mango']
for index in range(len(fruits)):
	print 'current fruit:',fruits[index]

print 'good bye!'

len()返回列表的长度，即元素的个数。range返回一个序列的数
输出结果：

current fruit: banana
current fruit: apple
current fruit: mango
good bye!

for …else
(同while…else)for中的语句和普通的没有区别，else中的语句会在循环正常执行完（即for不是通过break跳出而中断的）的情况下执行。

嵌套循环

for循环嵌套

for iterating_var in sequence:
	for iterating_var in sequence:
		statements(s)
	statements(s)

while循环嵌套

while expression:
	while expression:
		statement(s)
	statements(s)

while循环和for循环可以互相嵌套
实例：
1.从第一个列表每次取出一个，从第二个列表每次也取出一个，组合成一个新的列表，新列表包含表中所有组合

list1 = ['zi','zhang','san','wang']
list2 = [1,2]

new_list = []
for m in list1:
	for n in list2:
		new_list.append([m,n])
print new_list

运行结果：

[['zi', 1], ['zi', 2], ['zhang', 1], ['zhang', 2], ['san', 1], ['san', 2], ['wang', 1], ['wang', 2]]

2.从一个列表中每次取出两个，找出所有组合方式

list1 = [1,2,3,4,5]
length = len(list1)

for m in range(0,length-1):
	for n in range(m+1,length):
		print list1[m], list1[n]

运行结果：

1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5

3.使用嵌套循环输出2~20之间的素数。
对于一个数n，如果从1到 n**0.5 的数都不能整除，那么这个数是素数
for…else

for i in range(2,20):
	for j in range(2,i):
		if i%j==0:
			break
	else:
		print i,'sushu'

输出结果：

2 sushu
3 sushu
5 sushu
7 sushu
11 sushu
13 sushu
17 sushu
19 sushui

while

i=2
while (i<=20) :
	j=1
	while (j<i-1):
		j=j+1
		if (i%j == 0):
			break
	else:
		print i,'sushu'
	i=i+1

输出同上

注意 range() 函数的用法
range(start , stop[,step]) # [] 内可以省略，默认步长是1
参数说明

• start：计数从start开始。默认从0开始。如，range(5)等价于range(0,5)
• stop：计数到stop结束，但不包括stop。如，range(0,5)是[1,2,3,4]
• step：步长，默认为1。如，range(0,5)等价与range(0,5,1)

break 和 continue 语句

continue 语句跳出本次循环，跳过当前循环的剩余语句，然后继续进行下一轮循环。
break跳出整个循环

pass语句

pass是空语句，为了保持结构完整性

for letter in 'python':
	if letter == 'h':
		pass
		print 'this is pass block'
	print 'current letter:',letter
print 'end'

输出结果：

Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n
Good bye!

python数字

数据类型用于存储数值，数据类型不允许改变，如果改变数字数据类型的值，将重新分配内存空间

数学函数

函数	返回值
abs(x)	返回数字绝对值
ceil(x)	返回数字的上入整数，如math.ceil(4.1)返回5 ，小数点后全入了
cmp(x,y)	x<y返回-1、x==y返回0、x>y返回1
exp(x)	返回e的x次幂
fabs(x)	返回数字的绝对值，float
floor(x)	返回数字的下舍整数
log(x,y)	返回以y为底x的对数，如math.log(100,10)=2.0
log10(x)	返回以10为底x的对数
max(x1,x2…)	返回给定参数的最大值，参数可以为序列
min(x1,x2…)	返回给定参数的最小值，参数可以为序列
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
pow(x,y)	x**y运算后的值
round(x[,n])	返回浮点数x的四舍五入值，如给出n，则代表舍入到小数点后的位数
sqrt(x)	返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

python随机数函数

import random
random.choice()

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内

pyhton字符串

python不支持单字符类型，单字符也是作为一个字符串使用

字符串更新

对已经存在的字符串进行修改

var1 = 'hello world!'
print "updated string :-",var1[:6]+'python'

输出结果：updated string ：-hello python

转义字符

转义字符	描述
(在行尾时)	续行符
\	反斜杠符号
’	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数yy代表的字符，例如：\o12代表换行
\xyy	十进制数yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

字符串格式化

最基本的用法是将一个值插入到一个有字符串格式符%s的字符串中

print "my name is %s and weight is %d kg~"%('zara',21)

输出结果：
my name is zara and weight 21 kg~
字符串格式化符号

符号	描述
%c	格式化字符及其ascii码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%p	用十六进制数格式化变量的地址

辅助符号

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
	在正数前面显示空格
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格
%	‘%%‘输出一个单一的’%’
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

三引号

所见即所得，自始至终保持一小块字符串的格式

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

unicode字符串

引号前用小写的u表示这里创建的是一个unicode的字符串。
u'hello world!

字符串内建函数

方法	描述
string.capitalize()	把字符串的第一个字符大写
string.center(width)	返回一个原字符串剧中，并使用空格填充至长度width的新字符串
string.count(str,beg=0,end=len(string)	返回str在string里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数
string.decode(encoding=‘UTF-8’,errors=‘strict’)	以encoding指定的编码格式解码string，如果出错默认报一个valueerror的异常，除非errors指定的是‘ignore或者’replace‘
string.encode(encoding=‘UTF-8’,errors=‘strict’)	以encoding指定的编码格式编码string，如果出错默认报valueerror异常，除非errors指定的是’ignore‘或者’replac‘
sring.endswith(obj,beg=0,end=len(string))	检查字符串是否以obj结束，如果beg或者end指定则检查指定范围内是否以obj结束，如果是返回true否则返回false
string.expandtabs(tabsize=8)	把字符串中的tab符号转为空格，默认的空格数tabsize是8
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isdecimal()	如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()	如果 string 只包含数字则返回 True 否则返回 False.
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()	如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()	如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()	如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq)	Merges (concatenates)以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width)	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()	转换 string 中所有大写字符为小写.
string.lstrip()	截掉 string 左边的空格
string.maketrans(intab, outtab])	maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.partition(str)	有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2, num=string.count(str1))	把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) )	类似于 find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string))	类似于 index()，不过是从右边开始.
string.rjust(width)	返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)	类似于 partition()函数,不过是从右边开始查找.
string.rstrip()	删除 string 字符串末尾的空格.
string.split(str="", num=string.count(str))	以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
string.splitlines(num=string.count(’\n’))	按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj])	在 string 上执行 lstrip()和 rstrip()
string.swapcase()	翻转 string 中的大小写
string.title()	返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
string.upper()	转换 string 中的小写字母为大写
string.zfill(width)	返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
string.isdecimal()	isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

python 列表list [ ]

序列中的每一个元素都分配一个数字-他的位置（索引），从0开始
list(seq) 将元组转换为列表

相关操作
1.list.append(obj) 列表末尾添加新的对象
2. list.count(obj) 统计某个元素在列表中出现的次数
3. list.extend(seq) 在列表末尾一次性最佳另一个序列中的多个值
4. list.index(obj) 从列表中找出某个值第一个匹配项的索引
5. list.insert(index,ogj)将对象插入列表
6. list.pop([index]) 移除列表中的一个元素（默认最后一个元素），并返回该元素的值
7. list.remove(obj) 移除列表中某个值的第一个匹配项
8. list.reverse() 反向列表中的元素
9. list.sort([func]) 对原列表进行排序

python元组（）

元组不可以修改

• 可以使用下标索引访问，从0开始
  任意无符号的对象，以逗号隔开，默认为元组
  x, y= 1,2
• tuple(seq) 将列表转换为元组

字典 dictionary { }

字典由 键 和 对应值 成对组成。字典也被称作关联数组或哈希表

• 访问字典里的值，键值放入 [ ] 内print "dict['name']:",dict['name']
• 删除 del dict['name']删除一个条目，dict.clear() 清空字典所有条目， del dict 删除字典
• str() 函数将值转换为适合人阅读的形式，以可打印的字符串表示 str(dict)

dict = {'name':'zara','age':24};
print 'equivalent string : %s' % str (dict)

结果：Equivalent String : {'Age': 7, 'Name': 'Zara'}

• type() 函数返回输入的变量类型，如果变量是字典就返回字典类型
• 键 必须不可变，可以用数、字符串、元组充当，不可以用列表充当

内置函数

1. radiansdict.clear() 删除字典内所有元素
2. radiansdict.copy()返回一个字典的浅复制
3. radiansdict.fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所值
4. radiansdict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值
5. radiansdict.has_key(key)如果键在字典dict里返回true，否则返回false
6. radiansdict.items()以列表返回可遍历的(键, 值) 元组数组
7. radiansdict.keys()以列表返回一个字典所有的键
8. radiansdict.setdefault(key, default=None)和get()类似, 但如果键不已经存在于字典中default
9. radiansdict.update(dict2)把字典dict2的键/值对更新到dict里
10. radiansdict.values()以列表返回字典中的所有值

python 日期和时间

时间
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

import time
print time.time()
print time.localtime(time.time())

输出：

1554108210.93
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=1, tm_hour=16, tm_min=45, tm_sec=40, tm_wday=0, tm_yday=91, tm_isdst=0)

年，月，日，小时，分钟，秒，星期0~6，天数，是否为夏令时的旗帜
格式化输出时间

>>> import time;print time.asctime(time.localtime(time.time()))
Mon Apr 01 16:53:58 2019

TIME内置函数

1. time.altzone
   返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
2. ** time.asctime([tupletime])**
   接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
3. time.clock( )
   用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。(在不同的系统上含义不同。在UNIX系统上，它返回的是"进程时间"，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确）
4. time.ctime([secs])
   作用相当于asctime(localtime(secs))，未给参数相当于asctime()

>>> import time;print time.ctime()
Mon Apr 01 19:02:55 2019

5. time.gmtime([secs])
   接收时间辍（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t (time.struct_time)。注：t.tm_isdst始终为0

>>> import time;print time.gmtime()
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=1, tm_hour=11, tm_min=5, tm_sec=59, tm_wday=0, tm_yday=91, tm_isdst=0) 

6. time.localtime([secs])
   接收时间辍（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
7. time.mktime(tupletime)
   接受时间元组并返回时间辍（1970纪元后经过的浮点秒数）。

>>> import time;t = (2009, 2, 17, 17, 3, 38, 1, 48, 0);print time.mktime(t)
1234861418.0

8. time.sleep(secs)
   推迟调用线程的运行，secs指秒数。
9. time.strftime(fmt[,tupletime])
   接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
   根据fmt的格式把一个时间字符串解析为时间元组。
   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;print time.strftime("%b %d %y",time.gmtime())
Apr 01 19

10. time.strptime(str[,fmt=’%a %b %d %H:%M:%S %Y’])

>>> import time;print time.strptime("30 Nov 00","%d %b %y")
time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

11. time.time( )
    返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
12. time.tzset()
    根据环境变量TZ重新初始化时间相关设置。

日历

>>> import calendar;print calendar.month(2019,1)
    January 2019
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

python 函数

所有参数在python里都是按引用传递

• 必备参数
• 命名参数 参数顺序不重要，解释器能够用参数名匹配参数值

def printinfo(name,age):
	"打印任何传入的字符串"
	print "name",name
	print "age",age
printinfo(age=33,name="miki")

输出：

name:miki
age 33

• 缺省参数
• 不定长参数

def functionname([formal_args,]*var_args_tuple)
	function_suite
	return [expression]

加了星号 （*）的变量名会存放所有未命名的变量参数。选择不多传参数也可以

def printinfo(arg1,*vartuple)
	print "output"
	print arg1
	for var in vartuple:
		print var
printinfo (10)
printinfo(20,30,22)

输出：

output
10
output
20
30
22

匿名函数

用lambda关键词能创建小型匿名函数。

• lanbda 函数能接收任何数量的参数但只能返回一个表达式的值，同时不能包含命令或多个表达式
• 匿名函数不能直接调用print，因为lambda需要一个表达式
• lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的函数
• 不同于c或c++的内敛函数

sum = lambda arg1,arg2:arg1+arg2

print sum(10,20)
print sum(20,20)

输出：
30
40

python 操作 mysql

python DB-API 使用流程

• 引入API模块
• 获取与数据库的链接
• 执行SQL语句和存储过程
• 关闭数据库链接

MySQLdb
MySQLdb时用于python链接mysql数据库的接口，它实现了python数据库API规范V2.0，基于MySQL C API 上建立的。