Python 编辑注意点

文本编辑 Python：

绝对不能用Word和Windows自带的记事本。

（1）Word保存的不是纯文本文件

（2）记事本会自作聪明地在文件开始的地方加上几个特殊字符（UTF-8 BOM），结果会导致程序运行出现莫名其妙的错误。

像.exe文件，直接运行 .py文件：

（1）在Windows下不能直接运行。在MAC、Linux下可直接运行

（2）方法：

step1：在.py文件的第一行加上一个特殊的注释： #!/usr/bin/env python3

step2：通过命令给hello.py以执行权限： $ chmod a+x hello.py

# : 以#开头的语句是注释，注释是给人看的，可以是任意内容，解释器会忽略掉注释。

:冒号：当语句以冒号:结尾时，缩进的语句视为代码块。约定俗成：使用4个空格的缩进

Python程序是大小写敏感的，如果写错了大小写，程序会报错

如果字符串内部既包含'又包含" 。则可以用 转义字符\来标识（放置在 ' 或 ” 之前）比如： 'I\'m \"OK\"!' 表示的字符串内容是 I'm "OK"! 。

输入多行内容时，可以 '''...'''的格式表示多行内容。如在cmd窗口中输入 print('''a 回车则会出现... 示意继续输入。结束时，以输入''' 结束。

python 是动态语言，变量本身类型不固定，可以反复赋值

在Python中，有两种除法:

（1）一种除法是/ 。/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数： 9 / 3 》3.0

（2）一种除法是//，称为地板除，两个整数的除法仍然是整数：10 / 3 》3

Python 余数运算。 % 。可以得到两个整数相除的余数：10 % 3 》1

字符串与编码

len() ：计算str包含多少个字符，可以用len()函数： len(b'ABC') 》 3

由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3     告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；



# -*- coding: utf-8 -*-          告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码：


（1）%  运算符:  是用来格式化字符串的

（2）常见占位符：

%d 整数：

%d 普通的整数输出；

%2d整数输出，整数的宽度是2位，若不足两位，左边补空格；

%02d整数输出，整数的宽度是2位，若不足两位，左边补0；

%.2d 整数输出，整数的有效数字是2位。

>>> '%2d-%02d' % (3, 1)

 ' 3-01'

%f 浮点数
%s 字符串
%x 十六进制整数

（3）字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%： 'growth rate: %d %%' % 7 >>> 'growth rate: 7 %'

函数

for x in ...循环：是把每个元素代入变量x，然后执行缩进块的语句。 for a in list:

range()函数：range(5)生成的序列是从0开始小于5的整数

列表list （有序的集合）可变

创建数组 classmates = ['Michael', 'Bob', 'Tracy']

len()函数可以获得list元素的个数（如果一个list中一个元素也没有，就是一个空的list，它的长度为0） >>> len(classmates)

用索引来访问list中每一个位置的元素，记得索引是从0开始的 >>> classmates[0] 'Michael'

用 -1做索引，直接获取最后一个元素 >>> classmates[-1]

往list中追加元素到末尾 >>> classmates.append('Adam')

把元素插入到指定的位置，比如索引号为1的位置： >>> classmates.insert(1, 'Jack')

删除list末尾的元素 >>> classmates.pop()

要删除指定位置的元素，用pop(i)方法，其中i是索引位置 >>> classmates.pop(1)

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置： >>> classmates[1] = 'Sarah'

list元素也可以是另一个list， >>> s = ['python', 'java', ['asp', 'php'], 'scheme'] 。s[2]又是一个list。要拿到'php'可以写p[1]或者s[2][1]

元组tuple （有序列表）不可变

tuple一旦初始化就不能修改

用括号()可以表示tuple >>> classmates = ('Michael', 'Bob', 'Tracy')

如果要定义一个空的tuple >>> t = ()

如果要定义一个空的tuple >>> t = (1) >>> t = (1,)

tuple元素，指向永远不变。但元素中如果有list，则该list 的值是可变的。

例：打印数组信息

#!/user/bin/env python3

# -*- coding: utf-8 -*-

L = [

    ['Apple', 'Google', 'Microsoft'],

    ['Java', 'Python', 'Ruby', 'PHP'],

    ['Adam', 'Bart', 'Lisa']

]

print('输出1：%s， 输出2： %s  ，输出3： %s'     %(L[0][0],L[1][1],L[2][2]))

条件判断

if  条件：

   do

else:

   do

if else的判断是很粗略的，完全可以用elif做更细致的判断。

elif是else if的缩写，完全可以有多个elif，所以if语句的完整形式就是：

if <条件判断1>:

    <执行1>

elif <条件判断2>:

    <执行2>

elif <条件判断3>:

    <执行3>

else:

    <执行4>

if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else。即若第一个条件判断成功，就不会判断剩下的条件。

if判断条件还可以简写，比如写：

if x:

    print('True')

只要x是非零数值、非空字符串、非空list等，就判断为True，输出print。否则为False。

循环（for .in . \ while）

for x in ...循环：把每个元素代入变量x，然后执行缩进块的语句

while循环：只要条件满足，就不断循环，条件不满足时退出循环。

break ：作用是在循环过程中直接退出循环。提前结束循环。

continue： 在循环过程中，也可以通过continue语句，跳过本轮循环，直接开始下一次循环。

ps：如果程序陷入“死循环”，可以Ctrl+C退出程序，或者强制结束Python进程。

字典 dict (全称：dictionary/map)

把数据放入dict的方法:

（1）初始化时指定： ex： d={'aa': 11, 'bb': 22, 'cb': 33}

（2）通过key放入： d['dd']=44

要避免key不存在的错误：

（1）通过in判断key是否存在：'dd' in d >>存在则输出true ,否则false

（2）通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value

d.get('ddddd') #key不存在，则不输出结果。key存在，则输出value值。
d.get('dddd',-1) # 同上

一个key只能对应一个value.多次对一个key放入value，后面的值会把前面的值冲掉

删除key：用pop(key)方法删除key，对应的value也会从dict中删除 d.pop('dd')

key必须是不可变对象。因为dict根据key来计算value的存储位置。这种算法称为哈希算法（Hash）。

set集合
set 是一组key的集合，但不存储value。（set的key不能重复。）

s=set([1,2,3]) 创建set（提供list作为输入集合）

s.add(dd) 可以添加元素

s.remove(dd) 可以删除元素

set中重复的元素会被自动过滤。

set可以看成数学意义上的无序和无重复元素的集合，两个set可以做数交集（s1 & s2）、并集（s1 | s2）等操作

set和dict的唯一区别仅在于没有存储对应的value

函数

定义函数： 使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def my_abs(x):

    if not isinstance(x, (int, float)):

        raise TypeError('bad operand type')  #如果传入错误的参数类型，函数就可以抛出一个错误：bad operand type

    if x >= 0:

        return x

    else:

        return -x

位置参数

对于power(x,n)函数，参数x、n都是位置参数。调用函数时，传入的两个值按照位置顺序依次赋给参数x和n
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s

（2）默认参数

默认参数可以简化函数的调用。降低调用函数的难度：

a.必选参数在前，默认参数在后，否则Python的解释器会报错
b.函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数（注：当值与默认参数不符时，再进行指定）
c.默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

**（3）可变参数 *args**

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

定义可变参数有2种方案：

方案一： 将参数作为一个list 或者 tuple传进来。定义如下，与普通函数无差别，但是调用的时候，需要组装lst

def calc(numbers):

sum = 0

for n in numbers:

sum = sum + n * n

return sum

方案二： 在参数前面加了一个*号。则调用时，可以传入任意个参数。 ex: calc(1, 2) >>> 5

def calc(*numbers):

sum = 0

for n in numbers:

sum = sum + n * n

return sum

（4）关键字参数 kw**

关键字参数允许你传入0个或任意个含参数名的参数，这些参数在函数内部自动组装为一个dict。可以扩展函数的功能。

定义：

def person(name, age, **kw):

    print('name:', name, 'age:', age, 'other:', kw)

调用：

>>> person('Michael', 30) #只传必选参数

name: Michael age: 30 other: {}

>>> person('Bob', 35, city='Beijing')  #传入1个关键字参数

name: Bob age: 35 other: {'city': 'Beijing'}

>>> person('Adam', 45, gender='M', job='Engineer') #传入2个关键字参数

name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

（5）命名关键字参数

限制调用者可以传入的参数名，同时可以提供默认值。

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数（若没有* ，则定义的是位置参数）

def person(name, age, *, city, job):

    print(name, age, city, job)

（99）参数组合

参数组合使用时，参数的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a, b, c=0, *args, **kw):

print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

递归函数

所有的递归函数都可以写成循环的方式。但循环的逻辑不如递归清晰。

递归函数 fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n

# fact（n）用递归的方式写出来

def fact(n):

    if n==1:

        return 1

    return n * fact(n - 1)

汉诺塔 的移动也可以看做是递归函数。

思路：
对柱子编号为a, b, c，将所有圆盘从a移到c可以描述为： 
- 如果a只有一个圆盘，可以直接移动到c； 
- 如果a有N个圆盘，可以看成a有1个圆盘（底盘） + (N-1)个圆盘，首先需要把 (N-1) 个圆盘移动到 b，然后，将 a的最后一个圆盘移动到c，再将b的(N-1)个圆盘移动到c。

#编写一个函数，给定输入 n, a, b, c，打印出移动的步骤

def move(n, a, b, c):

    if n ==1:

        print a, '-->', c

    else：

    move(n-1, a, c, b)

    move(1, a, b, c) # 或 print a, '-->', c

    move(n-1, b, a, c)

 # 调用时，输入如 move(2,'A','B','C')。可参看结果