1.0 Python基础
Python版本的安装
Anaconda是一个用于科学计算的Python发行版,支持 Linux, Mac, Windows系统,提供了包管理与环境管理的功能,可以很方便地解决多版本python并存、切换以及各种第三方包安装问题
Python3.5版本:https://repo.continuum.io/archive/Anaconda3-5.0.1-Windows-x86_64.exe
Python2.7版本:https://repo.continuum.io/archive/Anaconda2-5.0.1-Windows-x86_64.exe
Anaconda安装第三方包:conda install opencv
工具:http://www.pythontutor.com/live.html#mode=edit
1.1 数据类型
Python一切皆对象!
空值:None
数字类型:bool,int,float,complex
序列:str,list,tuple
字典:dict
集合:set,frozenset
注意:在python 2.7中 int类型中包含long类型
验证方式:
import sys
a = sys.maxint
b = a + 1
type(b) #long类型
1.1.1 None值
表示该值是一个空对象,空值是Python里一个特殊的值,用None表示
1.1.2 数字类型
bool:None 0 空字符串 以及没有元素的容器对象都可为False,反之就是True
通过下面代码验证:
def isBool(x):
isFlag = isinstance(x,bool)
if isFlag:
print(isFlag)
else:
print(isFlag)
if __name__ == '__main__':
list(map(isBool,[None,0,"",list(),tuple(),dict(),set(),frozenset()]))
bool不仅可以表示True OR False而且可以表示1 OR 0
注意:此处牵扯到类型之前的转换
int(x):将x转换为一个整数
float(x):将x转换到一个浮点数
str(x):将对象 x 转换为字符串
tuple(s):将序列 s 转换为一个元组
list(s):将序列 s 转换为一个列表
set(s):将序列 s 转换为一个集合
int(False) ---> 0
int(True) ---> 1
int:整数类型
获取int类型的最大值:9223372036854775807
int类型在[-5,256]之间会缓存数据,在此创建int类型会到缓存中获取数据而不再重新创建对象
通过id()来获取变量中的内存地址
注意:
在pyton终端解释器中可以看到变化(在大于等于257之后的值内存地址不一样)
在pycharm中大于等于257的数值内存地址是一样的,同一个模块内,相同的常量对象只分配一个存储单元
import sys
sys.maxint ----python 2.7
sys.maxsize ----python 3.0
a = 4
b = 4
print(id(a))
print(id(b))
float:浮点类型
双精度浮点数,就是类似的小数 1.2,3.5,-2.3,浮点数的一个普遍问题是它们并不能精确的表示十进制数。 并且,即使是最简单的数学运算也会产生小的误差
例如:
3 0.1 == 0.3 # False (==:用来比较两个的对象是否相等)
3 0.1 #0.30000000000000004
complex 复数类型
+BJ的形式,其中a,b是彩车和J(或J)表示-1的平方根(这是一个虚数)。 a是真正的数字部分,b是虚部
例子:
a = complex(3,5) #(3+5j)
d.real #3.0
d.imag #5.0
str 字符串
字符串是以单引号’或双引号”括起来的任意文本,比如’def’,”cde”等等。’’或””本身只是一种表示方式,不是字符串的一部分,因此,字符串’cde’只有a,b,c这3个字符。如果’本身也是一个字符,那就可以用””括起来
这里牵扯到转义如果是单引号就用\转义
建议最好使用”” 不用转义了
字符串利用intern机制来节省内存
例如:
a = 'abxc\'s'
a = a = 'abxc's' #报错SyntaxError: invalid syntax 语法错误
"a" + "b" #拼接字符串 利用 + 来完成字符串的拼接 还可以使用format方法
",".join(["a","b"]) #合并多个字符串 "a,b"
"a,b,c".split(",") #根据,来截取字符串 ['a', 'b', 'c']
"a\nb\r\nc".splitlines() #按行分割 ['a', 'b', 'c'] splitlines(True) 保留换行符
"abc".startswith("ab") #判断字符串是否是已ab开头的
"abc".endswith("bc") #判断字符串是否是已bc结束的
"abc".upper() "ABC"。lower() #大小写的转换
"abc".find("a") #查找起始位置
" abc ".lstrip() #删除左边空格 rstrip()右边空格 strip()删除两边的空格
"abcabc".replace("bc","BC") #替换字符串
注意:字符串也可以用列表中的特性比如切片,列表后面有介绍
a = "acbcde"
a[0] #第一个元素
a[0:2] #获取前两个元素 这里实际是:[0:2)
list 列表
list是一种有序的集合,可以随时添加和删除其中的元素,列表会动态的调整数组的大小,预分配的内存多余实际元素的数量,所以列表属于变长对象(对象的定义是不知道对象所占用的内存大小)
1.创建列表的方式:
a = [12,3,4,5]
a=list("abcd")
[ x for x in range(10)] #列表生成器
a = list([1,2,3,4])
2.列表的访问方式(通过下标的方式进行访问)
l = [1,2,3,4]
l[0] #第一个元素 列表的下标是从0开启计算的
len(l) #获取列表中元素的个数
l[len(l)] # 这里就会造成越界 报错IndexError: list index out of range 如果访问最后一个元素可以len(1) -1 或者使用l[-1] -1表示:最后一个元素 依此类推 -2,-3 还可以使用切片
切片
切片操作的方法是:consequence[start_index: end_index: step]。
start_index:表示是第一个元素对象,正索引位置默认为0;负索引位置默认为 -len(consequence)
end_index:表示是最后一个元素对象,正索引位置默认为 len(consequence)-1;负索引位置默认为 -1。
step:表示取值的步长,默认为1,步长值不能为0。
对于序列结构数据来说,索引和步长都具有正负两个值,分别表示左右两个方向取值。索引的正方向从左往右取值,起始位置为0;负方向从右往左取值,起始位置为-1。因此任意一个序列结构数据的索引范围为 -len(consequence) 到 len(consequence)-1 范围内的连续整数
在切片运算中,步长为正,表示从左至右,按照索引值与起始位置索引之差可以被步长整除的规律取值;当步长为负,则表示从右至左,按照按照索引值与起始位置索引之差可以被步长整除的规律取值
例如:
L = [x for x in range(10)] #0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
L[:5] #前5个
L[-5:] #后5个
L[:10:2] # 前10个 步长为2 #[0, 2, 4, 6, 8]
L[::-1] #反转 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
列表的增删改查
L = ['A','V','d']
L.append('e') #增加
L.index(5,2) #指定的位置查找
L.insert(1,100) #指定的位置插入
L.extend(rang(3)) #合并列表
L.remove(2) #移除指定元素
L.pop(1) #弹出指定位置的元素
遍历列表:
第一种写法:
L = ["a","b","c"]
for x in L:
print(x) #循环迭代元素
第二种写法:
L = ["a",'b','c']
i = 0
while i <len(L):
print(L[i])
i = i + 1
第三种写法:
L = ["a",'b','c']
it = iter(L) #通过迭代器来遍历列表
try:
while True:
d = next(it)
print(d)
except StopIteration: #抓取异常 后续会介绍
print("异常")
元祖
元祖也属于序列列表和list非常相似,只是元祖是不可变的,后面会对数据类型进行总结,既然元祖是不可变的那么就没有list中的append(),insert()这样的插入方法
元祖的定义:
d=(1,2,3)
d=tuple([1,2,3,4])
d = tuple("abcd")
如果元祖是一个元素必须写成(1,),都好是必不可少的
元祖也适应切片具体详见list中的切片
元祖中的元素的遍历也可以详见list的方式来
d.count(1) # 对元素进行统计
d.index(1) #查找元素
字典:
python中字典就是键-值的方式存储,具有极快的查找速度
创建字典以及基本的操作:
{"a":1,"b":2} # 第一种方式
dict(a=1,b=2) #第二种方式
del d["b"] #删除b元素
d.update({"c":3}) #合并元素
d.pop(“a”) #弹出元素
d.items() 返回一个包含字典中(键, 值)对元组的列表
d.keys() 返回一个包含字典中键的列表
d.get(“a”) 对字典 dict 中的键 key,返回它对应的值 value
字典的迭代:
L = {"name":"小明","age":23,"school":"北京大学"}
print(L.items())
for i in L.keys():
print(i,L.get(i))
for k,v in L.items():
print(k,v)
##python2.7中
for k, v in L.iteritems():
print(k+ "=>" + v)
set 集合
也是一组key的集合和字典类似,但不存储value。由于key不能重复,所以,在set中,没有重复的key,集合只能存储可哈希对象,frozenset是只读的版本
s = set("abc")
d = set({'a','b','c'})
d.add("d")#添加
d.remove("a")#删除
d.discard('a') #如果存在就删除
注意:
可变对象:list,dict.
不可变对象有:int,string,float,tuple
set以及dic中的key只能存储不可变的对象
2.0 函数
在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回
例子:
def demo(x):
if x>10:
return x
else:
return "ddd"
demo(11) #调用
def demo1(): #空函数不实现任何的功能
pass
注意:
函数执行完毕也没有return语句时,自动return None。
函数可以同时返回多个值,但其实就是一个tuple
函数的参数:
python除了正常的定义的必须的参数外,还可以有默认的参数,可变参数,关键字参数
例如:
1.位置参数
def demo(x):
pass
2.默认参数
def demo(x,n=3):
pass
demo(3) 或者 demo(4,5) #没有第二个参数默认就n=3
需要注意的必须的参数必须在默认的参数前面
3.可变的参数
def demo(*args): #自动装配成一个元祖
pass
4.关键字参数 #参数可以构造出成字典
def demo(**kwargs):
pass
demo(name="x",age=23) 或者 demo(**dict)
5.命名关键字参数 仅在3.0支持
如果要限制参数的名字,就可以用命名关键字参数
*号后面的参数才是命名关键字的参数(实参传递参数的时候必须是name="" 和 age=23)的形式
如果函数定义中已经有了一个可变参数,后面跟着的命名关键字参数就不再需要一个特殊分隔符*了:
def demo(args,*,name,age):
pass
def demo(*args,name,age):
pass
demo(2,name="小明",age=23) #调用
注意:
多个参数组合:必选参数、默认参数、可变参数、命名关键字参数和关键字参数的顺序
*args是可变参数,args接收的是一个tuple
**kw是关键字参数,kw接收的是一个dict
3.0 面向对象编程-类
类和实例
面向对象最重要的概念就是类(Class)和实例(Instance),class后面紧接着是类名,即Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下来的,通常,如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类
例如:
class Student(object):
pass
#创建类的实例
stu = Student()
#封装实例
class Student(object):
def __init__(self,name,age):
self.name = name
self.age = age
stu = Student("小明",23)
#set,get封装实例
class Student(object):
def set_age(self,age):
self.age = age
def get_age(self):
return self.age
if __name__ == '__main__':
stu = Student()
stu.set_age(23)
d = stu.get_age()
print(d)
#利用装饰器来简化set,get封装实例
class Student:
@property
def age(self):
return self._age #必须加下划线 私有的不然导致死循环
@age.setter
def age(self,value):
self._age = value
if __name__ == '__main__':
stu = Student()
stu.age = 23
print(stu.age)
说明:
“单下划线” 开始的成员变量叫做保护变量,意思是只有类对象和子类对象自己能访问到这些变量;
“双下划线” 开始的是私有成员,意思是只有类对象自己能访问,连子类对象也不能访问到这个数据
面向对象之继承
当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类
例如:
class People:
def run(self):
print("跑")
#子类
class Student(People):
pass
if __name__ == '__main__':
stu = Student()
stu.run() #继承父类的方法
4.0 代码规范以及资源
代码规范参考:https://github.com/anjuke/coding-style
Python试题:https://github.com/taizilongxu/interview_python
Python实战:https://github.com/bytename/LearnPython
Python资源:https://github.com/jobbole/awesome-python-cn
5.0 实战练习
1.MySQL,Nginx安装脚本
2.注册新浪微博开发者,利用官方API,来获取粉丝信息即可
Python API WIKI:https://github.com/michaelliao/sinaweibopy/wiki/OAuth2-HOWTO
新浪开发者平台:http://open.weibo.com/wiki/%E9%A6%96%E9%A1%B5
新浪微博API接口:http://open.weibo.com/wiki/%E5%BE%AE%E5%8D%9AAPI
后续前端仅仅根据w3c了解基本标签:
http://www.w3school.com.cn/
用到具体标签可随时查API文档