编程≈乐高

[toc]

python3默认使用UTF-8编码，无需指定UTF-8编码

模块

  • 代码文件的结构 Python的文件结构可以分为代码、模块、包。

  • 模块中内置如__name__等属性，到模块被导入到其他模块中时，__name__的值为模块本身名字；模块独立运行时，该值会变成__main__ 。（理解为main函数）

  • python文件有两种使用方式，作为脚本直接执行、import到其他python脚本中被调用。

  • if __name__ == '__main__': 之后的代码只有在第一种情况下才能运行。

模块导入方式

  • import a as b：将模块a导入并重命名为b
  • from a import func：从模块a中导入func函数
  • from import *：将模块中所有的名字导入到当前模块，容易造成命名冲突
  • a = __import__("3-2 a"): 处理模块名称含有空格的问题

变量

通过var1, var2, var3 = value1, value2, value3同时为多条语句赋值

1
a,b,c = 1,2,"john"

变量类型

**dir( )**可查看相关函数

​ 数值numbers、字符串string、列表list、元组tuple、集合sets、字典dictionaries

  • 数值类型

    包括int float bool complex（复数）等类型

    复数类型2+5j 或complex(2,5)表示数学上的复数2+5i

  • 字符串类型

    字符串：由数字、字母、下划线组成的一串字符

    有两种取值顺序：从左到右索引，从0开始；从右向左索引，从-1开始；

    image-20200101194418828

    截取字符串：使用[头下标：尾下标]来截取字符串，包含头下标，不包含尾下标

    1
    2
    3
    s = 'abcdef'
    s[1:5]  #表示'bcde'
    s[2]='C'	#错误，字符串的元素不能改变

    字符串常用函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    str(123)   #将123转化为字符串
    str=str1+str2 #字符串拼接


    Count(sub[,start[,end]])    #表示sub在字符串里出现的次数，start和end表示出现次数
    Endswith(sub[,start[,end]]) #检查字符串是否以sub为结束，start end可选范围；返回bool类型
    Find(sub[,start[,end]])     #监测sub是否包括在字符串中，如果包括返回索引值，否则返回-1
    Index(sub[,start[,end]])    #跟find一样，但是如果sub不在字符串中会产生一个异常
    Replace(old,new[,count])    #将字符串中的old字符串替换成new字符串，如果count指定，则替换不超过coutn次数
    split(sep=None,maxsplit=-1) #不带参数默认是以空格为分隔符切片字符串，如果maxsplit参数有设置，则仅分割maxsplit个字符串，返回切片后的子字符串拼接的结果
    Captialize()    #将字符串第一个字符改为大写
    Lower()        	#转换字符串中所有大写字符为小写
    Partition(sub)  #找到子字符串sub，将字符串分成一个3元组（pre_sub,sub,fol_sub)，如果字符串不包括sub则返回（‘原字符串’,’’,’’)

    更多字符串函数

  • 列表类型（list）

    实际上以栈的形式存储

    列表用[ ]标识，可以存放不同的数据类型，支持字符、数字、字符串、列表（嵌套）

    1
    list = ['run',386,70.2]

    列表添加元素 append（‘ name’），entend（ [list] ），insert( i, ‘name’ )

    列表删除元素 remove（‘name’），pop（），pop（i），del

    列表切片：使用[头下标：尾下标]来截取字符串，包含头下标，不包含尾下标

    列表比较：比较大小关系与String相同（> = < …）in not in

    其他函数：sort( ) reverse( ) count( )

    分片拷贝为深拷贝，赋值为浅拷贝

    1
    2
    3
    list = [1,2,3]
    list1 = list[:]   #深拷贝，创建对象，原对象的所有内容都会在新对象中创建一次
    list2 = list	  #浅拷贝，创建对象，其内容是原对象中元素的引用

  • 元组（tuple）

    元组用( )标识，不能二次赋值，相当于只读列表

    1
    2
    tuple = ('run',386,70.2)
    tuple[1] = 400  #错误，元组不能更新

    创建单个元素的元组，需要加逗号

    1
    2
    3
    4
    tuple1 = (1)
    tuple2 = (1,)
    type(tuple1)      #<class 'int'>   单个元素的元组相当于该元素，如8*（8）
    type(tuple2)      #<class 'tuple'>

    元组内容不能改变，可以给元组重新赋值

    1
    2
    tuple = (1,2,4,5)
    tuple = tuple[:2]+(3,)+tuple[2:]    #tuple包含12345 +拼接操作符左右元素必须一致

  • 字典（dictionary）

    字典用{ }标识，字典中的元素无序，通过键来存取

    1
    2
    3
    4
    5
    6
    7
    dict = {}
    dict['one'] = 'this is one'
    dict[2] = 'this is two'

    print dict 			 #输出完整字典
    print dict.keys()    #输出所有键
    print dict.values()  #输出所有值

分支和循环

  • if 语句

    1
    2
    3
    4
    5
    6
    7
    #一般表达形式
    if 条件:
        ...
    elif 条件:
        ...
    else 条件:
        ...

  • 三元运算符

    1
    val= val1 if 条件成立 else val2

  • assert断言

    1
    assert 1>2    #当为假时抛出AssertionError异常，可用来调试程序

  • while 语句

    一般形式

    1
    2
    while condition：
    	statements...

    while循环中使用else语句

    1
    2
    3
    4
    5
    #while...else在条件语句为false时执行else语句
    while condition:
        statements...
    else:
        statement...

  • for 语句

    一般形式

    1
    2
    3
    4
    for variable in sequence:
        statements...
    else:
        statements...
    1
    2
    3
    4
    #python for循环可以遍历任何序列的项目，如一个列表或者一个字符串
    languages=['C','C++','Python']
    for x in languages:
        print(x)

    需要遍历数字序列或者控制次数，使用range( )函数

    1
    2
    range([start,]stop[,step=1])
    #从start到stop，默认从0开始，默认间隔为1
    1
    2
    3
    #与for循环结合使用
    for i in range(5):
        print i			#输出0 1 2 3 4

  • break与continue

    break跳出当前循环体

    continue跳过当前循环的剩余语句开始下一次循坏

列表推导式

快速生成包含一堆数据的列表

1
[i+1 for i in range(10)]  # 生成1-10列表

字典推导式

快速生成包含一堆数据的字典

1
2
{i+1:for i in range(10)}
{'a{}'.fomart(i):i for i in range(10)}

三元运算符

1
a = 10 if 4>3 else 20

函数

  • 函数的一般格式

    1
    2
    3
    def func(...):
        ...
        return ...  #可以返回多个返回值，用元组表示

  • 函数文档

    1
    2
    3
    4
    5
    6
    def fun():
        'this is an empty function'   #函数文档
        
    #查看函数文档的两种方式，通过此可以查看系统函数如print
    fun.__doc__
    help(fun)

  • 关键字参数

    使用关键字参数允许函数调用时参数的顺序与声明时不一致

    1
    2
    3
    4
    5
    def fun(name,age):
        ...

    #调用时
    fun(age=22,name='w')

  • 默认参数

    调用函数时，如果没有传递参数则会使用默认参数

    1
    2
    def fun(name='w',age=22):
        ...

  • 可变参数、不定长参数

    不确定参数的个数

    1
    2
    3
    4
    def fun(*num):
        return len(num)

    fun(1,2,3,4)	#调用时可传入多个参数
    1
    2
    3
    #可变参数后面的参数最好带有默认参数，通过关键字参数调用，如print
    print(*objects,sep=' ',end='\n',file=sys.stdout,flush=False)
    print(1,2,sep='+')

  • global与nonlocal关键字

    1
    ...

  • 闭包

    1
    ...

  • 内部函数

    在函数中定义的函数

    1
    2
    3
    4
    def fun1():
        def fun2():
            ...
        fun2()

文件

  • 读写文件的步骤

    • 打开文件：使用open函数，返回文件对象
    • 具体读写：使用文件对象的read、write方法读写
    • 关闭文件：使用close函数

  • 删除具体文件

    1
    2
    import os
    os.remove(filename)

  • 打开文件

    1
    open(filename,mode)  #mode默认为r

    各种模式

    • r：只读，文件必须存在
    • w：只写，覆盖或创建文件
    • a：只写，创建文件或在文件后追加内容
    • +：读写（不能单独使用）
    • b：二进制模式打开（不能单独使用）

    读写模式r+、w+、a+

    • r+：文件必须存在，写入时覆盖文件
    • w+：文件不存在创造文件，文件存在覆盖文件
    • a+：文件不存在创造文件，文件存在在文件后追加内容

  • 文件对象的方法

    1
    2
    3
    4
    5
    6
    f.read(size)    #读取size个字符，size为负或不存在读取全部文件
    f.readline()    #读取一行，以字符串返回
    f.readlines()   #读取所有行，以列表返回
    f.write(string) #写入文件
    f.tell()        #返回当前文件所处的位置
    f.seek(offset,from_what) #改变文件所处的位置，from_what:0文件头，默认；1当前位置；2文件尾

  • 文件对象当成迭代器来读取

    1
    2
    for line in f:
        print(line)

  • 使用with语句

    相当于自动执行close操作

    1
    2
    3
    4
    5
    with open(file,'r+') as f:
        try:
            ...		# 对文件进行操作
        except:
            ...

  • os模块中关于文件的方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    getcwd()   #返回当前工作目录
    chdir(path)    #改变工作目录
    mkdir(path)    #创建单层目录，若存在抛出异常
    makedirs(path) #创建多层目录，若存在抛出异常
    remove(path)   #删除文件
    rmdir(path)	   #删除单层目录，目录非空抛出异常
    removedirs(path)#递归删除空目录，目录非空抛出异常
    rename(old,new)	#文件重命名
    system(command) #运行系统的shell命令

  • pickle模块

    pickle用于对python对象进行序列化和反序列化，可以方便的将类对象存储在文件中。

    常用函数

    1
    2
    3
    4
    5
    6
    7
    8
    pickle.dump(obj,file[,protocol])
    #将obj对象序列化存入已经打开的file中
    pickle.load(file)
    #将file中的对象序列化读出
    pickle.dumps(obj[,protocol])
    #将obj对象序列化为string形式，而不是存入文件中
    pickle.loads(string)
    #从string中读出序列化前的obj对象

    使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #dump使用（序列化）
    f=open('b://test.pkl','wb')  #.pkl为pickle的文件，.txt也可以，反正都是乱码，.pkl显得专业;一定要使用二进制模式
    list=[1,2.2,'33']
    pickle.dump(list,f)
    f.close()

    #load使用（反序列化）
    f=open('b://test.pkl','rb')
    list=pickle.load(f)
    f.close()

    #dumps与loads使用
    list=[1,2.2,'33']
    bytes=pickle.dumps(list)  #将list序列化
    list=pickle.loads(bytes)  #将bytes反序列化

异常

  • Python标准异常

  • 异常处理

    1
    2
    3
    4
    5
    6
    7
    #‘标准’的异常处理
    try:
        ...
    except <Exception> [as result]:
    	...
    finally:
    	...
    1
    2
    3
    4
    5
    #使用except不带任何异常类型，不推荐使用
    try:
        ...
    except:
    	...
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #使用except带有多种异常类型
    try:
        ...
    except (Exception1,Exception2,...):
    	...
    #或者多次except
    except Exception1:
        ...
    except Exception2:

  • 触发异常

    1
    raise Exception    #闹着玩

  • 用户自定义异常

​

类和对象

类的实现

  • 创建类

    1
    2
    3
    4
    5
    class MyClass:						#定义类							
        """A simple example class"""    #定义类的说明字符串
        i = 1234						#定义成员变量
        def fun(self):					#定义方法
            return i

  • 使用类

    1
    2
    m = MyClass()			#创建类对象
    print(m.fun())			#调用类方法

  • 类的内置属性

    1
    2
    3
    4
    5
    __name__	#类名称
    __doc__		#类文档
    __module__	#类定义所在的模块，如果是当前模块则为__main__
    __base__	#该类的父类列表，tuple类型
    __dict__	#该类的所有属性，dict类型

  • 类属性的私有化

    1
    2
    class Myclass:
        __name='myclass'   #属性名前加两道下划线表示为private变量，其余为public变量

类的动态属性

python中的类，可以为实例化的对象添加动态属性，增加灵活性。

动态属性仅作用于当前对象

  • 添加动态属性

    1
    2
    3
    4
    5
    class Myclass:
        pass			#pass关键字占格，不进行操作

    m=Myclass()
    m.name='Myclass'	#通过 对象名.属性名 添加属性

  • 删除动态属性

    1
    del m.name    		#通过 del 对象名.类名 删除属性

  • 限制类属性

    通过 _slots__可以限制类的属性，即限定该类所允许添加的动态属性名称

    1
    2
    class Myclass:
        __slots__=('name','age') #添加的动态属性只能为name、age

实例化类对象

  • 类的初始化方法

    实现带有初始值的实例化，需要在定义类时，在类中实现_init__方法，相当于构造函数

    1
    2
    3
    4
    5
    6
    7
    class Myclass:
        def __init__(self,name,age):
            self.name=name
            self.age=age
            
        def getMyClass(self):
            return self.name,self.age

  • class中的self

    self关键字来指定本身，相当于java中的this。不同的是，python中类成员函数必须第一个参数是self

类的继承

  • 单继承

    1
    2
    class DerivedClassName(FatherClassName):
        ...

  • 多继承

    1
    2
    class DerivedClassName(FatherClassName1,FatherClassName2,...):
        ...

  • 覆写

    子类与父类的成员函数名相同，则父类会被覆写

    1
    2
    3
    4
    5
    #通过 父类名.函数 调用父类直接调用被覆写的函数
    FatherclassName.method(self,arguments)

    #也可以通过super()调用，使用super不使用self
    super().method(arguments)

类的魔法方法

图形用户界面GUI

  • EasyGUI 简单操作
  • Tkinter 功能强大