基于Python 3.4.3

一 二 三 四  基础

print 三版必须加括号，二版不用加

alt + n ：上一条语句

alt + p ：下一条语句

打印三条hello

没有大括号，用缩进来表示

BIF 内建函数

使用变量前要先对其赋值

字母可以使大小写，但是大小写是不同的

字符串可以用单引号或者是双引号

原始字符串：在字符串前面加上r，就不用加转义字符了

长字符串，多行，用三引号字符串

条件分支

if 条件：

　　条件为真执行的操作

else：

　　条件为假执行的操作

猜数字：

 print("这是一个猜数字游戏")

 import random

 secret = random.randint(1,10)

 temp = input("请输入1-10数字：")

 guess = int(temp)

 while guess != secret:

     if secret > guess:

         temp = input("小了\n")

         guess = int(temp)

     else:

         temp = input("大了\n")

         guess = int(temp)

 print("恭喜答案正确")

五 变量类型

整型、浮点、e记法、布尔类型(布尔类型首字母大写，True，False)

不要把str当作变量名，str()是个BIF

获得关于类型的BIF type()

python更建议用isinstance()判断类型，返回值是bool

六 操作符

+  -  *  % **  //

可以写成 a = b = c = d = 10

幂运算的优先级比起左侧操作符高，比右侧操作符低

>>> -3 ** 2
-9

>>> 3 ** -2
0.1111111111111111

七 八 九 分支和循环

 score = int(input("请输入一个分数："))

 if 90 <= score <=100:

     print("A")

 elif 80 <= score <90:

     print("B")

 elif 70 <= score <80:

     print("C")

 elif 60 <= score <70:

     print("D")

 else:

     print("E")

三元操作符

语法： x if 条件 else y

eg：

x = 6
y = 5
small = x if x<y else y
print(small)

结果：

5

for循环

 s = "favourite"

 for i in s:

     print(i,end = " ")

列表

member = ["a","ab","abc","abcd","abcde","abcdefg"]

for i in member:

    print(i,len(i))

range()

range([strat,][stop][,step=1])

经常与for循环使用，这个BIF有三个参数，其中中括号括起来的的两个表示这两个参数是可选的。

step=1表示第三个参数的值默认值是1

range这个bif的作用是生成一个从start参数的值开始到stop结束的序列

break

 print("这是一个猜数字游戏")

 import random

 secret = random.randint(1,10)

 guess = int(input("请输入1-10数字："))

 while True:

     if guess == secret:

         break

     else:

         guess = int(input("输入错误，请重新输入"))

 print("恭喜答案正确")

十 十一 十二  列表

查看列表方法：

列表可以是混合类型的

列表可以使空的

Noen是Python的一个内建值

.append()表尾追加一个值

.extend()在表尾追加一个列表

.insert(位置，元素)

.index(元素)　　获取元素位置

可以加上搜索范围.index(元素，其实位置，终止位置)

.remove(元素)　　删除元素

del 序列[位置]

.pop(元素位置)　　默认是最后一个

.count(元素)  计算元素个数

.reverse()　　元素翻转

.sort()　　排序

改变原始列表

倒序可以：

列表分片

第一个索引是提取第一个元素的编号，而最后的索引则是分片之后剩余部分的第一个元素的编号

也就是第一个索引元素包含在分片之内，而第二个则不包含在分片之内

列表复制一定要用这种方法

列表能用的元算 +（两个序列必须类型一致） *

成员资格 in

访问列表中的列表，类似于二维数组

十三 元组

元组不可修改，是由括号和逗号定义的

修改元祖只能给其重新赋值：

十四  字符串方法

字符串和元组一样都是都是不可改变的

几个常用的方法：

.find()

find方法可以在一个较长的字符串中查找子串。返回字串所在位置最左端的索引，如果没有则返回-1。这个方法可以接收可选的起始点或结束点参数

.lower()

返回字符串的小写字母版，主要用于编写不区分大小写的代码

.split()

分割字符串成序列，如果不提供任何分割符，则把所有空格当作分隔符

.joint()

split的逆方法，分隔符.join(字符串)

.replace()

返回字符串的所有匹配项被替换后的字符串，.replace(“被替换”，“替换”)

.translate()

translate方法只处理单个字符，优势在于可以同时进行多个字符替换，使用translate转换之前，需要先完成一张转换表

注意import的是string，但是用的时候是str

十五  字符串格式化

.format() 位置输出

% 格式化操作符

用#填充数字进制格式

控制字段宽度精度

总结：

十六  序列

列表、元组和字符串放在一块儿来讲解是有道理的，我们发现Ta们之间有很多共同点：

1. 都可以通过索引得到每一个元素

2. 默认索引值总是从0开始（当然灵活的Python还支持负数索引）

3. 可以通过分片的方法得到一个范围内的元素的集合

4. 有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）

所以我们把他们叁统称为：序列

序列常用的方法

list(iterable) 把一个可迭代对象转换为列表

tuple([iterable]) 把一个可迭代对象转换为元组

str(obj) 把obj对象转换为字符串

len(sub) 返回sub的长度

max() 返回序列或者参数集合中的最大值

min() 返回序列或者参数集合中的最小值

sum(iterable[, start=0]) 返回序列iterable和可选参数start的总和

sorted(iterable, key=None, reverse=False) 返回一个排序的列表，使用方法跟列表的内建函数（list.sort()）一致，注意，这个sorted()后边有“ed”哦。

reversed(sequence) 返回逆向迭代序列的值，一样道理，跟列表的内建函数（list.reverse()）一致，注意，这个reversed()后边也多了个“d”哦。

enumerate(iterable) 生成由每个元素的index值和item值组成的元组

zip(iter1 [,iter2 […]]) 返回由各个参数的序列组成的元组

 二十五 二十六  字典

字典是Python语言中唯一的映射类型。

映射类型对象里哈希值（键，key）和指向的对象（值，value）是一对多的的关系，通常被认为是可变的哈希表。

字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。

字典类型与序列类型的区别：

1.存取和访问数据的方式不同。

2.序列类型只用数字类型的键（从序列的开始按数值顺序索引）；

3.映射类型可以用其他对象类型作键（如：数字、字符串、元祖，一般用字符串作键），和序列类型的键不同，映射类型的键直

4.接或间接地和存储数据值相关联。

5.映射类型中的数据是无序排列的。这和序列类型是不一样的，序列类型是以数值序排列的。

6.映射类型用键直接“映射”到值。

字典的创建

特点：
1、键与值用冒号“：”分开；
2、项与项用逗号“，”分开；
3、字典中的键必须是唯一的，而值可以不唯一。

使用工厂函数dict()创建字典：

注意括号的个数，因为dict()只接受一个参数，所以用（）把键值对包括

键值对的增加与删除

字典的方法

1、adict.keys() 返回一个包含字典所有KEY的列表；

2、adict.values() 返回一个包含字典所有value的列表；

3、adict.items() 返回一个包含所有（键，值）元祖的列表；

4、adict.clear() 删除字典中的所有项或元素；

5、adict.copy() 返回一个字典浅拷贝的副本；

直接赋值并没有创建新的内存空间

6、adict.fromkeys(seq, val=None) 创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值（默认为None）；

初始化一个空字典：

注意，仅仅是返回一个新字典，并不能改变旧字典，要想改变必须用a = a.fromkeys

7、adict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）；

一般来说如果试图访问字典中不存在的项时会出错，而用get就不会

8、  in 、 not in；

9、adict.iteritems()、adict.iterkeys()、adict.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；

10、adict.pop(key[,default]) 和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；

11、adict.setdefault(key, default=None) 和set()方法相似，但如果字典中不存在Key键，由 adict[key] = default 为它赋值；

12、adict.update(bdict) 将字典bdict的键值对添加到字典adict中。

字典中的键，值，键值对用　　.keys()　　.values()　　.items()表示

二十七 集合

集合不会出现重复元素，用｛｝标记，set()函数将其他容器类型转变为集合，有.add()和.remove()方法，当用frozenset()函数定义一个集合时，这个集合不可改变

函数

裴波那切的例子：

利用上列表的-1 -2来表示后两个元素的方法很巧妙

 def fibs(num):

     a = [0,1]

     for i in range(num-2):

         a.append(a[-1] + a[-2])

     return a

 num = int(input("How many Fibonacci nubmers do you want:"))

 print(fibs(num))

执行结果：

另一个方法 ：

 def fib(num):

    n,a,b = 0,0,1

    while(n < num):

       print(b)

       a,b = b,a+b

       n += 1

 num = int(input("How many Fibonacci nubmers do you want:"))

 fib(num)

在函数里面修改全局变量的值需要加上globle，否则将在函数内创建另一个同名的局部变量

 num = 3

 def chcange_globle():

     global num

     num = 6

 print(num)

注意是globle不是global（前者是名次，后者是形容词）

关键字参数和默认参数

在函数调用过程中用参数名提供的参数是关键字参数

在函数定义过程中用参数名提供的参数是默认参数

 def who_words(name = '王尼玛',words = '来来来'):

     print(name,words)

 who_words()#使用默认参数

 who_words('丁尼玛')

 who_words(words = '我草',name = '赵尼玛')#使用关键字参数

收集函数

*params

 def print_params(*params):

     print("the num of params is :",len(params))

     print("the third param is :",params[2])

     print(params)

 print_params('a','b','c','d','e')

若参数中还有其他参数需要用关键字参数指出，否则会被认成收集参数，导致程序出错

 def print_params(*params,name,age):

     print("the num of params is :",len(params))

     print(params)

     print(name,age)

 print_params('a','b',name = '王叔叔',age = '')

**params

返回字典

 def fun(**params):

     print(params)

 fun(x=1,y=2)

嵌套

一个函数放在另一个函数里面，就是嵌套

闭包：如果在一个内部函数，对在外部作用域引用的变量，内部函数就叫做闭包

 def fun1(x):

     def fun2(y):

         return x*y

     return fun2()

两种实现方式：

递归

 def han(n,x,y,z):

     "将n层汉诺塔从x移动到z上"

     if n == 1:

         print(x,'-->',z)

     else:

         han(n-1,x,z,y)

         print(x,'-->',z)

         han(n-1,y,x,z)

 n = int(input("input n:"))

 han(n,'X','Y','Z')

执行结果：

如果在函数开头写下字符串，它会作为函数的一部分进行存储，这称为文档字符串。调用方法：函数名.__doc__  （注意是双下划线）

函数式编程

某些语言使用函数就可以完成所有的事（Lisp,Erlang,F#），没有变量，只有输入输出和函数（以上为自己理解）

Python提供函数式编程思想的函数有：lambda、map、filter、reduce

lambda:

map:将序列中的元素全部传递给一个函数

map(function, sequence[, sequence, ...]) -> list

通过定义可以看到，这个函数的第一个参数是一个函数，剩下的参数是一个或多个序列，返回值是一个集合。

function可以理解为是一个一对一或多对一函数，map的作用是以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的list。

filter：过滤出为真值的列表

filter(function or None, sequence) -> list, tuple, or string

function是一个谓词函数，接受一个参数，返回布尔值True或False。

filter函数会对序列参数sequence中的每个元素调用function函数，最后返回的结果包含调用结果为True的元素。

求奇数：