5.14 python任务

Task3（2day）

1. Dict字典
   1） 定义
   字典是由key and value 构成，无序结构（不想列表那样有固体位置）；
   note:key 是唯一的，没有重复；
   字典可以多级嵌套；
   2） 创建
   创建字典
   直接创建，用大括号 ainfo{‘1’:3000,‘2’:2000,‘3’:4500,‘4’:8500}
   利用dict函数 info=dict(1=3000,2=2000,3=4500,4=8500)
   3） 字典的方法
   
2. 集合
   1） 特性
   一个无序不重复的元素的组合
   2） 创建
   s = {1,2,3,4,5,6,7,8}
   set（）可变集合

set_test = set(‘hello’)
set_test
{‘h’, ‘l’, ‘e’, ‘o’}
frozenset()不可变集合

set_test = set(‘hello’)
set_test
{‘h’, ‘l’, ‘e’, ‘o’}　　# 由此可见集合中的元素不可重复，都是不同的

n_set_test = frozenset(set_test)
n_set_test
frozenset({‘h’, ‘l’, ‘e’, ‘o’})
3） 方法
1.add 向集合中添加元素

s = {1, 2, 3, 4, 5, 6}
s.add(“s”)
s
{1, 2, 3, 4, 5, 6, ‘s’}

2.clear 清空集合

s = {1, 2, 3, 4, 5, 6}
s.clear()
s
set()

3.copy 返回集合的浅拷贝

s = {1, 2, 3, 4, 5, 6}
new_s = s.copy()
new_s
{1, 2, 3, 4, 5, 6}

4.pop 删除并返回任意的集合元素（如果集合为空，会引发 KeyError）

s = {1, 2, 3, 4, 5, 6}
s.pop()　　# pop删除时是无序的随机删除
1

s
{2, 3, 4, 5, 6}

5.remove 删除集合中的一个元素（如果元素不存在，会引发 KeyError

s = {1, 2, 3, 4, 5, 6}
s.remove(3)
s
{1, 2, 4, 5, 6}

6.discard 删除集合中的一个元素（如果元素不存在，则不执行任何操作

s = {1, 2, 3, 4, 5, 6}
s.discard(“sb”)
s
{1, 2, 3, 4, 5, 6}

7.intersection 将两个集合的交集作为一个新集合返回

s = {1, 2, 3, 4, 5, 6}
s2 = {3, 4, 5, 6, 7, 8}
s.intersection(s2)
{3, 4, 5, 6}

s&s2　　# 可以达到相同的效果
{3, 4, 5, 6}

8.union 将集合的并集作为一个新集合返回

s = {1, 2, 3, 4, 5, 6}
s2 = {3, 4, 5, 6, 7, 8}
print(s.union(s2))
{1, 2, 3, 4, 5, 6, 7, 8}

print(s|s2) # 用 | 可以达到相同效果
{1, 2, 3, 4, 5, 6, 7, 8}

9.difference 将两个或多个集合的差集作为一个新集合返回

s = {1, 2, 3, 4, 5, 6}
s2 = {3, 4, 5, 6, 7, 8}
print(“差集:”,s.difference(s2)) # 去除s和s2中相同元素，删除s2 保留s中剩余元素
差集: {1, 2}

print(“差集:”,s2.difference(s))　　# 去除s和s2中相同元素，删除s2 保留s2中剩余元素

差集: {8, 7}

print(“差集:”,s - s2) # 符号 - 可以达到相同结果
差集: {1, 2}

print(“差集:”,s2 - s) # 符号 - 可以达到相同结果
差集: {8, 7}

10.　symmetric_difference 将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)

s = {1, 2, 3, 4, 5, 6}
s2 = {3, 4, 5, 6, 7, 8}
s.symmetric_difference(s2)
{1, 2, 7, 8}

11.update 用自己和另一个的并集来更新这个集合

s = {‘p’, ‘y’}
s.update([‘t’, ‘h’, ‘o’, ‘n’]) # 添加多个元素
s
{‘p’, ‘t’, ‘o’, ‘y’, ‘h’, ‘n’}

s.update([‘H’, ‘e’], {‘l’, ‘l’, ‘o’}) # 添加列表和集合
s
{‘p’, ‘H’, ‘t’, ‘l’, ‘o’, ‘y’, ‘e’, ‘h’, ‘n’}

12.intersection_update() 用自己和另一个的交集来更新这个集合

s = {‘a’, ‘b’, ‘c’, ‘d’, ‘q’}
s2 = {‘c’, ‘d’, ‘e’, ‘f’}
s.intersection_update(s2) # 相当于s = s - s2
s
{‘c’, ‘d’}

13.isdisjoint() 　如果两个集合有一个空交集，返回 True

s = {1, 2}
s1 = {3, 4}
s2 = {2, 3}
s.isdisjoint(s1)
True # s 和 s1 两个集合的交集为空返回 True

s.isdisjoint(s2)
False # s 和 s2 两个集合的交集为 2 不是空 所有返回False

14.issubset()　如果另一个集合包含这个集合，返回 True

s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s.issubset(s1)
True # 因为 s1 集合 包含 s 集合

s.issubset(s2)
False # s2 集合 不包含 s 集合

15.issuperset() 　如果这个集合包含另一个集合，返回 True

s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s.issuperset(s1)
False # s 集合不包含 s1 集合

s.issuperset(s2)
True # s 集合包含 s2 集合

16.difference_update() 从这个集合中删除另一个集合的所有元素

s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s.difference_update(s2)
s
{1} # s2中的2,3 s集合中也有2,3 所以保留1

s1.difference_update(s2)
s1
{1, 4}
　　
17.symmetric_difference_update() 用自己和另一个的对称差来更新这个集合

s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s1.symmetric_difference_update(s)
s1
{4}

s1.symmetric_difference_update(s2)
s1
{2, 3, 4}

s.symmetric_difference_update(s2)
s
{1}

3. 判断语句（要求掌握多条件判断）
   if条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

每个条件后面要使用冒号（:），表示接下来是满足条件后要执行的语句块。

使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

在Python中没有switch – case语句。

以下为if中常用的操作运算符:
操作符 描述
< 小于
<= 小于或等于

大于
= 大于或等于
== 等于，比较对象是否相等
!= 不等于

if 嵌套

在嵌套 if 语句中，可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中

while 循环

while循环：只要符合条件（条件语句返回的是True）则循环执行某个代码段

break和continue语句及循环中的else子句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。
4. 三目表达式
python中没有其他语言中的三元表达式，不过有类似的实现方
其他语言中，例如java的三元表达式是这样
int a = 1;
String b = “”;
b = a > 1? “执行表达式1”:“执行表达式2”
System.out.println(b)
在python中只有类似的替代办法，如果a>b的结果为真，h=“变量1”,如果为假，h=“变量2”
a = 1
b = 2
h = “”
h = “变量1” if a>b else “变量2”
print(h)
也可以用简单的公式，如下，
a = 1
b = 2
h = “”
h = a-b if a>b else a+b
print(h)
循环语句