Python基础知识点

主要内容来源于《Python基础教程（第三版）》，回忆下基本知识点。只写来大部分不太熟悉的，很熟悉的那些知识点就没写

文章目录

Python基础知识点
- Python基础知识点

Python基础知识点

一、基本运算

1、`//`整除

注意点：向下取整，即结果为正，向0靠近，结果为负，偏离0

>>> 10 // -3
-4
>>> -10 // -3
3

2、`%`取余

参考//计算

3、`**` 乘方（求幂）(函数`pow()`)

乘方优先级比求负高

>>> -3 ** 2
-9
>>> (-3)** 2
9
>>>pow(2,3)
8

4、`0x`十六进制、`0`八进制、`0b`二进制

>>> 0xAF
175
>>> 010
8
>>> 0b1011010010
722

5、`round()` 将浮点数向最接近的整数取整 `floor`向下取整`ceil`向上取整

如若同样距离，则取偶整数

>>> round(32.9)
33
>>> import math
>>> math.floor(32.9)
32
>>> math.ceil(32.3)
33
>>> math.ceil(32)
32

6、`cmath`复数模块

7、前缀`r`原始字符串

>>>path='C:\nowhere'
>>>path
'C:\nowhere'
>>>print(path)
C:
owhere
>>>print(r'C:\nowhere')
C:\nowhere

注意：引号仍然需要转义，转义所需要的反斜杠仍然会留在字符串中

8、Unicode、bytes、bytearray

python默认使用UTF-8

二、列表和元组

1、基本操作

1、`:`切片Slicing

第一个索引为开始元素，第二个索引是切片后余下的第一个元素编号

>>> a=[0,1,2,3,4]
>>> a[0:3]
[0,1,2]
>>> a[3:]  #如果切片结束于序列末尾，可省略第二个索引（同理于序列开头）
[3,4]
>>> a[0:3:2] #步长为2，每隔一个元素取一个,可以为负数即从右向左提取元素
[0,2]
>>> a[::2]
[0,2,4]

2、 `+`序列相加

3、 `*`重复序列

>>> a=[1,2,3]
>>> a*3
[1,2,3,1,2,3,1,2,3]
>>> s=[None]*3  #一般用来初始化列表
>>>s
[None,None,None]

4、`in`成员资格

>>>a='abc'
>>> 'b' in a
True

2、列表

2.1 `list`

将任何序列修改为列表

>>>list('Hello')
['H','e','l','l','o']

2.2 `del`删除元素

>>> name=['a','b','c']
>>> del name[1]
>>> name
['a','c']

2.3 给切片赋值

可以通过切片将目标序列替换成不同长度的序列

>>> name=list('perl')
>>> name[2:0]=list('abc')
>>> name
['p','e','a','b','c']
>>> name[1:1]=list('kl') #给空切片插入新元素  插入
>>> name
['p','k','l','e','a','b','c']
>>> name[1:6]=[]  # 将目标元素替换成空切片 删除
>>> name
['p','c']

2.4 列表方法

append eg: lst.append(1) 在列表最后追加内容
clear eg: lst.clear() 清空列表内容

copy 复制列表

>>> a=[1,2,3]
>>> b=a   #将名称b关联到列表a，并没有复制
>>> b[1]=4
>>> a
[1,4,3]
#copy用法如下
>>> a=[1,2,3] 
>>> b=a.copy()  #b关联到a 的副本，类似于a[:],list(a)
>>> b[1]=4
>>> a
[1,2,3]

count 计算指定的元素在列表里出现了多少次
```
>>> [1,2,3,1,2,1].count(1)
3
```
extend 同时附加多个值到列表末尾
```
>>> a=[1,2]
>>> b=[3,4]
>>> a.extend(b)
>>> a
[1,2,3,4]
```
extend会修改当前列表，而拼接方法+会返回新的列表
index 在列表中查找指定值第一次出现的索引
```
>>> a=[1,2,3,4]
>>> a.index(1)
0
```

insert 指定位置插入

>>> a=[1,2,3]
>>> a.insert(1,'abc')
>>> a
[1,'abc',2,3]

pop 从列表中删除一个元素，并返回该元素
```
>>> a=[1,2,3]
>>> a.pop()
3
>>> a
[1,2]
>>> a.pop(0)
1
>>> a
[2]
```
栈可以由pop 和 append来形成

remove 删除第一个为指定值的元素

>>> a=[1,2,3,1]
>>> a.remove(1)
>>> a
[2,3,1]

reverse 按相反序列排列列表元素（不返回任何值）
若要按相反的顺序迭代序列用reversed,返回一个迭代器
sort 就地排序列表
sorted（） 获取排序后的列表副本 x=[2,1,3];y=sorted(x);print(y); >>>[1,2,3] 可用于任何序列，总返回列表

高级排序

sort可选参数 key and reverse

key 使用它为每个元素设置一个键，再根据这些键对元素排序

>>> a=['a','abc','bc']
>>> a,sort(key=len)  #使用函数len，按元素长度排序
>>> a
['a','bc','abc']

reverse 设置为真，即可反序排序

>>> a=[2,3,1]
>>> a.sort(reverse=True)
>>> a
[3,2,1]

3 元组：不可修改的序列

字符串同样不可修改

>>>1,2,3  或者 (1,2,3)  创建元组
(1,2,3)
>>> 1, 创建只有一个值的元组
(1,)
>>> 3*(40+2,)
(42,42,42)
>>> tuple([1,2,3]) 将序列转换成元组
(1,2,3)

三字符串

1 基本操作

1 字符串不可变

因此不能切片赋值，元素赋值

2 `%s` 转换说明符格式设置

s 视为字符串处理

%.3f将值的格式设置为包含3位小数的浮点数

>>> w="wo,%s.%s enough "
>>> v = ('wor','hot')
>>> w % v
"wo,wor.hot enough"

3 `format`

>>> "{},{} and {}".format("first","second","third")
'first,second and third'
>>> "{1},{0} and {2}".format("first","second","third")  # 按照索引赋值
'second,first and third'
>>> "{who} is {value:.2f}".format(value=2.323,who="we") # 名称赋值
'we is 2.32'

2 方法

1 `center` 在字符串两边填充字符，居中字符串

>>> "we".center(6,"*")
"**we**"

2 `find` 查找子串

若找到返回第一个字符的索引，否则返回-1

>>> s="abcdefgh"
>>> s.find('ef',0,3) #0和3指定搜索起点和终点
-1

3 `join` 合并序列的元素

>>> a=['1','2','3']
>>> b='+'
>>> b.join(a)
'1+2+3'

4 `lower` 返回字符串的小写版本

title将字符串换成词首大写，所有单词的首字母大写，其他小写

5 `replace` 将指定子串替换成另一个字符串，并返回替换后的结果

>>>"i am your dad".replace('dad','mom')
'i am your mom'

6 `split` 将字符串拆分成序列

如果未指定分隔符，将在空白字符处拆分

7 `strip` 将字符串开头和末尾的空白删除，并返回删除后的结果

8 `is...` 判断条件

isspace 判断字符串是否是空白
isdigit 判断字符串是否是数字
issupper 判断字符串是否是空白大写

四索引炸掉时

1 字典

字典属于映射数据结构，其中键不可相同

1 `dict`创建字典

>>> item=[('name','meng'),('age',18)]
>>> d=dict(item)
>>> d
{'age':18,'name':'meng'}
>>> k=dict('name'='meng','age'=18)  #关键字实参
>>> k
{'age':18,'name':'meng'}

2 `del d[k]` 删除键为k 的项

3 `k in d`检查字典d是否包含键为k的项

4 `d.clear()` 删除字典d的所有字典项什么都不返回

5 `copy` 浅复制，此处很神奇

>>> x={'name':"meng",'house':['fo','bo','ko']}
>>> y=x.copy()
>>> y=['name']='ting' #替换副本的值，原件不影响
>>> y=['house'].remove('ko')  # 就地修改副本的值，原件也会变化，因为原件也是指向被修改的值
>>> y
{'name':"ting",'house':['fo','bo']}
>>> x
{'name':"meng",'house':['fo','bo']}

深复制 from copy import deepcopy y=x.deepcopy()

6 `fromkeys`创建新字典，包含指定的键，值为None

>>> dict.fromkeys(['name','age'])
{'name':None,'age':None}
>>> dict.fromkeys(['name','age'],'(unKnown)') # 不用None，指定一个值
{'name':'(unKnown)','age':'(unKnown)'}

7 `get` 访问字典项

使用get访问字典不存在的键，不会引发异常，会返回None

>>> d={}
>>>print(d.get('name','N/A'))   #指定返回值，而不是None
'N/A'

8 `d.items()` 返回包含所有字典项的列表，每个元素（key，value）

返回值属于字典视图，不是复制，可迭代

9 `d.keys()` 返回一个字典视图，包含所有的键

10 `d.pop('x')` 从字典中获取键为’x’的值，并返回该值，并删除该键值对

11 `d.popitem()` 随机从字典中弹出一个字典项

12 `setdefault` 获取指定键的值，若没有，则添加指定的字典项

>>> d={}
>>> d.setfault('name','N/A')
>>> d
{'name':'N/A'}

13 `update` 用一个字典中的项来更新另一个字典

>>> d={'name':'meng','age':'16'}
>>> a={'age':'18'}
>>> d.update(a)
>>> d
{'name':'meng','age':'18'}

14 `values`返回一个由字典中的值组成的字典视图，可能包含重复值

五语句

1 `zip` 并行迭代

>>> k=[1,2,3]
>>> v=['a','b','c']
>>> list(zip(k,v))
[(1,'a'),(2,'b'),(3,'c')]

2 `enumerate` 迭代时获取索引

 >>> a=[1,2,3]
 >>> for index, n in enumerate(a):
 			....

3 `sorted reversed` 返回排序和反转后的版本

sorted返回列表

reversed 返回一个可迭代对象

4 简单推导

>>> [x*x for x in range(10) if x%3==0]
[0,9,36,81]
>>> [(x,y) for x in range(2) for y in range(2)]
[(0,0),(0,1)(1,0),(1,1)]

5 `exec` 执行字符串中的python代码 **

>>> exec("print('a')")
a

注意不要和现有命名冲突

6 `eval` 计算用字符串表示的python表达式的值 **

>>> eval("1+2+3")
6

六抽象

1 `def f(*params)`收集参数,允许提供任意数量的参数

前面带*号的参数将会被放进元组中,收集剩下的位置参数

def f(*params):
    print(params)
>>> f('test')
('test',)
>>> f(1,2,3)
(1,2,3)
def f(x,*y,z):
    print(x,y,z)
>>> f(1,2,3,z=4) #一个*号不会收集关键字参数
1,(2,3),4

可使用**收集关键字参数（按顺序）

2 分配参数

调用函数时，使用*

def a(x,y):
	return x+y
>>> d=(1,2)
>>> a(*d)
3

七对象

1 类的命名空间

def foo(x): return x*x
foo = lambda x:x*X
#上面俩大致等价

2 多重继承

如果多个超类以不同的方式实现了同一个方法（同名，不同操作），位于前面的类的方法将会覆盖位于后面的类的方法

3 接口和内省

hasattr(tc,'talk') 检查类tc是否有方法talk
callable(getattr(tc,'talk',None)) 检查属性talk是否可以调用  #getattr None表示指定属性不存在时，返回None
setattr(tc,'name','ting')  #给类tc设置一个属性name，值为'ting'

八异常

1 `raise` 引出异常

>>> raise Exception   #引出异常，并将一个类（必须是Exception的子类）或者实例作为参数
Traceback (most recent call last):
    File "<stdin>", line 1, in ?
Exception
>>> raise Exception('you are wrong')   #指出错误
Traceback (most recent call last):
    File "<stdin>", line 1, in ?
Exception: you are wrong

可以自定义异常类，但必须继承Exception

2 `try/except` 捕获异常

try:
    x=int(input('Enter x:'))
    y=int(input('Enter y:'))
    print(x/y)
except ZeroDivisionError:   # 不加参数，将捕获所有异常！！！慎用
    print("y cant't be zero")
except TyprError #可使用多个except
#或者可以将多个异常放在元组中加入except
except (ZeroDivisionError,TyprError)

异常可从函数向外传播到调用函数的地方

3 捕获异常后，可用raise（不带参数）重新引发异常（继续向上传播）

class MuffledCalcaulator:
    muffled=False
    def calc(self,expr):
        try:
            return eval(expr)
        except  ZeroDivisionError:
            if self.muffled:
                print('Division by zero is illegal')
            else:
                raise
 #muffled=False时，启动抑制异常，方法calc返回None，

4 捕获对象

try:
    x=int(input('Enter x:'))
    y=int(input('Enter y:'))
    print(x/y)
except ZeroDivisionError as e:  捕获对象本身
    print(e)

5 万事大吉时，没有异常时

try:
    x=int(input('Enter x:'))
    y=int(input('Enter y:'))
    print(x/y)
except ZeroDivisionError:  
    print("y cant't be zero")
else:
    print('no wrong')
    
#加入while可以实现循环输入，只有输入正确才会退出循环
while True:
    try:
        x=int(input('Enter x:'))
        y=int(input('Enter y:'))
        print(x/y)
    except ZeroDivisionError:  
        print("y cant't be zero")
    else:
        break

6 `finally`最后

在发生异常时，执行清理工作

x=None
try:
    x = 1/0
finally:
    print('clean up')
    del x
#无论try发生什么异常，都会执行finally子句

7 警告不那么异常

>>> from warning import warn
>>> warn("shit")
__main__:1: UserWarning:shit

警告只显示一次，再次运行什么都不会发生

可以使用filterwarning抑制发出的警告，并指定采取的措施

九魔法方法/特性/迭代器

1 类的构造函数`def init(self):`

2 类的析构函数`def del():` 尽量不要用

3 `super` 调用超类的构造函数

4 基本的序列和映射协议

__len__(self) 返回集合包含的个数
__getitem__(self,key) 返回指定键相关联的值
__setitem__(self,key,value)
__delitem__(self,key)

5 特性`property` 隐藏存取方法

class Rectangle:
    def __init__(self):
        self.w=0
        self.h=0
    def set_size(self,size):
        self.w,self.h=size
    def get_size(self):
        return self.w,self.h
   	size=property(get_size,set_size)  #通过调用函数property，创建了一个特性，并将size关联到这个特性

>>> r=Rectangle()
>>> r.w=10
>>> r.h=5
>>> r.size  自动计算了
(10,5)
>>> r.size=150,100
>>> r.w
150

property(fget,fset,fde;,doc)四个参数

6 静态方法（使用装饰器实现）

class MyClass:
    @staticmethod
    def smeth():
        print('static method')
   	@classmethod
    def cmeth(cls):
        print('class method',cls)
  
>>> MyClass.smeth()  ##无需实例化类
>>> MyClass.cmeth()

7 getattribute/getattr/setattr/delattr 方法

__getattribute__(self,name)在属性被访问时自动调用
__getattr__(self,name)在属性被访问而对象没有这样的属性时自动调用
__setattr__(self,name)试图给属性赋值时，自动调用
__delattr__(self,name)试图删除属性时，自动调用

8 迭代器

1 实现了`iter`的对象是可迭代的，而实现了`next`的对象是迭代器

2 `iter`

>>> it =iter([1,2,3])
>>> next(it)
1
>>> next(it)
2

3 从迭代器创建序列

class TestIterator:
    value=0
    def __next__(self):
        self.value +=1
        if self.value>4: raise StopIteration
        return self.value
   	def __iter__(self):
        return self
    
>>> ti = TestIterator()
>>> list(ti)
[1,2,3,4]

9 生成器

1 `yield`

nested = [[1,2],[3,4],[5]]
def flatten(nested)
	for sublist in nested:
        for element in sublist:
            yield element   #每次调用函数，程序运行到这里就会冻结，并返回element。直到下次调用，再从这里开始运行
>>> list(flatten(nested))
[1,2,3,4,5]

2 简单生成器

sum(i**2 for i in range(10))

3 递归式生成器

nested = [[1,[2],3,[3,4],[5]]
#若要对任意深的列表进行迭代呢？
def flatten(nested)
    try:
		for sublist in nested:
        	for element in flatten(sublist):
            	yield element 
    except TypeError:
		yield nested

十开箱即用：模块

1 添加模块所属路径

#假设模块位于'C:/python'下
import sys
sys.paath.append('C:/python')

2 `pycache`

导入模块时，会生成__pycache__的子目录，包含处理后的文件

只导入一次，防止猫追尾巴，互相导入

3 `if name=='main':` 当该文件被作为程序执行时成立，作为模块导入时不成立

4 解释器去哪里找模块

import sys,pprint
pprint.pprint(sys.path)

5 包

模块位于.py文件中，而包是一个目录，必须包含文件_init_.py

如果像普通模块一样导入包，包的内容就是文件_init_.py的内容

6 探索模块的使用

1 `dir（module_name）` 查明模块包含哪些东西

2 变量`all`

from copy import * 将只会导入copy.__all__中提供的方法

3 `help(copy.copy)` 获取该方法的信息

4 `print(range.doc)` 查看range文档

5 `print(copy.file)` 查看copy源代码的位置

7 时尚流行的模块（快乐的孩，欢快的用）

1 `sys`

sys.argv 包含传递给Python解释器的参数，包括脚本名

2 `os`

os.system 用于运行外部程序
- os.system('/usr/bin/firefox')
- os.system(r'C:\"Progrem Files"\"Mozilla Firefox"\firefox.exe')

3 `set`集合

字典–散列表

列表–动态数组

>>> set(range(4))  #直接创建集合（不能仅用{}创建，这会创建一个空字典）
{0,1,2,3}

集合不重复，无序（集合主要用于成员资格检查）

交集，并集，子集等。。。

集合可变，因此不能为字典的键，集合只能包含不可变（可散列）的值，因此集合不能包含集合

a=set()
b=set()
a.add(frozenset(b))  #frozenset类型，表示不可变（可散列）的集合

4 `heap`堆(优先队列)

只有模块heapq

heappush(heap,x) 将x压入堆中
heappop(heap) 从堆中弹出最小的元素
heapify(heap) 让列表具备对特征
heapreplace(heap,x) 弹出最小的元素，并将x压入堆中
nlargest(n,iter) 返回iter中n个最大的元素
nsmallest(n,iter)返回iter中n个最小的元素

5 双端队列

在collections包含deque

from collections import deque
>>> q=deque(range(5))
>>> q.append(5)
>>> q.appendleft(6)
>>> q
deque([6,0,1,2,3,4,5])
>>> q.pop()
5
>>> q.popleft()
6
>>> q.roate(3)
>>> q
deque([2,3,4,0,1])
>>> q.roate(-1)
>>> q
deque([3,4,0,1,2])

6 `time`

日期元组中的字段：

索引：0：年，1：月；2：日；3：时；4：分；5：秒；6：星期；7：儒略日；8：夏令时；

time.time() 当前时间（新纪元开始后的秒数，Unix中新纪元为1970年）

sleep(secs) 休眠

7 `random`

random() 返回一个0-1（含）的随机实数
getrandbits(n) 以长整数方式返回n个随机的二进制位
uniform(a,b) 返回一个a~b（含）的随机实数
choice(seq) 从序列seq中随机选择一个元素
sample(seq,n)从序列seq中随机选择n个不同的元素
shuffle() 打乱序列

8 `re`

正则表达式

通配符句点与除换行符外的任意字符都匹配，只与一个字符匹配
对特殊字符转义\
字符集 [] eg: [pj] 与p，j 匹配[a-z],与a到z之内的字符匹配
排除指定字符集 [^abc] 匹配除a,b,c外的字符
二选一，子模式 p(ython|erl)
重复0，1，多次：（abc)*
重复1，多次：（abc)+

re模块使用正则表达式

。。。。百度。。。

十一文件

1 打开文件`open`

open参数mode

'r' 读取模式（默认）
'w' 写入模式 #文件不存在时，自动创建，若文件存在，则文件中已有内容会被删除（截断）
'x' 独占写入模式 #若文件已存在，则引发FileExistsError异常
'a' 附加模式
'b' 二进制模式
't' 文本模式
'+' 读写模式 r+不会截断文件，w+会

默认模式为rt : 默认将文件视为经过编码的Unicode文本，因此自动执行解码和编码，默认使用UTF-8编码

2 读取

readline 读取一行，并返回

3 关闭

with open('file.txt') as f:

4 迭代文件内容

1 每次一个字符（或字节）

with open(filename) as f:
    while True:
        char = f.read(1)
        if not char: break
         process(char)

2 每次一行

with open(filename) as f:
    while True:
        line = f.readline()
        if not  line : break
         process( line )

3 全部内容

with open(filename) as f:
    for line in f.readlines():
        process(line)
#或者
with open(filename) as f:
    for char in f.read():
        process(char)

暂时没了，后续补充多线程的高级知识点

原文链接：https://blog.csdn.net/jiamenghu/article/details/114261388

Python基础知识点

文章目录

Python基础知识点

一、基本运算

1、//整除

2、%取余

3、** 乘方（求幂）(函数pow())

4、0x十六进制、0八进制、0b二进制

5、round() 将浮点数向最接近的整数取整 floor向下取整ceil向上取整

6、cmath复数模块

7、前缀r原始字符串

8、Unicode、bytes、bytearray

二、列表和元组

1、基本操作

1、:切片Slicing

2、 +序列相加

3、 *重复序列

4、in成员资格

2、列表

2.1 list

2.2 del删除元素

2.3 给切片赋值

2.4 列表方法

3 元组：不可修改的序列

三 字符串

1 基本操作

1 字符串不可变

2 %s 转换说明符 格式设置

3 format

2 方法

1 center 在字符串两边填充字符，居中字符串

2 find 查找子串

3 join 合并序列的元素

4 lower 返回字符串的小写版本

5 replace 将指定子串替换成另一个字符串，并返回替换后的结果

6 split 将字符串拆分成序列

7 strip 将字符串开头和末尾的空白删除，并返回删除后的结果

8 is... 判断条件

四 索引炸掉时

1 字典

1 dict创建字典

2 del d[k] 删除键为k 的项

3 k in d检查字典d是否包含键为k的项

4 d.clear() 删除字典d的 所有字典项 什么都不返回

5 copy 浅复制，此处很神奇

6 fromkeys创建新字典，包含指定的键，值为None

7 get 访问字典项

8 d.items() 返回包含所有字典项的列表，每个元素（key，value）

9 d.keys() 返回一个字典视图，包含所有的键

10 d.pop('x') 从字典中获取键为’x’的值，并返回该值，并删除该键值对

11 d.popitem() 随机从字典中弹出一个字典项

12 setdefault 获取指定键的值，若没有，则添加指定的字典项

13 update 用一个字典中的项来更新另一个字典

14 values返回一个由字典中的值组成的字典视图，可能包含重复值

五 语句

1 zip 并行迭代

2 enumerate 迭代时获取索引

3 sorted reversed 返回排序和反转后的版本

4 简单推导

5 exec 执行字符串中的python代码 **

6 eval 计算用字符串表示的python表达式的值 **

六 抽象

1 def f(*params)收集参数,允许提供任意数量的参数

2 分配参数

七 对象

1 类的命名空间

2 多重继承

3 接口和内省

八 异常

1 raise 引出异常

2 try/except 捕获异常

3 捕获异常后，可用raise（不带参数） 重新引发异常（继续向上传播）

4 捕获对象

5 万事大吉时，没有异常时

6 finally最后

7 警告 不那么异常

九 魔法方法/特性/迭代器

1 类的构造函数def __init__(self):

2 类的析构函数def __del__(): 尽量不要用

3 super 调用超类的构造函数

1、`//`整除

2、`%`取余

3、`**` 乘方（求幂）(函数`pow()`)

4、`0x`十六进制、`0`八进制、`0b`二进制

5、`round()` 将浮点数向最接近的整数取整 `floor`向下取整`ceil`向上取整

6、`cmath`复数模块

7、前缀`r`原始字符串

1、`:`切片Slicing

2、 `+`序列相加

3、 `*`重复序列

4、`in`成员资格

2.1 `list`

2.2 `del`删除元素

三字符串

2 `%s` 转换说明符格式设置

3 `format`

1 `center` 在字符串两边填充字符，居中字符串

2 `find` 查找子串

3 `join` 合并序列的元素

4 `lower` 返回字符串的小写版本

5 `replace` 将指定子串替换成另一个字符串，并返回替换后的结果

6 `split` 将字符串拆分成序列

7 `strip` 将字符串开头和末尾的空白删除，并返回删除后的结果

8 `is...` 判断条件

四索引炸掉时

1 `dict`创建字典

2 `del d[k]` 删除键为k 的项

3 `k in d`检查字典d是否包含键为k的项

4 `d.clear()` 删除字典d的所有字典项什么都不返回

5 `copy` 浅复制，此处很神奇

6 `fromkeys`创建新字典，包含指定的键，值为None

7 `get` 访问字典项

8 `d.items()` 返回包含所有字典项的列表，每个元素（key，value）

9 `d.keys()` 返回一个字典视图，包含所有的键

10 `d.pop('x')` 从字典中获取键为’x’的值，并返回该值，并删除该键值对

11 `d.popitem()` 随机从字典中弹出一个字典项

12 `setdefault` 获取指定键的值，若没有，则添加指定的字典项

13 `update` 用一个字典中的项来更新另一个字典

14 `values`返回一个由字典中的值组成的字典视图，可能包含重复值

五语句

1 `zip` 并行迭代

2 `enumerate` 迭代时获取索引

3 `sorted reversed` 返回排序和反转后的版本

5 `exec` 执行字符串中的python代码 **

6 `eval` 计算用字符串表示的python表达式的值 **

六抽象

1 `def f(*params)`收集参数,允许提供任意数量的参数

七对象

八异常

1 `raise` 引出异常

2 `try/except` 捕获异常

3 捕获异常后，可用raise（不带参数）重新引发异常（继续向上传播）

6 `finally`最后

7 警告不那么异常

九魔法方法/特性/迭代器

1 类的构造函数`def init(self):`

2 类的析构函数`def del():` 尽量不要用

3 `super` 调用超类的构造函数

5 特性`property` 隐藏存取方法

1 实现了`iter`的对象是可迭代的，而实现了`next`的对象是迭代器

2 `iter`

1 `yield`

十开箱即用：模块

2 `pycache`

3 `if name=='main':` 当该文件被作为程序执行时成立，作为模块导入时不成立

1 `dir（module_name）` 查明模块包含哪些东西

2 变量`all`

3 `help(copy.copy)` 获取该方法的信息

4 `print(range.doc)` 查看range文档

5 `print(copy.file)` 查看copy源代码的位置

1 `sys`

2 `os`

3 `set`集合

4 `heap`堆(优先队列)

6 `time`

7 `random`

8 `re`

十一文件

1 打开文件`open`