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 = "1234"
print(id(str7))
str7 = "1234"
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"] = "13712345678"
dict1["phone"] = "15923423455"
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("123")
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": "10001", "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 = "1234"
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 = "123123123123"
print(y.replace("12", "AB"))
print(y.replace("12", "AB", 1))
print(y.replace("12", "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", "123456", "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":"123456"})
data = data.encode("UTF-8")
resp = urllib.request.urlopen("http://localhost:8080/login", data)
print(resp.read().decode("UTF-8"))

# 带Header
header = {
    "POSID": "1010101"
}
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":"123", "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))

感想

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

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