JB的Python之旅-基础篇-简明Python教程

须要说明下，此处会以小白角色把知识点列出，但遇到不太了解的信息，不会过太多研究，先留个印象~
正文开始，滴滴滴~~~

1.Python的介绍

关于Python
Python是一种极少数能声言兼具简单与功能强大的编程语言

Python的特点
简单、易于学习、自由且开放、高级语言、跨平台性、解释性、面向对象、可扩展性、可嵌入性、丰富的库

2.如何安装Python

在Windows中安装
访问 https://www.python.org/downloads/ 并下载最新版本的 Python，当时看 文档时最新的版本是Python 3.6.5。安装过程跟其余Windows软件安装过程无异；

因楼主是win10，因此打开官网的连接默认就是Windows下的文件，若是须要下载Linux或者Mac的话，在上图红框那点击须要的系统后，选择对应的Python版本下载便可；

在官网下载这个软件花了快半个小时，为了节省其余同窗的时间，须要的同窗能够点击下方的连接进行下载（只有Windows的）：

连接：https://pan.baidu.com/s/1RHJil0gv4S66jAufOqLdqg 密码：oogi

下载完成后打开文件，界面以下，此时有个小细节注意下：

把Add Python 3.6 to PATH 这个选项勾上（默认是不勾的），勾上后，就不须要手动配置环境变量了； 若是须要更换安装目录，点击 Customize installation 选项，点击 Next 后在安装位置中输入自定义目录，好比D:\python35 。

而后就安装，安装完成后看到以下的显示，就说明安装成功了；

既然安装成功了，就来试试吧~ 键盘里安装win键+R，会弹出一个运行框，输入cmd，点击回车，就会打开命令行窗口，手动输入python，只要不报错，就说明安装成功了，里面能看到安装的Python信息，这样就说明安装成功啦~

安装成功图

若是没有安装Python，而在命令行窗口输入python的话，就会报下面的错误信息：

万一在安装时忘记勾上呢？不要紧，手动配置下环境变量便可；这里假设Python安装目录为C:\Python； 在桌面右击计算机并选择属性或点击开始并选择控制面板-系统与安全-系统 。 点击左侧的高级系统设置并选择高级标签。点击底部系统变量下的环境变量，找到 PATH属性，将其选中并点击编辑，前往变量值的最后一行并添加 ;C:\Python 便可； 而后重复上面的验证便可； 这里有个小细节，安装完Python后须要从新打开新的命令行窗口才行，不然会报错；

在 Mac OS 下安装

对于Mac用户，你可使用Homebrew并经过命令brew install python3进行安装。 要想验证安装是否成功，你能够经过按键 [Command + Space] （以启动 Spotlight 搜索），输 入 Terminal 并按下 [enter] 键来启动终端程序。如今，试着运行 python3 来确保其没有 任何错误。

在 GNU/Linux 下安装

对于 GNU/Linux 用户，你可使用发行版的包管理器来安装 Python 3，例如在 Debian 与 Ubuntu 平台下，你能够输入命令： sudo apt-get update && sudo apt-get install python3 。 要想验证安装是否成功，你能够经过打开 Terminal 应用或经过按下 Alt + F2 组合键并输 入 gnome-terminal 来启动终端程序。若是这不起做用，请查阅你所使用的的 GNU/Linux 发 行版的文档。如今，运行 python3 命令来确保其没有任何错误。 你会看到在运行命令后 Python 的版本信息显示在屏幕上：

$ python3 -V
Python 3.6.5
复制代码

3.第一个项目及编译器选择

hello world
在命令行中输入python进行到解释器提示符，而后输入print("hello world")

怎么退出解释器提示符？ 直接输入exit() 便可~

小知识点：python3.X的print是须要括号，而2.X是不须要括号的

编译器的选择-pycharm
pycharm有免费版跟收费版，通常而言，免费版足以~
官网下载连接：http://www.jetbrains.com/pycharm/download/#section=windows 或者度娘找也能够
下载完毕安装便可，没有太特别的点，能够全默认；安装完毕就点击打开~

使用pycharm建立第一个项目
安装完毕后打开pycharm，会显示图1的界面，此时须要点击“Create New Project"，点击后会弹出选择框选择项目的路径，可默承认修改，这里就修改为jbtest的目录，而后点击create~

建立完项目后，对着项目点击右键，选择NEW，此时会发现能够建立不少东西，好比目录，文件，package等，这里就选择Python File便可，
点击后会要求填写文件名，这里就能够自定义输入啦，这边输入的是jb_helloworld，点击OK后，会自动打开这个文件，而后在文件里输入print("jb_hello_world"),
而后在这个文件里点击右键，选择RUN文件名，点击后会发现下方会显示print里面的内容，那就恭喜你，第一个项目已经完成啦~
虽然只是几步，但要记住，之后要建立文件时，就是在对应的项目里点击右键->New->Python File->输入文件名就能够建立啦~

在命令行窗口执行Python文件
刚刚在使用pycharm建立了一个文件，那这个文件在不使用pycharm时是怎么运行的呢？
通常这种状况会在命令行窗口执行，直接输入python 对应文件的绝对路径，好比python D:\jbtest\jb_helloworld.py,这样就能在命令行窗口看到这个文件里的输出内容啦~

总结：
应该懂的如何编写、打开Python程序，那接下来，来学习更多的基础知识吧~

4.Python基础

1)注释
注释是任何存在于#号右侧的文案，其做用是给读者提供信息； 举个例子：

print("jbtest") #print是一个函数
复制代码

而通常# 用于单行注释，而三引号用于多行注释，以下：

'''这
是
一个
多行注释
'''
复制代码

2)字面常量
好比一、二、334这样的数字或者这是一串文本、This is a string这样的文本，都成为字面常量，特色是值不能改变；

3)数字
数字分为两种类型：
整数(integers)和浮点数(floats)，好比2是整数，2.123是属于浮点数；

4)字符串
字符串就是一串词汇，好比'This is JBtest!'

5)单引号
单引号用于来指定字符串，好比'This is JBtest!'
全部引号内的内容，都会被保留，好比空格、符号等，都会原数保留；

6)双引号
被双引号包括的字符串和被单引号包括的字符串的工做机制是同样的，好比'This is JBtest!' 跟"This is JBtest!"是同样的内容；

7)三引号
上面讲注释有说起到，三引号(""" or ''')主要用于多行注释，以下：

'''这个一个多行的字符串，这是它的第一行。
This is second line.
"What is your name?," he asked.
'My name is jb'.
'''
复制代码

这里能够留意，三引号里面是能够随意使用单引号跟双引号的~

8)字符串是不可变的
记住，字符串一旦被创造了，是没法改变的。

9)格式化方法
格式化经常使用有两种方法，好比百分号方法、format方法;
百分号方法：

print("我叫%s，今年%d岁了" % ("jb", 2))
复制代码

format方法--正常使用：

print("我叫{}，今年{}岁了".format("jb", 2)")
我叫jb，今年2岁了
复制代码

format方法--经过在括号里填写数字，修改格式化的顺序：

print("我叫{1}，今年{0}岁了".format("jb", 2))
我叫2岁，今年jb岁了
复制代码

format方法--经过key取变量：

print("我叫{name}，今年{age}岁了".format(name="jb", age=2))
我叫jb，今年2岁了
复制代码

10)转义序列
当须要多行字符串的时候，须要怎么办？除了上面说起到的使用三引号以外，可使用\n 这个新一行的转义序列~

This is first line \n This is second line.
复制代码

而在这里，\n就是换行的意思，更多转义字符信息以下：

转义字符	做用
行尾的\	续行符
\a	响铃
\000	空
\t	横向制表符
\o	八进制数表明字符
\\	反斜杠
\b	退格
\n	换行
\r	回车
\x	十六进制数表明字符
\'	单引号
\e	转义
\v	纵向制表符
\f	换页

11)原始字符串
若是须要指定一些未经处理的字符串，好比转义序列，那就须要在字符串前面增长r或R来指定一个原始(Raw)字符串；

r"Newlines ar indicated by \n"
复制代码

舒适提示：在处理正则表达式时应全程使用原始字符串，不然将会有大量的Backwhacking须要处理。

12)变量
因常量是不可变的，因此没法知足更多需求，所以变量就诞生了，变量是能够储存任何东西，所以须要为变量命名。

13)标识符命名
变量是标识符的一个例子。标识符（Identifiers） 是为 某些东西 提供的给定名称。在你命名标识符时，你须要遵照如下规则： 第一个字符必须是字母表中的字母（大写 ASCII 字符或小写 ASCII 字符或 Unicode 字符）或下划线（ _ ）。

标识符的其它部分能够由字符（大写 ASCII 字符或小写 ASCII 字符或 Unicode 字符）、下划线（ _ ）、数字（0~9）组成。

标识符名称区分大小写。例如， myname 和 myName 并不等同。要注意到前者是小写字母 n 然后者是大写字母 N 。

汇总下：
由字母，数字和下划线组成，且首字符必须为字母或下划线；
Python对大小写敏感，区分大小写；

附上网上找的一个命名规则：

1.项目名：首字母大写，其他小写，用下划线增长可读性，如：Ui_test；
2.包名与模块名：所有小写字母；
3.类名：首字母大写，其他小写，多个单词驼峰命名法；
4.方法(函数)名：所有小写，多个单词用下划线分隔；
5.参数名：小写单词，若是与关键词冲突，参数名前加上下划线，好比_print;
6.变量：小写，多个单词用下划线分隔；
7.常量：所有大写，多个单词用下划线分隔
复制代码

14)数据类型
共6个，分别为数字、字符串、列表、元组、集合、字典；
其中不可变数据（四个）：
Number（数字）、String（字符串）、Tuple（元组）、Sets（集合）；

可变数据（两个）：
List（列表）、Dictionary（字典）。

15)对象概念
Python 将程序中的任何内容统称为 对象（Object）;
Python 是强（Strongly）面向对象的，由于全部的一切都是对象， 包括数字、字符串与函数。

16)逻辑行与物理行
物理行是你在编写程序时，你所看到的内容。
逻辑行是Python所看到的单个语句。
Python会假定每一物理行会对应一个逻辑行。

举个例子：
i = 5
print i
i = i + 5;print 5;
这个例子里面是有三个物理行，四个逻辑行

例子2
i = i + 5;print 5;
这个例子里面有一个物理行，2个逻辑行
复制代码

这里有个小建议，在Python里，建议一个物理行对应一个逻辑行，尽可能少用分号~

17)缩进
在Python里面，缩进是很是很是重要的！！！错误的缩进，会走不少弯路，因此不要用记事本写代码！！用专业的IDE！
放置在一块儿的语句必须拥有相同的缩进，举个例子：

i = 5
#下面将发生错误，注意行首有一个空格
 print(i)
print(i+1)

执行后会报错：
 File "E:/PyCharm Community Edition 2017.2.1/PycharmProjecst/jbtest/jbtest1.py", line 2
 print(i)
 ^
IndentationError: unexpected indent   #缩进错误：意外缩进
复制代码

那怎么避免因缩进致使没必要要的问题？
官方的建议是，使用4个空格来缩进，而通常好的编辑器都会自动搞定这一步，无需操做，又或者使用TAB键也能够~

18)运算符
运算符是进行某些操做，而且能够用诸如 + 等符号或特殊关键词加以表达的功能；

下面是可用运算符的速览：
+ （加）
    两个对象相加。
    3+5	则输出  8 。 
    'a' + 'b'  则输出  'ab' 。

- （减）
    从一个数中减去另外一个数，若是第一个操做数不存在，则假定为零。
    -5.2，将输出一个负数， 
    50 - 24，输出26。

* （乘）
    给出两个数的乘积，或返回字符串重复指定次数后的结果。
    2 * 3，输出6。 
    'la' * 3，输出'lalala'。

**	（乘方）
    返回 x 的y次方。
    3 ** ，输出81（即  3 * 3 * 3 * 3 ）。

/	（除）
    x 除以 y
    13 / 3，输出4.333333333333333。

//	（整除）
    x 除以y并对结果向下取整至最接近的整数。
    13 // 3，输出4。
    -13 // 3，输出-5。

%	（取模）
    返回除法运算后的余数。
    13 % 3，输出1。
    -25.5 % 2.25，输出1.5。

<<	（左移）
    将数字的位向左移动指定的位数。（每一个数字在内存中以二进制数表示，即 0 和1） 2 << 2 输出 8 。 2 用二进制数表示为10。
    向左移2位会获得1000,这一结果，表示十进制中的8。

>>	（右移）
    将数字的位向右移动指定的位数。
    11 >> 1	,输出5 。
    11在二进制中表示为1011，右移一位后输101,这一结果，表示十进制中的5。

&	（按位与）
    对数字进行按位与操做。
    5 & 3,输出1。

|	（按位或）
    对数字进行按位或操做。
    5 | 3,输出7。

^	（按位异或）
    对数字进行按位异或操做。
    5 ^ 3，输出6。

~	（按位取反）
    x 的按位取反结果为 -(x+1)。
    ~5输出-6 。

<	（小于）
    返回x是否小于y。全部的比较运算符返回的结果均为 True 或 False 。请注意这些名称之中的大写字母。
    5 < 3，输出False ， 3 < 6 ，输出True。
    比较能够任意组成组成连接：3 < 5 < 7，返回  True 。

>	（大于）
    返回x是否大于y。
    5 > 3返回True。若是两个操做数均为数字，它们首先将会被转换至一种共同的类型。不然，它将老是返回False。

<=	（小于等于）
    返回 x 是否小于或等于 y。
    x = 3; y = 6; x<=y，返回True。

>=	（大于等于）
    返回x是否大于或等于y。
    x = 4; y = 3; x>=3，返回True。

==	（等于）
    比较两个对象是否相等。
    x = 2; y = 2; x == y，返回True。
    x = 'str'; y = 'stR'; x == y，返回False。
    x = 'str'; y = 'str'; x == y，返回True。

!=	（不等于）
    比较两个对象是否不相等。
    x = 2; y = 3; x != y，返回True。

not	（布尔“非”）
    若是x是True，则返回False 。若是x是False，则返回True 。
    x = True; not x，返回False。

and	（布尔“与”）
    若是x是False，则x and y	返回False，不然返回y的计算值。
    当x是False时，x = False; y = True; x and y将返回False。
    在这一情境中，Python 将不会计算 y，由于它已经了解 and 表达式的左侧是 False ，这意味着整个表达式都将是 False 而不会是别的值。

or （布尔“或”）
    若是x是True，则返回True，不然它将返回 y 的计算值。
    x = Ture; y = False; x or y将返回Ture。
复制代码

19)求值顺序
在给定的表达式中，Python 将优先计算表中位列于后的较高优先级的运算符与表达式。

优先级	转义字符	做用
1	lambda	Lambda 表达式
2	if - else	条件表达式
3	or	布尔“或”
4	and	布尔“与”
5	not x	布尔“非”
6	in, not in	成员测试
7	is, is not	统一性测试
8	<, <=, >, >=, !=, ==	比较
9	|	按位或
10	^	按位异或
11	&	按位与
12	<<, >>	移动
13	+, -	加与减
14	*, /, //, %	乘、除、整除、取余
15	+x, -x, ~x	正、负、按位取反
16	**	求幂
17	x.attribute	属性参考
18	x[index]	下标
19	x[index:index]	寻址段
20	x(arguments...)	函数调用
21	(expressions...)	绑定或元组显示
22	[expressions...]	列表显示
23	{key: value...}	字典显示
24	{expressions...}	字符串转换

20)改变运算顺序
括号除了能让表达式更加易懂外，还能改变表达式的运算顺序；

2 + 3 * 4，先算乘法再算加法 
(2 + 3) * 4 ，先算加法再算乘法
复制代码

21)控制流
像这样的状况：你须要程序做出一些决定，并依据不一样的状况去完成不一样的事情，例如依据天天时间的不一样打印出 '早上好' 'Good Morning' 或 '晚上好' 'Good Evening'？
这时候就须要控制流来改变工做顺序.
在 Python 中有三种控制流语句—— if、for和while 。

22)if语句
if 语句用以检查条件：
若是 条件为真（True），咱们将运行一块语句（称做 if-block 或 if 块），不然 咱们将运行另外一块语句（称做 else-block 或 else 块）。其中 else 从句是可选的。

int_score = int(input("请输入你的分数")) #input函数是从键盘读入一个字符串,int是为了把输入的字符串强转int类型
if(int_score > 90):
    print("优")
elif 80 <= int_score <= 90:
    print("良")
elif 60 <= int_score < 80:
    print("中")
else:
    if int_score < 60 :
        print("差")
        
输出结果：
请输入你的分数：20
差
复制代码

而elif语句将两个相连的 if else-if else 语句合并成一句 if-elif-else 语句。这可以使程序更加简便。

若是在if里面命中了条件，但内部又不想处理，能够输入pass便可，pass是个空语句，不作任何事情

23)while
while语句可以在条件为真的前提下重复执行某块语句。
while 语句一样能够拥有 else 子句做为可选选项。

i = 8;
while i < 10:
    print(i);
    i = i + 1;
else:
    print("end of while");  
    
输出结果：
8
9
end of while 
复制代码

小提醒：在while/for的循环里面，若是想中断循环有2种方式：break跟continue~
二者区别在于，break是跳出整个循环，而continue是跳出本次循环，后面会说明~

24)for
for...in 语句是另外一种循环语句，其特色是会在一系列对象上进行迭代，意思是会遍历序列中的每个项目。

for i in range(1, 5):   #range返回的是一个整数列表
    print(i)
else:
    print('The for loop is over')
    
输出的结果：
1
2
3
4
The for loop is over
复制代码

for循环里也能够用break跟continue跳出循环哦~

25)break语句
break 语句用以中断循环语句，也就是停止循环语句的执行，即 else 块都将不会被执行；

for letter in 'Python':  # 第一个实例
if letter == 'h':
    break
print('当前字母 :', letter)

输出结果：
当前字母 : P
当前字母 : y
当前字母 : t
复制代码

26)continue语句
continue 语句用以告诉 Python 跳过当前循环块中的剩余语句，并继续该循环的下一次迭代；

for letter in 'Python':  
if letter == 'h':
    continue
print('当前字母 :', letter)

输出结果：
当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : o
当前字母 : n
复制代码

27)函数
函数是指可重复使用的程序片断，容许为某个代码块赋予名字，容许经过这一特殊的名字在你的程序任何地方来运行代码块，并可重复任何次数。上面的学习也用到不少内置函数，好比len、range。
函数能够经过关键字 def 来定义。
这一关键字后跟一个函数的标识符名称，再跟一对圆括号，其中能够包括一些变量的名称，再以冒号结尾，结束这一行。

def say_hello():#	该块属于这一函数
    print('hello world')
#	函数结束
say_hello()	# 调用函数

输出的结果是：
hello world
复制代码

28)函数参数
函数中的参数经过将其放置在用以定义函数的一对圆括号中指定，并经过逗号予以分隔。
在定义函数时给定的名称称做形参，在调用函数时你所提供给函数的值称做实参。

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(3, 4)
x = 5
y = 7
#	以参数的形式传递变量
print_max(x, y)

输出的结果：
4 is maximum
7 is maximum
复制代码

29)局部变量
你在一个函数的定义中声明变量时，它们不会以任何方式与身处函数以外但具备相同名称的变量产生关系。
也就是说，这些变量名只存在于函数这一局部。这被称为变量的做用域。
全部变量的做用域是它们被定义的块，从定义它们的名字的定义点开始。

x = 50
def func(x):
    print('x is', x)
    x = 2
    print('Changed local x to', x)
func(x)
print('x is still', x)

输出的结果：
x is 50
Changed local x to 2
x is still 50
复制代码

30)global 变量
若是想给一个在程序顶层的变量赋值，而且不受其余做用域的影响，那可使用global来告诉程序是全局变量；

x = 50
def func(x):
    global x
    print('x is', x)
    x = 2
    print('Changed local x to', x)
func(x)
print('x is still', x)

输出的结果：
x is 50
Changed local x to 2
x is still 2
复制代码

31)默认参数值
对于一些函数来讲，可能会但愿使一些参数可选并使用默认的值，以免用户不想为他们提供值的状况。
默认参数值能够有效帮助解决这一状况。

def say(message,times=1):
    print(message*times)
say('Hello')
say('World',5)

输出的结果：
Hello
WorldWorldWorldWorldWorld
复制代码

32)关键字参数
若是有较多的函数，又但愿只对其中的一些进行指定，那么能够经过命名它们来给这些参数赋值——这就是关键字参数
好处时：
再也不须要考虑参数的顺序，函数的使用将更加容易。
能够只对那些但愿赋予的参数以赋值，只要其它的参数都具备默认参数值。

def func(a,b=5,c=10):
    print('a is ',a,' and b is ',b,' and c ic ',c)
func(3,7)
func(25,c=24)
func(c=50,a=100)    

输出的结果：
a is  3  and b is  7  and c ic  10
a is  25  and b is  5  and c ic  24
a is  100  and b is  5  and c ic  50
复制代码

33)可变参数
可变参数就是传入的参数个数是可变的，能够是1个、2个到任意个，还能够是0个；
在Python里，带*的参数就是用来接受可变数量参数的。

def funcD(a, b, *c):
  print(a)
  print(b)
  print("length of c is: %d " % len(c))
  print(c)
funcD(1,2,3,4,5,6,7,8,9)    
    
输出的结果：
1
2
length of c is: 7 
(3, 4, 5, 6, 7, 8, 9)
复制代码

前面两个参数被a、b接受了，剩下的7个参数，所有被c接受了，c在这里是一个tuple（元组）。
在调用funcD的时候，至少要传递2个参数，2个以上的参数，都放到c里了，若是只有两个参数，那c就是empty tuple。

若是一个函数定义中的最后一个形参有 **（双星号）前缀,全部正常形参以外的其余的关键字参数都将被放置在一个字典中传递给函数

def func(a,**b):
    print(a)
    for x in b:
        print(x+':'+str(b[x]))
func(100,c='你好',b=200)    

输出的结果：
100
c:你好
b:200
复制代码

b是一个dict对象实例，它接受了关键字参数b和c

34)return语句
return 语句用于从函数中返回，也就是中断函数。
咱们也能够选择在中断函数时从函数中返回一个值。

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

输出的结果：
3
复制代码

35)DocStrings
Python有一个很奇妙的特性，称为 文档字符串 ，它一般被简称为 docstrings。
DocStrings是一个重要的工具，因为它帮助你的程序文档更加简单易懂，应该尽可能使用它。
甚至能够在程序运行的时候，从函数恢复文档字符串！

def print_max(x,y):
    '''打印两个数值中的最大数。

    这两个数都应该是整数'''
    # 若是可能，将其转换至整数类型
    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__)

输出的结果：
5 is maximum
打印两个数值中的最大数。

这两个数都应该是整数
复制代码

36)模块
Python 模块，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你可以有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。

support.py 模块：
def print_func( par ):
    print "Hello : ", par
    return
复制代码

37)import语句
块定义好后，咱们可使用 import 语句来引入模块，语法以下：

import module1[, module2[,... moduleN]
复制代码

好比要引用模块 math，就能够在文件最开始的地方用 import math 来引入。

# 导入模块
import support

# 如今能够调用模块里包含的函数了
support.print_func("Runoob")

输出的结果：
Hello : Runoob
复制代码

38)from..import语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法以下：

from modname import name1[, name2[, ... nameN]]
复制代码

例如，要导入模块 fib 的 fibonacci 函数，使用以下语句：

from fib import fibonacci
复制代码

这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。

39)模块的 name
每一个模块都有一个名称，而模块中的语句能够找到它们所处的模块的名称。
这对于肯定模块是独立运行的仍是被导入进来运行的这一特定目的来讲大为有用。

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

输出的结果：
$ python module_using_name.py
This program is being run by itself

$ python
>>> import module_using_name
I am being imported from another module
复制代码

40)包
包是指一个包含模块与一个特殊的 init.py 文件的文件夹，包是一种可以方便地分层组织模块的方式。

41)dir函数
Python中内置的dir函数用于显示模块中定义的标识符的， 包括函数、变量、类等;
dir()函数的参数能够是模块，也能够是类、函数等

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；
带参数时，返回参数的属性、方法列表。若是参数包含方法__dir__()，该方法将被调用。

>>> dir(sys)
['__displayhook__', '__doc__','argv', 'builtin_module_names','version', 'version_info']

#	此处只展现部分条目

#	给出当前模块的属性名称

>>> dir()

['__builtins__', '__doc__','__name__', '__package__','sys']
复制代码

42)数据结构
数据结构是一种结构，可以将一些数据聚合在一块儿。换句话说，它们是用来存储一系列相关数据的集合。
Python 中有四种内置的数据结构——列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set）。

43)列表
列表是一种用于保存一系列有序项目的集合
列表能够修改，而字符串和元组不能

下面是一些关于列表的方法介绍：

方法	描述
list.append(x)	把一个元素添加到列表的结尾，至关于 a[len(a):] = [x]
list.extend(L)	经过添加指定列表的全部元素来扩充列表，至关于 a[len(a):] = L
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表以前，而 a.insert(len(a), x) 至关于 a.append(x)
list.remove(x)	删除列表中值为 x 的第一个元素。若是没有这样的元素，就会返回一个错误
list.pop([i])	从列表的指定位置删除元素，并将其返回。若是没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被删除
list.clear()	移除列表中的全部项，等于del a[:]
list.index(x)	返回列表中第一个值为 x 的元素的索引。若是没有匹配的元素就会返回一个错误
list.count(x)	返回 x 在列表中出现的次数
list.sort()	对列表中的元素进行排序
list.reverse()	倒排列表中的元素
list.copy()	返回列表的浅复制，等于a[:]

44)有关对象与类的快速介绍
列表是使用对象与类的实例。
当启用一个变量 i 并将整数 5 赋值给它时，能够认为这是在建立一个 int 类（即类型）之下的对象（即实例）i 。

45)元组
元组（Tuple）用于将多个对象保存到一块儿。
元组的一大特征相似于字符串，它们是不可变的，也就是说，你不能编辑或更改元组。

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
复制代码

元组在输出时老是有括号的，以便于正确表达嵌套结构。

元组是经过特别指定项目来定义的，在指定项目时，你能够给它们加上括号，并在括号内部用逗号进行分隔。
元组一般用于保证某一语句或某一用户定义的函数能够安全地采用一组数值，意即元组内的数值不会改变。

46)字典
字典以关键字为索引，关键字能够是任意不可变类型，一般用字符串或数值。
理解字典的最佳方式是把它看作无序的键=>值对集合。在同一个字典以内，关键字必须是互不相同。
一对大括号建立一个空的字典：{}。

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
复制代码

构造函数 dict() 直接从键值对元组列表中构建字典。若是有固定的模式，列表推导式指定特定的键值对：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
复制代码

47)序列
序列的主要功能是资格测试（也就是 in 与 not in 表达式）和索引操做，它们可以容许咱们直接获取序列中的特定项目

48)集合
集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
能够用大括号({})建立集合。
注意：若是要建立一个空集合，你必须用 set() 而不是 {} ；后者建立一个空的字典，下一节咱们会介绍这个数据结构。 如下是一个简单的演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 删除重复的
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 检测成员
True
>>> 'crabgrass' in basket
False

>>> # 如下演示了两个集合的操做
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 中惟一的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 在 a 中的字母，但不在 b 中
{'r', 'd', 'b'}
>>> a | b                              # 在 a 或 b 中的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 在 a 和 b 中都有的字母
{'a', 'c'}
>>> a ^ b                              # 在 a 或 b 中的字母，但不一样时在 a 和 b 中
{'r', 'd', 'b', 'm', 'z', 'l'}
复制代码

49)面向对象编程
在至今编写的全部程序中，曾围绕函数设计的程序，也就是那些可以处理数据的代码块。这被称做面向过程的编程方式。
类与对象是面向对象编程的两个主要方面。

简介	描述
类	用来描述具备相同的属性和方法的对象的集合。它定义了该集合中每一个对象所共有的属性和方法。对象是类的实例。
类变量	类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体以外。类变量一般不做为实例变量使用。
数据成员	类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
方法重写	若是从父类继承的方法不能知足子类的需求，能够对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量	定义在方法中的变量，只做用于当前实例的类。
继承	即一个派生类（derived class）继承基类（base class）的字段和方法。继承也容许把一个派生类的对象做为一个基类对象对待。
实例化	建立一个类的实例，类的具体对象。
方法	类中定义的函数。
对象	经过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

50)self
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
self 表明的是类的实例，表明当前对象的地址，而 self.class 则指向类。
self 不是 python 关键字。

51)类
使用 class 语句来建立一个新类，class 以后为类的名称并以冒号结尾:

class Person:
    pass	# 一个空的代码块
p = Person()
print(p)
复制代码

52)方法
类与对象一如函数那般均可以带有方法（Method），惟一的不一样在于咱们还拥有一个额外的 self 变量。

class Person:
    def say_hi(self):
        print('Hello, how are you?')
p = Person()
p.say_hi()
复制代码

53)__init__方法
__init__ 方法会在类的对象被实例化时当即运行。
这一方法能够对任何你想进行操做的目标对象进行初始化操做。
这里你要注意在 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()
复制代码

54)类变量与对象变量
字段有两种类型——类变量与对象变量。
类变量在整个实例化的对象中是公用的。<br 对象变量由类的每个独立的对象或实例所拥有。

55)继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是经过继承机制。
继承彻底能够理解成类之间的类型和子类型关系。
须要注意的地方：继承语法 class 派生类名（基类名）：//...
基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。
在python中继承中的一些特色：
1：在继承中基类的构造（__init__()方法）不会被自动调用，它须要在其派生类的构造中亲自专门调用。
2：在调用基类的方法时，须要加上基类的类名前缀，且须要带上self参数变量。区别在于类中调用普通函数时并不须要带上self参数
3：Python老是首先查找对应类型的方法，若是它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
若是在继承元组中列了一个以上的类，那么它就被称做"多重继承" 。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Parent:  # 定义父类
    parentAttr = 100

    def __init__(self):
        print("调用父类构造函数")

    def parentMethod(self):
        print('调用父类方法')

    def setAttr(self, attr):
        Parent.parentAttr = attr

    def getAttr(self):
        print("父类属性 :", Parent.parentAttr)


class Child(Parent):  # 定义子类
    def __init__(self):
        print("调用子类构造方法")

    def childMethod(self):
        print('调用子类方法')


c = Child()  # 实例化子类
c.childMethod()  # 调用子类的方法
c.parentMethod()  # 调用父类方法
c.setAttr(200)  # 再次调用父类的方法 - 设置属性值
c.getAttr()  # 再次调用父类的方法 - 获取属性值

输出的结果：
调用子类构造方法
调用子类方法
调用父类方法
父类属性 : 200
复制代码

56)输入与输出
但愿获取用户的输入内容，并向用户打印出一些返回的结果，能够分别经过 input() 函数与 print 函数来实现这一需求。
对于输入，还可使用str（String，字符串）类的各类方法。
另外一个常见的输入输出类型是处理文件。建立、读取与写入文件对于不少程序来讲是必不可少的功能。

57)用户输入内容

#把输入的文本进行翻转，若是翻转先后都一致，则认为是回文
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")

输出的结果：
Enter text: jbj
Yes, it is a palindrome
复制代码

58)文件
能够经过建立一个属于 file 类的对象并适当使用它的read 、 readline 、 write 方法来打开或使用文件，并对它们进行读取或写入。
当完成了文件，能够调用 close 方法来告诉 Python 已经完成了对该文件的使用。

jb = "if you make your work also fun: use python~"
#打开文件编辑
f = open("jb.txt",'w')
#向文件中编写文本
f.write(jb)
#关闭文件
f.close()

#若是没有特别指定，
#将假定启用默认的阅读（'r'ead）模式
f = open("jb.txt")
while True:
    line = f.readline()
    #长度为零，就中断
    if len(line) == 0:
        break
    print(line,end='')
f.close()

输出的结果：
if you make your work also fun: use python~
复制代码

打开模式能够是阅读模式（ 'r' ），写入模式（ 'w' ）和追加模式（ 'a' ）

59)Pickle2
Python 提供了一个叫做 Pickle 的标准模块，经过它你能够将任何纯 Python 对象存储到一个文件中，并在稍后将其取回。
在机器学习中，经常须要把训练好的模型存储起来，也是能够用Pickle这个模块把数据存储~

import pickle

jb = 'jb'
jblist = ['apple','mango','carrot']

f = open(jb,'wb')
#存入已经打开的file中
pickle.dump(jblist,f)
f.close()

del jblist

f = open(jb,'rb')
#将file中的对象序列化读出
storedlist = pickle.load(f)
print(storedlist)

输出的结果：
['apple', 'mango', 'carrot']
复制代码

60)Unicode
当咱们阅读或写入某一文件或当咱们但愿与互联网上的其它计算机通讯时，咱们须要将咱们的 Unicode 字符串转换至一个可以被发送和接收的格式，这个格式叫做“UTF-8”。

#	encoding=utf-8 import io
f = io.open("abc.txt", "wt", encoding="utf-8")
f.write(u"Imagine non-English language here")
f.close()
text = io.open("abc.txt", encoding="utf-8").read()
print(text)
复制代码

61)异常
当想要读取一个文件时，而那个文件却不存在，怎么办？
又或者在程序执行时不当心删除了，怎么办？
这些经过使用异常来进行处理。

62)错误
能够想象一个简单的 print 函数调用。
若是把 print 误拼成 Print 会怎样？
会注意到它的首字母是大写。
在这一例子中，Python 会抛出（Raise）一个语法错误。

>>>	Print("Hello World") Traceback (most recent call last):
File "<stdin>", line 1, in <module> NameError: name 'Print' is not defined
>>>	print("Hello World")
Hello World
复制代码

会注意到一个 NameError 错误被抛出，同时 Python 还会打印出检测到的错误发生的位置。
这就是一个错误处理器 为这个错误所作的事情。

63)处理异常
能够经过使用 try..except 来处理异常情况。
通常来讲会把一般的语句放在 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))
复制代码

64)抛出异常
能够经过 raise 语句来引起一次异常，具体方法是提供错误名或异常名以及要抛出（Thrown）异常的对象。
可以引起的错误或异常必须是直接或间接从属于 Exception （异常） 类的派生类。

import traceback
 
def throw_error():
  raise Exception("抛出一个异常")#异常被抛出，print函数没法执行
  print("jb")
   
throw_error()

输出的结果：
    Traceback (most recent call last):
  File "E:/PyCharm Community Edition 2017.2.1/PycharmProjecst/jbtest/jbtest1.py", line 9, in <module>
    throw_error()
  File "E:/PyCharm Community Edition 2017.2.1/PycharmProjecst/jbtest/jbtest1.py", line 5, in throw_error
    raise Exception("抛出一个异常")  # 异常被抛出，print函数没法执行
Exception: 抛出一个异常
复制代码

65)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)")
复制代码

66)with语句
使用with后无论with中的代码出现什么错误，都会进行对当前对象进行清理工做。

with open("jb.txt") as f:
for line in f:
    print(line, end='')
复制代码

67)标准库
Python标准库中包含了大量有用的模块，同时也是每一个标准的 Python 安装包中的一部分.
熟悉 Python 标准库十分重要，由于只要你熟知这些库能够作到什么事，许多问题都可以轻易解决。

68)sys模块
sys模块包括了一组很是实用的服务，内含不少函数方法和变量，用来处理Python运行时配置以及资源;

函数	描述
sys.argv	命令行参数List，第一个元素是程序自己路径
sys.modules.keys()	返回全部已经导入的模块列表
sys.exc_info()	获取当前正在处理的异常类,exc_type、exc_value、ext_traceback当前处理的异常详细信息
sys.exit(n)	退出程序，正常退出时exit(0)
sys.hexversion	获取Python解释程序的版本值，16进制格式如：0x020403F0
sys.version	获取Python解释程序的版本信息
sys.maxint	最大的Int值
sys.maxunicode	最大的Unicode值
sys.modules	返回系统导入的模块字段，key是模块名，value是模块
sys.path	返回模块的搜索路径，初始化时使用Pythonpath环境变量的值
sys.platform	返回操做系统平台名称
sys.stdout	标准输出
sys.stdin	标准输入
sys.stderr	错误输出
sys.exc_clear()	用来清除当前线程所出现的当前的或最近的错误信息
sys.exec_prefix	返回平台独立的Python文件安装的位置
sys.byteorder	本地字节规则的指示器，big-endian平台的值是'big'，little-endian平台的值是'little'
sys.copyrighte	记录Python版权相关的东西
sys.api_version	解释器的C的API版本
sys.getdefaultencoding()	返回当前所用的默认字符编码格式
sys.getfilesystemencoding()	返回将Unicode文件名转换成系统文件名的编码的名字
sys.setdefaultencoding(name)	用来设置当前默认的字符编码
sys.builtin_module_names	Python解释器导入的模块列表
sys.executable	python解释程序路径
sys.getwindowsversion()	获取Windows的版本
sys.stdin.readline()	从标准输入读一行，
sys.stdout.write("a")	屏幕输出a

69)日志模块
若是想将一些调试信息或一些重要的信息储存在某个地方，以即可以检查程序是否如所指望那般运行，应该怎么作？
应该如何将这些信息“储存在某个地方”？这能够经过 logging 模块来实现。

import logging

logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')

输出的结果：
WARNING:root:This is warning message
复制代码

70)传递元组
只需使用一个元组，就能达到从一个函数返回两个不一样的值

def get_error_details():
    return (2, 'details')
errnum, errstr = get_error_details()
print(errnum)
print(errstr)

输出的结果：
2
details
复制代码

Python 中交换两个变量的最快方法是

a=5;b=6
a,b = b,a
print(a)
print(b)

输出的结果：
6
5
复制代码

71)特殊方法

方法	描述
__init__(self, ...)	这一方法在新建立的对象被返回准备使用时被调用
__del__(self)	这一方法在对象被删除以前调用（它的使用时机不可预测，因此避免使用它）
__str__(self)	当咱们使用 print 函数时，或 str() 被使用时就会被调用
__lt__(self, other)	当小于运算符（<）被使用时被调用。相似地，使用其它全部运算符（+、> 等等）时都会有特殊方法被调用
__getitem__(self, key)	使用 x[key] 索引操做时会被调用
__len__(self)	当针对序列对象使用内置 len() 函数时会被调用

72)单语句块
若是语句块只包括单独的一句语句，那么能够在同一行指定它

flag = True
if flag: print('Yes')
复制代码

73)Lambda表格
lambda语句能够建立一个新的函数对象,是一个匿名函数;
从本质上说， lambda 须要一个参数，后跟一个表达式做为函数体，这一表达式执行的值将做为这个新函数的返回值。

g = lambda x : x ** 2
print g(3)

输出的结果：
9
复制代码

74)列表推导
列表推导用于从一份现有的列表中获得一份新列表;
例子：如今已经有了一份数字列表，想获得一个相应的列表，其中的数字在大于 2 的状况下将乘以2。列表推导就是这类状况的理想选择。

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

输出的结果：
[6,8]
复制代码

75)assert语句
assert 语句用以断言某事是真的
例如说很是肯定正在使用的列表中至少包含一个元素，并想确认这一点，若是其不是真的，就抛出一个错误， assert 语句就是这种状况下的理想选择。
当语句断言失败时，将会抛出 AssertionError 。

mylist = ['item']
assert len(mylist) >= 1
mylist.pop()
assert len(mylist) >= 1

输出的结果：
Traceback (most recent call last):
  File "C:/Users/jb/PycharmProjects/jbtestprojects/testplay.py", line 4, in <module>
    assert len(mylist) >= 1
AssertionError
复制代码

76)装饰器
装饰器是应用包装函数的快捷方式~
举个例子：

def cal(x, y):
    result = x + y
    return result
复制代码

这里有个函数，假若有N个这样的函数，若是想每一个函数执行时顺带执行下Log操做，就变成这样了

def cal(x, y):
        logging.info("111")
        result = x + y
        return result
        
    def cal1(x, y):
        logging.info("2222")
        result = x + y
        return result
复制代码

这样暴露一个问题，假若有N个函数，那个都在里面加一个print()，不须要时再手动删除，是很是痛苦的事情，这时候，装饰器就有用了；

def log(func):
    def wrapper(*arg,**kw):
        logging.warn("%s " % func.__name__)
        return
    return wrapper()

@log
def cal(x, y):
    result = x + y
    return result
    
@log
def cal1(x, y):
    result = x + y
    return result  
复制代码

之后只须要在执行前输入@函数名便可，大体就是这样啦~

77)小贴士
在使用python过程，须要用到各类各样第三方库，以前楼主是每一个手动安装，各类环境（windows\linux）等，痛不欲生！可是，出现转折啦~

在使用pycharm发现能够快速安装所须要的库，不须要本身额外安装，很是方便！
File->Settings>Projects Interpreter，右侧有个+号，点击后输入对应须要的库，点击install便可，是否是很是方便啊啊！！！

结语
陆陆续续的，花了2周多的时间把这书啃完而后再回头整理出来，回头看，感受算是比较适合新手阅读，讲的点不算特别深，固然也不太详细，只能留个印象，后面确定是要深刻了解的~
可是，这本书讲的顺序很是乱，所以笔记也跟着一块儿乱了。。。跳跃式阅读。。

后续计划
按照以前定的计划，接下来会看笨方法学python、廖雪峰3.0教程、Python核心编程第三篇，可是因为时间的关系，会作下调整，下一步会的目标是2个：
爬虫跟利用python作接口自动化
而上面说起到的3本书也会阅读而且输出，但不会像这篇同样讲太多基础的内容，还请各位见谅~

文章连接以下：
简明python教程

最后，整理了下脑图，供参考，射射你们~