python(面向过程二)

近风臾

已于 2023-11-20 00:06:44 修改

阅读量165

点赞数 1

文章标签： python 开发语言

于 2023-08-20 16:43:46 首次发布

本文链接：https://blog.csdn.net/2301_76473891/article/details/132393433

版权

3.运算符

3.1算术运算符

以下假设变量 a=10，变量 b=21：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 31
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - 返回除法的余数	b % a 输出结果 1
**	幂 - 返回x的y次幂	a**b 为10的21次方
//	取整除 - 往小的方向取整数	`>>> 9//2 4 >>> -9//2 -5`

3.2赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。	在这个示例中，赋值表达式可以避免调用 len() 两次:`if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")`

3.3比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

3.4按位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
\|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a \| b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

3.5逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

3.6成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

3.7身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ，类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

3.8运算符优先级

以下表格列出了从最高到最低优先级的所有运算符，相同单元格内的运算符具有相同优先级。运算符均指二元运算，除非特别指出。相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：

运算符	描述
`(expressions...)`,`[expressions...]`, `{key: value...}`, `{expressions...}`	圆括号的表达式
`x[index]`, `x[index:index]`, `x(arguments...)`, `x.attribute`	读取，切片，调用，属性引用
await x	await 表达式
`**`	乘方(指数)
`+x`, `-x`, `~x`	正，负，按位非 NOT
`*`, `@`, `/`, `//`, `%`	乘，矩阵乘，除，整除，取余
`+`, `-`	加和减
`<<`, `>>`	移位
`&`	按位与 AND
`^`	按位异或 XOR
`\|`	按位或 OR
`in,not in, is,is not, <, <=, >, >=, !=, ==`	比较运算，包括成员检测和标识号检测
`not x`	逻辑非 NOT
`and`	逻辑与 AND
`or`	逻辑或 OR
`if -- else`	条件表达式
`lambda`	lambda 表达式
`:=`	赋值表达式

4.流程控制

4.1选择结构

4.1.1if语句

a.格式

if语句的一般形式如下所示：

if condition_1:
    statement_block_1
elif condition_2:   #可无
    statement_block_2
else:                #可无  
    statement_block_3

如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
如果 “condition_1” 为False，将判断 “condition_2”
如果"condition_2" 为 True 将执行 “statement_block_2” 块语句
如果 “condition_2” 为False，将执行"statement_block_3"块语句

注意：

1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3.Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。
4、在 Python 中没有 switch…case 语句，但在 Python3.10 版本添加了 match…case，功能也类似.

b.示例

#!/usr/bin/python3
 
var1 = 100
if var1:
    print ("1 - if 表达式条件为 true")
    print (var1)
 
var2 = 0
if var2:
    print ("2 - if 表达式条件为 true")
    print (var2)
print ("Good bye!")

执行以上代码，输出结果为：

1 - if 表达式条件为 true
100
Good bye!

4.1.2if嵌套

在嵌套 if 语句中，可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中。

a.格式

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

b.示例

# !/usr/bin/python3
 
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"

将以上程序保存到 test_if.py 文件中，执行后输出结果为：

$ python3 test.py 
输入一个数字：6
你输入的数字可以整除 2 和 3

4.1.3match…case

Python 3.10 增加了 match…case 的条件判断，不需要再使用一连串的 if-else 来判断了。

match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切

a.格式

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

case _: 类似于 C 和 Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。

b.示例

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"

mystatus=400
print(http_error(400))

以上是一个输出 HTTP 状态码的实例，输出结果为:

Bad request

4.2循坏结构

4.2.1for循环

for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

a.格式

for item in iterable:
    # 循环主体
else:       #可无
    # 循环结束后执行的代码

b.示例

for x in range(6):
  print(x)
else:
  print("Finally finished!")

以上代码执行输出结果为：

0
1
2
3
4
5
Finally finished!

4.3while循环

a.格式

while <expr>:
    <statement(s)>
else:         #可无
    <additional_statement(s)>

expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)

while 循环使用 else 语句,如果 while 后面的条件语句为 false 时，则执行 else 的语句块。

注意: 在 Python 中没有 do…while 循环

b.示例

#!/usr/bin/python3
 
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

执行以上脚本，输出结果如下：

0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于

4.3break&continue区别

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

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

while 语句代码执行过程：

for 语句代码执行过程：

Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句

5.函数

5.1函数基础

5.1.1函数定义

a.格式

def 函数名（参数列表）:
    函数体

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 **()**内的形参列表
函数内容以冒号 : 起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None.

b.示例

#!/usr/bin/python3
 
def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

以上实例输出结果：

5.1.2参数传递

python 函数的参数传递：

**不可变类型：**类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
**可变类型：**类似 C++ 的引用传递，如列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

a.传不可变对象实例

def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
print(id(a))
change(a)

通过 id() 函数来查看内存地址变化：

以上实例输出结果为：

4379369136
4379369136
4379369424

b.传可变对象实例

#!/usr/bin/python3
 
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了

输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

5.1.3函数调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

5.1.4变量的作用域

局部变量:作用范围在函数内部，在函数外部无法使用
全局变量在函数内部和外部均可使用

如何将函数内定义的变量声明为全局变量?

使用global关键字，global变量

5.2函数参数

在Python中，函数允许你定义不定数量的参数，这些参数可以是位置参数、关键字参数或者混合使用。这使得函数能够接受不确定数量的输入，从而更加灵活。

以下是调用函数时可使用的正式参数类型：

必需参数
关键字参数
默认参数
不定长参数

5.2.1位置参数（Positional Arguments）：

位置参数是最常见的参数类型。它们按照从左到右的顺序依次指定在函数定义中。调用函数时，你必须按照相同的顺序传递相应的参数。

def greet(name, message):
    print(f"Hello, {name}! {message}")

greet("Alice", "How are you?")  # 输出：Hello, Alice! How are you?

5.2.2关键字参数（Keyword Arguments)：

关键字参数允许你通过参数名来传递参数，从而不必严格遵循位置顺序。这使得函数调用更具有可读性。

函数调用时通过"键-值"形式传递参数

def greet(name, message):
    print(f"Hello, {name}! {message}")

greet(message="How are you?", name="Bob")  # 输出：Hello, Bob! How are you?

注意

函数调用时如果有位置参数,位置参数必须在发关键字参数的前面,但关键字参数之间不存在先后顺序

5.2.3默认参数（Default Arguments）：

默认参数是在函数定义中给定默认值的参数。如果在调用函数时没有提供对应的参数，函数会使用默认值。

def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Alice")  # 输出：Hello, Alice!
greet("Bob", "Hi")  # 输出：Hi, Bob!

5.2.4不定长度参数（Variable-Length Arguments）：

不定长度参数允许函数接受不确定数量的参数。它们分为两种类型：不定长度位置参数 (*args) 和 不定长度关键字参数 (**kwargs)。

*args 收集所有位置参数，并将它们作为元组传递给函数。
**kwargs 收集所有关键字参数，并将它们作为字典传递给函数。

def mixed_args(*args, **kwargs):
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f"{key}: {value}")

mixed_args(1, 2, 3, a=4, b=5)
# 输出：
# 1
# 2
# 3
# a: 4
# b: 5

5.3匿名函数 (Lambda 函数)

Python 使用关键字lambda 来创建匿名函数。所谓匿名,即无函数名，意即不再使用 def 语句这样标准的形式定义一个函数。

格式

# lambda 参数列表:函数体(一行代码)
lambda [arg1 [,arg2,.....argn]]:expression

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。

示例

x = lambda a : a + 10
print(x(5))

以上实例输出结果：

5.3匿名函数 (Lambda 函数)

Python 使用关键字lambda 来创建匿名函数。所谓匿名,即无函数名，意即不再使用 def 语句这样标准的形式定义一个函数。

格式

# lambda 参数列表:函数体(一行代码)
lambda [arg1 [,arg2,.....argn]]:expression

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。

示例

x = lambda a : a + 10
print(x(5))

以上实例输出结果：

近风臾

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python(面向过程二)

a.格式def 函数名（参数列表） : 函数体函数代码块以def关键词开头，后接函数标识符名称和圆括号 **()**内的形参列表函数内容以冒号起始，并且缩进。return [表达式]结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None.b.示例if a > b:return aelse:return ba = 4b = 55。
复制链接

扫一扫