Python学习

简介

• 教程：基于python3.x版本
  https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431611988455689d4c116b2c4ed6aec000776c00ed52000

• 解释性语言，常用作粘合剂
  解释器常用CPython，即C语言开发的解释器
  数学计算表达式：同MATLAB
  在命令行下直接输入数学表达式，会显示结果
  但是运行写好的.py文件不会，除非显式调用print(“”)函数

• 文本编辑器：
  Sublime Text，免费使用，但是不付费会弹出提示框
  notepad++
  不要用记事本（他会在文件开始的地方加上几个特殊字符（UTF-8 BOM），结果会导致程序运行出现莫名其妙的错误）

• linux
  在.py文件目录下 python *.py可以运行
  在linux的.py文件开头写上一下代码可以直接运行

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

语法

• 输入输出
  输出：print函数也可以接受多个字符串，用逗号“,”隔开，遇到逗号“,”会输出一个空格
  输入： name = input()
  后面直接写name观察变量状态

• 编码
  ASCII->Unicode->可变长编码UTF-8
  在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。
  比如，用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件：
  浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器
  Python对bytes类型的数据用带b前缀的单引号或双引号表示：
  x = b’ABC’
  encode()与decode() 字节表示与字符串表示一一对应
  要计算str包含多少个字符，可以用len()函数
  如果换成bytes，len()函数就计算字节数

• 格式化实例

替换符	类型
%d	整数
%f	浮点数
%s	字符串，通用
%x	十六进制整数

'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'
有多个占位符后面就需要加括号进行几个替换，仅有一个占位符时不需要括号
设定格式对齐、补零与小数位数

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

• list与tuple

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

#初始化
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']
#检测长度
>>> len(classmates)
3
#支持下标检索
>>> classmates[0]
'Michael'
#如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素。倒数第2第3则可以用-2,-3引索
#不讲道理的这个，跟MATLAB很像，是约定的，解释性的。
>>> classmates[-1]
'Tracy'
#添加元素
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
#插入元素到指定位置
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
#删除指定位置元素用pop(i)，无i默认删除末尾元素
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']
#替换元素，索引赋值即可
#list里面的元素的数据类型也可以不同
>>> L = ['Apple', 123, True]
#支持嵌套，即list元素可以是另一个list
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4
--------------------------------
tuple
另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改。注意是指向不变而不是内容不变

#改方括号为圆括号表示
>>> classmates = ('Michael', 'Bob', 'Tracy')
#注意括号里面只有一个数时，t为普通变量而不是tuple
#活用t=(1,)表示避免歧义
>>> t = (1)
>>> t
1

• 条件与循环
  
  • 条件语句：不需要括号也不需要end，根据缩进判断结构。注意else后面加冒号，elif分支
    birth = input(‘birth: ‘)：这样输入会有提示，但是输入数字均以str保存，需要强制转换
  • 循环语句

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)
或者for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
range(i)可以生成0~(i-1)的整数序列，可以用于for循环
变量类型()是强制转换的作用，list作为一种变量类型自然也可以
while n > 0:
注意for与while循环中冒号的位置

• dict与set

---------------------------------------
dict类似于C++的 map——key-value存储方式
#初始化
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
#把数据放入dict的方法，除了初始化时指定外，还可以通过key放入
>>> d['Adam'] = 67
>>> d['Adam']
67
#要避免key不存在的错误，有两种办法，
#一是通过in判断key是否存在
>>> 'Thomas' in d
False
#二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value。注意：返回None的时候Python的交互式命令行不显示结果。
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
#要删除一个key，用pop(key)方法，对应的value也会从dict中删除
>>> d.pop('Bob')
75
#要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。

-------------------------------
#初始化需要用到set关键字
>>> s = set([1, 2, 3])
>>> s.add(4)
>>> s.remove(4)
#两个set可以做数学意义上的交集、并集等操作
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

• 函数
  文档查询：http://docs.python.org/3/library/functions.html#abs
  在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。

#还有这种操作
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

#自定义函数
在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
注意缩进，否则expected an indented block

#空函数
如果想定义一个什么事也不做的空函数，可以用pass语句：
def nop():
    pass
作用等同于C++中纯分号

#错误异常处理
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

#头文件：import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数。
#返回多个值的函数，返回值是一个tuple
def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny
#也可以直接用分离变量接受返回值
 x, y = move(100, 100, 60, math.pi / 6)
#函数的默认参数，在C++中也有
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
#这样，当我们调用power(5)时，相当于调用power(5, 2)：默认参数在后，变换小的参数在后
#也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')，意思是，city参数用传进去的值，其他默认参数继续使用默认值。

#以下程序会在每次运行中改变默认值
def add_end(L=[]):
    L.append('END')
    return L
#所以默认参数必须指向不变对象，吧其中的None改成0也是可以的，因为如果有参数输入则程序用输入参数，默认情况下则在函数内部有类型替换
def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

#可变参数，以指针方式输入，写程序和使用都可以当做非指针
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
调用
>>> calc(1, 2)
5
>>> calc()
0
如果已经有一个list或者tuple，要调用一个可变参数
>>> calc(*nums)
14

#关键词参数
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
调用
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
#**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

#如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
def person(name, age, *, city, job):
    print(name, age, city, job)
#如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
#后面两个将不会被视为位置参数
def person(name, age, *args, city, job):
    print(name, age, args, city, job)
#所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

高级特性

• 切片

L[0:3]  #索引不包括3，切片的个数是首尾相减
['Michael', 'Sarah', 'Tracy']
第一个参数：起
第二个参数：止
默认为头部或者尾部
第三个参数：切片间隔

迭代——实际上是元素的遍历方式

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)  #这输出还自带换行的
...
a
c
b
因为dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样。
默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()

#如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：
>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

#如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：
>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

• 列表生成器

>>> [x * x for x in range(1, 11)]
#还可以使用两层循环，可以生成全排列：
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
#把一个list中所有的字符串变成小写
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']
#直接输出的每个都是字符串，所以.lower()实际上可以对字符串操作

使用内建的isinstance函数可以判断一个变量是不是字符串：
>>> x = 'abc'
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, str)
False