#!/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)