python基础训练营03——字典、集合、判断、循环

一、字典dict：

相比列表list而言，列表list像一本书，如果要查书中的某一个内容，需要把书从前往后翻一遍，直到找到想要获取的东西；而字典dict，就像现实中的字典一样，通过查找特定的字或者词(键key)，从而找到相对应的它的定义和解释(value值)

1. 字典的标志：{ }

2. 字典的定义：

字典由多个键key和与其相对应的值value，构成键-值对，键-值对也称为项item。每项中的键和值之间，用冒号(:)隔开，项之间用逗号(,)隔开。整个字典用一对大括号{ }括起来。空字典不包括任何项，由两个大括号组成——{}

• 字典是python中唯一的内建的映射类型
• 字典是无序的
• 字典中的键key，是唯一的，值value不唯一。
• 键key：可以是任何不可变类型，如：数字、字符串、元组。

3. 基本操作：增删改查：

(1) len(d)：返回字典d中，项item（键值对）的数量

(2) 字典名[键名]：返回字典中键相应的值

(3) 增/改：字典名[键名] = 值

• • • 如果键不存在，向字典中增加一项

• 如果键存在，修改字典中的这一项

注意：字典和列表不同，字典是自动添加。即：即使起初，字典的键并不存在，也可以为他赋值，这样字典就会建立新的项，而无需使用append方法。

x= []
x[42] = 'football'
>>报错

x = {}
x [42] = 'football'
x
>>{42: 'football'}

(4) 删除：del 字典名[键名] ——删除该键名的项

(5) 查询：键名 in 字典名：键key是否在字典中。——检查成员资格。

注意：检查的是键，而不是值。

(6) dict函数：

dict()函数用于创建一个字典

 #创建一个空字典
 >>>dict()
 {}

 5 #通过关键字，创建字典
 >>>dict('name' = 'tom', 'age' = 20)
 {name: "tom", age: 20}

 #通过一个可迭代对象，创建字典
 >>>dict(('name', 'tom'), ('age', 20))

4. 字典方法：

(1) clear()：

用于：清除字典中的所有项，没有返回值(返回None)

eg:

>>>dict2 = {}
>>>dict1['age'] = 20
>>>dict
['age': 20]
>>> d = dict2.clear()
>>>dict2
{}
>>>d
None

(2) copy()：

返回：字典的一个浅复制

>>> x = {'one': 1, 'two': 2, 'three': [1, 2, 3]}
>>> y = x.cpoy()
>>> y
{'one': 1, 'two': 2, 'three': [1, 2, 3]}
>>> y['one'] = 000
>>> y
{'one': 000, 'two': 2, 'three': [1, 2, 3]}
>>> x
{'one': 1, 'two': 2, 'three': [1, 2, 3]}
>>> del y['two']
>>> y
{'one': 000,  'three': [1, 2, 3]}
>>> x
{'one': 1, 'two': 2, 'three': [1, 2, 3]}
>>> y['three'][1] = 5000
>>> y
{'one': 000,  'three': [1, 5000, 3]}
>>> x
{'one': 1, 'two': 2, 'three': [1, 5000, 3]}

可以看到，直接对字典内的“一级元素”，进行操作时，对副本y操作，原始字典x不受影响。但是当对“元素的元素”进行操作时，操作副本y，原始字典x也会发生改变。

所以说，浅拷贝，不是一个完完全全独立的副本。

避免的方法是，使用深拷贝（deep copy），需要调用copy模块的deepcopy函数。

直接赋值、浅拷贝、深拷贝的区别：只有涉及对象嵌套时，有区别

a、直接赋值：b = a: 赋值引用，a 和 b 都指向同一个对象。

b、浅拷贝：b = a.copy(): a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。

c、深拷贝：b = copy.deepcopy(a): a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

3. fromkeys(seq, val)：

以序列seq中的元素，作为字典中的键，以val作为每个键对应的初始值，val默认值是None

>>> dict.fromkeys([1, 2, 3])
{1: None, 2: None, 3: None}
>>> dict.fromkeys([1, 2, 3], ('val'))
{1: 'val', 2: "val", 3: 'val'}

4. get(key, default = None)：

获取字典中，指定键key的值value，如果该键key，不存在。则返回默认值

>>> x = {1: 'one', 2: 'two', 3: 'three'}
>>> x.get(1)
'one'
>>> x.get(5)
None
>>> x.get(5, '不存在')
'不存在'

5. key in dict

键名 in 字典名

判断键key，是否在字典中，是，返回True；否则：返回False

>>> d = {1: "A", 2: "B", 3: "C"}
>>> 1 in d
True
>>> 5 in d
False

6. items():

items()方法，返回字典中的所有项（键-值对），返回的是一个迭代器对象，使用list()函数，可以使之变为列表list，以列表的方式返回，列表中的每一项都表示为(键，值)的形式，项在返回时没有遵循特定的顺序。

>>> d = {1:"A", 2: "B", 3: "C"}
>>> d.items()
dict_items([(1, "A"), (2, "B"), (3, "C")])　　#迭代器对象
>>> list(d.items())
[(1, "A"), (2, "B"), (3, "C")]

7. keys()：

keys()方法，将字典中的键key，以返回，返回的是一个迭代器，使用list()函数，可以使之变为列表list

>>> d = {1:"A", 2: "B", 3: "C"}
>>> d.keys()
dict_keys([1, 2, 3])　　#迭代器对象
>>> list(d.keys())
[1, 2, 3]

8. values():

values()方法，将字典中的键value，以返回，返回的是一个迭代器，使用list()函数，可以使之变为列表list

>>> d = {1:"A", 2: "B", 3: "C"}
>>> d.values()
dict_values(["A", "B", "C"])　　#迭代器对象
>>> list(d.values())
["A", "B", "C"]

9. pop(key):

pop(key)，移出指定的键key的键值对，然后方法返回指定的键key的值value。

>>>  d = {1:"A", 2: "B", 3: "C"}
>>>  d.pop(1)
"A"　　　　　　　　　　　　#返回了pop中的键，对应的value值
>>> d
{2: "B", 3: "C"}       #pop中对应的键值对，被从字典中删除了

10. popitem():

字典中的 popitem()方法和列表list中的pop()方法相似，不过，由于字典是无序的，所以：popitem()弹出的是随机的项item

11. setdefault(key, default = None):

a、setdefault() 方法和 get()类似,：

• • • 如果键key存在于字典中，则返回对于的值value
    • 如果键不已经存在于字典中，则返回：参数default默认值，并且将会添加键key并将值value设为默认值default。

b、参数含义：

• key： 查找的键的值
• default：键key不存在于字典中时，设置到默认值default

c、返回值：

如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None

>>> dict1 = {'Name': 'Runoob', 'Age': 7}
>>> dict1.setdefault("Age",None)
7
>>> dict1
 {'Name': 'Runoob', 'Age': 7}

>>> dict1.setdefault("Sex")
None
>>> dict1
 {'Name': 'Runoob', 'Age': 7, "Sex": None}
>>> dict1.setdefault("address", "unknow")
"unknow"
>>> dict1
 {'Name': 'Runoob', 'Age': 7, "Sex": None, "address": unkown)

12. update():

update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> dict2 = {'Sex': 'female' }
>>> dict.update(dict2)
>>> dict
{'Name': 'Runoob', 'Age': 7, 'Sex': 'female' }

二、集合set：

集合（set）是一个无序的不重复元素序列。

三、条件判断：

1. if判断结构，一般形式：

if condition_1:
     statement_block_1
elif condition_2:
     statement_block_2
else:
     statement_block_3

——如果condition_1为True，则执行statement_block_1代码块；

——如果condition_2为False，则判断condition_2；

——如果condition_2为True，则执行statement_block_2代码块；

——如果condition_2为False，则执行statement_block_3代码块；

注意：

1. 每个条件后面，都要有冒号(：)
2. 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3. if语句可以嵌套

2. 常用的操作符：

逻辑操作符：and、or、not

注意：逻辑操作符，执行的是短路逻辑。

即：

(1)if conditon_A and condition_B:

先看conditon_A 是True还是False，如果是False，就直接返回False，不用再去看condition_B

(2)if conditon_A or condition_B:

同理，先看conditon_A是True还是False，如果是True，就直接返回True，不用再去判断condition_B

3.三目运算符：

4.关于布尔值：

四、循环：

1.while循环：

while 条件表达式:
       代码块

(1) 无限循环：

可以通过设置条件表达式永远不为 false 来实现无限循环，无限循环在服务器上客户端的实时请求非常有用。

可以使用 CTRL+C 来退出当前的无限循环。

(2) while循环使用else语句：

while … else 在条件语句为 false 时执行 else 的语句块：

while 条件表达式:
　　代码块1
else:
　　代码块2

(3) 简单while语句：

当while循环的循环体中只有一条语句时，while循环可以简写成一句话

while 条件表达式: 循环体代码块

eg:

flag = 1
while (flag): print("hello world")

2.for循环：

for <variable> in <sequence>:
    <statements_1>
else:
    <statements_2>

(1) range()函数：

rang(下限，上限，步长)

下限默认为0；步长默认为1

range()函数会一次性创建整个序列，它包括下限，不包括上限。

>>> range(1, 7, 2)
[1, 3, 5]

3.break语句：

直接跳出当前层的循环

4. continue语句：

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

5.循环的else语句：

循环语句可以有 else 子句，

• 它在穷尽列表(以for循环)时，被执行
• 条件变为 false (以while循环)导致循环终止时被执行
• 但循环被break终止时不执行。

6. pass语句：

pass语句是空语句，不做任何作用，只用来占位