本文详细介绍了Python的基础语法，包括在线运行环境、输入输出、变量、逻辑运算、循环结构、字符串处理、正则表达式等。同时，探讨了面向对象编程的概念，通过实例展示了如何创建类和对象。此外，还涉及到了文件读写、异常处理、字典、模块使用等进阶操作。文章适合初学者阅读，帮助他们快速掌握Python编程。
一、基础语法内容
1.一个在线的 python 运行环境：
左上角的“Execute Sctipt”，就可以在右边页面看到输出结果
Python Cloud IDE | Python Fiddle
2.简单输入输出
>>>print "hello"#双引号字符串 hello >>> print 'world'#单引号字符串 world >>> print 1 1 >>> print 3.14 3.14 >>> print 3e30#指数 3e+30 >>> print 1 + 2 * 3 7 >>> print 2 > 5#逻辑判断 False >>> 'Your YiDa!' 'Your YiDa!' >>> 2+13+250 265 >>> 5<50 True
3.输入
1.input()
print "Who do you think I am?" input() print "Oh, yes!"
python 还有一个输入的方法：raw_input()，它把所有的输入都直接当作一串字符， 于是就可以不用加引号
4.变量
1.简单变量
name = 'Crossin'//引号 myVar = 123 price = 5.99 visible = True
2.变量赋值
a = 123 print a a = 'hi' print a
a可以先是整形，可以再次赋值字符串
value = 3 * 4 print value value = 2 < 5 print value
name = input() print name
5.bool
not：逻辑“非”。如果 x 为 True，则 not x 为 False
and：逻辑“与”。如果 x 为 True，且 y 为 True，则 x and y 为 True
or：逻辑“或”。如果 x、y 中至少有一个为 True，则 x or y 为 True
6.if
if 内部的语句需要有一个统一的缩进，一般用 4 个空格。python 用这种方法替代了其他很多编程语言中的{}
千万不可以 tab 和空格混用，不然就会出现各种莫名其妙的错误
thisIsLove = input() if thisIsLove: print "再转身就该勇敢留下来"
7.while
python 里，以“#”开头**的文字都不会被认为是可执行的代码**
a = 1 #先 a 设为 1 while a != 0: #a 不等于 0 就一直做 print "please input" a = input() print "over"
8.random
python 还提供了很多模块，用来实现各种常见的功能，比如时间处理、科学计算、 网络请求、随机数
1.引入模块的方法
from 模块名 import 方法名
2.随机数
from random import randint
之后你就可以用 randint 来产生随机数了，在括号中提供两个数字，先后分别是产生随机整数范围的下限和上限
randint(5, 10) #这样将会产生一个 5 到 10 之间（包括 5 和 10）的随机整数。
9.变量2
1.#==== 变量命名规则 ====#
第一个字符必须是字母或者下划线“_”
剩下的部分可以是字母、下划线“_”或数字（0-9）
变量名称是对大小写敏感的，myname 和 myName 不是同一个变量。
i __my_name name_23 a1b2_c3
错误例子
2things this is spaced out my-name
2.#==== 变量的运算 ====#
变量还可以进行数学运算： a = 5 b = a + 3 c = a + b
python 中运算的顺序是，先把“=”右边的结果算出了，再赋值给左边的变量。
a = 5 a = a + 3 print a
10.逻辑判断
a = 1 print a>3 #False print a==2-1 #Trueb = 3 print a+b==2+2 #True
比较容易搞混的，是 bool 变量的值和一个逻辑表达式的值，比如：
a = False print a #False print a==False #True
11.for循环
1.for ... in ...
for i in range(1, 101): print i
解释一下，range(1, 101)表示从 1 开始，到 101 为止（不包括 101），取其中所有的整数。
for i in range(1, 101)
就是说，把这些数，依次赋值给变量 i。相当于一个一个循环过去，第一次 i = 1，第二次 i = 2，……，直到 i = 100。当 i = 101 时跳出循环。所以，当你需要一个循环 10 次的循环，你就只需要写：
for i in range(1, 11)
或者
for i in range(0, 10)
12.字符串
内容带有单引号，就用双引号表示"It's good"
反之亦然
‘You are a "BAD" man’
python 中还有一种表示字符串的方法：三个引号（‘’‘）或者（"""）
在三个引号中，你可以方便地使用单引号和双引号，并且可以直接换行
''' "What's your name?" I asked. "I'm Han Meimei." '''
还有一种在字符串中表示引号的方法，就是用\，可以不受引号的限制
#\'表示单引号，\"表示双引号
‘I\'m a \"good\" teacher’
\被称作转译字符，除了用来表示引号，还有比如用
\表示字符串中的\
\n 表示字符串中的换行
\还有个用处，就是用来在代码中换行，而不影响输出的结果：
"this is the\ same line"
13.字符串格式化
我们在输出字符串的时候，如果想对输出的内容进行一些整理，比如把几段字符拼接起来， 或者把一段字符插入到另一段字符中间，就需要用到字符串的格式化输出。
str1 = 'good' str2 = 'bye' #你可以 print str1 + str2 #或者还可以把字符变量一个字符串相加 print 'very' + str1 print str1 + ' and ' + str2
#但如果你想要把一个数字加到文字后面输出，比如这样 num = 18 print 'My age is' + num #程序就会报错。因为字符和数字不能直接用+相加。
str()把数字转换成字符串
print 'My age is' + str(18) #或 num = 18 print 'My age is' + str(num)
#还有一种方法，就是用%对字符串进行格式化 num = 18 print 'My age is %d' % num #输出的时候，%d 会被%后面的值替换。输出 #My age is 18
#这里，%d 只能用来替换整数。如果你想格式化的数值是小数，要用%f print ‘Price is %f’ % 4.99
#如果你想保留两位小数，需要在 f 前面加上条件：%.2f print ‘Price is %.2f’ % 4.99 #输出 #Price is 4.99 #另外，可以用%s 来替换一段字符串 name = 'Crossin' print '%s is a good teacher.' % name #输出 #Crossin is a good teacher. #或者 print 'Today is %s.' % 'Friday' #输出 #Today is Friday
14.循环的嵌套
for i in range(0, 5): for j in range(0, 5): print i, j
第二个 for 循环在第一个 for 循环的内部，表示每一次外层的循环中，都要进行一遍内层的循环。
15.字符串格式化
#在 python 中，你可以这样实现：
print "%s's score is %d" % ('Mike', 87)
#或者
name = ‘Lily’
score = 95
print "%s's score is %d" % (name, score)
('Mike', 87)这种用()表示的一组数据在 python 中被称为元组（tuple），是 python 的一种基本 数据结构，以后我们还会用到。
16.类型转换
python 在定义一个变量时不需要给它限定类型。变量会根据赋给它的值，自动决定它的类型。你也可以在程序中，改变它的值，于是也就改变了它的类型。例如
a = 1 print a a = 'hello' print a
虽然类型可以随意改变，但当你对一个特定类型的变量进行操作时，如果这个操作与它的数据类型不匹配，就会产生错误。比如以下几行代码
print ‘Hello’+1 print ‘hello%d’ % '123'
int(x) #把 x 转换成整数 float(x) #把 x 转换成浮点数 str(x) #把 x 转换成字符串 bool(x) #把 x 转换成 bool 值
#以下等式的结果均为真：
int('123') == 123
float('3.3') == 3.3
str(111) == '111'
bool(0) == False
并不是所有的值都能做类型转换，比如 int('abc')同样会报错，python 没办法把它转成一个整数。
17.bool类型转换
在 python 中，以下数值会被认为是 False：
为 0 的数字，包括 0，0.0
空字符串，包括''，""
表示空值的 None
空集合，包括()，[]，{}
其他的值都认为是 True。
None 是 python 中的一个特殊值，表示什么都没有，它和 0、空字符、False、空集合都不一 样。
同样 bool(' ')的结果是 True，一个空格也不能算作空字符串。
bool('')才是 False。
18.函数
PS：range 还可以接受 1 个或 3 个参数，input 也可以接受 1 个字符串 参数。
def sayHello(): print 'hello world!'
但括号和后面的冒号都不能少
19.命令行常用命令
dir 显示出当前目录下的文件和文件夹。
cd 目录名 进入到当前目录下的子目录里
如果要跳回到上级目录，可以用命令：
cd ..
另外，Windows 下如果要写换盘符，需要输入
盘符
python 你把程序保存的文件名
就可以运行你写的程序了。
20.函数的参数
def plus(num1, num2): print num1+num2
def isEqual(num1, num2): if num1<num2: print 'too small' return False; if num1>num2: print 'too big' return False; if num1==num2: print 'bingo' return True
这里说一下，return 是函数的结束语句，return 后面的值被作为这个函 数的返回值。函数中任何地方的 return 被执行到的时候，这个函数就会 结束。
from random import randint
num = randint(1, 100)
print 'Guess what I think?'
bingo = False
while bingo == False:
answer = input()
bingo = isEqual(answer, num)
#在 isEqual 函数内部，会输出 answer 和 num 的比较结果，如果相等的话，bingo 会得到返回值 True，否则 bingo 得到 False，循环继续。
21.if,elif,else
if a == 1: print 'right' else print 'wrong'
if a == 1: print 'one' elif a == 2: print 'two' elif a == 3: print 'three' else: print 'too many'
def isEqual(num1, num2): if num1<num2: print 'too small' return False; elif num1>num2: print 'too big' return False; else: print 'bingo' return True
if 条件 1: if 条件 2: 语句 1 else: 语句 2 else: if 条件 2: 语句 3 else: 语句 4
22.list
1.概念
用来处理一组有序项目的数据结构
print range(1,10) #得到的结果是： #[1, 2, 3, 4, 5, 6, 7, 8, 9]
l = [1, 1, 2, 3, 5, 8, 13] #可以用 print 输出这个列表： print l for i in l: print l,
#列表中的元素也可以是别的类型，比如： l = ['meat', 'egg', 'fish', 'milk'] #甚至是不同类型的混合： l = [365, 'everyday', 0.618, True]
2.操作list,索引
1)访问
要访问 l 中的第 1 个元素 365，只要用 l[0]就可以了。依次类推，
print l[1]
就会输出'everyday'
2）修改
修改 list 中的某一个元素，只需要直接给那个元素赋值就可以了：
l[0] = 123
输出 l，得到[123, 'everyday', 0.618, True]，第 1 个元素已经从 365 被
改成了 123。
3）添加
list 有一个 append 方法，可以增加元素。以 l 这个列表为例，调用的方 法是：
l.append(1024)
输出 l，你会看到[123, 'everyday', 0.618, True, 1024]，1024 被添加到 了 l，成为最后一个元素。（第一个元素在上一步被改成了 123）然后同样可以用 l[4]得到 1024。
4）删除
删除 list 中的某一个元素，要用到 del：
del l[0]
输出 l，得到['everyday', 0.618, True, 1024]。这时候再调用 l[0]，会得到'everyday'，其他元素的序号也相应提前。
3.操作list，切片
l = [365, 'everyday', 0.618, True] l[-1]#表示 l 中的最后一个元素。 l[-3]#表示倒数第 3 个元素。
切片操作符是在[]内提供一对可选数字，用:分割。冒号前的数表示切片 的开始位置，冒号后的数字表示切片到哪里结束。同样，计数从 0 开始。 注意，开始位置包含在切片中，而结束位置不包括。
l[1:3] #得到的结果是['everyday', 0.618]。 #如果不指定第一个数，切片就从列表第一个元素开始。如果不指定第二个数，就一直到最后一个元素结束。都不指定，则返回整个列表的一个拷贝。 l[:3] l[1:] l[:] #同索引一样，切片中的数字也可以使用负数。比如： l[1:-1] #得到['everyday', 0.618]
23.小游戏
from random import choice print 'Choose one side to shoot:' print 'left, center, right' you = raw_input() print 'You kicked ' + you direction = ['left', 'center', 'right'] com = choice(direction) print 'Computer saved ' + com if you != com: print 'Goal!' else: print 'Oops...'
用random的另一个方法：choice。 它的作用是从一个 list 中随机挑选一个元素。
24.字符串的分割
sentence = 'I am an Englist sentence' sentence.split() #split()会把字符串按照其中的空格进行分割，分割后的每一段都是一个新的字符串，最终返回这些字符串组成一个 list。于是得到 #['I', 'am', 'an', 'Englist', 'sentence'] #除了空格外，split()同时也会按照换行符\n，制表符\t 进行分割。所以应该说，split 默认是按照空白字符进行分割
#split 还可以指定分割的符号。比如你有一个很长的字符串
section = 'Hi. I am the one. Bye.'
#通过指定分割符号为'.'，可以把每句话分开
section.split('.')
#得到
#['Hi', ' I am the one', ' Bye', '']
每个'.'都会被作为分割符，即使它的后面没有 其他字符，也会有一个空串被分割出来
'aaa'.split('a')
#将会得到['', '', '', '']，由四个空串组成的 list。
25.字符串的连接
join 则是把一个 list 中的所有字符串连接成一个字符串。
join 的格式有些奇怪，它不是 list 的方法，而是字符串的方法
s = ';' li = ['apple', 'pear', 'orange'] fruit = s.join(li) print fruit #得到结果'apple;pear;orange'。 #从结果可以看到，分号把 list 中的几个字符串都连接了起来。
26.字符串的索引和切片
\1. 遍历
通过 for...in 可以遍历字符串中的每一个字符。
word = 'helloworld' for c in word: print c
\2. 索引访问
通过[]加索引的方式，访问字符串中的某个字符。
print word[0] print word[-2]
与 list 不同的是，字符串能通过索引访问去更改其中的字符。
word[1] = 'a'
这样的赋值是错误的。
\3. 切片
通过两个参数，截取一段子串，具体规则和 list 相同。
print word[5:7] print word[:-5] print word[:]
\4. 连接字符
join 方法也可以对字符串使用，作用就是用连接符把字符串中的每个字符重新连接成一个 新字符串。不过觉得这个方法有点鸡肋，不知道在什么场景下会用到。
二、一些较高端操作
1.读文件
把这个文件放在接下来你打算保存代码的文件夹下，这么做是为了方便我们的程序找 到它。准备工作就绪，可以来写我们的代码了
#打开一个文件的命令很简单：
file('文件名')
#这里的文件名可以用文件的完整路径，也可以是相对路径。因为我们把要读取的文件和代码放在了同一个文件夹下，所以只需要写它的文件名就够了。
f = file('data.txt')
#你可以通过 read()函数把文件内所有内容读进一个字符串中。
data = f.read()
#读取文件内容的方法还有
readline() #读取一行内容
readlines() #把内容按行读取至一个 list 中
f = file('data.txt')
data = f.read()
print data
f.close()
2.写文件
#但 python 默认是以只读模式打开文件。如果想要写入内容，在打开文件的时候需要指定打开模式为写入：
f = file('output.txt', 'w')
f = open('output.txt', 'w')
#原来文件中的内容会被你新写入的内容覆盖掉，如果文件不存在，会自动创建文件。
只读模式，文件必须存在，否则引发异常。
另外还有一种模式是'a'，appending。它也是一种写入模式，但你写入的内容不会覆盖之前 的内容，而是添加到文件中。
data = 'I will be in a file.\nSo cool!'
out = open('output.txt', 'w')
out.write(data)
out.close()
3.处理文件中的数据案例
#-- scores.txt
刘备 23 35 44 47 51
关羽 60 77 68
张飞 97 99 89 91
诸葛亮 100
1. 先把文件读进来：
f = file('scores.txt')
2.取得文件中的数据。因为每一行都是一条学生成绩的记录，所以用 readlines，把每
一行分开，便于之后的数据处理：
lines = f.readlines()
f.close()
提示：在程序中，经常使用 print 来查看数据的中间状态，可以便于你理解程序的运行。
比如这里你可以 print lines，看一下内容被存成了什么格式。
3.对每一条数据进行处理。按照空格，把姓名、每次的成绩分割开：
for line in lines:
data = line.split()
接下来的 4、5 两个步骤都是针对一条数据的处理，所以都是在 for 循环的内部。
4.整个程序最核心的部分到了。如何把一个学生的几次成绩合并，并保存起来呢？我的
做法是：对于每一条数据，都新建一个字符串，把学生的名字和算好的总成绩保存进去。
最后再把这些字符串一起保存到文件中：
sum = 0
for score in data[1:]:
sum += int(score)
result = '%s\t: %d\n' % (data[0], sum)
这里几个要注意的点：
对于每一行分割的数据，data[0]是姓名，data[1:]是所有成绩组成的列表。
每次循环中，sum 都要先清零。
score 是一个字符串，为了做计算，需要转成整数值 int。
result 中，我加了一个制表符\t 和换行符\n，让输出的结果更好看些。
5.得到一个学生的总成绩后，把它添加到一个 list 中。
results.append(result)
results 需要在循环之前初始化 results = []
6.最后，全部成绩处理完毕后，把 results 中的内容保存至文件。因为 results 是一个
字符串组成的 list，这里我们直接用 writelines 方法：
output = file('result.txt', 'w')
output.writelines(results)
outpus.close()
大功告成，打开文件检验一下结果吧。
f = file('scores.txt')
lines = f.readlines()
print lines
f.close()
results = []
for line in lines:
print line
data = line.split()
print data
sum = 0
for score in data[1:]:
sum += int(score)
result = '%s \t: %d\n' % (data[0], sum)
print result
results.append(result)
print results
output = file('result.txt', 'w')
output.writelines(results)
output.close()
4.break
while 循环 在条件不满足时 结束，
for 循环 遍历完序列后 结束。
如果在循环条件仍然满足或序列没有遍历完的时候，想要强行跳出循环，就需要用到 break
while True: a = raw_input() if a == 'EOF': break
for i in range(10): a = raw_input() if a == 'EOF': break
5.continue
而 continue 只是略过本次循环的余下内容，直接进入下一次循环
for score in data[1:]: point = int(score) if point < 60: continue sum += point
6.异常处理
python 中，可以使用 try...except 语句来处理异常。做法是，把可能引发异常的语句放在 try-块中，把处理异常的语句放在 except-块中。
try:
f = file('non-exist.txt')
print 'File opened!'
f.close()
except:
print 'File not exists.'
print 'Done'
但无论如何，整个程序不会中断，最后的“Done”都会被输出。
7.字典
在字典中，名字叫做“键”，对应的内容信息叫做“值”。字典就是一个键/值对的集合。
d = {key1 : value1, key2 : value2 }
关于字典的键要注意的是：
1.键必须是唯一的；
2.键只能是简单对象，比如字符串、整数、浮点数、bool 值。list 就不能作为键，但是可以作为值。
python 字典中的键/值对没有顺序，我们无法用索引访问字典中的某一项，而是要用键来访问。
score = { '萧峰': 95, '段誉': 97, '虚竹': 89 }
print score['段誉']
如果要改变某一项的值，就直接给这一项赋值：
score['虚竹'] = 91
增加一项字典项的方法是，给一个新键赋值：
score['慕容复'] = 88
删除一项字典项的方法是 del：
del score['萧峰']
注意，这个键必须已存在于字典中。
如果你想新建一个空的字典，只需要:
d = {}
8.模块
python 自带了功能丰富的标准库，另外还有数量庞大的各种第三方库。使用这些“巨人的” 代码，可以让开发事半功倍，就像用积木一样拼出你要的程序。 使用这些功能的基本方法就是使用模块。通过函数，可以在程序里重用代码；通过模块， 则可以重用别的程序中的代码。
模块可以理解为是一个包含了函数和变量的 py 文件。在你的程序中引入了某个模块，就可 以使用其中的函数和变量。
import random random.randint(1, 10) random.randchoic([1, 3, 5]) #想知道 random 有哪些函数和变量，可以用 dir()方法： dir(random) #如果你只是用到 random 中的某一个函数或变量，也可以通过 from...import...指明： from math import pi print pi #为了便于理解和避免冲突，你还可以给引入的方法换个名字： from math import pi as math_pi print math_pi
9.函数的默认参数
def hello(name):
print 'hello ' + name
#然后我们去调用这个函数：
hello('world')
#程序就会输出
#hello world
#如果很多时候，我们都是用 world 来调用这个函数，少数情况才会去改参数。那么，我们就可以给这个函数一个默认参数：
def hello(name = 'world'):
print 'hello ' + name
#当你没有提供参数值时，这个参数就会使用默认值；如果你提供了，就用你给的。这样，在默认情况下，你只要调用hello()
#就可以输出
#hello world
#注意，当函数有多个参数时，如果你想给部分参数提供默认参数，那么这些参数必须在参数的末尾。比如：
def func(a, b=5)
#是正确的
def func(a=5, b)
#就会出错
三.高端操作
（一）面向对象
1.基本概念
一个类/对象可以有属于它的变量，这种变量被称作“域”。域根据所属不同，又分别被称作“类变量”和“实例变量”。
python 是一种高度面向对象的语言
s = 'how are you' #s 被赋值后就是一个字符串类型的对象 l = s.split() #split 是字符串的方法，这个方法返回一个 list 类型的对象 #l 是一个 list 类型的对象
通过 dir()方法可以查看一个类/变量的所有属性： 1. dir(s) 2. dir(list)
2.类
1. class MyClass: 2. pass 3. 4. mc = MyClass() 5. print mc #之后缩进的代码块是这个类的内部。在这里，我们用 pass 语句，表示一个空的代码块。 #类名加圆括号()的形式可以创建一个类的实例，也就是被称作对象的东西。我们把这个对象赋值给变量 mc。于是，mc 现在就是一个 MyClass 类的对象 看一下输出结果： 1. <__main__.MyClass instance at 0x7fd1c8d01200> #这个意思就是说，mc 是__main__模块中 MyClass 来的一个实例（instance），后面的一串十六进制的数字是这个对象的内存地址。
我们给这个类加上一些域： 1. class MyClass: 2. name = 'Sam' 3. 4. def sayHi(self): 5. print 'Hello %s' % self.name 6. 7. mc = MyClass() 8. print mc.name 9. mc.name = 'Lily' 10. mc.sayHi() #类方法和我们之前定义的函数区别在于，第一个参数必须为 self。而在调用类方法的时候，通过“对象.方法名()”格式进行调用，而不需要额外提供 self 这个参数的值。self 在类方法中的值，就是你调用的这个对象本身。
3.面向对象实例
假设我们有一辆汽车，我们知道它的速度(60km/h)，以及 A、B 两地的距离(100km)。要算出 开着这辆车从 A 地到 B 地花费的时间。（很像小学数学题是吧？）
#面向过程的方法： 1. speed = 60.0 2. distance = 100.0 3. time = distance / speed 4. print time
#面向对象的方法： 1. class Car: 2. speed = 0 3. def drive(self, distance): 4. time = distance / self.speed 5. print time 6. 7. car = Car() 8. car.speed = 60.0 9. car.drive(100.0)
面向过程把数据和处理数据的计算全部放在一起，当功能复杂之后，就会显 得很混乱，且容易产生很多重复的代码。而面向对象，把一类数据和处理这类数据的方法封 装在一个类中，让程序的结构更清晰，不同的功能之间相互独立。这样更有利于进行模块化的开发方式
4.面向对象高级实例
我们要使用的方法是，创建一个叫做 Vehicle 的类，表示某种车，它包含了汽车和自行车所共有的东西：速度，行驶的方法。然后让 Car 类和 Bike 类都继承这个 Vehicle 类，即作为 它的子类。在每个子类中，可以分别添加各自独有的属性。
#Vehicle 类被称为基本类或超类，Car 类和 Bike 类被成为导出类或子类。 1. class Vehicle: 2. def __init__(self, speed): 3. self.speed = speed 4. 5. def drive(self, distance): 6. print 'need %f hour(s)' % (distance / self.speed) 7. 8. class Bike(Vehicle): 9. pass 10. 11. class Car(Vehicle): 12. def __init__(self, speed, fuel): 13. Vehicle.__init__(self, speed) 14. self.fuel = fuel 15. 16. def drive(self, distance): 17. Vehicle.drive(self, distance) 18. print 'need %f fuels' % (distance * self.fuel) 19. 20. b = Bike(15.0) 21. c = Car(80.0, 0.012) 22. b.drive(100.0) 23. c.drive(100.0) 24.
init函数会在类被创建的时候自动调用，用来初始化类。它的参数，要在创建类的时候提供。于是我们通过提供一个数值来初始化 speed 的值。
Bike(Vehicle)就是说 Bike 是继承自 Vehicle 中的子类。Vehicle 中的属性和方法，Bike 都会有。因为 Bike 不需要有额外的功能，所以用 pass 在类中保留空块，什么都不用写。
Car 类中，我们又重新定义了init和 drive 函数，这样会覆盖掉它继承自 Vehicle 的同名函数。但我们依然可以通过“Vehicle.函数名”来调用它的超类方法。以此来获得它作为 Vehicle 所具有的功能。注意，因为是通过类名调用方法，而不是像之前一样通过对象来调 用，所以这里必须提供 self 的参数值。在调用超类的方法之后，我们又给 Car 增加了一个fuel 属性，并且在 drive 中多输出一行信息。 最后，我们分别创建一个速度为 15 的自行车对象，和一个速度为 80、耗油量为 0.012 的汽 车，然后让它们去行驶 100 的距离
(二)其他一些内容
1.and-or技巧
1. a = "heaven" 2. b = "hell" 3. c = True and a or b 4. print c 5. d = False and a or b 6. print d
#有了它，原本需要一个 if-else 语句表述的逻辑： 1. if a > 0: 2. print "big" 3. else: 4. print "small" #就可以直接写成： 1. print (a > 0) and "big" or "small"
和 c 语言中的?:表达式不同，这里 的 and or 语句是利用了 python 中的逻辑运算实现的。当 a 本身是个假值（如 0，""）时， 结果就不会像你期望的那样。
1. a = "" 2. b = "hell" 3. c = True and a or b 4. print c #得到的结果就是"hell"。因为""和"hell"做 and 的结果是"hell"。
#所以，and-or 真正的技巧在于，确保 a 的值不会为假。最常用的方式是使 a 成为 [a] 、 b 成为[ b ] ，然后使用返回值列表的第一个元素： 1. a = "" 2. b = "hell" 3. c = (True and [a] or [b])[0] 4. print c #由于[a]是一个非空列表，所以它决不会为假。即使 a 是 0 或者''或者其它假值，列表[a]也为真，因为它有一个元素。
2.元组
元组（tuple）也是一种序列，和我们用了很多次的 list 类似，只是元组中的元素在创建之后就不能被修改。
1. postion = (1, 2)
2. geeks = ('Sheldon', 'Leonard', 'Rajesh', 'Howard')
1. print postion[0] 2. for g in geeks: 3. print g 4. print geeks[1:3]
#再来看一下元组作为函数返回值的例子： 1. def get_pos(n): 2. return (n/2, n*2) #得到这个函数的返回值有两种形式，一种是根据返回值元组中元素的个数提供变量： 1. x, y = get_pos(50) 2. print x 3. print y #这就是我们在开头那句代码中使用的方式。 #还有一种方法是用一个变量记录返回的元组： 1. pos = get_pos(50) 2. print pos[0] 3. print pos[1]
3.数学运算
import math #math 包里有两个常量： math.pi #圆周率 π：3.141592... math.e #自然常数：2.718281... #数值运算： math.ceil(x) #对 x 向上取整，比如 x=1.2，返回 2 math.floor(x) #对 x 向下取整，比如 x=1.2，返回 1 math.pow(x,y) #指数运算，得到 x 的 y 次方 math.log(x) #对数，默认基底为 e。可以使用第二个参数，来改变对数的基底。比如 math.log(100, 10) math.sqrt(x) #平方根 math.fabs(x) #绝对值 #三角函数: math.sin(x) math.cos(x) math.tan(x) math.asin(x) math.acos(x) math.atan(x) #注意：这里的 x 是以弧度为单位，所以计算角度的话，需要先换算 #角度和弧度互换: math.degrees(x) #弧度转角度 math.radians(x) #角度转弧度
官方文档：9.2. math — Mathematical functions — Python 2.7.18 documentation
4.真值表
NOT not False <=> True not True <=> False （not 的结果与原值相反） OR True or False <=> True True or True <=> True False or True <=> True False or False <=> False （只要有一个值为 True，or 的结果就是 True） AND True and False <=> False True and True <=> True False and True <=> False False and False <=> False （只要有一个值为 False，or 的结果就是 False） NOT OR not (True or False) <=> False not (True or True) <=> False not (False or True) <=> False not (False or False) <=> True NOT AND not (True and False) <=> True not (True and True) <=> False not (False and True) <=> True not (False and False) <=> True != 1 != 0 <=> True 1 != 1 <=> False 0 != 1 <=> True 0 != 0 <=> False == 1 == 0 <=> False 1 == 1 <=> True 0 == 1 <=> False 0 == 0 <=> True
5.随机数
import random
num = random.randint(1,100)
random.randint(a, b)
#生成一个 a 到 b 间的随机整数，包括 a 和 b。 a、b 都必须是整数，且必须 b≥a。当等于的时候，比如：random.randint(3, 3)的结果就永远是3.
#除了 randint，random 模块中比较常用的方法还有：
random.random()
#生成一个 0 到 1 之间的随机浮点数，包括 0 但不包括 1，也就是[0.0, 1.0)。
random.uniform(a, b)
#生成 a、b 之间的随机浮点数。不过与 randint 不同的是，a、b 无需是整数，也不用考虑大小。
random.uniform(1.5, 3)
random.uniform(3, 1.5)
#这两种参数都是可行的。
random.uniform(1.5, 1.5)#永远得到 1.5。
random.choice(seq)
#从序列中随机选取一个元素。seq 需要是一个序列，比如 list、元组、字符串。
random.choice([1, 2, 3, 5, 8, 13]) #list
random.choice('hello') #字符串
random.choice(['hello', 'world']) #字符串组成的 list
random.choice((1, 2, 3)) #元组
#都是可行的用法。
random.randrange(start, stop, step)
#生成一个从 start 到 stop（不包括 stop），间隔为 step 的一个随机数。start、stop、step 都要为整数，且 start<stop。比如：
random.randrange(1, 9, 2)
#就是从[1, 3, 5, 7]中随机选取一个。start 和 step 都可以不提供参数，默认是从 0 开始，间隔为 1。但如果需要指定 step，则必须指定 start。
random.randrange(4) #[0, 1, 2, 3]
random.randrange(1, 4) #[1, 2, 3]
random.randrange(start, stop, step)#其实在效果上等同于
random.choice(range(start, stop, step))
random.sample(population, k)
#从 population 序列中，随机获取 k 个元素，生成一个新序列。sample 不改变原来序列。
random.shuffle(x)
#把序列 x 中的元素顺序打乱。shuffle 直接改变原有的序列。
#以上是 random 中常见的几个方法。如果你在程序中需要其中某一个方法，也可以这样写：
from random import randint
randint(1, 10)
(三)正则表达式
1.基本内容
1）
最简单的正则表达式，它没有特殊的符号，只有基本的字母或数字。 它满足的匹配规则就是完全匹配。例如：有个正则表达式是“hi”，那么它就可 以匹配出文本中所有含有 hi 的字符。
最简单的正则表达式，它没有特殊的符号，只有基本的字母或数字。 它满足的匹配规则就是完全匹配。例如：有个正则表达式是“hi”，那么它就可以匹配出文本中所有含有 hi 的字符。
默认情况下正则表达式是严格区分大小写的
1. import re 2. text = "Hi, I am Shirley Hilton. I am his wife." 3. m = re.findall(r"hi", text) 4. if m: 5. print m 6. else: 7. print 'not match'
2)
如果我们只想找到“hi”这个单词，而不把包含它的单词也算在内，那就可以使 用“\bhi\b”这个正则表达式。在以前的字符串处理中，我们已经见过类似“\n” 这种特殊字符。在正则表达式中，这种字符更多，以后足以让你眼花缭乱。
“\b”在正则表达式中表示单词的开头或结尾，空格、标点、换行都算是单词的分割。而“\b”自身又不会匹配任何字符，它代表的只是一个位置。所以单词前 后的空格标点之类不会出现在结果里。
在前面那个例子里，“\bhi\b”匹配不到任何结果。但“\bhi”的话就可以匹配 到 1 个“hi”，出自“his”。用这种方法，你可以找出一段话中所有单词“Hi”，
3)
在正则表达式中，[]表示满足括号中任一字符。比如 “[hi]”，它就不是匹配“hi”了，而是匹配“h”或者“i”。
如果把正则表达式改为“[Hh]i”，就可以既匹配“Hi”，又匹 配“hi”了
2.解释
#这里字符串前面加了 r，是 raw 的意思，它表示对字符串不进行转义。为什么要加这个？你 可以试试 print "\bhi"和 r"\bhi"的区别。 >>> print "\bhi" hi >>> print r"\bhi" \bhi #可以看到，不加 r 的话，\b 就没有了。因为 python 的字符串碰到“\”就会转义它后面的字符。 #如果你想在字符串里打“\”，则必须要打“\\”。 >>> print "\\bhi" \bhi #这样的话，我们的正则表达式里就会多出很多“\”，让本来就已经复杂的字符串混乱得像五仁月饼一般。但加上了“r”，就表示不要去转义字符串中的任何字符，保持它的原样。
re.findall(r"hi", text) #re 是 python 里的正则表达式模块。findall 是其中一个方法，用来按照提供的正则表达式， #去匹配文本中的所有符合条件的字符串。返回结果是一个包含所有匹配的 list。
#“.”和“*”，顺带“\S”和“?”。“.”在正则表达式中表示除换行符以外的任意字符。在上节课提供的那段例子文本中： Hi, I am Shirley Hilton. I am his wife. #如果我们用“i.”去匹配，就会得到 ['i,', 'ir', 'il', 'is', 'if'] #你若是暴力一点，也可以直接用“.”去匹配，看看会得到什么。 与“.”类似的一个符号是“\S”，它表示的是不是空白符的任意字符。注意是大写字符 S。
#在很多搜索中，会用“?”表示任意一个字符，“*”表示任意数量连续字符，这种被称为通配符。但在正则表达式中，任意字符是用“.”表示，而“*”则不是表示字符，而是表示数量：它表示前面的字符可以重复任意多次（包括 0 次），只要满足这样的条件，都会被表达式匹配上。结合前面的“.*”，用“I.*e”去匹配，想一下会得到什么结果？ ['I am Shirley Hilton. I am his wife'] #是不是跟你想的有些不一样？也许你会以为是 ['I am Shirle', 'I am his wife'] #这是因为“*”在匹配时，会匹配尽可能长的结果。如果你想让他匹配到最短的就停止，需要用“.*?”。如“I.*?e”，就会得到第二种结果。这种匹配方式被称为懒惰匹配，而原本尽可能长的方式被称为贪婪匹配。
3.扩展
1）常用元字符
\w - 匹配字母或数字或下划线或汉字（我试验下了，发现 3.x 版本可以匹配汉 字，但 2.x 版本不可以）
\s - 匹配任意的空白符
^ - 匹配字符串的开始
$ - 匹配字符串的结束
2）
\S 其实就是\s 的反义，任意不是空白符的字符。同理，还有：
\W - 匹配任意不是字母，数字，下划线，汉字的字符
\D - 匹配任意非数字的字符
\B - 匹配不是单词开头或结束的位置
[a]的反义是a，表示除 a 以外的任意字符。abcd就是除 abcd 以外的任意
字符。
3）
之前我们用过*、+、{}来表示字符的重复。其他重复的方式还有：
? - 重复零次或一次
{n,} - 重复 n 次或更多次
{n,m} - 重复 n 到 m 次
正则表达式不只是用来从一大段文字中抓取信息，很多时候也被用来判断输入的
文本是否符合规范，或进行分类。来点例子看看：
^\w{4,12}$
这个表示一段 4 到 12 位的字符，包括字母或数字或下划线或汉字，可以用来作
为用户注册时检测用户名的规则。（但汉字在 python2.x 里面可能会有问题）
\d{15,18}
表示 15 到 18 位的数字，可以用来检测身份证号码
^1\d*[x]?
以 1 开头的一串数字，数字结尾有字母 x，也可以没有。有的话就带上 x。另外再说一下之前提到的转义字符\。如果我们确实要匹配.或者*字符本身，而
不是要它们所代表的元字符，那就需要用.或*。\本身也需要用\。
比如"\d+.\d+"可以匹配出 123.456 这样的结果。
扫一扫
651
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
