文章目录

  • python
    • 最重要的是缩进
    • 变量，字符串，原始字符串，长字符串
    • 条件分支、while循环
    • python逻辑运算符
    • 数字类型
      • int
      • foalt
      • 复数
    • 数值运算
    • 布尔类型
    • 运算优先级
    • 流程图
    • 思维导图
    • 分支和循环
      • 分支结构嵌套
    • for
    • 列表
    • 浅拷贝和深拷贝
    • 列表推导式（用的c语言进行的）
    • KISS原则
    • 元组tuple
    • 字符串
    • 序列
      • is is not
      • in not in
      • del
      • 可迭代对象和迭代器
    • 字典
      • 增
      • 改
      • 删
      • 查
      • 视图对象：
      • 嵌套
      • 字典推导式
    • 集合
      • 建立
      • frozenset 不可变集合
        • 删除：
      • 可哈希

python

最重要的是缩进

变量，字符串，原始字符串，长字符串

  • （如无必要，勿增实体）
  • 里面变量不能以数字开头
  • 单引号、双引号、三引号
  • 转义字符都是以反斜杠开头

  • \路径里面的双斜杠，就是用反斜杠来转义反斜杠！

  • 在字符串前面加一个原始字符r，表示字符串后的反斜杠都是字符，而不是转义字符

  • 字符串最后是反斜杠，说明表示未完待续，程序不会执行，可以继续写

  • 字符串也可以作乘法输出

条件分支、while循环

  • int（）
  • if 条件：
  • else：记住后面都有冒号哦！
  • is 、is not 判断两个对象的id是否相等的
  • Python3 中，一行可以书写多个语句=》；
  • 也可以多行写一个语句，用反斜杠就可以 \
  • while_条件：
  •  语句

python逻辑运算符

  • and 从左到右计算表达式,若所有的都为真,则返回最后一个值,若存在假,返回第一个假值.同时也是与的逻辑作用 遇假出假
  • or 从左到右计算表达式,只要遇到真值就返回那个真是,如果表达式结束依旧没有遇到真值,就返回最后一个假值.同时也是或的逻辑作用 遇真出真
  • 以上也叫做短路逻辑（short-circuit logic）
  • not 取反，非逻辑作用
  • (10 < cost) and (cost < 50)等价于 10 < cost < 50
  • random.getstate() random.setstate

数字类型

int

python里整除了，最后结果还是以浮点数形式存在

foalt

  • python中小数是以浮点数形式存放的

  • 精确计算浮点数

  • decimal.Decimal（）实例对象

  • 比较的时候还是要用同一对象进行比较，不能用0.3直接和decimal对象比较，那是不同对象的，会报错。

  • python科学计数法，e表示10的幂次方

  • 将数字转换为科学计数法
    num = 123456789
    print(“{:.2e}”.format(num)) # 输出为1.23e+08

    那个{：.xe}x是表示小数点后几位数字

复数

  • python是向下取整，int（5.5）=5
  • 取变量类型用instance（）、type（）

数值运算

  • //地板除
    – [ ] 用int转换小数字符串的时候，会截断
  • pow （x,y,z） y可以为负数，就做log函数，还有z是求余的运算。

布尔类型

  • 值为false
  • 可以这样理解，bool类型是特殊的整数类型
  • python所有对象都能进行真值测试

运算优先级

  • 当学生只能硬记，由上至下，优先级越高！

流程图

思维导图

分支和循环

  • 条件表达式
  • 用一个小括号来把代码封起来，等价于\实现多行代码连续输入。

分支结构嵌套

  • while break 跳出循环体

  • continue 跳出本次循环，回到循环体

  • while else 语句：当循环完整结束后会执行 else

  • break和continue都是作用于最小循环

for

  • for in中的可迭代对象
  • range
    是生成一个数字序列，其参数必须是整型。

列表

  • 注意最后的，还可以倒序输出。
  • 增 ：append（）、 extend（）
  • 也可以使用切片的方法去做
    和extend的原理一样
  • insert（ x，y） x插入的位置，y是插入的元素
  • 删除： remove（）但是有多个匹配的元素，只会删除第一个，如果没有匹配到，就会报错。
  • pop（） 删除 某个位置的元素
  • clear（）清空
  • 列表元素的替换：
  • 列表排序：sort（）从小到大排序

    或者在sort（reverse=True）直接在sort里翻转
  • 列表反转：reverse（）
  • index（） 索引 index（a,b,c） a是元素内容、bc分别表示起始位置
    – [ ] 可以通过该方法替换未知索引的内容
  • count（） 计算列表里有多少该元素
  • copy（）浅拷贝
  • 负数索引表示从数组的末尾开始往前数的元素
  • 列表 加法 乘法
  • 嵌套列表
  • 嵌套列表输出
  • 只给一个下标索引，给出的是以行为单位的整个列表
  • 初始化列表
  • is判断两个变量是不是指向的同一对象。
  • 若字符串是相同，则两个对象是指向的同一对象；而列表不是。

  • 为什么不能用B=[ [ 0 ] * 3 ] *3来初始化列表
    如下图：
  • 在python中，变量不是盒子，是引用
  • 我们要真正获得两个独立的列表，就需要用到copy（）或者切片

在C++中类似，不能对数组进行直接复制，拷贝，只能通过for循环，对数组中每一个元素逐个进行复制。

浅拷贝和深拷贝

  • 在面对多维列表的时候，在使用copy就不行了，因为浅拷贝只是对外围数据进行拷贝，对内层数据还是以引用形式存在的。

  • copy模块 import copy

  • copy.deepcopy（）深拷贝

  • copy.copy（）浅拷贝
    python虚拟机 pvm

列表推导式（用的c语言进行的）

  • 结果是一个列表
  • 其执行顺序为 先执行for 的迭代 ，然后再执行，for后判断语句。
  • 嵌套的列表推到式
  • 可以用嵌套的列表推导式来表示笛卡尔乘积，每个for后面都可以加一个if来进行条件筛选

KISS原则

要保证代码简洁好看，不介意多行列表嵌套式，容易看不懂

元组tuple

不可逆的、圆括号、也可以不带括号、也支持切片操作

  • count、index（）

  • 支持拷贝

  • 支持嵌套


    生成一个元素的元组：x =

  • 打包和解包:一堆数据生成一个元组称为元组的打包，用一个元组对几个变量进行赋值，称为解包。打包和解包用于所有序列。注意解包的时候，需要左右两边的变量数量要一致。

  • 除非用以下这个方式：


  • _：表示匿名变量
    python中多重赋值就是这样的来的。

元组中的元素是不可变的，但是元组中的元素如果指向的是可变的元素，那就可以改变。如下：

字符串

  • 用切片来实现回文数的查找

  • 字符串里的方法：

    capitalize（）将字符串首字母大写
    title（）各单词首字母大写
    swapcase（）将原字符串大小写翻转
    upper（）将所有字母都大写
    lower（）将所有字母都小写
    casefold（）小写，并且可以处理其他语言

    center（w）w>字符串长度则，将其居中。小于则直接输出。
    ljust左对齐
    rjust右对齐
    zfill（）字符串前面补0，不是单纯的补，如果字符串前面有符号，在前面也会有符号站位

    count（a，b，c）bc分别是指定的查找位置参数
    find（）rfind（）从左往右、从右往左找
    index（）找不到就抛出异常

  • 使用空格来替换制表符，返回一个新的字符串
  • replace（old，new，count==-1）指定新字符串替换旧字符串，count默认为-1，即为替换全部

    配合str.maketrans()使用，相当于是在里面生成了一个转换规则。
    依照这个转化规则执行：

    还可以再加一个参数，将指定的字符串忽略掉

序列

** + * **
在python中，每一个对象都有三个属性：唯一标志、类型、值。
id（）返回一个代表指定对象的唯一标识的整数值
对于不可变的序列类型，使用增量赋值的时候，其唯一标志就会改变。

is is not

判断对象是否是同一对象

in not in

判断对象是否包含在序列中

del

删除指定对象
可以删除可变序列中的指定元素

记住清空内容和清空这个序列对象的区别哦！

可迭代对象直接转为列表
min（）max（）输出可迭代对象的最小和最大值，如果是字符串，那就是比较各个字符的编码值，大写字母的编码值是在小写字母编码之前的。
遇到空对象，就需要设置default的值
len（）函数有个问题是有最大值上限：2*63-1的长度
sum（x,z）z是指定参数 从z开始相加
sorted(x,reverse,key) 返回的是新的序列 key参数是排序的方式
比如key=len

t.sort是对整个序列进行排序，对每个元素先执行len（），求出字符串长度，然后由长度从大到小排序。
reverse() 是返回的迭代器，可以在reverse（）的基础上，在外加一个list（）就可以了

all()判断某个序列中是否所有元素都为真
any()判断某个序列中是否存在一个元素为真
**enumerate（a,b）**返回一个二元组，b是二元组索引下标起始位置
zip（）
相同长度的序列进行组合

当面对相同不同长度的序列时，取最小值的那个，类似木桶原理；
如果要取最大值的，导入itertools模块；

**map（x,y,z）**x是操作，y，z分别是两个序列，对y，z序列中每对元素进行x操作；比如：

还是执行的同样的木桶原理，按序列长度最小值来确定；返回的还是迭代器，所以要用list（）进行转换

** filter** 过滤器


第一个参数用于过滤的函数，第二是序列，只有判断结果为true才会输出。

可迭代对象和迭代器

一个迭代器肯定是一个可迭代对象，最大的区别就是可迭代对象是可以重复使用的，而迭代器是一次性的；
返回迭代器对象：reversed（）、enumerate（）、zip（）

iter（x）能够返回一个以x的数据的迭代器。其类型是list_iterator。
next（）对迭代器进行迭代；

当其中没有元素后，就会抛出异常。
也可以添加第二个参数，当next（）掏空迭代器后，就抛出参数

字典

通过指定一个不存在的键，就可以创建一个新的键值对
键是不能重复的，是与序列的本质区别

创建字典的方法：

  1. { }
  2. dict（）不能对键的关键字进行加引号
  3. dict（[k,v],[k,v],[k,v]…）里面使用列表
  4. dict（{ }）
  5. dict（混合）
  6. 使用zip函数，因为zip函数返回的是一个迭代器

增

fromkeys（）：创建后续以第一个参数为键，第二个参数为所有相同的值的字典。

改

d[‘x’] = “ y”
update（）可以直接传入一个字典，对原字典进行覆盖

删

pop（key[,default]）返回的是指定的键和值

default是返回一个不存在的键的默认值。
popitem（）弹出最后加入的键值对，在3.7版本之前，字典里的键值对的顺序是没有保证的，而3.7版本之后，字典里面的键值对有了先后加入的顺序
del（）函数也能完成删除操作
clear（）也可以进行清空操作

查

get(x,y) y是当找不到x键的时候返回的值
setdefault（x,y）当字典中存在x键的时候，返回对应的值，但是如果不存在x的键，就返回y值，并且在原有字典中添加x->y键值对

视图对象：


dict.keys dict.values dict.items

len（d）返回d字典键值对的数量
in
not in
list（d）得到字典中所有键构成的列表
iter（d）得到由字典的键构成的迭代器
reversed（）对字典的键进行反转，适用于3.8以后的版本

嵌套

字典也是可以进行嵌套的；
嵌套不仅可以嵌套字典类型、还可以嵌套列表

字典推导式

键值互换：

字符串生成字典：

推导式两个for循环，如果和列表一样的话，就应该生成一个3*3的嵌套列表，但是在字典中，键是唯一的，因此只保留最后一个每次只保留最后一个循环的键值对，1>6;3>6;5>6;

集合

集合中的元素都是独一无二的，并且也是无序的

建立

  1. {}
  2. 集合推导式：
  3. set（）类型构造器
    会生成一个无序的集合，不能使用下标进行访问
    但是可以使用in 或者 not in判断某个元素是否在里面

结合len（），可以对一个列表判断其中元素是否唯一：
len（s） == len(set(s))
如果一个列表的长度和他转化为集合的长度是一样的，那么就说明其中每个元素都是唯一的
s.copy() 浅拷贝
s.isdisjoint()判断两个集合之间是否有交集，有交集则返回False
issubset（）判断一个集合是否是另一个集合的子集
issuperset()判断一个集合是否是另一个集合的超集

并、交、差（以下三个可以有多个参数）
union()返回一个新的并集
intersection（）返回两个集合的交集
difference（）返回存在调用该函数的集合且不存在（）里面的集合

对称差集：

sysmmetric_difference() 只能单参数

\ > <都可以用于集合包含关系的判断，
| 并集
&交集
-差集
^对称差集
需要注意的，使用上述方法，只要是可迭代对象就可以使用，但是对于运算符而言，两边只能是集合

frozenset 不可变集合

update（*others）表示支持多个参数，如果是other就只能一个参数。
更新集合。

以上的函数，当集合调用的时候，会对调用的集合进行改变
add（）：如果插入一个字符串的话，是将整个字符串作为一个整体插入到集合中；而update插入字符串，是将字符串拆开成为几个字符分别插入进去。

删除：

remove()：当删除一个不存在的元素，则会抛出异常
discard（）：当删除一个不存在的元素，静默处理
pop（）随机弹出一个元素
clear（）清空

可哈希

只有可哈希的值才能作为字典的键或者集合的元素，判断一个元素能不能哈希： hash（x），整数的哈希值就为它本身，如果两个数据相等，只是不同的数据类型 比如1和1.0，他们的哈希值也是相等的。

列表是可变的，因此它就不能哈希；元祖是不可变的，它就可以哈希。集合也是不可哈希的。因此直接进行集合的嵌套是不行的，因为集合中的元素和字典中的键是一样的，都是应该能够哈希的。

如果要实现一个集合的嵌套，就在用frozen（）生成子集合，在放入需要嵌套的母集合中去，就实现了集合的嵌套。

集合的查找效率是比列表快很多的，背后是以后散列表的存在，但是牺牲了海量的存储空间来实现的，因此就符合了空间换时间、时间换空间。

方法 含义
capitalize() 把字符串的第一个字符改为大写
casefold() 把整个字符串的所有字符改为小写
center(width) 将字符串居中，并使用空格填充至长度width的新字符串
count(sub[,start[,end]]) 返回sub在字符串里边出现的次数，start和end参数表示范围，可选
encode(encoding=‘utf-8’, errors=‘strict’) 以encoding指定的编码格式对字符串进行编码
endswith(sub[,start[,end]]) 检查字符串是否以sub子字符串结束，如果是返回True，否则返回False。start和end参数表示范围，可选
expandtabs([tabsize=8]) 把字符串中的tab符号（\t）转换为空格，如不指定参数，默认的空格数是tabsize=8
find(sub[,start[,end]]) 检测sub是否包含在字符串中，如果有则返回索引值，否则返回-1，start和end参数表示范围，可选
index(sub[,start[,end]]) 跟find方法一样，不过如果sub不在string中会产生一个异常
isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False
isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回True，否则返回False
isdecimal() 如果字符串只包含十进制数字则返回True，否则返回False
isdigit() 如果字符串只包含数字则返回True，否则返回False
islower() 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回True，否则返回False
isnumeric() 如果字符串中只包含数字字符，则返回True，否则返回False
isspace() 如果字符串中只包含空格，则返回True，否则返回False
istitle() 如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回True，否则返回False
isupper() 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回True，否则返回False
join(sub) 以字符串作为分隔符，插入到sub中所有的字符之间。>>> str5 = ‘Fishc’ >>> str5.join(‘12345’) ‘1Fishc2Fishc3Fishc4Fishc5’
ljust(width) 返回一个左对齐的字符串，并使用空格填充至长度为width的新字符串
lower() 转换字符串中所有大写字符为小写
lstrip() 去掉字符串左边的所有空格
partition(sub) 找到子字符串sub，把字符串分成一个3元组（pre_sub,sub,fol_sub），如果字符串中不包含sub则返回(‘原字符串’, ’’, ’’)
replace(old,new[,count]) 把字符串中的old子字符串替换成new子字符串，如果count指定，则替换不超过count次。>>> str7 = ‘i love fishdm and seven’ >>> str7.replace(‘e’,‘E’,2) 输出’i lovE fishdm and sEven’
rfind(sub[,start[,end]]) 类似于find()方法，不过是从右边开始查找
rindex(sub[,start[,end]]) 类似于index()方法，不过是从右边开始
rjust(width) 返回一个右对齐的字符串，并使用空格填充至长度为width的新字符串
rpartition(sub) 类似于partition()方法，不过是从右边开始查找
rstrip() 删除字符串末尾的空格
split(sep=None, maxsplit=-1) 不带参数默认是以空格为分隔符切片字符串，如果maxsplit参数有设置，则仅分隔maxsplit个子字符串，返回切片后的子字符串拼接的列表。>>> str7.split () [‘i’, ‘love’, ‘fishdm’, ‘and’, ‘seven’]
splitlines(([keepends])) 按照‘\n’分隔，返回一个包含各行作为元素的列表，如果keepends参数指定，则返回前keepends行
startswith(prefix[,start[,end]]) 检查字符串是否以prefix开头，是则返回True，否则返回False。start和end参数可以指定范围检查，可选
strip([chars]) 删除字符串前边和后边所有的空格，chars参数可以定制删除的字符，可选
swapcase() 翻转字符串中的大小写
title() 返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串
translate(table) 根据table的规则（可以由str.maketrans(‘a’,‘b’)定制）转换字符串中的字符。>>> str8 = ‘aaasss sssaaa’ >>> str8.translate(str.maketrans(‘s’,‘b’)) ‘aaabbb bbbaaa’
upper() 转换字符串中的所有小写字符为大写
zfill(width) 返回长度为width的字符串，原字符串右对齐，前边用0填充