本文共 15955 字，大约阅读时间需要 53 分钟。

一、数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

1．Python3中有六个标准的数据类型：

       Number（数字）  String（字符串）        List（列表）

       Tuple（元组）      Set（集合）               Dictionary（字典）

       其中数字、字符串、元组为不可变数据类型。

2．Number

int

float

bool

complex（实部和虚部为浮点型）

3．String

使用单引号、双引号、三引号（多行）括起来的字符序列。同时使用反斜杠\转义特殊字符。如果不需要让反斜杠发生转义，可以在字符串前添加r,例如：r’RU\noon’,此外反斜杠可以作为续行符，表示下一行是上一行的延续。

没有单独的字符类型，一个字符就是长度为1的字符串。

注意：print函数末尾自带换行符

4．List

写在[]之间的、用逗号分隔的元素列表，列表的元素类型可以不同而且值可以改变。

5．Tuple

写在（）中，元素之间用逗号隔开，元组中的类型也可以不同，不过元组中的数据元素不可以改变。

6．Set

集合（set）是一个无序不重复元素的序列。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

7.字典

Dictionary中的元素是通过键值来存取的，字典使用{}标识，是一个无序的键值对的集合。在同一个字典中，键必须是唯一的。

label = {"tele": telephone, "email": email, "add": address, "birth": birthday}

 

8.数据类型转换

       与c++相似，例如int(x)表示将x转换为一个整数。

 

二 、运算符

算数运算符：＋ － *  /  %  **（幂运算）//（整除）

比较运算符：==  !=  >  <  >=  <=

赋值运算符：=  +=  -=  *=  /=  %=  **=  //=

位运算符：&（按位与） |（按位或） ^（异或） ~（取反） <<  >>

逻辑运算：and  or  not

成员运算符：in   not in

身份运算符：is   is not

 

三、控制流

1.if语句

 注意if语句后面的冒号

number = 23guess = int(input('Enter a integer'))if guess == number:    print('Congratulations! You guessed it')elif guess < number:    print('No, it is a little higher than that')else:    print('No, it is a little lower than that')print("Done")

 

2. while语句

   注意while语句后面的冒号，while匹配的else语句表示while循环条件为假时执行的语句块。

number = 23running = Truewhile running:    guess = int(input('Enter a integer'))    if guess == number:        print('Congratulations! You guessed it')    elif guess < number:        print('No, it is a little higher than that')    else:        print('No, it is a little lower than that')else:  # 在while循环的条件变成假时开始执行    print("The while loop is over")print("Done")

 

3. for…in...语句

  与C#中的foreach语句意思相近。

# range()返回左开右闭区间上的数字，可以通过第三个参数设置步长for i in range(1, 5):    print(i)# for循环结束后执行else包含的语句else:    print("The for loop is over!")

4.break语句

while True:    s = input("Enter something:")    if s == 'QUIT':        break    print("Lenght of the string is", len(s))

5.continue语句

while True:    s = input("Enter something:")    if s == 'QUIT':        break    if len(s) < 3:        print("Too small!")        continue    print("Input is of sufficient length")

 

四 、迭代器与生成器

1.迭代器

迭代器是访问集合元素的一种方式，是一个可以记住遍历位置的对象。从对象集合的第一个元素开始访问，直达所有的元素被访问技术，迭代器只能往前不能后退。

两个基本的方法：iter() next()

import sys              # 引入sys模块list = [1, 2, 3, 4]     # 定义列表it = iter(list)         # 创建迭代器对象while True:    try:        print(next(it))    # 输出迭代器的下一个元素    except StopIteration:        sys.exit()

2.生成器：使用yield的函数

生成器是一个返回迭代器的函数，只能用于迭代操作。在调用生成器运行的过程中，每次遇到yield时函数会暂停并保存当前所有的运行信息，返回yield的值，并在下一次执行next()方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

import sysdef fibonacci(n):       # 生成器函数——斐波那契    a, b, counter = 0, 1, 0    while True:        if counter > n :            return        yield a        a, b = b, a+b        counter += 1f = fibonacci(10)   # f是一个迭代器，由生成器返回生成while True:    try:        print(next(f), end=" ")    except StopIteration:        sys.exit()

 

五 、函数

1.定义函数：注意（）后面的冒号

def say_hello():    print("Hello Wrold")# 函数结束say_hello()

2.函数调用

# 定义函数def print_max(a, b):    if a > b:        print(a, "is maximum")    elif a==b:        print(a, "is equal to b")    else:        print(b, "is maximum")# 函数调用，传递常量print_max(2, 3)# 函数调用，传递参数x = 5y = 7print_max(x, y)

3.参数传递

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

def ChangeInt(a):    a = 10    b = 2ChangeInt(b)print(b) # b的值仍然是2

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

def changeme(mylist):    """修改传入的列表"""    mylist.append([1, 2, 3, 4])    print("函数内取值: ", mylist)    return# 调用changeme函数mylist = [10, 20, 30]changeme(mylist)print("函数外取值: ", mylist)

 

3.gobal语句：用于声明一个变量为全局变量

global x, y, z # 声明x,y,z为全局变量

4.默认参数数值

 函数中的某些参数可选并使用默认的值，通过在函数定义时附加一个赋值运算符来为参数指定默认参数值。默认参数值是常数，而且是不可改变的。

 注意只有位于参数列表末尾的参数才能被赋予默认的参数值，也就是说在函数的参数列表中拥有默认参数值的参数不能位于没有默认参数值的参数之前。

def say(message, times = 1):    # 为参数times指定默认值1，注意末尾的冒号    print(message * times)say('Hello')        # 使用times的默认值，打印1次say('Hello', 5)     # times的值为5，打印5次

5.关键字参数 Keyword Arguments

  使用命名（关键字）而非位置来指定函数中的参数。

def func(a, b = 5, c = 10):    print('a is', a, 'and b is', b, 'and c is', c)# 函数调用func(3, 7)func(25, c = 24)func(c = 50, a = 100)    # 全部使用关键字参数来指定值

6.可变参数

  定义的函数里面能够有任意数量的变量，也就是参数数量是可变的，使用*来实现。

def total(a=5, *numbers, **phonebook):    """声明一个*para的星号参数时，从此开始到结束的所有位置参数都将被收集并汇集成一个名为para的元组"""    """同样，声明一个**param的双星号参数时，从此开始到结束的所有关键字参数都将被收集并汇集成一个名为param的字典"""    print('a', a)    # 遍历元组中的所有项目    for single_item in numbers:        print('single_item', single_item)    # 遍历字典中的所有项目    for first_part, second_part in phonebook.items():        print(first_part, second_part)print(total(10, 1, 2, 3, Jack = 1223, John = 2351, Inge = 4231))

7.匿名函数

所谓匿名，是指不用使用def语句定义函数，而是使用lambda来创建匿名函数。lambda只是一个表达式，函数体比def简单；它拥有自己的命名空间，不能访问自己的参数列表或全局命名空间里的参数。

sum = lambda arg1, arg2: arg1 + arg2# 调用sum函数print("相加后的值为：", sum(10, 20))

 

8.return语句

 return语句用于从函数中返回，也就是中断函数。如果return语句，没有搭配任何一个值则代表着返回None。None在Python中是一个特殊的类型，代表着虚无。每一个函数在其末尾隐含了一句return None,除非自己写了return语句。

def maximum(x, y):    if x > y:        return x    elif x == y:        return 'The numbers are equal'    else:        return yprint(maximum(2, 3))

9.文档字符串 Document Strings（DocStrings）

# 函数的第一行逻辑行中的字符串是该函数的文档字符串。该文档字符串是一串多行字符串def maximum(x, y):    """打印两个数值中的最大数    这两个数都应该是整数"""    x = int(x)    y = int(y)    if x > y:        print(x, 'is maximum')    else:        print(y, 'is maximum')print(maximum(2, 3))# 使用函数的__doc__属性来获取maximum函数的文档字符串属性print(maximum.__doc__)

 

六 、数据结构 Data Structures

 数据结构是一种结构，能够将一些数据聚合在一起，即用来存储一系类相关数据的集合。

 Python中有四种内置的数据结构——列表List、元组Tuple、字典Dictionary和集合Set。

1.列表List

 列表是一种用于保存一系列有序项目的集合。列表用方括号括起来，创建列表后，可以添加、删除或者搜索列表中的项目。列表是一种可变的数据类型。

# This is my shopping listshopping_list = ['apple', 'mango', 'carrot', 'banana']  # 定义列表# 返回列表长度print('I have', len(shopping_list), 'items to purchase.')   # len()返回列表的长度# 输出列表元素print('The items are:', end=" ")    # end参数通过一个空格来结束输出，而不是通常的换行for item in shopping_list:    print(item, end=" ")# 添加列表元素print("\nI also have to but rice.")shopping_list.append('rice')    # 通过列表对象的append方法向列表中添加一个对象print("The shopping list is now", shopping_list)# 列表排序print("I will sort my list now")shopping_list.sort()    # sort函数排序后不会返回一个修改过的列表，而是影响列表本身print("The shopping list is now", shopping_list)# 访问列表元素print("The first item I will buy is", shopping_list[0])olditem = shopping_list[0]# 删除列表元素del shopping_list[0]    # del语句用于删除项目print("I bought the", olditem)print("My shopping list is now", shopping_list)

2.元组Tuple

元组用于将多个对象保存到一起，元组类似于列表，但不能更改和编辑。通过指定项目来定义，在指定项目时，加上（），并在括号内部用逗号分隔。元组通常用于保证某一语句或某一用户定义的函数可以安全的采用一组数据。

zoo = ('python', 'elephant', 'penguin')     # 定义元组，包含了3个项目print("Number of animals in the zoo is", len(zoo))new_zoo = 'monkey', 'camel', zooprint("Number of cages in the new zoo is", len(new_zoo))print("All animals in new zoo are:", new_zoo)print("animals brought from old zoo are:", new_zoo[2])  # 通过索引运算符[]获得指定项目print("Last animal brought from old zoo are:", new_zoo[2][2])print("Number of animals in the new zoo is", len(new_zoo) - 1 + len(new_zoo[2]))

3.字典

字典是无序的键值对集合,形式：d = {key1 : value1,  key2 : value2 },key称为键值，value称为值。Key必须是唯一的，而且不可变。磁瓦字典中成对的键值——值匹配对不会以任何方法进行排序。

# 定义字典ab = {    'Swaroop': 'swaroop@swaroop.com',    'Lary': 'Lary@wall.org',    'Liuhui': 'liuhui@126.com',    'Spammer': 'spammer@hotmail.com'}# 通过键值获得相应的值print("Liuhui's address is", ab['Liuhui'])# 删除一对键值对del ab['Lary']print("\nThere are {} contacts in the address-book\n".format(len(ab)))# 遍历所有的键值对for name, address in ab.items():    print('Contact {} at {}'.format(name,address))# 添加键值对ab['Guido'] = 'Guido@python.org'# 根据键值搜索相应的键值对if 'Guido' in ab:    print("Guido's address is", ab['Guido'])

4.序列

列表、元组、字典都可以看做是序列的某种表现形式。序列的主要功能是资格测试（也就是in 和not in表达式）和索引操作。列表、元组、字典同样拥有一种切片运算符，能够容许将序列中的某段切片——取序列中的一部分。

# This is my shopping listshopping_list = ['apple', 'mango', 'carrot', 'banana']  # 定义列表# 索引操作i = 0while i < len(shopping_list):    print("Item", i, 'is', shopping_list[i])    # 通过索引运算符[]    i += 1# 切片操作print("Item 1 to 3 is", shopping_list[1:3])     # 冒号前数字为开始位置，冒号后为结束位置，取[1.3)print("Item 2 to end is", shopping_list[2:])    # 第二个数字不写，表示到最后一个元素print("Item 1 to -1 is", shopping_list[1:-1])   # 负数表示从末尾开始计数print("Item start to end is", shopping_list[:]) # 两个数字都不写表示整个序列# 设置步长print(shopping_list[::1])   # 第三个参数表示步长，默认为1print(shopping_list[::2])print(shopping_list[::-1])

5.集合

  集合是简单对象的无序集合。

6.引用

  创建一个对象，并将其分配给某个变量时，变量只会查阅某个对象，不会代表对象本身。

print("Simple Assignment:")shopping_list = ['apple', 'mango', 'carrot', 'banana']  # 定义列表mylist = shopping_list  # mylist只是指向同一对象的另一种名称# 删除一个项目del shopping_list[0]print("shopping_list is:", shopping_list)print("mylist is:", mylist)print("Copy by making a full slice:")mylist = shopping_list[:]del mylist[0]print("shopping_list is:", shopping_list)print("mylist is:", mylist)

   如果需要创建复杂对象的副本，必须使用切片操作。

 

七 、模块

如果使用python解释器来编程，那么所定义的方法、变量在退出解释器后就无法再使用了。因此，Python提供了一个方法，把定义存放在文件中，这个文件就被称为模块。模块是一个包含用户定义函数和变量的文件，后缀为.py。

模块可以被别的程序引入，以使用该模块中的函数等功能。在使用Python标准库的功能时也是如此。（个人理解：类似C语言中的include<>和inlucde’’）

1.Python标准库 import语句

# 通过import语句导入sys模块import sys  # sys模块包含了与Python解释器及其环境相关的功能，也就是所谓的系统功能print('The command line arguments are:')for i in sys.argv:  # sys.argv变量是一系列字符串的列表，包含命令行参数    print(i)# sys.path包含了导入模块的字典名称列表。print('\n\nThe PYTHONPATH is', sys.path, '\n')

2. from import语句

from math import sqrtprint("Square root of 16 is", sqrt(16))

为了避免每次都使用sys. ，可以使用from import语句。不过一般尽量避免使用，这是为了避免名称冲突，同时也使得程序更加易读。

3.模块的__name__

每个模块都有一个名称，模块中的语句可以找到他们所处的模块的名称。这可以用于确定模块是独立运行还是被导入进来运行的。如果模块的__name__属性与__main__属性相同则代表这一模块是由用户独立运行的。

if __name__ == '__main__':

    print('This program is being run by itself.')else:

    print('I am being imported from another module.')

4.dir函数

Python内置的dir（）函数能够返回由对象所定义的名称列表。如果这一对象是一个模块，则该列表会包含所定义的函数、类与变量。

如果参数是模块名称，则返回这一指定模块的名称列表，如果没有提供参数，则返回当前模块的名称列表。

 

5.包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。比如一个模块的名称是 A.B， 那么它表示一个包 A中的子模块 B 。如同函数是程序中的可重用部分那般，模块是一种可重用的程序，包是用于组织模块的另一种层次结构。

 

八 、面向对象

1.基本概念

字段Field ：属于对象或者类的变量，分为实例变量和类变量

方法Method：属于类的函数

属性Attribute：字段和属性统称类的属性

类变量Class Variable：共享的，可以被属于该类的所有实例访问。任何一个对象对类变量做出改变时，发生的变动将在其他所有实例中得到体现。

对象变量Object Variable：由类的每一个独立的对象或者实例所拥有。

2.类定义

# 定义类class Robot:    """表示一个带有名字的机器人"""    # 一个类变量，用来计数机器人的数量    population = 0    # 定义类的方法    # __init__方法 在对象被实例化的时候运行，类似C++、Java和C#中的构造函数的功能    def __init__(self, name):       # self：类似于Java和C#中的this指针        """初始化数据"""        self.name = name            # name变量属于对象，使用self访问        print("(Initializing{})".format(self.name))        Robot.population += 1       # population变量属于类，使用类名访问    def die(self):        """死亡"""        print("{}is being destroyed!".format(self.name))        Robot.population -= 1        if Robot.population == 0:            print("{}was the last one".format(self.name))        else:            print("There are still{:d}robots working".format(Robot.population))    def say_hi(self):        """问候"""        print("Greetings, my masters call me{}".format(self.name))    # 类方法 使用装饰器@classmethod将其标记为类方法    @classmethod    def how_many(cls):        """打印当前机器人的数量"""        print("We have {:d}robots".format(cls.population))# 类的实例化，声明对象droid1 = Robot("R2-D2")droid1.say_hi()     # 对象方法，使用对象名访问Robot.how_many()    # 类方法，使用类名访问droid2 = Robot("C-3P0")droid2.say_hi()Robot.how_many()print("\nRobots can do some work here\n")print("Robots have finished their work")droid1.die()droid2.die()Robot.how_many()

注意：Python中所有的类成员都是公开的，因此，最好在类或者对象之中使用的变量名以双下划线开头，Python会将其调整为私有变量。

3.继承 Inheritance

# 定义父类 SchoolMemberclass SchoolMember:    """代表学校里的所有成员"""    def __init__(self, name, age):        self.name = name        self.age = age        print("Initialized SchoolMember:{}".format(self.name))    def tell(self):        """显示详细信息"""        print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")# 定义子类 Teacher类class Teacher(SchoolMember):    # 注意继承父类的写法    """代表一位老师"""    def __init__(self, name, age, salary):        SchoolMember.__init__(self, name, age)  # 显式调用父类构造函数        self.salary = salary        print("Initialized Teacher:{}".format(self.name))    def tell(self):        SchoolMember.tell(self)        print('Salary: "{:d}"'.format(self.salary))# 定义子类 Student类class Student(SchoolMember):    """代表一位学生"""    def __init__(self, name, age, marks):        SchoolMember.__init__(self, name, age)        self.marks = marks        print("Initialized Student:{}".format(self.name))    def tell(self):        SchoolMember.tell(self)        print('Marks: "{:d}"'.format(self.marks))# 实例化类的变量，定义对象t = Teacher('Lily', 39, 10000)s = Student('hyy', 20, 87)members = [t, s]    # 定义成员列表for member in members:    member.tell()   # 调用的是子类的tell方法，如果子类没有，会搜索父类

 

九、输入输出

1.输入

input 函数可以接收一个Python表达式作为输入，并将运算结果返回。input()可以接受一个字符串作为参数，并将其展示给用户。然后等待用户输入内容，如果用户输入，将返回用户输入的文本。

def reverse(text):    return text[::-1]def is_palindrome(text):    return text == reverse(text)something = input("Enter text:")if is_palindrome(something):    print("Yes, it is a palindrome")else:    print("No, it is not a palindrome")

2.输出

使用print()函数打印结果，同时可以使用 str.format() 函数来格式化输出值。

import mathprint('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))

：后的整数表示宽度，小数表示保留到小数点后几位

3.读写文件

创建一个属于file类的对象，使用其read、readline、write等方法打开或使用文件，对文件进行读写操作，当使用结束后需要close文件。

打开文件：open(filename, mode)。mode：决定了打开文件的模式：阅读（r）、写入（w）、追加（a）,文本模式（t）、二进制模式（b）

pome = """\Programming is funwhen the work is doneif you want to make your work also fun    use Python"""# 打开文件f = open('contacts.txt', 'w')   # 写模式打开contacts文件f.write(pome)                   # 写入poemf.close()                       # 关闭文件f = open('contacts.txt', 'r')   # 读模式打开contacts文件while True:                     # 读文件    line = f.readline()    if len(line) == 0:        break    print(line, end=" ")f.close()                       # 关闭文件

4.文件对象f的方法

○ f.read(size)：读取一定数目的数据, 然后作为字符串或字节对象返回。size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

○f.readline()：从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

○f.readlines()：返回该文件中包含的所有行。如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

○f.write(string)：将 string 写入到文件中, 然后返回写入的字符数。

○f.tell()：返回文件对象当前所处的位置, 从文件开头开始算起的字节数。

○f.close()：关闭文件并释放系统的资源

5.Pickle

 标准模块Pickle可以将任何纯Python对象存储到一个文件中，并将其取回。

import pickle# 使用pickle模块将数据对象保存到文件data1 = {'a': [1, 2.0, 3, 4+6j],         'b': ('string', u'Unicode string'),         'c': None}selfref_list = [1, 2, 3]selfref_list.append(selfref_list)output = open('data.pkl', 'wb')# Pickle dictionary using protocol 0.pickle.dump(data1, output)# Pickle the list using the highest protocol available.pickle.dump(selfref_list, output, -1)output.close()

十、异常 Exception

1.异常与异常处理

 Python有两种错误很容易辨认：语法错误和异常。即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。

异常处理使用try…except…else或者try…except…finally语句，把容易发生异常的语句放在try代码块中，并将相应的错误或异常处理放在except子句中，else 子句可选，在没有发生异常的时候执行;finally子句也是可选的，无论是否发生异常，finally子句总会执行。

2.抛出异常

Python 使用 raise 语句抛出一个指定的异常。

3.自定义异常

通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承。

# 定义异常类class ShortInputException(Exception):   # 继承Exception类    """自定义异常类"""    def __init__(self, length, atleast):        Exception.__init__(self)        self.length = length        self.atleast = atleasttry:    text = input('Enter something:')    if len(text) < 3:        raise ShortInputException(len(text), 3)  # 抛出异常except EOFError:    print("Why did you do an EOF on me?")except ShortInputException as ex:    print('ShortInputException: The input was'+'{0}long,excepted at least{1}'.format(ex.length,ex.atleast))else:    print("No exception was raised")

4.with open：关闭文件的操作

with open("myfile.txt") as f:    for line in f:        print(line, end="")

 

十一、标准库 Python Standard Library

sys模块：包括了一些针对特定系统的功能

logging模块：日志模块，用于记录日志信息

os模块：和操作系统交互

platform模块：获得操作系统的信息

math模块：为浮点运算提供了对底层C函数库的访问

datetime模块：为日期和时间处理同时提供了简单和复杂的方法。支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出。