Python学习的个人笔记（基础语法）

Posted 2020-08-31 星过无痕

Python学习的个人笔记

题外话：

我是一个大二的计算机系的学生，这份python学习个人笔记是趁寒假这一周在慕课网，w3cschool，还有借鉴了一些博客，资料整理出来的，用于自己方便的时候查阅，一开始保存在word上，代码不是很好看，于是决定复制到博客里面，可能有复制过程中出错的，或者我本身在理解方面有出错的地方，希望能得到指正，谢谢

 后续的内容我会继续学习……

 

python下载地址  www.python.org

Python 分为2.7和3.3两个版本，3.3有些库不兼容，因此用2.7版本

Python解释型语言  代码量小，可移植性高，执行速度慢

配置环境变量 Path   ;C:\\Python27;

对缩进要求严格，四个空格，不建议用Tab，不同平台上缩进不一样

要输出中文在开头写上  # -*- coding: utf-8 -*-

我使用的IDE为Pycharm，注释为ctrl + /

官方文档 http://docs.python.org/2/

中文文档  http://python.usyiyi.cn/

http://www.pythondoc.com/

一张图概况Python学习（转自W3Cschool）

目录：

Python基础语法：

（1）打印出hello world

（2）注释

（3）数据类型

（4）运算

（5）输入

（6）输出

（7）序列

（8）相等比较

（9）选择

（10）循环

（11）字典(dict)

（12）集合(set)（不常用）

（14）pass,del,exec,eval

（15）内建函数

Python进阶语法：

（1）文件

（2）错误和异常

（3）模块和包

（4）作用域

（5）高阶函数

（6）装饰器

（7）参数

（8）面向对象

（9）定制类（魔术方法）

（10）日期和时间

（11）数学与随机数

（12）正则表达式

 

 

 

Python基础语法：

（1）打印出hello world

# -*- coding: utf-8 -*-
print "hello world"
print "你好 世界"

（2）注释

1、（单行注释）以 # 开头，后面的文字直到行尾都算注释

2、（多行注释）多行注释是用三引号\'\'\'   \'\'\'包含的（单引号和双引号均可）

3、（中文注释）要注释中文必须程序开头先写上# -*- coding: utf-8 -*-，不然会报错

 

（3）数据类型

1、变量不需要声明，可以直接输入，大小写敏感

2、这里的var = xxxx不叫变量赋值，而叫变量绑定，一个符号可以绑定任意类型的值。

3、内置函数type(), 用以查询变量的类型

var = 1
print var  #1
print type(var)  #整数类型 # <type \'int\'>
var = 1.1
print var   #  1.1
print type(var)  #浮点数类型  # <type \'float\'>
var = \'hello\'
print var  # hello
print type(var)  #字符串  # <type \'str\'>
var = (1==1)  
print var  # True
print type(var)  #布尔型  # <type \'bool\'>
var = None
print var  # None
print type(var)  #空值  # <type \'NoneType\'>
var = 1+1j  或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
print var  # (1+1j)
print type(var)  #复数类型     # <type \'complex\'>

4、字符串以\'\'或" "括起来的任意文本

5、布尔型（True, False，可以用and, or, not运算，而不是C语言的&&和||）

6、多变量赋值

a = b = c = 1
a, b, c = 1, 2, "john"    #等号两边都是元组，建议加上括号，增加可读性
x,y = y,x     #两值交换，不需要temp,更加简洁

 7、赋值语句不可以返回值，对象是通过引用传递的

y = (x = x + 1)   #这是非法的

（4）运算

1、加、减、乘、除、求余、乘方

2、乘方  ** 右结合

2**3=8 

2**2**3=256

（2**2）**3=64

3、整数运算结果仍然是整数，浮点数运算结果仍然是浮点数。

但是整数和浮点数混合运算的结果就变成浮点数了。

4、字符串与整数相乘

print \'abc\' * 3  结果 abcabcabc

5、因为Python把0、空字符串\'\'和None看成 False，其他数值和非空字符串都看成 True

True and \'a=T\' 计算结果是 \'a=T\'

继续计算 \'a=T\' or \'a=F\' 计算结果还是 \'a=T\'

要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。

①在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

②在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

6、不支持自加(i++)和自减(i--)

7、地板除（//）除法不管操作数何种数值类型，总是舍去小数部分，返回数字序列中比真正的商小的最接近的数字。

print 5//3  #1
print 1.0//2.0  #0.0
print -1/2  #-1

（5）输入

x = input()   #1+2
print type(x)   #<type \'int\'>
y = raw_input()   #1+2
print type(y)    # <type \'str\'>

1、由此可见, input() 在对待纯数字输入返回所输入的数字的类型（int，float）

而raw_input() 将所有输入作为字符串看待，返回字符串类型。 

为了避免类型发生错误，一般情况下使用 raw_input() 来与用户交互。

（6）输出

1、Python2 里面print可以直接接字符串或者运算。

2、Python3 里面print变成了一个函数，上面的写法不支持了，必须用一个括号括起来，否则会报告语法错误。

3、>>>是Python解释器的提示符，不是代码的一部分。

4、print语句也可以跟上多个字符串，用逗号“,”隔开，遇到逗号“,”会输出一个空格：

print \'1+2=\',1+2  #1+2= 3

5、多行输出使用三个引号和使用换行符\\n一致

print \'\'\'哈
哈
哈\'\'\'
print "哈\\n哈\\n哈"
#  输出结果
# 哈
# 哈
# 哈
# 哈
# 哈
# 哈

6、转义

print r\'C:\\log.txt\'
print \'C:\\\\log.txt\'
# C:\\log.txt
# C:\\log.txt

7、print 语句与字符串格式运算符( % )结合使用，可实现字符串替换功能

print "%s is number %d!" % ("Python", 1)

%s表示由一个字符串来替换，%d表示由一个整数来替换，%f表示由一个浮点数来替换。

Python 非常灵活，即使将数字传递给 %s，也不会像其他要求严格的语言一样引发严重后果。

（7）序列

1、序列有两种： list (可变列表) 和tuple（不可变元组）

2、定义:序列是一组有顺序的元素的集合,可以包含一个或多个元素，也可以没有任何元素。

list  =  [0,1,2,3,4,5]    #列表用中括号，可改变，理解为数组
tuple =  (0,1,2,3,4,5)    #元祖用小括号，不可改变

由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型

2、序列的通用操作

seq = "0123456789"
print seq[0] #序列元素的下标从0开始。注意不要越界
print seq[-1] #倒序索引，-1代表倒数第一。
print seq[1:5] #支持切片操作，seq[start:end]，start包含在结果中，end不包含在结果中。
print range(1,101)[0:10]#从第1个数元素开始取，到第11元素结束
print seq[7:] #seq[start:end]中的end可以省略。
print seq[-3:] #分片也支持负数。
print seq[:3] #seq[start:end]中的start也可以省略。
print seq[:] #全部省略会复制整个序列。
print seq[::2] #支持步长。
print seq[::-1] #逆序输出。
print seq[9:1:-1] #支持负步长。
print range(1,101)[2::3]#从第三元素开始取，每隔2个取一个元素，即3的倍数
print range(1,101)[4:50:5]#从第五个取，每隔4个取一个，50以内5的倍数 
print [1, 2, 3] + [4, 5, 6] # 序列支持相加，这解释了为啥字符串可以相加。
print [1, 2, 3] * 3 #序列支持相乘，这解释了为啥字符串可以相称。
print [None] * 10 #生成一个空序列。
print 1 in [1, 2, 3] #成员判断。
print range(1,101)[4::5][-10:] #切片可以嵌套，最后10个5的倍数，先获得5的倍数再取后10个

记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

3、可变的列表(list)

list = [0,1,2,3,4,5]
list.append(7)   #append()总是把新元素添加到list的尾部
print list  # [0, 1, 2, 3, 4, 5, 7]
list.insert(0,-1)  #insert()接受两个参数，第一个是索引，第二个是元素
print list  # [-1, 0, 1, 2, 3, 4, 5, 7]
list.insert(-1,6) #insert(-1)是最后一个元素之前，即倒数第二个元素，因为insert()前插
print list  # [-1, 0, 1, 2, 3, 4, 5, 6, 7]
list.pop()  #pop()方法总是删掉最后一个元素
print list   # [-1, 0, 1, 2, 3, 4, 5, 6]
list.pop(0) #参数为索引
print list  # [0, 1, 2, 3, 4, 5, 6]
list[6]=7 #对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素
print list  # [0, 1, 2, 3, 4, 5, 7]
list[0],list[-1]=list[-1],list[0] #第一与最后位置调换
print list  # [7, 1, 2, 3, 4, 5, 0] 

在使用可变对象的方法如 sort(),extend()和 reverse()的时候要注意,这些操作会在列表

中原地执行操作,也就是说现有的列表内容会被改变,但是没有返回值!

4、不可变的元组（tuple）

字符串是一种特殊的元组

没有 append()方法，也没有insert()和pop()方法，也不能赋值

Tuple 比 list 操作速度快.如果您定义了一个值的常量集,并且唯一要用它做的是不断地遍历它,请使用 tuple 代替 list.如月份，星期。

print (1,) #一个元素的元祖。

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义。

可变的元组：tuple的元素指向list，而list内的值可变

5、序列解包

x, y, z = 1, 2, 3
print x, y, z
(x, y, z) = (1, 2, 3)
print x, y, z
(x, y, z) = [1, 2, 3]
print x, y, z

（8）相等比较

#== 和 is的差别，==比较的是值，is比较的是引用。
x = [1, 2, 3]
y = x
z = [1, 2, 3]
print(x == y) #True
print(x == z) #True
print(x is y) #True
print(x is z) #False

（9）选择

1、Python代码的缩进规则。具有相同缩进的代码被视为代码块

2、缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格

3、格式

if  条件1:
    statement
elif 条件2:
    statement
elif 条件3：
    statement
else:
    statement

  If后面不需要括号，但是条件后面需要冒号

    elif 即 else if

4、三元运算符

x, y = 4, 3
if x < y:
    result = x
else:
    result = y
print result
#等价于
result = x if x < y else y
print result

（10）循环

1、for循环依次把list或tuple的每个元素迭代出来

格式

for 元素 in 序列: 
    statement

name 这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体（就是缩进的代码块）

L = [\'Adam\', \'Lisa\', \'Bart\']
for name in L:
    print name

这样一来，遍历一个list或tuple就非常容易了。

 2、while循环，不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束。

while 条件:
    statement

3、中断循环 break和continue

4、range()的用法

range(1,5) #代表从1到5(不包含5)   [1, 2, 3, 4]

range(1,5,2) #代表从1到5，间隔2(不包含5)   [1, 3]

range(5) #代表从0到5(不包含5)   [0, 1, 2, 3, 4]

5、Python中，迭代永远是取出元素本身，而非元素的索引。

对于有序集合，元素确实是有索引的。使用enumerate() 函数拿到索引

L = [\'Adam\', \'Lisa\', \'Bart\', \'Paul\']
for index, name in enumerate(L):
    print index, \'-\', name
#结果
# 0 - Adam
# 1 - Lisa
# 2 - Bart
# 3 - Paul

使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。但是，这不是 enumerate() 的特殊语法。实际上，enumerate() 函数把：

[\'Adam\', \'Lisa\', \'Bart\', \'Paul\']

变成了类似：

[(0, \'Adam\'), (1, \'Lisa\'), (2, \'Bart\'), (3, \'Paul\')]

因此，迭代的每一个元素实际上是一个tuple：

6、好用的zip()方法

for x, y in zip(range(1, 10), range(1, 10)):
    print(x, y)
# 结果
# (1, 1)
# (2, 2)
# (3, 3)
# (4, 4)
# (5, 5)
# (6, 6)
# (7, 7)
# (8, 8)
# (9, 9)

7、列表生成式，非常简洁

要生成[1x1, 2x2, 3x3, ..., 10x10]

print [x * x for x in range(1, 11)]
#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表生成式的 for 循环后面还可以加上 if 判断。例如：

print  [x * x for x in range(1, 11) if x % 2 == 0]
# [4, 16, 36, 64, 100]

8、迭代器

它为类序列对象提供了一个类序列的接口。

迭代非序列集合(例如映射和文件)时, 可以创建更简洁可读的代码。

myTuple = (123, \'xyz\', 45.67)
i = iter(myTuple)
print i.next()  #123
print i.next()  #xyz
print i.next()  #45.67
i.next()        #报错

（11）字典(dict)

1、字典的元素没有顺序。你不能通过下标引用元素。字典是通过键来引用，用大括号

查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

dict的缺点是占用内存大，还会浪费很多内容

dict是按 key 查找，所以，在一个dict中，key不能重复

作为 key 的元素必须不可变

2、已知两个列表，一个是名字，一个是成绩，要根据名字找到对应的成绩用两个list不方便，如果把名字和分数关联起来，组成类似的查找表，即 Python中的dict

用 dict 表示“名字”-“成绩”的查找表如下：

dic = {\'tom\':11, \'sam\':57,\'lily\':100}
print type(dic)   #<type \'dict\'>

d = {
    \'Adam\': 95,
    \'Lisa\': 85,
    \'Bart\': 59
}
print d   #{\'Lisa\': 85, \'Adam\': 95, \'Bart\': 59}

3、我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。

4、花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

5、由于dict也是集合，len()函数可以计算任意集合的大小：

print len(d)  #运算结果为3

一个 key-value 算一个，因此，dict大小为3。

6、可以简单地使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key：

print d[\'Adam\']   #95

注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。

要避免 KeyError 发生，有两个办法：

一是先判断一下 key 是否存在，用 in 操作符：

二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：

 

print d.get(\'Bart\')  #59
print d.get(\'Paul\')  #None

7、在字典中增添一个新元素的方法：

d = {
    \'Adam\': 95,
    \'Lisa\': 85,
    \'Bart\': 59
}
print d   #{\'Lisa\': 85, \'Adam\': 95, \'Bart\': 59}
d[\'lilei\'] = 99
print d   #{\'lilei\': 99, \'Lisa\': 85, \'Adam\': 95, \'Bart\': 59}

8、循环调用

for key in d:   #或for key in d.keys()
    print d[key]
# 结果
# 99
# 85
# 95
# 59

9、字典的常用方法

print d.keys()          # 返回d所有的键

print d.values()         # 返回d所有的值

print d.items()         # 返回d所有的元素（键值对）

d.clear()            # 清空d，dict变为{}

del d[‘xxx’]                   # 删除 d 的‘xxx’元素

for key, value in d.items():
   print key, \':\', value

10、cmp()比较

（1）先比较字典长度

（2）再比较字典的键

（3）最后比较字典的值

（4）都一样就相等

（12）集合(set)（不常用）

1、dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。

有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。

2、set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

3、创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：

s = set([\'A\', \'B\', \'C\'])
print s  #set([\'A\', \'C\', \'B\'])

4、添加、删除：

s.add(\'D\')
print s  #set([\'A\', \'C\', \'B\', \'D\'])
s.add(\'D\') #已存在不会报错
s.remove(\'D\')
print s  #set([\'A\', \'C\', \'B\'])
s.remove(\'D\')  #报错，需要先判断

 

（13）函数

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

def say_b():
    print "b"
say_b()  #调用函数，打印出b

2、如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。

3、函数返回多个值

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
r = move(100, 100, 60, math.pi / 6)
print r    #(151.96152422706632, 70.0)

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

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

4、在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
print fact(10)  #计算10的阶乘

5、定义函数的时候，还可以有默认参数。

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
print power(2)  #默认计算2的平方
print power(2,3)  #计算2的三次方

由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：

6、一个函数能接受任意个参数，我们就可以定义一个可变参数：

def fn(*args):
    print args
fn(\'a\')   #(\'a\',)
fn(\'a\', \'b\')  #(\'a\', \'b\')
fn(\'a\', 以上是关于Python学习的个人笔记（基础语法）的主要内容，如果未能解决你的问题，请参考以下文章
 
 Swift学习笔记——基础语法
 Python学习笔记
 Python学习笔记
 Python 3学习笔记
 学习笔记：python3，代码片段（2017）
 Java学习笔记总结