Python

name=input(“Please input your name:”) input括号里面可以写输入

print(“Hello,” , name) 双引号完了必须加逗号

r” 单引号里面的字符默认不转义。

Python允许用”’…”’的格式表示多行内容：
print(”’line1
line2
line3”’)

line1
line2
line3

and、or和not（与，或，非）

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

/ 除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数
还有一种除法是 //，称为地板除，两个整数的除法仍然是整数

ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

ord(‘A’)
65
ord(‘中’)
20013
chr(66)
‘B’
chr(25991)
‘文’

如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。Python对bytes类型的数据用带b前缀的单引号或双引号表示：
x = b’ABC’

以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：

‘ABC’.encode(‘ascii’)
b’ABC’
‘中文’.encode(‘utf-8’)
b’\xe4\xb8\xad\xe6\x96\x87’

如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：

b’ABC’.decode(‘ascii’)
‘ABC’
b’\xe4\xb8\xad\xe6\x96\x87’.decode(‘utf-8’)
‘中文’

如果bytes中只有一小部分无效的字节，可以传入errors=’ignore’忽略错误的字节：

b’\xe4\xb8\xad\xff’.decode(‘utf-8’, errors=’ignore’)
‘中’

要计算str包含多少个字符，可以用len()函数：

len(‘ABC’)
3
len(‘中文’)
2

如果换成bytes，len()函数就计算字节数：

len(b’ABC’)
3
len(b’\xe4\xb8\xad\xe6\x96\x87’)
6
len(‘中文’.encode(‘utf-8’))
6

（为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。）

申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码（当文本中有中文的时候）

在Python中，采用的格式化方式和C语言是一致的，用 % 实现，举例如下：

‘Hello, %s’ % ‘world’
‘Hello, world’
‘Hi, %s, you have $%d.’ % (‘Michael’, 1000000) ‘Hi, Michael, you have$ 1000000.’

另一种格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……，不过这种方式写起来比%要麻烦得多：

‘Hello, {0}, 成绩提升了 {1:.1f}%’.format(‘小明’, 17.125)
‘Hello, 小明, 成绩提升了 17.1%’

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。比如，列出班里所有同学的名字，就可以用一个list表示：

classmates = [‘Michael’, ‘Bob’, ‘Tracy’]
classmates
[‘Michael’, ‘Bob’, ‘Tracy’]

变量classmates就是一个list。用len()函数可以获得list元素的个数：

len(classmates)
3

用索引来访问list中每一个位置的元素，记得索引是从0开始的：

classmates[0]
‘Michael’
classmates[1]
‘Bob’
classmates[2]
‘Tracy’

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：（-2为倒数第二个，-3为倒数第三个）

classmates[-1]
‘Tracy’

list是一个可变的有序表，所以，可以往list中追加元素到末尾：

classmates.append(‘Adam’)
classmates
[‘Michael’, ‘Bob’, ‘Tracy’, ‘Adam’]

也可以把元素插入到指定的位置，比如索引号为1的位置：

classmates.insert(1, ‘Jack’)
classmates
[‘Michael’, ‘Jack’, ‘Bob’, ‘Tracy’, ‘Adam’]

要删除list末尾的元素，用pop()方法：

classmates.pop()
‘Adam’
classmates
[‘Michael’, ‘Jack’, ‘Bob’, ‘Tracy’]

list元素也可以是另一个list，比如：

s = [‘python’, ‘java’, [‘asp’, ‘php’], ‘scheme’]
len(s)
4

也可以拆开写：

p = [‘asp’, ‘php’]
s = [‘python’, ‘java’, p, ‘scheme’]
要拿到’php’可以写p[1]或者s[2][1]，因此s可以看成是一个二维数组，类似的还有三维、四维……数组，不过很少用到。

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

classmates = (‘Michael’, ‘Bob’, ‘Tracy’)
因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来（可以为空）
如果要定义一个空的tuple，可以写成()： t = ()

但是，要定义一个只有1个元素的tuple，如果你这么定义：t = (1)
定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：t = (1,)

条件判断：
age = 3
if age >= 18:
print(‘your age is’, age)
print(‘adult’)
else:
print(‘your age is’, age)
print(‘teenager’)

当然上面的判断是很粗略的，完全可以用elif做更细致的判断：
age = 3
if age >= 18:
print(‘adult’)
elif age >= 6:
print(‘teenager’)
else:
print(‘kid’)

（不要忘记if、elif、else后面有冒号）

input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。Python提供了int()函数来完成这件事情：
s = input(‘birth: ‘)
birth = int(s)
if birth < 2000:
print(‘00前’)
else:
print(‘00后’)

Python的循环有两种，一种是for…in循环，依次把list或tuple中的每个元素迭代出来，看例子：
names = [‘Michael’, ‘Bob’, ‘Tracy’]
for name in names:
print(name)
执行这段代码，会依次打印names的每一个元素：
Michael
Bob
Tracy

所以for x in …循环就是把每个元素代入变量x，然后执行缩进块的语句。
再比如我们想计算1-10的整数之和，可以用一个sum变量做累加：
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
sum = sum + x
print(sum)

如果要计算1-100的整数之和，从1写到100有点困难，幸好Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数：

list(range(5))
[0, 1, 2, 3, 4]

第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现：
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)

如果要提前结束循环，可以用break语句：
n = 1
while n <= 100:
if n > 10: # 当n = 11时，条件满足，执行break语句
break # break语句会结束当前循环
print(n)
n = n + 1
print(‘END’)

Python内置了字典：dict的支持，具有极快的查找速度
举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：

names = [‘Michael’, ‘Bob’, ‘Tracy’]
scores = [95, 75, 85]

如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：（让一个和另一个一一对应）

d = {‘Michael’: 95, ‘Bob’: 75, ‘Tracy’: 85}
d[‘Michael’]
95

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

d[‘Adam’] = 67
d[‘Adam’]
67

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

d[‘Jack’] = 90
d[‘Jack’]
90
d[‘Jack’] = 88
d[‘Jack’]
88

要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

‘Thomas’ in d
False

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：（注意：返回None的时候Python的交互环境不显示结果。）

d.get(‘Thomas’)
d.get(‘Thomas’, -1)
-1

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

d.pop(‘Bob’)
75
d
{‘Michael’: 95, ‘Tracy’: 85}

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个list作为输入集合：

s = set([1, 2, 3])
s
{1, 2, 3}

重复元素在set中自动被过滤：

s = set([1, 1, 2, 2, 3, 3])
s
{1, 2, 3}

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

s.add(4)
s
{1, 2, 3, 4}
s.add(4)
s
{1, 2, 3, 4}

通过remove(key)方法可以删除元素：

s.remove(4)
s
{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1 & s2
{2, 3}
s1 | s2
{1, 2, 3, 4}

函数：

调用函数：

abs( ) 求绝对值
max()可以接收任意多个参数，并返回最大的那个
int()函数可以把其他数据类型转换为整数

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

a = abs # 变量a指向abs函数
a(-1) # 所以也可以通过a调用abs函数
1

定义函数：

定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
我们以自定义一个求绝对值的my_abs函数为例：

def my_abs(x):
if x >= 0:
return x
else:
return -x

如果想定义一个什么事也不做的空函数，可以用pass语句：
def nop():
pass

pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
pass还可以用在其他语句里，比如：
if age >= 18:
pass

缺少了pass，代码运行就会有语法错误。

参数检查：

让我们修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现：
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError(‘bad operand type’)
if x >= 0:
return x
else:
return -x

返回多个值：

比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的新的坐标：
import math

def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny

import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数。

然后，我们就可以同时获得返回值：

x, y = move(100, 100, 60, math.pi / 6)
print(x, y)
151.96152422706632 70.0

但其实这只是一种假象，Python函数返回的仍然是单一值：

r = move(100, 100, 60, math.pi / 6)
print(r)
(151.96152422706632, 70.0)

原来返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

函数的参数：

默认参数就排上用场了。由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2：（输入power(5)也为5的平方）
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s

一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
二是如何设置默认参数。

我们可以把年龄和城市设为默认参数：
def enroll(name, gender, age=6, city=’Beijing’):
print(‘name:’, name)
print(‘gender:’, gender)
print(‘age:’, age)
print(‘city:’, city)

这样，大多数学生注册时不需要提供年龄和城市，只提供必须的两个参数：

enroll(‘Sarah’, ‘F’)
name: Sarah
gender: F
age: 6
city: Beijing

只有与默认参数不符的学生才需要提供额外的信息：
enroll(‘Bob’, ‘M’, 7)
enroll(‘Adam’, ‘M’, city=’Tianjin’)

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
定义默认参数要牢记一点：默认参数必须指向不变对象！（不能用list）

可变参数：

可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

calc(1, 2)
5
calc()
0

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

nums = [1, 2, 3]
calc(nums[0], nums[1], nums[2])
14

这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

nums = [1, 2, 3]
calc(*nums)
14

*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

关键字参数：

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：
def person(name, age, **kw):
print(‘name:’, name, ‘age:’, age, ‘other:’, kw)

函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数：

person(‘Michael’, 30)
name: Michael age: 30 other: {}

也可以传入任意个数的关键字参数：

person(‘Bob’, 35, city=’Beijing’)
name: Bob age: 35 other: {‘city’: ‘Beijing’}
person(‘Adam’, 45, gender=’M’, job=’Engineer’)
name: Adam age: 45 other: {‘gender’: ‘M’, ‘job’: ‘Engineer’}

关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

命名关键字：

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
def person(name, age, *, city, job):
print(name, age, city, job)

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
print(name, age, args, city, job)

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错。

尾递归：

上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：
def fact(n):
return fact_iter(n, 1)

def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

模块

’ a test module ‘

author = ‘Michael Liao’

import sys

def test():
args = sys.argv
if len(args)==1:
print(‘Hello, world!’)
elif len(args)==2:
print(‘Hello, %s!’ % args[1])
else:
print(‘Too many arguments!’)

if name==’main‘:
test()

第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；

第6行使用author变量把作者写进去，这样当你公开源代码后别人就可以瞻仰你的大名；

以上就是Python模块的标准文件模板，当然也可以全部删掉不写，但是，按标准办事肯定没错。

后面开始就是真正的代码部分。

你可能注意到了，使用sys模块的第一步，就是导入该模块：