Python -- 基础

Posted 2022-11-27 Y_ZhiWen

最近还在考试，紧张的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的学习是我在网上学的，知识漏洞很多，所以等有时间买本书补补

如有不足或者错误之处，还请指出，谢谢！