4-1 Python之if语句

if条件后有一个 : ,这是条件分支判断的格式，在最后加入冒号 : ,表示接下来是分支代码块
if判断的子分支代码块需要缩进，在Python规范中，一般使用4个空格作为缩进（可在编辑器中设置tab长度为四个空格）参考链接
相关报错：
1. 没有进行缩进时会报错：
  SyntaxError: expected an indented block
  翻译过来就是:
  语法错误：需要一个缩进的代码块
2. 同一代码块内缩进量不同时会报错：
  SyntaxError: unexpected indent
  翻译过来就是：
  语法错误：意外的缩进

# 举例：  score = 59  if score < 60:print('抱歉，考试不及格')  # ==> 抱歉，考试不及格（当if条件为True时，执行if的子逻辑分支）

4-2 Python之if-else语句

# 举例
score = 59
if score < 60:  print('抱歉，考试不及格')
else:  print('恭喜你，考试及格')

4-3 Python之if-elif-else语句

同if-else语句一样，需要注意 冒号 : 以及缩进
else: 部分为可选语句，实际操作中可以没有 else: 部分
这一系列条件判断会从上到下依次判断，如果某个判断为 True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行了

score = 59
if score < 60:print('抱歉，考试不及格')
elif score >= 90:print('恭喜你，拿到卓越的成绩')
elif score >= 80:print('恭喜你，拿到优秀的成绩')
else:print('恭喜你，考试及格')

4-4 Python之for循环

# for循环的语法格式如下：
for iterating_var in sequence:  statements(s)

举例

s = 'ABCD'
for ch in s[0:2]:  print(ch) # 注意缩进

ch是在for循环中定义的，意思是把字符串s中的每一个元素依次赋值给ch，然后再把ch打印出来，直到打印出字符串s的最后一个字符为止。

4-5 Python之while循环

while循环可以继续进行下去的条件更加简单，只需要判断while循环的条件是否为True即可，当条件为True时，即继续运行下去。

while True:  print(1)  # VsCode直接崩了哈哈哈哈哈哈嗝

num = 1
sum = 0
while num <= 100:  sum = sum + num  # 注意缩进  num = num + 1  # 注意缩进
print(sum)  # ==> 5050

4-6 Python之break跳出循环

用于在循环体内跳出循环

# 综合使用while True和break，计算0~1000以内，所有偶数的和。
num = 0
sum = 0
while True:
&emsp;&emsp;if num > 1000:
&emsp;&emsp;&emsp;&emsp;break
&emsp;&emsp;if num % 2 == 0:
&emsp;&emsp;&emsp;&emsp;sum = sum + num
num = num + 1
print(sum)

# 字符串s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'，输出s的前20个字符
s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
num = 1
for ch in s:  if num > 20:  break  print(ch)  num = num + 1

4-7 Python之continue继续循环

if letter == 'h':continue #此处跳出for枚举'h'的那一次循环
print('当前字母 :', letter)

break:跳出循环，不再执行
continue：跳出本次循环，执行下一次

# s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',输出字符串s中第10个以后的字符
s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
num = 1
for ch in s:if num < 10:num = num + 1continue # 当num < 10时，跳过后续循环代码，继续下一次循环print(ch)num = num + 1

4-8 Python之嵌套循环

示例1

#使用两层嵌套循环输出字符串'ABC'中每个字符和字符串'123'每个字符的排列
s1 = 'ABC'
s2 = '123'
for x in s1:for y in s2:print(x + y)  # +用于拼接字符串
# 在上述代码中，对于外层循环，外层每循环1次，内层就会循环3次

上述代码会得到以下结果

A1
A2
A3
B1
B2
B3
C1
C2
C3

示例2

#字符串s1='ABC'，字符串s2='123'，字符串s3='xyz'，请输出s1、s2、s3中所有字符的排列。
s1 = 'ABC'
s2 = '123'
s3 = 'xyz'
for ch1 in s1:for ch2 in s2:for ch3 in s3:print(ch1 + ch2 + ch3)

输出

A1x
A1y
A1z
A2x
A2y
A2z
A3x
A3y
A3z
B1x
B1y
B1z
B2x
B2y
B2z
B3x
B3y
B3z
C1x
C1y
C1z
C2x
C2y
C2z
C3x
C3y
C3z

第五章 Python的list（列表）容器

5-1 什么是容器、什么是list

容器
容器是一种可以把多个元素放在一起的数据结构，容器中的元素可以逐个地迭代获取，可以用in, not in等关键字判断某个元素是否包含在容器中。
在Python中，包括列表(list)、元组(tuple)、字典(dict)、**集合(set)**等，他们都可以放入多个元素，因此都可以算作是容器，这些容器是Python编程中非常重要的数据结构。
list列表

列表(list)是一种有序的容器，放入list中的元素，将会按照一定顺序排列。构造list的方法非常简单，使用中括号[]把需要放在容器里面的元素括起来，就定义了一个列表。
list不对放入其中的类型进行判断，list可以同时放入任意类型的数据，这是Python这门语言决定的，因为Python是动态语言

names = ['Alice', 'Bob', 'David', 'Ellena']
# 注意，字符串元素仍需要引号
L = ['Alice', 66, 'Bob', True, 'False', 100]
print(L)
# 对于list，可以直接把list的内容打印出来。

5-2 Python按顺序访问list

列表是有序的，因此我们可以按顺序访问列表中的元素。
事实上字符串也可以看作是一种特殊的列表，它只能按顺序存放多个字符。通过for循环访问列表每一个元素的方式，我们称为迭代。

L = ['Alice', 66, 'Bob', True, 'False', 100]
for item in L:print(item) # ==> ['Alice', 66, 'Bob', True, 'False', 100]

对于一个空的列表，使用for循环访问，将不会打印任何东西。

L = []
for item in L:print(item)

使用迭代的方式按顺序输出列表 L = [‘Alice’, 66, ‘Bob’, True, ‘False’, 100] 的偶数位置的元素:

num = 0 # num代表位置
L = ['Alice', 66, 'Bob', True, 'False', 100]
for item in L:num = num + 1if num % 2 != 0: # 注意 : # num为奇数时利用continue跳出本次循环开始下次循环continueprint(item)# 注意缩进

5-3 Python按索引访问list

5-4 Python倒序访问list

索引(index)介绍
1. 和C语言下标类似
2. 从零开始
3. 存在负数索引，采用负数索引时，Python将从右（即从最后一个元素）开始往左数，因此-1是最后一个元素的位置
4. 负数索引与正数索引之间存在一个规律：当正数索引+负数索引的绝对值=元素的个数，它们所指的是同一个元素
索引不能越界

# 越界提示
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range

利用索引切片(slicing)
1. 使用两个索引，并用冒号分隔(同字符串切片，区间左闭右开)
2. 越界切片不会报错，获取不到元素
利用索引简写
如果切片位于列表开头，可省略第一个索引
如果切片位于列表结尾，可省略第二个索引
如果需要整个列表，可省略两个索引，直接使用 [ : ]

5-5 Python向list添加新的元素

# 示例
names = ['Alice', 'Bob', 'David', 'Ellena']

append() 添加
将元素添加到列表末尾

names = ['Alice', 'Bob', 'David', 'Ellena']
names.append('Candy')
print(names) # ==> ['Alice', 'Bob', 'David', 'Ellena', 'Candy']

insert() 插入
需要两个参数，分别为插入的位置与插入的元素

ames = ['Alice', 'Bob', 'David', 'Ellena']
names.insert(2, 'Candy')
print(names) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

5-6 Python从list删除元素

pop()
默认删除最后一个元素

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop()
print(name) # ==> Ellena
print(L) # ==> L = ['Alice', 'Bob', 'Candy', 'David']

pop( 参数 ) 参数用来说明删除的元素的位置

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop(2)
print(name) # ==> Candy
print(L) # ==> ['Alice', 'Bob', 'David', 'Ellena']

5-7 Python替换list中的元素

直接利用索引完成替换

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
L[2] = 'Canlina'
print(L) # ==> ['Alice','Bob', 'Canlina', 'David', 'Ellena']

注意替换时避免索引越界，否则会报错

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
L[6] = 'Canlina'

Traceback (most recent call last):File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range

5-8 Python二维list

例一

alice_scores = [100,89,92]
bob_scores = [70,65,81]
candy_scores = [88,72,77]
all_scores = [alice_scores, bob_scores, candy_scores]
score = all_scores[1][2] # ==> 81

其中all_scores[1]得到Bob的最近三次成绩的列表，再通过下标[2]得到Bob成绩列表中的第三个的元素

例二
有三个长方体，长宽高分别是[1, 2, 3], [5, 3, 2], [7, 3, 2]，定义在数组L中，L = [[1, 2, 3], [5, 3, 2], [7, 3, 2]]，请分别求出三个长方体的表面积

L = [[1,2,3], [5, 3, 2], [7,3,2]]
for cube in L: # 对一维[]进行遍历# 下方的索引指二维[ [] ]索引length = cube[0] width = cube[1]height = cube[2]result = length * width * 2 + width * height * 2 + length * height * 2print(result)

Python的tuple（元组）容器

6-1 什么是tuple

元组(tuple)和list一样，也是一个有序容器，在元组中，同样可以包含0个或者多个元素，并且也支持索引访问、切片等操作
定义元组的方式是使用parentheses圆括号()将元组内的元素括起来

T = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
# 通过下标的方式访问元素
print(T[0]) # ==> Alice
print(T[4]) # ==> Ellena
# 切片
print(T[1:3]) # ==> ('Bob', 'Candy')

tuple和list容器可以相互转换

# list ==> tupleL = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
print(L) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
T = tuple(L)
print(T) # ==> ('Alice', 'Bob', 'Candy', 'David', 'Ellena')

# tuple ==>listT = ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
print(T) # ==> ('Alice', 'Bob', 'Candy', 'David', 'Ellena')
L = list(T)
print(L) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

tuple和list的主要区别就是, tuple是一开始就定义好的, 即 assign first,之后就永远不能被改变了

# 删除tup, 会报错
del tup[0]

Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

存在的意义：

一般全局比较重要的数据,我们都是使用tuple进行存放的

tuple在内部有遍历加速(因为不变)，在运行上tuple的性能是list的数倍

tuple不可改变值的类型，但可以改变引用的类型
- 如果你的tuple里面放一些可变的内容的话, 比如,list的话,那情况就不一样了。基于这一点,我们理解tuple应该说为不能改变值类型,但可以改变引用类型
```
tup = ((1, 2, 3, [2, 3], 5))
print (tup[3]) # ==> [2, 3]
tup[3].append(1)
print (tup) # ==> (1, 2, 3, [2, 3, 1], 5)
```

6-2 访问tuple元素的其他方法

count()方法
count()方法用来统计tuple中某个元素出现的次数

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1

对于不存在的元素，count方法不会报错，而是返回0，这是合理的，因为元组里面有0个不存在的元素

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(10)) # ==> 0

index()方法
index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(5) # ==> 8
T.index(1) # ==> 0 # 多次出现，返回第一次出现的位置

当指定的元素不存在时，使用index()方法会报错

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(100)

Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple

6-3 Python创建单个元素的tuple

T = ()
print(T) # ==> ()T = (1)
print(T) # ==> 1

改变优先级通过()来实现的，这和元组的定义有冲突，这就解释了前面只有一个元素的元组，为什么打印出来却得到一个数字的结果了
因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1
要定义只有一个元素的tuple，需要在元素后面添加一个逗号 ,
例题

#tuple的元素也可以是tuple，请判断以下定义T的元素中，有多少个tuple
T = ((1+2),  ((1+2),), ('a'+'b'), (1, ), (1,2,3,4,5))
# 3个,第一个元素(1+2)，第三个元素('a'+'b')，计算的结果分别是数字3和字符串ab，不是tuple
# Python的dict容器
**********
**********
# 7-1 什么是dict
* 引例
```python
names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
scores = [45, 60, 75, 86, 49]
index = 0
for name in names:score = scores[index]print('name = {}, score = {}'.format(name, score))index = index + 1

得到映射

'Alice' ==> 45
'Bob' ==> 60
'Candy' ==> 75
'David' ==> 86
'Ellena' ==> 49

dict
python的dict就是专门保存这种映射的，用dict可以方便的保存“名字”->“成绩”的映射。
在dict中，每一项包含一个key(键)和一个value(值)，key和value是一一对应的，在解决上面的问题中，我们可以使用名字作为key，成绩作为value，那么dict的定义如下：

d = {             # 大括号'Alice': 45,  # 注意逗号的分割'Bob': 60,    # key和value之间使用冒号 : 分割'Candy': 75,'David': 86,'Ellena': 49  # 结尾无逗号
}

另一种定义方式

# 这种定义方式，默认得到的是一个空dict，需要调用函数往里面添加数据
d = dict()
print(d) # ==> {}

字典键的特性

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print ("dict['Name']: ", dict['Name']) # ==>dict['Name']:  Manni

键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

dict = {['Name']: 'Zara', 'Age': 7}
print "dict['Name']: ", dict['Name']

报错

Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {['Name']: 'Zara', 'Age': 7}

TypeError: list objects are unhashable
```

7-2 Python读取dict元素

dict提供通过key找到对应value的功能，通过d[key]的形式，就可以得到对应的value

方法一
dict提供通过key找到对应value的功能，通过 d[key] 的形式，就可以得到对应的value。（注意中括号[]）

d = {'Alice': 45,'Bob': 60,'Candy': 75,'David': 86,'Ellena': 49,'Gaven': 86
}
print(d['Bob']) # ==> 60
print(d['Alice']) # ==> 45

当对应的key不存在时，也会引发错误

d = {'Alice': 45,'Bob': 60,'Candy': 75,'David': 86,'Ellena': 49,'Gaven': 86
}
print(d['Dodo'])

# 抛出异常
Traceback (most recent call last):File "<stdin>", line 1, in <module>
KeyError: 'Dodo'
# 意思是key不存在，因此我们在需要通过key找到value时，一定要先判断key存不存在，然后才使用上面的方式获取对应的value，以避免错误

运用

if 'Alice' in d:print(d['Alice']) # ==> 45
if 'Dodo' in d: # Dodo不存在，所以不会走下面的逻辑print(d['Dodo'])

方法二
除了使用这种方法，还有一种方法可以通过key来获取对应的value，这种方法不会引起错误，dict本身提供get方法，把key当作参数传递给get方法，就可以获取对应的value，当key不存在时，也不会报错，而是返回None。

print(d.get('Alice')) # ==> 45
print(d.get('Dodo')) # ==> None

因为通过get方法在代码实现上更加简单，且不会引起错误，因此更加推荐使用get方法来获取dict的元素

7-3 Python添加dict元素

    d = {'Alice': 45,'Bob': 60,'Candy': 75,'David': 86,'Ellena': 49}# 添加数据d['Mimi'] = 72d['Dodo'] = 88print(d)# value可以是任何类型， 替换value类型d['Mimi'] = [72, 73]print(d)# 往value中追加值d['Mimi'].append(75)print(d)

结果:

{'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49, 'Mimi': 72, 'Dodo': 88}
{'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49, 'Mimi': [72, 73], 'Dodo': 88}
{'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49, 'Mimi': [72, 73, 75], 'Dodo': 88}

关于作业

本周项目实战第二题在操作中出了一些问题，思路如下：

思路一
将stu_info的键值进行对换，同时将原字典中value相同的key值合并到一起，但在实际操作过程中一旦将键值翻转，相同value的key就会出现覆盖的现象，导致出现数据的丢失
思路二
将stu_info字典中的key和value分别转换为列表形式，并对value中相同的值通过set进行剔除，然后创建一个班级号为key值的字典，通过判断将原字典中key和value转换的列表中元素的对应来将相应的元素添加到新字典里对应的班级下，然后对新字典进行遍历打印。
问题出现在将数据添加到新字典的部分，添加时出现了索引越界的的报错

Python 3 条件判断和循环语句，list、tuple、dict、set容器，部分函数相关推荐

python 动态执行条件判断_【人生苦短，我学 Python】基础篇——条件判断与循环语句（Day12）_不积跬步，无以至千里！-CSDN博客...
原文作者:AI 菌原文标题:[人生苦短,我学 Python]基础篇--条件判断与循环语句(Day12) 发布时间:2021-02-08 23:17:06 写在前面:大家好!我是[AI 菌],一枚爱弹 ...
linux循环条件,shell脚本编写之条件选择，条件判断，循环语句
1 概述编写shell脚本,一般离不开条件选择,条件判断以及循环语句.掌握这三个语法,将大大提高脚本的编写效率,使得脚本编写更加灵活,完成X相对复杂的工作 2 条件选择if语句 if语句选择执行,逐 ...
笔记整理1----Java语言基础（一）01 变量与数据类型+02 运算符与表达式+03 条件判断与循环语句+04 JAVA数组+05 函数与方法
01 变量与数据类型+02 运算符与表达式+03 条件判断与循环语句+04 JAVA数组+05 函数与方法第01天 java基础知识今日内容介绍  Java概述.helloworld案例  工 ...
python之条件判断、循环和字符串格式化
1. python的条件判断:if和else 在条件判断中可以使用算数运算符等于:== 不等于:!= 大于:> 小于:< 大于等于:>= 小于等于:<= 示例1: usern ...
Linux shell的条件判断、循环语句及实例
shell条件判断的两个特殊设备 /dev/null linux系统的空设备,也称为位桶,任何写入其中的数据均会被丢弃当你不想将标准化输出显示或者保存至文件时可以将文件从定向到/dev/null 禁止 ...
java基础语法——条件判断与循环语句
目录一.流程控制语句流程控制语句分类二.顺序结构顺序结构概述顺序结构图三.选择结构选择结构概述选择结构(if语句1) 选择执行图1 选择结构(if语句2) 选择执行图2 选择结构(if ...
Go (一) 基础部分2 -- if条件判断,for循环语句
一.if 条件语句 1.1.if 条件判断,Go语言中if条件判断的格式如下: if 表达式1 { 分支1 } else if 表达式2 { 分支2 } else{ 分支3 } ...
Python中的判断与循环语句
if判断语句的相关知识 if语句的应用 while循环语句的相关知识 for循环 break和continue if 语句用来进行判断的,其语法格式如下: if 要判断的条件: 条件成立后要执行的事情 ...
Python的条件判断与循环样例
2019独角兽企业重金招聘Python工程师标准>>> 一.if 判断 Python条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块. if exp ...

Python 3 条件判断和循环语句，list、tuple、dict、set容器，部分函数