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, -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