第五周 简单选择排序 字典 内置方法与同名系统函数对比(Markdown格式)

知识点 : Markdown 字典 datetime模块 内置方法与同名系统函数对比 生成器表达式和列表解析式对比


Markdown

一级标题

二级标题

斜体
加粗
删除线

有序列表

  1. 第一条
  2. 第二条
  3. 第三条

分割线以上


分割线以下

有序多级列表

  1. 1
    1. 1.1
    2. 1.2
  2. 2
  3. 3
    1. 3.1
    2. 3.2
    3. 3.3

无序多级列表

  • 1
    • 1.1
    • 1.2
    • 1.3
  • 2
  • 3
    • 3.1
    • 3.2
  • 4

链接

python官网

插入图片

python3的图片

代码块(三个反引号)

def tri(n):
    for i in range(1,n+1): 
    # for i in range(12,0,-1):
        line=''
        # lst=[]
        for j in range(i,0,-1):
            line+=' '+str(j)
            # lst.append(len(line))
        print('{:>27}'.format(line))
        # print(line.rjust(max(lst)))
        # print(max(lst))

表格

none历史系机电系
297
983

字典dict

由键值对key-value组成的数据集合
特点 : 可变 无序 key唯一

增:

  • 定义/初始化: d={‘a’:10,’b’:20,’c’:None,’d’:[1,2,3]}
  • 定义默认值: d = dict.fromkeys(range(5),0)
  • d[key] = value 覆盖旧值 添加新值
  • d.update(red=1)
  • e={‘a’:1 ,’f’:666} d.update(e)

  • pop(key[, default])
    key存在则移除它并返回value
    key不存在则返回给定的default
    default未设置,key不存在则抛出KeyError异常
  • popitem()
    移除并返回一个任意的键值对
    字典为empty,抛出KeyError异常
  • clear() 清空字典

  • d[key] = value 覆盖旧值 添加新值

  • d[key] 返回key对应的值value 不存在则抛KeyError异常
  • d.get(‘d’,223) 返回key的对应value 不存在则返回默认值223 不指定默认值则返回None
  • d.setdefault(‘e’,223) 返回key的对应value 不存在则写入默认值223字典并返回 不指定默认值则为None

字典遍历

  • for i in d: 等价于for i in d.keys():
  • for i in d.values()
  • for k,v in d.items()
    注意:遍历字典时不可改变字典长度(不允许增删操作)
    可在遍历时判断value 并记录欲移出的key
    再次循环key 用pop(key)移除
d = dict(a=1, b=2, c='abc')
keys = []
for k,v in d.items():
    if isinstance(v, str):
        keys.append(k)
for k in keys:
    d.pop(k)
print(d)
  • 字典key的要求和set的元素要求一致
  • set的元素可以理解为key,set可以看做dict的简化版
  • 可哈希(hashable)才可以作为key,可以使用hash()函数测试
    d = {1 : 0, 2.0 : 3, “abc” : None, (‘hello’, ‘world’, ‘python’) : “string”, b’abc’ : ‘135’}

import collections
collections.defaultdict([default_factory[, …]])

  • default_factory提供一个初始化函数。当key不存在的时候,会调用这个工厂函数来生成key对应的value
  • collections.defaultdict(int) #初始化字典 默认value为0

sort与reverse列表方法与系统函数对比

nonelist方法系统函数
sort就地修改 默认升序 返回值为None原列表不变 默认升序 返回值为升序列表
reverse就地反转 返回值为None原列表不变 返回值为反转迭代器

标准库datetime

datetime类

类方法:

  • datetime.datetime.now(tz=None) 返回当前时间的datetime对象,时间到微秒
  • datetime.datetime.utcnow() 没有时区的当前时间

日期格式化

类方法

  • strptime(date_string, format) ,返回datetime对象
    import datetime
  • dt = datetime.datetime.strptime(“21/11/06 16:30”, “%d/%m/%y %H:%M”)
  • print(dt.strftime(“%Y-%m-%d %H:%M:%S”))
  • print(“{0:%Y}/{0:%m}/{0:%d} {0:%H}::{0:%M}::{0:%S}”.format(dt))

timedelta对象
timedelta = datetime1 - datetime2
构造方法

  • datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,
    minutes=0, hours=0, weeks=0)
  • year = datetime.timedelta(days=365)
  • total_seconds() 返回时间差的总秒数

列表解析式List Comprehension

  • 语法:[返回值 for 元素 in 可迭代对象 if 条件] 返回一个新的列表
  • 列表解析式是一种语法糖 由编译器优化,提高效率
  • [expr for i in iterable1 for j in iterable2 ]等价于
ret = []
    for i in iterable1:
        for j in iterable2:
ret.append(expr)
  • [(x, y) for x in ‘abcde’ for y in range(3)]
    [[x, y] for x in ‘abcde’ for y in range(3)]
    [{x: y} for x in ‘abcde’ for y in range(3)]
    以上输出结果为 : ‘abcde’与0 1 2 的排列组合分别组成元组 列表 字典

  • [(i,j) for i in range(7) if i>4 for j in range(20,25) if j>23]
    [(i,j) for i in range(7) for j in range(20,25) if i>4 if j>23]
    [(i,j) for i in range(7) for j in range(20,25) if i>4 and j>23]
    以上三条语句输出结果相同 说明for与if语句无先后顺序之分 且if语句嵌套if语句可简化为 if1 AND if2

生成器表达式Generator expression

  • 语法:(返回值 for 元素 in 可迭代对象 if 条件)
  • 返回一个生成器Generator

生成器表达式和列表解析式的区别:

none生成器表达式列表解析式
求值策略惰性求值立即返回
返回结果生成器对象 只迭代一次可迭代对象 可多次迭代

集合解析式

  • {返回值 for 元素 in 可迭代对象 if 条件}
  • {(x,x+1) for x in range(10)}
  • {[x] for x in range(10)} #错误 集合内必须为可哈希对象 列表不可哈希

字典解析式

  • {返回值 for 元素 in 可迭代对象 if 条件}
  • 使用key:value形式

  • {x:(x,x+1) for x in range(10)}
    {x:[x,x+1] for x in range(10)}
    {(x,):[x,x+1] for x in range(10)}
    {[x]:[x,x+1] for x in range(10)} #错误 key必须可哈希
    {chr(0x41+x):x**2 for x in range(10)}
    {str(x):y for x in range(3) for y in range(4)}
    虽说是3x4的排列组合 但x作为key具有唯一性 因此value只会留下最后一次的结果3 {‘0’: 3, ‘1’: 3, ‘2’: 3}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: ``` Java示例代码: public class FakeSort { public static void main(String[] args) { int[] arr = {5, 4, 8, 2, 1, 9, 6}; int tmp; for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr.length - 1; j++) { if (arr[j] > arr[j + 1]) { tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } } } ``` ### 回答2: 冒泡排序(Bubble Sort)是一种简单的排序算法,它重复地遍历要排序的元素,比较相邻的两个元素,如果顺序不对则交换位置,直到整个序列有序为止。 以下是一个Java示例代码,使用冒泡排序算法对一个整数数组进行排序: ```java public class BubbleSort { public static void main(String[] args) { int[] arr = {5, 2, 8, 3, 1}; bubbleSort(arr); System.out.println("排序结果:"); for (int num : arr) { System.out.print(num + " "); } } public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { // 交换相邻两个元素的位置 int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } } ``` 在上述示例代码中,我们首先定义了一个整数数组 `arr`,然后调用 `bubbleSort` 方法对该数组进行排序。`bubbleSort` 方法使用了两个嵌套的循环,外层循环控制需要进行比较的轮数,内层循环负责相邻元素之间的比较和交换。如果相邻元素顺序不对,则进行交换。 最终在控制台打印出排序结果,排序结果为:1 2 3 5 8。 冒泡排序的时间复杂度为O(n^2),在最坏情况下需要进行n(n-1)/2次比较和交换,其中n为数组的长度。 ### 回答3: 冒泡排序是一种简单的排序算法,也称为冒牌排序,它通过不断交换相邻元素的位置来实现排序。下面是一个用Java语言实现冒泡排序的示例代码: ```java public class BubbleSort { public static void main(String[] args) { int[] array = {5, 3, 8, 2, 1}; System.out.println("排序前的数组:"); printArray(array); bubbleSort(array); System.out.println("\n排序后的数组:"); printArray(array); } public static void bubbleSort(int[] array) { int length = array.length; for (int i = 0; i < length - 1; i++) { for (int j = 0; j < length - 1 - i; j++) { if (array[j] > array[j + 1]) { swap(array, j, j + 1); } } } } public static void swap(int[] array, int i, int j) { int temp = array[i]; array[i] = array[j]; array[j] = temp; } public static void printArray(int[] array) { for (int num : array) { System.out.print(num + " "); } } } ``` 以上代码中,首先定义了一个数组`array`,然后调用`bubbleSort`方法进行冒泡排序。在`bubbleSort`方法中,通过双重循环遍历数组,比较相邻元素的大小,如果前一个元素大于后一个元素,则交换它们的位置。这个过程会不断重复,直到数组排序完成。 最后,调用`printArray`方法打印排序后的数组。整个程序运行后,会输出排序前和排序后的数组。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值