Python3学习（二）

简单输入和输出

输入

输出

条件控制

[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:
		break

1

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
# 输出finally

pass语句

Python中的pass语句详解

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 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。

参考：

Python3学习