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'\xe4\xb8\xad\xe6\x96\x87'

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

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.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

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