\documentclass[10pt,a4paper]{article}

% Packages
\usepackage{fancyhdr}           % For header and footer
\usepackage{multicol}           % Allows multicols in tables
\usepackage{tabularx}           % Intelligent column widths
\usepackage{tabulary}           % Used in header and footer
\usepackage{hhline}             % Border under tables
\usepackage{graphicx}           % For images
\usepackage{xcolor}             % For hex colours
%\usepackage[utf8x]{inputenc}    % For unicode character support
\usepackage[T1]{fontenc}        % Without this we get weird character replacements
\usepackage{colortbl}           % For coloured tables
\usepackage{setspace}           % For line height
\usepackage{lastpage}           % Needed for total page number
\usepackage{seqsplit}           % Splits long words.
%\usepackage{opensans}          % Can't make this work so far. Shame. Would be lovely.
\usepackage[normalem]{ulem}     % For underlining links
% Most of the following are not required for the majority
% of cheat sheets but are needed for some symbol support.
\usepackage{amsmath}            % Symbols
\usepackage{MnSymbol}           % Symbols
\usepackage{wasysym}            % Symbols
%\usepackage[english,german,french,spanish,italian]{babel}              % Languages

% Document Info
\author{simpleapples}
\pdfinfo{
  /Title (python-3.pdf)
  /Creator (Cheatography)
  /Author (simpleapples)
  /Subject (Python 3 Cheat Sheet)
}

% Lengths and widths
\addtolength{\textwidth}{6cm}
\addtolength{\textheight}{-1cm}
\addtolength{\hoffset}{-3cm}
\addtolength{\voffset}{-2cm}
\setlength{\tabcolsep}{0.2cm} % Space between columns
\setlength{\headsep}{-12pt} % Reduce space between header and content
\setlength{\headheight}{85pt} % If less, LaTeX automatically increases it
\renewcommand{\footrulewidth}{0pt} % Remove footer line
\renewcommand{\headrulewidth}{0pt} % Remove header line
\renewcommand{\seqinsert}{\ifmmode\allowbreak\else\-\fi} % Hyphens in seqsplit
% This two commands together give roughly
% the right line height in the tables
\renewcommand{\arraystretch}{1.3}
\onehalfspacing

% Commands
\newcommand{\SetRowColor}[1]{\noalign{\gdef\RowColorName{#1}}\rowcolor{\RowColorName}} % Shortcut for row colour
\newcommand{\mymulticolumn}[3]{\multicolumn{#1}{>{\columncolor{\RowColorName}}#2}{#3}} % For coloured multi-cols
\newcolumntype{x}[1]{>{\raggedright}p{#1}} % New column types for ragged-right paragraph columns
\newcommand{\tn}{\tabularnewline} % Required as custom column type in use

% Font and Colours
\definecolor{HeadBackground}{HTML}{333333}
\definecolor{FootBackground}{HTML}{666666}
\definecolor{TextColor}{HTML}{333333}
\definecolor{DarkBackground}{HTML}{3776AB}
\definecolor{LightBackground}{HTML}{F2F6F9}
\renewcommand{\familydefault}{\sfdefault}
\color{TextColor}

% Header and Footer
\pagestyle{fancy}
\fancyhead{} % Set header to blank
\fancyfoot{} % Set footer to blank
\fancyhead[L]{
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{C}
    \SetRowColor{DarkBackground}
    \vspace{-7pt}
    {\parbox{\dimexpr\textwidth-2\fboxsep\relax}{\noindent
        \hspace*{-6pt}\includegraphics[width=5.8cm]{/web/www.cheatography.com/public/images/cheatography_logo.pdf}}
    }
\end{tabulary}
\columnbreak
\begin{tabulary}{11cm}{L}
    \vspace{-2pt}\large{\bf{\textcolor{DarkBackground}{\textrm{Python 3 Cheat Sheet}}}} \\
    \normalsize{by \textcolor{DarkBackground}{simpleapples} via \textcolor{DarkBackground}{\uline{cheatography.com/61758/cs/15925/}}}
\end{tabulary}
\end{multicols}}

\fancyfoot[L]{ \footnotesize
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{LL}
  \SetRowColor{FootBackground}
  \mymulticolumn{2}{p{5.377cm}}{\bf\textcolor{white}{Cheatographer}}  \\
  \vspace{-2pt}simpleapples \\
  \uline{cheatography.com/simpleapples} \\
  \end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Cheat Sheet}}  \\
   \vspace{-2pt}Published 30th May, 2018.\\
   Updated 30th May, 2018.\\
   Page {\thepage} of \pageref{LastPage}.
\end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Sponsor}}  \\
  \SetRowColor{white}
  \vspace{-5pt}
  %\includegraphics[width=48px,height=48px]{dave.jpeg}
  Measure your website readability!\\
  www.readability-score.com
\end{tabulary}
\end{multicols}}




\begin{document}
\raggedright
\raggedcolumns

% Set font size to small. Switch to any value
% from this page to resize cheat sheet text:
% www.emerson.emory.edu/services/latex/latex_169.html
\footnotesize % Small font.

\begin{multicols*}{2}

\begin{tabularx}{8.4cm}{x{3.68 cm} x{4.32 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{内置方法}}  \tn
% Row 0
\SetRowColor{LightBackground}
abs(num) & 求绝对值 \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
all(iterable) & \seqsplit{判断可迭代对象中所有元素是否都为True} \tn 
% Row Count 4 (+ 3)
% Row 2
\SetRowColor{LightBackground}
any(iterable) & \seqsplit{判断可迭代对象中任意元素是否为True} \tn 
% Row Count 7 (+ 3)
% Row 3
\SetRowColor{white}
ascii(object) & \seqsplit{将对象中的非ascii字符转换为ascii字符} \tn 
% Row Count 10 (+ 3)
% Row 4
\SetRowColor{LightBackground}
bin(num) & \seqsplit{将数字转换为二进制数的字符串} \tn 
% Row Count 12 (+ 2)
% Row 5
\SetRowColor{white}
bool({[}value{]}) & \seqsplit{将value转换为bool值} \tn 
% Row Count 14 (+ 2)
% Row 6
\SetRowColor{LightBackground}
bytearray(source) & \seqsplit{将source转换为bytearray类型} \tn 
% Row Count 16 (+ 2)
% Row 7
\SetRowColor{white}
bytes(source) & \seqsplit{将source转换为byte类型} \tn 
% Row Count 18 (+ 2)
% Row 8
\SetRowColor{LightBackground}
callable(object) & \seqsplit{判断一个对象是否是可调用的} \tn 
% Row Count 20 (+ 2)
% Row 9
\SetRowColor{white}
chr(i) & \seqsplit{将ascii码转换为字符} \tn 
% Row Count 22 (+ 2)
% Row 10
\SetRowColor{LightBackground}
\seqsplit{classmethod(function)} & \seqsplit{将一个方法转换为类方法} \tn 
% Row Count 24 (+ 2)
% Row 11
\SetRowColor{white}
compile(source, filename, mode) & \seqsplit{将source编译为一个可执行的code对象} \tn 
% Row Count 27 (+ 3)
% Row 12
\SetRowColor{LightBackground}
complex({[}real{[}, imag{]}{]}) & \seqsplit{通过传入一个实数和一个虚数创建一个复数} \tn 
% Row Count 30 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{3.68 cm} x{4.32 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{内置方法 (cont)}}  \tn
% Row 13
\SetRowColor{LightBackground}
delattr(object, name) & \seqsplit{从对象object中移除名为name的属性，不存在时抛出异常} \tn 
% Row Count 4 (+ 4)
% Row 14
\SetRowColor{white}
dict() & 创建一个字典 \tn 
% Row Count 5 (+ 1)
% Row 15
\SetRowColor{LightBackground}
dir({[}object{]}) & \seqsplit{返回对象的属性列表} \tn 
% Row Count 7 (+ 2)
% Row 16
\SetRowColor{white}
divmod(x, y) & \seqsplit{x除以y，返回商和余数} \tn 
% Row Count 9 (+ 2)
% Row 17
\SetRowColor{LightBackground}
\seqsplit{enumerate(iterable}, start=0) & \seqsplit{将一个可迭代对象组合成为一个索引序列，包含下标和数据} \tn 
% Row Count 13 (+ 4)
% Row 18
\SetRowColor{white}
eval(expression) & \seqsplit{执行单个字符串表达式，并且返回结果} \tn 
% Row Count 16 (+ 3)
% Row 19
\SetRowColor{LightBackground}
exec(object, globals, locals) & \seqsplit{执行code类型或字符串类型的复杂代码，不返回结果} \tn 
% Row Count 20 (+ 4)
% Row 20
\SetRowColor{white}
filter(function, iterable) & \seqsplit{过滤可迭代对象，保留function中返回True的对象} \tn 
% Row Count 23 (+ 3)
% Row 21
\SetRowColor{LightBackground}
float({[}x{]}) & \seqsplit{将数字类型或字符串类型转换为浮点类型} \tn 
% Row Count 26 (+ 3)
% Row 22
\SetRowColor{white}
format(value{[}, format\_spec{]}) & \seqsplit{将对象格式化为字符串} \tn 
% Row Count 28 (+ 2)
% Row 23
\SetRowColor{LightBackground}
frozenset({[}iterable{]}) & \seqsplit{将可迭代对象转换为不可变集合类型} \tn 
% Row Count 31 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{3.68 cm} x{4.32 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{内置方法 (cont)}}  \tn
% Row 24
\SetRowColor{LightBackground}
getattr(object, name{[}, default{]}) & \seqsplit{根据名称获取对象的指定属性，如果属性名不存在则返回默认值} \tn 
% Row Count 4 (+ 4)
% Row 25
\SetRowColor{white}
globals() & \seqsplit{以字典形式返回所有的全局变量} \tn 
% Row Count 6 (+ 2)
% Row 26
\SetRowColor{LightBackground}
hasattr(object, name) & \seqsplit{判断对象是否含有指定名称的属性} \tn 
% Row Count 9 (+ 3)
% Row 27
\SetRowColor{white}
hash(object) & \seqsplit{获取对象的hash值} \tn 
% Row Count 11 (+ 2)
% Row 28
\SetRowColor{LightBackground}
help(object) & \seqsplit{获得某个对象的帮助文档} \tn 
% Row Count 13 (+ 2)
% Row 29
\SetRowColor{white}
hex(x) & \seqsplit{将一个整数转换为十六进制字符串} \tn 
% Row Count 16 (+ 3)
% Row 30
\SetRowColor{LightBackground}
id(object) & \seqsplit{返回对象的唯一标识符} \tn 
% Row Count 18 (+ 2)
% Row 31
\SetRowColor{white}
input({[}prompt{]}) & \seqsplit{读取用户输入的一行内容，并返回} \tn 
% Row Count 21 (+ 3)
% Row 32
\SetRowColor{LightBackground}
int(x=0, base=10) & \seqsplit{将数字类型或字符串转换为一个整数} \tn 
% Row Count 24 (+ 3)
% Row 33
\SetRowColor{white}
isinstance(object, classinfo) & \seqsplit{判断一个对象是否是一个类或者其父类的实例} \tn 
% Row Count 27 (+ 3)
% Row 34
\SetRowColor{LightBackground}
issubclass(object, classinfo) & \seqsplit{判断一个类师傅是另一个类（或其父类）的子类} \tn 
% Row Count 30 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{3.68 cm} x{4.32 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{内置方法 (cont)}}  \tn
% Row 35
\SetRowColor{LightBackground}
iter(object{[}, sentinel{]}) & \seqsplit{根据一个对象生成一个迭代器，如果sentinel为True则object必须是可调用的} \tn 
% Row Count 5 (+ 5)
% Row 36
\SetRowColor{white}
len(s) & \seqsplit{获取一个对象的长度（s必须是序列或集合类型）} \tn 
% Row Count 9 (+ 4)
% Row 37
\SetRowColor{LightBackground}
list({[}iterable{]}) & \seqsplit{将一个可迭代对象转换为一个列表} \tn 
% Row Count 12 (+ 3)
% Row 38
\SetRowColor{white}
locals() & \seqsplit{以字典形式返回所有的局部变量} \tn 
% Row Count 14 (+ 2)
% Row 39
\SetRowColor{LightBackground}
map(function, iterable, ...) & \seqsplit{将function应用到可迭代对象的每一个元素上，并返回执行后的结果列表} \tn 
% Row Count 19 (+ 5)
% Row 40
\SetRowColor{white}
max(arg1, arg2, *args{[}, key{]}) & \seqsplit{获取可迭代对象或传入参数中的最大值} \tn 
% Row Count 22 (+ 3)
% Row 41
\SetRowColor{LightBackground}
memoryview(obj) & \seqsplit{将一个对象包装成一个内存查看对象} \tn 
% Row Count 25 (+ 3)
% Row 42
\SetRowColor{white}
min(arg1, arg2, *args{[}, key{]}) & \seqsplit{获取可迭代对象或传入参数中的最大值} \tn 
% Row Count 28 (+ 3)
% Row 43
\SetRowColor{LightBackground}
next(iterator, default) & \seqsplit{获取可迭代对象的下一个元素，如果不存在下一个元素返回默认值} \tn 
% Row Count 33 (+ 5)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{3.68 cm} x{4.32 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{内置方法 (cont)}}  \tn
% Row 44
\SetRowColor{LightBackground}
object() & 返回一个对象 \tn 
% Row Count 1 (+ 1)
% Row 45
\SetRowColor{white}
oct(x) & \seqsplit{将一个整数转换成八进制字符串} \tn 
% Row Count 3 (+ 2)
% Row 46
\SetRowColor{LightBackground}
open(file) & \seqsplit{打开一个文件，并返回一个文件类型的对象} \tn 
% Row Count 6 (+ 3)
% Row 47
\SetRowColor{white}
ord(c) & \seqsplit{将一个unicode字符转换成整数类型的ascii码或unicode数值} \tn 
% Row Count 10 (+ 4)
% Row 48
\SetRowColor{LightBackground}
pow(x, y{[}, z{]}) & \seqsplit{计算x的y次方，除以z的余数} \tn 
% Row Count 12 (+ 2)
% Row 49
\SetRowColor{white}
print(*objects) & \seqsplit{将对象输出到标准输出或文件流中} \tn 
% Row Count 15 (+ 3)
% Row 50
\SetRowColor{LightBackground}
property() & \seqsplit{根据输入的getter、getter、deleter生成属性} \tn 
% Row Count 18 (+ 3)
% Row 51
\SetRowColor{white}
range(start, stop{[}, step{]}) & \seqsplit{根据开始、结束、步长来返回一个数字类型的不可变序列} \tn 
% Row Count 22 (+ 4)
% Row 52
\SetRowColor{LightBackground}
repr(obj) & \seqsplit{返回一个对象的可打印形式（适合解释器打印的形式）} \tn 
% Row Count 26 (+ 4)
% Row 53
\SetRowColor{white}
reversed(seq) & \seqsplit{将一个序列翻转并返回一个迭代器} \tn 
% Row Count 29 (+ 3)
% Row 54
\SetRowColor{LightBackground}
round(number{[}, ndigits{]}) & \seqsplit{根据输入的小数位数，将一个浮点型数字四舍五入} \tn 
% Row Count 33 (+ 4)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{3.68 cm} x{4.32 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{内置方法 (cont)}}  \tn
% Row 55
\SetRowColor{LightBackground}
set({[}iterable{]}) & \seqsplit{讲一个可迭代对象转换成一个集合类型} \tn 
% Row Count 3 (+ 3)
% Row 56
\SetRowColor{white}
setattr(object, name, value) & \seqsplit{根据属性名查找并设置对象的属性} \tn 
% Row Count 6 (+ 3)
% Row 57
\SetRowColor{LightBackground}
slice(start, stop, step) & \seqsplit{根据开始、结束、步长来返回一个切片对象} \tn 
% Row Count 9 (+ 3)
% Row 58
\SetRowColor{white}
sorted(iterable{[}, key{]}{[}, reverse{]}) & \seqsplit{对一个可迭代对象进行排序，并返回一个新的列表} \tn 
% Row Count 13 (+ 4)
% Row 59
\SetRowColor{LightBackground}
\seqsplit{staticmethod(function)} & \seqsplit{将一个方法转换为静态方法} \tn 
% Row Count 15 (+ 2)
% Row 60
\SetRowColor{white}
str(object='') & \seqsplit{讲一个对象转为字符串类型（适合人类阅读的形式）} \tn 
% Row Count 19 (+ 4)
% Row 61
\SetRowColor{LightBackground}
sum(iterable, start) & \seqsplit{求可迭代对象中所有元素的和} \tn 
% Row Count 21 (+ 2)
% Row 62
\SetRowColor{white}
super(type{[}, object-or-type{]}) & 获取父类 \tn 
% Row Count 23 (+ 2)
% Row 63
\SetRowColor{LightBackground}
tuple(iterable) & \seqsplit{将可迭代对象转换为一个元组} \tn 
% Row Count 25 (+ 2)
% Row 64
\SetRowColor{white}
type(object) & \seqsplit{返回一个对象的类型} \tn 
% Row Count 27 (+ 2)
% Row 65
\SetRowColor{LightBackground}
type(name, bases, dict) & \seqsplit{创建一个新的type对象} \tn 
% Row Count 29 (+ 2)
% Row 66
\SetRowColor{white}
vars(object) & \seqsplit{以字典形式返回对象的属性和属性值} \tn 
% Row Count 32 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{3.68 cm} x{4.32 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{内置方法 (cont)}}  \tn
% Row 67
\SetRowColor{LightBackground}
zip(*iterables) & \seqsplit{将多个可迭代对象中的对应元素打包成一个元组，并返回元组的列表} \tn 
% Row Count 5 (+ 5)
% Row 68
\SetRowColor{white}
\_\_import\_\_(name) & 动态导入模块 \tn 
% Row Count 6 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.12 cm} x{4.88 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{列表处理方法}}  \tn
% Row 0
\SetRowColor{LightBackground}
append(item) & \seqsplit{将一个元素添加到列表尾部} \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
extend(lst) & \seqsplit{将lst中的所有元素添加到列表中} \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
insert(index, element) & \seqsplit{在列表指定位置插入元素} \tn 
% Row Count 6 (+ 2)
% Row 3
\SetRowColor{white}
\seqsplit{remove(element)} & \seqsplit{从左侧查找并移除第一个找到的元素，找不到时候抛出异常} \tn 
% Row Count 10 (+ 4)
% Row 4
\SetRowColor{LightBackground}
index(element) & \seqsplit{从左侧查找并返回第一个找到元素的位置，找不到时候抛出异常} \tn 
% Row Count 14 (+ 4)
% Row 5
\SetRowColor{white}
count(element) & \seqsplit{返回指定元素的个数} \tn 
% Row Count 16 (+ 2)
% Row 6
\SetRowColor{LightBackground}
pop(index) & \seqsplit{移除并返回指定位置元素} \tn 
% Row Count 18 (+ 2)
% Row 7
\SetRowColor{white}
reverse() & 反转列表 \tn 
% Row Count 19 (+ 1)
% Row 8
\SetRowColor{LightBackground}
sort(key=..., reverse=...) & 对列表进行排序 \tn 
% Row Count 21 (+ 2)
% Row 9
\SetRowColor{white}
copy() & 浅拷贝列表 \tn 
% Row Count 22 (+ 1)
% Row 10
\SetRowColor{LightBackground}
clear() & \seqsplit{清除列表中所有元素} \tn 
% Row Count 24 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.52 cm} x{4.48 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{字典处理方法}}  \tn
% Row 0
\SetRowColor{LightBackground}
clear() & 清除所有元素 \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
copy() & 浅拷贝 \tn 
% Row Count 2 (+ 1)
% Row 2
\SetRowColor{LightBackground}
fromkeys(sequence{[}, value{]}) & \seqsplit{以sequence元素为键，value为值创建一个新字典} \tn 
% Row Count 5 (+ 3)
% Row 3
\SetRowColor{white}
get(key{[}, value{]}) & \seqsplit{返回字典中key对应的值，如果不存在则返回value} \tn 
% Row Count 8 (+ 3)
% Row 4
\SetRowColor{LightBackground}
items() & \seqsplit{返回字典中的所有键值对（键值对以tuple形式返回）} \tn 
% Row Count 12 (+ 4)
% Row 5
\SetRowColor{white}
keys() & \seqsplit{返回字典中所有的键} \tn 
% Row Count 14 (+ 2)
% Row 6
\SetRowColor{LightBackground}
popitem() & \seqsplit{移除并返回任意的（不是随机）元素} \tn 
% Row Count 17 (+ 3)
% Row 7
\SetRowColor{white}
setdefault(key{[}, default\_value{]}) & \seqsplit{如果key不存在，则插入key，值为default\_value，返回key对应的值} \tn 
% Row Count 21 (+ 4)
% Row 8
\SetRowColor{LightBackground}
pop(key{[}, default{]}) & \seqsplit{移除并返回key对应的值，如果key不存在则返回default} \tn 
% Row Count 25 (+ 4)
% Row 9
\SetRowColor{white}
values() & \seqsplit{返回字典中所有的值} \tn 
% Row Count 27 (+ 2)
% Row 10
\SetRowColor{LightBackground}
update({[}other{]}) & \seqsplit{使用other更新字典，other可以是一个字典或一个字典组成的可迭代对象} \tn 
% Row Count 32 (+ 5)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.68 cm} x{4.32 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{集合处理方法}}  \tn
% Row 0
\SetRowColor{LightBackground}
remove(element) & \seqsplit{移除指定元素，元素不存在则抛出异常} \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
add(elem) & \seqsplit{添加元素，元素已经存在则什么都不做} \tn 
% Row Count 6 (+ 3)
% Row 2
\SetRowColor{LightBackground}
copy() & 浅拷贝集合 \tn 
% Row Count 7 (+ 1)
% Row 3
\SetRowColor{white}
clear() & \seqsplit{移除集合中的所有元素} \tn 
% Row Count 9 (+ 2)
% Row 4
\SetRowColor{LightBackground}
a.difference(b) & \seqsplit{返回在集合a中存在，在集合b中不存在的元素的集合} \tn 
% Row Count 13 (+ 4)
% Row 5
\SetRowColor{white}
\seqsplit{a.difference\_update(b)} & \seqsplit{返回集合a移除了集合a和集合b交集元素的集合} \tn 
% Row Count 16 (+ 3)
% Row 6
\SetRowColor{LightBackground}
discard(x) & 移除指定元素 \tn 
% Row Count 17 (+ 1)
% Row 7
\SetRowColor{white}
\seqsplit{a.intersection(*other\_sets)} & \seqsplit{返回集合a和其他集合交集的元素集合} \tn 
% Row Count 20 (+ 3)
% Row 8
\SetRowColor{LightBackground}
\seqsplit{a.intersection\_update(*other\_sets)} & \seqsplit{返回集合a和其他集合交集与集合a的并集的集合} \tn 
% Row Count 23 (+ 3)
% Row 9
\SetRowColor{white}
a.isdisjoint(b) & \seqsplit{判断两个集合是否有交集} \tn 
% Row Count 25 (+ 2)
% Row 10
\SetRowColor{LightBackground}
a.issubset(b) & \seqsplit{判断集合a是否是集合b的子集} \tn 
% Row Count 27 (+ 2)
% Row 11
\SetRowColor{white}
pop() & \seqsplit{移除并返回集合中的任意（不是随机）元素} \tn 
% Row Count 30 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{3.68 cm} x{4.32 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{集合处理方法 (cont)}}  \tn
% Row 12
\SetRowColor{LightBackground}
\seqsplit{a.symmetric\_difference(b)} & \seqsplit{返回集合a和集合b各自独有元素的集合} \tn 
% Row Count 3 (+ 3)
% Row 13
\SetRowColor{white}
\seqsplit{a.symmetric\_difference\_update(b)} & \seqsplit{返回集合a和集合b各自独有元素与集合a的并集的集合} \tn 
% Row Count 7 (+ 4)
% Row 14
\SetRowColor{LightBackground}
\seqsplit{a.union(*other\_sets)} & \seqsplit{返回集合a和其他集合的并集} \tn 
% Row Count 9 (+ 2)
% Row 15
\SetRowColor{white}
a.update(b) & \seqsplit{使用集合b更新集合a} \tn 
% Row Count 11 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{2.08 cm} x{5.92 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{元组处理方法}}  \tn
% Row 0
\SetRowColor{LightBackground}
\seqsplit{index(element)} & \seqsplit{从左侧查找元素并返回元素位置，找不到时抛出异常} \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
\seqsplit{count(element)} & \seqsplit{计算指定元素出现次数} \tn 
% Row Count 5 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{p{1.04 cm} x{6.96 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{索引和切片}}  \tn
% Row 0
\SetRowColor{LightBackground}
a{[}x{]} & 获取第x + 1个元素 \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
a{[}-x{]} & \seqsplit{获取从结尾开始第x个元素} \tn 
% Row Count 2 (+ 1)
% Row 2
\SetRowColor{LightBackground}
a{[}x:{]} & 获取第x + 1到最后一个元素 \tn 
% Row Count 4 (+ 2)
% Row 3
\SetRowColor{white}
a{[}:x{]} & \seqsplit{获取第一个元素到第x} + 1个元素 \tn 
% Row Count 6 (+ 2)
% Row 4
\SetRowColor{LightBackground}
a{[}:-x{]} & \seqsplit{获取第一个元素到从结尾开始的第x个元素} \tn 
% Row Count 8 (+ 2)
% Row 5
\SetRowColor{white}
a{[}x:y{]} & 获取第x + 1个元素到第y + 1个元素 \tn 
% Row Count 10 (+ 2)
% Row 6
\SetRowColor{LightBackground}
a{[}:{]} & 浅拷贝a \tn 
% Row Count 11 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{字符串处理方法}}  \tn
% Row 0
\SetRowColor{LightBackground}
capitalize() & \seqsplit{将首字符转换为大写} \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
center(width{[}, fillchar{]}) & \seqsplit{居中并填充字符到指定宽度} \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
casefold() & \seqsplit{讲字符串转换成小写} \tn 
% Row Count 6 (+ 2)
% Row 3
\SetRowColor{white}
count(substring{[}, start{[}, end{]}{]}) & \seqsplit{计算子字符串出现的次数} \tn 
% Row Count 8 (+ 2)
% Row 4
\SetRowColor{LightBackground}
endswith(suffix{[}, start{[}, end{]}{]}) & \seqsplit{判断是否以指定的字符串结尾} \tn 
% Row Count 10 (+ 2)
% Row 5
\SetRowColor{white}
expandtabs(tabsize) & 将字符串中的\textbackslash{}t转换为指定数量的空格 \tn 
% Row Count 13 (+ 3)
% Row 6
\SetRowColor{LightBackground}
\seqsplit{encode(encoding='UTF-8'},errors='strict') & \seqsplit{将unicode字符串转换为任何Python支持的编码类型} \tn 
% Row Count 17 (+ 4)
% Row 7
\SetRowColor{white}
find(sub{[}, start{[}, end{]}{]}) & \seqsplit{从左侧查找指定字符串位置（不存在返回-1）} \tn 
% Row Count 20 (+ 3)
% Row 8
\SetRowColor{LightBackground}
format(p0, p1, ..., k0=v0, k1=v1, ...) & 格式化字符串 \tn 
% Row Count 22 (+ 2)
% Row 9
\SetRowColor{white}
index(sub{[}, start{[}, end{]}{]}) & \seqsplit{从左侧查找指定字符串位置（不存在抛出异常）} \tn 
% Row Count 26 (+ 4)
% Row 10
\SetRowColor{LightBackground}
isalnum() & \seqsplit{检查字符串是否仅由字母和数字组成} \tn 
% Row Count 29 (+ 3)
% Row 11
\SetRowColor{white}
isalpha() & \seqsplit{检查字符串是否仅由字母组成} \tn 
% Row Count 31 (+ 2)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{字符串处理方法 (cont)}}  \tn
% Row 12
\SetRowColor{LightBackground}
isdecimal() & \seqsplit{检查字符串是否只由十进制字符组成} \tn 
% Row Count 3 (+ 3)
% Row 13
\SetRowColor{white}
isdigit() & \seqsplit{检测字符串是否只由数字组成} \tn 
% Row Count 5 (+ 2)
% Row 14
\SetRowColor{LightBackground}
isidentifier() & \seqsplit{判断字符串是否是有效的标识符} \tn 
% Row Count 8 (+ 3)
% Row 15
\SetRowColor{white}
islower() & \seqsplit{检测字符串是否由小写字母组成} \tn 
% Row Count 11 (+ 3)
% Row 16
\SetRowColor{LightBackground}
isnumeric() & \seqsplit{检测字符串是否只由数字组成（只支持unicode字符串）} \tn 
% Row Count 15 (+ 4)
% Row 17
\SetRowColor{white}
isprintable() & \seqsplit{检测字符串是否可打印（空字符串也可以打印）} \tn 
% Row Count 19 (+ 4)
% Row 18
\SetRowColor{LightBackground}
isspace() & \seqsplit{检测字符串是否只由空白字符组成（包括空格、换行符、制表符等）} \tn 
% Row Count 24 (+ 5)
% Row 19
\SetRowColor{white}
istitle() & \seqsplit{判断字符串首字母是否大写} \tn 
% Row Count 26 (+ 2)
% Row 20
\SetRowColor{LightBackground}
isupper() & \seqsplit{判断字符串是否只由大写字母组成} \tn 
% Row Count 29 (+ 3)
% Row 21
\SetRowColor{white}
join(iterable) & \seqsplit{用指定字符连接字符串可迭代对象} \tn 
% Row Count 32 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{字符串处理方法 (cont)}}  \tn
% Row 22
\SetRowColor{LightBackground}
ljust(width{[}, fillchar{]}) & \seqsplit{居左返回指定长度的字符串，不足部分用fillchar填充} \tn 
% Row Count 4 (+ 4)
% Row 23
\SetRowColor{white}
rjust(width{[}, fillchar{]}) & \seqsplit{居右返回指定长度的字符串，不足部分用fillchar填充} \tn 
% Row Count 8 (+ 4)
% Row 24
\SetRowColor{LightBackground}
lower() & \seqsplit{将所有字符转换为小写} \tn 
% Row Count 10 (+ 2)
% Row 25
\SetRowColor{white}
upper() & \seqsplit{将所有字符转换为大写} \tn 
% Row Count 12 (+ 2)
% Row 26
\SetRowColor{LightBackground}
swapcase() & \seqsplit{将大写字符转换为小写，小写字符转换为大写} \tn 
% Row Count 15 (+ 3)
% Row 27
\SetRowColor{white}
lstrip({[}chars{]}) & \seqsplit{从左侧截取指定的字符（可以是多个）} \tn 
% Row Count 18 (+ 3)
% Row 28
\SetRowColor{LightBackground}
rstrip({[}chars{]}) & \seqsplit{从右侧截取指定的字符（可以是多个）} \tn 
% Row Count 21 (+ 3)
% Row 29
\SetRowColor{white}
strip({[}chars{]}) & \seqsplit{从两侧截取指定的字符（可以是多个）} \tn 
% Row Count 24 (+ 3)
% Row 30
\SetRowColor{LightBackground}
\seqsplit{partition(separator)} & \seqsplit{从左侧开始查找separator，找到后将字符串分割为separator左边部分、separator、separator右边部分} \tn 
% Row Count 30 (+ 6)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{字符串处理方法 (cont)}}  \tn
% Row 31
\SetRowColor{LightBackground}
maketrans(x{[}, y{[}, z{]}{]}) & \seqsplit{创建将指定字符映替换为映射的字符的映射表} \tn 
% Row Count 3 (+ 3)
% Row 32
\SetRowColor{white}
\seqsplit{rpartition(separator)} & \seqsplit{从右侧开始查找separator，找到后将字符串分割为separator左边部分、separator、separator右边部分} \tn 
% Row Count 9 (+ 6)
% Row 33
\SetRowColor{LightBackground}
translate(table) & \seqsplit{将指定字符映替换为映射的字符} \tn 
% Row Count 12 (+ 3)
% Row 34
\SetRowColor{white}
replace(old, new {[}, count{]}) & \seqsplit{将字符串中的old字符串中替换成new字符串，最多替换count次} \tn 
% Row Count 16 (+ 4)
% Row 35
\SetRowColor{LightBackground}
rfind(sub{[}, start{[}, end{]}{]}) & \seqsplit{从右侧查找指定字符串位置（不存在返回-1）} \tn 
% Row Count 19 (+ 3)
% Row 36
\SetRowColor{white}
rindex(sub{[}, start{[}, end{]}{]}) & \seqsplit{从右侧查找指定字符串位置（不存在抛出异常）} \tn 
% Row Count 23 (+ 4)
% Row 37
\SetRowColor{LightBackground}
split({[}separator {[}, maxsplit{]}{]}) & \seqsplit{从左侧以separator为分隔符切片，最多maxsplit次} \tn 
% Row Count 26 (+ 3)
% Row 38
\SetRowColor{white}
rsplit({[}separator {[}, maxsplit{]}{]}) & \seqsplit{从右侧以separator为分隔符切片，最多maxsplit次} \tn 
% Row Count 29 (+ 3)
% Row 39
\SetRowColor{LightBackground}
splitlines({[}keepends{]}) & \seqsplit{按行切分字符串，如果keepends=True则显示换行符} \tn 
% Row Count 33 (+ 4)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{字符串处理方法 (cont)}}  \tn
% Row 40
\SetRowColor{LightBackground}
title() & \seqsplit{将字符串转换为标题形式（所有单词首字母大写）} \tn 
% Row Count 4 (+ 4)
% Row 41
\SetRowColor{white}
zfill(width) & \seqsplit{将字符串左侧填充0到指定长度} \tn 
% Row Count 6 (+ 2)
% Row 42
\SetRowColor{LightBackground}
format\_map(mapping) & \seqsplit{使用字典格式化字符串} \tn 
% Row Count 8 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}


% That's all folks
\end{multicols*}

\end{document}