#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time
import calendar
student = {"age": 7,"name": "yzh"}
for key in student.keys():
if key == "name":
print student[key]
else:
print "不是需要的名称"
list = [3,12,34,45,35,67,8]
list1=[]
list2=[]
while len(list)>0:
#list.pop()默认从最后一个元素开始吐出，当然可以指定下标
number = list.pop()
if number % 2 ==0:
list1.append(number)
else:
list2.append(number)
print list1
print list2
print list2.pop(2)
#del list1[2] 删除列表元素，len(list)，max(list)，min(list)，list.append(obj)，list.count(obj)
#
aList = [123, 'Google', 'Runoob', 'Taobao', 'Facebook'];
#aList.sort();
aList.insert(0, "ooo")
print aList.remove(123)
aList.reverse()
print aList
aList.extend(["455",234])
print aList
#python字符串比较
a="ssd"
b="ssd"
print a==b
print cmp(a,b) #返回0代表相当，大于0代表大于，python3被移除
#字典操作cmp(dict1, dict2),len(dict),str(dict),type(variable),dict.values(),dict.has_key(key), dict.items()
#dict.keys(),dict.values(),dict.update(dict2),dict.clear()
#time
print time.time()
print time.localtime()
print time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
print calendar.month(2018,1)
#函数
def add(str):
print str
return;
add("sssssss")
print type("i am a girl".split(" "))
time.sleep(10)
print "稍等"
#python正则
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import re
#匹配策略：.匹配任意除换行符“\n”外的字符；*表示匹配前一个字符0次或无限次；+或*后跟？表示非贪婪匹配，即尽可能少的匹配，如*？重复任意次，但尽可能少重复；
# .*? 表示匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。
#正则表达式,re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
#匹配成功re.match方法返回一个匹配的对象，否则返回None。
#我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
# match严格匹配，从第一个开始，"abc"在"abcdefgabc"出现一次
matchobj = re.match(".*?[bc]", "abcdefgabc")
print(matchobj) #
print(type(matchobj))
print(matchobj.group(0)) # 挖掘的第一个匹配ab
#re.search 扫描整个字符串并返回第一个成功的匹配。
#re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
print(re.match('com', 'www.runoob.com'))
print(re.search('com', 'www.runoob.com').group())
#替换：Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
#re.sub(pattern, repl, string, count=0, flags=0),pattern : 正则中的模式字符串。repl : 替换的字符串，也可为一个函数。
# string : 要被查找替换的原始字符串。count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配
#$表示字符串的结尾，所以加上$表示匹配的内容必须在字符串的结尾
#\D匹配任意非数字,r代表非转义
phone = "2004-959-559 # 这是一个国外电话号码"
# 删除字符串中的 Python注释
num = re.sub(r'#.*$', "", phone)
print "电话号码是: ", num
# 删除非数字(-)的字符串
num = re.sub(r'\D', "", phone)
print "电话号码是 : ", num
#正则表达式模式语句
#re.compile compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
pattern = re.compile(r'\d+')
m = pattern.match('one12twothree34four', 3, 10)
print m.group(0)
m.start(0)
m.end(0)
m.span(0)
pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)# re.I 表示忽略大小写
m = pattern.match('Hello World Wide Web')
print m.group(0)
print m.group(1)
print m.group(2)#上面一个括号是一组，有几个括号就返回几组
#\d匹配任意数字，等价于 [0-9]. +匹配1个或多个的表达式。[...] 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k';不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
#^ 匹配字符串的开头 re{ n}精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
#re{ n,} 匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
#re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
#a| b 匹配a或b ;(re) 匹配括号内的表达式，也表示一个组
#\w 匹配字母数字及下划线;\W 匹配非字母数字及下划线 \s匹配任意空白字符，等价于 [\t\n\r\f].\S匹配任意非空字符
#\A 匹配字符串开始 \Z匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串 \z 匹配字符串结束
#\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。\B匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
#\n, \t, 等. 匹配一个换行符。匹配一个制表符。等
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
print "matchObj.group() : ", matchObj.group()
print "matchObj.group(1) : ", matchObj.group(1)
print "matchObj.group(2) : ", matchObj.group(2)
else:
print "No match!!"
#正则表达式修饰符常用 re.I使匹配对大小写不敏感；re.M多行匹配，影响 ^ 和 $
#findall,在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。注意： match 和 search 是匹配一次 findall 匹配所有。
import re
pattern = re.compile(r'\d+') # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
print(result1)
print(result2)
#re.finditer,和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
it = re.finditer(r"\d+","12a32bc43jf3")
for match in it:
print (match.group() )
#re.split,split 方法按照能够匹配的子串将字符串分割后返回列表
print re.split('\W+', 'runoob, runoob, runoob.')
for i in range(1, 5, 1):
print i
#python3 与python2不同
#print语句没有了，取而代之的是print()函数。
#在 Python 3，我们最终有了 Unicode (utf-8) 字符串，以及一个字节类：byte 和 bytearrays。
#由于 Python3.X 源码文件默认使用utf-8编码，这就使得以下代码是合法的：中国 = 'china',print(中国)
#在python 3.x中/除法不再这么做了，对于整数之间的相除，结果也会是浮点数。2中1 / 2=0;3中1/2=0.5
#Python 2.x中不等于有两种写法 != 和 <>
#Python 3.x中去掉了<>, 只有!=一种写法，还好，我从来没有使用<>的习惯
#多线程
#Python中使用线程有两种方式：函数或者用类来包装线程对象。
#函数式：调用thread模块中的start_new_thread()函数来产生新线程。
#!/usr/bin/python
# -*- coding:UTF-8 -*-
#多线程
#Python中使用线程有两种方式：函数或者用类来包装线程对象。
#函数式：调用thread模块中的start_new_thread()函数来产生新线程。
import time
import thread
import threading
def print_time(threadName,delay):
for i in range(1,5,1):
print i
time.sleep(delay)
print ""+threadName + str(time.localtime())
try:
thread.start_new_thread(print_time,("thread1",2, ))
thread.start_new_thread(print_time,("thread2",2, ))
time.sleep(20)#注，不写这一句会报错，因为没设置守护线程，执行完主线程后会报错
except:
print "Error: unable to start thread"
#线程模块：Python通过两个标准库thread和threading提供对线程的支持。thread提供了低级别的、原始的线程以及一个简单的锁。
#threading 模块提供的其他方法：
#threading.currentThread(): 返回当前的线程变量。run(): 用以表示线程活动的方法。start():启动线程活动。
#join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
#getName(): 返回线程名。setName(): 设置线程名。
def music(func):
for i in range(2):
print "I was listening to %s. %s" %(func,time.ctime())
time.sleep(1)
def move(func):
for i in range(2):
print "I was at the %s! %s" %(func,time.ctime())
time.sleep(5)
threads = []
t1 = threading.Thread(target=music,args=(u'爱情买卖',))
threads.append(t1)
t2 = threading.Thread(target=move,args=(u'阿凡达',))
threads.append(t2)
if __name__ == '__main__':
for t in threads:
t.setDaemon(True)
t.start()
t.join()
print "ssss"
#setDaemon(True)将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。
# 子线程启动后，父线程也继续执行下去，当父线程执行完最后一条语句print "all over %s" %ctime()后，没有等待子线程，直接就退出了，同时子线程也一同结束。
#只对上面的程序加了个join()方法，用于等待线程终止。join（）的作用是，在子线程完成运行之前，这个子线程的父线程将一直被阻塞。
#join ()方法：主线程A中，创建了子线程B，并且在主线程A中调用了B.join()，那么，主线程A会在调用的地方等待，直到子线程B完成操作后，
# 才可以接着往下执行，那么在调用这个线程时可以使用被调用线程的join方法。
#setDaemon()方法。主线程A中，创建了子线程B，并且在主线程A中调用了B.setDaemon(),这个的意思是，把主线程A设置为守护线程，这时候，要是主线程A执行结束了，就不管子线程B是否完成,
# 一并和主线程A退出.这就是setDaemon方法的含义，这基本和join是相反的。
# 此外，还有个要特别注意的：必须在start() 方法调用之前设置，如果不设置为守护线程，程序会被无限挂起。
#json
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import json
#json.dumps 用于将 Python 对象编码成 JSON 字符串。
data = {"name":"yzh","age":18}
print json.dumps(data)
#json.loads 用于解码 JSON 数据。该函数返回 Python 字段的数据类型。
str = '{"age": 18, "name": "yzh"}'
maptext = json.loads(str)
for key in maptext:
print key
print maptext[key]
#unittest
#针对发现做一个测试框架实例
#如何写接口测试用例
#python高级，包括一些框架，算法的使用
#用java 实现全套上述逻辑，并学习写代码覆盖率
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import practice;
practice.add("ssssssssssss")
#try:
#
#except Exception,err:
#
#else:
#
#python面向对象
class Employee:
count = 0;
def __init__(self,name,salary):
self.name = name;
self.salary = salary;
Employee.count += 1
def displaycount(self):
print Employee.count;
emp1 = Employee("Zara",2000);
emp2 = Employee("Manni",5000);
emp1.displaycount()
#继承
class Employer(Employee):
def __init__(self,name,salary):
self.name = name;
self.salary = salary;
Employee.count += 1
def displaycount(self):
print "子类方法"
emper = Employer("ss",3455)
emper.displaycount()
#反转英文句子
def reverseFun1(str):
lists = list(str.split(' '))
print lists
lists.reverse()
print " ".join(lists)
return;
strr = " i am a girl ";
reverseFun1(strr)
