目录
[if -- elif -- else](#if – elif – else)
[if 嵌套](#if 嵌套)
[break 和 continue](#break 和 continue)
简单输入和输出
输入
Python 提供了 **input()**内置函数从标准输入读入一行文本，默认的标准输入是键盘。
python
>>> print(input('请输入你的名字：'))
请输入你的名字：张三
张三输出
用 print() 在括号中加上字符串，就可以向屏幕上输出指定的文字。print() 可以接受多个字符串，用逗号隔开，会依次打印每个字符串，遇到逗号会输出一个空格。
python
>>> print('Welcome','to','python')
Welcome to python关键字 end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符。
python
# Fibonacci series: 斐波纳契数列（每个数字是前两个数字之和）
a, b = 0, 1
while b < 1000:
print(b, end=',')
a, b = b, a+b
# 结果为 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,条件控制
if -- elif -- else
Python学习中进行条件判断（if, else, elif）
Python 中用 elif 代替了 else if ，所以if语句的关键字为：if -- elif -- else。
如果condition_1为真，则执行statement_block_1，否则将判断condition_2；如果condition_2为真，则执行statement_block_2，否则将执行condition_3。
python
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3一个 if 语句块中最多只能有一个 else 语句，并且它必须放在所有 if 和 elif 语句的最后，else 语句在所有条件都不满足时执行相应的代码块，elif 可以有多个。
python
age = 33
if age >= 0 and age <= 17:
print("你是未成年人")
elif age >= 18 and age <= 44:
print("你是青年人")
elif age >= 45 and age <=59:
print("你是壮年人")
elif age >= 60 and age <=74:
print("你是中年人")
else:
print("你是高龄老人")
# 输出 你是青年人if 嵌套
在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。
python
if 表达式1:
语句
if 表达式2:
语句
elif 表达式3:
语句
else:
语句
elif 表达式4:
语句
else:
语句例如
python
num=int(input("输入一个数字："))
if num%2==0:
if num%3==0:
print ("你输入的数字可以整除 2 和 3")
else:
print ("你输入的数字可以整除 2，但不能整除 3")
else:
if num%3==0:
print ("你输入的数字可以整除 3，但不能整除 2")
else:
print ("你输入的数字不能整除 2 和 3")条件表达式
允许在一行代码中实现简单的条件判断。
python
value_if_true if condition else value_if_false例如下面的代码，age等于20，大于18，输出 adult 。
python
age = 20
status = "adult" if age >= 18 else "minor"
print(status)match...case
Python 中没有 switch...case 语句，但在 Python3.10 版本添加了功能相似的 match...case 。match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切，即当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。且一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开。
python
def http_error(status):
match status:
case 400:
return "Bad request"
case 404:
return "Not found"
case 418:
return "I'm a teapot"
case _:
return "Something's wrong with the internet"循环语句
while循环
python
while 判断条件(condition)：
执行语句(statements)......在 Python 中没有 do..while 循环；可以通过设置条件表达式永远不为 false 来实现无限循环，无限循环在服务器上客户端的实时请求非常有用，可以使用 CTRL+C 来退出当前的无限循环；可以联合 else 语句一起使用；如果while 循环体中只有一条语句，可以将该语句与 while 写在同一行中。
python
#例1
while 1 ：print("哈哈哈")
#例2
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")for循环
for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。
python
for <variable> in <sequence>:
<statements>整数范围值可以配合 range() 函数使用，也可以搭配 else 语句用于在循环结束后执行一段代码。
python
for number in range(1, 6): # 输出1到5的所有数字：
print(number)
else:
print("Finally finished!") # 1到5的数字输出完后，输出Finally finished!break 和 continue
break 语句可以跳出循环，如果从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
python
n = 5
while n > 0:
n -= 1
if n == 2:
break
print(n)
print('循环结束')4
3
循环结束
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
python
n = 5
while n > 0:
n -= 1
if n == 2:
continue
print(n)
print('循环结束')4
3
1
0
循环结束
推导式
列表推导式
python
[表达式 for 变量 in 列表]
或
[表达式 for 变量 in 列表 if 条件]
python
# 过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母
>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']元组推导式
元组推导式和列表推导式的用法相同，但元组推导式返回的结果是一个生成器对象。
python
(expression for item in Sequence )
或
(expression for item in Sequence if conditional )
python
>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50> # 返回的是生成器对象
>>> tuple(a) # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)集合推导式
python
{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }
python
>>> a = {x for x in 'abracadabra' if x not in 'abc'} # 输出不是 abc 的字母
>>> a
{'d', 'r'}字典推导式
python
{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }
python
>>> dic = {x: x**2 for x in (2, 4, 6)} #以2，4，6为键，以它们三个的平方为值来创建字典
>>> dic
{2: 4, 4: 16, 6: 36}函数
函数的定义与调用
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
Python 定义函数使用 def 关键字，一般格式如下：
python
def 函数名（参数列表）:
函数体任何传入参数和自变量必须放在圆括号中间；return关键字设置返回值，不带表达式的 return 相当于返回 None；函数调用很简单，通过 函数名（参数列表） 即可完成调用。
python
# 计算面积函数
>>> def area(width, height):
return width * height
>>> w, h = 4, 5
>>> print("width =", w, " height =", h, " area =", area(w, h))
# 输出 width = 4 height = 5 area = 20函数参数
形参和实参
形参：形式上的参数，赋值后才有意义，在定义时不占内存，以变量的形式来传递当前未知的值。
实参：有具体值的参数，实际占用内存地址，可以是常量、变量、表达式或其他函数调用的结果。
python
>>> def fun_add(a,b=2): # a是形参，b是实参
return a+b
>>> def fun1(x,y): # x和y是形参
return x-y
>>> fun1(5,3) # 5和3是实参，是在调用函数时传入的实参
2参数类型
位置参数
位置参数是默认的参数类型，必需参数须以正确的顺序传入函数，调用时的数量必须和声明时的一样。
python
>>> def fun_add(a,b):
return a+b
>>> fun(1,1)
2
>>> fun(1)
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
fun(1)
TypeError: fun() missing 1 required positional argument: 'b'
>>>
>>> def fun(a=1,b): # 注意：python中函数定义时要求形参在前，实参在后，位置放反会报错
SyntaxError: non-default argument follows default argument
>>> 关键字参数
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
python
>>> def printinfo( name, age ):
print ("名字: ", name)
print ("年龄: ", age)
return
>>> printinfo( age=20, name="linda" )
名字：linda
年龄：20默认参数
调用函数时，如果没有传递参数，则会使用默认参数。
python
>>> def fun_add(a,b=2):
return a+b
>>> fun(1)
3不定长参数
当需要一个函数能处理比当初声明时更多的参数，此时用到的参数叫做不定长参数，声明时不会命名。
python
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]加了星号 * 的参数会以元组的形式导入，存放所有未命名的变量参数；加了两个星号 ** 的参数会以字典的形式导入；星号 * 可以单独出现，但星号 * 后的参数必须用关键字传入。
python
>>> def printinfo( arg1, *vartuple ):
print (arg1)
print (vartuple)
>>> printinfo(1,2,3,4,5,6)
1
(2, 3, 4, 5, 6)
>>> def printinfo2( arg2, **vardict ):
print (arg2)
print (vardict)
>>> printinfo2(1, a=2,b=3)
1
{'a': 2, 'b': 3}
>>> def f(a,b,*,c):
return a+b+c
>>> f(1,2,3) # 报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
python
>>> def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
# 形参a和b必须使用指定位置参数，c或d可以是位置形参或关键字形参，e和f要求为关键字形参
>>> f(10, 20, 30, d=40, e=50, f=60) # 正确
>>> f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式
>>> f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式/ 前面的形参必须使用指定位置参数的形式，* 后面的形参必须使用关键字参数的形式。
匿名函数
匿名即不再使用 def 语句这样标准的形式定义一个函数，Python 使用 lambda 来创建匿名函数。lambda 函数是一种小型、匿名的、内联函数，它可以具有任意数量的参数，但只能有一个表达式。
python
lambda [arg1 [,arg2,.....argn]]:expression
# arguments 是参数列表，可以包含零个或多个参数，多个参数用逗号隔开
# expression 是一个表达式，用于计算并返回函数的结果lambda 的主体是一个表达式，而不是一个代码块，仅仅能在 lambda 表达式中封装有限的逻辑进去。lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
python
>>> sum = lambda arg1, arg2: arg1 + arg2
>>> print ("相加后的值为 : ", sum( 10, 20 ))
30可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。
python
>>> def myfunc(n):
return lambda a : a * n
>>> mydoubler = myfunc(2)
>>> mytripler = myfunc(3)
>>> print(mydoubler(11))
22
>>> print(mytripler(11))
33迭代器和生成器
迭代器
迭代是访问集合元素的一种方式，迭代器是一个可以记住遍历的位置的对象，迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，迭代器只前进不后退。迭代器有两个基本的方法：iter() 和 next()。
python
import sys # 引入 sys 模块
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
try:
print (next(it))
except StopIteration:1
2
3
4
StopIteration
StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况。
python 异常处理 StopIteration 用来作为迭代器的输出停止/next()
有StopIteration的情况：
python
>>> it = iter([1,2,3,4,5])
>>> while True:
try:
x=next(it)
print(x)
except StopIteration:
break1
2
3
4
5
没有StopIteration的情况：
python
>>> it = iter([1,2,3,4,5])
>>> while True:
x=next(it)
print(x)Traceback后就不能往下执行代码了
1
2
3
4
5
Traceback (most recent call last):
File "<pyshell#4>", line 2, in <module>
x=next(it)
StopIteration
try...except语句
一文彻底搞懂Python异常处理：try-except-else-finally
异常：程序正常执行过程中出现的不正常的情况，该情况影响了程序的正常执行。Python提供了try...except语句（拓展 try-except-else-finally ）来处理程序在运行中出现的异常和错误。try：正常情况下，程序计划执行的语句；except：程序异常执行的语句；else：程序无异常即try段代码正常执行后会执行该语句；finally：不管有没有异常，都会执行的语句。
python
try:
# 代码段1
pass
except name:
# 代码段2
pass
else:
# 代码段3
pass
finally:
# 代码段4
pass例1：除数为0，不使用 try 直接报错退出
python
>>> a = 5 / 0
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
a = 5 / 0
ZeroDivisionError: division by zero
>>> try:
a = 5 / 0
print("try")
except:
print("except")
# 输出except加上 else 和 finally，执行逻辑：try-->except-->finally
python
try :
a = 5 / 0
print('try')
except :
print('except')
else :
print('else')
finally :
print('finally')
# 输出except
# 输出finallypass语句
pass 语句在Python编程中是一个实用的占位符，它可以让程序运行在某些特定的情况下，而不引发任何错误。占位作用：编写一个函数或类，但还没有实现具体功能时，可以使用pass语句作为占位符，以避免语法错误。控制流程：在循环或条件语句中，pass 语句可以用作空的执行体，使得控制流程继续进行。
假设需要开发一个学生管理系统，其中有一个Student类，在开发初期可能只需要定义类的结构，而不需要实现具体功能，这时就可以使用pass语句作为占位符，在后续开发过程中，再逐步实现display_info和update_info方法的具体功能，最终完成整个系统的开发。
python
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def display_info(self):
pass
def update_info(self, new_name, new_age):
pass生成器
使用了 yield 的函数被称为生成器（generator），yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作。调用一个生成器函数，返回的是一个迭代器对象。
当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。
参考：