一、基础元素

• 对于一件事情正确与否的判断。

• 根据判断的结果做不同的事情，就是我们的逻辑业务。

• 对于条件满足的判断语句，就是条件语句。
  

• 一个逻辑语句是由条件语句和业务语句组合而成的。

• 判断一个命题的真实性，如果命题为真(True)则执行if的逻辑语句。
  if属于关键字，没有返回值

# coding:utf-8

info = 'my name is xiaoming'

info_list = info.split()

print(info_list)

if info_list[0] == 'xiaoming':
    print(1)
    info_list[0] = 'xyj'

if info_list[1] == 'xiaoming':
    print(2)
    info_list[1] = 'xyj'

if info_list[2] == 'xiaoming':
    print(3)
    info_list[2] = 'xyj'

if info_list[-1] == 'xiaoming':
    print(4)
    info_list[-1] = 'xyj'

print(info_list)
info = ' '.join(info_list)
print(info)

这里只解释join函数，join函数的作用是以指定的字符连接生成一个新的字符串。

info = 'my name is dewei, i am a pythoner, i love python'
info_list = info.split()
print(info_list)

if info_list[0] == 'python' or info_list[0] == 'i':
    info_list[0] = '*'

if info_list[0] in ['python', 'i']:
    info_list[0] = '*'

if info_list[1] == 'python' or info_list[1] == 'i':
    info_list[1] = '*'

if info_list[2] == 'python' or info_list[2] == 'i':
    info_list[2] = '*'

if info_list[3] == 'python' or info_list[3] == 'i':
    info_list[3] = '*'

if info_list[4] == 'python' or info_list[4] == 'i':
    info_list[4] = '*'

if info_list[5] == 'python' or info_list[5] == 'i':
    info_list[5] = '*'

if info_list[6] == 'python' or info_list[6] == 'i':
    info_list[6] = '*'

if info_list[7] == 'python' or info_list[7] == 'i':
    info_list[7] = '*'

if info_list[8] == 'python' or info_list[8] == 'i':
    info_list[8] = '*'

if info_list[9] == 'python' or info_list[9] == 'i':
    info_list[9] = '*'

if info_list[10] == 'python' or info_list[10] == 'i':
    info_list[10] = '*'

# if info_list[-1] in ['python', 'i']:
    # info_list[10] = '*'

print(info_list)

info = ''.join(info_list)
print(info)

运行结果：

这里只解释两个点：

• 第一点是复习in关键字， if info_list[0] in ['python', 'i']:这里代表”或“的意思，就是有一个成立则成立的意思。
• 第二点是复习split()，按照默认的空格对字符串进行分割。

info = 'my name is xiaozhu'
print(len(info))

if len(info) > 10 and len(info) != 15:
# if len(info) > 10 and len(info) != 16:
    print(info.replace('xiaozhu', 'xijao'))

print('finish')

运行结果：

这里只解释两个点：

• and关键字表示“并且”的意思，就是两者都要成立。
• replace()函数的第一个参数是表示要被替换的字符串，第二个参数是替换为什么字符串。

二、 else

• else 就是对于if条件不满足的时候执行另一个代码块的入口。
  

• 当if语句不满足时所执行的代码块的入口。

用法：
if bool_result:
	do
else:
	elsedo  # else语法块，需缩进
	# 缩进等级与do语法块一致

参数： elsedo: else 语句对应的python代码块
返回值：else属于语法，没有返回值

url = 'https://www.baidu.com'

if 'www.baidu.com' in url:
    print('你进入了百度搜索引擎，请进行搜索')
else:
    print('请前往自习室看高数')

• 最基础的if-else逻辑代码，如果if后面的判断成立的话，那么输出if逻辑内的语句，如果判断不成立的话就输出else逻辑内的语句。

3. elif

• elif 对于命题的非第一次的多种判断，每一种判断条件对应一组业务代码。
• 对于首次if判断不满足后，其他条件的判断语句。

用法：
if bool_result:
	do
elif bool_result:
	elifdo  # 当前elif语句对应语法块
else:
	elsedo
参数：elifdo: 当前elif语句对应的python代码
返回值：elif属于语法，没有返回值

• 条件语句种满足一个条件后，将退出当前条件语句。
• 每个条件语句种仅由且必须有一个if语句，可以有0各或者多个elif语句，可以有0或者1各else语句。
• 每个条件语句if必须是第一个条件语句。

users = [
    ('dewei', 33, 90),
    ('xiaomu', 10, 99),
    ('xiaoming', 18, 100)
]

xiaoming = ['xiaoming', 19, 90]

if users[0][0] == 'xiaoming':
    xiaoming[0] = '%s_new' % xiaoming[0]
    users.append(xiaoming)
elif users[1][0] == 'xiaoming':
    xiaoming[0] = '%s_new' % xiaoming[0]
    users.append(xiaoming)
elif users[2][0] == 'xiaoming':
    xiaoming[0] = '%s_new' % xiaoming[0]
    users.append(xiaoming)
else:
    users.append(xiaoming)
print(users)

运行结果：

代码整体实现的是判断xiaoming是否是新生，如果是新生则添加xiaoming到users中，如果不是则输出users。

users = [
    ('dewei', 33, 90),
    ('xiaomu', 10, 99),
    ('xiaoming', 18, 100)
]

xiaoming = ['xiaomings', 19, 90]

if users[0][0] == xiaoming[0]:
    xiaoming[0] = '%s_new' % xiaoming[0]
    users.append(xiaoming)
elif users[1][0] == xiaoming[0]:
    xiaoming[0] = '%s_new' % xiaoming[0]
    users.append(xiaoming)
elif users[2][0] == xiaoming[0]:
    xiaoming[0] = '%s_new' % xiaoming[0]
    users.append(xiaoming)
else:
    users.append(xiaoming)
print(users)

运行结果：

4. for

通过for关键字将列表，元组，字符串，字典中的每一个元素按照序列顺序进行遍历（也叫循环）

用法：
for item in iterable: # for 循环语法块
	print(item)  # 每次循环对应的代码块
	# 代码块需要缩进
参数：
	iterable：可循环的数据类型，如列表，元组，字符串，字典
	item：iterable中的每一个元素（成员）
返回值：
	for循环是语句，没有返回值，但在特定情况下有返回值

字典利用items内置函数进行for循环，将字典转换为伪列表，每个key，value转成元组。

用法：
for key, value in dict.items():
	print(key, value)
参数：
items无参数，
key：for循环体中获取的字典当前元素的key
value：for循环体中对应当前key的value值
返回值：
for 循环是语句，没有返回值，items返回一个伪列表。

users = {'name': 'dewei', 'age': 18}
items = users.items()
print(items)

for key, value in users.items():
    print(key, value)

users_list = [
    {'username': 'dewei'},
    {'username': 'xiaomu'}
]

for user in users_list:
    print(user.get('username'))
    print(user.get('age'))

可以通过get函数操控键。

range函数是python的内置函数
返回的是一个一定范围的可迭代对象，元素为整形，他不是列表，无法打印信息，但可循环。

用法：
for item in range(start, stop, step=1):
	print(item)
参数：
start：开始的数字，类似索引的左边
stop：结束的数字，类似索引的右边
step：跳步，类似于索引中的第三个参数返回值
返回值：
返回一个可迭代的（循环的）以整形为主的对象

• else语句只有在for循环正常退出后执行。
• 循环没有报错，没有中途停止。

l = range(6)
print(l, type(l))

运行结果：

for i in l:
    print(i)
else:
    print('for 循环结束了')

运行结果：

5. 嵌套for循环

# coding:utf-8

a = [1, 2, 3]
b = [4, 5, 6]

for i in a:
    print(i)
    print('----')
    for j in b:
        print(i + j)
    print('===')

运行结果：

内外循环的关系，外循环跑一次，内循环跑三次。

6. while

以一定条件为基础的循环，条件满足则无线循环 ，条件不满足则退出循环。
不依赖可迭代的数据类型，而for循环依赖。

用法：
while bool_result:
	do
参数：
bool_result：布尔类型，此处与if语法完全一致。
do：while循环体的代码块  # 需要缩进
返回值：
while循环是语句，没有返回值

count = 0
total = 0

while count <= 100:
    total += count
    count += 1
    if count == 10:
        print('count is 10')
    elif count == 50:
        print('count is 50')
    elif count == 99:
        print('count is 99')

print(total)

判断1-100的求和，使用两个变量，count相当于初始值，total相当于每次循环的求和部分。

users = ['zhou', 'xiao', 'da', 'kan']
index = 0
length = len(users)

while index <= length - 1:
    print(users[index])
    index += 1

对users这个列表进行遍历，打破循环的条件是达到最大的索引值。

while True:
    print('xx')

可以使用while True的形式编写死循环，但是我们平时在写代码的过程中要尽量避免死循环，避免这种写法。

7. continue and break

循环遇到continue将停止本次数据循环，进入下一次循环。

用法： 
while bool:
	continue
for item in iterable:
	continue
	print(item)
参数：
	continue属于语法，不需要加() 即可执行。
	无参数
返回值：
continue是语法，没有返回值

break使循环正常停止循环（遍历），这时如果循环配合了else语句，else语句将不执行。

用法：
	while bool：
		break
	for item in iterable：
		break
参数：
	break属于语法，不需要加（）即可执行
	无参数
返回值：
	break是语法，没有返回值

continue与break通常伴随着循环语句中的条件，满足某些条件可以继续执行，不满足某些条件提前结束循环。
在while循环中，break语句优先于while逻辑体的判断。

users = [
    {'username': 'dewei', 'age': 33, 'top': 174, 'sex': '男'},
    {'username': '小慕', 'age': 10, 'top': 175, 'sex': '男'},
    {'username': 'xiaoyu', 'age': 18, 'top': 165, 'sex': '女'},
    {'username': 'xiaogao', 'age': 18, 'top': 188, 'sex': '男'}
]

man = []

for user in users:
    if user.get('sex') == '女':
        continue
    man.append(user)
    print('%s 加入了帮助的行列' % user.get('username'))

print(man)

运行结果：

l = range(100)

for i in l:
    if i == 80:
        print('---')
        print('已经循环80次了，程序要退出了')
        break
    print(i)
else:
    print('循环正常退出了！')

这里重要的是break，如果添加了break，那么在索引到达80的时候就会直接退出整个循环。运行结果如下：

如果不添加break，那么整个循环会执行完，不会中途退出。运行结果如下：