一、python教程

1、Python 教程

2、Python 3.10.7 文档

3、Python 3.10 的新特性

4、Python 3 教程

5、Python 3.6.3 中文手册

 

二、Python项目常见的目录结构

1、Python项目代码结构详解

 

三、基础知识

  • 单行注释以 # 开头

    # 第二个注释

     

  • 多行注释可以用多个 # 号,还有 ”’ 和 “””

    '''
    第三注释
    第四注释
    '''
     
    """
    第五注释
    第六注释
    """

     

  • 缩进不一致,执行后会出现错误

  • 使用反斜杠 \ 来实现多行语句;在 [], {}, 或 () 中的多行语句,不需要使用反斜杠 \

    total = item_one + \
            item_two + \
            item_three
    
    total = ['item_one', 'item_two', 'item_three',
            'item_four', 'item_five']

     

  • 字符串(String) 

    • Python 中单引号 ‘ 和双引号 ” 使用完全相同。

    • 使用三引号(”’ 或 “””)可以指定一个多行字符串。

      param = """这是一个段落,
      可以由多行组成"""
      print(param)
      
      运行结果:
      这是一个段落,
      可以由多行组成
      
      
    • 反斜杠可以用来转义,使用 r 可以让反斜杠不发生转义。 如 r”this is a line with \n” 则 \n 会显示,并不是换行。

    • 字符串可以用 + 运算符连接在一起,用 * 运算符重复。

      print(str * 2)             # 输出字符串两次
      
      
    • Python 中的字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始。

    • 字符串的截取的语法格式如下:变量[头下标:尾下标:步长],不包含尾下标。

      def reverseWords(input):
           
          # 通过空格将字符串分隔符,把各个单词分隔为列表
          inputWords = input.split(" ")
       
          # 翻转字符串
          # 假设列表 list = [1,2,3,4],  
          # list[0]=1, list[1]=2 ,而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
          # inputWords[-1::-1] 有三个参数
          # 第一个参数 -1 表示最后一个元素
          # 第二个参数为空,表示移动到列表末尾
          # 第三个参数为步长,-1 表示逆向
          inputWords=inputWords[-1::-1]
       
          # 重新组合字符串
          output = ' '.join(inputWords)
           
          return output
       
      if __name__ == "__main__":
          input = 'I like runoob'
          rw = reverseWords(input)
          print(rw)

       

  • 在同一行中使用多条语句,语句之间使用分号 ; 分割

    import sys; x = 'runoob'; sys.stdout.write(x + '\n')

     

  • 缩进相同的一组语句构成一个代码块,我们称之代码组。像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。

  • print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=””:

    # 换行输出
    print( x )
    # 不换行输出
    print( x, end=" " )

 

  • 将整个模块(somemodule)导入,格式为: import somemodule

  • 从某个模块中导入某个函数,格式为: from somemodule import somefunction

  • 从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc

  • 将某个模块中的全部函数导入,格式为: from somemodule import *

  • Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。在 Python 中,变量就是变量,它没有类型,我们所说的”类型”是变量所指的内存中对象的类型。

  • 允许同时为多个变量赋值
    a = b = c = 1
    a, b, c = 1, 2, "runoob" #两个整型对象 12 的分配给变量 a 和 b,字符串对象 "runoob" 分配给变量 c

     

  • 内置的 type() 函数可以用来查询变量所指的对象类型,此外还可以用 isinstance 来判断。type()不会认为子类是一种父类类型,isinstance ()会认为子类是一种父类类型
  • bool 是 int 的子类,True 和 False 可以和数字相加, True==1、False==0 会返回 True

  • 索引值以 0 为开始值,-1 为从末尾的开始位置。

 

 

  • 元组写在小括号 () 里,元素之间用逗号隔开。元组中的元素类型也可以不相同
    tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )

 

  • 虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表

  • 构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:
    tup1 = ()    # 空元组
    tup2 = (20,) # 一个元素,需要在元素后添加逗号
  • 可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
    parame = {value01,value02,...}
    或者
    set(value)
  • 字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(key) : 值(value) 的集合

  • list推导式:从一个数据序列构建另一个新的数据序列的结构体

    格式:结果值1 if 判断条件 else 结果2  for 变量名 in 原列表
    
    示例:
    list1 = ['python', 'test1', 'test2']
    list2 = [word.title() if word.startswith('p') else word.upper() for word in list1]
    print(list2)
    
    运行结果:
    ['Python', 'TEST1', 'TEST2']
  • 字典推导基本格式
    格式:
    { key_expr: value_expr for value in collection }
    或
    { key_expr: value_expr for value in collection if condition }
    
    示例:
    listdemo = ['Google','Runoob', 'Taobao']
    # 将列表中各字符串值为键,各字符串的长度为值,组成键值对
    newdict = {key:len(key) for key in listdemo}
    print(newdict)

     

  • 集合推导式
    格式:
    { expression for item in Sequence }
    或
    { expression for item in Sequence if conditional }
    
    示例:
    setnew={i**2 for i in(1,2,3)}
    print(setnew)

     

  • 元组推导式
    格式:
    (expression for item in Sequence )
    或
    (expression for item in Sequence if conditional )
    
    示例:
    print(tuple((x*2 for x in (1,10))))

     

  • r”” 的作用是去除转义字符,以f开头表示在字符串内支持大括号内的python表达式,b” “前缀表示:后面字符串是bytes 类型。

  • 除法
    a,b,c=21,10,0
    print(a/b)
    结果:2.1

     

  • 取模
    a,b,c=21,10,0
    c = a % b
    print ("返回除法的余数:", c)
    结果:1

     

  • a,b = 2,3
    print ("幂-返回a的b次幂:",  a**b )
    
    结果:8

     

  • 取整除 – 向下取接近商的整数
    a,b = 10,4
    print ("取整除 - 向下取接近商的整数:", a//b )
    
    结果:2

     

  • 数字类型转换
    int(x) 将x转换为一个整数。
    
    float(x) 将x转换到一个浮点数。
    
    complex(x) 将x转换到一个复数,实数部分为 x,虚数部分为 0。
    
    complex(x, y) 将 x 和 y 转换到一个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。
  • if语句格式
    if condition_1:
        statement_block_1
    elif condition_2:
        statement_block_2
    else:
        statement_block_3

     

  • while循环
    while 判断条件(condition):
        执行语句(statements)……

     

  • while 循环使用 else 语句

    格式:
    while <expr>:
        <statement(s)>
    else:
        <additional_statement(s)>
    
    示例:
    count = 0
    while count < 5:
       print (count, " 小于 5")
       count = count + 1
    else:
       print (count, " 大于或等于 5")

     

  • for循环
    格式:
    for <variable> in <sequence>:
        <statements>
    else:
        <statements>
    
    示例:
    sites = ["Baidu", "Google","Runoob","Taobao"]
    for site in sites:
        if site == "Runoob":
            print("菜鸟教程!")
            break
        print("循环数据 {site}")
    else:
        print("没有循环数据!")
    print("完成循环!")

     

  • range()函数:可以生成数列

    for i in range(5):
        print(i)
    结果:
    0
    1
    2
    3
    4
    
    
    for i in range(5,9) :
        print(i) 
    结果:    
    5
    6
    7
    8
    
    
    for i in range(0, 10, 3) :
        print(i)
    结果:    
    0
    3
    6
    9
    
    
    for i in range(-10, -100, -30) :
        print(i)
     结果:    
    -10
    -40
    -70

     

  • 函数
    def 函数名(参数列表):
        函数体

     

  • 列表可以修改,而字符串和元组不能
  • 异常处理

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话,无论异常是否发生都会执行。')

 

  • Python 使用 raise 语句抛出一个指定的异常。
    raise [Exception [, args [, traceback]]]
  • 类的私有属性:__private_attrs:两个下划线开头,声明该属性为私有,不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

  • 类的方法:在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同,类方法必须包含参数 self,且为第一个参数,self 代表的是类的实例。self 的名字并不是规定死的,也可以使用 this,但是最好还是按照约定使用 self。

  • 类的私有方法:__private_method:两个下划线开头,声明该方法为私有方法,只能在类的内部调用 ,不能在类的外部调用。self.__private_methods
  • 类的专有方法

    __init__ : 构造函数,在生成对象时调用
    __del__ : 析构函数,释放对象时使用
    __repr__ : 打印,转换
    __setitem__ : 按照索引赋值
    __getitem__: 按照索引获取值
    __len__: 获得长度
    __cmp__: 比较运算
    __call__: 函数调用
    __add__: 加运算
    __sub__: 减运算
    __mul__: 乘运算
    __truediv__: 除运算
    __mod__: 求余运算
    __pow__: 乘方

     

  • super() 函数是用于调用父类(超类)的一个方法。
    class Parent:        # 定义父类
       def myMethod(self):
          print ('调用父类方法')
     
    class Child(Parent): # 定义子类
       def myMethod(self):
          print ('调用子类方法')
     
    c = Child()          # 子类实例
    c.myMethod()         # 子类调用重写方法
    super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

     

  • 子类父类
    • 情况一:子类需要自动调用父类的方法:子类不重写__init__()方法,实例化子类后,会自动调用父类的__init__()的方法。

    • 情况二:子类不需要自动调用父类的方法:子类重写__init__()方法,实例化子类后,将不会自动调用父类的__init__()的方法。

    • 情况三:子类重写__init__()方法又需要调用父类的方法:使用super关键词:

      super(子类,self).__init__(参数1,参数2,....)
      class Son(Father):
        def __init__(self, name):   
          super(Son, self).__init__(name)

       

  • 多继承
    格式:
    class DerivedClassName(Base1, Base2, Base3):
        <statement-1>
        .
        .
        .
        <statement-N>

    需要注意圆括号中父类的顺序,若是父类中有相同的方法名,而在子类使用时未指定,python从左至右搜索 即方法在子类中未找到时,从左到右查找父类中是否包含方法。

  • 继承
    class DerivedClassName(BaseClassName):
        <statement-1>
        .
        .
        .
        <statement-N>

    子类(派生类 DerivedClassName)会继承父类(基类 BaseClassName)的属性和方法。BaseClassName(实例中的基类名)必须与派生类定义在一个作用域内。除了类,还可以用表达式,基类定义在另一个模块中时这一点非常有用

  • 当内部作用域想修改外部作用域的变量时,就要用到 global 和 nonlocal 关键字了。
    num = 1
    def fun1():
        global num  # 需要使用 global 关键字声明
        print(num) 
        num = 123
        print(num)
    fun1()
    print(num)

    如果要修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量则需要 nonlocal 关键字了,如下实例:

    def outer():
        num = 10
        def inner():
            nonlocal num   # nonlocal关键字声明
            num = 100
            print(num)
        inner()
        print(num)
    outer()

     

  • python中,函数内不能直接引用函数外的局部变量,可以通过global

 

版权声明:本文为搬砖滴原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/qtiger/p/16802017.html