python-数据类型-元祖&字符串&集合&文件操作1

1、字典打印

d = {'xiaohei':'123','xiaobai':'456'}
print(d)
print(d.items())
print("*"*50)
# 打印字典
# 方法1：更高效
for key in d:
    value = d.get(key)
    print('%s:%s'%(key,value))
print("*"*50)
# 方法2
for key,value in d.items():
    print('%s:%s'%(key,value))

运行结果：

 

 

 

 

2、元组

t = (1,2,3)

# 读取
print(t[0])
print(t[-1])

# 循环打印
for i in t:
    print(i)

# 一个元素的元组：注意逗号是必须的
t2 = ('lzh',)
print(t2)

 

t = (1,2,3)
# 特点：不能改变
t[0] = 3
print(t)

运行结果：

 

 

 

 

 

 

3、切片

l = list(range(1,11))  # 结果：1-10
print(l)

print(l[0:5])  # 顾头不顾尾，结果：1-5
print(l[:5])  # 从第一个开始取，结果：1-5

print(l[5:10])  # 结果：6-10
print(l[5:])  # 取到末尾，结果：6-10

print(l[0:10:2])  # step步长，结果：1、3、5、7、9
print(l[::2])  # 结果：1、3、5、7、9

print(l[::-1])  # 从后往前取，结果：10-1
print(l[::-2])  # 结果：10、8、6、4、2

print(l[0:11:-1]) # 无数据返回，下标统一用正数或负数
print(l[-1:-11:-1])  # 10-1

# 只要有下标的都可以用切片取值
s = 'abcdefg'
print(s[::2])  # 结果：aceg
print(s[::-1])  # 结果：gfedcba

 

 

4、字符串常用方法

s = "lzhtest"
print(s.count('t'))  # 统计t出现的次数，结果：2

print(s.index('t'))  # 返回t第一次出现的下标，结果：3
print(s.index('t',4))  # 返回t从下标4以后第一次出现的下标，结果：6

# 如果元素不存在，find()返回-1；index()抛出异常
print(s.find('o'))
print(s.index('o'))

s1 = "  lzhtest  \n"
# 默认去掉字符串两边的空格和换行符
print(s1)
print(s1.strip())

# 去掉左边的空格和换行符
print(s1.lstrip())

# 去掉左边的空格和换行符
print(s1.rstrip())

s = "lzhtest"

print(s.startswith('l'))  # s是否以l开头，结果：True
print(s.endswith('t'))  # s是否以t结果，结果：True

print(s.lower())  # s全部小写，结果：lzhtest
print(s.upper())  # s全部大写，结果：LZHTEST

s3 = 'lzhtest'

# 替换字符
print(s3.replace('lzh','zsb'))  # 结果：zsbtest
print(s3.replace('t',''))   # 结果：lzhes，替换所有t
print(s3.replace('t','',1))   # 结果：lzhest，替换第一个t

s = '123'
s1 = '123a'
print(s.isdigit())  # 判断是否是数字，结果：True
print(s1.isdigit())  # 判断是否是数字，结果：False

# s.join():连接字符串
l = ['zsb','lzh','zrh']

print(','.join(l))  # 结果：zsb,lzh,zrh
print('='.join(l))  # 结果：zsb=lzh=zrh

l3 = 'abcdefg'
print(','.join(l3))  # 结果：a,b,c,d,e,f,g

l2 = [1,2,3,4,5,6]
print(','.join(l2))  # 报错，提示非字符串

# s.split()：分割字符串

s='lzh,zsb'
print(s.split(','))  # 结果返回一个列表：['lzh', 'zsb']

s1 = 'lzh zsb'
print(s1.split())  # 默认以空格分割，结果：['lzh', 'zsb']

s2 = 'lzh.zsb'
print(s2.split('.'))  # 结果：['lzh', 'zsb']

 

 

5、集合

# 集合
# 1、集合天生可以去重
# 2、集合是无序的

s1 = {}  # 空字典
print(type(s1))  #结果：<class 'dict'>
s2 = set()  # 空集合
print(type(s2))  # 结果：<class 'set'>

s = {1,2,3,4,5,6,7,7,6,1}
print(s)  # 结果：{1, 2, 3, 4, 5, 6, 7}

# 列表去重：列表转换为字典，然后在转换为列表
l = [1,2,3,4,5,6,7,7,6,1]
l = list(set(l))
print(l)  # 结果：[1, 2, 3, 4, 5, 6, 7]

s = {1,2,3,4,5,6,7,7,6,1}
# 添加元素
s.add(8)
print(s)  # 结果：{1, 2, 3, 4, 5, 6, 7, 8}

# 把另外一个集合加入这个集合里面
s.update({4,5,6})
print(s)  # 结果：{1, 2, 3, 4, 5, 6, 7, 8}

# 删除指定的元素
s.remove(4)
print(s)  # 结果：{1, 2, 3, 5, 6, 7, 8}

# 关系测试，交集、并集、差集、对称集合
l1 = [1,2,3,4]  # 学自动化的学生
l2 = [2,4,5,6]  # 学性能的学生

l1 = set(l1)
l2 = set(l2)

# 取交集，就是两个集合里面相同的元素
print(l1 & l2)  # 结果：{2, 4}
print(l1.intersection(l2))

# 并集,就是把两个结合合并在一起
print(l1 | l2)  # 结果：{1, 2, 3, 4, 5, 6}
print(l1.union(l2))

# 差集:在a结合里面存着，在b集合不存在
print(l1-l2)  # 结果:{1, 3}
print(l1.difference(l2))
print(l2-l1)  # 结果：{5, 6}

# 对称差集:把a集合和b集合里面相同的元素去掉后，剩下的
print(l1 ^ l2)  # 结果：{1, 3, 5, 6}
print(l2.symmetric_difference(l1))  # 结果：{1, 3, 5, 6}

l3 = list(range(1,11))
l3 = set(l3)
l2 = [2,4,5,6]
l2 = set(l2)
print(l3)  # 结果：{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
print(l2)  # 结果：{2, 4, 5, 6}

# 判断l3是l2是的父集合
print(l3.issuperset(l2))  # 结果：True

# 判断l2是l3的子集合
print(l2.issubset(l3))  # 结果：True

 

 

6、文件操作

# 1、打开文件；2、读、写文件；3、关闭文件
# 打开模式：r：只读模式；w：写模式；a：追加模式
f = open('a.txt','r',encoding='utf-8')

# # 读文件,获取文件里面的全部内容
# result = f.read()
# print(result)

# # 读取文件，一次只读一行
# result = f.readline()
# print(result)

# 读取文件所有行到一个list，每行的内容是list的一个元素
result = f.readlines()
print(result)

f.close()

f = open('a.txt', 'w', encoding='utf-8')
# 写文件
f.write('lion')
f.close()

f = open('a.txt', 'a', encoding='utf-8')
l = ['tadpole\n','fish']
f.write("\n")
f.writelines(l)
f.close()