Python--------元组，集合，字典

1."=="和"is"区别
变量:
    id: 在内存中存储的位置;id(a)
    value:列表或者元组
    type:变量的数据类型; type(a)
is: 三个都判断

a is b ====> True, a==b一定相等， 返回True;

==判断value和type
a==b ====> True, a is b 不一定;
a = '1'
b = 1
a == b
False

a = '1'
b = a
a is b
True

li = [1,2,3]
li1 = li
li == li1
True
li is li1
True

li2 = li.copy()
id(li)
140198653811208
id(li2)
140198653810120

li=[1, 2, 3]
li2[1, 2, 3]
li == li2
True
li is li2
False

2.深拷贝和浅拷贝

 深拷贝和浅拷贝的区别?

直接赋值(li1 = li): 只传递对象的引用， li1指向对象li的内存地址空间,
因此， 原有列表li改变， 被赋值的li1也会做相应的改变.

浅拷贝(三种实现方式 eg： li2=li.copy()):li和li2的内存地址不同,
但是子对象的内存地址相同, 因此,原始数据改变 ， 子对象也改变.

深拷贝(import copy, eg: li3=copy.deepcopy(li)), li和li3的内存地址不同，
 包含子对象的拷贝， 所以原始对象改变并不会造成深拷贝里面任何子项的改变.

 当深拷贝和浅拷贝， 针对的对象全部是不可变数据类型时， 两者效果相同;
 当深拷贝和浅拷贝， 针对的对象包含是可变数据类型时， 两者才有上述区别;

li = [1,2,3]
li1 = li
li.append(4)
li
[1, 2, 3, 4]
li1
[1, 2, 3, 4]

li2 = li[:]
li3 = li.copy()
li
[1, 2, 3, 4]

列表里面嵌套列表
li = [['a', 'b'], 2, 3, 4]
li2 = li[:]
li3 = li.copy()
id(li), id(li1), id(li2),id(li3)
(140198666531528, 140198653810888, 140198653810824,140198653949512)

([['a', 'b'], 2, 3, 4, 5], [['a', 'b'], 2, 3, 4], [['a', 'b'], 2, 3, 4])

li[0].append('c')

([['a', 'b', 'c'], 2, 3, 4, 5], [['a', 'b', 'c'], 2, 3, 4], [['a', 'b', 'c'], 2, 3, 4])

li = [['a', 'b'], 1,2]
li2 = li.copy()
li
[['a', 'b'], 1, 2]
li2
[['a', 'b'], 1, 2]
id(li[0])
140198666473736
id(li2[0])
140198666473736

3.元组

【1】元组的创建

 元组: 带了紧箍咒的列表;

           不可变数据类型,没有增删改查;可以存储任意数据类型;

定义元组
t = (1, 2.1, 2e+10, True, 2j+3, [1,2,3],(1,2,3) )
print(t, type(t))

如果元组里面包含可变数据类型， 可以间接修改元组内容;
t = ([1,2,3], 4)
t[0].append(4)
print(t)

元组如果只有一个元素， 后面一定要加逗号, 否则数据类型不确定；
t4 = ('hello')
t5 = ('hello',)
print( type(t4), type(t5))

【2】元组的特性

 索引， 切片， 重复， 连接， 成员操作符

allowUsers = ('root', 'westos', 'fentiao')
allowPasswd = ('123', '456', '789')

索引，切片

print(allowUsers[0])
print(allowUsers[-1])
print(allowUsers[1:])
print(allowUsers[2:])
print(allowUsers[:-1])
print(allowUsers[::-1])

重复
print(allowUsers*3)

连接，
print(allowUsers + ('fensi', 'fendai'))

成员操作符
print('westos' in allowUsers)
print('westos' not in allowUsers)

 for循环
print("显示".center(50, '*'))
for user in allowUsers:
    print("白名单用户:%s" %(user))

print("索引显示".center(50, '*'))

 for循环并且求索引(枚举)
for index,user in  enumerate(allowUsers):
    print("第%d个白名单用户: %s" %(index+1, user))

zip: 集和用户名和密码两个元组， 元素之间一一对应
for user, passwd in  zip(allowUsers, allowPasswd):
    print(user,':', passwd)

【3】元组应用场景

 变量交换数值:
a = 1
b = 2

b,a = a,b

1. 先把(a,b)封装成一个元组, (1,2)
2. b,a = a,b ======> b,a =(1,2)
 b = (1,2)[0], a=(1,2)[1]
print(a,b)

 打印变量值
name = 'westos'
age = 10
t = (name, age)
print("name: %s, age: %d" %(name, age))
print("name: %s, age: %d" %t)

元组的赋值: 有多少个元素， 就用多少个变量接收
t = ('westos', 10, 100)
name, age,score  = t
print(name, age, score)

scores = (100, 89, 45, 78, 65)
先对元组进行排序
 scoresLi = list(scores)
 scoresLi.sort()
 print(scoresLi)

python3中
minScore, *middleScore, maxScore = scores
print(minScore, middleScore, maxScore)
print("最终成绩为: %.2f" %(sum(middleScore)/len(middleScore)))

4.集合

【1】集合的定义

集合里面的元素是不可重复的;
s = {1, 2, 3, 4, 1, 2, 3}
print(s, type(s))

s1 = {1}
print(s1, type(s1))

如何定义一个空集合?
s2 = {}   # 默认情况是dict， 称为字典
print(s2, type(s2))

 定义一个空集合.
s3 = set([])
print(s3, type(s3))

集合应用1： 列表去重
li = [1,2,3,1,2,3]
print(list(set(li)))

【2】集合特性

特性： 索引， 切片， 重复， 连接， 成员操作符

集合支持的特性只有 成员操作符， 索引， 切片， 重复， 连接，均不支持;

s = {1,2,3}

print(1 in {1,2,3})
print(1 not in {1,2,3})

for循环
for i in s:
    print(i, end='|')

print()

for i, v in enumerate(s):
    print("index: %s, value:%s" %(i, v))

【3】集合常用方法

 s = {6, 7, 3, 1,2,3}
可变, 无序数据类型
 添加的顺序， 和在集合中存储的顺序不同;
 增加:
s.add(1)
print(s)

 增加多个元素
 s.update({7,8,9})
 print(s)

删除
 s.pop()
print(s)
 删除指定的元素
 s.remove(2)
 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))        ##子集
print(s3.issuperset(s4))    ##父集
print(s3.isdisjoint(s4))       ##是否有交集

5.字典

【1】字典的定义

总结: 定义字典:
 定义空字典, {}, dict()
 赋值: d = {'key':'value', 'key1':'value1'}
 初始化所有value值: fromkeys()
 根据已有的数据创建字典:

users = ['user1', 'user2']
passwds = ['123', '456']
zip(users, passwds)

list(zip(users, passwds))
[('user1', '123'), ('user2', '456')]
userinfo = dict(zip(users, passwds))
userinfo
{'user1': '123', 'user2': '456'}

s = {}
print(type(s))

s = {
    'fentiao':[100, 80, 90],
    'westos':[100,100,100]
}
print(s, type(s))

d = dict()
print(d, type(d))

d = dict(a=1, b=2)
print(d, type(d))

cardinfo = {
    '001':'000000',
    '002':'000000',
}

# 随机生成100张卡号， 卡号的格式为610 334455 001 ---610 334455 100

cards = []
for cardId in range(100):
    card = "610 334455 %.3d" %(cardId+1)
    cards.append(card)
print(cards)
print({}.fromkeys(cards))
print({}.fromkeys(cards, '666666'))

定义空集合， 必须set(),
 {}默认的类型为字典;
d = {}
print(type(d))

字典: key-value值, 键值对；
 value值可以是任意数据类型: int,float,long, complex, list, tuple,set, dict
d = {
    '王旭': [18, '男', "请假"],
    '张龙': [18, '男', '俯卧撑']
}

print(d['张龙'])

d2 = {
    'a': 1,
    'b': 2
}

print(d2)

d3 = {
    'a': {1, 2, 3},
    'b': {2, 3, 4}
}
print(d3)

 字典的嵌套;
students = {
    '13021001': {
        'name':'张龙',
        'age':18,
        'score':100
    },
    '13021003': {
        'name': '张',
        'age': 18,
        'score': 90
    }
}
print(students['13021003']['name'])

工厂函数;
l = list([1,2,3])
print(l)

d5 = dict(a=1, b=2)
prrint(d5)

字典必须是不可变数据类型;d = {[1,2,3]:1}(x)

可变数据类型:list, set,  dict
 不可变: 数值类型， str, tuple

【2】字典的特性

 字典不支持索引， 切片， 重复，连接

 成员操作符， 默认判断key值是否存在.
print('a' in d)
print(1 in d)

 for循环: 默认遍历字典的key值;
for i in d:
    print(i)

【3】字典的增加，删除，修改查看

增加

d = dict(a=1, b=2)

添加或者更改key-value对
d['g'] = 10
d['a'] = 10
print(d)

 update:
如果key值已经存在， 更新value值；
如果key值不存在， 添加key-value值;
d.update({'a':4, 'f':1})
print(d)

 setdefault
如果key值已经存在， 不做修改;
如果key值不存在， 添加key-value值;默认情况下value值为None
 d.setdefault('g', 10)
 print(d)

删除

d = dict(a=1, b=2, c=3)

 pop:弹出指定key-value值
 d.pop('a')
print(d)

 popitem      ##随机删除
 d.popitem()
 print(d)

del d['a']
 print(d)

d.clear()
print(d)

查看修改

services = {
    'http':80,
    'mysql':3306
}

 查看字典里面所有的key值
print(services.keys())

查看字典里面所有的value值
print(services.values())

 查看字典里面所有的key-value值
print(services.items())

 遍历
for k,v in services.items(): # k,v = ('http', 80)
    print(k , '--->', v)

for k in services:
    print(k, '--->', services[k])

 查看指定key对应的value值, 注意: key不存在， 就会报错
print(services['http'])
 print(services['https'])

if 'https' in services:
     print(services['https'])
 else:
     print('key not exist')

get方法获取指定可以对应的value值
 如果key值存在， 返回对应的value值;
 如果key值不存在， 默认返回None, 如果需要指定返回的值， 传值即可;
print(services.get('https', 'key not exist'))

【4】应用 列表去重

 1. 列表去重：转换为集合
li = [1, 2, 3, 4, 65, 1, 2, 3]
print(list(set(li)))

2. 通过字典的方式去重
 ** 字典的key值是不能重复的.
 d = {'a':1, 'b':2}
 d['a'] = 3

li = [1, 2, 3, 4, 6, 1, 2, 3]
print({}.fromkeys(li).keys())

【5】python通过字典的间接方式实现swith语句

python里面不支持switch语句;
 C/C++/Java/Javascript:switch语句是用来简化if语句的.

grade='D'
d = {
    'A': '优秀',
    'B':'良好',
    'C':"及格"
}
if grade in d:
    print(d[grade])
 else:
    print("无效的成绩")

print(d.get(grade, "无效的成绩"))