集合与函数

目录

集合set, 固定集合frozenset
& | - ^ < >
>= <= == !=
in not in
s.add()
s.remove()
s.discard()
s.clear()
s.pop() 删除随机一个
...
集合是可迭代对象　

集合推导式
列表：　[x for x in range(10)]
集合：　{x for x in range(10)}
字典：　{x:x**2 for x in range(10)}

函数 function
def 语句语法：
def 函数名(形参列表)：
语句块

作用：创建函数

函数调用：
函数名（实参列表）

renter 语句

 

集合 set

集合是可变的容器
集合内的数据对象都是唯一的（不能重复多次）
集合是无序的存储结构，　集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代对象
集合是相当于只有键没有值的字典（键则是集合的数据）

创建空集合
s = set()
创建非空集合
s = {1, 2, 3}
s = {3.14, True, (1970,1,1), "hello"} 集合里不可加列表，字典，集合（可变）

>>> s = {1, 2, 3}
>>> s
{1, 2, 3}
>>> type(s)
<class 'set'>
>>> l=[6, 8, 10]
>>> s = {6, 8, 10}
>>> z = {}
>>> type(z)
<class 'dict'>

>>> s = set()
>>> type(s)
<class 'set'>

集合的构造函数　set
set()　　创建一个空的集合对象（不能用{}　创建集合）
set(iteerable) 用可迭代对象创建一个新的集合对象
例：
s = {1, 3, 5, 7}
s = set("ABC")
s = set("ABCCBA")
>>> s = set("ABCCBA")
>>> s
{'A', 'C', 'B'}
set({1:'1', 2:'2', 5:'5'})
>>> set({1:'1', 2:'2', 5:'5'})
{1, 2, 5}
s = set([1, 0, 3.14, "hello"])
>>> s = set([1, 0, 3.14, "hello"])
>>> s
{0, 1, 3.14, 'hello'}

s = set(('abc', '123', True))
>>> s = set(('abc', '123', True))
>>> s
{'123', True, 'abc'}

集合的运算：
交集　　 ＆
并集　　 |
补集　　 -
子集　　 <
超集　　 >
对称补集 ^

& 生成两个集合的交集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 #s3 = {2, 3}

|　　并集　　　　集合 D.update(D2) 将D2合并D, 同取D2的值做新值
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 #s3 = {1, 2, 3, 4}

- 　　补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 - s2 #生成输入属于s1 但不属于s2
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s3 = s1 - s2
>>> s3
{1}
>>> s4 = s2 - s1
>>> s4
{4}

^ 对称补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2
#(s1 - s2) | (s2 - s1)
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s3 = s1 ^ s2
>>> s3
{1, 4}

> 判断一个集合是另一个的超集
< 判断一个集合是另一个的子集
s1 = {1, 2, 3}
s2 = {2, 3}
s1 > s2
s2 < s1
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3}
s1 > s2
True #s1　为s2 的超集
>>> s1 < s2
False #s2 为　s1 的子集

== != 集合相同不同
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2
>>> s1 = {1, 2, 3}
>>> s2 = {3, 2, 1}
>>> s1 == s2
True

in / not in 运算符

等同于字典的in, not in, 作于集合中，　判断某个值是否存在于集合中

集合和字典的优点：
in / not in 运算的判断比列表的速度快

能用于集合的函数：
len(x), max(x), min(x), sum(x), any(x), all(x)

练习：
经理有：曹操，　刘备，　孙权
技术员：曹操，　孙权，　张飞，　关羽
用集合求：
１）即是经理，　也是技术员的
２）是经理，　但不是技术员的
３）是技术员，　不是经理
４）张飞是经理吗？
５）身兼一职
６）经理和技术员共几个

a = {'曹操','刘备','孙权'}
b = {'曹操','孙权','张飞','关羽'}
c = a & b
print('即是经理，　也是技术员的', c)
d = a -b
print('是经理，　但不是技术员的', d)
e = b - a
print('是技术员，　不是经理', e)
f = '张飞'in a
if f == True:
    print('张飞是经理')
else:
    print('张飞不是经理')
g = a ^ b
print('身兼一职', g)
f = a | b
print('经理和技术员共%d个' % len(f))

Python3 集合的常用方法
方法 意义
S.add(e) 在集合中添加一个新的元素e；如果元素已经存在，则不添加　　(列表insert +)
>>> s = set()
>>> s
set()
>>> s.add(100)
>>> s
{100}
>>> s.add(200)
>>> s.remove(100)
>>> s
{200}

S.remove(e) 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
S.discard(e) 从集合S中移除一个元素e,在元素e不存在时什么都不做;

S.clear() 清空集合内的所有元素
S.copy() 将集合进行一次浅拷贝
S.pop() 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常

>>> s = {2, 1, 4, 7, 8, 9}
>>> s
{1, 2, 4, 7, 8, 9}
>>> s.pop()
1
>>> s.pop()
2
>>> s.pop()
4
>>> s.pop()
7
>>> s.pop()
8
>>> s.pop()
9
>>> s.pop()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'pop from an empty set'

S.update(s2) 用 S与s2得到的全集更新变量S (+=)
>>> s = {1, 2, 3}
>>> s
{1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s = s | s2 #s.update(s2) #s |=s2
>>> s
{1, 2, 3, 4}

>>> s = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s |= s2
>>> s
{1, 2, 3, 4}

S.difference(s2) 用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合
S.difference_update(s2) 等同于 S = S - s2
S.intersection(s2) 等同于 S & s2
S.intersection_update(s2) 等同于S = S & s2
S.isdisjoint(s2) 如果S与s2交集为空返回True,非空则返回False
S.issubset(s2) 如果S与s2交集为非空返回True,空则返回False
S.issuperset(...) 如果S为s2的子集返回True,否则返回False
S.symmetric_difference(s2) 返回对称补集,等同于 S ^ s2
S.symmetric_difference_update(s2) 用 S 与 s2 的对称补集更新 S
S.union(s2) 生成 S 与 s2的全集

python 只有三种推导式 字典{:}列表[]集合{}
集合推导式
集合推导式是用可迭代对象生成集合的表达式
语法：
{表达式　for 变量　in 可迭代对象　[if 真值表达式]}
注：[]可略
例：
l =[1, 3, 5, 7, 2, 4, 6, 8, 1, 3, 5] #字典有：
s = {x for x in l}

>>> l =[1, 3, 5, 7, 2, 4, 6, 8, 1, 3, 5]
>>> s = {x for x in l}
>>> s
{1, 2, 3, 4, 5, 6, 7, 8}
>>> d = { x: x for x in l}#字典
>>> d
{1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8}

推导式嵌套：
语法同列表同

>>> l =[1, 3, 5, 7, 2, 4, 6, 8, 1, 3, 5]
>>> s = {x for x in l if x % 2==0}
>>> s
{8, 2, 4, 6}

练习：
任意输入一些数字，　存于列表L中，　当输入负数时结束输入
１）打印和
２）打印这些数有多少种（去重）
３）去重后，　打印这些剩余数字的和

l = []
while True:
    a = int(input("请输入数字：")
        if a < 0:
            break
        else:
            l.append(a)
print(l)
print('这些数的和:', sum(l))
s = set(l)
print('这些数有%d种' % len(s))
he = sum(s)
print('去重后，　打印这些剩余数字的和%d' % he)

固定集合frozenset

固定集合是不变的，　无序的，　含有唯一元素的集合

作用：
固定集合可以作为字典的键，　还可以作为集合的值

固定集合的构造函数：
frozenset() 创建一个空的固定集合
frozenset(iterable) 可用迭代对象创建固定集合

>>> s = {1, 2, 3, frozenset({4.4, 5.5})}
>>> s
{1, 2, 3, frozenset({4.4, 5.5})}

>>> fz = frozenset()
>>> type(fz)
<class 'frozenset'>

>>> fz = frozenset({1, 3, 5, 7})
>>> s = {1, 3, 5, 7}
>>> s
{1, 3, 5, 7}
>>> fz
frozenset({1, 3, 5, 7})

运算：
交集　　　＆
并集　　　｜
补集　　　-
对称补集^
< <= >　>= == !=
in /not in
(以上运算符和集合set 同)

固定集合的方法：
相当于集合的全部方法去掉添加，　删除（修改）集合的
方法

总结：
１．数据类型：
　　数值类型：(不可变的类型)
　　 bool,int,float,complex,
容器：
　　不可变容器
　　　　　　str,tuple,frozenset,bytes
　　可变容器：
　 　　list,dict,set,bytearray
２．值：
　　　None,False,True
　
运算符：
　　　算术运算符：
　　　　　　+ - * / // % **
　　　比较运算符：
　　　　　　> >= < <= == !=
　　　in ,　not in
is , is not
　　　布尔运算：
　　　 not , and , or
+(正号) -(负号)
& | ^
[ ] (索引，切片，键索引)

表达式：
100
100+200
len([1,2,3]) + max([1,2,3])#函数调用是表达式
print("hello")
条件表达式： x if x > y else y
全部的推导式：[x for x in range(5)]
　　　(列表，字典，集合推导式三种)

语句：statement
　　表达式语句：
　　　　所有的表达式都可以单独写一行，形成一个语句，例：
　　　　 print("hello world")
1 + 2
赋值语句：创建和修改变量
a=100
a=b=c=200
x,y,z=100,200,300
a[0] = 100
dict['name'] = 'tarena'
del 语句
　　if 语句
　 while 语句
for 语句
break 语句
continue 语句
pass 语句

内建函数：
　　len(x)
max(x)
min(x)
sum(x)
any(x)
all(x)

构造函数：(用来创建同类型的数据对象)
　　bool(x)
　　int(x,base=10)
　　float(x)
　　complex(real=0,image=0)
　　str(x)
　　list(x)
　　tuple(x)
　　dict(x)
　　set(x)
　　frozenset(x)

数字处理函数：
　　abs(x)
　　round(x)
　　pow(x, y, z=None)
字符串相关函数：
　　bin(x)
　　oct(x)
　　hex(x)
　　chr(x)
　　ord(x)

迭代器相关
　　range(start,stop,step)
　　reversed(x)
　　sorted(x)

输入输出相关：
　　input(x)
　　print(...)

bin(x), oct(x), hex(x)
chr(x), ord(x)
range(star, stop, step)
input(x), print(x), id(x)

>>> help(__builtins__)

函数function

函数名(实参...)
函数是可以重复执行的语句块，　可以重复调用
作用：
１．用于封装语句块，　提高代码的重用性
２．定义用户级别的函数

语法：
def 函数名(形参列表)：
语句块

说明：
１．函数的名字就是语句块的名称
２．函数名的命名规则写变量名相同(函数名必须是标识符)
３．函数名是一个变量（不要轻易对其赋值）
４．函数有自己名字空间，在函数外部不可以访问函数内部的变量，在函数内 部可以访问函数外部的变量，但不能修改此变量．
　　　(要让函数处理外部数据需要用参数给函数传入一些数据)
５．函数如果不需要传入参数，参数列表可以为空
６．语句部分不能为空，如果为空需要用pass语句填充

函数调用：
　　函数名（实际调用传递参数/实参）
　　　　注：实际调用传递参数，以后简称实参

　　函数名说明：
　　　　１．函数调用是一个表达式
　　　　２．如果函数内部没有return语句，函数调用完毕后返回None对象
　　　　３．如果函数需要返回其他的对象需要用到return语句

函数的调用
函数名（实际调用传递参数）
注：
实际调用传递参数，　简称实参

def say_hello():
    print('hello world!')
    print('hello tarena!')
    print('hello everyone!')

say_hello() # 调用函数   
say_hello()
say_hello()

# 此示例示意带有形式参数的函数的定义

# 写一个函数，打印出给定的两个数的最大值
def mymax(a,b):
    print('a =', a)
    print('b =', b)
    if a > b:
        print(a, '最大')
    else:
        print(b, '最大')

mymax(100,200)
mymax(10,20)
mymax('ABC','123')

# 　　　写一个函数myadd，此函数中的额参数列表里有两个参数x,y
# 　　　此函数的功能是打印x+y的和
def myadd(x,y):
    print(x + y)

myadd(100,200)  # 300
print('ABC','123')  # ABC123
myadd('ABC','123')

# 写一个函数mysum，传入一个参数x代表终止整数
# 打印出 1+2+3+4+...+x的和

def mysum(x):
    i = 1
    s = 0 # 创建变量用于累加
    while i <= x: # for x in range(1,x+1):
        s += i
        i += 1
    print(s)

mysum(100) # 5050
mysum(4)  # 10

return 语句：
语法：
　 return [表达式]
　　注: [] 代表内容可省略
作用：
　　用于函数中，结束当前的函数的执行，返回到调用该函数的地方，同时返回　　(表达式)一个对象的引用关系

return　语句说明：
　　１.return　语句后跟的表达式可以省略，省略后相当于return None
　　２．如果函数内没有return语句，则函数执行完最后一条语句后返回None　　　　（相当于在最后加了一条 return None　语句)

def say_hello():
    print('aaaaaa')
    print('bbbbbb')
    return None # 返回到调用此函数的地方
    print('cccccc')

say_hello()
say_hello()
print("-------------------------")
def say_hello():
    print('aaaaaa')
    print('bbbbbb')
    return [1,2,3,4] # 返回到调用此函数的地方
    print('cccccc')

v = say_hello()
print('v =',v)

函数的参数传递
　　传递方式：
　　　　位置传参
　　　　　　序列传参
　　　　关键字传参
　　　　　　字典关键字传参

练习

# １．写一个函数　mymax，给函数传递两个参数，返回两个实参中最大的一个
def mymax(a,b):
    if a > b:
        # zuida = a
        return a
    else:
        # zuida = b 
        return b
    # return zuida

v = mymax(100,200)
print('v =',v)  # v = 200
print(mymax('ABC','abc'))  #abc

def mymax(a,b):
    if a > b:
        return a
    return b

v = mymax(100,200)
print('v =',v)  # v = 200
print(mymax('ABC','abc')) 

def mymax(a,b):
    return max(a,b)

v = mymax(100,200)
print('v =',v)  # v = 200
print(mymax('ABC','abc')) 

写一个函数 input_number　，此函数用来获取用户循环输入的整数
，当用户输入负数时结束输入．将用户输入的数字以列表的形式返回，再用
内建函数　max,min,sum　取出用户输入的最大值，最小值及和

def input_number():
    lst = []
    while True:
        n = int(input("输入整数"))
        if n < 0:
            break
        lst.append(n)
    return lst

L= input_number()
print(L) # 打印此列表
print("用户输入的最大数是：",max(L))
print("用户输入的最小数是：",min(L))
print("用户输入的数的和是：",sum(L))

写一个函数　print_odd，打印从begin开始，到end结束(不包含end)内的全部奇数

def print_odd(begin,end):
    l = []
    for i in range(begin,end):
        if i % 2 == 1:
            l.append(i)
    print(l)
    
print_odd(1,10)  # 打印 1,3,5,7,9
print_odd(10,20) # 打印 11,13,15,17,19

定义两个函数：
sum3(a,b,c)用于'返回'三个数的和
pow3(x)用于'返回'x的三次方
用以上函数计算：
　１）计算1的立方+2的立方+3的立方的和
　２）计算 1+2+3 的和的立方　
　　　即：(1+2+3) **3 的和

def sum3(a, b, c):
    return(a + b + c)

# sum3(1, 2, 3)

def pow3(x):
    return(x**3)
 
print(sum3(pow3(1), pow3(2), pow3(3)))
print(pow3(sum3(1, 2, 3)))

改写之前的学生信息管理程序
　　　　改写两个函数
　　　１）写一个函数　input_student()　　用于返回学生信息的字典的列表
　　　　　（以前格式一样）
　　　２）写一个函数　output_stedent() 此函数传入一个列表lst　，
　　　　　即字典的列表　　　
　　　　　　此函数把lst　的内容以及表格形式打印出来

def input_student():


def output_student(lst):


L = input_student() # 获取学生信息的列表
output_student(L)  # 把L　以列表的形式打印


def input_student():
    l = []
    while True:
        name = input('请输入姓名：')
        if not name:#如果名字为空，　结束
            break
        age = input("请输入年龄：")
        score = input('请输入成绩：')
        d = {}
        d['name'] = name
        d['age'] = int(age) if age != "" else "death"
        d['score'] = int(score) if score != "" else ""
        l.append(d)
    return(l)



def output_student(lst):
    print('+--------------------+--------------+-------------+')
    print('|      name          |     age      |     score   |')
    print('+--------------------+--------------+-------------+')
    for d in lst:
        n = d["name"].center(20)
        a = str(d['age']).center(14)
        s = str(d['score']).center(13)#'-'的数量
        print("|%s|%s|%s|" % (n, a, s))
        print('+--------------------+--------------+-------------+')

#     |   xiaozhang        |     20       |    100      |
#     |     xiaoli         |     18       |     98      |
#     +--------------------+--------------+-------------+

l = input_student()
output_student(l)