大家好，小编为大家解答python命令大全及说明的问题。很多人还不知道python常用指令大全，现在让我们一起来看看吧！
这篇文章主要介绍了python命令大全及说明，具有一定借鉴价值，需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获，下面让小编带着大家一起了解一下Python工程师考什么证书。
这篇文章主要介绍了python命令大全及说明文档，具有一定借鉴价值，需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获，下面让小编带着大家一起了解一下Python祝生日快乐创意代码。
刚开始学习一门语言方法很重要，下面是一些非常实用的方法总结，站在巨人的肩膀上才能成长的更快
1、Python常用命令
1 在cmd下 盘与盘之间的切换 直接 D或d: 就好
2 查找当前盘或者文件下面的目录 直接 dir
3 想在一个盘下进去一个文件夹，用cd空格目标文件 cd p
4 写文件的第一个字母后 按tab键自动补全 如果有多个p开头的则在按tab 会在所有之间切换
5 d:切盘 dir 查找目录 cd 进去目标文件（相当于双击）
6 往上走一层 cd .. 走两层 cd ../..(之间有无空格都行)
7 用python打开一个预先用记事本打好的txt 则先打开python f:\Demo\hello.txt 这串代码即可
8 是什么样的文件就要用什么类型的后缀
9 每次运行都要找到python的路径比较麻烦，将python加入到环境变量中则可以直接调用程序，
我的电 脑--属性--高级系统设置--高级--环境变量--找到path--将python的路径加进去即可
10 将任一个程序加入环境变量 单击程序图标右键--属性--复制‘目标'--将目标加入path
（;分号一定 在英文状态下，然后复制，不用全复制，将.exe一串剪切下来），
打开cmd，输入粘贴，即可打开程序。
11 变量的具体要有描述性，比如mike是一个name name=‘mike'让人一看就知道是一个名字，习惯
12 变量命名当有两个单词可以用下划线_分隔 student_number
13 用全部大写的变量名来代表常量python自学好学嘛。
14 用引号包起来的为字符串，他会在内存中占用一个位置，而变量名不占，它指向内存中的字符串
15 del删除变量 del age 即可 手动拆 强拆 或者指向其他内存
16 在py2x vision里 想要打印中文 则需要在前面加上u‘'表示把类型变成unicode 万国码
17 notepad++复制当前行 ctrl+D
18 在notepad++上改完一定要保存 在cmd中才能正确运行
19 在cmd中找文件路径 多用tab键去补全，在每一个盘下面都可以打pathon直接运行程序，后边也用tab
20 input('str') 则str: 此构成交互
21 cmd出错行数与notepad++相对应
22 在pad中有行操作，光标应在所在行的最后边（end）或者在此行上
23 判断相等则为== =为赋值
24 每一个句子后边要加上：表示一句完了
通过缩进来判断要执行接下来的哪些代码
25 tab !=（不等于） 4个空格
26 else不能单独出现 要与if 在同一级别 在中间不能有同一级别
27 最好每打一个tab自动成4个空格（原来tab与4个空格不一样，要空格都空个，要tab都tab，
但官方 不建议tab），制表符为tab pad++ 设置 首选项 语言 制表符设置 转换为空格
28 视图 显示符号 显示空格与制表符
29 elif作为多种条件判断符 在if与else之间
以上为我日常学习Python的一个总结，希望能帮助到你。2、除此之外还整理了职场中Python面试高频考点
1.Python中pass语句的作用是什么？
pass语句什么也不做，一般作为占位符或者创建占位程序，pass语句不会执行任何操作。
2.Python是如何进行类型转换的？
Python提供了将变量或值从一种类型转换成另一种类型的内置函数。比如int函数能够将符合数学格式数字型字符串转换成整数。
否则，返回错误信息。
3.Python是如何进行内存管理的？
Python引用了一个内存池(memory pool)机制，即Pymalloc机制(malloc:n.分配内存)，用于管理对小块内存的申请和释放。
4.dict 的 items() 方法与 iteritems() 方法的不同？
items方法将所有的字典以列表方式返回，其中项在返回时没有特殊的顺序；
iteritems方法有相似的作用，但是返回一个迭代器对象
5.什么是lambda函数？它有什么好处?
编程中提到的 lambda 表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。
Python允许你定义一种单行的小函数。定义lambda函数的形式如下：labmda 参数：表达式lambda函数默认返回表达式的值。
你也可以将其赋值给一个变量。lambda函数可以接受任意个参数，包括可选参数，但是表达式只有一个。
6.说明os,sys模块不同，并列举常用的模块方法？
官方解释：
os： This module provides a portable way of usingoperating system dependent functionality.
翻译：提供一种方便的使用操作系统函数的方法。
sys：This module provides access to some variablesused or maintained by the interpreter and to functions that interact stronglywith the interpreter.
翻译：提供访问由解释器使用或维护的变量和在与解释器交互使用到的函数。
os 常用方法
20os.remove()删除文件
os.rename()重命名文件
os.walk()生成目录树下的所有文件名
os.chdir()改变目录
os.mkdir/makedirs创建目录/多层目录
os.rmdir/removedirs删除目录/多层目录
os.listdir()列出指定目录的文件
os.getcwd()取得当前工作目录
os.chmod()改变目录权限
os.path.basename()去掉目录路径，返回文件名
os.path.dirname()去掉文件名，返回目录路径
os.path.join()将分离的各部分组合成一个路径名
os.path.split()返回（dirname(),basename())元组
os.path.splitext()(返回filename,extension)元组
os.path.getatime\ctime\mtime分别返回最近访问、创建、修改时间
os.path.getsize()返回文件大小
os.path.exists()是否存在
os.path.isabs()是否为绝对路径
os.path.isdir()是否为目录
os.path.isfile()是否为文件
sys 常用方法
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.modules.keys() 返回所有已经导入的模块列表
sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
sys.exit(n) 退出程序，正常退出时exit(0)
sys.hexversion 获取Python解释程序的版本值，16进制格式如：0x020403F0
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.maxunicode 最大的Unicode值
sys.modules 返回系统导入的模块字段，key是模块名，value是模块
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout 标准输出
sys.stdin 标准输入
sys.stderr 错误输出
sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息
sys.exec_prefix 返回平台独立的python文件安装的位置
sys.byteorder 本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'
sys.copyright 记录python版权相关的东西
sys.api_version 解释器的C的API版本
sys.version_info
7.Python里面如何拷贝一个对象？deepcopy 和 copy的区别？
copy 仅拷贝对象本身，而不拷贝对象中引用的其它对象。
deepcopy 除拷贝对象本身，而且拷贝对象中引用的其它对象。
8.os.path和sys.path的区别？
os.path是module，包含了各种处理长文件名(路径名)的函数。
sys.path是由目录名构成的列表，Python 从中查找扩展模块( Python 源模块, 编译模块,或者二进制扩展). 启动 Python 时,
这个列表从根据内建规则,PYTHONPATH 环境变量的内容, 以及注册表( Windows 系统)等进行初始化.
9.re模块中match和search方法的不同？
match() 函数只检查 RE 是否在字符串开始处匹配，而search() 则是扫描整个字符串。
10.解释生成器(generator)与函数的不同，并实现和使用简单generator？
生成器和函数的主要区别在于函数 return avalue，生成器 yield a value同时标记或记忆point of the yield 以便于在下次调用时从标记点恢复执行。
yield 使函数转换成生成器，而生成器反过来又返回迭代器。
11.解释一下 WSGI 和 FastCGI 的关系？
CGI全称是“公共网关接口”(CommonGateway Interface)，HTTP服务器与你的或其它机器上的程序进行“交谈”的一种工具，其程序须运行在网络服务器上。 CGI可以用任何一种语言编写，只要这种语言具有标准输入、输出和环境变量。如php,perl,tcl等。
FastCGI像是一个常驻(long-live)型的CGI，它可以一直执行着，只要激活后，不会每次都要花费时间去fork一次(这是CGI最为人诟病的fork-and-execute模式)。它还支持分布式的运算, 即 FastCGI 程序可以在网站服务器以外的主机上执行并且接受来自其它网站服务器来的请求。
FastCGI是语言无关的、可伸缩架构的CGI开放扩展，其主要行为是将CGI解释器进程保持在内存中并因此获得较高的性能。众所周知，CGI解释器的反复加载是CGI性能低下的主要原因，如果CGI解释器保持在内存中并接受FastCGI进程管理器调度，则可以提供良好的性能、伸缩性、Fail- Over特性等等。
WSGI的全称为： PythonWeb Server Gateway Interface v1.0 （Python Web 服务器网关接口），
它是 Python 应用程序和 WEB 服务器之间的一种接口。
它的作用，类似于FCGI 或 FASTCGI 之类的协议的作用。
WSGI 的目标，是要建立一个简单的普遍适用的服务器与 WEB 框架之间的接口。
Flup就是使用 Python 语言对 WSGI 的一种实现，是可以用于 Python 的应用开发中的一种工具或者说是一种库。
Spawn-fcgi是一个小程序，这个程序的作用是管理fast-cgi进程，那么管理wsgi进程也是没有问题的，功能和php-fpm类似。
故，简单地说，WSGI和FastCGI都是一种CGI，用于连接WEB服务器与应用程序，而WSGI专指Python应用程序。而flup是WSGI的一种实现，Spawn-fcgi是用于管理flup进程的一个工具，可以启动多个wsgi进程，并管理它们。
12.解释一下 Django 和 Tornado 的关系、差别
Django源自一个在线新闻 Web站点，于 2005 年以开源的形式被释放出来。
Django 框架的核心组件有：
用于创建模型的对象关系映射为最终用户设计的完美管理界面一流的 URL 设计设计者友好的模板语言缓存系统等等
它鼓励快速开发,并遵循MVC设计。Django遵守 BSD版权，最新发行版本是Django
1.4，于2012年03月23日发布.Django的主要目的是简便、快速的开发数据库驱动的网站。它强调代码复用,多个组件可以很方便的以“插件”形式服务于整个框架，Django有许多功能强大的第三方插件，你甚至可以很方便的开发出自己的工具包。这使得Django具有很强的可扩展性。它还强调快速开发和DRY(Do Not RepeatYourself)原则。
Tornado是 FriendFeed使用的可扩展的非阻塞式 web 服务器及其相关工具的开源版本。这个 Web 框架看起来有些像 web.py 或者 Google 的 webapp，不过为了能有效利用非阻塞式服务器环境，这个 Web 框架还包含了一些相关的有用工具和优化。
Tornado 和现在的主流 Web 服务器框架（包括大多数Python 的框架）有着明显的区别：它是非阻塞式服务器，而且速度相当快。得利于其 非阻塞的方式和对epoll的运用，Tornado 每秒可以处理数以千计的连接，这意味着对于实时 Web服务来说，Tornado 是一个理想的 Web 框架。我们开发这个 Web 服务器的主要目的就是为了处理 FriendFeed 的实时功能 ——在 FriendFeed 的应用里每一个活动用户都会保持着一个服务器连接。（关于如何扩容 服务器，以处理数以千计的客户端的连接的问题。
13.解释下django-debug-toolbar的使用
使用django开发站点时，可以使用django-debug-toolbar来进行调试。在settings.py中添加’debug_toolbar.middleware.DebugToolbarMiddleware’到项目的MIDDLEWARE_CLASSES 内。
14.解释下Django使用redis缓存服务器
为了能在Django中使用redis，还需要安装redis for Django的插件。然后在Django的settings中配置了。现在连接和配置都已经完成了，接下来是一个简单的例子：
from django.conf import settings
from django.core.cache import cache
#read cache user id
def read_from_cache(self, user_name):
key = 'user_id_of_'+user_name
value = cache.get(key)
if value == None:
data = None
else:
data = json.loads(value)
return data
#write cache user id
def write_to_cache(self, user_name):
key = 'user_id_of_'+user_name
cache.set(key, json.dumps(user_name), settings.NEVER_REDIS_TIMEOUT)
15.如何进行Django单元测试
Django的单元测试使用python的unittest模块，这个模块使用基于类的方法来定义测试。类名为django.test.TestCase,继承于python的unittest.TestCase。
from django.test import TestCase
from myapp.models import Animal
class AnimalTestCase(TestCase):
def setUp(self):
Animal.objects.create(name="lion", sound="roar")
Animal.objects.create(name="cat", sound="meow")
def test_animals_can_speak(self):
"""Animals that can speak are correctly identified"""
lion = Animal.objects.get(name="lion")
cat = Animal.objects.get(name="cat")
self.assertEqual(lion.speak(), 'The lion says "roar"')
self.assertEqual(cat.speak(), 'The cat says "meow"')
执行目录下所有的测试(所有的test*.py文件)：运行测试的时候，测试程序会在所有以test开头的文件中查找所有的test cases(inittest.TestCase的子类),自动建立测试集然后运行测试。
$ python manage.py test
执行animals项目下tests包里的测试：
$ python manage.py testanimals.tests
执行animals项目里的test测试：
$ python manage.py testanimals
单独执行某个test case：
$ python manage.py testanimals.tests.AnimalTestCase
单独执行某个测试方法：
$ python manage.py testanimals.tests.AnimalTestCase.test_animals_can_speak
为测试文件提供路径：
$ python manage.py testanimals/
通配测试文件名：
$ python manage.py test--pattern="tests_*.py"
启用warnings提醒：
$ python -Wall manage.py test
16.解释下Http协议
HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。
HTTP协议的主要特点可概括如下：
1.支持客户/服务器模式。
2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。
3.灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。
4.无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。
5.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，
则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。
17.解释下Http请求头和常见响应状态码
Accept:指浏览器或其他客户可以接爱的MIME文件格式。可以根据它判断并返回适当的文件格式。
Accept-Charset：指出浏览器可以接受的字符编码。英文浏览器的默认值是ISO-8859-1.
Accept-Language：指出浏览器可以接受的语言种类，如en或en-us，指英语。
Accept-Encoding：指出浏览器可以接受的编码方式。编码方式不同于文件格式，它是为了压缩文件并加速文件传递速度。浏览器在接收到Web响应之后先解码，然后再检查文件格式。
Cache-Control：设置关于请求被代理服务器存储的相关选项。一般用不到。
Connection：用来告诉服务器是否可以维持固定的HTTP连接。HTTP/1.1使用Keep-Alive为默认值，这样，当浏览器需要多个文件时(比如一个HTML文件和相关的图形文件)，不需要每次都建立连接。
Content-Type：用来表名request的内容类型。可以用HttpServletRequest的getContentType()方法取得。
Cookie：浏览器用这个属性向服务器发送Cookie。Cookie是在浏览器中寄存的小型数据体，它可以记载和服务器相关的用户信息，也可以用来实现会话功能。
状态代码有三位数字组成，第一个数字定义了响应的类别，且有五种可能取值：
1xx：指示信息–表示请求已接收，继续处理
2xx：成功–表示请求已被成功接收、理解、接受
3xx：重定向–要完成请求必须进行更进一步的操作
4xx：客户端错误–请求有语法错误或请求无法实现
5xx：服务器端错误–服务器未能实现合法的请求
常见状态代码、状态描述、说明：
200 OK //客户端请求成功
400 Bad Request //客户端请求有语法错误，不能被服务器所理解
401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用
403 Forbidden //服务器收到请求，但是拒绝提供服务
404 Not Found //请求资源不存在，eg：输入了错误的URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable //服务器当前不能处理客户端的请求，一段时间后可能恢复正常
eg：HTTP/1.1 200 OK （CRLF）
3、一些学习开发建议
1. 首先
建议1、理解 Pythonic 概念—-详见 Python 中的《Python之禅》
建议2、编写 Pythonic 代码
（1）避免不规范代码，比如只用大小写区分变量、使用容易混淆的变量名、害怕过长变量名等。有时候长的变量名会使代码更加具有可读性。
（2）深入学习 Python 相关知识，比如语言特性、库特性等，比如Python演变过程等。深入学习一两个业内公认的 Pythonic 的代码库，比如Flask等。
建议3：理解 Python 与 C 的不同之处，比如缩进与 {}，单引号双引号，三元操作符？， Switch-Case 语句等。
建议4：在代码中适当添加注释
建议5：适当添加空行使代码布局更加合理
建议6：编写函数的 4 个原则
（1）函数设计要尽量短小，嵌套层次不宜过深
（2）函数声明应该做到合理、简单、易用
（3）函数参数设计应该考虑向下兼容
（4）一个函数只做一件事，尽量保证函数粒度的一致性
建议7：将常量集中在一个文件，且常量名尽量使用全大写字母
2. 编程惯用法
建议8：利用 assert 语句来发现问题，但要注意，断言 assert 会影响效率
建议9：数据交换值时不推荐使用临时变量，而是直接 a, b = b, a
建议10：充分利用惰性计算（Lazy evaluation）的特性，从而避免不必要的计算
建议11：理解枚举替代实现的缺陷（最新版 Python 中已经加入了枚举特性）
建议12：不推荐使用 type 来进行类型检查，因为有些时候 type 的结果并不一定可靠。如果有需求，建议使用 isinstance 函数来代替
建议13：尽量将变量转化为浮点类型后再做除法（Python3 以后不用考虑）
建议14：警惕eval()函数的安全漏洞，有点类似于 SQL 注入
建议15：使用 enumerate() 同时获取序列迭代的索引和值
建议16：分清 == 和 is 的适用场景，特别是在比较字符串等不可变类型变量时（详见评论）
建议17：尽量使用 Unicode。在 Python2 中编码是很让人头痛的一件事，但 Python3 就不用过多考虑了
建议18：构建合理的包层次来管理 Module
3. 基础用法
建议19：有节制的使用 from…import 语句，防止污染命名空间
建议20：优先使用 absolute import 来导入模块（Python3中已经移除了relative import）
建议21：i+=1 不等于 ++i，在 Python 中，++i 前边的加号仅表示正，不表示操作
建议22：习惯使用 with 自动关闭资源，特别是在文件读写中
建议23：使用 else 子句简化循环（异常处理）
建议24：遵循异常处理的几点基本原则
（1）注意异常的粒度，try 块中尽量少写代码
（2）谨慎使用单独的 except 语句，或 except Exception 语句，而是定位到具体异常
（3）注意异常捕获的顺序，在合适的层次处理异常
（4）使用更加友好的异常信息，遵守异常参数的规范
建议25：避免 finally 中可能发生的陷阱
建议26：深入理解 None，正确判断对象是否为空。
建议27：连接字符串应优先使用 join 函数，而不是+操作
建议28：格式化字符串时尽量使用 format 函数，而不是 % 形式
建议29：区别对待可变对象和不可变对象，特别是作为函数参数时
建议30：[], {}和()：一致的容器初始化形式。使用列表解析可以使代码更清晰，同时效率更高
建议31：函数传参数，既不是传值也不是传引用，而是传对象或者说对象的引用
建议32：警惕默认参数潜在的问题，特别是当默认参数为可变对象时
建议33：函数中慎用变长参数 args 和 kargs
（1）这种使用太灵活，从而使得函数签名不够清晰，可读性较差
（2）如果因为函数参数过多而是用变长参数简化函数定义，那么一般该函数可以重构
建议34：深入理解 str()和 repr() 的区别
（1）两者之间的目标不同：str 主要面向客户，其目的是可读性，返回形式为用户友好性和可读性都比较高的字符串形式；而 repr 是面向 Python 解释器或者说Python开发人员，其目的是准确性，其返回值表示 Python 解释器内部的定义
（2）在解释器中直接输入变量，默认调用repr函数，而print(var)默认调用str函数
（3）repr函数的返回值一般可以用eval函数来还原对象
（4）两者分别调用对象的内建函数 __str__ ()和 __repr__ ()
建议35：分清静态方法 staticmethod 和类方法 classmethod 的使用场景
4. 库的使用
建议36：掌握字符串的基本用法
建议37：按需选择 sort() 和 sorted() 函数
sort() 是列表在就地进行排序，所以不能排序元组等不可变类型。
sorted() 可以排序任意的可迭代类型，同时不改变原变量本身。
建议38：使用copy模块深拷贝对象，区分浅拷贝（shallow copy）和深拷贝（deep copy）
建议39：使用 Counter 进行计数统计，Counter 是字典类的子类，在 collections 模块中
建议40：深入掌握 ConfigParse
建议41：使用 argparse 模块处理命令行参数
建议42：使用 pandas 处理大型 CSV 文件
Python 本身提供一个CSV文件处理模块，并提供reader、writer等函数。
Pandas 可提供分块、合并处理等，适用于数据量大的情况，且对二维数据操作更方便。
建议43：使用 ElementTree解析XML
建议44：理解模块 pickle 的优劣
优势：接口简单、各平台通用、支持的数据类型广泛、扩展性强
劣势：不保证数据操作的原子性、存在安全问题、不同语言之间不兼容
建议45：序列化的另一个选择 JSON 模块：load 和 dump 操作
建议46：使用 traceback 获取栈信息
建议47：使用 logging 记录日志信息
建议48：使用 threading 模块编写多线程程序
建议49：使用 Queue 模块使多线程编程更安全
5. 设计模式
建议50：利用模块实现单例模式
建议51：用 mixin 模式让程序更加灵活
建议52：用发布-订阅模式实现松耦合
建议53：用状态模式美化代码
6. 内部机制
建议54：理解 build-in 对象
建议55：__init__ ()不是构造方法，理解 __new__ ()与它之间的区别
建议56：理解变量的查找机制，即作用域
局部作用域
全局作用域
嵌套作用域
内置作用域
建议57：为什么需要self参数
建议58：理解 MRO（方法解析顺序）与多继承
建议59：理解描述符机制
建议60：区别 __getattr__ ()与 __getattribute__ ()方法之间的区别
建议61：使用更安全的 property
建议62：掌握元类 metaclass
建议63：熟悉 Python 对象协议
建议64：利用操作符重载实现中缀语法
建议65：熟悉 Python 的迭代器协议
建议66：熟悉 Python 的生成器
建议67：基于生成器的协程和 greenlet，理解协程、多线程、多进程之间的区别
建议68：理解 GIL 的局限性
建议69：对象的管理和垃圾回收
7. 使用工具辅助项目开发
建议70：从 PyPI 安装第三方包
建议71：使用 pip 和 yolk 安装、管理包
建议72：做 paster 创建包
建议73：理解单元测试的概念
建议74：为包编写单元测试
建议75：利用测试驱动开发（TDD）提高代码的可测性
建议76：使用 Pylint 检查代码风格
代码风格审查
代码错误检查
发现重复以及不合理的代码，方便重构
高度的可配置化和可定制化
支持各种 IDE 和编辑器的集成
能够基于 Python 代码生成 UML 图
能够与 Jenkins 等持续集成工具相结合，支持自动代码审查
建议77：进行高效的代码审查
建议78：将包发布到 PyPI
8. 性能剖析与优化
建议79：了解代码优化的基本原则
建议80：借助性能优化工具
建议81：利用 cProfile 定位性能瓶颈
建议82：使用 memory_profiler 和 objgraph 剖析内存使用
建议83：努力降低算法复杂度
建议84：掌握循环优化的基本技巧
减少循环内部的计算
将显式循环改为隐式循环，当然这会牺牲代码的可读性
在循环中尽量引用局部变量
关注内层嵌套循环
建议85：使用生成器提高效率
建议86：使用不同的数据结构优化性能
建议87：充分利用 set 的优势
建议88：使用 multiprocessing 模块克服 GIL 缺陷
建议89：使用线程池提高效率
建议90：使用 Cythonb 编写扩展模块4、基础练习
1.编写第一个程序（python 3）
print('hello world!')
复制代码2.查看python 版本号
python -v
复制代码3.使用变量
message = 'hello world!'
print(message)
复制代码4.字符串
name = 'jetty'
print(name.title()) #Jetty 首字母大写
print(name) jetty
name.upper() #JEETY 转大写
name.lower() #jetty 转小写
复制代码5.合并拼接字符串
first_name = 'hongzhu'
last_name = 'zhan'
full_name = last_name +" "+ first_name
print(full_name) zhan hongzhu
复制代码6.使用制表来添加空白
language = 'python\nJava\nC\nRust'
print(language)
打印
python
Java
C
Rust
复制代码7.删除空白
_blank = ' python '
print(_blank.rstrip()) #去除右侧空白
print(_blank.strip()) #去除两侧空白
print(_blank.lstrip()) #去除左侧空白
复制代码8.变量类型
num = 2.340
print(int(num)) #整型 2
print(float(num)) #浮点型 2.34
复制代码9.列表
color = ['red','green','yellow','pink']
#访问元素
print(color[0]) ##red
#修改
color[0] = 'black'
#添加元素
color.append('orange')
#插入元素
color.insert(0,'blue') #插到第一位
print(color)
#删除元素
del color[0] #删除当前元素
color.pop() #删除数组最后一个元素
color.remove('red') #删除红色
复制代码10 组织列表
10.1排序列表
num_list = [1,2,3,4,2,1,3,1,2]
num_list.sort()
print(num_list) [1, 1, 1, 2, 2, 2, 3, 3, 4]
复制代码10.2临时排序
num_list = [1,2,3,4,2,1,3,1,2]
print(sorted(num_list)) [1, 1, 1, 2, 2, 2, 3, 3, 4]
复制代码10.3reverse 反序
num_list = [1,2,3,4,2,1,3,1,2]
num_list.reverse()
print(num_list) [2, 1, 3, 1, 2, 4, 3, 2, 1]
复制代码10.4列表的长度
num_list = [1,2,3,4,2,1,3,1,2]
print(len(num_list)) 9
复制代码11 遍历列表
num_list = [1,2,3,4,2,1,3,1,2]
for i in num_list:
print(i,end=" ") #一行显示
复制代码12.使用函数遍历
num_list = [1,2,3,4,2,1,3,1,2]
for i in range(len(num_list)):
print(num_list[i],end=" ")
复制代码13.乘方运算
squares = []
for i in range(1,6):
squares.append(i**2)
print(squares) [1, 4, 9, 16, 25]
复制代码14.内置函数
num_list = [1,2,3,4,2,1,3,1,2]
print(max(num_list)) 4
print(min(num_list)) 1
print(sum(num_list)) 19
复制代码15.列表解析
squeres = [value**2 for value in range(1,11)]
print(squeres) [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
复制代码16.练习示例
16.1 1-50奇数的和
odd_number =[]
for i in range(1,11,2):
odd_number.append(i)
print(sum(odd_number))
复制代码16.2 3-90 3的倍数
three_nmu = []
for i in range(3, 91):
if (i % 3==0):
three_nmu.append(i)
print(three_nmu)
复制代码16.3 1-10 的立方
squares = []
for i in range(3,11):
squares.append(i**3)
print(squares)
复制代码16.4 1-10 的立方列表解析
squares = [i**3 for i in range(3,11)]
print(squares)
复制代码17 列表切片
num_list = [1,2,3,4,2,1,3,1,2]
print(num_list[0:5]) [1, 2, 3, 4, 2] #从第一个开始取值到第五位
print(num_list[:5]) [1, 2, 3, 4, 2] #默认会从第一个开始取值
print(num_list[5:]) [1, 3, 1, 2] #取后面的4位
复制代码18 元组
dimensions = (100,300)
print(dimensions[0]) 100
for i in dimensions:
print(i) 100 300
复制代码19 if 语句
num_list = [1, 2, 3, 4, 2, 1, 3, 1, 2]
for i in num_list:
if i == 2:
print(i)
复制代码20 !=
num_list = [1, 2, 3, 4, 2, 1, 3, 1, 2]
for i in num_list:
if i != 2:
print(i)
复制代码21 and
num_list = [1, 2, 3, 4, 2, 1, 3, 1, 2]
for i in num_list:
if i >=1 and i <=2:
print(i)
复制代码22 字典
alien = {'color':0,'points':1}
print(alien['color']) ##color
复制代码23 修改字典
alien = {'color':0,'points':1}
alien['color'] = 'red'
print(alien) {'color': 'red', 'points': 1}
复制代码24 删除字典
alien = {'color':0,'points':1}
del alien['color']
print(alien)
复制代码25 案例练习
25.1创建两个人的字典，存储在列表，遍历列表，输出列表
people_nums1 = {'name':'jetty','name1':'jack'}
people_nums2 ={'name':'kitty','name1':'james'}
peoples = [people_nums1,people_nums2]
for i in peoples:
print(i)
复制代码26.用户输入和while循环
ipt = input('你是小黄么？1(true) or 2(false)?')
if ipt =='1':
print('是本人')
else:
print('不是本人')
复制代码27 % //运算符
print(4 % 2) 0
print(4 // 2) 2
复制代码28 while运算符
count = 0
arr = []
while count < 20:
for j in range(1, 100):
if j % 11 == 0:
count = count+1
arr.append(j)
print(arr)
复制代码29 函数
#简单求和
def num_sum(arr):
result =0
for i in arr:
result =result+i
return result
print(num_sum([1,2,3,4])) 10
复制代码30 函数默认值
def num_sum(arr=[1,2,3]):
result =0
for i in arr:
result =result+i
return result
print(num_sum()) 6
复制代码31 传递任意数量的实参
def make_prize(*top):
return top
print(make_prize(1))
print(make_prize(1,2,3))
print(make_prize(1,3,4,5))
print(make_prize(1,1,1,1,1))
#返回
(1,)
(1, 2, 3)
(1, 3, 4, 5)
(1, 1, 1, 1, 1)
复制代码32 导入函数
# 随机数
import random
print(random.randint(1,19))
复制代码33 类
class Dog():
def __init__(self,name,age):
self.name =name
self.age = age
def sit(self):
print(self.name+''+self.age)
dog = Dog('jeety',24)
print(dog.name)
复制代码34 类 汽车里程表
class Car():
def __init__(self,make,model,year):
self.make = make
self.model = model
self.year = year
def getCarName(self):
print(self.model)
car = Car('audi','ad4',2016)
print(car.make)
复制代码35 子类方法 init()
class Car():
def __init__(self,name):
self.name = name
class Elastic(Car):
def __init__(self, name):
super().__init__(name)
myTesla = Elastic('tesla')
print(myTesla.name)
复制代码36 class实例
class Car():
def __init__(self,make,name,color):
self.make = make
self.name = name
self.color = color
def getCarName(self):
print('获取车的名字为'+self.name+'获取汽车的颜色'+self.color)
class Batery():
def __init__(self,batery='60'):
self.batery = batery
def discribe_batery(self):
print('This car has'+str(self.batery)+'batery')
class Elatrity(Batery):
def __init__(self, batery):
super().__init__(batery)
self.batery = Batery()
elatrity = Elatrity('100')
print(elatrity.discribe_batery())
复制代码37 文件和异常
f = open('file.txt',mode="w",encoding='utf-8')
print(f)
f.write('叫我詹躲躲\n')
f.write('叫我詹躲躲1\n')
f.close()
复制代码38 将数据存入json文件
import json
numbers = [1,2,23,3,4,5,6,7,87]
filename = 'numbers.json'
with open(filename,'w') as f_obj:
json.dump(numbers,f_obj)
复制代码39 保存和读取用户生成的数据
import json
username = input('存储输入的数据')
filename = 'numbers.json'
with open(filename,'w') as f_obj:
json.dump(username,f_obj)
复制代码40 读取用户输入的信息
import json
filename = 'numbers.json'
with open(filename) as f_obj:
username = json.load(f_obj)
print('Welcome back',username)
复制代码41 输入和合并数据
import json
filename = 'numbers.json'
try:
with open(filename) as f_obj:
username = json.load(f_obj)
except FileNotFoundError:
username = input('存储输入的数据')
with open(filename,'w') as f_obj:
json.dump(username,f_obj)
else:
print('Welcome back',username)
复制代码42 封装成为一个函数
import json
def get_username():
filename = 'numbers.json'
try:
with open(filename) as f_obj:
username = json.load(f_obj)
except FileNotFoundError:
return None
else:
return username
def get_greeting():
username = get_username()
if username:
print('Welcome back',username)
else:
username = input('存储输入的数据')
filename = 'numbers.json'
with open(filename,'w') as f_obj:
json.dump(username,f_obj)
print('Welcome back',username)
get_greeting()
复制代码43 文件读取
f = open('index.txt',encoding='utf-8')
s = f.read()
print(s)
f.close()
复制代码44 文件写入
f = open('index.txt',mode="w",encoding='utf-8')
f.write('叫我詹躲躲n')
f.write('叫我詹躲躲1n')
f.close()
复制代码43 第三方库安装和使用
import random
random.randint() #随机数
import jieba #结巴
import wordcloud #词云
jieba.lcut('分割中文词语的序列') #分割中文词语的序列
word_cloud = wordCloud(font_path='msyh.ttc').generate('分割中文词语') #生成词云对象
word_cloud.to_file('123.png') #保存到图片
复制代码44 python 里面的类和对象
#面向对象编程
class Person:
def __init__(self,name,sex,birthday):
self.name = name
self.sex = sex
self.birthday = birthday
def say(self,word):
print(f'{self.name}说："{word}"')
zhang_san = Person('张三','男','2020202')
zhang_san.say('12121')
复制代码45.输出 %占位符
lastname = 'hello'
firstname = 'world'
print('我的名字是%s %s' %(lastname,firstname))
复制代码46.常用的格式化字符
%c #字符
%s #通过str来格式化
%i #有符号十进制整数
%d #有符号十进制整数
%u #无符号十进制整数
%o #八进制整数
%x #十六进制整数（小写字母）
%e #索引符号（小写e)
%E #索引符号（大写E)
%f #浮点实数
%g #%f和%e的简写
%G #%f和%E的简写
复制代码47 格式化的其他方式 format
name = '老夫子'
age = 28
print('姓名:{},年龄{}'.format(name,age))
#姓名:老夫子,年龄28
复制代码48 .匿名函数
48.1lambda 参数1，参数2，参数3：表达式
#特点:
#1.使用lambda关键字创建函数
#2.没有名字的函数
#3.匿名函数冒号后面的表达式有且只有一个，是表达式不是语句
#4.自带return
复制代码48.2.lambda 示例1
def computer(x,y):
#计算两数和
return x+y
M = lambda x,y:x+y
print(M(1,2))
复制代码48.3.lambda 示例1
result = lambda a,b,c:a*b*c
print(result(12,121,1))
复制代码48.4 lambda 三元表达式模拟
age = 15
print('可以参军' if age>18 else '继续上学')
#直接调用
result = (lambda x,y:x if x>y else y)(2,5)
复制代码49.递归函数
#阶乘函数
def factorial(n):
if n==1:
return 1
else:
return n*factorial(n-1)
pass
print(factorial(3))
复制代码49.1 递归案例 模拟实现 树形结构的遍历
import os 文件操作模块
def findFile(file_path):
listRs = os.listdir(file_path) 得到该路径所有的文件夹
for fileItem in listRs:
full_path = os.path.join(file_path,fileItem)
if os.path.isdir(full_path): 判断是否为文件夹
findFile(full_path)
else:
print(fileItem)
pass
pass
else:
return
findFile('F:\\7.代码学习')
复制代码50.python的内置函数
abs(-27) #绝对值
round(21.1123) #浮点近似值
pow(2,3) #幂 2**3
divmod(10,3) # 商余
max(1,2,3,4) #最大值
min(1,2,3,4) #最小值
sum(1,2,3,4) #求和
eval() #动态执行表达式
复制代码51.类型转换函数
int #整型
float #浮点型
str #字符类型
ord #返回对应字符的ASCII
chr #数字转字符 ASCII
bool #boolean
bin # 转换二进制
hex #转换为十六进制
oct #八进制
list #元祖转列表
tuple #元祖
dict #创建字典
bytes #转为字节
复制代码52.可迭代参数 all
#all 用于判定给定的可迭代参数中的所有元素是否都为TRUE,如果是返回TRUE，否则返回FALSE,除了0，空，False 外都算TRUE
def all(iterable):
for ele in iterable:
if not ele:
return False
return True
li = [1,2,3,4,5,6,False]
print(all(li)) ##False
复制代码53 可迭代参数 any
#全部为false,返回false
def any(iterable):
for ele in iterable:
if ele:
return False
return True
li = [0,False,'']
print(any(li)) ##False
复制代码54.enumerate 列出遍历数据和下标
li = ['a','b','c']
for index,item in enumerate(li,7):
print(index,item)
#改下标
7 a
8 b
9 c
复制代码55.set集合 不支持索引和切片，无序不重复
55.1.创建集合1
set1 = {'1','2'}
set2 = {'11','1'}
#添加 add
set1.add('3')
#清空 clear()
set1.clear()
#取差集 difference
set1.difference(set2) ##set1取set1中有的
#取交集
set1.intersection(set2)
#取并集
set1.union(set2)
set1 | set2
#末尾移除
set1.pop()
#指定移除
set1.discard(3)
#更新 update 合并一起去重
set1.update(set2)
复制代码55.2 练习题1 三组数据求和
1-10,20-30，35-40
def threeSum(a1,a2,a3):
return sum(a1+a2+a3)
a1 = list(range(1,11))
a2 = list(range(20,31))
a3 = list(range(35,41))
print(threeSum(a1,a2,a3))
复制代码55.3练习题2 大小和尚多少个
def computers():
for i in range(1,101):
for j in range(1,34):
if i+j==100 and 3*j+i/3 ==100:
print('大和尚有{}个，小和尚有{}个'.format(j,i))
pass
computers()
#大和尚有25个，小和尚有75个
复制代码55.4 练习题3 找出独一无二的数据
li = [1,1,1,2,2,2,2,3,2,2,3,4,2,1,1]
def findUnionNumber(li):
for item in li:
if li.count(item)==1:
return item
pass
print(findUnionNumber(li))
复制代码56.字典统计每个元素的次数
dict ={}
for key in li:
dict[key] = dict.get(key,0)+1
print(dict)
复制代码56.1.collection包下Counter类统计
from collections import Counter
a = [1, 2, 3, 1, 1, 2]
result = Counter(a)
print(result)
复制代码56.2.pandas包下的value_counts方法统计
import pandas as pd
a = pd.DataFrame([[1,2,3],
[3,1,3],
[1,2,1]])
result = a.apply(pd.value_counts)
print(result)
复制代码56.3.利用set找出独一无二的数据
li = [1,2,3,3,2,3,4,4,5,1,2,1]
def uniqueNum(li):
set1 = set(li)
for i in set1:
li.remove(i)
set2 = set(li)
for j in set2:
set1.remove(j)
return set1
print(uniqueNum(li))
复制代码57 面向对象编程 oop
#面向过程编程 根据业务从上到下开始编程
#类的结构
#类名 属性 方法
class People:
name = 'zhan',
age = 20,
def eat(self):
print('正在吃饭')
#创建对象
people = People()
people.eat()
复制代码在类的内部，使用def定义的为实例方法，第一个参数为self,实例方法归实例所有
57.1 类的实例属性添加
class People:
name = 'zhan',
age = 20,
def eat(self):
print('正在吃饭')
#创建对象
people = People()
people.eat()
#添加属性
people.name2 = 'zhan'
people.age2 = 22
复制代码57.2 类的__init__()方法
class People:
# 初始化的操作，实例属性，自动执行
def __init__(self):
self.name = 'zhan'
self.age = 20
def eat(self):
print('正在吃饭')
#创建对象
people = People()
people.eat()
复制代码57.3 类的__init__()使用参数
class People:
# 初始化的操作，实例属性，自动执行
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self,food):
print(self.name+food)
#创建对象
people = People('叫我詹躲躲', 20)
people.eat('正在吃饭')
people.eat('洗澡')
people.eat('跑步')
复制代码57.4 理解类的self
#类似于js里面的this
class Person:
def eat(self):
print(id(self))
pass
pass
person = Person()
person.eat()
print(id(person))
#self和对象指向同一个内存地址,self就是对象的引用
# <__main__.Person object at 0x0000020864815CC0>
复制代码58 魔术方法
#__init__ :初始化实例属性
# __str__ ：自定义对象的格式
# __new__ :对象实例化
class Animal:
def __str__(self):
return '3213213123123'
pass
pass
animal = Animal()
print(animal)
class Animal:
def __str__(self):
return '3213213123123'
pass
pass
def __new__(cls,*args,**kwargs):
print("----new执行---")
return object.__new__(cls) 真正创建对象实例的
pass
animal = Animal()
print(animal)
#__new__ 和__init__的区别
#__new__ 类的实例化方法，必须返回实例，否则创建不成功
#__init__数据属性的初始化工作，认为是实例的构造方法，接受实例化self并对其进行构造
#__new__ 至少一个参数是cls,代表要实例化的类
#__new__ 执行要比__init__早
复制代码59 案例练习 —— 决战紫禁之巅
# 属性：
# name:玩家名称
# blood:血量
# 方法：
# tong() 捅一刀，掉10滴血
# kanren() 砍一刀掉15滴血
# chiyao() 补血10滴血
# __str__打印玩家的状态
class Role:
def __init__(self,name,blood):
self.name = name
self.blood = blood
pass
砍人
def tong(self,enemy):
enemy.blood -=10
info = '【%s】捅了【%s】一刀'%(self.name,enemy.name)
print(info)
pass
砍人
def kanren(self,enemy):
enemy.blood -=15
info = '【%s】砍了【%s】一刀'%(self.name,enemy.name)
print(info)
pass
吃药
def chiyao(self):
self.blood +=10
info = '【%s】吃了一口药,增加10滴血'%(self.name)
print(info)
pass
def __str__(self):
return '%s还剩下%s的血量'%(self.name,self.blood)
xmcx = Role('西门吹雪',100)
ygc = Role('叶孤城',100)
while True:
if xmcx.blood<=0 or ygc.blood<=0:
break
print('*********************')
xmcx.tong(ygc)
xmcx.kanren(ygc)
print('*********************')
ygc.tong(xmcx)
ygc.chiyao()
print('*********************')
print(xmcx)
print(ygc)
"""
*********************
【西门吹雪】捅了【叶孤城】一刀
【西门吹雪】砍了【叶孤城】一刀
*********************
【叶孤城】捅了【西门吹雪】一刀
【叶孤城】吃了一口药,增加10滴血
*********************
西门吹雪还剩下50的血量
叶孤城还剩下25的血量
*********************
【西门吹雪】捅了【叶孤城】一刀
【西门吹雪】砍了【叶孤城】一刀
*********************
【叶孤城】捅了【西门吹雪】一刀
【叶孤城】吃了一口药,增加10滴血
*********************
西门吹雪还剩下40的血量
叶孤城还剩下10的血量
*********************
【西门吹雪】捅了【叶孤城】一刀
【西门吹雪】砍了【叶孤城】一刀
*********************
【叶孤城】捅了【西门吹雪】一刀
【叶孤城】吃了一口药,增加10滴血
*********************
西门吹雪还剩下30的血量
叶孤城还剩下-5的血量
"""
复制代码60 实例练习1 水果类
class Fruit:
def __init__(self,name,color):
self.name = name
self.color = color
def showColor(self):
print('%s的颜色为%s'%(self.name,self.color))
apple = Fruit('苹果','红色').showColor()
orange = Fruit('橘子','黄色').showColor()
watermelen = Fruit('西瓜','绿色').showColor()
复制代码61 验证self 就是实例本身
class CkeckSelf:
def __str__(self):
print(id(self))
pass
CkeckSelf().__str__()
selfObj = CkeckSelf()
print(id(selfObj))
复制代码62 定义animal类，输出所有的属性
class Animal:
def __init__(self, color, name, age):
self.color = color
self.name = name
self.age = age
def run(self):
print('%s在跑步'%(self.name))
pass
def eat(self):
print('%s在吃东西' %(self.name))
pass
def __str__(self):
return '%s岁的%s的%s'%(self.age,self.color,self.name)
cat = Animal('黑色','小猫',2)
dog = Animal('白色','小狗',3)
cat.run()
dog.run()
print(cat)
print(dog)
"""
小猫在跑步
小狗在跑步
2岁的黑色的小猫
3岁的白色的小狗
"""
复制代码64 简易的学生管理系统
1、显示所有学生信息
2、新建学生信息
3、查询学生信息
4、修改学生信息
5、删除学生信息
0、退出系统
复制代码student_data = [
{
'id': 123456,
'name': 'Tom',
'sex': '男',
'address': '迪士尼'
},
{
'id': 123457,
'name': 'Jerry',
'sex': '女',
'address': '伦敦'
},
]
复制代码64.1美化显示
def beauty_list(datas):
for index, student in enumerate(datas):
print(f'序号：{index}', end="t")
print(f'姓名：{student["name"]}', end="t")
print(f'性别：{student["sex"]}', end="t")
print(f'地址：{student["address"]}')
复制代码64.2输入名字
def input_name():
while True:
name = input('输入名字：').strip()
if name:
return name
else:
continue
复制代码64.3选择性别
def choose_sex():
print('1(男) | 2(女)')
n = input('选择性别')
if n == '1':
return '男'
else:
return '女'
复制代码64.4显示所有学生信息
def show_all():
beauty_list(student_data)
复制代码64.5新建学生信息
def create_student():
sid = random.randint(1000, 10000)
name = input_name()
sex = choose_sex()
address = input('地址：')
student = {
'id': sid,
'name': name,
'sex': sex,
'address': address
}
student_data.append(student)
复制代码64.6查询学生信息
def find_student():
name = input_name()
for i in student_data:
if i['name'] == name:
print(i)
return
else:
print('无该学生任何信息')
复制代码64.7修改学生信息
def edit_student():
name = input_name()
for student in student_data:
if student['name'] == name:
print(student)
student['name'] = input_name()
student['sex'] = choose_sex()
student['address'] = input('地址：')
return
else:
print('查无此人')
复制代码64.8删除学生信息
def delete_student():
name = input_name()
for student in student_data:
if student['name'] == name:
student_data.remove(student)
return
else:
print('查无此人')
while True:
print('''
********************
欢迎使用学生管理系统
1、显示所有学生信息
2、新建学生信息
3、查询学生信息
4、修改学生信息
5、删除学生信息
0、退出系统
********************
'''
)
op = input('请输入序号：')
if op == '1':
print(student_data)
show_all()
elif op == '2':
create_student()
elif op == '3':
find_student()
elif op == '4':
edit_student()
elif op == '5':
delete_student()
else:
print('退出系统')
break
5128
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
