python学习

基础语法

第一个 Python 程序

• 交互式编程

In [ ]:print ("Hello, Python!")

• 脚本式编程

通过脚本参数调用解释器开始执行脚本，直到脚本执行完毕。当脚本执行完成后，解释器不再有效。

所有 Python 文件将以 .py 为扩展名。将以下的源代码拷贝至 test.py 文件中。

Python 标识符

在 Python 里，标识符由字母、数字、下划线组成。

在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。

Python 中的标识符是区分大小写的。

Python 保留字符

保留字不能用作常数或变数，或任何其他标识符名称。

行和缩进

Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。

python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

if True:
    print ("True")
else:
  print (False")

多行语句

Python语句中一般以新行作为语句的结束符。

但是我们可以使用斜杠（ \）将一行的语句分为多行显示，

item_1 = 1
item_2 = 2
item_3 = 3
total = item_1 + \
        item_2 + \
        item_3
total

语句中包含 [], {} 或 () 括号就不需要使用多行连接符。

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']
days

Python 引号

Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，引号的开始与结束必须的相同类型的。

其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

print(word)
print(sentence)
print(paragraph)

Python模块和包

在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护。

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块（Module）。

使用模块有什么好处？最大的好处是大大提高了代码的可维护性。

模块一共三种：

• python标准库

• 第三方模块

• 应用程序自定义模块

import sys 
 
print('Python 路径为：', sys.path, '\n')

import 语句

想使用 Python 源文件，只需在另一个源文件里执行 import 语句， 当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。 如想要导入模块 support，需要把命令放在脚本的顶端：

# Filename: support.py

def print_func( par ):
    print ("Hello : ", par)
    return

test1.py 引入 support 模块：

# Filename: test1.py

# 导入模块
import support

# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

在解释器的当前目录或者 sys.path 中的一个目录里面来创建一个fibo.py的文件，代码如下：

# Filename: fibo.py
 # 斐波那契(fibonacci)数列模块

def fib(n):    # 定义到 n 的斐波那契数列
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

def fib2(n): # 返回到 n 的斐波那契数列
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

import fibo

fibo.fib2(100)

 

from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，要导入模块 fibo 的 fib 函数，使用如下语句：

from fibo import fib, fib2
fib(500)

包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。比如一个模块的名称是 A.B， 表示一个包 A中的子模块 B 。

使用模块的时候，不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。

这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库。

不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）。现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav，:file:.aiff，:file:.au，），所以你需要有一组不断增加的模块，用来在不同的格式之间转换。

并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，增加均衡器功能，创建人造立体声效果），所以你还需要一组怎么也写不完的模块来处理这些操作。这里给出了一种可能的包结构（在分层的文件系统中）:

sound/                          顶层包
      __init__.py               初始化 sound 包
      formats/                  文件格式转换子包
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  声音效果子包
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  filters 子包
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

目录只有包含一个叫做 init.py 的文件才会被认作是一个包

用户可以每次只导入一个包里面的特定模块，比如:

import sound.effects.echo

这将会导入子模块:sound.effects.echo。 必须使用全名去访问:

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

还有一种导入子模块的方法是:

from sound.effects import echo

这同样会导入子模块: echo，并且不需要那些冗长的前缀，所以可以这样使用:

echo.echofilter(input, output, delay=0.7, atten=4)

还有一种变化就是直接导入一个函数或者变量:

from sound.effects.echo import echofilter

同样的，这种方法会导入子模块: echo，并且可以直接使用 echofilter() 函数:

echofilter(input, output, delay=0.7, atten=4)

变量，表达式和语句

变量和类型

变量是指向各种类型值的名字，以后再用到某个值时，直接引用这 个名字即可，不用在写具体的值。在Python中，变量的使用环境非常宽 松。没有明显的变量声明，而且类型不是固定的。你可以把一个整数赋值 给变量，如果觉得不合适，把字符串赋值给它完全可以。

x = 100
print (x)
type(x)

x = "China"
print (x)
type(x)

 

在别的语言中这是不允许的，若把字符串赋值给整数变量是错误的。

如果不能确定变量或数据的类型，就用解释器内置的函数type确认。

type("Hello,World!")

type(17)

x = "QHD"
type(x)

 

type(3.0)

type("2.5")

变量名和关键字

程序中的变量名要有实际意义。变量名可以是由数字和字符组成的任 意长度的字符串，但必须以字母开头。python是区分大小写的。

Name = "Yaohui"
name = "Jin"
print (name, Name)

符号“ ”连接由多个单词组成的变量名。

my_name = "金耀辉"
print (my_name)

如果定义了一个错误的变量名，解释器显示语法错误。

1_first = "第一名"

my$ = "dollar"

print = 12345 #谨慎操作

 

语句

语句是Python解释器可以执行的命令。我们已经知道两条语句:打印和赋值。 赋值语句有两个作用:一是建立新的变量，二是将值赋予变量。 当打印不存在的变量时，系统给出错误信息。

message = "How are you?"
n = 18
pi = 3.1415926
print (abc)

打印语句print输出表达式的计算结果。单个变量也可以看作是表达式。如果在一行打印多个变量，可以用逗号将这些变量隔开，逗号禁止换行。

x = 3
y = 8.9
print (x, y, "hello")

特殊符号的打印方法。

print (x,"\t","n","\n",y)

表达式

表达式由值、变量和运算符组成。如果在命令行上输入表达式，可以显示结果:

23.3 + 1.2

单一的值或变量也可以当作是表达式:

45

x = 1.2
x

 

计算表达式和打印值是有很大区别:

"I am free!"

message = "I am free!"
message

print (message)

 

 

运算符和操作数

运算符是像加号和减号之类的特殊符号。运算符操作的对象是操作数。

==

add = 72 + 23
sub = 108 - 204
mul = 108 * 0.5
div = 108 / 9
po  = 3 ** 2
re  = 18 % 7
print (add, sub, mul, div, po, re)

运算的顺序

如果表达式中有不止一个运算符，那么计算的顺序依靠“优先规则”。

• 小括号有最高的优先级

• 乘幂运算的优先级仅次于小括号

(1 + 3) ** 2

3 * 3 ** 2

 

• 乘法和除法的优先级相同，比加减法的优先级高

2 + 3 * 3 + 2

4 - 10 / 5

4 * 5 / 2

 

 

• 具有相同优先权的运算符从左到右进行计算

字符串操作

通常情况下，字符串放在双引号或单引号之间。字符串不能进行除法、减法和字符串之间的乘法运算，下面的操作都是非法的:

"hello" / 3

string = "string"
string - 1

string * "hello"

 

 

加法“+”能够连接两个字符串成为一个字符串。

string1 = "Jin"
string2 = "Yaohui"
print (string1 + string2)

乘法“*”可以操作字符串。只是其中一个操作数必须是字符串，另 一个必须是整数。字符串被重复整数遍。

3 * "Love"

string = "python"
string * 2

 

注释

当程序越来越复杂时，读懂它就变得非常困难。想依靠部分的代码来了解整个程序要做的，是困难的。因此，好的习惯是在程序中加入适当的注释，以解释它要做的事情。

注释必须以符号“#”开始:

# 打印1+1的结果 
print (1 + 1)

注释可以单独占一行，也可以放在语句行的末尾:

print (1 + 1) # 打印1+1的结果

练习1

还记得小学的复利计算应用题吗？如果你将1万元存入银行，每年的利息是3%，那么7年后一共能拿到多少钱呢？请按照下面的提示完成计算。

# 创建名为savings变量，存入初始本金
savings = 100

# 创建利息变量 factor


# 计算7年后的本金利息总和 result


# 输出计算结果 result

练习2

在交互模式上尝试下面，看看会怎么有什么结果

# n=42是可以的，那42=n怎么样？


# 试试x=y=1呢？


# 有的语言每个语句结尾都必须有个单引号或者分号，试试在Python句末放个会咋样？


# 句尾放个句号试试呢？


# 数学上你可以把x和y相乘写成xy，Python里面你这么试试看？

函数

函数

函数调用的例子

type("world") 

函数type,它的作用是显示值和变量的类型。括号内的变量和值是函数的参数。函数返回的结果叫返回值。

函数定义

函数的定义形式如下：

def add(p1, p2):
    print (p1, "+", p2, "=", p1+p2)

add(1, 2) 

 

函数的目的是把一些复杂的操作隐藏，来简化程序的结构，使其容易阅读。函数在调用前，必须先定义。 程序调用函数时，转到函数 内部执行函数内部的语句，函数执行完毕后，返回到它离开程序的地方， 执行程序的下一条语句。

函数的行参和实参

def subtracter(p1, p2): 
    print (p1, "-", p2, "=", p1-p2) 

var1 = 3.1415 
var2 = 4.0987 
subtracter(var1, var2) 

在这个例子中，函数subtracter有两个参数: p1和p2。他们是函数的行参。 变量var1和var2是函数的实参。实参把它的值传递给行参，行参被函数内的语句进行各种操作，而实参没有被改变。

函数也可以将表达式当作它的参数:

def display(arg): 
    print (arg)  
a1 = 4.5
a2 = 3 
display(a1 + a2) 

函数的返回值

函数的返回值，例如计算圆的面积

def area(radius): 
    atemp = 3.1415 * radius ** 2 
    return atemp 
area(2.0)

表达式还可以进一步简化成如下的形式

def area1(radius): 
    return 3.1415 * radius ** 2 
area1(3.0)

类型转换

将变量或值从一种类型转换成另一种类型的内置函数。例如int函数能够将符合数学格式数字型字符串转换成整数。否则，返回错误信息。

int('32') 

int('Hello') 

 

函数int也能够把浮点数转换成整数，但浮点数的小数部分被截去。 

int(3.99999)

int(-2.3)

 

函数float将整数和字符串转换成浮点数:

float(32)

float('3.14159')

 

函数str将数字转换成字符:

str(32)

str(3.14159)

 

练习3

写一个名叫right_justify的函数，形式参数是名为s的字符串，将字符串打印，前面流出足够的空格，让字符串最后一个字幕在第70列显示。

条件表达式

布尔表达式

布尔表达式的值只有两个: 真和假。 在Python语言中，真值为1，假值为0。

• x == y #x等于y
• x != y #x不等于y
• x > y #x大于y
• x < y #x小于y
• x >= y #x大于等于y
• x <= y #x小于等于y

x = 3.4
y = 9
z = 4.55

x == y

x != z

x > y

y > x

z <= y

 

逻辑操作符

Python有三种逻辑操作: and、or、not。分别是:与、或、非。

a = 1
b = 0 
a and b

a or b

not a

not 0

 

 

条件语句

在程序执行的过程中，时常依据一些条件的变化，改变程序的执行流程。

if (x > 0): 
    print (x) 

第二种if语句的形式是有两个执行流程，关键字else(否则)引出另一个程序流程。

if x%2 == 0: 
    print (x, "is even”) 
else: 
    print (x, "is odd”) 

程序的分支不止两个，可能是三个，或更多。

def largeNumber(x, y):
    if x < y:
        print (x, "小于", y)
    elif x > y:
        print (x, "大于", y)
    else:
        print (x, "等于", y)

largeNumber(3, 6)

while语句

计算机最擅长做自动的、重复性的工作，而且不会出错。

def f(x): 
    result = 0 
    while x > 0:   
        result = result + x 
        x = x - 1 
    return result

f(10)

f(10)

• 计算循环的条件，将得到1或0;
• 如果条件为0，退出while循环，执行循环外的语句;
• 如果条件为1，执行while块内的每一条语句，然后返回第一步。

条件嵌套

一个条件可以包含在另一个条件中。

逻辑操作符提供了简化条件嵌套的方法。

x = 8.9
if x > 0:
    if x < 10:
        print ("x大于0且小于10")

第二种写法利用了and操作符，易于阅读。

if (0 < x) and (x < 10):
    print ("x大于0且小于10")

第三种写法与数学上的很相似。

if 0 < x < 10:
    print ("x大于0且小于10")

return语句

return在函数中返回函数值。它的另一个作用是当函数内有错误发生时，终止函数的运行，提前退出。

I

def printc(a, b):
    if  (a-b) < 0:
        print ("a小于b") 
    return
    
    print (sqrt(a - b))

printc(3,6)

练习4

奇的数学家拉马努金发现了一个无穷级数（1914年的论文），能够用来计算圆周率倒数的近似值：

 

写一个名叫estimate_pi的函数，用上面这个方程来计算并返回一个圆周率π的近似值。要使用一个while循环来计算出总和的每一位，最后一位要小于10的-15次方。你可以对比一下计算结果和Python内置的math.pi。

字符串

组合数据类型

数据类型:int、float和string。

string类 型与其它两种类型的数据还有本质的区别，因为它是由多个字符组成的。 我们可以把字符串当成一个整体，也可以取得字符串的任何部分。

name = "qswtp"
print (name[0])

print (name[4])

len(name)

 

 

字符串片断

字符串的一部分叫做片断。选取片段与选单个取字符很相似:

os = "Linux Unix FreeBSD"
print (os[0:5])

操作符[n:m]返回字符串的一部分，从第n个字符开始，到第m个字符结 束，包括第n个，但不包括第m个。如果你忽略了n，则返回的字符串从索 引0开始;如果忽略了m，则字符串从n开始，到最后一个字符。

print (os[11:])

如果试图用“[]”操作符修改字符串中的任何一个字符，将产生运行时错误。

love = "python" 
love[0] = P

字符串的值是不可改变的。可以取原字符串的一部分和添加的字符串相加，生成一个新的字符串:

I

newstr = "P" + love[1:] 
print (newstr) 

练习5

写一个名叫 avoids 的函数，接收一个单词和一个禁用字母组合的字符串，如果单词不含有该字符串中的任何字母，就返回真。

修改一下程序代码，提示用户输入一个禁用字母组合的字符串，然后输入不含有这些字母的单词数目。

你能找到5个被禁用字母组合，排除单词数最少吗？

列表

列表是一组任意类型的值，按照一定顺序组合而成的。组成列表的值 叫做元素(Elements)。每一个元素被标识一个索引，第一个索引也是0。列 表中的元素可以是任意类型，甚至是列表类型，也就是说列表可以嵌套。

列表值

列表中的元素用中括号括起来，以逗号分割元素。

[10, 20, 30, 40]

["spam", "bungee", "swallow"]

["hello", 2.0, 5, [10,20]]

 

 

列表的元素还可以是变量。但是修改变量的值，并不影响列表中元素 的值。

a = 1
b = 2
num = [a, b, 3]
print(num)

a = b = 9

print(a, b, num)

 

 

读写元素

读写列表中元素的方法与读写字符串中字符的方法一样-都是通过操作符“[ ]”。中括号内的表达式代表索引，请记住索引是从0开始的。

numbers = [13, 15]
print (numbers[0])
numbers[1] = 5
print (numbers[1])

索引可以是任何整数表达式，但不能是浮点数:

numbers[3 - 2]

numbers[1.0]

 

读写一个不存在的元素，将会发生一个运行时错误:

numbers[2]

索引也可以是一个负数，那么列表的最后一个元素的索引是-1，倒数第二个的索引是-2，依此类推:

numbers = [1, 2, 3, 4]
numbers[-2]

列表的一些方法

append在列表的尾部追加元素，参数是插入元素的值:

number = [0, 1, 2, 3]
number.append(4)
print (number)

方法insert在列表中插入元素，它有两个参数，一个是索引位置，一个 是插入元素的值:

number.insert(3, 5)
print (number)

方法extend合并两个列表为一个:

nation1 = ["French", "German"]
nation2 = ["Chinese", "Korean"]
nation1.extend(nation2)
print (nation1)
print (nation2)

方法index取得元素的索引值:

cars = ["Ford", "Fiat", "Volvo"]
cars.index("Ford")

方法remove从列表中删除第一次出现的值:

color = ["red", "green", "yellow", "green", "black"]
color.remove("green")
print (color)

方法pop删除最后一个值，然后返回这个值:

letter = ["a", "b", "c", "d"]
letter.pop()

 

print (letter)

列表长度

函数len返回列表的长度，即元素的个数。可以用这个值作为遍历列表的变 量。

os = ["Linux", "Unix", "FreeBSD", "Mac"]
i = 0
while i < len(os):
    print (os[i])
    i=i+1

列表之中还可以包含列表，但嵌套的列表被当作一个元素。

list1 = ["hello", 2.0, 5, [10,20]]
len(list1)

in是一个布尔操作符，它测试左边的操作数是否包含于列表。

color = ["red", "green", "yellow", "green", "black"]
"yellow" in color

"purple" in color

 

我们可以用not和in 的组合来测试一个元素不包含于列表。

"purple" not in color

列表和for循环

用for循环遍历列表，更加简明，它没有循环变量。

os = ["Linux", "Unix", "Mac", "Windows"]
for os in os:
    print (os)

列表操作符

加号操作符”+”将两个列表连接成一个列表:

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print (c)

乘号操作符“*”表示把列表的所有元素重复一定的次数

[1, 2, 3] * 3

列表片断

通过操作符“[]”，将列表元素连续取出的部分，叫片断。

list = ["a", "b", "c", "d", "e", "f"]
list[1:3]

list[:4]

list[3:]

 

 

列表元素是可变的

和字符串不一样，列表的元素是可更改的，这意味着我们可以修改、添加 或删除列表的元素值。

fruit = ["banana", "apple", "quince"]
fruit[0] = "pear"
fruit[-1] = "orange"
print (fruit)

list = ["a", "b", "c", "d", "e", "f"]
list[1:3] = ["x", "y"]
print (list)

 

也可以通过给元素赋空值，删除一些元素:

list = ["a", "b", "c", "d", "e", "f"]
list[1:3] = []
print (list)

或是利用列表片断，在特定的位置插入元素。

list = ["a", "d", "f"]
list[1:] = ["b", "c"]
print (list)
list[4:4] = ["e"]
print (list)

元素的删除

Python提供了关键字del删除列表中的元素。

a = ["one", "two", "three"]
del a[1] 
a

关键字del可以处理负数索引。如果索引超出范围，就会产生运行时错 误。也可以用片断作为关键字del的索引:

list = ["a", "b", "c", "d", "e", "f"]
del list[1:5]
print (list)

别名

因为变量指向内存中的值，如果我们将一个变量赋值给另一个变量，那末这两个变量指向同一个对象。

a = [1,2,3]
b = a
id(a)

id(b)

 

因为列表有不同的名字，分别叫做a和b，我们叫它别名。利用操作符“[]”修改任何一个列表的元素，另一个列表做相同的改变。

a = [1,2,3]
b = a
b[0] = 5
print(a)

克隆列表

如果要修改列表，但是要保留原来列表的一份拷贝，就需要列表自我复 制，这过程叫做克隆。克隆的结果是产生两个值一样，但却有不同标识符 的列表。克隆的方法是利用列表的片断操作符:

x = [1, 3, 5, 7]
y = x[:]
print(y)

y[0] = 9
print(y)

print(x)

id(x)

id(y)

 

矩阵

嵌套列表可以代表矩阵

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

matrix[1]

matrix[1][1]

 

 

练习6

写一个函数，名为 nested_sum，接收一系列的整数列表，然后把所有分支列表中的元素加起来。如下所示：

t = [[1, 2], [3], [4, 5, 6]]
nested_sum(t)
21

练习7

写一个函数，名为 chop，接收一个列表，修改这个列表，掐头去尾，返回空值。如下所示：

t = [1, 2, 3, 4]
chop(t)
t
[2, 3]

In [ ]:

 

​