python查阅笔记

目录

  1. 行连接符:\
  • 作用:一行代码太长时,换行写要用 ’ \ ‘

    a = 'abcdef\
    ghigklmn\
    opqrst'
    print(a)
    输出:abcdefghigklmnopqrst
    
  1. 对象:标签,类型,值
a = 6
'''
创建了一个
	标签:xxxxx
	类型:int
	值:6
的内存块
a是一个指向该内存块标签的变量。
'''
  • 变量位于:栈内存

  • 对象位于:堆内存

  1. 删除变量与垃圾回收:del
a = 123
del a
#变量a被压出栈,变量a所对应堆中的对象会被垃圾回收。
  1. 链式、系列解包赋值
a = b = 123
#相当于:a=123;b=123
#将对象123的标签赋值给a和b

a,b,c = 1,2,3
#相当于:a=1,b=2,c=3

a,b = b,a
#相当于把a,b的值互换
  1. 常量:python不支持常量,逻辑上将全大写变量视为常量。
  2. 运算符:
    • 整除:’ // ‘ :做除法,舍去余数

    • 增强型:+= ,-= , /= , //= 等等…

      a += 1
      a -= 1
      #相当于:a=a+1、a=a-1
      
    • **同一运算符:**is

      a = 3
      b = 3
      a is b
      #输出:true
      #同一运算符用来比较两个对象的存储单元地址(id)是否一致
      
    • 相等运算符:==

      a = 3
      b = 3
      a == b
      #输出true
      #相当运算符判断两个对象的值(value)是否一致
      
    • **整数缓存问题:**python命令行下会对较小的整数【-5~256】进行缓存。

      a = 1000
      b = 1000
      a is b
      #输出false,原因是整数1000>256,python会为其创建一个新的内存块
      a = 3
      b = 3
      a is b
      #输出true,原因是整数3<256,python会缓存该内存块,并且直接使用
      

      在文件下,解释器会优化该部分,【-5~任意正整数】都会被缓存

    • **字符串驻留:**类似于整数缓存,python对符合标识符规则的字符串(下划线,字母,数字)会启用字符串驻留机制。

      a = 'abc_d'
      b = 'abc_d'
      a is b
      #输出true,原因是 a 创建的内存块被python驻留,而 b 直接赋值了该驻留的块的id,而并没有创建新的块。
      
    • 成员操作符:in、not in 用来判断 某个子字符是否存在于字符串中。

      a = 'abc'
      b = 'a'
      b in a
      #输出:true 很显然 b 中的值是 a 值的成员(一部分)
      
    • 位移:>>右移(除2)、<<左移(乘2)

    • 位运算符:^ 异或、| 或、& 与

  3. 函数:
  • divmod( ):得到商和余数

    divmod(13,3)
    返回:(4,1)
    
  • int( ):将小数取整、将布尔转换为 ’ 0 , 1 ‘ 、将字符串转换为数值型(必须符合数值类型)

  • float( ):同int( ),转为浮点型

  • str( ):同int( ),转为字符串型

  • print(‘字符’,end=’默认换行符‘):end=’任意字符‘,修改’任意字符‘print( )结尾就不是换行符了。

  • input(‘提示字符’):接受用户的输入。

  • list(‘数据’):将任何可迭代的数据转化成为列表

    • a = list(range(10))
      b = list("abcdef")
      #输出:[0,1,2,3,4,5,6,7,8,9],['a','b','c','d','e','f']
      
  1. 进制:
  • 0b:二进制
  • 0o:八进制
  • 0x:十六进制
  1. 字符提取:[]
    a = 'abcdefg'
    print(a[0])
    print(a[-1])
    #输出:a,g
    #用来截取单个字符,索引起始为0,截止为len(a)-1
    
  • 切片:[起始:结束:步长] 用于快速的提取字符

    a = 'abcd'
    print(a[1:4])
    #输出:‘abc’ 这体现了切片’包头 不包尾‘的特性
    print(a[1:5:1])
    print(a[1:5:2])
    #输出:’abcd‘ ’ac‘ 步长是指,一次处理n个字符,并提取第一个
    #很明显,步长为1,处理了所有的字符;步长为2,处理了’ab‘,提取了'a'
    #处理了’cd‘,提取了’c‘
    
  1. 方法:
  • ***x.replace(’ a ',’ b ‘ )***: 将 x 中的字符’ a ‘替换为’ b ‘

    • 该方法不会改变原来 x 的值,而是创建一个新的对象。
  • **x.split( ’ 分隔符 ’ ):**将 x 中的字符 按照 ’ 分割符 ‘ 进行分割成列表。

  • “连接符”.join( x ): 将 x 中的字符系列[列表] 用’ 连接符 ‘连接起来。

    a = ['text','val','ten']
    '@'.join(a)
    #输出:text@val@ten
    #join性能优于 ’ + ‘ ,因为字符是不可变的,但列表是可变的 
    
  • 查找方法:

    • len(a):返回字符串长度【中英同等地位】
    • x.startswith(’字符串‘):返回 x 是否以 ’ 字符串 ‘ 作为开头
    • x.endswith(‘字符串’):返回 x 是否以 ‘字符串’ 作为结尾
    • x.find(‘字符串’):返回 ‘ 字符串 ’ 在 x 中第一次出现的位置
    • x.rfind(‘字符串’):返回‘ 字符串 ’ 在 x 中最后一次出现的位置
    • x.count(‘字符串’):返回‘ 字符串 ‘ 在 x 中出现了几次

    【判断方法】:

    • x.isalnum( ):返回 x 中的值是否全部为数字或者字母
    • x.isspace( ):返回 x 中的值是否全部为空白符
    • x.isdigit( ):返回 x 中的值是否全部为数字
    • x.isalpha( ):返回 x 中的值是否全为字母或汉字
  • 去除首尾信息:

    • x.strip(’字符‘):去除 x 首尾的字符,默认是空格
    • x.lstrip(’字符‘):去除 x 首部的字符,默认是空格
    • x.rstrip(’字符‘):去除 x 尾部的字符,默认是空格
  • 格式排版:

    • x.center(’长度‘,’补齐‘):将 x 的值居中,两头根据指定长度用’ 补齐 ‘来填充,默认用空格填充
    • x.rjust(’长度‘,’补齐‘):同center( ),右对齐。
    • x.ljust(’长度‘,’补齐‘):同center( ),左对齐。
  • x.format( ):接受 n 个参数替换 x 中的占位符{ }

    • 占位符 {索引/参数名}:代替了原来的%
      • 用来代替不确定的值,当调用format时,format的参数替换该占位符
    a = 'yes i am {0},i like {1}'
    a.format('zlx','apple')
    #输出:'yes i am zle,i like apple' 使用索引占位符时要注意顺序,0就是format参数中的第一个值,依次...
    
    a = 'yes i am {name},i like {thing}'
    a.format(name='zlx',thing='apple')
    #输出:'yes i am zle,i like apple' 使用参数名占位符不需要注意顺序,只要名称对应即可。
    
    • 占位符用法:

    • {索引/参数名 (😃 (填充字符) (<,左对齐,>右对齐,^居中) (长度) (类型f,d,e,%) }

      {:*^8}.format('yes')
      #输出:**yes*** 长度为8,填充字符为*,居中对齐,替换字符为’yes‘
      
列表:
  • 列表的创建:

    • list()创建
    • 推导式创建:[「表达式」 「for 变量 in 列表」『 if x == 条件』]
  • 列表的增加与删除:

    • 增加

      • x.append(元素):在列表尾部增加

      • x=x+[元素]:创建新列表,替换原来的列表,并不是简单的添加。

      • x.extend([列表]):将目标列表的元素添加到本列表尾部。

      • a = [1,2,3]
        a.append([4,5])
        #输出:[1,2,3,[4,5]]直接将[4,5]列表添加到了尾部
        a.extend([6,7])
        #输出:[1,2,3,[4,5],6,7]将两个列表合并成了一个
        
    • 插入:

      • x.insert(索引,元素):将元素插入 x 指定索引处
    • 删除:

      • del x[索引]:将指定索引的元素删除
      • x.pop (n):将指定索引的元素删除,并返回值,未指定默认弹出最后一个元素。
      • x.remove (值):删除首次出现的值,如果没有则提示异常
    • 获得:

      • x.index (值,start,end):返回 指定值在列表中 首次出现的索引。start和end指定了搜索的范围。
    • 排序:

      • x.sort(reverse=True):对列表进行修改排序,默认升序。
      • 函数sorted(x,reverse=True):创建的已排序列表,不改变原来的列表。
      • 函数reversed(x):返回一个逆序迭代器,可以用list(迭代器)创建一个逆序列表。迭代器只能使用一次。
    • 数学函数:

      • max( x ):返回列表中的最大值
      • min( x ):返回列表中的最小值
      • sum( x ):对数值型列表进行求和
    • 多维列表:

      a = [
        ['搞笑二',18,3000,'上海'],
        ['找小三',19,4000,'北京'],
        ['王麻子',20,2000,'深圳']
      ]
      a[0]
      #输出:['搞笑二',18,3000,'上海']
      a[0][2]
      #输出:3000,a的第一个元素列表中 的第二个元素。
      
元组:
  • 元组属于不可变序列,不能修改元组中的元素。

  • 元组的创建:

    • tuple(可迭代对象)
    • x = (元素1,元素2…)
    • x = 元素1,元素2,元素3,…
    • 注意:单个元素这样写 x = (20,) 否则解释器会认为是整数类型不是元组。
  • 访问:x [索引] 或 x [切片]

  • 合成:

    • 连字符 ‘ + ’ :将两个元组合并

    • 函数zip(列表1,列表2,列表3…)

      • a = [1,2,3]
        b = [4,5,6]
        c = [7,8,9]
        d = zip(a,b,c)
        list(d)
        #输出:[(1,2,3),(4,5,6),(7,8,9)]
        #该函数将 多个列表 转换为 等量元组 并合并起来,返回这个对象。
        
    • 生成器:s = ([表达式] [for 变量 in 数据] [if 条件])

    • s.__next__():用来将生成器中的值一个个取出。

    • 注意:生成器实际上就是一个内存块指针,每次取值,指针会向后移动,直到生成器尾部。移动后的生成器不可复原,因此生成器是一次性的。

字典:
  • 字典的创建:

    • a = { ’ 键 ’ :’ 值 ’ ,…}:键是任意 不可改变 的数据,如:整数,浮点数字符串,元组。且键是 不可重复 的!

    • **函数dict(键=值,…)**或 dict( [ (键,值),(键,值) ] )

    • 函数zip(列表1,列表2):zip函数将 列表1 和 列表2 打包起来,在用dict()转换为字典时时,列表1 作为字典键,列表2 作为字典的值。

      • a = ['car','color','food']
        b = ['bus','red','apple']
        c = zip(a,b)#将 a ,b 打包为新的对象 赋值给c
        dict(c)#将 c 转换为字典,其中 a 作为键, b 作为值
        
    • Dict.fromkeys([键1,键2,键3,…]):创建空值的字典

  • 字典的访问:

    • a.[键]:访问值,键不存在返回错误❌
    • a.get[‘键’,‘默认值‘]:推荐使用。可以访问不存在的键,返回NONE。也可以为其制定 默认值 ,如果 键 不存在则返回默认值。
    • a.items():列出所有的 键和值
    • a.keys():列出所有的
    • a.values():列出所有的
  • 字典的 修改 添加 删除

    • 添加:

      • a[键] = ‘值’
      • a.update(字典):将新字典的所有 键值 添加到 a 中,键重复的直接覆盖。
    • 删除:

      • del( a[键] )
      • clear(字典):删除所有的 键值对
      • a.pop(键):弹出指定的 键值对
      • a.popitem():随机弹出 键值对
    • 序列解析包:方便的给多个变量赋值

      • s = ['name':'zlx','age':19,'job':'student']
        a,b,c=s
        #这里将s的 键 赋值给了a,b,c
        a,b,c=s.values()
        #这里将s的 值 赋值给了a,b,c
        a,b,c=s.items()
        #这里将s的 键值对 赋值给了a,b,c
        
模块:
  • time:时间模块
  • io:可变字符串
    • s=io.StingIO(x):将可变字符串 x 的id赋值给s
    • s.getvalue( ):获得 s 的值
    • s.seek(n):指向 s 值的第n个字符
    • s.write(‘字符’):修改当前指向的值
  • turtle:海龟绘图
  • random:乱序
  • random.shuffle(x):列表 x 的元素打乱顺序。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值