简明Python教程（A Byte of Python中文版）

参考资料地址：https://github.com/LenKiMo/byte-of-python（中文版）

https://github.com/swaroopch/byte-of-python（英文版）

https://python.swaroopch.com/（英文版）

注意点：

1. Python特点：解释性语言（无需编译成二进制码，直接源码->字节码->电脑语言）、强面向对象　　//字节码文件以.pyc为扩展名，独立于运行平台

2. 变量：无需声明或定义数据类型；没有long和char类型

3. 格式化方法：format()函数

4. 换行连接

• 显示行连接：利用"\"连接多行　　//后面立即接换行
• 隐式行连接：以括号开始的多行

5. Python 对块使用缩进，不使用大括号，同一组语句（块）缩进必须相同　　//建议统一用四个空格进行缩进

6. 运算符：整除为“//”

7. 控制流：Python不存在switch语句；while和for语句可以拥有else子句

8. 函数

（1）函数参数：

• 定义函数时给定的名称称作“形参”，调用函数时提供给函数的值称作“实参”
• 默认参数值：在定义时进行赋值　　//有默认参数值的参数必须位于参数列表的末尾
• 关键字参数：使用命名（关键字）而非位置来指定函数中的参数　　//优点：无需考虑参数顺序；仅需对部分指定参数进行赋值，其他的参数使用默认值
• 可变参数（参数数量是可变的）：def func(param1, *param2, **param3)，如：

def total(a=5, *numbers, **phonebook):
    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=1123,John=2231,Inge=1560))           

其中，*param2参数表明所有未指定的位置参数将构成名称为“param2”的元组（Tuple）,而**param3则表明所有未指定的关键字参数将构成名字为“param3”的字典（dictionary）

（2）变量作用域

局部变量：变量的作用域为被定义的块，如函数内变量

全局变量：使用global语句进行声明后再使用

（3）文档字符串(DocStrings)：用于在函数定义开始对程序功能进行说明，如 def print_max(x, y):

    '''Prints the maximum of two numbers.打印两个数值中的最大数。
    The two values must be integers.这两个数都应该是整数'''
    # 如果可能，将其转换至整数类型
    x = int(x)
    y = int(y)
    if x > y:
        print(x, 'is maximum')
    else:
        print(y, 'is maximum')

print_max(3, 5)
print(print_max.__doc__)      #使用函数对象的__doc__属性 ，也可使用help函数：help（print_max）,或者pydoc命令

注：文档字符串一般约定为一串多行字符串，其中第一行以某一大写字母开始，以句号结束。第二行为空行，后跟的第三行开始是任何详细的解释说明。

 9. 模块（以.py为后缀名，包含函数与变量的文件）

（1）导入模块

• （建议）利用import语句导入模块：如import sys　　//Python从当前程序目录和sys.path变量所提供的目录进行模块搜索；sys.path的值与环境变量PYTHONPATH等同
• 利用from...import...语句　　//应避免使用，防止程序中出现命名冲突
• 利用from...import *导入模块中所有公共名称　　//避免使用

（2）常用模块

import os, time

• print(os.getcwd())　　//输出当前目录
• os.sep　　//当前操作系统所采用的分隔符（便于程序可移植），Linux为“/”，Windows为“\\”（转义\），Mac为“：”
• os.path.exists()　　//判断目录路径是否存在
• os.mkdir()　　//创建目录
• time.strftime()　　//将当前日期转化为字符串，可以设置显示格式
• os.system()　　//使命令从系统中运行，如shell
• os.remove()　　//删除文件

（3）模块的名称__name__属性，用于确定所在模块的名称，如利用__name__确定模块是独立运行还是被导入进来运行：

if __name__ == '__main__':
    print('This program is being run by itself')
else:
    print('I am being imported from another module')

注：每一个 Python 模块都定义了它的 __name__ 属性。如果它与 __main__ 属性相同则代表这一模块是由用户独立运行的

（4）dir()函数　　//内置函数返回由对象所定义的名称列表，如果参数是模块名称，函数将返回这一指定模块的名称列表（函数、类、变量）；如果没有提供参数，函数将返回当前模块的名称列表。　　//del语句用于删除变量或名称，如del a

（5）包（Packages）：组织模块的层次结构　　//from 包.模块 import ...　　需要包文件夹位于python的搜索路径——环境变量PYTHONPATH中

包是指一个包含模块与一个特殊的__init__.py文件的文件夹　　//__init__.py表明这一文件夹包含Python模块

#创建一个名为“world”的包，其中还包含着 “asia”、“africa”等其它子包
#同时这些子包都包含了诸如“india”、“madagascar”等模块。
 1 - <some folder present in the sys.path>/
    - world/
        - __init__.py
        - asia/
            - __init__.py
            - india/
                - __init__.py
                - foo.py
        - africa/
            - __init__.py
            - madagascar/
                - __init__.py
                - bar.py

10. 数据结构

（1）列表（可变数据类型）：利用方括号定义，如shoplist = ['apple', 'mango', 'carrot', 'banana']　　//help(list)查看更多细节

（2）元组（不可变数据类型）：将多个对象保存在一起，建议利用圆括号定义，如zoo = ('python', 'elephant', 'penguin')，单项目元组 singleton = (2, ) 　　//help(tuple)

（3）字典（可变数据类型）：存储“键-值”对（类似地址簿），利用花括号定义，如d = {key : value1 , key2 : value2}，其中键必须是不可变的对象（如字符串），且字典中不同“键-值”对是无序的　　//help(dict)

（4）序列：列表、元组和字符串均可以看作序列（Sequence）的某种表现形式，序列的主要功能是资格测试（in和not in表达式）和索引操作（从0开始）

（5）集合：简单对象的无序集合，如bri = set(['brazil', 'russia', 'india'])　　//help(set)

（6）利用变量创建对象，变量仅仅是对对象的一个引用（refer），即变量名仅指向对象在内存中的地址，也被视为将名称绑定(Binding)到对象上；示例代码如下：

print('Simple Assignment')
shoplist = ['apple', 'mango', 'carrot', 'banana']
# mylist 只是指向同一对象的另一种名称
mylist = shoplist　　#简单赋值，不创建副本
# 我购买了第一项项目，所以我将其从列表中删除
del shoplist[0]
print('shoplist is', shoplist)
print('mylist is', mylist)
# 注意到 shoplist 和 mylist 二者都
# 打印出了其中都没有 apple 的同样的列表，以此我们确认
# 它们指向的是同一个对象
print('Copy by making a full slice')
# 通过生成一份完整的切片制作一份列表的副本
mylist = shoplist[:]　　#切片操作创建新的副本
# 删除第一个项目
del mylist[0]
print('shoplist is', shoplist)
print('mylist is', mylist)
# 注意到现在两份列表已出现不同

注：列表等复杂对象的赋值语句只是对同一对象的“查阅”，如果需要创建副本，必须使用切片操作制作副本

 11. 面向对象编程

对象（object）是类（class）的实例（instance），包含两种属性（attribute）：字段（变量）、方法（函数）

（1）类方法和普通函数的区别：类方法的第一个参数必须为self（引用对象本身）且不可缺省，但是调用时无需显式赋值　　//相当于C++中的指针以及Java与C#中的this指针

（2）__init__()方法：进行对象初始化，且无需显式调用　　//前后均为双下划线

class Person:
    def __init__(self, name):　　#无需显式调用
        self.name = name
    def say_hi(self):
        print('Hello, my name is', self.name)

p = Person('Swaroop')
p.say_hi()
# 前面两行同时也能写作
# Person('Swaroop').say_hi()    

（3）类变量和对象变量：类变量为该类的所有实例共享，对象变量为类的实例对象独立拥有

# coding=UTF-8
class Robot:
    """表示有一个带有名字的机器人。"""
    # 一个类变量，用来计数机器人的数量
    population = 0
    def __init__(self, name):
        """初始化数据"""
        self.name = name
        print("(Initializing {})".format(self.name))
        # 当有人被创建时，机器人
        # 将会增加人口数量
        Robot.population += 1　　#等同于self.__class__.population += 1

    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　　#类方法，使用装饰器Decorator将how_many标记为类方法
    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-3PO")
droid2.say_hi()
Robot.how_many()

print("\nRobots can do some work here.\n")
print("Robots have finished their work. So let's destroy them.")
droid1.die()
droid2.die()

Robot.how_many()

注：

• 所有的类成员都是公开的，如果使用数据成员并在其名字中使用双下划线作为前缀，形成诸如 __privatevar这样的形式，Python会使用名称调整来使其有效地成为一个私有变量；因此，建议遵循如下约定：任何在类或对象之中使用的变量其命名应以下划线开头，其它所有非此格式的名称都将是公开的，并可以为其它任何类或对象所使用。
• 装饰器（Decorators）是应用包装函数的快捷方式，有助于将某一功能与一些代码一遍又一遍地“包装”
• python装饰器的通俗理解：https://blog.csdn.net/u013471155/article/details/68960244

（4）继承：基类/超类、派生类/子类、多态性（子类型对象可以看作父类的实例）

# coding=UTF-8
class 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=" ")

class Teacher(SchoolMember):　　#继承，参数为包含基类名称的元组
    '''代表一位老师。'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)　　#子类定义__init__的情况下需要显式调用父类构造函数__init__
        self.salary = salary
        print('(Initialized Teacher: {})'.format(self.name))

    def tell(self):
        SchoolMember.tell(self)　　#子类对象作为父类方法的实例参数
        print('Salary: "{:d}"'.format(self.salary))

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('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 25, 75)
# 打印一行空白行
print()

members = [t, s]
for member in members:
    # 对全体师生工作
    member.tell()

 12. 输入与输出

（1）用户输入内容：input()函数

（2）文件：创建（open）一个属于file类的对象并适当使用它的read、readline、write方法

poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
use Python!
'''

# 打开文件以编辑（'w'riting）
f = open('poem.txt', 'w')
# 向文件中编写文本
f.write(poem)
# 关闭文件，保证内容已经被写入到文件
f.close()

# 如果没有特别指定，
# 将假定启用默认的阅读（'r'ead）模式
f = open('poem.txt')
while True:
    line = f.readline()
    # 零长度指示 EOF
    if len(line) == 0:
    break
    # 每行（`line`）的末尾
    # 都已经有了换行符
    #因为它是从一个文件中进行读取的
    print(line, end='')
# 关闭文件
f.close()

（3）pickle标准模块：将任何纯Python对象存储到一个文件中，并在稍后将其取回

import pickle

# The name of the file where we will store the object
shoplistfile = 'shoplist.data'
# The list of things to buy
shoplist = ['apple', 'mango', 'carrot']

# Write to the file
f = open(shoplistfile, 'wb')
# Dump the object to a file
pickle.dump(shoplist, f)　　#封装
f.close()

# Destroy the shoplist variable
del shoplist

# Read back from the storage
f = open(shoplistfile, 'rb')
# Load the object from the file
storedlist = pickle.load(f)　　#拆封
print(storedlist)

13. 异常

（1）try..except...语句：检查语句，并根据异常类型进行相应的处理

try:　　
    text = input('Enter something --> ')　　#需要检查的语句块
except EOFError:　　#捕获异常类型
    print('Why did you do an EOF on me?')
except KeyboardInterrupt:
    print('You cancelled the operation.')
else:
    print('You entered {}'.format(text))

（2）raise语句：主动抛出异常对象，引发异常处理

# encoding=UTF-8

class ShortInputException(Exception):　　#继承自Exception类
    '''一个由用户定义的异常类'''
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

try:
    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, expected at least {1}').format(ex.length, ex.atleast))
else:
    print('No exception was raised.')    

（3）try...finally...：确保finally出的语句块被执行，例如确保文件对象的正确关闭

import sys
import time

f = None
try:
    f = open("poem.txt")
    # 我们常用的文件阅读风格
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print(line, end='')
        sys.stdout.flush()　　#将输出立即打印到屏幕
        print("Press ctrl+c now")
        # 为了确保它能运行一段时间
        time.sleep(2)　　#休眠两秒
except IOError:
    print("Could not find file poem.txt")
except KeyboardInterrupt:
    print("!! You cancelled the reading from the file.")
finally:　　#该部分子句一定会执行
    if f:
        f.close()
    print("(Cleaning up: Closed the file)")    

注：确保文件关闭的快捷方式——with语句（避免显示调用try...finally语句）

#with语句会获取由open语句返回的对象‘thefile’，并在代码块开始前调用thefile.__enter__函数，在代码块执行完毕之后调用thefile.__exit__
1 with open("poem.txt") as f:　　#将关闭文件的操作交由with open来自动完成(__exit__方法）
    for line in f:
        print(line, end='')

14. 标准库（https://docs.python.org/3/library/）

 （1）sys模块：

 sys.argv：命令行参数，如查看Python软件版本sys.version_info

（2）logging日志模块：用于记录信息

（3）os模块：用于和操作系统交互

（4）platform模块：用于获取平台（操作系统）的信息

import os
import platform
import logging

if platform.platform().startswith('Windows'):　　#返回正在使用的操作系统
    logging_file = os.path.join(os.getenv('HOMEDRIVE'), os.getenv('HOMEPATH'), 'test.log')
else:
    logging_file = os.path.join(os.getenv('HOME'), 'test.log')

print("Logging to", logging_file)
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s : %(levelname)s : %(message)s',
    filename=logging_file,
    filemode='w',
)

logging.debug("Start of the program")
logging.info("Doing something")
logging.warning("Dying now")

15. 更多。。。（建议参考PDF原文）

（1）函数返回多个值：传递元组

（2）特殊方法：用来模拟内置类型的某些行为

•  __init__(self, ...)：初始化，在新创建的对象被返回准备使用时被调用
• __del__(self)：在对象被删除之前调用（它的使用时机不可预测，所以避免使用它）
• __str__(self)：使用print函数时，或str()被使用时被调用
• __lt__(self, other)：当小于运算符（<）被使用时被调用。类似地，其它所有运算符（+、> 等等）也存在相应的特殊方法
• __getitem__(self, key)：使用x[key]索引操作时会被调用
• __len__(self)：针对序列对象使用内置len()函数时会被调用

（3）单语句块：如果语句块只包括单独的一句语句时，可以在同一行指定它，如条件语句和循环语句，如if flag: print('Yes')

注：单语句块是在原地立即执行，不会被看作单独的语句块，但是会影响程序整体的工整性，不建议使用

（4）lambda语句：可以创建一个新的函数对象；从本质上说， lambda 需要一个参数，后跟一个表达式作为函数体，这一表达式执行的值将作为这个新函数的返回值

points = [{'x': 2, 'y': 3}, {'x': 4, 'y': 1}]
points.sort(key=lambda i: i['y'])　　#调用list的sort方法，通过获得一个key参数，用以决定列表的排序方式
print(points)

注：lambda表达式用于实现仅使用一次的简单函数，而无需编写独立的def块

（4）列表推导：用于从一份现有的列表中得到一份新列表，可避免显式调用循环过程，减少代码量

listone = [2, 3, 4]
listtwo = [2*i for i in listone if i > 2]
print(listtwo)

（5）assert语句：用于断言（判断）某事是真的；断言失败时，会抛出错误AssertionError

import numpy as np
a = np.random.randn((5,1))
assert(a.shape = (5,1))　　#保证数组a的大小是正确的

注：在大多数情况下，明智地选用 assert 语句好过捕获异常，也好过定位问题或向用户显示错误信息然后退出