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

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)字面常量
比如1、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教程

最后，整理了下脑图，供参考，射射大家~