编程基础
一组能让计算机识别和执行的指令
电子计算机
能够执行程序的机器
现代计算机
英国数学家、逻辑学家，艾伦.麦席森.图灵被称为计算机科学之父，人工智能之父。图灵提出的著名的图灵模型为现代计算机的逻辑工作方式奠定了基础
图灵机，又称图灵计算机、图灵计算机，由图灵提出的一种抽象计算机模型，即将人们使用纸笔进行数学运算的过程进行抽象，由一个虚拟的机器替代人们进行数学运算。
所谓的图灵机就是指一个抽象的机器，它有一条无限长的纸带，纸带分成一个一个的小方格，每个方格都有不同的颜色。有一个机器头在纸带上移来移去。机器头有一组内部状态，还有一些固定的程序。在每个时刻，机器头都要从当前纸带上读入一个方格信息，然后结合自己的内部状态查找程序表，根据程序输出信息到纸带方格上，并转换自己的内部状态，然后进行移动。
冯.诺依曼著名匈牙利美籍犹太人，数学家、计算机科学家、物理学家和化学家，数字计算机之父。他提出了以二进制作为数字计算机的数制基础，计算机按照程序顺序执行，应有五大部件。
1、CPU由运算器和控制器组成
2、运算器，完成各种算数运算、逻辑运算、数据传输等数据加工处理
3、控制器，控制程序的执行
4、存储器，用于记忆程序和数据，例如内存
5、输入设备，将数据或者程序输入到计算机中，例如键盘、鼠标
6、输出设备，将数据或程序的处理结果展示给用户，例如显示器、打印机
7、CPU中还有寄存器和多级缓存Cache
寄存器：寄存器是中央处理器内的组成部分。寄存器是有限存贮容量的高速存贮部件，它们可用来暂存指令、数据和地址。在中央处理器的控制部件中，包含的寄存器有指令寄存器(IR)和程序计数器(PC)。在中央处理器的算术及逻辑部件中，存器有累加器(ACC)。—可以不用过多了解。
缓存就是数据交换的缓冲区（称作Cache），当某一硬件要读取数据时，会首先从缓存中查找需要的数据，如果找到了则直接执行，找不到的话则从内存中找。由于缓存的运行速度比内存快得多，故缓存的作用就是帮助硬件更快地运行。
工作原理
1、读取顺序
CPU要读取一个数据时，首先从Cache中查找，如果找到就立即读取并送给CPU处理；如果没有找到，就用相对慢的速度从内存中读取并送给CPU处理，同时把这个数据所在的数据块调入Cache中，可以使得以后对整块数据的读取都从Cache中进行，不必再调用内存。
正是这样的读取机制使CPU读取Cache的命中率非常高（大多数CPU可达90%左右），也就是说CPU下一次要读取的数据90%都在Cache中，只有大约10%需要从内存读取。这大大节省了CPU直接读取内存的时间，也使CPU读取数据时基本无需等待。总的来说，CPU读取数据的顺序是先Cache后内存。
2、缓存分类
Intel从Pentium开始将Cache分开，通常分为一级高速缓存L1和二级高速缓存L2。在以往的观念中，L1 Cache是集成在CPU中的，被称为片内Cache。在L1中还分数据Cache（D-Cache）和指令Cache（I-Cache）。它们分别用来存放数据和执行这些数据的指令，而且两个Cache可以同时被CPU访问，减少了争用Cache所造成的冲突，提高了处理器效能。
3、读取命中率
CPU在Cache中找到有用的数据被称为命中，当Cache中没有CPU所需的数据时（这时称为未命中），CPU才访问内存。从理论上讲，在一颗拥有2级Cache的CPU中，读取L1 Cache的命中率为80%。也就是说CPU从L1 Cache中找到的有用数据占数据总量的80%，剩下的20%从L2 Cache读取。由于不能准确预测将要执行的数据，读取L2的命中率也在80%左右（从L2读到有用的数据占总数据的16%）。那么还有的数据就不得不从内存调用，但这已经是一个相当小的比例了。在一些高端领域的CPU（像Intel的Itanium）中，我们常听到L3 Cache，它是为读取L2 Cache后未命中的数据设计的—种Cache，在拥有L3 Cache的CPU中，只有约5%的数据需要从内存中调用，这进一步提高了CPU的效率。
编程基础
计算机语言
人与计算机之间交互的语言
机器语言
1、一定位数组成二进制的0和1的序列，成为机器指令。机器指令的集合就是机器语言
2、与自然语言差异太大，难学、难懂、难写、难记、难查错
汇编语言
1、用一些助记符号代替机器指令，称为汇编语言。ADD A,B指的是将寄存器A的数与寄存器B的数相加得到的数放到寄存器A中
2、汇编语言写好的程序需要汇编程序转换成机器指令
3、汇编语言只是稍微好记了些，可认为就是机器指令对应的助记符，只是符号本身接近自然语言
语言分类
低级语言
1、面向机器的语言，包括机器语言、汇编语言
2、不同的机器不能通用，不同的机器需要不同的机器指令或者汇编程序
高级语言
1、接近自然语言和数学语言的计算机语言
2、高级语言首先要书写源程序，通过编译程序把源程序转换成机器指令的程序
3、1954年正事发布的Fortran语言是最早的高级语言，本意是公式翻译
4、人们只需要关心怎么书写源程序，针对不同机器的编译的事交给编译器关心处理
二者对比:
1、语言越高级，越接近人类的自然语言和数学语言
2、语言越低级，越能让机器理解
3、高级语言和低级语言之间需要一个转换的工具：编译器、解释器
4、C、C++等语言的源代码需要本地编译
5、Java、Python、C#的源代码需要被解释器编译成中间代码（Bytecode），在虚拟机上运行
6、编译语言，把源代码转换成目标机器的CPU指令
7、解释语言，解释后转换成字节码，运行在虚拟机上，解释器执行中间代码
程序：
1、算法+数据结构=程序
2、数据一切程序的核心
3、数据结构是数据在计算机中的类型和组织方式
4、算法是处理数据的方式，算法有优劣之分
写程序的难点：
1、理不清数据
2、搞不清处理方法
3、无法把数据设计转换成数据结构、无法把处理方法转换成算法
4、无法用设计范式来进行程序设计
5、世间程序皆有bug，但不会debug
Python解释器：
1、官方CPython
C语言开发，最广泛的Python解释器
2、IPython
一个交互式、功能增强的Cpython
3、PyPy
Python语言写的Python解释器，JIT技术，动态编码
JIT技术，动态编码
4、Jython
Python的源代码变成Java的字节码，跑在JVM上
5、IronPython
与Jython类似，运行在.Net平台上的解释器，Python代码被编译成.Net的字节码
# Python基础语法
注释 #
数字
整数，不区分long（长整数）和int（整数）
进制0XA,0O10,0B10
bool,2个值True、False
int：（符号整数）通常被称为是整数或整数，没有小数点的正数或负数
long：（长整数）或渴望，无限大小的整数，这样写整数和一个大写或小写的L
Python允许你使用长L的小写，但建议您只使用一个大写字母L，以避免与数字1混淆。python长整数显示一个大写字母L。
浮点数
1.2、3.1415、-0.12、1.46e9等价于1.46*10*9
float:(浮点实际值)彩车，代表实数，小数除以整数部分和小数部分的书面。花车也可能是在科学记数法与E或指示的10次方（2.5e2 = 2.5 x 10*2 = 250）
复数，1+2j
complex:(复数)+BJ的形式，其中a、b是彩车和J（或j）表示-1的平方根（这是一个虚数）。a是真正的数字部分，b是虚部。复数不使用Python编程。
一个复杂的数字组成的有序对一个真正的浮点数字+ BJ，其中a是实部和b是复数的虚部表示
字符串
1、使用'”单双引号引用的字符的序列
2、”’ “””单双三引号，可以跨行，可以在其中自由的使用单双引号
3、在字符串前面加上R或者r前缀，表示该字符串不做特殊处理
数字转换类型
Python的数字转换内部包含一个共同的评价类型的混合型的表达。但有时，你需要明确强迫一个数字从一个类型到另一个运算符或函数的参数，以满足要求。
int类型（X）转换X到一个普通整数。
long（X）转换X到一个长整数。
float类型（X）转换X到浮点数字。
complex （x）的转换与真正的第X部和虚部为零的x到一个复杂的数量。 类型复杂（X，Y）转换x和y的第X部和虚部Ÿ复数。 x和y是数值表达式 内置数功能
数值类型实例：
int long float complex
10 51924361L 0.0 3.14j
100 -0x19323L 15.20 45.j
-786 0122L -21.9 9.322e-36j
080 0xDEFABCECBDAECBFBAEl 32.3e+18 .876j
-0490 535633629843L -90. -.6545+0J
-0x260 -052318172735L -32.54e100 3e+26J
0x69 -4721885298529L 70.2E-12 4.53e-7j
Python 保留字符
下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。
所有 Python 的关键字只包含小写字母。
and exec not
assert finally or
break for pass
class from print
continue global raise
def if return
del import try
elif in while
else is with
except lambda yield
基础语法
转义序列：
\\ \t \r \n \’ \”
model:
print(“I\’m OK.”)
I’m OK.
print(“I\’m \\OK.”)
I’m \OK.
print(“I\’m \tOK.”)
I’m OK.制表
print(“I\’m \nOK.”)
I’m 换行
OK.
print(r”I\’m OK.”)
I\’m OK. r”:”内的字符串默认不转义
print(‘\\\t\\’)
\ \
print(‘\\\n\\’)
\
\
缩进：
1、未使用C等语言的花括号，而是采用缩进的方式表示层次关系
2、约定使用4个空格缩进
续行：
1、在行尾使用\
2、如果使用各种括号，认为括号内是一个整体，内部跨行不用\
变量赋值：
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = “John” # 字符串
print counter
print miles
print name
标准数据类型
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dicionary（字典）
标识符：
1、一个名字，用来指代一个值
2、只能字母、下划线和数字
3、只能以字母或下划线开头
4、不能是python的关键字，例如def、class不能作为标识符
5、python是大小写敏感的
约定：
不允许使用中文
不允许使用歧义单词，例如class_
在python中不要随便使用下划线开头的表示符
常量：
一旦赋值就不能改变值的标识符
python中无法定义常量
字面常量：
一个单独的量，例如12、“ABC”、‘2341.09e-9’
变量：
赋值后，可以改变值的标识符
# python语言类型
1、python是动态语言、强类型语言
动态编译语言：
不用事先声明类型，随时可以赋值为其他类型
编程时不知道是什么类型，很难推断
强类型语言
不同类型之间操作，必须先强制类型转换为同一类型
运算符：
+：加，两个对象相加
-：得到负数或是一个数减去另一个数
*：两个数相乘或是返回一个被重复若干次的字符串
/：x除以y
%：取模，返回除法的余数
**：幂，返回x的y次幂
//：取整除，返回商的整数部分
备注：开篇就说过2.x和3.x区别
自然除／结果是浮点数，整除//
位运算符：
&：按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0
例如：a = 20 b =10
a&b即为：
20用二进制表示：0001 0100
10用二进制表示：0000 1010
这样得出a&b的值就为0
In [11]: a = 20
In [12]: b = 10
In [13]: print(a&b)
0
|：按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1
a|b二进制结果为：0001 1110即为30
In [14]: print(a|b)
30
^：按位异或运算符：当两个对应的二进位相异时，结果为1
In [15]: print(a^b)
30
这个刚好和a|b结果一样
假如：a = 5 b = 3
0000 0101
0000 0011
0000 0110 结果为6，而a|b为7
～：按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1
例如：～8
即： 0000 1000
按位取反：1111 0111
补位取反：0000 1001 得出值为-9
例如：60
0011 1100
1100 0011
0011 1101 得值-61
<<：左移动运算符：运算数的各二进位全部左移若干位，由”<<“右边的数指定移动的位数，高位丢弃，低位补0
In [24]: 2<<3
Out[24]: 16
值的由来：0000 0010 向左移动两位：0001 0000得值16
In [25]: 100<<2
Out[25]: 400
0110 0100
移动： 1 1001 0000 即2*8 + 2*7 + 2*4 = 400
>>：右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数
In [29]: 2 >> 2
Out[29]: 0
0000 0010 移动：0000 0000
In [30]: 200 >> 3
Out[30]: 25
1100 1000 移动 0001 1001 = 25
10^9=3 10^-9=-3
比较运算符：
== != > < >= <=
返回一个bool值
1 < ‘1’ 1 == ‘1’
==如果两个操作数的值相等，则条件为真。
!= 如果两个操作数的值不相等，则条件为真。
>如果左操作数的值大于右操作数的值，则条件成真
<如果左操作数的值小于右操作数，则条件为真
>=如果左操作数的值大于或等于右操作数的值，则成为真
<=如果左操作数的值小于或等于右操作数的值，则条件为真
逻辑运算符：
与或非 and or not
and：如果两个操作数都为真，则条件成立
or：如果两个操作数中的任何一个非零，则条件成为真
not：用于反转操作数的逻辑状态
短路运算符
and 如果第一个表达式为False，后面就没用必要计算了，这个逻辑表达式一定是False
or 如果第一个表达式True，后面没有必要计算了，这个逻辑表达式一定是True
赋值运算符：
a = min(3,5)
+= -= *= /= %=
=：将右侧操作数的值分配给左侧操作数
+=：将右侧操作数相加到左操作数，并将结果分配给左操作数
-=：从左操作数中减去右操作数，并将结果分配给左操作数
*=：将右侧操作数与左侧操作数相乘，并将结果分配给左操作数
／=：将左侧的操作数除以右操作数，并将结果分配给左操作数
%=：将左操作数除以右操作数的模数，并将结果分配给左操作数
**=：执行指数（幂）计算，并将值分配给左操作数
//=：取整除 – 返回商的整数部分
成员运算符：
in、not in
身份运算符：
is、is not
运算符优先级：
运算符 描述
** 指数(最高优先级)
~ + – 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ – 加法减法
>> << 右移，左移运算符
& 位 ‘AND’
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符
表达数：
由数字、符号、括号、变量等的组合
1、算数表达式
2、逻辑表达式
3、赋值表达式
python中，赋值即定义，如果一个变量已经定义，赋值相当于重新定义
内存管理
变量无须事先声明，也不需要指定类型
动态语言的特性
编程中一般无须关心变量的存亡，也不用关心内存的管理
python使用引用计数记录所有变量的引用数
当变量引用数变为0时，它可以被垃圾回收gc
计数增加：赋值给其它变量就增加引用计数，例如x=3;y=x
计数减少：
函数运行结束时，局部变量会自动销毁，对象引用计数减少
变量被赋值给其它对象。例如x=3;y=x;x=4
有关性能的时候，就需要考虑变量的引用问题，但是该释放内存，还是尽量不释放内存，看需求
程序控制
顺序：
按照先后循序一条条执行
分支：
根据不同的情况判断，条件满足执行某条件下的语句
循环：
条件满足就反复执行，不满足就不执行或不再执行
单分支结构：
if语句
if condition:
代码块
condition必须是一个bool类型，这个地方有一个隐式转换
if 1<2:
print(‘1 less than 2’)
代码块：
类似于if语句的冒号后面的就是一个语句块
在if、for、def、class等
多分支结构：
if…elif…else语句
if condition1:
代码块1
elif condition2:
代码块2
elif condition3:
代码块3
…
else：
代码块
分支嵌套：
score = 80
if score<0:
print(‘wrong’)
else:
if score == 0:
print(‘egg’)
elif score <= 100:
print(‘right’)
else:
print(‘too big’)
分支嵌套：
嵌套结构，可以是分支、循环的嵌套
可以互相嵌套多层
model：
score = 80
if score < 0:
print(‘wrong’)
else:
if score == 0:
print(‘egg’)
else score <= 100:
print(‘right’)
else:
print(‘too big’)
循环–while语句：
语法：
while condition:
block
当条件满足即condition为True，进入循环体，执行block
model：
flag = 10
while flag:
print(flag)
flag -= -1
循环continue语句：
中断当前循环的当次执行，继续下一次循环
model：计算10以内的偶数（for循环）
for i in range(10):
if not i%2:
print(i)
循环break语句
终止当前循环
model：
计算1000以内的被7整除的前20个数（for循环）
count = 0
for i in range(0,1000,7):
print(i)
count += 1
if count >= 20:
break
循环else子句：
语句：
while condition:
block
else:
block
for elemen in iteratable:
block
else:
block
如果循环正常的执行结束，就执行else子句；如果使用break终止，else子句不会执行
几个语句的详细解析如下：
程序控制：
if语句：
if condition condition：[kənˈdɪʃn]
代码块
condition必须是一个bool类型，这个地方有一个隐式转换bool(condition)
bool：是Boolean缩写，只有真（True）和假（False）两种取值。
bool函数只有一个参数，并根据这个参数的值返回真或者假
“”,0,(),[],{},None：值都为假
空集合：
空字符串
空字典
空列表
空元组
model：
In [21]: bool(1)
Out[21]: True
In [22]: bool(0)
Out[22]: False
In [23]: if 1<2:
…: print(‘1 less than 2’)
…:
1 less than 2
代码块：
类似于if语句的冒号后面就是一个语句块
在if、for、def、class等。
Python 编程中 if 语句用于控制程序的执行，基本形式为：
if 判断条件：
执行语句……
else：
执行语句……
model：
num = 3
name = ‘Eric’
if name == ‘Eric’:
print(‘Welcome Eric’)
else:
print(num)
结果是：Welcome Eric
if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
当判断条件为多个值时，可以使用以下形式：
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
model：
name = input(“Please enter a name: “)
if name == ‘Eric’:
print(‘Welcome 魏都酒狂泰谷子‘)
elif name == ‘zhangsan’:
print(‘old man’)
elif name == ‘lisi’:
print(‘young’)
else:
print(‘child’)
分支嵌套：
由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。
num = 9
if num >= 0 and num <= 10: # 判断值是否在0~10之间
print(‘hello’)
# 输出结果: hello
num = 10
if num < 0 or num > 10: # 判断值是否在小于0或大于10
print(‘hello’)
else:
print(‘undefine’)
# 输出结果: undefine
num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):
print(‘hello’)
else:
print(‘undefine’)
# 输出结果: undefine
练习：给定一个不超过5位的正整数，判断其有几位。
num = 13468
if num >= 1000:
if num >= 10000:
print(“5”)
else:
print(‘4’)
else:
if num >= 1000:
print(‘3’)
elif num >= 100:
print(‘2’)
else:
print(‘1’)
方法较多，不一一列举，发散思维。例如，可以使用if…elif…elif…
循环：
上面的打印出来是偶数，下面为奇数
多种实现：
那么上面的相反，把==0换成==1，打印出来的就是偶数了。
while语句：
while condition：
block #：当条件满足即condition为True，进入循环体，执行block。
num = 1
while num <9:
print(num)
num += 1 #不限定此条件的话，num从1开始，小于9，会一直循环下去，进入死循环。
while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外”判断条件”还可以是个常值，表示循环必定成立，具体用法如下：
model：
num = int(input(‘>>>’))
while num < 100:
num += 1
if num > 50:
continue
print(‘ok’)
model1:
# continue 和 break 用法
i = 1
while i < 10:
i += 1
if i % 2 > 0: # 非双数时跳过输出
continue
print(i) # 输出双数2、4、6、8、10
i = 1
while 1: # 循环条件为1必定成立
print(i) # 输出1~10
i += 1
if i > 10: # 当i大于10时跳出循环
break
从上面就可看出continue和break的区别，一个是跳出该次循环，一个是退出循环。
逆序排列：
flag=10
while flag:
print(flag)
flag -= 1
正序排列：
for i in range(10):
print(i)
加：
for i in range(10):
i+=1
print(i)
或者：
for i in range(10):
print(i+1)
count = 0
for i in range(0,10000,7):
print(i)
count += 1
if count < 4:
print(‘ok’)
else:
break
给定一个5位的正整数，判断其有几位，依次打印出个位，十位，百位，千位，万位的数字。
val = input(‘>>>’)
val = int(val)
if val >= 1000: #
if val>=10000: num = 5
else:
num = 4
else:
if val>=100:
num = 3
elif val >= 10:
num = 2
else:
num = 1
print(num)
pre = 0
for i in range(num,0,-1): #从上面的出的num值进行循环，步长-1
cur = val//(10**(i-1)) #cur的值为：输入的5位数整除10**（5-1），第一次循环得出万位数，依次类推
print(cur – pre*10) #如当num为4时，pre为1
循环else子句：
while condition:
block
else:
block
for element in iteratable:
block
else: block
练习，打印一个边长为n的正方形：
实心：
for i in range(4):
for i in range(4):
print(‘*’,end=‘ ‘)
print(‘\t‘)
空心的属于网络摘抄：
rows = int(input(‘输入列数： ‘))
for i in range(0, rows):
for k in range(0, rows):
if i != 0 and i != rows – 1:
if k == 0 or k == rows – 1:
print(” * ” ,end=“”)#由于视觉效果看起来更像正方形，所以这里*两侧加了空格，增大距离
else:
print(” “,end=“”) #该处有三个空格
else:
print(” * “,end=“”) #这里*两侧加了空格
k += 1
i += 1
print(“\t“)
2、求100以内所有奇数的和。
sum = 0
for i in range(1,100,2):
sum += i
print(sum)
本文来自投稿，不代表Linux运维部落立场，如若转载，请注明出处：http://www.178linux.com/87287
