python集合运算求出经理和技术人员有几人_PYTHON1.day08

最新推荐文章于 2022-10-21 10:56:55 发布

喵杀

最新推荐文章于 2022-10-21 10:56:55 发布

阅读量983

点赞数

文章标签： python集合运算求出经理和技术人员有几人

本文链接：https://blog.csdn.net/weixin_28870939/article/details/114467374

版权

day07 回顾:

两个容器:

元组 tuple(不可变的序列)

字典 dict(可变的无序的容器)

元组

序列: 字符串 str, 列表 list, 元组 tuple, bytes, bytearray

元组的表示方式:

() (20,) (1, 2 ,3) 20, 1,2,3

构造函数:

tuple() tuple(可迭代对象)

元组的运算:

+ += * *=

< <= > >= == !=

in / not in

索引取值和切片取值

len(x), max(x), ..........

reversed(x) sorted(x, reverse=False)

字典:

可变的容器,字典的存储是无序的

键值对方式存储, (键: 不可变对象, 值: 可以是任意对象)

字面值:

{1: "hello"}

{'name': 'xiaozhang', 'age': 20, 'score':100}

构造函数

dict()

dict([(1, "壹"), (2, '二')])

dict(name='xiaozhang', age=20, score=100)

字典的运算:

键索引取值:

v = 字典[键]

赋值:

字典[键] = v

del 字典[键]

== !=

能用于字典的函数:

len(x), max(x), min(x), sum(x), any(x), all(x)

字典的方法:

D.clear()

D.pop(key)

D.copy()

D.update(d2) 更新

D.get(key, default=None) # 取值(不会报错)

D.keys()

D.values()

D.items()

字典推导式

{键表达式: 值表达式 for 变量 in 可迭代对象 if 真值表达式}

day08笔记

集合 set

集合是可变的容器

集合内的数据对象都是唯一的(不能重复多次的)

集合是无序的存储结构,集合中的数据没有先后关系

集合内的元素必须是不可变对象

集合是可迭代对象(可以用for等遍历)

集合是相当于只有键,没有值的字典(键则是集合的数据)

创建空集合:

set()

创建非空集合的字面值:

s = {1, 2, 3}

集合的构造函数: set

set() 创建一个空的集合对象(不能用{}来创建空集合)

set(iterable) 用可迭代对象创建一个新的集合对象

示例:

s = set()

s = {1, 2, 3, 4}

s = set("ABC")

s = set("ABCABC") # s = {'A', 'B', 'C'}

s = set([1, 0, 3.14, 0.618])

# s = {1, 2, [3, 4], 5} # 报错,集合内不能放列表和字典

# s = {1, 2, {3, 4}, 5} # 出错集合是可变对象

集合的运算:

交集&, 并集|, 补集-, 对称补集^, 子集

& 运算符生成两个集合的交集

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 # 生成属于s1,但不属于s2的所有元素的集合

^ 生成两个集合的对称补集

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s3 = s1 ^ s2 # s3 = {1, 4}

> 判断一个集合是另一个集合的超集

< 判断一个集合是另一个集合的子集

s1 = {1, 2, 3}

s2 = {2, 3}

s1 > s2 # True, s1为s2的超集

s2 < s1 # True, s2为s1的子集

== != 集合相同或不同

s1 = {1, 2, 3}

s2 = {2, 3, 1}

s1 == s2 # True 相同

s1 != s1 # False

>= <= 超集或相同, 子集或相同

in / not in 运算符:

等同于字典, in 用于集合中,当某个值存在于集合中返回True,否

则返回False

not in 与 in 返回值相反

说明:

集合的in / not in 运算符查找速度比较快

能用于集合的内建函数:

len(x) max(x) min(x) sum(x) any(x) all(x)

集合是可迭代对象

练习:

经理有: 曹操, 刘备, 孙权

技术员有: 曹操, 孙权, 张飞, 关羽

用集合求:

1. 即是经理也是技术员的有谁?

2. 是经理,但不是技术人员的都有谁?

3. 是技术人员,但不是经理的人都有谁?

4. 张飞是经理吗?

5. 身兼一职的人都有谁?

6. 经理和技术人员共有几个人?

1 # 练习:

2 # 经理有: 曹操, 刘备, 孙权

3 # 技术员有: 曹操, 孙权, 张飞, 关羽

4 # 用集合求:

5 # 1. 即是经理也是技术员的有谁?

6 # 2. 是经理,但不是技术人员的都有谁?

7 # 3. 是技术人员,但不是经理的人都有谁?

8 # 4. 张飞是经理吗?

9 # 5. 身兼一职的人都有谁?

10 # 6. 经理和技术人员共有几个人?

13 manager = {"曹操", "刘备", "孙权"}

14 techs = {"曹操", "孙权", "张飞", "关羽"}

15 print("即是经理也是技术员的有:", manager & techs)

16 print("是经理,但不是技术人员的都有:", manager - techs)

17 print("是技术人员,但不是经理的人都有", techs - manager)

18 if "张飞" in manager:

19 print("张飞是经理")

20 else:

21 print("张飞不是经理")

23 print("身兼一职的人都有:", manager ^ techs)

24 print("经理和技术人员共有", len(manager | techs), "个人")

集合的方法:

文档参见:

python_base_docs_html/set.html

集合是可迭代对象

集合推导式:

集合推导式是用可迭代对象创建集合的表达式

语法:

{ 表达式 for 变量 in 可迭代对象 [if 真值表达式]}

示例:

s = { x**2 for x in range(1, 10)}

集合推导式可以嵌套

语法同列表推导式的嵌套相同

固定集合 frozenset

固定集合是不可变的,无序的,含有唯一元组的集合

作用:

固定集合可以作为字典的键,还可以作为集合的值

创建固定集合构造函数 frozenset

frozenset() 创建一个空的固定集合对象

frozenset(iterable) 用可迭代对象创建一个新的固定集合对象

示例:

fz = frozenset()

fz = frozenset(range(10))

fz = frozenset([1, 3, 8, 6, 9])

d = {frozenset({1,2,3}): "集合1,2,3"}

固定集合的运算:

& 交集

| 并集

- 补集

^ 对称补集

< 子集

> 超集

<= >= == !=

in / not in

(以上运算规则等同于set中的规则)

固定集合的方法:

相当于集合的全部方法去掉修改集合的方法

阶段总结:

数据类型:

不可变类型

数字: bool, int, float, complex

容器: str, tuple, frozenset, bytes(后面才学)

可变类型

list, dict, set, bytearray(后面才学)

值:

None, False, True

表达式:

1 + 2

print("hello")

max("ABC") + min("123")

条件表达式:x if x > y else y

全部的推导式: 列表, 字典, 集合推导式

语句:

表达式语句:

print("hello")

"""ABCD"""

赋值语句:

a = 100

a = b = c = 200

x, y = 100, 200

L[1] = 200

d['key'] = '键'

del语句

if 语句

while 语句

for 语句

break 语句

continue 语句

pass 语句

内建函数:

容器相关:

len(x), max(x), min(x), sum(x), any(x), all(x)

构造函数:

bool(x)

int(x)

float(x)

complex(r=0.0, i=0.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, reverse=False)

输入输出相关:

input(x)

print(...)

其它:

type(x)

id(x)

函数 function

什么是函数:

函数是可以重复执行的语句块,可以重复使用

函数是面向过程编程的最小单位

函数的作用:

1. 用于封装语句块,提高代码的重用性

2. 定义用户级别的函数

def 语句

语法:

def 函数名(形参列表):

语句块(代码块)

说明:

1. 函数的名字就是语句块的名称

2. 函数名的命名规则与变量名相同(函数名必须为标识符)

3. 函数名是一个变量(不要轻易对其赋值)

4. 函数有自己的名字空间,在函数外部不可以访问函数内部的变量

在函数内部可以访问函数外部的变量,要让函数处理外部数据

需要传入一些数据

5. 函数如果不需要传入参数,则参数列表可以为空

6. 语句部分不能为空,如果为空需要填充pass语句

作用:

用于创建函数,用函数名这个变量绑定这个函数

示例见:

def.py

def2.py

1 # def.py

4 # 此示例示意用def语句定义一个没有参数的函数

6 def say_hello():

7 print("hello world!")

8 print("hello china!")

9 print("hello tarena!")

11 say_hello()

12 say_hello()

13 say_hello()

def.py

1 # def2.py

4 # 此示例示意用def语句来定义带有参数的函数

5 # 此函数名为mymax, 有两个形式参数a, b 用于接收实参的传递

6 # 此函数计算两个参数的最大值并打印

7 def mymax(a, b):

8 print('a=', a)

9 print('b=', b)

10 if a > b:

11 print(a, "大于", b)

12 else:

13 print(a, '小于等于', b)

15 mymax(100, 200) # 函数调用

def2.py

函数的调用表达式:

函数名(实际调用传递参数)

说明:

函数调用是一个表达式

如果没有return语句,函数执行完毕后返回None对象

练习:

写一个函数myadd,此函数中的参数列表里有两个参数x,y

此函数的功能是打印 x + y 的和

如:

def myadd(...):

... # ...部分自己实现

myadd(100, 200) # 打印 300

myadd("ABC", "123") # 打印 ABC123

1 # 练习:

2 # 写一个函数myadd,此函数中的参数列表里有两个参数x,y

3 # 此函数的功能是打印 x + y 的和

4 # 如:

5 # def myadd(...):

6 # ... # ...部分自己实现

7 # myadd(100, 200) # 打印 300

8 # myadd("ABC", "123") # 打印 ABC123

11 def myadd(x, y):

12 z = x + y

13 print('和是:', z)

15 myadd(100, 200) # 打印 300

16 myadd("ABC", "123") # 打印 ABC123

18 # print(z) # 报错!

19 # print(x)

20 # print(y)

mymadd

2 def myadd(x, y):

3 z = x + y

4 print('和是:', z)

6 v = myadd(100, 200) # 打印 300

7 print("v=", v) # v= None

mymadd2

1 # 2. 写一个函数myadd,实现给出两个数,返回这两个数的和

2 # 如:

3 # def myadd(x, y):

4 # ...

5 # a = int(input("请输入第一个数:"))

6 # b = int(input("请输入第二个数:"))

7 # print("您输入的两个数的和是:", myadd(a, b))

9 # 方法1

10 # def myadd(x, y):

11 # z = x + y

12 # return z

14 # 方法2

15 # def myadd(x, y):

16 # return x + y

18 a = int(input("请输入第一个数:"))

19 b = int(input("请输入第二个数:"))

20 print("您输入的两个数的和是:", myadd(a, b))

mymadd3

练习2

写一个函数print_event,传入一个参数n代表终止的整数,打印

0 ~ n 之间所有的偶数

如:

def print_even(n):

..... 此处自己完成

print_even(10)

打印:

1 # 练习2

2 # 写一个函数print_even,传入一个参数n代表终止的整数,打印

3 # 0 ~ n 之间所有的偶数

4 # 如:

5 # def print_even(n):

6 # ..... 此处自己完成

7 # print_even(10)

8 # 打印:

9 # 0

10 # 2

11 # 4

12 # 6

13 # 8

16 def print_even(n):

17 for x in range(0, n+1, 2):

18 print(x)

20 print_even(10)

print_even

return 语句:

语法:

return [表达式]

注: [] 代表其中的内容可省略

作用:

用于函数中,结束当前函数的执行,返回到调用该函数的地方,同

时返回一个对象的引用关系

说明:

1. return 语句先执行右侧的表达式,再将表达式的执行结果送

回给当前函数的调用者

2. return 语句右侧的表达式可以省略,省略后相当

于return None

3. 如果函数内没有return语句,则函数执行完最后一条语句后

返回None(相当于在最后加了一条return None语句)

示例见:

return.py

1 # return.py

3 # 此示例示意return语句在函数中的应用

5 def say_hello2():

6 print("hello aaa")

7 print("hello bbb")

8 return # 等同于 return None

9 # return 1 + 2

10 # return [1, 2, 3, 4]

11 print("hello ccc")

13 v = say_hello2()

14 print("v=", v)

16 v2 = say_hello2()

17 print("v2=", v2)

1 # return.py

3 # 此示例示意return语句在函数中的应用

5 def say_hello2():

6 print("hello aaa")

7 print("hello bbb")

8 print("hello ccc")

9 return None

11 v = say_hello2()

12 print("v=", v)

练习:

1. 写一个函数mymax, 实现返回两个数的最大值:

如:

def mymax(a, b):

.... # 此处自己实现

print(mymax(100, 200)) # 200

print(mymax("ABC", 'ABCD')) # ABCD

1 # 练习:

2 # 1. 写一个函数mymax, 实现返回两个数的最大值:

3 # 如:

4 # def mymax(a, b):

5 # .... # 此处自己实现

7 # print(mymax(100, 200)) # 200

8 # print(mymax("ABC", 'ABCD')) # ABCD

10 # 方法1

11 # def mymax(a, b):

12 # zuida = a

13 # if b > zuida:

14 # zuida = b

15 # return zuida

17 # 方法2

18 # def mymax(a, b):

19 # if a > b:

20 # return a

21 # else:

22 # return b

24 # 方法3

25 def mymax(a, b):

26 if a > b:

27 return a

28 return b

30 print(mymax(100, 200)) # 200

31 print(mymax("ABC", 'ABCD')) # ABCD

mymax

2. 写一个函数myadd,实现给出两个数,返回这两个数的和

如:

def myadd(x, y):

...

a = int(input("请输入第一个数: "))

b = int(input("请输入第二个数: "))

print("您输入的两个数的和是:", myadd(a, b))

3 写一个函数 input_number

def input_number():

.... # 此处自己实现,此函数返回列表

此函数用来获取用户循环输往返整数,当用户输入负数时结束输入

将用户输入的数字以列表的形式返回,再用内建函数max,min,

sum 求出用户输入的最大值,最小值及和

L = input_number()

print("用户输入的最大数是:", max(L))

print("用户输入的最小数是:", min(L))

print("用户输入的全部数的和是:", sum(L))

1 # 3 写一个函数 input_number

2 # def input_number():

3 # .... # 此处自己实现,此函数返回列表

5 # 此函数用来获取用户循环输往返整数,当用户输入负数时结束输入

6 # 将用户输入的数字以列表的形式返回,再用内建函数max,min,

7 # sum 求出用户输入的最大值,最小值及和

9 # L = input_number()

10 # print("用户输入的最大数是:", max(L))

11 # print("用户输入的最小数是:", min(L))

12 # print("用户输入的全部数的和是:", sum(L))

17 def input_number():

18 # 1. 创建空列表

19 myL = []

20 # 2. 循环读取用户输入的正整数,存入在述列表

21 while True:

22 x = int(input("请输入正整数:"))

23 if x < 0:

24 break

25 myL.append(x)

26 # 3. 返回上述列表的引用关系

27 return myL

29 L = input_number()

30 print("用户输入的最大数是:", max(L))

31 print("用户输入的最小数是:", min(L))

32 print("用户输入的全部数的和是:", sum(L))

inputnumber

练习:

1. 定义两个函数:

sum3(a, b, c) 用于返回三个数的和

pow3(x) 用于返回x的三次方(立方)

用以上函数计算:

1. 计算1的立方 + 2的立方+3的立方的和

2. 计算 1+2+3 的和的立方

即:

1**3 + 2**3 + 3**3 和 (1+2+3)**3

1 # 1. 定义两个函数:

2 # sum3(a, b, c) 用于返回三个数的和

3 # pow3(x) 用于返回x的三次方(立方)

4 # 用以上函数计算:

5 # 1. 计算1的立方 + 2的立方+3的立方的和

6 # 2. 计算 1+2+3 的和的立方

7 # 即:

8 # 1**3 + 2**3 + 3**3 和 (1+2+3)**3

11 def sum3(a, b, c): # 用于返回三个数的和

12 return a + b + c

14 def pow3(x): # 用于返回x的三次方(立方)

15 return x ** 3

18 # 1. 计算1的立方 + 2的立方+3的立方的和

19 print(sum3(pow3(1), pow3(2), pow3(3))) # 36

21 # 2. 计算 1+2+3 的和的立方

22 print(pow3(sum3(1, 2, 3))) # 216

2. 写一个函数 get_chinese_char_count(s), 此函数功能是

给定一个字符串s,返回这个字符串中中文字符的个数

def get_chinese_char_count(s):

...

s = input("请输入中英文混合的字符串: ")

print("中文字符的个数是:",

get_chinese_char_count(s))

注: 中文的编码范围是: 0x4E00~0x9FA5

1 # 2. 写一个函数 get_chinese_char_count(s), 此函数功能是

2 # 给定一个字符串s,返回这个字符串中中文字符的个数

3 # def get_chinese_char_count(s):

4 # ...

5 # s = input("请输入中英文混合的字符串:")

6 # print("中文字符的个数是:",

7 # get_chinese_char_count(s))

8 # 注: 中文的编码范围是: 0x4E00~0x9FA5

11 def get_chinese_char_count(s):

12 count = 0

13 for ch in s:

14 if 0x4e00 <= ord(ch) <= 0x9fa5:

15 count += 1

16 return count

18 s = input("请输入中英文混合的字符串:")

19 print("中文字符的个数是:", get_chinese_char_count(s))

3. 改写之前的学生信息管理程序:

用两个函数来封装功能的代码块

函数1: input_student() # 返回学生信息字典的列表

函数2: output_student(L) # 打印学生信息的表格

def input_student():

... 此处自己实现

def output_student(L):

... 此处自己实现

infos = input_student()

print(infos) # 打印列表[{...}, {...}]

output_student(infos) # 根据实参infos打印表格

2 # 3. 改写之前的学生信息管理程序:

3 # 用两个函数来封装功能的代码块

4 # 函数1: input_student() # 返回学生信息字典的列表

5 # 函数2: output_student(L) # 打印学生信息的表格

7 def input_student():

8 L = [] # 创建一个列表,准备存放学生数据的字典

9 while True:

10 n = input("请输入姓名:")

11 if not n: # 如果用户输入空字符串就结束输入

12 break

13 a = int(input("请输入年龄:"))

14 s = int(input("请输入成绩:"))

15 d = {} # 一定要每次都创建一个新的字典

16 d['name'] = n

17 d['age'] = a

18 d['score'] = s

19 L.append(d) # 把d加入列表中L

20 return L

22 def output_student(L):

23 print("+---------------+----------+----------+")

24 print("| 姓名 | 年龄 | 成绩 |")

25 print("+---------------+----------+----------+")

26 for d in L:

27 name = d['name']

28 age = str(d['age']) # 转为字符串

29 score = str(d['score']) # 转为字符串

30 print("|%s|%s|%s|" % (name.center(15),

31 age.center(10),

32 score.center(10)))

33 print("+---------------+----------+----------+")

36 infos = input_student()

37 print(infos) # 打印列表[{...}, {...}]

38 output_student(infos) # 根据实参infos打印表格

喵杀

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
python集合运算求出经理和技术人员有几人_PYTHON1.day08

day07 回顾:两个容器:元组 tuple(不可变的序列)字典 dict(可变的无序的容器)元组序列: 字符串 str, 列表 list, 元组 tuple, bytes, bytearray元组的表示方式:() (20,) (1, 2 ,3) 20, 1,2,3构造函数:tuple() tuple(可迭代对象)元组的运算:+ += * *=< <= &g...
复制链接

扫一扫