python Day1（数据类型）

数据类型

1不可变数据

1.1Number（数字）

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

• int（有符号整型）
  【使用int】
• float（浮点型）
  【使用float】
• complex（复数）
  【使用complex】
• bool布尔类型
  在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
  【使用bool】

• 数字类型转换

int(x [,base]) #将x转换为一个整数 
float(x ) #将x转换到一个浮点数 
complex(real [,imag]) #创建一个复数 
str(x) #将对象x转换为字符串 
repr(x) #将对象x转换为表达式字符串 
eval(str) #用来计算在字符串中的有效Python表达式,并返回一个对象 
tuple(s) #将序列s转换为一个元组 
list(s) #将序列s转换为一个列表 
chr(x) #将一个整数转换为一个字符 
unichr(x) #将一个整数转换为Unicode字符 
ord(x) #将一个字符转换为它的整数值 
hex(x) #将一个整数转换为一个十六进制字符串 
oct(x) #将一个整数转换为一个八进制字符串

数学公式

 abs(x)    #返回数字的绝对值，如abs(-10) 返回 10
ceil(x)    #返回数字的上入整数，如math.ceil(4.1) 返回 5
exp(x)    #返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)   # 返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)# 返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)    #如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)# 返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)   # 返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)    #返回给定参数的最小值，参数可以为序列。
modf(x)    #返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) #x**y 运算后的值。
round(x [,n])# 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)   # 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)#返回 2+0j

1.2Tuple(元组)

Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可

创建元组

tup1=('physics','chemistry',1990,2018)
tup2 = (1,2,3435,46,7)
tup3 = "a","b","c", "d"

元组索引

tup1[0]
tup1[1:5]
tup1[-2]
tup1[1:]

拼接

tup3 = tup1 + tup2

删除
元组中的元素值是不允许删除的，可以使用del语句来删除整个元组

del tup1

元组运算

len(tup1)#计算个数
tup1+tup2 #连接
tup1*4#复制
1997 in tup1#判断元素是否存在
for x in tup1:# 遍历

内置函数

len(tuple)# 计算元组元素个数。
max(tuple) #返回元组中元素最大值。
min(tuple) #返回元组中元素最小值。
tuple(seq)# 将列表转换为元组。

1.3字符串

创建字符串

str='this is string'
str="this is string"
str='''this is string，
this is pythod string，
this is string'''

去除空格及特殊符号

str.replace(' ', '') # 使用字符串函数replace
''.join(a.split())# 使用字符串函数split

字符串格式输出对齐

str.center(20)       #空格补全 生成20个字符长度，str排中间
str.ljust(20)            #生成20个字符长度，str左对齐
str.rjust(20)            #生成20个字符长度，str右对齐

大小写转换

str.upper()                #转大写
str.lower()                #转小写 
str.capitalize()       　#字符串首为大写，其余小写
str.swapcase()         #大小写对换
str.title()                #以分隔符为标记，首字符为大写，其余为小写

字符串条件判断

str = '01234'
str.isalnum()                #是否全是字母和数字，并至少有一个字符
str.isdigit()                #是否全是数字，并至少有一个字符
str.isalpha()                  #是否全是字母，并至少有一个字符
str.islower()                  #是否全是小写，当全是小写和数字一起时候，也判断为True
str.isspace()                  #是否全是空白字符，并至少有一个字符
str.isupper()                  #是否全是大写，当全是大写和数字一起时候，也判断为True
str.istitle()                  #所有单词字首都是大写，标题
str.startswith('str')   　　　　　　　　　　　　　　#判断字符串以'str'开头
str.endswith('arn')        　　　　　　　　　　　　　　#判读字符串以'arn'结尾

字符串搜索定位及替换

str.find('z')              #查找字符串，没有则返回-1，有则返回查到到第一个匹配的索引
str.rfind('n')         #返回的索引是最后一次匹配的
str.index('a')         #如果没有匹配则报错  ,返回第一次匹配的索引值
str.rindex("n")         #返回最后一次匹配的索引值
str.count('a')      #字符串中匹配的次数
str.replace('EAR','ear')        #匹配替换
str.replace('n','N')
str.strip('n')          #删除字符串首尾匹配的字符，通常用于默认删除回车符 
str.lstrip('n')        #左匹配 
str.rstrip('n')        #右匹配
str.expandtabs()       #把制表符转为空格
str.expandtabs(2)      #指定空格数

字符串分隔变换

str = "Learn string"
'-'.join(str) # 'L-e-a-r-n- -s-t-r-i-n-g'
li = ['Learn','string']
'-'.join(li)# 'Learn-string'
str.split('n')#['Lear', ' stri', 'g']
str.split('n',1)#['Lear', ' string']
str.rsplit('n')# str.rsplit('n')
str.rsplit('n',1)# ['Learn stri', 'g']
str.splitlines()# ['Learn string']
str.partition('n')#('Lear', 'n', ' string')
str.rpartition('n')#('Learn stri', 'n', 'g')

2可变数据（4）

2.1List（列表）

== 创建列表==

list=['physics', 'chemistry', 1997, 2000]
nums=[1, 3, 5, 7, 8, 13, 20]

== 增==

list.append('sdfg')

改

list[0]= 'chedg'

== 删==

del list[1]

查

list[0]#返回标为0的元素
list[2:5] #从下标为2的元素切割到下标为5的元素，但不包含下标为5的元素'''
list[1:]#从下标为1切割到最后一个元素
list[:-3]#从最开始的元素一直切割到倒数第3个元素，但不包含倒数第三个元素
list[:] #返回所有元素

列表方法

list.append(obj) #在列表末尾添加新的对象
list.count(obj) #统计某个元素在列表中出现的次数
list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj) #从列表中找出某个值第一个匹配项的索引位置，索引从0开始
list.insert(index, obj)#将对象插入列表
list.pop(obj=list[-1]) #移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
list.remove(obj) #移除列表中某个值的第一个匹配项
list.reverse() #反向列表中元素，倒转
list.sort([func]) #对原列表进行排序

2.2dict字典

字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

== 创建字典==

每个键与值必须用冒号隔开(?，每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

增

dict["school"]= "datawhale"

改

dict['Name']= 'liu'

查

dict['name']
dict['age']

删

del dict['name'];# 删除键是'name'的条目
dict.clear() # 清空字典所有条目
del dict # 删除字典

== 内置函数==

len(dict) #计算字典元素个数，即键的总数。
str(dict) #输出字典可打印的字符串表示。
type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型。
radiansdict.clear() #删除字典内所有元素dict.clear()
radiansdict.copy() #返回一个字典的浅复制dict.copy()
#radiansdict.fromkeys() #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值dict.fromkeys(seq[, value])
#radiansdict.get('name', default=None) #返回指定键的值，如果值不在字典中返回default值dict.get(key, default=None)
radiansdict.has_key('name') #如果键在字典dict里返回true，否则返回false
radiansdict.items()# 以列表返回可遍历的(键, 值) 元组数组dict.items()
radiansdict.keys() #以列表返回一个字典所有的键dict.keys()
radiansdict.setdefault('name', default=None)# 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default 。dict.setdefault(key, default=None)
radiansdict.update(dict2) #字典dict2的键/值对更新到dict里 dict.update(dict2)
radiansdict.values() #以列表返回字典中的所有值dict.setdefault(key, default=None)
pop(key[,default])
#删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

2.3 Set（集合）

创建集合
创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

list_1 = [1,3,4,7,3,6,7,9]
list_1 = set(list_1)
list_2 = set([2,6,0,66,22,8,4])
list_3 = set([1,3,7])

方法

add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	删除集合中的元素，该元素在指定的集合中不存在。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

交集

list_1.intersection(list_2)

== 并集==

list_1.union(list_2)

差集把list_1里面有的而list_2里面没有的取出来

list_1.difference(list_2)

==【对称差集】==两个列表里面，互相没有的取出来，也就是只去掉那些互相都有的值

list_1.symmetric_difference(list_2)

子集判断list_1是否包含了list_3里面的所有值

list_3.issubset(list_1)

父集判断list_1是否为list_3的父集

list_1.issuperset(list_3)

无交集判断list_3和list_4是否完全没有任何交集

list_4 = set([5,6,8])
list_3.isdisjoint(list_4)

删除

list.discard('H')
list.remove('H')

2.4日期

获取当前日期

import time, datetime
localtime = time.localtime(time.time())# 返回 struct_time元组
#time.struct_time(tm_year=2018, tm_mon=12, tm_mday=17, tm_hour=21, tm_min=13, tm_sec=40, tm_wday=0, tm_yday=351, tm_isdst=0)

获取格式化的时间

time.strftime('%Y-%m-%d  %H:%M:%S')
#'2018-12-17  21:15:09'

日期转换为字符串

time.strftime('%Y-%m-%d %H:%M:%S')
datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S')
str(datetime.datetime.now())
#'2018-12-17 21:16:57.009211'

字符串转化为日期

expire_time=('2018-12-17  21:15:09')
d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")
#datetime.datetime(2018, 12, 17, 21, 15, 9)

获取日期差

oneday = datetime.timedelta(days=1)#一天
today = datetime.date.today()#今天tetime.date(2018, 12, 17)
yesterday = datetime.date.today() - oneday#昨天tetime.date(2018, 12, 17)
tomorrow = datetime.date.today() + oneday#明天datetime.date(2018, 12, 18)
today_zero_time = datetime.datetime.strftime(today, '%Y-%m-%d %H:%M:%S')#获取今天零点的时间
datetime.timedelta(milliseconds=1), #1毫秒
datetime.timedelta(seconds=1), #1秒
datetime.timedelta(minutes=1), #1分钟
datetime.timedelta(hours=1), #1小时
datetime.timedelta(days=1), #1天
datetime.timedelta(weeks=1)

获取时间差

oneday = datetime.timedelta(days=1)#1 day, 0:00:00
today_time = datetime.datetime.now()#今天
yesterday_time = datetime.datetime.now() - oneday#昨天
tomorrow_time = datetime.datetime.now() + oneday#明天
##注意时间是浮点数，带毫秒。
##那么要获取当前时间，需要格式化一下：
datetime.datetime.strftime(today_time, '%Y-%m-%d %H:%M:%S')
datetime.datetime.strftime(yesterday_time, '%Y-%m-%d %H:%M:%S')
datetime.datetime.strftime(tomorrow_time, '%Y-%m-%d %H:%M:%S')

字符串日期格式化为秒数，返回浮点类型

expire_time = "2013-05-21 09:50:35"
d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")
time_sec_float = time.mktime(d.timetuple())

日期格式化为秒数

d = datetime.date.today()
time_sec_float = time.mktime(d.timetuple())

秒数转字符串

time_sec = time.time()
time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time_sec))

3查看数据类型

type() 函数 查询变量所指的对象类型
isinstance(a, int)  用 isinstance 来判断