Python3练习

Hello Python3

 print("Hello Python!")
 #print("Hello, Python!");
 '''a=1
 b=2
 c=a+b
 print(c)
 '''

 #列表：存储多个元素的东西，列表里面的元素是可以重新赋值的
 a=[1,"a"]
 a[0]=2
 #元组：存储多个元素的东西，元组里面的元素不可用重新赋值
 b=(1,"b")
 #字典
 #{key1:value1, key2:value}
 #集合
 #去重

 #if语句
 a=10
 b=1
 if(a > 9):
     print(a)
     if(b < 9):
         print(b)

 age=18
 if(age <= 10):
     print("儿童")
 elif(age > 10 and age <= 20):
     print("青少年")
 elif(age > 20):
     print("青年")
 else:
     print("小伙子")

 #while语句
 a=0
 while(a<10):
     print("hello")
     a += 1

 #for语句：遍历列表
 a=["aa", "bb", "cc", "dd"]
 for i in a:
     print(i)
 #for语句：常规循环
 for i in range(0, 10):
     print(i)
 for i in range(0, 10):
     print("AAA")
 #中断退出：continue，break
 for i in a:
     if(i=="cc"):
         break
     print(i)
 for i in a:
     if(i=="cc"):
         continue
     print(i)
 #乘法口诀
 #end=""表示不换行输出
 for i in range(1, 10):
     for j in range(1, i+1):
         print(str(i) + "*" + str(j) + "=" + str(i*j), end=" ")
     print()
 print("-----------------------")
 for i in range(9, 0, -1):
     for j in range(1, i+1):
         print(str(i) + "*" + str(j) + "=" + str(i*j), end=" ")
     print()

 '''
 #作用域
 i=10
 def func():
     j=20
     print(j)
 print(j)
 '''

 #函数
 #函数定义格式：
 #def 函数名(参数):
 #   函数体

 def abc():
     print("abcdef")
 #调用函数：函数名(参数)
 abc()

 def func2(a, b):
     if(a > b):
         print("a>b")
     else:
         print("a<=b")
 func2(1,2)
 func2(5,4)

 #模块导入
 import cgi
 cgi.closelog()
 from cgi import closelog

 #文件操作
 #打开  open(文件路径, 操作形式)
 '''
 w:写
 r:读
 b:二进制
 a:追加
 '''
 file = open("D:/python/1.txt", "r")
 data=file.read()
 print(data)
 data=file.readline()
 print(data)
 file.close()
 #文件写入
 data2="一起学python"
 file2=open("D:/python/2.txt", "w")
 file2.write(data2)
 file2.close()
 data2="Java"
 file2=open("D:/python/2.txt", "a+")
 file2.write(data2)
 file2.close()

 #异常处理
 try:
     a = 1 / 0
 except Exception as ex:
     print(ex)

 #类
 class User:
     def __init__(self):
         print("无参构造函数")
 a=User()

 class Person:
     def __init__(self, name, age):
         print("带参数的构造函数，name=" + name + ", age=" + age)
 c1=Person("zhangsan", str(20))
 c2=Person("lisi", str(22))

 class Rabbit:
     def __init__(self, name, color):
         self.name = name
         self.color = color
     def func1(self):
         print("aaa");
     def func2(self, age):
         print("这个兔子已经" + str(age) + "岁了")
     def toString(self):
         print("Rabbit [name=" + self.name + ", color=" + self.color + "]")
 r1 = Rabbit("流氓兔", "白色")
 r1.func1()
 r1.func2(3)
 r1.toString()

 #继承
 class Father():
     def write(self):
         print("写作")
 class Son(Father):
     pass
 class Mother():
     def draw(self):
         print("画画")
     def makeDinner(self):
         print("做饭")
 class Daughter(Father, Mother):
     def draw(self):
         print("素描")
 son = Son()
 son.write()
 daughter = Daughter()
 daughter.write()
 daughter.draw()
 daughter.makeDinner()

 print("Hello\n" * 3)

 #str是关键字是函数名不能随便用
 tmp = input("请输入一个数字：")
 print(tmp)

 #递归
 def factorial(n):
     if(n == 1):
         return 1
     else:
         return n * factorial(n-1)
 number = int(input("请输入一个正整数："))
 result = factorial(number)
 print("%d的阶乘是%d"%(number, result))

 def fab(n):
     if(n == 1 or n == 2):
         return 1
     else:
         return fab(n-1) + fab(n-2)
 number = int(input("请输入一个正整数："))
 result = fab(number)
 print("总共" + str(result) + "对兔子")

数据类型以及传参

 # 数据类型
 num = 123
 print(type(num))
 f = 2.0
 f = 5.0 / 2
 print(f)
 str1 = 'hello world'
 print(str1)
 str2 = "hello world"
 print(str2)
 str3 = "hello \"world\""
 str4 = "hello 'world'"
 print(str3)
 print(str4)
 str5 = "Jack: \nI love you"
 print(str5)
 mail = """
 Rose:
     I'am Jack
     goodbye
 """
 print(mail)
 str6 = "abcdef"
 print(str6[0])
 print(str6[1])
 print(str6[0] + str6[1])
 print(str6[1:4])
 print(str6[4:])
 print(str6[:4])
 print(str6[2:])
 print(str6[::2])
 print(str6[-1])
 print(str6[-4:-1])
 str7 = ""
 print(id(str7))
 str7 = ""
 print(id(str7))

 # 元组
 t = ("Jack", 19, "male")
 print(t)
 print(t[0])
 print(type(t))
 t2 = (3,)
 print(type(t2))
 print(len(t2))
 print(len(str6))
 a,b,c=(1,2,3)
 print(a)
 print(b)
 print(c)
 a,b,c=t
 print(a)
 print(b)
 print(c)

 # 列表
 list1 = ["jack", 21, True, [1,2,3]]
 print(list1[0])
 print(type(list1))
 print(list1[3])
 print(len(list1))
 list1[0]="rose"
 list1[1]="jerry"
 print(list1)
 list1.append(3)
 print(list1)
 list1.remove(3)
 del(list1[2])
 print(list1)
 list2 = [1,2,3]
 list2.append(4)

 # 查看帮助
 help(list)
 help(list.remove)
 help(len)

 # 字典
 dict1 = {"name":"jack", "age":25, "gender":"male"}
 print(dict1["name"])
 print(dict1.keys())
 print(dict1.values())
 dict1["phone"] = ""
 dict1["phone"] = ""
 print(dict1)
 del dict1["phone"]
 print(dict1)
 print(dict1.pop("age"))

 # 条件语句
 if 1 < 2:
     print(1234)
 if(2 > 1):
     print("hhh")
 if(True):
     print("ok")
 if(1+1):
     print("yes")

 # for循环
 print(range(1,10))
 print(range(1, 10, 2))
 print(range(5))
 arr = ['a', 'b', 'c', 'd']
 for i in arr:
     print(i)
 for i in range(len(arr)):
     print(arr[i])
 num = 0
 for i in range(101):
     num += i
 print(num)

 for i in range(3):
     print(i)
 else:
     print("finish")

 # 遍历字典
 d = {1:111, 2:222, 3:333}
 for x in d:
     print(d[x])
 for k,v in d.items():
     print(k)
     print(v)
 d2 = {"name":"zhangsan", "age":20}
 for k,v in d2.items():
     print(k)
     print(v)

 # 函数
 def func():
     print("")
 func()

 def func2(x, y):
     print(x)
     print(y)
 func2(3,4)

 # 参数的默认值
 def func3(x=5,y=6):
     print("x=" + str(x) + ", y=" + str(y))
 func3()
 func3(7,8)

 def func4(x, y=9):
     print("x=" + str(x) + ", y=" + str(y))
 func4(10)
 func4(11, 12)

 def func5():
     x = input("Please Enter A Number: ")
     print(x)
 func5()

 def func6():
     global a
     a = "good"
 func6()
 print(a)

 # 传参：元组
 # 传元组
 def f(x,y):
     print("x=%s, y=%s" % (x,y))
 f(1,2)
 f(*(3,4))
 t = ("Tom", "Jerry")
 f(*t)

 def f1(x, y):
     print("x=%s, y=%s" % (x, y))
 t = (20, "Jack")
 f1(*t)

 # 传字典
 def f2(name, code, age):
     print("name=%s, code=%s, age=%s" % (name, code, age))
 d = {"name": "zhangsan", "code": "", "age": 22}
 f2(**d)
 d["age"] = 28
 f2(**d)
 f2(d["name"], d["code"], d["age"])

 # 参数冗余
 # 多余的实参
 def f3(x, *args):
     print(x)
     print(args)
 f3(1)
 f3(1,2)
 f3(1,2,3,4)
 def f4(x, *args, **kwargs):
     print(x)
     print(args)
     print(kwargs)
 f4(1)
 f4(1, 2)
 f4(1, 2, 3)
 f4(1, y=3, z=4)
 f4(1, **d)
 f4(1, 2, 3, 4, y=6, z=7, xy=8)

 # lambda表达式
 f6 = lambda x,y:x*y
 print(f6(3, 4))

内置函数

 # Python内置函数
 print(abs(2))
 print(abs(-2))
 r = range(11)
 print(max(r))
 print(min(r))
 print(max([3,2,1,9]))
 print(len(r))
 print(divmod(5,3))
 print(pow(2,10))
 print(round(2.5))
 print(type(r))
 a = ""
 print(int(a))
 b = 99
 print(str(b))
 print(hex(b))
 print(list([1,2,3,4]))

 # 字符串函数
 # str.capitalize()  首字母大写
 # str.replace()     字符替换
 # str.split()       分割
 help(str.capitalize)
 help(str.replace)
 help(str.split)
 s = "hello"
 print(s.capitalize())
 y = ""
 print(y.replace("", "AB"))
 print(y.replace("", "AB", 1))
 print(y.replace("", "AB", 2))
 ip = "192.168.12.93"
 print(ip.split("."))
 print(ip.split(".", 1))
 print(ip.split(".", 2))

 # 序列处理函数
 help(filter)
 help(zip)
 help(map)
 from functools import reduce
 help(reduce)
 def f1(x):
     if(x > 0):
         return True
     return False
 r = [1,2,-1,-2,0,3]
 ss = filter(f1, r)
 print(ss)
 print(list(filter(lambda x:x%2==0, range(10))))

 result = filter(lambda x:x*2, [1, 2, 3, 4, 5])
 print(result)
 print(list(result))
 print(list(filter(lambda x: x%2 == 0, range(8))))

 # 这里的map函数和reduce函数就相当于MapReduce中的Map阶段和Reduce阶段
 # Map阶段计算，Reduce阶段合并结果
 foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
 print(list(filter(lambda x:x % 3 == 0, foo)))
 print(map(lambda x:x*2+10, foo))
 print(list(map(lambda x:x*2+10, foo)))
 print(reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]))
 print(reduce(lambda x, y: x*y, range(1, 6)))
 print(reduce(lambda x,y:x+y, foo))

 t1 = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
 t2 = ["北京", "上海", "广州", "深圳"]
 t3 = [20, 21, 22, 23]
 res = zip(t1, t2, t3)
 print(list(res))

 '''
         包
 Python的模块可以按目录组织为包
 创建一个包的步骤是：
 1、建立一个名字为包名字的文件夹
 2、在该文件夹下创建一个__init__.py文件
 3、根据需要在该文件夹下存放脚本文件、已编译扩展及子包
 4、import pack.m1, pack.m2, pack.m3

         模块
 模块是Pyhon组织代码的基本方式
 Pyhon的脚本都是用扩展名为py的文本文件保存的，一个脚本可以单独运行，
 也可以导入另一个脚本中运行。当脚本被导入运行时，我们将其称为模块（module）

 模块名与脚本的文件名相同（例如，我们编写了一个名为items.py的脚本，则可以在另一个脚本中用import items语句来导入它）

 '''

正则表达式

 # 正则表达式
 # 参考菜鸟教程 http://www.runoob.com/python3/python3-reg-expressions.html
 import re
 print(re.match('www', 'www.baidu.com'))
 print(re.match('www', 'www.baidu.com').span(0))
 print(re.match('com', 'www.baidu.com'))

 line = "Cats are smarter than dogs"
 matchObj = re.match(r'(.*) are (.*?) .*', line, re.M|re.I)
 if matchObj:
     print(matchObj.group())
     print(matchObj.group(1))
     print(matchObj.group(2))
 else:
     print("No match!!!")

 print(re.search('www', 'www.baidu.com').span())
 print(re.search('com', 'www.baidu.com').span())

 # re.match与re.search的区别
 # re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
 # 而re.search匹配整个字符串，直到找到一个匹配。

 line = "Cats are smarter than dogs"

 # 简单地来说，re.match看的是字符串是不是以指定的正则表达式开头的
 matchObj = re.match(r'dogs', line, re.M|re.I)
 if matchObj:
     print("match --> matchObj.group(): ", matchObj.group())
 else:
     print("No match!!!")

 matchObj = re.search(r'dogs', line, re.M|re.I)
 if matchObj:
     print("search --> matchObj.group(): ", matchObj.group())
 else:
     print("No match!!!")

 # 检索和替换
 # re.sub用于替换字符串中的匹配项
 #
 # 语法：re.sub(pattern, repl, string, count=0)
 # 参数：
 #   pattern : 正则中的模式字符串。
 #   repl : 替换的字符串，也可为一个函数。
 #   string : 要被查找替换的原始字符串。
 #   count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

 phone = "2004-959-559 # 这是一个电话号码"
 num = re.sub(r'#.*$', "", phone)
 print("电话号码：", num)

 num = re.sub(r'\D', "", phone)
 print("电话号码：", num)

 # compile函数
 # compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
 # 语法：re.compile(pattern[, flags])

 pattern = re.compile(r'\d+')
 m = pattern.match('one1two2three3four4')
 print(m)
 m = pattern.match('one1two2three3four4', 3, 10)
 print(m)
 print(m.group())
 print(m.start())
 print(m.end())
 print(m.span())
 # group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
 # start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
 # end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
 # span([group]) 方法返回 (start(group), end(group))。

 # findall
 # 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
 #
 # 注意： match 和 search 是匹配一次 findall 匹配所有。

 # 语法：findall(string[, pos[, endpos]])
 # 参数：
 #   string  待匹配的字符串
 #   pos 可选参数，指定字符串的起始位置，默认为0
 #   endpos  可选参数，指定字符串的结束位置，默认为字符串的长度

 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+", "12a23bce34fj666")
 for match in it:
     print(match.group())

 # re.split
 # split 方法按照能够匹配的子串将字符串分割后返回列表
 # 语法：re.split(pattern, string[, maxsplit=0, flags=0])

 print(re.split('\W+', 'abc, runoob, wahaha, 1342'))
 print(re.split('(\W+)', 'abc, runoob, wahaha, 1342'))
 print(re.split('\W+', 'abc, runoob, wahaha, 1342', 1))
 print(re.split('a+', 'hello world'))# 对于一个找不到匹配的字符串而言，split 不会对其作出分割

文件操作

 # 文件读写
 f = open("D:/python/a.txt","r")
 print(f.readline())
 txt = f.read()
 print(txt)
 f.close()
 ## f.read()

 f = open("D:/python/a.txt","r")
 for line in f:
     print(line)
 f.close()

 f = open("D:/python/b.txt","w+")
 f.write("I am Mr.Cheng")
 f.write("Very Good!")
 print(f.read())
 f.flush()
 f.seek(0)
 print(f.read())
 f.close()

 f = open("D:/python/b.txt","a+")
 f.write("\nhot")
 f.seek(0)
 print(f.read())
 f.close()

异常处理

 # finally
 try:
     ff = open("D:/python/b.txt","a+")
 except Exception:
     print(1)
 finally:
     ff.close()
     print(2)

 try:
     f = open("abc.txt")
     f.close()
 except (OSError, RuntimeError, TypeError, NameError):
     pass

 try:
     f = open("abc.txt")
     f.close()
 except OSError as err:
     print("OSError")
 except ValueError:
     print("ValueError")
 except NameError:
     print("NameError")
 except:
     print("Unexpected Error")

 # raise 抛出异常
 try:
     x = int(input("Please enter a number: "))
     if(x == 123):
         raise NameError("You are kidding!")
 except NameError:
     print("name error")
 except ValueError:
     print("value error")
 except TypeError:
     print("type error")
 finally:
     print("Goodbye")

类和对象

 # 类和对象
 class MyClass:
     i = 123

     def m(self):
         return 'hello'

 x = MyClass()

 print(x.i)
 print(x.m())

 # __init__()是构造方法
 class Person:

     name = ""
     age = 0

     def __init__(self):
         print("无参构造方法被调用")

     def __init__(self, name, age):
         print("带参数的构造法被调用")
         self.name = name
         self.age = age

     def toString(self):
         print("Person [name={0}, age={1}]".format(self.name, self.age))

 person = Person("zhangsan", 25)
 person.toString()

 print(id(person))

 # self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数
 # self相当于Java中的this
 # 类的方法必须有一个额外的第一个参数，按照惯例它的名称是 self

 class Employee:

     empCount = 0

     def __init__(self, name, salary):
         self.name = name
         self.salary = salary
         Employee.empCount += 1

     def displayCount(self):
         print("Total Employee %d" % Employee.empCount)

     def toString(self):
         print("wahaha")

 employee1 = Employee("zhangsan", 27)
 employee2 = Employee("lisi", 28)
 employee3 = Employee("wangwu", 29)
 print(Employee.empCount)
 print(employee1.displayCount())
 print(employee2.name)
 print(employee3.salary)
 print(Employee.__name__)
 print(Employee.__module__)

 # 继承
 class Leader(Employee):
     def __init__(self):
         print("调用子类的构造方法")

 leader = Leader()
 leader.toString()

 class Father:
     def sing(self):
         print("我会唱歌")
     def write(self):
         print("我擅长写粉笔字")

 class Mother:
     def dance(self):
         print("我会跳舞")

 class Son(Father, Mother):
     def draw(self):
         print("我会画画")
     def write(self):
         print("我擅长写毛笔字")

 son = Son()
 son.sing()
 son.dance()
 son.draw()
 son.write()

 # 两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs
 # 两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods
 class Daughter:

     name = ""   # public属性
     _height = 0 # protected属性
     __age = 0   # private属性

     def __init__(self, name, height, age):
         self.name = name
         self._height = height
         self.__age = age

     def getName(self):  # public
         return self.name

     def __getAge(self): # private
         return self.__age

     def getAge(self):
         return self.__age

 daughter = Daughter("Alice", 170, 24)
 print(daughter.name)
 print(daughter._height)
 #print(daughter.__age)
 #print(daughter.__getAge())
 print(daughter.getAge())

MySQL操作

 import pymysql
 '''
 # 建立连接
 conn = pymysql.connect("localhost", "root", "123456", "mytest")
 # 获取游标
 cursor = conn.cursor()
 # SQL语句
 #sql = "insert into user_info(name, family, sword) values('蓝忘机', '姑苏蓝氏', '避尘')"
 sql = "insert into user_info(name, family, sword) values('%s', '%s', '%s')" % ('魏无羡', '云梦江氏', '随便')
 try:
     # 执行SQL
     cursor.execute(sql)
     # 提交
     conn.commit()
 except:
     # 回滚
     conn.rollback()
 finally:
     # 关闭连接
     conn.close()

 # 批量插入
 conn = pymysql.connect("localhost", "root", "123456", "mytest")
 cursor = conn.cursor()
 sqlTemplate = "insert into user_info(name, family, sword) values('%s', '%s', '%s')"
 dataList = [('江澄', '云梦江氏', '三毒'), ('蓝曦臣', '姑苏蓝氏', '朔月'), ('金子轩', '兰陵金氏', '岁华')]
 try:
     # 方式一：使用execute
     for data in dataList:
         sql = sqlTemplate % data
         cursor.execute(sql)

     # 方式二：使用executemany
     insertTemplate = "insert into user_info(name, family, sword) values(%s, %s, %s)"
     dataArray = [('江澄', '云梦江氏', '三毒'), ('蓝曦臣', '姑苏蓝氏', '朔月'), ('金子轩', '兰陵金氏', '岁华')]
     cursor.executemany(insertTemplate, dataArray)

     conn.commit()
 except Exception as ex:
     print(ex)
     conn.rollback()
 finally:
     conn.close()
 '''
 # 查询
 # Python查询Mysql使用 fetchone() 方法获取单条数据, 使用fetchall() 方法获取多条数据。
 # fetchone(): 该方法获取下一个查询结果集。结果集是一个对象
 # fetchall(): 接收全部的返回结果行.
 conn = pymysql.connect("localhost", "root", "", "mytest")
 cursor = conn.cursor()  # 隐式开启事务
 sql = "select * from user_info"
 try:
     cursor.execute(sql)     # 返回受影响的行数
     records = cursor.fetchall()
     for row in records:
         print(row)
     for row in records:     # 数组的元素是元组
         print("name=%s, family=%-3s, sword=%4s" % (row[0], row[1], row[2]))
 except:
     print("Error: unable to fetch data")
 finally:
     conn.close()

Socket编程

 import socket
 import sys

 # 创建socket对象
 serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

 # 绑定端口
 # #host = socket.gethostname()

 host = "localhost"
 port = 9999
 serverSocket.bind((host, port))

 # 设置最大连接数
 serverSocket.listen(5)

 # 监听客户端连接
 while True:
     print(1234)
     clientSocket, addr = serverSocket.accept()
     print("客户端连接: %s" % str(addr))
     msg = "Hello World"
     clientSocket.send(msg.encode("utf-8"))
     clientSocket.close()

 import socket
 import sys

 clientSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 print(4455)
 clientSocket.connect(("localhost", 9999))

 msg = clientSocket.recv(1024)

 print(msg.decode("utf-8"))

线程

 import threading
 import time

 '''
     相当于
     class MyThread extends Thread {
         public Integer threadId;
         public String threadName;

         public MyThread(Integer threadId, String threadName) {
             this.threadId = threadId;
             this.threadName = threadName;
         }

         @Override
         public void run() {
             System.out.print(this.threadName + " : " + new Date());
         }
     }

     Thread thread1 = new MyThread();
     Thread thread2 = new MyThread();
     thread1.start();
     thread2.start();
 '''

 class MyThread(threading.Thread):

     def __init__(self, threadId, threadName):
         threading.Thread.__init__(self)

         self.threadId = threadId
         self.threadName = threadName

     def run(self):
         print("启动线程：" + self.name)
         self.do_something()

     def do_something(self):
         print("%s: %s" % (self.threadName, time.ctime(time.time())))

 thread1 = MyThread(1, "Thread-1")
 thread2 = MyThread(2, "Thread-2")

 thread1.start()
 thread2.start()

 print("****************************************")

 # 相当于synchronized代码块
 threadLock = threading.Lock()

 class Ticket:
     __total = 100

     def decr(self):
         threadLock.acquire()
         time.sleep(1)
         if self.__total > 0:
             self.__total = self.__total - 1
             print("成功售出一张票，剩余%s张" % self.__total)
         else:
             print("今日已售罄")
         threadLock.release()

 class Customer(threading.Thread):
     def __init__(self, ticket):
         threading.Thread.__init__(self)
         self.ticket = ticket

     def run(self):
         self.ticket.decr()

 ticketObj = Ticket()
 for i in range(150):
     consumer = Customer(ticketObj)
     consumer.start()

HTTP请求

 import urllib.request
 import urllib.parse
 import requests

 resp = urllib.request.urlopen("http://www.baidu.com/")
 html = resp.read().decode("utf-8")
 print(html)

 # GET
 resp = urllib.request.urlopen("http://localhost:8080/sayHello?name=zhangsan")
 print(resp.status)
 print(resp.read().decode("UTF-8"))

 # POST
 data = urllib.parse.urlencode({"username": "lisi", "password":""})
 data = data.encode("UTF-8")
 resp = urllib.request.urlopen("http://localhost:8080/login", data)
 print(resp.read().decode("UTF-8"))

 # 带Header
 header = {
     "POSID": ""
 }
 req = urllib.request.Request("http://localhost:8080/login", data, header)
 resp = urllib.request.urlopen(req)
 print(resp.read().decode("UTF-8"))

 # requests
 # GET
 response = requests.get("http://localhost:8080/sayHello", "name=zhangsan")
 print(response.status_code)
 print(response.headers)
 print(response.headers["Content-Type"])
 print(response.encoding)
 print(response.text)

 # POST
 # 类似jQuery
 # response = requests.post("http://localhost:8080/login", {"username":"lisi","password":"123456"})
 response = requests.post("http://localhost:8080/login", "username=lisi&password=123456")
 if response.status_code == 200:
     print(response.text)
     print(response.json())

 # 带headers
 url = "http://localhost:8080/login"
 data = "username=lisi&password=123456"
 headers = {"id":"", "name": "abc"}
 response = requests.post(url, data, headers=headers, timeout=3)
 if response.status_code == 200:
     print(response.text)
     print(response.json())

JSON

 import json

 # Python中的json库提供的主要功能是在字典和JSON之间做转换
 # json.dumps(): 转成JSON
 # json.loads(): JSON字符串转字典

 data_list = [1, 2, 'a', 'b', True, [4, 5, 6]]
 json_str = json.dumps(data_list)
 print(json_str)

 data2 = {'name': 'zhangsan', 'age': 25}
 json_str2 = json.dumps(data2)
 print("原对象：", data2)
 print("JSON对象：", json_str2)

 data3 = '{"a":"b"}'
 json_str3 = json.loads(data3)
 print("原对象：", data3)
 print("字典对象：", json_str3)
 print()

日期时间

 import time
 from datetime import date
 from datetime import datetime
 from datetime import timedelta
 import calendar

 # time
 print("当前时间戳：", time.time())
 print("本地时间：", time.localtime(time.time()))
 print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
 # 日历
 cal = calendar.month(2018, 8)
 print(cal)

 # date
 print(date.today())

 startDate = date(2018, 6, 1)
 endDate = date(2018, 8, 5)
 print(startDate)
 print(endDate)
 diff = endDate - startDate
 print(diff.days)
 # print(diff.seconds)

 # datetime
 print(datetime.now())
 dt = datetime(2018, 8, 5, 19, 22, 18)
 print(dt)

 # 加3天
 print(dt + timedelta(3))
 # 减5天
 print(dt + timedelta(-5))
 # 加1小时
 print(dt + timedelta(hours=1))
 # 减2小时
 print(dt + timedelta(hours=-2))
 # 加25分钟
 print(dt + timedelta(minutes=25))
 # 减10分钟
 print(dt + timedelta(minutes=-10))

感想

 解决问题的思路才是关键，编程语言只是语法不同而已。

习惯性以分号结尾；哈哈哈！！！