Python常见操作(转)

1、注释的作用：在程序中对某些代码进行标注说明，增强秩序可读性

2、注释的快捷键 ctrl + /

3、变量：在内存中开辟一块空间，起一个别名，用来访问和存储空间中的数据

4、变量名是区分大小写的

5、变量名 = 值

6、变量的数据类型：整型（int）、浮点型（float）、布尔型（bool）

     非数字型：字符串（str）、列表（list）、元组（tuple）、字典（dict）

7、用type（变量） 测试变量的数据类型

8、整型：+-*/ % 取余

浮点型：+-*/ 通常不用他取余

布尔型：Ture（1） False（0） 两个数比较返回值都是布尔型

9、非数字类型的计算：字符串变量之间使用 + 拼接字符串 例如：name = “鹿晗” edu = “学历本科” info = name + edu

10、字符串变量和整数使用* 重复拼接重复的内容 “你好”*4 重复4次字符串

11、字符串和整型之间不能用+拼接

12、格式化输出 %d 十进制的整数 %06d 表示输出的整数显示六位，不足的补0

                                  %f            浮点型   %.3f   小数的位数显示3位

                                  %s     字符串

                                  %%          输出%

13、类型的转换 int（变量） 将XXX转换为int整数

                                  float（变量） 将XXX转换为浮点型

                                  str（XX）将XX转换为字符串

14、变量的交换 b，a = a，b

15、运算符 算数运算符：+ - * / //取整除 %取余数 **幂

                         比较运算符     > >= < <= !=不等于 ==      返回的结果只有Ture   False          是布尔型bool

                         逻辑运算符   and   or   not

                         赋值运算    =      == 判断

                         复合赋值运算符    +=   -=    *=   /=    //=   %=

16、if语句的格式：

               if 要判断的条件：

                        条件成立执行该代码

     如果条件不满足，代码一条都不会执行

     代码段缩进为一个tab键    就是四个空格

17、输出语句： input（要输出的内容） 用户输入的内容是字符串

18、if…..else 编程条件判断（双分支）

格式：if 判断条件：

                        满足条件执行改代码段1

                 else：

                        不满足条件执行该代码段2

19、if….elif….else

     格式：if 判断条件1：

                        如果判断条件1满足，执行代码段1

                 elif 判断条件2：

                        如果判断条件2满足，执行代码段2

                 elif 判断条件3：

                        如果判断条件3满足，执行代码段3

                 else：

                        上面的条件都不满足执行该语句

20、if嵌套

     格式：if 判断条件1：

                        满足条件执行改代码段1

                                 if 判断条件2：

                                           条件2满足执行该代码

                 else：

                        不满足条件1执行该代码

21、能够用randint获取一个随机数

     import random   # 模块导入

     random.randint（0,10）   # 0-10之间的随机数

22、while循环

     格式：变量的初始化

                 while 条件：

                        条件满足的时候：执行该代码

                        条件满足的时候：执行该代码

                        变量的更新

23、while 条件1：

               条件1满足时，执行该代码

               while 条件2：

                        条件2满足时，执行该代码

24、外部的while循环一次，里面的while循环多次

25、for 循环的基本格式: 遍历

     for 变量 in 数据

               代码

26、输出连续的数：

     range（start，stop）计数从start开始，默认从0开始，不包括stop     range（5）   等价于range（0,5）0,1,2,3,4

27、必须和for循环一起使用

     for i in range（1,100）

               print（i）

28、end=“ ”

29、break和continue作用

     break退出的是相关的所有的循环

     continue退出的是当前的循环，进入下一次循环

30、列表 list = [元素1，元素2，元素3…] 列表的索引（下标）从0开始的

31、获取列表中的某个元素

     a = list[0]    列表中的第一个元素

32、取值的时候，如果超出索引的范围，程序会报错

33、列表常见的操作：

     增加         列表.append（数据）                       在末尾追加数据，并且每次只能添加一个

                        列表.extend（[4,5,6,7,8,]）     可迭代     列表一次增加多个数据

                        列表.insert（索引，数据）           在指定位置插入数据（位置前有空元素会补位）

     删除         del 列表[索引]                                        删除指定索引的数据

                        列表.remove（数据）                               删除第一个出现的指定数据

                        列表.pop（）                                      删除列表中的最后一个元素   有返回值，删  除的元素

                        列表.pop（索引）                             删除指定索引数据

                        列表.clear（）                                             清空列表

     修改         列表[索引] = 数据）   修改指定索引的数据，如果数据不存在，就会报错

     查询         列表[索引]                                            根据索引取值，如果索引不存在，就会报错

                        len（列表）                                                  列表的长度

                        if 数据 in 列表                                           检查列表中是否包含某元素

     排序         列表.sort（）                                      升序排列

34、使用for的循环遍历列表

               遍历就是从头到尾依次取出每一个元素，并且执行相同的操作

35、列表的嵌套

               一个列表中的元素又是一个列表，那么这就是列表的嵌套

36、元组 tuple = （元素，元素，元素…）

37、元组的索引从0开始

38、元组只包含一个元素时，需要在元素后面添加逗号 tuple = （50，）

39、元组不能修改里面的数据

40、查看数据类型的时候 print（type（数据））

41、元组的操作

     元组.count（数据）      数据在元素中出现的次数

     len（列表）             元组长度

     if 数据 in 元组                         检查元组中是否包含某元素

42、格式化字符串后面（）本质商就是一个元组

43、字典可以存储多个数据，存储相关的信息

44、字典的定义格式

     格式：dict = {key:value,key:value}     键名 key是键索引        键值value是数据

45、字典使用键值对存储数据

46、键名和键值之间的使用：值可以是任何类型，键名只能是字符串，数字，元组

47、字典和列表的区别：

               字典：是无序的集合，通过键名来访问数据

               列表：是有序的集合，下标是从0开始的正整数

48、拆包

               tuple =(1,2,3,4)

               a,b,c,d = tuple  #可以把元组中的数据进行自动拆包

               print(a)

               print(b)

               print(c)

               print(d)

49、字典的操作，增加 删除，修改

               增加         字典[键] = 数据      键不存在，会添加键值对；键存在，会修改键值对的值

               删除         字典.pop（键）      删除指定键值对，返回被删除的值

                                 字典.clear                 清空字典

               修改         字典[键] = 数据      键不存在，会添加键值对；键存在，会修改键值对的值

               查询         字典[键]                              根据键的取值，键值对不存在会报错

                                 字典.keys（）                  可以进行遍历，获取所有的键名

                                 字典.values（）               可以进行遍历，获取索引的键值

                                 字典.items（）                可以进行遍历，获取所有的（键，值）键值对

                                           默认获取的是键名

50、列表 元组 字符串 都是有序的，索引计数是从0开始的

51、字符串的常见操作：

               string.isdecimal()        判断字符串是否都是数字

               string.isalpha()                    判断字符串是否都是字母

52、字符串查找

                        string.find（要查找的字符串）    找到返回对应的下标号，没有找到返回的是-1

                        string.rfind（要查找的字符串）            从右向左查找

                        string.index（要查找的字符串）          找到返回对应的下标号，没有找到则报错

                        string.rindex（要查找的字符串）               从右开始查找

53、字符串字符的替换

                        string.replace（old，new，次数）                返回一个新字符串，把string中的      old替换成new，如果num指定，则替换不超过num次

54、str.split（“分割”）字符串 变成一个列表

               str =”星期一-星期二-星期三”

               list  =str.split(“-”)                                                # [“星期一”,”星期二”,”星期三”]

55、去掉空白字符串

     str.lstrip                     去掉左边（开始）的空白字符，返回一个新的字符

     str.rstrip                     去掉右边（末尾）的空白字符，返回一个新的字符

     str.strip                      去掉开始和末尾的空白字符，返回一个新的字符

56、字符串的切片

     切片，可以截取字符串中一部分字符

     切片的语法：

               字符串[开始的索引：结束的索引]  指定的区间属于前闭后开[开始索引，结束索引

57、用切片完成字符串的逆序

               如果步长值是负数，就是倒序     例如：str[：：-1]   这是整个字符串的倒序

58、定义一个函数：

               def 函数名（）

                        函数体（函数封装的代码）

59、函数在函数调用的时候才会执行

60、带有参数的函数定义的格式

     def 函数名（形参1，形参2）

               函数的代码

     形参可以理解为是变量，不用提前定义，接收实参传递过来的数据

61、函数名（实参，实参）

     形参的作用：接收实参传递的数据，把数据传递给函数的内部

     实参：调用函数使用的数据是实参，直接值

     形参：实参的占位，中转站，接收实参专递过来的数据

62、形参的作用域：

               在函数内部使用，在函数的外部不能使用该形参

没有实参，使用的是默认的值，给了实参，就使用实参的值
*形参：元组
**形参：字典

拆包要注意：元组中有多少个值，就用多少个变量接收

关键字参数：给实参指定对应的形参

                                 关键字参数是给实参

                                 默认的参数是给形参

                                 给参数2指定了关键字，没有给参数1指定关键字，就会报错

                                 设置一个关键字参数，给所有的实参都设置关键字参数

函数的可变（不定长参数）的使用
*表示元组类型 def fun（*args）

               可变参数可以接收任意数量的实参数据，并且自动组包成一个元组

字典型的可变参数
**表示字典类型 def fun（**args）

               添加一个数据，输出的结果是字典

需要函数的返回值：将运算的结果返回给函数调用的位置
在项目中，返回一个结果，进行其他的运算，提供返回结果主要为了后续代码要用，跟语法无关，如果没有返回值，值为none

     返回值如果有多个，组包一个元组，返回到函数的调用的位置    

拆包要注意：元组中有多少个值，就用多少个变量接收
四种函数类型：无参数无返回值 无参数有返回值 有参数无返回值 有参数有返回值
range(1, 6) 1-6连续的数，不包含6
重复输出某个符号 print(“*”*20)
全局变量：在函数外部定义的变量，作用范围为整个文件
局部变量：在函数内部定义的变量，只能在函数的内部使用

     如果在函数的内部需要修改全局变量，需要使用global进行声明                   Global 变量名

匿名函数：以表达式的形式来定义的函数，只能做一些简单的处理
lambda 形参数1，形参数2，形参数3….：返回值

               lambda函数能够接收任意数量的参数，并且返回一个表达式的值

               f =(lambda num1,num2:num1+num2)(1,2)

               print(f)

导入模块使用import
一个函数在内部调用其本身，这个函数就是递归函数
step(n) = n * step(n - 1) step()函数实现了阶乘
列表推导式：list = [表达式 for 变量 in 数据] 列表中存放的是for遍历出来的表达式的数据
列表推导式支持if判断：list = [表达式 for 循环 if 判断条件]
列表list，字典dict是可变的
数据类型 int，bool，float 字符串str 元组是不可变类型

访问模式：
r：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

               w：打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

               a：打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入

               rb：以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式

               wb：以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件

               ab：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

               r+：打开一个文件用于读写。文件指针将会放在文件的开头

               w+：打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 

               a+：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写

               rb+：以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头

               wb+：以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

               ab+：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

打开文件
语法：变量 = open(文件名, 访问模式)

     关闭文件

     格式：close()

read（num）：可以从文件中读取数据，num表示要从文件中读取的数据的埠度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
读数据（readline）：每次读取一行

     读数据（readlines）：按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素    

在读写文件的过程中，如果想知道当前的位置，可以使用tell()来获取
如果在读写文件的过程中，需要从另外一个位置进行操作的话，可以使用seek()
seek(offset, from)有两个参数

               offset：偏移量，from是从0开始才能使用

               seek(2, 0)文件的开头

               from：方向     0：表示文件开头

                                           1：表示当前位置

                                           2：表示文件末尾

a + 在光标的位置写入内容
os模块中的rename()可以完成对文件的重命名
重命名：rename(需要修改的文件名, 新的文件名)

                        删除文件：remove()

                        创建文件夹：mkdir("文件夹名")

                        获取当前的操作路径：getcwd()

                        获取目录列表：listdir()

                        改变操作的路径：chdir()

                        删除一个文件夹：rmdir()   只能删除非空文件

判断文件是否存在
os.path.exist(“文件”) 存在Ture 不存在False

eval():将字符串对象转换为有效的表达式参与求值运算返回计算结果
类就是创建对象的模板
先有类才有对象

     定义类格式：class 类名：   命名规则（大驼峰）

创建对象的格式：
引用对象的变量名 = 类名()

调用对象的方法
对象的变量名.方法名()

101、定义/使用属性

               定义、设置属性格式：引用对象的变量名.属性名 = 数据

102、self的意义：

               关键字：主要用于对象方法中，表示调用该方法的对象

               方法中：可以获取到调用当前方法的对象，进而获取到该对象的属性和方法

103、对象.属性 = 属性值

104、魔法方法：

               __init__(self)的使用（重点）

                        对象的初始化方法，在创建一个对象后默认会被调用，不需要手动调用

                        定义属性并设置初始值

                        A、默认参数的使用

                                 1)对象的初始化方法

                                 2)实例的初始化

                                 3)对象的属性初始化

                                  # 通常__init__当创建对象的的时候自动调用该方法

                                  # __init__ 完成对象的属性初始化工作

                        B、自定义参数的使用

               __str__(self)

                        直接用print打印对象，会看到创建出来的对象在内存中的地址

                        该方法通常有一个return 语句，返回一个值

               __del__(self)

                        当对象在销毁前，自动调用该方法，（析构方法）

                        析构方法的作用：做一些额外的工作，比如垃圾回收（释放变量）、关闭文件  或文件夹



     def __init___(self)  创建对象的时候自动调用

     def __str___(self)   输出一个对象print(对象)

     def__del__(self)   对象被销毁 自动调用该方法      

105、封装

               将属性和方法放到一起作为一个整体，然后通过实例化一个对象来处理

               隐藏内部的细节，向外界提供操作的功能即可 print()

               将功能代码 进行打个包包，把代码都放到里面 ，给外界提供操作的功能，隐藏内         部的细节 ，你不要管我里面怎么实现的，你拿过来用就可以 了 

106、魔法方法init,都会被子类继承

107、查看类的继承链

                        格式：类名.__mro__

108、多层继承

               class 爷爷类（object）：   基类

               class 爸爸类（爷爷类）：

               class 儿子类（爸爸类）：

109、当父类和子类的方法名相同的情况下，默认使用的是子类中的方法

110、多继承

     子类（父类，父类）

     class child(Father, Mother):

111、多态 类的多态主要是指方法重写

112、静态方法的使用

      @staticmethod

               def 方法名()

113、私有属性 属性前面加了两个下划线是私有属性，否则是共有属性

114、new() 属于一个静态的方法 重写创建一个对象，必须用return返回对象的引用地址

115、使用try…except…捕获异常

116、常见的错误类型

      NameError 命名错误

      IndentationError 缩进错误

      FileNotFoundError 错误的类型：文件没有找到

      io.UnsupportedOperation

      Exception 常规错误基类    

117、Finally在异常中的作用：

     try：

     尝试执行的代码

     ...

     finally

               无论是否发生异常都执行finally