Python学习总结

第一篇：Python学习总结

Python总结

目录

Python总结.....................................................................................................................1 前言.............................................................................................................................2

（一）如何学习Python.........................................................................................2

（二）一些Python免费课程推荐.......................................................................4

（三）Python爬虫需要哪些知识？....................................................................5

（四）Python爬虫进阶.........................................................................................8

（五）Python爬虫面试指南..............................................................................11

（六）推荐一些不错的Python博客.................................................................13

（七）Python如何进阶.......................................................................................14

（八）Python爬虫入门.......................................................................................16

（九）Python开发微信公众号..........................................................................20

（十）Python面试概念和代码..........................................................................24

（十一）Python书籍...........................................................................................34

前言

知乎：路人甲

微博：玩数据的路人甲 微信公众号：一个程序员的日常

在知乎分享已经有一年多了，之前一直有朋友说我的回答能整理成书籍了，一直偷懒没做，最近有空仔细整理了知乎上的回答和文章另外也添加了一些新的内容，完成了几本小小的电子书，这一本是有关于Python方面的。

还有另外几本包括我的一些数据分析方面的读书笔记、增长黑客的读书笔记、机器学习十大算法等等内容。将会在我的微信公众号：一个程序员的日常进行更新，同时也可以关注我的知乎账号：路人甲及时关注我的最新分享用数据讲故事。

（一）如何学习Python 学习Python大致可以分为以下几个阶段：

1.刚上手的时候肯定是先过一遍Python最基本的知识，比如说：变量、数据结构、语法等，基础过的很快，基本上1~2周时间就能过完了，我当时是在这儿看的基础：Python 简介 | 菜鸟教程 2.看完基础后，就是做一些小项目巩固基础，比方说：做一个终端计算器，如果实在找不到什么练手项目，可以在 Codecademy知乎专栏

5.Python库是开发者利器，用这些库你可以做很多很多东西，最常见的网络爬虫、自然语言处理、图像识别等等，这些领域都有很强大的Python库做支持，所以当你学了Python库之后，一定要第一时间进行练习。如何寻找自己需要的Python库呢？推荐我之前的一个回答：如何找到适合需求的 Python 库? 6.学习使用了这些Python库，此时的你应该是对Python十分满意，也十分激动能遇到这样的语言，就是这个时候不妨开始学习Python数据结构与算法，Python设计模式，这是你进一步学习的一个重要步骤：faif/python-patterns

7.当度过艰难的第六步，此时选择你要研究的方向，如果你想做后端开发，不妨研究研究Django，再往后，就是你自己自由发挥了。

（二）一些Python免费课程推荐 以下课程都为免费课程

1.python零基础相关

适用人群：Python零基础的初学者、Web开发程序员、运维人员、有志于从事互联网行业以及各领域应用Python的人群

 疯狂的Python：快速入门精讲  零基础入门学习Python  玩转Python语言  Python语言程序设计  程序设计入门

 可汗学院公开课：计算机科学  python 入门到精通  Python交互式编程入门的课程主页

 Python交互编程入门（第2部分）的课程主页

2.python web方向

Python Django 快速Web应用开发入门

3.python爬虫

Python实战：一周学会爬取网页

4.python数据分析方向 数据分析实战基础课程

（三）Python爬虫需要哪些知识？

要学会使用Python爬取网页信息无外乎以下几点内容：

1、要会Python

2、知道网页信息如何呈现

3、了解网页信息如何产生

4、学会如何提取网页信息

第一步Python是工具，所以你必须熟练掌握它，要掌握到什么程度呢？如果你只想写一写简单的爬虫，不要炫技不考虑爬虫效率，你只需要掌握：      数据类型和变量 字符串和编码 使用list和tuple 条件判断、循环 使用dict和set

你甚至不需要掌握函数、异步、多线程、多进程，当然如果想要提高自己小爬虫的爬虫效率，提高数据的精确性，那么记住最好的方式是去系统的学习一遍Python，去哪儿学习？Python教程

假设已经熟悉了最基础的Python知识，那么进入第二步：知道网页信息如何呈现？你首先要知道所需要抓取的数据是怎样的呈现的，就像是你要学做一幅画，在开始之前你要知道这幅画是用什么画出来的，铅笔还是水彩笔...可能种类是多样的，但是放到网页信息来说这儿只有两种呈现方式：

1、HTML（HTML 简介）

2、JSON（JSON 简介）HTML是用来描述网页的一种语言 JSON是一种轻量级的数据交换格式

假设你现在知道了数据是由HTML和JSON呈现出来的，那么我们紧接着第三步：数据怎么来？数据当然是从服务器反馈给你的，为什么要反馈给你？因为你发出了请求。“Hi~，服务器我要这个资源” “正在传输中...”

“已经收到HTML或者JSON格式的数据”

这个请求是什么请求？要搞清楚这一点你需要了解一下http的基础知识，更加精确来说你需要去了解GET和POST是什么，区别是什么。也许你可以看看这个：浅谈HTTP中Get与Post的区别博客园

很高兴你使用的是Python，那么你只需要去掌握好快速上手知乎专栏 知乎--Python学习路径及练手项目合集

（四）Python爬虫进阶

爬虫无非分为这几块：分析目标、下载页面、解析页面、存储内容，其中下载页面不提。1.分析目标

所谓分析就是首先你要知道你需要抓取的数据来自哪里？怎么来？普通的网站一个简单的POST或者GET请求，不加密不反爬，几行代码就能模拟出来，这是最基本的，进阶就是学会分析一些复杂的目标，比如说：淘宝、新浪微博登陆以及网易云的评论信息等等。

2.解析页面

解析页面主要是选择什么库或者那些库结合能使解析速度更快，可能你一开始你通过种种地方了解到了bs库，于是你对这个库很痴迷，以后只要写爬虫，总是先写上： importrequests

frombs4importBeautifulSoup 当然bs已经很优秀了，但是并不代表可以用正则表达式解析的页面还需要使用bs，也不代表使用lxml能解决的还要动用bs，所以这些解析库的速度是你在进阶时要考虑的问题。

3.存储内容

刚开始学爬虫，一般爬取的结果只是打印出来，最后把在终端输出的结果复制粘贴保存就好了；后来发现麻烦会用上xlwt/openpyxl/csv的把存储内容写入表格，再后来使用数据库sqlite/mysql/neo4j只要调用了库都很简单，当然这是入门。

进阶要开始学习如何选择合适的数据库，或者存储方式。当爬取的内容过千万的时候，如何设计使存储速度更快，比如说当既有人物关系又有人物关系的时候，一定会用neo4j来存储关系，myslq用来存储用户信息，这样分开是因为如果信息全部存入neo4j，后期的存储速度经十分的慢。

当你每个步骤都能做到很优秀的时候，你应该考虑如何组合这四个步骤，使你的爬虫达到效率最高，也就是所谓的爬虫策略问题，爬虫策略学习不是一朝一夕的事情，建议多看看一些比较优秀的爬虫的设计方案，比如说Scrapy。

除了爬取策略以外，还有几点也是必备的： 1.代理策略以及多用户策略

代理是爬虫进阶阶段必备的技能，与入门阶段直接套用代理不同，在进阶阶段你需要考虑如何设计使用代理策略，什么时候换代理，代理的作用范围等等，多用户的抓取策略考虑的问题基本上与代理策略相同。2.增量式抓取以及数据刷新

比如说你抓取的是一个酒店网站关于酒店价格数据信息的，那么会有这些问题：酒店的房型的价格是每天变动的，酒店网站每天会新增一批酒店，那么如何进行存储、如何进行数据刷新都是应该考虑的问题。3.验证码相关的一些问题 有很多人提到验证码，我个人认为验证码不是爬虫主要去解决的问题，验证码不多的情况考虑下载到本地自己输入验证码，在多的情况下考虑接入打码平台。

（五）Python爬虫面试指南

前段时间快要毕业，而我又不想找自己的老本行Java开发了，所以面了很多Python爬虫岗位。因为我在南京上学，所以我一开始只是在南京投了简历，我一共面试了十几家企业，其中只有一家没有给我发offer，其他企业都愿意给到10K的薪资，不要拿南京的薪资水平和北上深的薪资水平比较，结合面试常问的问题类型说一说我的心得体会。

第一点：Python 因为面试的是Python爬虫岗位，面试官大多数会考察面试者的基础的Python知识，包括但不限于：

    Python2.x与Python3.x的区别 Python的装饰器 Python的异步

Python的一些常用内置库，比如多线程之类的

第二点：数据结构与算法

数据结构与算法是对面试者尤其是校招生面试的一个很重要的点，当然小公司不会太在意这些，从目前的招聘情况来看对面试者的数据结构与算法的重视程度与企业的好坏成正比，那些从不问你数据结构的你就要当心他们是否把你当码农用的，当然以上情况不绝对，最终解释权归面试官所有。

第三点：Python爬虫

最重要也是最关键的一点当然是你的Python爬虫相关的知识与经验储备，这通常也是面试官考察的重点，包括但不限于：

     你遇到过的反爬虫的策略有哪些？ 你常用的反反爬虫的方案有哪些？

你用过多线程和异步吗？除此之外你还用过什么方法来提高爬虫效率？ 有没有做过增量式抓取？ 对Python爬虫框架是否有了解？

第四点：爬虫相关的项目经验

爬虫重在实践，除了理论知识之外，面试官也会十分注重爬虫相关的项目：

 你做过哪些爬虫项目？如果有Github最好  你认为你做的最好的爬虫项目是哪个？其中解决了什么难题？有什么特别之处？

以上是我在面试过程中，会碰到的一些技术相关的问题的总结，当然面试中不光是技术这一点，但是对于做技术的，过了技术面基本上就是薪资问题了。

（六）推荐一些不错的Python博客

如果是Python基础的话，廖雪峰的博客教程会是一个不错的选择：

  Python3教程 Python 2.7教程

当然很多刚接触Python的同学反应廖大大的教程中部分跳跃性太大，如果觉得跳跃性太大可以结合菜鸟教程一起看：

  Python3 教程 | 菜鸟教程 Python 基础教程 | 菜鸟教程

如果你英文稍好的话推荐还是看官方文档：Python 3.6.0 documentation 如果不是为了学习Python基础的话，推荐几个其他的博客。

    董老师的博客：小明明s à domicile 《Python-Web开发实战》的作者，知乎某位工程师的博客：分类《Python》，具体是哪位大神我不太清楚。依云大大的博客文章值得深读：依云's Blog

《从Python开始学编程》的作者博客：PythonVamei博客园

Python | the5fire的技术博客

（七）Python如何进阶

很多人在学习编程之初都会碰到这种问题：学会了基础的语法了，但是还是做不了项目，不知道如何下手。

当初，我学习C的时候是这样、Java的时候是这样、Python的时候也是这样，其实不管什么语言、什么知识都是这样：理论基础知识谢科的回答 如果你想学习编程，但是找不到学习路径和资源，欢迎关注专栏：学习编程

第一：Python爬虫学习系列教程 Python版本：2.7 整体目录：

一、爬虫入门  Python爬虫入门一之综述  Python爬虫入门二之爬虫基础了解  Python爬虫入门三之Urllib库的基本使用  Python爬虫入门四之Urllib库的高级用法  Python爬虫入门五之URLError异常处理  Python爬虫入门六之Cookie的使用  Python爬虫入门七之正则表达式

二、爬虫实战

 Python爬虫实战一之爬取糗事百科段子  Python爬虫实战二之爬取百度贴吧帖子

 Python爬虫实战三之实现山东大学无线网络掉线自动重连  Python爬虫实战四之抓取淘宝MM照片

 Python爬虫实战五之模拟登录淘宝并获取所有订单  Python爬虫实战六之抓取爱问知识人问题并保存至数据库  Python爬虫实战七之计算大学本学期绩点

 Python爬虫实战八之利用Selenium抓取淘宝匿名旺旺

三、爬虫利器

 Python爬虫利器一之Requests库的用法  Python爬虫利器二之Beautiful Soup的用法  Python爬虫利器三之Xpath语法与lxml库的用法  Python爬虫利器四之PhantomJS的用法  Python爬虫利器五之Selenium的用法  Python爬虫利器六之PyQuery的用法

四、爬虫进阶

 Python爬虫进阶一之爬虫框架概述

 Python爬虫进阶二之PySpider框架安装配置  Python爬虫进阶三之爬虫框架Scrapy安装配置  Python爬虫进阶四之PySpider的用法

第二（第一的姊妹篇）：Python爬虫入门教程 Python版本：2.7 教程目录：

 [Python]网络爬虫

（一）：抓取网页的含义和URL基本构成

 [Python]网络爬虫

（二）：利用urllib2通过指定的URL抓取网页内容  [Python]网络爬虫

（三）：异常的处理和HTTP状态码的分类  [Python]网络爬虫

（四）：Opener与Handler的介绍和实例应用  [Python]网络爬虫

（五）：urllib2的使用细节与抓站技巧  [Python]网络爬虫

（六）：一个简单的百度贴吧的小爬虫  [Python]网络爬虫

（七）：Python中的正则表达式教程

 [Python]网络爬虫

（八）：糗事百科的网络爬虫（v0.3）源码及解析(简化更新)

 [Python]网络爬虫

（九）：百度贴吧的网络爬虫（v0.4）源码及解析  [Python]网络爬虫

（十）：一个爬虫的诞生全过程（以山东大学绩点运算为例）

 [Python]网络爬虫（11）：亮剑！爬虫框架小抓抓Scrapy闪亮登场！ [Python]网络爬虫（12）：爬虫框架Scrapy的第一个爬虫示例入门教程

第三：你已经看完上面（第一或者第二）的教程：再推荐知乎用户@陈唯源 的实战练习博客

 Python爬虫学习记录（1）——Xiami全站播放数  Python爬虫学习记录（2）——LDA处理歌词  百度音乐带标签，作曲，演唱者，类别的歌词数据

 Python爬虫学习记录（4）——传说中的足彩倍投法。好像也不是那么靠谱

 2011~2013.5全球所有足球比赛比分数据以及足彩各公司盘口

 Python爬虫学习记录（3）——用Python获取虾米加心歌曲，并获取MP3下载地址

 Python爬虫学习记录（5）——python mongodb + 爬虫 + web.py 的acfun视频排行榜

 Python爬虫学习记录（0）——Python 爬虫抓站 记录（虾米，百度，豆瓣，新浪微博）

第四：最后推荐知乎用户@gaga salamer 的实战练习博客

 爬虫教程（1）基础入门  爬虫教程（2）性能进阶

 知乎用户信息爬虫（规模化爬取） 用scrapy爬取豆瓣电影新片榜

 用scrapy对豆瓣top250页面爬取（多页面爬取） 用scrapy自动爬取下载图片

 用scrapy自动下载石原sama的豆瓣影人图集(727张图片，自动下载）

希望以上的教程可以帮助到大家。

（九）Python开发微信公众号

我的第一个Python项目就是做的微信公众号机器人，按照当时我的思路来讲讲如何学习使用Python来开发微信公众号：大家伙收藏顺手点个赞呗。微信公众号功能开发分为两大块：需要调用微信内部功能、不需要调用微信内部功能，重点在调用微信内部功能组建。

1、需要调用微信内部功能 需要调用微信内部功能组件的比如：公众号收发消息|图片、页面分享至朋友圈、用户授权提取用户基本信息、微信小店、微信公众号菜单等内部功能组件，这些功能组件在微信公众号开发者文档里面找到：微信公众平台开发者文档

对于这些功能组件，开发者文档都提供了详细的接口文档，告诉你如何调用，而你只需要用Python调用这些接口即可。比如一个很简单的消息发送的方法如下：

当然在这所有的调用之前，需要进行一些授权验证，同样开发者文档有一套完整的接入指南：接入指南廖雪峰的官方网站

（三）、简要描述Python的垃圾回收机制（garbage collection）Python中的垃圾回收是以引用计数为主，标记-清除和分代收集为辅。引用计数：Python在内存中存储每个对象的引用计数，如果计数变成0，该对象就会消失，分配给该对象的内存就会释放出来。标记-清除：一些容器对象，比如list、dict、tuple，instance等可能会出现引用循环，对于这些循环，垃圾回收器会定时回收这些循环（对象之间通过引用（指针）连在一起，构成一个有向图，对象构成这个有向图的节点，而引用关系构成这个有向图的边）。

分代收集：Python把内存根据对象存活时间划分为三代，对象创建之后，垃圾回收器会分配它们所属的代。每个对象都会被分配一个代，而被分配更年轻的代是被优先处理的，因此越晚创建的对象越容易被回收。

如果你想要深入了解Python的GC机制，点击这里：[转载]Python垃圾回收机制--完美讲解!

（四）、Python多线程（multi-threading）。这是个好主意吗？

Python并不支持真正意义上的多线程，Python提供了多线程包。Python中有一个叫Global Interpreter Lock（GIL）的东西，它能确保你的代码中永远只有一个线程在执行。经过GIL的处理，会增加执行的开销。这就意味着如果你先要提高代码执行效率，使用threading不是一个明智的选择，当然如果你的代码是IO密集型，多线程可以明显提高效率，相反如果你的代码是CPU密集型的这种情况下多线程大部分是鸡肋。

想要深入详细了解多线程，点击这里：详解Python中的多线程编程_python 想了解一下IO密集和CPU密集可以点击这里：CPU-bound(计算密集型)和I/O bound(I/O密集型)

（五）、说明os,sys模块不同，并列举常用的模块方法？ 官方文档：

os模板提供了一种方便的使用操作系统函数的方法

sys模板可供访问由解释器使用或维护的变量和与解释器交互的函数 另一种回答：

os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口。sys模块负责程序与Python解释器的交互，提供了一系列的函数和变量用户操作Python运行时的环境。一些常用的方法：

一些常用的用法示例：

想要了解更详细的使用请访问：os和sys模块Python

（七）、Python中pass语句的作用是什么？

pass语句不会执行任何操作，一般作为占位符或者创建占位程序

（八）、Python是如何进行类型转换的？

Python提供了将变量或值从一种类型转换为另一种类型的内置方法。

（九）、Python里面如何拷贝一个对象？

Python中对象之间的赋值是按引用传递的，如果要拷贝对象需要使用标准模板中的copy copy.copy：浅拷贝，只拷贝父对象，不拷贝父对象的子对象。copy.deepcopｙ：深拷贝，拷贝父对象和子对象。

（十）、__new__和__init__的区别。

__init__为初始化方法，__new__方法是真正的构造函数。

__new__是实例创建之前被调用，它的任务是创建并返回该实例，是静态方法 __init__是实例创建之后被调用的，然后设置对象属性的一些初始值。总结：__new__方法在__init__方法之前被调用，并且__new__方法的返回值将传递给__init__方法作为第一个参数，最后__init__给这个实例设置一些参数。

想要更加详细的了解这两个方法，请点击：Python中的__new__及其用法

（十一）、Python中单下划线和双下划线分别是什么？

__name__：一种约定，Python内部的名字，用来与用户自定义的名字区分开，防止冲突

_name：一种约定，用来指定变量私有

__name：解释器用_classname__name来代替这个名字用以区别和其他类相同的命名

想要更加详细的了解这两者的区别，请点击：Python中的下划线（译文）

（十二）、说一说Python自省。

自省就是面向对象的语言所写的程序在运行时，所能知道对象的类型。简单一句话就是运行时能够获得对象的类型。比如：type()、dir()、getattr()、hasattr()、isinstance()

想要完整的理解Python自省，请点击：Python自省（反射）指南 有关于元类以及单例模式会在后面文章中做详细的解释说明。

本文参考文献资料： 

七、PYTHON 一些基础面试题目总结  很全的 Python 面试题  Python自省（反射）指南

 Python学习笔记

（十二）：lambda表达式与函数式编程  Python面试必须要看的15个问题

（十一）Python书籍 入门书籍

 《Python学习手册》  《Head First Python》

 《Learn Python The Hard Way》  《Python编程：入门到实践》  《笨办法学Python》  《简明Python教程》

进阶书籍

 《Python Cookbook（第三版）》  《流畅的Python》  《Python源码剖析》  《Python进阶》

 《Flask Web开发:基于Python的Web应用开发实战》

第二篇：我的Python学习经验

Python经常出现的错误，Python作为语言是一中对缩进非常敏感的语言，给很多初学者带来了困惑，即便是很有经验的Python程序员，也可能陷入陷阱当中。最常见的情况是tab和空格的混用会导致错误，或者缩进不对，而这是用肉眼无法分别的。

Python初学者在编译时会出现这样的错IndentationError:expected an indented block说明此处需要缩进，你只要在出现错误的那一行，按空格或Tab（但不能混用）键缩进就行。

然而在平常中往往有的人会疑问：我根本就没缩进怎么还是错，不对，该缩进的地方就要缩进，不缩进反而会出错。

第三篇：Python学习心得&总结

0、命令行常用命令

命令行（Windows下叫“命令提示符”，Mac下叫“终端”）里的常用命令。打开命令行，我们会看到每行前面都有诸如

C:Documents and SettingsCrossin> 或者

MyMacBook:~ crossin$ 之类的。

这个提示符表示了当前命令行所在目录。

第一个常用的命令是：

dir（windows环境下）ls（mac环境下）

dir和ls的作用差不多，都是显示出当前目录下的文件和文件夹。

第二个常用命令是： cd 目录名

通过dir或ls了解当前目录的结构之后，可以通过“cd 目录名”的方式，进入到当前目录下的子目录里。

如果要跳回到上级目录，可以用命令： cd..另外，Windows下如果要写换盘符，需要输入 盘符: 比如从c盘切换到d盘 C:Documents and SettingsCrossin>d:

有了以上两个命令，就可以在文件目录的迷宫里游荡了。虽然没可视化的目录下的操作那么直观，但是会显得你更像个程序员。。

于是乎，再说个高阶玩法：现在你可以不用idle那套东西了，随便找个顺手的文本软件，把你的代码写好，保存好，最好是保存成py文件。然后在命令行下进入到py文件保存的目录，使用命令：python 程序保存的文件名 就可以运行你写的程序了。

一、关于分号“；”

在C、Java等语言的语法中规定，必须以分号作为语句结束的标识。Python也支持分号，同样用于一条语句的结束标识。但在Python中分号的作用已经不像C、Java中那么重要了，Python中的分号可以省略，主要通过换行来识别语句的结束。例如，以下两行代码是等价的： 1.print “hello world!” 2.print “hello world!”;第1行代码的输出结果：hello world!第2行代码的输出结果：hello world!如果要在一行中书写多条句，就必须使用分号分隔每个语句，否则Python无法识别语句之间的间隔：

1.# 使用分号分隔语句 2.x=1;y=1;z=1 第2行代码有3条赋值语句，语句之间需要用分号隔开。如果不隔开语句，Python解释器将不能正确解释，提示语法错误：SyntaxError: invalid syntax 注意分号不是Python推荐使用的符号，Python倾向于使用换行符作为每条语句的分隔，简单直白是Python语法的特点。通常一行只写一条语句，这样便于阅读和理解程序。一行写多条语句的方式是不好的习惯。

二、关于连行符 “ ”(双反斜杠好像不可以，已测试)Python同样支持多行写一条语句，Python使用“”作为连行符。在实践中，一条语句写在多行也是非常常见的。

【例】把SQL语句作为参数传递给函数，由于SQL的语句一般非常长，为了阅读方便，因此需要换行书写。

1.# 字符串的换行 2.# 写法一

3.sql = “select id,name 4.from dept 5.where name = 'A'” 6.print sql 7.# 写法二

8.sql = “select id,name ” 9.“from dept ” 10.“where name = 'A'” 11.print sql 写法一只使用了一对双引号，把SQL语句分为select、from、where等3部分分别书写。第6行代码输出结果：select id,name from dept where name = 'A' 写法二使用了3对双引号，select、from、where分别对应一对双引号。第11行代码输出结果：select id,name from dept where name = 'A' 第二种写法比第一种写法的可读性更强，可以使用空格和制表符对齐语句，使代码显得更工整。对于简短的语句不推荐换行的写法，这种写法只会造成阅读的复杂性。下面这段程序是不合理的换行写法： 1.# 一条语句写在多行 2.print 3.“hello world!” 第2行～第3行代码是一个整体，调用print输出“hello world!”，这种情况不适合分行书写。

三、关于单引号和双引号

双引号和单引号都是可以用的，只不过用单引号的时候可以在字符串里面使用双引号。同理，使用双引号时也可以在字符串里面使用单引号

先说1个双引号与3个双引号的区别，双引号所表示的字符串通常要写成一行 如：

s1 = “hello,world” 如果要写成多行，那么就要使用(“连行符”)，如 s2 = “hello, world” s2与s1是一样的。如果你用3个双引号的话，就可以直接写了，如下： s3 = “"”hello, world, hahaha.“"”，那么s3实际上就是“hello,n world,n hahaha.”, 注意“n”，所以，如果你的字符串里n很多，你又不想在字符串中用n的话，那么就可以使用3个双 引号。而且使用3个双引号还可以在字符串中增加注释，如下：

s3 = “"”hello, #hoho, this is hello, 在3个双引号的字符串内可以有注释哦 world, #hoho, this is world hahaha.“"” 这里我试过一下，确实可以加注释，不过在print s3的时候连注释内容会一起给打印出来 这就是3个双引号和1个双引号表示字符串的区别了，3个双引号与1个单引号的区别也 是和这个一样的，实际上python支持单引号是有原因的，下面我来比较1个单引号和 1个双引号的区别。

当我用单引号来表示一个字符串时，如果要表示 Let's go 这个字符串，必须这样：

s4 = 'Let's go'，注意没有，字符串中有一个'，而字符串又是用'来表示，所以 这个时候就要使用转义符 , 如果你的字符串中有一大堆的转义符，看起来肯定不舒服，python也很好的解决了这个问题，如下： s5 = “Let's go” 对于双引号，也是一样的，下面举个例子 s6 = 'I realy like “python”!' 这就是单引号和双引号都可以表示字符串的原因了。

例子：

(1)print(“Stay hungry,n”

#这里换行符n必须写在双引号里面

“stay foolish.n”

“--Steve Jobs”)(2)print('''Stay hungry，#这里用了三个单引号，没用换行符 stay foolish.--Steve Jobs''')(3)print(“"”Stay hungry，#这里用了三个双引号，没用换行符 stay foolish.--Steve Jobs“"”)这三个输出的结果都是三行： Stay hungry, stay foolish.--Steve Jobs

(4)print(“Stay hungry, stay foolish.--Steve Jobs”)这个输出的结果是一行：Stay hungry, stay foolish.--Steve Jobs

四、关于注释符 用井号作为注释一行 #此处为注释

一般用“"”（三个英文引号）也可以注释多行，不过一般用来表示函数文档 “"” 此处是注释

此函数功能为。。“"”

五、逻辑量True和 False 首字母必须大写

Python中的None： None是一个特殊的常量。None和False不同。None不是0。None不是空字符串。

None和任何其他的数据类型比较永远返回False。None有自己的数据类型NoneType。

你可以将None复制给任何变量，但是你不能创建其他NoneType对象。

六、if语句，if…elif…else语句，while循环，for循环, break和continue if 条件：

#注意冒号必须有

选择执行的语句

#注意这里有四个空格的缩进

if, elif, else可组成一个整体的条件语句： if是必须有的；elif可以没有，也可以有很多个，每个elif条件不满足时会进入下一个elif判断；else可以没有，如果有的话只能有一个，必须在条件语句的最后。if a == 1: print 'one' elif a == 2: print 'two' else: print 'too many'

while 条件： #注意冒号必须有

选择执行的语句

#注意这里有四个空格的缩进

for i in range(1, 101): #i从1取到100

print i 注：range(x, y, c)表示一个list：[x, x+c, x+2c, … , y-c]。如果没有第三个参数c, 默认c=1.break while 循环在条件不满足时 结束，for 循环遍历完序列后 结束。如果在循环条件仍然满足或序列没有遍历完的时候，想要强行跳出循环，就需要用到break语句。continue break是彻底地跳出循环，而continue只是略过本次循环的余下内容，直接进入下一次循环。

七、变量命名规则

python在定义一个变量时不需要给它限定类型。变量会根据赋给它的值，自动决定它的类型。你也可以在程序中，改变它的值，于是也就改变了它的类型。变量命名时第一个字符必须是字母或者下划线“_”，剩下的部分可以是字母、下划线“_”或数字（0-9）

变量名称是对大小写敏感的，myname和myName不是同一个变量。

八、字符串的输出和运算

字符串之间可以通过加法连接起来： str1 = 'good' str2 = 'bye' print(str1 + str2)print('very ' + str1)print(str1 + ' and ' + str2)

print('My age is ' + str(18))num = 18 print('My age is %d' %num)#注意，%num可以直接用%18代替，但是%num和字符串之

间不能加逗号，只能是空格（没有空格也可以）

print('Today is %s.' % 'Friday')print(„Price is %.2f‟ % 4.99)注意：%d表示整数，%s表示字符串，%f表示浮点数，%.4f表示带4位小数的浮点数

print（“%s's score is %d” %('Mike', 87)）

无论你有多少个值需要代入字符串中进行格式化，只需要在字符串中的合适位置用对应格式的%表示，然后在后面的括号中按顺序提供代入的值就可以了。占位的%和括号中的值在数量上必须相等，类型也要匹配。

('Mike', 87)这种用()表示的一组数据在python中被称为元组（tuple），是python的一种基本数据结构，以后我们还会用到。

九、变量强制类型转换 int(x)#把x转换成整数 float(x)#把x转换成浮点数 str(x)#把x转换成字符串 bool(x)#把x转换成bool值

例如，以下等式的结果均为真：int('123')== 123

float('3.3')== 3.3 str(111)== '111' bool(0)== False

bool('abc')== True

bool('False')== True bool('')== False 并不是所有的值都能做类型转换，比如int('abc')同样会报错，python没办法把它转成一个数。关于bool类型的转换，在python中，以下数值会被认为是False：

为0的数字，包括0，0.0 空字符串，包括''，"" 表示空值的None（None是python中的一个特殊值，表示什么都没有，它和0、空字符、False、空集合都不一样）

空集合，包括()，[]，{} 其他的值都认为是True。

十、函数

如果我们要写一个函数，就需要去定义它。Python里定义函数的关键字是def，格式如下： def sayHello():

print 'hello world!' 我们用sayHello()来调用这个函数。（注意括号必须带着）

return是函数的结束语句，return后面的值被作为这个函数的返回值。函数中任何地方的return

被执行到的时候，这个函数就会结束。

十一、list列表

格式：用中括号包围、逗号隔开的一组元素；列表中的元素可以是不同的类型。例如，range(1,10)或者[1, 2, 3, 4, 5, 6, 7, 8, 9]；I = [365, 'everyday', 0.618, True]。操作list：

1.访问list中的元素 python计数是从0开始，例如I[0]=365, I[1]= 'everyday' 2.修改list中的元素

修改list中的某一个元素，只需要直接给那个元素赋值就可以了：l[0] = 123 注意如下例子：c=[1,2,3] b=c a=c b[0]=2 print a 得到 a=[2,2,3] 特别注意：如果用一个list赋值给另一个list，但是想要改变一个list的时候另一个不变，这时需用如下赋值方法： a=[1,2]

b=[]

b[0 : len(a)]=a[0 : len(a)] b.append(3)

print a

得到[1,2] print b

得到[1,2,3] 3.向list中添加元素

list有一个append方法，可以增加元素。以I这个列表为例，调用的方法是：

I.append(1024)#注意这里是小括号

输出I，你会看到[123, 'everyday', 0.618, True, 1024]，1024被添加到了I，成为最后一个元素。（第一个元素在上一步被改成了123。）然后同样可以用I[4]得到1024。4.删除list中的元素

删除list中的某一个元素，要用到del： del I[0]，然后输出I，得到['everyday', 0.618, True, 1024]。这时候再调用I[0]，会得到'everyday'，其他元素的序号也相应提前。例子，#==== 点球小游戏 ====# from random import choice print 'Choose one side to shoot:' print 'left, center, right' you = raw_input()print 'You kicked ' + you direction = ['left', 'center', 'right'] com = choice(direction)print 'Computer saved ' + com if you!= com: print 'Goal!' else: print 'Oops...'

5.求和：例如 sum([1,2,3])=6, sum(range(101))=5050

list有两类常用操作：索引(index)和切片(slice)。用[]加序号访问的方法就是索引操作。除了指定位置进行索引外，list还可以处理负数的索引，例如I[-1]表示l中的最后一个元素，l[-3]表示倒数第3个元素。切片操作符是在[]内提供一对可选数字，用冒号分割。冒号前的数表示切片的开始位置，冒号后的数字表示切片到哪里结束。同样，计数从0开始。注意，开始位置包含在切片中，而结束位置不包括。例如，I = [365, 'everyday', 0.618, True]，I[1:3]得到的结果是['everyday', 0.618]。

如果不指定第一个数，切片就从列表第一个元素开始。如果不指定第二个数，就一直到最后一个元素结束。都不指定，则返回整个列表的一个拷贝。I[:3]

I[1:]

I[:] 同索引一样，切片中的数字也可以使用负数。比如：I[1:-1] 得到['everyday', 0.618]

十二、字符串的索引和切片（类似list的操作）1.遍历

通过for...in可以遍历字符串中的每一个字符。word = 'helloworld' for c in word: print c 2.索引访问

通过[]加索引的方式，访问字符串中的某个字符。word[0]= 'h' word[-2]= 'l' 与list不同的是，字符串不能通过索引访问去更改其中的字符。word[1] = 'a' 这样的赋值是错误的。3.切片

通过两个参数，截取一段子串，具体规则和list相同。print word[5:7] print word[:-5] print word[:] 4.连接字符

join方法也可以对字符串使用，与list的join用法类似。

','.join(word)= 'h,e,l,l,o,w,o,r,l,d'

十三、字符串的分割-- list 假设需要把一个句子中的每一个单词拿出来单独处理。sentence = 'I am an English sentence' 这时就需要对字符串进行分割:

sentence.split()

字符串.split()会把字符串按照其中的空格进行分割，分割后的每一段都是一个新的字符串，最终返回这些字符串组成一个list。于是得到['I', 'am', 'an', 'English', 'sentence'] 除了空格外，split()同时也会按照换行符n，制表符t进行分割。所以应该说，split默认是按照空白字符进行分割。

之所以说默认，是因为split还可以指定分割的符号。比如你有一个很长的字符串

section ='Hi.I am the one.Bye.' 通过指定分割符号为'.'，可以把每句话分开：section.split('.')得到['Hi', ' I am the one', ' Bye', '']。这时候，'.'作为分割符被去掉了，而空格仍然保留在它的位置上。注意最后那个空字符串。每个'.'都会被作为分割符，即使它的后面没有其他字符，也会有一个空串被分割出来。例如 'aaa'.split('a')将会得到['', '', '', '']，由四个空串组成的list。

十四、连接list--字符串

join：和split正好相反,join把一个list中的所有字符串连接成一个字符串,而split是把一个字符串分割成很多字符串组成的list。

join的格式有些奇怪，它不是list的方法，而是字符串的方法。首先需要有一个字符串作为list中所有元素的连接符，然后再调用这个连接符的join方法，join的参数是被连接的list： 例如：s = ';' li = ['apple', 'pear', 'orange'] fruit = s.join(li)print fruit 得到结果'apple;pear;orange'。

又例如：''.join(['hello', 'world'])得到'helloworld'，字符串被无缝连接在一起。十一**、元组（tuple）

元组（tuple）也是一种序列，和我们用了很多次的list类似，只是元组中的元素在创建之后就不能被修改。例如position =(1, 2)

geeks =('Sheldon', 'Leonard', 'Rajesh', 'Howard')都是元组的实例。它有和list同样的索引、切片、遍历等操作：

1.2.3.4.print postion[0] for g in geeks: print g print geeks[1:3] 其实我们之前一直在用元组，就是在print语句中：

print '%s is %d years old' %('Mike', 23)('Mike', 23)就是一个元组。这是元组最常见的用处。

再来看一下元组作为函数返回值的例子：

1.def get_pos(n): 2.return(n/2, n*2)得到这个函数的返回值有两种形式，一种是根据返回值元组中元素的个数提供变量：

1.x, y = get_pos(50)2.print x 3.print y 这就是我们在开头那句代码中使用的方式。还有一种方法是用一个变量记录返回的元组：

1.pos = get_pos(50)2.print pos[0] 3.print pos[1]

十五、读文件

新建个文件，就叫它data.txt。在里面随便写上一些话，保存。把这个文件放在接下来你打算保存代码的文件夹下，这么做是为了方便我们的程序找到它。

打开一个文件的命令很简单：file('文件名')这里的文件名可以用文件的完整路径，也可以是相对路径。因为我们把要读取的文件和代码放在了同一个文件夹下，所以只需要写它的文件名就够了。f = file('data.txt')#注意这里f不是字符串,是文件对象

但这一步只是打开了一个文件，并没有得到其中的内容。变量f保存了这个文件，还需要去读取它的内容。你可以通过read()函数把文件内所有内容读进一个字符串中。data = f.read()#这里data是字符串

做完对文件的操作之后，记得用close()关闭文件，释放资源。

完整程序示例：

f = file('data.txt')data = f.read()print data f.close()

读取文件内容的方法还有： readline()#读取一行内容

readlines()#把内容按行读取至一个list中 去替换程序的第二行，看看它们的区别。

十六、写文件

打开文件的几种模式：

python默认是以只读模式打开文件。如果想要写入内容，在打开文件的时候需要指定打开模式为写入： f = file('output.txt', 'w')

'w'就是writing，以这种模式打开文件，原来文件中的内容会被你新写入的内容覆盖掉，如果文件不存在，会自动创建文件。不加参数时，file为你默认为'r'，reading，只读模式，文件必须存在，否则引发异常。

另外还有一种模式是f = file('output.txt', 'a')，其中'a'是appending。它也是一种写入模式，但你写入的内容不会覆盖之前的内容，而是添加到文件中。

打开文件还有一种方法，就是open()，用法和file()是一致的。写文件：

写入内容的方法同样简单：

f.write('a string you want to write')write的参数可以是一个字符串，或者一个字符串变量。

示例程序：

data = 'I will be in a file.nSo cool!' out = open('output.txt', 'w')out.write(data)out.close()在你的程序保存目录下，打开output.txt就会看到结果。类似的，writelines(list)#把list的每一个元素写成一行 没有writeline(list)。

十七、处理文件中的数据 比如我现在拿到一份文档，里面有某个班级里所有学生的平时作业成绩。因为每个人交作业的次数不一样，所以成绩的数目也不同，没交作业的时候就没有分。我现在需要统计每个学生的平时作业总得分。

看一下我们的文档里的数据： #--scores.txt 刘备 23 35 44 47 51 关羽 60 77 68 张飞 97 99 89 91 诸葛亮 100

1.先把文件读进来：

f = file('scores.txt')2.取得文件中的数据。因为每一行都是一条学生成绩的记录，所以用readlines，把每一行分开，便于之后的数据处理： lines = f.readlines()f.close()提示：在程序中，经常使用print来查看数据的中间状态，可以便于你理解程序的运行。比如这里你可以print lines，看一下内容被存成了什么格式。3.对每一条数据进行处理。按照空格，把姓名、每次的成绩分割开：

for line in lines: data = line.split()#这里data是list

接下来的4、5两个步骤都是针对一条数据的处理，所以都是在for循环的内部。4.整个程序最核心的部分到了。如何把一个学生的几次成绩合并，并保存起来呢？我的做法是：对于每一条数据，都新建一个字符串，把学生的名字和算好的总成绩保存进去。最后再把这些字符串一起保存到文件中： sum = 0 for score in data[1:]: sum += int(score)result = '%st: %dn' %(data[0], sum)这里几个要注意的点：

对于每一行分割的数据，data[0]是姓名，data[1:]是所有成绩组成的列表。每次循环中，sum都要先清零。

score是一个字符串，为了做计算，需要转成整数值int。

result中，我加了一个制表符t和换行符n，让输出的结果更好看些。5.得到一个学生的总成绩后，把它添加到一个list中。

results.append(result)#这里results是list results需要在循环之前初始化results = [] 6.最后，全部成绩处理完毕后，把results中的内容保存至文件。因为results是一个字符串组成的list，这里我们直接用writelines方法： output = file('result.txt', 'w')output.writelines(results)outpus.close()

十八、异常处理

在python中，可以使用try...except语句来处理异常。做法是，把可能引发异常的语句放在try-块中，把处理异常的语句放在except-块中。例如：

try: f = file('non-exist.txt')print 'File opened!' f.close()except: print 'File not exists.' print 'Done'

十九、字典dictionary python中的基本类型--字典（dictionary）： 字典这种数据结构有点像我们平常用的通讯录，有一个名字和这个名字对应的信息。在字典中，名字叫做“键(key)”，对应的内容信息叫做“值(value)”。字典就是一个键/值对的集合。键/值对用冒号分割，每个对之间用逗号分割，整个字典包括在花括号中。

d = {key1 : value1, key2 : value2 } 举个简单的字典例子：score = {'萧峰': 95, '段誉': 97,'虚竹': 89} 关于字典的键要注意的是： 1.键必须是唯一的； 2.键只能是简单对象，比如字符串、整数、浮点数、bool值。list就不能作为键，但是 可以作为值。

3.python字典中的键/值对没有顺序，我们无法用索引访问字典中的某一项，而是要用键来访问。例如print score['段誉'] 或者print score.get('段誉')。如果你的键是字符串，通过键访问的时候就需要加引号，如果是数字作为键则不用。注意，字典类的get方法是按照给定key寻找对应项，如果不存在这样的key，就返回空值None 4.字典也可以通过for...in遍历： for name in score: print score[name] #这里要用中括号

或者 print score.get(name)#这里要用小括号

注意，遍历的变量中存储的是字典的键。5.如果要改变某一项的值，就直接给这一项赋值： score['虚竹'] = 91 6.增加一项字典项的方法是，给一个新键赋值： score['慕容复'] = 88 7.删除一项字典项的方法是del： del score['萧峰'] 注意，这个键必须已存在于字典中。

8.如果你想新建一个空的字典，只需要: d = {}

二十、模块

python自带了功能丰富的标准库，另外还有数量庞大的各种第三方库。使用这些功能的基本方法就是使用模块。通过函数，可以在程序里重用代码；通过模块，则可以重用别的程序中的代码。

模块可以理解为是一个包含了函数和变量的py文件。在你的程序中引入了某个模块，就可以使用其中的函数和变量。

来看一个我们之前使用过的模块： import random import语句告诉python，我们要用random模块中的内容。然后便可以使用random中的方法，比如：random.randint(1, 10)random.randchoic([1, 3, 5])注意，函数前面需要加上“random.”，这样python才知道你是要调用random中的方法。想知道random有哪些函数和变量，可以用dir()方法：dir(random)

如果你只是用到random中的某一个函数或变量，也可以通过from...import...指明： from random import randint； from math import pi print pi 等同于 import math print math.pi 为了便于理解和避免冲突，你还可以给引入的方法换个名字： from math import pi as math_pi print math_pi

二十一、函数的默认参数

之前我们用过函数，比如： def hello(name): print 'hello ' + name 然后我们去调用这个函数：hello('world')程序就会输出： hello world 如果很多时候，我们都是用world来调用这个函数，少数情况才会去改参数。那么，我们就可以给这个函数一个默认参数： def hello(name = 'world'): print 'hello ' + name 当你没有提供参数值时，这个参数就会使用默认值；如果你提供了，就用你给的。这样，在默认情况下，你只要调用hello()就可以输出 hello world 同样你也可以指定参数：hello('python')，输出hello python 注意，当函数有多个参数时，如果你想给部分参数提供默认参数，那么这些参数必须在参数的末尾。比如： def func(a, b=5)是正确的

def func(a=5, b)就会出错

二十二、数学运算python的数学运算模块叫做math，再用之前，需要 import math

1.math包里有两个常量： math.pi 圆周率π：3.141592...math.e 自然常数：2.718281...2.数值运算：

math.ceil(x)对x向上取整，比如x=1.2，返回2

math.floor(x)对x向下取整，比如x=1.2，返回1

math.pow(x,y)指数运算，得到x的y次方

math.log(x)对数，默认基底为e。可以使用第二个参数，来改变对数的基底。比如math.log(100, 10)

math.sqrt(x)平方根

math.fabs(x)绝对值 三角函数: math.sin(x)math.cos(x)math.tan(x)math.asin(x)math.acos(x)math.atan(x)注意：这里的x是以弧度为单位，所以计算角度的话，需要先换算

角度和弧度互换: math.degrees(x)弧度转角度 math.radians(x)角度转弧度

以上是你平常可能会用到的函数。除此之外，还有一些，这里就不罗列，可以去 http://docs.python.org/2/library/math.html 查看官方的完整文档。

二十三、类class和对象object class Person: def __init__(self, name): self.name = name def sayHi(self): print 'Hello, my name is', self.name p = Person('Swaroop')p.sayHi()__init__函数会在类被创建的时候自动调用，用来初始化类。它的参数，要在创建类的时候提供（所以定义p时Person后面的括号里有东西）注意：__init__前后各有两道下划线

第四篇：python语法小结

1.在Python中，一般来说一条语句占用一行。一条语句结束一般不需要使用C语言中的“;”，但在Python中也可以使用“;”将两条语句写在一行。另外，如果缩进语句中只有一条语句，也可以将其写在“:”之后。

2.单引号中的字符串可以包含双引号，双引号中的字符串可以包含单引号，而不需要使用转义字符。另外3个引号所包围的字符可以作为注释，还可以作为格式化的字符串，该字符串可以不再一行，格式化后行尾会自动转化为“n”转义字符。

3.在Python中可以使用“”将较长的语句分成几行来写，但是注意每行后面不可以有#注释。或者可以使用圆括号将较长的语句分行，每行后面可以使用#注释。

4.类型间转换

hex()：将整数转换为十六进制字符串，包含前缀“0x” oct()：将整数转换为八进制字符串，包含前缀“0o”

注：string模块中有string.atoi(x, base = 10)，类似int()，但是可以选择变换后的进制

5.math模块中数学函数：

hypot(x, y)：求直角三角形的斜边长度，x和y为两个直角边长度 fmod(x, y)：求x / y的余数，等同于x % y ceil(x)：求不小于x的最大整数 floor(x)：求不大于x的最小整数 fabs(x)：求x的绝对值 exp(x)：求e的x次幂

pow(x, y)：求x的y次幂，等同于x ** y log10(x)：求x以log10为底的对数 sqrt(x)：求x的平方根 pi：求pi的值

6.字符串操作

string.capitalize()：将字符串第一个字母大写 string.count(x)：获得字符串中某字符串的数目 string.find(x)：获得字符串中某子字符串的起始位置 string.isalnum()：是否仅包含0～

9、A～Z、a～z string.isalpha()：是否仅包含A～Z、a～z string.isaldigit()：是否仅包含0～9 string.islower()string.isupper()string.lower()string.upper()string.isspace()string.istitle()：字符串中所有单词是否首字母大写 string.title()string.join(x)：将string插入x中的每两个字符之间 string.swapcase()：大小写字母转换 string.split(x)：利用分割字符串的单词（默认是space）len(string)7.格式化字符串

%f %d %s %o：八进制整数 %x：十六进制整数

注：r“xxxxx”或者R“xxxxx”表示原始字符串，常用语正则表达式或者路径表示中，其间没有转义字符，均是正常字符。

8.列表list list.append(x)：追加成员x list.count(x)：参数x出现的次数

list.extend(x)：list1+list2无法改变list1，只能返回一个新的list，但是list2.extend(list2)函数可以改变list1的值

list.index(x)：获得x在list中的位置 list.insert(index, x)：在index处插入x list.pop(index)：删除索引为index的成员

list.remove(x)：删除值为x的成员 list.reverse()list.sort()list.clear()注：tuple的操作与list类似，但是不包含可修改元组的操作。

9.字典dict dict.clear()dict.copy(x)：将字典x拷贝给dict dict.get(key)：等同于dict[k] dict.has_key(key)：是否包含key键 dict.items()：获得键-值对组成的列表 dict.keys()：获得键组成的列表 dict.values()：获得值组成的列表 dict.pop(key)dict.update(x)：利用字典x更新原字典

10.文件操作

open(filename, mode, bufsize)filename：要打开的文件名

mode：打开模式（r是只读，w是替换写，a是追加写，+是读写等）bufsize：缓冲区大小，可以默认 file.read()：整个文件读入字符串中 file.readlines()：整个文件读入列表中 file.readline()：某行读入字符串中 file.write(x)：写入字符串 file.writelines(x)：写入列表x file.close().11.函数参数

调用函数可以同时使用按顺序传递参数，以及关键字传递参数等，但是必须注意按顺序传递的参数要位于按关键字传递的参数之前，而且不能有重复的情况发生。例如： def sample(x, y, z): pass mysum(1, z = 5, y = 6)#ok mysum(z = 6, y = 7, 3)#error 使用可变长参数的函数，将其所有参数保存在一个元组里，在函数中可以使用for循环来处理，声明一个可变长参数的函数只需用*开头定义一个参数即可。

12.局部/全局变量

局部作用域内的变量的改变并不影响全局作用域内的变量，除非通过引用的方式传递参数。如果要在函数内使用函数外的变量，可以在变量名前使用global关键字。例如： def func(x): global a return x + a 13.模块查找路径

导入模块时，python解释器首先在当前目录中查找导入的模块；如果未找到，解释器会从sys模块中的path变量指定的目录查找导入模块；如果均未找到，则会出错。import sys sys.path 在脚本中可以向sys.path添加查找路径，例如可以在.py中如下： import os import sys modulepath = os.getcwd()+ „module‟ #module是当前目录下的module子目录 sys.path.append(modulepath)import mymodule #mymodule在module子目录中 ************ 14.dir(x)可以获得导入模块中的所有定义的名字和函数等。

import sys dir(sys)当不使用参数时，该函数将返回当前脚本的所有名字列表。

15.模块包

包可以看成是出于同一个目录中的模块，在python中首先使用目录名，然后再使用模块名导入所需要的模块。在包的每个目录（包括子目录）中都必须包含一个“__init__.py”的文件，该文件甚至可以是一个空文件，仅用于表示该目录为一个包。

在__init__.py中设置__all__变量和包初始化所需的代码，可以保证在from中使用*时名字的正确导入。from A.B import a import A.B.a 有了包的概念可以很好地解决模块查找路径的问题，只要将所有的模块放在当前目录中的某个文件夹内（子目录），然后在子目录内新建一个__init__.py文件即可，而不需将子目录的路径添加到sys.path中。

第五篇：Python教学心得

Python教学心得

Python教学心得1

1、定义方法

关键字def是方法定义的标志。接下来紧跟方法名和被圆括号所包围的参数列表。方法的主

体语句将在下一行开始并且必须缩进。

方法主体的首句可选择性地是一句字符，用来说明方法的主要功能

例如：

“”“print a finabo series up to n.”“”

2、默认参数值

默认值仅被设置一次，这与以前默认值为可变对象(如列表、字典和多数类实

例时)有很大的区别。

例如：

i=5

def f(arg=i):

print(arg)

i=6

f

将会输出5

3、关键字参数

可以通过形式关键字参数调用方法

在方法调用中，关键字参数必须遵循位置参数。所有的关键参数必须符合方法接受的参数

其中之一。但是他们的次序不重要，这包含非选择的参数。没有参数可以多次接受一个值。

当最后一个形参是__name时，它可以接受包含除了形式参数之外的所有关键字的字典，

_name必须在__name之前出现

4、可变参数列表

正常来说，这些可变参数常常放在正式参数列表的后面，因为它们会包揽所有传递给该方法

的剩余输入参数。任何出现在_args参数后低的正式参数会被认为是关键字参数，意味着它

们只能当关键字使用而不是位置参数。

>>>def concat(_args,sep=“/”):

...returnsep.join(args)

...

>>>concat(“earth”,“mars”,“venus”)

’earth/mars/venus’

>>>concat(“earth”,“mars”,“venus”, sep=“.”)

’earth.mars.venus’

5、拆分参数列表

当参数已经存在列表或者元组中，但是需要分拆以供要求分离位置参数调用的方法，如果单独

分开它们无法使用，就需要写一个方法用_操作符来调用实现分拆列表或者元组中的参数。

同样的使用形式，字典可以用__操作符实现关键字参数。

6、形式

lamdba a,b:a+b该函数表示两个数的和，像内嵌函数

7、代码风格

对于python，PEP8作为许多项目应该遵守的编码指导书而做的。它提出了一种可读而悦

目的编码风格。每位python开发者应该读它。这里抽出一个重要的事项与你分享：

用四个空格代替tab键

每行不要超过79个字符。

用空行分离方法和类，大块代码中的方法。

必要的时候为每行添加注释。

用文档字符串

在操作符两边用空格

用统一的风格命名自定义的方法和类

如果你的代码打算用在国际环境中，请不要用想象的字符编码。Python默认的是

utf-8,在任何情况下可以用Ascii .

同样的，即使有很少机会让说不同语言的人们读代码或者维护代码，但在定义中不

要用非ASCII编码字符。

Python教学心得2

由于我是自学Python，非科班出生，所以只能分享一些关于我的学习心得，如果有不对地方欢迎指正。

不过非科班出生虽然是一个痛点，但是在工作上，我其实不输给我其他同事，这点我倒是很有自信，而且我也统一一句话“目前互联网上的免费编程课程，足够让你成为一个合格的码农”。

编程入门

我刚开始学习编程，主要是因为自己想动手做个网站，但是由于技术原因，再加上朋友都比较忙，最后抱着“求人不如求己”的想法，干脆自学。

编程难不难?

这个问题我觉得所有认真学过的人，都一定会肯定告诉你编程不难，但是精通那是相当困难的。

如果你还没去学习，就觉得编程一定很难，那么其实你是没有资格说这句话的，任何事情一定是要去尝试后，才能这么说。

编程其实很像堆积木，然后根据需求，把东西造出来，可以是房子，也可以是桥梁。

学习编程无非运用这些积木，来创造你要的东西。

编程语言选择

这边说个题外话，关于当时编程语言的选择，很多时候我觉得不是你选择编程语言，而是编程语言选择你，也就是你的“本命编程语言”。

人的性格会影响你适合的编程语言，比如你做事有条理，喜欢定期清理房间，那么可能C语言很适合你;如果你不喜欢打扫房间，实在受不了，才打扫一次，可能你适合Java。

哈哈，开个玩笑，不过确实有这种很玄的存在。

我当时在编程语言的选择上，用了一个笨方法。

我跑到w3cschool上面，把所有编程语言的第一章都去试了一遍，看看自己喜欢哪个语言，然后就选哪个语言，如果你不知道选哪门语言，可以用我的方法试试看。

至于编程语言，没有高低之分，因为无论你学习哪门语言，你都非常有市场，而且你都能够拿到高薪，关键是哪门语言适合你，并且能够让你有兴趣学下去，能学好，这个很关键。

兴趣是学习编程最大的驱动力!

为什么是Python

说下为什么选择Python?

因为简单，Python是公认的最容易入门的编程语言，而且也是公认有发展前景的编程语言，适用于机器人、大数据、人工智商等未来高科技。

基于以上的原因，我选择Python来作为自己的入门语言，而且我觉得我适合Python这么语言。(因为我很懒)

之前有个梗，大概就是其他编程语言在讨论某个问题，怎么解决，而Python的程序员已经下班了，由此可见Python的效率。

总结：Python的语言特点就是“一气呵成，痛快如拉稀”。

学习心得

由于我是自学的，所以参考的网站比较多，小伙伴可以按照我的学习路线，一般来说不会出现什么问题。

基础：教程+视频

进阶：视频+实践

进阶pro：视频+实践+书籍+交流

基础

刚开始学习的时候，我比较推荐w3cschool和菜鸟教程这两个网站。

w3cschool-学编程，从w3cschool开始www.w3cschool.cn!

菜鸟教程-学的不仅是技术，更是梦想!www.runoob.com

这两个网站在我看来，是编程自学的福音。

w3cschool这个网站手册非常棒，另外这个网站的编程微课以及编程实战对新手来说非常友好!

我当时就是靠这两个，引发我学习的乐趣，不然对着枯燥的代码，说实话，很无聊的。

菜鸟教程，这个网站的实例是最棒的，很多时候，你不仅仅要自己看教程，还要去看看为什么，而菜鸟教程的实例就能够让你清晰的知道，为什么，并且会原来如此。

总的来说，这两个网站就像新手村刚出来的剑和盾!是新手入门绝对不能少的，尤其是w3cschool，强烈推荐。

还有一个就是视频，视频我是在慕课网上面看的，我很喜欢慕课网这个网站，网站风格很棒，而且视频也很清晰。

也可以在阿里云上面看Python的视频，也很不错，并且是免费的。

进阶

进阶结束后，代表你是个初级工程师。

这一步实践非常重要，你要自己动手，做一些小玩意，实践才是最重要的，在实践中发现问题，那是学习最快并且效率最高的时刻。

你可以先给自己定下一个目标，比如我要做一个简单的页面，或者我要做一个简单的小程序。

然后就开始动手去实践，这步很重要。

同时还是要多看书籍。

进阶pro

到这一步，我建议务必买书，你需要书籍帮你反向梳理你的知识，这决定了你以后的高度，而不是这个也懂，那个也懂，但是东西就是做不出来。

我记得当时我买完书，看完后的第一感受就是：原来这个世界是这样的!

书会非常系统性的帮你梳理你自己学过的知识!

这里只推荐两本书：《Python入门手册》和《Python核心编程》

小伙伴可以自己去亚马逊购买。

然后就是和身边的小伙伴交流!

多看看别人的代码，自己多敲敲代码，是必经之路，也是一定要做的。

以上，希望对想入门Python的小伙伴能够提供一点点帮助。

Python教学心得3

最近这段时间我们学习了很多内容，增长了很多关于Python的知识，万事万物是相通的，正如学习新的知识就像吃饭一样。

吃多了就会消化不良，反映到学习上也是一样，不知各位最近的感觉怎样，反正学记是需要一些时间好好消化，掌握到手中，为下一步的知识补齐缺口。

接下来，学记和大家一起回顾一下最近学习的内容，循序渐进，循序渐进。

分支结构

分支结构就像上图一样，是用来选择道路的。

所用的关键字是

If elif else

这三个词的意思分别是

如果否则如果其他的

分支语句的写法需要将与关键字与关键字对齐

循环结构

循环结构应用于一些重复的进程

通常我们只接触两种循环

for-in循环和while循环

for-in循环适用于

确切的知道到底循环几次

while循环适用于

不知道到底有几次循环

此时要搭配bool来进行

即True和Flase

关键字

关键字的熟练运用对于今后的开发工作

有非常重要的作用，但这么多关键字我们不能***记硬背

只有在一个一个代码的验证当中去熟悉去掌握

那样是最可靠的

def设置模组

len计算字符串长度

capitalize获得字符串首字母大写的拷贝

upper获得字符串变大写后的拷贝

find从字符串中查找子串所在位置

index与find类似但找不到子串时会引发异常

startswith检查字符串是否以指定的字符串开头

endswith检查字符串是否以指定的字符串结尾

center将字符串以指定的宽度居中并在两侧填充指定的字符

rjust将字符串以指定的宽度靠右放置左侧填充指定的字符

isdigit检查字符串是否由数字构成

isalpha检查字符串是否以字母构成

isalnum检查字符串是否以数字和字母构成

append添加元素

remove删除元素

clear清空元素

sorted排序

大家可能会有些疑惑，学习这些东西真的有用吗?这些随处可见的基础方面的知识真的有用吗?

我可以非常肯定地告诉大家

有用的!

这些知识就像是建筑工地随处可见的砖石，不管这些砖石怎样的不起眼，但是没有一幢建筑可以离开砖石，学习的过程是枯燥的，不过这也正符合非常现实的一条规律。

学如逆水行舟，不进则退!

也正是因为它枯燥苦闷，学习有难度，才保证了，我们学习了这些知识以后，可以靠它们为生，在这个知识时代闯出自己的一片天!

不要放弃，绝对不要放弃!

黎明之前是最黑暗的!

为了自己的未来好好坚守吧!

青年学记陪伴着各位青年

Python教学心得4

011月，一群编程零基础的小伙伴们成立了Python学习小组，12名学员从此夜以继日地奔赴学习的征程。一个月过去了，从在屏幕上用最简单的语句打印出“Hello,Python; Hello,World”开始，我们逐步地学习Python语法，学习操作列表、字典，学习For，While，If语句，现在遇到了第一个难点：类。通过研读、练习、交流、讨论，作为程序界的小白，我们逐步地理解了类的概念，明白了面向对象与面向过程编程的差异，以下是我们的'小小心得，与大家分享：

编程基本思想

现实世界中，每个复杂的事务都可以拆分为多个组成部分，其中的每一部分就可称之为对象。比如要实现一个很大很复杂的项目，我们可以把项目拆分成不同的组成部分，然后分别对不同部分通过编程实现，最终再把各个部分组装起来完成整个项目。这让我们能够从整体上来控制项目，从而让程序开发更有效。

比如汽车制造，汽车厂所做的仅仅是各个部件的组装和匹配，而各个部件的生产是由相对专业的厂商完成。如果需要研发新型号汽车，整车厂所考虑的是如何对各个新式的零部件进行新的组装和匹配，而不是从头到尾重新生产一辆汽车。

面向对象的编程

VS

面向过程的编程

面向过程编程是针对一个需求的具体实现过程，但是对于大型项目的复杂需求，一步一步的做，这种编程效率显然是低下的。

面向对象编程则是对项目进行拆分后(一般按照功能拆分)，分别实现，再将各个对象组装起来。因此简单的小程序使用面向过程方法编程更适合。面向对象的编程特性是易维护(可读性高)，效率高，质量高(重用性)，扩展性好(高内聚,低耦合)。

对象

通俗的讲，对象就是事物，一个公司、一个部门、一个人，甚至一本书都可以是一个对象，程序员可以自由决定把什么作为对象。

比如eHR系统，需要对组织架构，员工进行管理，所以使用的对象可能是公司，部门，岗位，员工，等等。对象可大可小，可复杂也可简单，如果仅仅是做一个考勤系统，员工这个对象一定要比eHR系统中的员工对象简单。

类

现实世界中，类代表一组有共同特性的事物，把不同对象之间的共性抽象出来，就形成类的概念。比如说男人、女人可以抽象成人这个类;处长、秘书可以抽象成员工类。至于类如何去抽象，粒度的粗细，这是一个需要在学习和实践中摸索的过程。

实例

以下是一个实例，大家体会一下：

1.定义父类：

class Employee:

def __init__(self, name, age): #抽象员工共性(名字，年龄)

self.name = name

self.age = age

def signON(self):

print(self.name+“ sign on.”) #抽象签到的动作

def work(self):

print(self.name + “ on work.”) #抽象工作的动作

2.继承出子类：

class MEmployee(Employee): #继承父类的共性

def __init__(self, name, age):

super.__init__(name, age)

def work(self): #重写子类的方法(抽象出从事管理岗位工作的动作)

print(self.name + “ on manager_work.”)

3.继承出第二个子类：

class TEmployee(Employee):

def __init__(self, name, age, devLanguage): #继承父类的共性，增加语言的属性

super().__init__(name, age)

self.devLanguage = devLanguage

def work(self): #重写子类的方法(抽象出从事技术岗位工作的动作)

print(self.name + “ on technology_work.”)

def showLanguage(self): #增加子类的方法(抽象出会某种编程语言的动作)

print(“use ”+self.devLanguage+“ language.”)

在上面的程序中，我们先定义了一个父类：包含员工的姓名、年龄等一般特性，可以执行签到、工作这两类动作。在第一个子类中，管理层在前面一般特性的基础上，执行管理工作;在第二个子类中，作为一般员工在前面一般特性的基础上，执行技术工作，从事编程。

Python教学心得5

python是一门非常有潜力的高级语言，历经多年的发展，其在编程上发挥着越来越大的作用。在这学期中，通过选修python课上的基础知识学习，我对python也有了一定的认识。而且，在字符串上的处理，python相对于c语言也是给程序员极大的便利。而python不仅如此，它的库也很多，正因为它强大的库，让编程变得不再艰难。但是，我认为python虽然在许多方面相对于c语言比较方便，但也有其相对于弱一点的方面，比如说for循环等方面。虽然一学期下来，我对python的学习也仅仅只是它的基础方面，但python的强大，也是足足地吸引着我，希望自己能够在不断地学习中，将python学习的更加好。

python是一门非常有潜力的高级语言，历经多年的发展，其在编程上发挥着越来越大的作用。在这学期中，通过选修python课上的基础知识学习，我对python也有了一定的认识。

在学习python的第一节课上，其对我的最初的印象就是，相较于我学习过的c语言编程，它更加的简洁。所有的变量都不需要像c语言编程那样需要提前去定义，这样给了编程者很大的自由空间与方便。如x=2，即可同时完成变量的定义与赋值。对于简化程序的代码，起到了许多的作用。而且，在字符串上的处理，python相对于c语言也是给程序员极大的便利。在c语言中，只能用字符类的数组对字符串进行相应的操作，步骤也是相对于比较繁琐的，而在python中，当我们需要创建一个字符串的时候，只需要在创建字符串的时候用“s=”就可以了。而python不仅如此，它的库也很多，正因为它强大的库，让编程变得不再艰难。我们只需要调用库中的函数，而对于函数的具体实现，也没有特殊的需求。

但是，我认为python虽然在许多方面相对于c语言比较方便，但也有其相对于弱一点的方面，比如说for循环等方面。不过也依然不会影响到python的强大，而随着近几年来的发展，python的受欢迎度也越来越高，而它的运用的领域也是越来越多，比如人工智能和大数据等领域，python都是在其中扮演者重要的角色。虽然一学期下来，我对python的学习也仅仅只是它的基础方面，但python的强大，也是足足地吸引着我，希望自己能够在不断地学习中，将python学习的更加好。