Python基础知识点
主要内容来源于《Python基础教程(第三版)》,回忆下基本知识点。只写来大部分不太熟悉的,很熟悉的那些知识点就没写
文章目录
- Python基础知识点
- Python基础知识点
- 一、基本运算
- 二、列表和元组
- 三 字符串
- 四 索引炸掉时
- 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``返回一个由字典中的值组成的字典视图,可能包含重复值
- 五 语句
- 六 抽象
- 七 对象
- 八 异常
- 九 魔法方法/特性/迭代器
- 十 开箱即用:模块
- 十一 文件
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)
暂时没了,后续补充多线程的高级知识点