python的元组、集合和字典

#################元组##################

# 元组: 带了紧箍咒的列表;
不可变数据类型,没有增删改查;
可以存储任意数据类型;

# 定义元组#

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 = 2

b,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, "无效的成绩"))

python的元组、集合和字典

猜你喜欢