python学习笔记

最新推荐文章于 2024-07-23 16:23:28 发布

瓶中怪

最新推荐文章于 2024-07-23 16:23:28 发布

阅读量573

点赞数 2

分类专栏： python 文章标签： python 安装语法 2.7

本文链接：https://blog.csdn.net/qq_24696571/article/details/97382689

版权

python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

?基于python2.7

?基本数据类型 ?运算符 ?条件语句 ?循环 ?模块 ?函数 ?异常 ?IO流与文件操作 ?面向对象 ?数据库操作 ?socket网络编程 ?邮件发送 ?json的使用 ?日期时间

python安装

windows下安装

安装包
安装后目录
配置path环境变量 , 值为根目录和根目录下scripts目录
终端查看是否安装成功

命名规则

python命名规范和java不同 . 大致总结为类名命名时使用驼峰命名 , 全局变量名全部大写 , 其他全部小写

基本数据类型

字符串

# -*- coding:utf-8 -*-
#  ← 输出中文字符需要改设置

# ← 单行注释
"""
↑↓多行注释
"""

print '你好'

# (1) . 单引号,双引号和三引号

strr = "he""llo"
print "双引号:"+strr   # 双引号hello

strr = 'world'
print '单引号:'+strr   #单引号:world

# 三引号会保留原有的格式
strr="""
    SELECT * 
    FROM T_USER 
    WHERE id = 1
"""
print '三引号:'+strr

strr = (
    "s"
    "t"
    "r"
)
print(strr) # str

# (2). 内置函数
# 2.1 替换 replace()
strr2 = 'hello'
strr2 = strr2.replace('o',"o world!!");
print(strr2) # hello,world!!

# 2.2 切分 spilit()
strr2 = strr2.split(' ')
print strr2     # ['hello', 'world!!']
print strr2[0]  # hello

# 2.3 查找 , 返回下标(不存在返回-1) find()
strr2 = strr2[0].find('o')
print(strr2) # 4

# (3) 字符串拼接
name="张三"
sex=0
age=0

# 3.1普通拼接
# str(111) : 将数值转换字符串
print "select id from where name='" + name + "' and sex=" + str(sex) + " and age=" + str(age) + " ..."
# select id from where name='张三' and sex=0 and age=0 ...

# 3.2占位符赋值
# 占位符有序传参
# %s : 字符串 %d:整型 %f:浮点型
print "select id from where name='%s' and age=%d and sex=%d ..." %(
    name,
    age,
    sex
)
# select id from where name='张三' and sex=0 and age=0 ...

# 3.3 key-value赋值 , 常用
print "select id from where name='{name}' and age={age} and sex={sex} ...".format(
    name=name,
    age=age,
    sex=sex,
)
# select id from where name='张三' and sex=0 and age=0 ...

# (4) 字符串下标
#左闭右开
strr = "today is good day!!"
# 取下标1的字符
print(strr[1]) # o
# 取下标1开始到5结束 左闭右开
print(strr[2:5]) #day
#取下标0开始到5结束 左闭右开
print(strr[:5]) #today
# 取下标5开始到最后结束
print(strr[5:]) # is good day!!
# 倒数第2个字符到正数第19个字符(下标为18)
print(strr[-2:19]) #!!

print strr[:] # 相当于print strr

数值类型和布尔类型

# -*- coding:utf-8 -*-

# 1. 数值类型

#整形
i = 1
print(i) # 1

# 长整形
l = 1L
print(l)
# 类型判断 type()
print(type(i)) #<type 'int'>
print(type(l)) #<type 'long'>

# 浮点型
f1 = 1.0
f2 = .4 # = 0.4
print(f1,f2) #(1.0, 0.4)

# 复数 , 复数是由一个实数和一个虚数组合构成
complexx = 1j
print(complexx) #1j

complexx=123-12j
print(complexx.real) #实数: 123.0
print(complexx.imag) #虚数: -12.0

# 2. 布尔类型
b_true = True
print(b_true) # True

b_false = False
print(b_false) # False

元组

# -*- coding:utf-8 -*-
"""
元组：定长、内容不可变、元素类型多样
"""

# (1) .声明元组
t = ()
# 声明单个元素时需要逗号
t = (1,)
print(t) #(1,)

t=(1,'a',2L ,True)
print(t) #(1, 'a', 2L, True)

# (2) . 操作元组
t2 = (2 , )
# 2.1 元组的长度
# len() : 返回参数的长度
print("元组的长度:"+str(len(t2))) #元组的长度:1

## 2.2 元组扩大3倍 , 元素复制3份组成元组
tup = (1, "a", 1L, 1.2)
print tup * 3 #(1, 'a', 1L, 1.2, 1, 'a', 1L, 1.2, 1, 'a', 1L, 1.2)

# 2.3 元组的拼接
tup = (1, "a", 1L, 1.2)
print t2 + tup  #(2, 1, 'a', 1L, 1.2)

# 2.4 判断元素是否在元组中
print( 1 in tup) #True

# 2.5 遍历元组
for x in tup:
    print( "元素:" + str(x))


# (3) 元素子集
tup = (1, "a", 1L, 1.2)
#元组获取子集
print tup[1]  #a
print tup[1:3] #('a', 1L)
print tup[1:] #('a', 1L, 1.2)
print tup[:3] #(1, 'a', 1L)
print tup[:-1] #(1, 'a', 1L)

list列表

# -*- coding:utf-8 -*-

"""
list列表：队列结构、可变长度、元素的数据类型多样
"""

# (1)声明列表
# 声明列表
listt = ["A",True,1,1L]
print(type(listt)) #<type 'list'>
print(listt) #['A', True, 1, 1L]

# (2)操作列表
# 2.1 列表的长度
print( "列表长度:"+ str(len(listt))) #列表长度:4

# 2.2 添加元素 sppend()
listt.append("append")
print(listt) #['A', True, 1, 1L, 'append']

# 2.3 删除元素
# 删除单个元素
del listt[0] # 删除下标为0的元素
print(listt) #[True, 1, 1L, 'append']

# 删除整个列表
# del listt

# 2.4修改列表元素
listt[0] = False
print(listt) #[False, 1, 1L, 'append']

# 2.5查 , 遍历列表元素
for x in listt:
    x = str(x)
    print("list列表元素:"+x)
#list列表元素:False
#list列表元素:1
#list列表元素:1
#list列表元素:append

# (3) 子集
print listt[1] #1
print listt[1:3] #[1, 1L]
print listt[1:] #[1, 1L, 'append']
print listt[:3] #[False, 1, 1L]
print listt[:-1] #[False, 1, 1L]

字典

# -*- coding:utf-8 -*-

"""
字典(类似java中的Map)：键值对结构、key唯一，数据类型多样、valuey数据类型多样
字典元素为中文输出乱码的问题解决 ; print json.dumps(字典变量名,encoding='utf-8',ensure_ascii=False)
"""
#(1) 字典声明
import json

dictt = {}
print dictt #{}
dictt = {'name': 'sxt', "sex": "男", "age": 30}
print dictt #{'age': 30, 'name': 'sxt', 'sex': '\xe7\x94\xb7'}
#取值
print dictt["sex"] #男

#(2)操作字典
# 长度
print(str(len(dictt))) # 3

# 添加元素和修改元素
# 添加和修改的区别在于添加的key值在字典中是否存在, 存在则修改, 不存在则添加
dictt["add"] = "save" #key不存在 , 添加
print(dictt) #'age': 30, 'add': 'save', 'name': 'sxt', 'sex': '\xe7\x94\xb7'}
dictt["sex"] = "girl" #key存在 , 修改
print(dictt) #{'age': 30, 'add': 'save', 'name': 'sxt', 'sex': 'girl'}

# 查询 , 遍历字典
# 1 遍历key
for key in dictt.iterkeys():
    print("key:" + key + " ,value:" + str(dictt.get(key)))
# 2
print('======================================================>>>')
for key,value in dictt.items():
    print("key:"+str(key)+" ,value:"+str(value))

# 删除元素
del dictt["add"]
print(dictt) #{'age': 30, 'name': 'sxt', 'sex': 'girl'}
# del dictt #删除字典

#清空字典的全部元素
dictt.clear()
print(dictt) #{}

运算符

# -*- coding: UTF-8 -*-

# (1) 算术运算符
print "1 + 1 = ", 1 + 1 #1 + 1 =  2

print "2 - 1= ", 2 - 1 #2 - 1=  1

print "3 * 4 = ", 3 * 4 #3 * 4 =  12

print "4 / 2 = ", 4 / 2 #4 / 2 =  2

print "4 / 2.1 = ", 4 / 2.1 #4 / 2.1 =  1.90476190476

print "11 % 2 = ", 11 % 2 #11 % 2 =  1

print "2 ** 3 = ", 2 ** 3 #2 ** 3 =  8
#取整除 - 返回商的整数部分（向下取整）
print "10 // 5.8 = ", 10 // 5.8 #10 // 5.8 =  1.0

# (2)比较运算符

print 1 == 1 #True

print 1 != 1 #False

# PEP8中废弃，不等于 - 比较两个对象是否不相等 , 这个运算符类似 != 。建议使用!=
print 1 <> 1 #False

print 3 > 2 #True

print 3 < 2 #False

print 2 >= 2 #True

print 3 <= 3 #True

# (3)赋值运算符
a = 2
print "等号赋值：", a #等号赋值： 2

a += 1
print "加等号赋值：", a #加等号赋值： 3

a -= 1
print "减等号赋值：", a #减等号赋值： 2

a *= 3
print "乘等号赋值：", a #乘等号赋值： 6

a /= 4
print "整除等号赋值：", a #整除等号赋值： 1

b = 3
b %= 2
print "取余等号赋值：", b #取余等号赋值： 1

c = 2
c **= 4
print "幂等号赋值：", c #幂等号赋值： 16

c //= 3
print "取整数等号赋值：", c #取整数等号赋值： 5

"""
(4)逻辑运算符
and:	x and y	 , 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
or :   x or y	 , 如果 x 是True或者非 0，它返回 x 的值，否则它返回 y 的计算值。
not:	not x   , 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。
"""
print 1==1 and 2==1 #False

print 1==1 or 2==1 #True
print 10-1 or 2==1 #9
print 0 or 2==1 #False

print not 1==1 #False

"""
(5)位运算符
"""
a = 60  # 60 = 0011 1100
b = 13  # 13 = 0000 1101
c = 0

#与：如果两个相应位都为1,则该位的结果为1,否则为0
# 也就是0011 1100和0000 1101 , 他们的个位0和1 , 得0 . 十位0和0,得0 . 百位1和1得1 . 千位1和1得1 ... ...
c = a & b;  # 12 = 0000 1100
print "1 - c 的值为：", c

#或：只要对应的二个二进位有一个为1时，结果位就为1
c = a | b;  # 61 = 0011 1101
print "2 - c 的值为：", c

#异或：当两对应的二进位不同时，结果为1
c = a ^ b;  # 49 = 0011 0001
print "3 - c 的值为：", c

#取反：对数据的每个二进制位取反,即把1变为0,把0变为1(注意一个字节8位,将0补齐) .
c = ~a;  # -61 = 1100 0011
print "4 - c 的值为：", c

#左移：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。
c = a << 2;  # 240 = 1111 0000
print "5 - c 的值为：", c

#右移：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
c = a >> 2;  # 15 = 0000 1111
print "6 - c 的值为：", c

"""
(6)成员运算符
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
"""
list1 = [1, False, "a", "b"]

print 'c' in list1 #False
print False in list1 #True

print 'a' not in list1 #False
print 'c' not in list1 #True

"""
(7)身份运算符
is	is 是判断两个标识符是不是引用自一个对象 , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象,如果引用的不是同一个对象则返回结果 True，否则返回 False。
"""
a = 20
b = 20

print "a与b地址相同：", a is b  #a与b地址相同： True
print "a与b地址不相同：", a is not b #a与b地址不相同： False

# 修改变量 b 的值
b = 30
print "a与b地址相同：", a is b #a与b地址相同： False
print "a与b地址不相同：", a is not b #a与b地址不相同： True

#(8)运算符优先级
a = 20
b = 10
c = 15
d = 5
e = 0

e = (a + b) * c / d
print "(a + b) * c / d 运算结果为：", e #90

e = ((a + b) * c) / d
print "((a + b) * c) / d 运算结果为：", e #90

e = (a + b) * (c / d);
print "(a + b) * (c / d) 运算结果为：", e#90

e = a + (b * c) / d;
print "a + (b * c) / d 运算结果为：", e#50

条件语句

# -*- coding:UTF-8 -*-

"""
条件语句
"""

## 单条件判断
if 2 > 1: print '2大于1'
#2大于1
print '======================'

## 多条件判断
fruit = ['苹果', '梨', '桃子']
if '白菜' in fruit:
    print '白菜是水果！'
else:
    print  '白菜不是水果！'
# 白菜不是水果！
print '======================'

order_status = 3
if order_status == 0:
    print '订单状态未支付！'
elif order_status == 1:
    print '订单状态已支付！'
else:
    print '订单状态未知！'
# 订单状态未知！

循环

# -*- coding:UTF-8 -*-
"""
循环
"""

"""
(1)for循环
"""
# -*- coding:utf-8 -*-
fruits = ['苹果', '橘子', '香蕉']
for i in fruits:
    print i,'是水果'

# range(start, stop, step)函数产生一个整数列表,左闭右开
# 从1到10
for x in range(1, 10):
    print x

# 1,3,5...9
for x in range(1,10,2):
    print(x)

"""
(2)while循环
"""
count = 1
while count < 10:
    print(count)
    count+=1
else:
    print('ending...')

"""
(3)输出1-100以内的素数
"""
l=[]
for i in range(2,101,1):
    for x in range(2,i/2+1):
       if (i%x==0):
           break
    else:
        l.append(i)
print(l)

"""
(4)求10内的偶数
"""
for i in range(1,11):
    if i % 2 != 0:
        continue
    print i

"""
(5)99乘法表
"""
# 5.1
for x in range(1,10):
    print ''
    for y in range(1,10):
        if x < y:
            continue
        print '%d*%d=%d' % (y, x, x*y),

# 5.2
print('\n'.join([' '.join(['%s*%s=%-2s' % (y,x,x*y) for y in range(1,x+1)]) for x in range(1,10)]))

模块

# -*- coding:utf-8 -*-
"""
第三方模块的安装(离线安装，不依赖网络)
1.安装程序安装
    .msi .exe 安装程序(windows)
2.源码安装(离线安装，不依赖网络)
    下载源码
    python setup.py build
    python setup.py install

3.idea安装模块（同easy_install）
    setting → project → interpreter → 右上方加号添加模块

4.使用pip安装（不解决依赖，在线安装）
    pip install mysql-python

5.使用easy_install(解决依赖，在线安装)
    easy_install mysql-python

"""

# 导入模块
import math as m # 别名
import urllib2

# 使用模块
print m.pi
print m.floor(1.2)

# 读取网站源文件
html = urllib2.urlopen("https://kyfw.12306.cn/otn/leftTicket/init?linktypeid=dc&fs=%E6%9D%AD%E5%B7%9E%E4%B8%9C,HGH&ts=%E6%B7%B1%E5%9C%B3%E4%B8%9C,BJQ&date=2019-07-26&flag=N,N,Y").read()
print html

函数

# -*- coding:UTF-8 -*-

"""
函数定义
"""
# 使用def关键字定义函数
def printme(str):
    print(str)
    print('>>>>>>>>>>>')

# 调用函数
printme("hello")

# 主函数
# if __name__ == '__main__':
#     printme('main')


"""
(2)参数的传递：
    1、必备参数
    2、关键字参数
    3、默认参数
    4、可变参数
"""
def say(name, words):
    print name + " say: " + words

# 默认参数
def call(name, content = "你拨打的电话正在通话中。。"):
    print name + " call: " + content

# 可变参数
def can_change(args, *vars):
    print args
    print vars
# 可变参数key-value
def can_change_kv(args, **kargs):
    print args
    print kargs
# 函数返回值
def callback(name) :
    return name + " like you!"
# 参数为列表和字典
def handler_collections(users, dics):
    users.append("New")
    dics['abc'] = 'abc'
    print users
    print dics

if __name__ == '__main__':
    # 传参时根据参数顺序进行传递
    # say("Hello", "Python")
    # 传参可以通过关键字进行传递（就是key-value进行传递）
    # say(words="Hello!",name="Python")

    # 测试默认参数
    #  call("Hanmeimei")
    #  call(name="Hanmeimei", content="你好")

    # 测试可变参数
    # can_change(1, 2, 3)
    # can_change_kv(1,a=1,b=2,c=3) # 1   {'a': 1, 'c': 3, 'b': 2}

    # 测试函数返回
    # print callback("Lilei")

    # 测试
    handler_collections([1,2,3], {"user":"users"})


"""
(3)匿名函数 使用lambda声明，但不推荐使用
"""

# 匿名函数
sum = lambda arg1, arg2: arg1 + arg2

# 调用匿名函数
print sum(1, 10) # 11

#函数式编程 , 参数为函数( 规则)
def a(func):
    print func(1,2)

a(sum) # 3

"""
(4)全局变量
"""
# 这是一个全局变量
total = 0

def plus( arg1, arg2):
    # total在这里是局部变量
    # global total #声明修饰的变量是全局变量
    total = arg1 + arg2
    # id() : 全局变量的id值
    print id(total)
    print"函数内是局部变量 : ", total
    return total


# 调用sum函数
if __name__ == '__main__':
    print plus(10, 20)
    print"函数外是全局变量 : ", id(total)

异常

# -*- coding:utf-8 -*-
"""
异常

(1)捕捉异常使用try...except
try:
    正常的操作
except 异常名称, 数据:
   发生以上多个异常中的一个，执行这块代码
else:
    如果没有异常执行这块代码

"""
try:
    print 1/0
except ZeroDivisionError, error:
    print error
    print "异常来了。。"
else:
    # 没有捕获异常才会执行
    print "继续执行"

print "结束。。"
print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.')

"""
(2) 不指定异常类型
try:
    正常的操作
except:
   发生以上多个异常中的一个，执行这块代码
else:
    如果没有捕获异常执行这块代码
"""

def test(list):
    try:
        print list[0]
    except :
        print "异常来了"
    print "结束。。"

# if __name__ == '__main__':
#     test(12)

"""
(3) 指定多个异常类型
try:
    正常的操作
except(Exception1[, Exception2[,...ExceptionN]]]), 数据:
   发生以上多个异常中的一个，执行这块代码
else:
    如果没有异常执行这块代码
"""

def test(list):
    try:
        print list[1]
    except(TypeError, IndexError), message:
        print "异常来了", message
    print "结束。。"

# if __name__ == '__main__':
#     test(12)

"""
(4)finally : 不论是否捕获异常都会执行
try:
<语句>
finally:
<语句>    #退出try时总会执行

"""

def test(list):
    try:
        print list[1]
    except(TypeError, IndexError), message:
        print "异常来了", message
    finally:
        print "执行finally"

# if __name__ == '__main__':
#     test(12)

"""
(5)
抛出异常,使用关键字raise
"""

def test(num):
    if num < 1:
        raise Exception("错误异常", num) # 抛出异常

# if __name__ == '__main__':
#     try:
#         test(-1)
#     except Exception, e:
#         print e


"""
(6)
异常应该是典型的继承自Exception类
"""

# 定义一个异常
class ParamException(RuntimeError):
    def __init__(self, *args):
        self.args = args

# 抛出异常
def check_params(age):
    if (age < 15):
        raise ParamException("ParamException : 年龄不能小于15") 

# 捕获异常
def register(age):
    try:
        check_params(age)
    except ParamException,error:
        print error

register(1)

IO流与文件操作

# -*- coding:utf-8 -*-

"""
文件操作
# mod:w文件操作方式 ,
# r:读取 , w:写 , a:追加 , r+:r+w(读写,文件不存在报错) , w+:r+w(读写,文件不存在创建)
# a+:a+r(可追加可读,文件不存在创建). 对应的如果操作二进制文件 , 加b : rb , wb , ab , rb+ , wb+ , ab+
"""

# (1) 读写
"""
open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
"""
def open_file(mod = 'r'):
    test = open("test02.txt", mod)
    print"文件名: ", test.name
    print"是否已关闭 : ", test.closed
    print"访问模式 : ", test.mode
    print"末尾是否强制加空格 : ", test.softspace
    return test

# with open("test.txt", "r") as test:
#     print"文件名: ", test.name
#     print"是否已关闭 : ", test.closed
#     print"访问模式 : ", test.mode
#     print"末尾是否强制加空格 : ", test.softspace

def read():
    filee = open_file("r")
    # (1)全部读出
    # print "文件内容：", filee.read()
    # (2)一行一行读取
    line = filee.readline()
    while line:
        print line
        line = filee.readline()
    filee.close()

def write():
    # w: 有覆盖，没有创建
    # wb: 二进制打开，有覆盖，没有创建
    # a: 有追加，没有创建
    # filee = open_file("wb")
    # filee = open_file("a")
    # filee = open_file("a+")
    # r+追加到前面
    filee = open_file("r+")
    filee.write("中文中文中文中文中文中文中文中文中文")

    filee.close()

# if __name__ == '__main__':
#     #open_file()
#     write()
#     # print "###################"
#     # read()

"""
(2)打开一个文件
"""
test = open("test.txt", "r")
str = test.read(10);#读取前十个
print"读取的字符串是 : ", str

# 查找当前位置
#	file.tell()返回文件当前位置。
position = test.tell();
print "当前文件位置 : ", position

# 把指针从第9个字符开始查询10个字符
#file.seek(offset[, whence])设置文件当前位置
position = test.seek(10, 1);
str = test.read(10);
print"重新读取字符串 : ", str
# 关闭打开的文件
test.close()
print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')

"""
(3)
文件操作
"""
import os
import shutil

# 文件重命名
def rename(oldname, newname):
    os.rename(oldname, newname)

# 文件重命名super
def renames(oldname, newname):
    os.renames(oldname, newname)

# 文件删除
def delete(path):
    os.remove(path)

# 创建文件夹
def mkdir(path):
    os.mkdir(path)
    # 删除文件夹
    # os.rmdir(path)

# 文件的拷贝
def copy(src, dest):
    # 复制文件
    shutil.copyfile(src, dest)
    # 复制文件到文件或者目录
    # shutil.copy(src, dest)

# 文件夹移动或者删除
def move(src, dst):
    shutil.move(src, dst)

# 删除文件夹
def rmtree(path):
    shutil.rmtree(path)


if __name__ == '__main__':
    # rename("test01.txt", "test.txt")
    # 除了改名还可以移动文件夹
    # renames("123", "test/test01.txt")
    # delete("test/test01.txt")
    # mkdir("test_01")
    # copy("test.txt", "test02_1")
    # move("test/test02", "test_01/test01.txt")
    rmtree("test_01")

面向对象

# -*- coding:utf-8 -*-
"""
面向对象

(1)创建类和类的实例化
"""
class User:
    userName = ""
    password = ""
    age = 0
    address = ""
    salary = 0.0

    # 初始化函数或者构造函数
    # self:不用给self赋值，Python会自动给他赋值，而且这个值就是类的实例--对象本身 . 可以通过self给对象的成员属性赋值
    def __init__(self, userName, password, age, address, salary):
        self.userName = userName
        self.password = password
        self.age = age
        self.address = address
        self.salary = salary

    # 自定义函数
    def display_user(self):
        print "userName:", self.userName, "password:", self.password, "age:", self.age, \
            "address:",self.address, "salary:", self.salary


# 主方法
# if __name__ == '__main__':
#     #创建对象
#     user = User(userName="zhangThree", password="123455", age=10, address="家里蹲", salary=10000.78)
#     print "薪水是：", user.salary
#     user.display_user() # 调用对象的自定义函数

"""
(2)
对象属性的操作
# hasattr('对象','属性') : 判断某个对象是否存在指定属性
# getattr('对象','属性') : 获取某个对象指定属性的值 , 对象.属性来调用是一样的
# getattr('对象','属性','值') : 给某个对象指定的属性赋予新的值
# delattr('对象','属性') : 删除某个对象的执行属性的值, 删除后赋予默认值
"""
class Employee:
    name = ""
    salary = 0.0

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary


# if __name__ == '__main__':
#     emp = Employee("liFour", 10001.01)
#     # 新增属性
#     emp.gender = 1
#     print "新增属性：", emp.gender
#
#     print "修改前：", emp.name
#     # 属性值修改
#     emp.name = 'wangFive'
#     print "修改后：", emp.name
#
#     # 删除对象
#     # del emp.gender
#     print "删除后：", emp.gender
#
#     print "#############"
#     # hasattr('对象','属性') : 判断某个对象是否存在指定属性
#     print "hasattr判断是否有此属性：", hasattr(emp, 'salary')
#
#     # getattr('对象','属性') : 获取某个对象指定属性的值 , 对象.属性来调用是一样的
#     print "getattr获取name属性：", getattr(emp, "name")
#
#     # getattr('对象','属性','值') : 给某个对象指定的属性赋予新的值
#     setattr(emp, "salary", 1)
#     print "setattr属性gender：", getattr(emp, "salary")
#
#     # delattr('对象','属性') : 删除某个对象的执行属性的值, 删除后赋予默认值
#     delattr(emp, "salary")
#     print "删除后：", emp.salary

"""
(3)
内置类属性
__doc__ :类的文档字符串(多行注释)
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
"""
class InnerCls:

    """
    我是注释
    """
    '姓名'
    name = ""

    def __init__(self, name):
        self.name = name
        print "InnerCls.__doc__:", InnerCls.__doc__     #InnerCls.__doc__: 我是注释
        print "InnerCls.__name__:", InnerCls.__name__   #InnerCls.__name__: InnerCls
        print "InnerCls.__module__:", InnerCls.__module__ #InnerCls.__module__: __main__
        print "InnerCls.__bases__:", InnerCls.__bases__ #InnerCls.__bases__: ()
        print "InnerCls.__dict__:", InnerCls.__dict__ #InnerCls.__dict__: {'__module__': '__main__', '__doc__': '\n    \xe6\x88\x91\xe6\x98\xaf\xe6\xb3\xa8\xe9\x87\x8a\n    ', '__init__': <function __init__ at 0x0000000002210588>, 'name': ''}


# if __name__ == '__main__':
#     innerCls = InnerCls("abc")

"""
(4)
私有变量和方法
__私有变量名 : 两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。
__私有方法名 : 两个下划线开头，声明该方法为私有方法，不能在类的外部调用。
"""
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

    def count(self):
        # 调用私有方法
        self.__plus()
        print self.__secretCount

    def count2(self):
        print self.__secretCount


    # 私有方法
    def __plus(self):
        self.__secretCount += 1
        self.publicCount += 2


# if __name__ == '__main__':
#     counter = JustCounter()
#     counter.count() #1
#     # 在类的对象生成后,调用含有类私有属性的函数时就可以使用到私有属性.
#     counter.count() #2
#
#     # 第二次同样可以.
#     print counter.publicCount #4
#     # 实例不能访问私有变量 py3中废弃
#     print counter._JustCounter__secretCount #2
#
#     counter.count2()#2


"""
(5)
类的继承
# 子类继承父类 : class 派生类名(基类名)
"""
# 父类
class Parent:
    parentAttr = 100

    def __init__(self):
        print "调用父类构造函数"


    def parentMethod(self):
        print '调用父类方法'

# 子类
class Child(Parent):
    def __init__(self):
        print "调用子类构造方法"

    def childMethod(self):
        print '调用子类方法'

    # 同类型对象相加时的处理逻辑
    def __add__(self, other):
        return self.parentAttr + other.parentAttr


# if __name__ == '__main__':
#     c = Child()  # 实例化子类
#     c.childMethod()  # 调用子类的方法
#     c.parentMethod()  # 调用父类方法
#     setattr(c, "parentAttr", 200) # 设置父类属性值
#     print getattr(c, "parentAttr") # 获取父类属性值
#
#     #python中继承没有重载，只有运算符重载
#     c2 = Child()
#     print c + c2 #处理逻辑 : __add__()

"""
(6)
多继承
"""
# 动物
class Animal:
    cell = True
    age = 10

    def dynamic(self):
        print "动物会动。。"

# 哺乳动物
class Mammals():
    hair = True

    def breastfeed(self):
        print "哺乳动物会哺乳。。。"

# 人
class Human(Mammals, Animal):

    def say(self):
        print "人会说话"


# if __name__ == '__main__':
#     human = Human()
#     human.dynamic()
#     human.say()
#     human.breastfeed()

"""
(7)
方法重写
"""
# 哺乳动物
class Mammals():
    hair = True

    def call(self):
        print "动物会叫。。。"

# 人
class Human(Mammals):

    def say(self):
        print "人会说话"

    # 重写父类方法
    def call(self, str):
        print "人是讲话的。。。" ,str


# if __name__ == '__main__':
#     human = Human()
#     human.call("123")

"""
(8)
"""
class Student:
    name = ""
    age = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age

# 单个对象转dict
def convert_to_dict(obj):
    dict = {}
    dict.update(obj.__dict__)
    return dict


# 把对象列表转换为字典列表
def convert_to_dicts(objs):
    dict_arr = []
    for obj in objs:
        dict = convert_to_dict(obj)
        dict_arr.append(dict)
    return dict_arr


# 把对象(支持单个对象、list、set)转换成字典
def class_conver_to_dicts(obj):
    is_list = obj.__class__ == [].__class__
    is_set = obj.__class__ == set().__class__

    dict_arr = []
    if is_list or is_set:
        return convert_to_dicts(obj)

    return convert_to_dict(obj)


# 将dict转化成obj
def dict_conver_to_obj(d):
    if isinstance(d, list):
        d = [dict_conver_to_obj(x) for x in d]
    if not isinstance(d, dict):
        return d

    class C(object):
        pass
    o = C()
    for k in d:
        o.__dict__[k] = dict_conver_to_obj(d[k])
    return o

stu = Student("老张", 18)
print convert_to_dict(stu) #{'age': 18, 'name': '\xe8\x80\x81\xe5\xbc\xa0'}
stu2 = Student("老吴", 20)
print convert_to_dicts([stu, stu2]) #[{'age': 18, 'name': '\xe8\x80\x81\xe5\xbc\xa0'}, {'age': 20, 'name': '\xe8\x80\x81\xe5\x90\xb4'}]

print class_conver_to_dicts([stu, stu]) #[{'age': 18, 'name': '\xe8\x80\x81\xe5\xbc\xa0'}, {'age': 18, 'name': '\xe8\x80\x81\xe5\xbc\xa0'}]

# set是无序不重复集合
set_coll = set()
set_coll.add(stu)
set_coll.add(stu) #覆盖
print class_conver_to_dicts(set_coll) #[{'age': 18, 'name': '\xe8\x80\x81\xe5\xbc\xa0'}]

#
d = {'a': 1, 'b': {'c': 2}, 'd': ['hi', {'foo': 'bar'}]}
obj = dict_conver_to_obj(d)
print obj.d # ['hi', <__main__.C object at 0x00000000022DC3C8>]

数据库操作

# -*- coding:utf-8 -*-
import MySQLdb

"""
(1)增删查改
"""
# 建立连接
conn = MySQLdb.connect(host="192.168.200.210", passwd="123456", user="root", db="test",
                       port=3306, charset="utf8")
# 创建游标，传入游标的类型是DictCursor, 意味着查询出的结果是Dict类型，默认是tuple类型
curs = conn.cursor(cursorclass=MySQLdb.cursors.DictCursor)

# 创建表
def create_table():
    create_table_sql = """
                    CREATE TABLE t_user (id INT  NOT NULL auto_increment,
                      user_name VARCHAR(15) DEFAULT '',
                      password VARCHAR(20) DEFAULT '',
                      age int(2) DEFAULT 0 ,
                      PRIMARY KEY (id));
                """
    result = curs.execute(create_table_sql)
    # 关闭连接
    curs.close()
    conn.close()
    print type(result), result


# 单行插入
def insert_one():
    insert_sql = """
                    insert into t_user (user_name, password, age ) VALUES ('%s', '%s', '%s')
                """
    try:
        # 执行SQL
        result = curs.execute(insert_sql % ("test_0", "123456", 18))
        # 打印主键
        print "插入主键的ID：", conn.insert_id()
        # 提交事务
        conn.commit()
        print type(result), result
    except MySQLdb.Error,e:
        # 事务回滚
        conn.rollback()
    finally:
        # 打印影响的行
        curs.close()
        conn.close()

# 批量插入
def insert_many():
    insert_sql = """
                    insert into t_user (user_name, password, age ) VALUES (%s, %s, %s)
                """
    try:
        # 执行SQL
        values = []
        #批量插入9条数据
        for i in range(1, 10):
            value = ('test_%d'%(i), '123456', str(i))
            values.append(value)
        result = curs.executemany(insert_sql, values)
        # 提交事务
        conn.commit()
        print type(result), result
    except MySQLdb.Error,e:
        # 事务回滚
        conn.rollback()
    finally:
        # 打印影响的行
        curs.close()
        conn.close()


# 删除行
def delete_row(id):

    delete_sql = """
                delete from t_user where id = %d
            """
    try:
        result = curs.execute(delete_sql % (id, ))
        conn.commit()
        # 打印影响的行
        print "删除结果：", result
    except MySQLdb.Error,e:
        # 事务回滚
        conn.rollback()
    finally:
        curs.close()
        conn.close()


# 修改
def update_row(user_name, password, age, id):
    update_sql = """
                    update t_user set user_name = '%s', password = '%s',age = %d where id = %d
                """
    try:
        result = curs.execute(update_sql % (user_name, password, age, id))
        conn.commit()
        # 打印影响的行
        print "修改结果：", result
    except MySQLdb.Error,e:
        # 事务回滚
        conn.rollback()
    finally:
        curs.close()
        conn.close()


# 查询
def find_name(user_name):
    query = """
            select id, user_name, password, age from t_user where user_name like '%%%s%%'    
        """
    print query % (user_name,)
    curs.execute(query % (user_name,))
    result = curs.fetchall()
    curs.close()
    conn.close()
    print result
    return result


# 查询
def find_id(id):
    query = """
                select id, user_name, password, age from t_user where id = %d
            """
    curs.execute(query % (id,))
    result = curs.fetchone()
    print result
    curs.close()
    conn.close()
    return result


if __name__ == '__main__':
    # 创建
    # create_table()

    # 添加
    #insert_one()
    insert_many()

    # 删除
    # delete_row(2)

    # 修改
    # update_row(user_name="abc", password="1234", age=18, id=1)

    # 查询
    # find_id(1)

    # 查询
    # print  type(find_name("bc"))

socket网络编程

a . 建立socket访问badu首页

# -*- coding:utf-8 -*-
"""
建立socket访问badu首页
"""

import socket
# 创建socket对象
# AF_INET指定使用IPv4协议, 如果要用IPv6则指定为AF_INET6
# SOCK_STREAM指定使用面向流的TCP协议
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 建立连接
# url , 80端口
s.connect(("www.baidu.com", 80))

# 发送数据
# \r\n:回车换行
s.send("GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection:close\r\n\r\n")

# 获取返回结果
buffer = []
while True:
    # 每次最多接收1k字节
    d = s.recv(1024)
    if d:
        buffer.append(d)
    else:
        break
#将buffer列表中的数据转为字符串
data = ''.join(buffer)
print data

# 关闭连接
s.close()

header, html = data.split("\r\n\r\n")
print header
# 将数据写入文件
with open("baidu.html", "wb") as f:
    f.write(html)
    f.close()

b . tcp

server

# -*- coding:utf-8 -*-
import socket
import threading

# 处理客户端请求
def handlertcp(sock, addr):
    print "建立一个连接：", addr
    # 发送欢迎信息
    sock.send("Welcome")

    # 接收客户端信息
    while True:
        data = sock.recv(1024)
        print "客户端发来的信息：", data
        # 收到exit消息结束
        if "exit" == data or not data:
            sock.send("即将断开连接。。")
            break
        # 收到客户端消息之后的返回的消息
        sock.send("Hello " + data)
    sock.close()


if __name__ == '__main__':
    # 1、创建socket对象，操作tcp协议
    s = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
    # 2、绑定主机和端口
    s.bind(("127.0.0.1", 2222))
    # 3、监听
    s.listen(5)
    # 4、接收客户端的连接
    print "等待接收。。。"
    sock, addr = s.accept()
    # 5、利用多线程处理多个客户端信息
    t = threading.Thread(target=handlertcp, args=(sock, addr))
    t.start()

client

# -*- coding:utf-8 -*-
import socket

# 1、创建socket对象，操作tcp协议
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2、建立与服务端的连接
s.connect(("127.0.0.1", 2222))
# 3、接收欢迎消息
print "接收服务端欢迎信息：", s.recv(1024)
# 4、发送消息
while True:
    data = raw_input()
    s.send(data)
    print "接收服务端信息：", s.recv(1024)
    if data == "exit":
        break
s.close()

c . udp

server

# -*- coding:utf-8 -*-

import  socket

# 创建socket对象
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 绑定主机和端口
s.bind(("127.0.0.1", 18889))
print "等待连接。。。"
while True:
    # 接收客户端信息并发送
    data, client = s.recvfrom(1024)
    # client[0]:ip client[1]:端口 , data:消息内容
    print "接收客户端（%s:%s）的信息: %s" % (client[0], client[1], data)
    # 收到消息之后的响应
    s.sendto("Hello: " + data, client)

client

# -*- coding:utf-8 -*-
import socket

# 创建对象
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 连接服务端并发送数据
print "请输入数据："
while True:
    data = raw_input()
    s.sendto(data, ("127.0.0.1", 18889))
    print "接受服务端数据：", s.recv(1024)

邮件发送

SMTP 是发送邮件的协议，Python 内置对 SMTP 的支持，可以发送纯文本邮件、HTML
邮件以及带附件的邮件。
Python 对 SMTP 支持有 smtplib 和 email 两个模块，email 负责构造邮件，smtplib 负责发
送邮件。
使用163邮箱
首先, 开启smtp服务 , 获取授权码
文本邮件

# -*- coding: utf-8 -*-

from email.header import Header
from email.mime.text import MIMEText
from email.utils import parseaddr, formataddr
import smtplib

"""
文本邮件
"""
# 格式化邮件地址
def _format_addr(s):
    name, addr = parseaddr(s)
    return formataddr(( \
        Header(name, 'utf-8').encode(), \
        addr.encode('utf-8') if isinstance(addr, unicode) else addr))


# 发送邮箱
from_addr = "发件人邮箱"
# 发送密码
password = "授权码"
# 发送服务器
smtp_server = "smtp.163.com"
# 接收邮箱
to_addr = raw_input("To: ")

# 构建邮件内容对象，第一个参数是邮件内容，第二个参数是MIME,必须是plain即text/plain否则中文不显示，第三个参数是编码
msg = MIMEText('你好，收到来自python的一份Python发送的邮件.', 'plain', 'utf-8')
# 如果接收端的邮件列表需要显示发送者姓名和发送地址就需要设置Header，同时中文需要encode转码
msg['From'] = _format_addr(u'发件人<%s>' % from_addr)
# 如果接收端的邮件需要显示接收者姓名和发送地址就需要设置Header，同时中文需要encode转码
msg['To'] = _format_addr(u'管理员 <%s>' % to_addr)
# 设置主题，中文需要设置Header进行转码
msg['Subject'] = Header(u'来自Python中的SMTP的问候', 'utf-8').encode()

# 创建服务对象
server = smtplib.SMTP(smtp_server, 25)
# 设置debug级别0就不打印发送日志，1打印
server.set_debuglevel(1)
# 登录邮箱
server.login(from_addr, password)
# 发送：第一个参数是发送者邮箱，第二个是接收邮箱，第三个是发送内容
server.sendmail(from_addr, [to_addr], msg.as_string())
# 退出
server.quit()

html邮件

# -*- coding: utf-8 -*-

"""
html邮件
"""

from email.header import Header
from email.mime.text import MIMEText
from email.utils import parseaddr, formataddr
import smtplib


# 格式化邮件地址
def _format_addr(s):
    name, addr = parseaddr(s)
    return formataddr((
        Header(name, 'utf-8').encode(),
        addr.encode('utf-8') if isinstance(addr, unicode) else addr))


# 发送邮箱
from_addr = "发件人邮箱"
# 授权码
password = "授权码"
# 发送服务器
smtp_server = "smtp.163.com"
# 接收邮箱
to_addr = raw_input("To: ")

# 构建邮件内容对象，第一个参数是邮件内容，第二个参数是MIME,必须是html即text/html否则中文不显示，第三个参数是编码
content = """
            <html>
                <body>
                    <h1>
                        <a href="http://www.baidu.com">来着Python发送的HTML问候!</a>
                    </h1>
                </body>
            </html>
        """
msg = MIMEText(content, 'html', 'utf-8')
# 如果接收端的邮件列表需要显示发送者姓名和发送地址就需要设置Header，同时中文需要encode转码
msg['From'] = _format_addr(u'发件人名称<%s>' % from_addr)
# 如果接收端的邮件需要显示接收者姓名和发送地址就需要设置Header，同时中文需要encode转码
msg['To'] = _format_addr(u'管理员 <%s>' % to_addr)
# 设置主题，中文需要设置Header进行转码
msg['Subject'] = Header(u'来自Python中的SMTP的问候……', 'utf-8').encode()

# 创建服务对象
server = smtplib.SMTP(smtp_server, 25)
# 设置debug级别0就不打印发送日志，1打印
server.set_debuglevel(1)
# 登录邮箱
server.login(from_addr, password)
# 发送：第一个参数是发送者邮箱，第二个是接收邮箱，第三个是发送内容
server.sendmail(from_addr, [to_addr], msg.as_string())
# 退出
server.quit()

带附件的邮件

# -*- coding: utf-8 -*-

from email import encoders
from email.header import Header
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email.utils import parseaddr, formataddr
import smtplib

"""
带附件邮件
"""
# 格式化邮件地址
def _format_addr(s):
    name, addr = parseaddr(s)
    return formataddr(( \
        Header(name, 'utf-8').encode(), \
        addr.encode('utf-8') if isinstance(addr, unicode) else addr))


# 发送邮箱
from_addr = "发送者邮箱"
# 发送密码
password = "授权码"
# 发送服务器
smtp_server = "smtp.163.com"
# 接收邮箱
to_addr = raw_input("To: ")

msg = MIMEMultipart()
msg['From'] = _format_addr(u'邮件发送人 <%s>' % from_addr)
msg['To'] = _format_addr(u'管理员 <%s>' % to_addr)
msg['Subject'] = Header(u'标题……', 'utf-8').encode()

# add MIMEText:
msg.attach(MIMEText('你好 , 附件是一张图片', 'plain', 'utf-8'))

# add file:
# 附件为同一目录下test.jpg图片
with open('test.jpg', 'rb') as f:
    mime = MIMEBase('image', 'jpg', filename='test.jpg')
    mime.add_header('Content-Disposition', 'attachment', filename='test.jpg')
    mime.add_header('Content-ID', '<0>')
    mime.add_header('X-Attachment-Id', '0')
    mime.set_payload(f.read())
    encoders.encode_base64(mime)
    msg.attach(mime)

# 创建服务对象
server = smtplib.SMTP(smtp_server, 25)
# 设置debug级别0就不打印发送日志，1打印
server.set_debuglevel(1)
# 登录邮箱
server.login(from_addr, password)
# 发送：第一个参数是发送者邮箱，第二个是接收邮箱，第三个是发送内容
server.sendmail(from_addr, [to_addr], msg.as_string())
# 退出
server.quit()

# -*- coding: utf-8 -*-

from email import encoders
from email.header import Header
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email.utils import parseaddr, formataddr

import smtplib

def _format_addr(s):
    name, addr = parseaddr(s)
    return formataddr(( \
        Header(name, 'utf-8').encode(), \
        addr.encode('utf-8') if isinstance(addr, unicode) else addr))

# 发送邮箱
from_addr = "发件人邮箱"
# 授权码
password = "授权码"
# 发送服务器
smtp_server = "smtp.163.com"
# 接收邮箱
to_addr = "收件人邮箱" # raw_input("To: ")

msg = MIMEMultipart()
msg['From'] = _format_addr(u'Python爱好者 <%s>' % from_addr)
msg['To'] = _format_addr(u'管理员 <%s>' % to_addr)
msg['Subject'] = Header(u'来自SMTP的问候……', 'utf-8').encode()

# add MIMEText:
msg.attach(MIMEText('send with file...', 'plain', 'utf-8'))

# add file:
with open('test.jpg', 'rb') as f:
    mime = MIMEBase('image', 'jpg', filename='test.jpg')
    mime.add_header('Content-Disposition', 'attachment', filename='test.jpg')
    mime.add_header('Content-ID', '<0>')
    mime.add_header('X-Attachment-Id', '0')
    mime.set_payload(f.read())
    encoders.encode_base64(mime)
    msg.attach(mime)

server = smtplib.SMTP(smtp_server, 25)
server.set_debuglevel(1)
server.login(from_addr, password)
server.sendmail(from_addr, [to_addr], msg.as_string())
server.quit()

json的使用

json

# -*- coding:utf-8 -*-
import json

"""
json
"""

data = [{ 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': True }]

# 对象转json字符串
json_str = json.dumps(data, ensure_ascii=False)

print type(json_str) # str
print json_str #[{"a": 1, "c": 3, "b": 2, "e": true, "d": 4}]

json_data = '[{"a": 1, "c": 3, "b": 2, "e": "True", "d": 4}]'
# json字符串转对象
obj = json.loads(json_data)
print type(obj[0]) #<type 'dict'>
print obj[0]["e"] #尚学堂

使用第三方库：Demjson

# -*- coding:utf-8 -*-

"""
demjson
Demjson 是 python 的第三方模块库，可用于编码和解码 JSON 数据，包含了 JSONLint 的
格式化及校验功能。
"""

import demjson

data = [{ 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': "今天天气晴朗".decode("utf-8") }]
# 转json
print demjson.encode(data)

json_data = "[{ 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': '今天天气晴朗' }]"
# json转对象
json_obj = demjson.decode(json_data)
print type(json_obj) #<type 'list'>
print json_obj[0]['e']

日期时间

# -*- coding:utf-8 -*-
import datetime

"""
日期时间
"""
# 当前日期
now = datetime.datetime.now()
# 日期对象转字符串
now = now.strftime('%Y-%m-%d %H:%M:%S')
print "当前日期时间", now

# 字符串日期转日期对象
t_str = "2019-07-27 22:17:34"
t_datetime = datetime.datetime.strptime(t_str, "%Y-%m-%d %H:%M:%S")
print type(t_datetime), t_datetime #<type 'datetime.datetime'> 2019-07-27 22:17:34

# 两个日期相差多少天
dt1 = datetime.datetime.strptime("2019-01-01 00:46:05", "%Y-%m-%d %H:%M:%S") #2019-01-01 00:46:05
dt2 = datetime.datetime.strptime("2020-01-02 14:46:05", "%Y-%m-%d %H:%M:%S") #2020-01-02 14:46:05
delta = dt2 - dt1
print type(delta), delta # <type 'datetime.timedelta'> 366 days, 14:00:00
print "两日期相差", delta.days # 两日期相差 366

# 今天的n天后的日期
now = datetime.datetime.now()
# 20之后的日期
delta = datetime.timedelta(days=20)
n_datetime = now + delta
print n_datetime #2019-08-16 22:22:41.580000