python数据类型使用

数据类型

• 数字类型 int float

用来记录数字相关的数据类型

# int 用来记录整数类型数据
# 如：年龄、年份、人数
age = 18  #等同于age = int(18)
year = 2020
count = 20

#float 用来记录带小数点的数据类型
# 如：工资、身高、体重
salary = 1800.29
height = 180.3
weight = 50.2


#数字类型使用
#数学运算
>>> a = 1
>>> b = 2
>>> c = a + b
>>> c
3

#比较大小
>>> a = 1
>>> b = 2
>>> a > b
False

• 字符串类型 str

# 用来记录用户名、地址等描述性的数据
name = 'zhangsan'
address = '北京'

#使用
#可以用单引号、双引号、三引号定义字符串
#需要考虑引号嵌套问题
#内层使用单引号  外层就需要使用双引号
msg = "My name is zhangsan, I'm 18!"
msg = 'zangsan'
msg = '''
	君不见黄河之水天上来，奔流到海不复回。
	君不见高堂明镜悲白发，朝如青丝暮成雪。
	人生得意须尽欢，莫使金樽空对月。
	天生我材必有用，千金散尽还复来。
	烹羊宰牛且为乐，会须一饮三百杯。
	岑夫子，丹丘生，将进酒，杯莫停。
'''

# 字符串类型也可以相加或者相乘
>>> name = 'zhengsan'
>>> age = '18'
>>> name + age
'zhengsan18'
>>> name * 3
'zhengsanzhengsanzhengsan'

#按索引取值(正向取+反向取) ：只能取
msg = 'hello world'
#正向取
print(msg[0])	# h
print(msg[3])	# l
#反向取
print(msg[-1])	# d

#切片操作
#顾头不顾尾
print(msg[0:5])		# hello

# 设置切片操作步长
# 取到下标 0 2 4
print(msg[0:5:2])	#hlo

#反向步长
print(msg[5:0:-1])	#' olle'

print(msg[:])  # hello world
#相当于
print(msg[0:11])  # hello world

#把字符串倒过来
print(msg[::-1])  #dlrow olleh

字符串内置方法

strip    # 移除左右两边的指定字符
str1.strip('*')

lstrip   # 只移除左边的指定字符
str1.lstrip('*')    

rstrip   # 只移除右边的指定字符
str1.rstrip('*')    

lower   # 将英文字符串全部变小写
 str2.lower()  
 
upper  # 将英文字符串全部变大写
str2.upper()  
 
startswith   #判断字符串是否以某个字符开头，结果为布尔值True或False
str3.startswith('t') 

endswith   #判断字符串是否以某个字符结尾，结果为布尔值True或False
 str3.endswith('t') 
 
split  #split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
str5='1*2*3*4'
str5.split('*', 1) 

['1', '2*3*4']
 
rsplit  #rsplit刚好与split相反，从右往左切割，可以指定切割次数
str5='1*2*3*4'
str5.rsplit('*', 1)

['1*2*3', '4']
 
join   #从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
'%'.join('hello')  
 
 'h%e%l%l%o'
 
replace   # 用新的字符替换字符串中旧的字符
str6.replace('a', 'b')


isdigit   # 判断字符串是否是纯数字组成，返回结果为True或False
str8 = '5201314'
True

find  #从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
print(msg.find('o'))  #返回要查找的字符串在大字符串中的起始索引
msg.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引

index  #同find,但在找不到时会报错
print(msg.index('o'))  #返回要查找的字符串在大字符串中的起始索引,找不到会报错
msg.index('e',2,4)

count  #统计字符串在大字符串中出现的次数
msg.count('e')  # 统计字符串e出现的次数
msg.count('e',1,6)  # 字符串e在索引1~5范围内出现的次数


center
>>> name='zhangsan'
>>> name.center(20,'-')  # 总宽度为20，字符串居中显示，不够用-填充
'------zhangsan------'

ljust
name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
'**************************tony'

rjust
name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
'**************************tony'

zfill
name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充
'0000000000000000000000000000000000000000000000tony'


expandtabs
>>> name = 'tony\thello'  # \t表示制表符(tab键)
>>> name
tony    hello
>>> name.expandtabs(2)  # 修改\t制表符代表的空格数为2
tony  hello


captalize  #首字母大写
message.capitalize()


swapcase  #大小写翻转
message1.swapcase()  


print('abc'.islower())	#是否小写

print('ABC'.isupper())	#是否大写

print('Hello World'.istitle())	#是否每个单词首字母大写

print('123abc'.isalnum())  # 字符串是否是字母数字组成

print('abc'.isalpha())  # 字符串是否是字母组成

print('   '.isspace())  # 字符串是否是空格

• 列表 list

#列表用来记录多条数据
name = ['zhangsan', 'lisi', 'wangwu']

#使用
# 可以根据列表对应的下标来获取对应的值
name = ['zhangsan', 'lisi', 'wangwu']
#正向取值
print(name[0])	#zhangsan
print(name[1])	#lisi
#反向取值
print(name[-1])	#wangwu

#修改值
name[1] = 33
print(name)  # ['zhangsan', 33, 'wangwu']



name = [['zhangsan',18, ['看电影','听音乐']], ['lisi', 19, ['篮球','足球']]]
print(name[0][1])  #18

print(name[0][2])   #['看电影', '听音乐']

print(name[0][2][0])   #看电影


#切片操作   顾头不顾尾
name = ['zhangsan', 'lisi', 'wangwu', 'aa', 'bb', 'cc', 'dd']

print(name[0:3])  # ['zhangsan', 'lisi', 'wangwu']

#设置步长为2    #0 2 4
print(name[0:5:2])  # ['zhangsan', 'wangwu', 'bb']

print(name[0:len(name)]) 
# ['zhangsan', 'lisi', 'wangwu', 'aa', 'bb', 'cc', 'dd']

print(name[:])  #
# ['zhangsan', 'lisi', 'wangwu', 'aa', 'bb', 'cc', 'dd']


#列表长度
print(len(name))    #7

#判断字符串是否存在列表中
print('aa' in name)  #True

#向列表中追加值
name.append('ssss')
print(name)   #['zhangsan', 'lisi', 'wangwu', 'aa', 'bb', 'cc', 'dd', 'ssss']

#向列表指定位置插入值
name.insert(0,'小明')   #['小明', 'zhangsan', 'lisi', 'wangwu', 'aa', 'bb', 'cc', 'dd']
print(name)



#删除
#没有返回值
del name[1]  #['zhangsan', 'wangwu', 'aa', 'bb', 'cc', 'dd']
print(name)

#有返回值
res=name.pop()  #不指定参数默认删除最后一个
print(res)    #dd

res =name.pop(1)
print(res)    #lisi

#根据元素删除
name.remove('zhangsan')  
print(name)  #['lisi', 'wangwu', 'aa', 'bb', 'cc', 'dd']

#匹配字符串的个数
print(name.count('zhangsan'))  #1  

#返回字符串所在的位置， 找不到就报错
print(name.index('aa'))   #3  

name.clear()  # 清空列表
print(name)  # []

#翻转列表
name.reverse()  #['dd', 'cc', 'bb', 'aa', 'wangwu', 'lisi', 'zhangsan']
print(name)

#排序
name.sort()  #排序  默认从小到大
name.sort(reverse=True)  #从大到小

• 字典 dict

#用来存取key、value形式的数据
#造字典方式
#方式一：
dict = {'name': 'zhangsan', 'age': '18'}
#方式二：
d = dict(a=1, b=2, c=3)
print(d)    #{'a': 1, 'b': 2, 'c': 3}

#方式三
info=[
    ['name','zhansgan'],
    ('age',18),
    ['gender','male']
]
res=dict(info) # 一行代码搞定上述for循环的工作
print(res)

print(dict['name'])  #zhangsan
print(dict['age'])  #18

dict['k1']='aaa'  #key存在则修改，不存在则创建
print(dict)  #{'name': 'zhangsan', 'age': '18', 'k1': 'aaa'}
print(len(dict))  #2

#根据key判断是否存在
print('name' in dict)  #True
print('zhangsan' in dict)   #False

#删除元素
del dict['name']   #删除元素，没有返回值，有则删除，没有则报错
print(dict)

res = dict.pop('name')  #删除元素，有返回值，返回被删除元素的值，
print(res)  #zhangsan

res = dict.popitem()  #删除元素，返回元组
print(res)  #('age', '18')


#修改值
dict.update({'name':'lisi'})  #修改元素值
print(dict)   #{'name': 'lisi', 'age': '18'}

获取值
print(dict.get('name'))  #获取值,存在则返回值，不存在则返回None
print(dict['name'])   #获取值，存在则返回，不存在则报错

• 布尔 bool

#用来记录真假两种状态
is_ok = True
is_ok  = False

• 元组 tuple

#元组是一个不可变类型
t = (1, 1.3, 'aa')
print(type(t))   #<class 'tuple'>

t=(10,) # 如果元组只有一个元素，必须加上,逗号
print(t,type(t))

#类型转换
#字符串转元组
print(tuple('hello'))   #('h', 'e', 'l', 'l', 'o')

#列表转元组
print(tuple([1,2,3]))   #(1, 2, 3)

#字典转元组
print(tuple({'a1':111,'a2':333}))  #('a1', 'a2')


t = ('aa', 'bb', 'cc', 'dd', 'ee')
#正向取值
print(t[0])  #aa

#反向取值
print(t[-1])  #ee

#切片  顾头不顾尾
print(t[0:4])  #('aa', 'bb', 'cc', 'dd')
print(t[0:4:2])  #('aa', 'cc')
print(t[::-1])  # ('ee', 'dd', 'cc', 'bb', 'aa')

• 集合 set

#定义: 在{}内用逗号分隔开多个元素
#集合内的元素必须为不可变类型
#集合内的元素无序
#集合内的元素不可重复

#定义空集合
s = set()  
s = {}  #默认是空字典

s = {1, 2, 3}
print(s, type(s))  #{1, 2, 3} <class 'set'>

s1 = {11, 22, 33, 44}
s2 = {33, 22, 55, 66}

# 取交集，两者共有的
print(s1 & s2)  # {33, 22}
print(s1.intersection(s2))  # 等价于上边   #{33, 22}

# 取并集/合集  两者所有的
print(s1 | s2)  # {33, 66, 11, 44, 22, 55}
print(s1.union(s2))  # 等价于上边

# 取差集  取s1独有的
print(s1 - s2)  # {11, 44}
print(s1.difference(s2))  # 等价于上边
# 取s2独有的
print(s2 - s1)  # {66, 55}
print(s2.difference(s1))  # 等价于上边

# 对称差集，取两个集合独有的，去掉共同的部分
print(s1 ^ s2)  # {66, 11, 44, 55}
print(s1.symmetric_difference(s2))  # 等价于上边

s1 = {11, 22, 33, 44}
s2 = {33, 22, 44}

# 父子集，包含的关系
print(s1 > s2)  # True
print(s1.issuperset(s2))  # True  # 等价于上边
print(s1 < s2)  # False
print(s1.issubset(s2))   #False  # 等价于上边

res = s1.isdisjoint(s2)
print(res)  #两个集合完全独立，没有共同部分则返回True

#去重
s1 = {11, 22, 33, 44, 22, 33, 11, 55, 66}
print(s1)  #{33, 66, 11, 44, 22, 55}

#无序
s1 = {11, 22, 33, 44, 55, 66}
print(s1)  #{33, 66, 11, 44, 22, 55}



#删除元素
s1 = {11, 22, 33, 44, 55, 66}

s1.discard(11)  #删除元素，不存在什么都不做，存在则删除
print(s1)

s1.remove(33) #存在则删除，不存在则报错
print(s1)

res = s1.pop()
print(res)
print(s1)

#修改字典
s1.update({77})  
print(s1)   #{33, 66, 11, 44, 77, 22, 55}

#插入元素
s1.add(2)
print(s1)

数据类型间的转换

# 字符串转 int
# 如果字符串包含了非数字之外的特殊符号则会报错
>>> str = '123'
>>> res = int(str)
>>> res
123
>>> type(res)
<class 'int'>

#字符串转float
>>> str = '12.9'
>>> res = float(str)
>>> res
12.9
>>> type(res)
<class 'float'>

# 进制转换
>>> bin(5)  #转二进制
'0b101'
>>> oct(10)  #转八进制
'0o12'
>>> hex(17)  #转十六进制
'0x11'

#######################
>>> int('0b101',2)  #二进制转十进制
5
>>> int('0o12',8)   #八进制转十进制
10
>>> int('0x11',16)   #十六进制转十进制
17

 str() 可以将任意数据类型转成字符串类型
>>> res=str({'a':1})
>>> print(res,type(res))
{'a': 1} <class 'str'>


#但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
print(list('hello'))	#['h', 'e', 'l', 'l', 'o']

print(list({'k1':11,'k2':22,'k3':33}))  #['k1', 'k2', 'k3']