python学习——Day 2（python数据类型）

1.数据类型/变量

1.1 不可变数据（3 个）

1.1.1 String（字符串）

【创建字符串】

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 = "字符串学习"
str.encode('utf-8')#编码过程 编码为utf-8 
str.decode("utf-8").encode('gbk')           #编码过程，将unicode编码为gbk

【字符串分割变换】

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')

1.1.2 Numbers（数字）

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

• int（有符号整型）
  【使用int】

int= 20

• float（浮点型）
  【使用float】

float = 2.3

• complex（复数）
  【使用complex】

complex = complex(a,b) # a + bj

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

bool=False
bool=True

• 数字类型转换

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
cmp(x, y) #如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
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.1.3 Tuple（元组）

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

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
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:# 遍历

【元组内置函数】

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

1.2 可变数据（4个）

1.2.1 List（列表）

【创建列表】

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

【增】

list.append("adasda")

【删】

del tup1[0]

【改】

tup1=[0]="ljq"

【查】

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]) #对原列表进行排序

1.2.2 Dictionary（字典）

字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
【创建字典】
每个键与值必须用冒号隔开(?，每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict2 = { 'abc': 123, 98.6: 37 }

【增】

dict["school"]="wutong"

【删】

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

【改】

dict["age"]=27 #修改已有键的值

【查】

dict = {'name': 'Zara', 'age': 7, 'class': 'First'}
dict['name']
dict['age']

【字典内置函数&方法】

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

1.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])

【交集】

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')

1.2.4 日期

【获取当前时间】

import time, datetime
localtime = time.localtime(time.time())# 返回 struct_time元组

【获取格式化的时间】
可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime()

time.strftime('%Y-%m-%d %H:%M:%S')

【日期转换为字符串】

time.strftime('%Y-%m-%d %H:%M:%S')
datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S')
str(datetime.datetime.now())

【字符串转换为日期】

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

【获取日期差】

oneday = datetime.timedelta(days=1)#一天
today = datetime.date.today()#今天
yesterday = datetime.date.today() - oneday#昨天
tomorrow = datetime.date.today() + oneday#明天
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')

【获取上个月最后一天】

last_month_last_day = datetime.date(datetime.date.today().year,datetime.date.today().month,1)-datetime.timedelta(1)

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

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))

1.3 查看数据类型

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