Python全栈工程师（集合、函数）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

 　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　每天坚持 一天一篇 点个订阅吧  灰常感谢    当个死粉也阔以

　　　　　　　　　　　　　　　　　　　　　　　　　    　Python人工智能从入门到精通

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

创建集合：
　　s = set（） #空集合
　　s = {3.14，True，（1970.1.1），“hello”} #非空

集合的构造函数：
　　set（）创建一个空集合（不能用{} 否则就是字典了）
　　set（iterable）用可迭代对象创建一个新的集合
　　创建新集合 内容重复会自动去重

例如：

集合的运算：
　　交集、并集、补集，子集、超集
& 生成连个集合的交集：
　　重复部分
　　s1 ={1,2,3}
　　s2 ={2,3,4}
　　s3 = s1&s2 #s3 = {2,3}

| 生成两个集合的并集：
　　所有不重复部分
　　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 #s3 = {1}

^ 生成两个集合的对称补集：
　　相当于减法相加
　　s1 ={1,2,3}
　　s2 ={2,3,4}
　　s3 = s1 ^ s2 # (s1 - s2 | s2 - s1) #{1, 4}

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

　　（包含关系判断）
== ！= 集合相同/不同：
　　s1 ={1,2,3}
　　s2 ={3，2,1}
　　s1 == s2 # true
　　s1 ！= s2 #false

in / not in ：
　　等同于字典的运算
　　判断某个值是否存在

集合和字典的优点：
　　in/not in 运算符速度相对来说快一些

能用于集合的函数：
　　len（x）、max（x）、min（x）、sum（x）、any（x）、all（x）

Python3中常用的集合方法：
　　方法 ；　　　　　　　　  意义：
　　S.add(e) 　　　　　　 在集合中添加一个新的元素e；如果元素已经存在，则不添加
　　S.remove(e) 　　　　  从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
　　S.discard(e) 　　　　  从集合S中移除一个元素e,在元素e不存在时什么都不做;
　　S.clear() 　　　　　　 清空集合内的所有元素
　　S.copy() 　　　　　　 将集合进行一次浅拷贝
　　S.pop() 　　　　　　  从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
　　S.update(s2) 　　　    用 S与s2得到的全集更新变量S
　　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的全集

集合推导式：
　　结合推导式是用可迭代对象生成集合的表达式
语法：
　　{表达式 for 变量 in 可迭代对象[if 真值表达式]}
　　之前说过 [ ] 内的代表可以省略
例如：
　　L= [1, 2, 5, 6, 3, 5, 9, 4, 5]
　　s = {x for x in L）}
　　(推导式嵌套同列表 、 字典一致)

固定集合 frozenset：
　　是不可变的、无序的、含有唯一元素的集合
　　用于固定集合可以作为字典的键，还可以作为集合的值
构造函数：
　　frozenset（） 创建一个空固定集合
　　frozenset（iterable）用可迭代对象创建固定集合
例如：
　　f = frozenset（）# 空固定集合
　　f = frozenset（[ 1, 3, 5, 7]） # f = frozenset({1, 3, 5, 7})

固定集合运算：
　　& 交集 、 | 并集 、- 补集、^ 对称补集
　　>、 >= 、< 、<=、 ==、 !=
　　in /not in
　　（和集合 set 一致）
固定集合方法：
　　集合的方法取掉所有修改方法

  　　　　　　　　　　　　　　　　　　　　　　　　　　　小结：

数据类型：
　　数值类型：
　　　　int、float、complex、bool

　　容器类型：
　　　　不可变容器：
　　　　　　str、tuple、frozenset、bytes（字节串）
　　　　可变容器：
　　　　　　list、dict、set、bytearray（字节组）
　　值：
　　　　None、false、True
运算符：
　　算数运算符：
　　　　+、 - 、 * 、 / 、 // 、 % 、 **
　　比较运算符：
　　　　< 、 > 、 <= 、 >= 、 == 、 !=
　　　　in / not in 、 is / is not
　　布尔运算符：
　　　　not 、 and 、or
　　　　+（正号）、 -（负号）
　　　　&、^ 、| 、 [ ] (索引)
表达式：
　　1
　　1+2
　　max（1,2,3,）
　　x if x > y else y (条件表达式)
　　三种推导式：
　　　　列表、字典、集合推导式（3种）
语句：
　　表达式语句：
　　　　所有的语句都可单独写在一行，形成一个语句
　　　　例如：
　　　　　　print（“hello world”）
　　　　　　1 + 2
　　赋值语句：
　　　　a = 100
　　　　a = b = c = 100
　　　　x， y = 100， 200
　　　　a[0] = 100
　　　　dict [ "name"] = "tarena"
　　　　del 语句
　　　　while 语句
　　　　for 语句
　　　　break 语句
　　　　continue 语句
　　　　pass 语句
函数：
　　内建函数：（系统内置函数）
　　　　len（x）
　　　　max（x）
　　　　min（x）
　　　　sum（x）
　　　　any（x）
　　　　all（x）
　　构造函数：(用来创建同类型的数据对象)
　　　　bool（x）
　　　　int（x）（进制转换可以添加进制参数 be>=2 and <= 36）
　　　　float（x）
　　　　complex（x）
　　　　list（x）
　　　　tuple（x）
　　　　str（x）
　　　　dict（x）
　　　　set（x）
　　　　abs（x）
　　　　round（x）
　　　　pow（x，y，z = None）
　　　　bin（x）
　　　　oct（x）
　　　　hex（x）
　　　　chr（x）
　　　　ord（x）
　　　　range（star，stop，step）
　　　　input（x）
　　　　print（x）
　　　　help（__builtins__）

之前讲的差不多也就这些了

接下来我们讲函数

ok everyone   在开始之前的我想先说两句 咳咳：

之前比如说101等于5对吧  可能手一哆嗦打成了011

有细心的小伙伴就发发现了  给我评论 

你们如果有什么问题 可以随时评论  我看到后 都会回复的

能解决的我有时间都会去解决

比如说哪里不懂啊 逻辑想不通啊 或者比较迷茫的 都是可以的

前面12课说的都是常用的和偶尔用的一些基础的运算以及语法

很多东西一次测扯出来根本听不懂的 学习要循序渐进对吧

后面的东西 我们会做一个实战项目  边做边学  

有些可能一辈子用不几次的东西就没说  感兴趣的朋友可以 交互模式下help 查看一下帮助

或者官方的api文档 翻译好的api文档都是可以的   第一课之前的那个文章 我在里面加了api文档地址 有兴趣的可以去下载

这个项目的就是学生信息管理系统  昨天的第二题练习 我们已经做了一个开头了对吧 

好了不废话了  进入正题

函数： function
　　函数是可以重复执行调用的语句块
　　作用：
　　　　1.用于封装语句块，提高代码的重用性
　　　　2.定义用户级别的函数
def 创建函数语句：
　　def 函数名（形参列表）：
　　　　语句块
　　说明：
　　　　1. 函数的名字就是语句块的名称
　　　　2. 函数名的命名规则与变量名相同（函数名必须是标识符）
　　　　3. 函数名是一个变量（不要轻易对其赋值）
　　　　4. 函数有自己的空间，在函数外部不可以访问函数内部的变量，但是可以访问外部变量
　　　　5. 函数如果不需要传入参数，形参列表可以为空
　　　　6. 语句部分不能为空，如果为空需要填充pass
return 创建返回值语句：
　　用于函数中，结束当前函数的执行，返回调用该函数的地方，同时返回一个对象的引用关系
　　return[表达式]
　　（[ ] 代表可以省略）
　　说明：
　　　　1. 函数调用是一个表达式
　　　　2. 如果函数内部没有return语句，函数调用完毕后返回None对象
　　　　3. 如果函数需要返回其它的对象需要用到 return 语句
函数的调用：
　　函数名（实际调用传递参数）
　　（实际调用传递参数，简称实参）

练习:
1.任意输入一些数字，存于列表L中。当输入负数时结束输入
1) 打印这些数的和
2) 打印这些数有多少种(去重)
3) 除重复的数字后，打印这些剩余数字的和

提示,可以用集合去重

答案：

L = []
while True:
    a = int(input("please input at will ingeger (input '-1' over):"))
    if a < 0:
        break
    L.append(a)
print(sum(L))
s = set(L)
print(len(s))
print(sum(s))

2. 经理有: 曹操,刘备,孙权
技术员有: 曹操,孙权,张飞,关羽
用集合求:
1) 即是经理，也是技术员的有谁?
2) 是经理，但不是技术员的人员都有谁？
3) 是技术员，不是经理的都有谁
4) 张飞是经理吗？
5) 身兼一职的人都有谁？
6) 经理和技术员共有几个人?

答案：

s = {"曹操", "刘备", "孙权"}
s1 = {"曹操", "孙权", "张飞", "关羽"}
if "张飞" in s:
    x = "是"
else:
    x = "不是"
print('''
即是经理，也是技术员的有:%s
是经理，但不是技术员的人员有:%s
是技术员，不是经理的有:%s
张飞%s经理
身兼一职的人有:%s
经理和技术员共有:%d个人
''' % (
    s & s1,
    s - s1,
    s1 - s,
    x, s ^ s1,
    len(s | s1)))

3. 写一个函数myadd, 此函数中的参数列表里有两个参数x, y
此函数的功能是打印 x + y 的和

def myadd(....):
.... # 注: .... 部是是我们要填写代码的地方

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

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

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

答案：

def mysum(x):
    s = 0
    for i in range(1, x + 1):
        s += i
    print(s)
mysum(100)
mysum(4)

5. 写一个函数 mymax, 给函数传递两个参数，返回两个实参中最大的一个
def mymax(a, b):
....

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
x = mymax(100, 200)
print(x)

6. 写一个函数 input_number
def input_number():
....

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

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

答案：

def inout_number():
    L = []
    while True:
        number = int(input("please inoput (-1:over):"))
        if number < 0:
            break
        L.append(number)
    return L
L = inout_number()
print("Top1  ", max(L))
print("lower1  ", min(L))
print("sum  ", sum(L))

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

print_odd(1, 10) # 打印 1 3 5 7 9d
ptint_odd(10, 20) # 打印 11 13 15 17 19

答案：

def myodd(begin, end):
    for x in range(begin, end):
        if x % 2 != 0:
            print(x, end = " ")
    print()
myodd(1, 10)
myodd(10, 100)

9. 改写之前的学生信息管理程序
改为两个函数:
1. 写一个函数 input_student() 用于返回学生信息的字典的列表(以前格式一样)
2. 写一个函数 output_student(lst)
此函数传入一个列表lst,即字典的列表
此函数把lst的内容以表格形式打印出来
def input_student():
....

def output_student(lst):
...

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

 答案：

# 创建输入函数：input_student开始
def input_student():
    print("--------Student information enty--------")
    L = []
    while True:
        name = input("please input name:")
        if name == "":
            break
        age = input("please input age:")
        score = input("please input score:")
        d = {}
        d = {"name": name, "age": age, "score": score}
        L.append(d)
    return L
# 创建输入函数：input_student完成

# 创建输出函数：output_student开始
def output_student(lst):
    print("-------Student information sheet-------")
    print("+---------------+----------+----------+")
    print("|     name      |    age   |   score  |")
    print("+---------------+----------+----------+")
    for d in lst:
        name = d["name"].center(15)
        age = d["age"].center(10)
        score = d["score"].center(10)
        print('''|%s|%s|%s|''' % (name, age, score))
        print("+---------------+----------+----------+")
# 创建输出函数：output_student完成

output_student(input_student())