Python基础学习笔记

编译语言：C，java

解释语言：php,javascript,  需要保留源代码，需要解释器    维护方便，可移植性强

Python 中文为蟒蛇

拥有者是Python Software Foundation简称PSF，非盈利组织

1989年诞生    2000年 2.0版本    2008年 3.0版本

Python是 通用语言、脚本语言、开源语言、跨平台语言、多模块语言

Python主页下载安装Python基本开发和运行环境：https://www.python.org/downloads/

启动Python的方法：1、cmd-》Python

                                     2、IDLE

                                     3、保存到文本文件如：hello.py   运行：Python hello.py

                                     4、打开IDLE，点击Ctrl+N新建一个窗口，输入语句并保存，点F5运行

                                     5、将Python集成到Eclipse或PyCharm中

思考程序最基本的方法：IPO

                                            Input、Process、Output

编写程序的步骤：分析问题、确定问题、设计算法、编写程序、调试测试、升级维护

Python程序元素分析

1、缩进：

1个缩进=4个空格

缩进用以在Python代码中表明层次关系

缩进是程序语言中表明程序框架的唯一手段

2、注释：

单行注释：以#开头

多行注释：以‘‘‘开头和结尾（三个单引号）

3、变量：

程序中最长使用，能够表示值的一个名称

使用变量前要对变量进行赋值，不然Python编译器会报错

4、命名

命名规则，使用数字、字母和下划线组成，但首字母必须是大小写字母或下划线，不能有空格，中文等非字母符号也可以作为名字

区分大小写

33个保留字：

5、空格的使用

1）表示缩进关系的空格不能省略

2）空格不能分割一个命名

3）除上面两条外，可以在程序任意地方加空格，增加代码的可读性

6、输入函数

input（）函数从控制台获得用户输入。

使用方法：<变量>=input（<提示性文字>）

获得的输入以字符串的形式保存在变量中

7、表达式

Python中的字符串以单引号或双引号表示

如果字符串长度是l,那么他的第一个字节索引值为0或-l;做后一个字节的索引值为l-1或-1

如果val="28C"

val[-1]就是最后一个字节C

前两个字符组成的子串可以用val[0:2]表示

8、赋值语句

同步赋值

同时给多个表达式赋值，即先运算右侧的N个表达式，然后同时将表达式结果赋值给左侧

如：交换x、y的值，如使用同步赋值语句只用一行代码

9、输出函数

print（）函数通过%来表示要输出的变量

print("输出的温度是：%.2fF"%f)

10、循环语句

技术循环基本过程

for i in range(<计数值>):
    <表达式组>

蟒蛇绘制程序

Turtle库是Python语言中一个很流行的绘制图像的函数库

想象一个小乌龟，在一个横轴为x、纵轴为y的坐标系原点，(0,0)位置开始
它根据一组函数指令的控制，在这个平面坐标系中移动，从而在它爬行的路径上绘制了图形

def 用于定义函数

def所定义的函数在程序中未经调用不能直接执行，需要通过函数名调用才能够执行

import turtle
def drawSnake(rad,angle,len,neckrad):
    for i in range(len):
        turtle.circle(rad,angle)   #让小乌龟沿着一个圆形爬行，rad描述圆形轨迹半径的位置这个半径在小乌龟运行的左侧rad远位置处，如果rad为负值，则半径在小乌
        turtle.circle(-rad,angle)  #龟运行的右侧
    turtle.circle(rad,angle/2)
    turtle.fd(rad)                 #也可以用turtle.forward()表示乌龟向前直线爬行移动
    turtle.circle(neckrad+1,180)
    turtle.fd(rad*2/3)

def main():
    turtle.setup(1300,800,0,0)  #用于启动一个图形窗口，启动窗口的宽度，高度，窗口左上角在屏幕中的坐标位置  
    pythonsize=30
    turtle.pensize(pythonsize)  #表示小乌龟运动轨迹的宽度
    turtle.pencolor("blue")     #表示小乌龟运动轨迹的颜色采用RGB，同 turtle.pencolor(“#3B9909”)
    turtle.seth(-40)            #表示小乌龟启动时运动的方向,0表示向东，90度向北，180度向西，270度向南；负值表示相反方向
    drawSnake(40,80,5,pythonsize/2)

main()

函数库的引用

包含在安装包中的函数库：math 、 random、turtle库等

其他函数库：用户根据需求安装

Python对函数库引用的方式：

第一种方式：import <库名>                    例如：import turtle      用到函数库中函数    turtle.fd(100)

第二种方式：from <库名> import <函数名>          from <库名> import *       调用函数不需要<库名>，直接使用<函数名> ，例 >>>from turtle import *     >>>fd(100)

如果采用第一种方式，用户自定义的函数名字可以和库中函数的名字一样，例如，程序中可以定义自己的fd()函数
如果采用第二种方式，用户程序中不能用函数库中的名字定义函数，例如：程序不能定义新的fd()函数，因为库turtle中的fd()函数也是直接通过fd()调用

Python语言的类型

数字类型

整数类型

没有取值范围的限制

示例
 1010, 99, -217
 0x9a, -0X89 (0x, 0X开头表示16进制数)
 0b010, -0B101 (0b, 0B开头表示2进制数)
 0o123, -0O456 (0o, 0O开头表示8进制数)

浮点数类型

 Python语言中浮点数的数值范围存在限制，小数精度也存在限制。这种限制与在不同计算机系统有关

示例
 0.0, -77., -2.17
 96e4, 4.3e-3, 9.6E5 （科学计数法）
 科学计数法使用字母“e”或者“E”作为幂的符号，以10为基数。科学计数法含义如下：e = a * 10 的b次方

复数类型

与数学中的复数概念一致, z = a + bj， a是实数部分，b是虚数部分，a和b都是浮点类型，虚数部分用j或者J标识

对于复数z，可以用z.real获得实数部分，z.imag获得虚数部分

如

 z = 1.23e-4+5.6e+89j            z.real = 0.000123 ，z.imag = 5.6e+89

数字类型的关系

三种类型存在一种逐渐“扩展”的关系：整数 -> 浮点数 -> 复数（整数是浮点数特例，浮点数是复数特例）
不同数字类型之间可以进行混合运算，运算后生成结果为最宽类型，如：123 + 4.0 = 127.0 (整数 + 浮点数 = 浮点数)

三种类型可以相互转换

示例：
 int(4.5) = 4 （直接去掉小数部分）
 float(4) = 4.0 （增加小数部分）
 complex(4) = 4 + 0J

不支持将复数转为整数或浮点数

数字类型的判断

函数：type(x)，返回x的类型，适用于所有类型的判断

示例：

数字类型的运算

字符串类型

字符串是用双引号""或者单引号''括起来的一个或多个字符

字符串可以保存在变量中，也可以单独存在

Python语言转义符： \

Python同时允许使用负数从字符串右边末尾向左边进行反向索引，最右侧索引值是-1

可以通过两个索引值确定一个位置范围，返回这个范围的子串
格式： [:]

start和end都是整数型数值，这个子序列从索引start开始直到索引end结束，但不包括end位置

字符串之间可以通过+或*进行连接，如：

 len()函数能否返回一个字符串的长度，如：

大多数数据类型都可以通过str()函数转换为字符串，如：

字符串操作

字符串处理方法

元组类型

元组是包含多个元素的类型，元素之间用逗号分割    例如：t1 = 123,456, “hello”

元组可以是空的，t2=()

元组外侧可以使用括号，也可以不使用

元组的特点：

元组中元素可以是不同类型；

一个元组也可以作为另一个元组的元素，此时，作为元素的元组需要增加括号，从而避免歧义。

例如：

t1=123,456,("hello","China")

元组中各元素存在先后关系，可以通过索引访问元组中元素。

元组定义后不能更改，也不能删除。
与字符串类型类似，可以通过索引区间来访问元组中部分元素。

与字符串一样，元组之间可以使用+号和*号进行运算

不可变的tuple有什么意义呢？
因为tuple不可变，所以代码更安全。
如果仅考虑代码的灵活性，也可以用列表类型代替元组类型。

列表类型

基本概念:列表(list)是有序的元素集合

列表元素可以通过索引访问单个元素；

 列表与元组类似
            列表中每个元素类型可以不一样
            访问列表中元素时采用索引形式
列表与元组不同
           列表大小没有限制，可以随时修改

针对列表有一些基本操作，这些操作与字符串操作类似

示例：

列表相关方法：

示例：

对于字符串，可以通过split()函数，将字符串拆分成一个列表，默认以空格分割

math库和random库

数学库及其使用

 math库中常用的数学函数

 random库中常用的函数

随机数库及其使用

 示例

调用seed()函数，重置随机种子

再次设定相同的随机种子

当设定相同的种子后，每次调用随机函数后生成的随机数都是相同的。这就是随机种子的作用。

 因为计算机是一个确定设备，不能生成真正的随机数。所以，由计算机产生的随机数都是由一个种子开始的伪随机序列。

 相同的随机种子产生相同的伪随机数序列，也有利于程序的验证执行。

π的计算

 圆周率π是一个无理数，没有任何一个精确公式能够计算π值， π的计算只能采用近似算法。

 蒙特卡洛(Monte Carlo)方法，又称随机抽样或统计试验方法。当所求解问题是某种事件出现的概率，或某随机变量期望值时，可以通过某种“试验”的方法求解。

 简单说，蒙特卡洛是利用随机试验求解问题的方法。

 应用蒙瑞特卡罗方法求解π的步骤是这样的：

 首先构造一个单位正方形 和 1/4圆

 随机向单位正方形和圆结构抛洒大量点，对于每个点，可能在圆内或者圆外，当随机抛点数量达到一定程度，圆内点将构成圆的面积，全部抛点将构成矩形面积。圆内点数除以圆外点数就是面积之比，即π/4。随机点数量越大，得到的π值越精确。

π计算问题的IPO表示如下：

 输入：抛点的数量

 处理：对于每个抛洒点，计算点到圆心的距离，通过距离判断该点在圆内或是圆外。统计在圆内点的数量

 输出：π值

示例程序1：π的计算

from random import random
from math import sqrt
from time import clock
DARTS=1200000
hits=0
clock()
for i in range(1,DARTS):
    x,y=random(),random()
    dist=sqrt(x**2+y**2)
    if dist <=1.0:
        hits=hits+1
pi=4*(hits/DARTS)
print("Pi的值是%s"%pi)
print("程序运行时间为%-5.5ss"%clock())

DARTS值越大，π值越精确

 蒙特卡洛方法提供了一个利用计算机中随机数和随机试验解决现实中无法通过公式求解问题的思路。
 它广泛应用在金融工程学，宏观经济学，计算物理学（如粒子输运计算、量子热力学计算、空气动力学计算）等领域中。

字符串类型格式化采用 format()方法，基本使用格式是：

<模板字符串>.format(<逗号分隔的参数>)

<模板字符串>由一系列的槽组成，用来控制修改字符串中嵌入值出现的位置，其基本思想是将 format()方法的<逗号分隔的参数>中的参数按照序号关系替换到<模板字符串>的槽中。

槽用大括号({})表示，如果大括号中没有序号，则按照出现顺序替换，如图 3.1 所示。

如果大括号中指定了使用参数的序号，按照序号对应参数替换，如图 3.2 所示。调用 format()方法后会返回一个新的字符串，参数从 0 开始编号。

format()方法可以非常方便地连接不同类型的变量或内容，如果需要输出大括号，采用{{表示{，}}表示}，例如：

>>>"{}{}{}".format(" 圆周率是",3.1415926,"...")
'圆周率是 3.1415926...'
>>>" 圆周率{{{1}{2}}} 是{0}".format(" 无理数",3.1415926,"...")
'圆周率{3.1415926...}是无理数'
>>>s=" 圆周率{{{1}{2}}} 是{0}" # 大括号本身是字符串的一部分
>>>s
'圆周率{{{1}{2}}}是{0}'
>>>s.format(" 无理数",3.1415926,"...") # 当调用 format() 时解析大括号
'圆周率{3.1415926...}是无理数'

format()方法中<模板字符串>的槽除了包括参数序号，还可以包括格式控制信息。此时，槽的内部样式如下：

{<参数序号>: <格式控制标记>}

其中，<格式控制标记>用来控制参数显示时的格式，如图 3.3 所示。

<格式控制标记>包括：<填充><对齐><宽度>,<.精度><类型>6 个字段，这些字段都是可选的，可以组合使用，逐一介绍如下。

<填充>、<对齐>和<宽度>是 3 个相关字段：

<宽度>指当前槽的设定输出字符宽度，如果该槽对应的 format()参数长度比<宽度>设定值大，则使用参数实际长度。如果该值的实际位数小于指定宽度，则位数将被默认以空格字符补充。

<对齐>指参数在<宽度>内输出时的对齐方式，分别使用<、>和^三个符号表示左对齐、右对齐和居中对齐。

<填充>指<宽度>内除了参数外的字符采用什么方式表示，默认采用空格，可以通过<填充>更换。

例如：

>>>s = "PYTHON"
>>>"{0:30}".format(s)
'PYTHON '
>>>"{0:>30}".format(s)
' PYTHON'
>>>"{0:*^30}".format(s)
'************PYTHON************'
>>>"{0:-^30}".format(s)
'------------PYTHON------------'
>>>"{0:3}".format(s)
'PYTHON'

<格式控制标记>中逗号（，）用于显示数字的千位分隔符，例如：

>>>"{0:-^20,}".format(1234567890)
'---1,234,567,890----'
>>>"{0:-^20}".format(1234567890) # 对比输出
'-----1234567890-----'
>>>"{0:-^20,}".format(12345.67890)
'----12,345.6789-----'

<.精度>表示两个含义，由小数点（.）开头。对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度。

>>>"{0:.2f}".format(12345.67890)
'12345.68'
>>>"{0:H^20.3f}".format(12345.67890)
'HHHHH12345.679HHHHHH'
>>>"{0:.4}".format("PYTHON")
'PYTH'

<类型>表示输出整数和浮点数类型的格式规则。

对于整数类型，输出格式包括 6 种：
 b: 输出整数的二进制方式；
 c: 输出整数对应的 Unicode 字符；
 d: 输出整数的十进制方式；
 o: 输出整数的八进制方式；
 x: 输出整数的小写十六进制方式；
 X: 输出整数的大写十六进制方式；

>>>"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)
'110101001,Ʃ,425,651,1a9,1A9'

对于浮点数类型，输出格式包括 4 种：

 e: 输出浮点数对应的小写字母 e 的指数形式；
 E: 输出浮点数对应的大写字母 E 的指数形式；
 f: 输出浮点数的标准浮点形式；
 %: 输出浮点数的百分形式。

浮点数输出时尽量使用<.精度>表示小数部分的宽度，有助于更好控制输出格式。

>>>"{0:e},{0:E},{0:f},{0:%}".format(3.14)
'3.140000e+00,3.140000E+00,3.140000,314.000000%'
>>>"{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14)
'3.14e+00,3.14E+00,3.14,314.00%'

第4周  分支与循环

多分支

 使用if-elif-else描述多分支决策：

例：二次方程求解

异常处理

Python使用try...except...,可使程序不因为运行错误而崩溃

try:
     
except :
     
except :
     
except:
     

Python的异常处理语句还可以使用else和finally关键字

try:
     
except :
     
except :
     
except:
     
else:
     
finally:
     

如：

def main():
    try:
        number1,number2=eval(input("Enter two numbers,separated by a comma:"))
        result=number1/number2
    except ZeroDivisionError:
        print("Division by zero!")
    except SyntaxError:
        print("A comma may be missing in the input")
    except:
        print("Something wrong in the input")
    else:
        print("No exception, the result is",result)
    finally:
        print("executing the final clause")
main()

如：

import math
def main():
    print("This program finds the real solutions to a quadratic.\n")
    try:
        a,b,c=eval(input("Please enter the coefficients(a,b,c):"))
        discRoot=math.sqrt(b*b-4*a*c)
        root1=(-b+discRoot)/(2*a)
        root2=(-b-discRoot)/(2*a)
        print("\nThe solution are:",root1,root2)
    except ValueError as excObj:
        if str(excObj)=="math domain error":
            print("No Real Roots.")
        else:
            print("You didn't give me the right number of coefficients.")
    except NameError:
        print("\nYou didn't enter three numbers.")
    except TypeError:
        print("\nYour inputs were not all numbers.")
    except SyntaxError:
        print("\nYour input was not in the correct form. Missing comma?")
    except:
        print("\nSomething went wrong,sorry!")
main()

基本循环结构

n=eval(input("How many numbers?"))
sum=0.0
for i in range(n):
    x=eval(input("Enter a number>>"))
    sum=sum+x
print("\nThe average is",sum/n)

for循环-缺点

-程序开始时必须提供输入数字总数

-for循环需要提供固定循环次数

如：求10以内质数

for n in range(2,10):
    for x in range(2,n):
        if n%x==0:
            print(n,'equals',x,'*',n//x)
            break
    else:
        print(n,'is a prime number')

通用循环构造方法

交互式循环：

def main():
    sum=0.0
    count=0
    moredata="yes"
    while moredata[0]=="y":
        x=eval(input("Enter a number>>"))
        sum=sum+x
        count=count+1
        moredata=input("Do you have more numbers(yes or no)?")
    print("\nThe average of the number is",sum/count)
main()

哨兵循环：

def main():
    sum=0.0
    count=0
    x=eval(input("Enter a number(negative to quit)>>"))
    while x>0:
        sum=sum+x
        count=count+1
        x=eval(input("Enter a number(negative to quit)>>"))
    print("\nThe average of the number is",sum/count)
main()

改进：

def main():
    sum=0.0
    count=0
    xStr=input("Enter a number( to quit)>>")
    while xStr!="":
        x=eval(xStr)
        sum=sum+x
        count=count+1
        xStr=input("Enter a number( to quit)>>")
    print("\nThe average of the number is",sum/count)
main()

文件循环

def main():
    fileName=input("What file are the numbers in?")
    infile=open(fileName,'r')
    sum=0.0
    count=0
    for line in infile:
        sum=sum+eval(line)
        count=count+1
    print("\nThe average of the number is",sum/count)
main()

def main():
    fileName=input("What file are the numbers in?")
    infile=open(fileName,'r')
    sum=0.0
    count=0
    line=infile.readline()
    while line !="":
        sum=sum+eval(line)
        count=count+1
        line=infile.readline()
    print("\nThe average of the number is",sum/count)
main()

循环嵌套

def main():
    fileName=input("What file are the numbers in?")
    infile=open(fileName,'r')
    sum=0.0
    count=0
    line=infile.readline()
    while line !="":
        for xStr in line.split(","):
             sum=sum+eval(xStr)
             count=count+1
        line=infile.readline()
    print("\nThe average of the number is",sum/count)
main()

死循环
Python中可以利用死循环完成特定功能

while True:
	try:
		x=int(input("Please enter a number"))	
	except ValueError:
		print("Oops,that was no valid number.Try again...")
		break

布尔表达式

优先级从大到小：not    and    or

如： a or not b and c      等价于：（a or ((not b) and c)）

德摩根定律，not放进表达式后，and和or运算符之间发生的变化：

not(a or b)==(not a)and(not b)

not(a and b)==(not a)or (not b)

第五周 函数与递归

函数定义：使用def语句

def  ():

     

形式参数：定义函数时，函数名后面圆括号中的变量，简称“形参”。形参只在函数内部有效。

实际参数：调用函数是，函数名后面圆括号中的变量，简称“实参”。

return语句：结束函数调用，可选，没有return语句，函数体结束位置将控制权给调用方

def happy():
    print("Happy birthday to you!")
def sing(person):
    happy()
    happy()
    print("Happy birthday,dear "+person+"!")
    happy()
def main():
    sing("Mike")
    print()
    sing("Lily")
    print()
    sing("Elemer")
main()

递归定义特征：

有一个或多个基例是不需要再递归的；

多有的递归链都要以一个基例结尾。

Python默认最大递归深度900余次

例：字符串反转

def reverse(s):
    if s=="":
        return s
    else:
        return reverse(s[1:])+s[0]
def main():
    print(reverse("Hello"))
main()

例：树的绘制实例

# drawtree.py

from turtle import Turtle, mainloop

def tree(plist, l, a, f):
    """ plist is list of pens
    l is length of branch
    a is half of the angle between 2 branches
    f is factor by which branch is shortened
    from level to level."""
    if l > 5: #
        lst = []
        for p in plist:
            p.forward(l)#沿着当前的方向画画Move the turtle forward by the specified distance, in the direction the turtle is headed.
            q = p.clone()#Create and return a clone of the turtle with same position, heading and turtle properties.
            p.left(a) #Turn turtle left by angle units
            q.right(a)# turn turtle right by angle units, nits are by default degrees, but can be set via the degrees() and radians() functions.
            lst.append(p)#将元素增加到列表的最后
            lst.append(q)
        tree(lst, l*f, a, f)
  
def main():
    p = Turtle()
    p.color("green")
    p.pensize(5)
    #p.setundobuffer(None)
    p.hideturtle() #Make the turtle invisible. It’s a good idea to do this while you’re in the middle of doing some complex drawing,
    #because hiding the turtle speeds up the drawing observably.
    #p.speed(10)
    # p.getscreen().tracer(1,0)#Return the TurtleScreen object the turtle is drawing on.
    p.speed(10)
    #TurtleScreen methods can then be called for that object.
    p.left(90)# Turn turtle left by angle units. direction 调整画笔

    p.penup() #Pull the pen up – no drawing when moving.
    p.goto(0,-200)#Move turtle to an absolute position. If the pen is down, draw line. Do not change the turtle’s orientation.
    p.pendown()# Pull the pen down – drawing when moving. 这三条语句是一个组合相当于先把笔收起来再移动到指定位置，再把笔放下开始画
    #否则turtle一移动就会自动的把线画出来

    #t = tree([p], 200, 65, 0.6375)
    t = tree([p], 200, 65, 0.6375)
    
main()

turtle库学习

引入turtle库：

import turtle #或者
from turtle import *  #下文中提到的“第二种方式”

可以 turtle 库使用画笔 pen 绘制图形，表 1 给出了控制画笔绘制状态的函数。

turtle 以小海龟爬行角度来绘制曲线，小海龟即画笔，表 2 给出了控制 turtle 画笔运动的函数。

表 3 列出了与画笔颜色和字体相关的函数。