python3_简介和基本数据结构

目录

Python简介和基本数据结构

---

简介

Interpreter 解释器
Bytecode 中间代码, Java、Python、C#需要被解释器编译成中间代码，运行在虚拟机上
函数式语言：古老的编程范式，应用在数学计算、并行处理的场景
python是动态的，强类型语言
弱类型语言, 经常隐式转换类型 ,C,C++,JavaScript
强类型语言, 很少隐式转换类型,
动态语言, 运行时检查类型
静态语言, 编译时检查类型
算法 + 数据结构 = 程序 Program
Python 的解释器：Cpython、Ipython、PyPy、Jython、IroPython
GC 垃圾回收机制，引用计数

注释 #
"""文档字符串"""
#TODO 在代码中标记将要完成的代码
pass 无意义, 使语法完整

基本数据结构

---

int、float、complex复数、bool

int 不限制大小, 没有Long类型
float 可以使科学计数法表示float 2.5e2
使用decimal模块, 实现精确的浮点数计算
complex 表示:a + bj或complex(a, b)
bool True和False等效1和0

math模块

math.floor() 向下取整
math.ceil() 向上取整
\//熵做向下取整floor
math.sqrt() 开方
math.pi
math.e自然常数

位运算符

&位与(有0为0)
| 位或(有1为1)
~按位取反
^异或
<<位左移
>>右移

异或,相同为0, 相异为1

---

list 列表

要改变一个列表中的元素，只能通过索引
可变的，可迭代，可索引
一些方法:

.index(value,[start,[stop]]) 返回索引 时间复杂度O(n)，找不到返回ValueError
.count(value) 次数 O(n)
len() 列表形成过程中中计数, 时间复杂度O(1)
.append(object) -> None O(1) 追加 ,就地修改
.insert(index,object) ->None O(n) 追加，索引可越界>l两侧追加，就地修改
.extend(iteratable) ->None 就地修改
.remove(value) -> None O(n)从左至右匹配第一个value，删除，就地修改
.pop([index]) -> item O(1) 就地修改，不指定索引，从尾部弹出
.clear() -> None 清空
.reverse() -> None 就地修改，少用
.sort(*,key=None,reverse=False) ->None 注意keyword_only 参数 O(n log n), key是一个函数
sorted(iterable[,key][,reverse]) ->list 立即返回一个列表
in not in 判断是否在其中, O(n)


列表使用*乘号，是浅拷贝,
.copy() -> List 返回一个新列表 ，浅拷贝shadow copy
improt copy
copy.deepcopy(obj), 深拷贝


all(list) 列表中全是True -> True
any(list) 列表中有一个True -> True
例: all(\[i > 5 for i in \[6, 7, 8]])

另见deque双向队列

tuple 元组

不可变，可迭代，可索引, 比list占用空间更小
另见namedtuple

---

str 字符串

字符串是有序的字符集合
不可变 可迭代 可索引
编码: Unicode python3中默认UTF-8

一些方法
.join(iterable) -> str 用指定字符串将可迭代对象连接起来，可迭代对象本身元素都是字符串, join方法比+方法效率要高

字符串分割

.split(sep=None,maxsplit) -> 返回list 默认把尽可能多的空白字符连成一个作为分隔符
.rsplit() 从右至左分割
.splitlines([keepends]) -> list of strings 按行来分割\n、\r\n、\r keepends表示是否保留分隔符
.partition(sep) -> (head,sep,tail) ，返回tuple，有且只有一个参数，一切三段
.rpartition(sep)

格式调整

.upper()
.lower()
.swapcase() 交换大小写
.title() -> str 标题的每个单词都大写
.capitalize() ->str 首个单词大写
.center(width[,fillchar]) -> str
.zfill(width) -> 左边用0补齐
.ljust(width[,fillchar]) -> str 左对齐
.rjust(width[,fillchar]) -> str 右对齐

查找替换

.replace(old,new[,count]) -> str 查找替换，count不指定就全部替换
.strip([chars]) -> str 默认将两头的非空字符全部去掉，两头开始去掉字符集
.lstrip([chars]) 左 .rstrip([chars]) 右
.find(sub[,start[,end]]) -> int 从左至右查找，找到返回第一个字符index，找不到返回-1
.rfind(sub[,start[,end]]) -> int 从右至左
.index(sub[,start[,end]]) -> int 找不到，抛出indexerror
.rindex(sub[,start[,end]]) -> int 从右至左
.count(sub[,start[,end]]) -> int 从左至右
.endswith(suffix[,start[,end]]) -> bool
.startswith(prefix[,start[,end]]) ->bool

is系列:

isalnum()数字和字母 isalpha()字母 isdecimal()只包含十进制 .isdigit()全数字
.isidentifier()标识符 .islower()小写 .isupper()大写 .isspace()只包含空白字符

chr(int(ascii)) -> one-character string
ord(character) -> int 字符转Unicode

字符串格式化

printf-style formating
来自C语言的printf函数, 官方文档搜索printf
占位符 ：使用%和格式符组成%s；%r；%d；%c；%i; %o；%x/X；%e/%E；%f/%F；%%：表示%本身
s%调用str(), r%调用 repr(): represent 方法 所有对象都可以被这两个转换
格式： format % values ，values只能是一个对象，或是一个和占位符数目相同的元组或字典
%0-+m.n#(name)s
0不够补0，-左对齐，+正数加+，#十六进制加0x，(name)字典传入
m.n: m总宽度，n表示整数(d)位数或小数(f)位数，不够补零

format函数格式化, 推荐使用
语法: "{} {xxx}".format(*args,**kwargs) -> str
args是位置参数，是一个元组(解构) ，kwargs是关键字参数，是一个字典
{{}} 表示打印花括号
:><^ 对齐, 左右中
“{0[0]}.{0[1]}”.format((‘edu’,’com’)) 支持访问元素
“{{0.x},{0.y}}”.format(p) 支持访问对象属性访问
进制：
“int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}”.format(42)
“int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}”.format(42)
0补零，m.n同printf-style
千位分隔符:‘{:,}’.format(1000000)

string前面加上‘r’， 表示是raw string，不要转意backslash ‘\’ 。
例如，\n 在raw string中，是两个字符，\和n， 而不会转意为换行符。由于正则表达式和 \ 会有冲突，因此，当一个字符串使用了正则表达式后，最好在前面加上’r’

---

bytes 和 bytearray

bytes 不可变字节序列
bytearray 可变字节序列
编码
str.encode(encoding = 'utf-8') ->bytes
解码
bytes.decode(encoding='utf-8') ->str
bytearray.decode(endoding='utf-8') -str

定义(bytes构造函数init)

bytes() 空bytes
bytes(int) 指定字节的bytes，被0填充
bytes(iterable_of_ints) -> bytes [0,255]的int组成的可迭代对象
n = 12
bytes([n]) ==> n.to_bytes(1, ‘big’)
bytes(string, encoding) -> bytes 等价于string.encode()
bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer 从一个字节序列或者buffer复制出一个新的不可变的bytes对象
使用b前缀定义 只允许基本ASCII使用字符形式b’abc9’或使用16进制表示b”\x41\x61”

方法(类似str)
bytes.fromhex(string) -> bytes 类方法，string必须是2个2个16进制的字符形式

bytes和int的转换

bytes.fromhex(‘%x’ % num) : int -> bytes
int.from_bytes(bytes) bytes -> int
num.to_bytes(len,’big’or’little’) int -> bytes

bytearray定义:

bytearray() 空bytearray
bytearray(int) 指定字节的bytearray，被0填充
bytearray(iterable_of_ints) -> bytearray [0,255]的int组成的可迭代对象
bytearray(string, encoding) -> bytearray
bytearray(bytes_or_buffer) 从一个字节序列或者buffer复制出一个新的可变的bytearray对象

---

sequence线性结构, slice切片

线性结构
1. 可迭代 for … in
2. len()可以获取长度
3. 通过下标可以访问
4. 可以切片
list、tuple、str、bytes、bytearray, range都是线性结构
切片
关键是找到切片位置的索引
sequence[start:stop:step]
[::-1]等价于[len(l)::-1]等价于reversed(sequence)
切片的本质是**拷贝**copy, 产生新的对象
lst[:] = sorted(lst) 表示就地修改lst

切片和解构

nums = [9, 8, 7, 6, 5]
nums[2:] = [1, 2, 3]  -> nums[2], nums[3], nums[4] = 1, 2, 3

---

pack封装和unpack解构

封装：
将多个使用逗号分割的值，组合在一起，形成一个tuple
a = 1,2,3 => a = (1,2,3)
解构：
把线性结构的元素解开，并顺序的赋给其它变量
seq = seq 左右两侧侧都为线性结构，并且元素个数一致
加*号，表示接收剩余元素，组成list列表
*args, = [1,2,3]
a = [*range(4)] ==> a = [0, 1, 2, 3]
函数参数结构: func(*tup, **dic)

---

set集合

可变的，无序的，不重复的, 可迭代, 不可索引
元素要求必须可以hash，不可变类型一般可hash
Collection 集合
set(iterable)定义集合
set() 表示空集合 {}表示空字典

一些方法

.add(elem) 有重复的元素，忽略
.update(iterable) 将可迭代对象加入，就地修改
.discard(elem) 丢弃elem，找不到什么也不做
.remove(elem) 移除elem(只移除一个)，找不到keyerror
.pop() -> item 移除并返回任意元素，空集返回keyerror
.clear() 清空, remove所有元素

集合运算符

| union(other) 并集
& intersection(other) 交集
^ symmetric_differece(other) 对称差集
- difference(other)差集
<= issubset(other)
>= issuperset(other)
isdisjoint(other) 没有交集返回True
in / not in 时间复杂度O(1)

---

字典

key-value键值对的数据集合
可变的、无序的、key不重复, 可hash

定义

d = dict()
d = {}
d = dict(a=1,b=2)
dict(iterable) 使用可迭代对象,可迭代对象的元素必须是一个二元结构
d = dict(((1,’a’),(2,’b’)))
dict({‘b’:2}, a=1) 使用一个字典构建另一个字典
dict.fromkeys(iterable, value=None), 类方法, 可迭代对象作key, value取同一个值

访问元素

d[key] 返回key对应的值value, key不存在抛出KeyError异常
.get(key[, default])返回key对应的值value, key不存在返回缺省值，如果没有设置缺省值就返回None
.setdefault(key[, default])返回key对应的值value, key不存在，添加kv对，value为default，并返回default，如果default没有设置，缺省为None
d[key] = value 将key对应的值修改为value, key不存在添加新的kv对

一些方法

.pop(key[, default]) key存在，移除它，并返回它的value, key不存在，返回给定的default, default未设置，则抛出KeyError异常
.popitem() 移除并返回一个任意的键值对, 字典为empty，抛出KeyError异常
.update([other]) -> None 使用另一个字典的kv对更新本字典, key不存在，就添加, key存在，覆盖已经存在的key对应的值, 就地修改, 几种形式:
d.update(red=1)
d.update(((‘red’,2),))
d.update({‘red’:3})
.clear() 清空字典
del语句
del a[‘c’] 对象的引用计数减一
keys、values、items方法遍历字典时字典长度不能被改变
.keys()是一个集合, 可以进行集合运算
.keys(),.values(),.items() -> 有序的可迭代对象，类似range

另见defaultdict, OrderedDict