简明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)，如：

1 def total(a=5, *numbers, **phonebook):
2     print('a', a)
3     #遍历元组中的所有项目
4     for single_item in numbers:
5         print('single_item', single_item)
6     #遍历字典中的所有项目
7     for first_part, second_part in phonebook.items():
8         print(first_part,second_part)
9 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):

 2     '''Prints the maximum of two numbers.打印两个数值中的最大数。
 3     The two values must be integers.这两个数都应该是整数'''
 4     # 如果可能，将其转换至整数类型
 5     x = int(x)
 6     y = int(y)
 7     if x > y:
 8         print(x, 'is maximum')
 9     else:
10         print(y, 'is maximum')
11 
12 print_max(3, 5)
13 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__确定模块是独立运行还是被导入进来运行：

1 if __name__ == '__main__':
2     print('This program is being run by itself')
3 else:
4     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>/
 2     - world/
 3         - __init__.py
 4         - asia/
 5             - __init__.py
 6             - india/
 7                 - __init__.py
 8                 - foo.py
 9         - africa/
10             - __init__.py
11             - madagascar/
12                 - __init__.py
13                 - 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)到对象上；示例代码如下：

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

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

 11. 面向对象编程

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

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

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

 1 class Person:
 2     def __init__(self, name):　　#无需显式调用
 3         self.name = name
 4     def say_hi(self):
 5         print('Hello, my name is', self.name)
 6 
 7 p = Person('Swaroop')
 8 p.say_hi()
 9 # 前面两行同时也能写作
10 # Person('Swaroop').say_hi()    

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

 1 # coding=UTF-8
 2 class Robot:
 3     """表示有一个带有名字的机器人。"""
 4     # 一个类变量，用来计数机器人的数量
 5     population = 0
 6     def __init__(self, name):
 7         """初始化数据"""
 8         self.name = name
 9         print("(Initializing {})".format(self.name))
10         # 当有人被创建时，机器人
11         # 将会增加人口数量
12         Robot.population += 1　　#等同于self.__class__.population += 1
13 
14     def die(self):
15         """我挂了。"""
16         print("{} is being destroyed!".format(self.name))
17         Robot.population -= 1
18         if Robot.population == 0:
19             print("{} was the last one.".format(self.name))
20         else:
21             print("There are still {:d} robots working.".format(Robot.population))
22    
23      def say_hi(self):
24         """来自机器人的诚挚问候
25         没问题，你做得到。"""
26         print("Greetings, my masters call me {}.".format(self.name))
27 
28     @classmethod　　#类方法，使用装饰器Decorator将how_many标记为类方法
29     def how_many(cls):
30         """打印出当前的人口数量"""
31         print("We have {:d} robots.".format(cls.population))
32 
33 droid1 = Robot("R2-D2")
34 droid1.say_hi()
35 Robot.how_many()
36 
37 droid2 = Robot("C-3PO")
38 droid2.say_hi()
39 Robot.how_many()
40 
41 print("\nRobots can do some work here.\n")
42 print("Robots have finished their work. So let's destroy them.")
43 droid1.die()
44 droid2.die()
45 
46 Robot.how_many()

注：

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

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

 1 # coding=UTF-8
 2 class SchoolMember:
 3     '''代表任何学校里的成员。'''
 4     def __init__(self, name, age):
 5         self.name = name
 6         self.age = age
 7         print('(Initialized SchoolMember: {})'.format(self.name))
 8 
 9     def tell(self):
10         '''告诉我有关我的细节。'''
11         print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")
12 
13 class Teacher(SchoolMember):　　#继承，参数为包含基类名称的元组
14     '''代表一位老师。'''
15     def __init__(self, name, age, salary):
16         SchoolMember.__init__(self, name, age)　　#子类定义__init__的情况下需要显式调用父类构造函数__init__
17         self.salary = salary
18         print('(Initialized Teacher: {})'.format(self.name))
19 
20     def tell(self):
21         SchoolMember.tell(self)　　#子类对象作为父类方法的实例参数
22         print('Salary: "{:d}"'.format(self.salary))
23 
24 class Student(SchoolMember):
25     '''代表一位学生。'''
26     def __init__(self, name, age, marks):
27         SchoolMember.__init__(self, name, age)
28         self.marks = marks
29         print('(Initialized Student: {})'.format(self.name))
30 
31     def tell(self):
32         SchoolMember.tell(self)
33         print('Marks: "{:d}"'.format(self.marks))
34 
35 t = Teacher('Mrs. Shrividya', 40, 30000)
36 s = Student('Swaroop', 25, 75)
37 # 打印一行空白行
38 print()
39 
40 members = [t, s]
41 for member in members:
42     # 对全体师生工作
43     member.tell()

 12. 输入与输出

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

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

 1 poem = '''\
 2 Programming is fun
 3 When the work is done
 4 if you wanna make your work also fun:
 5 use Python!
 6 '''
 7 
 8 # 打开文件以编辑（'w'riting）
 9 f = open('poem.txt', 'w')
10 # 向文件中编写文本
11 f.write(poem)
12 # 关闭文件，保证内容已经被写入到文件
13 f.close()
14 
15 # 如果没有特别指定，
16 # 将假定启用默认的阅读（'r'ead）模式
17 f = open('poem.txt')
18 while True:
19     line = f.readline()
20     # 零长度指示 EOF
21     if len(line) == 0:
22     break
23     # 每行（`line`）的末尾
24     # 都已经有了换行符
25     #因为它是从一个文件中进行读取的
26     print(line, end='')
27 # 关闭文件
28 f.close()

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

 1 import pickle
 2 
 3 # The name of the file where we will store the object
 4 shoplistfile = 'shoplist.data'
 5 # The list of things to buy
 6 shoplist = ['apple', 'mango', 'carrot']
 7 
 8 # Write to the file
 9 f = open(shoplistfile, 'wb')
10 # Dump the object to a file
11 pickle.dump(shoplist, f)　　#封装
12 f.close()
13 
14 # Destroy the shoplist variable
15 del shoplist
16 
17 # Read back from the storage
18 f = open(shoplistfile, 'rb')
19 # Load the object from the file
20 storedlist = pickle.load(f)　　#拆封
21 print(storedlist)

13. 异常

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

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

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

 1 # encoding=UTF-8
 2 
 3 class ShortInputException(Exception):　　#继承自Exception类
 4     '''一个由用户定义的异常类'''
 5     def __init__(self, length, atleast):
 6         Exception.__init__(self)
 7         self.length = length
 8         self.atleast = atleast
 9 
10 try:
11     text = input('Enter something --> ')
12     if len(text) < 3:
13         raise ShortInputException(len(text), 3)　　#抛出自定义异常
14     # 其他工作能在此处继续正常运行
15 except EOFError:
16     print('Why did you do an EOF on me?')
17 except ShortInputException as ex:　　#捕获自定义异常
18     print(('ShortInputException: The input was ' + '{0} long, expected at least {1}').format(ex.length, ex.atleast))
19 else:
20     print('No exception was raised.')    

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

 1 import sys
 2 import time
 3 
 4 f = None
 5 try:
 6     f = open("poem.txt")
 7     # 我们常用的文件阅读风格
 8     while True:
 9         line = f.readline()
10         if len(line) == 0:
11             break
12         print(line, end='')
13         sys.stdout.flush()　　#将输出立即打印到屏幕
14         print("Press ctrl+c now")
15         # 为了确保它能运行一段时间
16         time.sleep(2)　　#休眠两秒
17 except IOError:
18     print("Could not find file poem.txt")
19 except KeyboardInterrupt:
20     print("!! You cancelled the reading from the file.")
21 finally:　　#该部分子句一定会执行
22     if f:
23         f.close()
24     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__方法）
2     for line in f:
3         print(line, end='')

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

 （1）sys模块：

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

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

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

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

 1 import os
 2 import platform
 3 import logging
 4 
 5 if platform.platform().startswith('Windows'):　　#返回正在使用的操作系统
 6     logging_file = os.path.join(os.getenv('HOMEDRIVE'), os.getenv('HOMEPATH'), 'test.log')
 7 else:
 8     logging_file = os.path.join(os.getenv('HOME'), 'test.log')
 9 
10 print("Logging to", logging_file)
11 logging.basicConfig(
12     level=logging.DEBUG,
13     format='%(asctime)s : %(levelname)s : %(message)s',
14     filename=logging_file,
15     filemode='w',
16 )
17 
18 logging.debug("Start of the program")
19 logging.info("Doing something")
20 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 需要一个参数，后跟一个表达式作为函数体，这一表达式执行的值将作为这个新函数的返回值

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

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

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

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

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

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

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

转载于:https://www.cnblogs.com/hg-love-dfc/p/10248599.html