python要点

python学习要点

注：本笔记为学习“冰冷的希望”博主python基础知识所记，仅用作学习记录。

一、字符串

1. 字符串索引左闭右开

   str[2:5],str的第3到第4个字符串

2. 字符串查找，.find（’ '）

3. 拼接字符串：字符串可以加、乘，不能除和减

   print('abc'+'123') #输出：abc123
   print('*'*600) #输出：600个*
   

   字符串.join

   str_a = ','
   str_b = str_a.join('123456')
   print(str_b) #输出：1，2，3，4，5，6
   

4. name = 'monsterholve'
   age = 30
   print('我是{}，今年{}岁'.format(name, age))
   print('我是%s,今年%d岁' % (name, age))
   print(f'我是{name},今年{age}岁') #python3.6以上版本支持
   

5. 常用方法

   

二、数据类型与常用内置函数

1. 数据类型

   

2. 常用内置函数

三、列表

1. 定义方法

   my_list = list()
   my_list = ['monsterholve', 5, 52, ['lkjsd2'],'hkjsh']
   

   注：列表类型可以容纳包含其他所有类型数据，其中的[‘lkjsd2’]作为my_list的一个元素

2. 元素操作

   • 增加元素，append、insert、extend

     • append：增加一个元素到列表末尾
     • insert：在指定位置前面插入一个元素
     • extend：在列表末尾扩展一个新的列表

     my_list.append('123') #输出：['monsterholve', 5, 52, ['lkjsd2'],'hkjsh', '123']
     my_list.insert(3, '456') #输出：['monsterholve', 5, 52, '456', ['lkjsd2'],'hkjsh', '123']
     my_list.extend(['12222', 'sfkjh']) # 输出：['monsterholve', 5, 52, '456', ['lkjsd2'], 'hkjsh', '123', '12222', 'sfkjh']
     

     注：列表中可以存在重复元素

   • 删除元素，pop、remove、del

     • pop：删除指定位置的元素，如果不指定index，默认删除列表末尾元素
     • remove：直接删除元素值
     • del：针对列表操作，可以删除列表索引元素，没有索引默认删除整个表

     my_list.pop(4) # 输出：['monsterholve', 5, 52, '456', 'hkjsh', '123', '12222', 'sfkjh']
     my_list.remove(52)# 输出：['monsterholve', 5, '456', ['lkjsd2'], 'hkjsh', '123', '12222', 'sfkjh']
     del my_list #删除整个列表
     del my_list[1] #输出：['monsterholve', 52, '456', ['lkjsd2', 'dff'], 'hkjsh', '123', '12222', 'sfkjh']
     

     注：pop和del的操作对象不同，pop是操作列表元素，del是对列表操作

   • 修改元素，下标修改

     my_list[1] = 66
     

   • 查询元素，切片，index、max、min

     print(my_list[:-1]) # 输出：['monsterholve', 52, '456', ['lkjsd2'], 'hkjsh', '123', '12222']   打印列表第一个到倒数第二个。
     print(my_list.count(52)) # 输出：1   .count(52)返回列表中52这个元素出现的次数
     

     • max：返回列表中元素的最大值 （针对只包含同一种元素的列表，如整数和字符串无法比较大小）

     • min：返回列表中元素的最小值

       my_list = [1, 2, 3, 4, 5]
       print(max(my_list)) # 5
       print(min(my_list)) # 1
       a=1
       b=4
       print(max(my_list[a:b])) # 4
       

   • 统计

     （1）list.count( obj )
     返回某个元素在列表中出现的次数
     （2）len( list )
     返回列表的长度（有多少个元素）

3. 列表推导式

   my_list1 = [i for i in range(0,10) if i % 2 == 0] #生成在0-9范围内能被2整除的数
   

四、元组

元组（Tuple）与列表（List）非常像，不过列表用方括号[ ]表示，元组用圆括号( )表示。元组与列表最大的区别就是：元组里的元素不能被更改！！！
也就是说，元组不能增、删、改，只能查。查询操作跟列表一样

注：如果元组中只有一个元素，为避免优先级误解，需要加逗号，即

aa = tuple()
aa = (2,)
aa = (2, 3, 5)

五、字典

字典（Dictionary）是用花括号{ }表示的，里面的元素由键、值两部分组成，称为键值对。

1. 定义

   键+值

   my_dict = dict()
   my_dict = {'k0': 'v0'}
   

2. 字典操作

   • 增加元素

     • 直接通过索引增加
     • .update（），如果原字典中有这个键，则更新键对应的值，如果没有，则增加该键和对应值
     • .setdefault()，设置默认值，如果原字典中没有这个键，则新增该键，并设置默认值，如果有这个键，则不起作用，不改变原键和值。

     my_dict['k1'] = 'v1'
     my_dict.update({'k2': 'v2'})
     my_dict.setdefault('k2', 'v3') # 字典内容不变
     my_dict.setdefault('k3', 'v3')
     

   • 删除元素

     • del，可删除整个字典或删除指定键值 (注：del删除只需要指定键，不能含有值)
     • .pop(‘key’, ‘value’)，删除指定的键和值，若不指定值，如果字典中没有该键，则会报错，若指定了键和值，则即使不存在也不会报错（可理解为将其写入有删除了）
     • .popitem()，删除字典的最后一项键和值（注：popitem（）不带参数，加参数会报错）

   • 修改元素 (同列表修改前两项)

     • 直接通过索引增加
     • .update（），如果原字典中有这个键，则更新键对应的值，如果没有，则增加该键和对应值

   • 查询元素

     print(my_dict['k1'])
     print(my_dict.get('k55', 'v555')) # 若key不存在，则返回给定的值（如v555），若key不存在且没有给定值，则返回None
     print(my_dict.kays()) # 输出所有键
     print(my_dict.values()) # 输出所有值
     print(my_dict.items()) # 输出字典所有键-值
     

六、集合

集合（Set）是一种复合类型，用花括号{ }表示，无序（写入元素后会随机排序）并唯一地存放容器元素的类型。集合有点像字典，用set()方法创建，但集合却只有键没有值，并且键不能重复并且无序。集合有并、差、交、补、判断子集等操作。

my_list = list()
my_list = ['dafsadf', 1, 45, 1]
my_set = set(my_list) # {1, 45, 'dafsadf'} （这一顺序是随机产生的 多次输出顺序不定）
my_set2 = {4, 6, 9, 1}
my_set3 = my_set ^ my_set2 # 补 {4, 6, 9, 45, 'dafsadf'}
my_set3 = my_set | my_set2 # 并 {1, 4, 6, 'dafsadf', 9, 45}
my_set3 = my_set & my_set2 # 交 {1}
my_set3 = my_set - my_set2 # 差 {'dafsadf', 45}
my_set3 = my_set2 - my_set # 差 {9, 4, 6}
print(my_set <= my_set2) # 判断是否子集 False

my_set3.update([5555, 3333]) # 注意：直接输入数字报错，update更新的必须是一个可跌倒对象（Iterable）,如序列类型的list、str、tuple，映类型的dict，以及其他类型可迭代对象（具体可百度）
my_set3.update("4444", 'ffff', 'father') # {4, 3333, 6, 'e', 'r', 'h', '4', 5555, 'a', 'f', 't'} update更新字符串时，将其拆成一个一个的字符并且去重后，作为子集与已有集合合并
my_set3.add(3) # {'f', 'r', 3, 4, 3333, 6, 'a', 9, 5555, '4', 't', 'h', 'e'}
my_set3.remove(3333) # {'e', 3, 4, 6, 'f', 9, 'r', '4', 5555, 't', 'a', 'h'}
my_set3.pop() # {3, 4, 6, '4', 9, 't', 'r', 5555, 'f', 'a', 'e'} 删除集合中的第一个元素（这个元素是随机的，如上一个集合中'h'成为了第一个元素，并被删除）

---

小结（列表、元组、字典、集合对比）

---

七、运算符

1. 算数运算符

   

2. 比较运算符

   

   注：<>是python2版本中的表达。

3. 赋值运算符

   用“=”表示，此外还有+=、-=、*=、/=等赋值方式。例：a = a + 1等价于a += 1。

4. 逻辑运算符

   and、or、not三种。对应且、或、非（取反）。

   print(5>4) # Ture
   print(not 5>4) # False
   

5. 成员运算符

   成员运算符判断某个值是否在字符串、列表等对象中，只有 in 和 not in 两种。

6. 身份运算符

   身份运算符用于比较两个对象的存储单元，只有 is 和 is not 两种。

   **注意：**is 和 == 不一样，前者判断两个变量id是否相同，后者值判断两个变量的值是否相等。

   x = 100
   y = 100
   print(x == y)  # 输出：True
   print(x is y)  # 输出：True
   print(id(x), id(y))  # 输出：2578683661648 2578683661648
   
   x = [1, 2, 3]
   y = [1, 2, 3]
   print(x == y)  # 输出：True
   print(x is y)  # 输出：False
   print(id(x), id(y))  # 输出：2578685027776 2578684997696
   

八、循环

1. 九九乘法表打印

   for i in range(1, 10):
       for j in range(1, i + 1):
           print('%d x %d = %-2d' % (j, i, j * i), end='  ') # %d标识整数，2d表示两位整数，当整数位数不够时在左侧补空格，-2d表示当整数位数不够2位时在右侧补空格
           # print('{} * {} = {}'.format(j, i, i * j), end='     ' if 3 <= i <= 4 and j == 2 else '    ')
           # print('{} * {} = {}'.format(j, i, i * j), end='     ' if i in range(3, 5) and j == 2 else '    ')
       print()
   

九、函数

1. 定义函数时：def 函数名(形参):

   def 函数名(参数):
   	#（注意缩进）
       函数体
       return 返回值
   

2. 调用函数时：函数名(实参)

3. 参数

   

   上述参数*args、*kwargs用法举例

   def info(name, *args, **kwargs):
       print("name:", name)
       print("args:", args)
       print("kwargs:", kwargs)
   
   info("pan", 18, "男", height=170, city="广西")
   
   # 打印输出：
   # name: pan
   # args: (18, '男')
   # kwargs: {'height': 170, 'city': '广西'}
   

4. 返回值

   若执行完一个函数得到一个值（也可以是其他），可以将其返回。比如说定义一个加法函数，计算完之后返回计算结果，并把结果赋值给一个变量。返回值可以是变量、确定的值、列表等，还可以是一个函数，比如说返回函数本身，实现阶乘。

   注意
   1）如果不指定返回值，即不写return，则会默认返回一个None
   2）return后面的语句不会再执行
   3）函数可以嵌套调用，即函数里可以再调用其他函数

5. 全局变量与局部变量

   # 定义全局变量
   num = 200
   def test():
       # global num 告诉解释器，函数内部使用的num就是外面的全局变量num
       global num
       num = 250  # 修改全局变量
       print('inner num=', num, id(num))
   
   test()  # 函数调用
   print('outer num=', num, id(num))
   
   def func_outer():
       count = 0
       def func_inner():
           nonlocal count
           count += 1
           return count
       return func_inner
   

6. 匿名函数

   如果你的函数的功能很简单，那就没必要那么麻烦定义一个函数了，可以直接使用lambda定义一个匿名函数。

   lambda [形参1], [形参2], ... : [单行表达式] 或 [函数调用]
   

   # 普通函数方式
   def add(a, b):
       return a + b
   
   print(add(10, 20))
   
   # lambda方式
   add = lambda a, b: a + b
   print(add(10, 20))
   

   注意
   1）匿名函数只能实现简单的逻辑，不能使用循环、分支等语法
   2）匿名函数不需要return，会自动返回表达式的结果

十、类

类（Class）是用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

1. 构造方法

   构造方法在创建类对象的时候，会自动执行，并将传入参数自动传递给init方法使用。

   class Person:  # 类名一般习惯首字母大写
       def __init__(self, name, age): # 相比一版函数，多了self参数，后面的位置参数根据需要设置
       self.name = name
       self.age = age
   

2. 内置方法（魔法方法）

   构造方法（init）也是内置方法。除了__init__方法，还有其他一些以双下划线开头和结尾的方法，都属于内置的专有方法,如：

   __init__ : 构造函数，在生成对象时调用
   __del__ : 析构函数，释放对象时使用
   __repr__ : 打印，转换
   __setitem__ : 按照索引赋值
   __getitem__: 按照索引获取值
   __len__: 获得长度
   __cmp__: 比较运算
   __call__: 函数调用
   __add__: 加运算
   __sub__: 减运算
   __mul__: 乘运算
   __truediv__: 除运算
   __mod__: 求余运算
   __pow__: 乘方
   __slots__：可以指定类的参数，指定后超出的参数无法传入，会报错
   

3. 私有方法和私有属性

   在一个类里定义属性（变量）或者方法的时候，若以双下划线开头，声明是私有属性或方法，不能在类的外部被使用或直接访问。

4. 继承

   可以用A类继承于B类，这样B类所具有的属性和方法A类也有，比如说student类继承于human类，则human的name、age、say()等内容student类不用自己定义就有了，而且还能重写父类的方法。

   class human: # 定义一个类
       def __init__(self, name="someone", age=20):
           self.name = name  # 类属性name
           self.age = age # 类属性age
       def say(self): # 类方法，所有的类方法都至少有一个参数self
           print("hello")
       def think(self,a=1,b=2):
           print(a+b)
   
   class student(human):  # 继承语法 class 类名 （父类）：
       def __init__(self, school="sxu", major="chem"): # 初始化类student
           super().__init__("pan", 25) # 调用父类human的初始化方法
           self.school = school
           self.major = major
       def think(self,a=1,b=2): # 重写think()方法，父类用加法，这里用乘法
           print(a*b)
   
   stu = student() # 实例化类得到对象stu
   print(stu.name) # stu也有父类的name属性
   print(stu.school)
   print(stu.major)
   stu.major = "python" # 修改major属性
   print(stu.major)
   stu.think(2, 3)
   

   • **多继承：**一个类可以继承多个父类。（如果父类有同名方法或属性，先继承的优先级高于后继承的）

   class 类名 （父类1，父类2，...）:
       类内容体     # （如果没有新内容，用pass代替）
   

   • 复写父类属性和方法

     直接将父类中的属性和方法重写一次即可。

   • 调用父类重名成员

     方式1：父类名.成员变量/父类名.成员方法(self)

     方式2：super().成员变量/super().成员方法 ()

5. 多态

   指的是：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态。（同样的行为（函数），传入不同的对象，得到不同的状态）。

   堕胎常作用在继承关系上：以父类做定义声明，以子类做实际工作，用以获得同一行为，不同状态。

6. 类方法与静态方法

   • 类属性：直接在类内容体中输入不带’self.'的变量即为类的属性。

   • 类方法：用装饰器@classmethod装饰方法，用cls代替self。

   • 静态方法：如果不需要传实例或类时，可以直接定义为静态方法，用@staticmethod装饰

     class Person(object):
         count = 0  # 类属性
         def __init__(self, name):
             self.name = name
             Person.count += 1
         @classmethod      # 类方法
         def say(cls):
             print('我被实例化{}次'.format(cls.count))
         @staticmethod   # 静态方法
         def read():
             print('我在阅读')
     

---

Tips:捕获异常、主动抛异常、调试程序

1. 捕获异常

   try:
       print('尝试执行代码')
       1/0
   except Exception as e:
       print('捕获到异常：{}'.format(e))
   else:
       print('没有异常')
   finally:
       print('都会执行')
   

2. 主动抛异常

3. 调试程序

---

十一、文件处理

1. 文件读写

   • 写入

     使用open()函数打开一个文件，write()函数写入内容，最后使用close()函数关闭已打开的文件。

     推荐with open()这种写法，比较简洁，而且避免了因为出错或其他原因导致不能close()文件的情况。

     text = "this is a text"
     with open("test.txt", "w", encoding="utf-8") as f:
         f.write()
     

     关于open()函数的三个参数

     （1）文件名。可以指定绝对路径，若不写路径则保存在该.py文件所在目录
     （2）操作模式。操作模式有很多，常用的有w、a、r、wb、rb等

     操作模式	说明
     w	打开一个文件只用于写入。如果该文件已经存在则打开文件，原有内容会被删除。如果该文件不存在，创建新文件
     a	打开一个文件用于追加。如果该文件已经存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件
     r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式
     +	打开一个文件进行更新（可读可写）
     wb	以二进制格式打开一个文件用于写入。一般用于非文本文件，如图片等
     rb	以二进制格式打开一个文件用于只读。一般用于非文本文件，如图片等
     w、r可分别与b、+进行组合

     （3）编码。常用编码有utf-8、gbk等，编码问题可以会导致乱码。

   • 读取

     with open("test.txt", "r", encoding="utf-8") as f:
         print(f.read())
     

     关于读取内容的方式：

     1、f.read()，一次性读取所有内容，若文件很大可能会导致内存不够用，故可以指定一个参数（每次读写的大小），比如说f.read(1024)
     2、f.readline()，只能读取一行
     3、f.readlines()，读取所有行，返回一个列表

     with open("test.txt", "r", encoding="utf-8") as f:
         #print(f.readlines())
         for line in f.readlines(): # 遍历列表
             print(line)
     

2. 上下文管理器

   可以避免文件打开后忘记关掉的情况，上下文管理器会自动将文件关闭：当使用with语句时，会调用上文方法__enter__()，with语句结束时会自动调用下文方法__exit__()进行关闭。

   class OptFile(object):
       def __init__(self, path, mode, encoding):
           self.path = path
           self.mode = mode
           self.encoding = encoding
   
       def __enter__(self):  # 调用上文方法
           self.f = open(self.path, self.mode, encoding=self.encoding)
           return self.f
   
       def __exit__(self, exc_type, exc_val, exc_tb): #调用下文方法
           if exc_type:
               print("exc_type:", exc_type)
               print("exc_val:", exc_val)
               print("exc_tb:", exc_tb)
           print("OptFile closed")
           self.f.close()
           return True
   
       def read_file(self, length=None):
           # 1 / 0  # 故意制造错误
           return self.f.read(length)
   
   with OptFile(r"C:\Users\admin\Desktop\kspc.txt", "r", "utf-8") as f:
       print(f.read_file())
   

3. JSON和CSV

   参考冰冷的希望的博客内容：JSON和CSV

4. OS模块

   os是python的内置模块，用于查看或操作硬盘的文件以及文件夹。

   

   递归获取某个文件夹里所有文件：

   import os
   def listdir(path, to_save_list: list):
       if not os.path.exists(path):
           return
       for file in os.listdir(path):
           file_path = os.path.join(path, file)
           if os.path.isdir(file_path):
               listdir(file_path, to_save_list)
           else:
               to_save_list.append(file_path)
   if __name__ == '__main__':
       dir_path = r"C:\Users\admin\Desktop"
       my_file_list = list()
       listdir(dir_path, my_file_list)
       for f in my_file_list:
           print(f)