# -*- coding: utf-8 -*-
import math, random,time
import threading
import tkinter as tk
import re
#import uuid
Fireworks=[]
maxFireworks=8
height,width=600,600
class firework(object):
def __init__(self,color,speed,width,height):
#uid=uuid.uuid1()
self.radius=random.randint(2,4) #粒子半径为2~4像素
self.color=color #粒子颜色
self.speed=speed #speed是1.5-3.5秒
self.status=0 #在烟花未爆炸的情况下，status=0；爆炸后，status>=1；当status>100时，烟花的生命期终止
self.nParticle=random.randint(20,30) #粒子数量
self.center=[random.randint(0,width-1),random.randint(0,height-1)] #烟花随机中心坐标
self.oneParticle=[] #原始粒子坐标（100%状态时）
self.rotTheta=random.uniform(0,2*math.pi) #椭圆平面旋转角
#椭圆参数方程：x=a*cos(theta),y=b*sin(theta)
#ellipsePara=[a,b]
self.ellipsePara=[random.randint(30,40),random.randint(20,30)]
theta=2*math.pi/self.nParticle
for i in range(self.nParticle):
t=random.uniform(-1.0/16,1.0/16) #产生一个 [-1/16,1/16) 的随机数
x,y=self.ellipsePara[0]*math.cos(theta*i+t), self.ellipsePara[1]*math.sin(theta*i+t) #椭圆参数方程
xx,yy=x*math.cos(self.rotTheta)-y*math.sin(self.rotTheta), y*math.cos(self.rotTheta)+x*math.sin(self.rotTheta) #平面旋转方程
self.oneParticle.append([xx,yy])
self.curParticle=self.oneParticle[0:] #当前粒子坐标
self.thread=threading.Thread(target=self.extend) #建立线程对象
def extend(self): #粒子群状态变化函数线程
for i in range(100):
self.status+=1 #更新状态标识
self.curParticle=[[one[0]*self.status/100, one[1]*self.status/100] for one in self.oneParticle] #更新粒子群坐标
time.sleep(self.speed/50)
def explode(self):
self.thread.setDaemon(True) #把现程设为守护线程
self.thread.start() #启动线程
def __repr__(self):
return ('color:{color}\n'
'speed:{speed}\n'
'number of particle: {np}\n'
'center:[{cx} , {cy}]\n'
'ellipse:a={ea} , b={eb}\n'
'particle:\n{p}\n'
).format(color=self.color,speed=self.speed,np=self.nParticle,cx=self.center[0],cy=self.center[1],p=str(self.oneParticle),ea=self.ellipsePara[0],eb=self.ellipsePara[1])
def colorChange(fire):
rgb=re.findall(r'(.{2})',fire.color[1:])
cs=fire.status
f=lambda x,c: hex(int(int(x,16)*(100-c)/30))[2:] #当粒子寿命到70%时，颜色开始线性衰减
if cs>70:
ccr,ccg,ccb=f(rgb[0],cs),f(rgb[1],cs),f(rgb[2],cs)
else:
ccr,ccg,ccb=rgb[0],rgb[1],rgb[2]
return '#{0:0>2}{1:0>2}{2:0>2}'.format(ccr,ccg,ccb)
def appendFirework(n=1): #递归生成烟花对象
if n>maxFireworks or len(Fireworks)>maxFireworks:
pass
elif n==1:
cl='#{0:0>6}'.format(hex(int(random.randint(0,16777215)))[2:]) # 产生一个0~16777215（0xFFFFFF）的随机数，作为随机颜色
a=firework(cl,random.uniform(1.5,3.5),width,height)
Fireworks.append( {'particle':a,'points':[]} ) #建立粒子显示列表，‘particle’为一个烟花对象，‘points’为每一个粒子显示时的对象变量集
a.explode()
else:
appendFirework()
appendFirework(n-1)
def show(c):
for p in Fireworks: #每次刷新显示，先把已有的所以粒子全部删除
for pp in p['points']:
c.delete(pp)
for p in Fireworks: #根据每个烟花对象，计算其中每个粒子的显示对象
oneP=p['particle']
if oneP.status==100: #状态标识为100，说明烟花寿命结束
Fireworks.remove(p) #移出当前烟花
appendFirework() #新增一个烟花
continue
else:
li=[[int(cp[0]*2)+oneP.center[0],int(cp[1]*2)+oneP.center[1]] for cp in oneP.curParticle] #把中心为原点的椭圆平移到随机圆心坐标上
color=colorChange(oneP) #根据烟花当前状态计算当前颜色
for pp in li:
p['points'].append(c.create_oval(pp[0]-oneP.radius, pp[1]-oneP.radius, pp[0]+oneP.radius, pp[1]+oneP.radius, fill=color)) #绘制烟花每个粒子
root.after(50, show,c) #回调，每50ms刷新一次
if __name__=='__main__':
appendFirework(maxFireworks)
root = tk.Tk()
cv = tk.Canvas(root, height=height, width=width)
cv.create_rectangle(0, 0, width, height, fill="black")
cv.pack()
root.after(50, show,cv)
root.mainloop()
import tkinter as tk
from PIL import Image,ImageTk
from time import time,sleep
from random import choice,uniform,randint
from math import sin,cos,radians
#重力变量
GRAVITY=0.5
#listof colors,can choose randomly or use as queue(FIFO
colors=['red','blue','yellow','white','green','orange','purple','seagreen','indigo','cornflowerblue']
'''
create a class for particles粒子
particles are emitted almost randomly on the sky,
forming around(组成一个圈) of circle(a star)before falling and getting removed from canvas
Attributes(属性)：
id:每个特定烟花的标识符
x，y：烟花的绽放坐标
vx,vy:烟花的绽放速度
total:一颗烟花里的星星总数
age:一颗星星会在画布上停留多久
color:自我移植
cv:画布
lifespan:星星在画布上停留的最后时间
'''
class part:#为每一个烟花绽放出来的粒子单独构建一个类的对象
def __init__(self,cv,idx,total,explosion_speed,x=0.,y=0.,vx=0.,vy=0.,size=2.,color='red',lifespan=2,**kwargs):
self.id=idx#每个烟花的特定标识符
self.x=x#烟花的绽放x轴
self.y=y#烟花的绽放x轴
self.initial_speed=explosion_speed#初速度
self.vx=vx#外放x轴速度
self.vy=vy#外放y轴速度
self.total=total#绽放的粒子数
self.age=0#已停留时间
self.color=color#颜色
self.cv=cv#画布
self.cid=self.cv.create_oval(x-size,y-size,x+size,y+size,fill=self.color)#create_oval()创建一个椭圆，参数为左上x，左上y，右下x，右下y，填满的颜色，该函数返回一个id
self.lifespan=lifespan#应该停留时间
def update(self,dt):#更新数据，已停留时间增加
self.age+=dt
#粒子膨胀
if self.alive() and self.expand():#如果停留时间（2s）足够&&膨胀时间（1.2s）足够
move_x=cos(radians(self.id*360/self.total))*self.initial_speed#粒子的x轴继续膨胀
move_y=sin(radians(self.id*360/self.total))*self.initial_speed#粒子的y轴继续膨胀
self.cv.move(self.cid, move_x, move_y)#根据id把画布上的粒子移动x和y个距离
self.vx=move_x/(float(dt)*1000)
#以自由落体坠落
elif self.alive():#如果只是停留时间足够，说明膨胀到最大了，应该准备下坠
move_x=cos(radians(self.id*360/self.total))#x轴继续膨胀
self.cv.move(self.cid,self.vx+move_x,self.vy+GRAVITY*dt)#而y轴按照重力因素做落体运动，但实际上这个重力是v而不是a
self.vy+=GRAVITY*dt#更新一下y轴
elif self.cid is not None:#如果粒子的生命周期已过，就将其移除
cv.delete(self.cid)#删除该粒子对象
self.cid=None
#定义膨胀效果的时间帧
def expand(self):
return self.age<=1.2#膨胀时间小于1.2s
#检查粒子是否仍在生命周期内
def alive(self):#已停留时间是不是比应该停留时间短
return self.age<=self.lifespan
'''
烟花模拟回路：
递归调用来在画布上重复发出新的烟火
通过每个“部件”对象内部的更新协议，每次调用时都要在画布上创建并绘制列表（星列表，每个星列表成员都是粒子列表）来重复地在画布上发出新的焰火
'''
#生成新的一轮爆炸
def simulate(cv):
t=time()#time()函数返回自1970年后经过的浮点秒数，精确到小数点后6位
explode_points=[]#爆炸点列表--烟花列表
wait_time=randint(10,100)#随机生成一个int n,10<=n<=100
numb_explode=randint(6,10)#爆炸的个数是6~10
#为所有模拟烟花绽放的全部例子创建一列列表
for point in range(numb_explode):#遍历爆炸的个数
objects=[]#这是每个点的爆炸粒子列表
x_cordi=randint(50,550)#每个点的爆炸x轴
y_cordi=randint(50,150)#爆炸y轴
speed=uniform(0.5,1.5)#随机生成一个float speed，0.5<=speed<1.5
size=uniform(0.5,3)#随机生成一个float size,0.5<=size<3
color=choice(colors)#choice（）是python内置函数，随机返回元组，列表，或字符串的一个成员
explosion_speed=uniform(0.2,1)#爆炸的绽放速度也要随机出来
total_particles=randint(10,50)#爆炸出来的粒子数半径也随机
for i in range(1,total_particles):#同一个烟花爆炸出来的粒子的大小，速度，坐标都是相同的
r = part(cv, idx=i, total=total_particles, explosion_speed=explosion_speed, x=x_cordi, y=y_cordi,
vx=speed, vy=speed, color=color, size=size, lifespan=uniform(0.6, 1.75))#把上述参数带入，但他们每个粒子的生存时间是自己独立的
objects.append(r)#添加进粒子列表里
explode_points.append(objects)#把该粒子列表添加进烟花列表里
total_time=.0#先把时间置0
#在1.8秒时间帧内保持更新
while total_time<1.8:
sleep(0.01)#让画面暂停0.01s
tnew=time()#刷新时间
t,dt=tnew,tnew-t#时间等于新时间，与上次时间间隔为tnew-t
for point in explode_points:#遍历烟花列表
for item in point:#遍历烟花里的粒子列表
item.update(dt)#更新时间
cv.update()#刷新页面
total_time+=dt#为上面的while循环增加时间
root.after(wait_time,simulate,cv)#将组件置于其他组件之后，就是放在最顶层，覆盖下面的，这里递归第哦啊用了自己，形成新的一轮爆炸
def close(*ignore):
#打开模拟循环并关闭窗口
global root
root.quit()
if __name__=="__main__":
root=tk.Toplevel()
cv=tk.Canvas(root,height=600,width=700)#绘制一个画布
#绘制一个黑色背景
#cv.create_rectangle(0,0,600,600,fill="black")
#use a nice background image
image=Image.open("C:/Users/MACHENIKE/Desktop/郑州/python烟花/timg.jpg")
photo=ImageTk.PhotoImage(image)
cv.create_image(0,0,image=photo,anchor='nw')#在画板上绘制一张图片
cv.pack()#把cv添加进去
root.protocol("WM_DELETE_WINDOW",close)
#在0.1s后才开始调用stimulate()
root.after(100,simulate,cv)#调用stimulate生成一轮烟花绽放效果
root.mainloop()#执行root，
一、变量和字符串
首先：Python 每个语句结束可以不写分号 ;， 如 print('hello') 打印 hello
1.1 变量
有过编程基础的话，变量就不用多说了。
变量的命名法：
驼峰式命名法
帕斯卡命名法
1.2 字符串
1、基本介绍
单引号 ' '或者双引号 " " 都可以，再或者 ''' ''' 三个引号，其中三个引号被用于过于长段的文字或者是说明，只要是三引号不完你就可以随意换行写下文字。
①字符串直接能相加，如：
str1 = 'hi'
str2 = 'hello'
print(str1 + str2)
1
2
3
运行结果：
hi jaybo
1
②字符串相乘，如：
string = 'bang!'
total = string * 3
1
2
打印 total 结果：
bang!bang!bang!
1
2、字符串的分片与索引
字符串可以通过 string[x] 的方式进行索引、分片。
字符串的分片实际可以看作是从字符串中找出来你要截取的东西，复制出来一小段你要的长度，存储在另一个地方，而不会对字符串这个源文件改动。分片获得的每个字符串可以看作是原字符串的一个副本。
先看下面这段代码：
name = 'My name is Mike'
print(name[0])
'M'
print(name[-4])
'M'
print(name[11:14]) # from 11th to 14th, 14th one is excluded
'Mik'
print(name[11:15]) # from 11th to 15th, 15th one is excluded
'Mike'
print(name[5:])
'me is Mike'
print(name[:5])
'My na'
1
2
3
4
5
6
7
8
9
10
11
12
13
如果感到困惑话，可以对照如下表格理解和分析：
:两边分别代表着字符串的分割从哪里开始，并到哪里结束。
以name[11:14]为例，截取的编号从第11个字符开始，到位置为14但不包含第14个字符结束。而像name[5:]这样的写法代表着从编号为5的字符到结束的字符串分片。相反，name[:5]则代表着从编号为0的字符开始到编号为5但包含第5个字符分片。可能容易搞混，可以想象成第一种是从5到最后面，程序员懒得数有多少个所以就省略地写，第二种是从最前面到5，同样懒得写0，所以就写成了[:5]。
3、字符串的方法
replace 方法：第一个参数表示被替代部分，第二个参数表示替代成怎样的字符串。
字符串填空，如：
city = input("write the name of city:"")
url = "http://apistore.baidu.com/mri.../weather?citypiny={}.format(city)
1
2
4、问题
问题1：
num = 1
string = '1'
print(num + string)
1
2
3
上面代码将出错？
解释：整数型不能和字符串直接相加。可以先把该字符串转为整数型，再相加，即 int(string)
num = 1
string = '1'
print(num + int(string))
1
2
3
二、函数
举些你可能已经使用过的函数例子：
判断数据类型：type(str)
字符串类型数据转为整数型：int(str)
...
1
2
3
通过观察规律不难发现，Python 中所谓的使用函数就是把你要处理的对象放到一个名字后面的括号就可以了。简单的来说，函数就是这么使用，可以往里面塞东西得到处理结果。这样的函数在 Python 中还有这些：
以 Python3.5 版本为例，一个有 68 个这样的函数，它们被称为内建函数。这里內建的是指这些函数为安装好了 Python 就可以使用。
2.1 函数格式
定义函数的格式：
其中，def 和 return 为关键字。
注意： 函数缩进后面的语句被称为是语句块，缩进是为了表名语句的逻辑与从属关系。缩进这个问题不能忽视，否则会导致代码无法成功运行，这里需要特别注意。
2.2 函数参数
①位置参数，举例，看代码：
def trapezoid_area(base_up, base_down, height):
return 1/2 * (base_up + base_down) * height
1
2
接下来我们开始调用该函数：
trapezoid_area(1,2,3)
1
不难看出，填入的参数1，2，3分别对应着参数 base_up，base_down 和 height。这种传入参数的方式被称作为位置参数。
②关键词参数：在函数调用的时候，将每个参数名称后面赋予一个我们想要传入的值，如调用 fun1 函数时候：fun1(a=1, b=2, c=3)。
看下图：
第一行的函数参数按照反序传入，因为是关键词参数，所以并不影响函数正常运作；
第二行的函数参数反序传入，但是到了第三个却变成了位置函数，遗憾的是这种方式是错误的语法，因为如果按照位置来传入，最后一个应该是参数 height 的位置。但是前面 height 已经按照名称传入了值3，所以是冲突的。
第三行的函数参数正序传入，前两个是以关键字的方式传入，最后一个以位置参数传入，但是位置参数不能再关键词参数后面，所以是错误的。
第四行的函数参数正序传入，前两个是以位置的方式传入，最后一个以关键字参数传入，这个函数是可以正常运行的。
③不定长参数
有时我们在设计函数接口的时候，可会需要可变长的参数。也就是说，我们事先无法确定传入的参数个数。
Python 提供了一种元组的方式来接受没有直接定义的参数。这种方式在参数前边加星号 * 。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。例如：
def print_user_info( name , age , sex = '男' , * hobby):
# 打印用户信息
print('昵称：{}'.format(name) , end = ' ')
print('年龄：{}'.format(age) , end = ' ')
print('性别：{}'.format(sex) ,end = ' ' )
print('爱好：{}'.format(hobby))
return;
# 调用 print_user_info 函数
print_user_info( '小明' , 25, '男', '打篮球','打羽毛球','跑步')
1
2
3
4
5
6
7
8
9
10
输出的结果：
昵称：小明 年龄：25 性别：男 爱好：('打篮球', '打羽毛球', '跑步')
1
通过输出的结果可以知道，* hobby 是可变参数，且 hobby 其实就是一个 tuple （元祖）。
可变长参数也支持关键参数，没有被定义的关键参数会被放到一个字典里。这种方式即是在参数前边加 **，更改上面的示例如下：
def print_user_info( name , age , sex = '男' , ** hobby ):
# 打印用户信息
print('昵称：{}'.format(name) , end = ' ')
print('年龄：{}'.format(age) , end = ' ')
print('性别：{}'.format(sex) ,end = ' ' )
print('爱好：{}'.format(hobby))
return;
# 调用 print_user_info 函数
print_user_info( name = '小明' , age = 25 , sex = '男', hobby = ('打篮球','打羽毛球','跑步'))
1
2
3
4
5
6
7
8
9
10
输出的结果：
昵称：小明 年龄：24 性别：男 爱好：{'hobby': ('打篮球', '打羽毛球', '跑步')}
1
通过对比上面的例子和这个例子，可以知道，* hobby 是可变参数，且 hobby 其实就是一个 tuple （元祖），** hobby是关键字参数，且 hobby 就是一个 dict （字典）。
④ 只接受关键字参数
关键字参数使用起来简单，不容易参数出错，那么有些时候，我们定义的函数希望某些参数强制使用关键字参数传递，这时候该怎么办呢？将强制关键字参数放到某个*参数或者单个*后面就能达到这种效果,比如：
def print_user_info( name , *, age, sex = '男' ):
# 打印用户信息
print('昵称：{}'.format(name) , end = ' ')
print('年龄：{}'.format(age) , end = ' ')
print('性别：{}'.format(sex))
return;
# 调用 print_user_info 函数
print_user_info( name = '小明' ,age = 25 , sex = '男' )
# 这种写法会报错，因为 age ，sex 这两个参数强制使用关键字参数
#print_user_info( '小明' , 25 , '男' )
print_user_info('小明',age='22',sex='男')
1
2
3
4
5
6
7
8
9
10
11
12
13
通过例子可以看，如果 age , sex 不适用关键字参数是会报错的。
2.3 匿名函数
有没有想过定义一个很短的回调函数，但又不想用 def 的形式去写一个那么长的函数，那么有没有快捷方式呢？
——答案是有的。
Python 使用 lambda 来创建匿名函数，也就是不再使用 def 语句这样标准的形式定义一个函数。
匿名函数主要有以下特点：
lambda 只是一个表达式，函数体比 def 简单很多。
lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
基本语法：lambda [arg1 [,arg2,.....argn]]:expression
示例：
sum = lambda num1 , num2 : num1 + num2;
print( sum( 1 , 2 ) )
1
2
输出的结果： 3
注意：尽管 lambda 表达式允许你定义简单函数，但是它的使用是有限制的。 你只能指定单个表达式，它的值就是最后的返回值。也就是说不能包含其他的语言特性了， 包括多个语句、条件表达式、迭代以及异常处理等等。
匿名函数中，有一个特别需要注意的问题，比如，把上面的例子改一下：
num2 = 100
sum1 = lambda num1 : num1 + num2 ;
num2 = 10000
sum2 = lambda num1 : num1 + num2 ;
print( sum1( 1 ) )
print( sum2( 1 ) )
1
2
3
4
5
6
7
8
你会认为输出什么呢？第一个输出是 101，第二个是 10001，结果不是的，输出的结果是这样：
10001
10001
1
2
这主要在于 lambda 表达式中的 num2 是一个自由变量，在运行时绑定值，而不是定义时就绑定，这跟函数的默认值参数定义是不同的。所以建议还是遇到这种情况还是使用第一种解法。
三、循环与判断
3.1 布尔表达式和判断
Python 中的布尔类型值：True 和 Flase 其中，注意这两个都是首字母大写。
但凡能够产生一个布尔值的表达式为布尔表达式：
1 > 2 # False
1 < 2 <3 # True
42 != '42' # True
'Name' == 'name' # False
'M' in 'Magic' # True
number = 12
number is 12 # True
1
2
3
4
5
6
7
注1：不同类型的对象不能使用<、>、<=、=>进行比较，却可以使用==和!=。
注2：浮点类型和整数类型虽然是不同类型，但不影响比较运算。还有，不等于!= 可以写作<> 。
话说，布尔类型可以比较吗？如：True > Flase，回答是可以的，Ture 和 Flase 对于计算机就像是 1 和 0 一样，所以结果是真，即True。
3.2 条件控制
定义格式：
用一句话该结构作用：如果…条件是成立的，就做…；反之，就做…
所谓条件成立，指的是返回值为True的布尔表达式。
3.3 循环
①for 循环
把 for 循环所的事情概括成一句话就是：于…其中的每一个元素，做…事情。
打印九九乘法表：
for i in range(1, 10):
for j in range(1, i+1):
print('{}x{}={}\t'.format(i, j, i*j), end='')
print()
1
2
3
4
运行结果：
1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
4x1=4 4x2=8 4x3=12 4x4=16
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
1
2
3
4
5
6
7
8
9
②while 循环
总结：只要…条件一成立，就一直做…
在循环过程中，可以使用 break 跳过循环，使用 continue 跳过该次循环。
在 Python 的 while 循环中，可以使用 else 语句，while … else 在循环条件为 false 时执行 else 语句块。如：
count = 0
while count < 3:
print (count)
count = count + 1
else:
print (count)
1
2
3
4
5
6
运行结果：
0
1
2
3
1
2
3
4
有 while … else 语句，当然也有 for … else 语句，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。如：
for num in range(10,20): # 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print ('%d 是一个合数' % num)
break # 跳出当前循环
else: # 循环的 else 部分
print ('%d 是一个质数' % num)
1
2
3
4
5
6
7
8
运行结果：
10 是一个合数
11 是一个质数
12 是一个合数
13 是一个质数
14 是一个合数
15 是一个合数
16 是一个合数
17 是一个质数
18 是一个合数
19 是一个质数
1
2
3
4
5
6
7
8
9
10
四、数据结构
Python 有四种数据结构，分别是：列表、字典、元组、集合。我们先从整体上认识一下这四种数据结构：
list = [val1,val2,val3,val4] #列表
dict = {key1:val1,key2:val2} #字典
tuple = (val1,val2,val3,val4) #元组
set = {val1,val2,val3,val4} #集合
1
2
3
4
4.1 列表（List）
列表中的每个元素都是可变的；
列表中的元素是有序的，也就是说每个元素都有一个位置；
列表中可以容纳 Python 中的任何对象。如下：
all_in_list = [
1, #整数
1.0, #浮点数
'a word', #字符串
print(1), #函数
True, #布尔值
[1,2], #列表中套列表
(1,2), #元祖
{'key':'value'} #字典
]
1
2
3
4
5
6
7
8
9
10
另外，对于数据的操作，最常见的为增删改查。在此就省略了，网上找下相应函数练习下即可。
4.2 字典（Dict）
字典中数据必须是以键值对的形式出现的；
逻辑上讲，键是不能重复的；
字典中的键（key）是不可变的，也就是无法修改的，而值（value）是可变的，可修改的，可以是任何对象。
下面是个例子：
NASDAQ_code = {
'BIDU':'Baidu',
'SINA':'Sina',
'YOKU':'Youku'
}
1
2
3
4
5
一个字典中键与值并不能脱离对方而存在，如果你写成了 {'BIDU':} 会引发一个语法错误：invalid syntax。
如果试着将一个可变（mutable）的元素作为 key 来构建字典，比如列表：key_test = {[]:'a Test'} ，则会报一个错：unhashable type:'list'。
同时字典中的键值不会重复，即便你这么做，相同的键值也只能出现一次：a = {'key':123,'key':123} 。
增删改查操作，在此省略了。
备注：
列表中用来添加多个元素的方法为extend，在字典中添加多个元素的方法为update()
字典是不能切片的，即这样的写法是错误的：chart[1:4]
4.3 元组（Tuple）
元组可以理解为一个稳固版的列表，因为元组是不可以修改的，因此在列表中的存在的方法均不可以使用在元组上，但是元组是可以被查看索引的，方式和列表一样。
letters = ('a, 'b', 'c', 'd')
letters[0]
1
2
相关的操作找代码练习下即可。
4.4 集合（Set）
集合则更接近数学上集合的概念。每一个集合中是的元素是无序的、不重复的任意对象，我们可以通过集合去判断数据的从属关系，有时还可以通过集合把数据结构中重复的元素减掉。
集合不能被切片也不能被索引，除了做集合运算之外，集合元素可以被添加还有删除：
a_set = {1,2,3,4}
a_set.add(5)
a_set.discard(5)
1
2
3
4.5 数据结构的一些技巧
4.5.1 多重循环
如下：
代码演示：
for a, b in zip(num, str):
print(b, 'is', a)
1
2
4.5.2 推导式
列表推导式的用法很好理解，可以简单地看成两部分。如下图：
红色虚线后面的是我们熟悉的 for 循环的表达式，而虚线前面的可以认为是我们想要放在列表中的元素。
代码演示：
a = []
for i in range(1, 11):
a.append(i)
1
2
3
可以换成列表解析的方式来写：
b = [i for in i range(1, 11)]
1
列表解析式不仅方便，并且在执行效率上要远远胜过前者。
五、类的理解
5.1 类的介绍
类的定义：
class CocaCola:
formula = ['caffeine','sugar','water','soda']
1
2
使用 class 来定义一个类，就如同创建函数时使用的 def 定义一个函数一样简单。如上你可以看到定义了名为 CocaCola 的类，接着在缩进的地方有一个装载着列表的变量的 formula，这个在类里面定义的变量就是类的变量，而类的变量有一个专有的术语，我们称之为类的属性。
类的属性：
类变量
方法
①类的实例化：
coke_for_me = CocaCola()
coke_for_you = CocaCola()
1
2
②类变量属性的引用：CocaCola.formula、coke_for_me.formula
类方法的使用：
class CocaCola:
formula = ['caffeine','sugar','water','soda']
def drink(self):
print('Energy!')
coke = CocaCola()
coke.drink()
1
2
3
4
5
6
结果：
Energy!
1
5.2 self
我想很多人会有关注到这个奇怪的地方——似乎没有派上任何用场的self参数。我们来说明下原理，其实很简单，我们修改下上面的代码：
class CocaCola:
formula = ['caffeine','sugar','water','soda']
def drink(coke): # 把self改为coke
print('Energy!')
coke = CocaCola()
coke.drink()
1
2
3
4
5
6
结果：
Energy!
1
怎么样，有些头绪了吧！这个参数其实就是被创建的实例本身。也就是将一个个对象作为参数放入函数括号内，再进一步说，一旦一个类被实例化，那么我们其实可以使用和与我们使用函数相似的方式：
coke = CocaCola
coke.drink() == CocaCola.drink(coke) #左右两边的写法完全一致
1
2
被实例化的对象会被编译器默默地传入后面方法的括号中，作为第一个参数。上面两个方法是一样的，但我们更多地会写成前面那种形式。其实self这个参数名称是可以随意修改的（编译器并不会因此而报错）。
和函数一样，类的方法也能有属于自己的参数，如下：
class CocaCola:
formula = ['caffeine','sugar','water','soda']
def drink(self,how_much):
if how_much == 'a sip':
print('Cool~')
elif how_much == 'whole bottle’:
print('Headache!')
ice_coke = CocaCola()
ice_coke.drink('a sip')
1
2
3
4
5
6
7
8
9
10
结果：
Cool~
1
5.3 魔术方法
Python 的类中存在一些方法，被称为「魔术方法」，_init_()就是其中之一。
class CocaCola():
formula = ['caffeine','sugar','water','soda']
def __init__(self):
self.local_logo = '可口可乐'
def drink(self):
print('Energy!')
coke = CocaCola()
print(coke.local_logo)
1
2
3
4
5
6
7
8
作用：在创建实例之前，它做了很多事情。说直白点，意味着即使你在创建实例的时候不去引用 init_() 方法，其中的语句也会先被自动的执行。这给类的使用提供了极大的灵活性。
class CocaCola:
formula = ['caffeine','sugar','water','soda']
def __init__(self,logo_name):
self.local_logo = logo_name
def drink(self):
print('Energy!')
coke = CocaCola('ݢݗݢԔ')
coke.local_logo
>>> 可口可乐
1
2
3
4
5
6
7
8
9
有过面向对象编程经验很好理解了，也就是很多面向对象语言中的「构造函数」。
5.4 类的继承
如下代码：
class CaffeineFree(CocaCola):
caffeine = 0
ingredients = [
'High Fructose Corn Syrup',
'Carbonated Water',
'Phosphoric Acid',
'Natural Flavors',
'Caramel Color',
]
coke_a = CaffeineFree('Cocacola-FREE')
coke_a.drink()
1
2
3
4
5
6
7
8
9
10
11
表示 CaffeineFree 继承了 CocaCola 类。
类中的变量和方法可以被子类继承，但如需有特殊的改动也可以进行覆盖。
Q1：类属性如果被重新赋值，是否会影响到类属性的引用？
class TestA():
attr = 1
obj_a = TestA()
TestA.attr = 24
print(obj_a.attr)
>>> 结果：24
1
2
3
4
5
6
7
8
A1：会影响。
Q2：实例属性如果被重新赋值，是否会影响到类属性的引用？
class TestA:
attr = 1
obj_a = TestA()
obj_b = TestA()
obj_a.attr = 42
print(obj_b.attr)
>>> 结果：1
1
2
3
4
5
6
7
8
9
A2：不会影响。
Q3：类属性实例属性具有相同的名称，那么.后面引用的将会是什么？
class TestA():
attr =1
def __init__(self):
self.attr = 24
obj_a = TestA()
print(obj_a.attr)
>>> 结果：24
1
2
3
4
5
6
7
8
9
10
A3：类属性赋值后的值。
总结：如图所示，Python 中属性的引用机制是自外而内的，当你创建了一个实例之后，准备开始引用属性，这时候编译器会先搜索该实例是否拥有该属性，如果有，则引用；如果没有，将搜索这个实例所属的类是否有这个属性，如果有，则引用，没有那就只能报错了。
六、使用第三方库
6.1 安装自己的库
我们一般使用 pip 来进行第三方库的安装，那么自己的库要怎么安装呢？当然可以把自己的库提交到 pip 上，但是还要添加一定量的代码和必要的文件才行，在这里我们使用一个更简单的方法：
1. 找到你的 Python 安装目录，找到下面的 site-packages 文件夹；
2. 记住你的文件名，因为它将作为引用时的名称，然后将你写的 py 文件放进去。
这个文件夹应该有你所安装的所有第三方库。如果你并不清楚你的安装路径，可以尝试使用如下方式搞清楚它究竟在哪里：
import sys
print(sys.path)
1
2
打印出来的会是一个列表，列表中的第四个将是你的库安装路径所在，因此你也可以直接这么做：
import sys
print(sys.path[3])
1
2
6.2 安装第三方库
令人惊叹的第三方库
如果用手机来比喻编程语言，那么 Python 是一款智能机。正如含量的手机应用出现在 iOS、Android 平台上，同样有各种各样的第三方库为 Python 开发者提供了极大的便利。
当你想要搭建网站时，可以选择功能全面的 Django、轻量的 Flask 等 web 框架；当你想写一个小游戏的时候，可以使用 PyGame 框架；当你想做一个 爬虫时，可以使用 Scrapy 框架；当你想做数据统计分析时，可以使用 Pandas 数据框架……这么多丰富的资源可以帮助我们高效快捷地做到想做的事，就不需要再重复造轮子了。
那么如何根据自己的需求找到相应的库呢？可以到 awesome-python.com 这个网站上按照分类去寻找，上面收录了比较全的第三方库。比如想要找爬出方面的库时，查看 Web Crawling 这个分类，就能看到相应的第三方库的网站与简介，可以进入库的网站查看更详细的介绍，并确认这个库支持的是 Python 2 还是 Python 3，不过绝大多数常用库已经都支持了这两者。另外也可以直接通过搜索引擎寻找。
安装第三方库方式：
①最简单的方式：在 PyCharm 中安装
在 PyCharm 的菜单中选择：File –> Default Setting
搜索 project interpreter，选择当前 python 版本，点击“+”添加库
输入库的名称，勾选，并点击 Install Package
在安装成功后， PyCharm 会有成功提示。也可以在 project interpreter 这个界面中查看安装了哪些库，点“-”号就可以卸载不再需要的库。
②最直接的方式：在终端/命令行中安装
PyPI（Python Package Index）是 Python 官方的第三方库的仓库，PyPI 推荐使用 pip 包管理器来下载第三方库。
安装 pip
在 Python 3.4 之后，安装好 Python 环境就可以直接支持 pip，你可以在终端/命令行里输入这句检查一下：pip --version （前提电脑 path 路径已经配置好了），如果显示 pip 版本，就说明 pip 已经成功安装了；如果发现没有安装，则根据不同系统如下方式安装：
windows 用户如何安装
Mac 用户如何安装
Linux 用户如何安装
使用 pip 安装库
在安装好了 pip 之后，以后安装库，只需要在命令行里面输入：pip3 install PackageName（注：如果你想要安装到 Python 2 中，需要把 pip3 换成 pip）。补充：
python3中的pip和pip3
安装python3后使用pip和pip3的区别
如果你安装了 Python 2 和 3 两种版本，可能会遇到安装目录的问题，可以换成：python3 -m pip install PackageName （注：如果你想安装到 Python2 中，需要把 Python3 换成 Python）
如果遇到权限问题，可以输入：sudo pip install PackageName
安装成功之后会提示：Successfully insyalled PackageName
一些常用的 pip 指令：
# pip 使用格式：pip <command> [options] package_name
pip install package_name==1.9.2 # 安装指定版本的包
pip install --upgrade package_name # 更新指定的包
pip uninstall package_name # 卸载指定的包
pip show package_name # 查看所安装包的详细信息
pip list # 查看所有安装的包
pip --help # 查看帮助
1
2
3
4
5
6
7
8
9
10
补充：如果下载很慢，可以考虑更改 pip 下载源。国内镜像有：
# 国内常用的镜像
http://pypi.douban.com/simple/ # 豆瓣
http://mirrors.aliyun.com/pypi/simple/ # 阿里
https://pypi.tuna.tsinghua.edu.cn/simple # 清华
http://pypi.mirrors.ustc.edu.cn/simple/ # 中国科学技术大学
http://pypi.hustunique.com/simple/ # 华中理工大学
1
2
3
4
5
6
更改方法：
临时使用，添加 -i 或 --index 参数：pip install -i http://pypi.douban.com/simple/ flask
Linux下永久生效的配置方法
cd $HOME
mkdir .pip
cd .pip
sudo vim pip.conf
# 在里面添加，trusted-host 选项为了避免麻烦是必须的，否则使用的时候会提示不受信任
[global]
index-url=https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host=pypi.tuna.tsinghua.edu.cn
disable-pip-version-check=true
timeout = 6000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Windows 下永久生效的配置方法
# a、进入如下目录（没有此目录或文件就自己创建下）
C:\Users\username\AppData\Local\pip
或
C:\Users\username\pip
# b、创建 “pip.ini” 文件（注意：以UTF-8 无BOM格式编码），添加如下内容
[global]
index-url=https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host=pypi.tuna.tsinghua.edu.cn
disable-pip-version-check=true
timeout = 6000
801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
