python 学习之集合 三元运算 深浅拷贝

一 集合 set 

set集合，是一个无序且不重复的元素集合

class set(object):
    """
    set() -> new empty set object
    set(iterable) -> new set object
     
    Build an unordered collection of unique elements.
    """
    def add(self, *args, **kwargs): # real signature unknown
        """
        Add an element to a set，添加元素
         
        This has no effect if the element is already present.
        """
        pass
 
    def clear(self, *args, **kwargs): # real signature unknown
        """ Remove all elements from this set. 清楚内容"""
        pass
 
    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a set. 浅拷贝  """
        pass
 
    def difference(self, *args, **kwargs): # real signature unknown
        """
        Return the difference of two or more sets as a new set. A中存在，B中不存在
         
        (i.e. all elements that are in this set but not the others.)
        """
        pass
 
    def difference_update(self, *args, **kwargs): # real signature unknown
        """ Remove all elements of another set from this set.  从当前集合中删除和B中相同的元素"""
        pass
 
    def discard(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set if it is a member.
         
        If the element is not a member, do nothing. 移除指定元素，不存在不保错
        """
        pass
 
    def intersection(self, *args, **kwargs): # real signature unknown
        """
        Return the intersection of two sets as a new set. 交集
         
        (i.e. all elements that are in both sets.)
        """
        pass
 
    def intersection_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the intersection of itself and another.  取交集并更更新到A中 """
        pass
 
    def isdisjoint(self, *args, **kwargs): # real signature unknown
        """ Return True if two sets have a null intersection.  如果没有交集，返回True，否则返回False"""
        pass
 
    def issubset(self, *args, **kwargs): # real signature unknown
        """ Report whether another set contains this set.  是否是子序列"""
        pass
 
    def issuperset(self, *args, **kwargs): # real signature unknown
        """ Report whether this set contains another set. 是否是父序列"""
        pass
 
    def pop(self, *args, **kwargs): # real signature unknown
        """
        Remove and return an arbitrary set element.
        Raises KeyError if the set is empty. 移除元素
        """
        pass
 
    def remove(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set; it must be a member.
         
        If the element is not a member, raise a KeyError. 移除指定元素，不存在保错
        """
        pass
 
    def symmetric_difference(self, *args, **kwargs): # real signature unknown
        """
        Return the symmetric difference of two sets as a new set.  对称交集
         
        (i.e. all elements that are in exactly one of the sets.)
        """
        pass
 
    def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the symmetric difference of itself and another. 对称交集，并更新到a中 """
        pass
 
    def union(self, *args, **kwargs): # real signature unknown
        """
        Return the union of sets as a new set.  并集
         
        (i.e. all elements that are in either set.)
        """
        pass
 
    def update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the union of itself and others. 更新 """
        pass

set 集合class

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = 'liujianzuo'
a={1:2,4:5}
b=set(a)

b.add(111111)
b.clear()
print(b)

n = {11,22,33}
b = {22,66}
c = {11}

# n中有的b中没有的赋值给新的变量 打印
new_n = n.difference(b)
print(new_n)

#n中有的 b中没有的 更新到n
# n.difference_update(b)
# print(n)

# 将迭代的序列加入
n.update("al")
n.update([1,3,4])
print(n)

#n存在的b不存在的 b存在n不存在的 组合一起输出
ret=n.symmetric_difference(b)
ret2 = n.symmetric_difference({11,22,33})
print(ret)
print("=========")
# n存在的b不存在的 b存在n不存在的 组合一起 更新到前面的集合
n.symmetric_difference_update(b)
print(n)

#  是否是子集  不是返回false  是的话True
ret = n.issubset(c)  # n是不是c的子
print(ret)
ret1 = c.issubset(n)  # c是不是n的子
print(ret1)
ret2 = n.issuperset(c) # n是不是c的父
print(ret2)


# pop discard remove 三个删除的区别

#pop 删除同时可以获取到该值
ret = n.pop() #由于集合是无序的，所以pop删除也是无序的
print(ret)
# discard 删除集合元素，如果元素不存在 返回False 不报错
n.discard(11)
print(n)
#remove 删除集合元素 如果元素不存在 报错
#n.remove(99)

z = {11,22,33}
p = {44}

z.intersection(p)  #取交集并更新到z中
print(z)


集合 练习

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = 'liujianzuo'

old_dict = {
    "#1":11,
    "#2":11,
    "#3":11,
}
new_dict = {
    "#1":33,
    "#4":22,
    "#7":100,
}
# b = set(old_dict.keys())
# print(b)
s1 =set()
s2 =set()
for i in  old_dict.keys():
    s1.add(i)
for n in new_dict:
    s2.add(n)
print(s1,s2)
ret1 = s1.difference(s2)
print("for deling ：",ret1)
ret2 = s2.difference(s1)
print("for adding:",ret2)
# ret=s1.intersection(s2)
# print(ret)
for i in s1 :
    del old_dict[i]

for i in  s2:
    old_dict[i]=new_dict[i]

print(old_dict)

set集合练习

交集

>>> a.append(10)
>>> set(a)
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> b =range(6)
>>> a = set(a) 
>>> b =set(b)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> b
set([0, 1, 2, 3, 4, 5])
取交集
>>> a & b
set([0, 1, 2, 3, 4, 5])
交集应用场景：比如两个班级都叫alex或者两个班级都是100分的 或者两个班级中都大于多少分的

并集应用
>>> a | b
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

差集
>>> a - b
set([8, 9, 10, 6, 7])

对称差集

>>> a - b
set([8, 9, 10, 6, 7])
把两个里面对方都没有的打印出来


A b 差集
a ^ b

set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> b
set([0, 1, 2, 3, 4, 5, 12])
>>> a ^ b
set([6, 7, 8, 9, 10, 11, 12])
a.add集合中添加一项，同样的去重不同样的增加
>>> a.add(0) 
>>> a.add(22)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 22])

a.update集合添加多项
>>> a.update([23,34,35])
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 35, 22, 23])

添加一个集合到另一个集合
>>> a.update(b)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 35, 22, 23])
#b.issubset(a) a.issuperset(b) 测试b中的每一个元素都在a中
>>> len(a)
>>> len(b)
>>> b in a
False
>>> a in a
False
>>> import tab
>>> b.issubset(a)  #测试b中的每一个元素都在a中
True
>>> a.issubset(b)
False
>>> 3 in a
True
>>> b.issuperset(a)
False
>>> a.issuperset(b)  #测试b中的每个元素都在a中
True

set集合练习

三、三元运算符

 

python 的三元运算

　　变量名 = 变量1 if 条件判断成立 else 变量2

　　　　　　意指: 条件成立 变量名值为变量1 否则为变量2

 

name = "eric" if 1 == 1 else "alex"
print("==",name)

 

lambda 带if条件的三元运算

 

1 2 3 4 5 6 7 8

l1 = [11,22,33,44,55] # for i in l1: #     if i % 2 == 0: #         m = map(lambda x:x+100,[i,]) #         l1[l1.index(i)] = list(m)[0] # print(l1) k=map(lambda x:(x+100) if (x%2==0) else x,l1) print(list(k))

　　

四  深浅拷贝

 1 数字和字符串

对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。

 

import copy
# ######### 数字、字符串 #########
n1 = 123
# n1 = "i am alex age 10"
print(id(n1))
# ## 赋值 ##
n2 = n1
print(id(n2))
# ## 浅拷贝 ##
n2 = copy.copy(n1)
print(id(n2))
  
# ## 深拷贝 ##
n3 = copy.deepcopy(n1)
print(id(n3))

 

二、其他基本数据类型

 

对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。

1、赋值

赋值，只是创建一个变量，该变量指向原来内存地址，如：

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
  
n2 = n1

 

2、浅拷贝

浅拷贝，在内存中只额外创建第一层数据

import copy
  
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
  
n3 = copy.copy(n1)

 

3、深拷贝

深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）  最底层数据要满足第一条赋值变量的条件

import copy
  
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
  
n4 = copy.deepcopy(n1)