python语法

Posted wp950416

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python语法相关的知识,希望对你有一定的参考价值。

Python

  1. 常见的DOS命令

    1. dir 查看目录
    2. cd 进入指定的目录
    3. md 目录名 创建目录
    4. rm 目录名 删除目录
    5. del 文件名(包括后缀) 删除文件
  2. 文本文件和字符集

    1. 文本分为纯文本跟富文本
    2. 开发时,使用的都是纯文本
    3. 字符集 utf-8(万国码,几乎通用),一般出现乱码就是字符集的问题
  3. 编译型语言和解释型语言

    1. c语言(编译型语言) 会在代码执行前将代码编译成机器码,再交给计算机执行,特点:执行快,跨平台型差
    2. Python、JS、Java(解释型语言) 不会再代码执行前编译,而是边执行边编译 特点:执行慢,跨平台型好
  4. Python的用途(排名tiobe)

    1. web应用

      1. facebook
      2. 豆瓣
    2. 爬虫程序

    3. 科学计算

    4. 自动化运维

    5. 大数据

    6. 云计算

    7. 人工智能

    8. 桌面软件/游戏等

  5. Python(anaconda navigator)结合pycharm

    1. pyCharm创建项目→create project→需要选择project interpreter(exciting interpreter选择python.exe)

    2. Python的基本语法

      1. 在Python中严格区分大小写
      2. Python的每一行就是一条语句,每条语句以换行结束.
      3. 一条语句可以分多行编写,多行编写时语句后边以结尾
      4. Python是缩进严格的语言,所以在Python中不要随便写缩进
      5. 在Python中使用#表示注释,习惯上#后面跟一个空格,‘‘‘表示多行注释
      6. Python中使用变量不需要申明,直接变量赋值
      7. Python不能使用没有进行赋值的变量
      8. Python可以为变量赋任意的值,也可以任意修改变量的值
  6. pyCharm的常用快捷键

    1. Ctrl + Alt + L 代码格式化
    2. Shift + Enter 另起一行
    3. Ctrl + Shift + R 全局替换
    4. Ctrl + Shift + F 全局查找
    5. Shift + F10 运行
    6. Shift + F9 调试
  7. 字面量和变量、标识符

    1. number值、String值都可以作为字面量

    2. 变量用于保存字面量

    3. 标识符(自主命名的内容都属于标识符)

      1. 变量名、函数名、类名都属于标识符
      2. 标识符可以含有字母、数字、_,但是不能以数字开头
      3. 标识符不可以使用关键字和保留字
  8. 命名规则

    1. 所有字母小写
    2. 单词与单词之间,首字母小写,其他单词首字母大小. 例:studentName
    3. 还有一种使用单词与单词之间使用下划线
  9. 数值

    1. 在Python中数值分为三种:整数、浮点数、复数

    2. 在Python中所有的整数都是int类型

    3. 如果数字的长度过大,可以使用下划线_作为分隔符

    4. 十进制的数值不能以0开头

    5. 对浮点数进行计算的时候,可能会得到一个不精确的值.比如:

      c=0.1+0.2
      print(c)
      
  10. 可以通过在字符串前添加一个f来创建一个格式化字符串,在格式化字符串中可以直接嵌入变量

    a="abc"
    b=124
    c=f"hello {a},{b}"
    print(c)
    # 该输出呈现的是字符串
    print(f"a={a},b={b}")
    
  11. 可以通过.format格式化输出,在格式化字输出中可以直接嵌入变量

    a="name"
    b=123
    print("a={},b={}" .format(a,b))
    
  12. 布尔型 bool 只能装(True/False)

    1. 布尔值主要用来做判断
    2. 布尔值实际上也属于整型,可用来跟number进行运算,True=1,False=0
  13. 序列的分类

    1. 可变序列

      1. 列表 可变可重复
      2. 集合 可变不可重复
    2. 不可变序列

      1. 字符串
      2. 元祖
  14. 列表 list [1,2,3,4...]

    # 按照下标获取列表中的字段
    nameList = ["王大锤", "唐马儒", "鹿晗", "蔡徐坤", "李现"]
    print(nameList[2])
      
    # 列表可以保存不同类型的元素
    a = ["abcd", 11, True]
      
    # len() 获取列表的长度
    l = len(nameList)
    print(l)
      
    # 表示从后向前获取元素,获取2个元素,-1表示倒数第一个
    print(nameList.stus[-2])
    # 表示获取元素(包括起始位置,不包括结束位置),stus函数在做切片操作时,总会返回一个新的列表,不会影响原来的列表
    print(nameList.stus[1:4])
    # 如果省略结束为值,则会一直截取到最后,同理如果省略开始位置,则会从第一个元素开始截取
    print(nameList.stus[1:])
    # 表示从开头位置截取到第5个位置,并且是每下两个截取一个(通俗的讲就是隔一个截取)
    print(nameList.stus[1:5:2])
        
    # 将两个列表拼成一个列表
    lists=[1,2,3]+[4,5,6]
    # 可以重复列表(表示123123)
    lists=[1,2,3]*2 
      
    # min()获取列表中的最小值
    # max()获取列表中的最大值
    
    #获取列表指定元素在列表中的位置
    print(nameList.index("王大锤"))
    # 查找列表中指定元素 ,第二个参数表示查找的起始位置(包括开始,但是如果第三个刚好是查找的元素,则忽略),第三个参数表示查找的结束位置(不包括)
    print(nameList.index("王大锤",3))
    
    # 查找元素在列表中出现的次数
    print(nameList.count("王大锤"))
      
    # 使用循环遍历列表,这里的i表示下标,range里面表示列表的长度
    for i in range(len(nameList)):
        print(nameList[i])
    # 此种遍历列表的方式,name表示的集合中可变的值(集合长度决定该值的个数),nameList是一个集合
    for name in nameList:
        print(name)
      
    # append() 向列表中添加元素,不需要返回值
    nameList.append("渣渣辉")
    for name in nameList:
        print(name, end=‘ ‘)
      
    # extend() 将一个列表添加到另一个列表中,并且是加入到另一个列表的末尾位置
    nameList2 = ["吴亦凡", "周杰伦", "古天乐"]
    nameList.extend(nameList2)
    print(nameList)
      
    # insert() 在指定的位置前插入元素
    nameList.insert(1, "东尼大木")
    print(nameList)
      
    # 修改元素,需要通过下标来修改
    nameList[0] = "张全蛋"
    print(nameList)
      
    # in 判断 指定的元素是否被包含在列表中,包含就返回true,不包含就返回false
    print("jack" in nameList)
    # not in 判断指定元素是否被包含在列表中,不包含返回true,包含了返回false
    print("jack" not in nameList)
       
      
    # 删除列表中元素,根据下标进行删除
    del nameList[0]
    print(nameList)
      
    # pop()函数,删除最后一个元素,括号内如果加上参数的话,跟del功能就类似,负值表示倒数,正值表示正数
    nameList.pop()
    print(nameList)
      
    # remove() 根据指定的元素来删除,完全匹配
    nameList.remove("吴亦凡")
    print(nameList)
      
    # sort排序
    number = []
    for i in range(10):
        number.append(random.randint(0, 100))
    number.sort()
    # reverse=True,由大到小排列
    number.sort(reverse=True)
    print(number)
    
    # reverse() 也可以作为函数使用,表示反转列表
    nameList.reverse()
    
  15. 列表的嵌套

       a = [[1, 2, 3], [11, 22, 33], [33, 66, 99]]
       print(a[0])
       print(a[1])
       print(a[2][2])
    
  16. 集合

    # 使用{}来粗创建集合,集合的顺序是由python解释器自己去排列的
    # 通过set可以将序列和字典转换为集合
    # 使用set()函数将字典转换为集合的时候,只会包含字典的键
    # 使用len()函数获取集合中元素的数量
    # 使用add()函数可以向集合中添加元素
    # 使用update()函数将另一个集合添加到当前集合中
    # 使用pop()函数随机删除集合中的一个元素
    # 使用remove()删除指定的元素name
    print(info.remove(name))
    # 使用clear()函数清空集合
    # 使用copy()函数对集合进行浅复制
    
  17. 集合的运算

    # 对集合做运算时,不会影响原来的集合,而是将运算结果返回
    # &交集运算
    s={1,2,3}
    s2={3}
    result=s & s2
    print(result)  输出3
    
    # |并集运算 表示合并集合
    # -差集运算 表示返回减号前面有的,后面没有的值
    # ^亦或集运算 表示返回两个集合中除了共有的值
    
    # <=检查一个集合是否是另一个集合的子集,意思就是当前集合中的元素是否全部在另一个集合中出现,那么当前的集合就是另一个集合的子集
    
  18. 字符串

    1. 在Python中字符串需要使用引号引起来,相同的引号不能嵌套使用

    2. 单双引号不能跨行使用,需要使用来进行连接

    3. 使用三重引号来表示一个长字符串,并且三重引号可以换行,会保留字符串中的格式.

    4. 字符串也可以进行加法运算,作为拼接

    5. 变量中存放字符串,如果使用*表示复制 例:a="abc" c=a * 3 print(c)

    6. %3.5s表示3-5个字符(多个截去,少了补空格)

    7. "hello %4s"%123 可以以数字作为占位符

    8. "hello %4s"%123.34 也可以以浮点数作为占位符

    9. "hello %4fs"%234.4 以浮点数作为占位符,并且小数保留4位

    10. "hello %4ds"%234.4 整数占位符

       # %s表示指定一个占位符,单独的s表示任意字符
          b="hello %s"%"world"
         print(b)
         # %s指定的占位符可以容纳多个字符,字符间用逗号隔开
         c="hello %s say %s"%("world","goodbye")
         print(c)
         # %3s表示限制占位3位,如果不够空格补充,超过则保留3位
          d="hello %3s"%"world" 
         print(d)
      
  19. 字符串常用函数

    str="thinking in python"
      print(str.find("in"))
      # find() 在指定的范围查找,包含开始不包含结束
      print(str.find("in",0,4))
      
      # count() 检测指定字符串,在字符串中出现的次数
      print(str.count("in"))
      
      # replace() 替换操作,将字符串中的内容,替换成新的内容
      print(str.replace("python","C++"))
      print(str.replace("in","out"))
      
      # split() 分割操作,按照指定的内容,将字符串分割
      print(str.split("i"))
      a="good good study day day up"
      print(a.split(" "))
      
      # capitalize() 把字符串第一个字符改成大写的
      print(str.capitalize())
      # title() 将字符串每个单词的首字母改成大写
      print(str.title())
      
      # startwith() 检测字符串是否以指定的内容开头,是则返回True,否则返回False
      print(str.startswith("think"))
      # endswith() 检测字符串是否以指定内容结尾,是返回True,否则返回False
      print(str.endswith("on"))
      
      # lstrip() 去除字符串左边的空格
      a="    asdw    "
      print(a.lstrip())
      # rstrip() 去除字符串右边的空格
      print(a.rstrip())
      # strip() 去除字符串两边的空格
      print(a.strip())
      
      # isalpha() 判断字符串中是字母返回True,不是就返回False
      str2 = "abc123"
      print(str2.isalpha())
      # isdigit() 判断字符串中全部是数字字符返回True,不是返回False
      str3 = "123456789"
      print(str3.isdigit())
      # isspace() 判断字符串中只包含空格返回True,不包含就返回False
      str4="       "
      print(str4.isspace())
    
  20. 字符串的下标应用

    1. 下标

      s="abcdef123啊啊啊"
      # 根据下标为0,获取字符串中第一个字符
      print(s[0])
      print(s[6])
      
    2. 截取字符串 s[a,b]

      strs="sdfsaf"
      # 做截取操作时,包含开始,不包含结束
      print(s[0:3])
      # 从指定位置截取到字符串末尾
      print(s[3:])
      # 表示截取倒数第二个字符,-2表示倒数第三个字符,以此类推
      print(s[0:-1])
      
  21. 元祖

    1. 操作方式基本和列表类似
    2. 不同的是,元祖的元素不能修改元祖使用小括号
    3. 一般我们希望数据不被改变时,就可以使用元祖,其余情况偶读使用列表
    4. 两个值交换,可以利用元祖的解包 a,b=b,a
  22. 判断数据类型 type(变量名)

  23. 函数

    1. input() 实现输入

    2. sum() 求和

      a=123
      b=345
      # sum里面第一个参数表示列表(相加),第二个表示相加的数
      c=sum([11,2],(4))
      print(c)
      
    3. range(start,stop,step)

      1. 用途 用来生成一个自然数的序列

      2. 三个参数的含义

        1. start 表示开始位置(包含)
        2. stop 表示结束位置(不包含)
        3. step 表示步数(默认自增1)
      3. 一般通过range()函数创建一个执行指定次数的for循环

  24. 自定义函数

    1. 语法:def 函数的名称():

    2. 调用方式:函数名()

    3. 自定义函数的四种定义方法

      1. 无参数,无返回值.若函数内没有print输出,那么调用该函数,则为空内容.
      2. 无参数,有返回值.创建一个变量接受函数内返回的值(需要return),那么调用该函数,输入的是返回的内容.
      3. 有参数,没有返回值.
      4. 有参数,有返回值.
    # 创建函数的时候,也可以定义默认形参,如果用户传递了参数则默认值没有任何作用;如果用户没有传递,那么默认值就会生效
    def info(name="吴鹏",age=19):
        print(name,age)
    info()
    
    # 在定义函数时,可以在形参前边加上一个*,这样这个形参将会获取到所有的实参,它会将所有的实参保存到一个元祖中,如下:*a会接受所有的位置实参,并且将这些实参统一保存到一个元祖中
    def fn(*a):
        print("a={}" .format(a),type(a))
    fn(1,2,3,4,5,6)
    
    # 定义一个函数,可以求任意个数字的和
    # 带*号的参数只能是一个,如果带*号的在形参的中间,那么后面的形参相对应的实参必须要有赋值的形式进行传递
    def sum(*a):
        result=0
        for fn in a:
            result+=fn
        print(result)
    sum(10,20,30,40)
    
    # 参数的解包,*t会自动将序列中的元素默认作为参数传递,要求序列中元素的个数必须和形参的个数一致
    def fn4(a,b,c):
        print(a)
        print(b)    
        print(c)    
    # 使用列表
    t=(10,20,30)
    fn4(*t)
    
    # 使用字典 **d的功能跟上面的类似
    d={"a":100,"b":200,"c":300}
    fn4(**d)
    
  25. 返回值

    1. return后边跟什么值,函数就会返回什么值
    2. return后边可以跟任意的对象,返回值甚至可以是一个函数
    3. 如果仅仅写一个return或者不写return,则相当于return None
    4. 在函数中,return后的代码都不会执行,return一旦执行函数自动结束
  26. 数据类型转换

    1. 转成整型 int()

      1. bool值 True会转成1,False会转成0
      2. 浮点数会直接转成整数
      3. 合法的整数字符串会转换成int类型,如果不是一个合法的,那么将会报错
    2. 转成浮点 float() 转换过程跟int类似,不同的是,小数点会用0代替

    3. 转成字符串 str()

    4. 转成bool值 bool()

      1. 任何对象都可以转换成bool值
      2. 对于所有表示空性的对象都会转换为False,其余的转换为True
  27. 算数运算符

    1. 对于字符串相加,就是将两个字符串拼接在一起
    2. 如果数字跟bool值进行加减法运算时,会先将bool值转换为number在进行运算
    3. 字符串和数值是不能相加.
    4. ** 幂运算
    5. /表示除号 //表示整除
    6. % 取余
  28. 转义字符

    1. ‘ 表示 ‘
    2. " 表示 "
    3. t 表示制表符
    4. n 表示换行符
    5. 表示反斜杠
    6. uxxxx 表示unicode编码
  29. 关系运算符 <,>,==,!==,<=,>=

    1. 关系运算返回结果是bool类型,只能返回True/False
    2. 数值类型和字符串类型不能比较
    3. 当对字符串进行比较时,实际上比的是字符串的unicode编码
    4. 如果需要对数字型字符串作比较的话,需要先转换为number
    5. is 比较两个对象是否是同一个对象,比较的是对象的id
    6. is not 比较两个对象是否不是同一个对象,比较的是对象的id
  30. 逻辑运算(and,or,not)

    1. 逻辑运算结果,只能是bool型,返回值True/False
    2. 当and(&)两边运算结果为True时,最终结果为True,否则为False
    3. 当or 左右两边的运算结果都为False的时候,最终结果为False,否则结果就是True
    4. not逻辑非是取反
  31. 分支结构

    1. if

      1. if...else
      2. if...elif...else
    2. 闰年的规则:

      1. 年份取余4等于0
      2. 年份取余100不等于0
      3. 年份取余400等于0
  32. 循环结构

    1. while
  33. for...in... 1. in后面跟的是序列 2. in后面也可以是一个字符串 3. in后也可以是range()函数

  34. 模块的引入

    1. random

      1. 引入random→import random
      2. random randint(0,100) 0-100的随机数
    2. 从另一个文件中引入函数(如果引入所有使用*)

  35. python的相关练习

     # 计算所有的奇数之和(使用while)
     num = 0
     sum = 0
     while num <= 100:
     	if num % 2 != 0:
     		print(num)
     		sum += num
     	num += 1
     print("所有奇数和:{}".format(sum))
    

     # 计算所有的奇数之和(使用for...in...)
     sum = 0
     # 与while的区别:num不需要定义变量为0
     for num in range(101):
         if num % 2 != 0:
             print(num)
             sum += num
         num += 1
     print("所有的奇数之和:{}".format(sum))
    

     # 使用for动态打印矩形
     # 外层循环控制行,内层循环控制列
     num=input("请输入边数:")
     num=int(num)
     for i in range(num-1):
         for j in range(num):
             print("*",end="")
         print("")
    

     # 动态打印正三角
     num = input("请输入三角的边数:")
     
     num = int(num)
     for i in range(num):
         for j in range(i + 1):
             print("*", end="")
         print("")
    

     # 乘法表
     # 1*1=1
     # 1*2=2 2*2=4
     # 1*3=3 2*3=6 3*3=9
     
     num = int(input("请输入乘法表边数(行跟列)"))
     for i in range(num + 1):
         for j in range(i + 1):
             print("{}*{}={}".format(j + 1, i + 1, (j + 1) * (i + 1)), end="  ")
         print("")
    

     # 电脑随机一个0-100的数,将用户输入的跟电脑随机的数字对比,满分是100分,猜错口扣10分,分数为0,停止程序.
     import random
     score = 100
     # randint(0,100) 包含0跟100
     a = random.randint(0, 100)
     count = 0
     while True:
         num = int(input("请输入第{}个:".format(count + 1)))
         if num > a:
             print("猜大了")
         elif num < a:
             print("猜小了")
         else:
             print("猜对了")
         count += 1
         if count == score / 10:
             break
     print("分已经全没,重启程序")
    

      ‘‘‘
      猜数字游戏,电脑随机产生一个0-100的整数,用户在控制台输入一个整数,将用户输入的和电脑产生的进行对比:
      如果用户猜大了,就提示猜大了,猜小了,就提示猜小了,猜对了就恭喜答对了
      满分是100分,猜错一次就减10分,
      当分数为0的时候,停止程序。
      ‘‘‘
      import random
      
      content = random.randint(0, 100)
      count = 0
      score = 100
      while True:
          if score == 0:
              print("您的分数已经归为0,再见")
              break
          num = int(input("请输入第{}个数:".format(count + 1)))
          if num > content:
              print("您猜大了")
              score -= 10
              print("当前分数为:{}".format(score))
          elif num < content:
              print("您猜小了")
              score -= 10
              print("当前分数为:{}".format(score))
          else:
              print("恭喜你,猜对了,当前分数为:{}".format(score))
              break
          count += 1
    

      ‘‘‘
      随机加减乘除运算,一共出10题,电脑随机产生2个0-100的整数,进行随机加减乘除法计算
      然后用户输入计算结果,判断用户输入的是否正确,回答正确就加十分,错误就不加分,10题全对就是100分
      ‘‘‘
      import random
      
      score = 0
      test = 0
      sum = 0
      while True:
          if test == 10:
              break
          num1 = random.randint(0, 100)
          num2 = random.randint(0, 100)
          t = random.randint(0, 3)
          if t == 0:
              print("请回答第{}题:{}+{}=?".format((test + 1), num1, num2))
              sum = num1 + num2
          elif t == 1:
              print("请回答第{}题:{}-{}=?".format((test + 1), num1, num2))
              sum = num1 - num2
          elif t == 2:
              print("请回答第{}题:{}*{}=?".format((test + 1), num1, num2))
              sum = num1 * num2
          else:
              print("请回答第{}题:{}//{}=?".format((test + 1), num1, num2))
              sum = num1 // num2
          user = int(input("请输入结果:"))
          if user == sum:
              score += 10
              print("回答正确加10分,当前分数为:{}".format(score))
          else:
              print("回答错误减10分,当前分数为:{}".format(score))
          print("当前总分为:{}".format(score))
          test += 1
    
  36. 循环、列表等混合练习

       ‘‘‘
       创建一个10个长度整数列表,列表中的10个元素,使用随机数赋值,范围0-100,然后找出列表中的最大值
       ‘‘‘
       import random
       
       list = []
       for i in range(10):
           list.append(random.randint(0, 100))
           for j in range(len(list)):
               max = list[0]
               if max < list[j]:
                   max = list[j]
           print(list[i], end=" ")
       print("最大值为:{}".format(max))
    

       # 冒泡排序
       num = [51, 12, 55, 29, 18, 18, 18, 18, 55, 295, 5, 29]
       for i in range(len(num)):
           # 选出最大去掉一个
           for j in range(len(num) - 1 - i):
               if num[j] > num[j + 1]:
                   t = num[j]
                   num[j] = num[j + 1]
                   num[j + 1] = t
       print(num)
    

     ‘‘‘
     从26个字母中,随机选出4个不重复的字母
     并且把4个字母,添加到一个列表中
     
     用户在控制台输入4个字母,将用户输入的也添加到一个列表中
     然后将电脑的和用户的 进行对比
     ‘‘‘
     import random
     
     # 从26个字母中,随机选出4个不重复的字母
     def getChar():
         c1 = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘, ‘h‘, ‘i‘, ‘j‘, ‘k‘, ‘l‘, ‘m‘, ‘n‘, ‘o‘, ‘p‘, ‘q‘, ‘r‘, ‘s‘, ‘t‘, ‘u‘, ‘v‘,
               ‘w‘, ‘x‘, ‘y‘, ‘z‘]
         c2 = []
         for i in range(4):
             index = random.randint(0, len(c1) - 1)
             c2.append(c1[index])
             del c1[index]
         print(c2)
         return c2
     
     # 检查用户输入是否正确的
     def check(charList, user):
         # 第一个下标保存猜对了几个,
         # 第二个下标保存位置对了几个
         result = [0, 0]
         for i in range(len(charList)):
             if user[i] in charList:
                 result[0] += 1
                 if user[i] == charList[i]:
                     result[1] += 1
         print("猜对了{}个,位置对了{}个。".format(result[0], result[1]))
         return result
     
     print("猜字母游戏开始了。")
     charList = getChar()
     while True:
         str = input("请输入四个字母,退出输入exit")
         if str == "exit":
             break
         user = []
         for s in range(4):
             user.append(str[s])
         print(user)
         res = check(charList, user)
         if res[1] == 4:
             print("恭喜,全部猜对了")
             break
     print("游戏结束")
    
  37. 作用域

    1. 全局作用域

      1. 在程序执行时创建,在程序执行结束时销毁
      2. 所有函数以外的区域都是全局作用域
      3. 在全局作用域中定义的变量,都属于全局变量,全局变量可以在程序的任意位置被访问
    2. 函数作用域

      1. 函数作用域在函数调用时创建,在调用结束后销毁
      2. 在函数作用域定义的变量,都是局部变量,只能在函数内部访问
    3. 变量的查找 当使用变量时,会优先在当前作用域中寻找该变量,如果有则使用如果没有则继续去上一级作用域中寻找,如果有则使用,直到找到全局作用域,依然没有找到,则会抛出异常.

    4. 如果希望在函数内部修改全局变量,则需要使用global关键字,来声明变量,声明多个使用逗号隔开

    # 全局变量
    allIn=99
    name="吴鹏"
    age=24
    
    def userInfo():
        age=18
    # 全局变量可以在函数中被访问,但是如果你想在函数中修改全局变量,那么就需要用 global进行修饰
        global allIn,name
        allIn+=1
        name="吴磊"
        print("姓名:{},年龄:{},allIn:{}".format(name,age,allIn))
    
    def thanme():
        print(allIn)
        
    def show():
        print("姓名:{},年龄:{},allIn:{}".format(name, age, allIn))
    
    userInfo()
    thanme()
    show()
    
  38. 命名空间

    1. 命名空间指的是变量存储的位置,每一个变量都需要存储到指定的命名空间当中
    2. 每一个作用域都会有一个对应的命名空间
    3. 全局命名空间,用来保存全局变量,函数命名空间用来保存函数中的变量
    4. 命名空间实际上就是一个字典,是一个专门用来存储变量的字典
    5. 如果在全局作用域中调用locals()则获取全局命名空间,如果在函数作用域中调用local()则获取函数命名空间
  39. 字典

    1. 字典和列表类似,也是永爱保存一堆数据

    2. 语法:变量名={"键名1":"值1","键名2":"值2"}

    3. 需要注意的是键名也是要用引号包起来

    4. 字典中的键名是不能重复的

    5. 修改键值 变量名["键名"]="新键值"

    6. 删除键值对 del 变量名["键名"]

    7. 删除字典中的内容,不删除字段 变量名.clear()

    8. 直接删除整个字典 del 变量名

    9. 获取字典中所有的key与value 变量名.key() 变量名.value()

      info={"name":"吴鹏","age":12}
      # 获取其中的键值,需要使用get方法,如果不存在,将会返回none
      print(info.get("name"))
      # 也可使用采用类似于下标的方法得到键值,但是在使用变量赋的键名,不能使用引号
      print(info["name"])
      
      # 可以使用dict()函数创建字典
      d=dict{"name":"吴磊","age":24}
      
      # 修改键值
      info["name"]="吴磊"
      print(info.get("name"))
      
      # 如果修改键值,该键名不存在,那么就是添加的操作
      info["adress"]="南京市"
      print(info)
      
      # 使用setdefault()函数,可以向字典中添加键值对.如果说存在键,那么就会返回key的值,不会对字典做任何操作
      info.setdefault("adress":"南京市")
      
      # 使用update()函数,将其他字典添加到当前的字典中
      a={"name":"abc",age=11}
      b={{"adress":"南京",classes=11}}
      # 将b中的键值对添加到a的字典中,如果有重复的,后面的会将前面的替换掉
      a.update(b)
      
      # 删除键值对
      del info["adress"]
      print(info)
      
      # 使用popitem()函数,随机删除字典中的一个键值对,一般都会删除最后一个键值对,删除之后,会将删除的key-value作为返回值返回,返回的是一个元素,第一个元素是删除的key,第二个删除的是value
      print(info.popitem())
      
      # 删除字典中的内容,不删除字典
      # info.clear()
      # print(info)
      
      # 直接删除整个字典
      # del info
      
      print(info.keys())
      print(info.values())
      
      # copy()函数,复制,好处就是复制以后的对象和源对象是独立的,修改一个不会影响另一个
      d1={"name":"ad","age":10}
      d2=d1.copy()
      
      # 获取字典键值对的个数
      print(len(info))
      
      # in检查字典中是否包含指定的键
      # not in 检查字典中是否不包含指定的键
      
      #遍历字典
      for k in d.keys():
          print(k,d[k])
      
      
  40. 文件操作

    1. 文件操作的语法 变量名=open("文件名称",打开方式,定义字符集)

      1. 打开方式 r:读取 w:写入,创建,覆盖 a:写入,创建,追加
      2. 字符集:encoding=utf-8
    2. 每操作一次文件,必须要关闭 变量.close()

    3. 判断文件是否是关闭 变量.closed

    4. 写入内容 变量.write()

    5. 读取文件内容 变量.read()

    6. 文件改名,需要引入模块os os.rename("原始文件名","新文件名")

    7. 删除文件 同样需要引入模块 os.remove("文件名")

      ‘‘‘
      文件操作
      f = open(‘文件名称‘,‘打开方式‘)
           r : 读取,
           w :写入,创建,覆盖
           a : 写入,创建,追加
      ‘‘‘
      f = open(‘a.txt‘,‘w‘)
      # 获取文件名称
      print(f.name)
      # 获取打开方式
      print(f.mode)
      # 判断文件是否关闭,关闭True, 没有关闭false
      print(f.closed)
      # close()函数,是用来关闭文件, 文件打开使用完之后,一定要记得关闭
      f.close()
      print(f.closed)
      
      f = open("a.txt","w")
      # write()写入字符串
      f.write("1234567890")
      # 操作完要记得关闭
      f.close()
      
      f = open("a.txt","w")
      f.write("我的贱就是你的贱")
      f.close()
      
      f = open("a.txt","w",encoding=‘utf-8‘)
      f.write("good good")
      f.close()
      
      # 追加内容操作
      f = open("a.txt","a",encoding=‘utf-8‘)
      f.write("艾斯帝王企鹅")
      f.close()
      
      
      f = open("a.txt","a",encoding=‘utf-8‘)
      f.write("
      ")
      f.write("面朝大海,春暖花开")
      f.close()
      
      # 读取文件内容
      f =  open("a.txt",‘r‘,encoding=‘utf-8‘)
      s1 = f.read()
      # 要记得关闭文件
      f.close()
      
      # 改名操作需要引入模块
      import os
      # os.rename("a.txt","b.txt")
      
      # 删除文件,remove()
      os.remove("a.txt")
      
      # 在with语句中可以直接使用对象来做文件操作
      with open("a.txt",‘r‘,encoding=‘utf-8‘) as f:
      #此时文件只能在with中使用,一旦with结束则文件会自动close()
          print(f.read())
      
      # 读取文件中的一行内容
      with open(‘a.txy‘,encoding=‘utf-8‘) as f:
          print(f.readline())
          
      # readlines()这个方法用于一行一行的读取内容,它会一次性将读取到的内容封装到一个列表中返回
      
      # 使用with as写入文件
      with open(‘a.txt‘,‘w‘,encoding=‘utf-8‘) as f:
          f.write(‘youname‘)
      
      # r表示只读
      # w表示可写
      # a表示追加
      # +表示操作符增加功能
      # x用来新建文件,如果文件包不存在则创建,存在则报错
      # r+表示可读与可写,文件不存在会报错
      # seek()方法可以修改当前读取的位置    f.seek()
      # tell()方法用来查看当前读取的位置    f.tell() 
      
  41. 对象

    1. 每个对象都要保存三种数据 id type value

      1. id id用来表示对象的唯一性,可以通过id()函数来查看对象的id,id是由解析器生成,一旦创建,它的id永远不能改变
      2. type 用来标识当前对象所属的类型,比如:int str float等
      3. value 就是对象中存储的具体的数据
    2. 对象在python中,变量中存储的不是对象的值,而是对象的id(内存地址),当我们使用变量时,实际上就是通过对象id在查找对象.

  42. ==和is

    1. 当a的列表跟b的列表相同时,使用==会返回True.比较的是值
    2. 当a的列表跟b的列表相同时,使用is会返回False.比较的是对象,内存地址值不同
  43. 文档字符串

    1. help() 是python中的内置函数,通过help()函数可以查询python中函数的用法

    2. 文档字符串只需要在函数的第一行写一个字符串就是文档字符串,该字符串使用‘‘‘引一下,最终使用help()函数传入函数名

      def fn(a:int,b:bool):
      ‘‘‘
      这是一个文档声明
      a的作用传入int类型的值
      b的作用传入一个bool类型的值
      ‘‘‘
      help(fn)
      
  44. 递归

    1. 简单的理解递归,就是循环自己一直,自己引用自己.

    2. 递归式函数的两个条件:

      1. 基线条件 问题可以被分解为最小问题,当满足基线条件时,递归就不在执行了.
      2. 递归条件 将问题继续分解的条件
    # 求10的阶乘(1*2*3*4*5*...*10)
    # 10!=10*9!
    # 9!=9*8!
    # 8!=8*7!
    # ...
    # 1!=1
    def factorial(n):
        # 该函数用来求任意数的阶乘
        # 基线条件,判断n是否为1,如果为1则此时不能再继续进行递归
        if n==1:
            # 1的阶乘就是1,直接返回1
            return 1
        return n*factorial(n-1)
    print(factorial())
    
  45. 递归的练习

    #   创建一个函数 power 来为任意数字做幂运算 n ** i
    #   10 ** 5 = 10 * 10 ** 4
    #   10 ** 4 = 10 * 10 ** 3
    #   ...
    #   10 ** 1 = 10
    def power(n , i):
        ‘‘‘
            power()用来为任意的数字做幂运算
    
            参数:
                n 要做幂运算的数字
                i 做幂运算的次数
        ‘‘‘
        # 基线条件
        if i == 1:
            # 求1次幂
            return n
        # 递归条件
        return n * power(n , i-1)
    
    # print(power(8,6))    
    

    # 检查指定的字符串是不是回文字符串
    def hui_wen(s):
        ‘‘‘
            该函数用来检查指定的字符串是否回文字符串,如果是返回True,否则返回False
    
            参数:
                s:就是要检查的字符串
        ‘‘‘
        # 基线条件
        if len(s) < 2 :
            # 字符串的长度小于2,则字符串一定是回文
            return True
        elif s[0] != s[-1]:
            # 第一个字符和最后一个字符不相等,不是回文字符串
            return False    
        # 递归条件    
        return hui_wen(s[1:-1])
    print(hui_wen(‘abcdefgfedcba‘))  
    
  46. 函数式编程 在python中,函数时一等对象,有如下几个特点:

    1. 对象是在运行时创建
  47. 能赋值给变量或作为数据结构中的元素

    1. 能作为参数传递
  48. 能作为返回值返回

  49. 高阶函数 至少符合以下两个特点中的一个:

    1. 接收一个或多个函数作为参数
    2. 将函数作为返回值返回
  50. 匿名函数

    1. lambda函数表达式专门用来创建一些简单的函数,他是函数创建的又一种方式

    2. 匿名函数一般都是作为参数使用,其他地方一般不会使用

    3. 语法:lambda 参数列表 : 返回值

      def fn(a,b):
          return a+b
      # 等同于如下的匿名函数
      fn2=lambda a,b : a + b  # 一般不会这么做
      
    4. map()函数可以滴可迭代对象中的所有元素做指定的操作,然后将其添加到一个新的对象中返回

      l=[1,2,3,4,5]
      r=map(lambda i:i+1,l)
      print(list(r))
      
    5. sort()函数

      1. 该方法用来对列表中的元素进行排序

      2. sort方法默认是直接比较列表中元素的大小

      3. 在sort()可以接受一个关键字参数key,它需要一个函数作为参数,当设置了函数作为参数,每次都会以列表中的一个元素作为参数来调用函数,并且使用函数的返回值来比较元素的大小

        # 字符串默认按照unicode编码排序
        l=["a","b","cc","aa"]
        # 使用key=len是按照字符串的长度排序
        l.sort(key=len)
        print(l)
        
        # 直接排序会报错
        m=[1,2,"3",2,"3"]
        # 使用key=int 会暂时转化为int类型排序
        m.sort(key=int)
        print(m)
        
    6. sorted()

      1. 这个函数和sort()的用法基本一致,但是sorted()可以对任意的序列进行排序
      2. 使用sorted()排序不会影响原来的对象,而是返回一个新对象
  51. 装饰器

    1. 希望函数可以在计算前,打印开始计算,计算结束后打印计算完毕

    2. 可以直接通过修改函数满足需求,但产生如下的问题:

      1. 如果修改的函数过多,修改过于麻烦
      2. 不方便维护
      3. 违反开闭原则(ocp) 程序的设计,要求开发对程序的扩展,要关闭对程序的修改
    1. 创建类 class 类名:(正常情况下类名需要大写)

    2. 在类中我们所定义的变量,将会成为所有实例的公共属性,所有实例都可以访问这些变量

    3. 在类中也可以定义函数,类中定义的函数,我们称为方法.这些方法可以通过该类的所有实例来访问

    4. init()函数 在创建一个对象完成时,会自动被调用一般用来初始化对象,self,不需要开发者传递,python解释器会自动把当前对象的引用传递进去.

      #  创建一个persion类,类可以有属性,有函数
      class Person():
          name="吴鹏"
          age=18
          #创建实例对象所传入的参数会跟init有关
          # 在使用init的时候,每次创建一个实例对象就会调用一次
          def __init__(self,name,age):
              print("我的姓名是:{},我的年龄是:{}".format(name,age))
          def info(self,name,age):
              print("我的姓名是:{},我的年龄是:{}".format(name,age))
      # 创建对象,wp是Person的实例
      wp=Person("吴娟",18)
      # 调用的时类中的属性
      print(wp.name)
      # 调用类中的函数,函数后传入了形参,与之对应会有实参
      wp.info("吴磊",18)
      # 检查一个对象是否是一个类的实例,如果是就是true,如果不是则是false
      result=isinstance(wp,Person);
      print(result)
      
      
    5. 在类中创建的方法中会默认添加一个参数,使用pychar系统会给一个self作为参数传递进去

  52. 属性和方法

    1. 当我们调用一个对象的属性时,解析器会现在当前对象中寻找是否含有该属性,如果有则直接返回当前对象的属性值,如果没有,则去当前对象的类对象中去寻找,如果有则返回类对象的属性值,如果没有则报错

    2. 类对象和实例对象中都可以保存属性和方法

      1. 如果这个属性(方法)是所有的实例共享的,则应该将其保存到类对象中
      2. 如果这个属性(方法)是某个实例独有,则应该保存到实例对象中.
      3. 一般情况下,属性保存到实例对象中,而方法保存到类对象中
      4. 在方法中不能直接使用类中的属性,需要使用self.属性名
    3. 类属性,直接在类中定义的属性是雷属性,类属性可以通过类或类的实例访问到,但是类属性只能通过类对象来修改,无法通过实例对象修改.

    4. 实例属性,通过实例对象添加的属性属于实例属性,实例属性只能通过实例对象来访问和修改,类对象无法访问修改

    5. 实例方法可以通过实例和类去调用,当通过实例调用时,会自动将当前调用对象作为self传入,当通过类调用时,不会自动传递self,此时需要手动传递self

    6. 在类内部使用@classmethod来修饰的方法属于类方法,类方法的第一个参数是cls,也会被自动传递,cls就是当前的类对象,类方法可以通过类去调用,也可以通过实例调用,没有区别

    7. 在类中使用@staticmethod来修饰的方法属于静态方法,静态方法不需要指定任何的默认参数,静态方法可以通过类和实例去调用,静态方法基本上是一个和当前类无关的方法.它只是一个保存到当前类中的函数,静态方法一般存放的都是一些工具方法

  53. 类的特殊方法

    1. 在类中可以定义一些特殊方法(魔术方法)

    2. 特殊方法都是以__ 开头,__ 结尾的方法

    3. 特殊方法不需要我们自己调用,不要去尝试调用特殊方法.特殊方法会在特殊的时刻自动调用

    4. 当我们打印一个对象时,实际上打印的是对象中的特殊方法__ str__()的返回值,作用就是制定对象转换为字符串的结果.

    5. __ repr __() 这个特殊方法会在对当前对象使用repr()函数时调用

    6. __ len __ () 获取对象的长度

    7. __ bool __() 返回对象的bool类型

    8. object.__ lt __ (self,other) 小于

    9. object.__ le __ (self,other) 小于等于

    10. object.__ eq __ (self,other) 等于

    11. object.__ ne __ (self,other) 不等于

    12. object.__ gt __ (self,other) 大于

    13. object.__ ge __ (self,other) 大于等于

       class Person:
           # 魔术方法比较对象
           def __init__(self,name,age):
               self.name=name
               self.age=age
           def __lt__(self, other):
               return  self.age>other.age
       
       p1=Person("吴鹏",18)
       p2=Person("吴磊",20)
       print(p1.age>p2.age)
      
    14. __ init __可以在新创建的对象中初始化属性

       class Person():
           name="吴鹏"
           age=18
           def __init__(self,name,age):
               self.name=name
               self.age=age
           def info(self):
               print("我叫:{},今年:{}" .format(self.name,self.age))
       wp=Person("吴鹏",18)
       wp.info()
      
  54. 创建对象的流程

    1. 创建一个变量
    2. 在内存中创建一个新对象
    3. 执行类的代码块中的代码
    4. __ init __(self)方法执行(只在类定义的时候执行一次)
    5. 将对象的id赋值给变量
  55. 封装 (确保对象中的数据安全)

    1. 隐藏对象中一些不希望被外部所访问到的属性或方法

    2. 如何隐藏一个对象中的属性?

      1. 将对象的属性名,修改为一个外部不知道的名字
    3. 如何获取(修改)对象中的属性

      1. 需要提供一个getter和setter方法使外部可以访问的属性
    4. property装饰器

      1. @property 奖get方法转换为对象的属性
      2. @属性名.setter 可以像调用属性一样使用get方法
     class Person:
         def __init__(self, name):
             self.name = name
     	# property装饰器,用来将一个get方法,转换为对象的属性
         # 添加为property装饰器后,我们就可以像调用属性一样使用get方法
         @property
         def get_name(self):
             return self.name
         # 指定setter方法的装饰器 @属性名.setter
         @get_name.setter
         def get_name(self,name):
             self.name=name
     p = Person("吴磊")
     print(isinstance(obj,p))
     print(p.get_name)
    
  56. 继承 (保证了对象的扩展性)

    1. 通过继承可以使一个类获取到其他类中的属性和方法

    2. 在定义类的时候,可以在类名后的括号中指定当前类的父类(超类),子类可以直接继承父类中的所有的属性和方法

    3. 通过继承可以直接让子类获取到父类的方法或属性,避免编写重复性的代码,并且也符合ocp原则,所以我们经常需要通过继承来对一个类进行扩展

    4. 在创建类时,如果省略了父类,则默认父类为object,object是所有类的父类,所有类都继承自object,所有的对象都是object的实例

    5. 多重继承

      1. 在python中是支持多重继承,也就是我们可以为一个类同时指定多个父类
      2. 在类名的()后面添加多个类,逗号隔开来实现多重继承
      3. 多重继承,会使子类同时拥有多个父类,并且会获取到所有父类中的方法
      4. 在开发中没有特殊的情况,尽量避免使用多重继承,因为多重继承会让我们的代码过于复杂
      5. 如果多个父类中有同名的方法,则会在第一个父类中寻找,然后找第二个,然后找第三个,第一个直接就将其他几个类的方法直接覆盖掉
      6. 出现多重继承,如果子类继承了父类,还继承了父类的父类,那么首先先去自身类中寻找,其次在到上一级父类寻找,最终在到父类的父类中寻找,一直到object
    6. 重写

      1. 如果在子类中有和父类同名的方法,则通过子类实例去调用方法时,会调用子类的方法而不是父类的方法
      2. 当我们调用一个对象的方法时,会优先去当前对象中寻找是否具有该方法,如果有则直接调用,如果没有则去当前对象的父类中寻找,如果父类中有则直接调用父类中的方法,如果依然没有则去父类的父类中寻找,一直找到object,如果依然没有找到,则报错.
      3. 父类中的所有方法都会被子类继承,包括魔术方法,如果希望子类中方法中参数多于父类,可以重写特殊方法包括其他方法
      4. 如果想要在子类中直接去使用父类的方法,可以使用父类名.方法名(self,参数),不过这种提高了耦合性,所以一般将父类名改成super()这样,父类进行修改的时候,子类动态修改了父类,并且通过super返回对象调用父类方法时,不需要传递self
    7. 多态 (保证了程序的灵活性)

      1. 定义一个不在类中的函数,只要对象中有属性,就可以作为参数传递到该函数,这个函数不会考虑对象的类型,只要该对象中有属性即可
      2. 一般在开发过程中像isinstance()这种函数,在开发中一般是不会使用的
  57. 模块化

    1. 采用模块化,统一将所有的代码编写到一个文件中

    2. 优点:方便开发,方便维护,模块可以复用.

    3. import语句一般引用在程序的开头位置

    4. 在一个模块中引入外部模块

      1. import 模块名
      2. import 模块名 as 模块别名
      3. import 目录名.模块名
    5. 在每一个模块内部都有一个__ name __属性,通过这个属性可以获取到模块的名字

    6. 访问模块中的变量:模块名.变量名

    7. 也可以引入模块中的部分内容

      1. 语法:from 模块名 import 变量1,变量2,...
      2. 引入所有的变量,类也属于一种特殊的变量 语法:from 模块名 import *,这种情况一般不会使用
      3. 也可以为引入的变量使用别名 语法:from 模块名 import 变量 as 别名
      4. 添加了带_的变量,只能在模块内部访问,只针对于访问模块中部分内容带*号的情况
    8. 编写测试代码,有些代码在当前文件作为主模块的时候才需要执行,而当模块被其他模块引入时,不需要执行,此时我们就必须要检查当前模块是否是主模块

      if __name__=="__main__":
          test() # 调用方法
      
      1. 也是一个模块,包中必须要一个一个__ init __.py这个文件,这个文件中可以包含主要内容
      2. 如果直接引入包的话,只能直接调用包中的__ init __.py文件中的属性,要想调用其他文件中的属性,需要引入包指定的文件名 语法:from 包名 import 指定文件名
  58. python的标准库

    1. 标准库会随python的安装一同安装

    2. sys模块

      1. sys.argv 表示获取执行代码时,命令行中所包含的参数,该属性是一个列表,列表中保存了当前命令的所有参数
      2. sys.modules 表示获取当前程序中引入的所有模块,modules是一个字典,字典的key是模块的名字,字典的value是模块的对象
      3. sys.path 是一个列表,列表中保存的是模块的搜索路径
      4. sys.platform 表示获取当前python运行的平台
      5. sys.exit() 函数用来退出程序
    3. os模块

      1. os.environ 通过这个属性可以获取到系统的环境变量,如果想要获取指定path的环境变量os.environ[‘path‘]
      2. os.system() 可以用来执行操作系统的名字 比如目录:os.system(‘dir‘)
    4. pprint模块

      1. pprint.pprint() 用来对打印的数据做简单的格式化
  59. 异常

    1. 程序运行时出现异常,目的并不是让我们的程序直接终止!python是希望在出现异常时,可以编写代码来对异常进行处理.

    2. 异常的处理语法:

      try 语句
      	try :
      		代码块(可能出现错误的语句)
      	except:
      		代码块(出现错误以后的代码)
          finally:
      	else:
      		代码块(没出错时要执行的语句)
      
    3. 可以将可能出错的代码放到try语句,这样如果代码没有错误,则会正常执行,如果出现错误,则会执行expect子句中的代码,这样我们就可以通过代码来处理异常,避免因为一个异常导致整个程序的终止.

    4. 异常的传播

      1. 当在函数中出现异常时,如果在函数中对异常进行了处理,则异常不会再继续传播,.

      2. 如果函数中没有对异常进行处理,则异常会继续向函数调用处传播

      3. 如果函数调用处处理了异常,则不再传播,如果没有处理则继续像调用处传播,知道传递到全局作用域(主模块)如果依然没有处理,则程序终止,并且显示异常信息

      4. 当程序运行过程中出现异常以后,所有的异常信息会被保存到一个专门的异常对象中,而异常传播时,实际上就是异常对象抛给了调用处

      5. 如果except后不跟任何的内容,那么此时会补货到所有的异常

      6. 如果except后跟着一个异常的类型,那么此时只会捕获该类型的异常 except NameError:

      7. Exception是所有异常类的父类,所以如果except后跟的是Exception他也会捕获到所有的异常

      8. 可以在异常类后面跟一个as xx此时的xx就是异常对象

      9. finally是无论是否出现异常,该子句都会执行.

        print(‘异常出现前‘)
        l=[]
        try:
        	print(c)
        	l[10]
            print(10/0)
        except NameError:
            print(‘出现NameError异常‘)
        except ZeroDivisionError as zde:
            print(‘出现ZeroDivisionError异常‘,zde)
        except:
            print(‘未知异常‘)
        print(‘异常出现后‘)
        
    5. 抛出异常

      1. 可以使用raise语句来抛出异常,raise语句后需要跟一个异常类或异常的实例

        def add(a,b):
            if a<0 or b<0:
                raise Exception("a跟b不能为负值")
            return a+b
        
        add(-1,20)
        

         

      2. 抛出异常的目的就是,告诉调用者这里调用时出现问题,希望你自己处理一下.

      3. 自定义异常 class MyError(Exception): 然后调用的时候直接调用MyError就可

以上是关于python语法的主要内容,如果未能解决你的问题,请参考以下文章

在下面的代码片段中的剩余 ='passthrough' 处的代码中出现语法错误

常用python日期日志获取内容循环的代码片段

python 有用的Python代码片段

Python 向 Postman 请求代码片段

python [代码片段]一些有趣的代码#sort

[Python]常用代码块