整数

  1. # 二进制
  2. n1 = 0b1010
  3. # 八进制
  4. n2 = 0o567
  5. # 十六进制
  6. n3 = 0xfdc2

浮点数

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

简单数学函数

内建函数

  • abs(num):```python

    返回数的绝对值

    n1, n2, n3 = 1, 0, -1 print(abs(n1), abs(n2), abs(n3)) # 1 0 1 ```

  • max(num) 和 min(num):```python

    参数不定长

    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]):```python

    四舍五入

    n表示四舍五入的小数位数，不写默认是0(取整)

    pi = 3.14159 print(round(pi)) # 3 print(round(pi, 3)) #3.142 ```

math模块中的函数

  • ceil():```python

    用来向上取整

    import math pi = 3.14159 print(round(pi)) # 3 print(math.ceil(pi)) # 4 print(round(pi + 0.5)) # 可以替代ceil() ```

  • floor():```python

    用来向下取整

    import math x = 3.678 print(round(x)) # 4 print(math.floor(x)) # 3 print(floor(x - 0.5)) # 可以替代floor() ```

  • sqrt():```python

    平方根运算

    import math print(math.sqrt(16)) # 4 print(math.sqrt(17)) # 4.123105635 ```

随机函数

  • random():python import random print(random.random()) # 生成[0, 1)的一个小数

  • choice(seq):python import random li = [1, 2, 4, 5] print(random.choice(li)) # 从对应的列表中随机选择一个元素

  • uniform(x, y):python import random print(random.uniform(1, 3) # 得到[1, 3]之间的随机小数

  • randint(x, y):python import random print(random.randint(1, 5)) # [1, 5]之间的随机整数

  • randrange(start, stop, step):```python import random print(random.randrange(2, 10, 2) # 参数类型与range()函数一样

    相当于random.choice([2, 4, 6, 8])

    ```

三角函数

  1. import math
  2. angle = 1 / 6 * math.pi     # 30°, pi/6
  3. res1 = math.sin(angle)      # 接收弧度值
  4. angle = math.radians(30)    # 将角度值转换为弧度值
  5. res1 = math.cos(angle)

布尔类型

是 int 的子类型，计算时会自动转换为 int 

  1. # True = 1, False = 0
  2. # 可以与整数进行运算
  3. print(2 + True)   # 3
  4. print(1 + False)   # 1

是一种单独的类型

  1. flag, tag = True, False

可以当作判定条件使用

  1. if True:
  2.     # todo

字符串

字符串表示方式

  1. str = 'abc'     # 单引号对
  2. str = "abc"     # 双引号对
  3. str = '''abc'''     # 三个单引号
  4. str = """abc"""     # 三个双引号
  6. # 混合表示，去掉字符串两端的限制符号就得到字符串数据
  7. # 可以避免使用引号的转义来表示引号
  8. str = "his name is 'rity', that is a good name"
  10. # 使用转义字符来完成
  11. str = "his name is \'rity\', that is a good name"
  13. # 消除字符串的转义
  14. str1 = "That\'s all"
  15. str2 = r"That\'s all"    
  16. print(str1)  # That's all
  17. print(str2)  # That\'s all
  19. # 字符串的跨行表示
  20. str = "his name is 'rity', " \
  21.     "that is a good name"
  22. str = ("his name is 'rity', "
  23.     "that is a good name")
  25. """
  26. 可以直接在三对双引号内进行换行
  27. 多用于程序段的注释
  28. ---end---
  29. """

字符串的操作

  • 一般操作

    • 字符串拼接python res1 = "abc" + "def" print(res1) # abcdef res2 = "abc" "def" print(res2) # abcdef res3 = "%s%S" % ("abc", "def") print(res3) # abcdef

    • 字符串的乘法python res = "a" * 3 print(res) # aaa

    • 字符串的切片```python 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():```python

      可用于所有可迭代对象

      计算字符串中字符的个数

      name1， name2 = “rity”, “瑞迪” print(len(name1), len(name2)) # 4 2 ```

    • find():```python

      查找子串的索引

      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():```python

      计算子字符串出现的个数

      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():```python

      用给定的新字符串替换旧的字符串

      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():```python

      对字符串进行长度调整(扩长)

      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()```python

      移除字符串指定位置的字符

      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():```python

      将父字符串分割成几个子字符串

      split(sep=None, maxsplit=-1)

      sep:要分割的字符，maxsplit：最大分割次数

      默认值：maxsplit(省略)，全部分解

      返回字符串列表

      info = “rity,nanchang,158-7926-7420” res = info.split(“,”) print(res) # [‘rity’, ‘nanchang’, ‘158-7926-7420’]

      多个分隔符连续的一种情况

      num = “12 3 4” res = num.split(“ “) print(res) # [‘12’, ‘’, ‘3’, ‘4’]

      省略分隔符的一种情况

      str = “a c b “ res = str.split() print(res) # [‘a’, ‘c’, ‘b’] 省略首尾的空白字符，将中间连续的空白字符视作一个分隔符进行分隔 ```

    • partition():```python

      把整个字符串分三部分

      partition(sep)

      从左往右找

      返回一个元组(分隔符左侧， 分隔符， 分隔符右侧)

      pi = 3.14159 res1 = pi.partition(“.”) res2 = pi.partition(“-“) print(res1) # (‘3’, ‘.’, ‘14159’) print(res2) # (‘3.14159’, ‘’, ‘’) ```

    • join():```python

      用指定的字符串，对可迭代参数进行拼接，返回字符串

      “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()python 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()```python

      是否以某个前缀开头/结尾,范围 [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 ```

列表

有序可变元素的集合

表示方式

  1. # 元素类型单一
  2. li = ["a", "b", "c"]
  4. # 多种类型的元素
  5. li = ["a", "b", 1, 2, True]
  7. # 列表可以相互嵌套
  8. li = [[1, 2, 3], 2, True, "hehe"]
  10. # list()函数，参数为可迭代对象
  11. li = list(range(1, 4))      # [1, 2, 3]
  12. li = list("abc")    # ('a', 'b', 'c')
  14. # 列表推导
  15. nums = [1, 2, 3, 4, 5]
  16. li = [n*n for n in nums if n % 2]
  17. print(li)   # [1, 9, 25]

常用操作

  • append():
    ```python

    向列表的尾部添加元素

    nums = [1, 2, 3, 4] nums.append(5) print(nums) # [1, 2, 3, 4, 5] ```

  • insert:
    ```python

    向列表中的任意位置插入元素

    nums = [1, 2, 3, 4] nums.insert(1, 9) print(nums) # [1, 9, 2, 3, 4] ```

  • extend():
    ```python

    合并两个列表

    nums1, nums2 = [1, 2], [3, 4] nums1.extend(nums2) print(nums1) # [1, 2, 3, 4] ```

  • del语句:
    ```python nums = [1, 2, 3] del nums[0] print(nums) # [2, 3]

    del用来删除所引用的对象

    ```

  • pop():
    ```python

    移除并返回列表中指定索引的元素

    pop(index)

    默认值：index(不写)，删除返回最后一个

    nums = [1, 2, 3] res = nums.pop() print(nums, res) # [1, 2] 3 ```

  • remove():
    ```python

    移除列表中指定的元素

    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:

    1.   nums.remove(n)

    print(nums) # [1, 3, 4, 2] ```

  • index():
    ```python

    获得元素所在的索引值,查找范围：[start, end)

    index(obj, start, end)

    默认值：start=0, end=len(list)

    li = [12, 34, 99] idx = li.index(34) print(idx) # 1 ```

  • count():
    ```python

    获得其中某个元素的个数

    li = [1, 1, 2, 3, 5] print(li.count(1)) # 2 ```

  • 切片：参考字符串切片

  • 列表遍历：
    ```python

    索引问题

    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) ```

  • 排序
    ```python

    ————————————————————

    使用内建函数 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]

  2. - **乱序**<br />```python
  3. # 打乱列表中元素的顺序
  4. # 直接修改原对象
  5. import random
  6. li = [1, 2, 3, 4, 5]
  7. random.shuffle(li)
  8. print(li)     # [2, 4, 3, 1, 5]
  • 反转
    ```python

    使用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’] ```

元组

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

表示方法

  1. # 单元组
  2. t = (1,)
  3. # 多元组
  4. t1, t2 = (1, 2), (2, 3, 9, 0)
  5. # 复合元组
  6. t = ("abc", [1, 2], 666)
  7. # 嵌套元组
  8. t = ("rity", (18, "nanchang"))
  9. # tuple()函数，用法与list()相同

拆包操作

  1. t = (1, 2, 3)
  2. a, b, c = t
  3. print(a, b, c)  # 1 2 3

字典

无序、可变的键值对的集合

表示方式

  • key不能重复，若有重复，后定义的覆盖前面定义的
  • key的类型必须是不可变的类型
    • 可变类型（列表，字典，可变集合）
    • 不可变类型（数值，布尔，字符串，元组）
  • Python的字典是通过哈希（hash）的方式实现的，计算键的哈希值，存储在哈希表中。
    1. person = {"name": "rity", "age": 18}
    2. print(person, type(person))     # {'name': 'rity', 'age': 18} '
    3. print(person["name"])   # rity
    4. print(person["age"])    # 18
    5. d = dict.fromkeys("abc", 666)
    6. print(d)    # {'a': 666, 'b': 666, 'c':666}

    添加元素

    ```python 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})

  1. <a name="ea5eb76d"></a>
  2. ## 删除元素
  3. ```python
  4. d = {"name": "s1", "age": 18}
  6. # 使用 del直接删除键值
  7. # 删除不存在的键值对会直接报错
  8. del d["name"]   
  9. print(d)    # {"age": 18}
  10. del d["name1"]  # KeyError: 'name1'
  12. # dic.pop()
  13. # 删除指定的键值对，并返回对应的值
  14. # 删除不存在的键值对会直接报错
  15. v = d.pop("age")
  16. print(v, d)     # 18 {'name': 's1'}
  18. # dic.popitem()
  19. # 删除按升序排序后的第一个键值对，并以元组的形式返回键值对
  20. # 字典为空报错
  21. res = d.popitem()
  22. print(res)      # ('age', 18)
  24. # dic.clear()
  25. # 清空字典，空字典，不是未定义的对象
  26. d.clear()
  27. print(d)    # {}
  28. del d
  29. print(d)     # 报错

获得元素

  1. d = {"name":"Rity", "age": 18}
  3. # 下标访问
  4. print(d["name"])    # Rity
  5. print(d["height")   # 报错，键不存在
  7. # dic.get(key, default)
  8. # 键不存在不会报错，default是键不存在时的返回值，默认为 None
  9. print(d.get("age"))     # 18
  10. print(d.get("height"))  # None
  11. print(d.get("height", 170)  # 170

遍历

  1. d = {"name":"Rity", "age": 18}
  3. #-------------------------------------
  4. # 下面三种方法返回的是一个 Dictionary view objects, 虽然以列表的形式展现，但严格来说不是列表
  5. # 不支持索引访问，但可以使用 list()来转换成普通的列表对象
  6. # 特点：当字典被修改后，以下 ks, vs, itms会同步修改
  7. # 获取所有的键
  8. ks = d.keys()
  9. print(ks)   # dict_keys(['name', 'age'])
  11. # 获取所有的值
  12. vs = d.values()
  13. print(vs)   # dict_values(['Rity', 18])
  15. # 获取所有的键值对
  16. itms = d.items()
  17. print(itms)    #dict_items([('name', 'Rity'), ('age', 18)])
  19. #-------------------------------------
  20. # 字典是可迭代对象，使用 for in
  21. # 若直接遍历字典，得到的是它的键
  22. for x in d.items():
  23.     print(x, end=' ')   # ('name':'Rity') ("age":18)
  25. # 元组解包
  26. for k, v in d.items():
  27.     print(k, v, sep='-')   # name-Rity age-18

集合

无序的，不可随机访问的，不可重复的元素集合

  • 与数学中的集合类似，可以进行集合的交、并、差、补等操作。
  • 分为可变集合和不可变集合
    • set: 可以进行增、删、改操作
    • frozenset: 创建好之后，无法再做修改。

      可变集合的表示

      ```python

      直接表示

      s = {1, 2, 3, 4} print(s, type(s)) # {1, 3, 4, 2}

set(Iterable)

s1 = set(“abc”) s2 = set([1, 2, 3]) print(s1, s2) # {‘a’, ‘b’, ‘c’} {1, 2, 3}

集合推导

参考列表推导

s = {x for x in range(3)} print(s) # {1, 0, 2}

  1. <a name="b57326ed"></a>
  2. ## 不可变集合
  3. ```python
  4. # frozenset(iterable)
  5. fs = frozenset("abc")
  6. print(fs)   # frozenset({'a', 'c', 'b'})
  8. # 集合推导
  9. fs = frozenset(x**2 for x in range(1, 6) if x % 2)
  10. print(fs)   # frozenset({1, 25, 9})

注意事项

  • 创建空集合```python

    错误做法

    s = {} # 实际上构建了一个空字典 s = set() # 空集合 ```

  • 集合中的元素必须是可哈希的值（不可变类型）。

  • 集合中元素若出现重复，则会被合并成一个。```python

    多用于给列表元素进行去重

    li = {1, 2, 2, 3, 3} li = list(set(li)) print(li) # [1, 2, 3] ```

集合的操作

  • 单集合操作 ```python s = {1, 2, 3}

    ————————————————————-

    新增元素

    1.集合可变 2.新增元素可哈希

    s.add(4) print(s) # {1, 3, 2, 4}

————————————————————-

删除元素

1.remove(element)

删除指定的元素，若无该元素，报错

s.remove(2) print(s) # {1, 3}

2.discard(element)

删除指定的元素，若无该元素，pass

s.discard(2) print(s) # {1, 3} s.discard(666) print(s) # {1, 3}

3.pop(element)

删除并返回指定元素，若无该元素，报错

省略 element，不指定删除元素，进行随机删除；集合为空，报错

s.pop(1) print(s) # {2, 3} s.pop()
print(s) # {2} s.pop()
print(s) # set() //空集合的意思

4.clear()

清空集合，集合依然存在

s.clear() print(s) # set()

————————————————————-

遍历集合

1.for in

for v in s: print(s, sep=’ ‘) # 1 2 3

2.迭代器

its = iter(s) print(next(its)) # 1 print(next(its)) # 2 print(next(its)) # 3

  2. - 多集合操作
  3.    - **intersection(iterable)**:<br />```python
  4. # 求交集，参数是可迭代类型
  5. s1, s2 = {1, 2, 3, 4, 5}, {9, 8, 8, 5, 4}
  6. res = s1.intersection(s2)
  7. print(res)                  # {4, 5}
  8. # s1也可以是frozenset，返回结果也是frozenset
  9. # 可以使用逻辑运算符来完成
  10. print(s1 & s2)      # {4, 5}

  • intersection_update(iterable)
    ```python

    更新调用该方法的对象

    s1, s2 = {1, 2, 3, 4, 5}, {9, 8, 8, 5, 4} s1.intersection_update(s2) print(s1) # {4, 5} ```

  • union(iterable):
    ```python

    求并集，参数是可迭代类型

    s1, s2 = {1, 2, 3}, {2, 3, 4} res = s1.union(s2) print(res) # {1, 2, 3, 4}

    可以使用逻辑运算符来完成

    print(s1 | s2) # {1, 2, 3, 4} ```

  • update(iterable)
    python s1, s2 = {1, 2, 3}, {2, 3, 4} s1.update(s2) print(s1) # {1, 2, 3, 4}

  • difference(iterable)
    ```python

    求差集

    s1, s2 = {1, 2, 3}, {2, 3, 4} res = s1.difference(s2) print(res) # {1}

    逻辑运算符

    print(s1 - s2) # {1} ```

  • difference_update(iterable):
    python s1, s2 = {1, 2, 3}, {2, 3, 4} s1.difference_update(s2) print(s1) # {1}

  • 判定操作
    ```python

    isdisjoint() 两个集合是否不相交

    isuperset() 一个集合是否包含另一个集合

    issubset() 一个集合是否包含于另一个集合

    ```

时间日历

time模块

  • 获得当前时间戳```python

    获得从 1970年1月1日到现在的时间秒数

    import time t = time.time() yearSpan = t / (60 60 24 * 365) print(yearSpan) # 48.6441059296045 ```

  • 获得时间元组```python

    根据所给的时间戳，返回当时的时间信息

    import time t = time.time() res = localtime(t) print(res) # time.struct_time(tm_year=2018, tm_mon=8, tm_mday=12, tm_hour=10, tm_min=22, tm_sec=4, tm_wday=6, tm_yday=224, tm_isdst=0) ```

  • 获得格式化的时间```python

    根据所给定的时间戳，返回一个更加可读的时间

    import time t = time.time() res = time.ctime(t) print(res) # Sun Aug 12 10:33:58 2018 ```

  • 获得格式化的时间字符串```python

    time.strftime(格式字符串, 时间元组)

    res = time.strftime(“%y-%m-%d %H:%M:%S”, time.localtime()) print(res) # 18-08-12 10:39:28 res = time.strftime(“%Y-%m-%d %H:%M:%S”, time.localtime()) print(res) # 2018-08-12 10:39:50 ```

  • 获取当前cpu时间```python

    常用来统计一段代码的执行时间

    import time

    IDLE环境测试

    start = time.clock() for i in range(0, 10) print(i, end=’ ‘) end = time.clock() print(end - start) # 0.02806393769252448 ```

  • 休眠

    1. # 线程休眠
    2. # 每隔一秒打印一个数字
    3. import time
    4. n = 0
    5. while True:
    6.   print(n)
    7.   time.sleep(1)   # 参数单位是秒

    datetiem模块

    模块内部有多个类：datetime、date、time。使用时选择合适的类进行操作就行了

  • 获取当天的日期python import datetime t = datetime.datetime.now() print(type(t)) # print(t) # 2018-08-12 11:04:12.982890 print(t.year) # 2018 print(t.month) # 8

  • 计算n天之后的日期python import datetime t = datetime.datetime.today() res = t + datetime.timedelta(days=7) print(t, res, sep='|') # 2018-08-12 11:10:31.995501|2018-08-19 11:10:31.995501

  • 获得两个日期的时间差python import datetime first = datetime.datetime(2018, 9, 10, 12, 0, 0) second = datetime.datetime(2018, 10, 1, 0, 0, 0) res = second - first print(res) # 20 days, 12:00:00