Python学习重点笔记专业资料.doc

Python基本数据类型解说

1、 python一切皆为对象
2、 Python一切皆为指针
3、 基本数据类型
Int bool(True False) string list tuple（元组） dict字典

4、 数据类型可变与不可变
Int bool string 不可变类型
List tuple dict 可变类型
5、 变量赋值一切皆为引用，动态性与动态类型只为什么不在动态。

Type isinstance

字符串认知与应用

1、 字符串概念
2、 len之结识
3、 转义符让文本更好解决 要转义字符前面加反斜杠
4、 字符串前面小尾巴究竟是什么
u”哈哈” Unicode编码
r”哈哈” 不转码
5、 替代字符串 replace
6、 字符串拼接
join([a,b,c])
7、 读写文献
d=open(‘文献名’ ，‘w’)
d.write(‘hi.\nsecond hi.’)
d.close()

d=open(‘文献名’ ，‘r’)
d.readline() / d.read(0)

Python基本数据类型解说

1、 数据类型与可变类型变量
2、 再谈字符串
序列究竟是什么
1、三个符号区别’’,””,””” “””
2、如何修改字符串 replace find
3、格式化细究
1、%格式化方式

“this is a %s” % “apple”

2、format格式化方式
“this is a {1} {0}” .format(“apple” ，“my”)
“this is a {fruit} {whose}” . format(fruit=“apple” ，whose=“my”)
3、为什么要用format
4、尚有一种办法，字典来了

4、再议打开文献 linecache
1、读文献.getline()
2、读文献.getlines()

列表
1、有序集合
2、通过偏移来索引，从而读取数据
3、支持嵌套
4、可变类型

1、 切片 slice a = [1 ，2 ，3，4，5，6，7] number[1：3] 2 3
正向索引
反向索引
默认索引

2、 添加操作
+生成一种新列表
Extend 接受参数并将该参数每个元素添加到原有列表中
Append 添加任意对象到列表末端
Insert 插入任意对象到列表中，可以控制插入位置。

3、 修改操作
修改列表自身只需要直接赋值就行
4、 删除操作
Del 通过索引删除指定位置元素 非函数 例如：del number[9]
Remove 移除列表中指定值第一种匹配值
Pop 返回最后一种元素，并从list中删除

5、 成员关系：
In/not in 咱们可以判断一种元素与否在列表里 返回一种bool类型

6、 列表推导式：
[expr for iter_var in iterable]
一方面迭代iterable里所有内容，每一次迭代，都把iterable里相应内容放到iter_var中，再在表达式中应用该iter_var内容，最后用表达式计算值生成一种列表。

例如要生成一种包括1到10列表
[x for x in range(1,11)]

[expr for iter_var in iterable if cond_expr]
只有满足条件才可以生成列表。

7、 排序翻转 sort reverse

1、 内置list办法
A = “cdc”
List(a)
返回一种列表，参数是可迭代对象。里面输出内容还是保持了传入可迭代对象元素和顺序.
如果参数为空，则返回一种空列表
2、 xrange和range详细区别
2.1、xrange用法
Xrange(开始，结束，步长)

Range直接生成一种列表对象
Xrange“它是生成一种xrange对象

Xrange用法：
1、 操作一种非常大数据，并且内存比较吃紧时。
2、 Xrange普通用在循环里边。

简朴函数
1、def定义函数核心字
2、形参不需要类型修饰
3、函数体定义需要：
4、函数体整体进行缩进
5、函数可以拥有返回值，若无返回值返回None，相称于C中NULL
局部变量与全局变量
1、局部变量作用域覆盖全局变量
2、函数内有局部变量定义，解释器不使用全局变量，局部变量定义晚于被引用，报错
3、代码体内可以直接访问全局变量
4、函数体内修改全局变量，必要使用核心字global

表达式
算术表达式
逻辑表达式
关系表达式
位运算

语法格式缩进表达，函数、分枝、循环。：千万不能丢

List列表（数组）
元组Tuple(只读列表)
字典Dictiontory 键值对
Direct help(dict)
X = Dict(((‘fdfd’ ，‘erer’) ，))
X = Dict(“fdf” = “ee”)
X.fromkeys(keys，values)
办法： keys values() items() get() setdefault(keys,values)

集合： set frozenset

字符串解决与特殊函数：单引号 双引号 三引号（支持字符串跨行）

模块：文档字符串
‘xxxxxxx’ xxx.__doc__
核心字参数： def hello(name ，words)

Hello(name=”mmmm” ，words=”dfdfdf”)
默认参数
收集参数

lambda 参数：表达式（返回值）

filter()
map()

import sys
sys.setrecursionlimit(1000000) 递归最大深度

在Python类中定义办法普通有3种：实例办法、类办法、以及静态办法
实例办法普通以self做为参数
类办法普通以cls做为参数，定义时使用@classmethod,那么通过引用必然是类对象属性和办法。
静态办法不需要默认任何参数，定义时使用@staticmethod

引入模块办法：
import math
math.sin(32)
或者
from math import *
sin(32)

常量命名时普通使用大写字母，如：NAME=’hello’

OS模块： 文献操作

永久保存（保存为文献）
#写
Import pickle
Mylist = []
Picklefile = open(‘mylist.pkl’ ，‘wb’)
Pickle.dump(Mylist ，picklefile)
Picklefile.close()
#读
Picklefile = open(‘mylist.pkl’ ，‘rb’)
Mylist = pickle.load(pickfile)

Exception
try:

except Error [as reason]:

finally：

raise Error类型 引起异常

Else语句
要么如何，要么不如何 if else语句
干完了能如何，干不完就别想如何 while else 语句

没有问题，那就干吧
Try:

Except Error [as reason]:
Else:

with语句(关闭文献)
例如:
Try:
F = open(“hello.txtx” ，‘r’)
Except OSError as reason:
Print(reason)
Finally:
F.close()

Try:
With open(“hello.txtx” ，‘r’) as f
Except OSError as reason:
Print(reason)

类属性与办法
咱们商定：类名以大写字母开头

OO特性 OOP面向对象编程
封装（信息隐蔽技术）
继承
多态
构造办法__init__(self ，paramer1，paramer2，.......)
公有和私有 无核心字，理论上类办法与属性都是公开，Python采用了一种name mangling （名字改编 ， 名字重组）即添加__即为私有属性。（可以通过 __类名__ 属性访问私有属性）

继承：
class 子类名（父类名1，父类名2,.....） 如果子类中定义与父类名字同样办法或者属性，则覆盖父类属性或办法。
使用super（）函数 super().__init__()

类定义、类对象和实例对象

属性名与办法名相似，属性覆盖办法。
绑定：Python规定办法必要有实力才干被调用，这种限制就是绑定。
BIF
Issubclass(子类，（父类或父类元组）)
Isinstance(对象类型，（父类或父类元组）)
Hasattr(对象，属性名)
Getattr(object ，name[,default])
Getattr(A ，‘x’，“您所打印属性不存在”)
Setattr(object，name，value)
Delattr(object，name)
(属性设立属性)property(fget，fset，fdel，doc)
例如;
X = property(getsize ，setsize，delsize)

构造和析构
__new__(cls[，.....])
__init__(self[，.....])

__del__(self)

time模块

属性访问：

描述符：将某种特殊类型类实例指派给另一种类属性。
特殊类型实现三个办法
__get__(seld ，instance，owner) 用于访问属性，它返回属性值。
__set__(self，instance，value) 将在属性分派操作中调用，不反回任何内容。
__delete__(self ，instance) 控制删除操作，不反回任何内容

定制容器：
合同（编程接口）
如果定制容器不可变，需要定义__len__(self)和__getitem__(self,key)办法。
如果定制容器不可变，需要定义__len__()、__getitem__()、__setitem__(self,key，value)和__delitem__(self，key)办法。

迭代器：
iter()
next()
例如：
string = “hello”
it = iter(string)
next(it)

生成器：是迭代器一种实现。普通函数加上yield即可。协同进程就是可以运营独立函数调用，函数可以暂停或者挂起，并在需要时候从程序离开地方继续或者重新开始。
def myGen():
print("hello")
yield 1
yield 2

成果：
>>> next(m)
hello
1
>>> next(m)
2

模块：
容器：数据封装
函数：语句封装
类：办法和属性封装
模块：程序
命名空间：
导入模块：
第一种：import 模块名
第二种:from 模块名 import 函数名
第三种：import 模块名 as 新名字
If __name__ = ‘__main__’(区别模块与主程序)
搜索途径：
import sys
Sys.path
Sys.path.append(“途径”) 添加搜索途径
包（package）:
1、 创立一种文献夹。（包名）
2、 文献夹内创立一种__init__.py文献，可以是空文献。
3、 导入包 import 包名.模块名
Python自己带着电池 Batteries included
开发哲学 优雅、明确、简朴
开发者哲学 用一种办法，最佳是只有一种办法来做一件事
Python原则库
Import 模块名
模块名.__doc__
dir(模块名) 属性
模块名.__all__ 调用办法
模块名.__file__ 查看文献途径

爬虫：
Python如何访问互联网。
urllib URL + lib
URL 有三某些构成： 合同 IP地址 资源详细地址
import urllib.request

response = urllib.request.urlopen("")
cat_img = response.read()

with open("cat_500_600.jpg"，'wb') as f:
f.write(cat_img)

修改headers：
通过Requestheaders参数修改
通过Request.add_header()办法修改

延迟提交时间：
import time
time.sleep()

代理：
环节：
1、 参数是一种字典{类型：代理IP：端标语}
proxy_support = urllib.request.ProxyHandler({})
2、 定制、创立一种opener
opener= urllib.request.build_opener(proxy_support)
3、 安装opener
urllib.request.inatall_opener()
4、 调用opener
opener.open(url)

正则表达式：
import re
re.search(正则表达式， 字符串)
元字符： . ^ $ * + ? { } [ ] \ | ()
re.findall(正则表达式， 字符串)
如果你需要重复使用某个正则表达式，那么你可以先将该正则表达式编译成模式对象。
咱们使用re,compile()来编译。
例如：p = pile(r”[A-z]”)
r = p.search(字符串)
r.group()

Scrapy：

Tkinter： TK + Interface (默认GUI库)
import tkinter

Django:

Python 长处：
简朴、优雅、明确
强大第三方库
易移植
面向对象
可扩展（C\Java\C#.........）
Python缺陷：
代码不能加密
速度慢

Linux编译Python文献时，必要添加一句：
#!/usr/bin/env python

Python解释器：
1、 Cpython 官方原则
2、 Ipython
3、 Jython
4、 PYPY
5、 IronPython .net version

Python编程风格：
语法规定：
缩进统一
变量 ： 大写（常量） 小写（变量）

Python数据类型

按特性划分：
1、 数字类型
整型
布尔型（True False） 长整型 原则整形
非整型
双精度浮点型 复数 decimal（不是內建数据类型）
2、 序列类型
字符串(str) 元组 列表
3、 映像类型
字典（dict）
4、 集合类型
可变集合 不可变集合
Python注释
单行注释：#
多行注释 三引号

理解字符编码：
ASSIC码
Unicode码
UTF-8码（Python3 默认编码方式）
# _*_ coding:utf-8 _*_

导入模块：
Import 模块名
from模块名 import
Import 模块名 as new

顾客交互：
input() 输出成果是字符串
格式化输出：%s %d %f

流程控制：
if elif else
Strip（去掉字符） split（切割 分割） len()
while else

文献解决模式：
r
w
a
r b 尽量加b
w b
ab

File办法：
办法：close()
seek() 拟定文献读写位置
1. file.seek(off, whence=0)：从文献中移动off个操作标记（文献指针），正往结束方向移动，负往开始方向移动。如果设定了whence参数，就以whence设定起始位为准，0代表从头开始，1代表当前位置，2代表文献最末尾位置。  

tell() 回到文献当前位置
next() 迭代办法 = readline()
truncate() 截断文献
writelines(列表、元组)
文献内容替代
属性：closed encoding mode name

1、文献写入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import time
import random

#打开模式列表：
#w      以写方式打开，
#a      以追加模式打开 (从 EOF 开始，必要时创立新文献)
#r+     以读写模式打开
#w+     以读写模式打开 (参见 w )
#a+     以读写模式打开 (参见 a )
#rb     以二进制读模式打开
#wb     以二进制写模式打开 (参见 w )
#ab     以二进制追加模式打开 (参见 a )
#rb+    以二进制读写模式打开 (参见 r+ )
#wb+    以二进制读写模式打开 (参见 w+ )
#ab+    以二进制读写模式打开 (参见 a+ )
f = open('tpm.txt'，'a+')

for i in range(10) :
    f.write(time.strftime('%Y-%m-%d %H:%M:%S'))
    f.write(' ' + str(random.randint(0，i)) + '\n')

f.close()
2、文献读取
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
f = open('tpm.txt')
# read方式读取
s = f.read()
print(s，'\n\n\n')
print(f.tell())
#上面读取完后指针移动到最后，通过seek将文献指针移动到文献头
f.seek(0)
#使用readline每次读取一行
while(True):
    line = f.readline()
    print(line)
    if(len(line) == 0):
        break

f.close()
3、文献目录操作（OS包）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#os模块，解决文献和目录一系列函数
import os

#打印当前目录下所有文献 非递归
print(os.listdir(os.getcwd()))

#切换目录为当前目录
os.chdir('.')

#判断目的与否存在，不存在则创立
if(os.path.exists('./osdirs') == False):
    os.mkdir("./osdirs")

#重命名文献或目录名
if(os.path.exists("./os") == False) :
    os.rename("./osdirs"，"./os")

#rmdir删除目录，需要先清空文献中子目录或文献夹
#removedirs可多层删除目录（需要目录中无文献） makedirs可多层创立目录
if(os.path.isdir("./os")) :
    os.rmdir("./os")

#删除文献
if(os.path.exists('./tpm.txt')):
    os.remove('./tpm.txt')
os模块中惯用办法和属性：
属性
os.linesep 文献中分割行字符串
os.sep文献途径名分隔符
os.curdir当前工作目录字符串名称
os.pardir父目录字符串名称
办法
os.remove()删除文献
os.rename()重命名文献
os.walk()生成目录树下所有文献名
os.chdir()变化目录
os.mkdir/makedirs创立目录/多层目录
os.rmdir/removedirs删除目录/多层目录
listdir()列出指定目录文献
getcwd()获得当前工作目录(current work directory)
chmod()变化目录权限
os.path.basename()去掉目录途径，返回文献名
os.path.dirname()去掉文献名，返回目录途径
os.path.join()将分离各某些组合成一种途径名
os.path.split()返回（dirname(),basename())元组
os.path.splitext()(返回filename,extension)元组
os.path.getatime\ctime\mtime分别返回近来访问、创立、修改时间
os.path.getsize()返回文献大小
os.path.exists()与否存在
os.path.isabs()与否为绝对途径
os.path.isdir()与否为目录
os.path.isfile()与否为文献
4、文献目录操作（shutil包）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import os
import shutil

#复制文献，相称于CP命令
shutil.copy('start2.txt'，'start3')

#移动文献或目录，相称于MV命令
shutil.move('start3'，'start4')

if(os.path.exists('./a/b/c') == False) :
    os.makedirs('./a/b/c')
#删除目录
shutil.rmtree('./a')

if(os.path.exists('./a/b/c/d') == False) :
    os.makedirs('./a/b/c/d')

#复制目录
if(os.path.exists('b') == False) :
    shutil.copytree('a'，'b')
shutil中惯用办法
copyfile( src，dst) 从源src复制到dst中去。固然前提是目的地址是具备可写权限。抛出异常信息为IOException. 如果当前dst已存在话就会被覆盖掉
copymode( src，dst) 只是会复制其权限其她东西是不会被复制
copystat( src，dst) 复制权限、最后访问时间、最后修改时间
copy( src，dst) 复制一种文献到一种文献或一种目录
copy2( src，dst) 在copy上基本上再复制文献最后访问时间与修改时间也复制过来了，类似于cp –p东西
copy2( src，dst) 如果两个位置文献系统是同样话相称于是rename操作，只是改名；如果是不在相似文献系统话就是做move操作
copytree(olddir,newdir,True/Flase) 把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文献夹下符号连接，如果第3个参数是False，则将在复制目录下生成物理副本来代替符号连接
rmtree(path[，ignore_errors[，onerror]]) 删除目录
move( src，dst) 移动文献或目录
5、应用 - 遍历文献夹
1
2
3
4
5
6
7
8
9
10
import os
#遍历当前路劲下所有目录和文献夹
#返回元组包括三个参数：1.父目录 2.所有文献夹名字（不含途径） 3.所有文献名字
for root，dirs，files in os.walk(os.getcwd()):
    #输出文献夹信息
    for dir in  dirs:
        print(os.path.join(root,dir))
    #输出文献信息
    for file in files:
        print(os.path.join(root,file))
6、总结
Python文献操作和PHP类似，均有现成函数去实现，因此基本上记住惯用函数就可以了。

字符串解决：
S.find(子串，开始， 结束)
S.rfind(子串，开始， 结束)
S.index(子串，开始， 结束) ValueError
S.rindex(子串，开始， 结束)
S.count(子串，开始， 结束)

关系测试：测试两组数据关系
name_set = set{1，2，3，4}

模块写法加上一句;
If __name__ == ‘__main__’:
Pass

函数式编程
原则一：
研发带来附加值产品。
原则二：
研发基于最小成本原则。
原则三：
任何成功软件产品都会晤临重新开发。

*args 可变参数列表 列表传参
**kargs 可变参数列表 字典传承

Python’s with statement provides a very convenient way of dealing with the situation where you have to do a setup and teardown to make something happen. A very good example for this is the situation where you want to gain a handler to a file，read data from the file and the close the file handler.
有某些任务，也许事先需要设立，事后做清理工作。对于这种场景，Pythonwith语句提供了一种非常以便解决方式。一种较好例子是文献解决，你需要获取一种文献句柄，从文献中读取数据，然后关闭文献句柄。
Without the with statement，one would write something along the lines of：
如果不用with语句，代码如下：
1
2
3
file = open("/tmp/foo.txt")
data = file.read()
file.close()
There are two annoying things here. First，you end up forgetting to close the file handler. The second is how to handle exceptions that may occur once the file handler has been obtained. One could write something like this to get around this：
这里有两个问题。一是也许忘掉关闭文献句柄；二是文献读取数据发生异常，没有进行任何解决。下面是解决异常加强版本：
1
2
3
4
5
file = open("/tmp/foo.txt")
try:
    data = file.read()
finally:
    file.close()
While this works well，it is unnecessarily verbose. This is where with is useful. The good thing about with apart from the better syntax is that it is very good handling exceptions. The above code would look like this，when using with：
虽然这段代码运营良好，但是太冗长了。这时候就是with一展身手时候了。除了有更优雅语法，with还可以较好解决上下文环境产生异常。下面是with版本代码：
1
2
with open("/tmp/foo.txt") as file:
    data = file.read()
with如何工作？
while this might look like magic，the way Python handles with is more clever than magic. The basic idea is that the statement after with has to evaluate an object that responds to an __enter__() as well as an __exit__() function.
这看起来布满魔法，但不但仅是魔法，Python对with解决还很聪颖。基本思想是with所求值对象必要有一种__enter__()办法，一种__exit__()办法。
After the statement that follows with is evaluated，the __enter__() function on the resulting object is called. The value returned by this function is assigned to the variable following as. After every statement in the block is evaluated，the __exit__() function is called.
紧跟with背面语句被求值后，返回对象__enter__()办法被调用，这个办法返回值将被赋值给as背面变量。当with背面代码块所有被执行完之后，将调用前面返回对象__exit__()办法。 This can be demonstrated with the following example：
下面例子可以详细阐明with如何工作：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/env python
# with_example01.py

class Sample:
    def __enter__(self):
        print "In __enter__()"
        return "Foo"

    def __exit__(self，type，value，trace):
        print "In __exit__()"

def get_sample():
    return Sample()

with get_sample() as sample:
    print "sample:"，sample
When executed，this will result in：运营代码，输出如下
1
2
3
4
bash-3.2$ ./with_example01.py
In __enter__()
sample：Foo
In __exit__()
As you can see，The __enter__() function is executed The value returned by it - in this case "Foo" is assigned to sample The body of the block is executed，thereby printing the value of sample ie. "Foo" The __exit__() function is called. What makes with really powerful is the fact that it can handle exceptions. You would have noticed that the __exit__() function for Sample takes three arguments - val，type and trace. These are u