Python基础语法知识——简化版

作者: Super_Grace | 来源:发表于2019-07-02 20:01 被阅读0次

一、Python入门

1.1适合的领域! 1561449898888.png

1.2不适合的领域 1561450264211.png

1.3与其他语言区别

1.4优缺点

优点 1、代码量少
缺点 1、运行速度慢
2、Python源码并不能加密

二、Python安装

2.1跨平台语言

1561450541101.png

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

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。

补：等差数列

1561451761372.png

3.3转义字符

1561452088262.png

如果一个字符串包含很多需要转义的字符，在字符串前面加个前缀 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

1561463998122.png

定义时，tuple包含的三个元素：

1561464022746.png

当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：

1561464070662.png

表面上看，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<N :

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 "<stdin>", line 1, in <module>
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<y，返回 -1，如果 x==y，返回 0，如果 x>y，返回 1：

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()
<dictionary-valueiterator object at 0x106adbb50>
for v in d.itervalues():
print v
85
95
59

两个方法有何不同之处呢？

values() 方法实际上把一个 dict 转换成了包含 value 的list。

但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省内存。

打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象，这说明在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入门基础课程所做的简单记录~