Python3基础数据类型

1 字符串
1.1 使用单引号(')
用单引号括起来表示字符串，例如：
str='this is string';
print(str);
用双引号(")
1.2 双引号中的字符串与单引号中的字符串用法完全相同，
例如：
str="this is string";
print(str);
1.3 使用三引号(''')
利用三引号，表示多行的字符串，可以在三引号中自由的使用单引号和双引号，例如：
str='''this is string
this is pythod string
this is string'''
print(str);
1.5 字符串的内置方法
capitalize(首字母转变成大写，如果首子母已经是大写则还是输出首字母大写结果)
casefold(大写转小写针对所有内容)
center(内容居中)
count(统计出现的次数，返回一个正整数类型)
encode(编码修改)
endswith(判断是否以指定字符串结尾，返回bool值)
expandtabs(将字符串中的tab(\t)转换为空格，默认空格数tabsize是8个字符)
find(查找字符串所在的位置，可先参数start:起始位置，end:结束位置。结果将返回int类型。如果查找失败返回-1)
format(字符串格式化(可接收不限数量参数，使用‘{}’占位符))
index(返回索引位置;可先参数，start:起始位置，end:结束位置，返回一个整数类型(当字符串没有找到时，会提示报错信息))
join(返回通过指定字符分隔的新字符串)
lstrip(删除左边的空白或自定义的字符)
replace(使用新的字符串替换老的字符串(可选参数count 指定替换的次数，默认是全部))
strip (去除左边空白或自定义字符串)
splitlines(拆分多行字符串，以每行一个元素生成一个新的列表，如果是单行字符串，则返回原字符串)
split(与rsplit 相反，从左边开始操作)
rsplit(从右边开始拆分，返回一个列表类型,(可选参数maxsplit 每次+- 1 sep 的值默认是空格))

2 布尔类型
bool=False;
print(bool);
bool=True;
print (bool);
3 整数
int=20
print(int)
3.1 int内置方法
__abs__(返回绝对值)
n = -5
print(n.__abs__())
#输出：5
__add__(相加，运算符：+)
n = 3
print(n.__add__(5))
#输出：8
__and__（按位与运算，运算符：&）
n = 5
print(n.__and__(7))
#输出：5
# 00000110
#与运算
# 00000111
#等于 00000110
__bool__
#占位
__ceil__（返回自身）
n = 1234
print(n.__ceil__())
#输出：1234
__divmod__(返回除数和余数)
n = 13
print(n.__divmod__(5))
#输出：(2, 3)
__eq__（判断两数是否相等，运算符：==）
n = 5
print(n.__eq__(3))
#输出：False
__float__（转换成浮点型）
n = 5
print(n.__float__())
#输出：5.0
__floordiv__（取整除，返回商的整数部分，运算符：//）
n = 9
print(n.__floordiv__(4))
#输出：2
__floor__
#占位
__format__
#占位
__getattribute__
#占位
__getnewargs__
#占位
__ge__(判断是否 >=)
n = 5
print(n.__ge__(3))
#输出：True
__gt__(判断是否 > )
n = 5
print(n.__gt__(3))
#输出：True
__hash__
#占位
__index__
#占位
__invert__（二进制按位取反，运算符：~）
n = 11
print(n.__invert__())
#输出：-12
#ps:二进制的负数表示方法：正数按位取反再加1
__le__（判断是否 <=）
n = 5
print(n.__le__(3))
#输出：False
__lshift__(二进制左移运算，运算符：<<)
n = 12
print(n.__lshift__(2))
#输出：48
#ps:二进制左移1位等于十进制乘2，右移一位等于十进制除2
__lt__(判断是否 <)
n = 5
print(n.__lt__(3))
# #输出：False
__mod__(取模-返回除法的余数，运算符：%)
n = 14
print(n.__mod__(3))
#输出：2
__mul__(相乘，运算符：*)
n = 3
print(n.__mul__(6))
#输出：18
__neg__(取反，正数变负数，负数变正数，运算符：-)
n = 5
print(n.__neg__())
#输出：-5
__new__
#占位
__ne__(判断两值是否不相等，运算符：!= )
n = 5
print(n.__ne__(3))
#输出：True
__or__(按位或运算，运算符：|)
n = 3
print(n.__or__(5))
#输出：7
# # 00000011
# #或
# # 00000110
# # 00000111
__pos__
# """ +self """ （不知道有啥意义）
__pow__(返回 x y [x的y次方] 的值)
n = 2
print(n.__pow__(3))
#输出：8
__radd__(相加，运算符：+)
n = 5
print(n.__radd__(3))
#输出：8
__rand__
#""" Return value&self. """
__rdivmod__
#""" Return divmod(value, self). """
__repr__（返回自身）
#""" Return repr(self). """
__rfloordiv__（取整除，返回商的整数部分，运算符：//）
#""" Return value//self. """
__rlshift__(二进制左移运算，运算符：<<)
#""" Return value<<self. """
__rmod__(取模-返回除法的余数，运算符：%)
#""" Return value%self. """
__rmul__(相乘，运算符：*)
#""" Return value*self. """
__ror__
#""" Return value|self. """
__round__
#占位
__rpow__(返回 y x [y的x次方] 的值)
n = 3
print(n.__rpow__(2))
#输出：8
__rrshift__
#""" Return value>>self. """
__rshift__
#""" Return self>>value. """
__rsub__
#""" Return value-self. """
__rtruediv__
#""" Return value/self. """
__rxor__
#""" Return value^self. """
__sizeof__
#""" Returns size in memory, in bytes """
__str__
#""" Return str(self). """
sub(相减)
#""" Return self-value. """
__truediv__（相除）
#""" Return self/value. """
__trunc__
#占位
__xor__（按位异或，运算符：^）
#""" Return self^value. """
bit_length(返回二进制的最小长度)
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
conjugate
#占位
from_bytes
#占位
to_bytes
#占位
4 浮点数
float = 0.73
print(float)
5 数字
包括整数、浮点数。
5.1 删除数字对象引用，例如：
a = 1
b = 2
c = 3
del a
print(a) ##会报错，对象未定义

5.2 数字类型转换
int ()
x='11'
print(int(x,2))
注意：
x，为字符串
2位现在的进制
输出值 为转成十进制的数字
如果 x本来是 数字类型，可用x=str(x)
float(x)
转为浮点数
complex()
转为复数形式
print(complex(1))
print(complex('2+1j'))
print(complex(2, 5))
l = [1, 3]
for i in l:
print(complex(i, 5))
输出
(1+0j)
(2+1j)
(2+5j)
(1+5j)
(3+5j)
str()
是将数值转成字符串。
repr()
是将一个对象转成字符串显示
eval(str)
计算一个字符串，并返回一个对象。
tuple(s)
把s转换为一个元组。
list(s)
把s转换为一个列表。
set(s)
把s转换为一个集合。
dict(d)
创建一个字典。 d必须的（键，值）元组序列。
frozenset(s)
把s转换为冻结集。
chr(x)
整数转换为一个字符。
unichr(x)
整数转换为一个Unicode字符。
ord(x)
转换单个字符为整数值。
hex(x)
将整数转换为十六进制字符串。
oct(x)
将整数转换为以八进制的字符串
5.3 数学函数
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 会生成按顺序排在这个输入值之后的最小整数 math.ceil(6.6)返回7、math.ceil(-6.6)返回-6
trunc(x) 截断x小数点后的数字，只留下构成x整数部分的有效数字 math.trunc(6.6)返回6、math.trunc(-6.6)返回-6
floor(x) 将x转换为不大于它的最大整数 math.floor(6.6)返回6、math.floor(-6.6)返回-7
exp(x) 返回e（自然常数）的x次幂(e**x) math.exp(1)返回2.718281828459045
fabs(x) 返回x的绝对值 math.fabs(-10)返回10、math.fabs(6.6)返回6.6
log(x) log(x)计算以e为底数的x的自然对数 math.log(10)返回2.302585092994046
log(x,y) log(x,y)计算以y为底数的x的自然对数 math.log(27,3)返回3.0
log10(x) 返回以10为底数的x的自然对数，对等于log(x,10) math.log10(1000)返回3.0
modf(x) 返回一个tuple,其中包含x的小数和整数部分 math.modf(6.32)返回 (0.3200000000000003, 6.0)
pow(x,y) 返回x**y的值 math.pow(3,4)返回81.0
sqrt(x) 计算x的平方根，数字不能使复数 math.sqrt(9)返回3.0
max(x1,x2,…) 返回给定参数的最大值 max(3,2,1,4,5,6)返回6
min(x1,x2,…) 返回给定参数的最小值 min(3,2,1,4,5,6)返回1
round(x[,n]) 返回浮点数x的四舍五入值，如果给出n值，则代表舍入到小数点后的位数
round(3.1415926)返回3
round(3.1415926,3)返回3.142
5.4 随机数函数
随机数可以用于数学，游戏、安全领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性
choice(seq) 返回seq中的随机项，seq可以是列表、元组或字符串
random.choice(range(10))
randrange([x,]y[,a]) 从x到y之间，以a递增的范围内随机取一个数
random.randrange(5,10,2)
random() 随机生成一个实数，它在(0,1)范围内
random.random()
seed([x]) 改变随机数生成器的种子seed，x可以是任意可散列对象
random.seed(2)
shuffle(lst) 将lst里的所有元素重新排序
random.shuffle(list1)
uniform(x,y) 在x至y的范围内随机生成一个实数
random.uniform(1,10)
5.5 三角函数
acos(x) 返回x的反余弦弧度值
math.acos(0.64)返回0.8762980611683406
asin(x) 返回x的反正弦弧度值
math.asin(0.64)返回0.694498265626556
atan(x) 返回x的正切弧度值
math.atan(0.64)返回0.5693131911006619
atan2(x,y) 返回给定的x及y坐标值的反正切值
math.atan2(-0.50, -0.50)返回-2.356194490192345
cos(x) 返回x的弧度的余弦值
math.cos(3)返回-0.9899924966004454
hypot(x,y) 返回欧几里得范数sqrt(x*x+y*y)
math.hypot(3, 2)返回3.605551275463989
sin(x) 返回x的弧度的正弦值
math.sin(3)返回0.1411200080598672
tan(x) 返回x的弧度的正切值
math.tan(3)返回-0.1425465430742778
degrees(x) 将弧度转换为角度，如degrees(math.pi/2)返回90.0
math.degrees(3)返回171.88733853924697
radians(x) 将角度转换为弧度
math.radians(3)返回0.05235987755982989
6、列表
功能：将字符创转化为列表，例：
>>>messages = 'hello word'
>>>result = list(messages)
>>>print(result)
>>>['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'd']
6.1 元素赋值
list1 = [1,2,3]
print(list1)
list1[0] = 0
print(list1)
[1, 2, 3]
[0, 2, 3]
6.2 分片操作
2.1 显示序列
将显示列表的从list1[beg]到list1[end-1]的元素，list1[end]不会显示
2.2 修改序列
list1 = [1+1,'dsad','dsadasd']
list1[1:] = list('sjie')
print(list1)
2.3 插入序列
message = list('hello')
message.insert(0,'hel')
message[2:2] = [1,2,3]
print(message)
['hel', 'h', 1, 2, 3, 'e', 'l', 'l', 'o']
2.4 删除序列
message = list('hello')
message.insert(0,'hel')
message[2:] = []
print(message)
6.3 count函数(统计列表中某元素出现的次数)
message = list('hello')
message.insert(0,'hel')
result = message.count('l')
print(result)
2
6.4 len函数(统计列表中元素的个数)
message = list('hello')
message.insert(0,'hel')
result = len(message)
print(result)
6
6.5 append函数(往列表的最后一个位置插入（入栈）操作)
list1 = [1,2,3,3]
result = list1.append('3')
print(list1)
[1, 2, 3, 3, '3']
6.6 extend函数(修改原序列，链接两个序列产生新的序列)
a = [1,2,3]
b = ['a','b','c']
a.extend(b)
print(a)
[1, 2, 3, 'a', 'b', 'c']
6.7 insert函数(将元素插入到列表的指定位置)
message = list('hello')
message.insert(0,'hel')
print(message)
['hel', 'h', 'e', 'l', 'l', 'o']
6.8 pop函数(删除指定位置元素,默认从最后一个删除并打印删除的元素)
message = list('hello')
message.insert(0,'hel')
message.pop(0)
print(message)
['h', 'e', 'l', 'l', 'o']
6.9 remove函数(删除一个指定元素)
message = [1,2,3,3]
message.remove(3)
print(message)
[1, 2, 3]
message = [1,2,3,3]
while 3 in message:
message.remove(3)
print(message)
[1, 2]
6.10 index函数(从列表中找出与某个元素匹配的第一个匹配项的位置)
message = [1,2,3,3,3]
result = message.index(2)
print(result)
1
6.11 reverse函数(翻转列表)
message = [1,2,3,3,3]
print(message)
message.reverse()
print(message)
[1, 2, 3, 3, 3]
[3, 3, 3, 2, 1]
6.12 sort函数(对列表进行排序，sort函数修改了原序列)
message = [2,12,3,3,3]
message.sort()
print(message)
[2, 3, 3, 3, 12]
如果想不修改原序列
list1 = [1,2,1]
a = sorted(list1)
print(a)
print(list1)
[1, 1, 2]
[1, 2, 1]
关键字排序：key
list1 = ['dasd','da','dasdasd','dsasd']
list1.sort(key = len)
print(list1)
['da', 'dasd', 'dsasd', 'dasdasd']
关键字排序：reverse()
list1 = [321,12,3223,321312]
list1.sort(reverse=False)
print(list1)
[12, 321, 3223, 321312]
list1 = [321,12,3223,321312]
list1.sort(reverse=True)
print(list1)
[321312, 3223, 321, 12]
reverse = True 降序
reverse = False 升序
6.13 set集合(列出列表中不重复的元素（去重）集合)
tuple1=(1,2,3,4,1,2,3)
message = list(tuple1)
print(message)
new = set(message)
print(new)
[1, 2, 3, 4, 1, 2, 3]
{1, 2, 3, 4}
13.1 update(是把要传入的元素拆分成单个字符，存于集合中，并去掉重复的字符)
message=[1,2,1,3,1,31,31,1,2]
message1=set(message)
print(message1)
message1.update('hello')
print(message1)
13.2 add(是把要传入的元素作为一个整体添加到集合中)
message=[1,2,1,3,1,31,31,1,2]
message1=set(message)
print(message1)
message1.add('hello')
print(message1)
{1, 2, 3, 31}
{1, 2, 3, 'hello', 31}
13.3 remove(集合删除)
sTest = ['e', 'two', 'o', 'n', '1', '3', '2']
set1 = set(sTest)
print(set1)
set1.remove('1')
print(set1)
{'1', 'o', 'two', '3', 'e', 'n', '2'}
{'o', 'two', '3', 'e', 'n', '2'}
13.4 集合的遍历
第一种方法：
st = set([1,2,'a','c',4,'d'])
for i in st:
print(i)
第二种方法：
st = set([1,2,'a','c',4,'d'])
for idx,i in enumerate(st):
print(idx,i)
13.5 pop()方法
删除并返回set类型的s中的一个不确定的元素，如果为空引发KeyError错误。
st = set([1,2,'a','c',4,'d'])
st.pop()
print(st)
13.6 clear()方法
清空集合中的所有元素
st = set([1,2,'a','c',4,'d'])
print(st)
st.clear()
print(st)
{1, 2, 'c', 4, 'a', 'd'}
set()
13.7 集合的一些操作符
1.交集:Python中求集合的交集使用的符号是“&”，返回连个集合的共同元素的集合，即集合的交集
st1 = set('Python')
st2 = set('htc')
result = st1 & st2
print(result)
{'t', 'h'}
2.并集:Python中求集合的并集用的是符号“|”，返回的是两个集合所有的并去掉重复的元素的集合
st1 = set('Python')
st2 = set('htc')
result = st1 | st2
print(result)
{'n', 'P', 'h', 'y', 'o', 'c', 't'}
3.差集:Python中差集使用的符号是减号“-”,返回的结果是在集合st1中但不在集合st2中的元素的集合
st1 = set(['1', '3', '2', '5', '4', '7', '6'])
st2 = set(['9', '8', '5', '4'])
result = st1 - st2
print(result)
{'7', '3', '1', '2', '6'}
13.8 集合的拷贝函数是：copy()
st1 = set(['1', '3', '2', '5', '4', '7', '6'])
st2 = st1.copy()
print(st2)
{'5', '2', '3', '4', '1', '7', '6'}
13.9 求集合的关系: issuperset(),issubset()
判断s1集合是否是集合s2的父集，是返回True，否则返回False
st1 = set([1, 2, 3, 4])
st2 = set([1, 2, 3, 4, 5])
result = st2.issuperset(st1)
print(result)
判断s2集合是否是集合s1的子集，是返回True，否则返回False
st1 = set([1, 2, 3, 4])
st2 = set([1, 2, 3, 4, 5])
result = st1.issubset(st2)
print(result)
13.10 不可变集合frozenset
Python中还有一种不可改变的集合，那就是frozenset，不像set集合，可以增加删除集合中的元素，该集合中的内容是不可改变的，类似于字符串、元组。

> ---------------------------------------------------------------------

7、元组(元组和列表几乎一样,元组的元素不可修改，但是元组元素的元素是可以修改的),tuple(iterable)，可以存放所有可迭代的数据类型
7.1.count(用于计算元素出现的个数)
T = ('a','b','c','d',1,2,2,3,4)
result = T.count(2)
print(result)
2
7.2.index(获取元素在元组中的索引值,对于重复的元素,默认获取从左起第一个元素的索引值)
T = ('a','b',2,'c','d',1,2,3,4)
result = T.index(2)
print(result)
2
7.3.元组支持切片操作
#取所有元素
T = ('a','b','c','d','e','f','g','h')
result = T[:]
print(result)
('a','b','c','d','e','f','g','h')
#取从索引2开始到末尾的元素
T = ('a','b','c','d','e','f','g','h')
result = T[2:]
print(result)
('c', 'd', 'e', 'f', 'g', 'h')
#取索引2到6的所有元素，不包含索引6
T = ('a','b','c','d','e','f','g','h')
result = T[2:6]
print(result)
('c', 'd', 'e', 'f')
#从索引2到6，每隔一个元素取一个
T = ('a','b','c','d','e','f','g','h')
result = T[2:6:2]
('c', 'e')
print(result)
7.4.tuple元祖常用的内置方法
cmp(tuple1, tuple2)比较两个元组元素
len(tuple)计算元组元素个数
max(tuple)返回元组中元素最大值
min(tuple)返回元组中元素最小值
tuple(seq)将列表转换为元组

> ---------------------------------------------------------------------
8、字典:字典是可变的，并且可以存储任意数量的Python对象，包括其他容器类型另一个容器类型。字典包括键对(称为项目)及其相应的值
8.1 字典的内置方法
8.1.1 dict.clear()删除字典dict中的所有元素
dict = {'Name': 'Sjie', 'Age': 7}
print("Start Len : %d" % len(dict))
dict.clear()
print("End Len: %d" %len(dict))
Start Len : 2
End Len: 0
8.1.2 dict.copy()返回字典dict的浅表副本
dict1 = {'Name': 'Zara', 'Age': 7}
dict2 = dict1.copy()
print("New Dictinary : %s" % str(dict2))
print("Old Dictinary : %s" % str(dict1))
New Dictinary : {'Name': 'Zara', 'Age': 7}
Old Dictinary : {'Name': 'Zara', 'Age': 7}
8.1.3 dict.fromkeys()创建一个新的字典，设置键为seq 和值为value，seq -- 这是将用于字典的键准备的值的列表。value -- 这是可选的，如果提供的话则值将被设置为这个值
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print("New Dictionary : %s" % str(dict))
dict = dict.fromkeys(seq, 10)
print("New Dictionary : %s" % str(dict))
New Dictionary : {'name': None, 'age': None, 'sex': None}
New Dictionary : {'name': 10, 'age': 10, 'sex': 10}
8.1.4 dict.get(key, default=None)
对于键key，返回键，如果不是在字典的值或默认
dict = {'Name': 'Zara', 'Age': 27}
print("Value : %s" % dict.get('Age'))
print("Value : %s" % dict.get('Sex', "Never"))
Value : 27
Value : Never
8.1.5 dict.items()
返回字典的（键，值）元组对的列表
dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.items())
Value : dict_items([('Name', 'Zara'), ('Age', 7)])

8.1.6 dict.keys()
返回字典的键的列表
dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.keys())
Value : dict_keys(['Name', 'Age'])

8.1.7 dict.setdefault(key, default=None)
类似get()，但会设定dict[key]=default如果key不是已经在于字典中
dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.setdefault('Age', None))
print("Value : %s" % dict.setdefault('Sex', None))
8.1.8 dict.update(dict2)
增加字典dict2的键值对到字典中
dict = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }
dict.update(dict2)
print("Value : %s" % dict)
8.1.9 dict.values()
返回字典dict的值列表
dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.values())
8.2 字典的迭代
# 迭代
for key in d # 迭代key
for value in d.values() # 迭代value
for k, v in d.items() # 迭代key和value
8.3 字典的交换key和value
{value:key for key, value in a_dict.items()}
8.4 列表转换为字典
dic = {}
list1 = [11,22,33,44,55,66,77,88,99]
for i in list1:
if i > 66:
if "k1" in dic.keys():
dic['k1'].append(i)
else:
dic['k1'] = [i,]
else:
if "k2" in dic.keys():
dic['k2'].append(i)
else:
dic['k2'] = [i,]
print(dic)

9、日期
9.1 time(时间模块)
time.time() 返回当前时间戳
time.asctime() 返回当时时间的ascii表式形势
time.ctime() 当前时间的字符串形式跟asctime()一样
time.localtime() 返回当前时区的内部time格式struct_time格式
time.gmtime() 将时间戳转变成UTC时区(0时区)的struct_time结构
time.mktime(t)将内部time格式转换成时间戳,接受truct_time结构
time.strftime("%Y-%m-%d",time.localtime(time.time()))将内部 time结构转变成我们人为可读的指定的字符串格式 '2014-3-12'
time.strftime("%Y-%m-%d%H:%M:%S",time.localtime())将当前时间格式化指定的字符串格式
time.clock()返回当前CPU时间为几秒钟的浮点数。以测量不同方法的计算成本，time.clock的值比time.time()更有用
time.sleep(secs)暂停secs秒钟调用线程
time.strptime()将字符串格式的时间转变成内部time格式
time.strptime("Sat Mar 28 22:24:25 2009","%a %b %d %H:%M:%S %Y")
python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
9.2 calendar(日历模块)
#打印2017的日历
import calendar
result = calendar.calendar(theyear=2017,w=2,l=1,c=6)
print(result)
#判断是否为闰年
calendar.isleap(year)
#打印指定的年跟月的日历
result = calendar.month(2017,6,w=2,l=1)
#返回给定日期的星期代码
calendar.weekday(2016,6,9)
9.3 datetime(处理日期时间模块)
datetime模块定义了下面这几个类：
datetime.date：表示日期的类。常用的属性有year, month, day；
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond；
datetime.datetime：表示日期时间。
datetime.timedelta：表示时间间隔，即两个时间点之间的长度。
datetime.tzinfo：与时区有关的相关信息。

9.3.1 date对象表示由年，月，日组成的简单日期
date(year,month,day)
此函数创建一个新的日期对象，year是范围在datetime.MINYEAR和datetime.MAXYEAR之间的整数。month是在一个范围在1到12直接的整数，而day是一个范围在1到指定月份天数之间的整数。返回的date对象是不可变的
date.today()
返回对应当前日期的date对象
date.fromtimestamp(timestamp)
返回对应时间戳timestamp的date对象。timestamp是time.time()函数的返回值
date.fromordinal(ordinal)
返回对应从允许的最小日期开始的ordinal天的date对象(例如，1年1月1日的序数值为1，而2006年1月1日的序数值为732312)
date.min()
表示能够表示的最早日期(datetime.date(1,1,1))
date.max()
表示可能的最晚日期(datetime.date(9999,12,31))
from datetime import *
d = date(year=2013,month=4,day=13)
d.ctime #返回一个字符串，表示日期格式与time.ctime()函数一般使用的格式相同
d.isocalendar() #以元祖(iso.year,iso_week,iso_weekday)的形式返回日期
d.isoformat() #返回表示日期的iso 8601格式的字符串
d.isoweekday() #返回一周的一天，范围在1(星期一)到7(星期日)之间
d.replace() #返回一个新的date对象，并使用新值代替其中一个，例如：d.replace(month=1)
d.strftime(format("%Y-%m-%d")) #返回一个字符串，表示日期格式与time.strftime()函数相同
d.timetuple() #返回适合函数在time模块中使用的time.struct_time对象
d.toordinal() #将d转化为一个序数值
d.weekday() #返回一周内的时间，范围在0(星期一)到6(星期日)之间
9.3.2 time对象用于表示包含小时，分，秒，微秒的时间
time.min() #表示可表示的最小时间(datetime.time(0,0))
time.max() #表示可表示的最大时间(datetime.time(23,59,59,999999))
t.isoformat() #返回一个字符串，表示时间格式为"HH::MM:SS.mmmmmm"
t.strftime(format) #返回自定义格式化字符串表示时间

9.3.3 datetime对象用于表示日期和时间
datetime(year,month,day,hour,minute,second,microsecond,tzinfo) #创建一个新的datetime的对象，它同时包含date和time对象的所有特性
datetime.today() #返回一个表示当前本地时间的 datetime 对象
datetime.now(tz=None) #返回一个表示当前本地时间的datetime对象；如果提供了参数tz，则获取tz参数所指时区的本地时间
datetime.utcnow() #返回一个当前UTC时间的datetime对象
datetime.fromtimestamp(timestamp, tz=None) #根据时间戮创建一个datetime对象，参数tz指定时区信息
datetime.utcfromtimestamp(timestamp) #根据时间戮创建一个UTC时间的datetime对象
datetime.combine(date, time) #根据参数date和time，创建一个datetime对象
9.3.4 timedelta对象表示两个日期之间或时间之间的差值
timedaelta(days,seconds,microseconds) #例如：
import datetime
today = datetime.datetime.now()
t = today.ctime()
print(t)
oneday = datetime.timedelta(days=1)
tomorrow = today + oneday
print(tomorrow.ctime())
Fri Jun 9 17:14:46 2017
Sat Jun 10 17:14:46 2017