Python

2403_86618054

已于 2024-08-04 08:28:40 修改

阅读量877

点赞数 18

文章标签： python

于 2024-08-04 08:26:59 首次发布

本文链接：https://blog.csdn.net/2403_86618054/article/details/140901505

版权

Python

第一章前言

1.1 Python 语言特点

易于学习
易于阅读
易于维护
一个广泛的标准库
互动模式
可移植
可扩展
数据库
GUI编程
可嵌入

1.2 Python 应用领域/就业方向

Web开发（Python后端）/后端
Python爬虫工程师
AI工程师
自动化测试工程师
Python游戏开发

1.3 Python 开发工具

IDLE
PyCharm
Sublilme Text
Eric

1.4 PyCharm 快捷键

删除当前行：Shift+delete
复制当前行：Ctrl+D
添加注释，取消注释：Ctrl+/
快速格式化：Ctrl+Alt+L
快速运行：Ctrl+Shift+F10
查看一个类的层次关系(学习OOP继承后，非常有用)：Ctrl+H
复制/粘贴/剪切：Ctrl+C/V/X
查找：Ctrl+F
替换：Ctrl+R

第二章基础语法

2.1 编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。

2.2 标识符

注意：

Python 对各种变量、函数和类等命名时使用的各种字符序列称为标识符
第一个字符必须是字母表中字母或下划线 _ ，不可以数字开头
标识符的其他的部分由字母、数字和下划线组成
标识符不能包含空格
标识符对大小写敏感
不能使用关键字作为标识符，但可以包含关键字
在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了

标识符命名规范：

变量：变量要小写，若有多个单词，用下划线分开
常量：常量全部大写
函数：函数名一律小写，若有多个单词，用下划线分开。特别注意的是，私有函数以双下划线开头
类：使用大驼峰命名

拓展：驼峰命名法

驼峰命名法有两种，分别是大驼峰命名和小驼峰命名
大驼峰命名，多个单词的首字母用大写开头，例如：MyName
小驼峰命名，第一个单词的首字母用小写，后面的首字母都大写，例如：myName

2.3 保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

2.4 注释（Comment）

2.4.1 单行注释和多行注释

# 注释

# 使用#进行单行注释
# print("0")

# 使用'''注释文字'''进行多行注释
'''
print("1")
print("2")
print("3")
'''

# 使用"""注释文字"""进行多行注释
"""
print("4")
print("5")
print("6")
"""

# 使用#进行单多行注释
# print("7")
# print("8")
# print("9")

# 嵌套注释
"""
print("10")
# print("11")
# print("12")
"""

2.4.2 文件编码声明注释

2.5 转义字符

# \t 制表
print("jack\t20\n")

# \n 换行
print("Hello,jack\nhello,tom\n")

# \\ 输出\
print("D\\:python\\chapter02\n")

# \\\\   输出\\
print("D\\\\:python\\\\chapter02\n")

# \" 输出"
print("杨过说：\"小龙女你嫁给我吧\"\n")

# \' 输出'
print("郭靖说：\'hello\'\n")  # Python单引号也可以不使用转义字符
print("郭靖说：'hello'\n")

# \r 回车
print("段誉向西行，\r他虽不会武功\n")

2.6 格式化输出

2.6.1 %操作符输出

符号	描述
%s	格式化字符串
%d	格式化整数，%06表示输出6位整数，不足的位数补0
%f	格式化浮点数字，可指定小数点后的精度
%%	输出%

语法：print(“格式化字符串”%(变量1，变量2，……))

2.6.2 format()函数输出

2.6.3 f-string输出

# 格式化输出

# 定义变量
name = '张三'
age = 18
score = 90.5
gender = '男'

# %操作符输出
print("个人信息：%s %d %.2f %s " % (name, age, score, gender))

# # format()输出
print("个人信息：{} {} {} {}".format(name, age, score, gender))
print("个人信息：{} {} {:.2f} {}".format(name, age, score, gender))

# f-string输出
print(f"个人信息：{name} {age} {score} {gender}")

2.7 加号的使用

# 加号的使用
name = '张三'
score = 39.3
print(score + 38)  # 77.3
print(name + "hi")  # 张三hi
print("288" + "27")  # 28827
print(2345.2 + 243)  # 2578.2

2.8 进制转换

# 进制转换
# 二进制binary,八进制octal,十进制decimal,十六进制hexadecimal

# 二进制转换
bin_number = '10101010'
dec_number = int(bin_number, 2)  # int()函数，将二进制转换为十进制
oct_number = oct(dec_number)  # oct()函数，将十进制转换为八进制
hex_number = hex(dec_number)  # hex()函数，将十进制转换为十六进制
print("二进制数为:", bin_number)  # 10101010
print("十进制数为:", dec_number)  # 170
print("八进制数为:", oct_number)  # 0o256
print("十六进制数为:", hex_number)  # 0xaa

print("------------------------")

# 八进制转换
oct_number = '52'
dec_number = int(oct_number, 8)  # int()函数，将八进制转换为十进制
bin_number = bin(dec_number)  # bin()函数，将十进制转换为二进制
hex_number = hex(dec_number)  # hex()函数，将十进制转换为十六进制
print("八进制数为：", oct_number)  # 52
print("十进制数为：", dec_number)  # 42
print("二进制数为：", bin_number)  # 0b101010
print("十六进制数为：", hex_number)  # 0x2a

print("------------------------")

# 十进制转换
dec_number = 100
bin_number = bin(dec_number)  # bin()函数，将十进制转换为二进制
oct_number = oct(dec_number)  # oct()函数，将十进制转换为八进制
hex_number = hex(dec_number)  # hex()函数，将十进制转换为十六进制
print("十进制数为：", dec_number)  # 100
print("二进制数为：", bin_number)  # 0b1100100
print("八进制数为：", oct_number)  # 0o144
print("十六进制数为：", hex_number)  # 0x64

print("------------------------")

# 十六进制转换
hex_number = '2a'
dec_number = int(hex_number, 16)  # int()函数，将十六进制转换为十进制
bin_number = bin(dec_number)  # bin()函数，将十进制转换为二进制
oct_number = oct(dec_number)  # oct()函数，将十进制转换为八进制
print("十六进制数为：", hex_number)  # 2a
print("十进制数为：", dec_number)  # 42
print("二进制数为：", bin_number)  # 0b101010
print("八进制数为：", oct_number)  # 0o52

2.9 import 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

# 导入 sys 模块
import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)

# 导入 sys 模块的 argv,path 成员
from sys import argv,path  #  导入特定的成员
 
print('================python from import===================================')
print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

第三章基本数据类型

3.1 变量

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号**（=）**用来给变量赋值。

等号**（=）**运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

# 变量的实列

# 定义了一个变量，变量的名称是a，变量的值是1，变量的类型是int类型
a = 4
# 定义了一个变量，变量的名称是b，变量的值是3.1，变量的类型是float类型
b = 2
b = 3.1
print("a的值是：", a, "类型是：", type(a))
print("b的值是：", b, "类型是：", type(b))
print("a+b的值是：", a + b, "类型是：", type(a + b))
print("a-b的值是：", a - b, "类型是：", type(a - b))
print("a*b的值是：", a * b, "类型是：", type(a * b))
print("a/b的值是：", a / b, "类型是：", type(a / b))

3.2 标准数据类型

Python 3 中常见的数据类型有：

Number（数字）
String（字符串）
bool（布尔类型）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

Python 3 的六个标准数据类型中：

**不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）
**可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）

此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

3.3 Number（数字）

在Python 3 里，只有一种整数类型 int，表示为长整型，没有 python 2 中的 Long。

3.3.1 整型 int

# 整型

# 范围: -2**63 ~ 2**63-1
the limit (4300 digits) for integer
n1 = 9 ** 8888
print(n1)

3.3.2 浮点型 float

# 浮点型

# 范围：-1.8E308 ~ 1.8E308
import sys

sys.float_info
print(sys.float_info)

# 浮点类型的一般形式
n1 = 5.12
n2 = .512
print("n1=", n1)  # n1= 5.12
print("n2=", n2)  # n2= 0.512

# 科学计数法
n3 = 5.12e2
n4 = 5.12e+2
n5 = 5.12E2
n6 = 5.12e-2
print("n3=", n3)  # n3= 512.0
print("n4=", n4)  # n4= 512.0
print("n5=", n5)  # n5= 512.0
print("n6=", n6)  # n6= 0.0512

# 浮点数精度
# 使用Decimal类进行精度计算
from decimal import Decimal

n7 = Decimal('8.1') / Decimal('2.7')
print("n7=", n7)  # n7= 3

注意：

Python 可以同时为多个变量赋值，如 a, b = 1, 2
一个变量可以通过赋值指向不同类型的对象
数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数
在混合计算时，Python 会把整型转换成为浮点数

3.3.3 数值运算

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方
32

3.3.4 数值类型实例

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3e+18	.876j
-0490	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2E-12	4.53e-7j

Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a,b) 表示，复数的实部 a 和虚部 b 都是浮点型。

3.3.5 查询变量所指的对象类型

# tpye
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

# isinstance
>>> a = 111
>>> isinstance(a, int)
True
>>>

拓展：isinstance 和 type 的区别在于：

type() 不会认为子类是一种父类类型
isinstance() 会认为子类是一种父类类型

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

3.4 String（字符串）

Python 中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

加号 + 是字符串的连接符，星号 ***** 表示复制当前字符串，与之结合的数字为复制的次数。

str = 'Runoob'  # 定义一个字符串变量

print(str)           # 打印整个字符串
print(str[0:-1])     # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])        # 打印字符串的第一个字符
print(str[2:5])      # 打印字符串第三到第五个字符（包含第五个字符）
print(str[2:])       # 打印字符串从第三个字符开始到末尾
print(str * 2)       # 打印字符串两次
print(str + "TEST")  # 打印字符串和"TEST"拼接在一起

Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个r，表示原始字符串。

print('Ru\noob')
print(r'Ru\noob')

另外，反斜杠 \ 可以作为续行符，表示下一行是上一行的延续。也可以使用 “”“…”“” 或者 ‘’‘…’‘’ 跨越多行。

注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = ‘m’ 会导致错误。

注意：

反斜杠 \ 可以用来转义，使用r可以让反斜杠不发生转义
字符串可以用**+运算符连接在一起，用***运算符重复
Python中的字符串有两种索引方式，从左往右以0开始，从右往左以**-1**开始
Python 中的字符串不能改变

拓展：字符串驻留机制

Python仅保存一份相同且不可变字符串，不同的值被存放在字符串的驻留池中，Python的驻留池机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。

Python的字符串驻留机制是一种优化技术，用于提高内存使用效率和性能。

# 字符串驻留机制
# Python的字符串驻留机制是一种优化技术，用于提高内存使用效率和性能。
# 它通过将相同的字符串对象存储在内存中一次，而不是每次创建字符串时都分配新的内存空间。

# 内置函数id(),用于获取对象的内存地址
str1="hello"
str2="hello"
str3="hello"
print(id(str1),id(str2),id(str3))

驻留机制几种情况讨论（交互模式下）：

字符串是由26个英文字母大小写，0-9，**__**组成
字符串长度为0或1时
字符串在编译时进行驻留，而非运行时
[5，256]的整数数字

注意：

PyCharm对字符串进行了优化处理
sys中的intern方法可以强制2个字符串指向同一个对象

str1 = "abc123#"
str2 = "abc123#"
str3 = -100
str4 = -100
print(id(str1))
print(id(str2))
print(id(str3))
print(id(str4))

3.5 bool（布尔类型）

布尔类型即 True 或 False。

在 Python 中，True 和 False 都是关键字，表示布尔值。

布尔类型可以用来控制程序的流程，比如判断某个条件是否成立，或者在某个条件满足时执行某段代码。

布尔类型特点：

布尔类型只有两个值：True 和 False
bool 是 int 的子类，因此布尔值可以被看作整数来使用，其中 True 等价于 1，Flase 等价于0
布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0
布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值
布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0
可以使用 bool() 函数将其他类型的值转换为布尔值。以下值在转换为布尔值时为 False：None、False、零 (0、0.0、0j)、空序列（如 ‘’、()、[]）和空映射（如 {}）。其他所有值转换为布尔值时均为 True

# 布尔类型的值和类型
a = True
b = False
print(type(a))  # <class 'bool'>
print(type(b))  # <class 'bool'>

print("------------------------")

# 布尔类型的整数表现
print(int(True))  # 1
print(int(False))  # 0

print("------------------------")

# 使用 bool() 函数进行转换
print(bool(0))  # False
print(bool(42))  # True
print(bool(''))  # False
print(bool('Python'))  # True
print(bool([]))  # False
print(bool([1, 2, 3]))  # True

print("------------------------")

# 布尔逻辑运算
print(True and False)  # False
print(True or False)  # True
print(not True)  # False

print("------------------------")

# 布尔比较运算
print(5 > 3)  # True
print(2 == 2)  # True
print(7 < 4)  # False

print("------------------------")

# 布尔值在控制流中的应用
if True:
    print("This will always print")

if not False:
    print("This will also always print")

x = 10
if x:
    print("x is non-zero and thus True in a boolean context")

注意: 在 Python 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True，只有 0、空字符串、空列表、空元组等被视为 False。因此，在进行布尔类型转换时，需要注意数据类型的真假性。

3.6 List（列表）

3.7 Tuple（元组）

3.8 Dictionary（字典）

3.9 Set（集合）

3.10 bytes 类型

3.11 数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，一般情况下你只需要将数据类型作为函数名即可。

Python 数据类型转换可以分为两种：

隐式类型转换 - 自动完成
显式类型转换 - 需要使用类型函数来转换

3.11.1 隐式类型转换

在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。

以下实例中，我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

num_int = 123
num_flo = 1.23

num_new = num_int + num_flo

print("num_int 数据类型为:",type(num_int))
print("num_flo 数据类型为:",type(num_flo))

print("num_new 值为:",num_new)
print("num_new 数据类型为:",type(num_new))

3.11.2 显式类型转换

# 数据类型转换

# 显式类型转换int()、float()、str()
i = 10
j = float(i)
print(j, type(j))  # 10.0 <class 'float'>
k = str(i)
print(k, type(k))  # 10 <class 'str'>

print("------------------------")

# 显式类型转换注意事项
n1 = 100
n2 = 123.123
print(float(n1))  # 100.0
print(int(n2))  # 123
print(int(n1 + n2))  # 223
print(float(int(n1 + n2)))  # 223.0

n3 = "12.3"
n4 = "123"
print(float(n3))  # 12.3
print(int(float(n3)))  # 12
print(int(n4))  # 123
print(float(n4))  # 123.0

n5 = "abc"
print(int(n5))  # ValueError
print(float(n5))  # ValueError

函数	描述
int()	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex()	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

第四章运算符

4.1 算术运算符

运算符	描述
+	加 + ：两个对象相加
-	减 - ：得到负数或是一个数减去另一个数
*	乘 * : 两个数相乘或是返回一个被重复若干次的字符串
/	除 / : x 除以 y
//	整除 // : 向下取整
%	取余 % : 返回除法的余数，对应的运算公式为：a % b = a - a // b * b
**	幂 :返回x的y次幂，对应的运算公式为：a b = a^b

# 算数运算符
# +,-,*,/,//,%,**

# /:除法，返回浮点数
print(10 / 3)  # 3.3333333333333335
print(-10 / 3)  # -3.3333333333333335
print(10 / -3)  # -3.3333333333333335

print("------------------------")

# //:整除，返回整数（向下取整）
print(10 // 3)  # 3
print(-10 // 3)  # -4
print(10 // -3)  # -4
print(-10 // -3)  # 3

print("------------------------")

# %:取余，对应的运算公式为：a % b = a - a // b * b
print(10 % 3)  # 1
print(-10 % 3)  # 2
print(10 % -3)  # -2
print(-10 % -3)  # -1

print("------------------------")

# **:指数运算，对应的运算公式为：a ** b = a^b
print(2 ** 3)  # 8

4.2 比较运算符

比较运算符的结果要么是 True，要么是 Flase

运算符	描述
==	等于：比较对象是否相等
!=	不等于：比较两个对象是否不相等
>	大于：返回x是否大于y
<	小于：返回x是否小于y
>=	大于等于：返回x是否大于等于y
<=	小于等于：返回x是否小于等于y
is	判断两个变量引用对象是否为同一个
is not	判断两个变量引用对象是否不同

# 比较运算符
# ==, !=, >, <, >=, <=, is, is not

a = 21
b = 10
print(a == b)  # False
print(a != b)  # True
print(a > b)  # True
print(a < b)  # False
print(a >= b)  # True
print(a <= b)  # False
print(a is b)  # False
print(a is not b)  # True

print("------------------------")

# PyCharm对字符串驻留的优化
c = "abc#"
d = "abc#"
print(c == d)  # True
print(c != d)  # False
print(c is d)  # True
print(c is not d)  # False

注意：

在交互模式下，发生驻留会导致值相同但数据空间不同

4.3 赋值运算符

运算符	描述	实例
=	简单的赋值运算符	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
:=	同时进行赋值和返回赋值的值

# 赋值运算符
# =,+=,-=,*=,/=,//=,%=,**=

a, b, c, d, e, f, g, h, i, j = 12, 23, 34, 45, 56, 67, 78, 89, 90, 2

# =
c = a + b
print(c)  # 35

# +=
d += a
print(d)  # 57

# -=
e -= a
print(e)  # 44

# *=
f *= a
print(f)  # 804

# /=
g /= a
print(g)  # 6.5

# //=
h //= a
print(h)  # 7

# %=
i %= a
print(i)  # 6

# **=
j **= a
print(j)  # 4096

拓展：海象运算符

在 Python 3.8 及更高版本中，引入了一种新的语法特性，称为"海象运算符"（Walrus Operator）
它使用 := 符号。这个运算符的主要目的是在表达式中同时进行赋值和返回赋值的值
使用海象运算符可以在一些情况下简化代码，尤其是在需要在表达式中使用赋值结果的情况下。这对于简化循环条件或表达式中的重复计算很有用
海象运算符的主要用途是在需要同时进行赋值和条件判断的情况下，简化代码。例如，在循环中，你可能需要检查某个条件，并在满足条件时更新一个变量，同时打印这个变量的值。使用海象运算符可以避免额外的变量赋值步骤
海象运算符只能在表达式内部使用，不能在函数定义、类定义、循环或条件语句之外使用
海象运算符的引入是为了提高代码的简洁性和可读性，但过度使用可能会导致代码难以理解。因此，建议在确实需要简化代码的情况下使用

# 海象运算符 := 可以在表达式内部为变量赋值
# 适用于需要先计算表达式结果，再赋值给变量的场景

# 传统写法
n = 10
if n > 5:
    print(n)    # 10

# 使用海象运算符
if (n := 10) > 5:
    print(n)       # 10

if (n := 19) > 388:
    print(n)       # 19
else:
    print("n<388")   # n<388

4.4 逻辑运算符

运算符	逻辑表达式	描述
and	x and y	布尔"与" ：如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值
or	x or y	布尔"或" ：如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值
not	not x	布尔"非" ：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True

# 逻辑运算符
# and, or, not

# and: 两个条件都为真，结果才为真
# or: 两个条件中有一个为真，结果就为真
# not: 取反，如果条件为真，结果为假，如果条件为假，结果为真
# 逻辑运算符可以用于比较运算符的结果，也可以用于布尔值
# 逻辑运算符的优先级：not > and > or
# 逻辑运算符的短路：如果逻辑运算符的第一个条件已经可以确定结果，那么后面的条件就不会再执行

a, b = 10, 20
print(a and b)  # 20
print(a or b)  # 10
print(not (a and b))  # False

print("------------------------")

# and
score = 70
if score >= 60 and score <= 80:
    print("及格")

c, d = 1, 99
print(c and d)  # 99
print((c > d) and d)  # False
print(d and (c > d))  # False
print((c < d) and d)  # 99
print(d and (c < d))  # True
print((c < d) and (d > c))  # True

print("------------------------")

# or
score = 70
if score >= 60 or score <= 80:
    print("及格")

e, f = 1, 99
print(e or f)  # 1
print((e > f) or f)  # 99
print(f or (e > f))  # 99
print((e < f) or f)  # True
print(f or (e < f))  # 99
print((e < f) or (f > e))  # True

print("------------------------")

# not
g = 9
h = not (g > 9)
print(not g)  # False
print(not h)  # False
print(not True)  # False
print(not False)  # True
print(not 0)    # True
print(not 1)    # False
print(not 18.74)    # False
print(not "")    # True
print(not "jack")    # False

4.5 成员运算符

4.6 身份运算符

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

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

# 身份运算符
a,b=20,20

if (a is b):
    print("1 - a 和 b 有相同的标识")
else:
    print("1 - a 和 b 没有相同的标识")

if (id(a) == id(b)):
    print("2 - a 和 b 有相同的标识")
else:
    print("2 - a 和 b 没有相同的标识")

print("------------------------")

# 修改变量 b 的值
b = 30
if (a is b):
    print("3 - a 和 b 有相同的标识")
else:
    print("3 - a 和 b 没有相同的标识")

if (a is not b):
    print("4 - a 和 b 没有相同的标识")
else:
    print("4 - a 和 b 有相同的标识")

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等

>>>a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

4.7 位运算符

在Python中，负数是以补码形式存储的。

运算符	描述
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
\|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1
^	按位异或运算符：当两对应的二进位相异时，结果为1
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，符号位不变，高位丢弃，低位补0。左移多少位就是乘以2的多少次方
>>	右移动运算符：把">>“左边的运算数的各二进制全部右移若干位，由”>>"右边的数指定移动的位数，低位丢弃，符号位不变，并用符号位补溢出的高位。右移多少位就是整除2的多少次方

# 位运算
# 按位取反~，按位与&，按位或|，按位异或^，左移<<,右移>>

# 按位取反~:将数字的每一位都取反
a = 60  # 60的原码是0011 1100，反码是0011 0011，补码是0011 1100
b = -60  # -60的原码是1011 1100，反码是1100 0011，补码是1100 0100
c = 13  # 13的原码是0000 1101，反码是0000 1101，补码是0000 1101
print(~a)  # -61    60的补码是0011 1100，取反后（补码）是1100 0011，取反后的反码是1100 0010，取反后的原码是1011 1101，即-61
print(~b)  # 59     -60的补码是1100 0100，取反后（补码）是0011 1011，取反后的反码是0011 1011，取反后的原码是0011 1011，即59
print(~c)  # -14    13的补码是0000 1101，取反后（补码）是1111 0010，取反后的反码是1111 0001，取反后的原码是1000 1110，即-14

print("------------------------")

# 按位与&:将两个数字的每一位都进行与运算。参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0。
d = a & b  # 60的补码是0011 1100，-60的补码是1100 0100，与运算后（补码）是0000 0100，与运算后的反码是0000 0100，与运算后的原码是0000 0100，即4
e = a & c  # 60的补码是0011 1100，13的补码是0000 1101，与运算后（补码）是0000 1100，与运算后的反码是0000 1100，与运算后的原码是0000 1100，即12
print(d)  # 4
print(e)  # 12

print("------------------------")

# 按位或|:将两个数字的每一位都进行或运算。只要对应的二个二进位有一个为1时，结果位就为1。
f = a | b  # 60的补码是0011 1100，-60的补码是1100 0100，或运算后（补码）是1111 1100，或运算后的反码是1111 1011，或运算后的原码是1000 0100，即-4
g = a | c  # 60的补码是0011 1100，13的补码是0000 1101，或运算后（补码）是0011 1101，或运算后的反码是0011 1101，或运算后的原码是0011 1101，即61
print(f)  # -4
print(g)  # 61

print("------------------------")

# 按位异或^:将两个数字的每一位都进行异或运算。当两对应的二进位相异时，结果为1。
h = a ^ b  # 60的补码是0011 1100，-60的补码是1100 0100，异或运算后（补码）是1111 1000，异或运算后的反码是1111 0111，异或运算后的原码是1000 1000，即-8
i = a ^ c  # 60的补码是0011 1100，13的补码是0000 1101，异或运算后（补码）是0011 0001，异或运算后的反码是0011 0001，异或运算后的原码是0011 0001，即49
print(h)  # -8
print(i)  # 49

print("------------------------")

# 左移<<:运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，符号位不变，高位丢弃，低位补0。左移多少位就是乘以2的多少次方。
j = a << 2  # 60*2^2=240
k = b << 2  # -60*2^2=-240
l = c << 2  # 13*2^2=52
print(j)  # 240
print(k)  # -240
print(l)  # 52

print("------------------------")

# 右移>>:把">>"左边的运算数的各二进制全部右移若干位，由">>"右边的数指定移动的位数，低位丢弃，符号位不变，并用符号位补溢出的高位。右移多少位就是整除2的多少次方。
m = a >> 2  # 60//2^2=15
n = b >> 2  # -60//2^2=-15
o = c >> 2  # 13//2^2=3
print(m)  # 15
print(n)  # -15
print(o)  # 3

4.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	逻辑非 NOT
and	逻辑与 AND
or	逻辑或 OR
if – else	条件表达式
lambda	lambda 表达式
:=	赋值表达式

注意：

Python3 已不支持 <> 运算符，可以使用 != 代替，如果你一定要使用这种比较运算符，可以使用以下的方式：

>>> from __future__ import barry_as_FLUFL
>>> 1 <> 2
True

第五章 Number（数字）

第六章 String（字符串）

第七章 bool（布尔类型）

第八章 List（列表）

第九章 Tuple（元组）

第十章 Dictionary（字典）

第十一章 Set（集合）

第十二章条件控制

12.1 if 语句

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意：

1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块
3、在 Python 中没有 switch…case 语句，但在 Python3.10 版本添加了 match…case，功能也类似，详见下文

以下为if中常用的操作运算符:

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于，比较两个值是否相等
!=	不等于

# 判断一个年份是否为闰年
year = int(input("请输入一个年份："))
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
    print(f"{year}年是闰年")
else:
    print(f"{year}年不是闰年")

score1 = float(input("请输入第一个成绩："))
score2 = float(input("请输入第二个成绩："))
score3 = float(input("请输入第三个成绩："))
if score1 >= 90 and score2 >= 90 and score3 >= 90:
    print("A")
elif score1 >= 90 or score2 >= 60 or score3 >= 60:
    print("B")
else:
    print("C")

12.2 if 嵌套

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

age = int(input("请输入年龄："))
month = int(input("请输入月份："))
if 4 <= month <= 10:
    if age < 18:
        print("儿童票30")
    elif 18 <= age <= 60:
        print("成人票60")
    else:
        print("老年票20")
else:
    if 18 <= age <= 60:
        print("成人票40")
    else:
        print("儿童老人票20")