#################元组##################
# 元组: 带了紧箍咒的列表;
不可变数据类型,没有增删改查;
可以存储任意数据类型;
# 定义元组#
t = (1, 2.1, 2e+10, True, 2j+3, [1,2,3],(1,2,3) )
print(t, type(t))# 如果元组里面包含可变数据类型， 可以间接修改元组内容;
t1 = ([1,2,3], 4)
t1[0].append(4)
print(t1)
t2 = ()
t3 = tuple([]) #定义一个空元组
# 元组如果只有一个元素， 后面一定要加逗号, 否则数据类型不确定；
t4 = ('hello')
t5 = ('hello',)
print(type(t2), type(t3), type(t4), type(t5))
#元组的特性#
# 索引， 切片， 重复， 连接， 成员操作符
allowUsers=('root','cooffee','fentiao')
print(allowUsers[0])
print(allowUsers[-1])
print(allowUsers[1:])
print(allowUsers[:-1])
print(allowUsers[::-1])
print(allowUsers*3)
print(allowUsers+('floating','foot'))
print('cooffee'in allowUsers)
#for循环#
allowUsers = ('root', 'cooffee', 'fentiao')
allowPasswd = ('123', '456', '789')
print("显示".center(50,'*'))
for user in allowUsers: #for循环依次遍历
print("白名单用户:%s" %(user))
print("索引显示".center(50,'*'))
for index,user in enumerate(allowUsers): #for循环并且求索引(枚举)
print("第%d个白名单用户:%s" %(index+1,user))
print("显示所有信息".center(50,'*'))
for user,passwd in zip(allowUsers,allowPasswd): #zip: 集和用户名和密码两个元组， 元素之间一一对应
print(user,':',passwd)
#元组的常用方法#
• t.count(value)-->int
返回value在元组中出现的次数;
• t.index(value)
返回value在元组中的偏移量(即索引值)
#元组的应用场景#
1. 变量交换数值:
a = 1
b = 2b,a = a,b
#先把(a,b)封装成一个元组, (1,2)
#b,a = a,b ======> b,a =(1,2)
# b = (1,2)[0], a=(1,2)[1]
print(a,b)
2.打印变量值
name = 'cooffee'
age = 10
t = (name, age)
print("name: %s, age: %d" %(name, age))
print("name: %s, age: %d" %t)
3.元组的赋值: 有多少个元素， 就用多少个变量接收
t = ('cooffee', 10, 100)
name, age,score = t
print(name, age, score)
4.先对元组进行排序
scores = (100, 89, 45, 78, 65)
# scoresLi = list(scores)
# scoresLi.sort()
# print(scoresLi)
scores = sorted(scores) #注意这是一个列表
5.python3中可以用*middleScore接收中间的元素
#去掉一个最高分和最低分求平均分
scores = (100, 89, 45, 78, 65)
scores = sorted(scores)
minScore, *middleScore, maxScore = scores
print(minScore, middleScore, maxScore)
print("最终成绩为: %.2f" %(sum(middleScore)/len(middleScore)))
#################集合###################
# 集合里面的元素是不可重复的;
# 集合应用1： 列表去重
s = {1, 2, 3, 1, 2, 3}
print(s, type(s))
li = [1,2,3,1,2,3]
print(list(set(li)))
#集合的定义
s1={1}
s2={} #是字典
s3=set([])
print(type(s1),type(s2),type(s3))
#集合的特性#
# 索引， 切片， 重复， 连接， 成员操作符
# 集合支持的特性只有 成员操作符， 索引， 切片， 重复， 连接，均不支持;
# for循环#
s={1,2,3}
for i in s:
print(i, end='|')print()
for i, v in enumerate(s): #for循环并且求索引(枚举)
print("index: %s, value:%s" %(i, v))
#集合常用方法#
# 增加:
可变, 无序数据类型
添加的顺序， 和在集合中存储的顺序不同;
s={3,2,4}
s.add(1)
print(s)
s.update({7,8,9}) # # 增加多个元素
print(s)
# # 删除
s.remove(2) # # 删除指定的元素
print(s)s.pop()
print(s)
# 交集， 并集， 差集
s1 = {1, 2, 3}
s2 = {2, 3, 4}# 并集
print("并集：", s1.union(s2))
print("并集：", s1 | s2)# 交集
print("交集:", s1.intersection(s2))
print("交集:", s1 & s2)# 差集
print("差集:", s1.difference(s2)) # s1- (s1&s2)
print("差集:", s2.difference(s1)) # s2- (s1&s2)
print("差集:",s1-s2)
print("差集:",s2-s1)
# 对等差分: 并集-交集
print("对等差分:", s1.symmetric_difference((s2)))
print("对等差分:", s1^s2)#子集和父集关系
s3 = {1,2}
s4 = {1,2,3}
print(s3.issubset(s4)) #s3是s4子集
print(s3.issuperset(s4)) #父集
print(s3.isdisjoint(s4)) #s3和s4没有交集
###########字典############
#字典: key-value值, 键值对；
value值可以是任意数据类型: int,float,long, complex, list, tuple,set, dict
#定义字典:
- 定义空字典, {}, dict()
- 赋值: d = {'key':'value', 'key1':'value1'}
- 初始化所有value值: fromkeys()
- 根据已有的数据创建字典:
s={} #定义空字典
print(type(s))
s1=dict() #定义空字典
print(type(s1))
s2={'cooffee':[18,'happy'],'floating':[18,'sad']}
print(s2,type(s2))
s3=[1,2,3,4,5]
print({}.fromkeys(s3)) #fromkeys第一个参数可以列表/tuple/str/set， 将列表的每一个元素作为字典的key值，
print({}.fromkeys(s3,'666')) 第二个参数是key的value值，若无定义为None
# 字典的嵌套;
students = {
'13021001': {
'name':'张龙',
'age':18,
'score':100
},
'13021003': {
'name': '张',
'age': 18,
'score': 90
}
}print(students['13021001']['name'])
#工厂函数
d5 = dict(a=1, b=2)
print(d5)
#字典的特性#
# 索引， 切片， 重复， 连接， 成员操作符
字典没有索引，切片，重复，连接 ， 成员操作符， 默认判断key值是否存在.
d = dict(a=1, b=2)
print(d)
print('a' in d)
print(1 in d)
#for循环: 默认遍历字典的key值;
d=dict(a=1,b=2)
d = dict(a=1, b=2) for i in d: print(i) for i in d.items(): #可用次方法遍历得到value print(i) for i,v in enumerate(d): print(i, '-----', v) #枚举可求value
#字典的增删改查#
1.增加
d = dict(a=1, b=2,c=3,d=4)
# 添加或者更改key-value对
d['g'] = 10
d['a'] = 10
print(d)
# # update:
# 如果key值已经存在， 更新value值；
# 如果key值不存在， 添加key-value值;
d.update({'c':4, 'f':1})
print(d)
# # setdefault
# 如果key值已经存在， 不做修改;
# 如果key值不存在， 添加key-value值;默认情况下value值为None
d.setdefault('k', 10)
d.setdefault('d',12)
print(d)
2.删除
d = dict(a=1, b=2, c=3,d=4)
# pop:弹出指定key-value值
d.pop('a')
print(d)
# popitem
d.popitem()
print(d)
del d['c']
print(d)
d.clear()
print(d)
3.修改与查看
#查看
services = {
'http':80,
'mysql':3306
}
# 查看字典里面所有的key值
print(services.keys())# 查看字典里面所有的value值
print(services.values())# 查看字典里面所有的key-value值
print(services.items())
# 遍历
services = {
'http':80,
'mysql':3306
}
for k,v in services.items(): # k,v = ('http', 80)
print(k , '--->', v)
for k in services:
print(k, '--->', services[k])
# 查看指定key对应的value值, 注意: key不存在， 就会报错
services = { 'http':80, 'mysql':3306 }
print(services['http'])
# print(services['https']) ##会报错
# get方法获取指定可以对应的value值
如果key值存在， 返回对应的value值;
如果key值不存在， 默认返回None, 如果需要指定返回的值， 传值即可;
services = { 'http':80, 'mysql':3306 }
print(services.get('https', 'key not exist')) print(services.get('http'))
##########知识拓展############
#可变与不可变数据类型#
判别方法：该数据类型是否可以增删改查
# 可变数据类型:list, set, dict
# 不可变: 数值类型， str, tuple,数值，bool
#有序与无序数据类型
有序:str,list,tuple
无序：数值，bool,set
python2:dict无序 python3:dict有序
#列表的去重#
# 1. 列表去重：转换为集合
li = [1, 2, 3, 4, 65, 1, 2, 3]
print(list(set(li)))
# 2. 通过字典的方式去重
# ** 字典的key值是不能重复的.
li = [1, 2, 3, 4, 65, 1, 2, 3]
print({}.fromkeys(li).keys())
#python里面实现switch语句#
python里面是不支持switch语句的
C++:
char grade = 'B'
switch(grade)
{
case 'A':
print('')
break
case 'B':
print('')
break
default:
print('error')
}
"""
grade = 'A' d = { 'A': '优秀', 'B':'良好', 'C':"及格" } print(d.get(grade, "无效的成绩"))
