#!/usr/bin/python# -*- coding: UTF-8 -*-import timeimport 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 list1print list2print 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 aListaList.extend(["455",234])print aList

#python字符串比较a="ssd"b="ssd"print a==bprint 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()

#timeprint 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 timeimport threadimport 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)