python自学笔记第二弹——了解python

1. Python简介

1.1 Python命令行模式和交互模式

• 命令行模式，它的提示符：C:\>。执行一个.py文件只能在命令行模式下。
• 在命令行模式下敲命令python，就看到类似如下的一堆文本输出，然后就进入到Python交互模式，提示符是:>>>。它是输入一行，执行一行，主要是为了调试Python代码用的，也便于初学者学习，它不是正式运行Python代码的环境！

1.2 Python解释器和文本编辑器

• 重点： Mac 如何在终端执行保存的“.py”文件
• 变量（不同于Java, Python是动态语言）、输入input()、输出
• input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。

s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

2.Python基础

2.1 数据类型：整数(d)、浮点数(f)、字符串(s)、布尔值、空值（None）、常量

需要注意的是：

• 对变量赋值x = y是把变量x指向真正的对象，该对象是变量y所指向的。随后对变量y的赋值不影响变量x的指向。
• 整数和浮点数在计算机内部存储的方式不同。整数运算永远是精确的（除法也是精确的），而浮点数运算则可能会有四舍五入的误差
• 转义字符：\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\。为了简化，Python还允许用r''expression''内部的字符串默认不转义，'''...'''的格式表示多行内容。

2.2 字符串与编码

1. 计算机系统通用的字符编码工作方式：字符编码

2. Python的字符串：在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言。Python的文本在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。

#以Unicode表示的str通过encode()方法可以编码为指定的bytes：
>>>'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
#含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错:
>>> '中文'.encode('ascii')
Traceback (most recent call last):
  File "", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
#如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法:
>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'

重点： 由于Python源代码也是一个文本文件，所以，当源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

3. 格式化

• 与C语言是一样，用%实现：

>>>print('%2d-%02d' % (3, 1))
3-01
>>>print('%.2f' % 3.1415926)
3.14

• 使用字符串的format()方法，不过这种方式写起来比%要麻烦得多：

>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'

2.3 list 和tuple

1. list[]列表：有序的集合，可以随时添加和删除其中的元素

#追加追加元素到末尾
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
#把元素插入到指定的位置
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
#删除list末尾的元素
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
#把某个元素替换成别的元素，可以直接赋值给对应的索引位置
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

2. tuple()元组：tuple和list非常类似，但是tuple一旦初始化就不能修改

#只有1个元素的tuple定义时必须加一个逗号,，来消除歧义
>>> t = (1,)
>>> t
(1,)

理解tuple所谓的“不变”：tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

2.4 条件判断: if, elif, else

注意：条件判断从上向下匹配，当满足条件时执行对应的块内语句

2.5 循环

1. for x in …循环：把每个元素代入变量x，然后执行缩进块的语句。
2. while循环：只要条件满足，就不断循环，条件不满足时退出循环。
3. break：提前结束循环。
4. continue：跳过当前的这次循环，直接开始下一次循环。

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

2.6 dic字典和set集合

1.dic{} 原理：给定一个名字(key)，比如’Michael’，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出value来，所以速度非常快.

• dic.get(key): 查找key
• dic.pop(key): 删除key

2.set() 集合：一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
（Set）常用操作

重点：

• 不可变对象：对于不变对象来说（str,整数，tuple等），调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
• 哈希函数：讨论：关于哈希表

3.函数

3.1 定义函数

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

• 如果定义函数没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。
• 如果想定义一个什么事也不做的空函数，可以用pass语句。

def my_abs(x):
#如果有必要，可以先对参数的数据类型做检查；
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

注意：

• 在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数可以同时返回多个值，但其实就是一个tuple。

3.2 函数的参数

1. 位置参数：调用函数时，传入的值按照位置顺序依次赋给参数。
2. 默认参数：默认参数降低了函数调用的难度，但：

def add_end(L=[]):
    L.append('END')
    return L

这是因为Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。所以默认参数必须指向不变对象（str、none等）

3. 可变参数：可变参数传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

#定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

4. 关键字参数kw：关键字参数允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

>>> def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {
     'gender': 'M', 'job': 'Engineer'}
#可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去。
#试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
>>> extra = {
     'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {
     'city': 'Beijing', 'job': 'Engineer'}

5. 命名关键字参数：用来限制关键字参数的名字，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

def person(name, age, *, city, job):
    print(name, age, city, job)
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
# 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
    print(name, age, args, city, job)

4. 高级特性

4.1 迭代

给定一个list或tuple，通过for循环来遍历这个list或tuple，这种遍历称为迭代（Iteration）。

#只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代
>>> d = {
     'a': 1, 'b': 2}
>>> for key in d:
...     print(key)
...
a
c

• dic迭代：默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。
• enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

• 判断对象是否可迭代：通过collections模块的Iterable类型。一般来说，str、list、dic等都可以迭代，整数等不可以迭代。

4.2 列表生成式

#使用两个变量来生成list
>>> d = {
     'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

注意：for前面的if … else是表达式，没有else 会报错；而for后面的if是过滤条件，不能带else。

>>> [x if x % 2 == 0 else -x for x in range(1, 11)]
[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]
>>> [x for x in range(1, 11) if x % 2 == 0]
[2, 4, 6, 8, 10]

4.3 生成器（generator）

一边循环一边计算的机制，称为生成器：generator
创建方法：
1.把一个列表生成式的[]改成()，就创建了一个generator

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

调用：next(g)：每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。或者使用for循环，因为generator也是可迭代对象。

2.如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。这时候只需要把函数变成generator，即把print(values)改为yield values就可以了：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

注意：1. 函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
2. for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done