python07 内置结构list set dict tuple

# -*- coding: utf-8 -*-
"""
Created on Tue Jun 25 18:43:50 2019

@author: cheng
"""
#7.1传值与传地址的区别
def a(n):
    n[2]=300
    print(n)
    return None

def b(n):
     n = n + 180
     print(n)
     return None

an = [1,2,3,4,5,6]
bn = 9

print(an)
a(an)
print(an)

print(bn)
b(bn)
print(bn)    

结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
[1, 2, 300, 4, 5, 6]
9
189
9

#关于列表的函数
l = ['a','123','网']
print(l)
结果：
['a', '123', '网']

 -append插入一个内容
a = [i for i in range(1,5)]
print(a)
a.append(20)
print(a)
结果：
[1, 2, 3, 4]
[1, 2, 3, 4, 20]

 -insert：制定位置插入,插入位是index前面
print(a)
a.insert(3,666)
print(a)
结果：
[1, 2, 3, 666, 4, 20]

 -del删除
 -pop，从对位拿出一个元素，把最后一个元素取出来
last_pop = a.pop()
print(last_pop)
print(a)
结果：
20
[1, 2, 3, 666, 4]

 -remove:在列表中删除指定的值
 -如果被删除的值没在list,则报错
 -输出的id值是一样的
print(a)
print(id(a))
a.remove(666)
print(a)
print(id(a))
结果：
[1, 2, 3, 666, 4]
2168746010504
[1, 2, 3, 4]
2168746010504

 -clear:清空
 -如果id不需要，a = list[]即可
a.clear()
print(a)
print(id(a))
结果：
[]
2168746010504

 -reverse:翻转
a = [1,2,3,4,5]
print(a)
print(id(a))
a.reverse()
print(a)
print(id(a))
结果：
[1, 2, 3, 4, 5]
2168745975624
[5, 4, 3, 2, 1]
2168745975624

 -extend:扩展，拼接两个列表
b = [6,7,8,9,10]
a.extend(b)
print(a)
print(id(a))
结果：
[5, 4, 3, 2, 1, 6, 7, 8, 9, 10]
2168745975624

 -count():查找列表中指定值或者元素的个数
a.append(8)
a.insert(4,8)
print(a)
a_len = a.count(8)
print(a_len)
结果：
[5, 4, 3, 2, 8, 1, 6, 7, 8, 9, 10, 8]
3

 -copy:拷贝，浅拷贝
a = [1,2,3,4,5,666]
print(a)
b = a ####传地址
b[3]=777
print(a)
print(b)
结果：
[1, 2, 3, 4, 5, 666]
[1, 2, 3, 777, 5, 666]
[1, 2, 3, 777, 5, 666]

a = [1,2,3,4,5,666]
b = a.copy()
b[2] = 888
print(a)
print(b)
结果：
[1, 2, 3, 4, 5, 666]
[1, 2, 888, 4, 5, 666]
 -深拷贝与浅拷贝的区别
 -浅拷贝只是第一层
a = [1,2,3,[10,20,30]]
b = a.copy()
print(id(a))
print(id(b))
print(id(a[3]))
print(id(b[3]))
a[3][2] = 666
print(a)
print(b)
结果：
2168745856072
2168746008520
2168746006664
2168746006664
[1, 2, 3, [10, 20, 666]]
[1, 2, 3, [10, 20, 666]]

####元组
 -元组可以看成一个不可更改的list
#创建空元组
t = ()
print(type(t))
结果：

#创建多个值的元组
t = (1,2,3,4,5)
t1 = 1,2,3,4,5
print(type(t))
print(type(t1))
结果：

#元组的特性
 -有序性
 -元组数据值可以访问，不能修改
 -元组数据可以是任意类型
#索引操作
print(t[4])
结果：
5

#超标错误
print(t[10])
结果：
IndexError: tuple index out of range

#切片
t = (1,2,3,4,5,6,7,8)
t1 = t[1::2]
print(t1)

#序列相加
t1 = (1,2,3)
t2 = (4,5,6)

 -传地址操作，t1的地址改变
print(id(t1))
t1 = t1 + t2
print(t1)
print(id(t1))
结果：
2168725821408
(1, 2, 3, 4, 5, 6)
2168726882824

#元组相乘
t = (1,2,3)
t = t * 3
print(t)
结果：
(1, 2, 3, 1, 2, 3, 1, 2, 3)

#成员检测
t = (1,2,3)
if 2 in t:
    print('Yes')
else:
    print('No')
结果：
Yes

#元组遍历，一般采用for
 -1.单层元组遍历
t = (1,2,3,'youmi','i','0')
for i in t:
    print(i,end = ' ')
结果：
1 2 3 youmi i 0 

 -2.双层元组遍历
t = ((1,2,3),(4,5,6),('q','w','r'))
for i in t:
    print(i)

for  k,m,n in t:
    print(k,'--',m,'--',n)
结果：
(1, 2, 3)
(4, 5, 6)
('q', 'w', 'r')
1 -- 2 -- 3
4 -- 5 -- 6
q -- w -- r

#关于元组的函数
 -len:获取长度
t = (1,2,3,4,5)
len(t)
结果：
5

 -max,min:最大值，最小值
print(max(t))
print(min(t))
结果：
5
1

#tuple:转化或创建元组
l = [1,2,3,4,5]
t = tuple(l)
print(t)
结果：
(1, 2, 3, 4, 5)

#元组的函数
 -count：计算数据出现的次数
t = (2,1,2,5,1,2,4)
print(t.count(2))
结果：
3

 -index：在元组中的索引的位置
 -有多个时，返回第一个
print(t.index(2))
结果：
0

#元组变量交换法
  -两个变量的交换
a = 1
b = 3

c = a
a = b
b = c
print(a)
print(b)
 -python写法
a,b = b,a
print(a)
print(b)
结果：
3
1

#集合-set
 -集合是高中数学中一个概念
 -一堆确定的无序的唯一的数据，集合中的每一个数据为一个元素

s = set()
print(type(s))
print(s)
结果：

set()

 -大括号一定要有值
s = {1,2,3,4,5}
print(s)
结果：
{1, 2, 3, 4, 5}

#集合的特征
 -集合内数据无序，无法使用索引和分片
 -集合数据元素具有唯一性，可以用来排除重复数据
 -集合内的数据，str,intfloat,tuple
#集合序列操作
 -成员检测
s = {4,5,'p','sdf'}
if 5 in s:
    print('Yes')
结果：
Yes

#集合便利操作
 -for循环
s = {4,5,'p','sdf'}
for i in s:
    print(i,end=' ')
结果：
p sdf 4 5 

  -带有元组的集合遍历
t = {(1,2,3),(4,5,6),('q','w','r')}
for i in t:
    print(i)

for  k,m,n in t:
    print(k,'--',m,'--',n)
结果：
(4, 5, 6)
('q', 'w', 'r')
(1, 2, 3)
4 -- 5 -- 6
q -- w -- r
1 -- 2 -- 3

#集合的内涵
 -普通集合内涵
 -在初始化后自动过滤重复元素
s = {23,223,545,3,2,1,2,3,4,2,3,1,2}
print(s)
结果：
{545, 2, 3, 1, 4, 23, 223}

 -带有条件的集合内涵
ss = {i for i in s if i % 2 == 0}
print(ss)
结果：
{2, 4}

 -多循环的集合内涵
s1 = {1,2,3}
s2 = {'q','w','e'}
s = {m*n for m in s2 for n in s1}
print(s)
结果：
{'www', 'qqq', 'q', 'ww', 'e', 'w', 'qq', 'ee', 'eee'}

#集合函数/关于集合的函数
 - len,max,min：跟其他函数一致
 -set:生成一个集合
l = [1,2,3,4,2,3]
s = set(l)
print(s)
结果：
{1, 2, 3, 4}

 -add:向集合内添加元素
s = {1}
s.add(234)
print(s)
结果：
{1, 234}

 -clear:清除，只清空数据
s = {1,2,3}
print(s)
print(id(s))
s.clear()
print(s)
print(id(s))
结果：
{1, 2, 3}
2168745962184
set()
2168745962184

 -copy：拷贝
 -remove:移除定制的值，直接改变原有值，如果删除的值不存在，报错
 -discard：移除集合中指定的值，跟remove一样

s = {23,4,2,3,5,2,3,1}
s.remove(4)
print(s)
s.discard(1)
print(s)
结果：
{1, 2, 3, 5, 23}
{2, 3, 5, 23}

 -pop:随机移除一个元素
s = {23,4,2,3,5,2,3,1}
s.pop()
print(s)
结果：
{2, 3, 4, 5, 23}

#集合函数
 -intersection：交集
 -difference:差集
 -union:并集
 -issubset:检查一个几个是否为另一个子集
 -issuperset:检查一个几个是否为另一个超集

s1 = {1,2,3,4,5}
s2 = {5,6,7,8,9}

s_1 = s1.intersection(s2)
print(s_1)

s_2 = s1.difference(s2)
print(s_2)

s_3 = s1.issubset(s2)
print(s_3)
结果：
{5}
{1, 2, 3, 4}
False

#frozen set：冰冻集合
 -冰冻和就是不可以进行任何修改的集合
 -frozenset是一种特殊的集合
s = frozenset()
print(s)
结果：
frozenset()

#####dist字典
 -字典是一种组合数据，没有顺序，以键值对形式出现
 -字典的创建
d = dict()
print(d)

d = {'one':1,'two':2,'three':3}
print(d)
d = dict(one=1,two=2,three=3)
print(d)
结果：
{'one': 1, 'two': 2, 'three': 3}

#字典的特征
 -字典是序列类型，但是无序，所以没有分片
 -字典中的数据每个都是键值对组成
 -key:必须是可哈希的值
 -value：任何值
 
#字典常见操作
 -访问数据
d = {'one':1,'two':2,'three':3}
print(d['one']) 
结果：
1

d['one'] = 'eins'
print(d)
结果:
{'one': 'eins', 'two': 2, 'three': 3}

 -del删除操作
del d['one']
print(d)
结果：
{'two': 2, 'three': 3}

 -成员检测，检测是key内容
d = {'one':1,'two':2,'three':3}
if 2 in d:
    print('value')

if 'two' in d:
    print('key')

if ('two',2) in d:
    print('kv')
结果：
key
 
#字典生成式
d = {'one':1,'two':2,'three':3}
dd = {k:v for k,v in d.items()}
print(dd)

dd = {k:v for k,v in d.items() if v % 2 == 0}
print(dd)
结果：
{'two': 2}

#字典相关函数
 -len,max，min,dict
 -str(字典)：返回字典的字符创格式
 -clear:清空字典
 -items:返回字典的键值对组成的元组格式
d = {'one':1,'two':2,'three':3}
i = d.items()
print(type(i))
print(i)
结果：

dict_items([('one', 1), ('two', 2), ('three', 3)])

 -keys:返回字典的键组成的一个结构
k = d.keys()
print(type(k))
print(k)
结果：

dict_keys(['one', 'two', 'three'])

 -values:一个可迭代的结构
v = d.values()
print(type(v))
print(v)
结果：

dict_values([1, 2, 3])

 -get:根据指定键返回相应的值
d = {'one':1,'two':2,'three':3}
print(d.get('on333'))
print(d.get('one',100))
结果：
None
1

 -fromkeys:使用制定的序列作为键，使用一个值作为字典的所有的键的值
l = ['eins','zwei','drei']
d = dict.fromkeys(l,'hahahha')
print(d)
结果：
{'eins': 'hahahha', 'zwei': 'hahahha', 'drei': 'hahahha'}