Python复习 一

概述Python回炉复习 1 变量 Python的变量和C语言的变量书写方式类似； 书写要求 python程序编写结构利用缩进表示，抛弃花括号； 结构 分支： if(条件语句1): 执行语句块else if(条件语句2): 执行语句块else: 执行语句块 循环： while 循环 while 循环条件: 循环语句体 for 循环 for 目标 in 表达式： Python回炉复习 1 变量

Python的变量和C语言的变量书写方式类似；

书写要求

python程序编写结构利用缩进表示，抛弃花括号；

结构 分支：

if(条件语句1):    执行语句块else if(条件语句2):    执行语句块else:    执行语句块

循环： while 循环

while 循环条件:    循环语句体

for 循环

for 目标 in 表达式：    循环语句体

表达式的结果会和目标联成共体

range()函数：

步长函数；

range(x,y,z)

? x：开始

? y：结束（y-1）

? z：步长

break 语句：

跳出当前结构体

continue 语句：

结束以此循环体的运行

列表 创建列表

>>> num = [1,2,3,4,5] // 列表创建>>> num               // 列表输出[1,5]>>> num = ['Hello','你好',666]>>> num // 列表支持各种类型，除数字以外的其他字符都需要用单引号['Hello',666]

append()：添加元素

>>> num.append(6)>>> num[1,5,6]

extend()：添加多个元素

>>> num.extend([7,8,9])>>> num[1,6,7,9]

append()是添加一个单独的元素，就是简单的扩充；

而extend()则是将原有的列表和自己要添加的列表拼接成一个新列表

insert()：在列表中插入元素

>>> num.insert(0,0) // 在0索引位置添加元素0>>> num[0,1,9]

pop()：删除列表元素 PHP()：删除列表最后一个元素 PHP(X)：删除列表中索引为X的元素 pop()会返回被删除的元素内容

>>> num.pop()9>>> num.pop(0)0>>> num[1,8]

del 语句：删除列表 del [Listname]：删除整个列表（也可以同时删除多个） del [Listname[X]]：删除索引为X的元素

>>> num = [1,8]>>> num[1,8]>>> del num[7]>>> num[1,7]>>> del num>>> numTraceback (most recent call last):  file "<pyshell#19>",line 1,in <module>    numnameError: name 'num' is not defined

如报错提示：num不存在

remove()：删除已知X元素 搜索元素X内容并删除

我们之前的del语句和pop()函数都是依靠列表的索引来删除索引下的元素，remove()则是不靠索引，而是根据元素的具体内容来删除。

>>> num = ['Hello',666]>>> num['Hello',666]>>> num.remove(666)>>> num['Hello','你好']>>> num.remove('你好')>>> num['Hello']

列表分片

将一个列表只输出或显示或复制一部分数据元素，就是所谓的列表分片

>>> num = ['HUAWEI',"CHINA",'Mirror','XIAOMI']>>> num['HUAWEI','CHINA','XIAOMI']>>> num[0:1]['HUAWEI']>>> num[0:2]['HUAWEI','CHINA']>>> num[0:4]['HUAWEI','XIAOMI']>>> num[:2]['HUAWEI','CHINA']>>> num[:]['HUAWEI','XIAOMI']>>> num[2:]['Mirror','XIAOMI']

仔细观察，发现分片的[x:y]是左闭右开的范围（原则）【python里很多时候和范围有关的闭合问题都是左闭右开的原则】

同时，分片机制还支持省略范围值；即左为空则从0开始，右为空则到最后一个元素结束，左右皆为空则全部元素输出；

分片的高级玩法

大家都认为分片只有两个参数？

分片有三个参数 ==> [x:y:z]

? x：开始

? y： 结束

? z： 步长（即每次递加的数量为z也可以理解为数学中的等差概念）

>>> num = [] // 创建一个空数组>>> for i in range(1,10):    num.append(i)>>> num[1,9]>>> num[0:10:2][1,9]

深浅复制初讨论

>>> List = [1,4]>>> copy = List>>> copy1 = List>>> copy2 = List[:]>>> copy1[1,4]>>> copy2[1,4]

从上边可以看出，List直接复制和List[:]分片复制的结果一样，但其实暗藏心急哦！

>>> List.append(5)>>> copy1[1,5]>>> copy2[1,4]

向原来的源列表 append() 添加一个元素，发现copy1的内容和List源列表一同别改变（append() *** 作）

解释：

copy1 = List : 属于将List的内存地址给了copy1，

copy2 = List[:]：属于将List的值给了copy2

列表比较

列表支持比较运算符的比较 *** 作：

>>> List1 = [123]>>> List2 = [234]>>> List3 = [123]>>> List1 < List2True>>> List1 <= List3True>>> List1 == List3True>>> List1 != List2True>>> List1.append(234)>>> List2.append(123)>>> List1[123,234]>>> List2[234,123]>>> List1 > List2False

两个列表的比较是根据ASCII值的大小比较的，如果遇到两个元素，则比较第一个，若第一个相同在比较第二个元素。

字符串列表 拼接和重复

>>> str1['HUAWEI']>>> str2['CHINA']>>> str1 + str2['HUAWEI','CHINA']>>> str1 * 3['HUAWEI','HUAWEI','HUAWEI']>>> str1 = str1 +str2>>> str1['HUAWEI','CHINA']>>> str1[1] * 3'CHINACHINACHINA'

元素判断：in/not in 判断元素是否存在列表中：’str‘ in List / ’str‘ not in List

>>> str1['HUAWEI','CHINA']>>> "CHINA" in str1True>>> "CHINA" not in str1False

元素查询 index()：查询元素的索引

>>> str = ["H","U","A","W","E","I"]>>> str['H','U','A','W','E','I']>>> str.index("I")5>>> str.index("K")  // 元素不存在保存Traceback (most recent call last):  file "<pyshell#4>",in <module>    str.index("K")ValueError: 'K' is not in List>>>

count()：查询元素重复次数

>>> List[3,66,7]>>> List.count(5)3

排序：reverse() 、sort() reverse()：反向排列 sort()：升序排列

>>> List[3,7]>>> List.reverse() // 反向排列>>> List[7,3]>>> List.sort()   // 升序>>> List[2,66]>>> List.reverse()  // 反向排列 （srot+reverse ==> 降序）>>> List[66,2]

元组

元组可以理解为：一旦定义不可被更改的列表。

元组创建

>>> tuple = (1,5)>>> number = [1,5]>>> tuple(1,5)>>> number[1,5]

tuple是元组，number是列表；

可以发现；两者的定义有所不同

元组是由圆括号组成的一组列表数据，列表是由方括号组成的一组数据

元组访问

元组的访问方法和列表是一样的，主要通过元组的索引来访问元组的元素，和列表一样可以通过分片（切片）的方式访问。

>>> tuple(1,5)>>> tuple[2]3>>> tuple[3]4>>> tuple[:](1,5)

type() 方法 返回参数的类型

>>> tup = ()>>> num = []>>> type(tup)<class 'tuple'>>>> type(num)<class 'List'>

很多时候，都会认为圆括号定义的列表数据就是元组，然而并不是！

>>> del tup>>> tupTraceback (most recent call last):  file "<pyshell#14>",in <module>    tupnameError: name 'tup' is not defined>>> tup = 1,4>>> type(tup)<class 'tuple'>

没错，没有圆括号的列表数据也是tuple元组。

定义元组的特点是：逗号

>>> (6)*636>>> (6,)*6(6,6)

所以在元组的定义时候，需要一个逗号告诉程序，这是元组

>>> tup = (1,)>>> type(tup)<class 'tuple'>

这是最标准的定义方法，为什么？

元组更新与删除 更新：

元组和列表的功能除了数据改变以外几乎一致，一个元组的数据是不可以改变的，但元组和元组之间是可以拼接的

>>> tup(1,3)>>> tup = tup[:3] + 4,+ 5,Traceback (most recent call last):  file "<pyshell#28>",in <module>    tup = tup[:3] + 4,TypeError: can only concatenate tuple (not "int") to tuple>>> tup = tup[:3] + (4,) + (5,)>>> tup(1,6)

tup利用拼接将tup元组数据进行了更新；

注意：

? 这里在拼接的时候，将拼接的内容均用括号和逗号等标志表示这是一个元组数据，否则会被程序认为是一个字符或者数字数据。

逗号是元组的标志定义

删除：

>>> tup = tup[:2] + tup[4:]>>> tup(1,6)

通过拼接方法覆盖掉需要删除的元素，以此达到删除元素的目的。

总结：

元组的数据是不变的，但是元组可以和列表一样自由的拼接：

? 利用末尾的切片拼接的方式让元素增加元素（注意元组元素逗号标识）

? 利用分片拼接的方式切除删除元素的前后内容拼接成一个新的元组

字符串 python3的所有字符串都是Unicode（编码）字符串 创建

>>> char = "HUAWEI">>> str = 'XIAOMI'>>> char'HUAWEI'>>> str'XIAOMI'

字符串的创建可以使用单引号和双引号

字符串修改

>>> str = str[:3] + "-" + str[3:]>>> str'XIA-OMI'

字符串的修改和元组类似，采用分片拼接的方式实现更改字符串内容。

ps：是重新组成新的字符串给一个新的字符串变量所以要赋值

字符串格式化 format() 按照索引坐标

>>> '{0}-{1}={2}'.format('XIAOMI','CHINA')'XIAOMI-HUAWEI=CHINA'

从代码中可以看出，字符串中的花括号内容是对应这format方法的参数值索引内容，通俗说：花括号里的索引会将format中的对应的参数值调用组成一个字符串。{format中的参数称为：位置参数}

按照(关键字)键值对

>>> '{x}-{h}={c}'.format(x='XIAOMI',h='HUAWEI',c='CHINA')'XIAOMI-HUAWEI=CHINA'

注意：位置参数索引要放在关键字索引前面 格式化 *** 作 格式化 *** 作符

格式符号	描述
%c	格式化字符以及ASCII
%s	格式化字符串
%d	格式化整数（十进制）
%o	格式化无符号八进制
%x 、%X	格式化无符号十六进制（小写、大写）
%f	格式化浮点数
%e 、%E	格式化科学计数法浮点数

以上为常见的格式符号 *** 作；和C语言异曲同工。

格式化 *** 作书写

'[格式化 *** 作符]' % [需要格式化 *** 作的内容]

>>> '%c' % 99'c'

格式化 *** 作的表达方式是：百分号 ==> %

辅助参数

参数命令	描述
m.n	m为最小从宽度，n为小数点后的位数
-	左对齐
+	证书前显示加好
#	在八进制和十进制结果中分别显示：0o 和 0x/0X
0	数字前面用”0“填充空格
转义字符	描述
?‘	单引号
?"	双引号
?a	系统响鸣
?b	退格符
?n	换行符
?t ， ?v	制表符（8个空格）
?f	换页符
?r	回车符
?\	反斜杠
?0	代表一个空字符

序列 列表、元组、字符串（*）都可以视为可迭代对象 List()：可迭代对象转为列表

>>> List = List((1,4))>>> List[1,4]>>> List = List("HUAWEI")>>> List['H','I']

tuple()：可迭代对象转为元组

>>> tuple = tuple("HUAWEI")>>> tuple('H','I')>>> type(tuple)<class 'tuple'>

str()：obj对象转为字符串

>>> s = str(1)>>> s'1'>>> type(s)<class 'str'>>>> tuple(s)('1',)

len(sub)：返回参数长度

>>> num = [1,7]>>> len(num)6

max()/min()：序列最大/最小值

>>> num = [1,7]>>> len(num)6>>> max(num)7>>> min(num)1

sum()：返回总和

>>> num = [1,7]>>> sum(num)24

sorted()：排序

>>> num[12,24,33,32,243,23,15,1]>>> sorted(num)[1,12,243]>>> num[12,1]>>> num.sort()>>> num[1,243]

代码中我们和前面的sort()进行了对比发现

? sorted()：返回升序后的结果但不改变原有数据

? sort()：将源列表进行了升序

reversed()：逆向迭代

>>> List = List((2,67,8))>>> for i in reversed(List):    print(i,end='-')8-3-7-3-67-4-2-

可以看出，reversed()方法会将一个可迭代的序列逆向迭代输出

enumerate()：生成二元组

二元组：元素为2的元组构成一个迭代对象，每个二元组有迭代参数的索引和对应的元素组成。

>>> for i in enumerate(List):    print(i)    (0,'H')(1,'U')(2,'A')(3,'W')(4,'E')(5,'I')

zip()：迭代参数合为元组

返回可迭代参数共同组成的元组

>>> List[2,8]>>> str['H','I']>>> for i in zip(List,str):    print(i)    (2,'H')(4,'U')(67,'W')(7,'E')(3,'I')

函数 函数创建、调用

函数的含义就是将需要的且重复的功能代码封装在一个对象函数中，需要使用的时候直接调用即可。

def out():    print("Hello,World!")    print("I am Mirror")    out() // 调用out函数Hello,World!I am Mirror

函数参数

在函数定义的时候，可以在括号内添加参数设置，为函数设置参数，在调用函数时就会要求传入参数，函数体内也可以引用这个参数值进行工作。

def name(s):    print(s)def sum(x,y):    print(x+y)name("Mirror")sum(1,2)================ RESTART ================Mirror3

函数可以接收零个或多个参数值，在函数定义的时候，参数的数据类型可以不定义

函数返回值

def name(s):    return "I am {0}".format(s)def sum(x,y):    return "SUM = {0}".format(x+y)print (name("Mirror"))print (sum(1,2))================ RESTART================I am MirrorSUM = 3

灵活的函数 形参和实参

从上例函数的参数认识到了参数的设置和传递，但是如果我们不知道我们传递多少个数据参数的时候怎么办？

形参：函数创建时的参数定义 实参：函数调用过程中有调用出传递的参数 函数文档 指在函数定义下方注明函数的具体作用，增加可读性

一般情况下，在嗲吗开头的三引号里不会打印出来，但是依旧会被存储，和注释的功能非常的类似，我们可以在调用的时候获取这个三引中的内容，了解函数的作用

_ _ doc _ _：获取函数

def sum(x,y):    """ 返回 x,y 的求和"""    return "SUM = {0}".format(x+y)print (sum.__doc__)================ RESTART ================ 返回 x,y 的求和

关键字函数

def sum(x,y 的求和"""    return "SUM = {0}".format(x+y)print (sum(x=1,y=2))

将形参的名称作为关键字，采用”赋值“模式对指定的形参传递实参

默认参数

def sum(x=1,y=2):    """ 返回 x,y 的求和"""    return "SUM = {0}".format(x+y)print (sum())

默认参数：函数定义形参的同时给形参设置一个默认的参数，如果函数调用时为接收到实参传递则使用形参的默认参数进行运行

可变参数

回到形参时提出的关于不知道传递参数：

从上例函数的参数认识到了参数的设置和传递，但是如果我们不知道我们传递多少个数据参数的时候怎么办？

这时候就需要我们设置一个可变的形参（参数）：

* 形参名

def sum(* s):    print(len(s))    print(type(s))sum(1,7)================ RESTART ================7<class 'tuple'>

观察分析得出：使用星号表示的形参会自动将接收的实参序列压缩为一个”元组“，我们在没有使用可变参数的时候只可以传递单个（数字、字符、字符串）参数

可变参数可以接收的是：可迭代的序列（列表，元组，字符，字符串……） 字典集合 python的字典集合采用：（Key：Value）键值对进行保存、读取等 *** 作 字典创建（dict）

>>> dict = {1:10086,"a":"CHINA"}>>> dict{1: 10086,'a': 'CHINA'}>>> dict[1]  // 根据Key索引并返回Value10086>>> dict["a"]'CHINA'

字典的标志特点就是：花括号包围的键值对序列

Key：是独一无二的，在同一个字典集合中不会重复 Value：每一个Value对应一个Key，Value可以重复，但必须不可变 字典内置 *** 作 formkeys()：创建返回新字典 参数： key：必须 Value：默认None

>>> del dict>>> dict.fromkeys((1,3)){1: None,2: None,3: None}

返回字典内容 keys()：返回字典所有Key值

>>> dict{1: None,3: None}>>> dict.keys()dict_keys([1,3])

values()：返回字典所有Value值

>>> dict.values()dict_values([None,None,None])

items()：返回字典所有项

>>> dict.items()dict_items([(1,None),(2,(3,None)])

get()：查询一个key的value

>>> dict{1: 10086,'a': 'CHINA'}>>> dict.get("a")'CHINA'>>> dict.get(1)10086>>> dict.get("CHINA")>>> dict.get(112)

get()查询一个key，如果不存在不会返回报错！可以利用 in/not in 来实现判断是否存在

claer()：清空字典

>>> dict.clear()>>> dict{}

ps： 是清空内容不是删除

copy()：复制字典

>>> dict{1: 10086,'a': 'CHINA'}>>> c = {} // 定义一个空字典>>> c{}>>> type(c)<class 'dict'>>>> c = dict.copy()>>> c{1: 10086,'a': 'CHINA'}

pop()：d出（删除）值 pop(key)：删除key和对应的value popitem()：删除最后一个key和value

>>> dict = {1:10086,"a":"CHINA"}>>> dict.pop(1)10086>>> dict{'a': 'CHINA'}>>> dict = {1:10086,"a":"CHINA"}>>> dict.popitem()('a','CHINA')>>> dict{1: 10086}

update()：更新字典 dict.update(dict)

>>> dict.update({2:2019})>>> dict{1: 10086,'a': 'CHINA',2: 2019}

集合创建（set） 先看dict和set的区别

>>> dict1 = {}>>> dict2 = {1,5} // 集合创建>>> type(dict1)<class 'dict'>>>> type(dict2)<class 'set'>

可以通过集合与字典的比较发现集合的特点：

? 集合是使用花括号但不适用键值对，以逗号分隔的序列

集合开始

>>> set = {1,6}

访问集合

>>> set1{1,6}>>> for i in set1:    print(i,end=" ")1 2 3 4 5 6

Python文件 文件打开 open() *** 作符

标志	描述
r	以只读方式打开文件
w	以写入方式打开文件
x	文件存在会抛出异常
a	以写入方式打开，已存在文件可追加
b	以二进制打开文件
t	以文本方式打开
+	可读写模式
U	通用换行符支持

open()函数

open()：用于创建一个文件对象，以便其他 *** 作使用该文件对象

单参数：可以是文件的具体路径和文件名（如果只是文件名会索引当前目录） *** 作符：决定文件的打开模式（默认为只读 ”r“） *** 作函数 close()：关闭文件 read()：读取字符 read(size=-1)：从文件中读取size指定的字符内容大小；未赋值表示读取全部内容并作为String返回 readline()：读取一行字符串 write()：向文件输出内容 writelines()：向文件输出序列 seek()：移动文件指针 seek(offset,form)：从form偏移offset字节 offset：0 = 起始；1 = 当前位置；2 = 末尾 tell()：返回当前文件的位置 OS 文件模块

os模块；import os 导入os模块

目录 *** 作 getcwd()：获取当前目录 chdir()：切换目录 Listdir()：查看任意目录内容 mkdir()：创建文件夹（目录） makedirs()：创建多级文件夹（目录） 删除 *** 作 remove()：删除指定文件 radir()：删除指定文件夹（目录） removedirs()：删除多级文件夹（目录） rename()：文件/文件夹 重命名 系统 *** 作 system()：调用工具 walk()：遍历子目录返回三元组 path 路径 *** 作 path.basename()：获取文件名 path.dirname()：获取路径名 path.join()：完整路径join path.split()：分隔路径和文件名 path.splitext()：分隔文件名和扩展名 path.getsize()：获取文件大小（字节） path 时间函数 path.getatime()：最近访问时间 path.getctime()：创建时间 path.getmtime()：修改时间 prckle()模块

可以将对象以文件的形式存放在磁盘中；是一种简单的持久化功能

python的所有数据类型都可以使用 prckle()来序列化存放磁盘

异常处理 AssertionError：断言

assert在测试程序的时候，在代码植入检查点

>>> List = ['Mirror']>>> assert len(List)>0>>> List.pop()'Mirror'>>> assert len(List)>0Traceback (most recent call last):  file "<pyshell#3>",in <module>    assert len(List)>0AssertionError

assert断言：在其语句后面的条件成立的时候则不会编译assert，若断言条件满足后则会在程序中报错。

如上例代码程序：原先List列表内有一个元素，assert没有报错，但是pop方法d出（删除）元素后，assert的条件得不到满足就会报错

try - except语句

try:    检测范围except exception[as e]:    检测发现exception异常后的处理方法finally:// 可选    必须执行的代码块

范例：

>>> try:        file = open("a.txt")        file.close()    except OSError:        print("Error")    Error

如范例中的程序，检测到在调用file文件对象的时候发生了OSError错误，由此执行报错（异常）代码执行块

>>> try:        file = open("a.txt")        file.close    except OSError as e:        print(str(e) + "Error")    except TypeError as e:        print(str(e) + "Error")    [Errno 2] No such file or directory: 'a.txt'Error

如上；利用as error方法，将错误信息写入e变量中，在以str的类型输出错误信息；同时发现，可以定义多种不同的错误类型和报错输出。

异常

Exception： 所有异常的基类（可以接收任何类的异常）

AssertionError：assert语句失败（assert条件不成立）

AttributeError：访问一个对象没有的属性（对象属性不存在）

IOError：输入输出 *** 作异常

importError：无法引入模块或包（路径错误等）

IndexError：索引超出序列边界

KeyError：访问字典中不存在的key

KeyboardInterrupt：Ctrl+C被触发

namerror：使用的对象无变量

SyntaxError：代码逻辑语法错误

TypeError：对象类型和语句要求不符

UnboundLocalError：全局变量的异常

ValueError：传入的value值异常出错

ZerodivisonError：触发除零的异常

第三方GUI模块：EasyGUI 类和对象 认识类和对象

类：class 类名称:

对象：def 方法名():

一个程序可以由多个类组成，一个类由多个对象方法组成；

self关键字：代表自己的对象参数

类的方法与普通的函数只有一个区别：它们必须有一个额外的参数名称，但在调用这个方法的时候不可以为这个参数赋值，python会提供这个值。这个特别的变量指的是对象的本身，名为：self；

初探Python魔法方法 __ init__()构造方法

只要实例化一个对象前，这个方法就会在对象被创建前自动调用；参数形参也会自动传入该方法中；可以利用重写该方法实现初始化的 *** 作

class Potate:    def __init__(self.name):        self.name = name    def kick(self):        pirnt(self.name)

公有和私有

public ：公有、公共

private：私有

以上是C++和Java方法；

在Python中表示私有的属性：变量名前两个下划线“__”

继承

class 类名(被继承的类):

self：只可以使用自己的类中的对象 super：可以从子类中调用父类中的属性对象

Python支持多重继承，即一个类继承多个父类；【不建议使用】

总结

以上是内存溢出为你收集整理的Python复习 一全部内容，希望文章能够帮你解决Python复习 一所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。