Python基础概览

前言

Python自从出现以来，使用者越来越多，而且非常简单易用。
同样的功能，使用Java可能需要1000行代码，但是使用Python可能只需要200行就够了。因为Python作为一门高级语言，有丰富的代码库和高级的数据结构可以使用，对于一些功能不需要重复的开发。而且Python以缩进的风格组织代码，去除了大量的{}表示。最后Python不需要声明很多变量。
Python可以用来做什么：
Python可以作为脚本帮你完成一些重复工作、可以编写GUI程序、可以作为网络服务的后台

Python的编程风格：
Python语法简单，采用缩进的方式，当一条语句以:号结束时，接下来缩进的语句就是代码块。
比如：if,for,while以及函数都是以:号结束。采用缩进可以让代码格式化，但同时在忽略缩进时也可能导致错误。
Python以#开头的语句是注释，#适用于单行注释，多行注释使用”’ ”’(三个单引号)组合。

Python基础

数据类型：
整数：
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3

浮点数：
浮点数运算可能会有四舍五入的误差。

字符串：
字符串是”(单引号)或”“(双引号)括起来的任意副本，字符串在Python中也是不可变的。”和”“只是一种表示，它们也作为字符串的一部分，当一个字符串同时有’和”的存在，可以使用转义符号\。比如：’I\’m \”OK\”!’ 的字符串内容就是：I’m “OK”!
遍历与分割字符串

str = "hello world"
str[0] -> 'h'  # 在位置0的字符
str[-1] -> 'd'  # 最后一个字符
str[1:3] -> 'el' # 从位置1到位置3的字符,包括位置1,不包括位置3
str[:2] -> 'he' #从开始到位置2的字符，不包括位置2
str[2:] -> 'llo world' #从位置2到末尾的字符
str[-2:] -> 'ld' #从倒数第二个到末尾的字符
str[9:99] -> 'ld'  #当超过字符串长度范围时也会自动解决
str[99:] -> ''  #当超过字符串长度范围时也会自动解决
len(str) -> 11 #获取str的长度

str顺序表

  +---+---+---+---+---+---+---+---+---+---+---+
  | h | e | l | l | o |   | w | o | r | l | d |
  +---+---+---+---+---+---+---+---+---+---+---+
  0   1   2   3   4   5   6   7   8   9  10   11
 -11 -10 -9  -8  -7  -6  -5  -4  -3  -2  -1   

布尔值：
在Python中用True和False直接表示布尔值。

空值：
None表示Python的空值，这是一个特殊的值。也可以类比Java中的null

变量：
因为Python是动态语言，所以在运行之前变量的类型是不确定的。比如：可以是这样的

a = 1 
print(a) -> 1
a = "abc"
print(a) -> abc

Python中的数据结构

list:
Python内置的数据类型，是一种有序列表。list中可以存在不同类型的数据

list = []  #创建一个空的list
list = ['1', 2] #创建list
len(list) = 2  #获取list的长度
list[1]  #通过索引获取元素，如果越界会抛出IndexError
list[1] = "2"  #相当于替换元素
list.append(12)   #append(x)添加元素，添加后为：['1', 2, 12]，添加到末尾
list.insert(1, "qqq")  #insert(i, x)将元素插入指定位置i表示位置,x为插入元素
list.remove(2)  #remove(x) 删除相应元素，不存在则抛出错误
list.extend("abc") -> ['1', 2, 'a', 'b', 'c'] #extend(iterable) 向list添加iterable(list、tuple、string等类型) 等效于list[len(list):] = iterable
list.clear() #clear() 清除所有元素 等效于 del list[:] or list[:] = []
list.index(2) -> 1  #index(x[, start[, end ]]) 找出元素在list中的位置,statr和end(都是可选参数)表示在list中的范围
list.count(2) -> 1  #count(x) 统计list中元素的数量
list.pop()  #pop([i]) i是可选参数。不传,则删除末尾元素;传入i,则删除指定位置元素
list.sort()  #sort(key=None, reverse=False) 传入关键字参数,key表示排序的键值,reverse表示是否反转排序结果 将list排序,但不支持不同类型的数据排序,比如int与string
list.reverse() #reverse() 将list元素顺序反转
list.copy #copy() 返回一个list浅拷贝的副本
'''
所谓浅拷贝就是将元素的地址复制到新的list中。
当修改不可变对象时(string、tuple),会在新地址中得到修改值;
不会影响到拷贝的list，但对于可变对象，就会将修改同步到拷贝的list中,比如：
'''
list = [1, 2, ['a']]
list1 = list.copy()
list[2].append('b')
print("list: ", list, "list copy: ", list1)
-> list: [1, 2, ['a', 'b']] list copy: [1, 2, ['a', 'b']]  # list1也被修改

tuple:
tuple也是一种有序列表，但是在初始化之后就不能修改。

tuple = ()  #初始化一个空tuple
tuple = (1, "2")  #初始化tuple
tuple = (1,)   #定义只能有1个元素的tuple,以,号作为标记

dict:
dict是Python中内置的字典，也就是一种Map结构，内部存储无序，使用键值对存储数据，具有很快的查询效率。由于dict需要通过key值计算value存储的位置，所以key必须是不可变的，比如整数和字符串。

dict = ["1":1, "2":2]  #dict初始化
dict["1"] -> 1  #通过键取的相应的值，如果key不存在，抛出KeyError
dict.get("4") -> None #如果键不存在，返回None
dict["3"] = 3  #如果没有相应的键值，加入dict中
dict.pop("3")  #删除键值对"3":3

set:
set是一组有序的集合，set中元素不能重复

#初始化set时传入一个list
set = set([1, 2, 3, 3]) #输出结果是：{1, 2, 3} 
set.add(4)  #加入元素
set.remove(4)   #删除元素

条件判断：
if语句加条件判断，以:号结束，缩进表示该条件下的代码块

if condition : 
    do something...

下面的语句就相当于if和elseif，当某个条件成立时，其他条件语句就不会继续执行

if condition :
    do something...
elif condition :
    do something...
...
else :
    do something...

循环：
Python中有两种循环，一种是for…in循环，另外一种是while循环，循环语句以:号结束。
for…in循环可以将list或tuple或字符串中的元素迭代出来：

list = ["1", "2", 3]
for x in list:
    do something...

tuple = (1, 2, 3)
for x in tuple:
    do something...
#range(100)生成0到100的整数序列
for x in range(100):   
    do something...

Python中的函数

在Python中通过def关键字定义函数，后面跟随函数名、参数列表和:冒号。

def func_name(param...) :
    do something...

函数的参数：
(1)位置参数：
在函数中按照位置顺序赋值。

 def add(a, b):  #调用函数时,传入的两个值按照顺序依次赋值给a和b
        return a + b

(2)默认参数：
将参数设置默认值，当调用函数时没有赋值，则使用默认值。设置默认参数时，必选参数在前，默认参数在后。
(1 默认值在函数定义起点处开始，比如：

    i = 3
    def add(a, b=i):
        return a + b
    i = 4
    add(1) -> 4 #此时b = 3而不是4

(2 默认值只计算一次,下面这个例子默认值被共享

    def f(a, L=[]):
        L.append(a)
        return L
    print(f(1)) -> [1]
    print(f(2)) -> [1, 2]
    print(f(3)) -> [1, 2, 3]

    #解决方案
    def f(a, L=None):
        if L is None:
        L = []
        L.append(a)
        return L

    def add(a, b=2):
        return a + b
    add(2) -> 4

    def add(a, b=1, c=2):
        return a + b + c
    add(1, c=2)  #当有多个默认参数时,如果前面的默认参数不赋值,后面的默认参数需要使用参数名赋值

(3)可变参数：
函数中参数的数量是可变的，可以是0个或者大于0个。

def add(*number):
        sum = 0
        for n in number:
            sum += n
        return sum
    add(1, 2) -> 3
    add() -> 0
    list = [1, 2, 3]
    add(*list) -> 6  #也可以将list作为可变参数传递

(4)关键字参数：
可以传递0个或0个以上的带有参数名的参数，这些参数在函数内部自动组装为dict。

def person(name, age, **other):
        print("name:", name, "age:", age, "other:", other)
    person("ls", 20) -> name: ls age: 20 other: {}
    person("ls", 20, city="hz") -> name: ls age: 20 other: {city: hz}
    dict = {"city:":"hz"}
    person("ls", 20, **dict) -> name: ls age: 20 other: {city: hz}

(5)命名关键字参数：
限制关键字参数的命名，即只接受该命名的参数。使用号与其他参数隔开，号后面的为命名关键字参数，当有可变参数时不用使用*号分隔符。

def person(name, age, *, city, job):
        print(name, age, city, job)
    person('Jack', 24, city='Beijing', job='Engineer') -> Jack 24 Beijing Engineer

函数可以作为参数：
在Python中，函数也可以作为参数传递给其他函数。

def f(x):
        return x
    def add(a, b, f):
        return f(a) + f(b)
    func = f
    add(1, 2, func) -> 3

函数可以作为返回值：
函数处理可以作为参数外，也可以作为结果返回。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f = lazy_sum(1, 3, 5, 7, 9)
f() -> 25

匿名函数：
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

lambda x:x * x <=> 
def f(x):
    return x * x

Python模块

在Python中有内置模块、第三方模块以及自己编写的模块。使用模块时，使用import关键字即可。
模块中的作用域：
在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过_前缀来实现的。
正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等；
类似xxx这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的author，name就是特殊变量，hello模块定义的文档注释也可以用特殊变量doc访问，我们自己的变量一般不要用这种变量名；
类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等;

Fibonacci numbers module 定义一个模块,命名为fibo

def fib(n): # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
    print(b, end=' ')
    a, b = b, a+b
    print()
def fib2(n): # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
    result.append(b)
    a, b = b, a+b
    return result

import fibo  #导入模块
import fibo as fib #相当于给模块设置名称
fibo.fib(2)  #调用模块方法

from fibo import fib, fib2 #导入模块中的fib, fib2,但fibo没有在当前模块的变量表中，无法使用
from fibo import fib as fibonacci #将fib命名为fibonacci
from fibo import * #将fibo模块中所有非private的内容加载进来

模块的搜索：
当导入一个模块spam.py时，Python解释器首先从内置模块中查找(自己定义的模块名称不要与内置模块名称冲突)。如果找到，就是用内置模块;
没有找到，就在由变量sys.path给出的目录列表中搜索名为spam.py的文件。

Python的输入输出

格式化输出：字符串对象使用format方法可以将输出格式化

#{}代表占位符
print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"

# {0}带有位置符号的占位符,根据位置填充
print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam

# 关键字占位符,通过关键字填充
print('This {food} is {adjective}.'.format(food='s 
for name, phone in table.items():
 print('{0:10} ==> {1:10d}'.format(name, phone))
Jack ==> 4098
Dcab ==> 7678
Sjoerd ==> 4127

Python的文件操作
open(filename, mode)方法返回一个文件对象。filename表示文件名，mode表示操作文件的模式（’r’表示只能对文件进行读操作；’w’表示只能对文件进行写，同时文件原有的内容将被擦除；’a’表示在文件末尾追加写入内容；’r+’表示既可以对文件读也可以写。mode参数可选，默认为’r’）当打开一个文件时，默认是由text模式打开的，传入’b’就是以二进制模式打开。

'''
由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现。
'''
try:
    f = open('/path/to/file', 'r')
    print(f.read())
finally:
    if f:
        f.close()

#也可以使用with关键字，可以帮助我们自动关闭文件流,等同于try-finally
with open('workfile') as f:
    read_data = f.read()
f.closed -> true

读取文件内容使用read()方法，可以将整个文件的内容读取出来。如果文件很大，直接使用read()方法就不在适用，这时可以使用read(size)方法，每次最多可以读取size字节的内容，同时还有readline()方法，每次读取一行内容。

#关于readline方法
for line in f.readlines():  #readlines()返回多行内容
    print(line) 
f.readline() #返回一行内容
#另外一种遍历方法
for line in f:
    print(line, end='')

向文件写入内容时，可以使用write()方法。

#关于写操作
f = open('workfile', 'rb+')
f.write(b'0123456789abcdef')  #向文件写入内容
16
f.seek(5) #定位到第6个位置，从第六个字符开始读
5
f.read(1)
b'5'
f.seek(-3, 2) # 定位到倒数第三个字符
13
f.read(1)
b'd'

Python中的错误和异常

Syntax Errors(语法错误)
这个可以说是最普遍的一个错误了。当我们在编写程序时，关键字的拼写错误或者漏了个冒号都会导致这个错误。

while True print('Hello world')
File "<stdin>", line 1
while True print('Hello world')
^
SyntaxError: invalid syntax

当出现语法错误时，解析器会重复有问题的行并显示一个指向检测到错误的行中最早点的“箭头”。 错误是由箭头前面的标记（或至少在其处检测到）引起的：在此示例中，由于在它之前缺少冒号(‘:’)，所以在函数print()处检测到错误。 打印文件名和行号，以便在输入来自脚本时知道在哪里查看。

Exceptions(异常)
即使在编写程序时语法书写正确，但也会产生异常，比如除0异常(ZeroDivisionError)，类型异常(TypeError)以及自定义的异常等。在最后一行会打印错误信息，包括异常类型，放生的位置等。

>>>10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly

Handling Exceptions(处理异常)
在Python中可以通过try-except关键字处理异常。

try语句的工作原理如下。
• 首先，执行try子句（try和except关键字之间的语句）。
• 如果没有发生异常，则跳过except子句，并完成try语句的执行。
• 如果在执行try子句期间发生异常，则会跳过该子句的其余部分。 然后如果它类型匹配以except关键字命名的异常，然后执行except子句try语句后继续执行。
• 如果发生的异常与except子句中指定的异常不匹配，则会传递该异常到外部尝试报表; 如果没有找到处理程序，则它是一个未处理的异常，并且以停止执行.

while True:
    try:
    x = int(input("Please enter a number: "))
    break
    except ValueError:
    print("Oops! That was no valid number. Try again...")

#一个try的声明下，也可以处理多个异常
except (RuntimeError, TypeError, NameError):
    pass

#也可以自定义异常
class B(Exception):
    pass
class C(B):
    pass
class D(C):
    pass
for cls in [B, C, D]:
    try:
        raise cls()
    except D:
        print("D")
    except C:
        print("C")
    except B:
        print("B")

'''
最后一个except子句可以省略例外名称，作为通配符。 请谨慎使用此功能，因为以这种方式很容易掩盖真正的编程错误！
它也可以用来打印错误消息，然后重新引发异常（允许调用者也处理异常）：
'''
import sys
try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

'''
try ... except语句有一个可选的else子句，当存在时，它必须遵循除了子句之外的所有子句。
如果try子句不引发异常，则必须执行该代码。 例如
'''
for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except OSError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

Raising Exceptions(抛出异常)
raise语句可以使程序强制执行指定的异常

>>> raise NameError('HiThere')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: HiThere

Python面向对象编程

类是对事物的一种抽象，可以将数据和功能绑定在一起。在python中，可以使用class关键字创建一个类。

'''
class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的。
'''
class Student(object):
    def __init__(self, name, score): #可以理解为类的构造方法，当实例化类时，会调用该方法
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))
 stu = Student() #实例化一个类
 stu = student("Tom", 99) #实例化类，带参数
 stu.print_score() -> tom: 99  #调用类方法

class Dog:
    tricks = []  # 该类变量被实例共享
    def __init__(self, name):
        self.name = name
    def add_trick(self, trick):
        self.tricks.append(trick)
d = Dog('Fido')
e = Dog('Buddy')
d.add_trick('roll over')
e.add_trick('play dead')
d.tricks # unexpectedly shared by all dogs
['roll over', 'play dead']

#这是正确的使用方式
class Dog:
    def __init__(self, name):
        self.name = name
        self.tricks = [] # creates a new empty list for each dog
    def add_trick(self, trick):
        self.tricks.append(trick)
d = Dog('Fido')
e = Dog('Buddy')
d.add_trick('roll over')
e.add_trick('play dead')
d.tricks
['roll over']
e.tricks
['play dead']

类的访问限制
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__, Python中，实例变量以两个下划线开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。

class Student(object):

    def __init__(self, name, score):
        self.__name = name  #私有变量
        self.__score = score #私用变量

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

类的继承
在面向对象的程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。

class Animal(object):
    def run(self):
        print('Animal is running...')

class Dog(Animal):
    pass

class Cat(Animal):
    pass

dog = Dog()
dog.run() -> Animal is running...  #继承了父类的run()方法
cat = Cat()
cat.run() -> Animal is running...  #继承了父类的run()方法

class Dog(Animal):
    def run(self):
        print('Dog is running...')

class Cat(Animal):
    def run(self):
        print('Cat is running...')

dog = Dog()
dog.run() -> Dog is running...  #重写了父类的run()方法
cat = Cat()
cat.run() -> Cat is running...  #重写了父类的run()方法

类的多重继承
在Python中也支持了多重继承。对于多重继承来说，在最简单的情况下，你可以将从父类继承的属性视为深度优先，从左到右搜索，而不是在层次结构中存在重叠的相同类中搜索两次。 因此，如果在DerivedClassName中找不到属性，则在Base1中搜索该属性，然后（递归地）在Base1的基类中搜索该属性，如果未找到该属性，则在Base2中搜索该属性，依此类推。

#多重继承的基本实现结构
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    ...
    <statement-N>

总结

以上就是对Python基础知识的一个总结，主要参考了官方文档以及廖雪峰的Python教程。Python作为一种高级语言，使得它入门变得相对简单，而且学好了后，Python可以帮我们做很多事情。最后推荐一份关于Python编程风格的文档。