Python笔记

Python学习笔记（完善ing)

极简 ——2021.2.21

The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!

注释

# 单行注释
’’'
’’'
多行注释

变量

直接定义，无需声明类型
type( object )可返回一个变量的类型

运算符

/  按浮点数除，得到的结果为浮点数（准确值）
//  整除，得到商，将余数舍去 (取掉小数点后的值）
**  幂，a**b意为a的b次方
and  布尔与，例 a and b
or  布尔或，例 a or b
not  布尔非，例 not a
in  在指定序列找值，找到返回true，否者false
not in  在指定序列找值，未找到返回 true，否者false
is  判断两个标识符是否引用自一个对象，是返回true，否者false，
x is y  类似 id(x)==id(y)
is not  判断两个标识符是否引用自一个对象，是返回true，否者false
x is not y  类似 id(x)!=id(y)     注：id(x)函数用于获取对象的内存地址

输入

variable=input( ”str“ )  提示用户输入，并将值赋给variable
输入默认按字符串接收

输出

print( “str” )  输出字符串(默认带换行符）
print( “str”, end=“X” )  用X替换默认的换行符

---

print(“str”,“str")  加逗号分隔默认为中间空格输出
print(“str”,“str”,sep=“X”) 用X替换默认的空格

---

print( “XX %d” %variable)  使用占位符占位，用对应类型variable替换占位符
print( “X %d X %d” %(object1, object2) )  有多个占位符号时后用元组(,)

---

常用占位符(不熟悉的)：
%i  有符号十进制整数      %d  无符号十进制整数     %o  八进制整数
%x  十六进制整数(可小大写x)     %e  科学计数法浮点数字(可小大写e)
%f  浮点数字(用小数点符号，小数点后六位)
%g  浮点数字(根据值的大小采用%e或%f)
%p  指针(用十六进制打印值的内存地址)
%n  存储输出字符的数量放进参数列表的下一个变量中(??不是很懂）

判断

if judge1 :
  statement1
elif judge2 :
  statement2
else :
  statement3
注：Python中True和False关键字首字母需要大写

循环

      for
for i in range( 5 ):
  print( i )
遍历 [0, 5)，步进为1
   
for i in range( 0, 10, 3 ) :
  print( i )
遍历 [0, 10)，步进为3
   
name=“str”
for x in name ：
  print( x ,end=" ")
遍历字符串，其他数据结构也同
 
range()函数返回一个可迭代对象

---

      while
i=0
while i <2 :
  i+=1
  print( i )
else :
  print( i )
当 i 满足 i<2 时执行while内语句，否者执行else并退出循环(可以没有else语句）

---

break continue pass
break和continue同其他语言
pass为占位语句，不做事情

字符串

用 ‘ ’ 或 " " 或 ”“” “”“ 或 ’‘’ ‘’‘ 表示
其中 “”“ ”“” 和 ’‘’ ‘’‘ 中可以含回车
字符串是由字符组成的一个不可变序列

---

str1+str2  拼接
str*n  连续打印多次
r"str"  在字符串前加r表示忽略转义 （r在引号外）
 
str[a]  取字符串中索引为a的字符（下标从0开始)
str[a:b]  截取索引为[a,b)的子串
str[a:]  str[:b]  分别为 从a到最后，从第一个到b
str[a: b: l]  范围[a, b)，步长l

---

常用转义字符（不熟悉）：
 
\a  响铃     \b  退格(BackSpace 即删掉一个 )
\n  换行     \r  回车(例a=“123 \r 3”，只会输出 \r 后面的3
\0(反斜杠零)  八进制数，后接的两位为八进制字符，如\012表示换行
\x  十六进制数，后接的两位为字符，如\x0a表示换行

---

常用方法：
str.title()              #以首字母大写的方式显示每个单词（不改变原字符）
str.upper() / str.lower        #全部大写/小写显示（不改变原字符）
str.strip() / str.rstrip() / str.lstrip()    #去除两端/右端/左端空白（不改变原字符）
…

列表(List)

定义：
   list=[1, 1.2, ‘str’]
   list=[ k for k in range(a, b) (if condition) ]      #列表推导式
 
增：
   list.append( object )       #在末尾增加一个元素，当增加的元素为列表时则将列表当作元素（列表的嵌套）
   list1.extend( list2 )        #将list2列表扩展进list1中
   list.insert( index, object )      #插入一个元素在index处，当元素为列表时整个插入（列表的嵌套）
 
删：
   del list[i]             #删除指定元素
   list.pop()             #弹出最后一个元素，返回这个元素，可用变量接收，如 a=list.pop()
   list.remove( object )        #删除指定内容的第一个出现的元素，未找到元素则抛出异常
 
改：
   list[i]=object           #修改指定位置元素
   list.reverse()           #将列表反转（永久的修改了列表）
   list.sort()             #将列表升序排序（永久），仅当元素同为数字（可同含整数和浮点），或同为字符时
   list.sort( reverse=True )       #将列表降序排序（永久）
   list.sorted()            #对列表临时排序，其他同 list.sort()
 
查：
   list [ i ]
   object in list / object not in list      #判断元素是否在列表中，返回 True 或 False
   list.index( object, begin, end )      #在 [begin, end)中寻找object，找到返回下标，未找到抛出异常
   list.count( object )          #返回元素object出现的次数
 
   遍历列表同时取出下标可用函数 enumerate( )：
            for index, value in enumerate( list ):
              print( index, value )
复制：
   list1=list2[ : ]      #创建一个新的列表list1，里面的值和list2相同

---

 可以含多种类型的变量
 可以用负数索引，-1表示最后一个，-2表示倒数第二个
 可以使用切片（同字符串），如 list[a: b:c]等
 可以用 + 拼接， 用 * 重复
 用 len( list )可返回列表长度
 列表嵌套可实现多维列表 ，list[ [ ], [ ], [ ] ]
 可用max( ) min( )方法寻找最值
 可以使用list( ) 强制转换其他类型

元组(Tuple)

定义：
   tuple=(a, )    #只有一个元素时
   tuple=(a, b)    #多个元素
   tuple=( k for k in range(a, b) (if condition) )    #生成器推导式，产生一个生成器对象(不同于列表等)
 
增：
   不能增加，只能通过拼接，即t=t1+t2（连接两个元组，并创建新的元组储存）
 
删：
   del tuple                 #直接删除整个元组，无法操作其中的元素
 
改：
   报错，不允许修改
 
查：
   t [ i ]
   object in tuple / object not in tuple      #判断元素是否在元组中，返回 True 或 False
   tuple.index( object, begin, end )      #在 [begin, end)中寻找object，找到返回下标，未找到抛出异常
   tuple.count( object )           #返回元素object出现的次数

---

 基本类似列表
 元素不能修改，但可以包含可变对象，如list
 定义一个只有一个元素的元组，必须加逗号，即 t=( object, )
 可用max( ) min( )方法寻找最值
 可以使用list( ) 强制转换其他类型

字典（dict)

定义：
   dict={ key1:value1, key2: value2 }
   dict={ key:value for key, value in zip( range(a), range(b) ) if condition }    #字典推导式
 
增：
   dict[ newkey ] = newvalue     #增加新元素到列表末尾
 
删：
   del dict [ key ]          #删除key对应的键值对
   del dict             #删除整个字典对象
   dict.clear( )           #清空字典内的所有元素
   dict.pop( )
 
改：
   dict [key] = newvalue       #通过key修改
 
查：
   dict [key]          #通过key访问，返回对应的value，当key不存在时抛出异常
   dict.get( key )        #通过key访问，返回对应的value，当key不存在时，默认返回 None
   dict.get( key, k )       #通过key访问，返回对应的value，当key不存在时，返回 k
 
   dict.keys( )         #返回所有的key（以列表形式返回）
   dict.values( )         #返回所有的value（以列表形式返回）
   dict.items( )         #返回所有的项（列表），列表中每个 键–值对是一个元组，即[ (key, value), (key, value) ] 
 
   遍历整个字典方法：
          for key, value in dict.items( ):
            print( key, value )
   当遍历的为dict,等价于dict.keys( )，即默认遍历key
          for key in dict :
            print( key )   #遍历的是key
   若直接 for key, value in dict: 会报错

---

 使用键–值储存，键需为不可变类型，且键值唯一
 可用in判断key是否在字典中，即 object in dict，是返回True
 字典合并：dict1.update( dict2 )，将dict2的元素加在dict1后

集合(set)

定义：
   a={1, 2, 3}
   a={ i for i in range(a, b) (if condition) }    #推导式
   a=set( [1, 2, 2, 1] )    #通过set()函数转化列表等,此时会自动去重
运算:
   交集
      set_a & set_b 或 set_a. intersection( set_b )
   并集
      set_a | set_b 或 set_a.union( set_b )
   差集
      set_a - set_b 或 set_a.difference( set_b )
   对称差集( (A-B)+(B-A) )
      set_a ^ set_b 或 set_a.symmetric_difference( B )
   判断A是否为B的子集
      set_a <= set_b 或 set_a.issubset( set_b )
   判断A是否为B的父集
      set_a >= set_b 或 set_a.issuperset( set_b )

---

key不能重复，其他操作基本同列表（update add remove pop clear del）
只保存key，没有value
可用于去重

函数(function)

定义
   def function_name ( ):      #括号内也可带参数
     code
   
   返回多个值时：
          def function_name( ):
            return a, b
   接收方法：variable1, variable2 = function_name( )
 
实参和形参
大部分类似其他语言，区别及注意点有
 
关键字实参
    定义：def function_name( parameter1, parameter2 ):
         …
    调用：function_name( parameter1=a, parameter2=b ）    #也可不使用关键字实参，按顺序传入
 
强制使用关键字实参的函数定义
    def function_name( parameter1=, parameter2= )    #此时只能使用关键字实参传入参数
 
传递列表等数据结构，传递拷贝的方法（不改变原列表）
    浅拷贝（只复制一层，列表内嵌套的列表的引用内的内容不会复制，直接复制引用本身，
    此时可能会改变原嵌套内列表的内容，因为两个引用指向了同一个地址）
      function_name（ list_name[ : ] ）    #way1
      function_name( list_name.copy() )    #way2
      function_name( copy.copy(list_name) )     #way3（需要引入copy)
    深拷贝（递归复制，相当于创建了一个全新的内存，存储复制的数据，与原地址没有关联）
      function_name( copy.deepcopy(list_name) )    #需要引入copy
 
传递任意数量的实参
    定义：def function_name( *parameter ):      #形参名中的星号让Python创建一个名为parameter
                            #的空元组，将接受的值封装在该元组中
          for element in parameter:    #当元组用
            …
    调用：function_name( a, b, …)’
 
传递任意数量的关键字实参
    定义：def function_name( **parameter ):    #形参中的两个星号让Python创建一个名为
                          #parameter的空字典，并接受封装键值对
         for key, value in parameter.items():    #当字典用
    调用：function_name( a=1, b=2 )
 
 
序列解包参数
    当传递的实参为 *parameter 或 **parameter 时，传值时将序列中的元素依次取出，然后赋值
           …
 
lambda表达式
    定义：
        lambda 参数列表 ：表达式
    
    lambda表达式只能包含一个表达式语句，不能包含多条语句，表达式的结果相当于函数的返回值
    可以直接把lambda表达式定义的函数赋值给一个变量，用变量名来表示lambda表达式所创建的匿名函数
    lambda表达式的函数体可以为一个推导式（解析式）
    eg.
        lambda_func = lambda x : x * 2    #定义
        print( lambda_func( 5 ) )    #调用
 
map( )函数
    定义：
        map( func, iterabes )
    用于多次调用某一函数，返回结果为函数运行结果的迭代器
    func表示需要调用的函数(函数或lambda表达式)，iterables表示可迭代对象，即每次叫用时传递的实参
    eg.
        传递一个参数
                result = map(lambda x:x *2, (10, “A”, 12.7 ) )
                print( tuple(result) )      #也可以是list()等
        传递多个参数
                list=[1,2,3]
                tuple=(4,5,6)
                result=map( lambda a, b:a *b, list, tuple )
                print( list(result) )
 
filter( ) 函数
    定义：
         filter(func, iterable)        #函数+迭代对象
    func表示需要调用的函数(函数或lambda表达式)，iterables表示可迭代对象，即每次叫用时传递的实参
    用于过滤可迭代对象中的元素，只保留使得函数调用结果为True或可转化为True的元素，返回符合要求的迭代器
    eg.
        words=[“i”, “love”, “you”]
        rusult=filter(lambda x: len(x)>=5, words)
        print(list(rusult)
 
reduce( )函数
    定义：
             reduce( func,iter [,init] )
       func为一个有两个参数的函数，iter为序列，init为固定初始值，无初始值时从序列的第一个参数开始
    reduce依次从iter中取一个元素，和上一次调用func的结果作参数再次调用func(参数顺序为上次结果在后)
    第一次调用function时，如果提供initial参数，会以seq中的第一个元素和initial作为参数调用function，
    否则会以序列seq中的前两个元素做参数调用function。
 
    eg.
        from functools import reduce
        res=reduce( lambda x,y:x-y, [5,2,1], 8 )
        print( res )
    result: 0
 
函数闭包
    定义：
     在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用
    eg.
      def outer( a ):
        b = 10
        def inner( c ):
          return a+b+c
        return inner
      test=outer( 6 )
      print( test( 5 ) )
    result: 21
    其中a=6, b=10, c=5
 
装饰器
    不好下手，搬个blog吧
    python装饰器，一文秒懂
 
导入
    import module_name      #导入整个模块（原理：打开该包/文件，将其说有的函数复制到该位置）
    from module_name import function1, function2    #导入特定函数（可直接通过函数名调用，此时应注意命名冲突）
    import module_name as mn             #导入模块并取别名
    from module_name import function_name as fn     #导入函数并取别名
    from module_name import *             #导入模块中所有函数

---

 函数中可用 global 声明全局变量，可实现修改全局变量

类

初始化方法
   def _ init _( self ):      #参数self为调用该方法创建实例时自动传入,它是一个指向实例本身的引用(类似于this)
           #self对象由构造方法__new__创建，传递给初始化方法，构造方法若没定义，将使用由父类继承的
   
属性
 
实例属性变量(相当于成员变量（public)）
   def _ init _( self, property1, property2 ):
      self.property1=property1
      self.__property2=property2  # 私有变量
   在构造方法中定义，可通过self赋值初始化
   在一般方法中，对不存在的实例属性变量赋值(self.x=x)，将回为该对象添加一个实例属性变量。注：方法执行了后才会创建
   双下横线打头打头表示私有实例属性变量
   通过 对象名.属性名 访问，也可通过 类名.属性名 (不推荐)
 
类属性变量(相当于静态变量)
   定义：在类中所有方法之外定义
   如果类变量名以两个下画线开始，表示该变量属于私有变量，只允许在这个类的内部调用，在外部无法直接调用。
   通过 类名.属性名 访问
 
装饰器
   把类中的方法“装饰”成属性使用，如需修改成员变量的值，可搭配使用@属性名.setter，删除则用@属性名.deleter
 class Person:
   def __init__(self, age = 18):
     self.__age = age
   @property
   def age(self):    #将age()方法装饰成age属性使用
     return self.__age
 
   @age.setter
   def age(self, new_age):
     if new_age < 1 or new_age > 120:
       print(“年龄范围不对！”)
     else:
       self.__age = new_age
 
   @age.deleter
   def age(self):
     del self.__age
 p = Person(20)
 p.age = 123  #因为age实例变量为私有变量无法直接访问(不是的话会报错?)，这里会直接调用age()方法（装饰成了属性）
 print(p.age)
   结果为：
      年龄范围不对！
      20
 
方法
实例方法
   与函数定义相似，但定义时第一个参数必须为实例对象，参数名通常为self，表示当前调用这个方法的对象
   方法名以两个下画线开始，表示私有方法
类方法
   定义前一般添加@classmethod装饰器，第一个参数必须为类对象，参数通常为cls，表示当前类
   类方法只能访问类变量，不能访问实例变量。
静态方法
   定义前需要添加@staticmethod装饰器，形式上与普通函数无区别
   静态方法只能访问属于类的成员，不能访问属于对象的成员
 
继承
   class Son( Father1， Father2 ):
      def __init __( self, property ):
         super.__ init __()
         self.property=property
   继承后子类获取父类除私有外的所有的属性和方法,可通过super()函数访问父类的属性和方法

---

Python类中的属性和方法都没有访问属性修饰，相当于默认都是public，只有在__的修饰下才表示私有变量
如果类变量名和实例变量名相同，通过“对象名.变量名"访问时，访问的是实例变量。此时只能通过”类名.类变量名“访问
对类属性变量的赋值只能通过”类名.类属性变量名“来执行，对”对象名.类属性变量名“进行赋值，相当于创建了一个同名的实例属性变量
python可以多重继承，使用类的实例对象调用一个方法时，若在子类中未找到，则会在小括号从左到右查找父类中是否包含该方法
可以通过类提供的__bases__属性查看该类的所有字节父类
多重继承的调用顺序：创建子类对象时，会默认按顺序创建所有父类的对象，即调用父类的__new__()方法，但并不会调用所有父类的__init__()方法。若子类未提供__init__方法，会默认调用第一个父类的__init__()方法；若提供了，默认不会调用父类的，此时父类的成员变量无法初始化，通常会在子类的__init__()中，显式调用父类的__init__()方法

文件操作

打开文件：
     open( file_name, pattern )      #返回一个文件流，用于操作，如 f=open(file, w)
 
   常用访问模式(pattern)：
   r  默认模式(即不加参数时使用的模式)，只读，文件存在指针在文件开头，不存在则报错
   w  只写，文件存在则覆盖，不纯在则新建文件写入
   a  追加，文件存在指针在文件末尾，不存在则新建文件写入
   以上三个模式后加 b ,表示以二进制方式读写，其他功能不变即 rb wb ab
 
写入文件：
     f.write( input )      #将input写入文件中
 
读取文件：
     f.read( num )      #从当前指针所指位置读取num个字符，同时将指针后移num个字符，返回读取的字符
     f.read( )        #read中不加参数时读取文件直到文件末尾
     f.readlines( )      #读取整个文件，每一行的字符作为一个元素，返回一个列表
     f.readline( )       #从当前指针所指位置读取，直到遇到换行，同时将指针移至下一行开始，返回一个字符串
 
关闭文件：
     f.close( )
 
      os模块

   需引入os模块，即加 import os
 
重命名：
     os.rename( old_file_name, new_file_name )
删除:
     os.remove( file_name )
创建：
     os.mkdir( file_name )
…etc

错误与异常

   try:
     code
   except ( error_type1, error_type ):      #可同时捕获多个
     code
 
   try:
     code
   except error_type as result:      #获取错误信息
     print( result )
 
     if condition:
         raise 异常实例或异常类("… ")     #使用raise主动抛出异常

---

 基本类似于JAVA，关键字为 try except finally
 可用异常的父类Exception捕获所有异常