Python 基础代码

基本函数：

print(value, end, sep)

输出

end="\n"：结束符

sep=" "：分隔符

input(str)

输出str，读取输入的字符串

eval(str)

字符串 => 变量

help(arg)

查看帮助

id(var)

返回变量标识

type(obj).__name__

返回变量的类型

dir(mod | obj)

返回内置变量列表

数值 *** 作：

int(str, base)

将对应进制的字符串转化成int

abs(num)

返回数字绝对值

divmod(a, b)

返回商、余数 (效率低下)

round(float, decimals)

改变浮点数精度

bin(num)

返回

字符串

2进制，前缀0b

oct(num)

8进制，前缀0o

hex(num)

16进制，前缀0x

complex(real, imag)

实例化复数

COM.real

返回复数

实部

COM.imag

虚部

COM.conjugate()

对应共轭复数

基本语句：

del VAR

删除变量

pass

不做任何动作

@funtion

将下一行的函数

作为参数

@type()

传入__init__()

ASCII码：

48 - 57：0 - 9

ord(char)

字符 -> ASCII码

65 - 90：A - Z

chr(ascii)

ASCII码 -> 字符

97 - 122：a - z

转义序列：

振铃字符\a

换行字符\n

垂直制表符\v

退格字符\b

水平制表符 (以4个字符为一列)\t

回车字符\r

使用\"和\'和\和\?可打印对应符号

运算优先级：

幂运算

**

位翻转

~

算术 *** 作符

*，/，+，-，//，%

位移动

<<，>>

位运算

&，|，^

比较 *** 作符

>，>=，<，<=，==，!=

逻辑运算符

not，and，or

PyCharm：

Ctrl + F

查找

Ctrl + R

替换

Ctrl + Alt + L

格式化文件

IDLE：

Ctrl + ]

加缩进

Ctrl + [

减缩进

Ctrl + N

文件编辑

Alt + M

代码模块

F1

帮助文档

var = x if cond else y

条件赋值

while、if、elif、else

分支常用语句

for VAR in SEQ

变量循环获得序列里的值

不覆盖使用变量

break

跳出循环体

continue

返回循环语句

异常语句：

raise ERROR(str)

引发指定解释的异常

assert COND, "str"

其后条件为False则报错

Error基类：

BaseException

所有异常

Exception

常规错误

StandardError

内建标准异常

ArithmeticError

数值计算错误

EnvironmentError

*** 作系统错误的基类

LookupError

无效数据查询的基类

Error常用：

SystemExit

解释器请求退出

KeyboardInterrupt

用户中断执行 (通常是输入^C)

StopIteration

迭代器没有更多的值

GeneratorExit

生成器发生异常来通知退出

AssertionError

断言语句失败

AttributeError

实例没有这个属性

IndexError

序列中没有没有此索引

KeyError

映射中没有这个键

SystemError

一般的解释器系统错误

TypeError

对类型无效的 *** 作

ValueError

传入无效的参数

try:

检测范围

except:

异常后的处理代码

finally:

必定执行的代码

else:

iter(seq)

返回序列的迭代器实例

next(seq)

返回迭代器实例的下一个值

len(seq)

返回序列长度

max(seq, key)

返回序列最大值

min(seq, key)

返回序列最小值

sum(seq, extra=0)

返回列表/元组中的数字之和(可再加一个参数)

*seq

返回序列对应的参数

sorted(seq, key)

将元素从小到大排序

key：取键函数

reversed(seq)

颠倒元素顺序

返回生成器实例

enumerate(seq)

将元素转化为携带偏移量的元组

返回迭代器实例

zip(seq)

将多个列表、元组合并

range(B, E, P)

返回 [B, E) 区间内步长P的数字序列

all(seq)

返回元素bool与运算

SEQ[begin: end: step]

切片，[::-1] 逆转序列

list(seq)

将序列转化为列表

LIST.append(obj)

添加元素

LIST.extend(seq)

用列表扩充LIST

LIST.remove(obj)

将元素移出LIST

LIST.insert(idx, obj)

将元素obj放在idx的位置

LIST.pop(idx=-1)

取出对应偏移量的元素作为返回值

LIST.count(obj)

返回元素出现次数

LIST.index(obj, start, end)

返回元素的位置

LIST.reverse()

颠倒元素顺序

LIST.sort(key, reverse=False)

将元素从小到大排序

LIST.clear()

清空列表

字符前缀：

u

Unicode

r

不识别转义

b

bytes

f

格式化

大小写：

STR.capitalize()

字符串首字母大写

STR.title()

STR.casefold()

所有字母

改为小写

STR.upper()

改为大写

STR.swapcase()

翻转STR中的字母大小写

端 *** 作：

STR.ljust(width, char=" ")

STR左对齐

使用char填充至width

STR.rjust(width, char=" ")

STR右对齐

STR.center(width, char=" ")

STR居中

STR.lstrip(char=" ")

STR左端

删去所有子字符串

STR.rstrip(char=" ")

STR右端

STR.strip(char=" ")

STR两端

STR.startswith(char, start, end)

STR开头

是否为子字符串

STR.endswith(char, start, end)

STR结尾

查找：

STR.count(char, start, end)

输出子字符串在STR中出现次数

STR.find(sub, start, end)

查找子字符串

的位置

无则返回-1

STR.index(sub, start, end)

无则报错

切分：

STR.partition(sub)

左端开始

以子字符串为界切分成三元组

STR.rpartition(sub)

右端开始

STR.split(seq=" ", time)

切片字符串，返回子字符串列表

STR.join(seq)

以STR为分隔符，返回新字符串

修改：

STR.replace(old, new, time)

将旧字符串替换为新字符串

STR.expandtabs(tabsize)

修改水平制表字符数 (默认为8)

BYTES.decode("utf-8")

按给定的解码方式

bytes -> str

STR.encode("gb2312")

str -> bytes

编码：

'unicode_escape'

'utf-8'

'gbk'

判断：

STR.isalpha()

是否只包含字母

STR.isalnum()

是否只包含字母、数字

%c

格式化字符及其ASCII码

%s

格式化字符串

%M.Nd

格式化整数

M限定数字最小总宽度

N制定小数点后精度

"-M"左对齐

%M.Ne

用e记法格式化定点数(1.5e10，1.5E10)

%M.Nf

格式化定点数(小数点后精度默认6位)

%M.Ng

根据值的大小使用%e或%f

%o

格式化无符号8进制数

%x

格式化无符号16进制数

f"{VAR:mode}"

f字符串

mode

<5：左对齐

>5：右对齐

^5：居中对齐

千位分隔符：,  _

字符样式：

3[{font};{color};{bk_color}m

字符前缀

range(108)

样式编码

ascii_uppercase

大写字母字符流

ascii_lowercase

小写字母字符流

whitespace

空白字符字符流

punctuation

标点符号字符流

正则表达式EXP：

.

匹配换行符之外的任意字符 (只匹配.时用"\.")

\d

数字

\s

空白字符

\w

单词、数字、下划线字符

\D

非数字

\S

非空白字符

\W

非单词、数字、下划线字符

1-9的数字：表对应序号括号中的内容

开头0或3位数字：匹配对应ASCII码的字符

^

其后的字符匹配偏移量=0的字符，同\A

$

其前的字符匹配偏移量=-1的字符，同\Z

|

表示"或"

( )

将表达式中的内容分组

(?：表非捕获组

[ ]

其中为

字符类

-：在中间则描述范围，否则为普通字符

^：在首位表不在其中的任何字符，否则为普通字符

{ }

数字或范围表前一字符重复次数

{ }?：启用非贪婪

*

等价于{0,}

*?：启用非贪婪

+

等价于{1,}

+?：启用非贪婪

?

等价于{0,1}

??：启用非贪婪

(.*?)

非贪婪截取内容

[\u4e00-\u9fa5]

中文

search(r"EXP", str)

返回EXP在str中的匹配结果

match(r"EXP", str)

str开头与EXP匹配则返回匹配结果

findall(r"EXP", str)

返回str中与EXP匹配的字符串列表(EXP有层则返回元组构成的列表)

compile(r"EXP")

返回正则表达式模式实例

sub(r"EXP", rep, str)

将匹配内容替换成rep，并返回新字符串

RESULT.group(m)

返回匹配内容(m可指定分组序号)

RESULT.start()

返回匹配内容

起始位置

RESULT.end()

结束位置

RESULT.span()

范围

编译标志FLAG：

A

使转义字符只能匹配ASCII字符

S

使'.'可匹配换行符

I

匹配时不区分大小写

L

支持当前的语言设置

M

多行匹配，影响^和$

X

启用详细的正则表达式

创建：

{key1: value1}

返回字典

dict(key1=value1)

将列表、元组、合适的迭代器实例转化为字典

DICT[key]=value

修改、添加DICT中的映射

dict.fromkeys(keys, value)

返回键序列对应值的字典

**DICT

返回DICT对应的关键字参数

映射 *** 作：

DICT.keys()

返回key/value/(key, value)的迭代器实例

DICT.values()

DICT.items()

DICT.get(key, value)

获取key对应的value

不存在时返回value

DICT.setdefault(key, value)

不存在时添加进DICT

DICT.pop(key)

取出对应的映射并以其value作为返回值

DICT.popitem()

取出最后一个映射并作为返回值

DICT.copy()

拷贝DICT

DICT1.update(DICT2)

使用DICT2更新DICT1

元素 *** 作：

SET.add(element)

添加元素

SET.remove(element)

移除元素

SET.issubset(set)

判断是否为

子集

SET.issuperset(set)

超集

运算 *** 作：

SET.intersection(*set)

返回集合的交集

SET1 & SET2

SET.union(*set)

返回集合的并集

SET1 | SET2

SET.difference(*set)

返回集合的差集

SET1 - SET2

SET.symmetric_difference(*set)

返回对称差集

(SET1 | SET2) - (SET1 & SET2)

SET.symmetric_difference_update(*set)

更新为对称差集

open(file, mode, encoding, newline)

返回打开的文件实例

mode

默认模式

"r" 只读模式

"t" 文本模式

写入模式

(若文件存在)

"w" 覆盖

"x" 报错

"a" 追加写入

"b" 二进制模式

"U" 通用换行模式

"+" 可读写模式

文件属性：

TEXT.closed

关闭的布尔值

TEXT.mode

访问模式

TEXT.name

文件名称

文件方法：

TEXT.read(limit=-1)

读取指定个数的字符

TEXT.readlines()

从指针开始读取行列表

TEXT.tell()

返回当前指针的位置

TEXT.seek(offset, begin)

移动指针，从begin偏移

offset字节并返回指针位置

n

0

文件起始位置

1

当前位置

2

文件末尾

TEXT.close()

关闭并保存

TEXT.write(str)

写入str并返回str的字符数

TEXT.writelines(lines)

写入返回字符串的可迭代实例

定义函数

def

常规函数

lambda

匿名函数

返回值

return

执行时结束函数

yield

将函数转变为返回值生成器

next(gen)

执行函数并产出值

GEN.send(value)

指定yield语句的value

变量声明

global

全局变量

nonlocal

上一级函数的局部变量

特殊参数

key: type = ?

设置参数类型、默认值

*args

收集剩余参数

返回元组

**kwargs

收集剩余关键字参数

返回字典

批量函数转换：

filter(fun, seq)

保留返回值是True的元素

map(fun, seq)

返回转换结果

repr(obj)

转化为供解释器读取的形式，返回对象str

vars(obj)

返回对象的实例属性字典

super()

返回对象的父类

issubclass(obj, class|seq)

判断obj是否为class

子类

isinstance(obj, obj|seq)

实例

hasattr(obj, attr)

判断是否含有属性

getattr(obj, attr, rep)

返回对应属性的值

不存在时返回rep(未提供则报错)

setattr(obj, attr, rep)

将rep赋值给obj中属性attr

不存在则创建

delattr(obj, attr)

删除obj中属性

不存在则报错

attr = property(FUNget, FUNset, FUNdel)

self.attr

触发FUNget

self.attr = VALUE

触发FUNset

del self.attr

触发FUNdel

@staticmethod

静态方法

@classmethod

类方法

基本方法：

__new__(self, *args, **kwargs)

实例化时被调用 (__new__没有返回实例对象，

则__init__不会被调用)

__init__(self, *args, **kwargs)

初始化实例

__del__(self)

实例被销毁时调用

__call__(self, *args, **kwargs)

允许实例像函数一样被调用

类型 *** 作：

__len__(self)

len()

__repr__(self)

repr()

__str__(self)

str()

__bytes__(self)

bytes()

__hash__(self)

hash()

__bool__(self)

bool()

__format__(self, format_spec)

format()

__dir__(self)

dir()

__complex__(self)

complex()

__int__(self)

int()

__float__(self)

float()

__round__(self,n)

round()

__enter__(self)

with语句

索引 *** 作：

__index__(self)

切片表达式

__iter__(self)

next()

__next__(self)

iter()

__getitem__(self, idx)

object[idx]

属性 *** 作：

__getattr__(self, item)

获取不存在的属性的行为

__getattribute__(self, item)

属性被访问的行为

__setattr__(self, key, value)

属性被设置的行为

__delattr__(self, item)

属性被删除的行为

__get__(self, instance, owner)

描述符被访问时的行为

__set__(self, instance, value)

描述符被设置时的行为

__delete__(self, instance)

描述符被删除时的行为

十进制运算：

__add__(self, other)

"+"

__sub__(self, other)

"-"

__mul__(self, other)

"*"

__truediv__(self, other)

"/"

__floordiv__(self, other)

"//"

__mod__(self, other)

"%"

__divmod__(self, other)

divmod()

__pow__(self, other[, mod])

"**"、pow()

比较 *** 作：

__lt__(self, other)

"<"

__gt__(self, other)

">"

__le__(self, other)

"<="

__ge__(self, other)

">="

__eq__(self, other)

"=="

__ne__(self, other)

"!="

按位运算：

__lshift__(self, other)

"<<"

__rshift__(self, other)

">>"

__and__(self, other)

"&"

__xor__(self, other)

"^"

__or__(self, other)

"|"

from MOD import *

导入__all__列表中的变量

from MOD import FUN

从模块MOD中导出FUN

import MOD as VAR

导入模块并命名为VAR

help("modules")

读取模块列表

代码属性：

__name__

"__main__"

主代码

"MOD"

作为模块被导入

__file__

代码文件名

__path__

代码位置

哈希表：

Counter(var)

返回哈希表

COUNT.most_common(int)

返回指定数量高频值

COUNT.update(var)

更新哈希表

加法

COUNT.subtract(var)

减法

copy(var)

浅拷贝变量

deepcopy(var)

深拷贝变量

date(year, month, day)

实例化日期

date.today()

今日日期

DELTA.day

日期差

Fraction()

返回实例化的分数

FRACT.numerator

返回分子

FRACT.denominator

返回分母

小根堆：

heapify(seq)

原地小根堆化

heappush(heap, item)

添加堆结点

heappop(heap)

d出堆顶，并重排

nsmallest(n, seq)

返回升序前n元素

nlargest(n, seq)

返回降序前n元素

heapreplace(heap, item)

pop -> push

heappushpop(heap, item)

push -> pop

大根堆：

_heapify_max(seq)

原地大根堆化

_heappop_max(heap)

d出堆顶，并重排

_heapreplace_max(heap, item)

pop -> push

cycle(seq)

返回循环链表

accumulate(seq, operator)

返回累积运算结果

dropwhile(filter, seq)

过滤直到条件变False

takewhile(filter, seq)

筛选直到条件变True

combinations(seq, num)

返回不放回

组合序列

combinations_with_replacement(seq, num)

返回有放回

compress(seq, bool_seq)

返回压缩过滤序列

常用数值：

pi

п

e

e

inf

∞

运算函数：

log(x, a)

loga(x)，a默认为e

sin(x)

sin( )

asin(x)

arcsin( )

cos(x)

cos( )

acos(x)

arccos( )

tan(x)

tan( )

atan(x)

arctan( )

ceil(x)

⌈x⌉

floor(x)

⌊x⌋

pow(x, a)

x ** a

gcd(a, b)

最大公约数

factorial(x)

x!

degrees(x)

弧度 -> 角度

radians(x)

角度 -> 弧度

float

random()

[0,1)

uniform(start, end)

[start, end]

int

randint(start, end)

[start, end]

randrange(start, end, pace)

range(start, end, pace)

getrandombits(bits)

k位二进制

obj

choice(seq)

单次选取

sample(seq, time)

不放回选取

seq

shuffle(seq)

原地打乱

时间 *** 作：

time()

获得当前秒数

sleep(secs)

睡眠指定时间

时间转换：

秒数

ctime(seconds=None)

秒数 => 字符串

%a %b %d %H:%M:%S %Y

gmtime(seconds=None)

秒数 => 时间元组

格林威治时间

localtime(seconds=None)

当地时间

时间元组

mktime(time_tuple)

时间元组 => 秒数

strftime(format, time)

时间元组 => 字符串

字符串

strptime(str, format)

字符串 => 时间元组

时间元组 (起点：1970.1.1)：

tm_year

%Y

2001

tm_mon

%m

01~12

%b

Jan ~ Dec

%B

January ~ December

tm_mday

%d

1~31

tm_hour

%H

0~23

tm_min

%M

0~59

tm_sec

%S

0~61

tm_wday

%a

Mon ~ Sun

%A

Monday ~ Sunday

tm_yday

年中第几天

1~366

tm_isdst

是否夏令时

0,1,-1(代表夏令时)

calc

计算器

cls

清屏

CD

改变工作路径

chcp 65001

使用UTF-8编码

rd /s /q DIR

强制删除文件夹

copy /Y dir path("\")

复制工作目录下文件夹中内容到另一路径

dir *.jpg /S

搜索当前目录中的所有文件

help

帮助

ipconfig

IP地址

runas /user:荷碧， cmd

管理员权限运行

pip install --upgrade MOD

升级包

python -m pip install --upgrade pip

升级pip

pip freeze > requirements.txt

导出

依赖包文件

pip install -r requirements.txt

安装

notebook.auth

passwd(str)

字符串 -> 密文

命令行：

jupyter notebook

启动jupyter

jupyter notebook --generate-config

生成配置文件

配置

文本

c.NotebookApp.ip = '*'

对外开放的IP

c.NotebookApp.allow_remote_access = True

允许远程访问

c.NotebookApp.password

设置密文

c.NotebookApp.port = 8888

开放端口

代码：

%%time

输出执行时间

快捷键：

shift + Tab

函数文档

Tab

补全建议

conda create -n Modeling python==3.7.0

克隆

环境

conda activate base

激活

conda base

关闭

conda info --envs

查看虚拟环境列表

conda remove -n Backup --all

删除虚拟环境

python -V

查看当前Python版本

conda upgrade --all

升级全部包

conda clean -p

conda clean -t

conda clean -y --all

清理安装包

conda install -y python==3.7 anaconda=custom

安装指定Python版本

参数：

-c

默认

使用控制台，无窗口

-D

创建包含exe、依赖文件的目录

-w

使用窗口，无控制台

-F

打包生成单exe

语句：

-p D:\Anaconda3

添加文件搜索路径

-i ico.ico

设置exe图标

--hidden-import MOD

导入自定义模块

--add-data FILE;PATH

添加文件到打包后的路径