2018年5月28日
第一节，数字类型及序列类型
00-数字类型
符号数字类型（全部不可变）
float浮点数
bool布尔值（True,False）
complex复数
int整数
浮点数运算不精确（用decimal ）
例子： In[1]: import decimal
In[2]: a=decimal.Decimal("1.2")
In[3]: b=decimal.Decimal("1.1")
In[4]: a-b
Out[5]: Decimal("0.1")
例子： In[8]:1.2-1.1
Out[9]: 0.09999999999999987
Ceil ： 向上取整
例子： In[1]:import math
In[2]:math.ceil(5/3)
Out[3]:2 #结果
//取整运算符（无论除不除得断，舍弃小数部分）
%取余运算符
**幂运算
01-序列类型
str（不可变）字符串：“abv” list(可变)
list(可变)列表:["1",2,"qww"]
tuple（不可变）元组:(1,3.14,"abc")或者（1,）或者1，
python里内置的函数就是bif
索引取值：
例子：a=[1,'hello','word']或者b=(1,'hello','word')
a[0]或者b[0]
1 #输出
列表可变元组不可变：
a=1 a指向一个内存空间将1存入
a=2 a指向程序再开辟一个的空间，将2存入
a
2
id(a) 查看a的地址，两次地址不一样，只是指向改变了，存储内容没有变
a=[1,'hello','word']
b=(1,'hello','word')
a[0]=2
a:a=[2,'hello','word']
b[0]=2
b:报错error
切片操作：
a=[1,'hello','word']
a[0:3]或者a[0:]或者a[:3]或者a[:-1]或者a[-3:] #左闭右开,取全部
不同序列类型转换：
int(3.14) #出来整数3 其他类型也如此
判断元素是否在列表里：
a=[1,'hello','world']
1 in a #成员运算符
True
1 not in a #成员运算符
False
第二节，序列类型的方法
00-列表的方法
dir(list)可查询list中的方法
增加删除修改查找复制
append(加入的元素) <加在最后面，只能插入单个元素，可以是列表>clear() <删除所有数据>索引赋值index(元素) <查找元素位置，有相同元素则只查第一个，不存在则报错>copy()
insert(插入的位置，插入元素) <只能插入单个元素>pop(可以添加位置参数) <不添加位置参数则删除最后一个元素并返回最后一个元素>count(元素) <统计元素在列表中出现次数，如果元素不存在则返回0>反序reverse()
extend(列表或者元组) <可插入多个数据到最后面>remove(元素) <有相同元素则删除第一个>默认从小到大排序sort()
01-字符串的方法
查找与判断修改拼接
count(元素) <统计元素在字符串里出现次数，不存在则返回0>upper()<将所有小写改为大写>+ <用加好直接将字符串拼接起来>
find(元素) <查找元素索引位置，多个则只找第一个出现的，若不存在则返回-1>lower()<将所有大写改为小写>字符串3.join([字符串1，字符串2]) <将字符串1和字符串2用字符串3拼接在一起>
index(元素)<查找元素索引位置，多个则只找第一个出现的，若不存在则报错>strip(元素)<删除字符串开头和结尾的字符>
isdigit() <判断是否全为数字组成>capitalize() <将第一个单词首字母大写>
isalpha()<判断是否全为字母组成>title() <将所有单词首字母大写>
endswith(元素)<判断是否以元素参数结尾>split(元素) <将字符串分开并将其存入列表，不指定则指定空格，分割符会被丢掉>
startswith(元素)<判断是否以元素参数开头>replace(旧字符，新字符) <用新字符替换旧字符>
islower()<判断字符串的字母是否全为小写>
isupper() <判断字符串所有字母是否为大写>
02-转义字符
\n换行符
\t制表符
\b退格符（光标退回一格）
\r光标回到开头
\\\
\'‘
\0空字符
\a系统提示音
如果想将字符串转义去掉，在转义前加上r即可
03-元组的方法
查找
count(元素) <统计元素出现次数>
index(索引位置) <查找位置的元素>
第三节，使用vim编写Python代码
01-linux常用命令
命令作用命令作用
pwd返回当前目录cat -n install .sh查看文件内容并显示行数
ls查看当前目录下的文件和文件夹cp (文件名) (复制的路径)复制文件到想去的路径
cd 路径（绝对或相对路径）相对路径：在当前目录下直接打开文件 绝对路径：从根目录开始写rm 文件名删除文件
cd -返回上一级(只能返回一次)rm -r 文件夹名删除文件夹
cd /到根目录mv 文件名 路径移动文件
cd或者cd ~回到家目录cd ..上一级目录（可重复使用）
su 用户名切换用户mkdir创建文件夹
touch 文件名创建文件rmdir删除空的文件夹
cat 文件名查看文件内容
02-vim的使用
交互环境指我们输一条就输出一条
exit() 退出交互环境
deactivate 退出虚拟环境
vim 文件名 用vim编辑文件如果没有则自动创建
vim有命令模式，输入模式，末行模式
命令模式：q 退出vim，：wq 保存后退出，：q!强制退出
进入（命令模式）退出（命令模式）移动光标（命令模式）输入模式复制和粘贴删除
vim 文件名:q 退出gg (移动到第一行)i(进入输入模式)yy(复制整行)dd(删除光标所在乎)
：wq 保存后退出G(shift+g)（移动到最后一行）I(在行首进入输入模式)p(粘贴)dw(删除光标到单词结尾)
：q!强制退出^(移动到非空格行)a（在光标后面一个字符添加）9yy(复制9行从光标开始向下九行)x(删除光标所在的字符)
0（移动到行首）A（在行尾进行添加）yw(复制当前光标到单词词尾的内容)u(撤销上一次操作)
$(移动到行尾)o(在光标下面加一行)ctrl+r(撤销u操作)
O（在光标上面加一行）
块操作查找
v(光标可以自由选中)：/a或者?a(查找所有a)
ctrl+v(列块选择)n(/向下查找，？向上查找)
shift+*(查找光标所在字符串)
命令行按F5自动执行代码
03-虚拟环境使用
虚拟机用来装系统，
命令意义
workon查看有哪些虚拟环境
workon 虚拟环境名进入虚拟环境
deactivate退出虚拟环境
mkvirtualenv 虚拟环境名（默认python2）创建虚拟环境
which 程序名查看程序安装在哪里
mkvirtualenv -p /usr/bin/python3 py3创建名为py3的虚拟环境
rmvirtualenv 虚拟环境名删除虚拟环境
第四节，格式化输出，字符串拼接和深浅复制
00-格式化输出
占位符例子
%d“hello %d”%(1)
%s
%f
%cASCII码格式化
%o8进制
%x16进制
%e科学计数法
%-8s占位字符最小要8位,并左对齐
%.2f小数后面保留2位
%+8d 正号，最小占位8位
01-format格式化
例子：“hello{}”.format("world")
"hello {1} {0}".format("world","python")
输出：hello python world
"hello {ab}".format(ab="python")
输出：hello python
"{a:<10}".format(a=1234) #后面填充的必须为10个，如果没有在前面加空格补齐，并左对齐
"{a:x^10}".format(a=1234) #后面填充为10个，前后用x填充
01-字符串编码
ASCII码表：只能表示英文字母和符号
GBK编码：中国特有的
iso指定统一标准：unicode字符集：企图将地球上所有语言囊括，浪费空间，更新后出现UTF-8,UTF-16等
Python中都是Unicode方式存储
编码：“字符串”.encode("utf8")
解码：" ".decode("utf8")
02-深浅复制
针对列表来说的
列表里可以放列表
a=[1,2,3,["a",1,2]]
a.copy() #浅复制，只能复制一层，不能复制里层的列表只能引用
深复制
import copy
b=copy.deepcopy(a)
03-bytes和bytearray
bytes:二进制序列不可修改
bytearray:二进制序列可修改
第五节，散列类型，逻辑运算符
进入后在末尾加workon py3env
ipython #以后直接进入Python环境
00-散列类型
01-set（集合）--不可变
不能出现重复元素，用大括号括起来
{1，“2”，3}
set([1,2,3])
&交集
|并集
-差集（补集）
方法
S.add(x) x只能为不可变类型S.copy()s.remove()S.issubset(T) 判断S是否是T的子集
S.clear()S.pop(元素) 若不添加元素则随机删除一个S.isdisjoint(T) 有交集返回FalseS.issuperset(T) 判断T是否是S的子集
S.copy()s.discard()len(S)
s.update(列表或元组) 添加列表或元组里的内容到集合x in Sx not in S
02-dict（字典）---可变的散列类型
01，定义
di1={'key':'value'} #键值对形式存在，建相当于一个变量
#key不能重复，value可以重复，key不能是可变数据类型，value可以是可变数据类型
#无序的
di2=dict() #定义空字典
02，字典的方法
di1={1：‘s’}
di1.clear() #清空字典
dil.setdefault(1,'3') #如果key存在则查询，不存在则添加
dil.pop(1) #删除key对应的键值对，不存在则报错
dil.popitem() #随机删除
dil.get(1) #获取指定key对应的value,不存在则返回none
dil.keys() #取出所有的key，并输出一个list
dil.values() #取出所有的value,并输出一个list
dil.items() #取出所有的键值对
dil.updata({3:'7'}) #添加字典到字典，key重复则覆盖
di1=dict.fromkeys(（'abcd'，'聆听'）)#返回一个字典，字典的key是第一个参数的拆分，value是第二个参数
print(dil)
{'b':'聆听','a':'聆听'，'c':'聆听'，'d':'聆听'} #输出
01-运算符优先级
优先级从上到下越来越低
**幂运算
+ -一元运算（正负号）
* / %算术运算符
+ -
< > <= >=比较运算符
== ！=
= %= /= += *= **=赋值运算符
is is not身份运算符
in not in成员运算符
not>and>or逻辑运算符
02-逻辑运算
isinstance(1,int) #用来判断参数1是否为参数2所表示的类型
and #与
or #或
not #非
第六节，控制流程
00-条件判断
if 判断语句1:
执行语句1
elif 判断语句2:
执行语句2
...
else:
执行语句
01-三目运算
执行语句1 if 条件语句 else 执行语句
02-条件循环
while 判断语句：
循环体
break :跳出循环
else:只要条件不满足就执行else
continue:只结束当前循环，继续下一次循环
for in obj:
循环体
第七节，函数基础
00-函数基础
定义：
def 函数名(参数)：
pass
return 表达式
函数调用：
函数名（参数）
01-函数参数
不定长参数：
*args 存到元组里
关键字参数：
**kwargs #将a=1,b=2，这样的参数变成键值对放到字典里，关键字参数必须放到参数最后
02-常见内置函数
sorted(对象，reverse=True/False)排序，有返回值ord()字符转ASCII
dir(builtins)查看python里所有函数chr()ASCII码转字符
len(对象)查看对象长度filter(函数，参数)过滤器
min()求最小值map(函数，参数)筛选
max()求最大值zip(序列类型1，序列类型2)对应
reversed()反向eval()把字符串当成代码运行
sum()求和exec()与eval()用法一样，只是没有返回值
bin()转换为二进制
oct()转换为八进制
hex()转换为十六进制
第八节，函数作用域及闭包
00-函数作用域
匿名函数 lambda
lambda 参数：表达式
filter(func,a)
filter(lambda x:x%2==0,a) #输出a中的偶数
filter(map(lambda x:x*x,a))
局部变量只能作用于局部
全局变量可作用于局部
globle #声明全局变量,z在局部修改全局要声明
nonlocal #修改局部变量
变量命名规则：
小驼峰规则：首字母除了第一个其他都大写
大驼峰规则：首字母全部大写
全局变量：全大写用下划线连接
01-闭包
闭包是函数里面嵌套函数，外层函数返回里层函数，这种情况称之为闭包闭包是概念，不是某种函数类型，和递归的概念类似，就是种特殊的函数调用闭包可以得到外层函数的局部变量，是函数内部和函数外部沟通的桥梁
闭包：
def fx(x):
x += 1
def fy(y):
return x*y
return fy
def calculate(operator='+'):
def add_func(x,y):
return x+y
def sub_func(x,y):
return x-y
if num == '+':
return add_func
elif num == '-':
return sub_func
else:
return None
resualt = calculate('+')
print(resualt(3,2))
resualt = calculate('-')
print(resualt(3,2))
02-递归和回调函数
递归
阶乘：
def factorial(n):
if n == 1:
return 1
return factorial(n-1)*n
递归中可以函数自身调用自身，但是使用时类似于条件循环一样，要有递归的终止条件
回调（函数里面调用自己）
示例：
def choice(callback, ch):
if ch:
callback()
else:
print(‘做一些见不得人的勾当')
def play():
print(‘好像没有人啊')
choice(play, 1)
回调函数： 自身是一个函数，只是被传入到另一个函数当中，供其调用
回调函数不一定会被调用，是否调用由被传入函数的内部逻辑决定
第九节，类和对象
00-面向对象
相关的变量和函数都“封装”在对象里，以对象为单位整理代码
01-类和实例
类：是一类事物的抽象，不是真实存在的，描绘了该类事物的共性
实例（对象）：某类事物的具体个体，是该类事物的具体表现，它是真实存在的
类一般用大驼峰，函数一般用小驼峰
#定义类
class Person：
#实例化对象
a=Person() #实例化的对象赋予a
02-属性封装
类的属性就是变量
封装在“实例”里的变量，是实例的特征
每个实例都是一个独立的变量空间
私有属性：
在属性前加两个下划线则为私有属性，私有属性只能在类里面用
在python中有两私有属性，分别是在属性前加 一个下换线(_)（被保护的） 和 两个下划线(__)
03-方法
把函数写在类里面就是方法
通常，将默认会传入的那个参数命名为self，用来表示调用这个方法的实例对象本身。
class Person：
name="人"
def func(self): #self表示一个实例对象
print("{}:hhhhh".format(self.name))
a=Person() #实例化一个对象
#a.func() #将对象a传给了func
#Person.func(1) #用类调用必须传个参数
a.name="daisy"
a.func()
04-初始化(魔术方法)
魔法方法：名字前后都有两个下划线。
class Person:
def __init__(self,name,sex): #初始化方法，实例的时候自动执行
self.name=name
self.sex=sex
a=Person("daisy","nv")
第十章，继承与魔术方法
00-继承
一个类可以继承一个类（自己有则不继承，自己没有才去继承）
class A:
pass
class B(A): #B继承A
pass
class C(A,B): #多继承，C先继承A,再继承B
#从左到右的原则继承
pass
广度优先算法（python3）：一层一层的来
深度优先算法：从一条线走完再从头开始
类名.mro #查看继承顺序
顶级基类object，python3中默认有，python中所有类都是从object中继承来的
类名.bases #查看父类
01-多继承
class C(A,B):
def play(self):
A.play（self） #调用A方法，需要什么参数传什么
print("这是C")
class C(A,B):
def play(self):
super().play() #都可以用，按顺序先A后B，不用传参数
print("这是C")
02-魔术方法
class C:
def __init__(self,a):
self.a=a
def __add__(self,other): #other和self一样表示实例化的对象
print(str(self.a)+str(other.a))
def __str__(self): #使用print时才会触发，向用户友好
return XXXX
def __repr__(self): #，使用print才触发，有__str__则用__str__,向开发者友好
return XXXX
int1=C(10)
int2=C(5)
int1+int2 #有+号则触发__add__
一般实例不能像函数调用，如果要用则要用__call__方法
class C:
def __init__(self,a):
self.a=a
def __call__(self,*args,**kwargs):
return "hhhhhh"
a=C(1)
a() #调用实例则触发__call__方法
__class__ 查看类名
__base__ 查看继承的父类
__bases__ 查看继承的全部父类
__dict__ 查看全部属性，返回属性和属性值键值对形式
__doc__ 查看对象文档，即类中的注释（用引号注释的部分）
__dir__ 查看全部属性和方法
第十一章，描述器与装饰器
00-定制属性访问
查找：
hasattr(re, 'length')# 返回bool值，判断re实例有没有length属性getattr(re, 'length')# 返回属性值，触发__getattr__方法b. __getattribute__('length') # 返回属性值,调用存在属性不触发，不存在则触发
增加和修改：
setattr(b, ‘length’, 6) #没有返回值，对实例b的length属性添加值6b.__setattr__('length', 5)
删：
delattr(b, 'ccc')#没有返回值b.__delattr__('bbb')del b
class Persons: def __init__(self,name): self.name=nametest=Persons()print(hasatter(test,"name")) #判断test对象有没有name属性
01-new方法
__new__class Person: def __new__(cls，*args,**kwargs): print("XXXXXX")test=Person(10) #先调用new方法，然后再是init方法,实例化就触发
class Earth: def __new__(cls): if not hasattr(cls, 'instance'): cls.instance = super().__new__(cls) return cls.instance def __init__(self): self.name = 'earth'e = Earth()print(e, id(e))a = Earth()print(a, id(a))在上面的例子中，我们可以看到两个实例的ID是相同的意味着这两个其实引用的是同一个实例，是一个实例的不同名字
02-描述器
用一个类来管理另外一个“类属性”，用来控制另一个类属性的访问，修改和删除
类属性：访问 __get__
赋值：__set__
删除：__deleter__
class MyAtrribute: def __get__(self, instance, owner): print('get') def __set__(self, instance, value): print('set') def __delete__(self, instance): print('del')class MyClass: m = MyAtrribute() def __del__(self): print('instance delete') c = MyClass()c.m #触发__get__c.m = 1 #触发__set__del c.m #删除__delete__这类里面实例化另一个类，对这个实例做访问时，需要定义 __get__ __set__ __delete__ 方法
03-装饰器
在不改变函数里代码的情况下给它添加新的功能
下面这里实现了给函数添加新功能
类也可以做装饰器，但是需要定义 call 方法
04-常用内置装饰器