初学python之路-day07-数据类型总结

数据类型的各种使用方法：
#1.字符串类型
s='abcdef'
s1=s[0]
s2=s[-1]
print(s1,s2) #h d 索引取值，正向，反向
a = 10
b = "20"
c = True
res = "%s%s%s" % (a, b, c)
print(res) # res = "1020True" 字符串拼接
print(len(s)) # 6
#切片[start:end;step] 根据索引来进行字符串切片的操作 取头不取尾
print(s[0:2:]) # ab #切片 根据索引来进行字符串切片的操作
#可反向取值，从-1开始，步长设为负值
print(s[-1:-6:-1]) #fedcb
#成员运算 in | not in
print('a'in s) #True
print('a' not in s) #False
# 遍历取值：
s='abcdef'
for i in s: # 遍历 循环取值 把s里面的字符循环取出赋值给i
print(i, end='') # abcdef
print()
print(s.index('c',1,4)) #2 index取c在1，4之内第一次出现的索引位置
# 去留白strip() 默认去两端留白，也可以去指定字符
s2 = '***好 * 的 ***'
print(s2.strip('*')) #好 * 的
#计算子字符串个数
s3 = '12312312'
print(s3.count('123')) #2

# 判断字符串是否是数字:只能判断正整数(自然数）
s4 = '123'
print(s4.isdigit())#True
# 大小写转换
s5 = "AbC def"
print(s5.upper()) # 全大写ABC DEF
print(s5.lower()) # 全小写abc def
# 了了解
print(s5.capitalize()) # 首字母大写Abc def
print(s5.title()) # 每个单词首字母大写Abc Def

# 以某某开头或结尾
s6 = 'https://www.baidu.com'
r1 = s6.startswith('https:')
r2 = s6.startswith('http:')
r3 = s6.endswith('com')
r4 = s6.endswith('cn')
if (r1 or r2) and (r3 or r4):
print('合法的链接') #合法的链接
else:
print('非合法的链接')
# 替换
s7 = 'egon say: he is da shuai b，egon！egon！egon！'
new_s7 = s7.replace('egon', 'Liu某') # 默认替换所有
print(new_s7) #Liu某 say: he is da shuai b，Liu某！Liu某！Liu某！
new_s7 = s7.replace('egon', 'Liu某', 1) # 替换一次
print(new_s7)#Liu某 say: he is da shuai b，egon！egon！egon！

# 格式化
# 默认按位置
s8 = 'name：{}，age：{}'
print(s8.format('Owen', 18)) #name：Owen，age：18
# 标注位置，一个值可以多次利用
print('name：{1}，age：{1}, height：{1}'.format('Owen', 18)) #name：Owen，age：18
# 指名道姓
print('name：{n}，age：{a}, height：{a}'.format(a=18, n="Zero")) #name：Zero，age：18, height：18
# 了解
st1='abcdef'
# 1. find | rfind：查找子字符串索引，无结果返回-1
print(st1.find('k')) # -1
# 2. lstrip：去左留白
# 3. rstrip：去右留白
# 4. center | ljust | rjust | zfill：按位填充
# 语法：center(所占位数, '填充符号')
print(st1.center(20,'*'))#*******abcdef*******
print(st1.ljust(20,'*' ))#abcdef**************
print(st1.rjust(20, '*'))#**************abcdef
# 5. expandtabs：规定\t所占空格数
print(st1.expandtabs( ))#abcdef
# 6. captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转
# 7. isdigit | isdecimal | isnumeric：数字判断
s1='1234'
print(s1.isdigit())#True
# 8. isalnum | isalpha：是否由字母数字组成 | 由字母组成
print(st1.isalnum())#True
print(st1.isalpha())#True
# 9. isidentifier：是否是合法标识符
# 10. islower | isupper：是否全小 | 大写
# 11. isspace：是否是空白字符
# 12. istitle：是否为单词首字母大写格式
print(isinstance(s1,int))#False
print(isinstance(s1,str))#True

# 2.列表类型
# 1.索引取值: 列表名[index]
s1 = [1, 3, 2]
print(s1[0])#1
print(s1[-1])#2

# 2.列表运算: 得到的是新list
s2 = [1, 2, 3]
print(s2 + s2)#[1, 2, 3, 1, 2, 3]
print(s2 * 2)#[1, 2, 3, 1, 2, 3]
print(s2)#[1, 2, 3, 1, 2, 3]

# 3.list的长度
s3 = [3, 4, 1, 2, 5]
print(len(s3))#5

# 4.切片：[start_index:end_index:step]
s4 = [3, 4, 1, 2, 5]
new_s4 = s4[::-1]
print(new_s4)#[5, 2, 1, 4, 3]
new_s4 = s4[1:4:]
print(new_s4)#[4, 1, 2]
new_s4 = s4[-2:-5:-1]
print(new_s4)#[2, 1, 4]

# 5.成员运算：in
s5 = [3, 4, '1', 2, 5]
print('1' in s5)#True
print(1 in s5)#False
print(5 not in s5)#False

# 6.循环
for v in s5:
print(v, type(v))
# 3 <class 'int'>
# 4 <class 'int'>
# 1 <class 'str'>
# 2 <class 'int'>
# 5 <class 'int'>
# 只打印数字类型的数据******
for v in s5:
if isinstance(v, int):
print(v, end=' ')#3 4 2 5

# 1.列表的增删改查
ls = [1, 2, 3]

# 查
print(ls)
print(ls[1])#可以根据索引来取出里面的值

# 增
ls.append(0) # 末尾增
print(ls)#[1, 2, 3, 0]
ls.insert(1, 666) # 任意index前增
print(ls)#[1, 666, 2, 3, 0]
ls.insert(len(ls), 888) # insert实行末尾增
print(ls)#[1, 666, 2, 3, 0, 888]
# 改
ls[1] = 66666
print(ls)#[1, 66666, 2, 3, 0, 888]
# 删
ls.remove(888)
print(ls)#[1, 66666, 2, 3, 0]
res = ls.pop() # 默认从末尾删，并返还删除的值
print(res)#0
res = ls.pop(1) # 从指定索引删除，并返还删除的值
print(res, ls)#66666 [1, 2, 3]
# 了了解
del ls[2]
print(ls)#[1, 2]
# 清空
ls.clear()
print(ls)#[]

# 1）排序: 针对于同类型
ls = ['3', '1', '2']
ls.sort() # 默认正向排序
print(ls)#['1', '2', '3']
ls.sort(reverse=True) # 正向排序结果上翻转，形成倒序
print(ls)#['3', '2', '1']

# 2）翻转
ls = ['3', '1', '2']
ls.reverse() # 按存储的顺序进行翻转
print(ls)#['2', '1', '3']

# 3）计算值的个数 => 列表中可以存放重复数据
ls = [1, 2, 1, 2, 3, 1]
print(ls.count(1)) # 对象1存在的次数3

# 1）整体增加，添加到末尾
ls = [1, 2, 3]
ls.extend('123')
print(ls)#[1, 2, 3, '1', '2', '3']
ls.extend([0, 1, 2])
print(ls)#[1, 2, 3, '1', '2', '3', 0, 1, 2]

# 2) 目标的索引位置，可以规定查找区间
ls = [1, 2, 1, 2, 3, 1]
# 找对象1，在索引3开始往后找到索引6之前
ind = ls.index(1, 3, 6)
print(ind)#5

# 3.元组
# 元组类型的操作 可以理解为不可变的列表
#值可以为任意类型的值
#可以存放多个值- 可以进行成员运算
#可以存放重复的值- 可以计算成员出现的次数
#有序存储 索引取值，可以切片

t1=(1,'adc',['a',1])
t2=('a','c','b')
print(t1[0]) #元组可以通过索引 取值 所以元组是有序排列的
print(t1+t2) #元组之间可以相加
print(len(t1)) #元组的长度
print(t1[0:1:1]) #正向切
print(t1[::-1]) #反向切
print('a' in t1) #成员运算
for x in t1: #遍历循环取值
print(x)
print(t1.count(1))# 1在元组中存在的个数
print(t1.index(['a',1])) #对象的索引值

# 4.字典
# 定义为一个存放多个值的容器
# # 字典属于双列容器，以key:value 的形式存放 key为不可变类型的数据 value可以为任何的数据类型

d1={}#定义空字典
dic1=dict()# 定义空字典的另一种方式

d2=dict({'s':1})#map映射创建
d3=dict(name='dd') # name=变量名 赋值的方式
d4={}.fromkeys('abc',0)#对象只能是可迭代的 key只能指定一个
print(d1,d2,d3,d4)
# key 要确保唯一性，必须为不可变 类型；value为任意类型
#1.可变 2.没有索引 用key取值3无序的
dic5={'a':1,'b':2} #字典通过Key来取得value 如果key不在字典中 则新增key：value
dic5['c']=123 # 如果key存在 则可以修改key对应的value
print(dic5)
print(dic5['c']) # 取字典中的key 如果有可以取得对应的key
# print(dic5['d']) #如果有可以取得key对应的如果没有则报错

# 增删改查：d1.update(d2) | d1.setdefault(key,d_value) | get(key,default)
# pop(key) clear
print(dic5.get('c','返还'))# 取字典中的KEY 如果有返还KEY的value 如果没有返还自定义的值
dic5.pop('a') #指定删除字典中KEY的VALUE 并能返还VALUE
print(dic5)
print(dic5.popitem())# 删除末尾的 并返还成（key,value)类型
dic6={'a':1,'b':20,'c':1} #更新dic6 如果dic7里面的相同的K dic6k的value则替换为dic7 k的value
dic7={'a':10,'b':20}
dic6.update(dic7) #如果dic7里面有新的K 则dic6里面加入新的k:value
print(dic6)

dic6.setdefault('a',100) #如果dic6有'a'存在啥事不干
print(dic6)
dic6.setdefault('d',100) #如果dic6没有'd'则添加 'd':100
print(dic6)

# 循环：keys() values() items()
#字典的成员运算完成的就是key是否在目标字典中
for x in dic6: #循环得到是dic6中key的值
print(x)
print(dic6.keys)
for x in dic6.keys(): #循环k的值
print(x)
print(dic6.values())
for x in dic6.values(): #循环k的value
print(x)
print(dic6.items()) #循环 k value 以元组的形式打印出来
for x in dic6.items():
print(x,type(x))
for k ,v in dic6.items(): #把字典中Key 的值给 k 字典中Value的值给v 打印出来
print(k,v,type(k),type(v))
# 解压赋值
a, _, _, b = (1, 2, 3, 4)
print(a,b)

#
# 集合：set不能取值
s=set()
# # 1.可变-可增可删
# 2.无序,无索引,无key，不能取值，不能改值
# 3.for可以对集合取值，但是取值结果顺序不确定
# 不可以存放重复数据，因此意义是’去重‘
#
s.add('1')
s.add('2')
print(s)
s.update({2,'3'})# 重复的剔除 新的新增
print(s)
# s.pop() #随机删除
# print(s)
s.remove(2) #指定删除对象
print(s)
s.clear() #清空集合
print(s)

se1={'a','b','c','egon'}
se2={'x','y','z','egon'}
print(se1.intersection(se2)) #两个集合的交集
print(se1.union(se2)) #两个集合的合集
print(se1.symmetric_difference(se2)) #除去共有的
print(se1.difference(se2)) # 独有的
se11={'a','b','c','egon'} #一定要包含的关系才能比较
se22={'egon'}
print(se11>se22)