1. 1. python2与3区别
    1. 1.1. print语句
    2. 1.2. 一行输入多个数
    3. 1.3.
    4. 1.4. 比较运算符
  2. 2. 基础语法
    1. 2.1. 注释
    2. 2.2. 语句换行
    3. 2.3. 缩进
    4. 2.4. 变量的数据类型
    5. 2.5. 科学计数法
    6. 2.6. 运算符
  3. 3. 常用语句
    1. 3.1. 判断语句
    2. 3.2. 循环语句
    3. 3.3. 其他语句
  4. 4. 数据类型相关函数
    1. 4.1. 转换函数
    2. 4.2. 数据类型
  5. 5. 字符串
    1. 5.1. 什么是字符串
    2. 5.2. 字符串操作
    3. 5.3. 字符串的输入和输出
    4. 5.4. 访问字符串中的值
    5. 5.5. 字符串内建函数
  6. 6. 列表
    1. 6.1. 列表内元素的操作
    2. 6.2. 元素排序
    3. 6.3. 列表遍历
      1. 6.3.1. for遍历:常与range搭配使用
      2. 6.3.2. while遍历,常与len搭配使用
    4. 6.4. 列表解析式
    5. 6.5. 列表切片
  7. 7. 元组
    1. 7.1. 访问元祖
    2. 7.2. 修改元组
    3. 7.3. 遍历元组
  8. 8. 序列
  9. 9. 字典
    1. 9.1. 根据键访问值
    2. 9.2. 修改字典元素
    3. 9.3. 添加字典元素
    4. 9.4. 删除字典元素
    5. 9.5. 计算字典的键值对的个数
    6. 9.6. 字典的遍历
  10. 10. 函数
    1. 10.1. 函数的定义和使用
    2. 10.2. 函数的参数
    3. 10.3. 函数的返回值
    4. 10.4. 变量作用域
    5. 10.5. 匿名函数
    6. 10.6. 时间日期函数
    7. 10.7. 随机函数
  11. 11. 文件
    1. 11.1. 文件打开及读写
    2. 11.2. 文件的定位读写
    3. 11.3. 文件的重命名和删除
    4. 11.4. 文件夹
  12. 12. 异常
    1. 12.1. 异常类
    2. 12.2. 异常处理
    3. 12.3. 抛出异常
    4. 12.4. assert(断言)语句:
    5. 12.5. 预定义清理
  13. 13. 模块
    1. 13.1. 模块的基本使用
    2. 13.2. 模块的制作
  14. 14. 类和对象
    1. 14.1.
    2. 14.2. 对象
    3. 14.3. 封装
    4. 14.4. 继承
    5. 14.5. 多态
    6. 14.6. 类属性和实例属性
  15. 15. 其他知识
    1. 15.1. 内置函数
    2. 15.2. pyinstaller
    3. 15.3. 图像缩放操作

Python基础知识

大一结束,把这学期做的python笔记整到博客上

python2与3区别

print语句

在Python 2里,print是一个语句。无论你想输出什么,只要将它们放在print关键字后边就可以

在Python 3里,print()是一个函数。就像其他的函数一样,print()需要你将想要输出的东西作为参数传给它

notes Python 2 Python 3
1 print print()
2 print 1 print(1)
3 print 1, 2 print(1, 2)
4 print 1, 2, print(1, 2, end=’ ‘)

解释:

  1. 为输出一个空白行,需要调用不带参数的print()。
  2. 为输出一个单独的值,需要将这这个值作为print()的一个参数就可以了。
  3. 为输出使用一个空格分隔的两个值,用两个参数调用print()即可。
  4. 在Python 2里,如果使用一个逗号(,)作为print语句的结尾,它将会用空格分隔输出的结果,然后在输出一个尾随的空格,而不输出回车。在Python 3里,通过把end=’ ‘作为一个关键字参数传给print()可以实现同样的效果。参数end的默认值为’\n’,所以通过重新指定end参数的值,可以取消在末尾输出回车符。

一行输入多个数

python2用raw_input()实现输入;python3使用input()实现输入

用name.split()的方法,将空格隔开的字符串分成单一的部分,再进行转换数据类型

1
2
3
4
5
sum = raw_input('')    
x,y,a = sum.split()
x = float(x)
y = float(y)
a = int(a)

Python2.x 里,整数除整数,只能得出整数。如果要得到小数部分,把其中一个数改成浮点数即可:

1
2
3
4
5
6
7
8
>>> 5/2
2
>>> 5/2.0
2.5
>>> 5//2
2
>>> 5//2.0
2.0

python3:

1
2
3
4
>>> 5/2
2.5
>>> 5//2
2

比较运算符

Python 2支持<>作为!=的同义词。Python 3只支持!=,不再支持<>了。

Python 2 Python 3
if x <> y: if x != y:
if x != y:

基础语法

注释

#进行单行注释;使用三重引号''' '''进行多行注释

语句换行

在末尾加\

缩进

缩进的空格数是可变的,但同一个代码块的语句必须包含相同的缩进空格数。

变量的数据类型

  • 数字类型:包括整型,浮点型,复数类型。
  • 布尔类型:布尔类型是特殊的整型,它的值只有两个,分别是True和False。如果将布尔值进行数值运算,True会被当做整型1,False会被当做整型0。
  • 字符串类型:python中字符串被定义为一个字符集合,它被引号所包含,引号可以是单引号、双引号、或者三引号。字符串具有索引规则,第一个字符的索引是0。
  • 列表和元祖类型
  • 字典类型:映射数据类型

科学计数法

实数E(e)整数。如:1.34E3 表示1.34*10^3

运算符

1.算术运算符

  • *:两数相乘或返回一个被重复若干次的字符串
  • / : 除
  • // : 整除
  • **: 次幂
  • 求绝对值:abs(), fabs();(abs()是一个内置函数,而fabs()在math模块中定义的)

2.赋值运算符

  • a,b = b,a 两数值交换
  • 不支持自增自减操作符
  • += 加赋值运算,除此还有-=*=/=%=**=//=

3.比较运算符

  • == 相等
  • != 不相等
  • ><>=<=

4.逻辑运算符

  • and 布尔“与”
  • or 布尔“或”
  • not 布尔“非”

5.成员运算符

  • in :如果在指定的序列中找到值返回True,否则返回False
  • not in :如果在指定的序列中没找到值返回True,否则返回False

6.位运算符

  • <<:按位左移:二进制位全部左移n位,高位丢弃,低位补0
  • >>:按位右移:二进制位全部右移n位,移出的位丢弃,移进的位补0
  • &:按位与:两个数的二进制按位运算,都为1时结果为1,否则为0
  • |:按位或:两个数的二进制按位运算,有一个为1时结果为1,都为0时结果才为0
  • ^:按位异或:两个数的二进制按位运算,相同时结果为0,否则为1
  • ~: 按位取反:将二进制的每一位取反,0转换成1,1转换成0

常用语句

判断语句

  1. if语句

    if 判断语句 :

    执行1

    elif 判断语句:

    执行2

    else :

    执行n
  1. if-elif语句

    if 判断条件1:

    doing

    elif 判断条件2:

    doing

注意:
当满足判断条件1时,执行满足条件1时要做的事情,然后整个if结束。

elif必须和if一起使用,否则程序会出错。

循环语句

1.while循环

while 判断式 :
    表达式

2.for循环

for 变量 in 序列:
    循环语句

判断语句和循环语句需注意:
(1)每个条件后要使用冒号: ,表示接下来是满足条件后要执行的语句。

(2)使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块。

其他语句

1.break

结束整个循环(当前循环体)

2.continue

结束本次循环,紧接着执行下一次的循环

注意:

(1) break/continue 只能用在循环中,除此以外不能单独使用
(2)break/continue 在嵌套循环中,只对最近的一层循环起作用

3.pass

空语句,保持程序结构的完整性

4.else

python中的while和for循环中也可以使用else语句,在循环中使用时,else语句只在循环完成后执行

数据类型相关函数

转换函数

ord() 返回字符的ASCII编码   
chr() 返回指定编码的字符   
bin() 十进制数转换成二进制数   
oct() 十进制数转换成八进制数   
hex() 十进制数转换成十六进制数   
int() 转换成整数   
float() 转换成浮点数    
str() 转换成字符串   
complex() 创建复数   

数据类型

  1. 获取数据类型

    type()

  2. 比较数据类型是否一致

    isinstance(a,b)

字符串

什么是字符串

字符串是一种表示文本的数据类型,字符串中的字符可以是ASCLL字符、各种符号以及各种Unicode字符。

表现方式:

使用单引号包含字符,注意:单引号表示的字符串里不能包含单引号   
使用双引号包含字符,注意:双引号表示的字符串里不能包含双引号,并且只能有一行   
使用三引号包含字符,注意:三个引号能包含多行字符串,并常常用来注释

注意:
与c语言不同的是,python字符串不能被改变,例如,word[0]=’m’会导致错误

转义字符

1. 三种引号混合使用   
2. 反斜杠转义其后的特殊字符   
3. 在字符串前添加r,表示原始字符串 

字符串操作

字符串可以与数字n相乘,得到n个重复字符串:

1
2
>>> print('*'*10)
**********

字符串之间可以相加进行拼接,但不可以相减:

1
2
>>> print('i'+'love'+'you')
iloveyou

字符串的输入和输出

字符串输入

a = input('') 

input 函数接收的输入会直接赋值给等号左边的变量a。input 函数获取的数据,即使是数字,也是以字符串的方式进行保存的。则进行整数输入:a = int(input(‘’))

字符串输出

print('')

格式化符号

%s 通过str()字符串转换来格式化
%d 十进制正数   
%f 浮点实数 

name = 'xiaoming'
print('我叫%s'%name)

输出不换行

print('hello', end='')     

访问字符串中的值

字符串的储存方式:

python不支持单字符类型,单字符在python也是作为一个字符串使用。每个字符都对应着一个编号,并且编号是从0开始的,如果要从字符串中取出字符,可以通过下标获取,例如,a = ‘abcde’,取出c:print(a[2])

使用切片截取字符串:

name = 'abcdef'
print(name[0:3])  #取下标为0~2的字符, 即print(name[:3]) 
print(name[3:5])  #取下标为3~4的字符,即   
print(name[3:]) 

注意:从0开始或末尾结束,可省略不写

print(name[1:-1])  #取下标为1开始到倒数第2个字符之间的字符   
print(name[:-1])  #取倒数第一位字符   
print(name[::-1])  #字符串逆序    

字符串内建函数

find :检测字符串中是否包含子字符串,如果包含子字符串则返回开始的索引值,否则返回-1(可选开始与结束位置)

str = 'hello it is it'       
>>> print(str.find('it'))   
6

rfind:检测字符串中是否包含子字符串,如果包含子字符串则返回最后的索引值,否则返回-1(可选开始与结束位置)

str = 'hello it is it'       
>>> print(str.rfind('it'))  
12

index :检测字符串中是否包含子字符串,如果包含子字符串则返回开始的索引值,否则抛出异常 (可选开始与结束位置)

str = 'hello it is it'       
>>> print(str.index('he'))  
ValueError

count : 统计字符串里某字符出现的次数 (可选开始与结束位置)

str = 'hello it is it'       
>>> print(str.count('it'))   
2

replace :旧字符串替换成新字符串,如果指定第三个参数,则替换次数不会超过这个参数指定的次数.
替换后原字符串并未发生改变

str = 'hello it is it'       
>>> print(str.replace('it','he',1)) 
hello he is it

split :通过指定分隔符对字符串进行切片,分隔符默认为所有空字符;若有指定值,则分割相应的次数.
分割后原字符串并未发生改变(返回列表)

str = 'hello it is it'
>>> print(str.split())
['hello', 'it', 'is', 'it']
>>> print(str.split('i'))
['hello ', 't ', 's ', 't']
>>> print(str.split('i',1))
['hello ', 't is it']

capitalize :将字符串第一个字母变成大写,其他字母变小写
改变后原字符串并未发生改变

str = 'hello it is it'
>>> print(str.capitalize())
Hello it is it

title :所有单词均以大写开始,其余字母均为小写

str = 'hello it is it'
>>> print(str.title())
Hello It Is It

startswith :检查字符串是否以指定字符串开头(可选开始与结束位置)

str = 'hello it is it'
>>> print(str.startswith('he'))
True

endswith :检查字符串是否以指定字符串结尾
(可选开始与结束位置)

str = 'hello it is it'
>>> print(str.endswith('it'))
True

upper :将小写字母转化为大写字母

str = 'hello it is it'
>>> print(str.upper())
HELLO IT IS IT

ljust : 原字符串左对齐,并使用空格填充至指定长度;如果指定的长度小于原字符串的长度,则返回原字符串

str = 'hello it is me'
>>> print(str.ljust(30,'*'))
hello it is me****************

rjust : 原字符串右对齐,并使用空格填充至指定长度;如果指定的长度小于原字符串的长度,则返回原字符串

str = 'hello it is me'
>>> print(str.rjust(30,'*'))
****************hello it is me

列表

列表是python中的一种数据结构,它可以储存不同类型的数据

列表内元素的操作

1、添加

append( )  # 在列表的末尾新增元素
extend( )  # 将一个列表中的元素全部添加到另一个列表
insert(index,object)   # 在列表的指定位置添加元素   

2、查找

in  存在   
not in 不存在

a = ['hi','hello']
>>> 'hi'in a
True

3、修改
通过修改下标来修改列表中的元素

>>> a[0] = 'haha'
>>> a
['haha', 'hello']

4、 删除

del name[index] 根据下标进行删除
pop()删除最后一个元素
remove()根据元素的值进行删除   

5 、删除列表

del name

6、重复操作符‘*’

>>> a = [0]
>>> s2 = a*19
>>> s2
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

元素排序

排序默认为:数字从小到大,字母按首位顺序

  1. 反序:reverse()

    a = [1,2,3]
    a.reverse()
    a
    [3, 2, 1]
    
    # or
    for i in reversed(range(1,4)):
          print(i,end='')
    # 321
  1. sort()对列表永久排序

    a = [2,4,1,3]
    a.sort()
    a
    [1, 2, 3, 4]
  1. sorted()对列表临时排序

    a = [2,4,1,3]   
    print(sorted(a))   
    [1, 2, 3, 4]   
    a   
    [2, 4, 1, 3]   

列表遍历

for与while遍历

for遍历:常与range搭配使用

range()特点:左闭右开,可以生成一个数字序列

for循环然后遍历这个范围,for i in range(1,5)相当于 for i in [1, 2, 3, 4],这就像把序列中的每一个数(或对象)分配给i,一次一个,然后为每个i值执行该语句块。

提供两个数字,range返回一个从第一个数字到第二个数字的一个数字序列。例如,range(1,5)给出序列[1, 2, 3, 4]。默认情况下,range 步距取为1。如果我们提供第三个数字,range那么它变成了步距。例如range(1,5,2)得到[1,3]。请记住,范围扩展到第二号码,即它不包括第二个数字。

注意

range()生成一个数字序列,当for循环请求下一个项目时,它一次只生成一个数字。如果你想立刻看到完整的数字序列,使用list(range())。

>>> for each in range(1,10):
    print(each,end = '')

123456789
while遍历,常与len搭配使用

len(列表名):获取列表的长度

2.利用zip函数,同时遍历多个列表

a = ['n1','n2','n3','n4']
for m,n in zip(range(1,5),a):
    print(m,':',n)

1 : n1
2 : n2
3 : n3
4 : n4

列表解析式

  1. 用append方法向列表添加元素

    a = []
    for i in range(11):
        a.append(i)
    print(a)
    
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  2. 列表解析式(在执行效率上远远超过append)

    a = [i for i in range(11)]
    print(a)
    
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = [i**3 for i in range(11)]
print(a)

[0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]


a = [i for i in range(11) if i%2 == 0]
print(a)
[0, 2, 4, 6, 8, 10]

列表切片

切片并不改变原列表,相当于拷贝后的操作   
左闭右开
  1. 从0开始或末尾结束,可省略不写

    a = [1,2,3,4]
    print(a[:2])
    print(a[1:])
    
    [1, 2]
    [2, 3, 4]
  1. 拷贝

    a = [1,2,3,4]
    b = a[:]
    print(b)
    
    [1, 2, 3, 4]
  2. 实现字符串的逆序

    a = [1,2,3,4]
    b = a[::-1]
    print(b)
    
    [4, 3, 2, 1]
  3. 取字符串末位

    a = [1,2,3,4]
    b = a[-1]
    print(b)
    
    4

元组

元组与列表类似,不同之处在于,元组的元素不能修改,元组使用圆括号包含元素,而列表使用方括号包含元素

访问元祖

可以使用下表索引来访问元祖中的值

修改元组

1.元组中的元素值是不允许修改的,但我们可以对元组进行连接组合

a = (1,2)
b = (3,4)
print(a+b)

(1, 2, 3, 4)


2.python不允许修改元组的数据,包括不能删除其中的元素

3.带括号的不一定是元组,不带括号的不一定不是元组

>>> a = (1)
>>> print(type(a))
<class 'int'>
>>> b = 1,2,3
>>> print(type(b))
<class 'tuple'>

逗号才是关键!

可以这样创建一个空元祖

a = ()

怎样创建一个只有一个元素的元组呢?

a = (1,)
a = 1,

4.通过拼接的方法修改元组里的值(实际上是创建一个新的元组)

 >>> a = ('1','2','3')
>>> a = ('6',) + a[1:] #注意要加括号和逗号!
>>> a
('6', '2', '3')

遍历元组

while
for   

序列

列表、字符串、元组的共同点

1.都可以通过索引得到每一个元素
2.默认索引值都是从0开始
3.可以通过分片的方法得到一个范围内的元素的集合
4.有很多共同的操作符

方法

len() : 计算元素个数
max() : 返回最大值(数字返回最大值,字母返回其对应ascll值最大值所对应的字母)
min() : 返回最小值
#max和min中元素的类型要为同一种类型
tuple() : 转为元祖
list() : 转为列表   
sum() : 返回数据类型序列的和

字典

定义:字典的每个元素都是由两部分组成的,分别是键和值。
例,a = {'name':'boy','score':'80'}  
其中,'name'为键,'boy'为值。键必须是唯一的,但值可以是任何类型的   

根据键访问值

info = {'name':'xiaoming'}   
print(info['name'])      # xiaoming

如果不确定字典中是否存在某个值而又想获取其值时,可以使用get,如果访问的键不在字典中,会返回默认值

info = {'name':'xiaoming'}  

print(info.get('age'))    # None   
print(info.get('age',18)) # 18

修改字典元素

如果要添加的键已经存在,那么字典中该键对应的值会被新值替代

info{'id' : 16}   
info['id'] = 2   
print(info['id'])    # 2

添加字典元素

使用变量名[‘键’] = ’数据‘ 时,如果字典不存在这个键,则会在字典中新增一个元素

info{'id' : 16}    
info['name']  = 'xiaoming'   
print(info)    

删除字典元素

del 删除字典

del  name   

clear 清空字典元素

name.clear()

计算字典的键值对的个数

print( len(name) )   

字典的遍历

1.遍历字典的键

获取字典的键视图

name.keys() #可用此方法遍历键

dict = {'name':'xiaoming','age':12}    
for key in dict.keys():   
    print(key)   

2.遍历字典的值

获取字典的值视图

name.values() #可用此方法遍历值

dict = {'name':'xiaoming','age':12}    
for values in dict.values():   
    print(key)   

3.遍历字典中的元素

-获取字典的元素视图

name.items() #可用此方法遍历元素

dict = {'name':'xiaoming','age':12}    
for key,values in dict.items():   
    print(key)   

函数

函数的定义和使用

1.定义函数

def 函数名(参数列表):   
    "函数_文档字符串"   
    函数体   
return 表达式

函数内容以冒号起始,并且缩进
return表达式结束函数

2.调用函数
定义完函数后,函数是不会自动执行的,需要调用它

def hanshu()
    print('hi')
hanshu()  # 调用

函数的参数

1.函数参数的传递
可以在定义函数的时候添加参数,让参数来接收传递给函数的值

def add(num1,num2)   
    print(num1 + num2)
add(1,3)   # 打印出4

在调用函数的时候,传递的数据要和定义的参数一一对应

2.默认参数
定义函数时,可以给函数的参数设置默认值,这个参数就被称为默认参数。调用函数时,默认参数可直接忽略,而其它参数是必须要传入值的。如果默认参数没有传入值,则直接使用默认的值;如果默认参数传入了值,则使用传入的新值替代。

def hanshu(name,age = 35)
    print(name)
    print(age)
hanshu('xiaoming')     #xiaoming 35
hanshu('xiaoming',15)  #xiaoming 15

带有默认值的参数一定要位于参数列表的最后面

3.不定长参数
args参数没有接受到数据,为一个空元祖

def test(a,b,*args):
    print(a)
    print(b)
    print(args)
test(1,2)  #1  2  ()












def test(a,b,*args):
    print(a)
    print(b)
    print(args)
test(1,2,3,4,5)  # 1,2,(3,4,5)

如果传入的参数没有名字,那么传入的值会给args变量;如果传入的参数有名字,那么传入的值会给kwargs变量

def test(a,b,*args,**kwargs):
    print(a)
    print(b)
    print(*args)
    print(**kwargs)
test(1,2,3,4,5)  # 1,2,(3,4,5) {}
test(1,2,3,m=4,n=5) # 1,2,(3) {'m':4,'n':5}

函数的返回值

程序中的函数完成一件事后,最后给调用者的结果。

根据函数的参数和返回值,函数可分为四种类型:
1.函数无参数,无返回值

def hanshu():
    print('hi')
hanshu()

2.函数无参数,有返回值

def hanshu():
    return 30
temperature = hanshu()
print(temperature)

3.函数有参数,无返回值

def hanshu(num1,num2):
    result = num1 + num2
    print(result)
hanshu(1,2)   

4.函数有参数,有返回值

def hanshu(num):
    if num == 1:
        result = 1
    else:
        result = hanshu(num - 1) * num
    return result
print('5!=',hanshu(5))

变量作用域

1.全局变量和局部变量
局部变量,指的是定义在函数内的变量,即定义在def函数内的变量名,只能在def函数内使用,它与函数外具有相同名称的其它变量没有任何关系

def hanshu():
    num = 1
    print(num)
def hanshu1():
    num = 2
    print(num)
hanshu()
hanshu1()

1
2

全局变量是定义在函数外的变量,它拥有全局作用域

num = 5
def hanshu():
    num = 1
    print(num)
hanshu()
print(num)

1
5

2.global和nonlocal关键字
global关键字用来在函数或其他局部作用域中使用全局变量(修改全局变量)

num = 5
def hanshu():
    global num
    num += 1
    print(num)
hanshu()
print(num)

6
6

nonlocal关键字可以在一个嵌套的函数中修改嵌套作用域中的变量

#不加 nonlocal
def hanshu():
    num = 1
    def hh():
        num = 2
    hh()
    print(num)
hanshu()

1

#加 nonlocal
def hanshu():
    num = 1
    def hh():
        nonlocal num
        num = 2
    hh()
    print(num)
hanshu()

2

使用global关键字修饰的变量之前可以不存在,而使用nonlocal关键字修饰的变量在嵌套作用域中必须已经存在

匿名函数

匿名函数是没有名称的函数,不再使用def定义,能接收任何数量的参数,但只能返回一个表达式的值

sum = lambda a,b:a+b
print(sum(1,2))

3


# 声明的函数支持所有运算
def hanshu(a,b,opt):
    print(opt(a,b))
hanshu(11,22,lambda x,y:x+y)
hanshu(11,22,lambda x,y:x-y)

33
-11

匿名函数与一般函数的区别、优缺点

def创建的函数是有名称的,  而lambda没有函数名称,这是最明显的区别之一    
lambda 返回的结果通常是一个对象或者一个表达式,它不会将结果赋给一个变量,def则可以   
lambda只是一个表达式,函数体比def简单很多,而def是一个语句   
lambda表达式的冒号后面只能有一个表达式,def则可以有多个   
像if或for等语句不能用于lambda中,def则可以   
lambda一般用来定义简单的函数,而def可以定义复杂的函数    
lambda函数不能共享给别的程序调用,def可以   

时间日期函数

1.时间函数

time模块

# 推迟调用线程的运行,括号内为秒数
import time
time.sleep(1)

print(time.ctime())
#Thu Jan 31 14:44:49 2019

datatime

# 获取时间
import datetime
nowTime=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')#现在
pastTime = (datetime.datetime.now()-datetime.timedelta(hours=1)).strftime('%Y-%m-%d %H:%M:%S')#过去一小时时间
afterTomorrowTime = (datetime.datetime.now()+datetime.timedelta(days=2)).strftime('%Y-%m-%d %H:%M:%S')#后天
tomorrowTime = (datetime.datetime.now()+datetime.timedelta(days=1)).strftime('%Y-%m-%d %H:%M:%S')#明天
print('\n',nowTime,'\n',pastTime,'\n',afterTomorrowTime,'\n',tomorrowTime)

2.日历函数
import calendar

import calendar
data = calendar.month(2018,6)
print(data)

June 2018
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30

随机函数

import random
random.random():用于生成一个0~1之间的随机浮点数
random.uniform(a,b):返回a与b之间的随机浮点数,a,b大小可随机.返回范围范围左闭右闭
random.randint(a,b):返回a与b之间的随机整数,a的值一定要小于b的值.返回范围左闭右闭
random.randrang(a,b,step):返回某个区间内的整数,可以设置step.只能传入整数
random.choice(sequence):从列表、元组或字符串中返回一个随机的元素
random.shuffle():将列表中的元素打乱顺序
random.sample(sequence,k):从指定序列中随机获取k个元素作为一个片段返回,不会改变原有序列

文件

文件打开及读写

1.文件打开

f = open(‘文件名’,‘访问模式’)   

2.访问模式

r :只读    
w :只写 如已存在则覆盖,不存在则重新创建    
a :只写 追加内容    
w+ :打开后,清空原有内容,成为一个新的空文件,对这个空文件具有读写权限     
r+ :打开后,保存原有内容,可以读取文件内容,追加写内容

3.关闭文件
在每次使用完文件后,都要使用close关闭文件

f.close()    

4.写入数据
用write方法写入数据

f.write(' ') 

5.读取文件
read

b = f.read()    #可加入数字表示读取数据的长度   
print(b)

redlines

#返回一个列表,可循环打印出每行的数据     
a = open('gtf.txt','r')
b = a.readlines()
for i in b:
        print(i)

readline

#一行一行读取数据
a = open('gtf.txt','r')
b = a.readline()
print(b)

6.修改数据
可以先读取文件内容,然后修改后重新写入该文件

文件的定位读写

1.使用tell方法来获取文件当前的读写位置,返回文件的当前位置,即文件指针当前位置

'gtf.txt' :hello it is me


​ a = open(‘gtf.txt’,’r’)
​ b = a.read(5)
​ print(b)
​ position = a.tell()
​ print(position)
​ c = a.read(3)
​ print(c)
​ position1 = a.tell()
​ print(position1)

​ hello
​ 5
​ it
​ 8

2.用seek定位到文件的指定读写位置

seek(a,b)     

a:表示偏移量,即需要移动的字节数     
b:
 0:从文件的起始位置开始偏移      
 1:从文件的当前位置开始偏移     
 2:从文件末尾开始偏移     

文件的重命名和删除

import os  

1.重命名

os.rename(oldname,newname)

描述路径时,原文件和新文件都应描述清楚,否则文件可能丢失
2.删除

os.remove(name)

文件夹

import os  

1.创建

os.mkdir(name)

2.删除

os.rmdir(name)

3.获取当前目录

os.getcwd()

4.改变默认目录

os.chdir('..\')    将目录改变为上一级的目录

5.获取目录列表

os.listdir('./')

异常

异常类

NameError
尝试访问一个未声明的变量,会引发NameError

ZeroDivisionError
当除数为零的时候,会引发ZeroDivisionError

SyntaxError
当解释器发现语法错误时,会引发SyntaxError错误
SyntaxError异常是唯一不在运行时发生的异常

IndexError
当使用序列中不存在的索引时,会引发IndexError异常

KeyError
当时用映射中不存在的键时,会引发KeyError异常

FileNotFoundError
试图打开不存在的文件时,会引发FileNotFoundError异常

AttributeError
当尝试访问未知的对象属性时,会引发AttributeError异常

异常处理

1.捕获简单异常

try:
    ......
except nameError:
......

只要监控到错误,程序就会执行except里面的语句,并且不再执行try里面未执行的语句
2.捕获多个异常

try:
    ......
except nameError1:
    ......
except nameError2:
    ......
......

要使一个except子句捕获多个异常,可以使用元组来表示

except (nameError1,nameError2): 

3.捕获异常的描述信息
使用一个except子句捕获多个异常时,为了区分不同的错误信息,可以使用as获取系统反馈的错误信息

try:
    ......
except (nameError1,nameError2) as result:
    print(result)
# 捕获到异常中的任意一个时,就会把描述信息保存到result变量中

4.捕获所有的异常

try:
    ......
except:
    ......
# 捕获所有的异常


try:
    ......
except Exception as result:
    print(result)
# 捕获所有的异常以及描述信息

5.异常处理的完整语句

try:
...
except NameError:
...
except:
...
else: #若果无异常,则执行
...
finally: # 无论是否异常,总会执行(通常情况下,用于释放资源)
...

抛出异常

1.使用类名引发异常

raise 异常的类名    

2.使用异常类的实例引发异常

a = Indexerror()    
raise a     

3.传递异常

不带任何参数的raise语句,可以再次引发刚刚发生过的异常

4.指定异常的描述信息

raise IndexError('下标超出范围')

5在异常中抛出另外一个异常

try:
    num
excpt Exception as except:
    raise IndexError('下标超出范围') from exception
# 会产生NameError和IndexError

assert(断言)语句:

1.当用户定义的约束条件不满足的时候,会触发AssertionError异常
格式:assert 逻辑表达式,data
逻辑表达式相当于条件,data通常是一个字符串,当表达式false时,作为异常类型的描述信息使用
逻辑上等于

if not 逻辑表达式:    
    raise AssertionError(data)     

预定义清理

使用with语句,无论资源在使用过程中是否发生异常,都会执行释放资源的操作

with 上下文表达式[as 资源对象]:   
    对象的操作


with open('gtf.txt') as file:
    data = file.read()

# 如果能顺利打开文件,则将文件对象赋值给file,然后调用read方法读取了file对象的数据;当对象操作结束后,with语句会关闭文件,即使这段代码在运行过程中产生了异常,with语句也会关闭文件

模块

模块的基本使用

1.引入模块

import ...

调用模块中的函数时,必须:模块名.函数名
2.只引入函数

from 模块名 import 函数名1,2...   

调用函数时,只能给出函数名
3.引入模块的所有函数

from 模块名 import *

模块的制作

1.制作函数

test.py:

def sum(a,b):
    print(a+b)

则在主程序中可以引入这个函数

from test import sum   
sum(1,3)

import test   
test.sum(1,3)

但test.py中可能有测试代码,为了不使主程序运行测试代码,可在测试代码前加上

if __name__ == '__main__':

每个模块都有一个name属性,当其值为’main‘时,表明该模块自身在运行,否则是被引用

2.制作类
lei.py:

class first():
    def move(self):
        print('biu')

在主程序可以引入这个类

from lei import first    
duixiang = first()  #创建对象   

import lei   
duixiang = lei.first() #创建对象

类和对象

类是有一些系列有共同特征和行为事物的抽象概念的总和

类名:首字母必须大写
属性:描述特征
方法:描述行为

类的定义

class 类名:
#属性
#方法
    def move(self):
        print(‘move’)
#方法必须显示地声明一个self函数,第一个参数永远都是self,表示的是对象自身

对象

1.根据类创建对象

创建对象
对象名 = 类名()   

添加属性
对象名.属性名 = 值

调用方法   
对象名.方法函数名()

2.构造方法
在创建对象的时候设置好属性,当创建类实例的时候,系统会自动调用构造方法,从而实现对类进行初始化的操作

def __init__(self):   
    self.other = 值
#在init中返回 None

带参构造

def __init__(self,other):
    self.others = other

3.析构方法
当删除一个对象来释放类所占用资源的时候,python解释器默认会调用另外一个方法:del 方法

使用del语句可以删除一个对象,释放它所占用的空间

>>> class lei:
        def __init__(self):
            print('我是init方法,我被调用了')
        def __del__(self):
            print('我是del方法,我被调用了')


​ >>> a1 = lei()
​ 我是init方法,我被调用了
​ >>> a2 = a1 #增加标签
​ >>> del a1
​ >>> del a2 #完全删除才会调用
​ 我是del方法,我被调用了

python有自动回收垃圾的机制,当python程序结束的时候,python解释器会检测当前是否有需要释放的内存空间,如果有就自动调用del语句删掉,如果已经手动调用了del语句,就不再自动删除

封装

通常把隐藏属性、方法与方法实现细节的过程称为封装。为了保护类里面的属性,避免外界随意赋值,可采用如下方式解决:

把属性定义为私有属性,即在属性名的前面加上两个下划线
添加可以供外界调用的两个方法,分别用于设置或者获取属性值

下列代码中,将age设为了私有属性,类的外面无法知道类里面的私有属性,更无法访问类的私有属性

>>> class lei:
        def __init__(self,name,age):
            self.name = name
            self.__age = age


​ >>> a1 = lei(‘xiaoming’,12)
​ >>> a1.name
​ ‘xiaoming’
​ >>> a1.age
​ Traceback (most recent call last):
​ File “<pyshell#16>”, line 1, in
​ a1.
age
​ AttributeError: ‘lei’ object has no attribute ‘__age’

添加可以供外界调用的两个方法,分别设置和获取私有属性__age的值:

>>> class lei:
        def __init__(self,name,age):
            self.name = name
            self.__age = age
        def set(self,newage):
            if newage > 0 and newage < 100:
                self.__age = newage
        def get(self):
            return self.__age


​ >>> a = lei(‘xiaoming’,12)
​ >>> a.name
​ ‘xiaoming’
​ >>> a.set(13)
​ >>> a.get()
​ 13

继承

类的继承是指在一个现有类的基础上构建一个新的类,构建出来的新类被称作子类,现有类被称作父类,子类会自动拥有父类的属性和方法
1.单继承
格式如下:

class 子类名(父类名):

假设有两个类A、B,B类是A类的子类

class A(object):
class B(A):

如果在类的定义中没有标注出父类,这个类默认是继承自object的:class lei 与 class lei(object)是等价的

父类的私有属性和私有方法是不会被子类继承的,更不能被子类访问

如果子类没有初始化,则默认同父类初始化相同

>>> class lei(object):
        def __init__(self,color):
            self.color = color
        def print(self):
            print('我在父类里面创建')

>>> class zilei(lei):
        pass

>>> a = zilei('black')

>>> a.color
'black'

>>> a.print()
我在父类里面创建

2.多继承
多继承就是子类拥有多个父类,并且具有他们共同的特征
格式如下:

class 子类(父类1,父类2...)

如果子类继承的多个父类间是平行关系,子类先继承哪个类就会调用哪个类的方法

>>> class fish:
        def move(self):
            print('im fish')


​ >>> class bird:
​ def move(self):
​ print(‘im bird’)


​ >>> class sum(fish,bird):
​ pass

​ >>> a = sum()
​ >>> a.move()
​ im fish

3.重写父类方法与调用父类方法

在子类中重写的方法要和父类被重写的方法具有相同的方法名和参数列表

>>> class foreigner:
        def say(self):
            print('hello')


​ >>> class chinese(foreigner):
​ def say(self):
​ print(‘你好’)


​ >>> one = chinese()
​ >>> one.say()
​ 你好

4.子类和父类都定义了初始化函数,则父类的属性不会被初始化

class parent(object):

    def __init__(self, name):
        self.name = name


​ class child(parent):

​ def init(self):
​ print(‘Im a child’)

a = child()
#a = child('xiaoming')会报错

5.可以使用super方法调用父类,子类和父类的属性均可被初始化

class parent(object):

    def __init__(self, name):
        self.name = name


​ class child(parent):

​ def init(self):
​ print(‘Im a child’)
​ super(child,self).init(“xiaoming”)


​ a = child()
​ print(a.name)

运行结果为:

Im a child
xiaoming

参考:

https://blog.csdn.net/brucewong0516/article/details/79121179

多态

调用同一个方法,出现多种表现形式。不关注对象的类型,而是关注对象具有的行为

>>> class dog:
        def shout(self):
            print('旺旺!')

>>> class cat:
        def shout(self):
            print('喵喵!')

>>> def hanshu(obj):
        obj.shout()

>>> dog = dog()
>>> cat = cat()

>>> hanshu(dog)
旺旺!
>>> hanshu(cat)
喵喵!

类属性和实例属性

1.实例属性:通过 ‘实例.属性’ 的方式添加属性和访问属性值

class cat:
    def __init__(self):
        self.age = 12 #实例属性

2.类属性:类拥有的属性,位于类内部,方法外面,它被所有类的实例对象所共有,在内存中只存在一个副本

class cat:
    num = 0 #类属性

类属性可以通过类或者类的实例访问到

>>> class cat:
    num = 0
    def __init__(self):
        self.age = 11


​ >>> a = cat()
​ >>> a.num
​ 0
​ >>> cat.num
​ 0

当类属性和实例属性的名字相同时,通过对象访问属性时会获取实例属性对应的值,通过类获取到的一定是类属性的值

>>> class cat:
    num = 0
    def __init__(self):
        self.num = 11

>>> a = cat()
>>> a.num
11
>>> cat.num
0

其他知识

内置函数

eval() : 将字符串str当成有效的表达式来求值并返回计算结果

round() : 返回浮点数的四舍五入值

id() : 返回对象的内存地址

pyinstaller

pyinstaller -F -w -i C:\\a.ico C:\\main.py

-i : 设置图标;先图标路径,再程序路径

图像缩放操作

from PIL import Image

# 打开一个jpg图像文件,注意是当前路径:
im = Image.open('test.jpg')
# 获得图像尺寸:
w, h = im.size
print('Original image size: %sx%s' % (w, h))
# 缩放到50%:
im.thumbnail((w//2, h//2))
print('Resize image to: %sx%s' % (w//2, h//2))
# 把缩放后的图像用jpeg格式保存:
im.save('thumbnail.jpg', 'jpeg')