1.1【基础】常量与变量
变量：用来存储和访问数据的容器，可以使用变量名称来引用存储在变量中的值。
常量：在程序执行过程中，值不会改变的量。例如数学常量π和e
小结：Python中变量与常量的共同点是都可以用来存储数据，即创建时都会在内存中开辟一块空间，用于保存它的值；而在程序中都可以使用变量名或者常量名来访问所存储的数据。
1.1.1- 变量不需要声明类型
Python有一种称为“动态类型”的特性，可以根据存储在变量中的值自动确定其类型，因此不需要在声明变量时预先指定其类型
PS:在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
实例
name = '航哥' # 字符串
age = 21 # 整型变量
weight = 141.5 # 浮点型变量
print(name)
print(age)
print(weight)
运行结果
航哥
21
141.5
1.1.2-变量的赋值
在编程语言中，将数据放入变量的过程叫做赋值（Assignment）。Python 使用等号=作为赋值运算符，具体格式为：
name = value
name 表示变量名；value 表示值，也就是要存储的数据。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。
注意，变量是标识符的一种，它的名字不能随便起，要遵守 python标识符命名规范，还要避免和python内置函数以及python保留字重名。
实例
name = 'Python'
print(name)
运行结果
Python
代码解析
上面实例中的代码就是将字符串python赋值给变量neme
从此以后，name就代表字符串Python，使用name就是使用Python
1.1.3-赋值的方式
第一种：单个直接赋值
age = 21 # 将整数21赋值给变量age
print(age) # 打印变量age
weight = 124.5 # 将小数124.5赋值给变量weight
print(weight) # 打印变量weight
name = '航哥' # 将字符串航哥赋值给变量name
print(name) # 打印变量name
运行结果
21
124.5
航哥
第二种：多个批量赋值
a = b = c = 1 # 为a、b、c变量赋值为1，该语句等价于 a = 1; b = 1; c = 1
print(a)
print(b)
print(c)
运行结果
1
1
1
第三种：先计算再赋值
sum = 120 + 40 # 将加法的结果赋值给变量
rem = 34 * 43 % 6 # 将余数赋值给变量
www = '百度' + 'https://www.baidu.com/' # 将字符串拼接的结果赋值给变量
print(www)
print(sum)
print(rem)
运行结果
百度https://www.baidu.com/
160
4
第四种：分别赋值
a, v, b, n = 5, 8, 7, 6 # 将赋值操作右边的各个值，分别赋给左边的每个变量
print(a)
print(v)
print(b)
print(n)
运行结果
5
8
7
6
1.1.4-深度理解赋值
在了解赋值时，理解变量在计算机内存中的表示也非常重要。
为了下面的知识点易于理解；将上面**‘变量’**这个知识点进行深度理解：
变量的定义
- 变量由三部分组成
- 标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取
- 类型：表示的是对象的数据类型，使用内置函数Type(obj)来获取
- 值：表示对象所存储的具体数据，使用print(obj)可以将值打印输出
实例
name = '航哥'
tname = name
print(name)
print('标识', id(name))
print('标识', id(tname))
print('类型', type(name))
print('值', name)
name = '无名氏'
print(name)
print('标识', id(name))
print('标识', id(tname))
运行结果
航哥
标识 1815525466736
标识 1815525466736
类型 <class 'str'>
值 航哥
无名氏
标识 2291859990064
标识 1815525466736
看图知义
小结：当我们写：name = "航哥" 时，Python解释器干了两件事情：
- 在内存中创建了一个
'航哥'的字符串对象； - 在内存中创建了一个名为
name的变量，并把它指向'航哥'。
而当你把一个变量name赋值给另一个变量tname，这个操作实际上是将变量b指向变量a所指向的数据；
通过id() 可以查看变量值的内存地址，打印出来的 name 和 tname的内存地址是一样的，因此二者其实是一个数据。
但如果继续对 a 进行赋值其他值， 会发现 name 的内存地址变了，而 tname 的并没有变
请牢记：Python中的一切都是对象，变量是对象的引用！：
- 执行name = ‘航哥’，解释器创建字符串‘航哥’对象和变量name，并把name指向‘航哥’对象；
- 执行tame = name,解释器创建变量tame，并且将其指向变量name指向的字符串‘航哥’对象；
- 执行name = ‘无名氏’,解释器创建字符串‘无名氏’对象，并把name改为指向‘无名氏’对象，与tame无关。
1.1.5-简易说明常量
说完变量，还要说下常量。
常量就是不变的变量，比如常用的数学常数圆周率就是一个常量。在Python中，通常用全部大写的变量名表示常量：
实例
PI = 3.14159265359
print(PI)
运行结果
3.14159265359
但事实上，从Python语法角度看，PI仍然是一个变量，因为Python根本没有任何机制保证PI不会被改变。你完全可以给PI赋值为10，不会弹出任何错误。所以，用全部大写的变量名表示常量只是一个习惯上的用法。
常量通常放置在代码的最上部，并作为全局使用。
2.2【基础】字符串类型
2.2.1-如何定义字符串？
字符串是Python中最常用的数据类型之一。
若干个字符的集合就是一个字符串（String）。
字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字。
使用单引号或双引号来创建字符串，使用三引号创建多行字符串。字符串要么使用两个单引号，要么两个双引号，不能一单一双！Python不支持单字符类型，单字符在Python中也是作为一个字符串使用。
PS:单字符类型是指只有一个字符的类型，例如C语言中的’a’，Java中的‘b’等。Python不支持这个单字符类型，即使在赋值时，也必须用引号将单字符括起来，使其成为字符串，如"a"，“b”。
以下创建字符串的四种写法是等价的
>>> name_1 = '航哥' # 单引号
>>> name_2 = "航哥" # 双引号
>>> name_3 = '''航哥''' # 三个单引号
>>> name_4 = """航哥""" # 三个双引号
>>> name_1 == name_2 == name_3 == name_4
True
2.2.2-处理字符串中的引号
当字符串内容中出现引号时，我们需要进行特殊处理，否则 Python 会解析出错，例如：
'I'm a great coder!'
由于上面字符串中包含了单引号，此时 Python 会将字符串中的单引号与第一个单引号配对，这样就会把'I'当成字符串，而后面的m a great coder!'就变成了多余的内容，从而导致语法错误。
对于这种情况，我们有两种处理方案：
1) 对引号进行转义
在引号前面添加反斜杠\就可以对引号进行转义，让 Python 把它作为普通文本对待，例如：
str1 = 'I\'m a great coder!'
str2 = "引文双引号是\"，中文双引号是“"
print(str1)
print(str2)
运行结果
I'm a great coder!
引文双引号是"，中文双引号是“
2) 使用不同的引号包围字符串
如果字符串内容中出现了单引号，那么我们可以使用双引号包围字符串，反之亦然。例如：
str1 = "I'm a great coder!" # 使用双引号包围含有单引号的字符串
str2 = '引文双引号是"，中文双引号是“' # 使用单引号包围含有双引号的字符串
print(str1)
print(str2)
运行结果和上面相同。
2.2.3-字符串的换行
Python 不是格式自由的语言，它对程序的换行、缩进都有严格的语法要求。要想换行书写一个比较长的字符串，必须在行尾添加反斜杠\，请看下面的例子：
s2 = '我花了一段时间来编写这个 Python 自学指南. \
请给我更多的支持。 \
我会保持更新.
上面 s2 字符串的比较长，所以使用了转义字符\对字符串内容进行了换行，这样就可以把一个长字符串写成多行。
另外，Python 也支持表达式的换行，例如：
num = 30 + 3 / 4 + \
4 * 5
print(num)
2.2.4-Python长字符串
长字符串，就是可以直接换行（不用加反斜杠\）书写的字符串。
Python 长字符串由三个双引号"""或者三个单引号'''包围
在长字符串中放置单引号或者双引号不会导致解析错误。
如果长字符串没有赋值给任何变量，那么这个长字符串就不会起到任何作用，和一段普通的文本无异，相当于被注释掉了。
注意，此时 Python 解释器并不会忽略长字符串，也会按照语法解析，只是长字符串起不到实际作用而已。
当程序中有大段文本内容需要定义成字符串时，优先推荐使用长字符串形式，因为这种形式非常强大，可以在字符串中放置任何内容，包括单引号和双引号。
【实例】将长字符串赋值给变量：
longstr = '''我花了一段时间来编写这个python自学指南.
如果你喜欢这份教学指南请"关注",'点赞',收藏.
你的鼓励将是我创造的最大动力.'''
print(longstr)
运行结果
我花了一段时间来编写这个python自学指南.
如果你喜欢这份教学指南请"关注",'点赞',收藏.
你的鼓励将是我创造的最大动力.
长字符串中的换行、空格、缩进等空白符都会原样输出，所以你不能写成下面的样子：
longstr = '''
我花了一段时间来编写这个python自学指南.
如果你喜欢这份教学指南请"关注",'点赞',收藏.
你的鼓励将是我创造的最大动力.
'''
print(longstr)
虽然这样写格式优美，但是输出结果将变成：
我花了一段时间来编写这个python自学指南.
如果你喜欢这份教学指南请"关注",'点赞',收藏.
你的鼓励将是我创造的最大动力.
字符串内容前后多出了两个空行，并且每一行的前面会多出空格。
2.2.5-字符串对象的方法
字符串对象本身自带了许多非常实用的方法，文章只会为你介绍最常用的那些方法，而剩下的你只要在需要的时候去过一下Python官方文档就 OK了。
去除首尾空格
msg = " Python自学指南 "
qwe = msg.lstrip() # 去除左边空格
asd = msg.rstrip() # 去除右边空格
zxc = msg.strip() # 去除左右两边空格
print(qwe)
print(asd)
print(zxc)
运行结果
Python自学指南
Python自学指南
Python自学指南
判断字符串是否以某字符串开头
msg = "Hello, Python"
msg.startswith("Hello")
msg.startswith("hello")
运行结果
True
False
判断字符串是否以某字符串结尾
msg = "Hello, Python"
asd = msg.endswith("Python")
ads = msg.endswith("python")
print(asd)
print(ads)
运行结果
True
False
分割字符串：以逗号为分割符分割字符串
languages = "Python,Java,Golang"
sdf = languages.split(",")
print(sdf)
运行结果
['Python', 'Java', 'Golang']
判定字符串是否由空格组成
str = " "
print (str.isspace())
str = "Runoob example....wow!!!"
print (str.isspace())
运行结果
True
False
判断字符串是否由字母和数字组成
str = "niubi2016" # 字符串没有空格
print (str.isalnum())
str = "www.niubi.com"
print (str.isalnum())
运行结果
True
False
判断字符串是否只由字母或文字组成
str = niubi
print (str.isalpha())
# 字母和中文文字
str = "niubi教程"
print (str.isalpha())
str = "niubi example....wow!!!"
print (str.isalpha())
运行结果
True
True
False
判断字符串是否只由数字组成
str = "123456";
print (str.isdigit())
str = "niubi example....wow!!!"
print (str.isdigit())
运行结果
True
False
PS: isdigit() 方法只对正整数有效，负数及小数均返回不正确。
可以使用以下函数来解决：
实例
# 判断是否为数字
def is_number(s):
try: # 如果能运⾏ float(s) 语句，返回 True（字符串 s 是浮点数）
float(s)
return True
except ValueError: # ValueError 为 Python 的⼀种标准异常，表⽰"传⼊⽆效的参数"
pass # 如果引发了 ValueError 这种异常，不做任何事情（pass：不做任何事情，⼀般⽤做占位语句）
try:
import unicodedata # 处理 ASCII 码的包
unicodedata.numeric(s) # 把⼀个表⽰数字的字符串转换为浮点数返回的函数
return True
except (TypeError, ValueError):
pass
return False
print(is_number(1))
print(is_number(1.0))
print(is_number(0))
print(is_number(-2))
print(is_number(-2.0))
print(is_number("abc"))
运行结果
True
True
True
True
True
False
判断字符串是否由小写字母组成
str = "NIUBI example....wow!!!"
print (str.islower())
str = "niubi example....wow!!!"
print (str.islower())
运行结果
False
True
判断字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
str = "This Is String Example...Wow!!!"
print (str.istitle())
str = "This is string example....wow!!!"
print (str.istitle())
运行结果
True
False
2.3 【基础】整数与浮点数
Python 支持的数字类型有三种：整数、浮点数和复数。
2.3.1- 整数（Int）
整数就是没有小数部分的数字，Python 中的整数包括正整数、0 和负整数。
Python 整数的取值范围是无限的，不管多大或者多小的数字，Python 都能轻松处理。
a = 100
>>> type(a)
<class 'int'>
>>>
>>> b = -100
>>> type(b)
<class 'int'>
表示数字的时候，有时我们还会用八进制或十六进制来表示：
- 十六进制：用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2。
- 八进制：用0o前缀和0-7表示，例如0o12
>>> a = 0x0001 # 十六进制
>>> a
1
>>> type(a)
<class 'int'>
>>>
>>> b = 0o01 # 八进制
>>> b
1
>>> type(b)
<class 'int'>
2.3.2-浮点数(Float)
浮点数也就是小数，如1.23，3.14，-9.01，等等。
>>> a = 1.23
>>> a
1.23
>>> type(a)
<class 'float'>
之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x10^9和12.3x10^8是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
>>> 1.23e9
1230000000.0
>>> 12.3e8
1230000000.0
2.3.3-复数(Complex)
复数由实数部分和虚数部分构成，可以用a + bj，或者 complex(a,b) 表示，复数的实部a和虚部b都是浮点型。关于复数，不做科学计算或其它特殊需要，通常很难遇到，这里不做过多解释。
>>> a = 10 + 0.2j
>>> a
(10+0.2j)
>>> type(a)
<class 'complex'>
>>>
>>> b = complex(10, 0.2)
>>> b
(10+0.2j)
>>> type(b)
<class 'complex'>
2.3.4- 常用方法
两数运算
两数相加减
>>> a = 10
>>> b = 20
>>> a + b
30
>>> b - a
10
两数相乘除
>>> a = 10
>>> b = 20
>>> a * b
200
>>> b / a
2.0
取模取余
>>> a = 10
>>> b = 3
>>> a // b
3
>>> a % b
1
计算绝对值
>>> a = -10
>>> abs(a)
10
数值直接取整
>>> a = 3.14
>>> int(a)
3
>>> b = 3.78
>>> int(b)
3
数值四舍五入
>>> a = 3.14
>>> round(a)
3
>>> b = 3.78
>>> round(b)
4
PS：更多计算方法及数字函数可查询python官方文档得知
这里不过多阐述
2.3.5-知识拓展
随机数函数
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用随机数函数：
| 函数 | 描述 |
|---|---|
| choice(seq) | 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。 |
| randrange([start,]stop[,step]) | 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1 |
| shuffle(lst) | 将序列的所有元素随机排序 |
| randint(start, stop) | 指定范围内的整数。 |
choice() 函数
描述
choice() 方法返回一个列表，元组或字符串的随机项。
语法
以下是 choice() 方法的语法:
import random
random.choice( seq )
**注意：**choice()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
- seq – 可以是一个列表，元组或字符串。
返回值
返回随机项。
实例
import random
print ("从 range(100) 返回一个随机数 : ",random.choice(range(100)))
print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9]))
print ("从字符串中 'niubi' 返回一个随机字符 : ", random.choice('niubi'))
运行结果
从 range(100) 返回一个随机数 : 88
从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : 2
从字符串中 'niubi' 返回一个随机字符 : u
randrange() 函数
描述
randrange() 方法返回指定递增基数集合中的一个随机数，奇数默认值为1。
语法
以下是 randrange() 方法的语法:
import random
random.randrange ([start,] stop [,step])
**注意：**randrange()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
- start – 指定范围内的开始值，包含在范围内。
- stop – 指定范围内的结束值，不包含在范围内。
- step – 指定递增基数。
返回值
从给定的范围返回随机项。
实例
import random
# 从 1-100 中选取一个奇数
print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))
# 从0-100中随机选取一个偶数
print ("randrange(0,100, 2) : ", random.randrange(0, 100, 2))
# 从 0-99 选取一个随机数
print ("randrange(100) : ", random.randrange(100))
运行结果
randrange(1,100, 2) : 97
randrange(1,100, 2) : 98
randrange(100) : 24
shuffle() 函数
描述
shuffle() 方法将序列的所有元素随机排序。
语法
以下是 shuffle() 方法的语法:
import random random.shuffle (lst )
**注意：**shuffle() 是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
- lst – 列表。
返回值
返回 None。
实例
import random
list = [20, 16, 10, 5];
random.shuffle(list)
print ("随机排序列表 : ", list)
random.shuffle(list)
print ("随机排序列表 : ", list)
运行结果
随机排序列表 : [20, 5, 16, 10]
随机排序列表 : [5, 20, 10, 16]
randint() 函数
描述
randint() 方法用于生成指定范围内的随机整数。
randint(start, stop) 等价于 randrange(start,stop+1).
语法
random.randint() 方法语法如下：
random.randint(start, stop)
参数说明：
- start – 必需， 一个整数，指定开始值。
- stop – 必需， 一个整数，指定结束值。
返回值
返回指定范围内的整数。
实例
# 导入 random 包
import random
# 返回一个 1 到 9 之间的数字
print(random.randint(1, 9))
运行结果
8
2.4 【基础】布尔值：真与假
2.4.1- 什么是布尔值
在计算机世界里，都是 0 和 1 组成的，代表了开关、真假两种状态。在 Python 里，True 和 False 代表真假，它都属于布尔型，布尔型只有这两个值。
注意
True 和 False 首字母都是大写。
2.4.2-布尔值类型的转换和变量（bool()）
bool()函数可以将其它类型转换为布尔值类型True或False，
实例：
使用bool()对字符串和数字转换布尔值：
print(bool("Hello"))
print(bool(15))
运行结果
True
True
实例：
使用bool()对两个变量转换布尔值：
x = "Hello"
y = 15
print(bool(x))
print(bool(y))
运行结果
True
True
大多数的值都是True
如果它具有某种内容，则几乎所有值都将转换为True。
除空字符串(''或“”)外，任何字符串均为True。
除0外，任何数字均为True。
任何非空的列表，元组，集合和字典都是True。
实例：
以下内容将返回True：
bool("abc")
bool(123)
bool(["c", "java", "python"])
某些值是False
实际上，除了空值（例如（），[]，{}，“”，数字0和值None。 值False也可转换为False。
实例：
以下将返回False：
bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})
另外一个值或对象（在这种情况下）的计算结果为False，也就是说，如果您有一个对象，该对象是由具有__len__函数的类制成的，该函数返回0或False：
实例：
class myclass():
def __len__(self):
return 0
myobj = myclass()
print(bool(myobj))
2.4.3-布尔运算
以下是按优先级从低到高分别有：
| 运算 | 表达式 | 运算说明 |
|---|---|---|
| 或 | a or b | a=真:真; a=假b=真:真; 其余为假 |
| 与 | a and b | a 和 b 全为真:真, 其余为假 |
| 非 | not a | a=真:假, a=假:真 |
需要注意的是：
a = 0
b = 1
c = 2
a and b # 0 a 为假返回假的值
b and a # 0 b为真，返回a的值
a or b # 1 输出为真值的结果
a and b or c # 2
a and (b or c) # 0 用类似数学中的括号提高运算优先级
# not 的注意事项
not a # True
not a == b # True
not (a == b) # True 同上逻辑
a == not b # ！这个是错误的语法, 正确如下：
a == (not b) # True
# and 优先级高 'a' 为真，返回 'b', '' or 'b' 返回 'b'
'' or 'a' and 'b' # 'b'
可运算赋值：
x = a or b # 哪个为真就就将值赋值到 x
x = a and b # 哪个为假就将值赋到 x
x = not a # 将结果赋值给 x, False
比较运算
对两个值或者变量进行比较，如果表达式成立返回 True，否则返回 False。
| 操作符 | 说明 |
|---|---|
| < | 小于 |
| <= | 小于等于 |
| > | 大于 |
| >= | 大于等于 |
| == | 等于 |
| != | 不等于 |
| is | 是相同对象 |
| is not | 是不同对象 |
示例：
a = 0
b = 1
c = 2
a > b # False
a == b # False
b == (c - b) # True
a != b # True
a < (b + c) # True
a is not a # False
2.4.4-空值：None
什么是空值：空值指的是一个变量没有任何值，即它是空的，没有任何内容。在 Python 中，None 是代表空值的对象。 类似于其他编程语言中的 null、nil、undefined 等。
实例
# 定义空值
val = None
# 判断类型
print(type(val))
运行结果
<class 'NoneType'>
None 有以下特点：
- None 是 Python 的一个特殊对象，表示“无”、“空”或“不存在”。
- NoneType 是 None 对象的类型。
- None 在布尔上下文中相当于 False。
- None 是一个全局变量，在 Python 程序中随时可以访问。
以下是一些示例：
# 示例1：使用 None 作为函数返回值
def divide(x, y):
if y == 0:
return None
else:
return x / y
result = divide(10, 0)
if result is None:
print("Cannot divide by zero")
# 示例2：使用 None 作为函数参数默认值
def greet(name=None):
if name is None:
print("Hello, world!")
else:
print("Hello, " + name + "!")
greet() # 输出：Hello, world!
greet("Alice") # 输出：Hello, Alice!
在上述示例中，示例1演示了使用 None 作为函数返回值。如果分母 y 为 0，则函数返回 None。在调用函数时，需要检查函数的返回值是否为 None，如果是，则说明除数为 0，不能执行除法操作。
示例2演示了使用 None 作为函数参数的默认值。在定义函数时，可以指定参数的默认值为 None。当调用函数时，如果没有传递参数，则函数使用默认值 None。
除此之外，还可以使用 is 和 == 运算符来检查变量是否为 None。is 运算符用于检查变量是否为 None 对象，而 == 运算符用于检查变量的值是否为 None。
# 检查变量是否为 None 对象
x = None
if x is None:
print("x is None")
# 检查变量的值是否为 None
y = 10
if y == None: # 不推荐
print("y is None")
if y is None:
print("y is None")
2.5-【基础】输入与输出
2.5.1-input输入函数
Python3.x 中 input（） 函数接受一个标准输入数据，返回为 string 类型。
重要的话，说两遍，input函数的返回值是一个字符串类型。哪怕你输入的是个数字1，返回给你的只会是字符串“1”，而不是 整数1。
input() 函数的用法为：
str = input(tipmsg)
说明：
- str 表示一个字符串类型的变量，input 会将读取到的字符串放入 str 中。
- tipmsg 表示提示信息，它会显示在控制台上，告诉用户应该输入什么样的内容；如果不写 tipmsg，就不会有任何提示信息。
实例
a = input('请输入你的号码前五位：') # 使用input函数显示提示信息然后赋值给变量a
print('类型', type(a)) # 打印变量a的类型
b = input('请输入你剩余的号码：')
print('类型', type(b))
result = a + b # 把a+b的结果赋值给result
print("resultValue: ", result) # 打印变量result的值
print("resultType: ", type(result)) # 打印变量result的类型
运行结果
请输入你的号码前五位：12345
类型 <class 'str'>
请输入你剩余的号码：987456
类型 <class 'str'>
resultValue: 12345987456
resultType: <class 'str'>
本例中我们输入了两个整数，希望计算出它们的和，但是事与愿违，Python 只是它们当成了字符串，+起到了拼接字符串的作用，而不是求和的作用。
我们可以使用 Python 内置函数将字符串转换成想要的类型，比如：
- int(string) 将字符串转换成 int 类型；
- float(string) 将字符串转换成 float 类型；
- bool(string) 将字符串转换成 bool 类型。
修改上面的代码，将用户输入的内容转换成数字：
实例
a = int(input('请输入你的号码前五位：')) # 使用input函数显示提示信息然后赋值给变量a
print('类型', type(a)) # 打印变量a的类型
b = int(input('请输入你剩余的号码：'))
print('类型', type(b))
result = a + b # 把a+b的结果赋值给result
print("resultValue: ", result) # 打印变量result的值
print("resultType: ", type(result)) # 打印变量result的类型
运行结果
请输入你的号码前五位：12345
类型 <class 'int'>
请输入你剩余的号码：5461
类型 <class 'int'>
resultValue: 17806
resultType: <class 'int'>
知识拓展
有时候可能输入两边会多敲入几个空格，这时候可以使用 strip() 函数去除首尾空格
实例
name = input("请输入你的姓名: ")
print(name)
name = name.strip()
print(name)
运行结果
请输入你的姓名: 张三丰
张三丰
张三丰
有时候用户输入的内容会不符合程序的预期，比如我想要获取年龄，那输入必然是全数字，而不能是其他非数值，这时候就可以使用 isdigit 函数进行判断
实例
age = input("请输入你的年龄: ")
if age.isdigit():
age = int(age)
print('你的年龄是：', age)
else:
print('输入不合法')
运行结果-1
请输入你的年龄: 18
你的年龄是： 18
运行结果-2
请输入你的年龄: asd
输入不合法
2.5.2-print 输入函数
print() 方法的语法:
print (objects,...,sep='',end='\n',file=sys.stdout,flush=False)
参数
- objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
- sep – 用来间隔多个对象，默认值是一个空格。
- end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
- file – 要写入的文件对象。
- flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。
objects参数实例
user_name ＝ 'Charlie'
user_age = 8
#同时输出多个变量和字符串
print("读者名：",user_name,"年龄：",user_age)
运行结果
读者名： Charlie 年龄： 8
sep参数实例
#同时输出多个变量和字符串，指定分隔符
print("读者名：" ,user_name,"年龄：",user_age,sep='|')
运行结果
读者名：|Charlie|年龄：|8
end参数实例
#设置end 参数，指定输出之后不再换行
print(40,'\t',end＝"")
print(5O,'\t',end＝"")
print(60,'\t',end＝"")
运行结果
40 50 60
file参数实例
f = open('file.txt', 'w')
f.write('Hello World!')
f.close()
flush参数实例
我们知道print也可输出到文件。在python3 交互模式中输入：
f = open("123.txt", "w")
print("123456789", file = f)
运行后打开123.txt文件，发现“123456789”未被写入，文件内容为空。只有f.close()后才将内容写进文件中。如果加入flush = True，即上面代码改为：
f = open("123.txt", "w")
print("123456789",file = f, flush = True)
不用f.close()即可将内容写进文件中
flush参数主要是刷新， 默认flush = False，不刷新，如上面例子，print到f中的内容先存到内存中，当文件对象关闭时才把内容输出到 123.txt 中；而当flush = True时它会立即把内容刷新存到 123.txt 中。
2.6 【基础】字符串格式化
格式化输出，主要有三种方式
- 使用 % 进行格式化
- 使用 format 函数进行格式化
- 使用 f-string 进行格式化
由于这三种格式化的内容都非常的多，这里仅为了你看本教程后面的内容，我只介绍最常用的几种
2.6.1-第一种方法：使用 %
%s 表示这个位置接的是一个字符串变量
%d 表示这个位置接的是一个整型变量
前面有多少个 %，后面就要有多少个变量，一一对应，多个变量要括号括起来
>>> name = "Jack"
>>> age = 18
>>> print("我的名字是: %s，今年 %d 岁" %(name, age))
我的名字是: Jack，今年 18 岁
更多的格式化式符号，可以参考这张表
| 符号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f 和 %e 的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
2.6.2-第二种方法：使用 format
在字符串中，使用 {} 进行占位，然后在字符串后跟上 .format() 函数，这个函数的参数就是我们要往字符串中填充的变量。
format 函数会依次填充，比如第一个 {} 会取到第一个参数 name，第二个 {} 会取到第二个参数 age
>>> name = "Jack"
>>> age = 18
>>> print("我的名字是:{}, 今年 {} 岁".format(name, age))
我的名字是:Jack, 今年 18 岁
然后如果变量值比较多的话，这样往往会看错乱掉。你可以改成使用索引
>>> print("我的名字是:{0}, 今年 {1} 岁".format(name, age))
我的名字是:Jack, 今年 18 岁
甚至还可以直接用变量名进行替代
>>> name = "Jack"
>>> age = 18
>>> print("我的名字是:{name}, 今年 {age} 岁".format(name=name, age=age))
我的名字是:Jack, 今年 18 岁
2.6.3-第三种方法：使用 f-string
这种方法是 Python 3.6 才支持的写法，只要你在字符串前面加一个 f，开启 f-string ，就可以在字符中写入变量。
直接看案例了
>>> name = "Jack"
>>> age = 18
>>> print(f"我的名字是:{name}, 今年 {age} 岁")
我的名字是:Jack, 今年 18 岁
2.7【基础】运算符（超全整理）
2.7.1-什么是运算符？
运算符是用于在 Python 中对变量和值执行操作的符号。
Python语言支持以下类型的运算符:
- 算术运算符
- 比较（关系）运算符
- 赋值运算符
- 逻辑运算符
- 位运算符
- 成员运算符
- 身份运算符
- 三目运算符
2.7.2-算术运算符
| 运算符 | 说明 | 实例 | 结果 |
|---|---|---|---|
| + | 加 | 12.45 + 15 | 27.45 |
| - | 减 | 4.56 - 0.26 | 4.3 |
| * | 乘 | 5 * 3.6 | 18.0 |
| / | 除法（和数学中的规则一样） | 7 / 2 | 3.5 |
| // | 整除（只保留商的整数部分） | 7 // 2 | 3 |
| % | 取余，即返回除法的余数 | 7 % 2 | 1 |
| ** | 幂运算/次方运算，即返回 x 的 y 次方 | 2 ** 4 | 16，即 24 |
+ 加法运算符
加法运算符很简单，和数学中的规则一样，请看下面的代码：
m = 10
n = 97
sum1 = m + n
x = 7.2
y = 15.3
sum2 = x + y
print("sum1=%d, sum2=%.2f" % (sum1, sum2) )
运行结果：
sum1=107, sum2=22.50
拼接字符串
当+用于数字时表示加法，但是当+用于字符串时，它还有拼接字符串（将两个字符串连接为一个）的作用，请看代码：
name = "CSDN"
url = "https://www.csdn.net/"
age = 24
info = name + "的网址是" + url + "，它已经" + str(age) + "岁了。"
print(info)
运行结果：
CSDN的网址是https://www.csdn.net/，它已经24岁了。
str() 函数用来将整数类型的 age 转换成字符串。
- 减法运算符
减法运算也和数学中的规则相同，请看代码：
n = 45
m = -n
x = -83.5
y = -x
print(m, ",", y)
运行结果：
-45 , 83.5
求负
-除了可以用作减法运算之外，还可以用作求负运算（正数变负数，负数变正数），请看下面的代码：
n = 45
n_neg = -n
f = -83.5
f_neg = -f
print(n_neg, ",", f_neg)
运行结果：
-45 , 83.5
注意，单独使用+是无效的，不会改变数字的值，例如：
n = 45
m = +n
x = -83.5
y = +x
print(m, ",", y)
运行结果：
45 , -83.5
＊乘法运算符
乘法运算也和数学中的规则相同，请看代码：
n = 4 * 25
f = 34.5 * 2
print(n, ",", f)
运行结果：
100 , 69.0
重复字符串
*除了可以用作乘法运算，还可以用来重复字符串，也即将 n 个同样的字符串连接起来，请看代码：
str1 = "hello "
print(str1 * 4)
运行结果：
hello hello hello hello
/ 和 // 除法运算符
Python 支持/和//两个除法运算符，但它们之间是有区别的：
/表示普通除法，使用它计算出来的结果和数学中的计算结果相同。//表示整除，只保留结果的整数部分，舍弃小数部分；注意是直接丢掉小数部分，而不是四舍五入。
请看下面的例子：
#整数不能除尽
print("23/5 =", 23/5)
print("23//5 =", 23//5)
print("23.0//5 =", 23.0//5)
print("-------------------")
#整数能除尽
print("25/5 =", 25/5)
print("25//5 =", 25//5)
print("25.0//5 =", 25.0//5)
print("-------------------")
#小数除法
print("12.4/3.5 =", 12.4/3.5)
print("12.4//3.5 =", 12.4//3.5)
运行结果：
23/5 = 4.6
23//5 = 4
23.0//5 = 4.0
-------------------
25/5 = 5.0
25//5 = 5
25.0//5 = 5.0
-------------------
12.4/3.5 = 3.542857142857143
12.4//3.5 = 3.0
从运行结果可以发现：
/的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。- 当有小数参与运算时，
//结果才是小数，否则就是整数。
需要注意的是，除数始终不能为 0，除以 0 是没有意义的，这将导致 ZeroDivisionError 错误。在某些编程语言中，除以 0 的结果是无穷大（包括正无穷大和负无穷大）。
% 求余运算符
Python % 运算符用来求得两个数相除的余数，包括整数和小数。Python 使用第一个数字除以第二个数字，得到一个整数的商，剩下的值就是余数。对于小数，求余的结果一般也是小数。
注意，求余运算的本质是除法运算，所以第二个数字也不能是 0，否则会导致 ZeroDivisionError 错误。
Python % 使用示例：
print("-----整数求余-----")
print("15%6 =", 15%6)
print("-15%6 =", -15%6)
print("15%-6 =", 15%-6)
print("-15%-6 =", -15%-6)
print("-----小数求余-----")
print("7.7%2.2 =", 7.7%2.2)
print("-7.7%2.2 =", -7.7%2.2)
print("7.7%-2.2 =", 7.7%-2.2)
print("-7.7%-2.2 =", -7.7%-2.2)
print("---整数和小数运算---")
print("23.5%6 =", 23.5%6)
print("23%6.5 =", 23%6.5)
print("23.5%-6 =", 23.5%-6)
print("-23%6.5 =", -23%6.5)
print("-23%-6.5 =", -23%-6.5)
运行结果：
-----整数求余-----
15%6 = 3
-15%6 = 3
15%-6 = -3
-15%-6 = -3
-----小数求余-----
7.7%2.2 = 1.0999999999999996
-7.7%2.2 = 1.1000000000000005
7.7%-2.2 = -1.1000000000000005
-7.7%-2.2 = -1.0999999999999996
---整数和小数运算---
23.5%6 = 5.5
23%6.5 = 3.5
23.5%-6 = -0.5
-23%6.5 = 3.0
-23%-6.5 = -3.5
从运行结果可以发现两点：
- 只有当第二个数字是负数时，求余的结果才是负数。换句话说，求余结果的正负和第一个数字没有关系，只由第二个数字决定。
%两边的数字都是整数时，求余的结果也是整数；但是只要有一个数字是小数，求余的结果就是小数。
本例中小数求余的四个结果都不精确，而是近似值，这和小数在底层的存储有关系。
** 次方（乘方）运算符
Python ** 运算符用来求一个 x 的 y 次方，也即次方（乘方）运算符。
由于开方是次方的逆运算，所以也可以使用 ** 运算符间接地实现开方运算。
Python ** 运算符示例：
print('----次方运算----')
print('3**4 =', 3**4)
print('2**5 =', 2**5)
print('----开方运算----')
print('81**(1/4) =', 81**(1/4))
print('32**(1/5) =', 32**(1/5))
运行结果：
----次方运算----
3**4 = 81
2**5 = 32
----开方运算----
81**(1/4) = 3.0
32**(1/5) = 2.0
2.7.3-比较运算符
比较运算符，也称关系运算符，用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的，则返回 True（真），反之则返回 False（假）。
| 比较运算符 | 说明 |
|---|---|
| > | 大于，如果>前面的值大于后面的值，则返回 True，否则返回 False。 |
| < | 小于，如果<前面的值小于后面的值，则返回 True，否则返回 False。 |
| == | 等于，如果==两边的值相等，则返回 True，否则返回 False。 |
| >= | 大于等于（等价于数学中的 ≥），如果>=前面的值大于或者等于后面的值，则返回 True，否则返回 False。 |
| <= | 小于等于（等价于数学中的 ≤），如果<=前面的值小于或者等于后面的值，则返回 True，否则返回 False。 |
| != | 不等于（等价于数学中的 ≠），如果!=两边的值不相等，则返回 True，否则返回 False。 |
Python 比较运算符的使用举例：
print("89是否大于100：", 89 > 100)
print("24*5是否大于等于76：", 24*5 >= 76)
print("86.5是否等于86.5：", 86.5 == 86.5)
print("34是否等于34.0：", 34 == 34.0)
print("False是否小于True：", False < True)
print("True是否等于True：", True < True)
运行结果
89是否大于100： False
24*5是否大于等于76： True
86.5是否等于86.5： True
34是否等于34.0： True
False是否小于True： True
True是否等于True： False
2.7.4-赋值运算符
赋值运算符用来把右侧的值传递给左侧的变量（或者常量）；可以直接将右侧的值交给左侧的变量，也可以进行某些运算后再交给左侧的变量，比如加减乘除、函数调用、逻辑运算等。
Python中最基本的赋值运算符是等号=；结合其它运算符，=还能扩展出更强大的赋值运算符。
基本赋值运算符
=是 Python 中最常见、最基本的赋值运算符，用来将一个表达式的值赋给另一个变量，请看下面的例子：
#将字面量（直接量）赋值给变量
n1 = 100
f1 = 47.5
s1 = "http://c.biancheng.net/python/"
#将一个变量的值赋给另一个变量
n2 = n1
f2 = f1
#将某些运算的值赋给变量
sum1 = 25 + 46
sum2 = n1 % 6
s2 = str(1234) #将数字转换成字符串
s3 = str(100) + "abc"
连续赋值
Python 中的赋值表达式也是有值的，它的值就是被赋的那个值，或者说是左侧变量的值；如果将赋值表达式的值再赋值给另外一个变量，这就构成了连续赋值。请看下面的例子：
a = b = c = 100
=具有右结合性，我们从右到左分析这个表达式：
- c = 100 表示将 100 赋值给 c，所以 c 的值是 100；同时，c = 100 这个子表达式的值也是 100。
- b = c = 100 表示将 c = 100 的值赋给 b，因此 b 的值也是 100。
- 以此类推，a 的值也是 100。
最终结果就是，a、b、c 三个变量的值都是 100。
= 和 ==
= 和 == 是两个不同的运算符，= 用来赋值，而 == 用来判断两边的值是否相等，千万不要混淆。
扩展后的赋值运算符
=还可与其他运算符（包括算术运算符、位运算符和逻辑运算符）相结合，扩展成为功能更加强大的赋值运算符，如表 1 所示。扩展后的赋值运算符将使得赋值表达式的书写更加优雅和方便。
| 运算符 | 说 明 | 用法举例 | 等价形式 |
|---|---|---|---|
| = | 最基本的赋值运算 | x = y | x = y |
| += | 加赋值 | x += y | x = x + y |
| -= | 减赋值 | x -= y | x = x - y |
| *= | 乘赋值 | x *= y | x = x * y |
| /= | 除赋值 | x /= y | x = x / y |
| %= | 取余数赋值 | x %= y | x = x % y |
| **= | 幂赋值 | x **= y | x = x ** y |
| //= | 取整数赋值 | x //= y | x = x // y |
| &= | 按位与赋值 | x &= y | x = x & y |
| |= | 按位或赋值 | x |= y | x = x | y |
| ^= | 按位异或赋值 | x ^= y | x = x ^ y |
| <<= | 左移赋值 | x <<= y | x = x << y，这里的 y 指的是左移的位数 |
| >>= | 右移赋值 | x >>= y | x = x >> y，这里的 y 指的是右移的位数 |
这里举个简单的例子：
n1 = 100
f1 = 25.5
n1 -= 80 #等价于 n1=n1-80
f1 *= n1 - 10 #等价于 f1=f1*( n1 - 10 )
print("n1=%d" % n1)
print("f1=%.2f" % f1)
运行结果为：
n1=20
f1=255.00
通常情况下，只要能使用扩展后的赋值运算符，都推荐使用这种赋值运算符。
但是请注意，这种赋值运算符只能针对已经存在的变量赋值，因为赋值过程中需要变量本身参与运算，如果变量没有提前定义，它的值就是未知的，无法参与运算。例如，下面的写法就是错误的：
n += 10
该表达式等价于 n = n + 10，n 没有提前定义，所以它不能参与加法运算。
2.7.5-位运算符
Python位运算按照数据在内存中的二进制位（Bit）进行操作，它一般用于底层开发（算法设计、驱动、图像处理、单片机等）
Python 位运算符只能用来操作整数类型，它按照整数在内存中的二进制形式进行计算。
| 运算符 | 名称 | 描述 |
|---|---|---|
| & | 按位与运算符(AND) | 如果两个位均为1，则将每个位设置为1 |
| | | 按位或运算符(OR) | 如果两位之一为1，则将每个位设置为1 |
| ^ | 按位异或运算符(XOR) | 如果两位中只有一位为1，则将每个位设置为1 |
| ~ | 按位取反运算符(NOT) | 反转所有位 |
| << | 左移动运算符 | 运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 |
| >> | 右移动运算符 | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 |
例如：
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b; # 12 = 0000 1100
c = a | b; # 61 = 0011 1101
c = a ^ b; # 49 = 0011 0001
c = ~a; # -61 = 1100 0011
c = a << 2; # 240 = 1111 0000
c = a >> 2; # 15 = 0000 1111
2.7.6-逻辑运算符
Python中的逻辑运算符用来对逻辑表达式进行逻辑操作，主要有and、or和not三种。它们可以帮助开发者判断条件表达式的真假性，从而得出最终的结果。
| 逻辑运算符 | 含义 | 基本格式 | 说明 |
|---|---|---|---|
| and | 逻辑与运算，等价于数学中的“且” | a and b | 当 a 和 b 两个表达式都为真时，a and b 的结果才为真，否则为假。 |
| or | 逻辑或运算，等价于数学中的“或” | a or b | 当 a 和 b 两个表达式都为假时，a or b 的结果才是假，否则为真。 |
| not | 逻辑非运算，等价于数学中的“非” | not a | 如果 a 为真，那么 not a 的结果为假；如果 a 为假，那么 not a 的结果为真。相当于对 a 取反。 |
逻辑运算符一般和关系运算符结合使用，例如：
14>6 and 45.6 > 90
14>6 结果为 True，成立，45.6>90 结果为 False，不成立，所以整个表达式的结果为 False，也即不成立。
再看一个比较实用的例子：
age = int(input("请输入年龄："))
height = int(input("请输入身高："))
if age>=18 and age<=30 and height >=170 and height <= 185 :
print("恭喜，你符合报考飞行员的条件")
else:
print("抱歉，你不符合报考飞行员的条件")
运行结果
请输入年龄：23
请输入身高：178
恭喜，你符合报考飞行员的条件
2.7.7-成员运算符
in 与 not in是Python独有的运算符（全部都是小写字母），用于判断对象是否某个集合的元素之一，非常好用，并且运行速度很快。返回的结果是布尔值类型的True或者False。
| 运算符 | 描述 | 示例 |
|---|---|---|
| in | 如果对象中存在具有指定值的序列，则返回True | y in x |
| not in | 如果对象中不存在具有指定值的序列，则返回True | x not in y |
看个例子，传统的方式，我们判断某个集合里是否有某个元素时，都是使用for循环遍历一次集合，逐一进行比对，最后给出结果：
list1 = [1, 2, 3, 4, 5]
a = 1
flag = False #标记开关
for i in list1:
if i == a:
flag = True
break
if flag:
print("a是list1的元素之一")
else:
print("a不是list1的元素")
事实上根本不用这么麻烦，直接使用in运算符就好了
list1 = [1, 2, 3, 4, 5]
a = 1
if a in list1:
print("a是list1的元素之一")
else:
print("a不是list1的元素")
知识拓展
Flag这一变量名常常被用于命名旗标变量，或者说哨兵变量。这种变量的作用体现在帮助进行条件判断中；
在Python中，flag=False表示将一个名为flag的布尔变量设置为False，因此在条件判断时，当flag为False时，条件被认为是不满足的。
2.7.8-身份运算符
身份运算符用于比较对象，不是比较它们是否相等，但如果它们实际上是同一个对象，则具有相同的内存位置
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | 本质上是判断两个对象的内存地址是否相同 |
| is not | is not 是判断两个标识符是不是引用自不同对象 | 与is功能相反，本质上仍然是对两个对象的内存地址是否相等进行判断 |
先来几个示例，感受一下它的功能
a = 1
b = 1
print(a is b)
程序输出结果
True
is 与 == 的区别
a = [1, 2, 3] # 创建一个新的列表
b = [1, 2, 3] # 创建一个新的列表
print(a == b)
print(a is b)
print(id(a), id(b))
程序输出结果
True
False
4367682696 4367682952
== 比较运算符，比较的是两个对象的值是否相等，从字面上看，这两个列表的值是完全相等的
is 是身份运算符，它比较的是两个对象的内存地址是否相同，如果内存地址相同，那么他们就是同一个对象。
上面的示例代码中，虽然列表的值相同，但他们是在两个不同的赋值语句中被创建的，因此他们的内存地址不同
同时对两个变量赋值1，为什么这两个1的内存地址相同
a = 1
b = 1
print(a is b)
程序输出结果
True
为什么这两个1的内存地址会相同呢?这里和python的内存管理有关，python设计者认为在[-5, 257)这个范围内的整数，是经常被使用的对象，因此，没有必要经常性的创建和释放他们，于是python建立了一个内存池，存储了这个范围内的整数，当你使用这个范围内的整数时，其实都是从这个内存池中取数，并没有重新创建
>>> a = 256
>>> b = 256
>>> a is b
True
>>> a = 257
>>> b = 257
>>> a is b
False
如果超出这个范围，尽管值相同，但是已经超出了内存池存储数据范围，因此分别在内存中创建了两个257，他们的内存地址不同
2.7.9-三目运算符（三元表达式）
我们从一个具体的例子切入本节内容。假设现在有两个数字，我们希望获得其中较大的一个，那么可以使用 if else 语句，例如：
if a>b:
max = a;
else:
max = b;
但是 Python提供了一种更加简洁的写法，如下所示：
max = a if a>b else b
这是一种类似于其它编程语言中三目运算符? :的写法。Python 是一种极简主义的编程语言，它没有引入? :这个新的运算符，而是使用已有的 if else 关键字来实现相同的功能。
使用 if else 实现三目运算符（条件运算符）的格式如下：
exp1 if contion else exp2
condition 是判断条件，exp1 和 exp2 是两个表达式。如果 condition 成立（结果为真），就执行 exp1，并把 exp1 的结果作为整个表达式的结果；如果 condition 不成立（结果为假），就执行 exp2，并把 exp2 的结果作为整个表达式的结果。
前面的语句max = a if a>b else b的含义是：
- 如果 a>b 成立，就把 a 作为整个表达式的值，并赋给变量 max；
- 如果 a> b 不成立，就把 b 作为整个表达式的值，并赋给变量 max。
三目运算符的嵌套
Python 三目运算符支持嵌套，如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对，例如：
a if a>b else c if c>d else d
应该理解为：
a if a>b else ( c if c>d else d )
【实例】使用 Python 三目运算符判断两个数字的关系：
a = int( input("Input a: ") )
b = int( input("Input b: ") )
print("a大于b") if a>b else ( print("a小于b") if a<b else print("a等于b") )
可能的运行结果：
Input a: 45↙
Input b: 100↙
a小于b
该程序是一个嵌套的三目运算符。程序先对 a>b 求值，如果该表达式为 True，程序就返回执行第一个表达式 print(“a大于b”)，否则将继续执行 else 后面的内容，也就是：
( print("a小于b") if a<b else print("a等于b") )
进入该表达式后，先判断 a<b 是否成立，如果 a<b 的结果为 True，将执行 print(“a小于b”)，否则执行 print(“a等于b”)。
Python运算符优先级
Python运算符优先级，是描述在计算机运算计算表达式时执行运算的先后顺序。 先执行具有较高优先级的运算，然后执行较低优先级的运算。 例如，我们常说的先执行相乘和除，再执行加减运算。
Python运算符详细说明
下表从高到低列出了运算符的优先级。同一行中的运算符具有相同优先级，然后运算符的优先级是运算表达式从左到右。
| 优先级 | 运算符 | 描述 |
|---|---|---|
| 1 | lambda | Lambda表达式 |
| 2 | or | 布尔“或” |
| 3 | and | 布尔“与” |
| 4 | not x | 布尔“非” |
| 5 | in，not in | 成员测试 |
| 6 | is，is not | 同一性测试 |
| 7 | <，<=，>，>=，!=，== | 比较 |
| 8 | ` | ` |
| 9 | ^ | 按位异或 |
| 10 | & | 按位与 |
| 11 | <<，>> | 移位 |
| 12 | +，- | 加法与减法 |
| 13 | *，/，% | 乘法、除法与取余 |
| 14 | +x，-x | 正负号 |
| 15 | ~x | 按位翻转 |
| 16 | ** | 指数 |
| 17 | x.attribute | 属性参考 |
| 18 | x[index] | 下标 |
| 19 | x[index:index] | 寻址段 |
| 20 | f(arguments...) | 函数调用 |
| 21 | (experession,...) | 绑定或元组显示 |
| 22 | [expression,...] | 列表显示 |
| 23 | {key:datum,...} | 字典显示 |
| 24 | 'expression,...' | 字符串转换 |
Python运算符计算顺序
一般情况下，运算符优先级表决定了哪个运算符在别的运算符之前计算。但是，如果你想要改变它们默认计算顺序，你得使用圆括号。例如，你想要在一个表达式中让加法在乘法之前计算，那么你就得写成类似(10 + 55) * 13的样子。
Python运算符结合规律
Python运算符通常由左向右结合，即具有相同优先级的运算符按照从左向右的顺序计算。例如，2 + 3 + 4被计算成(2 + 3) + 4。一些如赋值运算符那样的运算符是由右向左结合的，即a = b = c被处理为a = (b = c)。
Python运算符优先级排行榜
在一个表达式中可能包含多个有不同运算符连接起来的、具有不同数据类型的数据对象；由于表达式有多种运算，不同的运算顺序可能得出不同结果甚至出现错误运算错误，因为当表达式中含多种运算时，必须按一定顺序进行结合，才能保证运算的合理性和结果的正确性、唯一性。优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。表达式的结合次序取决于表达式中各种运算符的优先级。优先级高的运算符先结合，优先级低的运算符后结合，同一行中的运算符的优先级相同。
# coding=utf-8
#优先级的简单实例
priorityNumber=2+1*4
print priorityNumber #输出结果：6
#优先级使用实例
#以下优先级排名从高到低，在同一运算中，先执行优先级高的再执行低的，以此类推。
#Top 1:函数调用、寻址、下标
#Top 2:幂运算**
priorityNumber=2*2**3
print priorityNumber #输出结果：16
#Top 3:翻转运算~
#Top 4:正负号
print 1+2*-3 #输出结果：-5
#Top 5:*、/、%
print 2+1*2/5 #输出结果：2
#Top 6:+、-
print 3<<2+1 #输出结果：24
#Top 7:<<、>>
#Top 8:按位&、^、|
#Top 9:比较运算符
priority=2*3+2<=2+1*7
print priority #输出结果：True
#Top 10:逻辑的not and or
#Top 11:lambda表达式
2.python运算符优先级使用规律：
#python优先级使用规律
#1、一般情况下是左结合的
#ps:在没有更高优先级运算符，即只有同级运算符时时从左到右结合
print 1+2+3*5+5 #输出结果：23
#2、出现赋值的时候一般是右结合
#ps:在有赋值运算符时，是右结合，即先算出1+2的值以后再赋值给priority
priority=1+2
print priority #输出结果：23
Python运算符优先级之发大招
大家可能会觉得Python运算符的优先级不容易记忆，而且有时候还容易混淆。在实际运用中根据业务逻辑可能我们知道要先做什么再做什么，但是却忘记Python运算符的优先级了，该怎么办？这里教大家一个杀手锏，绝对百试不爽。
#python运算符优先级大招
'''比如说有这个需求：
去商店买水，买3瓶水，每瓶5块，再买一个绿箭(假设绿箭3块)，总共多少钱？
这个简单的应用非常明显，需要先用乘法再用加法，如果这里你忘记了乘法和加法的优先级，可以这样：
'''
print (3*5)+3 #输出结果：18
#ps: 这只是一个简单的例子，只是为了告诉大家实际应用中实在不行咱就放大招。有备无患。
Python表达式
Python表达式基本概念：
python中，值、变量和运算符共同组成的整体称为表达式
#python表达式
#1 字符串表达式
"Hello"
#2 计算表达式
2+3
#3 赋值表达式
first=0
#4 变量表达式
first
#5 值表达式
#等等
按位与 |
| 11 | <<，>> | 移位 |
| 12 | +，- | 加法与减法 |
| 13 | *，/，% | 乘法、除法与取余 |
| 14 | +x，-x | 正负号 |
| 15 | ~x | 按位翻转 |
| 16 | ** | 指数 |
| 17 | x.attribute | 属性参考 |
| 18 | x[index] | 下标 |
| 19 | x[index:index] | 寻址段 |
| 20 | f(arguments...) | 函数调用 |
| 21 | (experession,...) | 绑定或元组显示 |
| 22 | [expression,...] | 列表显示 |
| 23 | {key:datum,...} | 字典显示 |
| 24 | 'expression,...' | 字符串转换 |
Python运算符计算顺序
一般情况下，运算符优先级表决定了哪个运算符在别的运算符之前计算。但是，如果你想要改变它们默认计算顺序，你得使用圆括号。例如，你想要在一个表达式中让加法在乘法之前计算，那么你就得写成类似(10 + 55) * 13的样子。
Python运算符结合规律
Python运算符通常由左向右结合，即具有相同优先级的运算符按照从左向右的顺序计算。例如，2 + 3 + 4被计算成(2 + 3) + 4。一些如赋值运算符那样的运算符是由右向左结合的，即a = b = c被处理为a = (b = c)。
Python运算符优先级排行榜
在一个表达式中可能包含多个有不同运算符连接起来的、具有不同数据类型的数据对象；由于表达式有多种运算，不同的运算顺序可能得出不同结果甚至出现错误运算错误，因为当表达式中含多种运算时，必须按一定顺序进行结合，才能保证运算的合理性和结果的正确性、唯一性。优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。表达式的结合次序取决于表达式中各种运算符的优先级。优先级高的运算符先结合，优先级低的运算符后结合，同一行中的运算符的优先级相同。
# coding=utf-8
#优先级的简单实例
priorityNumber=2+1*4
print priorityNumber #输出结果：6
#优先级使用实例
#以下优先级排名从高到低，在同一运算中，先执行优先级高的再执行低的，以此类推。
#Top 1:函数调用、寻址、下标
#Top 2:幂运算**
priorityNumber=2*2**3
print priorityNumber #输出结果：16
#Top 3:翻转运算~
#Top 4:正负号
print 1+2*-3 #输出结果：-5
#Top 5:*、/、%
print 2+1*2/5 #输出结果：2
#Top 6:+、-
print 3<<2+1 #输出结果：24
#Top 7:<<、>>
#Top 8:按位&、^、|
#Top 9:比较运算符
priority=2*3+2<=2+1*7
print priority #输出结果：True
#Top 10:逻辑的not and or
#Top 11:lambda表达式
2.python运算符优先级使用规律：
#python优先级使用规律
#1、一般情况下是左结合的
#ps:在没有更高优先级运算符，即只有同级运算符时时从左到右结合
print 1+2+3*5+5 #输出结果：23
#2、出现赋值的时候一般是右结合
#ps:在有赋值运算符时，是右结合，即先算出1+2的值以后再赋值给priority
priority=1+2
print priority #输出结果：23
Python运算符优先级之发大招
大家可能会觉得Python运算符的优先级不容易记忆，而且有时候还容易混淆。在实际运用中根据业务逻辑可能我们知道要先做什么再做什么，但是却忘记Python运算符的优先级了，该怎么办？这里教大家一个杀手锏，绝对百试不爽。
#python运算符优先级大招
'''比如说有这个需求：
去商店买水，买3瓶水，每瓶5块，再买一个绿箭(假设绿箭3块)，总共多少钱？
这个简单的应用非常明显，需要先用乘法再用加法，如果这里你忘记了乘法和加法的优先级，可以这样：
'''
print (3*5)+3 #输出结果：18
#ps: 这只是一个简单的例子，只是为了告诉大家实际应用中实在不行咱就放大招。有备无患。
Python表达式
Python表达式基本概念：
python中，值、变量和运算符共同组成的整体称为表达式
#python表达式
#1 字符串表达式
"Hello"
#2 计算表达式
2+3
#3 赋值表达式
first=0
#4 变量表达式
first
#5 值表达式
#等等
所以在我们非常清楚Python运算优先级的前提下，最好运算符的书写的时候，还是要以圆括号来标记优先级，这样可读性强，也是一个良好的编程习惯。
232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
