一、Python入门
1.1适合的领域!
1561449898888.png
1.2不适合的领域
1561450264211.png
1.3与其他语言区别
1.4优缺点
优点 1、代码量少
缺点 1、运行速度慢
2、Python源码并不能加密
二、Python安装
2.1跨平台语言
2.2下载和配置系统变量
1、下载：官网www.python.org
2、配置变量：我的电脑-属性-环境变量-系统变量-Path-变量值末尾加；加安装路径
2.3一个python程序
1、严格控制缩进！！
2、.py结尾
3、执行时，在cmd进入目录后 ：
eg： python hello.py 便可运行文件
三、变量和数据类型
3.1数据类型
3.1.1整数
可以处理任意大小的整数，包括负数
有时用十六进制表示# 0x（零x）
3.1.2浮点数
1.23x10^9---1.23e9
0.000012可以写成1.2e-5
整数运算永远是精确的（除法也是的！），而浮点数运算则可能会有四舍五入的误差。
3.1.3字符串
‘.......' "......"
3.14布尔值
True，False（首字母大写）
运算：and、or、not
3.1.5空值
None！=0
注释一行用 #
3.2变量
3.2.1动态语言
eg：
a = 123 # a是整数
print a
a = 'imooc' # a变为字符串
print a
这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。
补：等差数列
3.3转义字符
如果一个字符串包含很多需要转义的字符，在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了
如果要表示多行字符串，可以用r'''...'''表示
3.4Unicode字符串
3.4.1编码
1、一个字节能表示的最大的整数就是255（二进制11111111=十进制255），0 - 255被用来表示大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码
2、中国制定了GB2312编码
3、Unicode通常用两个字节表示一个字符，把所有语言都统一到一套编码里
raw+多行：
ur'''Python的Unicode字符串支持"中文",
"日文",
"韩文"等多种语言'''
如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。在第一行添加注释：# -- coding: utf-8 --
3.6Python整数和浮点数运算
整数运算结果---整数
浮点数运算结果---浮点数
整数和浮点数混合运算的结果---浮点数
3.7布尔运算
在Python中，布尔类型还可以与其他数据类型做 and、or和not运算：
a = True
print a and 'a=T' or 'a=F'
计算结果不是布尔类型，而是字符串 'a=T'
因为Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True，所以：
True and 'a=T' 计算结果是 'a=T'
短路计算 'a=T' or 'a=F' 计算结果还是 'a=T'
短路计算：
在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，
在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；
所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。
四、List和Tuple集合类型
4.1List类型
4.1.List特点
1、 Python内置的一种数据类型是列表：list
有序的集合，列表
可添加和删除其中的元素
2、由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，一个list中可以包含各种数据：
L = ['Michael', 100, True]
3、一个元素也没有的list，就是空list：
empty_list = [ ]
4.1.2List索引访问和倒序访问
1、索引访问
索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，不要越界！！！
eg：print L[0]
2、倒序访问
用 -1 这个索引来表示最后一个元素
倒数第二用 -2 表示
倒数第三用 -3 表示
不要越界！！！
eg: print L[-1]
4.1.3List元素添加、删除、替换
1、添加元素
（1）第一个办法是用 list 的 append() 方法，把新元素加到 List 的末尾
eg：
L = ['Adam', 'Lisa', 'Bart']
L.append('Paul')
print L
['Adam', 'Lisa', 'Bart', 'Paul']
(2)用list的 insert( )方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：
eg:
L = ['Adam', 'Lisa', 'Bart']
L.insert(0, 'Paul')
print L
['Paul', 'Adam', 'Lisa', 'Bart']
2、删除元素pop()
（1）删除最后一个元素，用pop()方法直接删
eg： L.pop()
（2）删除指定位置元素，pop()带上索引位置
eg：L.pop(2)
同时删除几个元素的时候，注意先后顺序和索引变化
3、替换元素
找到指定位置，用新元素直接替换掉：
eg: L[2] = 'Paul'
4.2Tuple
4.1Tuple特点
1、tuple是另一种有序的列表，“ 元组 ”
有序列表
tuple 和 List 非常类似，
Tuple一旦创建完毕，不能修改
t = ('Adam', 'Lisa', 'Bart')
2、tuple和list一样，可以包含 0 个、1个和任意多个元素。
（1）包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：
t = ()
print t
()
（2）创建包含1个元素的 tuple 呢？来试试：
t = (1)
print t
1
注意！！！t 不是 tuple ，而是整数1。为什么呢？
因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：
t = (1,)
print t
(1,)
4.2.2“内容可变”的Tuple
定义时，tuple包含的三个元素：
当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：
表面上看，tuple的元素确实变了，但其实变的不是 tuple 的元素，而是list的元素。
tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
五、条件判断和循环
5.1条件判断
If格式
(1) if age>=18 ：
(2) if age>=18 ：
......
else:
......
(3) if age >= 6 :
......
elif age >= 18 :
......
else :
......
！！！！冒号千万记住！！！！
Python代码的缩进规则：
具有相同缩进的代码被视为代码块
Python的习惯写法：
4个空格，不要使用Tab，更不要混合Tab和空格
5.2循环
5.2.1For循环
eg:
for name in L :
5.2.2While循环
eg:
while x
5.2.3break和continue
break直接跳出循环
while True:
sum = sum + x
x = x + 1
if x > 100:
break
continue跳过本次循环，继续下一次循环
for x in L:
if x < 60:
continue
sum = sum + x
n = n + 1
5.2.4多重循环
在循环内部，还可以嵌套循环
eg：（冒号千万不要忘掉！！）
for x in ['A', 'B', 'C']:
for y in ['1', '2', '3']:
print x + y
六、Dict和Set类型
6.1Dict集合
6.1.1Dict定义
花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可，最后一个 key: value 的逗号可以省略：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
key-value，dict就是通过 key 来查找 value。
由于dict也是集合，len() 函数可以计算任意集合的大小：
eg:
len(d)
3
6.1.2Dict访问
（1）用 d[key] 查找对应的 value,先判断一下 key 是否存在，用 in 操作符,从而避免KeyError：
if 'Paul' in d :
print d['Paul']
（2）使用dict本身提供的 get()，在Key不存在的时候，返回None：
print d.get('Bart')
59
print d.get('Paul')
None
6.1.3Dict的特点
（1）查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
dict的缺点是占用内存大，list正好相反，占用内存小，但是查找速度慢。
dict是按 key 查找，在一个dict中，key不能重复。
（2）存储的key-value序对是无序，list有序
（3）作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。
6.1.4Dict更新
dict是可变的，可以随时往dict中添加新的 key-value；如果 key 已经存在，新的 value 值会替换掉原来的 value值
6.1.5Dict遍历
eg：遍历key
for key in d :
... print key
eg：遍历key：value
for key in d :
print key+':',d[key]
6.2Set集合
6.2.1Set定义
1、dict的作用是建立 key - value 的映射关系，dict的key是不能重复的。
set只想要 dict 的 key，不关心 key 对应的 value，保证这个集合的元素不会重复
2、set 特点
与 list 很像：持有一系列元素
与dict的key很像：元素没有重复，而且无序必须是不变对象
set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
3、创建 set
调用 set() 并传入一个 list，list的元素将作为set的元素：
s = set(['A', 'B', 'C'])
print s
set(['A', 'C', 'B'])
6.2.2Set访问
set存储的是无序集合，无法通过索引访问，访问 set中的某个元素实际上是判断一个元素是否在set中。
s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
我们可以用 in 操作符判断：
'Bart' in s
True
6.2.3Set遍历
由于 set 也是一个集合，所以，遍历 set 和遍历 list 类似，都可以通过 for 循环实现。
s = set(['Adam', 'Lisa', 'Bart'])
for name in s:
... print name
6.2.4更新Set（添加，删除）
1、添加元素时，用set的add()方法：
s = set([1, 2, 3])
s.add(4)
print s
set([1, 2, 3, 4])
如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：
s = set([1, 2, 3])
s.add(3)
print s
set([1, 2, 3])
2、删除set中的元素时，用set的remove()方法：
s = set([1, 2, 3, 4])
s.remove(4)
print s
set([1, 2, 3])
如果删除的元素不存在set中，remove()会报错：
s = set([1, 2, 3])
s.remove(4)
Traceback (most recent call last):
File "
KeyError: 4
所以用add()可以直接添加，而remove()前需要判断。
七、函数
7.1函数定义
7.2函数调用
1、Python内置了很多有用的函数，我们可以直接调用。
要调用一个函数，需要知道函数的名称和参数
比如求绝对值的函数 abs，它接收一个参数。可以直接从Python的官方网站查看文档：
http://docs.python.org/2/library/functions.html#abs
也可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。
2、参数错误：
（1）参数个数
调用函数的时候，如果传入的参数数量不对，会报TypeError的错误
TypeError: abs() takes exactly one argument (2 given)
（2）参数类型错误，也会报TypeError的错误
TypeError: bad operand type for abs(): 'str'
3、比较函数 cmp(x, y) 就需要两个参数，如果 x
cmp(1, 2)
-1
cmp(2, 1)
1
cmp(3, 3)
0
4、int()函数和str()函数
int('123')
123
int(12.34)
12
str(123)
'123'
str(1.23)
'1.23'
7.3自定义函数
定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回
自定义函数：
def square_of_sum(L) : (冒号记得)
sum=0
for num in L:
sum=sum+num*num
return sum
函数调用
print square_of_sum([1, 2, 3, 4, 5])
返回值
一旦执行到return时，函数就执行完毕，并将结果返回
如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。
return None可以简写为return。
7.4“返回多值”假象
math包提供了sin()和 cos()函数，我们先用import引用它：
import math
def move(x, y, step, angle):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
这样我们就可以同时获得返回值：
x, y = move(100, 100, 60, math.pi / 6)
print x, y
151.961524227 70.0
但其实这只是一种假象，Python函数返回的仍然是单一值：
r = move(100, 100, 60, math.pi / 6)
print r
(151.96152422706632, 70.0)
用print打印返回结果，原来返回值是一个tuple！
但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。
7.5递归函数
汉诺塔递归：
def move(n, a, b, c):
if n==1:
print a,'-->',c
return
move(n-1,a,c,b)
print a,'-->',c
move(n-1,b,a,c)
move(4, 'A', 'B', 'C')
7.6定义默认参数
定义函数的时候，还可以有默认参数。
int() 函数，有两个参数，既可以传一个参数，又可以传两个参数：
int('123')
123
int('123', 8)
83
int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。
函数的默认参数的作用是简化调用，你只需要把必须的参数传进去。在需要的时候，又可以传入额外的参数来覆盖默认参数值。
由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面
7.7定义可变参数（个数可变）
想让一个函数能接受任意个参数，就可以定义一个可变参数：
def fn(*args):
print args
可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数：
fn()
()
fn('a')
('a',)
fn('a', 'b')
('a', 'b')
fn('a', 'b', 'c')
('a', 'b', 'c')
Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 。
八、切片
8.1List、Tuple切片
Python提供了切片（Slice）操作符，能大大简化这种操作。
1、正序切片
（1）用一行代码就可以完成切片：
L[0:3]
['Adam', 'Lisa', 'Bart']
L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。
（2）如果第一个索引是0，还可以省略：
L[:3]
['Adam', 'Lisa', 'Bart']
（3）只用一个 : ，表示从头到尾：
L[:]
['Adam', 'Lisa', 'Bart', 'Paul']
因此，L[:]实际上复制出了一个新list。
（4）切片操作还可以指定第三个参数：
L[::2]
['Adam', 'Bart']
第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。
把list换成tuple，切片操作完全相同，只是切片的结果是tuple。
2、倒序切片
对于list，支持倒数切片，倒数第一个元素的索引是-1。
L[-4:-1:2]
['Adam', 'Bart']
倒序切片包含起始索引，不包含结束索引。
8.2对字符串切片
字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符，字符串切片结果仍是字符串：
'ABCDEFG'[:3]
'ABC'
'ABCDEFG'[-3:]
'EFG'
'ABCDEFG'[::2]
'ACEG'
Python没有针对字符串的截取函数，只需要切片一个操作就可以完成，非常简单。
字符串的 upper() 可以把字符变成大写字母：
'abc'.upper()
'ABC'
九、迭代
9.1迭代(for循环)
在Python中，通过for循环来遍历一个list或tuple，这种遍历我们成为迭代（Iteration），
在Python中，迭代是通过 for ... in 来完成的，可以作用在list、tuple及其他任何可迭代对象上。
注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：
- 有序集合：list，tuple，str和unicode；
- 无序集合：set
- 无序集合并且具有 key-value 对：dict
迭代是一个动词，它指的是一种操作，在Python中，就是 for 循环。
9.2索引迭代
Python中，迭代永远是取出元素本身，而非元素的索引。
若要取得索引，方法是使用 enumerate() 函数：
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in enumerate(L):
... print index, '-', name
...
0 - Adam
1 - Lisa
使用 enumerate() 函数，在for循环中同时绑定索引index和元素name。实际上，enumerate() 函数把：
['Adam', 'Lisa']
变成了类似：
[(0, 'Adam'), (1, 'Lisa')]
因此，迭代的每一个元素实际上是一个tuple。
索引迭代也不是真的按索引访问，而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身。
zip()函数可以把两个 list 变成一个 list：
zip([10, 20, 30], ['A', 'B', 'C'])
[(10, 'A'), (20, 'B'), (30, 'C')]
9.3迭代dict的value
dict对象本身就是可迭代对象，用 for 循环直接迭代 dict，可以每次拿到dict的一个key。
如果我们希望迭代 dict 对象的value，
（1）dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
[85, 95, 59]
for v in d.values():
print v
85
95
59
(2)dict对象的itervalues() 方法，用 itervalues() 方法迭代效果完全一样：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()
for v in d.itervalues():
print v
85
95
59
两个方法有何不同之处呢？
- values() 方法实际上把一个 dict 转换成了包含 value 的list。
- 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省内存。
- 打印 itervalues() 发现它返回一个
对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。
如果一个对象说自己可迭代，那我们就直接用 for 循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。
9.4同时迭代dict的key-value
（1） dict 对象的 items() 方法返回的值：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.items()
[('Lisa', 85), ('Adam', 95), ('Bart', 59)]
可以看到，items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：
for key, value in d.items():
... print key, ':', value
...
Lisa : 85
Adam : 95
Bart : 59
（2）dict对象的iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59}
sum = 0.0
for k, v in d.iteritems() :
sum = sum + v
print k,':',v
print 'average', ':', sum/len(d)
十、列表生成式
10.1生成列表
（1）要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
（2）如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做
[x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
这种写法就是Python特有的列表生成式，利用列表生成式，可以以非常简洁的代码生成 list。
（3）利用列表生成式生成列表 [1x2, 3x4, 5x6, 7x8, ..., 99x100]
提示：range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]
print [x*(x+1) for x in range(1,100,2)]
10.2列表生成式--条件过滤
列表生成式的 for 循环后面还可以加上 if 判断。eg：只想要偶数的平方，不改动 range()的情况下，可以加上 if 来筛选：
[x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
有了 if 条件，只有 if 判断为 True 的时候，才把循环的当前元素添加到列表中。
isinstance(x, str) 可以判断变量 x 是否是字符串
10.3多层表达式
for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。
（1）对于字符串
'ABC' 和 '123'，可以使用两层循环，生成全排列：
[m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
（2）对于数
找出对称的 3 位数 ：
print [i100+j10+k for i in range(1,10) for j in range(0,10) for k in range(1,10) if i==k]
以上是2019-06-24到2019-06-25学习廖雪峰老师的python入门基础课程所做的简单记录~