python基础（8）——集合 & return
一、集合 set
集合是可变的容器
集合内的数据对象都是唯一的(不能重复多次的)
集合是无序的存储结构,集合中的数据没有先后关系
集合内的元素必须是不可变对象 （不支持索引）
集合是可迭代对象
集合是相当于只有键没有值的字典(键则是集合的数据)
1、创建空的集合:
set()
2、创建非空的集合的字面值:
s = {1, 2, 3}
3、集合的构造函数:
set() 创建一个空的集合(不能用{} 来创建空集合)
set(iterable) 用可迭代对象创建一个新的集合
示例:
s = set()
s = {2,3,5,7}
s = set("ABC") # s = {'A', 'B', 'C'}
s = set("ABCCBA") # s = {'A', 'B', 'C'}
s = set({1:"1", 2:'2', 5:'5'}) # s = {1, 2, 5}
s = set(('ABC', '123', True))
s = {True, None, "ABC", (1, 2, 3)}
4、python3 中不可变数据类型
bool, int, float, complex, str, tuple, frozenset,bytes
None（特殊对象）
5、可变数据类型
list, dict, set, bytearray
6、集合的运算:
交集& 并集| 补集- 对称补集^ 子集< 超集 >
& 用于生成两个集合的交集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 & s2 # {2, 3}
| 生成两个集合的并集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 | s2 # {1, 2, 3, 4}
- 生成两个集合的补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} # 生成属于s1, 但属于 s2的所元素的集合
^ 生成两个集合的对称补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 ^ s2 # {1, 4}
> 判断一个集合是另一个集合的超集（包含关系）
< 判断一个集合是别一个集合的子集
s1 = {1, 2, 3}
s2 = {2, 3}
s1 > s2 # True
s2 < s1 # True
== != 集合相同/不同
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True
in / not in 运算
in 同列表和字典的in运算符规则相同,如果存在于集合中返回 True,否则返回False
示例:
2 in {1, 2, 3} # True
7、用于集合的函数
len(x) 返回集合的长度
max(x) 返回集合的最大值元素
min(x) 返回集合的最小值元素
sum(x) 返回集合中所有元素的和
any(x) 真值测试，规则与列表相同
all(x) 真值测试，规则与列表相同
集合是可迭代对象,可以用于for语句中
练习:
经理有: 曹操，刘备，孙权
技术员有: 曹操，孙权，张飞，关羽
用集合求:
1. 即是经理也是技术员的有谁?
2. 是经理，但不是技术人员的都有谁?
3. 是技术人员，但不是经理的都有谁?
4. 张飞是经理吗？
5. 身兼一职的人都有谁?
6. 经理和技术员共有几个人?
1 managers = {'曹操', '刘备', '孙权'} 2 techs = {'曹操', '孙权', '张飞', '关羽'} 3 4 print("即是经理也是技术员的有:", managers & techs) 5 print("是经理，但不是技术人员的都有:", managers - techs) 6 print("是技术人员，但不是经理的都有:", techs - managers) 7 if '张飞' in managers: 8 print("张飞是经理") 9 else: 10 print("张飞不是经理") 11 12 print("身兼一职的人都有", managers ^ techs) 13 print("经理和技术员共有%d个人" % len(managers | techs))
8、集合的方法:
详见:
>>> help(set)
文档参见:
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 |
| S.difference(s2) | S - s2 补集运算，返回存在于在S中，但不在s2中的所有元素的集合 |
| S.difference_update(s2) | 等同于 S -= s2 |
| S.intersection(s2) | 等同于 S & s2 |
| S.intersection_update(s2) | 等同于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 与 s2 的对称补集更新 S |
| S.union(s2) | 生成 S 与 s2的全集, 等同于 S |
例如：S.update(s2) 等同于 S|=s2 或S=S|s2
二、集合推导式:
是用可迭代对象创建集合的表达式
语法:
{表达式 for 变量 in 可迭代对象 [if 真值表达式]}
[] 部分代表可省略
示例:
numbers = [1, 3, 5, 7, 9, 3, 4, 5, 6, 7]
s = {x ** 2 for x in numbers if x % 2 == 1}
print(s)
三、固定集合 frozenset
固定集合是不可变的，无序的，含有唯一元素的集合
1、作用:
固定集合可以作为字典的键，也可以作为集合的值
2、固定集合的构造函数 frozenset
frozenset() 创建一个空的固定集合
frozenset(iterable) 用可迭代对象创建一个新的固定集合
示例:
fz = frozenset()
fz = frozenset("ABCAB") #frozenset({'C','A','B'})
fz = frozenset([1, 2, 3, 4, 5])
3、固定集合的运算:
& 交集
| 并集
- 补集
^ 对称补集
in / not in运算
> >= < <= == !=
(以上运算等同于集合的运算)
4、固定集合的方法:
相当于集合的全部方法去掉修改集合的方法
四、阶段总结:
1、数据类型:
不可变数据类型:
bool, int, float, complex, str, tuple, frozenset,bytes(后面才学)
可变的数据类型:
list, dict, set, bytearray(后面才学)
值:
None, False, True, ....
2、运算符:
+ - * / // % **
< <= > >= == !=
is , is not
in , not in
not and or
& | ^ ~ << >>
+(正号) -(负号)
3、表达式:
100
100 + 200
max(1,2,3) # 函数调用也是表达式
条件表达式 x if x > y else y
全部的推导式:
列表，字典，集合推导式(只有三种)
4、语句:
表达式 语句:
print("hello world!")
'''这是字符串'''
赋值语句:
a = 100
b = c = d = 200
x, y = 100, 200
列表[整数表达式] = 表达式
字典[键] = 表达式
if 语句
while语句
for 语句
break 语句
continue语句
pass 语句
del 语句
5、函数:
len(x),max(x), min(x), sum(x), any(x),all(x)
构造函数:
bool(x) int(x),float(x), complex(x),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)
input(x), print(....)
五、函数 function
1、什么是函数
函数是可以重复执行的语句块，可以重复的调用
2、作用:
用于封装语句块，提高代码的重用性
定义用户级别的函数
1、def 语句
语法：
def 函数名(形参列表):
语句块（代码块)
作用:
用语句块创建一个函数，并用函数名变量绑定这个函数
语法说明:
1. 函数名是变量，它用于绑定语句块
2. 函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数内部可以访问函数外部的变量
(要让函数处理外部的数据需要用参数给函数传入一些数据)
3. 函数不需要传入参数时，形参列表可以为空
4. 语句部分不能为空，如果为空需要填充pass语句
1 # 此示例示意用def语句来定义一个函数并调用这个函数 2 3 def say_hello(): 4 print("hello world!") 5 print("hello tarena!") 6 print("hello everyone!") 7 # return None 8 9 10 say_hello() # 函数调用 11 say_hello() 12 v = say_hello() 13 print(v) # None
# 此示例示意定义带有参数的函数，及调用 def mymax(a, b): if a > b: print("最大值是", a) else: print("最大值是", b) mymax(100, 200) # 200 # 传参调用 mymax(50, 30) # 50 mymax("ABC", "123") # mymax(1, 2, 3, 4) # 出错
2、函数调用
函数名(实际调用传递参数)
注: 实际调用传递参数 以后称为实参
说明:
函数调用是一个表达式
如果函数内部没有return语句，则函数执行完毕后返回None对象
练习：
1、写一个函数 myadd,此函数中的参数列表里有两个参数x,y
此函数的功能是打印x+y的和
def myadd(...):
....
myadd(100, 200) # 300
myadd("ABC", '123') # ABC123
1 # def myadd(x, y): 2 # s = x + y # 求实参的和 3 # print(s) 4 5 def myadd(x, y): 6 if type(x) is int: 7 s = x + y # 求实参的和 8 elif type(x) is str: 9 s = y 10 print(s) 11 12 13 myadd(100, 200) # 300 14 myadd("ABC", '123') # ABC123
2. 写一个函数 print_even, 传入一个参数n代表终止整数
打印 2 4 6 8 ... n之间的所有偶数
函数定义如下:
def print_even(n):
... 此处自己完成
测试调用：
print_even(8)
2
4
6
8
def print_even(n): for i in range(2, n + 1, 2): print(i) print_even(80)
六、return 语句:
1、语法:
return [表达式]
注: []代表可以省略其中的内容
2、作用:
用于函数中结束当前函数的执行，返回到调用该函数的地方，同时返回一个对象的引用关系
3、return 语句说明:
1. return 语句后跟表达式可以省略，省略后相当于 return None
2. 如果函数内没有 return 语句，则函数执行完最后一条语句后返回None(相当于在最后加了一条return None语句)
# 此示例示意return 语句在函数中的作用 def say_hello(): print("hello world!") print("hello tarena!") return [1, 2, 3] print("hello everyone") v = say_hello() print('v =', v) # say_hello() # say_hello()
练习:
1、写一个函数myadd2, 实现返回两个数的和:
如:
def myadd(a, b):
.... # 此处自己实现
#测试代码如下:
a = int(input("请输入第一个数: "))
b = int(input("请输入第二个数: "))
print("您输入的两个数之和是: ", myadd(a, b))
def myadd(a, b): s = a + b # print(s) return s a = int(input("请输入第一个数: ")) b = int(input("请输入第二个数: ")) print("您输入的两个数之和是: ", myadd(a, b)) print(s) # 错的 #myadd2(a,b)
2、 写一个函数mymax, 实现返回两个数的最大值:
如:
def mymax(a, b):
...
print(mymax(100, 200)) # 200
print(mymax("ABCD", "ABC")) # ABCD
# 方法1 def mymax(a, b): if a > b: return a else: return b # 方法2 def mymax(a, b): if a > b: return a return b # 方法3 def mymax(a, b): return max(a, b) print(mymax(100, 200)) # 200 print(mymax("ABCD", "ABC")) # ABCD
3、写一个函数 input_number:
def input_number():
...
此函数用来获取用户输入的整数，当输入负数时结束输入.
将用户输入的数字以列表的形式返回，再用内建函数max,min,sum求出用户输入的最大值，最小值及和
L = input_number()
print(L) # 打印列表中的数据
print("用户输入的最大数是:", max(L))
print("用户输入的最小数是:", min(L))
print("用户输入的这些数的和是:", sum(L))
#方法1 def input_number(): lst = [] # 创建一个列表，同时用函数内部的局部变量lst绑定 while True: n = int(input("请输入一个正整数: ")) if n < 0: break lst.append(n) return lst #方法2 def input_number(): lst = [] # 创建一个列表，同时用函数内部的局部变量lst绑定 while True: n = int(input("请输入一个正整数: ")) if n < 0: return lst lst.append(n) L = input_number() print(L) # 打印列表中的数据 print("用户输入的最大数是:", max(L)) print("用户输入的最小数是:", min(L)) print("用户输入的这些数的和是:", sum(L))
4、编写函数fun,其功能是: 计算并返回下载多项式的值
Sn = 1 + 1/2 + 1/3 + 1/4 + .... + 1/n
函数如下：
def fun(n):
...
print(fun(3)) # 1.8333333333333
print(fun(10)) # ?????????????
#方法1 def fun(n): s = 0 for x in range(1, n + 1): s += 1 / x return s #方法2 def fun(n): return sum([1 / x for x in range(1, n + 1)]) print(fun(3)) # 1.8333333333333 print(fun(10)) # ?????????????
5、编写函数fun2,计算下列多项式的和
Sn = 1/(1*2) + 1/(2*3) + 1/(3*4) +
... + 1/n*(n+1) 的和
print(fun2(3)) # 0.75
print(fun2(1000))
1 def fun2(n): 2 s = 0 3 for x in range(1, n + 1): 4 s += 1 / (x * (x + 1)) 5 return s 6 7 8 print(fun2(3)) # 0.75 9 print(fun2(1000))
练习:
1. 写一个函数 get_chinese_char_count,此函数实现的功能是从一个给定的字符串中返回中文字符的个数
def get_chinese_char_count(x):
...
s = input("请输入中英文混合的字符串:") # hello中国
print('您输入的中文的字符个数是:', get_chinese_char_count(s)) # 2
def get_chinese_char_count(x): count = 0 # 先假设个数为0 for ch in x: # 如果ch为中文字典,则count 做加一操作 if ord(ch) > 127: count += 1 return count s = input("请输入中英文混合的字符串:") # hello中国 print('您输入的中文的字符个数是:', get_chinese_char_count(s)) # 2
2. 写一个函数isprime(x) 判断x是否为素数，如果为素数，返回True,否则返回False
如:
print(isprime(5)) # True
print(isprime(6)) # False
def isprime(x): if x < 2: return False for i in range(2, x): if x % i == 0: # 如果整数则不是素数 return False return True print(isprime(5)) # True print(isprime(6)) # False
3. 写一个函数prime_m2n(m, n) 返回从m开始，到n结束范围内的素数，返回这些素数的列表，并打印．
如:
L = prime_m2n(10, 20)
print(L) # [11, 13, 17, 19]
def prime_m2n(m, n): L = [] # 容器 for x in range(m, n): if isprime(x): L.append(x) return L L = prime_m2n(10, 20) print(L) # [11, 13, 17, 19]
4. 写一个函数 primes(n) 返回指定范围内n(不包含n)的全部素数的列表，并打印这些列表
如:
L = primes(10)
print(L) # [2, 3, 5, 7]
1) 打印100以内全部素数的和
2) 打印200以内全部素数的和
def primes(n): return prime_m2n(1, n) L = primes(10) print(L) # [2, 3, 5, 7] # 1) 打印100以内全部素数的和 print("100以内全部素数的和", sum(primes(100))) # 2) 打印200以内全部素数的和 print("200以内全部素数的和", sum(primes(200)))
5. 改写之前的学生信息管理程序，将其改为两个函数：
def input_student():
...
def output_student(L):
....
input_student用于从键盘读取学生数据，形成列表并返回列表
output_student(L) 用于将传和的列表L 打印成为表格
测试代码：
L = input_student()
print(L)
output_student(L) # 打印表格
def input_student(): L = [] # 创建一个新的列表，用此列表准备保存学生信息 # 录入学生信息 while True: n = input("请输入姓名: ") if not n: break a = int(input("请输入年龄: ")) s = int(input('请输入成绩: ')) # 创建一个新的字典，把学生的信息存入字典中 d = {} # 每一次都重新创建一个新的字典 d['name'] = n d['age'] = a d['score'] = s L.append(d) return L def output_student(L): print("+---------------+----------+----------+") print("| name | age | score |") print("+---------------+----------+----------+") for d in L: n = d['name'] a = d['age'] s = d['score'] print('|%s|%s|%s|' % (n.center(15), str(a).center(10), str(s).center(10) ) ) # print("| tarena | 20 | 99 |") # print("| name2 | 30 | 88 |") print("+---------------+----------+----------+") L = input_student() print(L) output_student(L) # 打印表格
posted on 2018-10-12 17:22 破天荒的谎言、谈敷衍 阅读(106) 评论(0) 收藏 举报
浙公网安备 33010602011771号