Python基础学习笔记

Python基础学习笔记

一、环境配置

下载链接：https://www.python.org/
　　推荐下载Python2.7版本，兼容库比较多

二、Python与Java区别

1. 静态与动态语言

Java是静态语言，即初始化变量时需要指定变量数据类型，如：int a = 12;
Python是动态语言，即初始化变量时不需要指定变量数据类型，且在代码执行过程中可对变量的数据类型进行改变，如：

a = 123    # a是整数  
print a  
a = 'imooc'   # a变为字符串  
print a

2. 注释

Python：#
Java：//或/**/

3. 表达式

Python表达式后无”;”
Python表达式中代码块不用”{…}”来表示，而是用代码缩进的方式
Python中没有”++”、”–”的表达式
Python中if、while、for不同，具体见下文

4. 逻辑运算符

与：Python：and；Java：&或&&
或：Python：or；Java：|或||
非：Python：not；Java：!

三、数据类型

1. 基本数据类型：整数、浮点数、布尔值、字符串、空值

布尔值：True、False，首字母大写
空值：None
字符串：使用’ ‘或” “表示
示例：

print 45678  
print 'Learn Python in imooc'  
print True  
print False

2. Python中”(单引号)与”“(双引号)的用法：

字符串中没有”单引号字符时，使用’ ‘表示字符串，如：s = ‘123’
字符串中有”单引号字符时，使用” “表示字符串,如：s = “I’m Kevin”
字符串中既有”，也有”“时，解决办法如下：
(1) 转义符
如：

Python was started in 1989 by "Guido".  
-->  
'Python was started in 1989 by \"Guido\".'

(2) 加前缀 r
如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。如：

r'\(~_~)/ \(~_~)/'

(3) 多行字符串
如果要表示多行字符串，可以用”’…”’表示：

'''Line 1  
Line 2  
Line 3'''

(4) 多行字符串包含特殊字符
使用r”’…”’表示：

r'''Python is created by "Guido".  
It is free and easy to learn.  
Let's start learn Python in imooc!'''

3. Unicode字符串

Unicode字符串支持中文编码，如：
(1) 中文字符：

u'中文'

(2) 支持转义符：

u'中文\n日文\n韩文'

(3) 多行：

u'''第一行  
第二行'''

(4) raw+多行：

ur'''Python的Unicode字符串支持"中文",  
"日文",  
"韩文"等多种语言'''

(5) # -*- coding: utf-8 -*-：
目的是告诉Python解释器，用UTF-8编码读取源代码。然后用Notepad++ 另存为… 并选择UTF-8格式保存。

4. 布尔值

涉及到 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。

四、list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

1. 创建list

(1) 创建空list：
　　

empty_list = []

(2) 创建有值的list

L = ['Michael', 100, True]

由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据。

2. list根据索引查询

(1) 顺序查询
　　

a = L[0]  
a = L[1]

(2) 倒序查询

a = L[-1]  
a = L[-2]

顺序查询时，索引是从0开始；倒序查询时，索引是从-1开始的。

3. 添加新元素

(1) append添加到list末尾

L.append('Paul')

(2) insert根据索引添加到list中

L.insert(0, 'Paul')

4. 删除元素

L.pop() #删除list末尾数据  
L.pop(0) #根据索引删除list中数据

5. 替换元素

L[0] = 'replace'

五、tuple

tuple是另一种有序的列表，中文翻译为“元组”。tuple和list非常类似，但是，tuple一旦创建完毕，就不能修改了。tuple没有append()方法，也没有insert()和pop()方法。

1. 创建tuple

t = ()  
t = ('Adam', 'Lisa', 'Bart')

2. 创建单元素tuple

t = (1,)

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义。

3.“可变”的tuple

t = ('a', 'b', ['A', 'B'])

六、条件判断与循环　　

Python代码的缩进规则。具有相同缩进的代码被视为代码块。缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

1. if语句、if-else语句、if-elif-else语句

if score >= 60:  
    print 'passed'

if score >= 60:   
    print 'passed'  
else:  
    print 'not passed'

if score >= 90:
    print 'excellent'
elif score >= 80:
    print 'good'
elif score >= 60:
    print 'passed'
else:
    print 'failed'

2. for循环

Python的 for 循环就可以依次把list或tuple的每个元素迭代出来。

L = ['Adam', 'Lisa', 'Bart']
for name in L:
    print name

3. while循环

while 循环不会迭代list或tuple的元素，而是根据表达式判断循环是否结束。

N = 10
x = 0
while x < N:
    print x
    x = x + 1 #不可以使用x++，Python中不支持

4. break和continue

Python中break和continue关键字与Java中使用方法相同。

七、dict

Dict就是通过 key 来查找 value。花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。

1. 创建dict

(1) 创建Dict

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}

(2) 获取dict的长度

print len(d)

2. 访问dict

通过key来找value。
(1) 需要判断key是否存在

if 'Paul' in d:
    print d['Paul']

(2) 通过get(key)方法，不需要判断key的存在，如果不存在时，会返回None

print d.get('Bart')

3. dict的特点

(1) 查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
由于dict是按 key 查找，所以，在一个dict中，key不能重复。
(2) 存储的key-value序对是没有顺序的。
(3) 作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。

4. 更新dict

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}  
d['Paul'] = 72

如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value。

5. 遍历dict

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }  
for key in d:
    print key
    print d.get(key)

6. dict常用函数

dict.values()：这个方法把dict转换成一个包含所有value的list。
dict.itervalues()：返回一个 对象，可以再通过for循环取出value；
dict.items()：{ ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59, ‘Paul’: 74 }–>[(‘Lisa’, 85), (‘Paul’, 74), (‘Adam’, 95), (‘Bart’, 59)]

八、set

set 持有一系列元素，这一点和list很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

1. 创建set

s = set(['A', 'B', 'C'])

2. 访问set

由于set存储的是无序集合，所以我们没法通过索引来访问。访问set中的某个元素实际上就是判断一个元素是否在set中。

s = set(['Adam', 'Lisa', 'Bart', 'Paul'])  
'Bart' in s

3. set的特点

(1) set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
(2) set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。
(3) set存储的元素也是没有顺序的。

4. 遍历set

s = set(['Adam', 'Lisa', 'Bart'])  
for name in s:
    print name

5. 更新set

由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
一是把新的元素添加到set中，二是把已有元素从set中删除。

s = set([1, 2, 3])  
s.add(4)

s = set([1, 2, 3])  
s.remove(3)

调用add()方法时，如果set中已有这个元素，则不会添加且不会报错；调用remove()方法时，如果set中没有这个元素，则会报错。

九、函数

Python内置了很多有用的函数，我们可以直接调用。要调用一个函数，需要知道函数的名称和参数。

可以直接从Python的官方网站查看文档：
http://docs.python.org/2/library/functions.html

1. 编写函数

在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

在Python中，可以返回多值。

import math
def move(x, y, step, angle):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

2. 定义默认参数

函数的默认参数的作用是简化调用，你只需要把必须的参数传进去。但是在需要的时候，又可以传入额外的参数来覆盖默认参数值。由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面。

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

# OK:
def fn1(a, b=1, c=2):
    pass
# Error:
def fn2(a=1, b):
    pass

3. 定义可变参数

如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数。

def fn(*args):
    print args

可变参数也不是很神秘，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。

4. 常用函数

abs(arg) : 返回arg的绝对值；
range(n)：返回0~(n-1)的list；
range(m,n)：返回m~(n-1)的list；
range(m,n,i)：返回m~(n-1)中每隔i个数取出生成的list；
sum(L)：返回list或tuple中各元素的和；
cmp(x, y) 就需要两个参数，如果 xy，返回 1；
enumerate(L)：将[‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]变成了类似：[(0, ‘Adam’), (1, ‘Lisa’), (2, ‘Bart’), (3, ‘Paul’)]；
zip(L1, L2)：zip([10, 20, 30], [‘A’, ‘B’, ‘C’])–>[(10, ‘A’), (20, ‘B’), (30, ‘C’)]；
join(L)：可以把一个 list 拼接成一个字符串；
isinstance(x, s)：判断x是否是s的实例化；
str.upper()：将字符串转化为大写字母；
str.lower()：将字符串转化为小写字母。

十、切片

1. list、tuple切片

(1) 创建list

L = ['Adam', 'Lisa', 'Bart', 'Paul']
T = ('Adam', 'Lisa', 'Bart', 'Paul')

(2) 切出所有值

L[:]  
L[:3]  
L[0:3]
T[:]  
T[:3]  
T[0:3]

(3) 切出1~2

L[1:2]
T[1:2]

(4) 每隔n个取值

L[::n]
T[::n]

2. list、tuple倒序切片

(1) 创建list

L = ['Adam', 'Lisa', 'Bart', 'Paul']
T = ('Adam', 'Lisa', 'Bart', 'Paul')

(2) 切出所有值

L[-1:-4]  
T[-1:-4]  

(3) 切出1~2

L[-2:-3]
T[-2:-3]

(4) 每隔n个取值

L[-1:-4:n]
T[-1:-4:n]

3. 字符串切片

字符串切片与list、tuple的切片操作相同，只是将list、tuple替换成字符串。

十一、列表生成式

1. 生成列表

L = []
for x in range(1, 11):
    L.append(x * x)
# 使用列表生成式
L = [x * x for x in range(1, 11)]

2. 条件过滤

L = []
for x in range(1, 11):
    if x % 2 == 0: 
        L.append(x * x)
# 使用列表生成式
L = [x * x for x in range(1, 11) if x % 2 == 0]

3. 多层表达式

L = []
for m in 'ABC':
    for n in '123':
        L.append(m + n)
# 使用列表生成式
L = [m + n for m in 'ABC' for n in '123']