01_python基础语法

python基础语法

一.基本数据类型

  • Number:数字

  • int: 整数

  • float: 浮点数

  • '2/2’得到的是一个浮点类型的结果,'2//2’得到的则是一个整型的结果;例如:

    1/2=0.5
    1//2=0
    
  • bool: 布尔类型,表示真(True)和假(False),布尔类型属于数字,可以通过int(True)和int(False)将布尔类型转化为数字,也可以通过bool方法将数字转换为bool类型,例如:

    int(True)=1 
    int(False)=0 
    bool(10)=True 
    bool(1.3)=True
    bool(0)=False
    
  • bool方法还可以用做非空判断:

    bool('abc')=True 
    bool('')=False
    bool([1,2,3])=True 
    bool([])=False
    bool({1,1,1})=True 
    bool({})=False
    bool(None)=False
    
  • complex: 复数

  • str:字符串,可以使用单引号,双引号和三引号表示字符串

  • 获取一个字符的ascii码值:

    ord("a")=97
    
  • 多行字符串:使用三引号定义多行字符串

  • 原始字符串:r’str’,原始字符串不会去识别转义字符,而是将其原样去输出

  • 字符串运算:

    • +:把两个字符串拼接起来

    • *:例如’hello’*3,表示把’hello’这个字符串重复3次

    • 访问字符串中的任意一个字符:例如

      'hello'[1]='e','hello'[-1]='o'
      
    • 截取字符串的字串:例如:

      'hello'[0:4]='hell'
      'hello'[0:-1]='hell'
      'hello'[1:]='ello'
      'hello'[-3:]='llo'
      
  • 列表:类似java中的数组,不同的是,在python中,列表中的每一个元素可以是任意的数据类型

  • 列表的基本操作:

    • 访问列表中的元素:例如

      ["a", "b", "c", "d", "e", "f"][1]="b"
      
    • 截取子列表:例如:

      ["a", "b", "c", "d", "e", "f"][0:3]=['a', 'b', 'c'],
      ["a", "b", "c", "d", "e", "f"][0:-4]=['a', 'b'],
      ["a", "b", "c", "d", "e", "f"][3:]=['d', 'e', 'f'],
      ["a", "b", "c", "d", "e", "f"][-4:]=['c', 'd', 'e', 'f'],
      
    • 将两个列表拼接成一个新的列表:

      ["a", "b", "c", "d"] + ["e", "f"] = ['a', 'b', 'c', 'd', 'e', 'f']
      
    • 将列表中的所有元素按顺序重复3次:

      ["a", "b"]*3=['a', 'b', 'a', 'b', 'a', 'b']
      
  • 元组:(1,2,3,True,False)

  • 元组的基本操作:与列表类似

  • 定义只有一个元素的元组:

    (1)会被运算为1,所以应写成(1,)
    
  • 字符串、列表、元组都属于序列,其中字符串和元组属于不可变类型

    • 判断一个元素是否在序列中:使用’in’或者’not in’关键字,例如:

      2 in [1,2,3]=True
      2 not in [1,2,3]=False
      
    • 计算一个序列内部包含多少个字元素:使用len方法,例如:

      len([1,2,3])=3
      
    • 序列解包:

      a = (0,1,2)
      b, c, d = a
      print(b, c, d)
      
    • 计算一个序列中最大的元素:使用max方法

      max([1,2,3,4])=4
      
    • 计算一个序列中最小的元素:使用min方法

      min([1,2,3,4])=1
      
  • 集合:例如{1,2,3,4,5}

    • 集合是无序的

    • 集合没有索引

    • 集合不能进行切片操作[0:5]

    • 集合中的元素是不重复的,例如

      {1,1,2,2,3,3,4,4}={1,2,3,4}   
      
    • 集合同样支持len方法、‘in’、'not in’关键字

    • 剔除集合中的元素(补集):

      {1,2,3,4,5,6} - {3,4} = {1,2,5,6}
      
    • 找出两个集合中共同的元素(交集):

      {1,2,3,4,5,6} & {3,4} = {3,4}
      
    • 将两个集合拼接,并去除重复(合集):

      {1,2,3,4,5,6} | {3,4,7} = {1,2,3,4,5,6,7}
      
    • 定义一个空的集合:

      set()
      
  • 字典:很多个key:value组成的集合,{key1:value1, key2:value2},其中key必须使用不可变类型

  • 遍历字典:

    d = {'one':1, 'two':2, 'three':3, 'four':4}
    
    for key in d:
        print(key)
    
    print('--------------------')
    
    for item in d.items():
        print(item)
    
    print('--------------------')
    
    for key, value in d.items():
        print(key,':',value)
    
    

二.进制的表示与转换

  • 二进制的表示:python中表示二进制只需在数字前面加’0b’即可,例如:

    '0b10'表示二进制的10
    
  • 八进制的表示:python中表示八进制只需在数字前面加’0o’即可,例如:

    '0o10'表示八进制的10
    
  • 十六进制的表示:python中表示十六进制只需在数字前面加’0x’即可,例如:

    '0x10'表示十六进制的10
    
  • 将其他进制的数转化为二进制:使用bin方法,例如:

    'bin(10)='0b1010',即将十进制的10转化为二进制'
    
  • 将其他进制的数转化为十进制:使用int方法,例如:

    'int(0b111)=7, 即将二进制的111转化为十进制'
    
  • 将其他进制的数转为十六进制:使用hex方法,例如:

    'hex(888)='0x378', 即将十进制的888转化为十六进制'
    
  • 将其他进制的数转为八机制:使用oct方法,例如:

    'oct(0x777)='0o3567', 即将十六进制的777转化为八进制'
    

三.变量与运算符

  • 定义一个变量:

    A = [1,2,3,4,5,6]
    
  • 变量的命名规则:

    • 不能以字母、数字、下划线开头
    • 系统关键字不能用在变量命名中
    • 运算符不能用在变量命名中
  • 可变与不可变:

    • 不可变:在python中,不可变是指要改变一个变量的值,必须重新创建一个新的出来
    • 可变:在python中,可变是指不需要重新创建一个新的,就能改变变量的值
  • 值类型和引用类型:

    • 值类型:int、str、tuple,不可改变
    • 引用类型: list、set、dict,可改变
  • 算术运算符:

    • ‘+’、‘-’、‘*’、‘/’
    • ‘//’:取整
    • ‘%’:取余数
    • ‘**’:平方
  • 赋值运算符:

    • ‘=’
    • ‘+=’、‘*=’、‘/=’、‘%=’、‘**=’、‘//=’:先运算,再赋值,例如:c += 1 等价于 c = c + 1
  • 关系运算符:

    • ‘==’、‘!=’、‘>’、‘<’、‘>=’、‘<=’,关系运算符的返回结果为bool类型,不只是数字才能做比较运算
  • 逻辑运算符:

    • ‘and’、‘or’、‘not’,逻辑运算符操作的是bool类型,返回的也是bool类型
    • 对于int、float,0被认为是False,非0被认为是True
    • 对于字符串,空字符串被认为是False,非空会被认为是True
  • 成员运算符:

    • ‘in’:一个元素是否在一组元素里
    • ‘not in’:一个元素是否不在一组元素里
    • 字典的成员运算:字典的成员运算是针对key来做运算的
  • 身份运算符:

    • ‘is’、‘is not’:比较两个变量的内存地址是否相等
  • 判断变量的类型

    • 使用isinstance方法来判断,例如:

      a = 1, isinstance(a, int) = True
      
  • 位运算符:把数字当作二进制进行运算

    • ‘&’:按位与
    • ‘|’:按位或
    • ‘^’:按位异或
    • ‘~’:按位取反
    • ‘<<’:左移
    • ‘>>’:右移

四.分支、循环、条件

  • 表达式:表达式是运算符和操作数所构成的序列

  • 表达式的优先级

  • 条件控制语句:

        ```
        条件控制语句
        ```
        
        ACCOUNT = "gale"
        PASSWD = "123456"
    
        print("please input the account:")
        USER_ACCOUNT = input()
        print("please input the passwd:")
        USER_PASSWD = input()  
    
        #在python中是通过冒号换行和缩进来区分条件语句的开始和结尾
        if USER_ACCOUNT == ACCOUNT and USER_PASSWD == PASSWD: 
            print("success")
        else: 
            print("fail")
            
    
  • while循环:

    # 在python中是通过冒号换行和缩进来区分while语句的循环体的开始和结尾
    # 递归的场景中适合使用while循环
    while condition:
        pass
    
  • for循环:

    # 主要用于遍历序列、集合、字典
    # 可以使用break跳出当前循环体
    # 可以使用continue结束本次循环,继续下一次循环
    for target in expression_list:
        pass
    
    # 使用range函数控制循环次数
    for x in range(0, 10):
        pass
    # 等价于java的:
    for(int i=0; i<10; i++) {
    
    }
    
    for x in range(0, 10, 2):
        pass
    # 等价于java的:
    for(int i=0; i<10; i += 2) {
    
    }
    
    for x in range(10, 0, -2):
        pass
    # 等价于java的:
    for(int i=10; i>0; i -= 2) {
    
    }
    

五.包、模块

  • 在python中,一个包对应一个文件夹,一个模块对应一个文件

  • 区分不同包下的两个同名的模块:通过’包名.模块名’来区分

  • 如果想让一个文件夹成为一个包,在这个文件夹下必须有一个特定的文件:'init.py’文件

  • init.py文件对应的模块名字是_init__.py所在包的名字,也就是__init__.py文件所在的文件夹的名字

  • 导入模块: 当在一个模块中导入了另一个模块后,可以在当前模块中使用另一个模块中的变量和函数和类

    • 使用import关键字:

      import module_name
      print(module_name.variable)
      
    • 使用import配合as关键字:

      import module_name as alias_name
      print(alias_name)
      
    • 使用from import关键字:

      from pkg_name/module_name import module_name/variable
      print(variable)
      
    • __all__配合*:

          ```
              t包下的m1.py文件
          ```
          __all__ = ['a', 'b']
          
          a = 1
          b = 2
          c = 3
          
          ```
              和t包同级的m2.py
          ```
          # 从t包下的m1模块中引入所有被__all__包含的变量,如果m1模块中没有__all__变量,则m1中所有的变量和函数会被引入
          from t.m1 import *
          print(a)
          print(b)
          print(c) #报错
      
  • _init_.py的使用:

    • 当一个包或包下面的模块或变量被导入的时候,这个包下的__init__.py文件会被自动执行

    • 可以通过__init__.py文件批量导入一个包下面的模块:

          ```
              p包下的子包t下的__init__.py
              并且p包下包含m1.py、m2.py、m3.py三个模块
          ```
          __all__ = ['m1', 'm2']
          
          ```
              p包下的m4.py模块
          ```
          from t import * #t包下的m1、m2模块被批量导入
      
  • 包与模块的注意事项:

    • 包和模块不会被重复导入
    • 避免循环导入
    • 当在导入一个模块时,python会首先执行该模块中所有的代码
  • 模块内置变量:

    • 使用dir方法可以查看模块中的所有内置变量
    • _name_:模块名(包名.模块名)
    • _package_:当前模块所在的包名
    • _file_:当前模块所在的文件路径
    • _doc_:当前模块的文档注释
  • 入口文件和普通模块内置变量的区别:

    • 入口文件和普通模块:当通过python3 **.py执行时,**.py即为入口文件,在入口文件中导入的其他模块即为普通模块
    • 入口文件所对应的模块不属于任何包
    • 入口文件的模块名固定为’main
  • 模块内置变量__name__的经典应用:

    # 使python模块即可以作为入口文件,也可以作为普通模块
    if __name__ == '__main__':
        pass
    
  • 相对导入和绝对导入

    • 顶级包:和入口文件同级的包
    • 在入口文件中只能使用绝对导入
    • 绝对导入必须从顶级包开始
    • 使用from import来进行相对导入
    • 使用相对导入对模块进行导入时,不能超过被引入模块的顶级包

六.python函数、变量作用域

  • 函数的定义和调用

    • 函数的定义

      def funcname(parameter_list):
          pass
      
  • 函数调用:在python中,必须保证被调用的函数已经事先被定义好了

  • 函数的参数列表可以没有

  • 在函数体中可以使用return关键字来返回函数调用的结果

  • 如果函数体里面,没有使用return关键字,则该函数被调用后默认会返回None

  • 在python中,函数可以一次性返回多个值,这多个值之间用逗号隔开即可,且函数的调用结果为一个元组

    # 该函数会返回一个元组
    def funcname(parameter_list):
        return result1,result2
    
  • 必须参数与关键字参数

    • 必须参数

      # x,y为必须参数
      def funcname(x, y):
          pass
      
    • 关键字参数:在调用函数的时候,明确指定给哪一个形参赋值

      def add(x, y):
          return x + y
      
      # 关键字参数 
      c = add(y = 3, x = 2)
      
  • 默认参数

    # x,y在定义时被指定了默认值,称为默认参数
    # 在调用该函数时,如果不传入任何参数,则x取默认值1, y取默认值3 
    def add(x = 1, y = 3):
        return x + y
       
    # x = 1, y = 3
    c = add()
    # x = 5, y = 3
    d = add(5)
    # x = 1, y = 5
    e = add(y = 5)
    
    # 默认参数必须放在非默认参数之后
    def add1(x, y=1, z = 2):
        return x + y + z
    # 不能写成
    def add1(y=1, z = 2, x):
        return x + y + z
    
  • 可变参数

    # param为可变参数,这里的可变指的是长度可变
    # 当调用该函数时,会把传入的多个参数打包成一个元组,并赋值给param
    def test(*param):
        print(type(param)) # <class 'tuple'>
    
    test(1, 2, 3, 4) 
    
    a = (1,2,3,4,5)
    test(*a)
    # 等价于
    test(1,2,3,4,5)  
    
  • 必须参数、可变参数、默认参数的组合形式

        def test(param1, *param2, param3 = 3):
            print(param1)
            print(param2)
            print(param3)
        
        
        ```
        输出:
            a
            (1,2,3,4,5)
            3
        ```
        test('a', 1,2,3,4,5)
        ```
        输出:
            a
            (1,2,3,4)
            5
        ```
        test('a', 1,2,3,4, param3 = 5)
    
    
  • 可变关键字参数

    def test(**param):
        print(type(param)) # <class 'dict'>
        
    test(a = 1, b = 2, c = 3)
    
    d = {'one' : 1, 'two' : 2, 'three' : 3}
    test(**d)
    
  • 变量的作用域

    • 全局变量:在模块内部,函数外部声明的变量,作用域为整个模块

    • 局部变量:在函数内部声明的变量为局部变量,其作用域仅限于函数内部

    • 在函数内部声明的变量不能在函数外部访问

    • 全局变量可以在模块内的函数内部使用,但需要遵循先声明后使用的原则

    • 在python中没有块级作用域的概念,因此,可以在for循环的外部访问循环体中的变量

      for i in range(0,10):
          a = 'a'
      print(a) # 输出:a
      
    • global关键字:使用global关键字可以是局部变量变为全局变量

      def test():
          global c
          c = 10
      
      test()
      print(c) # 输出:10
      

七.面向对象

  • 类和对象:类是具体某一类事物的总和,是一类对象的模板,对象是类的一个具体实例。

  • 类包含静态属性(成员变量)和动态的方法(函数)

  • 编写并实例化一个类

    class Cat():
        name = 'Tom'
        age = 10
        
        def info(self):
            print('name: ' + self.name + ', age: ' + str(self.age))
    
    cat = Cat()
    cat.info()
    
  • 构造方法

    • 当对象被实例化时,对象的构造方法会被自动调用

    • 对象的构造方法只能返回None

    • 对象的构造方法的名字固定为__init__

      class Cat():
          name = ''
          age = 0
      
          def __init__(self, name, age):
              self.name = name
              self.age = age
          
          def info(self):
              print('name: ' + self.name + ', age: ' + str(self.age))
      
      cat = Cat('Tom', 20)
      cat.info()
      
  • 类变量与实例变量

    class Cat():
        # 类变量
        name = ''
        age = 0
        
        def __init__(self, name, age):
            # 注意:此处只是相当于在构造函数里重新定义了两个局部变量,并不是为类的实例变量赋值
            name = name
            age = age
    
            # 通过self关键字来定义实例变量
            self.name = name
            self.age = age
    
    • 访问类变量

      # 直接通过'类名.变量名'即可访问类变量
      a = Cat.name
      
    • 访问实例变量

      # 访问实例变量,首先需要将类实例化成一个对象,然后通过'对象.变量名'即可访问实例变量
      c = Cat('Tom', 20)
      name = c.name
      
  • 类与对象的变量查找顺序:

    • 当通过’对象.变量’的方式去访问实力变量的时候,会首先从类的实例变量列表中去查找,如果没有找到,则会去类变量列表中去查找,如果还没找到,则会到当前类的父类中去寻找

    • 通过对象的内置变量’dict’可以访问到对象的实例变量列表

    • 通过类的内置变量’dict’可以访问到类的类变量列表

      class Cat():
          # 类变量
          name = ''
          age = 0
          
          def __init__(self, name, age):             
              # 通过self关键字来定义实例变量
              self.name = name
              self.age = age
              
      cat = Cat('Tom', 20)
      print(cat.__dict__) # 输出: {'name': 'Tom', 'age': 20}
      print(Cat.__dict__) 
      # 输出: {'__module__': '__main__', 'name': '', 'age': 0, '__init__': <function Cat.__init__ at 0x106036700>, 'info': <function Cat.info at 0x106036790>, '__dict__': <attribute '__dict__' of 'Cat' objects>, '__weakref__': <attribute '__weakref__' of 'Cat' objects>, '__doc__': None}
      
  • self与实例方法:类的实例方法默认会有一个self参数

    class Cat():
        # 类变量
        name = ''
        age = 0
        
        def __init__(self, name, age):
            # 通过self关键字来定义实例变量
            self.name = name
            self.age = age
            
        # 实例方法
        # self只和对象有关,谁调用了它的实例方法,self就指代谁
        def info(self):
            print('name = ' + self.name + ', age = ' + str(str.age))
    
  • 在实例方法中访问实例变量和类变量

    class Cat():
        # 类变量
        name = ''
        age = 0
        
        def __init__(self, name, age):
            # 通过self关键字来定义实例变量
            self.name = name
            self.age = age
            
        # 实例方法
        # self只和对象有关,谁调用了它的实例方法,self就指代谁
        def info(self):
            # 在实例方法中,可以通过'self.变量名'来访问实例变量
            print(self.name)
            # 在实例方法中,可以通过'类名.变量名'来访问类变量
            print(Cat.name)
            #在实例方法中,也可以通过'self.__class__.变量名'来访问类变量
            print(self.__class__.age)
    
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值