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)

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