rtpdhw01

摘要: 上来就是满满鸡汤，工作经历，作品，以及关于生活，现实性问题的探讨阐述、python历史，基础知识简介之类。

一、喂汤第一步

　　1、套路一，各种美好前景，各种和牛x人士共事之经历，各种美好前程简介

　　2、Follow Me，以后各种美好的生活，tesla之类，不是梦想而是目标；

　　　But，师傅领进门，修行靠个人，脚踏实地，沉下心来，一步一个脚印，在这个浮躁的社会，静下来才能看清楚并顺其自然实现自己的目标

 

二、编程入门仪式(生活要有仪式感，随便的人生，不会精彩)

　　虽然很烦这些套路，但是仪式感，这个梗，吃 

　　首先Python版本选择，工作中线上版本还是2.6版本，但是本课程是按照3.0的版本来教学的，为了方便后续的工作和学习，贪一个，

　　python2.6,2.7,3.3一个不落下的全部安装上，步骤如下：

　　1、下载对应版本Python安装包（Windows版本）

　　2、运行下载的MSI安装包，在选择安装组件的一步时，勾上所有的组件：

　　

　　特别要注意选上 pip 和 Add python.exe to Path ，然后一路点“Next”即可完成安装，当然路径可以自定义。

　　其他版本的python按照上述步骤处理即可

　　接下来就是配置系统环境变量

　　 

　　点击 Environment Variables 

　　

　　新增Python安装路径

　　如：;D:\Soft\Python33\

　　 win + r 调用windows命令行界面

　　

　　出现如图界面代表环境变量配置OK

　　Python多版本配置类似

　　3、言归正传，hellow world! 走起

　　(现在python3.x几乎已经得到所有python2.x强大的第三方库的支持)

　　不选择python2.7因为官方公告，Python2.7只支持到2020年

　　

 

三、变量

　　变量定义：　　　　

　　　　1、变量名只能是字母、数字、下划线的任意组合。

　　　　2、变量名的一个字符不能是数字。

　　　　3、以下关键字 系统保留变量名，有特殊含义 不能声明为变量名：

　　　　[and,as,assert,break,class,continue,def,del,elif,else,except,exec,finally,for,from,global,if,import,in,is,lambda,not,

　　　　or,pass,print,raise,return,try,while,with,yield]

　　　　4、python命名规范详述

　　变量赋值：

　　　　在Python中变量名规则与其他大多数高级语言一样，都是受C语言影响的，另外变量名是大小写敏感的。
　　　　Python是动态类型语言，也就是说不需要预先声明变量类型，变量的类型和值在赋值那一刻被初始化，

　　　　下面详细介绍了Python的变量赋值问题

　　　　我们先看一下如下代码:

　　　　

　　　　输出结果：

　　　　

 

　　　　Python 属于动态语言，程序的结构可以在运行的过程中随时改变，而且 python 还是弱类型的语言，所以如果你是从静态、

　　　　强类型编程语言转过来的，理解起 Python 的赋值，刚开始可能会感觉有些代码有点莫名其妙。

　　　　可能你会以为上面代码的输出会是这样的：

　　　　

　　　　你可能认为 a 没有被改变，因为没有看到哪里对它做了改变；b 和 d 的改变是和明显的；

　　　　c呢，因为是在函数内被改变的，你可能认为 c 会是一个局部变量，所以全局的 c 不会被改变。

　　　　实际上，这里的 a, b, c, d 同时指向了一块内存空间，这可内存空间保存的是一个字典对象。

　　　　这有点像 c 语言的指针，a, b, c, d 四个指针指向同一个内存地址，也就是给这块内存其了 4

　　　　个笔名。所以，不管你改变谁，其他三个变量都会跟着变化。那为什么 c 在函数内部被改变，

　　　　而且没有用 global 申明，但全局的 c 却被改变了呢？

　　　　我们再来看一个例子：　

　　　　

　　　　当 b = a 时，a 与 b 指向同一个对象，所以在 a 中添加一个元素时，b 也发生变化。而当 a = 4 时， a 就已

　　　　经不再指向字典对象了，而是指向一个新的 int 对象（python 中整数也是对象），这时只有 b 指向字典，所以

　　　　a 改变时 b 没有跟着变化。这是只是说明了什么时候赋值变量会发生质的改变，而以上的问题还没有被解决。

 　　　　那么，我么再来看一个例子：

　　　　

　　　　由以上的实例可以了解到，如果仅改变对象的属性（或者说成是改变结构），所有指向该对象的变量都会随之改变。

　　　　但是如果一个变量重新指向了一个对象，那么其他指向该对象的变量不会随之变化。所以，最开始的例子中，c 虽然

　　　　在函数内部被改变，但是 c 是全局的变量，我们只是在 c 所指向的内存中添加了一个值，而没有将 c 指向另外的变量。

　　　　需要注意的是，有人可能会认为上例中的最后一个输出应该是 d['g'].x: 8。 这样理解的原因可能是觉得已经把字典中

　　　　 ‘g' 所对应的值取出来了，并重新命名为 xx，那么 xx 就与字典无关了。其实际并不是这样的，字典中的 key 所对应的

　　　　 value 就像是一个指针指向了一片内存区域，访问字典中 key 时就是去该区域取值，如果将值取出来赋值给另外一个变量，

　　　　例如 xx = d['g'] 或者 xx = d.get("g", None)，这样只是让 xx 这个变量也指向了该区域，也就是说字典中的键 ‘g' 和 xx

　　　　 对象指向了同一片内存空间，当我们只改变 xx 的属性时，字典也会发生变化。

　　　　下例更加直观的展示了这一点：

　　　　

　　　　这个知识点非常简单，但如果没有理解，可能无法看明白别人的代码。这一点有时候会给程序设计带来很大的便利，例如设计一个在整个程序中保存状态的上下文：

　　　　

　　　　示例中我们可以把需要保存的状态添加到 context 中，这样在整个程序的运行过程中这些状态能够被任何位置被使用。

　　　　在来一个终结的例子，执行外部代码：

　　　　outer_code.py

from __future__ import print_function
 
def initialize(context):
 g.a = 333
 g.b = 666
 context.x = 888
 
def handle_data(context, data):
 g.c = g.a + g.b + context.x + context.y
 a = np.array([1, 2, 3, 4, 5, 6])
 print("outer space: a is %s" % a)
 print("outer space: context is %s" % context)

main_exec.py

from __future__ import print_function
 
import sys
import imp
from pprint import pprint
 
class Context(object):
 pass
 
class PersistentState(object):
 pass
 
 
# Script starts from here
 
if __name__ == "__main__":
 outer_code_moudle = imp.new_module('outer_code')
 outer_code_moudle.__file__ = 'outer_code.py'
 sys.modules["outer_code"] = outer_code_moudle
 outer_code_scope = code_scope = outer_code_moudle.__dict__
 
 head_code = "import numpy as np\nfrom main_exec import PersistentState\ng=PersistentState()"
 exec(head_code, code_scope)
 origin_global_names = set(code_scope.keys())
 
 with open("outer_code.py", "rb") as f:
 outer_code = f.read()
 
 import __future__
 code_obj = compile(outer_code, "outer_code.py", "exec", flags=__future__.unicode_literals.compiler_flag)
 exec(code_obj, code_scope)
 # 去除掉内建名字空间的属性，仅保留外部代码中添加的属性
 outer_code_global_names = set(outer_code_scope.keys()) - origin_global_names
 
 outer_func_initialize = code_scope.get("initialize", None)
 outer_func_handle_data = code_scope.get("handle_data", None)
 
 context = Context()
 context.y = 999
 outer_func_initialize(context)
 outer_func_handle_data(context, None)
 
 g = outer_code_scope["g"]
 assert g.c == 2886
 print("g.c: %s" % g.c)
 print(dir(g))
 print(dir(context))
 pprint(outer_code_moudle.__dict__)

　　　　简单版变量赋值(赋值的本质)：

　　　　Python 中的变量名有些类似于C++中的指针的概念.　　　　

>>> var = 3
>>> tmp = var
>>> var
3
>>> tmp
3
>>> id(var)
10417272
>>> id(tmp)
10417272
>>> id(3)
10417272

　　

>>> var = 4
>>> id(var)
10417260
>>> id(4)
10417260
>>> id(tmp)
10417272
>>> tmp
3
>>> var
4
>>>

　　　　上边的例子指出, 当执行 "var = 3" 时, python会在内存中分配一块空间, 把"3"赋值给这块空间.

　　　　然后, 将变量名 "var" 关联到分配的内存.

　　　　当执行 "var = 4" 时, python 会再分配一块内存并存入"4", 然后将变量名 "var" 关联到"4" 所在内存.

　　　　此时"3"所在的内存并没有变化.

　　　　分配内存编号10417272, 存入"3"

　　　　将"var" 关联到 10417272

　　　　>>> var = 4 

　　　　分配内存编号10417260, 存入"4"

　　　　将"var" 关联到 10417260

　　　　>>> tmp
　　　　3

　　　　>>> id(tmp)
　　　　10417272

　　　　此时10417272中的内容没有破坏, 仍然是"3", 并且"tmp"仍然指向10417272 

　　　　事实上,当没有任何变量名指向一个内存中的变量时, python将释放该内存变量

 

四、字符编码和二进制

　　二进制：由烽火戏诸侯的典故引出相关二进制表示的需求和原理，类似中国的太极，比较基础的内容，可以参考百度百科-二进制

　　字符编码：Alex也粗略的讲了下，详情可以参考百度百科-字符编码

• 　　ASCII、GB2312（big5是支持中文繁体的）、GBK1.0、GB18030。
• 　　这里要解释的是PC端都支持GB18030。手机端只支持到GB2312。
• 　　所以可能会出现乱码。 解决方法是使用utf-8。
• 　　Unicode（万国码、统一码、单一码）
• 　　utf-8只是其中一个格式。个人建议以后代码都使用utf-8。

　　注释：

　　　　单行注释

　　　　多行注释

　　　　如下图：

　　　　　　

 

五、用户交互程序

　　1、最简单的获取用户输入账户密码，如下图所示。

　　　　代码：

　　　　　　

　　　　输出：

　　　　　　

　　　　By the way:input()获取到的内容，都是字符串类型(对象)

　　2、低效率方法，Python实际编程中不推荐使用

　　　　代码：

　　　　　　

　　　　输出：

　　　　　　

　　3、格式化字符串的一种常用方式%s %d

　　　　如下图：

　　　　　　

　　4、格式化字符串之format{0}占位符

　　　　如下图：

　　　　　　

　　5、格式化字符串之format {name}占位符

　　　　如下图：

　　　　　　

　　6、if...elif...else判断之最简单的例子

　　　　代码：

　　　　　　

　　　　输出：

　　　　　　

　　7、if...elif...else判断之完整的例子--猜年龄

　　　　代码：

　　　　　　

　　　　基本的逻辑都很简单和清晰，具体的例子可以自己运行得到

　　8、while...else...循环

　　　　代码：

　　　　　　

　　9、for循环

　　　　代码：

　　　　　　

 

 　　10、 for循环之任性玩

　　　　代码：

　　　　　　

　　　　有个小小的巧妙之处，善于发现，会节省很多流程，实现的方式有多种，可以多途径尝试