python基础教程系列1-基础语法

      最近在学习python，主要通过廖雪峰的python教程入门，看看自己能够花多少时间最快入门。通过写博客梳理自己的知识点，强化自己的记忆。总的学习思路是，快速学习一遍教程，然后做一些算法题目实践，再然后就找几个小项目练手。

     python是解释性语言，没有编译运行，直接运行得到结果，运行过程中逐行翻译得到二进制文件，慢！不会得到exe这种文件。

• 安装运行python

    廖雪峰学习的python版本是python3.7 .在ubuntu 16.04版本中，系统默认安装 了python 2.7和3.5版本，因此参考资料安装python3.7。默认同时安装python编辑器cPython。

    打开终端后，输入python启动python进入Python交互模型，然后输入exit()退出python交互模式。

   用文本编辑器写Python程序，然后保存为后缀为.py的文件，就可以用Python直接运行这个程序了。

　运行python.py程序有两种方法：

  1）python xxx.py

  2)在xxx.py文件里面最前面加上

#!/usr/bin/env python3

然后通过命令给python程序执行权限

chmod a+x hello.py

　然后可以执行通过./xxx.py直接运行程序了。

• 输入input()，输出print()

name = input()

print('hello',name)

• 缩进组织程序结构

      Python使用缩进来组织代码块，请务必遵守约定俗成的习惯，坚持使用4个空格的缩进。以#开头的语句是注释，注释是给人看的，可以是任意内容，解释器会忽略掉注释。其他每一行都是一个语句，当语句以冒号:结尾时，缩进的语句视为代码块。

# print absolute value of an integer:
a = 100
if a >= 0:
    print(a)
else:
    print(-a)

• 数据类型

    字符串是使用‘’ 、“”引起来的文本，如果字符串内部既包含'又包含"怎么办？可以用转义字符来标识，Python允许用'''...'''的格式表示多行内容。

    空值使用None表示。

    python是动态语言，声明一个变量不需要指定数据类型，可以随便赋予不同的数据类型。

a = 123 # a是整数
print(a)
a = 'ABC' # a变为字符串
print(a)

　　全部大写的变量名字表示常量。

数据类型转换

Python内置的常用函数还包括数据类型转换函数，比如int()函数可以把其他数据类型转换为整数：

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

• 字符编码（这块经常忘记，记住UTF-8）

     ASCII编码和Unicode编码的区别：ASCII编码是1个字节，而Unicode编码通常是2个字节。对于英文用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。所以，本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间，其实UTF-8包含了ASCII编码。

    在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

    用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件。

   浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器：

•   Python的字符串

    Python3的字符串使用Unicode编码，使用ord()编码，chr()进行解码。以Unicode表示的str通过encode()方法可以编码为指定的bytes：

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'xe4xb8xadxe6x96x87'

　　如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'xe4xb8xadxe6x96x87'.decode('utf-8')
'中文'

　　要计算str包含多少个字符，可以用len()函数：len('hello'), len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：len(b'ABC')。

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

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

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码。

• 格式化输出

%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。不需要像c语言一样在中间隔开前面输出和%之间的内容。要加引号。

>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

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

字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%。

name = ['d','z']
for x in name:
    print('%s' %(x))#要加引号

• 条件判断和循环

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

age = 20
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')

for循环：for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句。

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

while循环：

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

• 数据结构

顺序存储数据结构：

list列表：可变大小的有序表，类比vector，使用[ ]表示。len()获得list的大小。使用索引访问元素，第一个是0，最后一个可以使用-1进行访问。里面的元素类型可以不同。

常用函数操作：append，insert，pop，pop(i)

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

#在指定位置插入元素
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

#弹出末尾元素
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

#弹出制定位置元素
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

#替换某个元素
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

tuple / ˈtʌpəl/元组：使用（ ）表示。定义好之后就不能改变其中的元素和元组的大小了。只有1个元素的tuple定义时必须加一个逗号,里面的元素加入一个list，就可以改变tuple中list中的元素。

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

关系型数据结构：

dict字典：使用{ }表示。dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入，记住key不能更改！所以list不能作为dict的key。

>>> d['Adam'] = 67
>>> d['Adam']
67

判断key是否存在dictionary的方法有两种：

1）通过in判断key是否存在：

>>> 'Thomas' in d
False

2）通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

>>> d.get('Thomas')#None不显示
>>> d.get('Thomas', -1)
-1

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

set：只存key，不存value，key不能重复。

要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

通过add(key)方法可以添加元素到set中

通过remove(key)方法可以删除元素：

>>> s.add(4)
>>> s
{1, 2, 3, 4}

>>> s.remove(4)
>>> s
{1, 2, 3}

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

• 函数

     可以到Python官网上查看文档，也可以使用help()查看制定函数的帮助。

   函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

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

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

空函数：如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。缺少了pass，代码运行就会有语法错误。

返回多个值，其实就是一个tuple元组：

import math

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

 默认参数要放在参数表的后面，赋值的时候，默认参数必须指向不变对象。如果指向可变对象，就会如下所示：

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

>>> add_end()
['END']
>>> add_end()
['END', 'END']

默认参数是[]，但是函数似乎每次都“记住了”上次添加了'END'后的list。

原因解释如下：

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

要改为指向不变对象None：

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

#调用的时候需要组装一个list/tuple
>>> calc([1, 2, 3])
14

#将函数参数改成可变参数形式
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

>>> calc(1, 2, 3)
14

Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

可变参数适用于函数参数不确定的时候。