Python学习笔记2

作者: MetaT1an | 来源:发表于2018-08-24 20:54 被阅读17次

    数据类型

    Python数据类型

    数值

    整数
    # 二进制
    n1 = 0b1010
    
    # 八进制
    n2 = 0o567
    
    # 十六进制
    n3 = 0xfdc2
    
    浮点数
    # 一般形式
    n1 = 3.14
    
    # 科学计数法
    n2, n3 = 3.2e6, 1.2e-3
    
    简单数学函数
    • 内建函数
      • abs(num):
        # 返回数的绝对值
        n1, n2, n3 = 1, 0, -1
        print(abs(n1), abs(n2), abs(n3))   # 1 0 1
        
      • max(num)min(num):
        # 参数不定长
        n1, n2, n3, n4 = 1, 2, 3, 4
        print(max(n1, n2), min(n2, n3 , n4))     # 2 4
        
        # 接收可迭代对象
        li = [1, 2, 3, 4]
        print(max(li))  # 4
        
      • round(num, n]):
        # 四舍五入
        # n表示四舍五入的小数位数,不写默认是0(取整)
        
        pi = 3.14159
        print(round(pi))    # 3
        print(round(pi, 3))     #3.142
        
    • math模块中的函数
      • ceil():
        # 用来向上取整
        
        import math
        
        pi = 3.14159
        print(round(pi))    # 3
        print(math.ceil(pi))    # 4
        
        print(round(pi + 0.5)) # 可以替代ceil()
        
      • floor():
        # 用来向下取整
        
        import math
        
        x = 3.678
        print(round(x))     # 4
        print(math.floor(x))     # 3
        
        print(floor(x - 0.5)) # 可以替代floor()
        
      • sqrt():
        # 平方根运算
        import math
        
        print(math.sqrt(16))    # 4
        print(math.sqrt(17))    # 4.123105635
        
    随机函数
    • random():
      import random
      
      print(random.random())    # 生成[0, 1)的一个小数
      
    • choice(seq):
      import random
      
      li = [1, 2, 4, 5]
      print(random.choice(li))  # 从对应的列表中随机选择一个元素
      
    • uniform(x, y):
      import random
      
      print(random.uniform(1, 3)    # 得到[1, 3]之间的随机小数
      
    • randint(x, y):
      import random
      
      print(random.randint(1, 5))     # [1, 5]之间的随机整数
      
    • randrange(start, stop, step):
      import random
      
      print(random.randrange(2, 10, 2)  # 参数类型与range()函数一样
      # 相当于random.choice([2, 4, 6, 8])
      
    三角函数
    import math
    
    angle = 1 / 6 * math.pi     # 30°, pi/6
    res1 = math.sin(angle)      # 接收弧度值
    
    angle = math.radians(30)    # 将角度值转换为弧度值
    res1 = math.cos(angle)
    

    布尔类型

    • int的子类型
      # True = 1, False = 0
      # 可以与整数进行运算
      print(2 + True)   # 3
      print(1 + False)   # 1
      
    • 是一种单独的类型
      flag, tag = True, False
      
    • 当作判定条件使用
      if True:
          # todo
      

    字符串

    字符串表示方式
    str = 'abc'     # 单引号对
    str = "abc"     # 双引号对
    str = '''abc'''     # 三个单引号
    str = """abc"""     # 三个双引号
    
    # 混合表示,去掉字符串两端的限制符号就得到字符串数据
    # 可以避免使用引号的转义来表示引号
    str = "his name is 'rity', that is a good name"
    
    # 使用转义字符来完成
    str = "his name is \'rity\', that is a good name"
    
    # 消除字符串的转义
    str1 = "That\'s all"
    str2 = r"That\'s all"    
    
    print(str1)  # That's all
    print(str2)  # That\'s all
    
    # 字符串的跨行表示
    
    str = "his name is 'rity', " \
        "that is a good name"
    
    str = ("his name is 'rity', "
        "that is a good name")
        
    """
    可以直接在三对双引号内进行换行
    多用于程序的注释
    ---end---
    """
    
    字符串的操作
    • 一般操作
      • 字符串拼接
        res1 = "abc" + "def"
        print(res1)    # abcdef
        
        res2 = "abc" "def"
        print(res2)    # abcdef
        
        res3 = "%s%S" % ("abc", "def")
        print(res3)    # abcdef
        
      • 字符串的乘法
        res = "a" * 3
        print(res)    # aaa
        
      • 字符串的切片
        str = "abcdefg"
        
        # 获得单个字符
        print(str[3])   # d
        print(str[-1])   # g
        
        # 获得字符串片段
        # str[start:end:step]
        # 默认值:start=0, end=len(str), step=1
        # 获得范围 [start, end)
        
        print(str[::])      # abcdefg
        print(str[0:len(str):1])    # agcdefg
        
        print(str[::2])     #aceg
        print(str[::-1])     #gfedcba
        
    • 函数操作
      • len():
        # 可用于所有可迭代对象
        # 计算字符串中字符的个数
        
        name1, name2 = "rity", "瑞迪"
        print(len(name1), len(name2))     # 4 2
        
      • find():
        # 查找子串的索引
        # find(substr, start, end)
        # 默认值:start=0, end=len(str)
        
        str = "abcdabefg"
        print(str.find("ab"))   # 0
        print(str.find("ab", 1))    # 4
        print(str.find("xy"))   # -1
        
      • count():
        # 计算子字符串出现的个数
        # count(sub, start, end)
        # 默认值:start=0, end=len(str)
        
        str = "abcda"
        print(str.count("a"))     # 2
        print(str.count("a", 2)     # 1
        print(str.count("x"))     # 0
        
      • replace():
        # 用给定的新字符串替换旧的字符串
        # replace(old, new, count)
        # 默认值:count(省略),全部替换
        
        str = "abacad"
        print(str.replace("a", "A"))    #AbAcAd
        print(str.replace("a", "A", 2))    #AbAcad
        print(str)  # abacad
        
      • ljust() 和 rjust():
        # 对字符串进行长度调整(扩长)
        # ljust(width, fillchar)
        # width:要扩展到的长度,fillchar:填充的字符
        
        str = "abc"
        print(str.ljust(6, "x"))    # abcxxx
        print(str.rjust(6, "x"))    # xxxabc
        print(str)      # abc
        
      • lstrip() 和 rstrip() 和 strip()
        # 移除字符串指定位置的字符
        # lstrip(str)
        # 默认值:str是空字符集
        
        name = "xi am rity ."
        print(name.lstrip("ix"))    # | am rity .|
        print(name.rstrip(". ")     # |xi am rity|
        print(name.strip("ix."))    # | am rity |
        
      • split():
        # 将父字符串分割成几个子字符串
        # split(sep, maxsplit)
        # sep:要分割的字符,maxsplit:最大分割次数
        # 默认值:maxsplit(省略),全部分解
        # 返回字符串列表
        
        info = "rity,nanchang,158-7926-7420"
        res = info.split(",")
        print(res)  # ['rity', 'nanchang', '158-7926-7420']
        
      • partition():
        # 把整个字符串分三部分
        # partition(sep)
        # 从左往右找
        # 返回一个元组(分隔符左侧, 分隔符, 分隔符右侧)
        
        pi = 3.14159
        res1 = pi.partition(".")
        res2 = pi.partition("-")
        print(res1)      # ('3', '.', '14159')
        print(res2)      # ('3.14159', '', '')
        
      • join():
        # 用指定的字符串,对可迭代参数进行拼接,返回字符串
        # "xx".join(iterable)
        # 与split()的作用相反
        
        li = ["137", "9878", "0098"]
        res1 = "-".join(li)
        res2 = "".join(li)
        print(res1)      # 137-9878-0098
        print(res2)     # 13798780098
        
      • isalpha(), isdigit(), isalnum()
        str1, str2, str3, str4, str5 = "agcD", "123", "2j3e4ef", ""
        
        print(str1.isalpha())   # True
        print(str2.isdigit())   # True
        print(str4.isalnum())   # True
        print(str5.isalpha(), str5.isdigit(), str5.isalnum())   # False False False
        
      • startswith() 和 endswith()
        # 是否以某个前缀开头/结尾,范围 [start, end)
        # startswith("xx", start, end)
        # 默认值:start=0, end=len(str)
        
        name = "2018-08-09: xxx报告"
        file = "xxx.md"
        
        print(name.startswith("2018"))  # True
        print(file.endswith(".md"))  # True
        

    列表

    有序可变元素的集合

    表示方式
    # 元素类型单一
    li = ["a", "b", "c"]
        
    # 多种类型的元素
    li = ["a", "b", 1, 2, True]
        
    # 列表可以相互嵌套
    li = [[1, 2, 3], 2, True, "hehe"]
        
    # list()函数,参数为可迭代对象
    li = list(range(1, 4))      # [1, 2, 3]
    li = list("abc")    # ('a', 'b', 'c')
        
    # 列表推导
    nums = [1, 2, 3, 4, 5]
    li = [n*n for n in nums if n % 2]
    print(li)   # [1, 9, 25]
    
    常用操作
    • append():

      # 向列表的尾部添加元素
      
      nums = [1, 2, 3, 4]
      nums.append(5)
      print(nums)     # [1, 2, 3, 4, 5]
      
    • insert:

      # 向列表中的任意位置插入元素
      
      nums = [1, 2, 3, 4]
      nums.insert(1, 9)
      print(nums)       # [1, 9, 2, 3, 4]
      
    • extend():

      # 合并两个列表
      
      nums1, nums2 = [1, 2], [3, 4]
      nums1.extend(nums2)
      print(nums1)      # [1, 2, 3, 4]
      
    • del语句:

      nums = [1, 2, 3]
      del nums[0]
      print(nums)   # [2, 3]
      
      # del用来删除所引用的对象
      
    • pop():

      # 移除并返回列表中指定索引的元素
      # pop(index)
      # 默认值:index(不写),删除返回最后一个
      
      nums = [1, 2, 3]
      res = nums.pop()
      print(nums, res)      # [1, 2] 3
      
    • remove():

      # 移除列表中指定的元素
      # remove(obj)
      # 若元素不存在会报错,若有多个元素,删除最左边的那个
      
      names = ["Rity", "Jack", "Tom"]
      names.remove("Jack")
      print(names)      # ["Rity", "Tom"]
      
      # 遍历删除元素会出现错误
      # 元素删除后影响了列表的结构,进而影响了遍历的过程
      nums = [1, 2, 2, 3, 4, 2]
      for n in nums:
          if n == 2:
              nums.remove(n)
      print(nums)       # [1, 3, 4, 2]
      
    • index():

      # 获得元素所在的索引值,查找范围:[start, end)
      # index(obj, start, end)
      # 默认值:start=0, end=len(list)
      
      li = [12, 34, 99]
      idx = li.index(34)
      print(idx)    # 1
      
    • count():

      # 获得其中某个元素的个数
      li = [1, 1, 2, 3, 5]
      print(li.count(1))    # 2
      
    • 切片:参考字符串切片

    • 列表遍历

      # 索引问题
      
      val = ["a", "b", "a", "d"]
      currentIdx = 0    # 解决index("a")恒为0的问题
      for v in val:
          idx = val.index(v, currentIdx)
          print(idx, v)
          currentIdx += 1
      
      # 建立索引列表
      idxList = list(range(0, len(val)))
      for idx in idxList:
          print(idx, val[idx])
      
      # 利用枚举对象
      val = ["a", "b", "c", "d"]
      print(list(enumerate(val)))   # [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
      
      for idx, val in enumerate(val):
          print(idx, val)
      
    • 排序

      # ----------------------------------------
      # 使用内建函数 sorted(),可以对所有可迭代对象排序
      # sorted(itrearble, key=None, reverse=False)
      # 不改变原对象,以列表的形式返回处理后的结果
      # 默认按照升序排列
      
      s = "acgehijd"
      res = sorted(s)
      print(res)    # ['a', 'c', 'd', 'e', 'g', 'h', 'i', 'j']
      print(sorted(s), reverse=True)    # ['j', 'i', 'h', 'g', 'e', 'd', 'c', 'a']
      
      
      # 指定关键字进行排序
      def getKey(x):
          return x[1]
          
      li = [("s0", 18), ("s1", 17), ("s2", 16)]
      res0, res1 = sorted(li), sorted(li, key=getKey)
      print(res0)   # [("s0", 18), ("s1", 17), ("s2", 16)]   
      print(res1)   # [("s2", 15), ("s1", 17), ("s0", 18)]
      
      # -----------------------------------------
      # 使用列表的对象方法
      # 直接修改原对象
      # 参数列表与 sorted()相同
      
      li = [1, 3, 5, 2, 0]
      li.sort()
      print(li)     # [0, 1, 2, 3, 4, 5]
      
    • 乱序

      # 打乱列表中元素的顺序
      # 直接修改原对象
      
      import random
      
      li = [1, 2, 3, 4, 5]
      random.shuffle(li)
      print(li)     # [2, 4, 3, 1, 5]
      
    • 反转

      # 使用reverse()直接修改原对象
      
      li = [1, 2, 4, 0]
      li.reverse()
      print(li)     # [0, 4, 2, 1]
      
      # 使用切片操作获得新的对象
      li = ["ss", "yu", "sfj"]
      res = li[::-1]
      print(li, res)    # ["ss", "yu", "sfj"] ['sfj', 'yu', 'ss']
      

    元组

    有序的不可变的元素集合,切片和根据索引获得单个元素的方式和列表相同。

    表示方法
    # 单元组
    t = (1,)
    
    # 多元组
    t1, t2 = (1, 2), (2, 3, 9, 0)
    
    # 复合元组
    t = ("abc", [1, 2], 666)
    
    # 嵌套元组
    t = ("rity", (18, "nanchang"))
    
    # tuple()函数,用法与list()相同
    
    拆包操作
    t = (1, 2, 3)
    a, b, c = t
    print(a, b, c)  # 1 2 3
    

    字典

    无序可变键值对的集合

    表示方式
    • key不能重复,若有重复,后定义的覆盖前面定义的
    • key的类型必须是不可变的类型
      • 可变类型(列表,字典,可变集合)
      • 不可变类型(数值,布尔,字符串,元组)
    • Python的字典是通过哈希(hash)的方式实现的,计算键的哈希值,存储在哈希表中。
    person = {"name": "rity", "age": 18}
    print(person, type(person))     # {'name': 'rity', 'age': 18} <class 'dict>'
    print(person["name"])   # rity
    print(person["age"])    # 18
    
    d = dict.fromkeys("abc", 666)
    print(d)    # {'a': 666, 'b': 666, 'c':666}
    
    添加元素
    d = {"name": "s1", "age": 18}
    d["height"] = 175
    
    d["height"] = 180   # 若键已经存在,则会修改原来对应的值
    
    # 多次打印的结果可能不同,因为字典是无序的
    print(d)    # {'age': 18, 'name': 's1', 'height': 175}
    
    # 使用 d0.update(d1)
    # 将两个字典合并,若旧字典中有对应的 key,则更新;否则添加
    
    d.update({"year": 1997, "height":180})
    
    删除元素
    d = {"name": "s1", "age": 18}
    
    # 使用 del直接删除键值
    # 删除不存在的键值对会直接报错
    
    del d["name"]   
    print(d)    # {"age": 18}
    del d["name1"]  # KeyError: 'name1'
    
    # dic.pop()
    # 删除指定的键值对,并返回对应的值
    # 删除不存在的键值对会直接报错
    
    v = d.pop("age")
    print(v, d)     # 18 {'name': 's1'}
    
    # dic.popitem()
    # 删除按升序排序后的第一个键值对,并以元组的形式返回键值对
    # 字典为空报错
    
    res = d.popitem()
    print(res)      # ('age', 18)
    
    # dic.clear()
    # 清空字典,空字典,不是未定义的对象
    
    d.clear()
    print(d)    # {}
    del d
    print(d)     # 报错
    
    获得元素
    d = {"name":"Rity", "age": 18}
    
    # 下标访问
    print(d["name"])    # Rity
    print(d["height")   # 报错,键不存在
    
    # dic.get(key, default)
    # 键不存在不会报错,default是键不存在时的返回值,默认为 None
    
    print(d.get("age"))     # 18
    print(d.get("height"))  # None
    print(d.get("height", 170)  # 170
    
    遍历
    d = {"name":"Rity", "age": 18}
    
    #-------------------------------------
    # 下面三种方法返回的是一个 Dictionary view objects, 虽然以列表的形式展现,但严格来说不是列表
    # 不支持索引访问,但可以使用 list()来转换成普通的列表对象
    # 特点:当字典被修改后,以下 ks, vs, itms会同步修改
    
    # 获取所有的键
    ks = d.keys()
    print(ks)   # dict_values(['Rity', 18])
    
    # 获取所有的值
    vs = d.values()
    print(vs)   # dict_keys(['name', 'age'])
    
    # 获取所有的键值对
    itms = d.items()
    print(itms)    #dict_items([('name', 'Rity'), ('age', 18)])
    
    #-------------------------------------
    # 字典是可迭代对象,使用 for in
    # 若直接遍历字典,得到的是它的键
    
    for x in d.items():
        print(k, end=' ')   # ('name':'Rity') ("age":18)
        
    # 元组解包
    for k, v in d.items():
        print(k, v, sep='-')   # name-Rity age-18
    

    相关文章

      网友评论

        本文标题:Python学习笔记2

        本文链接:https://www.haomeiwen.com/subject/xmiiiftx.html