本文是汇总帖，后面发了会陆续更新到这里来。

 

 

1900页Python系列PPT分享一：基础知识（106页）

1900页Python系列PPT分享二：Python序列（列表、元组、字典、集合）（154页）

1900页Python系列PPT分享三：选择与循环结构语法及案例（96页）

1900页Python系列PPT分享四：字符串与正则表达式（109页）

1900页Python系列PPT分享五：函数设计与应用（134页）

1900页Python系列PPT分享六：面向对象程序设计（86页）

1900页Python系列PPT分享七：文件操作（132页）

1900页Python系列PPT分享八：异常处理结构与程序调试、测试（70页）

报告PPT（163页）：基于Python语言的课程群建设探讨与实践

报告PPT（123页）：Python编程基础精要

2000页Python系列PPT分享九：（GUI编程）（122页）

Python实验项目1例：使用进程池统计指定范围内素数的个数

（PPT）Python程序设计课程教学内容组织与教学方法实践

 

非计算机专业《Python程序设计基础》教学参考大纲

非计算机专业《Python程序设计基础》教学参考大纲

计算机相关专业“Python程序设计”教学大纲（参考）

《Python程序设计》实验指导书（30个实验）

《Python程序设计基础与应用》课后习题答案

《Python程序设计基础（第2版）》习题答案

 

PPT内容

这是Python经典入门教程ppt，包括了起源，特性，用途，不足，如何学习等内容，欢迎点击下载。

Python——新语言，新平台

杨帆

大纲

起源

特性

用途

不足

如何学习

起源

作者 ：Guido Van Rossum (GvR)

http://www.python.org/~guido/

名字的读法

"仁慈的终身独裁者”

Benevolent Dictator For Life

他持续关注 Python 的开发进程，指导支持

Python开源社区的活动，并在必要的时刻做出决定。

目前在 Google 工作

得名

"1989年12月，我在寻找一门"课余”编程项目来打发圣诞节前后的时间。我的办公室会关门，但我有一台家用电脑，而且没有太多其它东西。我决定为当时我正构思的一个新的脚本语言写一个解释器，它是 ABC 语言的后代，对 UNIX / C 程序员会有吸引力。作为一个略微有些无关想法的人，和一个蒙提·派森（Monty Python）的飞行马戏团的狂热爱好者，我选择了 Python 作为项目的标题。”

每个人都会

Computer Programming for Everybody

1999年，Guido向DARPA 阐述Python语言的特性：

简单、直观、强大

开源，以便任何人都可以为它做贡献

代码像纯英语那样容易理解

适用于短期开发的日常任务

这些想法中的一些已经成为现实。Python 已经成为一门流行的

编程语言，尤其是在互联网环境下。

大纲

起源

特性

用途

不足

如何学习

特性

交互式命令行(Interactive console)

不只是脚本

强大易用的标准库

胶水语言(glue language)

收放自如(scalability)

不要括号

vs Perl

vs Ruby

交互式命令行(Interactive console)

Python可以单步直译运行。运行Python解释器进入交互式

命令行的环境，你可以在提示符号>>>旁输入代码，按Enter键

输出结果：

>>> print("Hello, Python!")

Hello, Python!

有点像Shell 脚本的执行方式。

不只是脚本

原因是"脚本语言”泛指仅作简单编程任务的语言，

如Linux shell script、JavaScript等，它们只能处理简单的任务

而Python是面向对象编程（OOP)的，支持异常处理和类型检查

Python的支持者较喜欢称它为一种高阶动态编程语言

强大易用的标准库

核心库不超过10Mb

Html、Xml解析：BeautifulSoup, Expat

字符串处理：字典、数组切片、正则表达式 re

单元测试： PyUnit

代码版本控制： PySVN

网络访问： urllib2

图形模块： Tkinter、PyTCL、WxPython

串行化、多线程等

扩展标准库十分容易

胶水语言(glue language)

Python经常用作将不同语言编写的程序"粘”在一起的胶水语言。

Google内部的很多项目使用C++编写性能要求极高的部分，

然后用Python调用相应的模块。

C/C++:

Boost.Python使得 Python 和 C++ 的类库能互相调用（.pyc）

Java:

Jython 是用Java实现的Python，可同时使用二者的类库

.NET:

IronPython是Python在.NET平台上的版本。

收放自如(scalability)

Python内建的数据结构（variable, list 和 dict）以及对多线程

分布式操作的支持，使得程序可以用相同的代码处理不同规模

的数据，以及并发的用户需求。

Google App Engine

http://code.google.com/intl/zh-CN/appengine/

不要括号

Python使用缩进而不是括号来进行代码段标识，减少了视觉上

的混乱，并且使程序变短，从而提高了程序的可读性。

vs. Perl

Perl是另一种广泛使用(滥用)的动态高级语言,

经常被用来与Python 比较。

正则表达式的典范

催生了CGI、PHP

黑客最喜爱的语言

Larry Wall Perl语言之父，语言学家

www.wall.org/~larry/

两届国际C语言混乱代码大赛（IOCCC） 的冠军

第一届自由软件奖得主

程序员的三大美德

懒惰：能让人尽量减少总能量支出的美德。它使你写出节省脑力、可以重用的代码；也督促你为程序写注释和文档，那样你就不用回答各种问题。所以它是程序员的第一大美德。所以有了这本书。参见下两条。

不耐烦：当电脑想偷懒时你爆发的怒气. 它使你写的代码能主动预测、而非被动满足用户需求，至少装作是这样。所以它是程序员的第二大美德。 参见懒惰和傲慢。

傲慢：自傲到人神共愤的程度，也是一种品质，能使你编写(维护)的程序让人无可指摘。所以它是程序员的第三大美德. 参见前两条。

观点

Perl之父Larry Wall:

"做一件事有很多种方法”

Python资深开发者Tim Peters：

"做一件事，应该有一种最直观的方法，而且最好只有一种。”

Python之父Guido Van Rossum：

"做一件事情只有一种方法”

vs. Ruby

Ruby：比Python更年轻的动态语言

完全面向对象

支持正则表达式

整合了多种语言的优势

Ruby on Rails 网站快速开发工具

松本行弘 ("Matz”)

"不要重复自己”

国籍？

大纲

起源

特性

用途

不足

如何学习

用途

脚本程序

大型程序的原型开发

科学计算

网络应用

计算机图形编程

知名的Python应用

Zope：www.zope.com

一个应用程序服务器，具有内容管理、团队开发、XML、面向对象、SOAP接口等一系先进特性，开源。

Gadfly：http://www.chordate.com/gadfly.html

一个用Python写的面向对象关系型数据库，具有小巧、快速、可移植性好的

特点，具有大部分SQL语言特性。开源。

Wallbase: http://wallbase.net

Python编写的图片站点。

uTorrent : http://www.utorrent.com

BitTorrent下载软件，主程序仅2Mb，支持ipv6地址解析。开源。

Torchlight: torchlight.perfectworld.com

Python编写的大型3D游戏，原Blizzard公司人员制作发行，开源。

Google Apps Engine

"Google App Engine 可让您在 Google 的基础架构上运行您的网络

应用程序。App Engine 应用程序易于构建和维护，并可根据您的访

问量和数据存储需要的增长轻松扩展。使用 Google App Engine，

将不再需要维护服务器：您只需上传您的应用程序，它便可立即为您的用户提供服务。”

Python 为GAE的数据存储区、Google 帐户、网址抓取和电子邮件服务提供了丰富的 Python API。GAE还提供了一个称为 webapp 的简单 Python 网络应用程序框架，从而可以轻松开始构建应用程序。

GAE的主要服务

动态网络服务，提供对常用网络技术的完全支持

持久存储空间，支持查询、分类和事务

自动扩展和负载平衡

用户身份验证和使用 Google 帐户发送电子邮件的 API

一套在本地模拟 GAE的开发环境

用于在指定时间和定期触发事件的计划任务

两个例子

"集体智慧编程”

根据品味相似度进行电影推荐

(第2章）

家族旅行问题的最优化算法

(第5章)

根据品味相似度进行电影推荐

基本思路：

从一大群人中找出与我们品味相近的一小群人，对这些人所喜爱的其他内容进行考查，并把它们组合起来创建一个经过排名的推荐列表。（协作过滤 Collaborative Filtering)

步骤：

1.搜集偏好

2.寻找相似的用户

3.推荐电影

搜集偏好

首先找到一种表示不同人及其偏好的电影的方法。

可以使用人对几部电影的评分来刻画他们的偏好，评分从1到5，

分数越高，表示某人对该电影越喜欢。

如何建立这种从人到电影的对应关系？

Python中有一个很简单的方法来表示这种数据结构：

使用嵌套的字典。

搜集偏好

创建名为recommandations.py 的数据文件：

critics={

'Lisa Rose': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5,

'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5,

'The Night Listener': 3.0},

'Gene Seymour': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5,

'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0,

'You, Me and Dupree': 3.5}

'Toby': {'Snakes on a Plane':4.5,'You, Me and Dupree':1.0,'Superman Returns':4.0}}

}

搜集偏好

我们可以使用交互控制台对字典的数据进行查询和修改：

>> from recommendations import critics

>> critics['Lisa Rose']['Lady in the Water']

2.5

>> critics['Toby']['Snakes on a Plane']=4.5

>> critics['Toby']

{'Snakes on a Plane':4.5,'You, Me and Dupree':1.0}

寻找相似的用户

收集了人们的偏好数据后，我们需要方法来计算某两个人电影品味的相似度。

有两种基本的方法可以实现这个目的：

欧几里得距离

皮尔逊相关度

欧几里得距离评价

以二维空间中的情形为例：设坐标轴

为人们都评价过的两部电影，然后将

参与评价的人根据他们对这两部电影

的评分绘制到图上，并考察他们彼此

间的距离，如图：

图中的点距离越近，表明两个人的偏好越接近。推广到多维

向量空间，欧几里得法可表示为：计算每一轴上两点的差值求

平方，再将各轴相加，最后取平方根。

欧几里得距离评价

如计算Toby和LaSalle的距离：

>> from math import sqrt

>> sqrt(pow(5-4,2)+pow(4-1,2))

3.1622776601683795

为了给偏好接近的情况给出较大的值，可取

该值的倒数，并+1避免除数为0：

>> 1/(1+sqrt(pow(5-4,2)+pow(4-1,2)))

0.2402530733520421

欧几里得距离评价

使用这种方法 构造出如下相似度函数:

def sim_distance(prefs,person1,person2):

# 得到共同的电影

si={}

for item in prefs[person1]:

if item in prefs[person2]:

si[item]=1

# 如果没有共同的电影则返回0

if len(si)==0: return 0

#计算欧几里得距离，返回相似度

Sum_of_squares=sum([pow(prefs[person1][item]-prefs[person2][item],2)

for item in prefs[person1] if item in prefs[person2]])

return 1/(1+sum_of_squares)

皮尔逊相关度

皮尔逊相关系数是一种更复杂的方法，它通过计算两组数据

与某一直线拟合的程度来判断它们的相似程度。

该方法有助于克服所谓的"夸大评价”现象对结果的影响。

右图中，虽然Jack对电影的评价

比Lisa更为极端(更容易给出高分

和低分）,但这个坐标系中的点都

相当靠近拟合曲线(图中虚线)，可

以说两人的品味较为相近。

皮尔逊相关度

使用如下函数计算皮尔逊相关度，该函数返回一个-1到1的值：

def sim_pearson(prefs,p1,p2):

# 得到共同评价的电影

si={}

for item in prefs[p1]:

if item in prefs[p2]: si[item]=1

# 如果没有共同评价的电影，返回0

if len(si)==0: return 0

# 将两人的偏好相加

sum1=sum([prefs[p1][it] for it in si])

sum2=sum([prefs[p2][it] for it in si])

皮尔逊相关度

# 计算平方和

sum1Sq=sum([pow(prefs[p1][it],2) for it in si])

sum2Sq=sum([pow(prefs[p2][it],2) for it in si])

# 计算对应项的乘积和

pSum=sum([prefs[p1][it]*prefs[p2][it] for it in si])

# 计算皮尔逊相关度

num=pSum-(sum1*sum2/n)

den=sqrt((sum1Sq-pow(sum1,2)/n)*(sum2Sq-pow(sum2,2)/n))

if den==0: return 0

r=num/den

return r

皮尔逊相关度

在交互式控制台中使用上述两种计算方法：

>>> reload(recommendations)

>>> recommendations.sim_distance(recommendations.critics,

... 'Lisa Rose','Gene Seymour')

0.148148148148

>>> recommendations.sim_pearson(recommendations.critics,

... 'Lisa Rose','Gene Seymour')

0.396059017191

给评论者打分

有了对两个人进行比较的函数，下面就可以找出与某人品味

最接近的人了，进而，可以根据这些人的喜好来推荐电影。

def topMatches(prefs,person,n=5,similarity=sim_pearson):

scores=[(similarity(prefs,person,other),other)

for other in prefs if other!=person]

# 对list排序，相似度最高的人排在最前

scores.sort( )

scores.reverse( )

return scores[0:n]

在交互控制台中使用该函数：

>> recommendations.topMatches(recommendations.critics,'Toby',n=3)

[(0.99124070716192991, 'Lisa Rose'), (0.92447345164190486, 'Mick LaSalle'),

(0.89340514744156474, 'Claudia Puig')]

推荐电影

我们固然可以选择只看那些和我们品味相近的人推荐的电影，

但这样做太武断，也许某部电影大家普遍都觉得不错，而恰

好与我们最相近的那个人没有看过。

所以，我们需要一种对推荐人进行加权的推荐，如下表：

给Toby的电影推荐表

推荐电影

S.X打头的列是经过加权的电影评分。

下面的代码给出了上述过程的具体实现：

def getRecommendations(prefs,person,similarity=sim_pearson):

totals={}

simSums={}

for other in prefs:

# 不和自己比

if other==person: continue

sim=similarity(prefs,person,other)

# 忽略小于等于0的评分

if sim<=0: continue

for item in prefs[other]:

推荐电影

# 只计算我没看过的电影

if item not in prefs[person] or prefs[person][item]==0:

# 相似度乘以得分

totals.setdefault(item,0)

totals[item]+=prefs[other][item]*sim

# 相似度求和

simSums.setdefault(item,0)

simSums[item]+=sim

# 对结果进行归一化

rankings=[(total/simSums[item],item) for item,total in totals.items( )]

# 排序并返回结果

rankings.sort( )

rankings.reverse( )

return rankings

推荐电影

然后就可以看结果了：

>>> reload(recommendations)

>>> recommendations.getRecommendations(recommendations.critics,'Toby')

[(3.3477895267131013, 'The Night Listener'), (2.8325499182641614, 'Lady in the

Water'), (2.5309807037655645, 'Just My Luck')]

>>> recommendations.getRecommendations(recommendations.critics,'Toby',

... similarity=recommendations.sim_distance)

[(3.5002478401415877, 'The Night Listener'), (2.7561242939959363, 'Lady in the

Water'), (2.4619884860743739, 'Just My Luck')]

结果显示，人们为Toby推荐了三部电影，而且用两种相似

度地算方法得到的列表是一样的 。

总结

到此为止，我们建立了一个完整的推荐系统，它适用于任何的

商品推荐以及基于相似度的数据关系挖掘。。

而这一切在Python中，仅仅是建立一个涉及人、商品以及评价

值的字典，然后根据某些相似度算法得出的人与人的相似度，

就可以进行推荐了。

家族旅行问题的最优化算法

问题描述：

Glass一家住在美国不同的地方。他们希望在纽约相聚，在同一天从各地坐飞机到纽约，几天后再一起离开。每天有许多往返的航班，起飞时间、价格以及飞行时间都不相同。

现在需要找到一种好的日程安排，使得大家的旅行花费尽可能少、等待亲友的时间尽可能短、乘坐飞机的时间尽可能短。

建立文件optimization.py,加入如下代码：

people = [('Seymour','BOS'),('Franny','DAL'),('Zooey','CAK'),('Walt','MIA'),…

('Buddy','ORD'),('Les','OMA')]

#目的地：纽约LaGuardia机场

destination='LGA'

问题分析

首先要找到一种通用的表示日程安排方案的方法。

然后，为了描述某种方案的好坏，需要定义某种函数。在优化

问题中，这个函数叫做代价函数(cost funciton)。一个方案越

好，它的代价函数值越小。这样找最优方案的问题转化为找代

价函数值最小的方案的问题。

最后设法找出具有最小代价函数值的方案，完成优化过程。

导入数据

从网址http://kiwitobes.com/optimize/schedule.txt

可以下载到航班数据，格式如下：

LGA,MIA,20:27,23:42,169

MIA,LGA,19:53,22:21,173

LGA,BOS,6:39,8:09,86

分别是起点、终点、起飞时间、到达时间和机票价格。

将数据载入到以起止点为键、以航班详情为值的字典中：

flights={}

for line in file('schedule.txt'):

origin,dest,depart,arrive,price=line.strip( ).split(',')

flights.setdefault((origin,dest),[])

# 将航班详情加入到航班字典的值中

flights[(origin,dest)].append((depart,arrive,int(price)))

描述方案

如何描述各种方案呢？一个通用的方法是使用数字列表，

它使得之后描述的优化算法并不依赖于具体的问题。

本例中，用数字表示某人乘坐当天的第几趟航班，0代表

第一趟，1代表第二趟，以此类推。

由于每个人都要选择往和返两趟班机，所以列表的总长是

人数的两倍。

例如：[1,4,3,2,7,3,6,3,2,4,5,3]

该方案表示Seymour坐第2趟航班去纽约，坐第5趟航班回波士顿

Franny坐第4趟航班去纽约，坐第3趟回达拉斯。

代价函数

代价函数的选取是优化算法的重要环节。

本例中，可以综合考虑如下因素来构造代价函数：

价格： 所有航班的总票价

旅行时间：所有人在飞机上度过的总时间

等待时间： 在机场等待其他成员到达的总时间

出发时间： 早晨太早起飞的航班有额外的代价，因为旅行者睡眠不足

汽车租用时间： 如果集体租车，那么他们最好在某个时间前将车归还，否则会多付租金。

代价函数

限于篇幅，就不给出代价函数的全部代码了，使用方法如下：

>>> reload(optimization)

>>> optimization.schedulecost(s)

5285

有了代价函数，下面就是找到具有最小函数值的方案了。

在这个例子中有16个航班、每个航班都有9种可能，所有的

可能数为916,约3000亿，所以穷举是不现实的。

下面使用两种方法实现优化：

随机优化

爬山法

随机优化

随机生成一些方案，找出其中最好的方案。

def randomoptimize(domain,costf):

best=999999999

bestr=None

for i in range(1000):

#随机生成一个方案

r=[random.randint(domain[i][0],domain[i][1])

for i in range(len(domain))]

# 计算代价

cost=costf(r)

# 与当前最优方案的代价比较

if cost

best=cost

bestr=r

return r

爬山法

随机优化的不足在于，没有充分利用已有的优解。

爬山法则以一个随机解开始，然

后在邻近的解集中寻找更好的解，

这类似于从斜坡上往下走，如图。

下面的代码片段描述了如何获取已有解的邻近解:

neighbors=[]

for j in range(len(domain)):

# 两个方向

if sol[j]>domain[j][0]:

neighbors.append(sol[0:j]+[sol[j]+1]+sol[j+1:])

if sol[j]

neighbors.append(sol[0:j]+[sol[j]-1]+sol[j+1:])

爬山法

爬山法虽然利用了已经找到的

优解，但它很容易陷入所谓的

局部最优解，而找不到全局最

优解。

一种改进是随机重复爬山法，

即从多个随机点开始运行爬山法若干次，以此希望有一个解能

逼近全局最小。

此外，模拟退火算法和遗传算法也能避免陷入局部最小值。

查看结果

在交互控制台中输入如下代码，查看优化结果：

>>> reload(optimization)

>>> domain=[(0,8)]*(len(optimization.people)*2)

>>> s=optimization.randomoptimize(domain,optimization.schedulecost)

>>> optimization.schedulecost(s)

3328

>>> optimization.printschedule(s)

Seymour Boston 12:34-15:02 $109 12:08-14:05 $142

Franny Dallas 12:19-15:25 $342 9:49-13:51 $229

Zooey Akron 9:15-12:14 $247 15:50-18:45 $243

Walt Miami 15:34-18:11 $326 14:08-16:09 $232

Buddy Chicago 14:22-16:32 $126 15:04-17:23 $189

Les Omaha 15:03-16:42 $135 6:19- 8:13 $239

查看结果

>>> s=optimization.hillclimb(domain,optimization.schedulecost)

>>> optimization.schedulecost(s)

3063

>>> optimization.printschedule(s)

Seymour BOS 12:34-15:02 $109 10:33-12:03 $ 74

Franny DAL 10:30-14:57 $290 10:51-14:16 $256

Zooey CAK 10:53-13:36 $189 10:32-13:16 $139

Walt MIA 11:28-14:40 $248 12:37-15:05 $170

Buddy ORD 12:44-14:17 $134 10:33-13:11 $132

Les OMA 11:08-13:07 $175 18:25-20:34 $205

总结

在本例中，首先使用Python的列表对不同的方案进行了数学

建模，然后根据一些指标建立了代价函数，最后使用两种方法

实现了优化过程。

在整个过程中，Python的简单易用让我们能够集中精力解决

实际的问题。而无需过多关注编程本身。

此外，Python的交互控制台使得编程与调试过程变得自然顺畅。

大纲

起源

特性

用途

不足

如何学习

硬币的另一面

限制Python发展的因素

缺乏预包装的解决方案

数据库访问层的局限性

文档差距

缺乏GUI和团队协作工具

限制Python发展的因素

缺乏预包装的解决方案

PHP 在企业软件领域赢得了辉煌的成功，主要原因就在于其广泛实用的产品门类，比如讨论板、聊天服务器和分组日历以及即时消息系统等。相比之下，Python提供的解决方案就少多了。Python语言的分发版中确实包含了一些扩展的类库，越来越多的程序员也在致力于开发等价PHP的Python工具，但是考虑到市场的时间紧迫性，而且你所面临的问题已经有现成的PHP解决方案可以对付，那么PHP自然会成为你的首选。

限制Python发展的因素

数据库访问层的局限性相比现有的成熟技术，比如ODBC和JDBC，Python的数据库访问层看起来就过于原始了。虽然这一方面也在发生变化，但是，开发部门需要平滑地接合现有的复杂遗留数据，同时需要快速的SQL数据库访问，所有这一些使其在短时期内难以对Python表现出什么太大的兴趣。

限制Python发展的因素

文档差距相比其对手语言，比如Perl、Java，在某种程度上再算上PHP，Python确实深受文档缺乏之苦，Python没有广泛、易于获得的文档和图书。市面上冠以PHP标题的图书数量几乎是Python的两倍多；而Perl就更多了，有400多种。Python的在线文档倒还组织得比较好，但是这些文档几乎全是些参考资料。幸而Python相当容易的学习曲线减轻了对图书资料的过多需要。

限制Python发展的因素

缺乏GUI和团队协作工具给Python应用程序创建图形用户界面未必复杂。Python分发版本随带的Tk就是Python开发人员最常用的工具。但是Tk缺乏可访问、易用的GUI工具。相比GUI工具的缺乏更要命的是Python几乎没有支持团队开发的协议工具。 Java在这些工具领域可谓相当丰富。在企业软件开发市场上，这一缺陷简直可视为致命的要害。没有这类工具要让很多程序员共同开发同一项目几乎是不可能的。Python利用其模块化和命名空间分析等特性减轻了这一方面的需求，这些特性可以让多个程序员开发项目时不可能发生代码冲突的情况。但是，这同样改变不了其协同性能缺乏的严重性。

大纲

起源

特性

用途

不足

如何学习

如何学习

"Don't learn. Just use it.”

"Hello world”

天气预报RSS 歌词

搜索引擎

版本

CPython: www.python.org

主流：2.5-2.7

最新：3.0 不向下兼容

ActivePython:

Windows 下的Python，文档和库较全

IronPython： http://ironpython.codeplex.com/

与.NET集成较好

可使用CPython的类库

NumPy，Python(x,y)：

对科学计算进行了优化的Python版本

工具

IDLE：CPython自带

PythonWin：ActivePython自带

Notepad++：查找/替换 tab和空格 语法高亮

Ulipad: 转到函数定义 Code Snippets

Eclipse：Java

Komodo Editor/IDE

Vim/Emacs: Linux下流行的IDE

资料

"集体智慧编程”

"简明Python教程”

"Python Cookbook”

"IronPython In Action”

"Google it.”

THANKS

www.peraglobal.com.cn

相关PPT

科多大数据――数据分析python简介ppt：这是科多大数据――数据分析python简介ppt，包括了Python 简介，环境安装，代码规范，编码格式等内容，欢迎点击下载。

Python培训ppt课件：这是Python培训ppt课件下载，主要介绍了快速开始简单语句；Python的数据类型；Python函数；内置特殊函数；Python脚本与模块；简单的网络通信及即时聊天；总结，欢迎点击下载。

pythonchapter2 ppt：这是pythonchapter2 ppt，包括了程序设计需要系统化的方法，软件开发过程，需求分析，制定程序规格，设计，实现，测试与排错，维护等内容，欢迎点击下载。

《Python经典入门教程ppt》是由用户Dream lover于2018-05-15上传，属于培训教程PPT。

主要记录在看网课过程中的ppt重点内容和实例代码

2

解释型语言，开发过程中没有编译环节

交互式语言

一切皆对象，面向对象的语言

3

1. IDLE自带简单开发环境
2. 交互式命令行程序
3. manuals官方技术文档
4. module已安装模块文档

5

print(520)
print('helloworld')
print(3+2)

#将数据输出到文件中,1.路径存在2.使用file=
fp=open('D:/text.txt','a+')#a+：如果文件不存在就创建，存在就在文件内容的后面继续追加
print('helloworld',file=fp)
fp.close()

#不进行换行输出（输出内容在一行当中）
print('hello','world','pyhton')

6 

print('hello\nworld')
print('hello\tworld')#四个字符一组
print('hello000\tworld')
print('hello\rworld\rfhd')#进行覆盖
print('hello\bworld')#退格，o没了

print('http:\\\www.com')
print('老师说:\'大家好\'')

#原字符，不希望字符串中的转义字符起作用，在字符串前加上r或者R
#注意事项，最后一个字符不能是反斜杠
print(r'hello\nworld')

8

import keyword
print(keyword.kwlist)#查看保留字

9

 10

变量多次赋值之后，变量名会指向新的空间

12

二进制0b开头

八进制0o开头

十六进制0x开头

注释快捷键ctrl+/

13

 15

 16

 18

19 

 21

 算数运算符

print(1/3)#除法运算0.3333333333333333
print(1//3)#整除运算0
print(2**2)#幂运算符：2的2次方
print(2**3)#2的3次方

print(9%-4)#-3

22

#支持解包赋值
a,b,c=20,30,40
print(a,b,c)

a=b=c=10#链式赋值，abc的id一样
print(a,id(a))#10 1627767990864
print(b,id(b)#10 1627767990864
print(c,id(c))#10 1627767990864

#交换两个变量的值
a,b=10,20
print('before:',a,b)
a,b=b,a
print('after:',a,b)

23

一个变量由三部分组成:标识，类型，值

== 比较的是值

is/is not 比较的是对象的标识id

a=10
b=10
print(a==b)#true
print(a is b)#true

24

布尔运算符 in / not in

s='helloworld'
print('w' in s)#true
print('k' in s)#false
print('o' not in s)#false
print('p' not in s )#true

25

位运算：将数据转成二进制进行计算

左移位相当于乘以2，右移位相当于除以2 

26

 28

#以下对象的布尔值均是False
print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))#空字符串
print(bool(""))
print(bool([]))#空列表
print(bool(list()))
print(bool(()))#空元祖
print(bool(tuple()))
print(bool({}))#空字典
print(bool(dict()))
print(bool(set()))#空集合

其他对象的布尔值均为True 

 31

 32

 33

条件表达式

 34

PASS语句

35

 通常用作for循环遍历的对象

36 37

#4步循环法
#1.初始化变量
#2.条件判断
#3.条件执行体（循环体）
#4.改变变量

#初始化变量、条件判断的变量、改变的变量为同一个

#累加和
a=0
sum=0
while a<5:
    sum+=a
    a+=1
print('sum=',sum)

计算1-100之间的偶数和:

a=1
sum=0
while a<=100:
    if not bool(a%2):
        sum+=a
    a+=1
print('sum=',sum)

38

for item in 'PYTHON':
    print(item)

sum=0
for i in range(10):
    sum+=i
print('sum=',sum)

#如果在循环体中不需要使用到自定义变量，可将自定义变量写为"_"
for _ in range(5):
    print('人生苦短')

使用for循环计算1-100的偶数和：

sum=0
for i in range(0,101,2):
    sum+=i
print('sum=',sum)

39

输出100-999之间的水仙花数：

for i in range(100,1000):
    if ((i//100%10)**3+(i//10%10)**3+(i%10)**3)==i:
        print(i,'为水仙花数')

40

三次输入密码机会，判断正误：

for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='9999':
        print('right!')
        break
    else:
        print('wrong!')

#或者
a=0
while a<3:
    pwd=input('请输入密码：')
    if pwd=='9999':
        print('right')
        break
    else:
        print('wrong')
    a+=1

41

输出1-50之间所有5的倍数：

for i in range(1,51):
    if i%5!=0:
        continue
    print(i,'是5的倍数')

 42

 输入密码三次均不正确时提醒：

for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起，三次密码均输入错误')

a=0
while a<3:
    pwd=input('请输入密码：')
    if pwd =='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a+=1
else:
    print('对不起，三次密码均输入错误')

43

嵌套循环：循环结构中有嵌套了另外的完整的循环结构体，其中内层循环作为外层循环的循环体执行

打印乘法表：

for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j,end='\t')#不换行输出
    print()

44

break和continue只控制本层循环 

for i in range(5):
    for j in range(1,11):
        if j%2==0:
            break
        print(j,end='\t')

#输出结果：1  1	1	1	1	

for i in range(5):
    for j in range(1,11):
        if j%2==0:
            continue
        print(j,end='\t')

#输出结果：
1	3	5	7	9	
1	3	5	7	9	
1	3	5	7	9	
1	3	5	7	9	
1	3	5	7	9	

45

46

lst=['hello','world',98]
lst2=list(['hello','world',98])

 47

 48 49

获取索引： 

lst=['hello','world',98,'hello']
print(lst.index('hello'))

#print(lst.index('sdj'))
#ValueError: 'sdj' is not in list

print(lst.index('world',1,3))

 获取单个元素：

lst=['hello','world',98,'hello','world',847]
print(lst[2])
print(lst[-4])
# print(lst[10])  IndexError: list index out of range

50

lst=[10,20,30,40,50,60,70,80]
#start=1,stop=6,step=1
print(lst[1:6:1])#[20, 30, 40, 50, 60]

print('原列表：',id(lst))
lst2=lst[1:6:1]
print('切片后列表：',id(lst2))
# 原列表： 1854183981504
# 切片后列表： 1854183978304

print(lst[1:6:])
print(lst[1:6])
# [20, 30, 40, 50, 60]
# [20, 30, 40, 50, 60]

print(lst[1:6:2])
# [20, 40, 60]
print(lst[:6:2])
# [10, 30, 50]
print(lst[1::2])
# [20, 40, 60, 80]

print(lst[::-1])
# [80, 70, 60, 50, 40, 30, 20, 10]
print(lst[7::-1])
# [80, 70, 60, 50, 40, 30, 20, 10]
print(lst[6:0:-2])
# [70, 50, 30]

51

lst=[10,20,'python','hello']
print(10 in lst)
print(100 in lst)
print(10 not in lst)
print(100 not in lst)
print('python' in lst)
print('Python' in lst)

for item in lst:
    print(item)

52 

增加后没有创建新的列表对象，标识没有发生更改

lst=[10,20,30]
print('添加元素之前',lst)
print('添加元素之前',id(lst))
lst.append(100)
print('添加元素之后',lst)
print('添加元素之后',id(lst))
# 添加元素之前 [10, 20, 30]
# 添加元素之前 2826758993216
# 添加元素之后 [10, 20, 30, 100]
# 添加元素之后 2826758993216
lst2=['hello','world']
lst.append(lst2)
print('添加元素之后',lst)
lst.extend(lst2)
print('添加元素之后',lst)
# 添加元素之后 [10, 20, 30, 100, ['hello', 'world']]将lst2作为一个元素添加到列表的末尾
# 添加元素之后 [10, 20, 30, 100, ['hello', 'world'], 'hello', 'world']
lst.insert(1,90)
print('添加元素之后',lst)
#添加元素之后 [10, 90, 20, 30, 100, ['hello', 'world'], 'hello', 'world']
lst3=[True,False,'hello']
#在任意位置添加多个,切掉之前的
lst=[1,2,3]
print('添加元素之前',lst)
print('添加元素之前',id(lst))
lst[1:]=lst3
print('添加元素之后',lst)
print('添加元素之后',id(lst))
# 添加元素之前 [1, 2, 3]
# 添加元素之前 2514633176384
# 添加元素之后 [1, True, False, 'hello']
# 添加元素之后 2514633176384

53

lst=[0,1,2,3,4,5,6]
new_list=lst[1:3]
print('原列表',lst)
print('原列表id',id(lst))
print('切片赋值后列表',new_list)
print('切片赋值后列表id',id(new_list))
# 原列表 [0, 1, 2, 3, 4, 5, 6]
# 原列表id 2609581603008
# 切片赋值后列表 [1, 2]
# 切片赋值后列表id 2609581603072

print('原列表',lst)
print('原列表id',id(lst))
lst[1:3]=[]#不产生新的列表对象，而是删除原列表中的内容
print('切片后列表',lst)
print('切片后列表id',id(lst))
# 原列表 [0, 1, 2, 3, 4, 5, 6]
# 原列表id 2609581603008
# 切片后列表 [0, 3, 4, 5, 6]
# 切片后列表id 2609581603008

#清楚列表中的所有元素
lst.clear()
print(lst)
#[]

#del语句将列表对象删除
del lst
#print(lst) NameError: name 'lst' is not defined

54

lst=[10,20,30,40,50]
print(lst)
lst[2]=100
print(lst)
# [10, 20, 30, 40, 50]
# [10, 20, 100, 40, 50]

lst[1:3]=[100,200,300,400,500]
print(lst)
#[10, 100, 200, 300, 400, 500, 40, 50]

55

lst=[10,46,90,20,60,30,50]
print(lst)
print(id(lst))
lst.sort()
print(lst)
print(id(lst))
# [10, 46, 90, 20, 60, 30, 50]
# 2519940612544
# [10, 20, 30, 46, 50, 60, 90]
# 2519940612544
#排序是在原列表上进行的
lst.sort(reverse=True)
print(lst)
lst.sort(reverse=False)
print(lst)
# [90, 60, 50, 46, 30, 20, 10]
# [10, 20, 30, 46, 50, 60, 90]

#使用内置函数sorted()对列表进行排序，将产生一个新的列表对象
lst=[10,46,90,20,60,30,50]
new_list=sorted(lst)
print(lst)
print(id(lst))
print(new_list)
print(id(new_list))
# [10, 46, 90, 20, 60, 30, 50]
# 2305728912192
# [10, 20, 30, 46, 50, 60, 90]
# 2305726038464
new_list=sorted(lst,reverse=True)
print(lst)
print(id(lst))
print(new_list)
print(id(new_list))
# [10, 46, 90, 20, 60, 30, 50]
# 1649469892160
# [90, 60, 50, 46, 30, 20, 10]
# 1649468728128

56

lst=[i for i in range(1,10)]
print(lst)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst=[i*i for i in range(1,10)]
print(lst)
# [1, 4, 9, 16, 25, 36, 49, 64, 81]

lst2=[i for i in range(2,11,2)]
lst3=[i*2 for i in range(1,6)]
print(lst2)
print(lst3)
# [2, 4, 6, 8, 10]
# [2, 4, 6, 8, 10]