Python知识点整理，图文结合近三万字（史上最全）

Python知识点（一）

✅作者简介：大家好我是编程ID
个人主页：编程ID的csdn博客
系列专栏：python
推荐一款模拟面试、刷题神器点击跳转进入网站
Python精华知识点手册【完整版】下载

Python知识点（二）

Python知识点（三）

Python对csv的处理：

#edcoding:utf-8
import pandas as pd
import csv
df=pd.read_csv('23.csv')
print df.week       #输出week这一列的数据
print df['week']     #输出week这一列的数据
print df.ix[1]       #输出第二行数据（下标是从0开始的）
print df.iloc[:,1:4]   #输出第二到第四列的数据但是只可以通过序列取，不能通过列名
print df.ix[:,['LEASETIME','SHEDID']]   #通过列名取出数据
print df.ix[:,[1,5]]         #取出第二行和第六行数据（下标是从0开始的）
print df.ix[5,1]       #输出第六行第二列的数据（下标是从0开始的）
print df.head(10)       #取出前十行数据
print df.tail(10)       #取出后十行数据（从后往前数）
print df[df.week==0]   #将week这列等于0的全部取出来
print df[(df.week==0)&(df.SHEDID==8)]
#将week这一列等于0且SHEDID这一列等于8的数据全部取出（|这个符号表示或）
list=['3','4']
print df[df.week.isin(list)]   #输出week这一列满足是‘3’或‘4’的所有数
print '===================='
print df.sort_values(by='week',ascending=True)  #以week这一列从小到大排序
df['a']=1
print df  #添加a这一列的值全部为1，也可以让他等于一个列表，但列表的长度必须与行数相等
del  df['a']
print df  #删除a这一列
print '==============================================================='
#groupby()这个函数是分组（但是不能单独使用），count()这个方法是统计次数，
print df.groupby(df.week).count()  #以week这一列分组后，统计相同的次数是多少
#分组后可以是用一下方法count()、sum()（求和）、mean()（求平均数）、max()（求最大值）、min()（求最小值)

Python中numpy：

#coding:utf-8
import numpy as np
import array
import pandas as pd
import numpy as np
#列表
n=np.array([1,2,3,4])
print n
list1=[1,2,3,'a']
print list1
#数组
n= np.array([1,2,3,'a'])
print n
#自定义两行两列数组
b=np.array([[1,2,3],[4,5,6]])
print b
print b.shape
#自定义两行两列数组
#自定义一个3行2列数组
m1=np.array([[1,2],[3,4],[4,5]])
print m1,m1.shape
#访问数组内元素
print m1[0,0]
print m1[1,1]

a=np.arange(5)
print a
print a.dtype
print a.dtype.itemsize
print np.int8(8.0)
a=1+0.1j
b=0.2
print a+b
a=np.arange(7,dtype='D')
print a
#查看数据类型
print np.dtype(float)
print np.dtype('f')
print np.dtype('f2');print np.dtype('f4');print np.dtype('f8')
print "AAAAAAAAAAAAA"
t=np.dtype(float) # t=np.dtype('float')
print t.char,t
#dtype类型属性type
print t.type
#dtype类型属性str 保存一个表示数据类型的字符串
print t.str
print "BBBBBBBBBBBBBB"
#一维数组的切片与索引
a=np.arange(10)
print a[3:5] #左闭右开
print a[1:7:2] ##左闭右开,间隔2
print a[4::-1] #  输出[4 3 2 1 0]
print "CCCCCCCCCCCCCCCC"
#处理数组形状
print a.reshape(2,5) #将1行10列数组转换成2行5列数组
b=np.arange(24).reshape(2,3,4)
print b
print b.ravel() #将多为数组降为1维数组,默认以行为准，参数-1以列为准
print b.flatten(-1) #拉直操作,默认以行为准，参数-1以列为准
print b.ravel().reshape(4,6)
print b.ravel().reshape(4,6).transpose() #转秩操作
print "DDDDDDDDDDDDDDDDDDD"
#reshape函数返回一个新数组，但原数组本身.不变；
resize在返回一个新数组的同时也改变原数组本身。
print "b=",b
print "b.reshape=",b.reshape(4,6)
print "b=",b
b.resize(2,12)
print "b=",b
b.shape=(2,3,2,2)  #用元组的形式指定数组形状
print b
print "EEEEEEEEEEEEEEEEEEEEEEEEE"
#堆叠数组
a=np.arange(9).reshape(3,3)
print a
b=a**2
print a**2
c=np.hstack((a,b,a)) #水平叠加
d=np.vstack((a,b))#垂直叠加
print c,"Hello",d
print np.concatenate((a,b),axis=1) #concatenate功能数组叠加，axis=0默认水平叠加，axis=1垂直叠加
d=np.dstack((a,b,a)) #深度叠加,沿着第三个坐标轴（纵向）的方向叠加一摞数组。
print d

aa=np.arange(2)
bb=aa*2
print aa,bb
#column_stack列式叠加，以列方式对一维数组进行堆叠，多维数组和hstack类似
print np.column_stack((aa,bb)) #以列方式对一维数组进行堆叠
print np.column_stack((a,b)) #多维数组和hstack类似
print np.hstack((a,b))==np.column_stack((a,b))
#row_stack行式叠加，以行方式对一维数组进行堆叠，多维数组和vstack类似
print np.row_stack((aa,bb))
print np.row_stack((a,b))
print np.row_stack((a,b))==np.vstack((a,b))

print "FFFFFFFFFFFFFFFFFFF"
#数组拆分
a=np.arange(9).reshape(3,3)
print a
print type(np.vsplit(a,3)),np.vsplit(a,3) #纵向切分
print np.hsplit(a,3)#横向切分
print "深向切分"
print "切分前"
a=np.arange(18).reshape(2,3,3)
print a
print "切分后"
print np.dsplit(a,3)
print "GGGGGGGGGGGGGGGG"
print"数组的属性，不需要加（）"
print a
print a.ndim #数组的维度
print a.shape#数组的每一维度的大小
print a.dtype#数组中元素的数据类型，numpy要求数组元素类型一致
print a.size #数组中元素个数
print a.itemsize #返回数组中各个元素所占用的字节数
print a.itemsize*a.size #返回数组占用空间大小（字节为单位）
b=np.arange(5)
print b
print a.T #转秩，与transpose()函数功能相同
print b.ndim
b=np.array([1,2+2j]) #复数用j表示，定义一个数组，包含两个元素
print b.real #获取数组的实部
print b.imag #获取数组的虚部
print b.dtype #复数数据类型自动变成复数类型
b=np.arange(4).reshape(2,2)
f=b.flat
print f[[1,3,2]] #取列表中的某几个元素
for i in f:  #对列表做循环
    print i
b.flat=7  #对数组整体赋值
print b
b.flat[2]=3

print b   #对数组某个元素赋值
b.flat[[2,3]]=2
print b

print "GGGGGGGGGGGGGGGGGGGGGGGGGGG"
print "数组的转换,tolist()方法"
a=np.array([1+1j,0.3+0.8j])
print a
print a.dtype
b=a.tolist()
print b
print type(b)  #此时b已经不是numpy数组，不能再具有dtype属性，查看类型
a=11
print type(a)   #a.dtype
b=np.array([1+1j,0.3+0.8j])
c=b.astype(float)  #将数组元素转换成指定类型
print c,b   #转换完成虚部被舍弃

print "HHHHHHHHHHHHHHHHHHHHHHH"
print "创建数组的视图"
#acopy=lena.copy()
#print acopy

Python中pandas：#coding=utf-8
import pandas as pd
import numpy as np
#Series
obj=pd.Series([1,2,3,4])
print obj
obj=pd.Series([1,2],index=['a','b'])
print obj
data=pd.Series([0,1,2,3],index=[1,2,3,4])
print data
print data[data>1]
print data*3
print data[3]
print pd.notnull('a')

#DataFrame
data={'state':['beijin','shanghai','hangzhou',],'a':['a','b','c']}
print pd.DataFrame(data)
print pd.DataFrame(data,columns=['state','a'],index=[1,2,3])
a=pd.DataFrame(data)
print a.ix[1]
print a.T
print a[2:4]


a=pd.Series(np.arange(4,8),index=['a','b','c','d'])
print a
print 'aaaaaa'
print a[:4]
print 'aaaaaa'
print a[:5]

df1=pd.DataFrame(np.arange(1,13).reshape(3,4),columns=['a','b','c','d'],index=['A','B','C'])
print df1
df2=pd.DataFrame(np.arange(1,10).reshape(3,3),columns=['a','b','e'])
print df2
print df1.add(df2,fill_value=0)

Python中matplotlib：
线型图：

import matplotlib.pyplot as plt
x=[1,3,5]
y=[4,6,8]

x1=[3,4,6]
y1=[5,4,9]

plt.plot(x, y, label='First Line')
plt.plot(x1, y1, label='Second Line')
plt.xlabel('Plot Number')
plt.ylabel('Important var')
plt.title('Interesting Graph\nCheck it out')
plt.legend()
plt.show()
在这里，我们绘制了我们已经看到的东西，但这次我们添加另一个参数label。 这允许我们为线条指定名称，我们以后可以在图例中显示它。
使用plt.xlabel和plt.ylabel，我们可以为这些相应的轴创建标签。 

接下来，我们可以使用plt.title创建图的标题，然后我们可以使用plt.legend()生成默认图例

条形图：

import matplotlib.pyplot as plt
plt.bar([1,3,5,7,9],[5,2,7,8,2], label="Example one")
plt.bar([2,4,6,8,10],[8,6,2,5,6], label="Example two", color='g')
plt.legend()
plt.xlabel('bar number')
plt.ylabel('bar height')
plt.title('Epic Graph\nAnother Line! Whoa')
plt.show()
plt.bar为我们创建条形图。 如果你没有明确选择一种颜色，那么虽然做了多个图，所有的条看起来会一样。
 这让我们有机会使用一个新的 Matplotlib 自定义选项。 你可以在任何类型的绘图中使用颜色，例如g为绿色，
b为蓝色，r为红色，y为黄色，k为黑色，w为白色，买等等。 你还可以使用十六进制颜色代码，如#191970。

直方图：
接下来，我们会讲解直方图。 直方图非常像条形图，倾向于通过将区段组合在一起来显示分布。 这个例子可能是年龄的分组，或测试的分数。
我们并不是显示每一组的年龄，而是按照 20 ~ 25，25 ~ 30… 等等来显示年龄。 这里有一个例子：

import matplotlib.pyplot as plt
population_ages = [22,55,62,45,21,22,34,42,42,4,99,102,110,120,121,122,130,111,115,112,80,75,65,54,44,43,42,48]
bins = [0,10,20,30,40,50,60,70,80,90,100,110,120,130]
plt.hist(population_ages, bins, histtype='bar', rwidth=0.8)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Interesting Graph\nCheck it out')
plt.legend()
plt.show()
对于plt.hist，你首先需要放入所有的值，然后指定放入哪个桶或容器。 在我们的例子中，我们绘制了一堆年龄，并希望以 10 年的增量来显示它们。
我们将条形的宽度rwidth设为 0.8，但是如果你想让条形变宽，或者变窄，你可以选择其他的宽度。

散点图

import matplotlib.pyplot as plt
x = [1,2,3,4,5,6,7,8]
y = [5,2,4,2,1,4,5,2]
plt.scatter(x,y, label='skitscat', color='k', s=25, marker="o")
plt.xlabel('x')
plt.ylabel('y')
plt.title('Interesting Graph\nCheck it out')
plt.legend()
plt.show()
plt.scatter不仅允许我们绘制x和y，而且还可以让我们决定所使用的标记颜色color，大小s和类型marker。 有一堆标记选项，请参阅 Matplotlib 标记文档中的所有选项。

堆叠图：
在这篇 Matplotlib 数据可视化教程中，我们要介绍如何创建堆叠图。 堆叠图用于显示『部分对整体』随时间的关系。 堆叠图基本上类似于饼图，只是随时间而变化。
让我们考虑一个情况，我们一天有 24 小时，我们想看看我们如何花费时间。 我们将我们的活动分为：睡觉，吃饭，工作和玩耍。
我们假设我们要在 5 天的时间内跟踪它，因此我们的初始数据将如下所

import matplotlib.pyplot as plt
days = [1,2,3,4,5]
sleeping = [7,8,6,11,7]
eating =   [2,3,4,3,2]
working =  [7,8,7,2,2]
playing =  [8,5,7,8,13]
plt.plot([],[],color='m', label='Sleeping', linewidth=5)
plt.plot([],[],color='c', label='Eating', linewidth=5)
plt.plot([],[],color='r', label='Working', linewidth=5)
plt.plot([],[],color='k', label='Playing', linewidth=5)
plt.stackplot(days, sleeping,eating,working,playing, colors=['m','c','r','k'])
plt.xlabel('x')
plt.ylabel('y')
plt.title('Interesting Graph\nCheck it out')
plt.legend()
plt.show()
我们在这里做的是画一些空行，给予它们符合我们的堆叠图的相同颜色，和正确标签。 我们还使它们线宽为 5，使线条在图例中显得较宽。 现在，我们可以很容易地看到，
我们如何花费我们的时间。

饼状图：
饼图很像堆叠图，只是它们位于某个时间点。 通常，饼图用于显示部分对于整体的情况，通常以％为单位。 幸运的是，Matplotlib 会处理切片大小以及一切事情，我们只需
要提供数值。

import matplotlib.pyplot as plt
slices = [7,2,2,13]
activities = ['sleeping','eating','working','playing']
cols = ['c','m','r','b']
plt.pie(slices,
        labels=activities,
        colors=cols,
        startangle=90,
        shadow= True,
        explode=(0,0.1,0,0),
        autopct='%1.1f%%')
plt.title('Interesting Graph\nCheck it out')
plt.show()
在plt.pie中，我们需要指定『切片』，这是每个部分的相对大小。 然后，我们指定相应切片的颜色列表。 接下来，我们可以选择指定图形的『起始角度』。 这使你可以在任
何地方开始绘图。 在我们的例子中，我们为饼图选择了 90 度角，这意味着第一个部分是一个竖直线条。 接下来，我们可以选择给绘图添加一个字符大小的阴影，然后我们
甚至可以使用explode拉出一个切片。
我们总共有四个切片，所以对于explode，如果我们不想拉出任何切片，我们传入0,0,0,0。 如果我们想要拉出第一个切片，我们传入0.1,0,0,0。最后，我们使用autopct，选择将
百分比放置到图表上面。

Python知识点（四）

一、print()函数
1.引号的用法
单引号和双引号：直接输出
例子：print(’字符串’)或print(’’字符串’’)

三引号：换行（\n）
例子：print(‘’’我愿意留在汤婆婆的澡堂里工作两年，
第一年在锅炉房和锅炉爷爷一起烧锅炉水，
第二年在澡堂给客人搓背，
如果我违背工作内容的话，
将在这个世界变成一头猪。
‘’')

2、转义字符
转义字符是一种特殊的字符常量，在编程语言中，我们用转义字符表示不能直接显示的字符，比如换行键、后退键，回车键等。
转义字符总结
【\】+转义内容英文缩写首字母

3、变量和赋值
3.1、变量的命名规范
name=‘函数’，这就是一个常见的“给变量赋值”的动作。在这里，name就是一个变量，这行代码的意思，就是把“千寻”这两个字【赋值】给了“name”这个【变量】。

变量的命名规范：
1、只能是一个词。
2、只能包含字母、数字和下划线
3、不能以数字开头
4、尽量描述包含的数据内容

二、数据类型与转换
1、数据类型
1.1、字符串
字符串英文string，简写str。只要是被【单/双/三引号】这层皮括起来的内容，不论那个内容是中文、英文、数字甚至火星文。只要是被括起来的，就表示是字符串类型。（示例：‘函数’、‘hanshu’、'123’）

1.2、整数
整数英文为integer，简写做int。和我们数学课本中定义的一样：是正整数、负整数和零的统称，是没有小数点的数字。（示例：-1、1、0、1、2）

1.3、浮点数
浮点数的英文名是float，与整数(int)和字符串(str)不同，浮点数没有简写。（示例：-0.33、1.0、3.14156）

2、数据拼接
就是利用数据拼接符号【+】，将需要拼接的变量连在一起就行了。

2.1、type()函数
只需把查询的内容放在type()函数中的括号里就行。（示例：print(type(‘查询的内容’))）

2.2、数据转换
2.2.1、str() 函数
将其它类型转化为字符型，也可以用引号’',进行转化为字符串
例子：num=123，转化成字符串：str(num)或者num=‘123’
数据类型转换方法：
str()：将其他数据类型转成字符串
int()：将其他数据类型转成整数
float()：将其他数据类型转成浮点数

2.2.2、int() 函数
将其它类型转化成整数型
注意：int函数不能将文字型字符串和浮点数字符串转换成整数型，只能将符合整数规范的字符串转换成整数。
（例如：'6好好’和’3.6’不能被int转化，'666’则可以被int转换）

2.2.3、float() 函数
将其它类型转化成浮点型
float()函数也可以将整数和字符串转换为浮点类型，（例如：float(3),float(‘3’)）

三、条件判断
1、单向判断：

if a=6
#为a赋值
if a>=6:
    #条件：如果a大于等于6
print('你可以吃蛋糕')
2、双向判断：if ... else ...
a=6
#为a赋值
if a>=6:
    #条件：如果a大于等于6
    print('1')
else:
     #条件：如果a小于6
    print('2')   

3、多向判断：if…elif…else…
a=6
#为a赋值

if a>=6:
    #条件：如果a大于等于6
    print('1')
elif 4<a<5
     #条件：如果a小于5大于4
    print('2')  
else:
     #其它
    print('3') 

4、if 嵌套

historyscore=26
if historyscore>=60:   
    print('你已经及格')
    if historyscore>=80:
        print('你很优秀')
    else:
        print('你只是一般般')
else:
    print('不及格')
    if historyscore<30:
        print('学渣')
    else:
        print('还能抢救一下')
print('程序结束')

解析：该逻辑是为了判断历史成绩的分数，来决定输出的语句；首先先有两个大分支，一个是historyscore>=60分，一个是historyscore<60分，所以if historyscore>=60与else: print(‘不及格’)同级；然后在两个大分支中又各分两个分支，当>=60分时，下面的一个分支historyscore>=80,一个是其它（60~80），所以 if historyscore>=80:与else:print(‘你只是一般般’)同级。当else:print(‘不及格’)时，下面的一个分支是 historyscore<30，一个是else:print(‘还能抢救一下’)，所以这两个同级
***注意：当碰到if条件嵌套时，先要理清谁与谁同级，谁是大分支，谁是小分支

四、input()函数的使用
例子：a=input(‘请铲屎官输入宠物的名字：’)
注意：运行后必须要在终端给input函数进行赋值
input()函数的使用：有问有答，有来有往，需要在终端处输入信息。

1、input()函数结果的赋值
函数好用，赋值第一，input()函数的结果必须赋值

2、input()函数的数据类型
例子：a=input(‘请铲屎官输入宠物的名字：’)
a的数据类型是字符串
返回类型，必为str，不管你在终端输入的是整数还是字符串，输入值必为字符串。

3、input()函数结果的强制转换
例子：a=int(input(‘请铲屎官输入宠物的名字：’))
a就变成了整数类型了
想要整数，源头转换，输入值需要整数时，input()函数结果需要强制转换。

Python知识点（五）

Python 变量类型
变量赋值
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = “John” # 字符串
print (counter)
print (miles)
print (name)
多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, “john”
以上实例，两个整型对象1和2的分配给变量 a 和 b，字符串对象 “john” 分配给变量 c。
标准数据类型
在内存中存储的数据可以有多种类型。
例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。
Python 定义了一些标准类型，用于存储各种类型的数据。
Python有五个标准的数据类型：
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
Python数字
数字数据类型用于存储数值。
他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
当你指定一个值时，Number对象就会被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象的引用。
del语句的语法是：
del var1[,var2[,var3[…,varN]]]]
您可以通过使用del语句删除单个或多个对象的引用。例如：
del var
del var_a, var_b
Python支持四种不同的数字类型：
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）
Python字符串

str = ‘Hello World!’

print(str) # 输出完整字符串
print(str[0] )# 输出字符串中的第一个字符
print(str[2:5])# 输出字符串中第三个至第五个之间的字符串
print(str[2:]) # 输出从第三个字符开始的字符串
print(str * 2) # 输出字符串两次
print(str + “TEST”)# 输出连接的字符串
Python列表
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：

list = [‘runoob’, 786, 2.23, ‘john’, 70.2]
tinylist = [123, ‘john’]

print(list)# 输出完整列表
print(list[0])# 输出列表的第一个元素
print(list[1:3])# 输出第二个至第三个元素
print(list[2:])# 输出从第三个开始至列表末尾的所有元素
print(tinylist * 2 )# 输出列表两次
print(list + tinylist)# 打印组合的列表
更新列表
你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：
实例(Python 2.0+)
#!/usr/bin/python # -- coding: UTF-8 -- list = [] ## 空列表 list.append(‘Google’) ## 使用 append() 添加元素 list.append(‘Runoob’) print list
删除列表元素
可以使用 del 语句来删除列表的元素，如下实例：
实例(Python 2.0+)
#!/usr/bin/python list1 = [‘physics’, ‘chemistry’, 1997, 2000] print list1 del list1[2] print “After deleting value at index 2 : " print list1
Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：



Python元组
元组是另一个数据类型，类似于List（列表）。
元组用”()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表
修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
#!/usr/bin/python# -- coding: UTF-8 --

tup1 = (12, 34.56);
tup2 = (‘abc’, ‘xyz’);
以下修改元组元素操作是非法的。# tup1[0] = 100;
创建一个新的元组
tup3 = tup1 + tup2;print tup3;
删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
#!/usr/bin/python

tup = (‘physics’, ‘chemistry’, 1997, 2000);
print tup;del tup;print "After deleting tup : "print tup;
元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。


无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组，如下实例：
#!/usr/bin/python
print ‘abc’, -4.24e93, 18+6.6j, ‘xyz’;
x, y = 1, 2;print "Value of x , y : “, x,y;
元组内置函数
Python元组包含了以下内置函数

Python 字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用”{ }"标识。字典由索引(key)和它对应的值value组成。
dict = {}
dict[‘one’] = “This is one”
dict[2] = “This is two”

tinydict = {‘name’: ‘john’, ‘code’: 6734, ‘dept’: ‘sales’}

print(dict[‘one’]) # 输出键为’one’ 的值
print(dict[2] )# 输出键为 2 的值
print(tinydict)# 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values()) # 输出所有值
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
实例
#!/usr/bin/python dict = {‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’}; dict[‘Age’] = 8; # update existing entry dict[‘School’] = “DPS School”; # Add new entry print "dict[‘Age’]: ", dict[‘Age’]; print "dict[‘School’]: ", dict[‘School’];
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
实例
#!/usr/bin/python # -- coding: UTF-8 -- dict = {‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’}; del dict[‘Name’]; # 删除键是’Name’的条目 dict.clear(); # 清空词典所有条目 del dict ; # 删除词典 print "dict[‘Age’]: ", dict[‘Age’]; print "dict[‘School’]: ", dict[‘School’];
字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
实例
#!/usr/bin/python dict = {‘Name’: ‘Zara’, ‘Age’: 7, ‘Name’: ‘Manni’}; print "dict[‘Name’]: ", dict[‘Name’];
字典内置函数&方法
Python字典包含了以下内置函数：







Python 条件语句
if 判断条件：
执行语句……else：
执行语句……
if 判断条件1:
执行语句1……elif 判断条件2:
执行语句2……elif 判断条件3:
执行语句3……else:
执行语句4……
Python 循环语句
Python提供了for循环和while循环（在Python中没有do…while循环）:

while 循环
while 判断条件：
执行语句……
while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立，具体用法如下：

continue 和 break 用法

i = 1
while i < 10: i += 1 i
f i%2 > 0: # 非双数时跳过输出
continue
print i # 输出双数2、4、6、8、10
i = 1
while 1: # 循环条件为1必定成立
print i # 输出1~10
i += 1
if i > 10: # 当i大于10时跳出循环
break
循环使用 else 语句
在 python 中，while … else 在循环条件为 false 时执行 else 语句块：
for iterating_var in sequence:
statements(s)
For 循环
循环使用 else 语句
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
Python for 循环嵌套语法：
for iterating_var in sequence: for iterating_var in sequence: statements(s) statements(s)
Python while 循环嵌套语法：
while expression: while expression: statement(s) statement(s)
你可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环， 反之，你可以在for循环中嵌入while循环。

循环控制语句
循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：

Python break 语句
Python break语句，就像在C语言中，打破了最小封闭for或while循环。
break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。
break语句用在while和for循环中。
如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。
Python continue 语句
Python continue 语句跳出本次循环，而break跳出整个循环。
continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
continue语句用在while和for循环中。
Python pass 语句

Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。
Python 语言 pass 语句语法格式如下：
Python 日期和时间
Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:
import time; # 引入time模块

ticks = time.time()print “当前时间戳为:”, ticks
上述也就是struct_time元组。这种结构具有如下属性：

获取当前时间
从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。
#!/usr/bin/python# -- coding: UTF-8 --
import time

localtime = time.localtime(time.time())
print (“本地时间为 :”, localtime)
格式化日期
我们可以使用 time 模块的 strftime 方法来格式化日期，：
time.strftime(format[, t])
#!/usr/bin/python# -- coding: UTF-8 --
import time

格式化成2016-03-20 11:45:39形式print time.strftime(“%Y-%m-%d %H:%M:%S”, time.localtime())

格式化成Sat Mar 28 22:24:24 2016形式print time.strftime(“%a %b %d %H:%M:%S %Y”, time.localtime())

将格式字符串转换为时间戳

a = “Sat Mar 28 22:24:24 2016"print time.mktime(time.strptime(a,”%a %b %d %H:%M:%S %Y"))
python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
获取某月日历
Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
#!/usr/bin/python# -- coding: UTF-8 --
import calendar

cal = calendar.month(2016, 1)print "以下输出2016年1月份的日历:"print cal;
Time 模块
Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：




Python 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法
def functionname( parameters ):
“函数_文档字符串”
function_suite
return [expression]
参数传递
在 python 中，类型属于对象，变量是没有类型的：
可更改(mutable)与不可更改(immutable)对象
在 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 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

Python 模块
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
import 语句
模块的引入
模块定义好后，我们可以使用 import 语句来引入模块，语法如下：
例子
下例是个简单的模块 support.py：
support.py 模块：
def print_func( par ): print "Hello : ", par return

import module1[, module2[,… moduleN]
比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：
模块名.函数名
from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：
from fib import fibonacci
from…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
dir()函数
dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。、
globals() 和 locals() 函数
根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。
reload() 函数
当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。
因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。
在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载 hello 模块，如下：
reload(hello)
Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
简单来说，包就是文件夹，但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。init.py 用于标识当前文件夹是一个包。

Python 文件I/O
本章只讲述所有基本的的I/O函数，更多函数请参考Python标准文档。
打印到屏幕
最简单的输出方法是用print语句，你可以给它传递零个或多个用逗号隔开的表达式。此函数把你传递的表达式转换成一个字符串表达式，
读取键盘输入
Python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘。如下：
raw_input
input
raw_input函数
raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）：
input函数
input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。
打开和关闭文件
现在，您已经可以向标准输入和输出进行读写。现在，来看看怎么读写实际的数据文件。
Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。
open 函数
你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
语法：
file object = open(file_name [, access_mode][, buffering])
File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：

close()方法
File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。
语法：
fileObject.close()
write()方法
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符(‘\n’)：
fileObject.write(string)

read()方法
read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
语法：fileObject.read([count])
Python的os模块提供了帮你执行文件处理操作的方法，比如重命名和删除文件。
要使用这个模块，你必须先导入它，然后才可以调用相关的各种功能。
rename()方法：
rename()方法需要两个参数，当前的文件名和新文件名。
os.rename(current_file_name, new_file_name)
你可以用remove()方法删除文件，需要提供要删除的文件名作为参数。
os.remove(file_name)
Python里的目录：
所有文件都包含在各个不同的目录下，不过Python也能轻松处理。os模块有许多方法能帮你创建，删除和更改目录。
mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。
chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
rmdir()方法
rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。
文件、目录相关的方法
File 对象和 OS 对象提供了很多文件与目录的操作方法，可以通过点击下面链接查看详情：
File 对象方法: file 对象提供了操作文件的一系列方法。
OS 对象方法: 提供了处理文件及目录的一系列方法

结束语
推荐一款模拟面试、Python刷题神器网站点击链接注册即可
1、算法篇（398题）：面试必刷100题、算法入门、面试高频榜单
2、SQL篇（82题）：快速入门、SQL必知必会、SQL进阶挑战、面试真题
3、大厂笔试真题：字节跳动、美团、百度、腾讯…

整理不易，不喜勿喷，喜欢的点个赞呗！