最近还在考试,紧张的4天考了7课,然后就是放了7天假,等待考大物,时间这么多,前几天也没复习,最近才刚开始复习。。
好吧,我承认我前几天看了EventBus,了解了这个库的使用和源码。不仅感叹是多么好用,但又不能滥用的库。。。是有点悲催,不过没有上手练习,毕竟看了很多篇文章,例子都能理解,用法确实简单,源码也能理解一二。所以等考试完的项目上再用,哈哈直接上手。
本来我很多计划都是打算寒假开始的,EventBus算是其一,看完EventBus,感觉没什么干,看了下鸿洋大神设配,虽然说好用,但是要继承他的Activity,所以等深入学习View后,结合源码,再看能不能装饰一个Activity出来,好了,非常简单的看了一下下设配,觉得还是没事干,还是看一下我计划中的RxJava,果然一下子就把我蒙了,有点难理解,源码又那么多又复杂,看了许久,重头再看一遍使用,非常非常勉勉强强,确实很难入手,然而,不知为何,我把RxJava搁一边了,看起计划之一的Python。。No,于是有了这篇文章,记录我的Hello World!。
记得学Java的时候很痛苦,估计有一个多月快两个月(寒假跟上学期间),可是到了现在,看了点《Java编程思想》,设计模式。记得我的大一第一学期的C在期末时还在敲函数,指针,结构体的代码,现在代码还保留着。可以可以
这几天学Python,语言基础上手很快,虽然有些新用法,但是还是出乎意外,接下来呢,要么赶紧看完Python的处理IO和数据库这方法的。要么就得阁下了。T^T。。毕竟数据结构的B树课设还没怎么写。。
开发环境搭建
步骤:
- 官网下载Python
- 设置环境变量:Path –> Python所在路径
- 在命令行中输入python查看是否安装完成,完成即可敲代码
eclipse配置python :
- 在Help菜单栏install new software,点击Add,输入PyDev - http://pydev.org/updates,再点击第一项pydev,安装过程中会弹出一个框,打勾ok,完成后即可创建Python项目
pyCharm :
- 官网下载pyCharm并安装
- 要收费,所以我使用的注册方式是:在注册时选择 License server ,填 http://idea.lanyus.com ,然后点击 OK
- 另一种方式(没尝试): 安装后,调整时间到2038年。申请30天试用,退出pycharm, 时间调整回来。
基本数据类型
我把Python的基本数据类型独有的特点写成代码形式理解,直接结合注释看代码:
# coding=utf-8
# Python编码为ASCII,如果没有上面语句,可能不支持中文注解
# 基本数据类型
a = 1000000000000000000 # Python可以处理任意大小的整数
print a
a = 'abc' # or a = "abc"
print a
a = u'中文字符串'
print a
a = True or False # and or not
print a
a = True
print a and 'a=T' or 'a=F' # 结果为a=T
# 因为Python把0、空字符串''和None看成 False,其他数值和非空字符串都看成 True,所以:
# True and 'a=T' 计算结果是 'a=T'
# 继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'
# 要解释上述结果,又涉及到 and 和 or 运算的一条重要法则:短路计算。
# 1. 在计算 a and b 时,如果 a 是 False,则根据与运算法则,整个结果必定为 False,因此返回 a;如果 a 是 True,则整个计算结果必定取决与 b,因此返回 b。
# 2. 在计算 a or b 时,如果 a 是 True,则根据或运算法则,整个计算结果必定为 True,因此返回 a;如果 a 是 False,则整个计算结果必定取决于 b,因此返回 b。
# a变量本身类型不固定的语言称之为动态语言
# print会依次打印每个字符串,遇到逗号“,”会输出一个空格
print 'The quick brown fox', 'jumps over', 'the lazy dog'
print 'The quick brown fox'+'jumps over'+'the lazy dog'
# 字符串包含 ' "
print "I'm ok"
print 'She said:"Hellow"'
print 'She said:"I\'m ok"'
# raw字符串 r'''...''' 字符内容不发生转义
print '\'\n\"'
print r'''\'\n\"'''
# 多行字符串
print '''Line 1\n..
Line 2
Line 3'''
# 多行raw字符串
print r'''Line 1\n..
Line 2
Line 3'''
# Unicode字符串 最早的Python只支持ASCII编码,Python在后来添加了对Unicode的支持,以Unicode表示的字符串用u'...'表示
# 如果中文字符串在Python环境下遇到 UnicodeDecodeError,这是因为.py文件保存的格式有问题。可以在第一行添加注释
# -*- coding: utf-8 -*-
# 目的是告诉Python解释器,用UTF-8编码读取源代码。然后用Notepad++ 另存为... 并选择UTF-8格式保存。
print '中文zhongwen'
print u'中文'
# 同理,多行Unicode字符串
print u'''第一行
第二行'''
# Unicode+raw+多行:
print ur'''第一行\n
第二行'''
基本语句
这里看的是if和while和for语句,同样,看例子:
# coding=utf-8
# if 语句
age = 24
if age>30:
print 'your age over 30'
elif age>20:
print 'your age less 30 but over 20'
else :
print 'less 20'
# 注意: Python代码的缩进规则。具有相同缩进的代码被视为代码块,
# for 循环
L = ['Adam', 'Lisa', 'Bart']
for name in L:
print name
# while 循环
N = 10
x = 0
while x < N:
print x
x = x + 1
数据结构
list
list是一种有序的集合,直接用 [ ] 把list的所有元素都括起来,就是一个list对象。
由于Python是动态语言,所以list中包含的元素并不要求都必须是同一种数据类型,我们完全可以在list中包含各种数据:
L = ['Michael', 100, True]
L[0],在使用索引时,千万注意不要越界。
倒序访问List,
- 俗称倒数第一,所以,我们可以用 -1 这个索引来表示最后一个元素:类似的,倒数第二用 -2 表示,倒数第三用 -3 表示,倒数第四用 -4 也要注意不要越界。
添加元素
- append()总是把新的元素添加到 list 的尾部。
- insert()方法,它接受两个参数,第一个参数是索引号,第二个参数是待添加的新元素
删除元素
- pop()方法总是删掉list的最后一个元素,并且它还返回这个元素
- pop(2):把引用为2的删除
替换元素
L[2] = 'Paul'
L[-1] = 'aa'
tuple
tuple 是另一种有序的列表,中文翻译为“ 元组 ”。但是,tuple 一旦创建完毕,就不能修改了
创建tuple和创建list唯一不同之处是用( )替代了[ ]
单元数 tuple
创建包含1个元素的 tuple 呢?来试试:
t = (1)
print t
# 结果:1
好像哪里不对!t 不是 tuple ,而是整数1。为什么呢?
因为()既可以表示tuple,又可以作为括号表示运算时的优先级,结果 (1) 被Python解释器计算出结果 1,导致我们得到的不是tuple,而是整数 1。
正是因为用()定义单元素的tuple有歧义,所以 Python 规定,单元素 tuple 要多加一个逗号“,”,这样就避免了歧义:
t = (1,)
print t
# 结果:(1,)
Python在打印单元素tuple时,也自动添加了一个“,”,为了更明确地告诉你这是一个tuple。
可变的 tuple
前面我们看到了tuple一旦创建就不能修改。现在,我们来看一个“可变”的tuple:
t = ('a', 'b', ['A', 'B'])
注意到 t 有 3 个元素:’a’,’b’和一个list:[‘A’, ‘B’]。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到,然后,我们把list的两个元素改一改:
L = t[2]
L[0] = 'X'
L[1] = 'Y'
再看看tuple的内容:
print t
# ('a', 'b', ['X', 'Y'])
tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。
上述例子改成:t = ('a', 'b', ('A', 'B'))
dict
但是,要根据名字找到对应的成绩,用两个 list 表示就不方便。
如果把名字和分数关联起来,组成类似的查找表:
‘Adam’ ==> 95
‘Lisa’ ==> 85
‘Bart’ ==> 59
给定一个名字,就可以直接查到分数。
Python的 dict 就是专门干这件事的。用 dict 表示“名字”-“成绩”的查找表如下:
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
我们把名字称为key,对应的成绩称为value,dict就是通过 key 来查找 value。
花括号 {} 表示这是一个dict,然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。
由于dict也是集合,len() 函数可以计算任意集合的大小:
len(d)
# 3
注意: 一个 key-value 算一个,因此,dict大小为3。
访问 dict
可以简单地使用 d[key] 的形式来查找对应的 value,这和 list 很像,不同之处是,list 必须使用索引返回对应的元素,而dict使用key:
print d['Adam']
# 95
print d['Paul']
# Traceback (most recent call last):
# File "index.py", line 11, in <module>
# print d['Paul']
# KeyError: 'Paul'
注意: 通过 key 访问 dict 的value,只要 key 存在,dict就返回对应的value。如果key不存在,会直接报错:KeyError。
要避免 KeyError 发生,有两个办法:
- 一是先判断一下 key 是否存在,用 in 操作符:如果 ‘Paul’ 不存在,if语句判断为False,自然不会执行 print d[‘Paul’] ,从而避免了错误。
if 'Paul' in d:
print d['Paul']
- 二是使用dict本身提供的一个 get 方法,在Key不存在的时候,返回None:
print d.get('Bart')
# 59
print d.get('Paul')
# None
dict 的特点
dict的第一个特点是查找速度快,无论dict有10个元素还是10万个元素,查找速度都一样。而list的查找速度随着元素增加而逐渐下降。不过dict的查找速度快不是没有代价的,dict的缺点是占用内存大,还会浪费很多内容,list正好相反,占用内存小,但是查找速度慢。
dict的第二个特点就是存储的key-value序对是没有顺序的!
dict的第三个特点是作为 key 的元素必须不可变,Python的基本类型如字符串、整数、浮点数都是不可变的,都可以作为 key。但是list是可变的,就不能作为 key。
更新 dict
d[key] = value
- 如果 key 已经存在,则赋值会用新的 value 替换掉原来的 value,否则新建一个key-value
遍历 dict
for key in d:
print key
d.get(key)
set
s = set([‘A’, ‘B’, ‘C’])
s = set([‘A’, ‘B’, ‘C’, ‘C’])
set 持有一系列元素,这一点和 list 很像,但是set的元素没有重复,而且是无序的,
用 in 操作符判断元素是否在set中,跟dict一样
遍历 set – 顺序很可能是不同的
for name in s:
print name
更新 set
- 添加元素时,用set的add()方法
- 删除set中的元素时,用set的remove()方法,如果删除的元素不存在set中,remove()会报错,所以用add()可以直接添加,而remove()前需要判断。
函数
函数的定义,返回值,返回多值,默认参数以及可变参数,见下面例子:
# coding=utf-8
# 函数 -- 定义一个函数要使用 def 语句,依次写出函数名、括号、括号中的参数和冒号:
# 如果没有return语句,函数执行完毕后也会返回结果,只是结果为 None。
# return None可以简写为return。
def my_abs(a):
if a > 0:
return
else:
return -a
print my_abs(-10) # 10
print my_abs(10) # None
# 返回多值
import math
def move(x, y, step, angle):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
x, y = move(100, 100, 60, math.pi / 6)
print x, y # 151.961524227 70.0
# 但其实这只是一种假象,Python函数返回的仍然是单一值:
r = move(100, 100, 60, math.pi / 6)
print r # (151.96152422706632, 70.0) -- tuple
#但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。
# 定义默认参数
# 函数的默认参数的作用是简化调用,你只需要把必须的参数传进去。但是在需要的时候,又可以传入额外的参数来覆盖默认参数值。
# 由于函数的参数按从左到右的顺序匹配,所以默认参数只能定义在必需参数的后面:
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
print power(11)
print power(11,11)
# 定义可变参数
# Python解释器会把传入的一组参数组装成一个tuple传递给可变参数,因此,在函数内部,直接把变量 args 看成一个 tuple 就好了。
def fn(*args):
print args
print fn(1,2,3,'yyy',902.2)
切片
对这种经常取指定索引范围的操作,用循环十分繁琐,因此,Python提供了切片(Slice)操作符,能大大简化这种操作。直接看例子:
# coding=utf-8
L = range(0,16) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
# 取前三个元素 L[0:3]表示,从索引0开始取,直到索引3为止,但不包括索引3。如果第一个索引是0,还可以省略
print L[0:3] # 3-0 = 3
print L[:3]
# 从索引1开始,取出2个元素
print L[1:3] # 3-1 = 2
# 只用一个 : ,表示从头到尾.L[:]实际上复制出了一个新list
print L[:]
# 切片操作还可以指定第三个参数,第三个参数表示每N个取一个
print L[::2] # [0, 2, 4, 6, 8, 10, 12, 14]
print L[::3] # [0, 3, 6, 9, 12, 15]
print L[::4] # [0, 4, 8, 12]
# 3的倍数
print L[3::3] # [3, 6, 9, 12, 15]
# 不大于50的5的倍数
ls = range(0,101)
print ls[5:51:5] # [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
# 倒序切片
# 记住倒数第一个元素的索引是-1。倒序切片包含起始索引,不包含结束索引。
L = ['Adam', 'Lisa', 'Bart', 'Paul']
print L[-2:] # ['Bart', 'Paul']
print L[:-2] # ['Adam', 'Lisa']
print L[-3:-1] # ['Lisa', 'Bart']
print L[-4:-1:2] # ['Adam', 'Bart']
# 对字符串切片
# 字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list,每个元素就是一个字符。操作结果仍是字符串:
print 'ABCDEFG'[:3] # 'ABC'
print 'ABCDEFG'[-3:] # 'EFG'
print 'ABCDEFG'[::2] # 'ACEG'
迭代
例子:
# coding=utf-8
# 迭代
# Python中,迭代永远是取出元素本身,而非元素的索引。
# 对于有序集合,元素确实是有索引的。有的时候,我们确实想在 for 循环中拿到索引,怎么办?
# 方法是使用 enumerate() 函数:
# 使用 enumerate() 函数,我们可以在for循环中同时绑定索引index和元素name。但是,这不是 enumerate() 的特殊语法。
# 实际上,enumerate() 函数把:['Adam', 'Lisa', 'Bart', 'Paul']
# 变成了类似:[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
# 因此,迭代的每一个元素实际上是一个tuple:
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in enumerate(L):
print index, '-', name
# t 为 tuple 写成上面的形式类似函数返回多值
for t in enumerate(L):
index = t[0]
name = t[1]
print index, '-', name
# 迭代dict的value
# dict 对象有一个 values() 方法,这个方法把dict转换成一个包含所有value的list
# 还有一个 itervalues() 方法,用 itervalues() 方法替代 values() 方法,迭代效果完全一样:
# 那这两个方法有何不同之处呢?
# 1. values() 方法实际上把一个 dict 转换成了包含 value 的list。
# 2. 但是 itervalues() 方法不会转换,它会在迭代过程中依次从 dict 中取出 value,所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
d = {
'a':85,
'b':95,
'c':66
}
for v in d.values():
print v
# 85
# 95
# 59
for v in d.itervalues():
print v
# 85
# 95
# 59
# 迭代dict的key和value
# items() 方法把dict对象转换成了包含tuple的list,我们对这个list进行迭代,可以同时获得key和value:
# 和 values() 有一个 itervalues() 类似, items() 也有一个对应的 iteritems(),
# iteritems() 不把dict转换成list,而是在迭代过程中不断给出 tuple,所以, iteritems() 不占用额外的内存。
for k,v in d.iteritems():
print k,v
# a 85
# c 66
# b 95
列表
直接看例子:
# coding=utf-8
# 生成列表
# 要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],我们可以用range(1, 11)
# range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]
#
# 但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做?
# 一种做法
L = []
for x in range(1, 11):
L.append(x * x)
print L
# 列表生成式
# 写列表生成式时,把要生成的元素 x * x 放到前面,后面跟 for 循环,就可以把list创建出来,十分有用,多写几次,很快就可以熟悉这种语法。
L = [x * x for x in range(1, 11)]
print L
# 完全可以通过一个复杂的列表生成式把它变成一个 HTML 表格:
# 注:字符串可以通过 % 进行格式化,用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串。
# tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]
# print '<table>'
# print '<tr><th>Name</th><th>Score</th><tr>'
# print '\n'.join(tds)
# print '</table>'
# 条件过滤
# 列表生成式的 for 循环后面还可以加上 if 判断。例如:
# 如果我们只想要偶数的平方,不改动 range()的情况下,可以加上 if 来筛选:
# 有了 if 条件,只有 if 判断为 True 的时候,才把循环的当前元素添加到列表中。
L = [x * x for x in range(1, 11) if x % 2 == 0]
print L # [4, 16, 36, 64, 100]
# 多层表达式
# for循环可以嵌套,因此,在列表生成式中,也可以用多层 for 循环来生成列表。
# 对于字符串 'ABC' 和 '123',可以使用两层循环,生成全排列:
L = [m + n for m in 'ABC' for n in '123']
print L # ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
# 翻译成循环代码就像下面这样:
L = []
for m in 'ABC':
for n in '123':
L.append(m + n)
print L # ['A1', 'A2', 'A3a', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
总结
- 以上Python的学习是我在网上学的,知识漏洞很多,所以等有时间买本书补补
如有不足或者错误之处,还请指出,谢谢!