这里写自定义目录标题
- 一、注释
- 分类
- 注意
- 二、变量
- 变量的声明
- 变量的命名
- 注意
- 变量的交换
- 常量
- 三、数据类型分类
- 六大标准数据类型
- Number 数字类型 分类：
- 2个内置方法 type 和 id
- 自动类型转换
- 强制类型转换
- 容器类型分类：五个
- 字符串类型 str
- 列表类型 list
- 内置函数 len
- 元组类型 tuple
- 字符串类型的索引取值
- 集合类型 set
- 字典 dict
- 变量的缓存机制
- 容器类型的强制类型转换
- 内置方法 repr （元字符串）
- 类型判断
- 四、运算符
- 分类
- 算数运算符
- 比较运算符
- 成员运算符 in
- 身份运算符
- 逻辑运算符
- 位运算符
- 运算符的优先级
- 欢迎使用Markdown编辑器
- 新的改变
- 功能快捷键
- 合理的创建标题，有助于目录的生成
- 如何改变文本的样式
- 插入链接与图片
- 如何插入一段漂亮的代码片
- 生成一个适合你的列表
- 创建一个表格
- 设定内容居中、居左、居右
- SmartyPants
- 创建一个自定义列表
- 如何创建一个注脚
- 注释也是必不可少的
- KaTeX数学公式
- 新的甘特图功能，丰富你的文章
- UML 图表
- FLowchart流程图
- 导出与导入
- 导出
- 导入
一、注释
注释: 就是对代码的解释，方便阅读，被注释的代码不执行
分类
- 单行注释
## 1.单行注释 以#号开头 ，右边的所有东西都被当做说明文字 ，程序不进行编译运行。
print('hello world')
- 多行注释
## 2.多行注释 三个单引号 或 三个双引号
'''
这是第一行
这是第二行
'''
注意
嵌套使用时，如果外面使用三个单引号，里面使用三个双引号，反之亦然。
'''
print('hello world')
"""
print('hello world, 嵌套使用')
"""
'''
注释具有一定的排错性
先注释一部分代码，然后执行另外一部分，看看是否报错，逐层缩小报错范围，找到最终错误点。
二、变量
可以改变的量,实际具体指的是内存中的一块存储空间
变量的声明
## 1
a = 100
b = 101
print(a)
print(b)
## 2
a,b = 200,201
## print(值1,值2,值3, ..... ) 一行打印所有变量
print(a , b)
## 3
a = b = 300
print(a, b)
变量的命名
- 字母数字下划线, 首字符不能为数字
- 严格区分大小写,且不能使用关键字
- 变量命名有意义,且不能使用中文哦
## 严格区分大小写
## 关键字 : 系统预设的相关属性和函数或者特殊意义的变量;
## 引入 模块(文件)
import keyword
## 模块.属性 (文件.变量)
print(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']
"""
## 系统预设的相关关键字不能被替换覆盖,不要使用该名字作为变量名;
"""
print = 100
print(1) ## 报错
"""
注意
- 起名字要见名知意
- 中文命名变量不会报错的,但是严禁使用
变量的交换
## 通用写法
tmp = a
a = b
b = tmp
print(a,b)
## python特有
a = 18
b = 19
a,b = b,a
print(a,b)
常量
永远不变的量(约定俗成:把每个字母都变成大写)
BIRTHDAY = "1010"
ID_CARD = 210205200010106688
三、数据类型分类
六大标准数据类型
Number 数字类型（int, float, bool, complex)
str 字符串类型
list 列表类型
tuple 元组类型
set 集合类型
dict 字典类型
Number 数字类型 分类：
int： 整数类型（正整数 0 负整数）
float： 浮点数类型（1普通小时 2科学计数法表示的小数 例如: a=3e-5 ## 3e-05）
bool: 布尔值类型（真 True 和 假False）
complex 负数类型（声明复数的2中方法）（复数用作与科学计算中，表示高精度的数据，科学家会使用）
2个内置方法 type 和 id
## type 获取值得类型
intvar=100
res = type(intvar)
print(res) ## <class 'int'>## id 获取值得地址
res = id(intvar)
print(res) ## 1926270160(用十进制表示的地址值)## 二进制整型
intvar = 0b110
## 八进制整型
intvar = 0o127
## 十六进制
intvar = 0xff ## 进制不区分大小写 0xFF## float 浮点型(小数)
## 表达方式1
floatvar = 3.6
print(floatvar , type(floatvar))
## 表达方式2 科学计数法
floatvar = 5.7e5 ## 小数点右移5 57000.0 10的5次幂
floatvar = 5.7e-2 ## 小数点左移2 0.057 10的-2次幂
print(floatvar , type(floatvar))## bool 布尔型 (True 真的, False 假的)
boolvar = True
boolvar = False
print(boolvar , type(boolvar)) ## bool## complex 复数类型
"""
3 + 4j
实数+虚数
实数: 3
虚数: 4j
j : 如果有一个数他的平方等于-1,那么这个数就是j , 科学家人员用,表达一个高精度的类型
"""
## 表达方式1
complexvar = 3 + 4j
complexvar = -3j
print(complexvar , type(complexvar))## 表达方法2
"""
complex(实数,虚数) => 复数
"""
res = complex(3,4)
print(res , type(res)) ## (3+4j) complex
自动类型转换
当2个不同类型的数据进行运算的时候，默认向更高精度转换
数据类型精度从低到高： bool int float complex
## bool + int
res = True + 100
print(res ,type(res)) ## 1 + 100 => 101## bool + float
res = True + 344.565 ## 1.0 + 344.565 => 345.565
print(res ,type(res)) ## bool + complex
res = True + 7 - 90j ## 1 + 0j + 7 - 90j => 8 - 90j
print(res ,type(res)) ## int + float
res = 5 + 7.88 ## 5.0 + 7.88 => 12.88
print(res ,type(res)) ## int + complex
res = 5 + 6 + 8j ## 5 + 0j 6 + 8j => 11 + 8j
print(res ,type(res)) ## float + complex
res = 5.66 + 9.1 -90j ## 5.66 + 0j + 9.1 -90j => 14.76-90j
print(res ,type(res)) ## 小数的精度损耗 (小数后面一般有时截取15~18位,但是不完全,存在精度损耗)
"""不要用小数作比较,不准"""
print(0.1 + 0.2 == 0.3) ## 0.0999999999999999 False
print(5.1 + 5.9 == 11.0)
## True
强制类型转换
## 1. Number 类型的强制转换 (int float complex bool)
## int 强制把数据变成整型
"""int float bool 纯数字字符串"""
var1 = 13
var2 = 5.67
var3 = True
var4 = "123456"
var5 = "123abc"
var6 = 3+5jres = int(var2) ## 5
res = int(var3) ## True => 1
res = int(False) ## False => 0
res = int(var4) ## 123456
## res = int(var5) ## ValueError
## res = int(var6) ## TypeError
print(res , type(res))## float 强制把数据变成小数
"""int float bool 纯数字字符串"""
res = float(var1) ## 13.0
res = float(var3) ## True => 1.0
res = float(False) ## False => 0.0
res = float(var4) ## 123456.0
print(res , type(res))## complex 强制把数据变成复数
"""int float bool 纯数字字符串 complex"""
res = complex(var1) ## (13+0j) 添加0j 表达复数
res = complex(var2) ## (5.67+0j)
res = complex(var3) ## True => 1+0j
res = complex(False) ## False => 0j
res = complex(var4) ## 123456+0j
print(res , type(res))## bool 强制把数据变成布尔型
"""布尔型可以强转一切数据类型"""
## 布尔型为假的十种情况
""" 0 , 0.0 , False , 0j , '' , [] , () ,set(), {}, None """
res = bool(None)
print(res , type(res))## 初始化变量时,不清楚用什么值,无脑写上None
"""None 代表空的,代表什么也没有,一般用于初始化变量"""
a =None
b =None"""
默认转换成当前数据类型的一个值
int() float() complex() bool()
"""
res = bool()
print(res , type(res))
容器类型分类：五个
str "hello"
list [1,2,3]
tuple (6,7,8)
set {"a", 1, 2}
dict {"a": 1, "b": 2}
字符串类型 str
## 字符串类型 str
"""
用引号引起来的就是字符串,单引号,双引号,三引号## 转义字符 \ + 字符(1) 可以将无意义的字符变得有意义(2) 可以将有意义的字符变得无意义\n : 换行
\r\n : 换行
\t : 缩进(水平制表符)
\r : 将\r后面的字符串拉到了当前行的行首
"""
## 1.单引号的字符串
strvar = '生活不止眼前的苟且'## 2.双引号的字符串
strvar = "还有诗和远方的田野"#### 转义字符
### a.可以将无意义的字符变得有意义
strvar = "还有诗和\n远方的田野"
### b.可以将有意义的字符变得无意义
strvar = "还有诗和\"远\"方的田野"## 3.三引号的字符串 (可以支持跨行效果)
strvar = '''
生活就像"醉"酒
表面上说'不'要
身体却很诚实
'''## 4.元字符串 r"字符串" 原型化输出字符串
strvar = "D:\nython32_python\tay02" ## 会转义
strvar = r"D:\nython32_python\tay02" ## 不会转义 ## 5.字符串的格式化
"""
%d 整型占位符
%f 浮点型占位符
%s 字符串占位符
语法形式:"字符串" % (值1,值2)
"""
## %d 整型占位符
strvar = "王同学昨天买了%d风油精,洗澡" % (2)
print(strvar)## %2d 占两位 (不够两位拿空格来补位) 原字符串具右
strvar = "王同学昨天买了%2d风油精,洗澡" % (2)
print(strvar)## %-2d 占两位 (不够两位拿空格来补位) 原字符串具左
strvar = "王同学昨天买了%-2d风油精,洗澡" % (2)
print(strvar)## %f 浮点型占位符
strvar = "赵同学一个月开%f工资" % (9.9)
print(strvar)## %.2f 保留小数点后面两位小数 (存在四舍五入的情况,默认保留六位小数)
strvar = "赵同学一个月开%.2f工资" % (9.178)
print(strvar)## %s 字符串占位符
strvar = "%s最喜欢在电影院尿尿" % ("赵同学")
print(strvar)## 综合案例
strvar = "%s在水里%s被发现了,罚款%.2f元,并且做了%d俯卧撑." % ("孟同学","拉屎",500.129,50000)
print(strvar)## 如果搞不清楚用什么占位符,可以无脑使用%s
strvar = "%s在水里%s被发现了,罚款%s元,并且做了%s俯卧撑." % ("孟同学 ","拉屎",500.129,50000)
print(strvar)
列表类型 list
特征: 可获取,可修改,有序
内置函数 len
len 获取容器类型数据中元素个数
## 1.定义普通列表
listvar = [98,6.9,True,12-90j,"hello"]
## 2.获取列表中的元素
### 正向索引 0 1 2 3 4
listvar = [98,6.9,True,12-90j,"hello"]
### 逆向索引 -5 -4 -3 -2 -1res = listvar[2]
## res = listvar[-3]
print(res)### 常规获取最后一个元素
length = len(listvar)
res = listvar[length-1]
print(res)## 简写
res = listvar[len(listvar)-1]
print(res)## python逆向索引的特点,瞬间得到列表中最后一个元素
print(listvar[-1])## 3.修改列表中的元素
listvar = [98,6.9,True,12-90j,"hello"]
listvar[3] = "大象"
print(listvar)
元组类型 tuple
特征: 可获取,不可修改,有序
## 1. 定义一个元组
tuplevar = ("梦好心","王伟","安晓东","孙坚")
print(tuplevar , type(tuplevar))## 2. 获取元组中的元素
## 正向索引 0 1 2 3
tuplevar = ("梦好心","王伟","安晓东","孙坚")
## 逆向索引 -4 -3 -2 -1print(tuplevar[2])
print(tuplevar[-2])## 修改元组中的元素 : 元组中的值不能修改
## tuplevar[0] = "萌不好心" error### 注意点
"""逗号才是区分是否是元组的标识符"""
tuplevar = (8.9,)
tuplevar = 8.1, ## 括号不写也可
print(tuplevar)
print(type(tuplevar))## 定义空元组
tuplevar = ()
print(type(tuplevar))字符串类型的索引取值
特征: 可获取,不可修改,有序
## #### 字符串类型
"""特征: 可获取,不可修改,有序"""
## 正向索引 0 1 2 3 4 5 6 7 8
strvar = "看你,我就心跳加速"
## 逆向索引 -9-8-7-6-5-4-3-2-1## 获取字符串中的元素
print(strvar[3])
print(strvar[-6])## 不能修改字符串中的元素
## strvar[3] = "你" TypeError print("<===============>")
strvar = "" ## 单纯定义一个字符串类型
print(strvar, type(strvar))
strvar = " " ## 字符串中含有3个空格字符
print(strvar[0], type(strvar))集合类型 set
特点: 无序,自动去重
支持运算： 交差并补
## 1.集合无序
setvar = {"巨石强森","史泰龙","施瓦辛格","hello"}
print(setvar , type(setvar))## 获取集合中的元素 不可以
## setvar[0] error## 修改集合中的元素 不可以
## setvar[2] = 111 error## 2.集合自动去重
setvar = {"巨石强森","史泰龙","施瓦辛格","hello","史泰龙","史泰龙","史泰龙"}
print(setvar , type(setvar))## 3.定义一个空集合
setvar = set()
print(setvar , type(setvar))字典 dict
键值对存储的数据,表面上有序,本质上无序
dictvar = {键1:值1, 键2:值2 , … }
3.6版本之前,完全无序,
3.6版本之后,存储的时候,保留了字典定义的字面顺序,在获取内存中数据时
重新按照字面顺序做了排序,所以看起来有序,实际上存储时还是无序
## 1.定义一个字典
dictvar = {"top":"the shy", "middle":"肉鸡"}
print(dictvar, type(dictvar))
## 2.获取字典中的值
res = dictvar["middle"]
print(res)
## 3.修改字典中的值
dictvar["top"] = "the xboy"
print(dictvar)
## 4.定义空字典
dictvar = {}
print(dictvar, type(dictvar))
## #### 3.set 和 dict 的注意点
"""
字典的键 和 集合的值 有数据类型上的要求:
(允许的类型范围)不可变的类型: Number(int float complex bool) str tuple
(不允许的类型)可变的类型 : list set dict哈希算法的提出目的是让数据尽量均匀的在内存当中分配,以减少哈希碰撞,提升存储分配的效率;
哈希算法一定是无序的散列,所以集合 和 字典都是无序字典的 键有要求,值没要求
字典的值可以任意换掉,但是键不可以.
"""
## 允许的类型范围
dictvar = {1:"abc",4.89:111,False:333,3+90j:666,"王文":"没毛病",(1,2,3,4,5,6):9999}
print(dictvar) ## 没报错
print(dictvar[(1,2,3,4,5,6)])
## dictvar = {[1,2,3]:123} TypeError: unhashable type: 'list'## 允许的类型范围
setvar = {1,"a",4.56,9+3j,False,(1,2,3)}
## setvar = {1,"a",4.56,9+3j,False,(1,2,3),{"a","b"}} error
print(setvar)变量的缓存机制
意义： 无论是变量缓存机制还是小数据池的驻留机制，都是为了节省内存空间，提升代码效率
## #### 在同一文件中,变量的缓存机制 (仅仅针对python3.6版本负责)
## 1.对于整型而言，-5~正无穷范围内的相同值 id一致
var1 = 5
var2 = 5
var1 = -100
var2 = -100
print(id(var1) , id(var2) )## 2.对于浮点数而言，非负数范围内的相同值 id一致
var1 = 4.67
var2 = 4.67
var1 = -4.67
var2 = -4.67
print(id(var1) , id(var2) )## 3.布尔值而言,值相同情况下，id一致
var1 = True
var2 = True
print(id(var1) , id(var2) )## 4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
var1 = 4 +5j
var2 = 4 +5j
## 5j 情况下例外
var1 = 5j
var2 = 5j
var1 = -5j
var2 = -5j
print(id(var1) ,id(var2)) ## 虚数地址值一样## -->容器类型部分
## 5.字符串 和 空元组 相同的情况下，地址相同
var1 = "你"
var2 = "你"
var1 = ()
var2 = ()
print(id(var1) ,id(var2))
## 6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
var1 = (1,2)
var2 = (1,2)
var1 = [1,2,3]
var2 = [1,2,3]
print(id(var1) ,id(var2))
from sys import intern
a = intern("aaaa哈哈哈bbb***123" * 10)
b = intern("aaaa哈哈哈bbb***123" * 10)
print(id(a), id( b))
## 可以指定任意字符串加入到小数据池中，无论声明多少个变量，只要此值相等，就都指向同一个地址空间
容器类型的强制类型转换
内置方法 repr （元字符串）
不转义字符原型化输出字符串
strvar = "hello"
listvar = [1,2,3]
tunplevar = (4,5,6)
setvar = {"name", "age", "gender"}
dictvar = {"name": "hmm", "age": 18, "gender": False}
numvar = 90
boolvar = True## str 强制转换成字符串
"""所有的数据类型都可以转换, 在当前的数据类型两边套上引号"""
res = str(listvar)
print(res ,type(res)) ## [1, 2]
## repr 不转义字符原型化输出字符串
print(repr(res)) ## '[1, 2]'## list 强制转换成列表
"""
如果是字符串:把字符串中的每个元素单独拿出来,作为列表中的新元素
如果是字典: 只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型的两边换上[]括号
"""
res = list(strvar) ## ['h', 'e', 'l', 'l', 'o']
res = list(tunplevar) ## [4, 5, 6]
res = list(setvar) ## ['gender', 'age', 'name']
## 字典: 只获取字典得键,忽略掉值
res = list(dictvar) ## ['name', 'age', 'gender']
## res = list(numvar) ## TypeError 'int' object is not iterable 只能是容器间的互转
print(res ,type(res))## tuple 强制转换成元组
"""
如果是字符串:把字符串中的每个元素单独拿出来,作为元组中的新元素
如果是字典: 只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上()括号
"""
res = tuple(strvar)
res = tuple(tunplevar)
res = tuple(setvar)
res = tuple(dictvar)
print(res ,type(res))## set 强制转换成集合，（自动去掉重复的值）
"""
如果是字符串:把字符串中的每个元素单独拿出来,作为集合中的新元素
如果是字典: 只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上{}括号
"""
res = set(strvar)
res = set(tunplevar)
res = set(dictvar)
print(res ,type(res))
## 多滤掉列表中所有重复元素;
lst = [1,222,3,3,3,44,88,999,77,88,1]
res = set(lst)
print(res)
## 在把当前的集合转换成原来的列表
res2 = list(res)
print(res2)"""
默认不加任何值,转换成该数据类型的空值
str() list() tuple() set() dict()
"""
res = dict()
print(res, type(res))## #### dict 字典类型的强制转换
"""
要求: 必须是等长的二级容器,并且里面的元素个数是2个;
## 等长的二级容器
## 外面是容器,里面的元素也是容器,且元素个数相同
lst = [(1,2,3),[4,5,6],{7,8,9}]
外层是列表,元组,集合 , 里层是列表或者元组的等长二级容器 => 字典;
"""## 1.外层是列表,里层是列表或者元组
lst = [ ["a",1] , ("b",2) ]
dic = dict(lst)
print(dic , type(dic)) ## {'a': 1, 'b': 2} <class 'dict'>## 2.外层是元组,里层是列表或者元组
tup = ( ["a",1] , ("b",2) )
dic = dict(lst)
print(dic , type(dic))## 3.外层是集合,里层是元组（里层不能是列表）
setvar = { ("a",1) , ("b",2) }
dic = dict(setvar)
print(dic , type(dic))## 例外1:外层是列表/元组,里层放集合
"""可以实现,不推荐使用,因为达不到想要的目的,集合无序,不推荐使用"""
lst = [ ["a",1] , {"b","250"} ]
dic = dict(lst)
print(dic)## 例外2:外层是列表/元组,里层放字符串
""" 字符串长度只能是2位,有极大的局限性,不推荐使用"""
lst = ["a1","b2"]
## lst = ["a11","b22"] ValueError
## dic = dict(lst)
## print(dic)类型判断
## #### 判断类型 isinstance
"""
## 使用方法一
isinstance(数据,类型)
如果该数据是这个类型,返回True 反之,返回False
类型: int float complex bool str list tuple set dict## 使用方法二
isinstance( 数据, (类型1,类型2,类型3...) )
如果该数据在所对应的类型元组当中,返回True,反之,返回False
"""## 使用方法一
n = 123
res = isinstance(n , int)
print(res)n = [1,2,3]
res = isinstance(n , list)
res = isinstance(n , tuple)
print(res)## 使用方法二
n = "1233"
res = isinstance(n , (list , tuple ,set , str) )
print(res)n = {"a":1}
res = isinstance(n , (list , tuple ,set , str) )
print(res)四、运算符
分类
(1)算数运算符: + - * / // % **
(2)比较运算符: > < >= <= == !=
(3)赋值运算符: = += -= *= /= //= %= **=
(4)成员运算符: in 和 not in (针对于容器型数据)
(5)身份运算符: is 和 is not (检测两个数据在内存当中是否是同一个值)
(6)逻辑运算符: and or not
(7)位运算符: & | ~ ^ << >>
算数运算符
## #### (1)算数运算符: + - * / // % **## +
var1 = 7
var2 = 90
res = var1 + var2
print(res)## -
var1 = 7
var2 = 90
res = var1 - var2
print(res)## *
var1 = 7
var2 = 10
res = var1 * var2
print(res)## / 结果永远为小数
var1 = 10
var2 = 5
res = var1 / var2
print(res , type(res)) ## 2.0## // 地板除
"""被除数 ➗ 除数 = 商"""
"""注意点:如果被除数或者除数是小数,那么得到正常结果之后,数值后面带上.0变成小数"""
var1 = 10.0
var2 = 3.0
## var2 = 3.0
res = var1 // var2
print(res) ## 都为整数时，结果为整数## % 取余
var1 = 7
var2 = 4
res = var1 % var2 ## 3
res = -7 % 4 ## -3 + 4 = 1 （没带负数的余数为3，被除数为负数，则正常的余数改为负数，加上除数）
res = 7 % -4 ## 3 + (-4) = -1
res = -7 % -4 ## -3 (被除数和除数都是负的,正常结果加负号)
res = 81 % 7 ## 4
res = 81 % -7 ## -3
res = -81 % 7 ## 3
res = -81 % -7 ## -4
print(res)## ** 幂运算
res = 2 ** 3
print(res)比较运算符
## (2)比较运算符: > < >= <= == !=
"""比较运算符的结果要么是True , 要么是False 只有两个值"""
res = 10 > 5
res = 10 >= 10
## ==这个符号是在做比较,比较==两边的数值是否一样
res = 5 == 9
res = 5 != 9
print(res)
赋值运算符
## #### (3)赋值运算符: = += -= *= /= //= %= **=
## = 赋值运算符 将右侧的值赋值给左侧变量
a = 5 <= 3
print(a)var1 = 10
var2 = 5
## +=
"""var1 = var1 + var2"""
## var1 += var2
## print(var1)## -=
"""var1 = var1 - var2"""
## var1 -= var2
## print(var1)## %=
"""var1 = var1 % var2"""
var1 %= var2
print(var1)成员运算符 in
## (4)成员运算符: in 和 not in (针对于容器型数据)
"""字符串判断时,必须是连续的片段"""
strvar = "今天天气要下雨,赶紧回家收衣服"res = "今" in strvar
res = "天气" in strvar
res = "赶回" in strvar
print(res)## 针对于列表,元组,集合
container = ["赵沈阳","赵万里","赵世超"]
container = ("赵沈阳","赵万里","赵世超")
container = {"赵沈阳","赵万里","赵世超"}
## res = "赵沈阳" in container
## res = "赵万里" not in container
res = "赵世超1223232" not in container
print(res)## 针对于字典 (判断的是字典的键,不是值)
container = {"zsy":"赵沈阳","zwl":"赵万里","zsc":"赵世超"}
res = "赵沈阳" in container ## False
res = "zsy" in container
print(res)身份运算符
## (5)身份运算符 is 和 is not (检测两个数据在内存当中是否是同一个值) ## 整型 -5~正无穷
var1 = 100
var2 = 100
print(var1 is var2) ## True## 浮点型 非负数
var1 = -9.1
var2 = -9.1
print(var1 is var2) ## False## bool 相同即可
var1 = True
var2 = True
print(var1 is var2) ## True## complex 在实数+虚数不相同 (只有虚数的情况下例外)
var1 = 6-8j
var2 = 6-8j
var1 = -10j
var2 = -10j
print(var1 is var2)## 容器: 相同字符串 , 空元组相同即可 剩下的所有容器都不相同
container1 = ()
container2 = ()
print(container1 is not container2)container1 = "你"
container2 = "你"
print(container1 is not container2)container1 = [1,23,3]
container2 = [1,23,3]
print(container1 is not container2)逻辑运算符
## (6)逻辑运算符: and or not
## and 逻辑与
"""全真则真,一假则假"""
res = True and True ## True
res = True and False ## False
res = False and True ## False
res = False and False ## False
print(res)## or 逻辑或
"""一真则真,全假则假"""
res = True or True ## True
res = False or True ## True
res = True or False ## True
res = False or False ## False
print(res)## not 逻辑非
res = not True
res = not False
print(res)## 逻辑短路
"""
无论后面的表达式是True 还是False 都已经无法改变最后的结果,那么直接短路,后面的代码不执行;
(1) True or print("程序执行了 ~ 1111")
(2) False and print("程序执行了 ~ 2222")True or print("程序执行了 ~ 1111")
True or True => True
True or False => True
False and print("程序执行了 ~ 2222")
False and True => False
False and False => False
""""""
计算规律:先脑补计算当前表达式的布尔值是True还是False如果出现了 True or 表达式 或者 False and 表达式的情况,直接返回前者,后面代码不执行如果没有出现短路效果,直接返回后者
"""res = 5 and 6 ## 6
"""
True and True =>True
True and False => False
"""
res = 5 or 6 ## 5
res = 0 and 999
res = 0 or "abc"
print(res)## 逻辑运算符的优先级
""" 优先级从高到低: () > not > and > or """
res = 5 or 6 and 7 ## 5 or 7 => 5
res = (5 or 6) and 7 ## 5 and 7
res = not (5 or 6) and 7 ## not 5 and 7 => False and 7 => False
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
"""
not (False or False) => True
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
res = True or False and True or True and True
res = True or False or True
res = True or True => True
"""
print(res)位运算符
## #### (7)位运算符: & | ^ << >> ~var1 = 19
var2 = 15## & 按位与
res = var1 & var2
"""
000 ... 10011
000 ... 01111
000 ... 00011 => 3
"""
print(res)## | 按位或
res = var1 | var2
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""
print(res)## ^ 按位异或
"""两个值不相同=>True 反之返回False"""
res = var1 ^ var2
"""
000 ... 10011
000 ... 01111
000 ... 11100
"""
print(res)## << 左移 (相当于乘法)
"""5乘以2的n次幂"""
res = 5 << 1 ## 10
res = 5 << 2 ## 20
res = 5 << 3 ## 40
print(res)"""
000 ... 101 => 5
000 .. 1010 => 10
000 ..10100 => 20
000 .101000 => 40
"""## >> 右移 (相当于除法)
"""5地板除2的n次幂"""
res = 5 >> 1 ## 2
res = 5 >> 2 ## 1
res = 5 >> 3 ## 0
"""
000 ... 101
000 ... 010 => 2
000 ... 001 => 1
000 ... 000 => 0
"""
print(res)## ~ 按位非 (针对于补码进行操作,按位取反,包含每一位)
""" -(n+1) """
## res = ~22
res = ~19
print(res)
"""
原码:000 ... 10011
反码:000 ... 10011
补码:000 ... 10011补码: 000 ... 10011
按位非: 111 ... 01100给你补码->原码
补码:111 ... 01100
反码:100 ... 10011
原码:100 ... 10100 => -20
"""res = ~-19
print(res)
"""
原码:100 ... 10011
反码:111 ... 01100
补码:111 ... 01101补码: 111 ... 01101
按位非: 000 ... 10010给你补码->原码 (因为是整数 ,原反补相同)
000 ... 10010 => 19
""""""
总结:个别运算符:运算符优先级最高的: **运算符优先级最低的: =()可以提升优先级一元运算符 > 二元运算符 (优先级)一元运算符 : 同一时间,操作一个值 ~ - 二元运算符 : 同一时间,操作一个值 + - * / ....同一种类运算符:算数运算符 : 乘除 > 加减逻辑运算符 : () > not > and > or 位运算符 : ( << >> ) > & > ^ > |整体排序: 算位比身成逻算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符赋值运算符用来做收尾
"""运算符的优先级
欢迎使用Markdown编辑器
你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。
新的改变
我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：
- 全新的界面设计 ，将会带来全新的写作体验；
- 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
- 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
- 全新的 KaTeX数学公式 语法；
- 增加了支持甘特图的mermaid语法1 功能；
- 增加了 多屏幕编辑 Markdown文章功能；
- 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
- 增加了 检查列表 功能。
功能快捷键
撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G
查找：Ctrl/Command + F
替换：Ctrl/Command + G
合理的创建标题，有助于目录的生成
直接输入1次#，并按下space后，将生成1级标题。
输入2次#，并按下space后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。
如何改变文本的样式
强调文本 强调文本
加粗文本 加粗文本
标记文本
删除文本
引用文本
H2O is是液体。
210 运算结果是 1024.
插入链接与图片
链接: link.
图片:
带尺寸的图片:
居中的图片:
居中并且带尺寸的图片:
当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。
如何插入一段漂亮的代码片
去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.
// An highlighted block
var foo = 'bar';
生成一个适合你的列表
- 项目
- 项目
- 项目
- 项目
- 项目1
- 项目2
- 项目3
- 计划任务
- 完成任务
创建一个表格
一个简单的表格是这么创建的：
| 项目 | Value |
|---|---|
| 电脑 | $1600 |
| 手机 | $12 |
| 导管 | $1 |
设定内容居中、居左、居右
使用:---------:居中
使用:----------居左
使用----------:居右
| 第一列 | 第二列 | 第三列 |
|---|---|---|
| 第一列文本居中 | 第二列文本居右 | 第三列文本居左 |
SmartyPants
SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：
| TYPE | ASCII | HTML |
|---|---|---|
| Single backticks | 'Isn't this fun?' | ‘Isn’t this fun?’ |
| Quotes | "Isn't this fun?" | “Isn’t this fun?” |
| Dashes | -- is en-dash, --- is em-dash | – is en-dash, — is em-dash |
创建一个自定义列表
- Markdown
- Text-to- HTML conversion tool Authors
- John
- Luke
如何创建一个注脚
一个具有注脚的文本。2
注释也是必不可少的
Markdown将文本转换为 HTML。
KaTeX数学公式
您可以使用渲染LaTeX数学表达式 KaTeX:
Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n−1)!∀n∈N 是通过欧拉积分
Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞tz−1e−tdt.
你可以找到更多关于的信息 LaTeX 数学表达式here.
新的甘特图功能，丰富你的文章
- 关于 甘特图 语法，参考 这儿,
UML 图表
可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：
这将产生一个流程图。:
- 关于 Mermaid 语法，参考 这儿,
FLowchart流程图
我们依旧会支持flowchart的流程图：
- 关于 Flowchart流程图 语法，参考 这儿.
导出与导入
导出
如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。
导入
如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。
mermaid语法说明 ↩︎
注脚的解释 ↩︎
