python基础知识点

1系列解包赋值
左右个数必须保持一致
a,b =b,a实现交换
2变化参数
函数传值*是一个turple
def func(kargs):
print(kargs)
a,b,c=1,2,3
func(a,b,c)
(1, 2, 3)
*是一个字典，
def func(kargs):
for i in kargs:
print(kargs.get(i))
func(a=1,b=2,c=4)
1，2，4
3解包裹： 和在函数调用时使用
一个星号的序列解包相当于位置参数，优先处理
demo((3,), **{‘a’:1, ‘b’:2})
这样’a’:1 重新给a赋值导致错误
4可变不可变对象
可变对象：对象存放在地址中的值不会被改变
dict set list属于可变对象
（所谓的改变是创建了一块新的地址并把新的对象的值放在新地址中原来的对象并没有发生变化）
可变对象对于自身的任意方法，是不需要重新开辟内存空间的，而是原地改变：
m=[5,9]
m.append(6)
print(m)
这样m的地址并不会改变
+=不会改变源地址 +=相当于entend相当于自身的函数
但是a = a + [4]这样重新赋值就会改变a的地址
不可变对象：对象存放在地址中的值会原地改变
tuple属于不可变对象
在除了tuple的不可变变量中，只要两个变量的数据类型相同并且值也相等，那么这两个变量的地址也相同

5深浅拷贝
copy.copy()
copy.deepcopy()
浅拷贝：不拷贝子对象的内容，只是拷贝子对象的引用。
浅拷贝中如果某个元素是列表a = [10, 20, [5, 6]]
b = copy.copy(a)
那么更改b[2].append会同时改变a中的值
但是单一元素如改变b[1]a不会改变或者b.append
深拷贝：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象
不可变对象包含可变子对象是可以改变的
a = (10,20,[5,6]) 可以改变[5,6]中的值

6复数
aa=complex(123,-12)
aa=123-12j注意这里边用的j
print aa.real
#output实数部分 123.0
print aa.imag
#output虚数部分 -12.0
7.pyc文件过程：
python代码的编译结果就是PyCodeObject对象，加载模块时，PyCodeObject对象被写入pyc文件。
python先把代码编译成字节码对应PyCodeObject对象
python test.py会对test.py进行编译成字节码并解释执行，但是不会生成test.pyc。
如果想生成test.pyc，我们可以使用python内置方法compile来编译。
import test这样就会生成test.pyc 相当于java下的jar包
8生成器推导式
生成器推导式生成的不是列表也不是元组，而是一个生成器对象
我们可以通过生成器对象，转化成列表或者元组
也可以使用生成器对象的__next__() 方法进行遍历，或者直接作为迭代器对象来使用
元素访问结束后必须重新生成生成器才能重新访问
s = (x2 for x in range(5))
s是一个generator object
9列表推导式
推导式生成列表a = [x2 for x in range(5)]
a = [x*2 for x in range(100) if x%9==0]
10列表的append 和extend 区别
list.append(object) 向列表中添加一个对象object
list.extend(sequence) 把一个序列seq的内容添加到列表中
append如果是个列表，这个列表会变成一个元素添加到list
extend的列表有几个元素就会在list中增加几个元素
11。lambda函数 reduce map eval
lambda arg1,arg2,arg3… : <表达式> arg1/arg2/arg3为函数的参数。
<表达式>相当于函数体。运算结果是：表达式的运算结果。

eval 把str内容当函数"a+b"就后可以执行这样容易造成不必要的错误

map函数
	map()函数接收两个参数，一个是函数，一个是序列 返回一个列表
	map函数
	def f(x):
	return x * x

	map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
	[1, 4, 9, 16, 25, 36, 49, 64, 81]
	map高级之处为
	map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])map可以参与各种复杂变换
	['1', '2', '3', '4', '5', '6', '7', '8', '9']
reduce函数
	reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
	接受也是函数f和列表
	
	拓展：str转换成int
	def fn(x, y):
	return x * 10 + y
	def char2num(s):
		return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
	reduce(fn, map(char2num, '13579'))
	13579
filter是个过滤函数

12异常
注意跟JAVA不同的是没有catch这个东西
try:
except IOError:
finally:
else:(未发现异常执行)注意是未发现 并不是没有匹配到Error
raise手动输出，引发一个异常，需要定义异常类型

13while else执行条件
当while正常结束循环时执行else中的内容，由break跳出的循环不执行
14查看关键字
help(“keywords”)
15super() mro c3
super()中省略了父类名称
super继承顺序为其mro序列下一个类
16if name = __main__作用
第一是 python文件通常有两种使用方法，第一是作为脚本直接执行
第二是 import 到其他的 python 脚本中被调用（模块重用）执行
直接执行 test.py，结果如下图，可以成功 print 两行字符串
即，if name"main": 语句之前和之后的代码都被执行。
在import时，if name"main"后边的语句不会被执行
test的__name__是test
test1导入__name__是test1 不等于test所以不会执行test的if name==“main”
17闭包问题 nonlocal global
典型错误用例
def foo():
a = 1
def bar():
a = a + 1
return a
return bar

//************
flist = []
for i in range(3):
	def foo(x):
		print(x + i)
flist.append(foo)
for f in flist:
	f(2)
	输出444
python默认函数中左边的变量是局部函数，在本例中，a是bar中的局部函数而不是foo中的故未初始化
想解决只需要在
def bar():
	nonlocal a声明这里a不是局部变量而是外部变量
    a = a + 1	
    return a
global声明是全局变量

18文件读写 file os 等等
open函数打开文件
file object = open(file_name [, access_mode][, buffering])
access_mode是r只读，w写入等等选择
buffering 取0就不会被寄存
buffering通常可以省略，
fo = open(“foo.txt”, “w”)
file.name
file.mode返回文件的访问模式
file.closed 未关闭返回true 关闭则返回false
file.close()关闭文件
fo.write(“”)写入文件
read(index) 从文件开头读取到index位置
fo.tell()找到当前index的位置
import os
重新命名：os.rename(currentfile,newname)
删除文件：os.remove(file_name)
os.mkdir()创建目录
os.getcwd()给出当前目录
os.rmdir()删除目录
19time模块使用
import time
时间有三种表达方式：
timestamp表示从1970年开始计时按秒计算偏移量 time.time()
struct_time时间元组，共有九个元素组 time.localtime()
format string格式化时间字符串，具有可读性
重点：三种模式之间的相互转化
struct_time是中间的，可以跟其他的两个相互转化
struct–>format time 去strftime() 回来 strptime()
struct–>Timestamp 去mktime() 回来 localtime()/gmtime()
time.strptime(‘2011-05-05 16:37:06’, ‘%Y-%m-%d %X’)
time.strftime("%Y-%m-%d %X",time.localtime())
重点：
%Y完整年份 %m 月 %d日 %X本地相应时间
%H小时 %M 分钟 %S 秒
datetime是个模块包括：date类 time类
date.today()
20turtle模块使用
import turtle
turtle.showturtle()显示箭头
write写
forword(200)向前200
color(“red”)画笔颜色改变
left(90)左转90度
goto(x,y)去
penup()抬笔
pendown()下笔
circle(100)半径100画圆

21 re模块正则表达式
正则表达式
预定义字符集
\d匹配数字0-9
\D匹配非0-9的
\w匹配字母
\W匹配所有非字母
\s匹配所有空格等特殊符号
\S匹配所有非空格等特殊符号
d w s 三个
*0-n次
+至少一次
|或
^/&开始符号，结束符号
[]字符集 匹配括内容
{m} a{2}至少匹配a两
{m,n}匹配至少m次，最多n次
\转义符号或其他三种
？可以用来表示0次或者1次/还可以用来表示非贪婪匹配

re模块
	compile():返回一个对象模式，可以用来findall(这个对象)
	match():print(re.match('com','comwww.runcomoob').group()) 从开始进行匹配否则返回None
	search():print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0))
	re.findall遍历匹配，可以获取字符串中所有匹配的字符串，返回一个列表。
	finditer()得到迭代器
	split('\d','adsva1das' )分割返回列表

22sys模块
sys.argv: 实现从程序外部向程序传递参数。
sys.path: 获取指定模块搜索路径的字符串集合，可以将写好的模块放在得到的某个路径下，就可以在程序中import时正确找到。
sys.getdefaultencoding(): 获取系统当前编码，一般默认为ascii。
sys.setdefaultencoding()：设置
23修饰器和多重修饰器
见另一张
@por

24列表
常见函数
append
extend
insert
index
count
copy
删除函数
remove
pop
clear
del
排序函数：
sort
reverse
这里list.是自己的方法，不会新建list
sorted(a)
reversed(a)就会重新创建一个函数 但是reversed只返回一个迭代器，不会排序

range函数(3,15,2) 左闭右开 -1倒序

25元组
zip生成
>>> a = [10,20,30]
>>> b = [40,50,60]
>>> c = [70,80,90]
>>> d = zip(a,b,c)
>>> list(d) [(10, 40, 70), (20, 50, 80), (30, 60, 90)]
可以由生成器推导式生成

26字典
创建方式
{}
dict()
传元组[(1,2),(1,2,)]
直接传值b = dict(name=‘gaoqi’,age=18,job=‘programmer’)
通过dict.fromkeys 函数创建一个空的 a = dict.fromkeys([‘name’,‘age’,‘job’])
zip()生成
k = [‘name’,‘age’,‘job’]
v = [‘gaoqi’,18,‘techer’]
d = dict(zip(k,v))
访问方式
get()
a.items()
a.keys()
a.values()
“name” in a
添加： a[‘age’]=16
更新：update() 有的覆盖，没有的添加
删除：del pop clear 注意字典没有remove
popitem()随机删除一个键值对

hash计算 bin(hash(str))从右向左查找为空就插入

27 new 继承一些不可变的class时使用 是类级别方法
init 实例级别方法
28 枚举enum
from enum import Enum
class Color(Enum):
red = 1
green = 2
blue = 3
成员名不可重复
成员值允许相同，第二个成员的名称被视作第一个成员的别名
@unique则不能成员值相同
属性有name value 跟字典很像

29编码类型
isinstance(s, str)来判断一个字符串是否为一般字符串
unicode
GB国标
utf-8 #-- coding:utf-8 -- encoding声明
str.encode(encoding=‘UTF-8’,errors=‘strict’)函数定义编码

30python中的反射
利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！
getattr(object, name , default)
hasattr(object, name)
setattr(object, name, value)
delattr(object, name)
这些可以直接操作类中的非私有属性

对于类中的私有属性
@property（相当于声明get函数）
def area(self):
    return self.__area
@area.setter
def area(self, value):
	self.__area = value
@area.deleter
def area(self):
	self.__area = 0

31 重点字符串

a = "hello WORLD"

print(a.upper())//全大写
print(a.lower())//全小写
print(a.capitalize())//第一个字符大写

print(a.startswith('h'))
print(a.startswith('e', 1, 3))
		endswith
a = " hello WORLD "
print(a.lstrip()) 去除首尾指定字符这里是space
print(a.rstrip())
print(a.strip())

print(a.split()) 分割

a = "abcd"
print(list(a))
print(max(a)) //最右边
print(min(a))	//第一个

a = """one
two
three"""
print(a)
print(a.splitlines())

a = """
one
two
three
"""
print(a)
print(a.splitlines())

a = 'abc'.join(['1', '2', '3'])
print(a)

print(a.index("b"))

b = a.encode(encoding='utf-8')
print(b)
print(b.decode(encoding='utf-8'))

32 类方法，静态方法
@classmethod类方法
def printCompany(cls):
print(cls.company) self变成cls

静态方法
	@staticmethod def add(a, b): # 静 态 方 法 
		print("{0}+{1}={2}".format(a,b,(a+b))) 
		return a+b

33栈帧
用户栈上的（当然内核栈同样适用）每一次函数调用涉及的相关信息的记录单元
栈帧的主要作用是用来控制和保存一个过程的所有信息的。