#!/usr/bin/env python
# -*- coding=utf-8 -*-
goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998},
]
zongzichang=0
i1=input('请输入你的总资产:')
zongzichang=int(i1)
#输出商品列表，包括商品名和价格
for i1 in goods:
	print(i1['name'], i1['price'])
#{"电脑":{"num":1,"single_price":1999}}
car_dir={}
while True:
	i2=input('请输入购买的商品(输入q来退出购买):')
	if 'q' == i2:
		break
	for items in goods:
		if items['name'] == i2:
			name=items['name']
			if i2 in car_dir.keys():
				car_dir[name]['num']+=1
			else:
				car_dir[i2]={"num":1,'single_price':items['price']}
		else:
			pass
print(car_dir)
sum=0
for i3 in car_dir:
	price=car_dir[i3]['num']*car_dir[i3]['single_price']
	sum=sum+price
if sum <= zongzichang:
	print('购买成功')
else:
	print('账户余额不足，请充值')

#!/usr/bin/env python
# -*- coding=utf-8 -*-
a = [11,22,33,44,55,66,77,88,99,90]
b = {
    "key1":[],
    "key2":[],
}
for i in a:
    if i > 66:
        b["key1"].append(i)
    else:
        b["key2"].append(i)
print(b)

#!/usr/bin/env python
# -*- coding=utf-8 -*-
import getpass       #模块功能让用户输入的内容不可见
time=1
while True:
	user=input('请输入用户名:')
	password=getpass.getpass("请输入密码:") #隐藏用户输入的内容
	if user == 'Hello' and password == 'Python':
		print(user,password)
		break
	else:
		pass
	time+=1		
	if time >3:
		break

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#商品列表有4个，我设置了可以输入4次
li = ["手机", "电脑", '鼠标垫', '游艇']
time=1
for key,i in enumerate(li,1):
	print(key,i)
while True:	
	xuanze=int(input('请输入序号:'))
	print(li[xuanze-1])
	time+=1
	if time > 4:
		break

#!/usr/bin/env python
# -*- coding=utf-8 -*-
name={
	"li":["alec", " aric", "Alex", "Tony", "rain"],
	"tu":("alec", " aric", "Alex", "Tony", "rain"),
	"dic":{'k1': "alex", 'k2': ' aric',  "k3": "Alex", "k4": "Tony"},
}
new_dic={}
for i1 in name:
	if isinstance((name[i1]),list) or isinstance((name[i1]),tuple):
		for i2 in name[i1]:
			i3=i2.strip()
			if (i3.startswith("a") or i3.startswith("A")) and i3.endswith("c"):
				print(i3)
				if i3 in new_dic:
					new_dic[i3]+=1
				else:
					new_dic[i3]=1
	else:
		for i4 in name[i1].values():
			i5=i4.strip()
			if (i5.startswith("a") or i5.startswith("A")) and i5.endswith("c"):
				print(i5)
				if i5 in new_dic:
					new_dic[i5]+=1
				else:
					new_dic[i5]=1
print(new_dic)

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# 数据库中原有
old_dict = {
    "1":{'hostname':'c1','cpu_count':2,'mem_capicity':80},
    "2":{'hostname':'c1','cpu_count':2,'mem_capicity':80},
    "3":{'hostname':'c1','cpu_count':2,'mem_capicity':80},
}
# 新汇报的数据
new_dict = {
    "1":{'hostname':'c1','cpu_count':2,'mem_capicity':800},
    "3":{'hostname':'c1','cpu_count':2,'mem_capicity':80},
    "4":{'hostname':'c2','cpu_count':2,'mem_capicity':80},
}
del_set=set(old_dict.keys()).difference(set(new_dict.keys()))         #{'2'}，需要删除的key，放在set集合里
add_set=set(new_dict.keys()).difference(set(old_dict.keys()))         #{'4'}，需要新增的key，放在set集合里
update_set=set(old_dict.keys()).intersection(set(new_dict.keys()))    #{'1','3'}，交集key，放在set集合里

#!/usr/bin/env python
# -*- coding=utf-8 -*-
arg1,arg2 = 1,2
result = arg1 if arg1>arg2 else arg2          #如果条件成立，那么将 "arg1" 赋值给result变量，否则，将"arg2"赋值给result变量
print(result)

#!/usr/bin/env python
# -*- coding=utf-8 -*-
def zidian(args):
	for key,value in args.items():
		if len(value) > 2:
			args[key]=value[0:2]
	return args	
	
dic = {'k1':"alex",'k2':[11,22,33,44],"k3":(11,22,33),"k4":"liyunliang"}
print(zidian(dic))

#!/usr/bin/env python
# -*- coding=utf-8 -*-
def liebiao(args):
	new_list=[]
	for i in range(len(args)):
		if i%2 == 1:
			new_list.append(args[i])
		else:
			pass
	return new_list			
list = [11,22,33,44,55,66,77] 
print(liebiao(list))

#!/usr/bin/env python
# -*- coding=utf-8 -*-
def space_jiancha(args):
	for i in args:
		if isinstance(i,int):   #判断是否是int类型,int类型不能使用isspace
			pass
		else:	
			if i.isspace():
				return True
				break		
	return False
			
list =[11,22,"liyunliang"," "]
ret=space_jiancha(list)          #ret等于True或False
if ret:
	print("用户传入的对象有空格")
else:
	print("用户传入的对象没有空格")

#!/usr/bin/env python
# -*- coding=utf-8 -*-
def sumnumber(args1,args2):
	return args1+args2

my_lambda=lambda args1,args2:args1+args2	

print(sumnumber(1,2))
print(my_lambda(1,2))

#!/usr/bin/env python
# -*- coding=utf-8 -*-
# 0 1 1 2 3 5 8 13 21 34 55 89
def f1(end,arg1,arg2):
	if end == 10:
		return arg1
	arg3 = arg1 + arg2
	r = f1(end+1,arg2,arg3)
	return r
ret= f1(1,0,1)
print(ret)

#!/usr/bin/env python
# -*- coding=utf-8 -*-
li = [112,3,6,50,40,1]            #将列表中数字从小到大依次排列
print(li)
for i in range(1,len(li)):
	for j in range(len(li)-i):
		if li[j] > li[j+1]:
			temp = li[j]
			li[j] = li[j+1]
			li[j+1] = temp
print(li)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
def outer(func):                                  #装饰器outer
    def inner(*args,**argss):                     #可接收任意参数
        print("你好!")
        r = func(*args,**argss)
        print("再见!")
        return r
    return inner
@outer	                                          #相当于outer(f2)
def f2(a1,a2):                                    #此函数若需要添加一些额外的功能，不改变原函数代码的情况可以使用装饰器
    return a1 + a2
print(f2(1,2))	                                  #输出为:'你好!'  '再见!'  3

#!/usr/bin/env python
# -*- coding:utf-8 -*-
def outer(func):                                  #装饰器outer
    def inner(*args,**argss):                     #可接收任意参数
        print("你好!")
        r = func(*args,**argss)
        print("再见!")
        return r
    return inner
def outer_1(func):                                #装饰器outer_1
    def inner(*args,**argss):
        print("欢迎来到测试系统!")
        r = func(*args,**argss)
        return r
    return inner
@outer_1                                          #相当于outer_1(f2)
@outer                                            #相当于outer(f2)
def f2(a1,a2):                                    #此函数若需要添加一些额外的功能，不改变原函数代码的情况可以使用装饰器
    return a1 + a2
@outer_1
@outer
def f3(a1,a2,a3):
    return a1 + a2 +a3
print(f2(1,2))
print(f3(1,2,3))

abs()     #取绝对值
all()     #循环参数，如果每个元素为真，那么all的返回值为真，0,None,空值为假，其余为真
any()     #循环参数，只要一个元素为真，则返回值为真
bin()     #二进制，0b表示
oct()     #八进制，0o表示
int()     #十进制	
hex()     #十六进制，0x表示
bool()    #转换成布尔值，返回真或假
bytes()   #转换为字节类型
str()     #转换为字符类型
chr()     #接收一个数字，找到对应的字符，c=chr(65) ,c的值为A
ord()     #接收一个字符，找到对应的数字, c=ord("A"),c的值为65
dir()     #查看帮助
help()    #查看帮助
divmod()  #取商和余数
enumrate() #为可迭代的对象添加序号
eval()    #执行一个字符串形式的表达式,有返回值
filter()  #过滤器，循环可迭代的对象，获取每一个参数，函数(参数)，filter(函数，可迭代的对象)
map()     #map(函数，可迭代的对象)
globals()   #获取所有全局变量，返回一个字典
locals()    #获取所有局部变量，返回一个字典
id()        #查看变量的内存地址,如a="li"，id(a)
input()      #接受一个标准输入数据，返回为 string 类型，与python2的写法不同，2为raw_input()
isinstance() #判断一个变量是否是某种类型，返回True/False
len()        #输出一个变量的长度，可测量str，列表，元组，字典的长度
max()        #取最大值
min()        #取最小值
pow()        #取幂数
round()      #对小数四舍五入
range()      #可创建一个整数列表，一般用在 for 循环中，用法为:range(start, stop[, step])，>=start，<stop，step为步长 
sorted()     #对所有可迭代的对象进行排序操作，sort只用于列表，用法为:sorted(iterable, key=None, reverse=False),reverse=True表示降序，False表示升序(默认)，生成新的对象，数字和字符串无法比较,字符串根据bytes值排序
sum()        #求和  
type()       #查看对象的类型
open()       #打开文件，用法为:open(name[, mode[, buffering]])，name为文件名,mode为打开方式，buffering可省略
list()       #可定义一个列表，也可用于将元组转换为列表。
tuple()      #可定义一个元组，也可用于将列表转换为元组。
dict()       #可创建一个字典 
set()        #可创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

abs(-1)    #返回值为1
all([1,0]) #0为假，返回False
any([1,0]) #1为真，返回True
bin(17)    #十进制转二进制
act(17)    #十进制转八进制
hex(17)    #十进制转十六进制
int('0b11',base=2)  #二进制转换为十进制,输出为3，0b可有可无，base=2表示二进制
int('0o11',base=8)  #八进制转换为十进制，输出为9，0o可有可无
int('0x11',base=16) #十六进制转换为十进制，输出为17 ，0x可有可无
bool(1)    #返回值为True
bytes("liyunliang",encoding="utf-8") #str转换为bytes，以uft-8的格式编码
str(b"liyunliang",encoding="utf-8")  #bytes转换为str，以utf-8的格式编码
chr(65)    #输出为字符A
ord("A")   #输出为数字65
dir(hash)  #查看hash有关的用法
help(hash) #查看hash有关的用法
divmod(10,3) #输出为元组(3,1)
li = [11,22,33]
for k,v in enumerate(li, 1):     #不指定为1的话默认从0开始
    print(k,v)                   #输出为1 11     2 22    3 33
eval("1+2")   #输出为数字3
eval("a+2",{"a":1})  #输出为数字3
def f1(x):
    if x > 22:
        return True
    else:
        return False
ret=filter(f1,[11,22,33,44])      #ret为可迭代的filter对象
for i in ret:
	print(i)                      #输出为过滤得到的数字33和44
ret=map(f1,[11,22,33,44])		  #ret为可迭代的map对象
for i in ret:
	print(i)                      #输出为False，False，True，True
id(1)                             #查看数字1的内存地址
u=input("请输入用户名:")          #则输入的数据为用户名
isinstance(1,(int))	              #判断1是否属于int类型，返回True,判断单个类型()可加可不加;isinstance(1,(int,str))，判断1是否属于int或者str类型
len("li")                         #返回值为2
max([11,22,33])                   #返回值为33
min([11,22,33])                   #返回值为11
pow(2, -1)                        #返回值为0.5,2的-1次方  
round(0.654,2)                    #返回值为0.65，2表示保留两位小数  
sorted([22,44,11,33])             #返回值为[11,22,33,44]
sorted([11,22,44,33],key=lambda x: x*-1) #返回值为[44,33,22,11]，利用key来降序
sorted([11,22,44,33],reverse=True)       #返回值为[44,33,22,11]
sum([11,22,33,44])                #返回值为110  
type(1)                           #可查看1的类型

f = open('test.txt','r')          #以只读的方式打开test.txt
f.read([size])                    #size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)
f.readline()                      #读取一行
f.readlines([size])               #返回包含size行的列表,size 未指定则返回全部行
for line in f: print line         #通过迭代器访问
f.write("hello\n")                #如果要写入字符串以外的数据,先将他转换为字符串.
f.tell()                          #返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).
f.seek(偏移量,[起始位置])         #用来移动文件指针.
f.close()                         #关闭文件
with open('test.txt','r') as f:   #以只读的方式打开文件test.txt，不需要close文件
模式说明：
r	#以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	#以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+	#打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	#以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	#打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb	#以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+	#打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+	#以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	#打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	#以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	#打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	#以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

#!/usr/bin/env python
# 基于密码数据文件的用户登录逻辑
import hashlib
def register(user,pwd):
    '''
    提供用户注册功能
    :param user:
    :param pwd:
    :return:
    '''
    with open('db','a',encoding="utf-8") as f1:
        f1.write(user+'|'+jiami(pwd)+'\n')

def jiami(pwd):
    '''
    提供密码MD5加密功能
    :param pwd:
    :return:
    '''
    temp = hashlib.md5(bytes('curry',encoding="utf-8"))
    temp.update(bytes(pwd,encoding="utf-8"))
    return temp.hexdigest()

def login(user,pwd):
    '''
    提供用户登录功能
    :param user:
    :param pwd:
    :return:
    '''
    with open('db','r',encoding="utf-8") as f2:
        for line in f2:
            u = line.strip().split("|")[0]
            p = line.strip().split("|")[1]
            if u == user and p == jiami(pwd):
                return True
            else:
                return False

def chpwd(user,pwd):
    '''
    提供用户修改密码功能
    :param user:
    :param pwd:
    :return:
    '''
    new_data = ""
    with open('db','r',encoding="utf-8") as f3:
        for line in f3:
            u = line.strip().split("|")[0]
            p = line.strip().split("|")[1]
            if u == user and p == jiami(pwd):
                new_pwd = input("请输入新的密码:")
                line = line.replace(p,jiami(new_pwd))            #文件内容替换
            else:
                pass
            new_data += line
    with open('db','w',encoding="utf-8") as f4:
        f4.write(new_data)
        print("密码更改成功")
        
def main():
    '''
    主函数
    :return:
    '''
    i = input("1.登录,2.注册,3.修改密码")
    if i == "2":
        user = input("用户名:")
        pwd = input("密码:")
        register(user,pwd)
    elif i == "1":
        user = input("用户名:")
        pwd = input("密码:")
        ret = login(user,pwd)
        if ret:
            print("登录成功")
        else:
            print("登录失败")
    elif i == "3":
        user = input("用户名:")
        pwd = input("密码:")
        chpwd(user,pwd)

if __name__ == "__main__":
    main()

#!/usr/bin/env python
# -*- coding=utf-8 -*-
def jiami(arg):
	temp = ''
	for i in arg:
		if i == ' ':
			temp += i
		elif ord(i) < 120:		
			temp += chr(ord(i) + 3)
		else:
			temp += chr(ord(i) - 23)			
	return temp		          
	   
inp = input("请输入字符串(只包含小写字母和空格):")
new_inp = jiami(inp)
print(new_inp)

ascii()       #对象的类中找_repr_，获取其返回值
例:
class Foo:
    def _repr_(self):
        return "hello"
		
r=ascii(Foo())
print(r)                 #返回值为<__main__.Foo object at 0x013E8B10>

bytearray()   #字节列表
callable()    #是否可执行，返回True/False，例如函数可执行，返回True
compile()     #接收一个字符串，把该字符串编译为python可执行的代码
exec()        #与eval类似，无返回值，只执行代码
例:
exec("for i in range(10):print(i)")
hash()        #得到一个对象的哈希值，如字典key,hash("liyun")，输出为哈希值:-416968271
issubclass()  #用于判断参数 class 是否是类型参数 classinfo 的子类，语法为:issubclass(class, classinfo)
例:
class A:
    pass
class B(A):
    pass
issubclass(B,A)  #返回值为True
iter()        #用来生成迭代器，语法为:iter(object[, sentinel])
例:
for i in iter([11,22,33]):
	print(i)
obj = iter([11,22,33]) #创建一个可迭代的对象  
print(next(obj))       #从11开始取值，每次取下一个值
reversed()   #反转，生成一个可迭代的对象
例:
for i in reversed([11,44,33]):
	print(i)               #输出为33  44  11
slice()                    #根据索引切片
例:
[11,22,33,44,55,66][slice(1,5,2)]       #输出为[22,44]，列表截取1-4元素布长为2的切片
zip()	                   #用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组
例:
li1 = [1,2,3,4]
li2 = ["a","b","c","d"]
r = zip(li1 ,li2)
for i in r:
    print(i)               #输出为:(1,'a')   (2,'b')   (3,'c')   (4,'d')

'^'  #匹配字符串的开头，若放在[]内，则表示非。
re.findall('^s','sb')                  #输出为:['s']
re.findall('[^s]','bssim')             #输出为:['b', 'i', 'm']

'$'  #匹配字符串的末尾。
re.findall('b$','sb')                  #输出为:['b']

'.'  #匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
re.findall('.','bssim\nc')             #输出为:['b', 's', 's', 'i', 'm', 'c']

'*'  #匹配0个或多个的表达式。
re.findall('.*m','bssim\nc')           #输出为:['bssim']
re.findall('.*c','bssim\nc')           #输出为:['c']

'+'  #匹配1个或多个的表达式。
re.findall('.+c','bssim\nc')           #输出为:[]
re.findall('.+m','bssim\nc')           #输出为:['bssim']

'?'  #匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re.findall('.?m','bssim\nc')           #输出为:['im'] 
re.findall('.m?','bssim\nc')           #输出为:['b', 's', 's', 'im', 'c']

'|'  #或运算
re.findall('s|i','bssim\nc')           #输出为:['s', 's', 'i']

'{m}'    #匹配前一个字符m次
re.findall('ab{2}','abb abc abbcbbb')       #输出为:['abb', 'abb']

'{n,m}'  #匹配前一个字符n到m次
re.findall("ab{1,3}","abb abc abbcbbb")     #输出为:['abb', 'ab', 'abb']

'(...)'  #分组匹配

'\'      #后面接常用符号，可将其普通化，接普通字符，可将其特殊化

'\A'     #从字符开头匹配
re.findall("\Aabc","alexabc")                #从开头匹配'abc'，输出为:[],匹配不到

'\Z'     #匹配字符结尾，同'$'

'\d'     #匹配数字0-9
re.findall('\d','ab1cd2ef3')           #输出为:['1','2','3']
    
'\D'     #匹配非数字
re.findall('\D','ab1cd2ef3')           #输出为:['a','b','c','d','e','f']

'\w'     #匹配字母和数字和下划线
re.findall('\w','a1$_#c2')             #输出为:['a','1','_','c','2']

'\W'     #匹配非字母和数字和下划线
re.findall('\W','a1_$#c2')             #输出为:['$','#']

'\s'     #匹配空白字符，如换行符等                 
re.findall('\s','a\t\nb')              #输出为:['\t','\n']

'\S'	 #匹配任何非空白字符，除换行符等除外

'\1'     #表示对应的分组在此处出现一次，如'(ab)(cd)\1\2'，则\1实际指的是(ab),\2指的是(cd)

re.findall()            #把所有匹配到的字符放到以列表中的元素返回
re.findall(string, start, end)                   #可以与re.compile()一起使用，字符串指定位置start到end查找
re.findall('\d+a','b13ac4ad')                    #输出['13a', '4a']
re.findall('(\d+)a','b13ac4ad')                  #输出['13', '4']，找到13a和4a，并去掉a输出 
re.findall('((\d+)a)','b13ac4ad')                #输出[('13a', '13'), ('4a', '4')]，组内再分组
re.findall('(\w+){4}','lishizheng')              #输出['g']，(\w)虽然重复了四次，但是表达式只有一个，默认输出末尾字符

re.match(pattern, string, flags)              #从头开始匹配,re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
r1 = re.match('h\w+','hello world')
r2 = re.match('(h)(\w+)','hello world')
r3 = re.match('(?P<n1>h)(?P<n2>\w+)','hello world')
print(r1.group(),r1.groups(),r1.groupdict())         #输出为hello () {} ，用法和search相同
print(r2.group(),r2.groups(),r2.groupdict())         #输出为hello ('h', 'ello') {}
print(r3.group(),r3.groups(),r3.groupdict())         #输出为hello ('h', 'ello') {'n1': 'h', 'n2': 'ello'} 

re.search(pattern, string, flags)             #匹配整个字符串，直到找到一个匹配，返回一个match对象，未匹配成功返回None
re.search(pattern, string, flags).group()     #group()默认等于group(0),即所有的元素，输出为字符串 
re.search('www', 'www.runoob.com').span())    #可查看匹配的位置

re.sub(pattern, repl, string, count,flag)        #匹配字符并替换，pattern为正则，repl为需要替换成的字符串,也可为函数，string为原始字符串，count为匹配模式后替换的最大数量，flag为标志位
re.sub('[0-9]','|', 'a1b2c3d e8',count=2)        #输出为新的字符串:'a|b|c3d e8'
re.sub('[0-9]','|', 'a1b2c3d e8')                #没有count或者等于0默认全部替换，输出为新的字符串:'a|b|c|d e|'
 
re.compile()            #编译正则表达式
rule = re.compile('[0-9]',re.I)          #将正则编译放到一个变量
rule.split('a1b2c3d e8')                 #根据这个规则来进行分割，输出为:['a', 'b', 'c', 'd e', '']
rule.findall('run88oob123google456', 0, 10)      #查找字符串0-10的位置的所有数字，输出为:['8','8','1','2']

re.finditer(pattern, string, flags=0)    #和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
       
re.split()              #将匹配到的格式当做分割点对字符串分割成列表
re.split('[0-9]', 'a1b2c3d e8')             #输出为:['a', 'b', 'c', 'd e', '']
re.split('(ab)','123ab456ab789',1)          #输出为:['123', 'ab', '456ab789'],加()表示连表达式匹配一起输出,1表示匹配一次，默认匹配多次

flag说明
re.I	#使匹配对大小写不敏感
re.L	#做本地化识别（locale-aware）匹配
re.M	#多行匹配，影响 ^ 和 $
re.S	#使 . 匹配包括换行在内的所有字符
re.U	#根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	#该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

#! /usr/bin/env python
# -*- coding:utf-8 -*-
import re
def f1(arg):
	sum1 = eval(arg)             #执行一个字符串形式的算术表达式
	return sum1	
	
inp = input("请输入您要计算的数学表达式，其中包含加减乘除:")
exp = inp
while True:
	list = re.split('\(([^()]+)\)', exp , 1)         #根据第一个括号内不含括号的表达式进行分割
	if len(list) == 3:
		temp1 = f1(list[1])
		temp2 = list[0] + str(temp1) +list[2]
		exp = temp2
	else:
		sum = f1(list[0])
		break
print("%s = %d" %(inp,sum))

import time             #导入time模块,如果执行`from time import time`,则调用时少写一个time
print(time.clock())     #返回处理器时间,3.3开始已废弃 , 改成了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来输出为:8.552505542023591e-07
print(time.altzone)     #返回与utc时间的时间差,以秒计算，输出为:-32400
rint(time.asctime())    #返回时间格式"Fri Aug 19 11:14:16 2016",输出为:Tue Mar 27 13:45:09 2018
print(time.localtime()) #返回本地时间 的struct time对象格式，输出为:time.struct_time(tm_year=2018, tm_mon=3, tm_mday=27, tm_hour=13, tm_min=45, tm_sec=9, tm_wday=1, tm_yday=86, tm_isdst=0)
print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式,输出为:time.struct_time(tm_year=2018, tm_mon=3, tm_mday=17, tm_hour=23, tm_min=31, tm_sec=49, tm_wday=5, tm_yday=76, tm_isdst=0)
print(time.asctime(time.localtime()))  #输出为:Tue Mar 27 13:45:09 2018
print(time.ctime())                    #输出为:Tue Mar 27 13:45:09 2018
truct = time.strptime("2016/05/22","%Y/%m/%d") #将日期字符串 转成 struct时间对象格式
print(string_2_struct)                         #输出为:time.struct_time(tm_year=2016, tm_mon=5, tm_mday=22, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=143, tm_isdst=-1)
struct_2_stamp = time.mktime(string_2_struct)  #将struct时间对象转成时间戳
print(struct_2_stamp)                          #输出为:1463846400.0   
print(time.gmtime(time.time()-86640))          #将utc时间戳转换成struct_time格式,输出为:time.struct_time(tm_year=2018, tm_mon=3, tm_mday=26, tm_hour=5, tm_min=49, tm_sec=7, tm_wday=0, tm_yday=85, tm_isdst=0)
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime())) #将utc struct_time格式转成指定的字符串格式,输出为:2018-03-27 05:53:07
print(time.strftime('%Y%m%d%H%M',time.localtime(time.time())))  #取本地时间的时间戳，输出为:201803271406
print(time.strftime('%Y%m%d%H%M',time.localtime()))             #取本地时间的时间戳，输出为:201803271406
print(time.strftime('%Y%m%d%H%M'))                              #取本地时间的时间戳，输出为:201803271406

import datetime    #导入datetime模块
print(datetime.datetime.now())                   #输出为:2018-03-27 13:56:12.918226     
print(datetime.date.fromtimestamp(time.time()))  #输出为:2018-03-27
print(datetime.datetime.now() + datetime.timedelta(3))  #当前时间加三天，输出为:2018-03-30 13:58:55.264512
print(datetime.datetime.now() + datetime.timedelta(-3))  #当前时间减三天，输出为:2018-03-24 13:58:55.264512
print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间加三小时，输出为:2018-03-27 16:58:55.264512
print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间加30分钟
print(datetime.datetime.now() + datetime.timedelta(weeks=1))    #当前时间加一周
c_time  = datetime.datetime.now()
print(c_time.replace(minute=3,hour=2))                          #时间替换

import sys         #导入sys模块
sys.argv           #命令行参数List,执行python文件时可以传入多个参数,参数以列表的形式保存,第一个元素是程序本身路径
sys.exit(n)        #退出程序，正常退出时exit(0)
sys.version        #获取Python解释程序的版本信息
sys.maxint         #最大的Int值
sys.path           #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值,默认当前路径优先,python\lib\site-packages 路径存放所有第三方安装的模块 
sys.platform       #返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sys,time
for i in range(31):
    sys.stdout.write('\r')             #清除屏幕输出
    sys.stdout.write('%s%% | %s' %(int(i/30*100),int(i/30*100)*'*'))
    sys.stdout.flush()                 #刷新，每一次都输出
    time.sleep(0.5)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sys,os
for i in range(1,len(sys.argv)):
    os.mkdir(sys.argv[i])

pickle.loads()     #将字符串转化为python数据类型列表，元组，字典，可从文件中读取列表，元组，字典类型的数据，主要使用带s的    
pickle.load()
pickle.dumps()     #将python数据类型转化为字符串，与open结合可将列表，元组，字典类型的数据放进文件中
pickle.dump()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pickle
account_info ={
    1:{
        'name':'liyunliang',
        'passwd':'lylapqh',
        'tel':'13888675421',
        'balance':15000
    }
}
f = open('account_db','wb')                 
f.write(pickle.dumps(account_info))                  #将字典的信息写进数据文件中
# pickle.dump(account_info,f)  和上面等价
f.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pickle
account_file = open('account_db','rb')                   
account_dic = pickle.loads(account_file.read())      #将数据文件读到字典里
# account_dic = pickle.load(account_file) 和上面等价      
account_file.close()
account_dic[1]['balance'] -= 500                     #购物后找到对应人账户余额减去商品价格
f = open('account_db','wb')
f.write(pickle.dumps(account_dic))                   #将新的字典写入数据文件
f.close()

os.getcwd()                 #获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")         #改变当前脚本工作目录；相当于shell下cd
os.curdir                   #返回当前目录: ('.')
os.pardir                   #获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2')    #可生成多层递归目录
os.removedirs('dirname1')   #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')         #生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')         #删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')       #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                 #删除一个文件
os.rename("oldname","new")  #重命名文件/目录
os.stat('path/filename')    #获取文件/目录信息
os.sep                      #操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep                  #当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep                  #用于分割文件路径的字符串
os.name                     #字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")   #运行shell命令，直接显示
os.environ                  #获取系统环境变量
os.path.abspath(path)       #返回path规范化的绝对路径
os.path.split(path)         #将path分割成目录和文件名二元组返回
os.path.dirname(path)       #返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)      #返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)        #如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)         #如果path是绝对路径，返回True
os.path.isfile(path)        #如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)         #如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)      #返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)      #返回path所指向的文件或者目录的最后修改时间

import hashlib

# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())
 
######## sha1 ######## 
hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha256 ######## 
hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha384 ########
hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha512 ######## 
hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
# ######## md5 ########
hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))
hash.update(bytes('admin',encoding="utf-8"))
print(hash.hexdigest())

import hmac 
h = hmac.new(bytes('898oaFs09f',encoding="utf-8"))
h.update(bytes('admin',encoding="utf-8"))
print(h.hexdigest())

import random
print(random.random())                 #随机生成0-1之间的小数
print(random.randint(1, 2))            #随机生成1或者2
print(random.randrange(1, 10))         #随机生成1-10中的一个数

#!/usr/bin/env python
# -*- coding=utf-8 -*-
import random
while True:
	temp=""
	for i in range(4):
		num = random.randrange(0,4)
		if num == 0 or num == 2:
			rad1 = random.randrange(0,10)
			temp += str(rad1)
		else:
			rad2 = random.randrange(65,91)
			temp += chr(rad2)                #chr()为找到数字对应的字符
	print(temp)
	shuru = str(input("请输入验证码:"))
	if shuru == temp:
		break
	else:
		pass

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from xml.etree import ElementTree as ET          #解析文件或者字符串，做修改，都在内存中进行，原对象不改变，如需修改得重新write写入
str_xml = open('xo.xml', 'r').read()             #打开文件，读取XML内容，内容为xml格式的字符串
print(ET.XML(str_xml))                           #将xml公司的字符串解析成xml特殊对象，获取xml文件的根节点
print(ET.parse("xo.xml"))                        #直接解析xml文件
print(ET.parse("xo.xml").getroot())                #获取xml文件的根节点
print(ET.parse("xo.xml").getroot().tag)            #顶层标签
root = ET.parse("xo.xml").getroot()                #与下面的相同
root = ET.XML(str_xml)

for child in root:         #遍历XML文档的第二层
    print(child.tag, child.attrib)                 #第二层节点的标签名称和标签属性
    for i in child:                                #遍历XML文档的第三层
        print(i.tag,i.text)                        #第二层节点的标签名称和内容
		
for node in root.iter('year'):    #遍历XML中所有的指定的year节点
    print(node.tag, node.text)                            #节点的标签名称和内容
	
for node in root.iter('year'):                 #循环所有的year节点
    new_year = int(node.text) + 1                         #将year节点中的内容自增1
    node.text = str(new_year)
    node.set('name', 'SubHy')                             #设置属性
    node.set('age', '18')
    del node.attrib['name']                               #删除属性
tree = ET.ElementTree(root)                               #保存文件
tree.write("newnew.xml", encoding='utf-8')

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from xml.etree import ElementTree as ET
from xml.dom import minidom
def mkxml(elem,filename):
    rough_string = ET.tostring(elem,'utf-8')
    reparsed = minidom.parseString(rough_string)
    raw_str = reparsed.toprettyxml(indent="\t")
    f = open(filename,'w',encoding='utf-8')
    f.write(raw_str)
    f.close()


root = ET.Element("famliy")                                     # 创建根节点
# son1 = ET.Element('son', {'name': '儿1'})                     #创建大儿子
son1 = root.makeelement('son', {'name': '儿1'})                                     
# son2 = ET.Element('son', {"name": '儿2'})                     #创建小儿子
son2 = root.makeelement('son', {"name": '儿2'})
# grandson1 = ET.Element('grandson', {'name': '儿11'})          #在大儿子中创建两个孙子  
grandson11 = son1.makeelement('grandson', {'name': '儿11'})
# grandson2 = ET.Element('grandson', {'name': '儿12'})
grandson12 = son1.makeelement('grandson', {'name': '儿12'})
son1.append(grandson11)                                         #把孙子添加到儿子1节点中
son1.append(grandson12)
root.append(son1)                                               #把儿子添加到根节点中
root.append(son2)
mkxml(root,"xxxoo.xml")

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from xml.etree import ElementTree as ET
ET.register_namespace('H',"http://www.company.com") #some name
# build a tree structure
root = ET.Element("{http://www.company.com}STUFF")
body = ET.SubElement(root, "{http://www.company.com}MORE_STUFF", attrib={"{http://www.company.com}hhh": "123"})
body.text = "STUFF EVERYWHERE!"
# wrap it in an ElementTree instance, and save as XML
tree = ET.ElementTree(root)
tree.write("page.xml",xml_declaration=True,encoding='utf-8',method="xml")

import requests,json
ret = requests.get('https://github.com/timeline.json')         #无参数示例,get请求
print(ret.url)                                                 #输出请求网址的地址字符串类型'https://github.com/timeline.json' 
print(ret.text)                                                #返回请求解析得到的字符串内容
print(ret.content)                                             #返回解析的二进制数据
print(ret.cookies)                                             #输出请求网址的cookies信息 
print(ret.headers)                                             #输出请求网址的headers所有信息
print(ret.status_code)                                         #输出请求页面的状态（状态码） 
print(ret.history)                                             #输出请求的历史记录（以列表的形式显示）
print(requests.codes.ok)                                       #requests请求状态码，为200 
ret.encoding = 'utf-8'                                         #当解析到的输出乱码时,可设置编码 

payload = {'key1': 'value1', 'key2': 'value2'}
ret = requests.get("http://httpbin.org/get", params=payload)   #有参数示例,get请求
print(ret.url)                                                 #返回字符串'http://httpbin.org/get?key1=value1&key2=value2'
print(ret.text)

ret = requests.post("http://httpbin.org/post", data=payload)   #基本POST请求示例 
print(ret.text)

url = 'https://api.github.com/some/endpoint'
payload = {'some': 'data'}
headers = {'content-type': 'application/json'}
ret = requests.post(url, data=json.dumps(payload), headers=headers)    #发送请求头和数据实例
print(ret.text)
print(ret.cookies)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#输入参数：QQ号码 String。返回数据：String，Y = 在线；N = 离线；E = QQ号码错误；A = 商业用户验证失败；V = 免费用户超过数量
import requests
from xml.etree import ElementTree as ET
def qqonlinedetect(args):
    r = requests.get('http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode='+args)
    result = r.text
    node = ET.XML(result)     #解析XML格式内容
    if node.text == "Y":      #获取内容
        return True
    else:
        return False
if __name__ == "__main__":
    ret = qqonlinedetect(input("请输入QQ号:"))
    if ret:
        print("您的QQ号在线")
    else:
        print("您的QQ号离线")

import urllib
import requests
from xml.etree import ElementTree as ET
#使用内置模块urllib发送HTTP请求，或者XML格式内容，该例中车次为:K113
"""
f = urllib.request.urlopen('http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=K113&UserID=')
result = f.read().decode('utf-8')
"""
#使用第三方模块requests发送HTTP请求，获取XML格式内容
r = requests.get('http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=K113&UserID=')
result = r.text
root = ET.XML(result)   # 解析XML格式内容
for node in root.iter('TrainDetailInfo'):
    print(node.find('TrainStation').text,node.find('StartTime').text,node.find('KM').text)

[section1]  # 节点
k1 = v1     # 值
k2:v2       # 值
 
[section2]  # 节点
k1 = v1     # 值

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import configparser
config = configparser.ConfigParser()
config.read('xx', encoding='utf-8')
ret = config.sections()                        #获取所有节点
ret = config.items('section1')                 #获取指定节点下所有的键值对
ret = config.options('section1')               #获取指定节点下所有的键
v = config.get('section1','k1')                #获取指定节点下的key
has_sec = config.has_section('section1')       #检查指定节点是否在config中，返回True/False
config.add_section("SEC_1")                    #添加一个节点，可以写到原文件，也可生成新文件
config.write(open('xx', 'w'))
config.remove_section("section1")              #移除一个节点
config.write(open('xx', 'w'))
has_opt = config.has_option('section2', 'k1')  #检测指定节点和key是否在config中，同时存在返回True，否则返回False
config.remove_option('section1', 'k1')         #删除指定节点下的key及对应的值
config.write(open('xx', 'w'))
config.set('section1', 'k10', "123")           #新增一个节点，新增对应的key和值
config.write(open('xx', 'w'))

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

import logging
logging.basicConfig(filename='log.log',                                                           #定义日志的格式，以及写等级
                    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',
                    level=10)                                                                     #level=10也可以换成level=logging.DEBUG
  
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'debug')             #用法和logging.debug一致

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import logging
# 定义文件
file_1_1 = logging.FileHandler('l1_1.log', 'a', encoding='utf-8')
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s")
file_1_1.setFormatter(fmt)
file_1_2 = logging.FileHandler('l1_2.log', 'a', encoding='utf-8')
fmt = logging.Formatter()
file_1_2.setFormatter(fmt)
# 定义日志
logger1 = logging.Logger('s2', level=logging.DEBUG)
logger1.addHandler(file_1_1)
logger1.addHandler(file_1_2)
# 写日志
logger1.critical('1111')

import subprocess
ret1 = subprocess.check_output(["echo","lyl"])                #执行命令不显示结果，如果正确执行 ，则返回执行结果(字节方式)，否则抛异常
ret2 = subprocess.call("echo lyl")                            #执行命令并显示结果，如果正确执行 ，则返回0，否则抛异常
ret3 = subprocess.check_call("echo lyl")                      #执行命令并显示结果，如果正确执行 ，则返回0，否则抛异常
ret4 = subprocess.Popen("echo lyl")                           #执行命令并显示结果，如果正确执行，返回值为Popen对象
print(ret1,ret2,ret3,ret4)

# 进入某环境，依赖再输入，如:python
obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")          #执行的命令
obj.stdin.write("print(2)")
obj.stdin.close()
cmd_out = obj.stdout.read()            #输出
obj.stdout.close()
cmd_error = obj.stderr.read()          #错误 
obj.stderr.close()                     
print(cmd_out)                         #输出:1,2 
print(cmd_error)                

out_error_list = obj.communicate()
print(out_error_list)                  #输出:('1\n2\n', '')

out_error_list = obj.communicate('print("hello")')             #可直接接收命令并输出
print(out_error_list)                  #输出:('hello\n', '')

shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))         #拷贝文件
shutil.copyfile('f1.log', 'f2.log')                                   #拷贝文件
shutil.copymode('f1.log', 'f2.log')                                   #仅拷贝权限，内容、组、用户均不变，文件不存在会报错
shutil.copystat('f1.log', 'f2.log')                                   #仅拷贝状态的信息，包括：mode bits, atime, mtime, flags,文件不存在会报错
shutil.copy('f1.log', 'f2.log')                                       #拷贝文件和权限
shutil.copy2('f1.log', 'f2.log')                                      #拷贝文件和状态信息
shutil.copytree("G:\mysite", "G:\mysite1",ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))        #递归拷贝文件夹，忽略pyc类型的文件和tmp开头的文件
shutil.rmtree("G:\mysite1")                                           #递归的删除文件夹 
shutil.move("G:\mysite", "G:\mysite1")                                #递归的去移动文件，它类似mv命令，其实就是重命名

# shutil.make_archive(base_name, format,...)
# 创建压缩包并返回文件路径，例如：zip、tar
#base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
＃　如：www                        =>保存至当前路径
＃如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
# format：	压缩包种类，“zip”, “tar”, “bztar”，“gztar”
# root_dir：	要压缩的文件夹路径（默认当前目录）
# owner：	用户，默认当前用户
# group：	组，默认当前组
# logger：	用于记录日志，通常是logging.Logger对象
shutil.make_archive("G:\\aaaaa","zip",root_dir="G:\mysite")           #将G:\mysite下的文件打包到G:\aaaaa.zip

# shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的
import zipfile
z = zipfile.ZipFile('laxi.zip', 'w')        #压缩后的文件为laxi.zip
z.write('log.log')                          #往压缩文件添加内容
z.write('xx')
z.close()
z = zipfile.ZipFile('laxi.zip', 'a')        #以追加的方式打开
z.write('a1.py')                            #往压缩文件中追加文件
z.close()
z = zipfile.ZipFile('laxi.zip', 'r')        #解压缩
z.extractall()                              #全部解压
print(z.namelist())                         #查看压缩包里的文件
z.extract(member="log.log")                 #指定文件解压
z.close()

import tarfile
tar = tarfile.open('your.zip','w')          #压缩后的文件为you.zip  
tar.add('log.log', arcname='new.log')       #往压缩文件添加内容并改文件名
tar.add('xx', arcname='cmdb.log')
tar.close()
tar = tarfile.open('your.zip','r')
print(tar.getnames())                       #查看压缩包里的文件
tar.extractall()                            #全部解压
tar.extract(member="new.log")              
tar.close()

import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('192.168.1.2', 22, 'root', 'rootadmin')                 #使用用户名和密码远程执行命令
# private_key_path = '/home/auto/.ssh/id_rsa'                       #密钥认证来远程执行
# key = paramiko.RSAKey.from_private_key_file(private_key_path)
# ssh.connect('192.168.1.2', 22, 'root', key)
stdin, stdout, stderr = ssh.exec_command('df -h')
print (stdout.read())
ssh.close()

import os,sys,paramiko
t = paramiko.Transport(("192.168.229.70",22))
t.connect(username="root",password="rootadmin")
# pravie_key_path = '/home/auto/.ssh/id_rsa'                       #密钥认证
# key = paramiko.RSAKey.from_private_key_file(pravie_key_path)
# t.connect(username='root',pkey=key)
sftp = paramiko.SFTPClient.from_transport(t)
sftp.put("a1.py","/tmp/test.py")                                   #服务器上传文件
sftp.get("/mancenter-3.9.3.war","G:\\mancenter.war")               #服务器下载文件
t.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
print(vars())      #python自带的全局变量
print(__doc__)     #py文件的注释
print(__package__) #指定文件所在的包，用.分割，当前文件返回None
print(__loader__)
print(__file__)    #当前文件路径
print(__name__)    #如果是主文件,在当前文件执行而不是调用，__name__ == "__main__"，否则等于模块名
print(__cached__)  #其他文件的缓存值，当前为None
print(__builtins__)  #内置函数在这里面
def f1():
    print("执行了")
    return True

if __name__ == "__main__":     #调用主文件前，必须加这个条件，只有当执行自身的文件才会执行f1()，被导入不执行f1()
    f1()

import os,sys
temp1 = os.path.dirname(__file__)     #当前文件路径
temp2 = "li"
temp = os.path.join(temp1,temp2)      #路径拼接
sys.path.append(temp)                 #路径添加到sys.path
import s1

print("i am %s" % "SubHyCan")
print("i am %s age %d" % ("SubHyCan", 24))
print("i am %(name)s age %(age)d" % {"name": "SubHyCan", "age": 18})
print("percent %.2f" % 99.97623)
print("i am %(pp).2f" % {"pp": 123.425556, })
print("i am %(pp).2f%%" % {"pp": 99.425556, })

print("i am {}, age {}, {}".format("seven", 24, 'SubHyCan')) 
print("i am {}, age {}, {}".format(*["seven", 24, 'SubHyCan']))  
print("i am {0}, age {1}, really {0}".format("seven", 18)) 
print("i am {0}, age {1}, really {0}".format(*["seven", 18])) 
print("i am {name}, age {age}, really {name}".format(name="seven", age=18))  
print("i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})) 
print("i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])) 
print("i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1))  
print("i am {:s}, age {:d}".format(*["seven", 18])) 
print("i am {name:s}, age {age:d}".format(name="seven", age=18))
print("i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18}))
print("numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2))
print("numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2))
print("numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15))
print("numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15))

class Foo():                               #Foo后的()可省略
	def f1(self):
		print(self)                        #self是python内部默认的参数，指向引用类的对象或实例
	def f2(self,arg2):
		print(self,arg)
obj = Foo()                                #通过类对象指针，创建一个引用类Foo的对象或实例
print(obj)                                 #和类中print(self)的值是一样的
obj.f1()
obj.f2("shuaiguo")		

### 封装
class Foo1():
    def __init__(self):        #封装,__init__构造方法，在遇到将类指向一个对象或实例时，会初始化执行        
        self.name = "lyl"
        self.age = 18
	def detail(self):
		print (self.name,self.age)
obj1 = Foo1()
obj1.detail()
print (obj1.name,obj1.age)                #直接调用obj1对象的name属性和age属性

class Foo2(Foo1):
    def __init__(self, name, age):        #封装，子类Foo2和父类Foo1都封装了__init__方法，则子类会覆盖父类的方法
		super().__init__()                #使用super函数可直接调用父类与子类相同的方法
        self.xinbie = name
        self.xinzuo = age
    def detail(self):
        print (self.xinbie,self.xinzuo)   
obj1 = Foo2('男', "射手")
obj1.detail()          #Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 lyl ；self.age 是 18
print (obj1.name,obj1.age)

class Person:
    def __init__(self, na, gen, age, fig):
        self.name = na
        self.gender = gen
        self.age = age
        self.fight =fig
    def grassland(self):
        """注释：草丛战斗，消耗200战斗力"""
        self.fight = self.fight - 200
    def practice(self):
        """注释：自我修炼，增长100战斗力"""
        self.fight = self.fight + 200
    def incest(self):
        """注释：多人游戏，消耗500战斗力"""
        self.fight = self.fight - 500
    def detail(self):
        """注释：当前对象的详细情况"""
        temp = "姓名:%s ; 性别:%s ; 年龄:%s ; 战斗力:%s"  % (self.name, self.gender, self.age, self.fight)
        print (temp)

# #####################  开始游戏  #####################
cang = Person('苍', '女', 18, 1000)    #创建苍角色
dong = Person('木木', '男', 20, 1800)  #创建木木角色
bo = Person('多多', '女', 19, 2500)    #创建多多角色

cang.incest() #苍参加一次多人游戏
dong.practice()#木木自我修炼了一次
bo.grassland() #多多参加一次草丛战斗
#输出当前所有人的详细情况
cang.detail()
dong.detail()
bo.detail()

class D(object):
    def bar(self):
        print ('D.bar')

class C(D):
    def bar(self):
        print ('C.bar')

class B(D):
    def bar(self):
        print ('B.bar')

class A(B, C):                                #多类继承，A有多个基类，继承优先级B优于C
    def bar(self):
        print ('A.bar')

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

class F1:
    pass
class S1(F1):
    def show(self):
        print 'S1.show'
class S2(F1):
    def show(self):
        print 'S2.show'
def Func(obj):                             #def Func(F1 obj):      伪代码实现java和C#的多态
    print obj.show()                       #	print obj.show() 	  
s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
inp = input("请输入url(以模块名/对象的格式):")           
mode,obejects = inp.split("/")
dd = __import__("lib." + mode, fromlist=True)      #以字符串的方式导入模块，假设输入的模块都在lib下，模块都存在
if hasattr(dd,obejects):                           #判断用户输入的对象是否在模块中，如果存在，则返回设定的值或者url  
    ret= getattr(dd,obejects,)()                  
    print(ret)
else:
    print("404")                                   #对象不存在，报404
print(hasattr(dd,"f1"))                            #False
temp = setattr(dd,"f1","lyl")                      #往内存中写入对象
print(hasattr(dd,"f1"))                            #True 
delattr(dd,"f1")                                   #在内存中删除对象  
print(hasattr(dd,"f1"))                            #False