Python学习笔记2

Python数据类型

数值

整数

# 二进制n1 = 0b1010# 八进制n2 = 0o567# 十六进制n3 = 0xfdc2

浮点数

# 一般形式n1 = 3.14# 科学计数法n2, n3 = 3.2e6, 1.2e-3

简单数学函数

• 内建函数

  • abs(num):

    # 返回数的绝对值n1, n2, n3 = 1, 0, -1print(abs(n1), abs(n2), abs(n3))   # 1 0 1

  • max(num) 和 min(num):

    # 参数不定长n1, n2, n3, n4 = 1, 2, 3, 4print(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.14159print(round(pi))    # 3print(round(pi, 3))     #3.142

• math模块中的函数

  • ceil():

    # 用来向上取整import math
    
    pi = 3.14159print(round(pi))    # 3print(math.ceil(pi))    # 4print(round(pi + 0.5)) # 可以替代ceil()

  • floor():

    # 用来向下取整import math
    
    x = 3.678print(round(x))     # 4print(math.floor(x))     # 3print(floor(x - 0.5)) # 可以替代floor()

  • sqrt():

    # 平方根运算import math
    
    print(math.sqrt(16))    # 4print(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/6res1 = math.sin(angle)      # 接收弧度值angle = math.radians(30)    # 将角度值转换为弧度值res1 = math.cos(angle)

布尔类型

• 是int的子类型

  # True = 1, False = 0# 可以与整数进行运算print(2 + True)   # 3print(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 allprint(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)    # abcdefres2 = "abc" "def"print(res2)    # abcdefres3 = "%s%S" % ("abc", "def")
    print(res3)    # abcdef

  • 字符串的乘法

    res = "a" * 3print(res)    # aaa

  • 字符串的切片

    str = "abcdefg"# 获得单个字符print(str[3])   # dprint(str[-1])   # g# 获得字符串片段# str[start:end:step]# 默认值：start=0, end=len(str), step=1# 获得范围 [start, end)print(str[::])      # abcdefgprint(str[0:len(str):1])    # agcdefgprint(str[::2])     #acegprint(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"))   # 0print(str.find("ab", 1))    # 4print(str.find("xy"))   # -1

  • count():

    # 计算子字符串出现的个数# count(sub, start, end)# 默认值：start=0, end=len(str)str = "abcda"print(str.count("a"))     # 2print(str.count("a", 2)     # 1print(str.count("x"))     # 0

  • replace():

    # 用给定的新字符串替换旧的字符串# replace(old, new, count)# 默认值：count(省略)，全部替换str = "abacad"print(str.replace("a", "A"))    #AbAcAdprint(str.replace("a", "A", 2))    #AbAcadprint(str)  # abacad

  • ljust() 和 rjust():

    # 对字符串进行长度调整(扩长)# ljust(width, fillchar)# width:要扩展到的长度，fillchar:填充的字符str = "abc"print(str.ljust(6, "x"))    # abcxxxprint(str.rjust(6, "x"))    # xxxabcprint(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.14159res1 = 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-0098print(res2)     # 13798780098

  • isalpha(), isdigit(), isalnum()

    str1, str2, str3, str4, str5 = "agcD", "123", "2j3e4ef", ""print(str1.isalpha())   # Trueprint(str2.isdigit())   # Trueprint(str4.isalnum())   # Trueprint(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"))  # Trueprint(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"])   # rityprint(person["age"])    # 18d = dict.fromkeys("abc", 666)
print(d)    # {'a': 666, 'b': 666, 'c':666}

添加元素

d = {"name": "s1", "age": 18}
d["height"] = 175d["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"])    # Rityprint(d["height")   # 报错，键不存在# dic.get(key, default)# 键不存在不会报错，default是键不存在时的返回值，默认为 Noneprint(d.get("age"))     # 18print(d.get("height"))  # Noneprint(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

作者：房顶上的喵
链接：https://www.jianshu.com/p/ef02257bd191