运算符
算数运算符
运算符 | 描述 |
+ | 加 |
- | 减 |
* | 乘 |
/ | 除 |
// | 取整除 |
% | 取余数 |
** | 幂 |
比较运算符
运算符 | 描述 |
== | 检查两个操作数的值是否 相等，如果是，则条件成立，返回 True |
!= | 检查两个操作数的值是否 不相等，如果是，则条件成立，返回 True |
> | 检查左操作数的值是否 大于 右操作数的值，如果是，则条件成立，返回 True |
< | 检查左操作数的值是否 小于 右操作数的值，如果是，则条件成立，返回 True |
>= | 检查左操作数的值是否 大于或等于 右操作数的值，如果是，则条件成立，返回 True |
<= | 检查左操作数的值是否 小于或等于 右操作数的值，如果是，则条件成立，返回 True |
逻辑运算符
运算符 | 逻辑表达式 | 描述 |
and | x and y | 只有 x 和 y 的值都为 True，才会返回 True 否则只要 x 或者 y 有一个值为 False，就返回 False |
or | x or y | 只要 x 或者 y 有一个值为 True，就返回 True 只有 x 和 y 的值都为 False，才会返回 False |
not | not x | 如果 x 为 True，返回 False 如果 x 为 False，返回 True |
赋值运算符
- 在 Python 中，使用
=可以给变量赋值 - 在算术运算时，为了简化代码的编写，
Python还提供了一系列的 与 算术运算符 对应的 赋值运算符 - 注意：赋值运算符中间不能使用空格
运算符 | 描述 | 实例 |
= | 简单的赋值运算符 | 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 |
运算符的优先级
以下表格列出了从最高到最低优先级的所有运算符：
运算符 | 描述 |
** | 指数 (最高优先级) |
~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
* / % // | 乘，除，取模和取整除 |
+ - | 加法减法 |
>> << | 右移，左移运算符 |
& | 位 'AND' |
^ | | 位运算符 |
<= < > >= | 比较运算符 |
<> == != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
is is not | 身份运算符 |
in not in | 成员运算符 |
not and or | 逻辑运算符 |
变量
定义：
变量名 = 值
- 在内存中创建一个变量，会包括：
- 变量的名称
- 变量保存的数据
- 变量存储数据的类型
- 变量的地址（标示）
注：
- 变量名 只有在 第一次出现 才是 定义变量
- 变量名 再次出现，不是定义变量，而是直接使用之前定义过的变量
- 在定义变量时，为了保证代码格式，
=的左右应该各保留一个空格
# 1. 定义苹果的单价
price = 8.5
# 2. 挑选苹果
weight = 7.5
# 3. 计算付款金额
money = weight * price
# 4. 只要买苹果，就返回 5 块钱
money = money - 5
print(money)变量的命名
标识符
标示符就是程序员定义的 变量名、函数名
- 名字 需要有 见名知义 的效果
- 标示符可以由 字母、下划线 和 数字 组成
- 不能以数字开头
- 不能与关键字重名
Python中的 标识符 是 区分大小写的
拓展：
驼峰命名法
- 当 变量名 是由二个或多个单词组成时，可以利用驼峰命名法来命名
- 小驼峰式命名法
- 第一个单词以小写字母开始，后续单词的首字母大写
- 例如：
firstName、lastName
- 大驼峰式命名法
- 每一个单词的首字母都采用大写字母
- 例如：
FirstName、LastName、CamelCase在
Python中，如果 变量名 需要由 二个 或 多个单词 组成时，可以按照以下方式命名
- 每个单词都使用小写字母
- 单词与单词之间使用
_下划线 连接- 例如：
first_name、last_name、qq_number、qq_password
关键字
关键字 就是在 Python 内部已经使用的标识符
- 关键字 具有特殊的功能和含义
- 开发者 不允许定义和关键字相同的名字的标示符
通过以下命令可以查看 Python 中的关键字
In [1]: import keyword
In [2]: print(keyword.kwlist)变量的数据类型
python中变量是不需要指定类型的，Python 可以根据等号右侧的值，自动推导出变量中存储数据的类型
数字的三种类型
int 整形 3
float 浮点型 3.14
complex 复数类型 3+2j（可以没有前面实部，但是必须有复数的虚部）
布尔类型
bool 布尔类型 首字母大写，注意不能用引号引起来，通常用于条件判断
- True 非0数字
- False 数字0
True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False字符串
str 字符串 'tom' "tom" '''tom''' """tom"""
bytes 字节序列 b'hello'
在 Python 中，字符串之间可以使用 +
In [1]: first_name = "三"
In [2]: last_name = "张"
In [3]: first_name + last_name
Out[3]: '三张'字符串变量 可以和 整数 使用 * 重复拼接相同的字符串
In [1]: "-" * 50
Out[1]: '--------------------------------------------------'高级类型
详细参考另外一篇博客
Python之高级变量类型_one ²⁰¹⁹的博客
list 列表 [1,2.0,False，'tom'] tuple 元组 (1,2.0,False，'tom') dict 字典 {'name':'tom','age':'29'},元组由键（key）和值（value）构成的键值对 set 集合 {11,22,33，11} 无序，创建空集合 set（）
None
None 代表具体类型待定， 或者说不确定具体类型
拓展：
序列（sequence）：str、bytes、list、tuple 整形、浮点型、布尔类型没有长度 print(len({})) print(len(9))
变量常用函数
查看变量类型
内置的 type(变量名) 函数可以用来查询变量所指的对象类型。
>>> 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注：Python3 中，bool 是 int 的子类
>>> issubclass(bool, int)
True变量的输入函数
- 所谓输入，就是用代码获取用户通过键盘输入的信息（例如去银行取钱，在ATM上输入密码）
- input函数读取用户在键盘上的输入信息，返回的是一个字符串类型的值
字符串变量 = input("提示信息：")变量的输出函数
# 可以打印一个值，也可以打印多个值， # 重要的参数： # sep：设置多个之间是用什么值连接，默认是空格字符' ' # end：设置最后一个值后面追加什么值，默认换行字符'/n' # 这两个参数谁在前面谁在后面都可以，但是这两个值需要放在其他要打印的值得后面 print("name", ":",end='', sep='----')
变量类型转换函数
int() float() bool() str() list() tuple() dict() set()
# 1. 提示用户输入苹果的单价
price = float(input("苹果的单价："))
# 2. 提示用户输入苹果的重量
weight = float(input("苹果的重量："))
# 3. 计算金额
money = price * weight
print(money)变量的格式化输出
1、百分号 (%)
格式化字符串就是把一个或者多个值以某种格式插入到字符串中进行格式化，通过print拼接成一个字符串显示出来 python格式化字符串： %s 字符串格式 %d 整数格式 %f 浮点数格式 浮点数的值默认保留小数点后六位 %% 输出% 注：%d和%f要求值必须得是数字形式
name = 'tom'
age = '29'
# 一个值得时候
s = '我叫%s，我今年5岁了' % name
print(s)
# 有两个值需要进行格式化的时候，需要把变量放在一个元组里面
s = '我叫%s，我今年%d岁了' % (name, age)
print(s)
# 数字5 最小打印宽度是5
# - 左对齐打印，空格补在右边
# 0 表示宽度不足的时候补0而不是空格，智能用在数字里面
# .1 表示小数点后保留1位小数，只能用于有小数位的情况
s = '我叫%-5s，我今年%05.1f岁了' % (name, age)
print(s)拓展：
# 如何把字典里的值插入到字符串中
# 直接把字典的名字放在百分号后面，把键放在括号里面，键必须字符串，而且键不能加引号
a = {'name': 'tome', 'age': 19}
s = '我叫%(name)s,我今年%(age)05d岁了' % a2、str.format()
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能
3、f-string
f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。之前我们习惯用百分号 (%):
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：
>>> name = 'Runoob'
>>> f'Hello {name}' # 替换变量
'Hello Runoob'
>>> f'{1+2}' # 使用表达式
'3'
>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：
>>> x = 1
>>> print(f'{x+1}') # Python 3.6
2
>>> x = 1
>>> print(f'{x+1=}') # Python 3.8
x+1=2转义字符
转义字符 | 描述 |
\\ | 反斜杠符号 |
\' | 单引号 |
\" | 双引号 |
\n | 换行 |
\t | 横向制表符（tab） |
如果需要字符串输出”\n”或者”\t”， 在字符串前面加 r，就代表转义字符不转义，原样输出
print("hello\tworld\nhello\\world")
print(r"hello\tworld\nhello\\world")Python数据类型转换
函数 | 描述 |
将x转换为一个整数 | |
将x转换到一个浮点数 | |
创建一个复数 | |
将对象 x 转换为字符串 | |
将对象 x 转换为表达式字符串 | |
用来计算在字符串中的有效Python表达式,并返回一个对象 | |
将序列 s 转换为一个元组 | |
将序列 s 转换为一个列表 | |
转换为可变集合 | |
创建一个字典。d 必须是一个 (key, value)元组序列。 | |
转换为不可变集合 | |
将一个整数转换为一个字符 | |
将一个字符转换为它的整数值 | |
将一个整数转换为一个十六进制字符串 | |
将一个整数转换为一个八进制字符串 |
多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "john"
以上实例，两个整型对象 1 和 2 分别分配给变量 a 和 b，字符串对象 "john" 分配给变量 c
变量的引用
1、变量 和 数据 都是保存在 内存 中的
2、在 Python 中 函数的参数传递以及返回值都是靠引用传递的
引用的概念
在 Python 中变量 和 数据 是分开存储的；数据 保存在内存中的一个位置；变量 中保存着数据在内存中的地址；变量 中 记录数据的地址，就叫做 引用
- 使用
id()函数可以查看变量中保存数据所在的 内存地址- 注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是 修改了数据的引用；变量 不再 对之前的数据引用；变量 改为 对新赋值的数据引用
1、变量引用的示例
在 Python 中，变量的名字类似于 便签纸 贴在 数据 上
- 定义一个整数变量
a，并且赋值为1
代码 | 图示 |
a = 1 |
|
- 将变量
a赋值为2
代码 | 图示 |
a = 2 |
|
- 定义一个整数变量
b，并且将变量a的值赋值给b
代码 | 图示 |
b = a |
|
变量 b 是第 2 个贴在数字 2 上的标签
2、函数的参数和返回值的传递
在 Python 中，函数的 实参/返回值 都是是靠 引用 来传递来的
def test(num):
print("在函数内部 %d 对应的内存地址是 %d" % (num, id(num)))
# 1> 定义一个字符串变量
result = "hello"
print("函数要返回数据的内存地址是 %d" % id(result))
# 2> 将字符串变量返回，返回的是数据的引用，而不是数据本身
return result
# 1. 定义一个数字的变量
a = 10
# 数据的地址本质上就是一个数字
print("a 变量保存数据的内存地址是 %d" % id(a))
# 2. 调用 test 函数，本质上传递的是实参保存数据的引用，而不是实参保存的数据！
# 注意：如果函数有返回值，但是没有定义变量接收
# 程序不会报错，但是无法获得返回结果
r = test(a)
print("%s 的内存地址是 %d" % (r, id(r)))可变和不可变类型
不可变类型，内存中的数据不允许被修改：
- 数字类型
int,bool,float,complex,long(2.x)- 字符串
str- 元组
tuple可变类型，内存中的数据可以被修改：
- 列表
list- 字典
dict
注意
- 可变类型的数据变化，是通过 方法 来实现的
- 如果给一个可变类型的变量，赋值了一个新的数据，引用会修改
- 变量 不再 对之前的数据引用
- 变量 改为 对新赋值的数据引用
a = 1
a = "hello"
a = [1, 2, 3]
a = [3, 2, 1]demo_list = [1, 2, 3]
print("定义列表后的内存地址 %d" % id(demo_list))
demo_list.append(999)
demo_list.pop(0)
demo_list.remove(2)
demo_list[0] = 10
print("修改数据后的内存地址 %d" % id(demo_list))
demo_dict = {"name": "小明"}
print("定义字典后的内存地址 %d" % id(demo_dict))
demo_dict["age"] = 18
demo_dict.pop("name")
demo_dict["name"] = "老王"
print("修改数据后的内存地址 %d" % id(demo_dict))拓展：哈希 (hash)
Python中内置有一个名字叫做hash(o)的函数；
- 接收一个 不可变类型 的数据作为 参数
- 返回 结果是一个 整数
哈希是一种 算法，其作用就是提取数据的 特征码（指纹）
- 相同的内容 得到 相同的结果
- 不同的内容 得到 不同的结果
- 在
Python中，设置字典的 键值对 时，会首先对key进行hash已决定如何在内存中保存字典的数据，以方便 后续 对字典的操作：增、删、改、查
- 键值对的
key必须是不可变类型数据- 键值对的
value可以是任意类型的数据
局部变量和全局变量
局部变量
局部变量是在函数内部 定义的变量，只能在函数内部使用；不同的函数，可以定义相同的名字的局部变量，但是彼此之间不会产生影响
def demo1():
num = 10
print(num)
num = 20
print("修改后 %d" % num)
def demo2():
num = 100
print(num)
demo1()
demo2()
print("over")局部变量的生命周期：
- 所谓生命周期就是变量从被创建到被系统回收的过程；
- 局部变量 在 函数执行时 才会被创建；
- 函数执行结束后 局部变量 被系统回
局部变量的作用：
- 在函数内部使用，临时保存函数内部需要使用的数据
全局变量
全局变量是在函数外部定义 的变量，所有函数内部都可以使用这个变量
注：
函数执行时，需要处理变量时会：
- 首先 查找 函数内部 是否存在 指定名称 的局部变量，如果有，直接使用
- 如果没有，查找 函数外部 是否存在 指定名称 的全局变量，如果有，直接使用
- 如果还没有，程序报错！
不允许直接修改全局变量的引用：
- 使用赋值语句修改全局变量的值，只是定义了一个局部变量，不会修改到全局变量，只是变量名相同而已
- 如果在函数中需要修改全局变量，需要使用
global进行声明全局变量定义的位置：
- 为了保证所有的函数都能够正确使用到全局变量，应该 将全局变量定义在其他函数的上方
# 全局变量
num = 10
def demo1():
# 希望修改全局变量的值 - 使用 global 声明一下变量即可
# global 关键字会告诉解释器后面的变量是一个全局变量
# 再使用赋值语句时，就不会创建局部变量
global num
num = 99
print("demo1 ==> %d" % num)
def demo2():
print("demo2 ==> %d" % num)
demo1()
demo2()
