Python复习 一
Python回炉复习 1变量Python的变量和C语言的变量书写方式类似; 书写要求python程序编写结构利用缩进表示,抛弃花括号; 结构分支:if(条件语句1): 执行语句块 else if(条件语句2): 执行语句块 else: 执行语句块 循环:while 循环while 循环条件: 循环语句体 for 循环for 目标 in 表达式: 循环语句体
列表创建列表>>> 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]
insert():在列表中插入元素>>> num.insert(0,0) // 在0索引位置添加元素0 >>> num [0,1,9] pop():删除列表元素
>>> num.pop() 9 >>> num.pop(0) 0 >>> num [1,8] del 语句:删除列表
>>> num = [1,8] >>> num [1,8] >>> del num[7] >>> num [1,7] >>> del num >>> num Traceback (most recent call last): File "<pyshell#19>",line 1,in <module> num NameError: name 'num' is not defined
remove():删除已知X元素
>>> 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']
分片的高级玩法
>>> 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()操作)
列表比较列表支持比较运算符的比较操作: >>> list1 = [123] >>> list2 = [234] >>> list3 = [123] >>> list1 < list2 True >>> list1 <= list3 True >>> list1 == list3 True >>> list1 != list2 True >>> list1.append(234) >>> list2.append(123) >>> list1 [123,234] >>> list2 [234,123] >>> list1 > list2 False
字符串列表拼接和重复>>> 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
>>> str1 ['HUAWEI','CHINA'] >>> "CHINA" in str1 True >>> "CHINA" not in str1 False 元素查询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()
>>> 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 >>> tup Traceback (most recent call last): File "<pyshell#14>",in <module> tup NameError: name 'tup' is not defined >>> tup = 1,4 >>> type(tup) <class 'tuple'> 没错,没有圆括号的列表数据也是tuple元组。 定义元组的特点是:逗号 >>> (6)*6 36 >>> (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) 通过拼接方法覆盖掉需要删除的元素,以此达到删除元素的目的。
元组的数据是不变的,但是元组可以和列表一样自由的拼接: ? 利用末尾的切片拼接的方式让元素增加元素(注意元组元素逗号标识) ? 利用分片拼接的方式切除删除元素的前后内容拼接成一个新的元组 字符串
创建>>> 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语言异曲同工。 格式化操作书写'[格式化操作符]' % [需要格式化操作的内容] >>> '%c' % 99 'c' 格式化操作的表达方式是:百分号 ==> % 辅助参数
序列
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 ================ Mirror 3 函数可以接收零个或多个参数值,在函数定义的时候,参数的数据类型可以不定义 函数返回值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 Mirror SUM = 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'> 观察分析得出:使用星号表示的形参会自动将接收的实参序列压缩为一个”元组“,我们在没有使用可变参数的时候只可以传递单个(数字、字符、字符串)参数
字典集合
字典创建(dict)>>> dict = {1:10086,"a":"CHINA"} >>> dict {1: 10086,'a': 'CHINA'} >>> dict[1] // 根据Key索引并返回Value 10086 >>> dict["a"] 'CHINA' 字典的标志特点就是:花括号包围的键值对序列
字典内置操作formkeys():创建返回新字典
>>> 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():弹出(删除)值
>>> 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({2:2019}) >>> dict {1: 10086,'a': 'CHINA',2: 2019} 集合创建(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()操作符
open()函数open():用于创建一个文件对象,以便其他操作使用该文件对象
操作函数close():关闭文件read():读取字符
readline():读取一行字符串write():向文件输出内容writelines():向文件输出序列seek():移动文件指针
tell():返回当前文件的位置OS 文件模块os模块;import os 导入os模块 目录操作getcwd():获取当前目录chdir():切换目录listdir():查看任意目录内容mkdir():创建文件夹(目录)makedirs():创建多级文件夹(目录)删除操作remove():删除指定文件radir():删除指定文件夹(目录)removedirs():删除多级文件夹(目录)rename():文件/文件夹 重命名系统操作system():调用工具walk():遍历子目录返回三元组path 路径操作path.basename():获取文件名path.dirname():获取路径名path.join():完整路径joinpath.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)>0 Traceback (most recent call last): File "<pyshell#3>",in <module> assert len(list)>0 AssertionError assert断言:在其语句后面的条件成立的时候则不会编译assert,若断言条件满足后则会在程序中报错。 如上例代码程序:原先list列表内有一个元素,assert没有报错,但是pop方法弹出(删除)元素后,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 类名(被继承的类):
Python支持多重继承,即一个类继承多个父类;【不建议使用】 (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |