【Datawhale】Python从入门到放弃

Task01：变量、运算符、数据类型及位运算

笔记

1. is, is not 对比的是两个变量的地址，==, != 对比的是两个变量的值。
2. bin(a) 可以把十进制转换为二进制后输出。
3. 对于正数而言，不管是反码还是补码，都没有变化；对于负数而言，反码是符号位不变，其余位取反，补码等于反码+1。
4. 通过^来实现两个整数的快速交换。
5. 当a是正数的时候，-a取得是补码。
6. 为了得到负数的补码，需要手动将其和0xffffffff进行按位与操作，再交给bin()进行输出，得到的才是负数的补码表示。

练习题

1. 怎样对Python中的代码进行注释？

   单行注释使用#，多行注释使用"""或者是'''。

2. Python有哪些运算符，这些运算符的优先级是怎么样的？

   运算符包括+ - * / // % ** ，一元优先级大于二元的，其次，算术运算 > 移位运算 > 位运算。

3. Python中is，is not与==，!= 的区别是什么？

   is 和 is not比较的是两个变量在内存中的地址，对于地址可变的元组等，两个变量就不会想等。==和!=比较的就是两个变量的值，无论地址可变不可变，我们人脑对比之后他们是相等的就是相等的。

4. Python中包含哪些数据类型？这些数据类型之间如何转换？

   数据类型type包括int,float,bool,str,转换的话就只需要符合格式type + ()即可。

编程题

Leetcode136：只出现一次的数字

这题在以前考研的时候做过，不过也还是看的题解。感觉位运算对于绝大多数人来说，虽然简单好理解，但是是属于比较灵活的题目，不太容易想到。

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        r = 0
        for i in nums:
            r ^= i
        return r

task02：条件循环

笔记

1. assert（断言）关键词后边的条件为False时，程序自动崩溃并抛出AssertionError，此关键词可以用来在程序中置入检查点，只有条件为True时才能正常运行。
2. while-else循环中，当while循环正常执行完成的情况下，执行else输出；如果while循环中置行了跳出循环的语句如break，将不执行else代码块的内容。for-else的循环规则与其相同。
3. str, list, tuple是有序序列，dict为可迭代对象，str迭代的是每个字母，list是每个对象。其中dict的迭代可以分成三种：
   • for key, value in dic.item()
   • for key in dic.keys()
   • for value in dic.values()
4. enumerate()函数返回的是枚举对象[()]，参数star表示从哪个位置开始遍历，返回的元素是(index, item)类型的。其实就是它不仅返回了元素，还顺便给每个元素都加了个索引值，默认从0开始。
5. 在不确定要在一个位置上放什么样的代码的时候，可以给个pass。
6. next(tuple)很像是推出元素，再打印的时候，首元素就被跳过了。

编程题

编写一个Python程序来查找那些既可以被7整除又可以被5整除的数字，介于1500与2700之间。

考虑到处理的是正数，余数只能为正，所以如果两个取余的和为0，就是可以被整除。

for i in range(1500, 2701):
    if (i % 7) + (i % 5) == 0:
        print(i, end=' ')
        
# 1505 1540 1575 1610 1645 1680 1715 1750 1785 1820 1855 1890 1925 1960 1995 2030 2065 2100 
# 2135 2170 2205 2240 2275 2310 2345 2380 2415 2450 2485 2520 2555 2590 2625 2660 2695 

龟兔赛跑游戏

菜鸡的本质暴露无遗- - .. 菜归菜，题解还是得写。

菜鸡题解：

1. 首先，假如乌龟在兔子休息的时候都还不能超越它，那基本就是胜利无望了，所以只需要计算兔子的花费时间即可。
   • 如果兔子在第一次尝试领先的时候就已经达到终点，那就是兔子赢得了胜利
   • 第二种情况，此时我们已经知道乌龟永远不能超过兔子，终点就是计算兔子啥时候到呢。事实上兔子每次都是领先t米后休息s秒，那么醒来后的兔子只需要再跑个v2 * s秒就又可以领先t米了，那么我们只需要计算一共需要重复几次这个过程，再计算花费的总时间。
2. 那么现在的另一种可能是乌龟在兔子休息的时候是可以超过它的，那还是有胜利的可能的。设r_distance表示目前兔子走了多少米，r_time表示目前兔子花费的时间。如果现在兔子尝试超过乌龟，此时它可能与乌龟之间存在距离，就是乌龟领先了，所以这时的distance是为了计算兔子重新领先乌龟t米需要花费的时间，和走过的距离。接下来就对这个距离进行下一步判断。
   • 假如该距离小于兔子离终点的剩余距离，那么可以让兔子放心的出发，同时把r_time和r_distance做相对应的修改，要记得加上休息时间。
   • 假如该距离等于兔子离终点的剩余距离，那么可以下定论，就是兔子赢了，此时的r_time只需要加上跑步的时间，没有休息时间。
   • 假如该距离小于兔子离终点的剩余距离，那就分别当前时刻起，兔子和乌龟抵达终点需要耗费的时间，时间短的是最后的胜利者。

v1, v2, t, s, l = int(input()), int(input()), int(input()), int(input()), int(input())

t_time = l / v2
r_time = 0  # 记录兔子目前花费的时间
r_distance = 0  # 记录兔子目前走过的路程

if v2 * s <= t:
    time_1 = t / (v1 - v2)  # 第一次兔子超过乌龟5米时花费的时间
    r_distance = time_1 * v1  # 此时走了多少米
    if r_distance > l:
        print("R")
        print(int(l / v1))
    else:  # 每次都只有多走一点点距离 
        time_2 = s * v2 / v1
        time_2 = (l - r_distance) / (s * v2) * time_2
        print("R")
        print(int(time_1 + time_2))
else:
    while r_distance < l:
        # 如果兔子要超过乌龟t米需要走的距离及时间
        distance = (r_time * v2 - r_distance) + t
        time = distance / (v1 - v2)  # 时间
        distance = v1 * time

        # 如果兔子超过乌龟的时候，走过的距离还不够抵达终点
        if (r_distance + distance) < (l - r_distance):
            r_time += (time + s)
            r_distance += distance
        elif (r_distance + distance) == (l - r_distance):
            print("R")
            print(int(r_time + time))
            break
        else:
            # 看谁先抵达
            time_r = (l - r_distance) / v1  # 兔子抵达终点花费的时间
            time_t = (l - r_time * v2) / v2  # 乌龟抵达终点花费的时间
            if time_r == time_t:
                print("D")
                print(int(t_time))
            elif time_r > time_t:
                print("T")
                print(int(t_time))
            else:
                print("R")
                print(int(r_time + time_r))
            break

task03：异常处理

笔记

1. 使用多个except代码块时，必须坚持对其规范排序，要从最具针对性的异常到最通用的异常。一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。
2. try-except-finally中的finally子句始终都会执行，try-except-else中else在没有异常时会执行。
3. raise语句可以用来抛出异常。

编程题

猜数字游戏：

import random

ans = random.randint(0, 101)
print("猜测一个0到100之间的整数。")
time = 1

while(1):
    print("第", time, "次猜，请输入一个整形数字:", end=' ')
    try:
        temp = int(input())
        if temp > ans:
            print("太大")
            time += 1
        elif temp < ans:
            print("太小")
            time += 1
        else:
            print("恭喜你猜到了这个数是", ans)
            break
    except Exception as e:
        print("输入无效")

task04：列表、元组和字符串

列表编程题

练习题1：列表操作练习

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]

# 在列表末尾增加元素15
lst.append(15)  # [2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
# 在列表的中间位置插入元素20
lst.insert(int(len(lst)/2), 20)  # [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
# 合并列表
lst.extend([2, 5, 6])  # [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
# 移除列表中索引为3的元素
lst.remove(lst[3])  # [2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
# 翻转列表里的所有元素
lst.reverse()  # [6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
# 排序
lst.sort()  # [2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]
lst.sort(reverse=True)  # [20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]

练习题2：修改列表

lst = [1, [4, 6], True]
for i in range(len(lst)):
    if isinstance(lst[i], list):
        for j in range(len(lst[i])):
            lst[i][j] *= 2
    else:
        lst[i] *= 2
print(lst)

练习题3：Leetcode852

class Solution:
    def peakIndexInMountainArray(self, A: List[int]) -> int:
        low=0
        high=len(A)-1
        while low<high:
            mid=(low+high)//2
            if A[mid]>A[mid-1] and A[mid]>A[mid+1]:
                return mid
            elif A[mid]>A[mid-1]:
                low=mid+1
            else:
                high=mid

元组课后题

元组概念

(1, 2) * 2  # (1, 2, 1, 2) 元组乘上某个值，是复制拼接的意思
(1, ) * 2  # (1, 1)
(1) * 2  # 2 元组内只有单个元素时，括号被视作运算符，所以(1)的类型是int型

拆包

1. 该过程不属于拆包
2. 在解压的时候，不管是一维还是二维的可迭代对象，等号左侧的变量结构需要和右侧相同，通配符*可以代表一个或多个元素，再加个下划线的话，表示并不在意对应位置上的值。

字符串课后题

**字符串函数回顾 **：

1. 批量替换字符串中的元素：str.strip().replace(old, new)
2. 把字符串按照空格拆分：str.split(str="", num)
3. 去除字符串首位的空格：str.lstrip()

实现isdigit函数：

def isdigit(string):
    print(string.isnumeric())

isdigit('123c')  # False
isdigit('12345')  # True

Leetcode No.5：最长回文串

class Solution:
    def longestPalindrome(self, s: str) -> str:
        size = len(s)
        if size < 2:
            return s

        dp = [[False for _ in range(size)] for _ in range(size)]

        max_len = 1
        start = 0

        for i in range(size):
            dp[i][i] = True

        for j in range(1, size):
            for i in range(0, j):
                if s[i] == s[j]:
                    if j - i < 3:
                        dp[i][j] = True
                    else:
                        dp[i][j] = dp[i + 1][j - 1]
                else:
                    dp[i][j] = False

                if dp[i][j]:
                    cur_len = j - i + 1
                    if cur_len > max_len:
                        max_len = cur_len
                        start = i
        return s[start:start + max_len]

task05：字典、集合和序列

字典编程题

字典基本操作：

dic = {
    'python': 95,
    'java': 99,
    'c': 100
}
length = len(dic)  # 3
dic['java'] = 98
del dic['c']
dic['php'] = 90
list1 = list(dic.keys())
list2 = list(dic.values())
print('True') if 'javascript' in dic.keys() else print('False')
value_sum = sum(dic.values())
max_num = max(dic.values())
min_num = min(dic.values())
dic1 = {'php': 97}
dic.update(dic1)

字典中的value：

data = {
    'python': {'上学期': '90', '下学期': '95'},
    'c++': ['95', '96', '97'],
    'java': [{'月考': '90', '期中考试': '94', '期末考试': '98'}]
}


def dict_to(value):
    # value 本身是dict了
    for k in value.keys():
        value[k] = int(value[k])


def list_to(value):
    # value本身是list了
    for i in range(len(value)):
        if isinstance(value[i], dict):
            dict_to(value[i])
        else:
            value[i] = int(value[i])


for key, value in data.items():
    if isinstance(value, dict):
        dict_to(value)

    if isinstance(value, list):
        list_to(value)

print(data)

集合编程题

# 1
tu = tuple((1,))

# 2
set1 = set()
set1.add('x')
set1.add('y')
set1.add('z')

# 3
lst = ['A', 'B', 'A', 'B']
set2 = set(lst)
lst = list(set2)

# 4
set1 = {6, 7, 8}
set2 = {7, 8, 9}
a = set1.difference(set2)
b = set2.difference(set1)

# 5
set1 = {'A', 'B', 'C'}
set2 = {'B', 'C', 'D'}
s = {}
for item in set1:
    if item in set2:
        s[item] = 1
    else:
        s[item] = 0
print(s)

序列编程题

1. max(sub)和min(sub)可以分别返回序列或参数集合中的最大值和最小值。

2. sort是应用在list上的方法，sorted可以对所有可迭代的对象进行排序操作。list的sort方法返回的是对已存在的列表操作后的结果，而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作。两者的语法分别是：sorted(iterable,cmp=None,key=None,reverse=False)，和sort(cmp=None,key=None,reverse=False)。

3. sum(list(range(0, 101)))可以直接计算出所有整数的相加之和。

4.  import math
    
    lst = [2, 3, 4, 5]
    lst1 = []
    for i in range(len(lst)):
        lst1.append(math.sqrt(lst[i]))
   

5.  import math
    
    lst1 = ['x', 'y', 'z']
    lst2 = [1, 2, 3]
    
    zipped = zip(lst1, lst2)
    print(list(zipped))